Inline function v. Macro in C — What’s the Overhead (Memory/Speed)?

by

Calling an inline function may or may not generate a function call, which typically incurs a very small amount of overhead. The exact situations under which an inline function actually gets inlined vary depending on the compiler; most make a good-faith effort to inline small functions (at least when optimization is enabled), but there is no requirement that they do so (C99, ยง6.7.4):

Making a function an inline function
suggests that calls to the function be
as fast as possible. The extent to
which such suggestions are effective
is implementation-defined.

A macro is less likely to incur such overhead (though again, there is little to prevent a compiler from somehow doing something; the standard doesn’t define what machine code programs must expand to, only the observable behavior of a compiled program).

Use whatever is cleaner. Profile. If it matters, do something different.

Also, what fizzer said; calls to pow (and division) are both typically more expensive than function-call overhead. Minimizing those is a good start:

double ratio = SigmaSquared/RadialDistanceSquared;
double AttractiveTerm = ratio*ratio*ratio;
EnergyContribution += 4 * Epsilon * AttractiveTerm * (AttractiveTerm - 1.0);

Is EnergyContribution made up only of terms that look like this? If so, pull the 4 * Epsilon out, and save two multiplies per iteration:

double ratio = SigmaSquared/RadialDistanceSquared;
double AttractiveTerm = ratio*ratio*ratio;
EnergyContribution += AttractiveTerm * (AttractiveTerm - 1.0);
// later, once you've done all of those terms...
EnergyContribution *= 4 * Epsilon;

More Related Contents:

  1. optimized sum of an array of doubles in C [duplicate]
  2. Improve INSERT-per-second performance of SQLite
  3. Why does the order of the loops affect performance when iterating over a 2D array?
  4. Is there a performance difference between i++ and ++i in C?
  5. Can the linker inline functions?
  6. Is it safe to read past the end of a buffer within the same page on x86 and x64?
  7. Efficient 4×4 matrix vector multiplication with SSE: horizontal add and dot product – what’s the point?
  8. Why is memcmp so much faster than a for loop check?
  9. Faster approach to checking for an all-zero buffer in C?
  10. Real-world use of X-Macros
  11. Creating C macro with ## and __LINE__ (token concatenation with positioning macro)
  12. Disable all optimization options in GCC
  13. Does C# optimize the concatenation of string literals?
  14. In an OpenMP parallel code, would there be any benefit for memset to be run in parallel?
  15. Which ordering of nested loops for iterating over a 2D array is more efficient [duplicate]
  16. How does the C offsetof macro work? [duplicate]
  17. Is Fortran easier to optimize than C for heavy calculations?
  18. How to get 100% CPU usage from a C program
  19. Measuring Cache Latencies
  20. Cache size estimation on your system?
  21. Do temp variables slow down my program?
  22. faster equivalent of gettimeofday
  23. Fastest Implementation of the Natural Exponential Function Using SSE
  24. undefined reference when calling inline function
  25. Algorithm to find all the exact divisors of a given integer
  26. Count each bit-position separately over many 64-bit bitmasks, with AVX but not AVX2
  27. Which is better way to calculate nCr
  28. Why GDB jumps unpredictably between lines and prints variables as “”?
  29. Is x += 1 more efficient than x = x + 1?
  30. How much overhead can the -fPIC flag add?

Leave a Comment