Am I profiling this the right way ( C++ virtual functions ) - c++

Question

I wanted to give up virtual functions in favor to function pointers, so I did some profiling, and here is how did it.
What I am trying to do, is decide whether to use virtual functions, or function pointers as in( int (*fcnPtr)(int); ) to achieve polymorphism.
Run time Polymorphism 1:
Just use virtual functions.
Run time Polymorphism 2 ( What I think is slightly fast, but bad design ):
Create a function pointer, like ( int (*fcnPtr)(int); ) as member variable.
Now each child class defines it own function pointer.
Call the function pointer, in the non virtual base function fct()
Now you have one direct method calling multiple functions.
This will result in two calls, one for the direct method, then the function pointer, that will be redefined in each child class.
even there are two calls, it's still faster than the virtual functions by ( 120 ms ), for 10 * 1000 * 1000 calls, and for 1000 child class, I think it's due to the virtual function lookups, if I am not mistaken, it has to look up the right class between 1000 classes in this case to call the right function.
I created a base class
void testFct()
{
int c = 0; c+=10;
}
class Base_Class{
public:Base_Class(){}
~Base_Class(){}
virtual void v_Fct() __attribute__ ((noinline)){ int c = 0; c+=10;
void fct() __attribute__ ((noinline)){ fcnPtr(); }
void (*fcnPtr)() = testFct;
};
Then I generated a 1000 child classes like this.
class Child_Class_0: public Base_Class
{
public:
Child_Class_0(){}
virtual void v_Fct() __attribute__ ((noinline)){ int c = 0; c+=10;}
};
.
class Child_Class_1: public Base_Class
{
public:
Child_Class_1(){}
virtual void v_Fct() __attribute__ ((noinline)){ int c = 0; c+=10;}
};
I also generated a factory function like this, to create objects at run time:
Base_Class *createObj( int i )
{
switch ( i ) {
case 0:
return new Child_Class_0();
break;
case 1:
return new Child_Class_1();
break;
case ..:
case 999:
}
Here are the profiling functions:
void profileVirtuals( int classCount , qreal maxCalls )
{
qreal i = 0;
QElapsedTimer myTimer;
myTimer.start();
/// At this point , the compiler has no idea
/// which child class to instantiate
for ( ;i < maxCalls; ++i) {
int randChild = random( 0 , classCount );
Base_Class *cc = createObj( randChild );
if( cc ){
/// Call virtual function
cc->v_Fct();
delete cc;
}
/// Make sure we are not missing any calls
else
qDebug() << "NULL";
}
int elapsed = myTimer.elapsed();
qDebug() << "VIRTUAL Function Called : " << i << " times.";
qDebug() << "DONE : " << elapsed;
}
.
void profileDirects( int classCount , qreal maxCalls )
{
qreal i = 0;
QElapsedTimer myTimer;
myTimer.start();
/// At this point , the compiler has no idea
/// which child class to instantiate
for ( ;i < maxCalls; ++i) {
int randChild = random( 0 , classCount );
Base_Class *cc = createObj( randChild );
if( cc ){
/// Call direct function
cc->fct();
delete cc;
}
/// Make sure we are not missing any calls
else
qDebug() << "NULL";
}
int elapsed = myTimer.elapsed();
qDebug() << "DIRECT Function Called : " << i << " times.";
qDebug() << "DONE : " << elapsed;
}
Here is the main functions, where I call both the virtual functions and the direct functions 10 * 1000 * 1000 times each
int main(int argc, char *argv[])
{
QCoreApplication a(argc, argv);
int classCount = 1000;
qreal maxCalls = 10 * 1000 * 1000;
profileVirtuals( classCount , maxCalls );
profileDirects( classCount , maxCalls );
return a.exec();
}
And what I get is for 10 * 1000 * 1000 calls , about a 120 ms difference ( Of course direct calls faster ). Not that significant difference after all
The code is in Qt framework, but can easily understood as standard C++.
I will update the question if there is something unclear, about what I just did, or trying to do.
Conclusion:
Polymorphism 1 is faster than Polymorphism 2, if there are fewer child classes around a 100 child class.
Polymorphism 2 is faster than Polymorphism 1, if there are lots of child classes, more than a 1000 child class, the vTable lookup is what slows it down.