Move methods to Machine/Container inner classes + clarifying documentation

Author: caspernorrbin

src/hotspot/os/aix/os_aix.cpp

@@ -258,15 +258,15 @@ bool os::free_memory(physical_memory_size_type& value) {
   return Aix::available_memory(value);
 }
 
-bool os::machine_free_memory(physical_memory_size_type& value) {
+bool os::Machine::free_memory(physical_memory_size_type& value) {
   return Aix::available_memory(value);
 }
 
 bool os::available_memory(physical_memory_size_type& value) {
   return Aix::available_memory(value);
 }
 
-bool os::machine_available_memory(physical_memory_size_type& value) {
+bool os::Machine::available_memory(physical_memory_size_type& value) {
   return Aix::available_memory(value);
 }
 
@@ -281,10 +281,10 @@ bool os::Aix::available_memory(physical_memory_size_type& value) {
 }
 
 bool os::total_swap_space(physical_memory_size_type& value) {
-  return machine_total_swap_space(value);
+  return Machine::total_swap_space(value);
 }
 
-bool os::machine_total_swap_space(physical_memory_size_type& value) {
+bool os::Machine::total_swap_space(physical_memory_size_type& value) {
   perfstat_memory_total_t memory_info;
   if (libperfstat::perfstat_memory_total(nullptr, &memory_info, sizeof(perfstat_memory_total_t), 1) == -1) {
     return false;
@@ -294,10 +294,10 @@ bool os::machine_total_swap_space(physical_memory_size_type& value) {
 }
 
 bool os::free_swap_space(physical_memory_size_type& value) {
-  return machine_free_swap_space(value);
+  return Machine::free_swap_space(value);
 }
 
-bool os::machine_free_swap_space(physical_memory_size_type& value) {
+bool os::Machine::free_swap_space(physical_memory_size_type& value) {
   perfstat_memory_total_t memory_info;
   if (libperfstat::perfstat_memory_total(nullptr, &memory_info, sizeof(perfstat_memory_total_t), 1) == -1) {
     return false;
@@ -310,7 +310,7 @@ physical_memory_size_type os::physical_memory() {
   return Aix::physical_memory();
 }
 
-physical_memory_size_type os::machine_physical_memory() {
+physical_memory_size_type os::Machine::physical_memory() {
   return Aix::physical_memory();
 }
 
@@ -2279,10 +2279,10 @@ int os::active_processor_count() {
     return ActiveProcessorCount;
   }
 
-  return machine_active_processor_count();
+  return Machine::active_processor_count();
 }
 
-int os::machine_active_processor_count() {
+int os::Machine::active_processor_count() {
   int online_cpus = ::sysconf(_SC_NPROCESSORS_ONLN);
   assert(online_cpus > 0 && online_cpus <= processor_count(), "sanity check");
   return online_cpus;

src/hotspot/os/bsd/os_bsd.cpp

@@ -137,15 +137,15 @@ bool os::available_memory(physical_memory_size_type& value) {
   return Bsd::available_memory(value);
 }
 
-bool os::machine_available_memory(physical_memory_size_type& value) {
+bool os::Machine::available_memory(physical_memory_size_type& value) {
   return Bsd::available_memory(value);
 }
 
 bool os::free_memory(physical_memory_size_type& value) {
   return Bsd::available_memory(value);
 }
 
-bool os::machine_free_memory(physical_memory_size_type& value) {
+bool os::Machine::free_memory(physical_memory_size_type& value) {
   return Bsd::available_memory(value);
 }
 
@@ -189,10 +189,10 @@ void os::Bsd::print_uptime_info(outputStream* st) {
 }
 
 bool os::total_swap_space(physical_memory_size_type& value) {
-  return machine_total_swap_space(value);
+  return Machine::total_swap_space(value);
 }
 
-bool os::machine_total_swap_space(physical_memory_size_type& value) {
+bool os::Machine::total_swap_space(physical_memory_size_type& value) {
 #if defined(__APPLE__)
   struct xsw_usage vmusage;
   size_t size = sizeof(vmusage);
@@ -207,10 +207,10 @@ bool os::machine_total_swap_space(physical_memory_size_type& value) {
 }
 
 bool os::free_swap_space(physical_memory_size_type& value) {
-  return machine_free_swap_space(value);
+  return Machine::free_swap_space(value);
 }
 
-bool os::machine_free_swap_space(physical_memory_size_type& value) {
+bool os::Machine::free_swap_space(physical_memory_size_type& value) {
 #if defined(__APPLE__)
   struct xsw_usage vmusage;
   size_t size = sizeof(vmusage);
@@ -228,7 +228,7 @@ physical_memory_size_type os::physical_memory() {
   return Bsd::physical_memory();
 }
 
-physical_memory_size_type os::machine_physical_memory() {
+physical_memory_size_type os::Machine::physical_memory() {
   return Bsd::physical_memory();
 }
 
@@ -2120,10 +2120,10 @@ int os::active_processor_count() {
     return ActiveProcessorCount;
   }
 
-  return machine_active_processor_count();
+  return Machine::active_processor_count();
 }
 
-int os::machine_active_processor_count() {
+int os::Machine::active_processor_count() {
   return _processor_count;
 }
 

src/hotspot/os/linux/osContainer_linux.cpp

@@ -122,7 +122,7 @@ bool OSContainer::available_memory_in_container(julong& value) {
 
 jlong OSContainer::memory_limit_in_bytes() {
   assert(cgroup_subsystem != nullptr, "cgroup subsystem not available");
-  julong phys_mem = static_cast<julong>(os::machine_physical_memory());
+  julong phys_mem = static_cast<julong>(os::Machine::physical_memory());
   return cgroup_subsystem->memory_limit_in_bytes(phys_mem);
 }
 

src/hotspot/os/linux/os_linux.cpp

@@ -217,7 +217,7 @@ bool os::is_containerized() {
   return OSContainer::is_containerized();
 }
 
-bool os::container_memory_limit(physical_memory_size_type& value) {
+bool os::Container::memory_limit(physical_memory_size_type& value) {
   assert(is_containerized(), "must be running containerized");
   jlong mem_limit = OSContainer::memory_limit_in_bytes();
   if (mem_limit <= 0) {
@@ -227,7 +227,7 @@ bool os::container_memory_limit(physical_memory_size_type& value) {
   value = static_cast<physical_memory_size_type>(mem_limit);
   return true;
 }
-bool os::container_memory_soft_limit(physical_memory_size_type& value) {
+bool os::Container::memory_soft_limit(physical_memory_size_type& value) {
   assert(is_containerized(), "must be running containerized");
   jlong mem_limit = OSContainer::memory_soft_limit_in_bytes();
   if (mem_limit <= 0) {
@@ -238,7 +238,7 @@ bool os::container_memory_soft_limit(physical_memory_size_type& value) {
   return true;
 }
 
-bool os::container_memory_throttle_limit(physical_memory_size_type& value) {
+bool os::Container::memory_throttle_limit(physical_memory_size_type& value) {
   assert(is_containerized(), "must be running containerized");
   jlong mem_limit = OSContainer::memory_throttle_limit_in_bytes();
   if (mem_limit <= 0) {
@@ -249,7 +249,7 @@ bool os::container_memory_throttle_limit(physical_memory_size_type& value) {
   return true;
 }
 
-bool os::container_used_memory(physical_memory_size_type& value) {
+bool os::Container::used_memory(physical_memory_size_type& value) {
   assert(is_containerized(), "must be running containerized");
   jlong mem_usage = OSContainer::memory_usage_in_bytes();
   if (mem_usage <= 0) {
@@ -261,19 +261,19 @@ bool os::container_used_memory(physical_memory_size_type& value) {
 }
 
 bool os::available_memory(physical_memory_size_type& value) {
-  if (is_containerized() && container_available_memory(value)) {
+  if (is_containerized() && Container::available_memory(value)) {
     log_trace(os)("available container memory: " PHYS_MEM_TYPE_FORMAT, value);
     return true;
   }
 
-  return machine_available_memory(value);
+  return Machine::available_memory(value);
 }
 
-bool os::machine_available_memory(physical_memory_size_type& value) {
+bool os::Machine::available_memory(physical_memory_size_type& value) {
   return Linux::available_memory(value);
 }
 
-bool os::container_available_memory(physical_memory_size_type& value) {
+bool os::Container::available_memory(physical_memory_size_type& value) {
   assert(is_containerized(), "must be running containerized");
   julong avail_mem = 0;
   if (OSContainer::available_memory_in_container(avail_mem)) {
@@ -310,15 +310,15 @@ bool os::Linux::available_memory(physical_memory_size_type& value) {
 }
 
 bool os::free_memory(physical_memory_size_type& value) {
-  if (is_containerized() && container_available_memory(value)) {
+  if (is_containerized() && Container::available_memory(value)) {
     log_trace(os)("free container memory: " PHYS_MEM_TYPE_FORMAT, value);
     return true;
   }
 
-  return machine_free_memory(value);
+  return Machine::free_memory(value);
 }
 
-bool os::machine_free_memory(physical_memory_size_type& value) {
+bool os::Machine::free_memory(physical_memory_size_type& value) {
   return Linux::free_memory(value);
 }
 
@@ -337,13 +337,13 @@ bool os::Linux::free_memory(physical_memory_size_type& value) {
 }
 
 bool os::total_swap_space(physical_memory_size_type& value) {
-  if (is_containerized() && container_total_swap_space(value)) {
+  if (is_containerized() && Container::total_swap_space(value)) {
     return true;
   } // fallback to the host swap space if the container value fails
-  return machine_total_swap_space(value);
+  return Machine::total_swap_space(value);
 }
 
-bool os::machine_total_swap_space(physical_memory_size_type& value) {
+bool os::Machine::total_swap_space(physical_memory_size_type& value) {
   struct sysinfo si;
   int ret = sysinfo(&si);
   if (ret != 0) {
@@ -354,7 +354,7 @@ bool os::machine_total_swap_space(physical_memory_size_type& value) {
   return true;
 }
 
-bool os::container_total_swap_space(physical_memory_size_type& value) {
+bool os::Container::total_swap_space(physical_memory_size_type& value) {
   assert(is_containerized(), "must be running containerized");
   jlong memory_and_swap_limit_in_bytes = OSContainer::memory_and_swap_limit_in_bytes();
   jlong memory_limit_in_bytes = OSContainer::memory_limit_in_bytes();
@@ -386,7 +386,7 @@ bool os::free_swap_space(physical_memory_size_type& value) {
   }
   size_t host_free_swap_val = MIN2(total_swap_space, host_free_swap);
   if (is_containerized()) {
-    if (container_free_swap_space(value)) {
+    if (Container::free_swap_space(value)) {
       return true;
     } else {
       // unlimited or not supported. Fall through to return host value
@@ -401,11 +401,11 @@ bool os::free_swap_space(physical_memory_size_type& value) {
   return true;
 }
 
-bool os::machine_free_swap_space(physical_memory_size_type& value) {
+bool os::Machine::free_swap_space(physical_memory_size_type& value) {
   return host_free_swap_f(value);
 }
 
-bool os::container_free_swap_space(physical_memory_size_type& value) {
+bool os::Container::free_swap_space(physical_memory_size_type& value) {
   assert(is_containerized(), "must be running containerized");
   jlong mem_swap_limit = OSContainer::memory_and_swap_limit_in_bytes();
   jlong mem_limit = OSContainer::memory_limit_in_bytes();
@@ -432,18 +432,18 @@ bool os::container_free_swap_space(physical_memory_size_type& value) {
 physical_memory_size_type os::physical_memory() {
   if (is_containerized()) {
     physical_memory_size_type mem_limit;
-    if (container_memory_limit(mem_limit)) {
+    if (Container::memory_limit(mem_limit)) {
       log_trace(os)("total container memory: " PHYS_MEM_TYPE_FORMAT, mem_limit);
       return mem_limit;
     }
   }
 
-  physical_memory_size_type phys_mem = machine_physical_memory();
+  physical_memory_size_type phys_mem = Machine::physical_memory();
   log_trace(os)("total system memory: " PHYS_MEM_TYPE_FORMAT, phys_mem);
   return phys_mem;
 }
 
-physical_memory_size_type os::machine_physical_memory() {
+physical_memory_size_type os::Machine::physical_memory() {
   return Linux::physical_memory();
 }
 
@@ -4751,22 +4751,22 @@ int os::active_processor_count() {
   }
 
   if (is_containerized()) {
-    double cpu_quota = container_processor_count();
+    double cpu_quota = Container::processor_count();
     int active_cpus = ceilf(cpu_quota); // Round fractional CPU quota up.
-    assert(active_cpus <= machine_active_processor_count(), "must be");
+    assert(active_cpus <= Machine::active_processor_count(), "must be");
     log_trace(os)("active_processor_count: determined by OSContainer: %d",
                    active_cpus);
     return active_cpus;
   }
 
-  return machine_active_processor_count();
+  return Machine::active_processor_count();
 }
 
-int os::machine_active_processor_count() {
+int os::Machine::active_processor_count() {
   return os::Linux::active_processor_count();
 }
 
-double os::container_processor_count() {
+double os::Container::processor_count() {
   assert(is_containerized(), "must be running containerized");
   return OSContainer::active_processor_count();
 }

src/hotspot/os/windows/os_windows.cpp

@@ -838,15 +838,15 @@ bool os::available_memory(physical_memory_size_type& value) {
   return win32::available_memory(value);
 }
 
-bool os::machine_available_memory(physical_memory_size_type& value) {
+bool os::Machine::available_memory(physical_memory_size_type& value) {
   return win32::available_memory(value);
 }
 
 bool os::free_memory(physical_memory_size_type& value) {
   return win32::available_memory(value);
 }
 
-bool os::machine_free_memory(physical_memory_size_type& value) {
+bool os::Machine::free_memory(physical_memory_size_type& value) {
   return win32::available_memory(value);
 }
 
@@ -866,10 +866,10 @@ bool os::win32::available_memory(physical_memory_size_type& value) {
 }
 
 bool os::total_swap_space(physical_memory_size_type& value)  {
-  return machine_total_swap_space(value);
+  return Machine::total_swap_space(value);
 }
 
-bool os::machine_total_swap_space(physical_memory_size_type& value) {
+bool os::Machine::total_swap_space(physical_memory_size_type& value) {
   MEMORYSTATUSEX ms;
   ms.dwLength = sizeof(ms);
   BOOL res = GlobalMemoryStatusEx(&ms);
@@ -883,10 +883,10 @@ bool os::machine_total_swap_space(physical_memory_size_type& value) {
 }
 
 bool os::free_swap_space(physical_memory_size_type& value) {
-  return machine_free_swap_space(value);
+  return Machine::free_swap_space(value);
 }
 
-bool os::machine_free_swap_space(physical_memory_size_type& value) {
+bool os::Machine::free_swap_space(physical_memory_size_type& value) {
   MEMORYSTATUSEX ms;
   ms.dwLength = sizeof(ms);
   BOOL res = GlobalMemoryStatusEx(&ms);
@@ -903,7 +903,7 @@ physical_memory_size_type os::physical_memory() {
   return win32::physical_memory();
 }
 
-physical_memory_size_type os::machine_physical_memory() {
+physical_memory_size_type os::Machine::physical_memory() {
   return win32::physical_memory();
 }
 
@@ -930,10 +930,10 @@ int os::active_processor_count() {
     return ActiveProcessorCount;
   }
 
-  return machine_active_processor_count();
+  return Machine::active_processor_count();
 }
 
-int os::machine_active_processor_count() {
+int os::Machine::active_processor_count() {
   bool schedules_all_processor_groups = win32::is_windows_11_or_greater() || win32::is_windows_server_2022_or_greater();
   if (UseAllWindowsProcessorGroups && !schedules_all_processor_groups && !win32::processor_group_warning_displayed()) {
     win32::set_processor_group_warning_displayed(true);