[GR-59582] Better messages for OutOfMemoryErrors and small cleanups/bugfixes.

PullRequest: graal/19233

Author: christianhaeubl

CENSUS.md

@@ -12,7 +12,7 @@ The project's census with roles as defined in [CONTRIBUTING.md](CONTRIBUTING.md)
 * Compiler
   * [Doug Simon](https://github.com/dougxc)
 * Native Image
-  * [Christian Wimmer](https://github.com/christianwimmer) 
+  * [Christian Wirth](https://github.com/wirthi)
 * Truffle
   * [Christian Humer](https://github.com/chumer)
 * Espresso
@@ -28,4 +28,4 @@ The project's census with roles as defined in [CONTRIBUTING.md](CONTRIBUTING.md)
 
 ### Committers
 
-See https://github.com/oracle/graal/graphs/contributors
+See https://github.com/oracle/graal/graphs/contributors

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

@@ -37,6 +37,7 @@
 import com.oracle.svm.core.heap.PhysicalMemory;
 import com.oracle.svm.core.heap.ReferenceAccess;
 import com.oracle.svm.core.util.TimeUtils;
+import com.oracle.svm.core.util.UnsignedUtils;
 import com.oracle.svm.core.util.VMError;
 
 /** Basic/legacy garbage collection policies. */
@@ -109,10 +110,7 @@ public final UnsignedWord getMaximumHeapSize() {
             int maximumHeapSizePercent = HeapParameters.getMaximumHeapSizePercent();
             /* Do not cache because `-Xmx` option parsing may not have happened yet. */
             UnsignedWord result = physicalMemorySize.unsignedDivide(100).multiply(maximumHeapSizePercent);
-            if (result.belowThan(addressSpaceSize)) {
-                return result;
-            }
-            return addressSpaceSize;
+            return UnsignedUtils.min(result, addressSpaceSize);
         }
 
         @Override

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

@@ -54,6 +54,10 @@
  * list. Memory for unaligned chunks is released immediately.
  */
 final class HeapChunkProvider {
+    /** These {@link OutOfMemoryError}s are only needed for legacy code, see GR-59639. */
+    private static final OutOfMemoryError ALIGNED_OUT_OF_MEMORY_ERROR = new OutOfMemoryError("Could not allocate an aligned heap chunk");
+    private static final OutOfMemoryError UNALIGNED_OUT_OF_MEMORY_ERROR = new OutOfMemoryError("Could not allocate an unaligned heap chunk");
+
     /**
      * The head of the linked list of unused aligned chunks. Chunks are chained using
      * {@link HeapChunk#getNext}.
@@ -78,10 +82,6 @@ public UnsignedWord getBytesInUnusedChunks() {
         return numUnusedAlignedChunks.get().multiply(HeapParameters.getAlignedHeapChunkSize());
     }
 
-    private static final OutOfMemoryError ALIGNED_OUT_OF_MEMORY_ERROR = new OutOfMemoryError("Could not allocate an aligned heap chunk");
-
-    private static final OutOfMemoryError UNALIGNED_OUT_OF_MEMORY_ERROR = new OutOfMemoryError("Could not allocate an unaligned heap chunk");
-
     /** Acquire a new AlignedHeapChunk, either from the free list or from the operating system. */
     @Uninterruptible(reason = "Called from uninterruptible code.", mayBeInlined = true)
     AlignedHeader produceAlignedChunk() {

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

@@ -117,13 +117,13 @@ public static int getHeapChunkHeaderPadding() {
 
     static int getMaximumYoungGenerationSizePercent() {
         int result = SerialAndEpsilonGCOptions.MaximumYoungGenerationSizePercent.getValue();
-        VMError.guarantee((result >= 0) && (result <= 100), "MaximumYoungGenerationSizePercent should be in [0 ..100]");
+        VMError.guarantee(result >= 0 && result <= 100, "MaximumYoungGenerationSizePercent should be in [0..100]");
         return result;
     }
 
     static int getMaximumHeapSizePercent() {
         int result = SerialAndEpsilonGCOptions.MaximumHeapSizePercent.getValue();
-        VMError.guarantee((result >= 0) && (result <= 100), "MaximumHeapSizePercent should be in [0 ..100]");
+        VMError.guarantee(result >= 0 && result <= 100, "MaximumHeapSizePercent should be in [0..100]");
         return result;
     }
 

substratevm/src/com.oracle.svm.core.windows/src/com/oracle/svm/core/windows/WindowsPhysicalMemorySupportImpl.java

@@ -24,10 +24,13 @@
  */
 package com.oracle.svm.core.windows;
 
+import static com.oracle.svm.core.Uninterruptible.CALLED_FROM_UNINTERRUPTIBLE_CODE;
+
 import org.graalvm.nativeimage.c.struct.SizeOf;
 import org.graalvm.word.UnsignedWord;
 import org.graalvm.word.WordFactory;
 
+import com.oracle.svm.core.Uninterruptible;
 import com.oracle.svm.core.feature.AutomaticallyRegisteredImageSingleton;
 import com.oracle.svm.core.graal.stackvalue.UnsafeStackValue;
 import com.oracle.svm.core.heap.PhysicalMemory.PhysicalMemorySupport;
@@ -37,6 +40,7 @@
 class WindowsPhysicalMemorySupportImpl implements PhysicalMemorySupport {
 
     @Override
+    @Uninterruptible(reason = CALLED_FROM_UNINTERRUPTIBLE_CODE, mayBeInlined = true)
     public UnsignedWord size() {
         SysinfoAPI.MEMORYSTATUSEX memStatusEx = UnsafeStackValue.get(SysinfoAPI.MEMORYSTATUSEX.class);
         memStatusEx.set_dwLength(SizeOf.get(SysinfoAPI.MEMORYSTATUSEX.class));

substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/IsolateArgumentParser.java

@@ -553,13 +553,9 @@ private static CCharPointer startsWith(CCharPointer input, CCharPointer prefix)
 
     @Fold
     public static int getOptionIndex(RuntimeOptionKey<?> key) {
-        return singleton().getOptionIndex0(key);
-    }
-
-    @Fold
-    protected int getOptionIndex0(RuntimeOptionKey<?> key) {
-        for (int i = 0; i < getOptionCount(); i++) {
-            if (getOptions()[i] == key) {
+        RuntimeOptionKey<?>[] options = getOptions();
+        for (int i = 0; i < options.length; i++) {
+            if (options[i] == key) {
                 return i;
             }
         }
@@ -568,7 +564,7 @@ protected int getOptionIndex0(RuntimeOptionKey<?> key) {
     }
 
     @Fold
-    public int getParsedArgsSize() {
+    public static int getParsedArgsSize() {
         return Long.BYTES * getOptionCount();
     }
 

substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/SubstrateGCOptions.java

@@ -51,7 +51,7 @@ public class SubstrateGCOptions {
         @Override
         protected void onValueUpdate(EconomicMap<OptionKey<?>, Object> values, Long oldValue, Long newValue) {
             if (!SubstrateUtil.HOSTED) {
-                HeapSizeVerifier.verifyMinHeapSizeAgainstAddressSpace(WordFactory.unsigned(newValue));
+                HeapSizeVerifier.verifyMinHeapSizeAgainstMaxAddressSpaceSize(WordFactory.unsigned(newValue));
             }
             super.onValueUpdate(values, oldValue, newValue);
         }
@@ -62,7 +62,7 @@ protected void onValueUpdate(EconomicMap<OptionKey<?>, Object> values, Long oldV
         @Override
         protected void onValueUpdate(EconomicMap<OptionKey<?>, Object> values, Long oldValue, Long newValue) {
             if (!SubstrateUtil.HOSTED) {
-                HeapSizeVerifier.verifyMaxHeapSizeAgainstAddressSpace(WordFactory.unsigned(newValue));
+                HeapSizeVerifier.verifyMaxHeapSizeAgainstMaxAddressSpaceSize(WordFactory.unsigned(newValue));
             }
             super.onValueUpdate(values, oldValue, newValue);
         }
@@ -73,7 +73,7 @@ protected void onValueUpdate(EconomicMap<OptionKey<?>, Object> values, Long oldV
         @Override
         protected void onValueUpdate(EconomicMap<OptionKey<?>, Object> values, Long oldValue, Long newValue) {
             if (!SubstrateUtil.HOSTED) {
-                HeapSizeVerifier.verifyMaxNewSizeAgainstAddressSpace(WordFactory.unsigned(newValue));
+                HeapSizeVerifier.verifyMaxNewSizeAgainstMaxAddressSpaceSize(WordFactory.unsigned(newValue));
             }
             super.onValueUpdate(values, oldValue, newValue);
         }

substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/code/AbstractRuntimeCodeInstaller.java

@@ -41,7 +41,7 @@ public class AbstractRuntimeCodeInstaller {
     protected Pointer allocateCodeMemory(long size) {
         PointerBase result = RuntimeCodeInfoAccess.allocateCodeMemory(WordFactory.unsigned(size));
         if (result.isNull()) {
-            throw new OutOfMemoryError();
+            throw new OutOfMemoryError("Could not allocate memory for runtime-compiled code.");
         }
         return (Pointer) result;
     }

substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/graal/snippets/CEntryPointSnippets.java

@@ -301,7 +301,7 @@ private static int createIsolate(CEntryPointCreateIsolateParameters providedPara
 
         IsolateArguments arguments = StackValue.get(IsolateArguments.class);
         UnmanagedMemoryUtil.fill((Pointer) arguments, SizeOf.unsigned(IsolateArguments.class), (byte) 0);
-        CLongPointer parsedArgs = StackValue.get(IsolateArgumentParser.singleton().getParsedArgsSize());
+        CLongPointer parsedArgs = StackValue.get(IsolateArgumentParser.getParsedArgsSize());
         arguments.setParsedArgs(parsedArgs);
 
         IsolateArgumentParser.singleton().parse(parameters, arguments);

substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/heap/HeapSizeVerifier.java

@@ -29,63 +29,96 @@
 
 import com.oracle.svm.core.SubstrateGCOptions;
 import com.oracle.svm.core.SubstrateUtil;
-import com.oracle.svm.core.feature.InternalFeature;
 import com.oracle.svm.core.feature.AutomaticallyRegisteredFeature;
+import com.oracle.svm.core.feature.InternalFeature;
 import com.oracle.svm.core.util.UserError;
 import com.oracle.svm.core.util.UserError.UserException;
 
+/**
+ * Verifies that the heap size options are used consistently. Note that some checks seem redundant
+ * at first glance. However, those checks are needed because options don't necessarily have a value.
+ */
 public final class HeapSizeVerifier {
+    private static final String MAX_HEAP_SIZE_NAME = "maximum heap size";
+    private static final String MIN_HEAP_SIZE_NAME = "minimum heap size";
+    private static final String MAX_NEW_SIZE_NAME = "maximum new generation size";
+
+    /**
+     * This method is executed once at build-time and once at runtime-time (after parsing all option
+     * values).
+     */
     public static void verifyHeapOptions() {
-        UnsignedWord minHeapSize = WordFactory.unsigned(SubstrateGCOptions.MinHeapSize.getValue());
+        verifyReservedAddressSpaceSize();
+        verifyMaxHeapSize();
+        verifyMinHeapSize();
+        verifyMaxNewSize();
+    }
+
+    private static void verifyReservedAddressSpaceSize() {
+        UnsignedWord reservedAddressSpaceSize = WordFactory.unsigned(SubstrateGCOptions.ReservedAddressSpaceSize.getValue());
+        verifyAgainstMaxAddressSpaceSize(reservedAddressSpaceSize, "value of the option '" + SubstrateGCOptions.ReservedAddressSpaceSize.getName() + "'");
+    }
+
+    private static void verifyMaxHeapSize() {
         UnsignedWord maxHeapSize = WordFactory.unsigned(SubstrateGCOptions.MaxHeapSize.getValue());
-        UnsignedWord maxNewSize = WordFactory.unsigned(SubstrateGCOptions.MaxNewSize.getValue());
+        verifyMaxHeapSizeAgainstMaxAddressSpaceSize(maxHeapSize);
+        verifyAgainstReservedAddressSpaceSize(maxHeapSize, MAX_HEAP_SIZE_NAME);
+    }
+
+    private static void verifyMinHeapSize() {
+        UnsignedWord minHeapSize = WordFactory.unsigned(SubstrateGCOptions.MinHeapSize.getValue());
+        verifyMinHeapSizeAgainstMaxAddressSpaceSize(minHeapSize);
+        verifyAgainstReservedAddressSpaceSize(minHeapSize, MIN_HEAP_SIZE_NAME);
 
-        verifyMaxHeapSizeAgainstAddressSpace(maxHeapSize);
-        verifyMinHeapSizeAgainstAddressSpace(minHeapSize);
-        verifyMaxNewSizeAgainstAddressSpace(maxNewSize);
-        verifyMinHeapSizeAgainstMaxHeapSize(minHeapSize);
-        verifyMaxNewSizeAgainstMaxHeapSize(maxHeapSize);
+        UnsignedWord maxHeapSize = WordFactory.unsigned(SubstrateGCOptions.MaxHeapSize.getValue());
+        if (maxHeapSize.notEqual(0) && minHeapSize.aboveThan(maxHeapSize)) {
+            throwError(minHeapSize, MIN_HEAP_SIZE_NAME, maxHeapSize, MAX_HEAP_SIZE_NAME);
+        }
     }
 
-    public static void verifyMinHeapSizeAgainstAddressSpace(UnsignedWord minHeapSize) throws UserException {
-        verifyAgainstAddressSpace(minHeapSize, "minimum heap size");
+    private static void verifyMaxNewSize() {
+        UnsignedWord maxNewSize = WordFactory.unsigned(SubstrateGCOptions.MaxNewSize.getValue());
+        verifyMaxNewSizeAgainstMaxAddressSpaceSize(maxNewSize);
+        verifyAgainstReservedAddressSpaceSize(maxNewSize, MAX_NEW_SIZE_NAME);
+
+        UnsignedWord maxHeapSize = WordFactory.unsigned(SubstrateGCOptions.MaxHeapSize.getValue());
+        if (maxHeapSize.notEqual(0) && maxNewSize.aboveThan(maxHeapSize)) {
+            throwError(maxNewSize, MAX_NEW_SIZE_NAME, maxHeapSize, MAX_HEAP_SIZE_NAME);
+        }
     }
 
-    public static void verifyMaxHeapSizeAgainstAddressSpace(UnsignedWord maxHeapSize) throws UserException {
-        verifyAgainstAddressSpace(maxHeapSize, "maximum heap size");
+    public static void verifyMinHeapSizeAgainstMaxAddressSpaceSize(UnsignedWord minHeapSize) throws UserException {
+        verifyAgainstMaxAddressSpaceSize(minHeapSize, MIN_HEAP_SIZE_NAME);
     }
 
-    public static void verifyMaxNewSizeAgainstAddressSpace(UnsignedWord maxNewSize) {
-        verifyAgainstAddressSpace(maxNewSize, "maximum new generation size");
+    public static void verifyMaxHeapSizeAgainstMaxAddressSpaceSize(UnsignedWord maxHeapSize) throws UserException {
+        verifyAgainstMaxAddressSpaceSize(maxHeapSize, MAX_HEAP_SIZE_NAME);
     }
 
-    private static void verifyAgainstAddressSpace(UnsignedWord actualValue, String actualValueName) {
-        UnsignedWord addressSpaceSize = ReferenceAccess.singleton().getAddressSpaceSize();
-        if (actualValue.aboveThan(addressSpaceSize)) {
-            throwError(actualValue, actualValueName, addressSpaceSize, "largest possible address space");
-        }
+    public static void verifyMaxNewSizeAgainstMaxAddressSpaceSize(UnsignedWord maxNewSize) {
+        verifyAgainstMaxAddressSpaceSize(maxNewSize, MAX_NEW_SIZE_NAME);
     }
 
-    private static void verifyMinHeapSizeAgainstMaxHeapSize(UnsignedWord minHeapSize) {
-        UnsignedWord maxHeapSize = WordFactory.unsigned(SubstrateGCOptions.MaxHeapSize.getValue());
-        if (maxHeapSize.notEqual(0) && minHeapSize.aboveThan(maxHeapSize)) {
-            throwError(minHeapSize, "minimum heap size", maxHeapSize, "maximum heap size");
+    private static void verifyAgainstMaxAddressSpaceSize(UnsignedWord actualValue, String actualValueName) {
+        UnsignedWord maxAddressSpaceSize = ReferenceAccess.singleton().getAddressSpaceSize();
+        if (actualValue.aboveThan(maxAddressSpaceSize)) {
+            throwError(actualValue, actualValueName, maxAddressSpaceSize, "largest possible heap address space");
         }
     }
 
-    private static void verifyMaxNewSizeAgainstMaxHeapSize(UnsignedWord maxNewSize) {
-        UnsignedWord maxHeapSize = WordFactory.unsigned(SubstrateGCOptions.MaxHeapSize.getValue());
-        if (maxHeapSize.notEqual(0) && maxNewSize.aboveThan(maxHeapSize)) {
-            throwError(maxNewSize, "maximum new generation size", maxHeapSize, "maximum heap size");
+    private static void verifyAgainstReservedAddressSpaceSize(UnsignedWord actualValue, String actualValueName) {
+        UnsignedWord reservedAddressSpaceSize = WordFactory.unsigned(SubstrateGCOptions.ReservedAddressSpaceSize.getValue());
+        if (reservedAddressSpaceSize.notEqual(0) && actualValue.aboveThan(reservedAddressSpaceSize)) {
+            throwError(actualValue, actualValueName, reservedAddressSpaceSize, "value of the option '" + SubstrateGCOptions.ReservedAddressSpaceSize.getName() + "'");
         }
     }
 
     private static void throwError(UnsignedWord actualValue, String actualValueName, UnsignedWord maxValue, String maxValueName) throws UserException {
         if (SubstrateUtil.HOSTED) {
-            throw UserError.abort("The specified %s (%s) is larger than the %s (%s).", actualValueName, format(actualValue), maxValueName, format(maxValue));
+            throw UserError.abort("The specified %s (%s) must not be larger than the %s (%s).", actualValueName, format(actualValue), maxValueName, format(maxValue));
         } else {
             throw new IllegalArgumentException(
-                            "The specified " + actualValueName + " (" + format(actualValue) + ") is larger than the " + maxValueName + " (" + format(maxValue) + ").");
+                            "The specified " + actualValueName + " (" + format(actualValue) + ") must not be larger than the " + maxValueName + " (" + format(maxValue) + ").");
         }
     }
 
@@ -105,8 +138,7 @@ private static String format(UnsignedWord bytes) {
 class HostedHeapSizeVerifierFeature implements InternalFeature {
     @Override
     public void beforeAnalysis(BeforeAnalysisAccess access) {
-        // At build-time, we can do a reasonable GC-independent verification of all the heap size
-        // settings.
+        /* At build-time, we can do a GC-independent verification of all the heap size settings. */
         HeapSizeVerifier.verifyHeapOptions();
     }
 }