Add support for jdk.incubator.concurrent.ScopedValue.

Author: peter-hofer

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

@@ -30,6 +30,7 @@
 import org.graalvm.nativeimage.ImageSingletons;
 import org.graalvm.nativeimage.Platform;
 import org.graalvm.nativeimage.Platforms;
+import org.graalvm.nativeimage.hosted.RuntimeClassInitialization;
 
 import com.oracle.svm.core.feature.InternalFeature;
 import com.oracle.svm.core.feature.AutomaticallyRegisteredFeature;
@@ -61,6 +62,12 @@ static JavaThreadsFeature singleton() {
     @Override
     public void duringSetup(DuringSetupAccess access) {
         access.registerObjectReplacer(this::collectReachableObjects);
+
+        /*
+         * This currently only means that we don't support setting custom values for
+         * jdk.incubator.concurrent.ScopedValue.cacheSize at runtime.
+         */
+        RuntimeClassInitialization.initializeAtBuildTime("jdk.incubator.concurrent");
     }
 
     private Object collectReachableObjects(Object original) {

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

@@ -31,7 +31,6 @@
 import java.util.Map;
 import java.util.Objects;
 import java.util.concurrent.ThreadFactory;
-import java.util.function.BooleanSupplier;
 
 import org.graalvm.compiler.api.directives.GraalDirectives;
 import org.graalvm.compiler.replacements.ReplacementsUtil;
@@ -59,11 +58,11 @@
 import com.oracle.svm.core.jdk.JDK17OrLater;
 import com.oracle.svm.core.jdk.JDK19OrEarlier;
 import com.oracle.svm.core.jdk.JDK19OrLater;
+import com.oracle.svm.core.jdk.JDK20OrLater;
 import com.oracle.svm.core.jdk.LoomJDK;
 import com.oracle.svm.core.jdk.NotLoomJDK;
 import com.oracle.svm.core.monitor.MonitorSupport;
 import com.oracle.svm.core.util.VMError;
-import com.oracle.svm.util.ReflectionUtil;
 
 @TargetClass(Thread.class)
 @SuppressWarnings({"unused"})
@@ -80,6 +79,10 @@ public final class Target_java_lang_Thread {
     @Alias //
     @TargetElement(onlyWith = JDK19OrLater.class) //
     static int NO_INHERIT_THREAD_LOCALS;
+
+    @Alias //
+    @TargetElement(onlyWith = JDK20OrLater.class) //
+    static Object NEW_THREAD_BINDINGS;
     // Checkstyle: resume
 
     /** This field is initialized when the thread actually starts executing. */
@@ -190,10 +193,13 @@ public final class Target_java_lang_Thread {
     @RecomputeFieldValue(kind = RecomputeFieldValue.Kind.Reset) //
     Object lockHelper;
 
-    @Inject @TargetElement(onlyWith = {HasScopedValueCache.class, HasExtentLocalCache.class, LoomJDK.class}) //
+    @Inject @TargetElement(onlyWith = JDK19OrLater.class) //
     @RecomputeFieldValue(kind = RecomputeFieldValue.Kind.Reset) //
     Object[] scopedValueCache;
 
+    @Alias @TargetElement(onlyWith = JDK20OrLater.class) //
+    Object scopedValueBindings;
+
     @Alias
     @Platforms(InternalPlatform.NATIVE_ONLY.class)
     native void setPriority(int newPriority);
@@ -370,6 +376,10 @@ private Target_java_lang_Thread(
         boolean allowThreadLocals = (characteristics & NO_THREAD_LOCALS) == 0;
         boolean inheritThreadLocals = (characteristics & NO_INHERIT_THREAD_LOCALS) == 0;
         JavaThreads.initializeNewThread(this, g, target, nameLocal, stackSize, acc, allowThreadLocals, inheritThreadLocals);
+
+        if (JavaVersionUtil.JAVA_SPEC >= 20) {
+            this.scopedValueBindings = NEW_THREAD_BINDINGS;
+        }
     }
 
     @Substitute
@@ -394,6 +404,10 @@ private Target_java_lang_Thread(String name, int characteristics, boolean bound)
         boolean allowThreadLocals = (characteristics & NO_THREAD_LOCALS) == 0;
         boolean inheritThreadLocals = (characteristics & NO_INHERIT_THREAD_LOCALS) == 0;
         JavaThreads.initNewThreadLocalsAndLoader(this, allowThreadLocals, inheritThreadLocals, Thread.currentThread());
+
+        if (JavaVersionUtil.JAVA_SPEC >= 20) {
+            this.scopedValueBindings = NEW_THREAD_BINDINGS;
+        }
     }
 
     @SuppressWarnings("hiding")
@@ -665,29 +679,44 @@ static Thread startVirtualThreadWithoutLoom(Runnable task) {
     }
 
     @Substitute
-    @TargetElement(onlyWith = HasExtentLocalCache.class)
+    @TargetElement(onlyWith = {JDK19OrLater.class, JDK19OrEarlier.class})
     static Object[] extentLocalCache() {
         return JavaThreads.toTarget(currentCarrierThread()).scopedValueCache;
     }
 
     @Substitute
-    @TargetElement(onlyWith = HasExtentLocalCache.class)
+    @TargetElement(onlyWith = {JDK19OrLater.class, JDK19OrEarlier.class})
     static void setExtentLocalCache(Object[] cache) {
         JavaThreads.toTarget(currentCarrierThread()).scopedValueCache = cache;
     }
 
     @Substitute
-    @TargetElement(onlyWith = HasScopedValueCache.class)
+    @TargetElement(onlyWith = JDK20OrLater.class)
     static Object[] scopedValueCache() {
         return JavaThreads.toTarget(currentCarrierThread()).scopedValueCache;
     }
 
     @Substitute
-    @TargetElement(onlyWith = HasScopedValueCache.class)
+    @TargetElement(onlyWith = JDK20OrLater.class)
     static void setScopedValueCache(Object[] cache) {
         JavaThreads.toTarget(currentCarrierThread()).scopedValueCache = cache;
     }
 
+    @Substitute
+    @TargetElement(onlyWith = JDK20OrLater.class)
+    static Object findScopedValueBindings() {
+        /*
+         * We don't have the means to extract the bindings object parameter from runWith frames on
+         * the stack like HotSpot does. However, at this time, we need to support only two cases:
+         * current bindings in a virtual thread, and current bindings in the carrier thread.
+         */
+        Object bindings = JavaThreads.toTarget(Thread.currentThread()).scopedValueBindings;
+        if (bindings != null) {
+            return bindings;
+        }
+        return JavaThreads.toTarget(currentCarrierThread()).scopedValueBindings;
+    }
+
     @Substitute
     static void blockedOn(Target_sun_nio_ch_Interruptible b) {
         JavaThreads.blockedOn(b);
@@ -725,22 +754,6 @@ boolean isTerminated() {
     @Alias
     @TargetElement(onlyWith = JDK19OrLater.class)
     native long threadId();
-
-    private static class HasExtentLocalCache implements BooleanSupplier {
-        @Override
-        public boolean getAsBoolean() {
-            boolean result = ReflectionUtil.lookupMethod(true, Thread.class, "extentLocalCache") != null;
-            assert !result || JavaVersionUtil.JAVA_SPEC == 19 : "extentLocalCache should not exist as of JDK 20";
-            return result;
-        }
-    }
-
-    public static class HasScopedValueCache implements BooleanSupplier {
-        @Override
-        public boolean getAsBoolean() {
-            return ReflectionUtil.lookupMethod(true, Thread.class, "scopedValueCache") != null;
-        }
-    }
 }
 
 @TargetClass(value = Thread.class, innerClass = "Builder", onlyWith = JDK19OrLater.class)

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

@@ -24,20 +24,25 @@
  */
 package com.oracle.svm.core.thread;
 
-import com.oracle.svm.core.annotate.KeepOriginal;
+import java.lang.ref.ReferenceQueue;
+import java.lang.ref.WeakReference;
+import java.util.Set;
+import java.util.stream.Stream;
+
+import com.oracle.svm.core.annotate.Delete;
 import com.oracle.svm.core.annotate.Substitute;
 import com.oracle.svm.core.annotate.TargetClass;
 import com.oracle.svm.core.jdk.JDK19OrLater;
 
 /**
- * The purpose of the target class is to support debugging and monitoring of threads. Because we
- * currently don't provide/expose means for doing so, we replace it with an almost empty
- * implementation.
+ * We currently don't provide/expose means for debugging and monitoring of threads, so we replace
+ * these methods with an empty implementation.
  */
 @TargetClass(className = "jdk.internal.vm.ThreadContainers", onlyWith = JDK19OrLater.class)
-@Substitute
 @SuppressWarnings("unused")
 final class Target_jdk_internal_vm_ThreadContainers {
+    @Delete static Set<WeakReference<Target_jdk_internal_vm_ThreadContainer>> CONTAINER_REGISTRY;
+    @Delete static ReferenceQueue<Object> QUEUE;
 
     @Substitute
     public static Object registerContainer(Target_jdk_internal_vm_ThreadContainer container) {
@@ -48,8 +53,10 @@ public static Object registerContainer(Target_jdk_internal_vm_ThreadContainer co
     public static void deregisterContainer(Object key) {
     }
 
-    @KeepOriginal
-    public static native Target_jdk_internal_vm_ThreadContainer root();
+    @Substitute
+    static Stream<Target_jdk_internal_vm_ThreadContainer> children(Target_jdk_internal_vm_ThreadContainer container) {
+        return Stream.empty();
+    }
 }
 
 @TargetClass(className = "jdk.internal.vm.ThreadContainer", onlyWith = JDK19OrLater.class)