local variable vs pointer performance

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();
}

The virtual method does seem like the most likely cause. When you call a virtual method on an object, the decision of which version to call can be done at compile time; when you call it on a pointer, the decision can only be done at runtime (of course, if the compiler can figure it out, in can make this decision at compile time, but there are definitely cases where it cannot). — user1233508
– user1233508, Commented Sep 12, 2012 at 7:33
I'm suprised you're getting slow performance results. The compiler should be able to optimize this since in this case, even though there is a virtual function call, the pointer is the same type as the derived type (i.e. there is no base class pointer involved in num_ptr->increment). — sashang
– sashang, Commented Sep 12, 2012 at 7:35
Hi sashang, I am indeed very surprised too. This program is built with static linking, I am using Visual Studio 2012 release mode with Optimization options /O2 /Oi /Ot — Bryan Fok
– Bryan Fok, Commented Sep 12, 2012 at 7:49

Luchian Grigore · Accepted Answer · 2012-09-12 07:32:43Z

6

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.

answered Sep 12, 2012 at 7:32

Luchian Grigore

260k68 gold badges465 silver badges634 bronze badges

Sign up to request clarification or add additional context in comments.

2 Comments

Bryan Fok Over a year ago

When you said it resolved dynamically, is that mean my program try to look up the vtable at run-time to determine where is the most derived method implementation? And my problem has nothing to do with their memory locations (stack or heap)? Thanks in advance.

Luchian Grigore Over a year ago

@BryanFok also, there's nothing on the heap. You only have stack objects.

Collectives™ on Stack Overflow

local variable vs pointer performance

1 Answer 1

2 Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

1 Answer 1

2 Comments

Your Answer

Sign up or log in

Post as a guest

Related