Re: volatile and sequence points in (GASP) multithreaded programs
On Jul 2, 11:03 am, Dave Rahardja
<drahardja_atsign_pobox_dot_...@pobox.com> wrote:
However, I'm confused about the relationship between observable behavior =
and
sequence points (=A71.9-7). What does it mean that all side effects befor=
e a
sequence point is completed before the next evaluation is performed?
How is that unclear? (the meaning of "side effects" is
precisely defined by the standard).
Does it mean that inserting a function call such as:
void foo(); // Defined in another compilation unit
bool flag;
while (!flag)
{
foo();
}
Forces the compiler to re-read flag at the head of each loop iteration?
I guess you mean, does it prevent the compiler from
optimising away the read of 'flag'. Supposing that
the compiler doesn't do optimization involving the
definition of foo() then the answer is 'yes'. foo()
might contain code such as:
extern bool flag;
flag = 1;
If flag were static then the loop condition check
could again be optimised away.
My thought is that the compiler is /technically/ still allowed to elide t=
he
access to flag, because its behavior is still not observable.
'flag' doesn't have behaviour. I guess you mean
that changes of the value of 'flag' do not
constitute "observable behaviour", which is correct.
The compiler can generate whatever code it likes,
as long as the observable behaviour produced
matches what is specified by the C standard.
"observable behaviour" is strictly defined by
a section of the standard.
Even after synchronizing access to member variables
(another off-topic operation), I'm still not sure if
my reads and writes to member variables are liable
to get optimized away.
Well, if you have code such as:
LockFoo();
foo = 4;
UnlockFoo();
even if foo is volatile, the compiler can re-order so
that the modification is outside the locks, if it knows
that the locks don't access foo.
Which is why if you want to do multithreaded
programming you need to have support from the
compiler vendor, which may provide synchronization
primitives and more importantly, documentation about
how to do such programming. You should probably post
followup questions on the newsgroup of the compiler
or thread package that you are using.