Attempt to improve memory usage of builder.

Author: fniephaus

substratevm/src/com.oracle.svm.driver/src/com/oracle/svm/driver/MemoryUtil.java

@@ -24,12 +24,21 @@
  */
 package com.oracle.svm.driver;
 
+import java.io.BufferedReader;
+import java.io.InputStreamReader;
 import java.lang.management.ManagementFactory;
+import java.nio.file.Files;
+import java.nio.file.Paths;
 import java.util.ArrayList;
 import java.util.List;
+import java.util.function.Function;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
 
+import com.oracle.svm.core.OS;
 import com.oracle.svm.core.util.ExitStatus;
 import com.oracle.svm.driver.NativeImage.NativeImageError;
+import com.oracle.svm.hosted.NativeImageOptions;
 
 class MemoryUtil {
     private static final long KiB_TO_BYTES = 1024L;
@@ -39,17 +48,22 @@ class MemoryUtil {
     /* Builder needs at least 512MiB for building a helloworld in a reasonable amount of time. */
     private static final long MIN_HEAP_BYTES = 512L * MiB_TO_BYTES;
 
-    /* If free memory is below 8GiB, use 85% of total system memory (e.g., 7GiB * 85% ~ 6GiB). */
-    private static final long DEDICATED_MODE_THRESHOLD = 8L * GiB_TO_BYTES;
+    /* Use 85% of total system memory (e.g., 7GiB * 85% ~ 6GiB) in dedicated mode. */
     private static final double DEDICATED_MODE_TOTAL_MEMORY_RATIO = 0.85D;
 
+    /* If available memory is below 8GiB, fall back to dedicated mode. */
+    private static final long MIN_AVAILABLE_MEMORY_THRESHOLD = 8L * GiB_TO_BYTES;
+
     /*
      * Builder uses at most 32GB to avoid disabling compressed oops (UseCompressedOops).
      * Deliberately use GB (not GiB) to stay well below 32GiB when relative maximum is calculated.
      */
     private static final long MAX_HEAP_BYTES = 32_000_000_000L;
 
-    public static List<String> determineMemoryFlags(NativeImage.HostFlags hostFlags) {
+    // Use another static field because NativeImageOptions are hosted only
+    private static final String BUILDER_RESOURCE_USAGE_TEXT_PROPERTY = NativeImageOptions.BUILDER_RESOURCE_USAGE_TEXT_PROPERTY;
+
+    public static List<String> determineMemoryFlags(NativeImage.HostFlags hostFlags, String resourceUsageValue) {
         List<String> flags = new ArrayList<>();
         if (hostFlags.hasUseParallelGC()) {
             // native image generation is a throughput-oriented task
@@ -61,9 +75,9 @@ public static List<String> determineMemoryFlags(NativeImage.HostFlags hostFlags)
          * -XX:InitialRAMPercentage or -Xms.
          */
         if (hostFlags.hasMaxRAMPercentage()) {
-            flags.add("-XX:MaxRAMPercentage=" + determineReasonableMaxRAMPercentage());
+            flags.addAll(determineReasonableMaxRAMPercentage(resourceUsageValue, value -> "-XX:MaxRAMPercentage=" + value));
         } else if (hostFlags.hasMaximumHeapSizePercent()) {
-            flags.add("-XX:MaximumHeapSizePercent=" + (int) determineReasonableMaxRAMPercentage());
+            flags.addAll(determineReasonableMaxRAMPercentage(resourceUsageValue, value -> "-XX:MaximumHeapSizePercent=" + value.intValue()));
         }
         if (hostFlags.hasGCTimeRatio()) {
             /*
@@ -82,23 +96,46 @@ public static List<String> determineMemoryFlags(NativeImage.HostFlags hostFlags)
     }
 
     /**
-     * Returns a percentage (0.0-100.0) to be used as a value for the -XX:MaxRAMPercentage flag of
-     * the builder process. Prefer free memory over total memory to reduce memory pressure on the
-     * host machine. Note that this method uses OperatingSystemMXBean, which is container-aware.
+     * Returns a percentage (0.0-100.0) to be used as a value for the -XX:MaxRAMPercentage or
+     * -XX:MaximumHeapSizePercent flags of the builder process. Dedicated mode uses a fixed
+     * percentage of total memory and is the default in containers. Shared mode tries to use
+     * available memory to reduce memory pressure on the host machine. Note that this method uses
+     * OperatingSystemMXBean, which is container-aware.
      */
-    private static double determineReasonableMaxRAMPercentage() {
+    private static List<String> determineReasonableMaxRAMPercentage(String resourceUsageValue, Function<Double, String> toMemoryFlag) {
         var osBean = (com.sun.management.OperatingSystemMXBean) ManagementFactory.getOperatingSystemMXBean();
         final double totalMemorySize = osBean.getTotalMemorySize();
-        double reasonableMaxMemorySize = osBean.getFreeMemorySize();
+        final double dedicatedMemorySize = totalMemorySize * DEDICATED_MODE_TOTAL_MEMORY_RATIO;
 
-        if (reasonableMaxMemorySize < DEDICATED_MODE_THRESHOLD) {
-            /*
-             * When free memory is low, for example in memory-constrained environments or when a
-             * good amount of memory is used for caching, use a fixed percentage of total memory
-             * rather than free memory. In containerized environments, builds are expected to run
-             * more or less exclusively (builder + driver + optional Gradle/Maven process).
-             */
-            reasonableMaxMemorySize = totalMemorySize * DEDICATED_MODE_TOTAL_MEMORY_RATIO;
+        String dedicatedModeReason;
+        boolean isDedicatedResourceUsage;
+        boolean isExplicitlySetByUser = resourceUsageValue != null;
+        if (isExplicitlySetByUser) {
+            isDedicatedResourceUsage = resourceUsageValue.equals("dedicated");
+            dedicatedModeReason = "selected explicitly";
+        } else {
+            isDedicatedResourceUsage = isContainerized();
+            dedicatedModeReason = isDedicatedResourceUsage ? "in container" : "not in container";
+        }
+
+        double reasonableMaxMemorySize;
+        if (isDedicatedResourceUsage) {
+            reasonableMaxMemorySize = dedicatedMemorySize;
+        } else {
+            reasonableMaxMemorySize = getAvailableMemorySize();
+            if (!isExplicitlySetByUser && reasonableMaxMemorySize < MIN_AVAILABLE_MEMORY_THRESHOLD) {
+                // fall back to dedicated mode (unless explicitly set by user)
+                isDedicatedResourceUsage = true;
+                reasonableMaxMemorySize = dedicatedMemorySize;
+                dedicatedModeReason = "insufficient available memory";
+            }
+        }
+
+        final String resourceUsageText;
+        if (isDedicatedResourceUsage) {
+            resourceUsageText = "dedicated mode: " + dedicatedModeReason;
+        } else {
+            resourceUsageText = "shared mode: sufficient available memory";
         }
 
         if (reasonableMaxMemorySize < MIN_HEAP_BYTES) {
@@ -111,6 +148,139 @@ private static double determineReasonableMaxRAMPercentage() {
         /* Ensure max memory size does not exceed upper limit. */
         reasonableMaxMemorySize = Math.min(reasonableMaxMemorySize, MAX_HEAP_BYTES);
 
-        return reasonableMaxMemorySize / totalMemorySize * 100;
+        double reasonableMaxRamPercentage = reasonableMaxMemorySize / totalMemorySize * 100;
+
+        return List.of(toMemoryFlag.apply(reasonableMaxRamPercentage), "-D" + BUILDER_RESOURCE_USAGE_TEXT_PROPERTY + "=" + resourceUsageText);
+    }
+
+    private static boolean isContainerized() {
+        if (!OS.LINUX.isCurrent()) {
+            return false;
+        }
+        try {
+            return Files.readAllLines(Paths.get("/proc/self/cgroup")).stream().anyMatch(
+                            s -> s.contains("docker") || s.contains("kubepods") || s.contains("containerd"));
+        } catch (Exception e) {
+        }
+        return false;
+    }
+
+    private static double getAvailableMemorySize() {
+        return switch (OS.getCurrent()) {
+            case LINUX -> getAvailableMemorySizeLinux();
+            case DARWIN -> getAvailableMemorySizeDarwin();
+            case WINDOWS -> getAvailableMemorySizeWindows();
+        };
+    }
+
+    /**
+     * Returns the total amount of available memory in bytes on Linux based on
+     * <code>/proc/meminfo</code>, otherwise <code>-1</code>. Note that this metric is not
+     * container-aware (does not take cgroups into account) and may report available memory of the
+     * host.
+     *
+     * @see <a href=
+     *      "https://github.com/torvalds/linux/blob/865fdb08197e657c59e74a35fa32362b12397f58/mm/page_alloc.c#L5137">page_alloc.c#L5137</a>
+     */
+    private static long getAvailableMemorySizeLinux() {
+        try {
+            String memAvailableLine = Files.readAllLines(Paths.get("/proc/meminfo")).stream().filter(l -> l.startsWith("MemAvailable")).findFirst().orElse("");
+            Matcher m = Pattern.compile("^MemAvailable:\\s+(\\d+) kB").matcher(memAvailableLine);
+            if (m.matches()) {
+                return Long.parseLong(m.group(1)) * KiB_TO_BYTES;
+            }
+        } catch (Exception e) {
+        }
+        return -1;
+    }
+
+    /**
+     * Returns the total amount of available memory in bytes on Darwin based on
+     * <code>vm_stat</code>, otherwise <code>-1</code>.
+     *
+     * @see <a href=
+     *      "https://opensource.apple.com/source/system_cmds/system_cmds-496/vm_stat.tproj/vm_stat.c.auto.html">vm_stat.c</a>
+     */
+    private static long getAvailableMemorySizeDarwin() {
+        try {
+            Process p = Runtime.getRuntime().exec(new String[]{"vm_stat"});
+            try (BufferedReader reader = new BufferedReader(new InputStreamReader(p.getInputStream()))) {
+                String line1 = reader.readLine();
+                if (line1 == null) {
+                    return -1;
+                }
+                Matcher m1 = Pattern.compile("^Mach Virtual Memory Statistics: \\(page size of (\\d+) bytes\\)").matcher(line1);
+                long pageSize = -1;
+                if (m1.matches()) {
+                    pageSize = Long.parseLong(m1.group(1));
+                }
+                if (pageSize <= 0) {
+                    return -1;
+                }
+                String line2 = reader.readLine();
+                Matcher m2 = Pattern.compile("^Pages free:\\s+(\\d+).").matcher(line2);
+                long freePages = -1;
+                if (m2.matches()) {
+                    freePages = Long.parseLong(m2.group(1));
+                }
+                if (freePages <= 0) {
+                    return -1;
+                }
+                String line3 = reader.readLine();
+                if (!line3.startsWith("Pages active")) {
+                    return -1;
+                }
+                String line4 = reader.readLine();
+                Matcher m4 = Pattern.compile("^Pages inactive:\\s+(\\d+).").matcher(line4);
+                long inactivePages = -1;
+                if (m4.matches()) {
+                    inactivePages = Long.parseLong(m4.group(1));
+                }
+                if (inactivePages <= 0) {
+                    return -1;
+                }
+                assert freePages > 0 && inactivePages > 0 && pageSize > 0;
+                return (freePages + inactivePages) * pageSize;
+            } finally {
+                p.waitFor();
+            }
+        } catch (Exception e) {
+        }
+        return -1;
+    }
+
+    /**
+     * Returns the total amount of available memory in bytes on Windows based on <code>wmic</code>,
+     * otherwise <code>-1</code>.
+     *
+     * @see <a href=
+     *      "https://learn.microsoft.com/en-us/windows/win32/cimwin32prov/win32-operatingsystem">Win32_OperatingSystem
+     *      class</a>
+     */
+    private static long getAvailableMemorySizeWindows() {
+        try {
+            Process p = Runtime.getRuntime().exec(new String[]{"cmd.exe", "/c", "wmic", "OS", "get", "FreePhysicalMemory"});
+            try (BufferedReader reader = new BufferedReader(new InputStreamReader(p.getInputStream()))) {
+                String line1 = reader.readLine();
+                if (line1 == null || !line1.startsWith("FreePhysicalMemory")) {
+                    return -1;
+                }
+                String line2 = reader.readLine();
+                if (line2 == null) {
+                    return -1;
+                }
+                String line3 = reader.readLine();
+                if (line3 == null) {
+                    return -1;
+                }
+                Matcher m = Pattern.compile("^(\\d+)\\s+").matcher(line3);
+                if (m.matches()) {
+                    return Long.parseLong(m.group(1)) * KiB_TO_BYTES;
+                }
+            }
+            p.waitFor();
+        } catch (Exception e) {
+        }
+        return -1;
     }
 }

substratevm/src/com.oracle.svm.driver/src/com/oracle/svm/driver/NativeImage.java

@@ -98,6 +98,7 @@
 import com.oracle.svm.driver.metainf.NativeImageMetaInfResourceProcessor;
 import com.oracle.svm.driver.metainf.NativeImageMetaInfWalker;
 import com.oracle.svm.hosted.NativeImageGeneratorRunner;
+import com.oracle.svm.hosted.NativeImageOptions;
 import com.oracle.svm.hosted.NativeImageSystemClassLoader;
 import com.oracle.svm.hosted.util.JDKArgsUtils;
 import com.oracle.svm.util.LogUtils;
@@ -983,7 +984,8 @@ static void ensureDirectoryExists(Path dir) {
 
     private void prepareImageBuildArgs() {
         addImageBuilderJavaArgs("-Xss10m");
-        addImageBuilderJavaArgs(MemoryUtil.determineMemoryFlags(config.getHostFlags()));
+        String resourceUsageValue = getHostedOptionArgumentValue(imageBuilderArgs, oH(NativeImageOptions.BuilderResourceUsage));
+        addImageBuilderJavaArgs(MemoryUtil.determineMemoryFlags(config.getHostFlags(), resourceUsageValue));
 
         /* Prevent JVM that runs the image builder to steal focus. */
         addImageBuilderJavaArgs("-Djava.awt.headless=true");

substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/NativeImageOptions.java

@@ -52,6 +52,7 @@
 import jdk.graal.compiler.options.Option;
 import jdk.graal.compiler.options.OptionKey;
 import jdk.graal.compiler.options.OptionStability;
+import jdk.graal.compiler.options.OptionType;
 import jdk.graal.compiler.options.OptionValues;
 import jdk.graal.compiler.serviceprovider.GraalServices;
 
@@ -185,6 +186,12 @@ public static CStandards getCStandard() {
         }
     }
 
+    @APIOption(name = "resource-usage", extra = true)//
+    @Option(help = "TBD: Either 'shared' or 'dedicated'.", type = OptionType.User)//
+    public static final HostedOptionKey<String> BuilderResourceUsage = new HostedOptionKey<>(null);
+
+    public static final String BUILDER_RESOURCE_USAGE_TEXT_PROPERTY = "svm.builder.resourceUsageText";
+
     /**
      * Configures the number of threads of the common pool (see driver).
      */

substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/ProgressReporter.java

@@ -425,7 +425,7 @@ private void printResourceInfo() {
 
         List<String> inputArguments = ManagementFactory.getRuntimeMXBean().getInputArguments();
         List<String> maxRAMPrecentageValues = inputArguments.stream().filter(arg -> arg.startsWith("-XX:MaxRAMPercentage")).toList();
-        String maxHeapSuffix = "determined at start";
+        String maxHeapSuffix = System.getProperty(NativeImageOptions.BUILDER_RESOURCE_USAGE_TEXT_PROPERTY, "unknown mode");
         if (maxRAMPrecentageValues.size() > 1) { // The driver sets this option once
             maxHeapSuffix = "set via '%s'".formatted(maxRAMPrecentageValues.get(maxRAMPrecentageValues.size() - 1));
         }