Question

For the below code example, the speed to execute method “increment” by the pointer – num_ptr is significantly slower than the local variable – num. I think it is related to the virtual method, but I don’t understand why. Please help explain this. I am trying to understand the performance issue from this example.

#include <iostream>

const long long iterations_count = 1000000;

// a number interface
struct number {        
    virtual void increment() = 0;
};

struct concrete_number:number
{
    long long a;
    concrete_number(long long p){
        a = p;
    }
    void increment()
    {
        a+=1;
    }
};

int main() {

    concrete_number num(0);
    concrete_number* num_ptr = &num;

    for (long long i = 0; i < iterations_count; i++) {
        num.increment();
    }

    for (long long i = 0; i < iterations_count; i++) {
        num_ptr->increment();
    }
    std::getchar();
}

Answer 1

num.increment(); is resolved statically, num_ptr->increment(); will be resolved dynamically (the function is called through dynamic dispatch because it’s virtual).

However, with full optimizations on, the compiler should produce similar results.

No optmizations:

    num.increment();
00341453  lea         ecx,[num]  
00341456  call        concrete_number::increment (341186h)  

vs

    num_ptr->increment();
00341490  mov         eax,dword ptr [num_ptr]  
00341493  mov         edx,dword ptr [eax]  
00341495  mov         esi,esp  
00341497  mov         ecx,dword ptr [num_ptr]  
0034149A  mov         eax,dword ptr [edx]  
0034149C  call        eax  
0034149E  cmp         esi,esp  
003414A0  call        @ILT+340(__RTC_CheckEsp) (341159h)  

With optimizations, at least for me, both calls are inlined.