虚拟功能和性能 - C++

Question

在我的类设计中，我广泛使用抽象类和虚函数。 我有一种感觉，虚拟函数会影响性能。 这是真的？ 但我认为这种性能差异并不明显，看起来我正在做过早的优化。 正确的？

Answer 1

我认为虚拟函数会成为性能问题的唯一方法是，如果在紧密循环内调用许多虚拟函数，并且当且仅当它们导致页面错误或其他“严重”问题。 ” 发生内存操作。

尽管就像其他人所说的那样，这在现实生活中对您来说几乎永远不会成为问题。 如果您认为是这样，请运行探查器，进行一些测试，并在尝试“取消设计”代码以获得性能优势之前验证这是否确实是一个问题。

Answer 2

当类方法不是虚拟的时，编译器通常会进行内联。 相反，当您使用指向带有虚函数的类的指针时，只有在运行时才会知道真实地址。

测试很好地说明了这一点，时间差~700%（！）：

#include <time.h>

class Direct
{
public:
    int Perform(int &ia) { return ++ia; }
};

class AbstrBase
{
public:
    virtual int Perform(int &ia)=0;
};

class Derived: public AbstrBase
{
public:
    virtual int Perform(int &ia) { return ++ia; }
};


int main(int argc, char* argv[])
{
    Direct *pdir, dir;
    pdir = &dir;

    int ia=0;
    double start = clock();
    while( pdir->Perform(ia) );
    double end = clock();
    printf( "Direct %.3f, ia=%d\n", (end-start)/CLOCKS_PER_SEC, ia );

    Derived drv;
    AbstrBase *ab = &drv;

    ia=0;
    start = clock();
    while( ab->Perform(ia) );
    end = clock();
    printf( "Virtual: %.3f, ia=%d\n", (end-start)/CLOCKS_PER_SEC, ia );

    return 0;
}

虚拟函数调用的影响很大程度上取决于情况。
如果函数内部调用很少且工作量很大，那么它可能可以忽略不计。

或者，当它是重复使用多次的虚拟调用，同时执行一些简单操作时 - 它可能非常大。

Answer 3

在我的特定项目中，我已经反复讨论了至少 20 次。 尽管在代码重用、清晰度、可维护性和可读性方面可以取得一些巨大的进步，但另一方面，虚拟函数仍然存在性能问题。

在现代笔记本电脑/台式机/平板电脑上，性能受到的影响是否会很明显......可能不会！ 但是，在嵌入式系统的某些情况下，性能下降可能是代码效率低下的驱动因素，特别是在循环中一遍又一遍地调用虚拟函数的情况下。

这是一篇有点过时的论文，分析了嵌入式系统环境中 C/C++ 的最佳实践：http://www.open-std.org/jtc1/sc22/wg21/docs/ESC_Boston_01_304_paper.pdf

总结：程序员需要了解使用某种结构优于另一种结构。 除非您是超级性能驱动的，否则您可能不关心性能影响，并且应该使用 C++ 中所有简洁的 OO 内容来帮助使您的代码尽可能可用。

Answer 4

根据我的经验，主要相关的是内联函数的能力。 如果您的性能/优化需求决定需要内联函数，那么您不能将函数设为虚拟，因为这会阻止这种情况的发生。 否则，您可能不会注意到其中的差异。

Answer 5

需要注意的是，这：

boolean contains(A element) {
    for (A current : this)
        if (element.equals(current))
            return true;
    return false;
}

可能比这更快：

boolean contains(A element) {
    for (A current : this)
        if (current.equals(element))
            return true;
    return false;
}

这是因为第一个方法仅调用一个函数，而第二个方法可能调用许多不同的函数。 这适用于任何语言的任何虚拟函数。

我说“可能”是因为这取决于编译器、缓存等。

Answer 6

使用虚拟函数的性能损失永远不会超过您在设计级别获得的优势。 据称，调用虚函数的效率比直接调用静态函数的效率低 25%。 这是因为通过 VMT 存在一定程度的间接性。 然而，与实际执行函数所花费的时间相比，进行调用所花费的时间通常非常短，因此总性能成本可以忽略不计，特别是在当前硬件性能的情况下。
此外，编译器有时可以优化并发现不需要虚拟调用并将其编译为静态调用。 所以不用担心，根据需要尽可能多地使用虚函数和抽象类。

Answer 7

我总是问自己这个问题，特别是因为 - 几年前 - 我也做了这样一个测试，比较标准成员方法调用和虚拟方法调用的时间，并且对当时的结果感到非常生气，因为空的虚拟调用被比非虚拟慢 8 倍。

今天，我必须决定是否在一个性能非常关键的应用程序中使用虚拟函数在我的缓冲区类中分配更多内存，所以我用谷歌搜索（并找到了你），最后再次进行了测试。

// g++ -std=c++0x -o perf perf.cpp -lrt
#include <typeinfo>    // typeid
#include <cstdio>      // printf
#include <cstdlib>     // atoll
#include <ctime>       // clock_gettime

struct Virtual { virtual int call() { return 42; } }; 
struct Inline { inline int call() { return 42; } }; 
struct Normal { int call(); };
int Normal::call() { return 42; }

template<typename T>
void test(unsigned long long count) {
    std::printf("Timing function calls of '%s' %llu times ...\n", typeid(T).name(), count);

    timespec t0, t1;
    clock_gettime(CLOCK_REALTIME, &t0);

    T test;
    while (count--) test.call();

    clock_gettime(CLOCK_REALTIME, &t1);
    t1.tv_sec -= t0.tv_sec;
    t1.tv_nsec = t1.tv_nsec > t0.tv_nsec
        ? t1.tv_nsec - t0.tv_nsec
        : 1000000000lu - t0.tv_nsec;

    std::printf(" -- result: %d sec %ld nsec\n", t1.tv_sec, t1.tv_nsec);
}

template<typename T, typename Ua, typename... Un>
void test(unsigned long long count) {
    test<T>(count);
    test<Ua, Un...>(count);
}

int main(int argc, const char* argv[]) {
    test<Inline, Normal, Virtual>(argc == 2 ? atoll(argv[1]) : 10000000000llu);
    return 0;
}

真的很惊讶它 - 事实上 - 真的不再重要了。
虽然内联比非虚拟更快是有意义的，而且它们比虚拟更快，但它通常涉及计算机的整体负载，无论您的缓存是否有必要的数据，并且虽然您可能能够优化我认为，在缓存级别，这应该由编译器开发人员而不是应用程序开发人员来完成。

Answer 8

你的问题让我很好奇，所以我继续在我们使用的 3GHz 有序 PowerPC CPU 上运行了一些计时。 我运行的测试是使用 get/set 函数创建一个简单的 4d 向量类

class TestVec 
{
    float x,y,z,w; 
public:
    float GetX() { return x; }
    float SetX(float to) { return x=to; }  // and so on for the other three 
}

然后我设置了三个数组，每个数组包含 1024 个这些向量（小到足以适合 L1）并运行一个循环将它们相互添加（Ax = Bx+Cx)1000次。 我使用定义为内联、虚拟和常规函数调用的函数来运行它。 结果如下：

• 内联：8 毫秒（每次调用 0.65 纳秒）
• 直接：68 毫秒（每次调用 5.53 纳秒）
• 虚拟：160 毫秒（每次调用 13 纳秒）

因此，在这种情况下（一切都适合缓存）虚拟函数调用约为 20 倍比内联调用慢。 但这到底意味着什么呢？ 每次循环都会导致 3 * 4 * 1024 = 12,288 次函数调用（1024 个向量乘以四个分量乘以每次添加的 3 个调用），因此这些时间表示 1000 * 12,288 = 12,288,000代码>函数调用。 虚拟循环比直接循环花费了 92 毫秒，因此每个函数每次调用的额外开销为 7 纳秒。

由此我得出结论：是，虚拟函数比直接函数慢得多，否，除非您打算每秒调用它们一千万次，否则不会。没关系。

另请参阅：生成的程序集的比较。

Answer 9

一个好的经验法则是：

在您能够证明这一点之前，这不是性能问题。

虚拟函数的使用将对性能产生非常轻微的影响，但不太可能影响应用程序的整体性能。 寻求性能改进的更好地方是算法和 I/O。

成员函数指针和最快的 C++ 是一篇讨论虚拟函数（以及更多内容）的优秀文章代表们。

Answer 10

当 Objective-C（所有方法都是虚拟的）是 iPhone 的主要语言，而奇怪的 Java 是 Android 的主要语言时，我认为在我们的 3 GHz 上使用 C++ 虚拟函数是相当安全的双核塔式。

Answer 11

在性能非常关键的应用程序（如视频游戏）中，虚拟函数调用可能会太慢。 对于现代硬件，最大的性能问题是缓存未命中。 如果数据不在缓存中，则可能需要数百个周期后才可用。

当 CPU 获取新函数的第一条指令并且该指令不在高速缓存中时，正常的函数调用可能会产生指令高速缓存未命中。

虚拟函数调用首先需要从对象加载vtable指针。 这可能会导致数据缓存未命中。 然后它从 vtable 加载函数指针，这可能导致另一个数据缓存未命中。 然后它调用该函数，该函数可能会像非虚函数一样导致指令缓存未命中。

在许多情况下，两次额外的缓存未命中并不重要，但在性能关键代码的紧密循环中，它会显着降低性能。

Answer 12

Agner Fog 的“用 C++ 优化软件”手册第 44 页：

如果函数调用语句始终调用相同版本的虚拟函数，则调用虚拟成员函数所需的时间比调用非虚拟成员函数所需的时间多几个时钟周期。 如果版本发生变化，您将受到 10 - 30 个时钟周期的错误预测惩罚。 虚函数调用的预测和误预测的规则与 switch 语句相同...

Answer 13

绝对地。 当计算机以 100Mhz 运行时，这是一个问题，因为每个方法调用都需要在调用之前查找 vtable。 但今天.. 在具有一级缓存且内存比我的第一台计算机更多的 3Ghz CPU 上？ 一点也不。 与所有功能都是虚拟的相比，从主 RAM 分配内存会花费更多时间。

就像过去人们说结构化编程很慢一样，因为所有代码都被分成函数，每个函数都需要堆栈分配和函数调用！

唯一一次我什至会考虑费心考虑虚拟函数对性能的影响，是如果它在模板化代码中被大量使用和实例化，而最终贯穿所有内容。 即使这样，我也不会花太多精力！

PS 考虑其他“易于使用”的语言 - 它们的所有方法都是虚拟的，并且现在不再爬行。

Answer 14

除了执行时间之外，还有另一个性能标准。 Vtable 也会占用内存空间，在某些情况下可以避免：ATL 使用编译时 "模拟动态绑定"与模板以获得“静态”的效果多态性”，这有点难以解释； 您基本上将派生类作为参数传递给基类模板，因此在编译时，基类“知道”每个实例中的派生类是什么。 不会让您在基类型集合中存储多个不同的派生类（即运行时多态性），但从静态意义上来说，如果您想创建一个与预先存在的模板类 X 相同的类 Y，该模板类 X 具有对于这种重写的钩子，你只需要重写你关心的方法，然后你就可以获得类X的基方法，而无需有vtable。

在内存占用较大的类中，单个 vtable 指针的成本并不高，但 COM 中的某些 ATL 类非常小，如果永远不会发生运行时多态情况，那么节省 vtable 是值得的。

另请参阅这个其他问题。

顺便说一句，这是一个帖子我发现 讨论了 CPU 时间性能方面。

Answer 15

是的，你是对的，如果你对虚拟函数调用的成本感到好奇，你可能会发现 这篇文章很有趣。