我想测量和比较不同函数调用的开销。在处理扩展类同时最小化代码修改的两种替代方法的意义上有所不同:

• 使用抽象基类并在虚拟成员函数中提供实现
• 使用策略宿主类并使用静态和成员函数定义不同的策略

这两个选项都与根本不调用函数进行了比较。我也知道 NVI设计支持动态多态的类时通常使用的惯用语——我使用的示例只是开销的基准。

这是我尝试用于此目的的代码:

#include <iostream>
#include <vector>
#include <chrono>
#include <ctime>
#include <memory>

class Interface 
{
    public:
        virtual double calculate(double t) = 0; 
        virtual ~Interface() = default;

};

class Square
: 
    public Interface
{
    public:

       double calculate(double d)
       {
           return d*d;
       }

};

class SquareStaticFunction
{
    public:
        static double calculate(double d)
        {
            return d*d; 
        }
};

class SquareMemberFunction
{
    public:
        double calculate(double d)
        {
            return d*d; 
        }
};

template<typename Function>
class Generic
:
    public Function
{
    public:
        using Function::calculate;
};

using namespace std;

int main(int argc, const char *argv[])
{
    vector<double> test(1e06, 5); 

    unique_ptr<Interface> sUptr(new Square());

    Interface* sPtr = new Square(); 

    Generic<SquareStaticFunction> gStatic; 
    Generic<SquareMemberFunction> gMember; 

    double result;

    typedef std::chrono::high_resolution_clock Clock; 

    auto start = Clock::now();
    for (auto d : test)
    {
        result = d * d;  
    }
    auto end = Clock::now(); 

    auto noFunction = end - start; 

    start = Clock::now();  

    for (auto d : test)
    {
        result = sUptr->calculate(d);
    }
    end = Clock::now();  

    auto virtualMemberFunction = end - start; 

    start = Clock::now();  

    for (auto d : test)
    {
        result = sPtr->calculate(d);
    }
    end = Clock::now();  

    auto virtualMemberFunctionRaw = end - start; 

    start = Clock::now();
    for (auto d : test)
    {
        result = gStatic.calculate(d);  
    }
    end = Clock::now(); 

    auto staticPolicy = end - start; 

    start = Clock::now();
    for (auto d : test)
    {
        result = gMember.calculate(d);  
    }
    end = Clock::now(); 

    auto memberPolicy = end - start; 

    cout << noFunction.count() << " " << virtualMemberFunction.count() 
        << " " << virtualMemberFunctionRaw.count() 
        << " " << staticPolicy.count() 
        << " " << memberPolicy.count() << endl;

    delete sPtr; 
    sPtr = nullptr;

    return 0;
}

我使用 gcc 4.8.2 在 Linux x86_64 机器上编译了代码，CPU 型号如下:Intel(R) Core(TM) i7-4700MQ CPU @ 2.40GHz。

在一个测试中通过原始指针访问虚拟成员函数，在另一个测试中通过 unique_ptr 访问。首先我编译了没有任何优化的代码:

g++ -std=c++11 main.cpp -o main

并使用以下 shell 命令运行 1000 次测试:

for i in {1..1000};做 ./main >> 结果；完成

我使用以下 gnuplot 脚本(注意对数 y 轴)绘制的结果文件:

set terminal png size 1600,800
set logscale y 
set key out vert right top
set out 'results.png' 
plot 'results' using 0:1 title "no function" , \
     'results' using 0:2 title "virtual member function (unique ptr)", \
     'results' using 0:3 title "virtual member function (raw ptr)", \
     'results' using 0:4 title "static policy", \
     'results' using 0:5 title 'member function policy'

对于未优化的代码，图表如下所示:

Q1 通过 unique_ptr 调用虚函数是否最终成为最昂贵的调用，因为它在 dereferencing 时涉及重定向？指向托管对象的指针？

然后我打开优化并编译代码:

g++ -std=c++11 -O3 main.cpp -o main

结果如下图:

Q2:在这种情况下，虚拟成员函数是否成本最高，因为当通过基类指针或引用访问时(打开 vtable 调度)，它是 not possible for the compiler to make them inline ?

Q3:这个问题是我发布所有这些的原因:在优化的图表中，静态和成员策略最终如何比这个简单示例的推出代码更快？

编辑:使 result volatile 并在打开优化的情况下进行编译，使策略的运行时间更长，但它们是类似于原始乘法代码:

编辑修改代码，以便将结果添加到而不是分配(由 dyk 在评论中提出)不使用 volatile:

result += ...

结果与原始代码的图表相同。

最佳答案

查看 -O3 -march=native -std=c++11 与您的代码的反汇编表明编译器通过检测不必要的重新影响来进行“过多”优化相同的未使用变量。正如评论中所建议的，我使用 += 而不是 =。我还初始化了 result = 0 和 main 返回 result 而不是 0 以确保编译器计算其值.此修改后的代码给出:

• noFunction、staticPolicy 和 memberPolicy 降低为 mulsd、addsd， addsd，即标量 SSE 指令。 Clang 也不会向量化(使用 vanilla 选项)，但英特尔的 icc 会(它生成 vector 和非 vector 版本，并根据对齐和迭代次数进行跳转)。
• virtualMemberFunction 和 virtualMemberFunctionRaw 导致动态函数调用(无去虚拟化和内联)

您可以通过粘贴代码来亲自查看 here .

回答您的第一季度“调试版本中的指针与 unique_ptr”:在 -O0 中，调用不会自动内联，特别是 unique_ptr::operator-> 被显式调用，没有内联，因此每次迭代调用 2 个函数，而不是常规指针调用 1 个。对于优化的构建，这种差异消失了

回答你的 Q2 “是否可以内联虚拟调用”:在这个例子中，gcc 和 clang 没有内联调用，因为它们可能没有做足够的静态分析。但你可以帮助他们。例如，使用 clang 3.3(但不是 3.2 和 gcc)将方法声明为 const 和 __attribute((pure)) 就可以完成这项工作。在 gcc(4.8，4.9 之前)中，我尝试将方法标记为 final 并使用 -fwhole-program 进行编译，但这并没有删除调用。所以是的，在这种特定情况下，可以去虚拟化，但不可靠。一般来说，jitted 编译器(C#、Java)更擅长去虚拟化，因为它们可以根据运行时信息做出更好的假设。

关于c++ - 如何衡量函数的调用开销？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/22301968/