Do not copy or age young objects in a full GC immediately following an incremental GC.

Author: peter-hofer

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

@@ -231,31 +231,30 @@ private boolean collectImpl(GCCause cause, boolean forceFullGC) {
     private boolean doCollectImpl(GCCause cause, boolean forceFullGC) {
         CommittedMemoryProvider.get().beforeGarbageCollection();
 
-        completeCollection = forceFullGC || policy.shouldCollectCompletely(false);
-        boolean outOfMemory = doCollectOnce(cause);
-        if (!completeCollection && (outOfMemory || policy.shouldCollectCompletely(true))) {
-            completeCollection = true;
-            outOfMemory = doCollectOnce(cause);
+        boolean incremental = HeapParameters.Options.CollectYoungGenerationSeparately.getValue() ||
+                        (!forceFullGC && !policy.shouldCollectCompletely(false));
+        boolean outOfMemory = false;
+        if (incremental) {
+            outOfMemory = doCollectOnce(cause, false, false);
+        }
+        if (!incremental || outOfMemory || forceFullGC || policy.shouldCollectCompletely(true)) {
+            outOfMemory = doCollectOnce(cause, true, incremental);
         }
 
-        CommittedMemoryProvider.get().afterGarbageCollection(completeCollection);
+        CommittedMemoryProvider.get().afterGarbageCollection();
         return outOfMemory;
     }
 
-    private boolean doCollectOnce(GCCause cause) {
+    private boolean doCollectOnce(GCCause cause, boolean complete, boolean followsIncremental) {
+        assert !followsIncremental || complete : "An incremental collection cannot be followed by another incremental collection";
+        completeCollection = complete;
+
         accounting.beforeCollection();
         policy.onCollectionBegin(completeCollection);
 
         Timer collectionTimer = timers.collection.open();
         try {
-            if (completeCollection) {
-                if (HeapParameters.Options.CollectYoungGenerationSeparately.getValue()) {
-                    scavenge(true);
-                }
-                scavenge(false);
-            } else {
-                scavenge(true);
-            }
+            scavenge(!complete, followsIncremental);
         } finally {
             collectionTimer.close();
         }
@@ -487,15 +486,15 @@ public boolean isCompleteCollection() {
     }
 
     /** Scavenge, either from dirty roots or from all roots, and process discovered references. */
-    private void scavenge(boolean fromDirtyRoots) {
+    private void scavenge(boolean incremental, boolean followingIncremental) {
         GreyToBlackObjRefVisitor.Counters counters = greyToBlackObjRefVisitor.openCounters();
         try {
             Timer rootScanTimer = timers.rootScan.open();
             try {
-                if (fromDirtyRoots) {
+                if (incremental) {
                     cheneyScanFromDirtyRoots();
                 } else {
-                    cheneyScanFromRoots();
+                    cheneyScanFromRoots(followingIncremental);
                 }
             } finally {
                 rootScanTimer.close();
@@ -561,7 +560,7 @@ private void cleanRuntimeCodeCache() {
         }
     }
 
-    private void cheneyScanFromRoots() {
+    private void cheneyScanFromRoots(boolean followingIncremental) {
         Timer cheneyScanFromRootsTimer = timers.cheneyScanFromRoots.open();
         try {
             /* Take a snapshot of the heap so that I can visit all the promoted Objects. */
@@ -572,6 +571,15 @@ private void cheneyScanFromRoots() {
              */
             prepareForPromotion();
 
+            if (followingIncremental) {
+                /*
+                 * We just finished an incremental collection, so we will not be able to reclaim any
+                 * young objects and do not need to copy them (and do not want to age or tenure them
+                 * in the process). We still need to scan them for roots into the old generation.
+                 */
+                HeapImpl.getHeapImpl().getYoungGeneration().emptyFromSpacesIntoToSpaces();
+            }
+
             /*
              * Make sure all chunks with pinned objects are in toSpace, and any formerly pinned
              * objects are in fromSpace.

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

@@ -148,6 +148,15 @@ void swapSpaces() {
         assert survivorsToSpacesAccounting.getChunkBytes().equal(0);
     }
 
+    void emptyFromSpacesIntoToSpaces() {
+        assert getEden().isEmpty() && getEden().getChunkBytes().equal(0) : "Eden must be empty.";
+        assert survivorsToSpacesAccounting.getChunkBytes().equal(0) : "Survivor to-spaces must be empty";
+        for (int i = 0; i < maxSurvivorSpaces; i++) {
+            assert getSurvivorToSpaceAt(i).isEmpty() && getSurvivorToSpaceAt(i).getChunkBytes().equal(0) : "Survivor to-space must be empty.";
+            getSurvivorToSpaceAt(i).absorb(getSurvivorFromSpaceAt(i));
+        }
+    }
+
     boolean walkHeapChunks(MemoryWalker.Visitor visitor) {
         if (getEden().walkHeapChunks(visitor)) {
             for (int i = 0; i < maxSurvivorSpaces; i++) {

substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/os/CommittedMemoryProvider.java

@@ -124,10 +124,8 @@ default void beforeGarbageCollection() {
     /**
      * Called by the garbage collector after a collection has ended, as an opportunity to perform
      * lazy operations, sanity checks or clean-ups.
-     *
-     * @param completeCollection Whether the garbage collector has performed a full collection.
      */
-    default void afterGarbageCollection(boolean completeCollection) {
+    default void afterGarbageCollection() {
     }
 
     enum Access {