虚函数和性能 C++

Question

在您对重复的标题感到畏缩之前，另一个问题不适合我在这里提出的问题 (IMO)。所以。

我真的很想在我的应用程序中使用虚函数来让事情变得简单一百倍（这不就是 OOP 的全部内容吗；））。但是我在某处读到它们是以性能为代价的，只看到过早优化的旧人为炒作，我决定在一个小型基准测试中快速旋转它，使用：

CProfiler.cpp

#include "CProfiler.h"

CProfiler::CProfiler(void (*func)(void), unsigned int iterations) {
    gettimeofday(&a, 0);
    for (;iterations > 0; iterations --) {
        func();
    }
    gettimeofday(&b, 0);
    result = (b.tv_sec * (unsigned int)1e6 + b.tv_usec) - (a.tv_sec * (unsigned int)1e6 + a.tv_usec);
};

main.cpp

#include "CProfiler.h"

#include <iostream>

class CC {
  protected:
    int width, height, area;
  };

class VCC {
  protected:
    int width, height, area;
  public:
    virtual void set_area () {}
  };

class CS: public CC {
  public:
    void set_area () { area = width * height; }
  };

class VCS: public VCC {
  public:
    void set_area () {  area = width * height; }
  };

void profileNonVirtual() {
    CS *abc = new CS;
    abc->set_area();
    delete abc;
}

void profileVirtual() {
    VCS *abc = new VCS;
    abc->set_area();
    delete abc;
}

int main() {
    int iterations = 5000;
    CProfiler prf2(&profileNonVirtual, iterations);
    CProfiler prf(&profileVirtual, iterations);

    std::cout << prf.result;
    std::cout << "\n";
    std::cout << prf2.result;

    return 0;
}

一开始我只进行了 100 和 10000 次迭代，结果令人担忧：非虚拟化 4 毫秒，虚拟化 250 毫秒！我几乎进入了“nooooooo”，但后来我将迭代次数提高到了大约 500,000 次；看到结果变得几乎完全相同（在没有启用优化标志的情况下可能会慢 5%）。

我的问题是，为什么与大量迭代相比，少量迭代会有如此显着的变化？纯粹是因为虚拟函数在这么多次迭代时在缓存中很热吗？

免责声明
我知道我的“分析”代码并不完美，但它提供了对事物的估计，这在这个级别上是最重要的。此外，我问这些问题是为了学习，而不是仅仅为了优化我的应用程序。

Answer 1

在我看来，当循环次数较少时，可能没有上下文切换，但是当你增加循环次数时，上下文切换发生的可能性很大，这在阅读中占主导地位。例如第一个程序需要 1 秒，第二个程序需要 3 秒，但如果上下文切换需要 10 秒，那么差异是 13/11 而不是 3/1。

Answer 2

扩展Charles' answer。

这里的问题是，您的循环所做的不仅仅是测试虚拟调用本身（内存分配可能会使虚拟调用开销相形见绌），所以他的建议是更改代码以便只测试虚拟调用。

这里的基准函数是模板，因为模板可能是内联的，而通过函数指针调用不太可能。

template <typename Type>
double benchmark(Type const& t, size_t iterations)
{
  timeval a, b;
  gettimeofday(&a, 0);
  for (;iterations > 0; --iterations) {
    t.getArea();
  }
  gettimeofday(&b, 0);
  return (b.tv_sec * (unsigned int)1e6 + b.tv_usec) -
         (a.tv_sec * (unsigned int)1e6 + a.tv_usec);
}

类：

struct Regular
{
  Regular(size_t w, size_t h): _width(w), _height(h) {}

  size_t getArea() const;

  size_t _width;
  size_t _height;
};

// The following line in another translation unit
// to avoid inlining
size_t Regular::getArea() const { return _width * _height; }

struct Base
{
  Base(size_t w, size_t h): _width(w), _height(h) {}

  virtual size_t getArea() const = 0;

  size_t _width;
  size_t _height;
};

struct Derived: Base
{
  Derived(size_t w, size_t h): Base(w, h) {}

  virtual size_t getArea() const;
};

// The following two functions in another translation unit
// to avoid inlining
size_t Derived::getArea() const  { return _width * _height; }

std::auto_ptr<Base> generateDerived()
{
  return std::auto_ptr<Base>(new Derived(3,7));
}

以及测量：

int main(int argc, char* argv[])
{
  if (argc != 2) {
    std::cerr << "Usage: %prog iterations\n";
    return 1;
  }

  Regular regular(3, 7);
  std::auto_ptr<Base> derived = generateDerived();

  double regTime = benchmark<Regular>(regular, atoi(argv[1]));
  double derTime = benchmark<Base>(*derived, atoi(argv[1]));

  std::cout << "Regular: " << regTime << "\nDerived: " << derTime << "\n";

  return 0;
}

注意：与常规函数相比，这测试了虚拟调用的开销。功能不同（因为在第二种情况下您没有运行时分派），但这是最坏情况下的开销。

编辑：

运行结果（gcc.3.4.2，-O2，SLES10 四核服务器）注意：在另一个翻译单元中定义函数，以防止内联

> ./test 5000000
Regular: 17041
Derived: 17194

没有说服力。

Answer 3

时间差异可能有多种原因。

• 您的计时功能不够精确

• 堆管理器可能会影响结果，因为sizeof(VCS) > sizeof(VS)。如果将new / delete 移出循环会发生什么？

• 同样，由于大小差异，内存缓存可能确实是时间差异的一部分。

但是：你真的应该比较类似的功能。使用虚函数时，您这样做是有原因的，即根据对象的身份调用不同的成员函数。如果您需要此功能，并且不想使用虚拟功能，则必须手动实现它，无论是使用函数表还是使用 switch 语句。这也是有代价的，这就是您应该与虚函数进行比较的原因。

Answer 4

调用虚函数会对性能产生影响，因为它比调用常规函数稍微多一点。然而，在现实世界的应用程序中，这种影响可能完全可以忽略不计——甚至比在最精心设计的基准测试中出现的影响还要小。

在现实世界的应用程序中，虚拟函数的替代方案通常会涉及到你手写一些类似的系统，因为调用虚拟函数和调用非虚拟函数的行为不同 - 前者改变了基于调用对象的运行时类型。您的基准测试，即使忽略它的任何缺陷，也不会测量等效行为，仅测量等效语法。如果您要制定禁止虚函数的编码策略，您要么必须编写一些可能非常迂回或令人困惑的代码（可能会更慢），要么重新实现编译器用来实现虚函数的类似类型的运行时调度系统函数行为（在大多数情况下，这肯定不会比编译器快）。

Answer 5

当迭代次数太少时，测量中会出现很多噪音。 gettimeofday 函数不够准确，无法仅在少数迭代中为您提供良好的测量结果，更不用说它记录了总的挂墙时间（包括被其他线程抢占时所花费的时间）。

不过，最重要的是，您不应该想出一些可笑的复杂设计来避免使用虚函数。他们真的不会增加太多的开销。如果您有非常关键的性能代码，并且您知道虚拟函数占大多数时间，那么也许需要担心。不过，在任何实际应用中，虚函数都不会导致您的应用变慢。

Answer 6

我认为您的测试用例过于人为，没有任何价值。

首先，在您的分析函数中，您动态分配和解除分配一个对象以及调用一个函数，如果您只想分析函数调用，那么您应该这样做。

其次，您没有分析虚拟函数调用代表给定问题的可行替代方案的情况。虚函数调用提供动态调度。您应该尝试分析一个案例，例如使用虚拟函数调用作为使用开关类型反模式的替代方案。

Answer 7

我认为这种测试其实没什么用：
1）您正在浪费时间来分析自己调用gettimeofday();
2）您并没有真正测试虚拟功能，恕我直言，这是最糟糕的事情。

为什么？因为您使用虚函数来避免编写诸如：

<pseudocode>
switch typeof(object) {

case ClassA: functionA(object);

case ClassB: functionB(object);

case ClassC: functionC(object);
}
</pseudocode>

在这段代码中，您错过了“if...else”块，因此您并没有真正获得虚函数的优势。在这种情况下，他们总是对非虚拟“失败者”。

要进行正确的分析，我认为您应该添加类似于我发布的代码的内容。

Answer 8

通过少量迭代，您的代码有可能被其他并行运行的程序抢占，或者发生交换或任何其他操作系统将您的程序与发生隔离的情况，您将有时间被操作暂停系统包含在您的基准测试结果中。这就是为什么你应该运行你的代码大约一千万次以或多或少可靠地测量任何东西的第一个原因。