shared vs __gshared

[Sergei Nosov]

Hi!

I'm puzzled with what's the difference between shared and 
__gshared. Until now I've (mistakenly) considered that shared 
variables are free from low-level data races. I.e. the operations 
with shared data are atomic. And that __gshared is the "usual" 
(in C++ sense) shared data.

So, in my understanding, it was that if I do

shared int s = 0;
void inc()
{
     s++;
}
void main()
{
     foreach (i; iota(100_000).parallel)
         s++;
}

I will always get s == 100_000 by the end of foreach loop. And if 
I use __gshared specifier, I will get the undefined value less or 
equal 100_000.

But now I've run the test and I get the "undefined value" result 
for both shared and __gshared.

I've looked this up in TDPL, and careful reading got me that 
shared guarantees only that the result of a write is instantly 
visible to all threads. So according to this, I can load the 
value in register, change it there, wait until someone else 
rewrites the value, and put my version on top, discarding someone 
else's result.

Is this how shared is supposed to work? If so, how is the 
__gshared different from it? Does it not guarantee that the 
result of a write is instantly visible to all threads? If so, 
does this difference really matter?