Always use Thread.tid for JavaMonitor owners.

Author: peter-hofer

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

@@ -34,7 +34,6 @@
 import com.oracle.svm.core.jfr.SubstrateJVM;
 import com.oracle.svm.core.jfr.events.JavaMonitorEnterEvent;
 import com.oracle.svm.core.thread.JavaThreads;
-import com.oracle.svm.core.thread.VirtualThreads;
 import com.oracle.svm.core.util.VMError;
 
 import jdk.internal.misc.Unsafe;
@@ -214,19 +213,10 @@ boolean isLocked() {
      */
     @Uninterruptible(reason = "Called from uninterruptible code.", mayBeInlined = true)
     protected static long getCurrentThreadIdentity() {
-        if (VirtualThreads.isSupported()) {
-            return JavaThreads.getThreadId(Thread.currentThread());
-        } else {
-            return CurrentIsolate.getCurrentThread().rawValue();
-        }
+        return JavaThreads.getCurrentThreadId();
     }
 
-    protected static long getThreadIdentity(IsolateThread isolateThread, Thread thread) {
-        if (VirtualThreads.isSupported()) {
-            return JavaThreads.getThreadId(thread);
-        } else {
-            VMError.guarantee(isolateThread.isNonNull());
-            return isolateThread.rawValue();
-        }
+    protected static long getThreadIdentity(Thread thread) {
+        return JavaThreads.getThreadId(thread);
     }
 }

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

@@ -30,8 +30,10 @@
 import java.util.concurrent.atomic.AtomicInteger;
 import java.util.concurrent.atomic.AtomicLong;
 
+import org.graalvm.compiler.api.directives.GraalDirectives;
 import org.graalvm.compiler.api.replacements.Fold;
 import org.graalvm.compiler.core.common.SuppressFBWarnings;
+import org.graalvm.compiler.replacements.ReplacementsUtil;
 import org.graalvm.compiler.serviceprovider.JavaVersionUtil;
 import org.graalvm.nativeimage.IsolateThread;
 import org.graalvm.word.Pointer;
@@ -383,4 +385,19 @@ public static void blockedOn(Target_sun_nio_ch_Interruptible b) {
             PlatformThreads.blockedOn(b);
         }
     }
+
+    /**
+     * Returns the result of calling {@link #getThreadId} on {@link Thread#currentThread}, but from
+     * a thread-local cache with potentially fewer accesses.
+     */
+    @Uninterruptible(reason = "Called from uninterruptible code.", mayBeInlined = true)
+    public static long getCurrentThreadId() {
+        long id = PlatformThreads.currentVThreadId.get();
+        if (GraalDirectives.inIntrinsic()) {
+            ReplacementsUtil.dynamicAssert(id == getThreadId(Thread.currentThread()), "ids must match");
+        } else {
+            assert id == getThreadId(Thread.currentThread());
+        }
+        return id;
+    }
 }

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

@@ -95,6 +95,7 @@
 import com.oracle.svm.core.thread.VMThreads.StatusSupport;
 import com.oracle.svm.core.threadlocal.FastThreadLocal;
 import com.oracle.svm.core.threadlocal.FastThreadLocalFactory;
+import com.oracle.svm.core.threadlocal.FastThreadLocalLong;
 import com.oracle.svm.core.threadlocal.FastThreadLocalObject;
 import com.oracle.svm.core.util.TimeUtils;
 import com.oracle.svm.core.util.VMError;
@@ -124,6 +125,13 @@ public static PlatformThreads singleton() {
     /** The platform {@link java.lang.Thread} for the {@link IsolateThread}. */
     static final FastThreadLocalObject<Thread> currentThread = FastThreadLocalFactory.createObject(Thread.class, "PlatformThreads.currentThread").setMaxOffset(FastThreadLocal.BYTE_OFFSET);
 
+    /**
+     * The {@linkplain JavaThreads#getThreadId thread id} of the {@link Thread#currentThread()},
+     * which can be a {@linkplain Target_java_lang_Thread#vthread virtual thread} or the
+     * {@linkplain #currentThread platform thread itself}.
+     */
+    static final FastThreadLocalLong currentVThreadId = FastThreadLocalFactory.createLong("PlatformThreads.currentVThreadId").setMaxOffset(FastThreadLocal.BYTE_OFFSET);
+
     /**
      * A thread-local helper object for locking. Use only if each {@link Thread} corresponds to an
      * {@link IsolateThread}, otherwise use {@link Target_java_lang_Thread#lockHelper}.
@@ -453,7 +461,7 @@ public static boolean ensureCurrentAssigned(String name, ThreadGroup group, bool
      * {@link #ensureCurrentAssigned(String, ThreadGroup, boolean)}. It is false when the thread is
      * started via {@link #doStartThread} and {@link #threadStartRoutine}.
      */
-    public static void assignCurrent(Thread thread, boolean manuallyStarted) {
+    static void assignCurrent(Thread thread, boolean manuallyStarted) {
         /*
          * First of all, ensure we are in RUNNABLE state. If !manuallyStarted, we race with the
          * thread that launched us to set the status and we could still be in status NEW.
@@ -479,17 +487,20 @@ public static void assignCurrent(Thread thread, boolean manuallyStarted) {
     @Uninterruptible(reason = "Called from uninterruptible code.", mayBeInlined = true)
     private static void assignCurrent0(Thread thread) {
         VMError.guarantee(currentThread.get() == null, "overwriting existing java.lang.Thread");
+        currentVThreadId.set(JavaThreads.getThreadId(thread));
         currentThread.set(thread);
 
         assert toTarget(thread).isolateThread.isNull();
         toTarget(thread).isolateThread = CurrentIsolate.getCurrentThread();
         ThreadListenerSupport.get().beforeThreadStart(CurrentIsolate.getCurrentThread(), thread);
     }
 
+    @Uninterruptible(reason = "Ensure consistency of vthread and cached vthread id.")
     static void setCurrentThread(Thread carrier, Thread thread) {
         assert carrier == currentThread.get();
         assert thread == carrier || (VirtualThreads.isSupported() && VirtualThreads.singleton().isVirtual(thread));
         toTarget(carrier).vthread = (thread != carrier) ? thread : null;
+        currentVThreadId.set(JavaThreads.getThreadId(thread));
     }
 
     @Uninterruptible(reason = "Called during isolate initialization")

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

@@ -301,7 +301,7 @@ static Thread currentCarrierThread() {
         return thread;
     }
 
-    /** On HotSpot, a field of C++ class {@code JavaThread}. Loads and stores are unordered. */
+    /** On HotSpot, a field in C++ class {@code JavaThread}. Loads and stores are unordered. */
     @Inject @TargetElement(onlyWith = ContinuationsSupported.class)//
     @RecomputeFieldValue(kind = RecomputeFieldValue.Kind.Reset)//
     Thread vthread = null;