C++ 编译器是否优化顺序 static 变量读取？

Question

Do C++ compilers optimize sequential readings of the same static variable in a function scope, when this variable is accessed through a const ref? So CPU will read its value from its address in the static data just once and then will store the value in CPU cached memory and reuse it assuming that the value is immutable? In other words: are static variable implicitly declared as volatile , like there are other threads and the value may be magically changed?

Because if CPU won't cache the value, sequential readings from the static variable address may hurt performance. Is it better in this case to manually copy the value in a variable on stack so it will be in CPU cache?

class Singleton
{
    // some code

    Data data;

public:
    static Singleton& instance()
    { 
        static Singleton inst;
        return inst; 
    }
}

int func(const Data& param);

int foo(int N)
{
    int result = 0;
    for (int i = 0; i < N; ++i)
    {
        // will compiler move the reading outside of the loop and the value will be cached by CPU?
        const auto& data = Singleton::instance().data; 

        result += func(data);
    }
    return result;
}

Answer 1

If the compiler is able to prove beyond doubt the value will not change between different accesses, then according to the as-if rule it may consolidate multiple reads into one.

But proving it is often hard to do with a variable with a static storage duration, because there could be code in other translation units ( func() in your example) that modifies it. So without seeing what func() does, the compiler is forced to re-load data in each iteration. Similarly, when func() itself is compiled, its argument needs to be re-loaded every time.

Then there could also be other threads that modify data . According to the C++ memory model rules, those changes do not have to become visible until a sync event, which can be a memory fence, a mutex or an atomic acquire/release, etc.

So yes, reducing the scope of a variable may often result in improved performance. It's much easier to prove that a local variable can't be modified from "outside" than a global variable.

In the end, the best way to achieve good performance is by giving the compiler as complete a picture about the code being compiled as possible. In the provided example, func() can be added to the same translation unit. Then, if if it doesn't make other "unknown" calls and can be inlined, static analysis optimizer passes will eliminate all unnecessary duplicate reads. For large applications, LTO (Link Time Optimization) is another way to improve performance, as it broadens the view for the optimizer.

Answer 2

C++ says objects are only volatile if you mark them as such. Nothing is magically marked volatile for you. You can usually assume the compiler will do whatever's fastest while still meeting the requirements of the C++ specification. So it almost certainly caches the accesses, whenever that helps.