Write first object table during fix-up instead.

Author: peter-hofer

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

@@ -449,7 +449,7 @@ private Object copyAlignedObject(Object originalObj) {
             if (SerialGCOptions.useCompactingOldGen() && GCImpl.getGCImpl().isCompleteCollection()) {
                 /*
                  * In a compacting complete collection, the remembered set bit is set already during
-                 * marking and the first object table is built during planning.
+                 * marking and the first object table is built later during fix-up.
                  */
             } else {
                 /*

substratevm/src/com.oracle.svm.core.genscavenge/src/com/oracle/svm/core/genscavenge/compacting/ObjectMoveInfo.java

@@ -36,8 +36,11 @@
 import com.oracle.svm.core.genscavenge.AlignedHeapChunk;
 import com.oracle.svm.core.genscavenge.HeapChunk;
 import com.oracle.svm.core.genscavenge.ObjectHeaderImpl;
+import com.oracle.svm.core.genscavenge.remset.AlignedChunkRememberedSet;
 import com.oracle.svm.core.genscavenge.remset.BrickTable;
+import com.oracle.svm.core.genscavenge.remset.FirstObjectTable;
 import com.oracle.svm.core.hub.LayoutEncoding;
+import com.oracle.svm.core.util.VMError;
 
 import jdk.graal.compiler.api.replacements.Fold;
 
@@ -164,18 +167,28 @@ static boolean useCompressedLayout() {
      * @see AlignedHeapChunk#walkObjects
      */
     @Uninterruptible(reason = CALLED_FROM_UNINTERRUPTIBLE_CODE, mayBeInlined = true)
-    public static void walkObjects(AlignedHeapChunk.AlignedHeader chunkHeader, ObjectFixupVisitor visitor) {
-        Pointer p = AlignedHeapChunk.getObjectsStart(chunkHeader);
+    public static void walkObjects(AlignedHeapChunk.AlignedHeader chunk, ObjectFixupVisitor visitor) {
+        Pointer p = AlignedHeapChunk.getObjectsStart(chunk);
         do {
-            Pointer nextObjSeq = getNextObjectSeqAddress(p);
-            Pointer objSeqEnd = p.add(getObjectSeqSize(p));
-            assert objSeqEnd.belowOrEqual(HeapChunk.getTopPointer(chunkHeader));
+            Pointer objSeq = p;
+            Pointer nextObjSeq = getNextObjectSeqAddress(objSeq);
+            Pointer objSeqNewAddress = getNewAddress(objSeq);
+            AlignedHeapChunk.AlignedHeader objSeqNewChunk = AlignedHeapChunk.getEnclosingChunkFromObjectPointer(objSeqNewAddress);
+            Pointer objSeqEnd = objSeq.add(getObjectSeqSize(objSeq));
+            assert objSeqEnd.belowOrEqual(HeapChunk.getTopPointer(chunk));
             while (p.notEqual(objSeqEnd)) {
                 assert p.belowThan(objSeqEnd);
                 Object obj = p.toObject();
                 UnsignedWord objSize = LayoutEncoding.getSizeFromObjectInlineInGC(obj);
                 if (!visitor.visitObjectInline(obj)) {
-                    return;
+                    throw VMError.shouldNotReachHereAtRuntime();
+                }
+                if (objSeqNewChunk.getShouldSweepInsteadOfCompact()) {
+                    assert objSeqNewChunk.equal(chunk);
+                } else {
+                    Pointer newAddress = objSeqNewAddress.add(p.subtract(objSeq));
+                    UnsignedWord offset = newAddress.subtract(AlignedHeapChunk.getObjectsStart(objSeqNewChunk));
+                    FirstObjectTable.setTableForObject(AlignedChunkRememberedSet.getFirstObjectTableStart(objSeqNewChunk), offset, offset.add(objSize));
                 }
                 p = p.add(objSize);
             }

substratevm/src/com.oracle.svm.core.genscavenge/src/com/oracle/svm/core/genscavenge/compacting/PlanningVisitor.java

@@ -121,43 +121,12 @@ public boolean visitChunk(AlignedHeapChunk.AlignedHeader chunk) {
                 }
 
                 objSeqSize = objSeqSize.add(objSize);
-                if (!sweeping) {
-                    if (allocPointer.add(objSeqSize).aboveThan(AlignedHeapChunk.getObjectsEnd(allocChunk))) {
-                        /* Out of space, move to the start of the next chunk. */
-                        allocChunk = HeapChunk.getNext(allocChunk);
-                        assert allocChunk.isNonNull();
-                        assert !allocChunk.getShouldSweepInsteadOfCompact();
-                        allocPointer = AlignedHeapChunk.getObjectsStart(allocChunk);
-
-                        /*
-                         * TODO: we should reset the FOT entries we already wrote in the last chunk
-                         * (but they should not be accessed, not even by heap verification)
-                         */
-
-                        /* Visit previous objects in sequence again to write new FOT entries. */
-                        FirstObjectTable.initializeTable(AlignedChunkRememberedSet.getFirstObjectTableStart(allocChunk), AlignedChunkRememberedSet.getFirstObjectTableSize());
-                        Pointer q = objSeq;
-                        while (q.notEqual(p)) {
-                            UnsignedWord offset = q.subtract(objSeq);
-                            UnsignedWord size = LayoutEncoding.getSizeFromObjectInlineInGC(q.toObject());
-                            FirstObjectTable.setTableForObject(AlignedChunkRememberedSet.getFirstObjectTableStart(allocChunk), offset, offset.add(size));
-                            q = q.add(size);
-                        }
-                    }
-
-                    Pointer allocEndOffset = allocPointer.add(objSeqSize).subtract(AlignedHeapChunk.getObjectsStart(allocChunk));
-                    FirstObjectTable.setTableForObject(AlignedChunkRememberedSet.getFirstObjectTableStart(allocChunk), allocEndOffset.subtract(objSize), allocEndOffset);
-                }
 
             } else { // not marked, i.e. not alive and start of a gap of yet unknown size
                 if (objSeqSize.notEqual(0)) { // end of an object sequence
+                    Pointer newAddress = sweeping ? objSeq : allocate(objSeqSize);
+                    ObjectMoveInfo.setNewAddress(objSeq, newAddress);
                     ObjectMoveInfo.setObjectSeqSize(objSeq, objSeqSize);
-                    if (sweeping) {
-                        ObjectMoveInfo.setNewAddress(objSeq, objSeq);
-                    } else {
-                        ObjectMoveInfo.setNewAddress(objSeq, allocPointer);
-                        allocPointer = allocPointer.add(objSeqSize); // ensured enough memory above
-                    }
 
                     objSeqSize = WordFactory.zero();
 
@@ -176,15 +145,10 @@ public boolean visitChunk(AlignedHeapChunk.AlignedHeader chunk) {
 
         if (gapSize.notEqual(0)) {
             chunk.setTopOffset(chunk.getTopOffset().subtract(gapSize));
-
         } else if (objSeqSize.notEqual(0)) {
+            Pointer newAddress = sweeping ? objSeq : allocate(objSeqSize);
+            ObjectMoveInfo.setNewAddress(objSeq, newAddress);
             ObjectMoveInfo.setObjectSeqSize(objSeq, objSeqSize);
-            if (sweeping) {
-                ObjectMoveInfo.setNewAddress(objSeq, objSeq);
-            } else {
-                ObjectMoveInfo.setNewAddress(objSeq, allocPointer);
-                allocPointer = allocPointer.add(objSeqSize); // ensured enough memory above
-            }
         }
 
         if (sweeping) {
@@ -210,4 +174,20 @@ public boolean visitChunk(AlignedHeapChunk.AlignedHeader chunk) {
 
         return true;
     }
+
+    private Pointer allocate(UnsignedWord size) {
+        Pointer p = allocPointer;
+        allocPointer = allocPointer.add(size);
+        if (allocPointer.aboveThan(AlignedHeapChunk.getObjectsEnd(allocChunk))) {
+            allocChunk = HeapChunk.getNext(allocChunk);
+            assert allocChunk.isNonNull();
+            assert !allocChunk.getShouldSweepInsteadOfCompact();
+
+            p = AlignedHeapChunk.getObjectsStart(allocChunk);
+            allocPointer = p.add(size);
+
+            FirstObjectTable.initializeTable(AlignedChunkRememberedSet.getFirstObjectTableStart(allocChunk), AlignedChunkRememberedSet.getFirstObjectTableSize());
+        }
+        return p;
+    }
 }