Re: InterlockedRead [was My -short- lock-free sequencer class]
This is useful, thanks!
By the way, now VC++ 2008 docum has exact definition how volatile behaves:
<quote>
A write to a volatile object (volatile write) has Release semantics;
a reference to a global or static object that occurs before a write to a
volatile object in the instruction sequence will occur before that
volatile write ...
A read of a volatile object ... has Acquire semantics; a reference to
a global or static object that occurs after a read of volatile memory in
the instruction sequence will occur after that volatile read ....
This allows volatile objects to be used for memory locks and releases in
multithreaded applications.
Note: Although the processor will not reorder un-cacheable memory
accesses, un-cacheable variables must be volatile to guarantee that the
compiler will not change memory order. </quote>
--pa
Ulrich Eckhardt wrote:
Pavel A. wrote:
And about volatile...
Right now I'm at the Boehm's c++ threads talk -
http://www.hpl.hp.com/personal/Hans_Boehm/misc_slides/c++threads.pdf
where he said (slide #20): "The C++ volatile qualifier continues to have
nothing to do with threads".
True. I haven't looked at the slides, but I guess he's talking about the
semantics guaranteed by the standard. There are in fact two aspects to
that:
1. behaviour of a volatile object
2. volatile as cv-qualifier
The first one simply says that volatile objects can be modified by other
things than the program itself. The standards are completely silent about
what that might be and what exactly that might be, leaving the exact
definition to the implementer. As far as MSC is concerned, reads to
volatile LONG variables are atomic, but that's guaranteed by MSC and no the
C or C++ standards.
The second one is a C++ specific thing and it just means that 'volatile' is
a qualifier like 'const' (cv=const/volatile). That means that just as you
can overload a function for const an non-const references, you can also
overload it for volatile.
struct foo {
void bar();
};
foo volatile& vf = ...;
foo const& cf = ...;
vf.bar(); // error
cf.bar(); // error
const_cast<foo&>(vf).bar(); // works
const_cast<foo&>(cf).bar(); // works
Uli