[GR-55222] Enable LazyDeoptimization by default

PullRequest: graal/19518

Author: Eric Wu

substratevm/CHANGELOG.md

@@ -9,6 +9,7 @@ This changelog summarizes major changes to GraalVM Native Image.
 * (GR-59864) Added JVM version check to the Native Image agent. The agent will abort execution if the JVM major version does not match the version it was built with, and warn if the full JVM version is different.
 * (GR-59135) Verify if hosted options passed to `native-image` exist prior to starting the builder. Provide suggestions how to fix unknown options early on.
 * (GR-61492) The experimental JDWP option is now present in standard GraalVM builds.
+* (GR-55222) Enabled lazy deoptimization of runtime-compiled code, which reduces memory used for deoptimization. Can be turned off with `-H:-LazyDeoptimization`.
 
 ## GraalVM for JDK 24 (Internal Version 24.2.0)
 * (GR-59717) Added `DuringSetupAccess.registerObjectReachabilityHandler` to allow registering a callback that is executed when an object of a specified type is marked as reachable during heap scanning.

substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/code/RuntimeCodeCache.java

@@ -210,7 +210,7 @@ protected void invalidateMethod(CodeInfo info) {
          * Deoptimize all invocations that are on the stack. This performs a stack walk, so all
          * metadata must be intact (even though the method was already marked as non-invokable).
          */
-        Deoptimizer.deoptimizeInRange(CodeInfoAccess.getCodeStart(info), CodeInfoAccess.getCodeEnd(info), false);
+        Deoptimizer.deoptimizeInRange(CodeInfoAccess.getCodeStart(info), CodeInfoAccess.getCodeEnd(info), false, CurrentIsolate.getCurrentThread());
 
         boolean removeNow = !LazyDeoptimization.getValue();
         continueInvalidation(info, removeNow);

substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/deopt/Deoptimizer.java

@@ -279,7 +279,7 @@ public static class Options {
          * {@code gpReturnValue} as an object reference.
          */
         @Option(help = "Enables delayed deoptimization of runtime-compiled code. This slightly enlarges code metadata.")//
-        public static final HostedOptionKey<Boolean> LazyDeoptimization = new HostedOptionKey<>(false);
+        public static final HostedOptionKey<Boolean> LazyDeoptimization = new HostedOptionKey<>(true);
     }
 
     /**
@@ -437,18 +437,22 @@ private void installDeoptimizedFrame(DeoptimizedFrame deoptimizedFrame) {
      */
     @NeverInline("deoptimize must have a separate stack frame")
     public static void deoptimizeAll() {
-        DeoptimizeAllOperation vmOp = new DeoptimizeAllOperation();
+        VMOperation.guaranteeNotInProgress("With a VM Operation in progress, we cannot determine the thread requesting deoptimization.");
+        DeoptimizeAllOperation vmOp = new DeoptimizeAllOperation(CurrentIsolate.getCurrentThread());
         vmOp.enqueue();
     }
 
     private static class DeoptimizeAllOperation extends JavaVMOperation {
-        DeoptimizeAllOperation() {
+        private final IsolateThread requestingThread;
+
+        DeoptimizeAllOperation(IsolateThread requestingThread) {
             super(VMOperationInfos.get(DeoptimizeAllOperation.class, "Deoptimize all", SystemEffect.SAFEPOINT));
+            this.requestingThread = requestingThread;
         }
 
         @Override
         protected void operate() {
-            deoptimizeInRange(Word.zero(), Word.zero(), true);
+            deoptimizeInRange(Word.zero(), Word.zero(), true, requestingThread);
         }
     }
 
@@ -459,42 +463,42 @@ protected void operate() {
      * @param toIp The upper address (excluding) of the method's code.
      */
     @NeverInline("deoptimize must have a separate stack frame")
-    public static void deoptimizeInRange(CodePointer fromIp, CodePointer toIp, boolean deoptAll) {
+    public static void deoptimizeInRange(CodePointer fromIp, CodePointer toIp, boolean deoptAll, IsolateThread requestingThread) {
         VMOperation.guaranteeInProgressAtSafepoint("Deoptimization requires a safepoint.");
-        deoptimizeInRangeOperation(fromIp, toIp, deoptAll);
+        deoptimizeInRangeOperation(fromIp, toIp, deoptAll, requestingThread);
     }
 
     /** Deoptimize a specific method on all thread stacks. */
     @NeverInline("Starting a stack walk in the caller frame. " +
                     "Note that we could start the stack frame also further down the stack, because VM operation frames never need deoptimization. " +
                     "But we don't store stack frame information for the first frame we would need to process.")
-    private static void deoptimizeInRangeOperation(CodePointer fromIp, CodePointer toIp, boolean deoptAll) {
+    private static void deoptimizeInRangeOperation(CodePointer fromIp, CodePointer toIp, boolean deoptAll, IsolateThread requestingThread) {
         VMOperation.guaranteeInProgressAtSafepoint("Deoptimizer.deoptimizeInRangeOperation, but not in VMOperation.");
         /* Handle my own thread specially, because I do not have a JavaFrameAnchor. */
         Pointer sp = KnownIntrinsics.readCallerStackPointer();
 
-        StackFrameVisitor currentThreadDeoptVisitor = getStackFrameVisitor((Pointer) fromIp, (Pointer) toIp, deoptAll, CurrentIsolate.getCurrentThread());
+        StackFrameVisitor currentThreadDeoptVisitor = getStackFrameVisitor((Pointer) fromIp, (Pointer) toIp, deoptAll, CurrentIsolate.getCurrentThread(), requestingThread);
         JavaStackWalker.walkCurrentThread(sp, currentThreadDeoptVisitor);
 
         /* Deoptimize this method on all the other stacks. */
         for (IsolateThread vmThread = VMThreads.firstThread(); vmThread.isNonNull(); vmThread = VMThreads.nextThread(vmThread)) {
             if (vmThread == CurrentIsolate.getCurrentThread()) {
                 continue;
             }
-            StackFrameVisitor deoptVisitor = getStackFrameVisitor((Pointer) fromIp, (Pointer) toIp, deoptAll, vmThread);
+            StackFrameVisitor deoptVisitor = getStackFrameVisitor((Pointer) fromIp, (Pointer) toIp, deoptAll, vmThread, requestingThread);
             JavaStackWalker.walkThread(vmThread, deoptVisitor);
         }
         maybeTestGC();
     }
 
-    private static StackFrameVisitor getStackFrameVisitor(Pointer fromIp, Pointer toIp, boolean deoptAll, IsolateThread targetThread) {
+    private static StackFrameVisitor getStackFrameVisitor(Pointer fromIp, Pointer toIp, boolean deoptAll, IsolateThread targetThread, IsolateThread requestingThread) {
         return new StackFrameVisitor() {
             @Override
             public boolean visitRegularFrame(Pointer frameSp, CodePointer frameIp, CodeInfo codeInfo) {
                 Pointer ip = (Pointer) frameIp;
                 if ((ip.aboveOrEqual(fromIp) && ip.belowThan(toIp)) || deoptAll) {
                     CodeInfoQueryResult queryResult = CodeInfoTable.lookupCodeInfoQueryResult(codeInfo, frameIp);
-                    Deoptimizer deoptimizer = new Deoptimizer(frameSp, queryResult, targetThread);
+                    Deoptimizer deoptimizer = new Deoptimizer(frameSp, queryResult, targetThread, requestingThread);
                     deoptimizer.deoptSourceFrameLazily(frameIp, deoptAll);
                 }
                 return true;
@@ -544,7 +548,8 @@ private static void deoptimizeFrame0(Pointer sp, boolean ignoreNonDeoptimizable,
             return;
         }
 
-        DeoptimizeFrameOperation vmOp = new DeoptimizeFrameOperation(sp, ignoreNonDeoptimizable, speculation, targetThread, deoptEagerly);
+        VMOperation.guaranteeNotInProgress("With a VM Operation in progress, we cannot determine the thread requesting deoptimization.");
+        DeoptimizeFrameOperation vmOp = new DeoptimizeFrameOperation(sp, ignoreNonDeoptimizable, speculation, targetThread, deoptEagerly, CurrentIsolate.getCurrentThread());
         vmOp.enqueue();
     }
 
@@ -553,23 +558,26 @@ private static class DeoptimizeFrameOperation extends JavaVMOperation {
         private final boolean ignoreNonDeoptimizable;
         private final SpeculationReason speculation;
         private final IsolateThread targetThread;
+        private final IsolateThread requestingThread;
         private final boolean deoptEagerly;
 
-        DeoptimizeFrameOperation(Pointer sourceSp, boolean ignoreNonDeoptimizable, SpeculationReason speculation, IsolateThread targetThread, boolean deoptEagerly) {
+        DeoptimizeFrameOperation(Pointer sourceSp, boolean ignoreNonDeoptimizable, SpeculationReason speculation, IsolateThread targetThread, boolean deoptEagerly, IsolateThread requestingThread) {
             super(VMOperationInfos.get(DeoptimizeFrameOperation.class, "Deoptimize frame", SystemEffect.SAFEPOINT));
             this.sourceSp = sourceSp;
             this.ignoreNonDeoptimizable = ignoreNonDeoptimizable;
             this.speculation = speculation;
             this.targetThread = targetThread;
             this.deoptEagerly = deoptEagerly;
+            this.requestingThread = requestingThread;
+
             if (Options.LazyDeoptimization.getValue() && deoptEagerly) {
                 /*
                  * If lazy deoptimization is enabled, eager deoptimization is only used for stack
                  * introspection. We enforce that eager deoptimization cannot be applied to other
                  * threads, because we do not want an eager deoptimization operation to interrupt
                  * and interfere with a thread that is undergoing lazy deoptimization.
                  */
-                assert targetThread == CurrentIsolate.getCurrentThread() : "With lazy deoptimization enabled, eager deoptimization cannot be used to deoptimize other threads";
+                VMError.guarantee(targetThread == requestingThread, "With lazy deoptimization enabled, a thread can request eager deoptimization only on itself.");
             }
         }
 
@@ -587,30 +595,33 @@ protected void operate() {
                 uninstallLazyDeoptStubReturnAddress(sourceSp, targetThread);
                 ip = FrameAccess.singleton().readReturnAddress(targetThread, sourceSp);
             }
-            deoptimizeFrame(targetThread, sourceSp, ip, ignoreNonDeoptimizable, speculation, deoptEagerly);
+            deoptimizeFrame(targetThread, sourceSp, ip, ignoreNonDeoptimizable, speculation, deoptEagerly, requestingThread);
         }
     }
 
     @Uninterruptible(reason = "Prevent the GC from freeing the CodeInfo object.")
-    private static void deoptimizeFrame(IsolateThread targetThread, Pointer sp, CodePointer ip, boolean ignoreNonDeoptimizable, SpeculationReason speculation, boolean deoptEagerly) {
+    private static void deoptimizeFrame(IsolateThread targetThread, Pointer sp, CodePointer ip, boolean ignoreNonDeoptimizable, SpeculationReason speculation, boolean deoptEagerly,
+                    IsolateThread requestingThread) {
         UntetheredCodeInfo untetheredInfo = CodeInfoTable.lookupCodeInfo(ip);
         Object tether = CodeInfoAccess.acquireTether(untetheredInfo);
         try {
             CodeInfo info = CodeInfoAccess.convert(untetheredInfo, tether);
-            deoptimize(targetThread, sp, ip, ignoreNonDeoptimizable, speculation, info, deoptEagerly);
+            deoptimize(targetThread, sp, ip, ignoreNonDeoptimizable, speculation, info, deoptEagerly, requestingThread);
         } finally {
             CodeInfoAccess.releaseTether(untetheredInfo, tether);
         }
     }
 
     @Uninterruptible(reason = "Pass the now protected CodeInfo object to interruptible code.", calleeMustBe = false)
-    private static void deoptimize(IsolateThread targetThread, Pointer sp, CodePointer ip, boolean ignoreNonDeoptimizable, SpeculationReason speculation, CodeInfo info, boolean deoptEagerly) {
-        deoptimize0(targetThread, sp, ip, ignoreNonDeoptimizable, speculation, info, deoptEagerly);
+    private static void deoptimize(IsolateThread targetThread, Pointer sp, CodePointer ip, boolean ignoreNonDeoptimizable, SpeculationReason speculation, CodeInfo info, boolean deoptEagerly,
+                    IsolateThread requestingThread) {
+        deoptimize0(targetThread, sp, ip, ignoreNonDeoptimizable, speculation, info, deoptEagerly, requestingThread);
     }
 
-    private static void deoptimize0(IsolateThread targetThread, Pointer sp, CodePointer ip, boolean ignoreNonDeoptimizable, SpeculationReason speculation, CodeInfo info, boolean deoptEagerly) {
+    private static void deoptimize0(IsolateThread targetThread, Pointer sp, CodePointer ip, boolean ignoreNonDeoptimizable, SpeculationReason speculation, CodeInfo info, boolean deoptEagerly,
+                    IsolateThread requestingThread) {
         CodeInfoQueryResult queryResult = CodeInfoTable.lookupCodeInfoQueryResult(info, ip);
-        Deoptimizer deoptimizer = new Deoptimizer(sp, queryResult, targetThread);
+        Deoptimizer deoptimizer = new Deoptimizer(sp, queryResult, targetThread, requestingThread);
         if (deoptEagerly) {
             DeoptimizedFrame sourceFrame = deoptimizer.deoptSourceFrameEagerly(ip, ignoreNonDeoptimizable);
             if (sourceFrame != null) {
@@ -687,11 +698,13 @@ private static void registerSpeculationFailure(SubstrateInstalledCode installedC
     protected int targetContentSize;
 
     private final DeoptState deoptState;
+    private final IsolateThread requestingThread;
 
-    public Deoptimizer(Pointer sourceSp, CodeInfoQueryResult sourceChunk, IsolateThread targetThread) {
+    public Deoptimizer(Pointer sourceSp, CodeInfoQueryResult sourceChunk, IsolateThread targetThread, IsolateThread requestingThread) {
         VMError.guarantee(sourceChunk != null, "Must not be null.");
         this.sourceChunk = sourceChunk;
         this.deoptState = new DeoptState(sourceSp, targetThread);
+        this.requestingThread = requestingThread;
     }
 
     public DeoptState getDeoptState() {
@@ -889,7 +902,7 @@ private static DeoptimizedFrame constructLazilyDeoptimizedFrameInterruptibly0(Po
         maybeTestGC();
         CodeInfoQueryResult sourceChunk = CodeInfoTable.lookupCodeInfoQueryResult(info, ip);
         maybeTestGC();
-        Deoptimizer deoptimizer = new Deoptimizer(sourceSp, sourceChunk, CurrentIsolate.getCurrentThread());
+        Deoptimizer deoptimizer = new Deoptimizer(sourceSp, sourceChunk, CurrentIsolate.getCurrentThread(), CurrentIsolate.getCurrentThread());
         maybeTestEagerDeoptInLazyDeoptFatalError(deoptimizer, ip);
         DeoptimizedFrame deoptFrame = deoptimizer.doDeoptSourceFrame(ip, true, false);
         if (hasException) {
@@ -1021,17 +1034,14 @@ static int savedBasePointerSize() {
      *
      * @param pc A code address inside the source method (= the method to deoptimize)
      */
-    public void deoptSourceFrameLazily(CodePointer pc, boolean ignoreNonDeoptimizable) {
+    private void deoptSourceFrameLazily(CodePointer pc, boolean ignoreNonDeoptimizable) {
         assert VMOperation.isInProgressAtSafepoint();
         if (!Options.LazyDeoptimization.getValue()) {
             deoptSourceFrameEagerly(pc, ignoreNonDeoptimizable);
             return;
         }
-        if (checkLazyDeoptimized(deoptState.targetThread, deoptState.sourceSp)) {
-            // already lazily deoptimized, nothing to do
-            return;
-        } else if (checkEagerDeoptimized(deoptState.targetThread, deoptState.sourceSp) != null) {
-            // if already eagerly deoptimized, don't lazily deoptimize.
+        if (checkLazyDeoptimized(deoptState.targetThread, deoptState.sourceSp) || checkEagerDeoptimized(deoptState.targetThread, deoptState.sourceSp) != null) {
+            // already deoptimized, nothing to do
             return;
         }
 
@@ -1051,7 +1061,7 @@ public void deoptSourceFrameLazily(CodePointer pc, boolean ignoreNonDeoptimizabl
     /**
      * Deoptimizes a source frame eagerly.
      */
-    public DeoptimizedFrame deoptSourceFrameEagerly(CodePointer pc, boolean ignoreNonDeoptimizable) {
+    private DeoptimizedFrame deoptSourceFrameEagerly(CodePointer pc, boolean ignoreNonDeoptimizable) {
         if (!canBeDeoptimized(sourceChunk.getFrameInfo())) {
             if (ignoreNonDeoptimizable) {
                 return null;
@@ -1065,6 +1075,11 @@ public DeoptimizedFrame deoptSourceFrameEagerly(CodePointer pc, boolean ignoreNo
         return operation.getResult();
     }
 
+    public DeoptimizedFrame deoptimizeEagerly() {
+        VMError.guarantee(requestingThread == CurrentIsolate.getCurrentThread(), "This method should be called by the thread which creates the Deoptimizer.");
+        return deoptSourceFrameEagerly(sourceChunk.getIP(), false);
+    }
+
     @Uninterruptible(reason = "Prevent stack walks from seeing an inconsistent stack.")
     private static void installLazyDeoptStubReturnAddress(boolean returnValueIsObject, Pointer sourceSp, IsolateThread targetThread) {
         assert Options.LazyDeoptimization.getValue();
@@ -1112,7 +1127,7 @@ private static final class EagerDeoptSourceFrameOperation extends JavaVMOperatio
             this.ignoreNonDeoptimizable = ignoreNonDeoptimizable;
             this.result = null;
             if (Options.LazyDeoptimization.getValue()) {
-                assert receiver.deoptState.targetThread == CurrentIsolate.getCurrentThread() : "With lazy deoptimization enabled, eager deoptimization cannot be used to deoptimize other threads";
+                VMError.guarantee(receiver.deoptState.targetThread == receiver.requestingThread, "With lazy deoptimization enabled, a thread can request eager deoptimization only on itself.");
             }
         }
 
@@ -1144,9 +1159,10 @@ private static boolean canBeDeoptimized(FrameInfoQueryResult frame) {
     }
 
     private DeoptimizedFrame doDeoptSourceFrame(CodePointer pc, boolean ignoreNonDeoptimizable, boolean isEagerDeopt) {
-        assert !Options.LazyDeoptimization.getValue() ||
-                        deoptState.targetThread == CurrentIsolate.getCurrentThread() : "with lazy deoptimization, this method may only be called for the current thread";
         assert !isEagerDeopt || VMOperation.isInProgressAtSafepoint() : "eager deopts may only happen at a safepoint";
+        if (Options.LazyDeoptimization.getValue()) {
+            VMError.guarantee(deoptState.targetThread == requestingThread, "With lazy deoptimization enabled, this method may only be called for the requesting thread.");
+        }
 
         DeoptimizedFrame existing = checkEagerDeoptimized(deoptState.targetThread, deoptState.sourceSp);
         if (existing != null) {

substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/stack/SubstrateStackIntrospection.java

@@ -214,7 +214,7 @@ class SubstrateInspectedFrame implements InspectedFrame {
     private Deoptimizer getDeoptimizer() {
         assert virtualFrame == null;
         if (deoptimizer == null) {
-            deoptimizer = new Deoptimizer(sp, codeInfo, CurrentIsolate.getCurrentThread());
+            deoptimizer = new Deoptimizer(sp, codeInfo, CurrentIsolate.getCurrentThread(), CurrentIsolate.getCurrentThread());
         }
         return deoptimizer;
     }
@@ -314,13 +314,13 @@ private VirtualFrame lookupVirtualFrame() {
     public void materializeVirtualObjects(boolean invalidateCode) {
         IsolateThread thread = CurrentIsolate.getCurrentThread();
         if (virtualFrame == null) {
-            DeoptimizedFrame deoptimizedFrame = getDeoptimizer().deoptSourceFrameEagerly(ip, false);
+            DeoptimizedFrame deoptimizedFrame = getDeoptimizer().deoptimizeEagerly();
             assert deoptimizedFrame == Deoptimizer.checkEagerDeoptimized(thread, sp);
         }
 
         if (invalidateCode) {
             /*
-             * Note that we deoptimize the our frame before invalidating the method, with would also
+             * Note that we deoptimize our frame before invalidating the method, which would also
              * deoptimize our frame. But we would deoptimize it with new materialized objects, i.e.,
              * a virtual object that was accessed via a local variable before would now have a
              * different value.