MSDN volatile sample

[George2]

Hello everyone,
In the MSDN volatile sample,

http://msdn2.microsoft.com/en-us/lib...fd(VS.80).aspx

I do not understand what is the purpose of the sample. I have tried to
remove the keyword volatile, and the result is the same. :-)

Any ideas?
thanks in advance,
George

[Dave Rahardja]

On 2007-12-28 02:53:28 -0600, George2 <ge*************@yahoo.comsaid:

http://msdn2.microsoft.com/en-us/lib...fd(VS.80).aspx

Compile it with optimizations on (i.e. Release build).

-dr

[steve.pagliarulo]

On Dec 28, 12:53*am, George2 <[e-mail]:

Hello everyone,

In the MSDN volatile sample,

http://msdn2.microsoft.com/en-us/lib...fd(VS.80).aspx

I do not understand what is the purpose of the sample. I have tried to
remove the keyword volatile, and the result is the same. :-)

Any ideas?

thanks in advance,
George

I would not rely on volatile for anything related to threads. Think of
it as more of a hint to the compiler when it's considering the
variable's scope (especially when optimizing).

[Dave Rahardja]

On 2007-12-28 18:56:26 -0600, st**************@gmail.com said:

On Dec 28, 12:53*am, George2 <[e-mail]:

>Hello everyone,

In the MSDN volatile sample,

http://msdn2.microsoft.com/en-us/lib...fd(VS.80).aspx

I do not understand what is the purpose of the sample. I have tried to
remove the keyword volatile, and the result is the same. :-)

Any ideas?

thanks in advance,
George

I would not rely on volatile for anything related to threads. Think of
it as more of a hint to the compiler when it's considering the
variable's scope (especially when optimizing).

I don't understand what you mean. volatile has nothing to do with scope
and everything to do with optimization.

Beyond its sequence-point properties, the behavior of volatile
variables is completely implementation-defined, which means that the
effect of the volatile qualifier is not portable in any meaningful,
externally-observable way.

Thus, I wouldn't use it for anything portable, period.

-dr

[spaglia]

On Dec 28, 8:34*pm, Dave Rahardja
<[e-mail]:

On 2007-12-28 18:56:26 -0600, [e-mail] said:

On Dec 28, 12:53*am, George2 <[e-mail]:

Hello everyone,

In the MSDN volatile sample,

>http://msdn2.microsoft.com/en-us/lib...fd(VS.80).aspx

I do not understand what is the purpose of the sample. I have tried to
remove the keyword volatile, and the result is the same. :-)

Any ideas?

thanks in advance,
George

I would not rely on volatile for anything related to threads. Think of
it as more of a hint to the compiler when it's considering the
variable's scope (especially when optimizing).

I don't understand what you mean. volatile has nothing to do with scope
and everything to do with optimization.

Beyond its sequence-point properties, the behavior of volatile
variables is completely implementation-defined, which means that the
effect of the volatile qualifier is not portable in any meaningful,
externally-observable way.

Thus, I wouldn't use it for anything portable, period.

-dr- Hide quoted text -

- Show quoted text -

I believe we are in agreement. My use of scope was targeted to the
optimizer and not the language proper.
-Steve

[Chris Thomasson]

[included comp.programming.threads]

"George2" <ge*************@yahoo.comwrote in message
news:dd**********************************@t1g2000p ra.googlegroups.com...

Hello everyone,
In the MSDN volatile sample,

http://msdn2.microsoft.com/en-us/lib...fd(VS.80).aspx

I do not understand what is the purpose of the sample. I have tried to
remove the keyword volatile, and the result is the same. :-)

Any ideas?

It means that MS compilers for PowerPC (e.g., XBOX), and Itanium (e.g.,
Itanic) based platforms do indeed assign significantly __overbearing!__
memory-barrier functionality to their most "basic" meaning of the volatile
keyword itself; by default! ;^(... Volatile is implementation defined
INDEED!

Basically, they assign heavy acquire-load membar semantics to EVERY _naked_
load, and release-store semantics to EVERY _naked_ store; this could be due
to their relationship with Intel I suppose. Keep in mind that Java does this
as well for programming "simplicity"; IMVHO, all of that crap is MAJOR
overkill and generates unneeded overheads on the memory coherency system in
general. Dumbs down things to a level that makes things ridiculous.

They certainly do NOT have any real need to define volatile such that it has
anything to do with shared-memory threading. IMO, using volatile and
threading in then same sentence is certainly misleading to say the least,
and usually winds up getting people to make erroneous assumptions about
C/C++ compilers...

;^(...

[Michal Nazarewicz]

George2 <ge*************@yahoo.comwrites:

In the MSDN volatile sample,

http://msdn2.microsoft.com/en-us/lib...fd(VS.80).aspx

I do not understand what is the purpose of the sample. I have tried to
remove the keyword volatile, and the result is the same. :-)

Any ideas?

volatile means that given variable may change at any time and compiler
have no way of knowing that it may happen (no, it's not the definition
of volatile keyword but it helps understand it). Assume that compiler
knows that Sleep() function will never modify Sentinel -- in this case
a loop

while (Sentinel)
Sleep(0);

might be replaced with

if (Sentinel)
while (1)
Sleep(0);

if there would be no volatile keyword. That's because without volatile
keyword compiler could came to a conclusion that value of Sentinel does
not change in body of the loop so if the condition was true at the
beginning it will be true all the time.

With volatile keyword compiler must check Sentinel's value since it no
longer knows that it's value was not changed (that's basically meaning
of that keyword).

--
Best regards, _ _
.o. | Liege of Serenly Enlightened Majesty of o' \,=./ `o
..o | Computer Science, Michal "mina86" Nazarewicz (o o)
ooo +--<mina86*tlen.pl>--<jid:mina86*jabber.org>--ooO--(_)--Ooo--

[Chris Thomasson]

"James Kanze" <ja*********@gmail.comwrote in message
news:4d**********************************@e23g2000 prf.googlegroups.com...
[...]

Interesting. The problem is that unless I've misunderstood
something about the x86 architecture, this description doesn't
correspond to the code generated by VC++ 8.

This might be useful:

http://developer.intel.com/products/...als/318147.pdf

?

[...]