[GR-57334] Update JavaMonitor to jdk-24+11.

PullRequest: graal/18630

Author: christianhaeubl

substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/monitor/JavaMonitor.java

@@ -46,7 +46,7 @@
 
 /**
  * {@link JavaMonitor} is based on the code of {@link java.util.concurrent.locks.ReentrantLock} as
- * of JDK 21+26.
+ * of JDK 24+11.
  *
  * Only the relevant methods from the JDK sources have been kept. Some additional Native
  * Image-specific functionality has been added.

substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/monitor/JavaMonitorQueuedSynchronizer.java

@@ -41,7 +41,7 @@
 
 /**
  * {@link JavaMonitorQueuedSynchronizer} is based on the code of
- * {@link java.util.concurrent.locks.AbstractQueuedLongSynchronizer} as of JDK 21+26. This class
+ * {@link java.util.concurrent.locks.AbstractQueuedLongSynchronizer} as of JDK 24+11. This class
  * could be merged with {@link JavaMonitor} but we keep it separate because that way diffing against
  * the JDK sources is easier.
  *
@@ -60,7 +60,7 @@
  */
 @BasedOnJDKClass(AbstractQueuedLongSynchronizer.class)
 abstract class JavaMonitorQueuedSynchronizer {
-    // Node.status field values
+    // Node status bits, also used as argument and return values
     static final int WAITING = 1; // must be 1
     static final int CANCELLED = 0x80000000; // must be negative
     static final int COND = 2; // in a condition wait
@@ -71,38 +71,38 @@ abstract class JavaMonitorQueuedSynchronizer {
     // see AbstractQueuedLongSynchronizer.Node
     @BasedOnJDKClass(value = AbstractQueuedLongSynchronizer.class, innerClass = "Node")
     abstract static class Node {
-        volatile Node prev;
-        volatile Node next;
-        Thread waiter;
-        volatile int status;
+        volatile Node prev; // initially attached via casTail
+        volatile Node next; // visibly nonnull when signallable
+        Thread waiter; // visibly nonnull when enqueued
+        volatile int status; // written by owner, atomic bit ops by others
 
         // see AbstractQueuedLongSynchronizer.Node.casPrev(Node, Node)
-        final boolean casPrev(Node c, Node v) {
+        final boolean casPrev(Node c, Node v) { // for cleanQueue
             return U.weakCompareAndSetReference(this, PREV, c, v);
         }
 
         // see AbstractQueuedLongSynchronizer.Node.casNext(Node, Node)
-        final boolean casNext(Node c, Node v) {
+        final boolean casNext(Node c, Node v) { // for cleanQueue
             return U.weakCompareAndSetReference(this, NEXT, c, v);
         }
 
         // see AbstractQueuedLongSynchronizer.Node.getAndUnsetStatus(int)
-        final int getAndUnsetStatus(int v) {
+        final int getAndUnsetStatus(int v) { // for signalling
             return U.getAndBitwiseAndInt(this, STATUS, ~v);
         }
 
         // see AbstractQueuedLongSynchronizer.Node.setPrevRelaxed(Node)
-        final void setPrevRelaxed(Node p) {
+        final void setPrevRelaxed(Node p) { // for off-queue assignment
             U.putReference(this, PREV, p);
         }
 
         // see AbstractQueuedLongSynchronizer.Node.setStatusRelaxed(int)
-        final void setStatusRelaxed(int s) {
+        final void setStatusRelaxed(int s) { // for off-queue assignment
             U.putInt(this, STATUS, s);
         }
 
         // see AbstractQueuedLongSynchronizer.Node.clearStatus()
-        final void clearStatus() {
+        final void clearStatus() { // for reducing unneeded signals
             U.putIntOpaque(this, STATUS, 0);
         }
 
@@ -119,7 +119,7 @@ static final class ExclusiveNode extends Node {
     // see AbstractQueuedLongSynchronizer.ConditionNode
     @BasedOnJDKClass(value = AbstractQueuedLongSynchronizer.class, innerClass = "ConditionNode")
     static final class ConditionNode extends Node {
-        ConditionNode nextWaiter;
+        ConditionNode nextWaiter; // link to next waiting node
         long notifierJfrTid;
 
         // see AbstractQueuedLongSynchronizer.ConditionNode.isReleasable()
@@ -153,16 +153,17 @@ protected final long getState() {
 
     // see AbstractQueuedLongSynchronizer.setState(long)
     protected final void setState(long newState) {
-        this.state = newState;
+        state = newState;
     }
 
     /**
-     * For {@linkplain JavaMonitorConditionObject#await conditional waiting}, returns the number of
-     * acquisitions, which is subsequently passed to {@link #tryRelease} to entirely release
-     * ownership, and later to {@link #tryAcquire} to regain ownership after waiting.
+     * Used for {@linkplain JavaMonitorConditionObject#await conditional waiting}. Returns the
+     * number of acquisitions, which is subsequently passed to {@link #tryRelease} to entirely
+     * release ownership, and later to {@link #tryAcquire} to regain ownership after waiting.
      *
-     * While {@code AbstractQueuedLongSynchronizer} calls {@link #getState()} assuming that it
-     * encodes the acquisition count, this method allows for more flexibility in implementations.
+     * Note that {@code AbstractQueuedLongSynchronizer} calls {@link #getState()} instead, assuming
+     * that the state encodes the acquisition count. This method allows for more flexibility in
+     * implementations.
      */
     protected abstract long getAcquisitions();
 
@@ -205,13 +206,13 @@ final void enqueue(ConditionNode node) {
             boolean unpark = false;
             for (Node t;;) {
                 if ((t = tail) == null && (t = tryInitializeHead()) == null) {
-                    unpark = true;             // wake up to spin on OOME
+                    unpark = true; // wake up to spin on OOME
                     break;
                 }
-                node.setPrevRelaxed(t);        // avoid unnecessary fence
+                node.setPrevRelaxed(t); // avoid unnecessary fence
                 if (casTail(t, node)) {
                     t.next = node;
-                    if (t.status < 0) {        // wake up to clean link
+                    if (t.status < 0) { // wake up to clean link
                         unpark = true;
                     }
                     break;
@@ -279,14 +280,15 @@ protected int getSpinAttempts(int parks) {
         return (1 << parks) - 1;
     }
 
-    // see AbstractQueuedLongSynchronizer.acquire(Node, long, boolean, boolean, boolean, long)
+    // see AbstractQueuedLongSynchronizer.acquire(Node, long, false, false, false, 0L)
     @SuppressWarnings("all")
     final int acquire(Node node, long arg) {
         Thread current = Thread.currentThread();
+        /* Spinning logic is SVM-specific. */
         int parks = 0;
         int spins = getSpinAttempts(parks);
         boolean first = false;
-        Node pred = null;
+        Node pred = null; // predecessor of node when enqueued
 
         for (;;) {
             if (!first && (pred = (node == null) ? null : node.prev) != null && !(first = (head == pred))) {
@@ -302,6 +304,7 @@ final int acquire(Node node, long arg) {
                 boolean acquired;
                 try {
                     if (spins > 0) {
+                        /* Spinning logic is SVM-specific. */
                         spins = trySpinAcquire(spins, arg);
                         acquired = (spins == SPIN_SUCCESS);
                         assert !acquired || isHeldExclusively();
@@ -323,11 +326,11 @@ final int acquire(Node node, long arg) {
                 }
             }
             Node t;
-            if ((t = tail) == null) {           // initialize queue
+            if ((t = tail) == null) { // initialize queue
                 if (tryInitializeHead() == null) {
                     return acquireOnOOME(arg);
                 }
-            } else if (node == null) {          // allocate; retry before enqueue
+            } else if (node == null) { // allocate; retry before enqueue
                 try {
                     node = new ExclusiveNode();
                 } catch (OutOfMemoryError oome) {
@@ -346,22 +349,28 @@ final int acquire(Node node, long arg) {
             } else if (node.status == 0) {
                 node.status = WAITING; // enable signal and recheck
             } else {
+                /* Spinning logic is SVM-specific. */
                 parks++;
                 spins = getSpinAttempts(parks);
-                LockSupport.park(this);
+                try {
+                    LockSupport.park(this);
+                } catch (Error | RuntimeException ex) {
+                    cancelAcquire(node); // cancel & rethrow
+                    throw ex;
+                }
                 node.clearStatus();
             }
         }
     }
 
-    // see AbstractQueuedLongSynchronizer.acquireOnOOME(boolean, long)
+    // see AbstractQueuedLongSynchronizer.acquireOnOOME(false, long)
     private int acquireOnOOME(long arg) {
         for (long nanos = 1L;;) {
             if (tryAcquire(arg)) {
                 return 1;
             }
-            U.park(false, nanos);               // must use Unsafe park to sleep
-            if (nanos < 1L << 30) {             // max about 1 second
+            U.park(false, nanos); // must use Unsafe park to sleep
+            if (nanos < 1L << 30) { // max about 1 second
                 nanos <<= 1;
             }
         }
@@ -401,7 +410,7 @@ private void cleanQueue() {
         }
     }
 
-    // see AbstractQueuedLongSynchronizer.cancelAcquire(Node, boolean, boolean)
+    // see AbstractQueuedLongSynchronizer.cancelAcquire(Node, false, false)
     private int cancelAcquire(Node node) {
         if (node != null) {
             node.waiter = null;
@@ -446,23 +455,29 @@ public final class JavaMonitorConditionObject {
 
         static final long OOME_COND_WAIT_DELAY = 10L * 1000L * 1000L; // 10 ms
 
+        JavaMonitorConditionObject() {
+        }
+
         // see AbstractQueuedLongSynchronizer.ConditionObject.doSignal(ConditionNode, boolean)
         @SuppressWarnings("all")
         private void doSignal(ConditionNode first, boolean all) {
             while (first != null) {
                 ConditionNode next = first.nextWaiter;
+
                 if ((firstWaiter = next) == null) {
                     lastWaiter = null;
                 } else {
                     first.nextWaiter = null; // GC assistance
                 }
                 if ((first.getAndUnsetStatus(COND) & COND) != 0) {
+                    /* JFR-related code is SVM-specific. */
                     first.notifierJfrTid = SubstrateJVM.getCurrentThreadId();
                     enqueue(first);
                     if (!all) {
                         break;
                     }
                 }
+
                 first = next;
             }
         }
@@ -562,6 +577,7 @@ private ConditionNode newConditionNode() {
         // see AbstractQueuedLongSynchronizer.ConditionObject.await()
         @SuppressWarnings("all")
         public void await(Object obj) throws InterruptedException {
+            /* JFR-related code is SVM-specific. */
             long startTicks = JfrTicks.elapsedTicks();
             if (Thread.interrupted()) {
                 JavaMonitorWaitEvent.emit(startTicks, obj, 0, 0L, false);
@@ -601,6 +617,7 @@ public void await(Object obj) throws InterruptedException {
         // see AbstractQueuedLongSynchronizer.ConditionObject.await(long, TimeUnit)
         @SuppressWarnings("all")
         public boolean await(Object obj, long time, TimeUnit unit) throws InterruptedException {
+            /* JFR-related code is SVM-specific. */
             long startTicks = JfrTicks.elapsedTicks();
             long nanosTimeout = unit.toNanos(time);
             if (Thread.interrupted()) {
@@ -643,7 +660,7 @@ public boolean await(Object obj, long time, TimeUnit unit) throws InterruptedExc
 
     // Unsafe
     private static final Unsafe U = Unsafe.getUnsafe();
-    static final long STATE = U.objectFieldOffset(JavaMonitorQueuedSynchronizer.class, "state");
+    private static final long STATE = U.objectFieldOffset(JavaMonitorQueuedSynchronizer.class, "state");
     private static final long HEAD = U.objectFieldOffset(JavaMonitorQueuedSynchronizer.class, "head");
     private static final long TAIL = U.objectFieldOffset(JavaMonitorQueuedSynchronizer.class, "tail");
 }