Move some methods related to virtual threads to JavaThreads.

Author: peter-hofer

substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/jfr/JfrEvent.java

@@ -28,7 +28,7 @@
 import org.graalvm.nativeimage.Platforms;
 
 import com.oracle.svm.core.Uninterruptible;
-import com.oracle.svm.core.thread.PlatformThreads;
+import com.oracle.svm.core.thread.JavaThreads;
 
 /**
  * This file contains the VM-level events that Native Image supports on all JDK versions. The event
@@ -96,7 +96,7 @@ public String getName() {
     @Uninterruptible(reason = "Prevent races with VM operations that start/stop recording.", callerMustBe = true)
     public boolean shouldEmit() {
         assert !hasDuration;
-        return shouldEmit0() && !JfrThreadLocal.isThreadExcluded(PlatformThreads.getCurrentThreadOrNull());
+        return shouldEmit0() && !JfrThreadLocal.isThreadExcluded(JavaThreads.getCurrentThreadOrNull());
     }
 
     @Uninterruptible(reason = "Prevent races with VM operations that start/stop recording.", callerMustBe = true)
@@ -108,7 +108,7 @@ public boolean shouldEmit(Thread thread) {
     @Uninterruptible(reason = "Prevent races with VM operations that start/stop recording.", callerMustBe = true)
     public boolean shouldEmit(long durationTicks) {
         assert hasDuration;
-        return shouldEmit0() && durationTicks >= SubstrateJVM.get().getThresholdTicks(this) && !JfrThreadLocal.isThreadExcluded(PlatformThreads.getCurrentThreadOrNull());
+        return shouldEmit0() && durationTicks >= SubstrateJVM.get().getThresholdTicks(this) && !JfrThreadLocal.isThreadExcluded(JavaThreads.getCurrentThreadOrNull());
     }
 
     @Uninterruptible(reason = "Prevent races with VM operations that start/stop recording.", callerMustBe = true)

substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/jfr/JfrThreadLocal.java

@@ -229,7 +229,7 @@ private static void flushToGlobalMemoryAndRetireBuffer(JfrBuffer buffer) {
      * moment, only the current thread may be excluded/included. See GR-44616.
      */
     public static void setExcluded(Thread thread, boolean excluded) {
-        if (thread == null || thread != PlatformThreads.getCurrentThreadOrNull()) {
+        if (thread == null || thread != JavaThreads.getCurrentThreadOrNull()) {
             return;
         }
         IsolateThread currentIsolateThread = CurrentIsolate.getCurrentThread();
@@ -247,7 +247,7 @@ public static void setExcluded(Thread thread, boolean excluded) {
      * thread, see {@link PlatformThreads#ensureCurrentAssigned(String, ThreadGroup, boolean)} where
      * a {@link Thread} object must be created before it can be assigned to the current thread. This
      * may happen during shutdown in {@link JavaMainWrapper}. Therefore, this method must account
-     * for the case where {@link PlatformThreads#getCurrentThreadOrNull()} returns null.
+     * for the case where {@link JavaThreads#getCurrentThreadOrNull()} returns null.
      */
     @Uninterruptible(reason = "Called from uninterruptible code.", mayBeInlined = true)
     public static boolean isThreadExcluded(Thread thread) {
@@ -286,7 +286,7 @@ public Target_jdk_jfr_internal_event_EventWriter newEventWriter() {
             throw new OutOfMemoryError("OOME for thread local buffer");
         }
 
-        Target_jdk_jfr_internal_event_EventWriter result = JfrEventWriterAccess.newEventWriter(buffer, isThreadExcluded(PlatformThreads.getCurrentThreadOrNull()));
+        Target_jdk_jfr_internal_event_EventWriter result = JfrEventWriterAccess.newEventWriter(buffer, isThreadExcluded(JavaThreads.getCurrentThreadOrNull()));
         javaEventWriter.set(result);
         return result;
     }

substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/jfr/JfrThreadRepository.java

@@ -88,7 +88,7 @@ public void registerRunningThreads() {
             if (thread != null) {
                 registerThread(thread);
                 // Re-register vthreads that are already mounted.
-                Thread vthread = PlatformThreads.getVThread(thread);
+                Thread vthread = PlatformThreads.getMountedVirtualThread(thread);
                 if (vthread != null) {
                     registerThread(vthread);
                 }

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

@@ -47,6 +47,9 @@
 import com.oracle.svm.core.jdk.StackTraceUtils;
 import com.oracle.svm.core.snippets.KnownIntrinsics;
 import com.oracle.svm.core.stack.StackFrameVisitor;
+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.util.ReflectionUtil;
 
 /**
@@ -68,6 +71,17 @@
  * and choose the appropriate action.
  */
 public final class JavaThreads {
+    /**
+     * The {@linkplain JavaThreads#getThreadId thread id} of the {@link Thread#currentThread()},
+     * which can be a {@linkplain Target_java_lang_Thread#vthread virtual thread} or a
+     * {@linkplain PlatformThreads#currentThread platform thread}.
+     *
+     * As the value of the thread local can change over the thread lifetime (see carrier threads),
+     * it should only be accessed by the owning thread (via {@link FastThreadLocalLong#get()} and
+     * {@link FastThreadLocalLong#set(long)}).
+     */
+    static final FastThreadLocalLong currentVThreadId = FastThreadLocalFactory.createLong("JavaThreads.currentVThreadId").setMaxOffset(FastThreadLocal.BYTE_OFFSET);
+
     /** For Thread.nextThreadID(). */
     static final AtomicLong threadSeqNumber = new AtomicLong();
     /** For Thread.nextThreadNum(). */
@@ -382,7 +396,7 @@ static void blockedOn(Target_sun_nio_ch_Interruptible b) {
      */
     @Uninterruptible(reason = "Called from uninterruptible code.", mayBeInlined = true)
     public static long getCurrentThreadId() {
-        long id = PlatformThreads.currentVThreadId.get();
+        long id = currentVThreadId.get();
         if (GraalDirectives.inIntrinsic()) {
             ReplacementsUtil.dynamicAssert(id != 0 && id == getThreadId(Thread.currentThread()), "ids must match");
         } else {
@@ -400,8 +414,27 @@ public static long getCurrentThreadId() {
     @Uninterruptible(reason = "Called from uninterruptible code.", mayBeInlined = true)
     public static long getCurrentThreadIdOrZero() {
         if (CurrentIsolate.getCurrentThread().isNonNull()) {
-            return PlatformThreads.currentVThreadId.get();
+            return currentVThreadId.get();
         }
         return 0L;
     }
+
+    @Uninterruptible(reason = "Ensure consistency of vthread and cached vthread id.")
+    static void setCurrentThread(Thread carrier, Thread thread) {
+        assert carrier == PlatformThreads.currentThread.get();
+        assert thread == carrier || isVirtual(thread);
+        toTarget(carrier).vthread = (thread != carrier) ? thread : null;
+        currentVThreadId.set(getThreadId(thread));
+    }
+
+    @Uninterruptible(reason = "Called from uninterruptible code.", mayBeInlined = true)
+    public static Thread getCurrentThreadOrNull() {
+        Thread thread = PlatformThreads.currentThread.get();
+        if (thread == null) {
+            return null;
+        }
+
+        Target_java_lang_Thread tjlt = SubstrateUtil.cast(thread, Target_java_lang_Thread.class);
+        return (tjlt.vthread != null) ? tjlt.vthread : thread;
+    }
 }

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

@@ -98,7 +98,6 @@
 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;
@@ -126,17 +125,6 @@ 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}.
-     *
-     * As the value of the thread local can change over the thread lifetime (see carrier threads),
-     * it should only be accessed by the owning thread (via {@link FastThreadLocalLong#get()} and
-     * {@link FastThreadLocalLong#set(long)}).
-     */
-    static final FastThreadLocalLong currentVThreadId = FastThreadLocalFactory.createLong("PlatformThreads.currentVThreadId").setMaxOffset(FastThreadLocal.BYTE_OFFSET);
-
     /**
      * The number of running non-daemon threads. The initial value accounts for the main thread,
      * which is implicitly running when the isolate is created.
@@ -452,36 +440,22 @@ static void assignCurrent(Thread thread, boolean manuallyStarted) {
     @Uninterruptible(reason = "Ensure consistency of vthread and cached vthread id.")
     private static void assignCurrent0(Thread thread) {
         VMError.guarantee(currentThread.get() == null, "overwriting existing java.lang.Thread");
-        currentVThreadId.set(JavaThreads.getThreadId(thread));
+        JavaThreads.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 || isVirtual(thread);
-        toTarget(carrier).vthread = (thread != carrier) ? thread : null;
-        currentVThreadId.set(JavaThreads.getThreadId(thread));
-    }
-
-    @Uninterruptible(reason = "Called from uninterruptible code.", mayBeInlined = true)
-    public static Thread getCurrentThreadOrNull() {
-        Thread thread = PlatformThreads.currentThread.get();
-        if (thread == null) {
-            return null;
-        }
-
-        Target_java_lang_Thread tjlt = SubstrateUtil.cast(thread, Target_java_lang_Thread.class);
-        return (tjlt.vthread != null) ? tjlt.vthread : thread;
-    }
-
-    /** Returns the mounted virtual thread if one exists, otherwise null. */
+    /**
+     * Returns the virtual thread that is mounted on the given platform thread, or {@code null} if
+     * no virtual thread is mounted.
+     */
     @Uninterruptible(reason = CALLED_FROM_UNINTERRUPTIBLE_CODE, mayBeInlined = true)
-    public static Thread getVThread(Thread thread) {
+    public static Thread getMountedVirtualThread(Thread thread) {
+        assert thread == currentThread.get() || VMOperation.isInProgressAtSafepoint();
+        assert !isVirtual(thread);
         return toTarget(thread).vthread;
     }
 

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

@@ -197,7 +197,7 @@ static Thread currentCarrierThread() {
     @Uninterruptible(reason = "Called from uninterruptible code.", mayBeInlined = true)
     @Substitute
     static Thread currentThread() {
-        Thread thread = PlatformThreads.getCurrentThreadOrNull();
+        Thread thread = JavaThreads.getCurrentThreadOrNull();
         if (GraalDirectives.inIntrinsic()) {
             ReplacementsUtil.dynamicAssert(thread != null, "Thread has not been set yet");
         } else {
@@ -209,7 +209,7 @@ static Thread currentThread() {
     @SuppressWarnings("static-method")
     @Substitute
     void setCurrentThread(Thread thread) {
-        PlatformThreads.setCurrentThread(JavaThreads.fromTarget(this), thread);
+        JavaThreads.setCurrentThread(JavaThreads.fromTarget(this), thread);
     }
 
     @Substitute

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

@@ -307,7 +307,7 @@ static Object acquireInterruptLockMaybeSwitch(Target_java_lang_VirtualThread sel
              * thread might never get unparked, in which case both threads are stuck.
              */
             Thread carrier = self.carrierThread;
-            PlatformThreads.setCurrentThread(carrier, carrier);
+            JavaThreads.setCurrentThread(carrier, carrier);
             token = self;
         }
         Object lock = asTarget(self).interruptLock;
@@ -323,7 +323,7 @@ static void releaseInterruptLockMaybeSwitchBack(Target_java_lang_VirtualThread s
             assert token == self;
             Thread carrier = asVTarget(token).carrierThread;
             assert Thread.currentThread() == carrier;
-            PlatformThreads.setCurrentThread(carrier, asThread(token));
+            JavaThreads.setCurrentThread(carrier, asThread(token));
         }
     }