On 11/25/2015 12:46 PM, Paul Sandoz wrote:
We are in Unsafe territory:-)
Since the Java mismatch method and the intrinsic only make temporary reads,
IIUC such updates by GC to the array can only occur at a safe points, and i
don’t think int loops produce a safe point check within the hot loop and nor
does the intrinsic, is this really an issue?
IIUC, in interpreter, safepoint can happen between any two bytecodes:
"Safepoints are initiated using a cooperative, polling-based mechanism.
In simple terms, every so often a thread asks “should I block for a
safepoint?”. Asking this question efficiently is not so simple. One
place where the question is often asked is during a thread state
transition. Not all state transitions do this, for example a thread
leaving the VM to go to native code, but many do. The other places where
a thread asks are in compiled code when returning from a method or at
certain stages during loop iteration. *Threads executing interpreted
code don't usually ask the question, instead when the safepoint is
requested the interpreter switches to a different dispatch table that
includes the code to ask the question; when the safepoint is over, the
dispatch table is switched back again*. Once a safepoint has been
requested, the VMThread must wait until all threads are known to be in a
safepoint-safe state before proceeding to execute the VM operation.
During a safepoint the Threads_lock is used to block any threads that
were running, with the VMThread finally releasing the Threads_lock after
the VM operation has been performed."
You could treat a "false positive" mismatch like you do with NaN floats
and doubles (fall-back to normal code), but what about "false negatives"?
Suppose that you take a snapshot of address of object A from the 1st
array, followed by safepoint which moves object A to somewhere else and
moves object B to the same address A has occupied before (compacting
collector). After safepoint returns, you take the snapshot of address of
object B from the corresponding slot of the 2nd array. Now you compare
the addresses and they are the same, but they represent(ed) pointers to
distinct objects.
Regards, Peter
