On Sun, 2007-10-28 at 18:29 +0100, Richard Guenther wrote:
> On 10/28/07, Erik Trulsson <[EMAIL PROTECTED]> wrote:
> > Unfortunately it seems that the POSIX standard for threads say that as long
> > as access to a shared variable is protected by a mutex there is no need to
> > use 'volatile'.
>
> Which is a very unpracticable say, as it essentially would force the compiler
> to assume every variable is protected by a mutex (how should it prove
> otherwise?)
So the proof is easy: mutex ops are function calls,
assume all function calls lock or unlock.
Thus: store registers aliasing sharable variables into
those variables on every function call.
int x = 1;
x = x + 1; // r0 <- x; r0++
x = x + 1; // r0++;
f(); // x <- r0; f();
Note: this is not well stated. There is no explicit coupling
between a given variable and a mutex.
If thread A locks Mutex MA, and B locks MB, there is no synchronisation
between these threads and sharing can fail: it has to be the same
mutex (to effect 'mutual exclusion').
When two threads are exclusive, it is safe to keep variables
in registers again (because the other thread is locked up).
OK .. hmm .. well this is the idea, but a more formal proof
would be cool.
--
John Skaller <skaller at users dot sf dot net>
Felix, successor to C++: http://felix.sf.net
