RFR 8136924 Vectorized support for array equals/compare/mismatch using Unsafe
Peter Levart
peter.levart at gmail.com
Wed Nov 25 17:29:59 UTC 2015
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
More information about the core-libs-dev
mailing list