Can I selectively (force) inline a function?

Question

In the book Clean Code (and a couple of others I have come across and read) it is suggested to keep the functions small and break them up if they become large. It also suggests that functions should do one thing and one thing only.

In Optimizing software in C++ Agner Fog states that he does not like the rule of breaking up a function just because it crosses a certain threshold of a number of lines. He states that this results in unnecessary jumps which degrade performance.

First off, I understand that it will not matter if the code I am working on is not in a tight loop and that the functions are heavy so that the time it takes to call them is dwarfed by the time the code in the function takes to execute. But let's assume that I am working with functions that are, most of the time, used by other objects/functions and are performing relatively trivial tasks. These functions follow the suggestions listed in the first paragraph (that is, perform one single function and are small/comprehensible). Then I start programming a performance critical function that utilizes these other functions in a tight loop and is essentially a frame function. Lastly, assume that in-lining them has a benefit for the performance critical function but no benefit whatsoever to any other function (yes, I have profiled this, albeit with a lot of copying and pasting which I want to avoid).

Immediately, one can say that tag the function inline and let the compiler choose. But what if I don't want all those functions to be in a `.inl file or exposed in the header? In my current situation, the performance critical functions and the other functions it uses are all in the same source file.

To sum it up, can I selectively (force) inline a function(s) for a single function so that the end code behaves like it is one big function instead of several calls to other functions.

Solution 1

You cannot force the inline. Also, function calls are pretty cheap on modern CPUs, compared to the cost of the work done. If your functions are large enough to need to be broken down, the additional time taken to do the call will be essentially nothing.

Failing that, you could ... try ... to use a macro.

Solution 2

There is nothing that prevents you to put inline in a static function in a .cpp file.

Some compilers have the option to force an inline function, see e.g. the GCC attribute((always_inline)) and a ton of options to fine tune the inlining optimizations (see -minline-* parameters).

My recommendation is to use inline or even better static inline wherever you see fit, and let the compiler decide. They usually do it pretty well.

Solution 3

No, inline is a recommendation to the compiler ; it does not force it to do anything. Also, if you're working with MSVC++, note that __forceinline is a misnomer as well ; it's just a stronger recommendation than inline.

Solution 4

This is as much about good old fashioned straight C as it is about C++. I was pondering this the other day, because in an embedded world, where both speed and space need to be carefully managed, this can really matter (as opposed to the all too oft "don't worry about it, your compiler is smart and memory is cheap prevalent in desktop/server development).

A possible solution that I have yet to vet is to basically use two names for the different variants, something like

inline int _max(int a, int b) {
    return a > b ? a : b;
}

and then

int max(int a, int b) {
    return _max(a, b);
}

This would give one the ability to selectively call either _max() or max() and yet still having the algorithm defined once-and-only-once.

Solution 5

Inlining – For example, if there exists a function A that frequently calls function B, and function B is relatively small, then profile-guided optimizations will inline function B in function A.

VS Profile-Guided Optimizations

You can use the automated Profile Guided Optimization for Visual C++ plug-in in the Performance and Diagnostics Hub to simplify and streamline the optimization process within Visual Studio, or you can perform the optimization steps manually in Visual Studio or on the command line. We recommend the plug-in because it is easier to use. For information on how to get the plug-in and use it to optimize your app, see Profile Guided Optimization Plug-In.

View more solutions

Comments

[Samaursa]

That I understand. The compiler is not able to inline some functions no matter what but it will not consider its own analysis when __forceinline is used and the function will be inlined if it can be.

[Samaursa]

That is a good suggestion. It does not work in my particular situation but definitely something to keep in mind (+1).

[Samaursa]

I changed my style to match the suggestions by writers of various books (that I am sure know better than me) by writing functions so that they do what their name suggests and nothing more and to keep the function vertical length small. This resulted in a lot of smaller functions which had a performance impact on my most recent performance sensitive code. After reading Agner Fog's book, I started thinking of the other aspect and am wondering whether I should strike a balance between the two contrasting pieces of advice (selective inline would have been the ideal solution - and macro may be it)

[Harsh Pathak]

@Samaursa: Yes, but the whole point is that you can never assume that the function will be inlined with any variant of the inline keyword (as per your question). At the most, you may be able to increase the chance of it being inlined.

[user541686]

@Jacob: You can't assume it, but you can verify it through enabling all warnings with /Wall and noting which functions weren't inlined.

[bobobobo]

@Jacob Indeed, I doubted it but you are right, "You cannot force the compiler to inline a particular function, even with the __forceinline keyword."

[gj13]

Now you can use __forceinline (msdn.microsoft.com/en-us/bw1hbe6y)

[Géza Török]

In some, mostly embedded, projects, the need of logical separation but "physical" contiguity of code often emerges. Consider interrupt handler routines, for example, where a number of mandatory operations must be performed both in the beginning and in the end. These operations may be implemented perfectly as static inline functions as long as it is guaranteed that the interrupt routine won't be polluted with extra stack pottering and call instructions (i.e the function is really inlined).

[Sachin Joseph]

A ton of info here: docs.microsoft.com/en-us/cpp/cpp/…

[Sachin Joseph]

_forceinline instructs the compiler to do its best to inline a function without performing any cost/benefit analysis. docs.microsoft.com/en-us/cpp/cpp/…

[Kotauskas]

Not appliable in some cases: sometimes, inline is used as an alternative to macros, since they are debuggable, more readable and can be put into a namespace. Sometimes, stack frame allocation can build up into precious microseconds of delay, and compiler might not know the execution frequency without the context (what if you inline a sin() function and the compiler does not inline it for some reason?).

[Epic Speedy]

This is now outdated please see some of the other answers below.