### Reduce Function-Call Overhead

Whether you are writing a function or calling a library function, there are a few things you should keep in mind:

- Use virtual functions only when necessary. They are usually compiled to be indirect calls, which are slower than direct calls.
- Usually, you should not declare virtual functions inline. If all virtual functions in a class are inline, the virtual function table and all the virtual function bodies will be replicated in each compilation unit that uses the class.
- Unless absolutely necessary, do not use function pointers; call functions directly.
- Fully prototype all functions. A full prototype gives the compiler and optimizer complete information about the types of the parameters. As a result, promotions from unwidened types to widened types are not required and the compiler never needs to emit eyecatcher instructions for the function.
- Use _Optlink linkage wherever possible. Keep _Optlink as your default linkage and use linkage keywords to change the linkage for specific functions.
- Avoid using unprototyped variable argument functions. Because of the nature of the _Optlink calling convention, unprototyped variable-length argument lists make performance slower. Prototype all of your functions. Also, use the _System calling convention for any variable argument functions.
- When designing a function, place the most used parameters in the left-most position in the function prototype. The left-most parameters have a better chance of being stored in a register. For the same reason, parameters used immediately upon function entry should also be placed near the left-most position (the first three integral parameters can be passed via parameters).
- Avoid passing structures or unions as function parameters or returning a structure or a union. Passing such aggregates requires the compiler to copy and store many values. This is worse in C++ programs in which class objects are passed by value, a constructor and destructor are called when the function is called. Instead, pass or return a pointer to the structure or union.
- Pass atomic types (like int and short) by value rather than passing by reference, wherever possible.
- If you call another function near the end of your function and pass it the same parameters that were passed to your function, put the parameters in the same order in the function prototypes. The compiler can then reuse the storage that the parameters are in and does not have to generate code to reorder them.
- Use the intrinsic and built-in functions, which include string manipulation, floating-point, and trigonometric functions, instead of coding your own. Intrinsic functions require less overhead and are faster than a function call, and often allow the compiler to perform better optimization. Your functions are automatically mapped to intrinsic functions if you include the IBM C and C++ Compilers header file. This mapping is overridden if you #undef the macro name.
- You can increase processing speed by inlining certain math functions with the _FP_INLINE macro.When you define _FP_INLINE, the prototypes for the trigonometric functions (sin, cos, tan, asin, acos, atan)and sqrt are modified so that the built-in functions are used instead of the run-time library equivalents.
  Note: you cannot take advantage of error handling when _FP_INLINE is defined. It is assumed that errno is never set or called.
- Use recursion only where necessary. Because recursion involves building a stack frame, an iterative solution is always faster than a recursive one.

Overview of Optimization
Calling Conventions
Eyecatchers

Optimize Your Application

C Library Reference - Intrinsic Functions