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

在数千个处理器上运行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>的工厂或用户< MeshB>实例取决于运行时信息.这有点令人担忧,因为这实际上意味着我的整个代码都是模板代码,编译时间会爆炸,错误将更难调试等.将触及大型代码库.

想法3：在我看来,应该能够在运行开始时解决用户获取的网格指针实际上是MeshA或MeshB,而不需要进行虚拟表查找并重新获得内联A或B实施.我不知道这样做的优雅方式基本上不会比Idea 1差,即用户带有case / switch的一堆重复代码.但如果有一种优雅的方式,这将是我的第一选择.

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

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>();
  }
}

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);
  }
}