C++ for Scientists - Technische Universität Dresden

40 CHAPTER 2. C++ BASICS
2.6.1 Inline Functions
Calling a function requires a fair amount of activities:
• The arguments (or at least their addresses) must be copied on the stack;
• The current program counter must be copied on the stack to continue the execution at
this point when the function is finished;
• Save registers to allow the function using them;
• Jump to the code of the function;
• Execute the function;
• Clean the arguments from the stack;
• Copy the result on the stack;
• Jump back to the calling code;
• Store back registers.
What happens exactly depends on the hardware. The good news is that the function call
overhead is dramatically lower than in the past. Furthermore, the compiler can optimize out
those activities not needed in a specific call.
Nonetheless, for small functions, like the square above, the effort for calling the function is still
significantly higher than what the function actually does. C programmers avoid the function-call
overhead by macros. Macros create so many problems in the software development that they
must only be used when there is absolutely no alternative whatsoever. Bjarne Stroustrup
says “Almost every macro demonstrates a flaw in the programming language, in the program,
or in the programmer.” We like to add a flaw “in the compiler optimization”. 16
Fortunately, we have an excellent alternative to macros: inline functions. The programmer just
adds the keyword inline to the function definition:
inline double square(double x)
{
return x ∗ x;
}
and all the overhead of the function call vanishes into thin air.
An excessive use of inline can have a negative effect on performance. When many large functions
are inlined then the binary executable becomes very large. The consequence is that a lot of
time is spend loading the binary from memory and lots of cache memory is wasted for it as
well. This decreases the memory bandwidth and cache available for data, causing more slow
down than what is saved on function calls.
16 Advanced: Compilers are today really smart in eliminating unused code. However, we experienced that
arguments of inline functions might be constructed although they are not used. This are usually only few
machine instructions. But when this happens extremely frequently as in an index range check that should
disappear in release mode, it can ruin the overall performance. We hope that further compiler improvement can
rescue us from this kind of macro usage.