Re: InterlockedRead [was My -short- lock-free sequencer class]
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
--
C++ FAQ: http://parashift.com/c++-faq-lite
Sator Laser GmbH
Gesch??ftsf??hrer: Thorsten F??cking, Amtsgericht Hamburg HR B62 932