23

I am aware that the keyword inline has useful properties e.g. for keeping template specializations inside a header file. On the other hand I have often read that inline is almost useless as hint for the compiler to actually inline functions. Further the keyword cannot be used inside a cpp file since the compiler wants to inspect functions marked with the inline keyword whenever they are called.

Hence I am a little confused about the "automatic" inlining capabilities of modern compilers (namely gcc 4.43). When I define a function inside a cpp, can the compiler inline it anyway if it deems that inlining makes sense for the function or do I rob him of some optimization capabilities ? (Which would be fine for the majority of functions, but important to know for small ones called very often)

Martin
  • 4,738
  • 4
  • 28
  • 57
  • 2
    You should check out your compiler's link-time optimization support. In GCC, this is enabled with `-flto`. – Kerrek SB Dec 09 '11 at 18:46
  • Many thanks for all the answers. Since they are similar I chose the fastest one as accepted, while all three have taught me something. – Martin Dec 09 '11 at 18:50
  • We do not want to encourage fast answers. There is already too much of a race that people type common (but incorrect information) quickly to get the up-votes. We want to encourage thoughtful and informative answers. Note: Note that I disagree with your final choice just the method it was derived by. – Martin York Dec 09 '11 at 18:57
  • 1
    @Loki: I totally agree with you and this race is a common plague in q&a. Perhaps I should add one more reason. If the content is valid, and satisfies my answer, I tend to accept the answer from the one with the lowest rep. I think that helps people to build up some reputation, encourages participation and leads to more diversity in the portal. Of course this is only true for good answers. – Martin Dec 12 '11 at 11:41
  • To clarify: do you mean inline *across* files? By "defined in a cpp file" do you mean "not in a shared hpp" is that it? – Ciro Santilli OurBigBook.com May 17 '15 at 14:41

4 Answers4

19

Microsoft Visual C++ was able to do so at least since Visual Studio 2005. They call it "Whole Program Optimization" or "Link-Time Code Generation". In this implementation, the compiler will not actually produce machine code, but write the preprocessed C++ code into the object files. The linker will then merge all of the code into one huge code unit and perform the actual compilation..

GCC is able to do this since at least version 4.5, with major improvements coming in GCC 4.7. To my knowledge the feature is still considered somewhat experimental (at least in so far as many Linux distributions not using it). GCC's implementation works very similarly by first writing the preprocessed source (in its GIMPLE intermediate language) into the object files, then compiling all of the object files into a single object file which is then passed to the linker (this allows GCC to continue to work with existing linkers).

Many big C++ projects also do what is now being called "unity builds". Instead of passing hundreds of individual C++ source files into the compiler, one source file is created that includes all the other source files in the project. The original intent behind this is to decrease compilation times (since headers etc. do not have to be parsed over and over), but as a side-effect, it will have the same outcome as the LTO/LTCG techniques mentioned above: giving the compiler perfect visibility into all functions in all compilation units.

I jump between being impressed by my C++ compiler's (MSVC 2010) ingenuity and its stupidity. Some code that did pixel format conversion via templates, which would have resolved into 5-10 assembly instructions when properly inlined, got bloated into kilobytes(!) of nested function calls. At other times, it inlines so aggressively that whole classes disappear even though they contained non-trivial functionality.

Cygon
  • 9,444
  • 8
  • 42
  • 50
19

Within the compilation unit the compiler will have no problem inline functions (even if they are not marked as inline). Across compilation units it is harder but modern compilers can do it.

Use of the inline tag has little affect on 'modern' compilers and whether it actually inlines functions (it has better heuristics than the human mind) (unless you specify flags to force it one way or the other (which is usually a bad idea as humans are bad at making this decision)).

Paul R
  • 208,748
  • 37
  • 389
  • 560
Martin York
  • 257,169
  • 86
  • 333
  • 562
  • +1, but I disagree with the `inline tag has little affect`. From what I've seen, even the most recent additions of MSVC will inline any and all functions marked as such, (and then crash when it runs out of memory. hooray!) – Mooing Duck Dec 09 '11 at 18:55
  • 1
    @MooingDuck: From: http://msdn.microsoft.com/en-us/library/z8y1yy88%28v=vs.71%29.aspx The insertion (called inline expansion or inlining) occurs only if the compiler's cost/benefit analysis show it to be profitable. . Inlining everything marked inline by a user would be very silly. Humans are notoriously bad programmers and have little real understanding of many parts of the system (long live our machine overlords). – Martin York Dec 09 '11 at 19:16
  • @LokiAstari: https://connect.microsoft.com/VisualStudio/feedback/details/699728/visual-studio-runs-out-of-memory-when-compiling-recursive-inline-templates-in-release: Proof that MSVC will inline some functions even to the point of running out of memory. [GCC](http://ideone.com/GLEKw) compiles and runs it just fine. – Mooing Duck Dec 09 '11 at 19:27
  • 1
    That just shows that MS compiler is over-aggressive in its heuristics while gcc is a bit more timid. – Martin York Dec 09 '11 at 19:30
11

This depends on your compilation flags. With -combine and -fwhole-program, gcc will do function inlining across cpp boundaries. I'm not sure how much the linker will do if you compile into multiple object files.

thiton
  • 35,651
  • 4
  • 70
  • 100
6

The standard dictates nothing about how a function can be inlined. And compilers can inline functions if they have access to their implementation. If you only have a header with binaries, it would be impossible. If it's in the same module, the compiler can inline the function even if it is in the cpp file.

Luchian Grigore
  • 253,575
  • 64
  • 457
  • 625