__inline functions vs normal functions in C

Generally the compiler will choose to inline if it decides that the performance will be better. So it has to compare the cost of actually calling the non-inline function (pushing arguments onto stack, saving registers etc) is more than the the code itself. So for simple accessors, or simple calculations it is often the case that the cost of calling a function is more, hence the compiler will inline.

Often compilers have size constraints too so that they don't allow inlining to grow the code too much.

There is also locality to be considered. An inlined function will not likely cause a page fault, will likely not cause a processor cache miss, so will generally be faster from that point of view. Non-inlined functions will often require code to be loaded into the processor cache, which is very slow by comparison.

There are other reasons for declaring functions to be inline, even though you don't really expect the compiler to inline them. The entire STL in C++ is inlined, even though it is unlikely that most of it would ever actually be inlined. It is done this way for reasons of template instantiation, and issues to do with application binary interfaces and so on.

The benefits of inlining a function is removing the function call overhead and giving the optimizer a better chance of optimizing the calling code with the function code. For example, the optimizer may completely eliminate the inlined code under some circumstances.

The drawback is the possibility of increasing your code size which under certain circumstances can also slow down the execution speed if the bottleneck is CPU instruction fetch.

So it depends. Compilers use various heuristics to figure out if inlining a function is a net benefit. A compiler may inline a function even if you don't specifiy the inline keyword or it may not inline if you do. There are usually ways of forcing a compiler to inline the function to override its decision.

This What are good heuristics for inlining functions? has a good discussion and further links regarding inlining heuristics.

When you use a inline function, the function code is pasted in the line when is called, it generates too a executable program bigger than the one which doesn't use inline functions, in the other hand, a no inline function, when is called, the program stop and jumps to the memory dir where the function code start...

Conclusion: inline function = better performance, more space funcion = less space, a slight less performance

There is a pretty good overview of gcc's inlining options and the decision processes at GNU GCC.

That identifies the cases where inlining is not possible: "use of varargs, use of alloca, use of variable sized data types, use of computed goto, use of nonlocal goto, and nested functions"

An important point is a non-static function, i.e one with extern linkage (which is every functions which is declared without static) may be called, or have its address taken in a different source file.

This forces the compiler to generate a 'normal' function as well as any inlined function bodies. This, of course, generates a program which is bigger than only generating the 'normal' non-inline function.

Gcc has an option -ffunction-sections which generate object files which enable the linker to eliminate functions which are not used, at the cost of "... the assembler and linker will create larger object and executable files and will also be slower."

On more recent versions of gcc, Link Time Optimisations (LTO) (see "Whole Program Optimizations") is supported. This allows an optimisation stage to look at all the compiled program, and do even more aggressive inlining and optimisation, and exclude unused code.

It is also interesting to look at some of the newer gcc-4.6 gcc-4.7 Interprocedural optimisations. For example inline-ing only the 'hot path' of an inline function, rather than the whole function. Gcc might also generate multiple instances of one function because constants are known, and gcc calculates it is better to have multiple implementations, each optimised for those known constants.

There are options in gcc to ask for the compiler to inline all “simple enough” functions.

Finally it says "As required by ISO C++, GCC considers member functions defined within the body of a class to be marked inline even if they are not explicitly declared with the inline keyword". In which case its rule for "simple enough" is used.

Summary: the compiler might do very clever optimisations above and beyond what might be expected from ordinary functions or inline functions.