Remove excess allocations from chunked layouting

Author: ivan-ristovic

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

@@ -26,18 +26,14 @@
 
 import java.util.ArrayDeque;
 import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Comparator;
 import java.util.List;
-import java.util.Map;
 import java.util.NavigableMap;
 import java.util.Queue;
 import java.util.TreeMap;
 
 import com.oracle.svm.core.config.ConfigurationValues;
 import com.oracle.svm.core.image.ImageHeapObject;
 import com.oracle.svm.core.image.ImageHeapPartition;
-import com.oracle.svm.core.meta.SubstrateObjectConstant;
 
 import jdk.graal.compiler.debug.Assertions;
 
@@ -124,63 +120,44 @@ private ImageHeapObject dequeueBestFit(NavigableMap<Long, Queue<ImageHeapObject>
         if (nbytes < minimumObjectSize) {
             return null;
         }
-        Map.Entry<Long, Queue<ImageHeapObject>> entry = sortedObjects.floorEntry(nbytes);
-        if (entry == null) {
+
+        /**
+         * Find a floor entry. We are purposefully not calling {@link TreeMap#getFloorEntry(Object)}
+         * as that method allocates a new entry object. Instead, we fetch the floor key and get the
+         * value for the returned key.
+         */
+        Long floorKey = sortedObjects.floorKey(nbytes);
+        if (floorKey == null) {
             return null;
         }
-        Queue<ImageHeapObject> queue = entry.getValue();
-        ImageHeapObject info = queue.remove();
+        Queue<ImageHeapObject> queue = sortedObjects.get(floorKey);
+        ImageHeapObject obj = queue.remove();
         if (queue.isEmpty()) {
-            sortedObjects.remove(entry.getKey());
+            sortedObjects.remove(floorKey);
         }
-        return info;
+        return obj;
     }
 
     private NavigableMap<Long, Queue<ImageHeapObject>> createSortedObjectsMap() {
-        ImageHeapObject[] sorted = objects.toArray(new ImageHeapObject[0]);
-        Arrays.sort(sorted, new SizeComparator());
-
         NavigableMap<Long, Queue<ImageHeapObject>> map = new TreeMap<>();
-        Queue<ImageHeapObject> currentQueue = null;
-        long currentObjectsSize = -1;
-        for (ImageHeapObject obj : sorted) {
+        for (ImageHeapObject obj : objects) {
             long objSize = obj.getSize();
-            if (objSize != currentObjectsSize) {
-                assert objSize > currentObjectsSize && objSize >= ConfigurationValues.getObjectLayout().getMinImageHeapObjectSize() : Assertions.errorMessage(obj, objSize);
-                currentObjectsSize = objSize;
-                currentQueue = new ArrayDeque<>();
-                map.put(currentObjectsSize, currentQueue);
-            }
-            assert currentQueue != null;
-            currentQueue.add(obj);
+            assert objSize >= ConfigurationValues.getObjectLayout().getMinImageHeapObjectSize() : Assertions.errorMessage(obj, objSize);
+            Queue<ImageHeapObject> q = map.computeIfAbsent(objSize, k -> new ArrayDeque<>());
+            q.add(obj);
         }
         return map;
     }
 
     private void appendAllocatedObject(ImageHeapObject info, long allocationOffset) {
         if (firstObject == null) {
-            firstObject = extractObject(info);
+            firstObject = info.getObjectOrHostedConstant();
         }
         assert info.getPartition() == this;
         long offsetInPartition = allocationOffset - startOffset;
         assert ConfigurationValues.getObjectLayout().isAligned(offsetInPartition) : "start: " + offsetInPartition + " must be aligned.";
         info.setOffsetInPartition(offsetInPartition);
-        lastObject = extractObject(info);
-    }
-
-    private static Object extractObject(ImageHeapObject info) {
-        if (info.getConstant() instanceof SubstrateObjectConstant) {
-            return info.getObject();
-        } else {
-            /*
-             * The info wraps an ImageHeapObject, i.e., a build time representation of an object
-             * that is not backed by a raw hosted object. We set the partition limit to the actual
-             * constant. The constant reflection provider knows that this is a build time value, and
-             * it will not wrap it in a JavaConstant when reading it. This case is not different
-             * from normal objects referencing simulated objects.
-             */
-            return info.getConstant();
-        }
+        lastObject = info.getObjectOrHostedConstant();
     }
 
     @Override
@@ -229,11 +206,4 @@ public boolean isFiller() {
     public String toString() {
         return name;
     }
-
-    private static final class SizeComparator implements Comparator<ImageHeapObject> {
-        @Override
-        public int compare(ImageHeapObject o1, ImageHeapObject o2) {
-            return Long.signum(o1.getSize() - o2.getSize());
-        }
-    }
 }

substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/image/ImageHeap.java

@@ -24,10 +24,8 @@
  */
 package com.oracle.svm.core.image;
 
-import java.util.Collection;
-
 public interface ImageHeap {
-    Collection<? extends ImageHeapObject> getObjects();
+    Iterable<? extends ImageHeapObject> getObjects();
 
     ImageHeapObject addLateToImageHeap(Object object, Object reason);
 

substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/image/ImageHeapObject.java

@@ -29,6 +29,8 @@
 public interface ImageHeapObject {
     long getSize();
 
+    Object getObjectOrHostedConstant();
+
     Object getObject();
 
     Class<?> getObjectClass();

substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/image/NativeImageHeap.java

@@ -901,6 +901,18 @@ public long getSize() {
             return size;
         }
 
+        @Override
+        public Object getObjectOrHostedConstant() {
+            /*
+             * The info wraps an ImageHeapConstant, i.e., a build time representation of an object
+             * that is not backed by a raw hosted object. We set the partition limit to the actual
+             * constant. The constant reflection provider knows that this is a build time value, and
+             * it will not wrap it in a JavaConstant when reading it. This case is not different
+             * from normal objects referencing simulated objects.
+             */
+            return getConstant();
+        }
+
         public int getIdentityHashCode() {
             return identityHashCode;
         }