[GR-44081] Use Blocker in Object.wait if pinned.

Author: peter-hofer

substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/jdk/JavaLangSubstitutions.java

@@ -107,13 +107,6 @@ private int hashCodeSubst() {
     @Substitute
     @TargetElement(name = "wait")
     private void waitSubst(long timeoutMillis) throws InterruptedException {
-        /*
-         * JDK 19 and later: our monitor implementation does not pin virtual threads, so avoid
-         * jdk.internal.misc.Blocker which expects and asserts that a virtual thread is pinned.
-         * Also, we get interrupted on the virtual thread instead of the carrier thread, which
-         * clears the carrier thread's interrupt status too, so we don't have to intercept an
-         * InterruptedException from the carrier thread to clear the virtual thread interrupt.
-         */
         MonitorSupport.singleton().wait(this, timeoutMillis);
     }
 

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

@@ -42,19 +42,22 @@
 
 import com.oracle.svm.core.Uninterruptible;
 import com.oracle.svm.core.WeakIdentityHashMap;
+import com.oracle.svm.core.annotate.Alias;
 import com.oracle.svm.core.annotate.TargetClass;
 import com.oracle.svm.core.heap.RestrictHeapAccess;
 import com.oracle.svm.core.heap.RestrictHeapAccess.Access;
 import com.oracle.svm.core.hub.DynamicHub;
 import com.oracle.svm.core.hub.DynamicHubCompanion;
 import com.oracle.svm.core.jdk.JDK17OrEarlier;
+import com.oracle.svm.core.jdk.JDK19OrLater;
 import com.oracle.svm.core.jfr.JfrTicks;
 import com.oracle.svm.core.jfr.events.JavaMonitorInflateEvent;
 import com.oracle.svm.core.monitor.JavaMonitorQueuedSynchronizer.JavaMonitorConditionObject;
 import com.oracle.svm.core.snippets.SubstrateForeignCallTarget;
 import com.oracle.svm.core.stack.StackOverflowCheck;
 import com.oracle.svm.core.thread.ThreadStatus;
 import com.oracle.svm.core.thread.VMOperationControl;
+import com.oracle.svm.core.thread.VirtualThreads;
 import com.oracle.svm.core.util.VMError;
 
 import jdk.internal.misc.Unsafe;
@@ -328,15 +331,35 @@ public boolean isLockedByAnyThread(Object obj) {
     @Override
     protected void doWait(Object obj, long timeoutMillis) throws InterruptedException {
         /*
-         * Ensure that the current thread holds the lock. Required by the specification of
-         * Object.wait, and also required for our implementation.
+         * JDK 19 and later: our monitor implementation does not pin virtual threads, so avoid
+         * jdk.internal.misc.Blocker which expects and asserts that a virtual thread is pinned
+         * unless the thread is pinned for other reasons. Also, we get interrupted on the virtual
+         * thread instead of the carrier thread, which clears the carrier thread's interrupt status
+         * too, so we don't have to intercept an InterruptedException from the carrier thread to
+         * clear the virtual thread interrupt.
          */
-        JavaMonitor lock = ensureLocked(obj, MonitorInflationCause.WAIT);
-        JavaMonitorConditionObject condition = lock.getOrCreateCondition(true);
-        if (timeoutMillis == 0L) {
-            condition.await(obj);
-        } else {
-            condition.await(obj, timeoutMillis, TimeUnit.MILLISECONDS);
+        long compensation = -1;
+        boolean pinned = JavaVersionUtil.JAVA_SPEC >= 19 && VirtualThreads.isSupported() &&
+                        VirtualThreads.singleton().isVirtual(Thread.currentThread()) && VirtualThreads.singleton().isCurrentPinned();
+        if (pinned) {
+            compensation = Target_jdk_internal_misc_Blocker.begin();
+        }
+        try {
+            /*
+             * Ensure that the current thread holds the lock. Required by the specification of
+             * Object.wait, and also required for our implementation.
+             */
+            JavaMonitor lock = ensureLocked(obj, MonitorInflationCause.WAIT);
+            JavaMonitorConditionObject condition = lock.getOrCreateCondition(true);
+            if (timeoutMillis == 0L) {
+                condition.await(obj);
+            } else {
+                condition.await(obj, timeoutMillis, TimeUnit.MILLISECONDS);
+            }
+        } finally {
+            if (pinned) {
+                Target_jdk_internal_misc_Blocker.end(compensation);
+            }
         }
     }
 
@@ -462,3 +485,12 @@ protected JavaMonitor newMonitorLock() {
 @TargetClass(value = ReferenceQueue.class, innerClass = "Lock", onlyWith = JDK17OrEarlier.class)
 final class Target_java_lang_ref_ReferenceQueue_Lock {
 }
+
+@TargetClass(className = "jdk.internal.misc.Blocker", onlyWith = JDK19OrLater.class)
+final class Target_jdk_internal_misc_Blocker {
+    @Alias
+    public static native long begin();
+
+    @Alias
+    public static native void end(long compensateReturn);
+}

substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/thread/LoomVirtualThreads.java

@@ -131,6 +131,13 @@ public void unpinCurrent() {
         Target_jdk_internal_vm_Continuation.unpin();
     }
 
+    @Override
+    public boolean isCurrentPinned() {
+        Target_java_lang_Thread carrier = JavaThreads.toTarget(Target_java_lang_Thread.currentCarrierThread());
+        Target_jdk_internal_vm_ContinuationScope scope = carrier.cont.getScope();
+        return Target_jdk_internal_vm_Continuation.isPinned(scope);
+    }
+
     @Override
     public Executor getScheduler(Thread thread) {
         return cast(thread).scheduler;

substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/thread/SubstrateVirtualThread.java

@@ -197,11 +197,7 @@ private void unmount() {
 
     private boolean yieldContinuation() {
         assert this == Thread.currentThread();
-        if (pins > 0) {
-            return false;
-        }
-        JavaFrameAnchor anchor = JavaFrameAnchors.getFrameAnchor();
-        if (anchor.isNonNull() && cont.getBaseSP().aboveThan(anchor.getLastJavaSP())) {
+        if (isPinned()) {
             return false;
         }
 
@@ -675,6 +671,15 @@ void unpin() {
         pins--;
     }
 
+    boolean isPinned() {
+        assert currentThread() == this;
+        if (pins > 0) {
+            return true;
+        }
+        JavaFrameAnchor anchor = JavaFrameAnchors.getFrameAnchor();
+        return anchor.isNonNull() && cont.getBaseSP().aboveThan(anchor.getLastJavaSP());
+    }
+
     @Override
     public void run() {
     }

substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/thread/SubstrateVirtualThreads.java

@@ -217,6 +217,11 @@ public void unpinCurrent() {
         current().unpin();
     }
 
+    @Override
+    public boolean isCurrentPinned() {
+        return current().isPinned();
+    }
+
     @Override
     public Executor getScheduler(Thread thread) {
         return cast(thread).getScheduler();

substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/thread/Target_jdk_internal_vm_Continuation.java

@@ -203,4 +203,7 @@ static void unpin() {
             carrier.cont.pinCount--;
         }
     }
+
+    @Alias
+    static native boolean isPinned(Target_jdk_internal_vm_ContinuationScope scope);
 }

substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/thread/VirtualThreads.java

@@ -70,6 +70,8 @@ static boolean isSupported() {
 
     void unpinCurrent();
 
+    boolean isCurrentPinned();
+
     Executor getScheduler(Thread thread);
 
     void blockedOn(Target_sun_nio_ch_Interruptible b);