Ergonomics Profile

src/hotspot/share/gc/shared/gcConfig.cpp

@@ -95,7 +95,7 @@ void GCConfig::fail_if_non_included_gc_is_selected() {
   NOT_ZGC(         FAIL_IF_SELECTED(UseZGC));
 }
 
-void GCConfig::select_gc_ergonomically() {
+void select_gc_ergonomically_shared() {
   if (os::is_server_class_machine()) {
 #if INCLUDE_G1GC
     FLAG_SET_ERGO_IF_DEFAULT(UseG1GC, true);
@@ -111,6 +111,41 @@ void GCConfig::select_gc_ergonomically() {
   }
 }
 
+// Selects the garbage collector (GC) ergonomically based on the system's characteristics.
+// It first checks the physical memory available on the system and the number of active processors.
+// Depending on these factors, it sets the appropriate GC flag to true using the FLAG_SET_ERGO_IF_DEFAULT macro.
+// If the system has only one active processor, it selects the Serial GC, no matter how much memory is available.
+// If the system has more than one active processor and the physical memory is greater than or equal to 16GB, it selects the ZGC.
+// If the physical memory is greater than 2GB, it selects the G1GC.
+// Otherwise, it selects the Parallel GC.
+void select_gc_ergonomically_dedicated() {
+  julong phys_mem = os::physical_memory();
+  if (os::active_processor_count() <= 1) {
+#if INCLUDE_SERIALGC
+      FLAG_SET_ERGO_IF_DEFAULT(UseSerialGC, true);
+#endif
+    } else if (phys_mem > 2048*M) {
+#if INCLUDE_G1GC
+      FLAG_SET_ERGO_IF_DEFAULT(UseG1GC, true);
+#endif
+    } else { 
+#if INCLUDE_PARALLELGC
+      FLAG_SET_ERGO_IF_DEFAULT(UseParallelGC, true);
+#endif
+    }
+}
+
+void GCConfig::select_gc_ergonomically() {
+  if (strcmp(ErgonomicsProfile, "shared") == 0) {
+    select_gc_ergonomically_shared();
+  } else if (strcmp(ErgonomicsProfile, "dedicated") == 0) {
+    select_gc_ergonomically_dedicated();
+  } else {
+    // We have got to have at least one GC selected. Otherwise, we will crash.
+    ShouldNotReachHere();
+  }
+}
+
 bool GCConfig::is_no_gc_selected() {
   FOR_EACH_INCLUDED_GC(gc) {
     if (gc->_flag) {

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

@@ -124,6 +124,13 @@
   product(bool, UseShenandoahGC, false,                                     \
           "Use the Shenandoah garbage collector")                           \
                                                                             \
+  /* notice: once stable enough, goal is to change default to auto */       \
+  product(ccstr, ErgonomicsProfile, "shared",                               \
+          "Ergonomics profile to use. "                                     \
+          "\"auto\" for automatic selection. "                              \
+          "\"shared\" for traditional environments (default). "             \
+          "\"dedicated\" for environments with dedicated resources.")       \
+                                                                            \
   /* notice: the max range value here is INT_MAX not UINT_MAX  */           \
   /* to protect from overflows                                 */           \
   product(uint, ParallelGCThreads, 0,                                       \

src/hotspot/share/runtime/arguments.cpp

@@ -72,6 +72,9 @@
 #if INCLUDE_JFR
 #include "jfr/jfr.hpp"
 #endif
+#ifdef LINUX
+#include "osContainer_linux.hpp"
+#endif
 
 #include <limits>
 
@@ -1438,6 +1441,15 @@ void Arguments::set_use_compressed_klass_ptrs() {
 #endif // _LP64
 }
 
+static void validate_ergonomics_profile() {
+  if (
+      strcmp(ErgonomicsProfile, "shared") != 0 &&
+      strcmp(ErgonomicsProfile, "dedicated") != 0 &&
+      strcmp(ErgonomicsProfile, "auto") != 0){
+    vm_exit_during_initialization(err_msg("Unsupported ErgonomicsProfile: %s", ErgonomicsProfile));
+  }
+}
+
 void Arguments::set_conservative_max_heap_alignment() {
   // The conservative maximum required alignment for the heap is the maximum of
   // the alignments imposed by several sources: any requirements from the heap
@@ -1451,6 +1463,8 @@ void Arguments::set_conservative_max_heap_alignment() {
 
 jint Arguments::set_ergonomics_flags() {
   GCConfig::initialize();
+  // Store the name of the selected GC
+  PropertyList_add(&_system_properties, new SystemProperty("java.vm.gc.name", GCConfig::gc_name(),  false));
 
   set_conservative_max_heap_alignment();
 
@@ -1465,6 +1479,27 @@ jint Arguments::set_ergonomics_flags() {
   return JNI_OK;
 }
 
+void Arguments::set_ergonomics_profile() {
+  validate_ergonomics_profile();
+
+  // Check if the value is 'auto'.
+  if (strcmp(ErgonomicsProfile, "auto") == 0) {
+    // Set the ergonomics profile based on platform.
+    // If it is a Linux environment, check if we are inside a container.
+    // If yes, we apply dedicated automatically.
+    // May support other platforms in the future (e.g. Windows Containers, Solaris Zones, FreeBSD Jails, Virtuozzo OpenVZ, etc).
+    #ifdef LINUX
+    if (OSContainer::is_containerized()){
+      FLAG_SET_ERGO(ErgonomicsProfile, "dedicated");
+    } else 
+    #endif //LINUX
+      FLAG_SET_ERGO(ErgonomicsProfile, "shared");
+  }
+
+  // Store so we can expose through JMX RuntimeMBean
+  PropertyList_add(&_system_properties, new SystemProperty("java.vm.ergonomics.profile", ErgonomicsProfile,  false));
+}
+
 size_t Arguments::limit_heap_by_allocatable_memory(size_t limit) {
   size_t max_allocatable;
   size_t result = limit;
@@ -1509,6 +1544,8 @@ void Arguments::set_heap_size() {
                                        : (julong)MaxRAM;
   }
 
+  set_ergonomics_profiles_heap_size_max_ram_percentage(phys_mem);
+
   // 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.
@@ -1616,6 +1653,25 @@ void Arguments::set_heap_size() {
   }
 }
 
+void Arguments::set_ergonomics_profiles_heap_size_max_ram_percentage(julong phys_mem) {
+  // Update default heap size for dedicated ergonomics profile
+  if (strcmp(ErgonomicsProfile, "dedicated") == 0) {
+    FLAG_SET_ERGO_IF_DEFAULT(InitialRAMPercentage, 50.0);
+
+    if (phys_mem >= 16 * G) {
+      FLAG_SET_ERGO_IF_DEFAULT(MaxRAMPercentage, 90.0);
+    } else if (phys_mem >= 6 * G) {
+      FLAG_SET_ERGO_IF_DEFAULT(MaxRAMPercentage, 85.0);
+    } else if (phys_mem >= 4 * G) {
+      FLAG_SET_ERGO_IF_DEFAULT(MaxRAMPercentage, 80.0);
+    } else if (phys_mem >= 0.5 * G) {
+      FLAG_SET_ERGO_IF_DEFAULT(MaxRAMPercentage, 75.0);
+    } else {
+      FLAG_SET_ERGO_IF_DEFAULT(MaxRAMPercentage, 50.0);
+    }
+  }
+}
+
 // This option inspects the machine and attempts to set various
 // parameters to be optimal for long-running, memory allocation
 // intensive jobs.  It is intended for machines with large
@@ -3654,6 +3710,9 @@ jint Arguments::parse(const JavaVMInitArgs* initial_cmd_args) {
 }
 
 jint Arguments::apply_ergo() {
+  // Set the ergonomics profile
+  set_ergonomics_profile();
+
   // Set flags based on ergonomics.
   jint result = set_ergonomics_flags();
   if (result != JNI_OK) return result;

src/hotspot/share/runtime/arguments.hpp

@@ -259,6 +259,7 @@ class Arguments : AllStatic {
   static bool _ClipInlining;
 
   // GC ergonomics
+  static void set_ergonomics_profile();
   static void set_conservative_max_heap_alignment();
   static void set_use_compressed_oops();
   static void set_use_compressed_klass_ptrs();
@@ -270,6 +271,8 @@ class Arguments : AllStatic {
   // Setup heap size
   static void set_heap_size();
 
+  static void set_ergonomics_profiles_heap_size_max_ram_percentage(julong phys_mem);
+
   // Bytecode rewriting
   static void set_bytecode_flags();
 

src/java.management/share/classes/java/lang/management/RuntimeMXBean.java

@@ -359,4 +359,16 @@ public default long getPid() {
      *     to the system properties.
      */
     public java.util.Map<String, String> getSystemProperties();
+
+    /**
+     * Returns the selected ergonomics profile for this Java virtual machine.
+     * The profile will be one of the following:
+     * <ul>
+     *   <li>shared</li>
+     *   <li>dedicated</li>
+     * </ul>
+     * 
+     * @return the name of the selected ergonomics profile
+     */
+    public String getJvmErgonomicsProfile();
 }

src/java.management/share/classes/sun/management/RuntimeImpl.java

@@ -133,6 +133,10 @@ public Map<String,String> getSystemProperties() {
         return map;
     }
 
+    public String getJvmErgonomicsProfile() {
+        return jvm.getErgonomicsProfile();
+    }
+
     public ObjectName getObjectName() {
         return Util.newObjectName(ManagementFactory.RUNTIME_MXBEAN_NAME);
     }

src/java.management/share/classes/sun/management/VMManagement.java

@@ -73,6 +73,7 @@ public interface VMManagement {
     public long    getStartupTime();
     public long    getUptime();
     public int     getAvailableProcessors();
+    public String  getErgonomicsProfile();
 
     // Compilation Subsystem
     public String  getCompilerName();

src/java.management/share/classes/sun/management/VMManagementImpl.java

@@ -201,6 +201,10 @@ public synchronized List<String> getVmArguments() {
     private native long getUptime0();
     public native int getAvailableProcessors();
 
+    public String getErgonomicsProfile() {
+        return System.getProperty("java.vm.ergonomics.profile");
+    }
+
     // Compilation Subsystem
     public String   getCompilerName() {
         @SuppressWarnings("removal")