Cleanups.

Author: christianhaeubl

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

@@ -232,7 +232,7 @@ private void initializeHeapInfo(int dynamicHubCount, long offsetOfFirstWritableA
                         getReadOnlyHuge().firstObject, getReadOnlyHuge().lastObject, writableAligned, writableUnaligned, dynamicHubCount);
     }
 
-    protected ImageHeapLayoutInfo createLayoutInfo(long heapStartOffset, long writableBeginOffset) {
+    private ImageHeapLayoutInfo createLayoutInfo(long heapStartOffset, long writableBeginOffset) {
         long writableEnd = getWritableHuge().getStartOffset() + getWritableHuge().getSize();
         long writableSize = writableEnd - writableBeginOffset;
         long imageHeapSize = getReadOnlyHuge().getStartOffset() + getReadOnlyHuge().getSize() - heapStartOffset;
@@ -276,30 +276,30 @@ private static void writeHeader(ImageHeapChunkWriter writer, Chunk previous, Chu
     }
 
     private ChunkedImageHeapPartition getReadOnlyPrimitive() {
-        return getPartitions()[READ_ONLY_PRIMITIVE];
+        return partitions[READ_ONLY_PRIMITIVE];
     }
 
     private ChunkedImageHeapPartition getReadOnlyReference() {
-        return getPartitions()[READ_ONLY_REFERENCE];
+        return partitions[READ_ONLY_REFERENCE];
     }
 
     private ChunkedImageHeapPartition getReadOnlyRelocatable() {
-        return getPartitions()[READ_ONLY_RELOCATABLE];
+        return partitions[READ_ONLY_RELOCATABLE];
     }
 
     private ChunkedImageHeapPartition getWritablePrimitive() {
-        return getPartitions()[WRITABLE_PRIMITIVE];
+        return partitions[WRITABLE_PRIMITIVE];
     }
 
     private ChunkedImageHeapPartition getWritableReference() {
-        return getPartitions()[WRITABLE_REFERENCE];
+        return partitions[WRITABLE_REFERENCE];
     }
 
     private ChunkedImageHeapPartition getWritableHuge() {
-        return getPartitions()[WRITABLE_HUGE];
+        return partitions[WRITABLE_HUGE];
     }
 
     private ChunkedImageHeapPartition getReadOnlyHuge() {
-        return getPartitions()[READ_ONLY_HUGE];
+        return partitions[READ_ONLY_HUGE];
     }
 }

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

@@ -68,7 +68,7 @@ public class ChunkedImageHeapPartition implements ImageHeapPartition {
         this.minimumObjectSize = ConfigurationValues.getObjectLayout().getMinImageHeapObjectSize();
     }
 
-    public void assign(ImageHeapObject obj) {
+    void assign(ImageHeapObject obj) {
         assert obj.getPartition() == this : obj;
         objects.add(obj);
     }
@@ -86,7 +86,7 @@ private void layoutInUnalignedChunks(ChunkedImageHeapAllocator allocator) {
         allocator.alignBetweenChunks(getStartAlignment());
         startOffset = allocator.getPosition();
 
-        for (ImageHeapObject info : getObjects()) { // No need to sort by size
+        for (ImageHeapObject info : objects) { // No need to sort by size
             appendAllocatedObject(info, allocator.allocateUnalignedChunkForObject(info, isWritable()));
         }
 
@@ -106,9 +106,9 @@ private void layoutInAlignedChunks(ChunkedImageHeapAllocator allocator) {
     }
 
     private void allocateObjectsInAlignedChunks(ChunkedImageHeapAllocator allocator) {
-        NavigableMap<Long, Queue<ImageHeapObject>> objects = createSortedObjectsMap(getObjects());
-        while (!objects.isEmpty()) {
-            ImageHeapObject info = dequeueBestFit(objects, allocator.getRemainingBytesInAlignedChunk());
+        NavigableMap<Long, Queue<ImageHeapObject>> sortedObjects = createSortedObjectsMap();
+        while (!sortedObjects.isEmpty()) {
+            ImageHeapObject info = dequeueBestFit(sortedObjects, allocator.getRemainingBytesInAlignedChunk());
             if (info == null) {
                 allocator.startNewAlignedChunk();
             } else {
@@ -133,7 +133,7 @@ private ImageHeapObject dequeueBestFit(NavigableMap<Long, Queue<ImageHeapObject>
         return info;
     }
 
-    private static NavigableMap<Long, Queue<ImageHeapObject>> createSortedObjectsMap(List<ImageHeapObject> objects) {
+    private NavigableMap<Long, Queue<ImageHeapObject>> createSortedObjectsMap() {
         ImageHeapObject[] sorted = objects.toArray(new ImageHeapObject[0]);
         Arrays.sort(sorted, new SizeComparator());
 
@@ -180,39 +180,35 @@ private static Object extractObject(ImageHeapObject info) {
         }
     }
 
-    public List<ImageHeapObject> getObjects() {
-        return objects;
-    }
-
     @Override
     public String getName() {
         return name;
     }
 
-    public boolean isWritable() {
+    boolean isWritable() {
         return writable;
     }
 
     boolean usesUnalignedObjects() {
         return hugeObjects;
     }
 
-    public final int getStartAlignment() {
+    final int getStartAlignment() {
         assert startAlignment >= 0 : "Start alignment not yet assigned";
         return startAlignment;
     }
 
-    public void setStartAlignment(int alignment) {
+    void setStartAlignment(int alignment) {
         assert this.startAlignment == -1 : "Start alignment already assigned: " + this.startAlignment;
         this.startAlignment = alignment;
     }
 
-    public final int getEndAlignment() {
+    final int getEndAlignment() {
         assert endAlignment >= 0 : "End alignment not yet assigned";
         return endAlignment;
     }
 
-    public void setEndAlignment(int endAlignment) {
+    void setEndAlignment(int endAlignment) {
         assert this.endAlignment == -1 : "End alignment already assigned: " + this.endAlignment;
         this.endAlignment = endAlignment;
     }
@@ -223,7 +219,7 @@ public long getStartOffset() {
         return startOffset;
     }
 
-    public long getEndOffset() {
+    long getEndOffset() {
         assert endOffset >= 0 : "End offset not yet set";
         return endOffset;
     }

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

@@ -59,14 +59,14 @@ private HeapVerifier() {
 
     public static boolean verify(Occasion occasion) {
         boolean success = true;
-        success &= verifyChunkedImageHeap();
+        success &= verifyImageHeap();
         success &= verifyYoungGeneration(occasion);
         success &= verifyOldGeneration();
         success &= verifyRememberedSets();
         return success;
     }
 
-    private static boolean verifyChunkedImageHeap() {
+    private static boolean verifyImageHeap() {
         boolean success = true;
         ImageHeapInfo info = HeapImpl.getImageHeapInfo();
         success &= verifyAlignedChunks(null, info.getFirstWritableAlignedChunk());