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