Hi,
I did a simple test to get a global variable from a struct pointer and from the global namespace directly.
The two cases result to an inlined get in release when you look at the assembly view from MSVC 2013.
I did the test for an executable build, is it always the case for executable, static and shared lib ?
To be clear, the variable is not declared in the header, only in the .cpp.
Thanks
Lot of cases here, to be clear the case studied here is : variables in the .cpp (or all variables in one struct and a pointer of this struct in the .cpp) and accessor in header.
The goal of this operation is to hide the global variable and force to use Init, Shutdown and multiple Get.
Anonymous namespaces place things the global scope but restrict them to the translation unit.
namespace {
int globalVar;
}You can use them in .cpp files for a "private" global, similar to static globals in C. Is this what you mean?
Global.h :
#pragma once
namespace Global
{
inline int GetGlobalInt();
} // GlobalGlobal.cpp :
namespace
{
int IntValue = 150;
}
namespace Global
{
int GetGlobalInt()
{
return IntValue;
}
}It's an example but the real use case is more to use a struct containing multiple variables and have a pointer with Init and Shutdown to call new and delete.
As mentioned, because it is in the cpp file it will only be inlined if the compiler has pulled in the cpp file. Some compilers and compiler options will span multiple cpp files, others will only consider the included header files.
For best results, mark the function as inline and put it in a header file.
Only focus on this kind of micro-optimization if you have profiled your code and proven that forcing a function to be inlined actually improves performance.
In my case, these functions are used to get the render system, logger, managers, factory .... so, it's important.
In my case, these functions are used to get the render system, logger, managers, factory .... so, it's important."important" is not a substitute for "profiling your code to check it makes any difference".
I don't know what your render system does, but my $random guess is that it walks over the world, collects things to draw, sends stuff to the GPU, and perhaps does a few calculations on the way. Even if you do a fraction of that, it is a whole lot more than a few instructions to get an address. Also, the render system is likely called less than 100 times / second, which is eons between the calls in CPU time.
In general - do not worry about inlining. With the proper compiler optimization settings the compiler will do it anyway where appropriate, and avoid it where appropriate.
Sounds like "inline" has gone the way of register variables. Present, but completely ignorable by the compiler.
