用可变值初始化静态变量有哪些运行时间成本？

Question

In C++, what is the expected runtime cost in a reasonable compiler of initializing a static variable with a variable value as opposed to a constant value?

For example consider this code:

bool foo();
bool baz1() {
  const bool value = foo();
  static bool alternate1 = value;
  static bool alternate2 = false;

  // Do something.
  return alternate1;
}

What is the expected run-time cost difference between alternate1 and alternate2 ?

Answer 1

Initialisation from a compile-time constant (alternate 2) will most likely happen during program startup, with no cost each time the function is called.

Thread-safe initialisation of a local static variable will cause the compiler to generate something like this pseudocode:

static bool alternate1;

static bool __initialised = false;
static __lock_type __lock;
if (!__initialised) {
    acquire(__lock);
    if (!__initialised) {
        alternate1 = value;
        __initialised = true;
    }
    release(__lock);
}

So there is likely to be a test of a flag each time the function is called (perhaps involving a memory barrier or other synchronisation primitive), and a further cost of acquiring and releasing a lock the first time.

Note that in your code, foo() is called every time, whether or not the variable is initialised yet. It would only be called the first time, if you changed the initialisation to

static bool alternate1 = foo();

The details are implementation-dependent of course; this is based on my observations of the code produced by GCC.

Answer 2

static variables are initialized at the start of your program, which means the init will only occur once. The cost for just a boolean is very low, and for your alternate1 will be the cost of executing foo() , which in your example is not much, since it's just an empty function.

To generalize, the cost will be the maximum cost of either initializing your basic type (int, float, etc) or the cost of initializing (running the ctor) of any user defined type/library defined type. Any static that is initialized with a function, then the max will be the cost of the function being executed.

Answer 3

It appears that your question is not about a static variable in general, but rather about a static variable declared inside a function.

The additional run-time costs of initializing such variable from a run-time value stem from several sources

1. Such variable should be initialized only once, when the control passes over its declaration the very first time (if ever). In order to achieve that an additional boolean variable/flag is allocated for each such variable and checked every time the control passes over the declaration. If the flag says that the variable is not initialized yet, it gets initialized.

2. For those static variables has non-trivial destructors, the language has to guarantee that their destruction order at program termination is the reverse of their construction order. Since the construction order determined at run-time, the program has to prepare a run-time structure to schedule the future destructions. This is also done as part of step 1 for variables with non-trivial destructors: they are registered in a "list" of constructed objects in order of their construction. The "list" is typically implemented as a pre-allocated array (since its maximum size is known at compile time).

3. In multithreaded configurations the above steps might/will be accompanied with additional locking/unlocking steps.

Since these are all "household" expenses implemented "under the hood", the actual cost might greatly depend on the implementation. See/profile the code your specific compiler generates.

Answer 4

Setting alternate1 value will mean calling the function, and even if the function is returning a static value, you will have to save the stack, call the function, get its return value, restore the stack and assign the value to a variable.

Literally, in the first case you will be executing at least 8 assembly code lines, and in the second one – only one line.