Promote chunks with pinned objects through survivor spaces.

Author: peter-hofer

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

@@ -921,21 +921,14 @@ private void scanGreyObjects() {
     }
 
     @AlwaysInline("GC performance")
+    @SuppressWarnings("static-method")
     Object promoteObject(Object original, UnsignedWord header) {
         Log trace = Log.noopLog().string("[GCImpl.promoteObject:").string("  original: ").object(original);
-        HeapImpl heap = HeapImpl.getHeapImpl();
 
+        HeapImpl heap = HeapImpl.getHeapImpl();
         boolean isAligned = ObjectHeaderImpl.isAlignedHeader(header);
-        Header<?> originalChunk;
-        Space originalSpace;
-        if (isAligned) {
-            originalChunk = AlignedHeapChunk.getEnclosingChunk(original);
-            originalSpace = HeapChunk.getSpace(originalChunk);
-        } else {
-            assert ObjectHeaderImpl.isUnalignedHeader(header);
-            originalChunk = UnalignedHeapChunk.getEnclosingChunk(original);
-            originalSpace = HeapChunk.getSpace(originalChunk);
-        }
+        Header<?> originalChunk = getChunk(original, isAligned);
+        Space originalSpace = HeapChunk.getSpace(originalChunk);
 
         Object result;
         if (originalSpace.getAge() < HeapParameters.getMaxSurvivorSpaces()) {
@@ -956,17 +949,27 @@ Object promoteObject(Object original, UnsignedWord header) {
         return result;
     }
 
+    private static Header<?> getChunk(Object obj, boolean isAligned) {
+        if (isAligned) {
+            return AlignedHeapChunk.getEnclosingChunk(obj);
+        }
+        assert ObjectHeaderImpl.isUnalignedObject(obj);
+        return UnalignedHeapChunk.getEnclosingChunk(obj);
+    }
+
     private static void promotePinnedObject(PinnedObjectImpl pinned) {
         HeapImpl heap = HeapImpl.getHeapImpl();
-        OldGeneration oldGen = heap.getOldGeneration();
-        /* Find the chunk the object is in, and if necessary, move it to To space. */
         Object referent = pinned.getObject();
         if (referent != null && !heap.isInImageHeap(referent)) {
-            /*
-             * The referent doesn't move, so I can ignore the result of the promotion because I
-             * don't have to update any pointers to it.
-             */
-            oldGen.promoteObjectChunk(referent);
+            boolean isAligned = ObjectHeaderImpl.isAlignedObject(referent);
+            Header<?> originalChunk = getChunk(referent, isAligned);
+            Space originalSpace = HeapChunk.getSpace(originalChunk);
+
+            if (originalSpace.getAge() < HeapParameters.getMaxSurvivorSpaces()) {
+                heap.getYoungGeneration().promoteChunk(originalChunk, isAligned, originalSpace);
+            } else {
+                heap.getOldGeneration().promoteChunk(originalChunk, isAligned, originalSpace);
+            }
         }
     }
 

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

@@ -76,4 +76,12 @@ public String getName() {
      *         was promoted through HeapChunk motion.
      */
     protected abstract Object promoteUnalignedObject(Object original, UnalignedHeapChunk.UnalignedHeader originalChunk, Space originalSpace);
+
+    /**
+     * Promote a HeapChunk from its original space to this Space.
+     *
+     * This turns all the Objects in the chunk from white to grey: the objects are in this Space,
+     * but have not yet had their interior pointers visited.
+     */
+    protected abstract void promoteChunk(HeapChunk.Header<?> originalChunk, boolean isAligned, Space originalSpace);
 }

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

@@ -84,8 +84,15 @@ protected Object promoteUnalignedObject(Object original, UnalignedHeapChunk.Unal
         return original;
     }
 
-    public void promoteObjectChunk(Object obj) {
-        getToSpace().promoteObjectChunk(obj);
+    @Override
+    protected void promoteChunk(HeapChunk.Header<?> originalChunk, boolean isAligned, Space originalSpace) {
+        if (originalSpace.isFromSpace()) {
+            if (isAligned) {
+                getToSpace().promoteAlignedHeapChunk((AlignedHeapChunk.AlignedHeader) originalChunk, originalSpace);
+            } else {
+                getToSpace().promoteUnalignedHeapChunk((UnalignedHeapChunk.UnalignedHeader) originalChunk, originalSpace);
+            }
+        }
     }
 
     void releaseSpaces(ChunkReleaser chunkReleaser) {

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

@@ -203,29 +203,6 @@ private Pointer allocateMemory(UnsignedWord objectSize) {
         return result;
     }
 
-    /**
-     * Promote the HeapChunk containing an Object from its original space to this Space.
-     *
-     * This turns all the Objects in the chunk from white to grey: the objects are in this Space,
-     * but have not yet had their interior pointers visited.
-     */
-    void promoteObjectChunk(Object original) {
-        if (ObjectHeaderImpl.isAlignedObject(original)) {
-            AlignedHeapChunk.AlignedHeader aChunk = AlignedHeapChunk.getEnclosingChunk(original);
-            Space originalSpace = HeapChunk.getSpace(aChunk);
-            if (originalSpace.isFromSpace()) {
-                promoteAlignedHeapChunk(aChunk, originalSpace);
-            }
-        } else {
-            assert ObjectHeaderImpl.isUnalignedObject(original);
-            UnalignedHeapChunk.UnalignedHeader uChunk = UnalignedHeapChunk.getEnclosingChunk(original);
-            Space originalSpace = HeapChunk.getSpace(uChunk);
-            if (originalSpace.isFromSpace()) {
-                promoteUnalignedHeapChunk(uChunk, originalSpace);
-            }
-        }
-    }
-
     public void releaseChunks(ChunkReleaser chunkReleaser) {
         chunkReleaser.add(firstAlignedHeapChunk);
         chunkReleaser.add(firstUnalignedHeapChunk);
@@ -427,7 +404,7 @@ private Object copyAlignedObject(Object originalObj) {
     }
 
     /** Promote an AlignedHeapChunk by moving it to this space. */
-    private void promoteAlignedHeapChunk(AlignedHeapChunk.AlignedHeader chunk, Space originalSpace) {
+    void promoteAlignedHeapChunk(AlignedHeapChunk.AlignedHeader chunk, Space originalSpace) {
         assert this != originalSpace && originalSpace.isFromSpace();
 
         originalSpace.extractAlignedHeapChunk(chunk);

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

@@ -225,7 +225,6 @@ protected Object promoteAlignedObject(Object original, AlignedHeapChunk.AlignedH
         }
 
         assert ObjectHeaderImpl.isAlignedObject(original);
-        assert originalSpace.isEdenSpace() || originalSpace.isSurvivorSpace() : "Should be Eden or survivor.";
         assert originalSpace.getAge() < maxSurvivorSpaces;
 
         int age = originalSpace.getNextAgeForPromotion();
@@ -247,4 +246,19 @@ protected Object promoteUnalignedObject(Object original, UnalignedHeapChunk.Unal
         toSpace.promoteUnalignedHeapChunk(originalChunk, originalSpace);
         return original;
     }
+
+    @Override
+    protected void promoteChunk(HeapChunk.Header<?> originalChunk, boolean isAligned, Space originalSpace) {
+        if (!originalSpace.isFromSpace()) {
+            return;
+        }
+        assert originalSpace.getAge() < maxSurvivorSpaces;
+        int age = originalSpace.getNextAgeForPromotion();
+        Space toSpace = getSurvivorToSpaceAt(age - 1);
+        if (isAligned) {
+            toSpace.promoteAlignedHeapChunk((AlignedHeapChunk.AlignedHeader) originalChunk, originalSpace);
+        } else {
+            toSpace.promoteUnalignedHeapChunk((UnalignedHeapChunk.UnalignedHeader) originalChunk, originalSpace);
+        }
+    }
 }