Cleanups.

Author: christianhaeubl

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

@@ -30,6 +30,7 @@
 
 import com.oracle.svm.core.Isolates;
 import com.oracle.svm.core.heap.GCCause;
+import com.oracle.svm.core.thread.VMOperation;
 import com.oracle.svm.core.util.BasedOnJDKFile;
 import com.oracle.svm.core.util.TimeUtils;
 import com.oracle.svm.core.util.Timer;
@@ -264,45 +265,45 @@ private void computeSurvivorSpaceSizeAndThreshold(boolean isSurvivorOverflow, Un
     }
 
     protected void computeEdenSpaceSize(@SuppressWarnings("unused") boolean completeCollection, @SuppressWarnings("unused") GCCause cause) {
-        UnsignedWord curEdenSize = sizes.getEdenSize();
-        UnsignedWord curPromoSize = sizes.getPromoSize();
+        UnsignedWord curEden = sizes.getEdenSize();
+        UnsignedWord curPromo = sizes.getPromoSize();
 
         boolean expansionReducesCost = true; // general assumption
         if (shouldUseEstimator(youngGenChangeForMinorThroughput, minorGcCost())) {
-            expansionReducesCost = expansionSignificantlyReducesTotalCost(minorCostEstimator, curEdenSize, majorGcCost(), curPromoSize);
+            expansionReducesCost = expansionSignificantlyReducesTotalCost(minorCostEstimator, curEden, majorGcCost(), curPromo);
             /*
              * Note that if the estimator thinks expanding does not lead to significant improvement,
              * shrink so to not get stuck in a supposed optimum and to keep collecting data points.
              */
         }
 
-        UnsignedWord desiredEdenSize = curEdenSize;
+        UnsignedWord desiredEdenSize = curEden;
         if (expansionReducesCost && adjustedMutatorCost() < THROUGHPUT_GOAL && gcCost() > 0) {
             // from adjust_eden_for_throughput():
-            UnsignedWord edenHeapDelta = edenIncrementWithSupplementAlignedUp(curEdenSize);
+            UnsignedWord edenHeapDelta = edenIncrementWithSupplementAlignedUp(curEden);
             double scaleByRatio = minorGcCost() / gcCost();
             assert scaleByRatio >= 0 && scaleByRatio <= 1;
             UnsignedWord scaledEdenHeapDelta = UnsignedUtils.fromDouble(scaleByRatio * UnsignedUtils.toDouble(edenHeapDelta));
 
             desiredEdenSize = alignUp(desiredEdenSize.add(scaledEdenHeapDelta));
-            desiredEdenSize = UnsignedUtils.max(desiredEdenSize, curEdenSize);
+            desiredEdenSize = UnsignedUtils.max(desiredEdenSize, curEden);
             youngGenChangeForMinorThroughput++;
         }
         if (!expansionReducesCost || (USE_ADAPTIVE_SIZE_POLICY_FOOTPRINT_GOAL && youngGenPolicyIsReady && adjustedMutatorCost() >= THROUGHPUT_GOAL)) {
-            UnsignedWord desiredSum = curEdenSize.add(curPromoSize);
-            desiredEdenSize = adjustEdenForFootprint(curEdenSize, desiredSum);
+            UnsignedWord desiredSum = curEden.add(curPromo);
+            desiredEdenSize = adjustEdenForFootprint(curEden, desiredSum);
         }
         assert isAligned(desiredEdenSize);
         desiredEdenSize = minSpaceSize(desiredEdenSize);
 
-        UnsignedWord edenLimit = getMaximumEdenSize();
+        UnsignedWord edenLimit = computeEdenLimit();
         if (desiredEdenSize.aboveThan(edenLimit)) {
             /*
              * If the policy says to get a larger eden but is hitting the limit, don't decrease
              * eden. This can lead to a general drifting down of the eden size. Let the tenuring
              * calculation push more into the old gen.
              */
-            desiredEdenSize = UnsignedUtils.max(edenLimit, curEdenSize);
+            desiredEdenSize = UnsignedUtils.max(edenLimit, curEden);
         }
         sizes.setEdenSize(desiredEdenSize);
     }
@@ -486,40 +487,40 @@ public void onCollectionEnd(boolean completeCollection, GCCause cause) { // {maj
     }
 
     private void computeOldGenSpaceSize(UnsignedWord oldLive) { // compute_old_gen_free_space
-        UnsignedWord curEdenSize = sizes.getEdenSize();
-        UnsignedWord curMaxOldSize = sizes.getMaxOldSize();
-        UnsignedWord curPromoSize = sizes.getPromoSize();
+        UnsignedWord curEden = sizes.getEdenSize();
+        UnsignedWord curPromo = sizes.getPromoSize();
+        UnsignedWord curMaxOld = sizes.getMaxOldSize();
 
         avgOldLive.sample(oldLive);
 
         // NOTE: if maxOldSize shrunk and difference is negative, unsigned conversion results in 0
-        UnsignedWord promoLimit = UnsignedUtils.fromDouble(UnsignedUtils.toDouble(curMaxOldSize) - avgOldLive.getAverage());
-        promoLimit = alignDown(UnsignedUtils.max(curPromoSize, promoLimit));
+        UnsignedWord promoLimit = UnsignedUtils.fromDouble(UnsignedUtils.toDouble(curMaxOld) - avgOldLive.getAverage());
+        promoLimit = alignDown(UnsignedUtils.max(curPromo, promoLimit));
 
         boolean expansionReducesCost = true; // general assumption
         if (shouldUseEstimator(oldGenChangeForMajorThroughput, majorGcCost())) {
-            expansionReducesCost = expansionSignificantlyReducesTotalCost(majorCostEstimator, curPromoSize, minorGcCost(), curEdenSize);
+            expansionReducesCost = expansionSignificantlyReducesTotalCost(majorCostEstimator, curPromo, minorGcCost(), curEden);
             /*
              * Note that if the estimator thinks expanding does not lead to significant improvement,
              * shrink so to not get stuck in a supposed optimum and to keep collecting data points.
              */
         }
 
-        UnsignedWord desiredPromoSize = curPromoSize;
+        UnsignedWord desiredPromoSize = curPromo;
         if (expansionReducesCost && adjustedMutatorCost() < THROUGHPUT_GOAL && gcCost() > 0) {
             // from adjust_promo_for_throughput():
-            UnsignedWord promoHeapDelta = promoIncrementWithSupplementAlignedUp(curPromoSize);
+            UnsignedWord promoHeapDelta = promoIncrementWithSupplementAlignedUp(curPromo);
             double scaleByRatio = majorGcCost() / gcCost();
             assert scaleByRatio >= 0 && scaleByRatio <= 1;
             UnsignedWord scaledPromoHeapDelta = UnsignedUtils.fromDouble(scaleByRatio * UnsignedUtils.toDouble(promoHeapDelta));
 
-            desiredPromoSize = alignUp(curPromoSize.add(scaledPromoHeapDelta));
-            desiredPromoSize = UnsignedUtils.max(desiredPromoSize, curPromoSize);
+            desiredPromoSize = alignUp(curPromo.add(scaledPromoHeapDelta));
+            desiredPromoSize = UnsignedUtils.max(desiredPromoSize, curPromo);
             oldGenChangeForMajorThroughput++;
         }
         if (!expansionReducesCost || (USE_ADAPTIVE_SIZE_POLICY_FOOTPRINT_GOAL && youngGenPolicyIsReady && adjustedMutatorCost() >= THROUGHPUT_GOAL)) {
-            UnsignedWord desiredSum = curEdenSize.add(curPromoSize);
-            desiredPromoSize = adjustPromoForFootprint(curPromoSize, desiredSum);
+            UnsignedWord desiredSum = curEden.add(curPromo);
+            desiredPromoSize = adjustPromoForFootprint(curPromo, desiredSum);
         }
         assert isAligned(desiredPromoSize);
         desiredPromoSize = minSpaceSize(desiredPromoSize);
@@ -530,7 +531,7 @@ private void computeOldGenSpaceSize(UnsignedWord oldLive) { // compute_old_gen_f
         // from PSOldGen::resize
         UnsignedWord desiredFreeSpace = calculatedOldFreeSizeInBytes();
         UnsignedWord desiredOldSize = alignUp(oldLive.add(desiredFreeSpace));
-        sizes.setOldSize(UnsignedUtils.clamp(desiredOldSize, minSpaceSize(), curMaxOldSize));
+        sizes.setOldSize(UnsignedUtils.clamp(desiredOldSize, minSpaceSize(), curMaxOld));
     }
 
     UnsignedWord calculatedOldFreeSizeInBytes() {
@@ -580,6 +581,11 @@ protected boolean shouldUpdateStats(GCCause cause) { // should_update_{eden,prom
         return cause == GenScavengeGCCause.OnAllocation || USE_ADAPTIVE_SIZE_POLICY_WITH_SYSTEM_GC;
     }
 
+    protected UnsignedWord computeEdenLimit() {
+        assert VMOperation.isGCInProgress() : "result wouldn't be consistent otherwise";
+        return alignDown(sizes.getMaxYoungSize().subtract(sizes.getSurvivorSize().multiply(2)));
+    }
+
     private void updateCollectionEndAverages(AdaptiveWeightedAverage costAverage, AdaptivePaddedAverage pauseAverage, ReciprocalLeastSquareFit costEstimator,
                     AdaptiveWeightedAverage intervalSeconds, GCCause cause, long mutatorNanos, long pauseNanos, UnsignedWord sizeBytes) {
         if (shouldUpdateStats(cause)) {

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

@@ -711,6 +711,7 @@ public void optionValueChanged(NotifyGCRuntimeOptionKey<?> key) {
         GCImpl.getPolicy().updateSizeParameters();
     }
 
+    /** For the GC policy, mainly heap-size-related GC options are relevant. */
     private static boolean isIrrelevantForGCPolicy(RuntimeOptionKey<?> key) {
         return key == SubstrateGCOptions.DisableExplicitGC ||
                         key == SubstrateGCOptions.PrintGC ||

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

@@ -142,19 +142,19 @@ protected boolean shouldUpdateStats(GCCause cause) {
     protected void computeEdenSpaceSize(boolean completeCollection, GCCause cause) {
         if (cause == GCCause.HintedGC) {
             if (completeCollection && lastGCCause == GCCause.HintedGC) {
-                UnsignedWord curEdenSize = sizes.getEdenSize();
-                UnsignedWord newEdenSize = UnsignedUtils.max(sizes.getInitialEdenSize(), alignUp(curEdenSize.unsignedDivide(2)));
-                if (curEdenSize.aboveThan(newEdenSize)) {
-                    sizes.setEdenSize(newEdenSize);
+                UnsignedWord curEden = sizes.getEdenSize();
+                UnsignedWord newEden = UnsignedUtils.max(sizes.getInitialEdenSize(), alignUp(curEden.unsignedDivide(2)));
+                if (curEden.aboveThan(newEden)) {
+                    sizes.setEdenSize(newEden);
                 }
             }
         } else {
             UnsignedWord sizeAfter = GCImpl.getChunkBytes();
             if (sizeBefore.notEqual(0) && sizeBefore.belowThan(sizeAfter.multiply(2))) {
-                UnsignedWord curEdenSize = sizes.getEdenSize();
-                UnsignedWord newEdenSize = UnsignedUtils.min(getMaximumEdenSize(), alignUp(curEdenSize.multiply(2)));
-                if (curEdenSize.belowThan(newEdenSize)) {
-                    sizes.setEdenSize(newEdenSize);
+                UnsignedWord curEden = sizes.getEdenSize();
+                UnsignedWord newEden = UnsignedUtils.min(computeEdenLimit(), alignUp(curEden.multiply(2)));
+                if (curEden.belowThan(newEden)) {
+                    sizes.setEdenSize(newEden);
                 }
             } else {
                 super.computeEdenSpaceSize(completeCollection, cause);

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

@@ -0,0 +1,150 @@
+/*
+ * Copyright (c) 2025, 2025, 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.nativeimage.c.struct.RawField;
+import org.graalvm.nativeimage.c.struct.RawStructure;
+import org.graalvm.word.PointerBase;
+import org.graalvm.word.UnsignedWord;
+
+/**
+ * Struct that stores all GC-related sizes. See {@link SizeParameters} for more details on its
+ * lifecycle. When adding fields to this struct, please also change
+ * {@link RawSizeParametersOnStackAccess#initialize} and {@link SizeParameters#matches} accordingly.
+ */
+@RawStructure
+interface RawSizeParameters extends PointerBase {
+    @RawField
+    UnsignedWord getInitialEdenSize();
+
+    @RawField
+    void setInitialEdenSize(UnsignedWord value);
+
+    @RawField
+    UnsignedWord getEdenSize();
+
+    @RawField
+    void setEdenSize(UnsignedWord value);
+
+    @RawField
+    UnsignedWord getMaxEdenSize();
+
+    @RawField
+    void setMaxEdenSize(UnsignedWord value);
+
+    @RawField
+    UnsignedWord getInitialSurvivorSize();
+
+    @RawField
+    void setInitialSurvivorSize(UnsignedWord value);
+
+    @RawField
+    UnsignedWord getSurvivorSize();
+
+    @RawField
+    void setSurvivorSize(UnsignedWord value);
+
+    @RawField
+    UnsignedWord getMaxSurvivorSize();
+
+    @RawField
+    void setMaxSurvivorSize(UnsignedWord value);
+
+    @RawField
+    UnsignedWord getInitialYoungSize();
+
+    @RawField
+    void setInitialYoungSize(UnsignedWord value);
+
+    @RawField
+    UnsignedWord getYoungSize();
+
+    @RawField
+    void setYoungSize(UnsignedWord value);
+
+    @RawField
+    UnsignedWord getMaxYoungSize();
+
+    @RawField
+    void setMaxYoungSize(UnsignedWord value);
+
+    @RawField
+    UnsignedWord getInitialOldSize();
+
+    @RawField
+    void setInitialOldSize(UnsignedWord value);
+
+    @RawField
+    UnsignedWord getOldSize();
+
+    @RawField
+    void setOldSize(UnsignedWord value);
+
+    @RawField
+    UnsignedWord getMaxOldSize();
+
+    @RawField
+    void setMaxOldSize(UnsignedWord value);
+
+    @RawField
+    UnsignedWord getPromoSize();
+
+    @RawField
+    void setPromoSize(UnsignedWord value);
+
+    @RawField
+    UnsignedWord getMinHeapSize();
+
+    @RawField
+    void setMinHeapSize(UnsignedWord value);
+
+    @RawField
+    UnsignedWord getInitialHeapSize();
+
+    @RawField
+    void setInitialHeapSize(UnsignedWord value);
+
+    @RawField
+    UnsignedWord getHeapSize();
+
+    @RawField
+    void setHeapSize(UnsignedWord value);
+
+    @RawField
+    UnsignedWord getMaxHeapSize();
+
+    @RawField
+    void setMaxHeapSize(UnsignedWord value);
+
+    /**
+     * Either points to null or to an obsolete {@link RawSizeParameters} struct that wasn't freed
+     * yet.
+     */
+    @RawField
+    RawSizeParameters getNext();
+
+    @RawField
+    void setNext(RawSizeParameters value);
+}