[GR-34100] Synchronization improvements.

PullRequest: graal/13301

Author: peter-hofer

substratevm/src/com.oracle.svm.core.posix/src/com/oracle/svm/core/posix/thread/PosixPlatformThreads.java

@@ -413,7 +413,11 @@ protected void unpark() {
         try {
             int s;
             boolean p;
-            PosixUtils.checkStatusIs0(Pthread.pthread_mutex_lock(mutex), "PosixParkEvent.unpark(): mutex lock");
+            int status = Pthread.pthread_mutex_trylock_no_transition(mutex);
+            if (status == Errno.EBUSY()) { // more expensive transition when potentially blocking:
+                status = Pthread.pthread_mutex_lock(mutex);
+            }
+            PosixUtils.checkStatusIs0(status, "PosixParkEvent.unpark(): mutex lock");
             try {
                 s = event;
                 event = 1;

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

@@ -26,6 +26,10 @@
 
 package com.oracle.svm.core.monitor;
 
+import static org.graalvm.compiler.nodes.extended.BranchProbabilityNode.FREQUENT_PROBABILITY;
+import static org.graalvm.compiler.nodes.extended.BranchProbabilityNode.NOT_FREQUENT_PROBABILITY;
+import static org.graalvm.compiler.nodes.extended.BranchProbabilityNode.probability;
+
 import org.graalvm.nativeimage.CurrentIsolate;
 import org.graalvm.nativeimage.IsolateThread;
 
@@ -145,16 +149,20 @@ protected long getAcquisitions() {
     @Override
     protected boolean tryAcquire(long acquires) {
         assert acquires > 0 && acquires == (int) acquires;
-        if (getState() == 0 && compareAndSetState(0, getCurrentThreadIdentity())) {
-            assert acquisitions == 1;
-            acquisitions = (int) acquires;
-            return true;
+        // Do not expect to acquire the lock because this method is typically called after having
+        // already failed to do so, except after conditional waiting.
+        if (probability(NOT_FREQUENT_PROBABILITY, getState() == 0)) {
+            if (probability(FREQUENT_PROBABILITY, compareAndSetState(0, getCurrentThreadIdentity()))) {
+                assert acquisitions == 1;
+                acquisitions = (int) acquires;
+                return true;
+            }
         }
         return false;
     }
 
     // see ReentrantLock.Sync.tryLock()
-    boolean tryLock() {
+    protected boolean tryLock() {
         long current = getCurrentThreadIdentity();
         long c = getState();
         if (c == 0) {

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

@@ -60,10 +60,14 @@
  * </ul>
  */
 abstract class JavaMonitorQueuedSynchronizer {
+    // Node.status field 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
 
+    /** Return value of {@link #trySpinAcquire} if successfully acquired. */
+    protected static final int SPIN_SUCCESS = -1;
+
     // see AbstractQueuedLongSynchronizer.Node
     abstract static class Node {
         volatile Node prev;
@@ -229,12 +233,36 @@ protected void signalReleaseSuccessor() {
         signalNext(head);
     }
 
+    /**
+     * Attempt to acquire as part of spinning, returning {@link #SPIN_SUCCESS} if successful, else
+     * the number of remaining attempts.
+     */
+    protected int trySpinAcquire(int spins, long arg) {
+        assert spins > 0;
+        if (tryAcquire(arg)) {
+            return SPIN_SUCCESS;
+        }
+        return spins - 1;
+    }
+
+    /**
+     * Given the number of previous park operations, returns the number of attempts for
+     * {@link #trySpinAcquire}, provided that the thread is eligible to acquire the lock (not queued
+     * yet or first in the queue).
+     */
+    protected int getSpinAttempts(int parks) {
+        if (parks < 0 || parks > 8) {
+            return 0xff;
+        }
+        return (1 << parks) - 1;
+    }
+
     // see AbstractQueuedLongSynchronizer.acquire(Node, long, boolean, boolean, boolean, long)
     @SuppressWarnings("all")
     final int acquire(Node node, long arg) {
         Thread current = Thread.currentThread();
-        byte spins = 0;
-        byte postSpins = 0;
+        int parks = 0;
+        int spins = getSpinAttempts(parks);
         boolean first = false;
         Node pred = null;
 
@@ -251,7 +279,13 @@ final int acquire(Node node, long arg) {
             if (first || pred == null) {
                 boolean acquired;
                 try {
-                    acquired = tryAcquire(arg);
+                    if (spins > 0) {
+                        spins = trySpinAcquire(spins, arg);
+                        acquired = (spins == SPIN_SUCCESS);
+                        assert !acquired || isHeldExclusively();
+                    } else {
+                        acquired = tryAcquire(arg);
+                    }
                 } catch (Throwable ex) {
                     cancelAcquire(node);
                     throw ex;
@@ -279,13 +313,13 @@ final int acquire(Node node, long arg) {
                 } else {
                     t.next = node;
                 }
-            } else if (first && spins != 0) {
-                --spins; // reduce unfairness on rewaits
+            } else if (first && spins > 0) {
                 Thread.onSpinWait();
             } else if (node.status == 0) {
                 node.status = WAITING; // enable signal and recheck
             } else {
-                spins = postSpins = (byte) ((postSpins << 1) | 1);
+                parks++;
+                spins = getSpinAttempts(parks);
                 LockSupport.park(this);
                 node.clearStatus();
             }