How do I force gcc to inline a function?

Question

Does __attribute__((always_inline)) force a function to be inlined by gcc?

Pedalfer

GCC uses code size as heuristic to determine whether something will be inlined. I have a networking/serialization library where it wont inline functions by default because of code size. I did inlining and it improved performance 30% in benchmark. One reason to inline, is if you know values at compile time (consts are passed in) and you want to flatten the function. For instance if a function is used in two different places with different static parameters, inlining can reduce branches. This is for functions usd in an inner loop. – Pedalfer

Another example reason: I do audio DSP coding. Sometimes I can't use the debugger because the non-inlined function calls (from lots of accessor functions and stuff) become so expensive the code can't service the buffer fast enough. – Munn

Just as a reminder ... you need to specify both inline and __attribute__((always_inline)). I just tested this on Android NDK r10d with GCC. Perhaps not a standard environment but from what I've read this requirement is the same for all platforms. – Glottal

Another example (not optimization-based): When writing a function for a microcontroller to write to its internal flash at runtime, I need to copy the routine that does the actual writing out of flash and into ram before starting the write, as simultaneous reads and writes are not allowed. If this routine calls any non-inlined functions, then I would have to copy all dependencies into ram and dynamically adjust any jump addresses, which is way more complex than the force-inline solution. – Communalize

Force inlining provides something akin at least portion of non-type template parameters in C++: when you know you want a new function compiled for each value of a parameter. You could try to use macros to get this ability, but force-inlining is often cleaner (although less portable). – Brackett

One exception is that gcc will not inline functions with variable argument lists int forexample ( const char * fmt, ... ); – Oestrin

Think of inline functions returning V8 handles. How would I know whether I should .Escape() the handles or not, if the functions are not ensured to be inline? If the compiler fails to inline such functions, V8 will make new handle scopes! – Junko

Answer 1

Yes.

• From documentation v4.1.2
• From documentation latest

always_inline

Generally, functions are not inlined unless optimization is specified. For functions declared inline, this attribute inlines the function even if no optimization level was specified.

Karolynkaron

Answer 2

It should. I'm a big fan of manual inlining. Sure, used in excess it's a bad thing. But often times when optimizing code, there will be one or two functions that simply have to be inlined or performance goes down the toilet. And frankly, in my experience C compilers typically do not inline those functions when using the inline keyword.

I'm perfectly willing to let the compiler inline most of my code for me. It's only those half dozen or so absolutely vital cases that I really care about. People say "compilers do a good job at this." I'd like to see proof of that, please. So far, I've never seen a C compiler inline a vital piece of code I told it to without using some sort of forced inline syntax (__forceinline on msvc __attribute__((always_inline)) on gcc).

Asaph

I appreciate the msvc vs. gcc comparison! – Astor

I agree but I force inlining way more than it. I use __forceinline on thousands of functions and have saved 20% of a 600 server farm. Assuming that the compiler will make the best decision WRT inlining is simply not true. The compiler is guessing. Educated guess or not, it is still a guess. The compiler doesn't know that you wrote the function to optimize out expressions formed with constant parameters. Etc etc etc. – Extinctive

with gcc you also need to specify inline explicitly: __attribute__((always_inline)) inline YourFunc(... else you will get warning: always_inline function might not be inlinable [-Wattributes] – Wald

Answer 3

Yes, it will. That doesn't necessarily mean it's a good idea.

Rudderpost

Inlining a function won't always improve performance (e.g. cache issues). – Scar

Example of a very good reason I use it sometimes: When developing audio DSP applications sometimes the debug build can't process fast enough to keep up with the sample rate. By forcing things like accessor functions to inline I am able to test and debug. – Munn

Correction: it doesn't necessarily mean it's a good idea. Sometimes it is. – Unbeaten

Answer 4

According to the gcc optimize options documentation, you can tune inlining with parameters:

-finline-limit=n
By default, GCC limits the size of functions that can be inlined. This flag 
allows coarse control of this limit. n is the size of functions that can be 
inlined in number of  pseudo instructions.

Inlining is actually controlled by a number of parameters, which may be specified
individually by using --param name=value. The -finline-limit=n option sets some 
of these parameters as follows:

    max-inline-insns-single is set to n/2. 
    max-inline-insns-auto is set to n/2.

I suggest reading more in details about all the parameters for inlining, and setting them appropriately.

Scar

Answer 5

I want to add here that I have a SIMD math library where inlining is absolutely critical for performance. Initially I set all functions to inline but the disassembly showed that even for the most trivial operators it would decide to actually call the function. Both MSVC and Clang showed this, with all optimization flags on.

I did as suggested in other posts in SO and added __forceinline for MSVC and __attribute__((always_inline)) for all other compilers. There was a consistent 25-35% improvement in performance in various tight loops with operations ranging from basic multiplies to sines.

I didn't figure out why they had such a hard time inlining (perhaps templated code is harder?) but the bottom line is: there are very valid use cases for inlining manually and huge speedups to be gained.

If you're curious this is where I implemented it. https://github.com/redorav/hlslpp

Uneventful

template function code tends not to get inlined, but rather every specialization gets into a separate .text section in order to make "vague linkage" possible (see gcc.gnu.org/onlinedocs/gcc-4.8.0/gcc/Vague-Linkage.html). By forcing inlining, you basically lose the ability to explicitly specialize template functions in different compilation units. – Boff

I see, thanks for the explanation @GézaTörök that explains the behavior. Most math classes are quite hard to write without templating (not to mention the perf gains), so it seems like explicitly forcing inline is often a must. – Uneventful

Answer 6

Yes. It will inline the function regardless of any other options set. See here.

Sarre

Answer 7

One can also use __always_inline. I have been using that for C++ member functions for GCC 4.8.1. But could not found a good explanation in GCC doc.

Rebellious

Answer 8

Actually the answer is "no". All it means is that the function is a candidate for inlining even with optimizations disabled.

Munn

and yet the top answer has a direct quote that specifically says "this attribute inlines the function". I see no reference to any "candidate" there at all. What is your source? – Wolverine

This is true for the inline keyword, not for the always_inline attribute, see here – Berglund