Re: local static variable (just a curiosity, btw)

From:

"Tom Widmer [VC++ MVP]" <tom_usenet@hotmail.com>

Newsgroups:

microsoft.public.vc.language

Date:

Mon, 30 Apr 2007 11:17:26 +0100

Message-ID:

<e8KnBDxiHHA.1884@TK2MSFTNGP06.phx.gbl>

Alex Blekhman wrote:

"Tom Widmer [VC++ MVP]" wrote:
[...]

Under the hood, that is going to be something like:

//both are statically initialized:
static const bool __x_is_initialized = false;
static const DWORD x = 0;

//dynamic initialization:
if (!__x_is_initialized)
{
__x_is_initialized = true; //1
x = perform::computation(); //2
}

return x;

[...]

but then another proposal came out:

  static const volatile DWORD x = perform::computation();
  while (x == 0) {}
  return x;

Would it work?

On VC2005, volatile has memory barrier semantics, and writes to
volatile DWORDs should be atomic, so I think it will work, yes.

I don't think `volatile' specifier will help here.

It helps by forcing the while loop to re-read the value of x each time.

It is because

`volatile' guards `x' only, while placement of internally generated
`__x_is_initialized' is left to its own devices (i.e., before `x').

__x_is_initialized does not matter - at least one thread will see is as
0, and that thread or threads will do the initialiazation of x. Any
other threads that arrive during that initialization will see the value
of x as 0, and hence spin in the while loop until one of the
initializing threads has set the value of x to non-zero.

With

or without `volatile' MSVC++2005 generates exactly the same code, which
is akin to that you posted.

I'm surprised that, without volatile, the compiler didn't optimize the
reads of x to the bare minimum, and thus generate a potential infinite loop.

Tom