[GR-32382] Add AggressiveShrinkCollectionPolicy for libgraal.

PullRequest: graal/11911

Author: mur47x111

compiler/CHANGELOG.md

@@ -2,6 +2,10 @@
 
 This changelog summarizes newly introduced optimizations that may be relevant to other teams.
 
+## Version 22.3.0
+* (GR-32382): Added a dedicated Native Image GC policy for libgraal that will adjust the eden space aggressively to
+minimize RSS memory usage.
+
 ## Version 22.2.0
 * (GR-23737): New global value numbering optimization for fixed nodes early in the compilation pipeline.
 Early global value numbering and loop invariant code motion is enabled per default.
@@ -11,9 +15,9 @@ Disable early loop invariant code motion with  `-Dgraal.EarlyLICM=false`.
 * (GR-35033): Enable floating and global value numbering of division nodes early on in the compilation pipeline if
   it is known they will not trap.
 * (GR-38405): Compute all unswitchable invariant then pick the most frequent one.  
-* (GR-38857): Deprecated and disabled the JMX `HotSpotGraalRuntime` management bean. Re-enable the `HotSpotGraalRuntime` 
+* (GR-38857): Deprecated and disabled the JMX `HotSpotGraalRuntime` management bean. Re-enable the `HotSpotGraalRuntime`
   management bean with `-Dgraal.LibGraalManagementDelay=0`.
-  
+
 ## Version 22.1.0
 * (GR-36751): Removed the `DuplicateIrreducibleLoops` option. To disable irreducible loop handling, set
   `-Dgraal.MaxDuplicationFactor` to a value less than or equal to 1. For AOT compilations, the effort
@@ -25,7 +29,7 @@ Disable early loop invariant code motion with  `-Dgraal.EarlyLICM=false`.
 ## Version 21.2.0
 * (GR-29770) Loop safepoint elimination: Not only consider 32bit loops for safepoint removal but also 64bit ones
 that iterate in 32bit ranges.
-* (GR-29341) AVX-512 support: Fix EVEX encoding and feature checks for existing instructions and add AVX-512 
+* (GR-29341) AVX-512 support: Fix EVEX encoding and feature checks for existing instructions and add AVX-512
 alternatives.
 * (GR-31162) Do not de-duplicate ValueAnchorNode. As part of this change, there is a new marker interface
 NodeWithIdentity to mark nodes that have identity.
@@ -38,7 +42,7 @@ NodeWithIdentity to mark nodes that have identity.
 
 ## Version 21.1.0
 * (GR-29126) Unify box optimizations in the compiler. Remove `-Dgraal.ReuseOutOfCacheBoxedValues=false`.
-* (GR-28523) Optimize Box nodes: Optimizes box operations by re-using boxed representations 
+* (GR-28523) Optimize Box nodes: Optimizes box operations by re-using boxed representations
 if the value of the boxed primitive is outside of the cache range of the Int/Long/Short/Char caches.
 Box node optimization is enabled per default. Disable it with `-Dgraal.ReuseOutOfCacheBoxedValues=false`.
 * (GR-29373) Eliminate unneeded STORE_LOAD barriers on sequential volatile writes on x86.

compiler/src/org.graalvm.compiler.core/src/org/graalvm/compiler/core/CompilationWrapper.java

@@ -48,6 +48,7 @@
 import org.graalvm.compiler.debug.PathUtilities;
 import org.graalvm.compiler.debug.TTY;
 import org.graalvm.compiler.options.OptionValues;
+import org.graalvm.compiler.serviceprovider.GraalServices;
 
 import jdk.vm.ci.code.BailoutException;
 
@@ -223,6 +224,11 @@ public final T run(DebugContext initialDebug) {
             return performCompilation(initialDebug);
         } catch (Throwable cause) {
             return onCompilationFailure(new Failure(cause, initialDebug));
+        } finally {
+            // Notify the runtime that most objects allocated in the current compilation are dead
+            // and can be reclaimed. If performCompilation includes code installation, the GC pause
+            // should not prolong the time until the compiled code can be executed.
+            GraalServices.notifyLowMemoryPoint(true);
         }
     }
 

compiler/src/org.graalvm.compiler.core/src/org/graalvm/compiler/core/phases/BaseTier.java

@@ -24,11 +24,14 @@
  */
 package org.graalvm.compiler.core.phases;
 
+import org.graalvm.compiler.nodes.StructuredGraph;
 import org.graalvm.compiler.nodes.loop.DefaultLoopPolicies;
 import org.graalvm.compiler.nodes.loop.LoopPolicies;
 import org.graalvm.compiler.options.OptionValues;
+import org.graalvm.compiler.phases.BasePhase;
 import org.graalvm.compiler.phases.PhaseSuite;
 import org.graalvm.compiler.phases.common.CanonicalizerPhase;
+import org.graalvm.compiler.serviceprovider.GraalServices;
 
 public class BaseTier<C> extends PhaseSuite<C> {
 
@@ -39,4 +42,14 @@ public LoopPolicies createLoopPolicies(@SuppressWarnings("unused") OptionValues
     public CanonicalizerPhase createCanonicalizerPhase() {
         return CanonicalizerPhase.create();
     }
+
+    @Override
+    protected void run(StructuredGraph graph, C context) {
+        for (BasePhase<? super C> phase : getPhases()) {
+            // Notify the runtime that most objects allocated in previous HIR phase are dead and can
+            // be reclaimed. This will lower the chance of allocation failure in the next HIR phase.
+            GraalServices.notifyLowMemoryPoint(false);
+            phase.apply(graph, context);
+        }
+    }
 }

compiler/src/org.graalvm.compiler.lir/src/org/graalvm/compiler/lir/phases/LIRPhaseSuite.java

@@ -31,6 +31,7 @@
 
 import org.graalvm.compiler.core.common.util.PhasePlan;
 import org.graalvm.compiler.lir.gen.LIRGenerationResult;
+import org.graalvm.compiler.serviceprovider.GraalServices;
 
 import jdk.vm.ci.code.TargetDescription;
 
@@ -97,6 +98,9 @@ public static <C> boolean findNextPhase(ListIterator<LIRPhase<C>> it, Class<? ex
     @Override
     protected final void run(TargetDescription target, LIRGenerationResult lirGenRes, C context) {
         for (LIRPhase<C> phase : phases) {
+            // Notify the runtime that most objects allocated in previous LIR phase are dead and can
+            // be reclaimed. This will lower the chance of allocation failure in the next LIR phase.
+            GraalServices.notifyLowMemoryPoint(false);
             phase.apply(target, lirGenRes, context);
         }
     }

compiler/src/org.graalvm.compiler.serviceprovider/src/org/graalvm/compiler/serviceprovider/GraalServices.java

@@ -563,4 +563,16 @@ public static Infopoint genImplicitException(int pcOffset, int dispatchOffset, D
             throw new InternalError("Exception when instantiating implicit exception dispatch", e);
         }
     }
+
+    /**
+     * Notifies that the compiler is at a point where memory usage is expected to be relatively low
+     * (e.g., just before/after a compilation). The garbage collector might be able to make use of
+     * such a hint to optimize its performance.
+     *
+     * @param fullGC controls whether the hinted GC should be a full GC.
+     */
+    public static void notifyLowMemoryPoint(@SuppressWarnings("unused") boolean fullGC) {
+        // Substituted by
+        // com.oracle.svm.hotspot.libgraal.Target_org_graalvm_compiler_serviceprovider_GraalServices
+    }
 }

substratevm/src/com.oracle.svm.core.genscavenge/src/com/oracle/svm/core/genscavenge/AbstractCollectionPolicy.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2021, 2021, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2021, 2022, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -26,6 +26,7 @@
 
 import java.util.concurrent.atomic.AtomicBoolean;
 
+import com.oracle.svm.core.heap.GCCause;
 import org.graalvm.compiler.api.replacements.Fold;
 import org.graalvm.compiler.nodes.PauseNode;
 import org.graalvm.nativeimage.Platform;
@@ -94,6 +95,11 @@ public boolean shouldCollectOnAllocation() {
         return edenUsed.aboveOrEqual(edenSize);
     }
 
+    @Override
+    public boolean shouldCollectOnRequest(GCCause cause, boolean fullGC) {
+        return cause == GCCause.JavaLangSystemGC && !SubstrateGCOptions.DisableExplicitGC.getValue();
+    }
+
     @Fold
     static UnsignedWord getAlignment() {
         return HeapParameters.getAlignedHeapChunkSize();
@@ -295,7 +301,7 @@ protected SizeParameters computeSizeParameters(SizeParameters existing) {
         }
         minHeap = UnsignedUtils.clamp(alignUp(minHeap), minAllSpaces, maxHeap);
 
-        UnsignedWord initialHeap = AbstractCollectionPolicy.INITIAL_HEAP_SIZE;
+        UnsignedWord initialHeap = getInitialHeapSize();
         initialHeap = UnsignedUtils.clamp(alignUp(initialHeap), minHeap, maxHeap);
 
         UnsignedWord initialYoung;
@@ -323,6 +329,10 @@ protected SizeParameters computeSizeParameters(SizeParameters existing) {
         return SizeParameters.get(existing, maxHeap, maxYoung, initialHeap, initialEden, initialSurvivor, minHeap);
     }
 
+    protected UnsignedWord getInitialHeapSize() {
+        return AbstractCollectionPolicy.INITIAL_HEAP_SIZE;
+    }
+
     protected static final class SizeParameters {
         final UnsignedWord maxHeapSize;
         final UnsignedWord maxYoungSize;

substratevm/src/com.oracle.svm.core.genscavenge/src/com/oracle/svm/core/genscavenge/AdaptiveCollectionPolicy.java

@@ -42,7 +42,7 @@
  * its base class {@code AdaptiveSizePolicy}. Method and variable names have been kept mostly the
  * same for comparability.
  */
-final class AdaptiveCollectionPolicy extends AbstractCollectionPolicy {
+class AdaptiveCollectionPolicy extends AbstractCollectionPolicy {
 
     /*
      * Constants that can be made options if desirable. These are -XX options in HotSpot, refer to
@@ -237,7 +237,7 @@ private void computeSurvivorSpaceSizeAndThreshold(boolean isSurvivorOverflow, Un
         }
     }
 
-    private void computeEdenSpaceSize() {
+    protected void computeEdenSpaceSize(@SuppressWarnings("unused") boolean completeCollection, @SuppressWarnings("unused") GCCause cause) {
         boolean expansionReducesCost = true; // general assumption
         if (shouldUseEstimator(youngGenChangeForMinorThroughput, minorGcCost())) {
             expansionReducesCost = expansionSignificantlyReducesCost(minorCostEstimator, edenSize);
@@ -441,7 +441,7 @@ public void onCollectionEnd(boolean completeCollection, GCCause cause) { // {maj
             computeSurvivorSpaceSizeAndThreshold(survivorOverflow, sizes.maxSurvivorSize());
         }
         if (shouldUpdateStats(cause)) {
-            computeEdenSpaceSize();
+            computeEdenSpaceSize(completeCollection, cause);
             if (completeCollection) {
                 computeOldGenSpaceSize(oldLive);
             }
@@ -536,11 +536,11 @@ private void decaySupplementalGrowth(boolean completeCollection) {
         }
     }
 
-    private static boolean shouldUpdateStats(GCCause cause) { // should_update_{eden,promo}_stats
+    protected boolean shouldUpdateStats(GCCause cause) { // should_update_{eden,promo}_stats
         return cause == GenScavengeGCCause.OnAllocation || USE_ADAPTIVE_SIZE_POLICY_WITH_SYSTEM_GC;
     }
 
-    private static void updateCollectionEndAverages(AdaptiveWeightedAverage costAverage, AdaptivePaddedAverage pauseAverage, ReciprocalLeastSquareFit costEstimator,
+    private void updateCollectionEndAverages(AdaptiveWeightedAverage costAverage, AdaptivePaddedAverage pauseAverage, ReciprocalLeastSquareFit costEstimator,
                     AdaptiveWeightedAverage intervalSeconds, GCCause cause, long mutatorNanos, long pauseNanos, UnsignedWord sizeBytes) {
         if (shouldUpdateStats(cause)) {
             double cost = 0;

substratevm/src/com.oracle.svm.core.genscavenge/src/com/oracle/svm/core/genscavenge/AggressiveShrinkCollectionPolicy.java

@@ -0,0 +1,134 @@
+/*
+ * Copyright (c) 2022, 2022, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+package com.oracle.svm.core.genscavenge;
+
+import org.graalvm.compiler.options.Option;
+import org.graalvm.word.UnsignedWord;
+import org.graalvm.word.WordFactory;
+
+import com.oracle.svm.core.heap.GCCause;
+import com.oracle.svm.core.option.HostedOptionKey;
+import com.oracle.svm.core.util.UnsignedUtils;
+
+/**
+ * A garbage collection policy that responses to GC hints and aggressively expands/shrinks the eden
+ * space.
+ */
+class AggressiveShrinkCollectionPolicy extends AdaptiveCollectionPolicy {
+
+    public static final class Options {
+        @Option(help = "Ratio of used bytes to total allocated bytes for eden space. Setting it to a smaller value " +
+                        "will trade more triggered hinted GCs for less resident set size.") //
+        public static final HostedOptionKey<Double> UsedEdenProportionThreshold = new HostedOptionKey<>(0.75D);
+        @Option(help = "Soft upper limit for used eden size. The hinted GC will be performed if the used eden size " +
+                        "exceeds this value.") //
+        public static final HostedOptionKey<Integer> ExpectedEdenSize = new HostedOptionKey<>(32 * 1024 * 1024);
+    }
+
+    protected static final UnsignedWord INITIAL_HEAP_SIZE = WordFactory.unsigned(64 * 1024 * 1024);
+    protected static final UnsignedWord FULL_GC_BONUS = WordFactory.unsigned(2 * 1024 * 1024);
+
+    private UnsignedWord sizeBefore = WordFactory.zero();
+    private GCCause lastGCCause = null;
+
+    /**
+     * The hinted GC will be triggered only if the used bytes in eden space is greater than
+     * {@link Options#ExpectedEdenSize}, or if the ratio of used bytes to total allocated bytes of
+     * eden space is above {@link Options#UsedEdenProportionThreshold}. The former condition sets a
+     * soft limit for max used eden space; the latter condition is a trade-off between more hinted
+     * GCs and more used eden space -- for instance, in libgraal it fits multiple typical-size
+     * compilations before actually performing a hinted GC, and the lower ratio is, the resident set
+     * size is lower but the hinted GC is more often.
+     */
+    @Override
+    public boolean shouldCollectOnRequest(GCCause cause, boolean fullGC) {
+        if (cause == GCCause.HintedGC) {
+            guaranteeSizeParametersInitialized();
+            UnsignedWord edenUsedBytes = HeapImpl.getHeapImpl().getAccounting().getEdenUsedBytes();
+            if (fullGC) {
+                // For full GC request, we slightly lower the threshold to increase their
+                // probability to be performed, as they are supposed to be issued at the lowest
+                // memory usage point.
+                edenUsedBytes = edenUsedBytes.add(FULL_GC_BONUS);
+            }
+            return edenUsedBytes.aboveOrEqual(Options.ExpectedEdenSize.getValue()) ||
+                            (UnsignedUtils.toDouble(edenUsedBytes) / UnsignedUtils.toDouble(edenSize) >= Options.UsedEdenProportionThreshold.getValue());
+        }
+        return super.shouldCollectOnRequest(cause, fullGC);
+    }
+
+    @Override
+    protected UnsignedWord getInitialHeapSize() {
+        return INITIAL_HEAP_SIZE;
+    }
+
+    @Override
+    public void onCollectionBegin(boolean completeCollection, long requestingNanoTime) {
+        sizeBefore = GCImpl.getChunkBytes();
+        super.onCollectionBegin(completeCollection, requestingNanoTime);
+    }
+
+    @Override
+    public void onCollectionEnd(boolean completeCollection, GCCause cause) {
+        super.onCollectionEnd(completeCollection, cause);
+        sizeBefore = WordFactory.zero();
+        lastGCCause = cause;
+    }
+
+    @Override
+    protected boolean shouldUpdateStats(GCCause cause) {
+        return cause == GCCause.HintedGC || super.shouldUpdateStats(cause);
+    }
+
+    /**
+     * The adjusting logic are as follows:
+     * 
+     * 1. if we hit hinted GC twice in a row, there is no allocation failure in between. If the eden
+     * space is previously expanded, we will aggressively shrink the eden space to half, such that
+     * the memory footprint will be lower in subsequent execution.
+     *
+     * 2. if a non-hinted GC cannot reclaim half of used bytes, there is likely a session with
+     * continuously high memory consumption (e.g, a huge libgraal compilation). In such case, we
+     * will double the eden space to avoid frequent GCs.
+     */
+    @Override
+    protected void computeEdenSpaceSize(boolean completeCollection, GCCause cause) {
+        if (cause == GCCause.HintedGC) {
+            if (completeCollection && lastGCCause == GCCause.HintedGC) {
+                UnsignedWord newEdenSize = UnsignedUtils.max(sizes.initialEdenSize, alignUp(edenSize.unsignedDivide(2)));
+                if (edenSize.aboveThan(newEdenSize)) {
+                    edenSize = newEdenSize;
+                }
+            }
+        } else {
+            UnsignedWord sizeAfter = GCImpl.getChunkBytes();
+            if (sizeBefore.notEqual(0) && sizeBefore.belowThan(sizeAfter.multiply(2))) {
+                edenSize = alignUp(edenSize.multiply(2));
+            } else {
+                super.computeEdenSpaceSize(completeCollection, cause);
+            }
+        }
+    }
+}

substratevm/src/com.oracle.svm.core.genscavenge/src/com/oracle/svm/core/genscavenge/BasicCollectionPolicies.java

@@ -61,6 +61,11 @@ public boolean shouldCollectOnAllocation() {
             return youngUsed.aboveOrEqual(getMaximumYoungGenerationSize());
         }
 
+        @Override
+        public boolean shouldCollectOnRequest(GCCause cause, boolean fullGC) {
+            return cause == GCCause.JavaLangSystemGC && !SubstrateGCOptions.DisableExplicitGC.getValue();
+        }
+
         @Override
         public UnsignedWord getCurrentHeapCapacity() {
             return getMaximumHeapSize();

substratevm/src/com.oracle.svm.core.genscavenge/src/com/oracle/svm/core/genscavenge/CollectionPolicy.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2014, 2021, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2014, 2022, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -56,6 +56,8 @@ static CollectionPolicy getInitialPolicy() {
         switch (name) {
             case "Adaptive":
                 return new AdaptiveCollectionPolicy();
+            case "AggressiveShrink":
+                return new AggressiveShrinkCollectionPolicy();
             case "Proportionate":
                 return new ProportionateSpacesPolicy();
             case "BySpaceAndTime":
@@ -108,6 +110,13 @@ static boolean shouldCollectYoungGenSeparately(boolean defaultValue) {
      */
     boolean shouldCollectOnAllocation();
 
+    /**
+     * Return true if a user-requested GC (e.g., call to {@link System#gc()} or
+     * {@link org.graalvm.compiler.serviceprovider.GraalServices#notifyLowMemoryPoint(boolean)})
+     * should be performed.
+     */
+    boolean shouldCollectOnRequest(GCCause cause, boolean fullGC);
+
     /**
      * At a safepoint, decides whether to do a complete collection (returning {@code true}) or an
      * incremental collection (returning {@code false}).
@@ -167,4 +176,5 @@ static boolean shouldCollectYoungGenSeparately(boolean defaultValue) {
 
     /** Called before the end of a collection, in the safepoint operation. */
     void onCollectionEnd(boolean completeCollection, GCCause cause);
+
 }