Performance C ++：动态加载库和循环

Question

I want to make fast iterations of a dynamically loaded library symbol. To see how much performance I can get comparing to hard-coding the function, I did some benchmarks for a simple addition operation.

I use this function to do the operation

long int func(long int x)
{
    return x+1;
}

And this loops to test the time

Hard-coded:

for(i=0;i<N;i++)
    c = c + 1;

With the function (defined in the same file where the loop is):

for(i=0;i<N;i++)
    c = func(c);

With func from a linked object (func.o):

for(i=0;i<N;i++)
    c = object_func(c);

With func from a dynamically loaded symbol ( using dlopen and dlsym )

for(i=0;i<N;i++)
    c = dynamic_func(c);

This are the results for different N values, and everything compiled with g++ -Ofast:

There are a couple of ''mysterious'' things, first the function version give some 0 time values so there are missing points in its line. Then, is almost an order of magnitude less than the hard-coded version. I presume that the compiler is optimizing the operation, so the times don't rise. Other strange thing is that for small N values the object or shared libraries give better times.

This is the same without optimizations. Again is curious that the hard-coded starts slower than the rest, but now it is clear that the optimizer was responsible of the flat curves. Nonetheless, the N parameter is an argument to the program, it is not fixed at building time.

Anyone can explain this behavior? And the main question: Is there a way to get better results for object or dynamic libraries for large N?

Thanks

Answer 1

Nothing misterious, it's simple:

1. object_func, dynamic_func are the same thing except dinamic requires bit more time for library loading. Complexity of cycle is O(n), so the charts.

2. c++ is not just c with classes it also has wary powerfull optimizer. So the optimizer look into hard code and replace it with this:

   c = N;

Note: optimizer only can do that if it knows N and operation/function in compile time.

Answer 2

Behaviour explanation :

For the first two, the code is optimized out by the compiler (O(1)). For the last two, the function is obviously called (O(N)).

How to get better results :

You should pass the N value as a parameter to your dynamically loaded function and perform the loop inside the function to avoid the function call overhead on large N.