Reputation: 975
It is often said a function can be inlined only if it is known at the compile time how it will be called, or something to that effect. (pls correct/clarify if I am wrong)
So say if I have a function like this
void Calling()
{
if (m_InputState == State::Fast) //m_inputstate is a class member and is set by user
{
CallFastFunction();
}
else if (m_InputState == State::Slow)
{
CallSlowFunction();
}
}
as m_inputstate is set by end-user, can we say this variable is not known at the compile time hence calling() cant be inlined?
Upvotes: 0
Views: 94
Reputation: 129524
The compiler can (and almost certainly WILL) inline your Calling
function. Depending on the availability of the source of CallFastFunction
and CallSlowFunction
, these may also be inlined.
If the compiler can determine the value of m_InputState
, it will remove the if
- but only if it's definitive that the value is one value.
For example, thing.m_InputState = State::Slow; thing.Calling();
will only compile in the "slow" call, without any conditonal code, where std::cin >> thing.m_InputState; thing.Calling();
will of course not.
If, through profile-based optimisation, the compiler knows how often each of the cases are chosen, it may also select which path ends up "next" in the order of the code, such that the most likely comes first (and it may also provide prefix or other indication to the processor that "you're likely going this way".
But inlining itself happens based on:
Modern compilers also support "link time optimisation", where the object files produced are only "half-done", such that the linker will actually produce the final code, and it can move code around and inline, just the same as the old-fashioned compiler, on the entire code that makes up the executable (all the code using link-time optimisation), allowing code that didn't have the same source file or not in a header file to still be inlined.
Upvotes: 1
Reputation: 27
The fact that m_InputState
is not known does not stop Calling()
from being inlined.
Typically, if you want a function to be inlinable, it has to be declared in the same .cpp file that it is called in (no function prototypes). This depends a bit on the compiler though.
Upvotes: 0
Reputation: 50111
Inlining has nothing to do with the function input being known at compile time.
Upvotes: 3