在数以千计的处理器上运行 10 小时的数字代码中，我有一个基类 (Mesh)，其方法被命中数百万次到 100 到 1000 次。目前有两个 (Mesh_A, Mesh_B) 派生类，但最终会扩展到三个或四个。用户代码直到运行时才能知道其指向 Mesh 的指针实际上是 Mesh_A 还是 Mesh_B，但对于运行的其余部分，它永远不会改变。

当前实现:

// Base class
class Mesh {
  ...
  virtual const Point& cell_centroid(int c) = 0;
}

// derived class A
class MeshA : public Mesh {
  ...
  Point& cell_centroid(int c) { return cell_centroids_[c]; }
}

// derived class B
class MeshB : public Mesh {
  ...
  Point& cell_centroid(int c) { return other_framework_->cell_centroid(c); }
}


// typical user class
class User {
  User(Mesh* mesh) : mesh_(mesh) {}

  void evalFunction() {
    for (int c=0; c!=mesh_->num_cells(); ++c) {
      double result = func(mesh_->cell_centroid(c));
      ...
    }
  }


  // Other methods which use mesh_->cell_centroid() very often, and in different ways.
}

之前MeshA是唯一的Mesh，没有基类，重击的方法都是内联的。分析表明，使用虚拟方法对运行时多态性的更改(可能是由于内联的丢失？)导致了约 15% 的命中率，这是行不通的。

我一直在讨论静态多态性和其他想法，但我很想听听关于如何以合理可持续的方式避免这种打击的想法。

想法 1:粗化虚函数以分摊开销。一种想法是尝试将这些方法的所有“调用模式”封装在一个虚拟方法中，将虚拟提升到更粗略的级别，同时将细粒度方法保持为非虚拟。例如，在上面的示例中，可以将函数指针传递给实现循环的 Mesh 的新虚拟方法，返回 double 组并在其中调用非虚拟的内联 cell_centroid() 方法。

// Base class
class Mesh {
  ...
  virtual void evalFunction(double (*func)(Point&), std::vector<double>* result) = 0;
}

// derived class A
class MeshA : public Mesh {
  ...

  void evalFunction(double (*func)(Point&), std::vector<double>* result) {
    for (int c=0; c!=num_cells(); ++c) (*result)[c] = (*func)(cell_centroid(c));
  }

  Point& cell_centroid(int c) { return cell_centroids_[c]; }
}

// similar for B


// typical user class
class User {
  User(Mesh* mesh) : mesh_(mesh) {}

  void evalFunction() {
    m_->evalFunction();
  }
}

我有点担心这会使 Mesh 接口(interface)变得庞大——我没有可以轻松封装的单一访问模式(如示例)。我的猜测是，对于当前 Mesh 类 (15-20) 中的每个虚方法，我会有 3 或 4 种不同的“调用模式”，并且 Mesh 的接口(interface)会爆炸。有多种“用户”类，虽然有时以相同的方式使用 Mesh，但并非总是如此，我不想将自己局限于几种模式。

想法 2: 使用 Mesh_T 模板化所有用户代码.编写一个创建 User<MeshA> 的工厂或 User<MeshB>实例取决于运行时信息。这有点令人担心，因为这实际上意味着我的整个代码都是模板化代码，编译时间会增加，错误会更难调试等等。将触及大型代码库。

想法 3: 在我看来，应该能够在运行开始时解决用户获得的 Mesh 指针实际上是 MeshA 或 MeshB，而不需要执行虚拟表查找并重新获得内联 A 或 B 实现。我不知道这样做的优雅方式基本上不会比想法 1 更糟糕，即 User 中的一堆重复代码与 case/switch。但如果有一种优雅的方式来做到这一点，那将是我的第一选择。

任何关于一个好的选择、更好的想法的想法，或对没有虚拟低级方法的高级类的运行时多态性的其他评论，我们将不胜感激!

最佳答案

前提是我理解正确，mesh_ 将始终是 MeshA 或 MeshB 而不是它们的混合。

//典型的用户类

class User {
  User(Mesh* mesh) : mesh_(mesh) {}

  template<class dType>
  void evalFunction() {
    dType *myMesh = dynamic_cast<dType *>(mesh_);
    for (int c=0; c!=myMesh _->num_cells(); ++c) {
      double result = func(myMesh _->cell_centroid(c));
      ...
    }
  }
  void evalFunction() {
    if (dynamic_cast<MeshA *>(mesh_))
      evalFunction<MeshA>();
    if (dynamic_cast<MeshB *>(mesh_))
      evalFunction<MeshB>();
  }
}

evalFunction 选择 A 或 B 模板。

或者

class User {
  User(Mesh* mesh) : mesh_(mesh) {}

  template<class dType>
  void evalFunction(dType *myMesh) {
    for (int c=0; c!=myMesh _->num_cells(); ++c) {
      double result = func(myMesh _->cell_centroid(c));
      ...
    }
  }
  void evalFunction() {
    MeshA *meshA = dynamic_cast<MeshA *>(mesh_);
    if (meshA)
      evalFunction<MeshA>(meshA);
    MeshB *meshB = dynamic_cast<MeshB *>(mesh_);
    if (meshB)
      evalFunction<MeshB>(meshB);
  }
}

关于c++ - 避免运行时多态性的性能问题，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/34162611/