避免运行时多态性的性能问题

Question

在数以千计的处理器上运行 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 的新虚拟方法，该方法实现了循环，返回一个双精度数组并在其中调用非虚拟内联 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 接口变得巨大——我没有可以轻松封装的单一访问模式（如示例）。我的猜测是，对于当前 Mesh 类（15-20）中的每个虚拟方法，我会有 3 或 4 种不同的“调用模式”，并且 Mesh 的接口会爆炸。有各种各样的“用户”类，虽然有时以相同的方式使用 Mesh，但它们并不总是如此，我不想将自己局限于几种模式。

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

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

任何关于没有虚拟低级方法的高级类的运行时多态性的好选择、更好的想法或其他 cmet 的想法将不胜感激！

Answer 1

如果我正确理解您，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);
  }
}