Changed the name of the option that is used to disable automatic reference handling.

Author: christianhaeubl

substratevm/mx.substratevm/mx_substratevm.py

@@ -991,9 +991,9 @@ def _native_image_launcher_extra_jvm_args():
                 '-H:-DeleteLocalSymbols',
 
 
-                # No VM-internal threads may be spawned for libgraal and the reference handler is executed manually.
+                # No VM-internal threads may be spawned for libgraal and the reference handling is executed manually.
                 '-H:-AllowVMInternalThreads',
-                '-R:ReferenceHandlerMode=0',
+                '-R:-AutomaticReferenceHandling',
             ],
         ),
     ],

substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/IsolateArgumentParser.java

@@ -56,7 +56,7 @@
  */
 public class IsolateArgumentParser {
     private static final RuntimeOptionKey<?>[] OPTIONS = {SubstrateGCOptions.MinHeapSize, SubstrateGCOptions.MaxHeapSize, SubstrateGCOptions.MaxNewSize,
-                    SubstrateOptions.ConcealedOptions.ReferenceHandlerMode};
+                    SubstrateOptions.ConcealedOptions.UseReferenceHandlerThread, SubstrateOptions.ConcealedOptions.AutomaticReferenceHandling};
     private static final int OPTION_COUNT = OPTIONS.length;
     private static final CGlobalData<CCharPointer> OPTION_NAMES = CGlobalDataFactory.createBytes(IsolateArgumentParser::createOptionNames);
     private static final CGlobalData<CIntPointer> OPTION_NAME_POSITIONS = CGlobalDataFactory.createBytes(IsolateArgumentParser::createOptionNamePosition);

substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/SubstrateOptions.java

@@ -572,28 +572,12 @@ public Boolean getValue(OptionValues values) {
         public static final HostedOptionKey<Boolean> UseDedicatedVMOperationThread = new HostedOptionKey<>(false);
 
         /** Use {@link ReferenceHandler#useDedicatedThread()} instead. */
-        @Option(help = "Determines how reference handling is done. " +
-                        "0 - reference handling can only be executed manually, " +
-                        "1 - reference handling is done in a dedicated reference handler thread, " +
-                        "2 - (deprecated) reference handling is done in regular Java threads.", type = OptionType.Expert) //
-        public static final RuntimeOptionKey<Integer> ReferenceHandlerMode = new ImmutableRuntimeOptionKey<>(null) {
-            @Override
-            public Integer getValueOrDefault(UnmodifiableEconomicMap<OptionKey<?>, Object> values) {
-                if (!values.containsKey(this)) {
-                    if (AllowVMInternalThreads.getValueOrDefault(values)) {
-                        return com.oracle.svm.core.heap.ReferenceHandlerMode.UseDedicatedThread;
-                    } else {
-                        return com.oracle.svm.core.heap.ReferenceHandlerMode.UseRegularJavaThreads;
-                    }
-                }
-                return super.getValueOrDefault(values);
-            }
+        @Option(help = "Populate reference queues in a separate thread rather than after a garbage collection.", type = OptionType.Expert) //
+        public static final RuntimeOptionKey<Boolean> UseReferenceHandlerThread = new ImmutableRuntimeOptionKey<>(true);
 
-            @Override
-            public Integer getValue(OptionValues values) {
-                return getValueOrDefault(values.getMap());
-            }
-        };
+        /** Use {@link ReferenceHandler#isExecutedManually()} instead. */
+        @Option(help = "Determines if the reference handling is executed automatically or manually.", type = OptionType.Expert) //
+        public static final RuntimeOptionKey<Boolean> AutomaticReferenceHandling = new ImmutableRuntimeOptionKey<>(true);
     }
 
     @Option(help = "Overwrites the available number of processors provided by the OS. Any value <= 0 means using the processor count from the OS.")//

substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/heap/Heap.java

@@ -38,6 +38,7 @@
 import org.graalvm.word.Pointer;
 import org.graalvm.word.UnsignedWord;
 
+import com.oracle.svm.core.SubstrateOptions;
 import com.oracle.svm.core.annotate.Uninterruptible;
 import com.oracle.svm.core.hub.DynamicHub;
 import com.oracle.svm.core.hub.PredefinedClassesSupport;
@@ -199,10 +200,10 @@ public List<Class<?>> getLoadedClasses() {
 
     /**
      * If the automatic reference handling is disabled (see
-     * {@link ReferenceHandlerMode#ExecuteManually}), then this method can be called to do the
-     * reference handling manually. On execution, the current thread will enqueue pending
-     * {@link Reference}s into their corresponding {@link ReferenceQueue}s and it will execute
-     * pending cleaners.
+     * {@link SubstrateOptions.ConcealedOptions#AutomaticReferenceHandling}), then this method can
+     * be called to do the reference handling manually. On execution, the current thread will
+     * enqueue pending {@link Reference}s into their corresponding {@link ReferenceQueue}s and it
+     * will execute pending cleaners.
      *
      * This method must not be called from within a VM operation as this could result in deadlocks.
      * Furthermore, it is up to the caller to ensure that this method is only called in places where

substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/heap/ReferenceHandler.java

@@ -35,20 +35,23 @@
 public final class ReferenceHandler {
     public static boolean useDedicatedThread() {
         if (ReferenceHandlerThread.isSupported()) {
-            int optionIndex = IsolateArgumentParser.getOptionIndex(SubstrateOptions.ConcealedOptions.ReferenceHandlerMode);
-            return IsolateArgumentParser.getIntOptionValue(optionIndex) == ReferenceHandlerMode.UseDedicatedThread;
+            int useReferenceHandlerThread = IsolateArgumentParser.getOptionIndex(SubstrateOptions.ConcealedOptions.UseReferenceHandlerThread);
+            int automaticReferenceHandling = IsolateArgumentParser.getOptionIndex(SubstrateOptions.ConcealedOptions.AutomaticReferenceHandling);
+            return IsolateArgumentParser.getBooleanOptionValue(useReferenceHandlerThread) && IsolateArgumentParser.getBooleanOptionValue(automaticReferenceHandling);
         }
         return false;
     }
 
     public static boolean useRegularJavaThread() {
-        int optionIndex = IsolateArgumentParser.getOptionIndex(SubstrateOptions.ConcealedOptions.ReferenceHandlerMode);
-        return IsolateArgumentParser.getIntOptionValue(optionIndex) == ReferenceHandlerMode.UseRegularJavaThreads;
+        int useReferenceHandlerThread = IsolateArgumentParser.getOptionIndex(SubstrateOptions.ConcealedOptions.UseReferenceHandlerThread);
+        int automaticReferenceHandling = IsolateArgumentParser.getOptionIndex(SubstrateOptions.ConcealedOptions.AutomaticReferenceHandling);
+        return (!ReferenceHandlerThread.isSupported() || !IsolateArgumentParser.getBooleanOptionValue(useReferenceHandlerThread)) &&
+                        IsolateArgumentParser.getBooleanOptionValue(automaticReferenceHandling);
     }
 
     public static boolean isExecutedManually() {
-        int optionIndex = IsolateArgumentParser.getOptionIndex(SubstrateOptions.ConcealedOptions.ReferenceHandlerMode);
-        return IsolateArgumentParser.getIntOptionValue(optionIndex) == ReferenceHandlerMode.ExecuteManually;
+        int automaticReferenceHandling = IsolateArgumentParser.getOptionIndex(SubstrateOptions.ConcealedOptions.AutomaticReferenceHandling);
+        return !IsolateArgumentParser.getBooleanOptionValue(automaticReferenceHandling);
     }
 
     public static void processPendingReferencesInRegularThread() {

substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/heap/ReferenceHandlerMode.java

@@ -32,6 +32,7 @@
 import java.util.Arrays;
 import java.util.Map;
 
+import com.oracle.svm.core.heap.Heap;
 import org.graalvm.collections.EconomicMap;
 import org.graalvm.compiler.debug.GlobalMetrics;
 import org.graalvm.compiler.hotspot.CompilationContext;
@@ -248,6 +249,12 @@ private static long compileMethod(PointerBase jniEnv,
             UNSAFE.putInt(stackTraceAddress, length);
             UNSAFE.copyMemory(stackTrace, ARRAY_BYTE_BASE_OFFSET, null, stackTraceAddress + Integer.BYTES, length);
             return 0L;
+        } finally {
+            /*
+             * libgraal doesn't use a dedicated reference handler thread, so we trigger the
+             * reference handling manually when a compilation finishes.
+             */
+            Heap.getHeap().doReferenceHandling();
         }
     }
 }

substratevm/src/com.oracle.svm.graal.hotspot.libgraal/src/com/oracle/svm/graal/hotspot/libgraal/LibGraalEntryPoints.java

@@ -27,7 +27,6 @@
 import java.lang.reflect.Array;
 import java.nio.ByteBuffer;
 
-import com.oracle.svm.core.heap.ReferenceHandlerMode;
 import org.graalvm.collections.EconomicMap;
 import org.graalvm.collections.UnmodifiableMapCursor;
 import org.graalvm.compiler.code.CompilationResult;
@@ -68,7 +67,7 @@ public static CompilerIsolateThread createCompilationIsolate() {
             builder.reservedAddressSpaceSize(WordFactory.signed(addressSpaceSize));
         }
         // Compilation isolates do the reference handling manually to avoid the extra thread.
-        builder.appendArgument(getOptionString(SubstrateOptions.ConcealedOptions.ReferenceHandlerMode, ReferenceHandlerMode.ExecuteManually));
+        builder.appendArgument(getOptionString(SubstrateOptions.ConcealedOptions.AutomaticReferenceHandling, false));
         CreateIsolateParameters params = builder.build();
         CompilerIsolateThread isolate = (CompilerIsolateThread) Isolates.createIsolate(params);
         initializeCompilationIsolate(isolate);
@@ -193,8 +192,8 @@ public static void applyClientRuntimeOptionValues(PointerBase encodedOptionsPtr,
         RuntimeOptionValues.singleton().update(options);
     }
 
-    private static String getOptionString(RuntimeOptionKey<Integer> option, int value) {
-        return "-XX:" + option.getName() + "=" + value;
+    private static String getOptionString(RuntimeOptionKey<Boolean> option, boolean value) {
+        return "-XX:" + (value ? "+" : "-") + option.getName();
     }
 
     private IsolatedGraalUtils() {