MaxRAM Obsolete

Author: jsikstro

src/hotspot/share/gc/shared/gc_globals.hpp

@@ -269,18 +269,13 @@
   product(bool, AlwaysActAsServerClassMachine, false,                       \
           "(Deprecated) Always act like a server-class machine")            \
                                                                             \
-  product(uint64_t, MaxRAM, 0,                                              \
-          "(Deprecated) Real memory size (in bytes) used to set maximum "   \
-          "heap size")                                                      \
-          range(0, 0XFFFFFFFFFFFFFFFF)                                      \
-                                                                            \
   product(bool, AggressiveHeap, false,                                      \
           "(Deprecated) Optimize heap options for long-running memory "     \
           "intensive apps")                                                 \
                                                                             \
   product(size_t, ErgoHeapSizeLimit, 0,                                     \
           "Maximum ergonomically set heap size (in bytes); zero means use " \
-          "MaxRAM * MaxRAMPercentage / 100")                                \
+          "(System RAM) * MaxRAMPercentage / 100")                          \
           range(0, max_uintx)                                               \
                                                                             \
   product(double, MaxRAMPercentage, 25.0,                                   \

src/hotspot/share/runtime/arguments.cpp

@@ -66,6 +66,7 @@
 #include "utilities/align.hpp"
 #include "utilities/debug.hpp"
 #include "utilities/defaultStream.hpp"
+#include "utilities/globalDefinitions.hpp"
 #include "utilities/macros.hpp"
 #include "utilities/parseInteger.hpp"
 #include "utilities/powerOfTwo.hpp"
@@ -538,7 +539,6 @@ static SpecialFlag const special_jvm_flags[] = {
 #endif
   { "ParallelRefProcEnabled",       JDK_Version::jdk(26),  JDK_Version::jdk(27), JDK_Version::jdk(28) },
   { "ParallelRefProcBalancingEnabled", JDK_Version::jdk(26),  JDK_Version::jdk(27), JDK_Version::jdk(28) },
-  { "MaxRAM",                       JDK_Version::jdk(26),  JDK_Version::jdk(27), JDK_Version::jdk(28) },
   { "AggressiveHeap",               JDK_Version::jdk(26),  JDK_Version::jdk(27), JDK_Version::jdk(28) },
   { "NeverActAsServerClassMachine", JDK_Version::jdk(26),  JDK_Version::jdk(27), JDK_Version::jdk(28) },
   { "AlwaysActAsServerClassMachine", JDK_Version::jdk(26),  JDK_Version::jdk(27), JDK_Version::jdk(28) },
@@ -553,6 +553,7 @@ static SpecialFlag const special_jvm_flags[] = {
 #endif
 
   { "PSChunkLargeArrays",           JDK_Version::jdk(26),  JDK_Version::jdk(27), JDK_Version::jdk(28) },
+  { "MaxRAM",                       JDK_Version::jdk(26),  JDK_Version::jdk(27), JDK_Version::jdk(28) },
 
 #ifdef ASSERT
   { "DummyObsoleteTestFlag",        JDK_Version::undefined(), JDK_Version::jdk(18), JDK_Version::undefined() },
@@ -1510,25 +1511,19 @@ void Arguments::set_heap_size() {
   // Check if the user has configured any limit on the amount of RAM we may use.
   bool has_ram_limit = !FLAG_IS_DEFAULT(MaxRAMPercentage) ||
                        !FLAG_IS_DEFAULT(MinRAMPercentage) ||
-                       !FLAG_IS_DEFAULT(InitialRAMPercentage) ||
-                       !FLAG_IS_DEFAULT(MaxRAM);
+                       !FLAG_IS_DEFAULT(InitialRAMPercentage);
 
-  if (FLAG_IS_DEFAULT(MaxRAM)) {
-    if (CompilerConfig::should_set_client_emulation_mode_flags()) {
-      // Limit the available memory if client emulation mode is enabled.
-      FLAG_SET_ERGO(MaxRAM, 1ULL*G);
-    } else {
-      // Use the available physical memory on the system.
-      FLAG_SET_ERGO(MaxRAM, os::physical_memory());
-    }
-  }
+  // Limit the available memory if client emulation mode is enabled.
+  const size_t phys_mem = CompilerConfig::should_set_client_emulation_mode_flags()
+      ? 1ULL*G
+      : os::physical_memory();
 
   // If the maximum heap size has not been set with -Xmx, then set it as
   // fraction of the size of physical memory, respecting the maximum and
   // minimum sizes of the heap.
   if (FLAG_IS_DEFAULT(MaxHeapSize)) {
-    uint64_t min_memory = (uint64_t)(((double)MaxRAM * MinRAMPercentage) / 100);
-    uint64_t max_memory = (uint64_t)(((double)MaxRAM * MaxRAMPercentage) / 100);
+    uint64_t min_memory = (uint64_t)(((double)phys_mem * MinRAMPercentage) / 100);
+    uint64_t max_memory = (uint64_t)(((double)phys_mem * MaxRAMPercentage) / 100);
 
     const size_t reasonable_min = clamp_by_size_t_max(min_memory);
     size_t reasonable_max = clamp_by_size_t_max(max_memory);
@@ -1615,7 +1610,7 @@ void Arguments::set_heap_size() {
     reasonable_minimum = limit_heap_by_allocatable_memory(reasonable_minimum);
 
     if (InitialHeapSize == 0) {
-      uint64_t initial_memory = (uint64_t)(((double)MaxRAM * InitialRAMPercentage) / 100);
+      uint64_t initial_memory = (uint64_t)(((double)phys_mem * InitialRAMPercentage) / 100);
       size_t reasonable_initial = clamp_by_size_t_max(initial_memory);
       reasonable_initial = limit_heap_by_allocatable_memory(reasonable_initial);
 

src/java.base/share/man/java.md

@@ -2454,8 +2454,8 @@ Java HotSpot VM.
 
 [`-XX:InitialRAMPercentage=`]{#-XX_InitialRAMPercentage}*percent*
 :   Sets the initial amount of memory that the JVM will use for the Java heap
-    before applying ergonomics heuristics as a percentage of the maximum amount
-    determined as described in the `-XX:MaxRAM` option.
+    before applying ergonomics heuristics as a percentage of the available memory
+    to the JVM process.
 
     The following example shows how to set the percentage of the initial
     amount of memory used for the Java heap:
@@ -2575,9 +2575,8 @@ Java HotSpot VM.
 
 [`-XX:MaxRAMPercentage=`]{#-XX_MaxRAMPercentage}*percent*
 :   Sets the maximum amount of memory that the JVM may use for the Java heap
-    before applying ergonomics heuristics as a percentage of the maximum amount
-    determined as described in the `-XX:MaxRAM` option. The default value is 25
-    percent.
+    before applying ergonomics heuristics as a percentage of the available
+    memory to the JVM process. The default value is 25 percent.
 
     Specifying this option disables automatic use of compressed oops if
     the combined result of this and other options influencing the maximum amount
@@ -2591,9 +2590,9 @@ Java HotSpot VM.
 
 [`-XX:MinRAMPercentage=`]{#-XX_MinRAMPercentage}*percent*
 :   Sets the maximum amount of memory that the JVM may use for the Java heap
-    before applying ergonomics heuristics as a percentage of the maximum amount
-    determined as described in the `-XX:MaxRAM` option for small heaps. A small
-    heap is a heap of approximately 125 MB. The default value is 50 percent.
+    before applying ergonomics heuristics as a percentage of the available memory
+    to the JVM process for small heaps. A small heap is a heap of approximately
+    125 MB. The default value is 50 percent.
 
     The following example shows how to set the percentage of the maximum amount
     of memory used for the Java heap for small heaps:
@@ -2939,25 +2938,6 @@ they're used.
     (`-XX:+UseParallelGC` or `-XX:+UseG1GC`). Other collectors employing multiple
     threads always perform reference processing in parallel.
 
-[`-XX:MaxRAM=`]{#-XX_MaxRAM}*size*
-:   Sets the maximum amount of memory that the JVM may use for the Java heap
-    before applying ergonomics heuristics. The default value is the amount of
-    available memory to the JVM process.
-
-    The maximum amount of available memory to the JVM process is the minimum
-    of the machine's physical memory and any constraints set by the environment
-    (e.g. container).
-
-    Specifying this option disables automatic use of compressed oops if
-    the combined result of this and other options influencing the maximum amount
-    of memory is larger than the range of memory addressable by compressed oops.
-    See `-XX:UseCompressedOops` for further information about compressed oops.
-
-    The following example shows how to set the maximum amount of available
-    memory for sizing the Java heap to 2 GB:
-
-    >   `-XX:MaxRAM=2G`
-
 [`-XX:+AggressiveHeap`]{#-XX__AggressiveHeap}
 :   Enables Java heap optimization. This sets various parameters to be
     optimal for long-running jobs with intensive memory allocation, based on
@@ -2967,8 +2947,8 @@ they're used.
 [`-XX:+NeverActAsServerClassMachine`]{#-XX__NeverActAsServerClassMachine}
 :   Enable the "Client VM emulation" mode which only uses the C1 JIT compiler,
     a 32Mb CodeCache and the Serial GC. The maximum amount of memory that the
-    JVM may use (controlled by the `-XX:MaxRAM=n` flag) is set to 1GB by default.
-    The string "emulated-client" is added to the JVM version string.
+    JVM may use is set to 1GB by default. The string "emulated-client" is added
+    to the JVM version string.
 
     By default the flag is set to `true` only on Windows in 32-bit mode and
     `false` in all other cases.

test/hotspot/gtest/runtime/test_globals.cpp

@@ -58,7 +58,7 @@ TEST_VM(FlagGuard, size_t_flag) {
 }
 
 TEST_VM(FlagGuard, uint64_t_flag) {
-  TEST_FLAG(MaxRAM, uint64_t, 1337);
+  TEST_FLAG(StringDeduplicationHashSeed, uint64_t, 1337);
 }
 
 TEST_VM(FlagGuard, double_flag) {

test/hotspot/jtreg/gc/arguments/TestMaxRAMFlags.java

@@ -26,17 +26,19 @@
 /*
  * @test TestMaxRAMFlags
  * @bug 8222252
- * @summary Verify correct MaxHeapSize and UseCompressedOops when MaxRAM and MaxRAMPercentage
- * are specified.
+ * @summary Verify correct MaxHeapSize and UseCompressedOops when MaxRAMPercentage is specified
  * @library /test/lib
  * @library /
  * @requires vm.bits == "64"
  * @modules java.base/jdk.internal.misc
  *          java.management
  * @build jdk.test.whitebox.WhiteBox
  * @run driver jdk.test.lib.helpers.ClassFileInstaller jdk.test.whitebox.WhiteBox
- * @run driver gc.arguments.TestMaxRAMFlags
- * @author bob.vandette@oracle.com
+ * @run main/othervm
+ *      -Xbootclasspath/a:.
+ *      -XX:+UnlockDiagnosticVMOptions
+ *      -XX:+WhiteBoxAPI
+ *      gc.arguments.TestMaxRAMFlags
  */
 
 import java.util.regex.Matcher;
@@ -45,14 +47,21 @@
 import java.util.ArrayList;
 import java.util.Arrays;
 
+import jdk.test.whitebox.WhiteBox;
 import jdk.test.lib.process.OutputAnalyzer;
+import jtreg.SkippedException;
 
 public class TestMaxRAMFlags {
 
-  private static void checkMaxRAMSize(long maxram, int maxrampercent, boolean forcecoop, long expectheap, boolean expectcoop) throws Exception {
+  private static final WhiteBox wb = WhiteBox.getWhiteBox();
+
+  private static long getHostMaxMemory() {
+      return Long.valueOf(wb.hostPhysicalMemory());
+  }
+
+  private static void checkMaxRAMSize(double maxrampercent, boolean forcecoop, long expectheap, boolean expectcoop) throws Exception {
 
     ArrayList<String> args = new ArrayList<String>();
-    args.add("-XX:MaxRAM=" + maxram);
     args.add("-XX:MaxRAMPercentage=" + maxrampercent);
     if (forcecoop) {
       args.add("-XX:+UseCompressedOops");
@@ -107,21 +116,32 @@ private static boolean getFlagBoolValue(String flag, String where) {
   }
 
   public static void main(String args[]) throws Exception {
-    // Tests
-    // 1. Verify that MaxRAMPercentage overrides UseCompressedOops Ergo
-    // 2. Verify that UseCompressedOops forces compressed oops limit even
-    //    when other flags are specified.
-
-    long oneG = 1L * 1024L * 1024L * 1024L;
-
     // Hotspot startup logic reduces MaxHeapForCompressedOops by HeapBaseMinAddress
     // in order to get zero based compressed oops offsets.
     long heapbaseminaddr = getHeapBaseMinAddress();
     long maxcoopheap = TestUseCompressedOopsErgoTools.getMaxHeapForCompressedOops(new String [0]) - heapbaseminaddr;
 
-    // Args: MaxRAM , MaxRAMPercentage, forcecoop, expect heap, expect coop
-    checkMaxRAMSize(maxcoopheap - oneG, 100, false, maxcoopheap - oneG, true);
-    checkMaxRAMSize(maxcoopheap + oneG, 100, false, maxcoopheap + oneG, false);
-    checkMaxRAMSize(maxcoopheap + oneG, 100, true, maxcoopheap, true);
+    // The headroom is used to get/not get compressed oops from the maxcoopheap size
+    long M = 1L * 1024L * 1024L;
+    long headroom = 64 * M;
+
+    long requiredHostMemory = maxcoopheap + headroom;
+
+    // Get host memory
+    long hostMemory = getHostMaxMemory();
+
+    System.out.println("hostMemory: " + hostMemory + ", requiredHostMemory: " + requiredHostMemory);
+
+    if (hostMemory < requiredHostMemory) {
+      throw new SkippedException("Not enough RAM on machine to run. Test skipped!");
+    }
+
+    double MaxRAMPercentage = ((double)maxcoopheap / hostMemory) * 100.0;
+    double headroomPercentage = ((double)headroom / hostMemory) * 100.0;
+
+    // Args: MaxRAMPercentage, forcecoop, expectheap, expectcoop
+    checkMaxRAMSize(MaxRAMPercentage - headroomPercentage, false, maxcoopheap - (long)headroom, true);
+    checkMaxRAMSize(MaxRAMPercentage + headroomPercentage, false, maxcoopheap + (long)headroom, false);
+    checkMaxRAMSize(MaxRAMPercentage, true, maxcoopheap, true);
   }
 }

test/hotspot/jtreg/gc/arguments/TestUseCompressedOopsFlagsWithUlimit.java

@@ -26,8 +26,7 @@
 /*
  * @test TestUseCompressedOopsFlagsWithUlimit
  * @bug 8280761
- * @summary Verify correct UseCompressedOops when MaxRAM and MaxRAMPercentage
- * are specified with ulimit -v.
+ * @summary Verify that ergonomic setting of UseCompressedOops adheres to ulimit -v
  * @library /test/lib
  * @library /
  * @requires vm.bits == "64"
@@ -50,10 +49,9 @@
 
 public class TestUseCompressedOopsFlagsWithUlimit {
 
-  private static void checkFlag(long ulimit, long maxram, int maxrampercent, boolean expectcoop) throws Exception {
+  private static void checkFlag(long ulimit, int maxrampercent, boolean expectcoop) throws Exception {
 
     ArrayList<String> args = new ArrayList<String>();
-    args.add("-XX:MaxRAM=" + maxram);
     args.add("-XX:MaxRAMPercentage=" + maxrampercent);
     args.add("-XX:+PrintFlagsFinal");
 
@@ -74,7 +72,7 @@ private static void checkFlag(long ulimit, long maxram, int maxrampercent, boole
     boolean actualcoop = getFlagBoolValue("UseCompressedOops", stdout);
     if (actualcoop != expectcoop) {
       throw new RuntimeException("UseCompressedOops set to " + actualcoop +
-        ", expected " + expectcoop + " when running with the following flags: " + Arrays.asList(args).toString());
+        ", expected " + expectcoop + " when running with the following flags: " + Arrays.asList(args).toString() + ", and ulimit: " + ulimit);
     }
   }
 
@@ -91,10 +89,13 @@ public static void main(String args[]) throws Exception {
     // Verify that UseCompressedOops Ergo follows ulimit -v setting.
 
     long oneG = 1L * 1024L * 1024L * 1024L;
+    long ulimit = 10 * oneG;
 
-    // Args: ulimit, max_ram, max_ram_percent, expected_coop
-    // Setting MaxRAMPercentage explicitly to make the test more resilient.
-    checkFlag(10 * oneG, 32 * oneG, 100, true);
-    checkFlag(10 * oneG, 128 * oneG, 100, true);
+    // Regardless of how much memory that is available on the machine, we should
+    // always get compressed oops if we have set a ulimit below the COOPS limit.
+    // We set MaxRAMPercentage explicitly to make the test more resilient.
+
+    // Args: ulimit, maxrampercent, expectedcoop
+    checkFlag(ulimit, 100, true);
   }
 }

test/hotspot/jtreg/runtime/7167069/PrintAsFlag.java

@@ -27,7 +27,7 @@
  *
  * @test PrintAsFlag
  * @summary verify that Flag::print_as_flag() works correctly. This is used by "jinfo -flag" and -XX:+PrintCommandLineFlags.
- * @run main/othervm -XX:+PrintCommandLineFlags -XX:-ShowMessageBoxOnError -XX:ParallelGCThreads=4 -XX:MaxRAM=1G -XX:ErrorFile="file" PrintAsFlag
+ * @run main/othervm -XX:+PrintCommandLineFlags -XX:-ShowMessageBoxOnError -XX:ParallelGCThreads=4 -XX:StringDeduplicationHashSeed=123456 -XX:ErrorFile="file" PrintAsFlag
  */
 
 public class PrintAsFlag {

test/hotspot/jtreg/runtime/CommandLine/OptionsValidation/TestOptionsWithRanges.java

@@ -237,7 +237,6 @@ public static void main(String[] args) throws Exception {
         excludeTestMaxRange("G1ConcRefinementThreads");
         excludeTestMaxRange("InitialHeapSize");
         excludeTestMaxRange("MaxHeapSize");
-        excludeTestMaxRange("MaxRAM");
         excludeTestMaxRange("NewSize");
         excludeTestMaxRange("ParallelGCThreads");
         excludeTestMaxRange("TLABSize");

test/lib-test/jdk/test/whitebox/vm_flags/Uint64Test.java

@@ -35,7 +35,7 @@
  */
 
 public class Uint64Test {
-    private static final String FLAG_NAME = "MaxRAM";
+    private static final String FLAG_NAME = "StringDeduplicationHashSeed";
     private static final Long[] TESTS = {0L, 100L, (long) Integer.MAX_VALUE,
             -1L, Long.MAX_VALUE, Long.MIN_VALUE};