C/C++ faster calls from array of functions - c++

Question

Dear all,
I've a program in C++ that should be as fast as possible.
In particular, there is a crucial part that works as follows:
There is a variable D ranging in [0,255], based on its value
it calls the function whose pointer is stored in a array F (with 255 elements).
i.e., F[D] gives the pointer to the function to call.
The functions are very simple, they execute few expressions or/and assignments (no cycles).
How can I do this faster?
I can replicate the code in the functions. I do not need features of functions call (I'm using them since it was simpler way to do).
My goal is that of removing the inefficiencies due to calls of functions.
I consider to use Switch/case.
The code of each case is the code of the corresponding function.
Is there a faster way to do it?

Answer 1

A switch/case may be faster, as the compiler can make more specific optimizations, and there are other things like code locality compared to calling a function pointer. However, it's unlikely that you'll notice a substantial performance increase.

Answer 2

Convert it to a switch
Make sure the tiny functions can be inlined (how to do this is compiler dependant - but explicitly marking them inline and placing them in the compilation unit is a good bet)
Finally, you might try profile-guided optimizations if (as seems quite possible) your switch statement calls the branches in a non-uniform fashion.
The aim is to avoid function-call overhead and have the compiler reorder the switch statement to reduce the number of branches typically encountered.
Edit: since there's some skeptical voices as to how much this helps; I gave it a shot. In the following program, the function-pointer loop needs 1.07 seconds, and the inlined switch statement takes 0.79 seconds on my machine - YMMV:
template<unsigned n0,unsigned n> struct F { static inline unsigned func(unsigned val); };
template<unsigned n> struct F<0,n> { static inline unsigned func(unsigned val) { return val + n;} };
template<unsigned n> struct F<1,n> { static inline unsigned func(unsigned val) { return val - n; } };
template<unsigned n> struct F<2,n> { static inline unsigned func(unsigned val) { return val ^ n; } };
template<unsigned n> struct F<3,n> { static inline unsigned func(unsigned val) { return val * n; } };
template<unsigned n> struct F<4,n> { static inline unsigned func(unsigned val) { return (val << ( n %16)) + n*(n&0xff); } };
template<unsigned n> struct F<5,n> { static inline unsigned func(unsigned val) { return (val >> ( n %16)) + (n*(n&0xff) << 16); } };
template<unsigned n> struct F<6,n> { static inline unsigned func(unsigned val) { return val / (n|1) + val; } };
template<unsigned n> struct F<7,n> { static inline unsigned func(unsigned val) { return (val <<16) + (val>>16); } };
template<unsigned n> struct f { static inline unsigned func(unsigned val) { return F<n%8,n>::func(val); } };
typedef unsigned (*fPtr)(unsigned);
fPtr funcs[256];
template<unsigned n0,unsigned n1> inline void fAssign() {
if(n0==n1-1 || n0==n1) //||n0==n1 just to avoid compiler warning
funcs[n0] = f<n0>::func;
else {
fAssign<n0,(n0 + n1)/2>();
fAssign<(n0 + n1)/2,n1>();
}
}
__forceinline unsigned funcSwitch(unsigned char type,unsigned val);//huge function elided
__declspec(noinline) unsigned doloop(unsigned val,unsigned start,unsigned end) {
for(unsigned x=start;x<end;++x)
val = funcs[x*37&0xff](val);
return val;
}
__declspec(noinline) unsigned doloop2(unsigned val,unsigned start,unsigned end) {
for(unsigned x=start;x<end;++x)
val = funcSwitch(x*37&0xff,val);
return val;
}
I verified that all function calls are inlined except those to doloop, doloop2 and funcs[?] to ensure I'm not measuring odd compiler choices.
So, on this machine, with MSC 10, this (thoroughly artifical) benchmark shows that the huge-switch version is a third faster than the function-pointer lookup-based version. PGO slowed both versions down; probably because they're too small to exhibit cache effects and the program is small enough to be fully inlined/optimized even without PGO.

Answer 3

You're not going to beat the lookup table based indirect call with any other method, including switch. Switch is going to take at best logarithmic time (well, it might hash to get constant time, but that'll likely be slower than logarithmic time with ints for most input sizes).
This is assuming your code looks like this:
typedef void (*myProc_t)();
myProc_t functionArray[255] = { ... };
void CallSomepin(unsigned char D)
{
functionArray[D]();
}
If you're creating the array each time the function is called however, it might be a good idea to amortize the cost of the construction by doing the initialization of the function array once, rather than every time.
EDIT: That said, the best way to avoid the inefficiency of the indirect call is simply to not do it. Look at your code and see if there are places you can replace the indirect lookup based call with a direct call.

Answer 4

There is a variable D ranging in [0,255], based on its value it calls the function whose pointer is stored in a array F (with 255 elements)
Warning, this will result in a buffer overflow if D has the value 255.