Renamings and small cleanups.

Author: christianhaeubl

sdk/src/org.graalvm.nativeimage/src/org/graalvm/nativeimage/Threading.java

@@ -60,8 +60,8 @@ private Threading() {
      * Registers a {@link RecurringCallback callback handler} that is called by the current thread
      * approximately at the provided interval. This functionality is only supported if the native
      * binary is built with {@code -H:+SupportRecurringCallback}. Note that only carefully crafted,
-     * uninterruptible code can be executed safely in a recurring callback. Executing any other code
-     * can result in deadlocks or crashes.
+     * uninterruptible code can execute safely in a recurring callback. Executing any other code
+     * easily results in deadlocks, crashes, and difficult-to-debug anomalies.
      * <p>
      * Only one callback can be active per thread. Each thread can have its own callback with a
      * different interval (or none at all). No guarantees are made about the actual interval. For

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

@@ -268,7 +268,7 @@ private static int runCore0() {
 
     @Uninterruptible(reason = "The caller initialized the thread state, so the callees do not need to be uninterruptible.", calleeMustBe = false)
     private static void runShutdown() {
-        RecurringCallbackSupport.suspendCallbackExecution("Recurring callbacks can't be executed during shutdown.");
+        RecurringCallbackSupport.suspendCallbackTimer("Recurring callbacks can't be executed during shutdown.");
         runShutdown0();
     }
 

substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/graal/snippets/CEntryPointSnippets.java

@@ -666,7 +666,7 @@ private static int tearDownIsolate() {
             }
 
             /* After threadExit(), only uninterruptible code may be executed. */
-            RecurringCallbackSupport.suspendCallbackExecution("Execution of arbitrary code is prohibited during the last teardown steps.");
+            RecurringCallbackSupport.suspendCallbackTimer("Execution of arbitrary code is prohibited during the last teardown steps.");
 
             /* Shut down VM thread. */
             if (VMOperationControl.useDedicatedVMOperationThread()) {

substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/graal/snippets/DeoptTester.java

@@ -118,7 +118,7 @@ public static void deoptTest() {
         try {
             if (Heap.getHeap().isAllocationDisallowed() ||
                             !CEntryPointSnippets.isIsolateInitialized() ||
-                            (RecurringCallbackSupport.isEnabled() && RecurringCallbackSupport.isCallbackExecutionSuspended()) ||
+                            (RecurringCallbackSupport.isEnabled() && RecurringCallbackSupport.isCallbackTimerSuspended()) ||
                             VMOperation.isInProgress() ||
                             SafepointBehavior.ignoresSafepoints() ||
                             !PlatformThreads.isCurrentAssigned()) {

substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/graal/snippets/StackOverflowCheckImpl.java

@@ -201,7 +201,7 @@ private static void onYellowZoneMadeAvailable(int oldState, int newState) {
              * a recurring callback in the yellow zone is dangerous because a stack overflow in the
              * recurring callback would then lead to a fatal error.
              */
-            RecurringCallbackSupport.suspendCallbackExecution("Recurring callbacks are considered user code and must not run in yellow zone");
+            RecurringCallbackSupport.suspendCallbackTimer("Recurring callbacks are considered user code and must not run in yellow zone");
 
             stackBoundaryTL.set(stackBoundaryTL.get().subtract(Options.StackYellowZoneSize.getValue()));
         }
@@ -241,7 +241,7 @@ private static void onYellowZoneProtected(int oldState, int newState) {
         VMError.guarantee(newState < oldState && newState >= STATE_YELLOW_ENABLED, "StackOverflowCheckImpl.onYellowZoneProtected: Illegal state");
 
         if (newState == STATE_YELLOW_ENABLED) {
-            RecurringCallbackSupport.resumeCallbackExecutionAtNextSafepoint();
+            RecurringCallbackSupport.resumeCallbackTimerAtNextSafepointCheck();
 
             stackBoundaryTL.set(stackBoundaryTL.get().add(Options.StackYellowZoneSize.getValue()));
         }

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

@@ -76,7 +76,7 @@ public static boolean isReferenceHandlerThread(Thread other) {
 
     @Override
     public void run() {
-        RecurringCallbackSupport.suspendCallbackExecution("An exception in a recurring callback must not interrupt pending reference processing because it could result in a memory leak.");
+        RecurringCallbackSupport.suspendCallbackTimer("An exception in a recurring callback must not interrupt pending reference processing because it could result in a memory leak.");
 
         this.isolateThread = CurrentIsolate.getCurrentThread();
         try {

substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/heap/dump/HeapDumpWriter.java

@@ -421,7 +421,7 @@ public HeapDumpWriter(HeapDumpMetadata metadata) {
 
     public boolean dumpHeap(RawFileDescriptor fd) {
         assert VMOperation.isInProgressAtSafepoint();
-        assert RecurringCallbackSupport.isCallbackExecutionNotSupportedOrSuspended();
+        assert RecurringCallbackSupport.isCallbackUnsupportedOrTimerSuspended();
 
         noAllocationVerifier.open();
         try {

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

@@ -673,7 +673,7 @@ private void changeEpoch() {
         @Uninterruptible(reason = "Prevent JFR recording.")
         private static void processSamplerBuffers() {
             assert VMOperation.isInProgressAtSafepoint();
-            assert RecurringCallbackSupport.isCallbackExecutionNotSupportedOrSuspended();
+            assert RecurringCallbackSupport.isCallbackUnsupportedOrTimerSuspended();
 
             JfrExecutionSampler.singleton().disallowThreadsInSamplerCode();
             try {

substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/jfr/sampler/JfrRecurringCallbackExecutionSampler.java

@@ -40,6 +40,7 @@
 import org.graalvm.nativeimage.hosted.Feature;
 import org.graalvm.word.Pointer;
 
+import com.oracle.svm.core.BuildPhaseProvider;
 import com.oracle.svm.core.NeverInline;
 import com.oracle.svm.core.Uninterruptible;
 import com.oracle.svm.core.feature.AutomaticallyRegisteredFeature;
@@ -53,6 +54,7 @@
 import com.oracle.svm.core.thread.VMOperation;
 import com.oracle.svm.core.thread.VMThreads;
 import com.oracle.svm.core.util.TimeUtils;
+import com.oracle.svm.core.util.VMError;
 
 import jdk.graal.compiler.api.replacements.Fold;
 
@@ -65,6 +67,7 @@ public final class JfrRecurringCallbackExecutionSampler extends AbstractJfrExecu
 
     @Fold
     public static boolean isPresent() {
+        VMError.guarantee(BuildPhaseProvider.isSetupFinished(), "JfrRecurringCallbackExecutionSampler.isPresent() must not be called too early");
         if (ImageSingletons.contains(JfrExecutionSampler.class)) {
             JfrExecutionSampler sampler = ImageSingletons.lookup(JfrExecutionSampler.class);
             return sampler instanceof JfrRecurringCallbackExecutionSampler;

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

@@ -34,7 +34,6 @@
 import org.graalvm.nativeimage.Threading.RecurringCallback;
 import org.graalvm.nativeimage.Threading.RecurringCallbackAccess;
 
-import com.oracle.svm.core.BuildPhaseProvider;
 import com.oracle.svm.core.Uninterruptible;
 import com.oracle.svm.core.heap.RestrictHeapAccess;
 import com.oracle.svm.core.jdk.UninterruptibleUtils;
@@ -60,14 +59,12 @@
  * VM. Even allocating Java objects can already be enough to cause problems.
  */
 public class RecurringCallbackSupport {
-    public static class Options {
-        @Option(help = "Test whether a thread's recurring callback is pending on each transition from native code to Java.") //
-        public static final HostedOptionKey<Boolean> CheckRecurringCallbackOnNativeToJavaTransition = new HostedOptionKey<>(false);
-    }
-
     public static class ConcealedOptions {
         @Option(help = "Support a per-thread timer that is called at a specific interval.") //
         public static final HostedOptionKey<Boolean> SupportRecurringCallback = new HostedOptionKey<>(false);
+
+        @Option(help = "Test whether a thread's recurring callback is pending on each transition from native code to Java.") //
+        static final HostedOptionKey<Boolean> CheckRecurringCallbackOnNativeToJavaTransition = new HostedOptionKey<>(false);
     }
 
     /**
@@ -80,7 +77,6 @@ public static class ConcealedOptions {
 
     @Fold
     public static boolean isEnabled() {
-        VMError.guarantee(BuildPhaseProvider.isSetupFinished(), "JfrRecurringCallbackExecutionSampler.isPresent() must not be called too early");
         return ConcealedOptions.SupportRecurringCallback.getValue() || JfrRecurringCallbackExecutionSampler.isPresent();
     }
 
@@ -158,7 +154,7 @@ static boolean isCallbackInstalled(IsolateThread thread) {
     }
 
     static boolean needsNativeToJavaSlowpath() {
-        return isEnabled() && Options.CheckRecurringCallbackOnNativeToJavaTransition.getValue() && timerTL.get() != null && !isCallbackExecutionSuspended();
+        return isEnabled() && ConcealedOptions.CheckRecurringCallbackOnNativeToJavaTransition.getValue() && timerTL.get() != null && !isCallbackTimerSuspended();
     }
 
     /**
@@ -167,7 +163,7 @@ static boolean needsNativeToJavaSlowpath() {
      * temporarily because we can't deal with arbitrary code execution or thrown exceptions.
      */
     @Uninterruptible(reason = CALLED_FROM_UNINTERRUPTIBLE_CODE, mayBeInlined = true)
-    public static void suspendCallbackExecution(@SuppressWarnings("unused") String reason) {
+    public static void suspendCallbackTimer(@SuppressWarnings("unused") String reason) {
         if (!isEnabled()) {
             return;
         }
@@ -184,13 +180,13 @@ public static void suspendCallbackExecution(@SuppressWarnings("unused") String r
      * might be triggered at the next safepoint check.
      */
     @Uninterruptible(reason = CALLED_FROM_UNINTERRUPTIBLE_CODE, mayBeInlined = true)
-    public static void resumeCallbackExecutionAtNextSafepoint() {
+    public static void resumeCallbackTimerAtNextSafepointCheck() {
         if (!isEnabled()) {
             return;
         }
 
         decrementSuspended();
-        if (!isCallbackExecutionSuspended()) {
+        if (!isCallbackTimerSuspended()) {
             RecurringCallbackTimer timer = timerTL.get();
             if (timer != null) {
                 timer.updateStatistics();
@@ -200,22 +196,22 @@ public static void resumeCallbackExecutionAtNextSafepoint() {
     }
 
     /**
-     * Like {@link #resumeCallbackExecutionAtNextSafepoint()} but with the difference that this
+     * Like {@link #resumeCallbackTimerAtNextSafepointCheck()} but with the difference that this
      * method may trigger the execution of the recurring callback right away.
      */
-    public static void resumeCallbackExecution() {
+    public static void resumeCallbackTimer() {
         if (!isEnabled()) {
             return;
         }
 
         decrementSuspended();
-        if (!isCallbackExecutionSuspended()) {
-            resumeCallbackExecution0();
+        if (!isCallbackTimerSuspended()) {
+            resumeCallbackTimer0();
         }
     }
 
     @Uninterruptible(reason = "Prevent unexpected recurring callback execution (pending exception must not be destroyed).")
-    private static void resumeCallbackExecution0() {
+    private static void resumeCallbackTimer0() {
         try {
             maybeExecuteCallback();
         } catch (SafepointException e) {
@@ -225,12 +221,12 @@ private static void resumeCallbackExecution0() {
     }
 
     @Uninterruptible(reason = CALLED_FROM_UNINTERRUPTIBLE_CODE, mayBeInlined = true)
-    public static boolean isCallbackExecutionNotSupportedOrSuspended() {
-        return !isEnabled() || isCallbackExecutionSuspended();
+    public static boolean isCallbackUnsupportedOrTimerSuspended() {
+        return !isEnabled() || isCallbackTimerSuspended();
     }
 
     @Uninterruptible(reason = CALLED_FROM_UNINTERRUPTIBLE_CODE, mayBeInlined = true)
-    public static boolean isCallbackExecutionSuspended() {
+    public static boolean isCallbackTimerSuspended() {
         assert isEnabled();
         return suspendedTL.get() != 0;
     }
@@ -403,7 +399,7 @@ void setCounter(int value) {
 
         @Uninterruptible(reason = CALLED_FROM_UNINTERRUPTIBLE_CODE, mayBeInlined = true)
         private boolean isCallbackDisabled() {
-            return isExecuting || isCallbackExecutionSuspended();
+            return isExecuting || isCallbackTimerSuspended();
         }
 
         /**