Bill (et al.) -- I read through JMMA and JMMB and frankly find them both
pretty opaque. I don't really develop any intuition at all from them.
Here is a wonderment: In the database community, within which I used to be
active lo so many years ago, we have notions such as serializability
(equivalence of a possibly interleaved execution of a set of transactions
to a serial execution of the transactions in some order). Is there any hope
of a similar definition and understanding for Java? For example, all
(sets of) actions protected by the same mutex must be serialized, just as
in standard database transaction models.
Also, within a thread (and I guess across threads when data propagates
through shared heap variables), I comprehend ideas like slices and
dependences just fine.
The model as presented appears to me to put "too many" edges into the
happens-before ordering, and then to justify allowing some of them to
"really happen" (causality) in a different order. It feels more intuitive
to me to define a happens-before with fewer edges, but that is always
causal. I suspect there's some deep reason why it can't be done this way,
or perhaps it would have been. (Does it have to do with the range of
compiler optimizations, perhaps?) What I am looking for would say which
shared heap writes depend (via intermediate computation private to a
thread) on which shared heap reads, and build up an ordering that
Within a thread, presumably only dependences, mutex accesses, and volatile
accesses inherently order actions on different variables; program order
determines the order of actions on the same variable.
Well, I could be entirely missing the point (but I remain concerned about
the eventual model being understandable and useable, by all three of users,
JVM builders, and hardware architects).
Best wishes -- Eliot
JavaMemoryModel mailing list - http://www.cs.umd.edu/~pugh/java/memoryModel
This archive was generated by hypermail 2b29 : Thu Oct 13 2005 - 07:00:46 EDT