[GR-43078] Add more actions to Isolate teardown.

PullRequest: graal/13435

Author: teshull

substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/c/function/CEntryPointActions.java

@@ -62,8 +62,9 @@ private CEntryPointActions() {
      * context. If the thread has already been attached, this does not cause the operation to fail.
      *
      * @param isolate an existing isolate.
-     * @param startedByIsolate Whether the current thread has been launched directly by the isolate,
-     *            which makes the isolate responsible for cleanups when the thread detaches.
+     * @param startedByIsolate Whether the current thread has been launched directly by the isolate
+     *            (as opposed to being an externally started thread), which makes the isolate
+     *            responsible for cleanups when the thread detaches.
      * @param ensureJavaThread when set to true, the method ensures that the {@link Thread} object
      *            for the newly attached thread is created. If the parameter is set to false, a
      *            later call to one of the {@link PlatformThreads#ensureCurrentAssigned} methods

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

@@ -471,21 +471,34 @@ public static int tearDownIsolateSnippet() {
     }
 
     @SubstrateForeignCallTarget(stubCallingConvention = false)
+    @Uninterruptible(reason = "All code executed after VMThreads#tearDown must be uninterruptible")
     private static int tearDownIsolate() {
         try {
-            RuntimeSupport.executeTearDownHooks();
-            if (!PlatformThreads.singleton().tearDown()) {
+            if (!initiateTearDownIsolateInterruptibly()) {
                 return CEntryPointErrors.UNSPECIFIED;
             }
 
             VMThreads.singleton().tearDown();
-            return Isolates.tearDownCurrent();
+            IsolateThread finalThread = CurrentIsolate.getCurrentThread();
+            int result = Isolates.tearDownCurrent();
+            // release the heap memory associated with final isolate thread
+            VMThreads.singleton().freeIsolateThread(finalThread);
+            return result;
         } catch (Throwable t) {
-            logException(t);
-            return CEntryPointErrors.UNCAUGHT_EXCEPTION;
+            return reportException(t);
         }
     }
 
+    @Uninterruptible(reason = "Used as a transition between uninterruptible and interruptible code", calleeMustBe = false)
+    private static boolean initiateTearDownIsolateInterruptibly() {
+        return initiateTearDownIsolateInterruptibly0();
+    }
+
+    private static boolean initiateTearDownIsolateInterruptibly0() {
+        RuntimeSupport.executeTearDownHooks();
+        return PlatformThreads.singleton().tearDown();
+    }
+
     @Snippet(allowMissingProbabilities = true)
     public static int enterByIsolateSnippet(Isolate isolate) {
         int result;

substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/jdk/TimeZoneSubstitutions.java

@@ -37,6 +37,7 @@
 import org.graalvm.nativeimage.ImageSingletons;
 import org.graalvm.nativeimage.PinnedObject;
 import org.graalvm.nativeimage.Platforms;
+import org.graalvm.nativeimage.UnmanagedMemory;
 import org.graalvm.nativeimage.c.type.CCharPointer;
 import org.graalvm.nativeimage.c.type.CTypeConversion;
 import org.graalvm.nativeimage.impl.InternalPlatform;
@@ -97,7 +98,10 @@ private static String getSystemTimeZoneID(String javaHome) {
                 tzMappingsPtr = pinnedContent.addressOfArrayElement(0);
             }
             CCharPointer tzId = LibCHelper.SVM_FindJavaTZmd(tzMappingsPtr, contentLen);
-            return CTypeConversion.toJavaString(tzId);
+            String result = CTypeConversion.toJavaString(tzId);
+            // SVM_FindJavaTZmd returns a newly allocated string
+            UnmanagedMemory.free(tzId);
+            return result;
         } finally {
             if (pinnedContent != null) {
                 pinnedContent.close();

substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/jvmstat/PerfMemory.java

@@ -163,7 +163,9 @@ private void addOverflowMemory(Word result) {
         if (overflowMemory == null) {
             overflowMemory = new Word[8];
         } else if (overflowMemory.length == overflowMemoryPos) {
-            overflowMemory = new Word[overflowMemory.length * 2];
+            Word[] expandedOverflowMemory = new Word[overflowMemory.length * 2];
+            System.arraycopy(overflowMemory, 0, expandedOverflowMemory, 0, overflowMemoryPos);
+            overflowMemory = expandedOverflowMemory;
         }
         overflowMemory[overflowMemoryPos] = result;
         overflowMemoryPos++;

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

@@ -523,7 +523,14 @@ public boolean tearDown() {
             return true;
         }
         /* Tell all the threads that the VM is being torn down. */
-        return tearDownPlatformThreads();
+        boolean result = tearDownPlatformThreads();
+
+        // Detach last thread data
+        Thread thread = currentThread.get(CurrentIsolate.getCurrentThread());
+        if (thread != null) {
+            toTarget(thread).threadData.detach();
+        }
+        return result;
     }
 
     @Uninterruptible(reason = "Thread is detaching and holds the THREAD_MUTEX.")

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

@@ -33,17 +33,20 @@
 import org.graalvm.nativeimage.IsolateThread;
 import org.graalvm.nativeimage.Platform;
 import org.graalvm.nativeimage.Platforms;
+import org.graalvm.nativeimage.StackValue;
+import org.graalvm.nativeimage.c.struct.SizeOf;
+import org.graalvm.word.Pointer;
 import org.graalvm.word.UnsignedWord;
 import org.graalvm.word.WordFactory;
 
 import com.oracle.svm.core.NeverInline;
 import com.oracle.svm.core.SubstrateOptions;
 import com.oracle.svm.core.SubstrateOptions.ConcealedOptions;
 import com.oracle.svm.core.Uninterruptible;
+import com.oracle.svm.core.UnmanagedMemoryUtil;
 import com.oracle.svm.core.feature.AutomaticallyRegisteredImageSingleton;
 import com.oracle.svm.core.heap.Heap;
 import com.oracle.svm.core.heap.RestrictHeapAccess;
-import com.oracle.svm.core.heap.RestrictHeapAccess.Access;
 import com.oracle.svm.core.heap.VMOperationInfos;
 import com.oracle.svm.core.locks.VMCondition;
 import com.oracle.svm.core.locks.VMMutex;
@@ -135,29 +138,41 @@ public static void startVMOperationThread() {
         control.dedicatedVMOperationThread.waitUntilStarted();
     }
 
+    @Uninterruptible(reason = "Executed during teardown after VMThreads#threadExit")
     public static void shutdownAndDetachVMOperationThread() {
         assert useDedicatedVMOperationThread();
 
-        StopVMOperationThread vmOp = new StopVMOperationThread();
-        vmOp.enqueue();
+        int size = SizeOf.get(NativeVMOperationData.class);
+        NativeVMOperationData data = StackValue.get(size);
+        UnmanagedMemoryUtil.fill((Pointer) data, WordFactory.unsigned(size), (byte) 0);
+        NativeStopVMOperationThread operation = get().stopVMOperationThreadOperation;
+        data.setNativeVMOperation(operation);
+        /*
+         * Note we don't call enqueueFromNonJavaThread b/c this thread still has characteristics of
+         * a Java thread even though VMTheads#threadExit has already been called.
+         */
+        get().mainQueues.enqueueUninterruptibly(operation, data);
 
         waitUntilVMOperationThreadDetached();
         assert get().mainQueues.isEmpty();
     }
 
-    private static class StopVMOperationThread extends JavaVMOperation {
-        StopVMOperationThread() {
-            super(VMOperationInfos.get(StopVMOperationThread.class, "Stop VM operation thread", VMOperation.SystemEffect.NONE));
+    private final NativeStopVMOperationThread stopVMOperationThreadOperation = new NativeStopVMOperationThread();
+
+    private static class NativeStopVMOperationThread extends NativeVMOperation {
+        NativeStopVMOperationThread() {
+            super(VMOperationInfos.get(NativeStopVMOperationThread.class, "Stop VM operation thread", VMOperation.SystemEffect.NONE));
         }
 
         @Override
-        protected void operate() {
-            VMOperationControl.get().dedicatedVMOperationThread.shutdown();
+        @Uninterruptible(reason = "Executed during teardown after VMThreads#exit")
+        protected void operate(NativeVMOperationData data) {
+            VMOperationControl.get().dedicatedVMOperationThread.stopped = true;
         }
     }
 
-    @RestrictHeapAccess(access = Access.NO_ALLOCATION, reason = "Called during teardown")
     @NeverInline("Must not be inlined in a caller that has an exception handler: We only support InvokeNode and not InvokeWithExceptionNode between a CFunctionPrologueNode and CFunctionEpilogueNode.")
+    @Uninterruptible(reason = "Executed during teardown after VMThreads#threadExit")
     private static void waitUntilVMOperationThreadDetached() {
         CFunctionPrologueNode.cFunctionPrologue(StatusSupport.STATUS_IN_NATIVE);
         waitUntilVMOperationThreadDetachedInNative();
@@ -433,11 +448,6 @@ public IsolateThread getIsolateThread() {
         public boolean isRunning() {
             return isolateThread.isNonNull() && !stopped;
         }
-
-        void shutdown() {
-            VMOperation.guaranteeInProgress("must only be called from a VM operation");
-            this.stopped = true;
-        }
     }
 
     private static final class WorkQueues {
@@ -468,6 +478,7 @@ private static final class WorkQueues {
             this.operationFinished = createCondition();
         }
 
+        @Uninterruptible(reason = "Called from uninterruptible code.", mayBeInlined = true)
         boolean isEmpty() {
             return nativeNonSafepointOperations.isEmpty() && nativeSafepointOperations.isEmpty() && javaNonSafepointOperations.isEmpty() && javaSafepointOperations.isEmpty();
         }
@@ -721,6 +732,7 @@ protected abstract static class AllocationFreeQueue<T> {
             this.name = name;
         }
 
+        @Uninterruptible(reason = "Called from uninterruptible code.", mayBeInlined = true)
         abstract boolean isEmpty();
 
         abstract void push(T element);
@@ -745,6 +757,7 @@ protected abstract static class JavaAllocationFreeQueue<T extends JavaAllocation
         }
 
         @Override
+        @Uninterruptible(reason = "Called from uninterruptible code.", mayBeInlined = true)
         public boolean isEmpty() {
             return head == null;
         }
@@ -815,6 +828,7 @@ protected static class NativeVMOperationQueue extends AllocationFreeQueue<Native
         }
 
         @Override
+        @Uninterruptible(reason = "Called from uninterruptible code.", mayBeInlined = true)
         public boolean isEmpty() {
             return head.isNull();
         }

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

@@ -153,6 +153,11 @@ public static VMThreads singleton() {
      * used for the stack overflow check.
      */
     public static final FastThreadLocalWord<UnsignedWord> StackEnd = FastThreadLocalFactory.createWord("VMThreads.StackEnd");
+    /**
+     * Tracks whether this thread was started by the current isolate or if it was an externally
+     * started thread which was attached to the isolate. This distinction determines the teardown
+     * process for the thread.
+     */
     private static final FastThreadLocalBytes<Pointer> StartedByCurrentIsolate = FastThreadLocalFactory.createBytes(() -> 1, "VMThreads.StartedByCurrentIsolate");
 
     private static final int STATE_UNINITIALIZED = 1;
@@ -448,12 +453,20 @@ private static void removeFromThreadList(IsolateThread thread) {
         }
     }
 
+    @Uninterruptible(reason = "Only uninterruptible code may be executed after VMThreads#threadExit.")
     public void tearDown() {
         ThreadingSupportImpl.pauseRecurringCallback("Execution of arbitrary code is prohibited during the last teardown steps.");
+
+        IsolateThread curThread = CurrentIsolate.getCurrentThread();
+        VMThreads.threadExit(curThread);
+        /* Only uninterruptible code may be executed from now on. */
+        PlatformThreads.afterThreadExit(curThread);
+
         if (VMOperationControl.useDedicatedVMOperationThread()) {
             VMOperationControl.shutdownAndDetachVMOperationThread();
         }
-        // At this point, it is guaranteed that all other threads were detached.
+
+        /* At this point, it is guaranteed that all other threads were detached. */
         IsolateListenerSupport.singleton().onIsolateTeardown();
         waitUntilLastOsThreadExited();
     }
@@ -486,7 +499,7 @@ private static void threadExit(IsolateThread thread) {
      * following tear-down.
      */
     public static void detachAllThreadsExceptCurrentWithoutCleanupForTearDown() {
-        DetachAllThreadsExceptCurrentOperation vmOp = new DetachAllThreadsExceptCurrentOperation();
+        DetachAllExternallyStartedThreadsExceptCurrentOperation vmOp = new DetachAllExternallyStartedThreadsExceptCurrentOperation();
         vmOp.enqueue();
     }
 
@@ -622,9 +635,9 @@ public static boolean printLocationInfo(Log log, UnsignedWord value, boolean all
         return false;
     }
 
-    private static class DetachAllThreadsExceptCurrentOperation extends JavaVMOperation {
-        DetachAllThreadsExceptCurrentOperation() {
-            super(VMOperationInfos.get(DetachAllThreadsExceptCurrentOperation.class, "Detach all threads except current", SystemEffect.SAFEPOINT));
+    private static class DetachAllExternallyStartedThreadsExceptCurrentOperation extends JavaVMOperation {
+        DetachAllExternallyStartedThreadsExceptCurrentOperation() {
+            super(VMOperationInfos.get(DetachAllExternallyStartedThreadsExceptCurrentOperation.class, "Detach all externally started threads except current", SystemEffect.SAFEPOINT));
         }
 
         @Override