[foreign-memaccess] RFR: Simplify MemoryScope implementation to use StampedLock

[Paul Sandoz]

On Wed, 13 May 2020 18:01:17 GMT, Maurizio Cimadamore <mcimadamore at openjdk.org> wrote:

> I've been playing around a bit and discussed this offline with @JornVernee too. A realization I had some time ago is
> that what we're trying to do here is a read/write lock, where multiple acquire can occur at the same time, but where
> close of the root should be exclusive. I think all the machinery around `CLOSING` is essentially due to the code trying
> to mimic that pattern.  This patch simplifies over the status quo, by using a `StampedLock` instead of managing races
> manually through a `CLOSING` state. The tweaked implementation also adds back the atomicity w.r.t. close() vs. dup()
> which was seeked in a previous attempt (see https://git.openjdk.java.net/panama-foreign/pull/160). Also, since now
> there some guarantee that no acquire can take place while a close is also taking place (and pending acquires will be
> invalidated - using the optimistic read logic), then we can just use a single long adder instead of two.  The state is
> also simplified, since we just need a boolean flag.  I ran the `ParallelSum` benchmark and could not spot any obvious
> regression compared to the previous code.

Very nice!

src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/MemoryScope.java line 154:

> 153:                         continue;
> 154:                     checkAliveConfined(); // plain read is enough here (either successful optimistic read, or ful
> read lock) 155:

s/ful/full

src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/MemoryScope.java line 158:

> 157:                     acquired.increment();
> 158:                     // did a call to close() occurred since we acquired the lock?
> 159:                     if (lock.validate(stamp)) {

s/occurred/occur

-------------

Marked as reviewed by psandoz (Committer).

PR: https://git.openjdk.java.net/panama-foreign/pull/163