C ++：两次调用虚函数之间执行时间的差异

Question

在gcc 4.5.1（Ubuntu 10.04，intel core2duo 3.0 Ghz）下考虑这个代码。这只是2个测试，在第一个我直接调用虚拟fucnion，在第二个我通过Wrapper类调用它：

TEST.CPP

#define ITER 100000000

class Print{

public:

typedef Print* Ptr;

virtual void print(int p1, float p2, float p3, float p4){/*DOES NOTHING */}

};

class PrintWrapper
{

    public:

      typedef PrintWrapper* Ptr;

      PrintWrapper(Print::Ptr print, int p1, float p2, float p3, float p4) :
      m_print(print), _p1(p1),_p2(p2),_p3(p3),_p4(p4){}

      ~PrintWrapper(){}

      void execute()
      { 
        m_print->print(_p1,_p2,_p3,_p4); 
      }

    private:

      Print::Ptr m_print;
      int _p1;
      float _p2,_p3,_p4;

};

 Print::Ptr p = new Print();
 PrintWrapper::Ptr pw = new PrintWrapper(p, 1, 2.f,3.0f,4.0f);

void test1()
{

 //-------------test 1-------------------------

 for (auto var = 0; var < ITER; ++var) 
 {
   p->print(1, 2.f,3.0f,4.0f);
 }

 }

 void test2()
 {

  //-------------test 2-------------------------

 for (auto var = 0; var < ITER; ++var) 
 {
   pw->execute();
 }

}

int main() 
{ 
  test1(); 
  test2();
}

我用gprof和objdump来描述它：

g++ -c -std=c++0x -pg -g -O2 test.cpp
objdump -d -M intel -S test.o > objdump.txt
g++ -pg test.o -o test
./test
gprof test > gprof.output

在gprof.output中我发现test2（）比test1（）花费的时间更长，但我无法解释它

Each sample counts as 0.01 seconds.
  %   cumulative   self              self     total           
 time   seconds   seconds    calls  ms/call  ms/call  name    
 49.40      0.41     0.41        1   410.00   540.00  test2()
 31.33      0.67     0.26 200000000     0.00     0.00  Print::print(int, float, float, float)
 19.28      0.83     0.16        1   160.00   290.00  test1()
  0.00      0.83     0.00        1     0.00     0.00  global constructors keyed to p

objdump.txt中的汇编代码也没有帮助我：

 //-------------test 1-------------------------
 for (auto var = 0; var < ITER; ++var) 
  15:   83 c3 01                add    ebx,0x1
 {
   p->print(1, 2.f,3.0f,4.0f);
  18:   8b 10                   mov    edx,DWORD PTR [eax]
  1a:   c7 44 24 10 00 00 80    mov    DWORD PTR [esp+0x10],0x40800000
  21:   40 
  22:   c7 44 24 0c 00 00 40    mov    DWORD PTR [esp+0xc],0x40400000
  29:   40 
  2a:   c7 44 24 08 00 00 00    mov    DWORD PTR [esp+0x8],0x40000000
  31:   40 
  32:   c7 44 24 04 01 00 00    mov    DWORD PTR [esp+0x4],0x1
  39:   00 
  3a:   89 04 24                mov    DWORD PTR [esp],eax
  3d:   ff 12                   call   DWORD PTR [edx]

  //-------------test 2-------------------------
 for (auto var = 0; var < ITER; ++var) 
  65:   83 c3 01                add    ebx,0x1

      ~PrintWrapper(){}

      void execute()
      { 
        m_print->print(_p1,_p2,_p3,_p4); 
  68:   8b 10                   mov    edx,DWORD PTR [eax]
  6a:   8b 70 10                mov    esi,DWORD PTR [eax+0x10]
  6d:   8b 0a                   mov    ecx,DWORD PTR [edx]
  6f:   89 74 24 10             mov    DWORD PTR [esp+0x10],esi
  73:   8b 70 0c                mov    esi,DWORD PTR [eax+0xc]
  76:   89 74 24 0c             mov    DWORD PTR [esp+0xc],esi
  7a:   8b 70 08                mov    esi,DWORD PTR [eax+0x8]
  7d:   89 74 24 08             mov    DWORD PTR [esp+0x8],esi
  81:   8b 40 04                mov    eax,DWORD PTR [eax+0x4]
  84:   89 14 24                mov    DWORD PTR [esp],edx
  87:   89 44 24 04             mov    DWORD PTR [esp+0x4],eax
  8b:   ff 11                   call   DWORD PTR [ecx]

我们如何解释这种差异？

Answer 1

在test2()该程序必须首先加载pw从堆中，然后调用pw->execute()其即被调用开销），然后加载pw->m_print以及所述_p1通过_p4参数，然后加载虚表指针对于pw ，然后为pw->Print加载vtable插槽，然后调用pw->Print 。 因为编译器无法通过虚拟调用进行查看，所以它必须假定所有这些值在下一次迭代中都已更改，并重新加载它们。

在test() ，参数在代码段中是内联的，我们只需要加载p ，vtable指针和vtable槽。 我们用这种方式节省了五个负载。 这可以很容易地解释时差。

简而言之 - pw->m_print和pw->_p1到pw->_p4的负载是这里的罪魁祸首。

Answer 2

一个区别是你在test1中传递给print的值将被存储在指令本身中，而PrintWrapper中的东西必须从堆中加载。 您可以在汇编程序中看到这种情况。 由于这个原因，可能会遇到不同的内存访问时间。

Answer 3

在直接调用中，编译器可以优化函数的虚拟性，因为p的类型在编译时是已知的（因为对p的唯一赋值是可见的）。 在PrintWrapper ，类型被擦除并且必须执行虚函数调用。

Answer 4

你实际打印，或只是调用一个名为Print的函数什么都不做？ 如果你真的在打印，那么你正在称重猪的头发。

无论如何，gprof对I / O是盲目的，所以它只关注你的CPU使用情况。

请注意，Test2在调用之前执行了11次移动，而Test1只执行了6.因此，如果有更多的PC样本在Test2中着陆，那就不足为奇了。