8357086: os::xxx functions returning memory size should return size_t

Reviewed-by: stefank, dholmes

Author: toxaart

src/hotspot/os/aix/os_aix.cpp

@@ -169,7 +169,7 @@ static void vmembk_print_on(outputStream* os);
 ////////////////////////////////////////////////////////////////////////////////
 // global variables (for a description see os_aix.hpp)
 
-julong    os::Aix::_physical_memory = 0;
+size_t    os::Aix::_physical_memory = 0;
 
 pthread_t os::Aix::_main_thread = ((pthread_t)0);
 
@@ -254,40 +254,43 @@ static bool is_close_to_brk(address a) {
   return false;
 }
 
-julong os::free_memory() {
-  return Aix::available_memory();
+bool os::free_memory(size_t& value) {
+  return Aix::available_memory(value);
 }
 
-julong os::available_memory() {
-  return Aix::available_memory();
+bool os::available_memory(size_t& value) {
+  return Aix::available_memory(value);
 }
 
-julong os::Aix::available_memory() {
+bool os::Aix::available_memory(size_t& value) {
   os::Aix::meminfo_t mi;
   if (os::Aix::get_meminfo(&mi)) {
-    return mi.real_free;
+    value = static_cast<size_t>(mi.real_free);
+    return true;
   } else {
-    return ULONG_MAX;
+    return false;
   }
 }
 
-jlong os::total_swap_space() {
+bool os::total_swap_space(size_t& value) {
   perfstat_memory_total_t memory_info;
   if (libperfstat::perfstat_memory_total(nullptr, &memory_info, sizeof(perfstat_memory_total_t), 1) == -1) {
-    return -1;
+    return false;
   }
-  return (jlong)(memory_info.pgsp_total * 4 * K);
+  value = static_cast<size_t>(memory_info.pgsp_total * 4 * K);
+  return true;
 }
 
-jlong os::free_swap_space() {
+bool os::free_swap_space(size_t& value) {
   perfstat_memory_total_t memory_info;
   if (libperfstat::perfstat_memory_total(nullptr, &memory_info, sizeof(perfstat_memory_total_t), 1) == -1) {
-    return -1;
+    return false;
   }
-  return (jlong)(memory_info.pgsp_free * 4 * K);
+  value = static_cast<size_t>(memory_info.pgsp_free * 4 * K);
+  return true;
 }
 
-julong os::physical_memory() {
+size_t os::physical_memory() {
   return Aix::physical_memory();
 }
 
@@ -326,7 +329,7 @@ void os::Aix::initialize_system_info() {
   if (!os::Aix::get_meminfo(&mi)) {
     assert(false, "os::Aix::get_meminfo failed.");
   }
-  _physical_memory = (julong) mi.real_total;
+  _physical_memory = static_cast<size_t>(mi.real_total);
 }
 
 // Helper function for tracing page sizes.
@@ -2193,7 +2196,7 @@ jint os::init_2(void) {
   os::Posix::init_2();
 
   trcVerbose("processor count: %d", os::_processor_count);
-  trcVerbose("physical memory: %lu", Aix::_physical_memory);
+  trcVerbose("physical memory: %zu", Aix::_physical_memory);
 
   // Initially build up the loaded dll map.
   LoadedLibraries::reload();

src/hotspot/os/aix/os_aix.hpp

@@ -35,7 +35,7 @@ class os::Aix {
 
  private:
 
-  static julong _physical_memory;
+  static size_t _physical_memory;
   static pthread_t _main_thread;
 
   // 0 = uninitialized, otherwise 16 bit number:
@@ -54,9 +54,9 @@ class os::Aix {
   //  1 - EXTSHM=ON
   static int _extshm;
 
-  static julong available_memory();
-  static julong free_memory();
-  static julong physical_memory() { return _physical_memory; }
+  static bool available_memory(size_t& value);
+  static bool free_memory(size_t& value);
+  static size_t physical_memory() { return _physical_memory; }
   static void initialize_system_info();
 
   // OS recognitions (AIX OS level) call this before calling Aix::os_version().

src/hotspot/os/bsd/os_bsd.cpp

@@ -114,7 +114,7 @@
 
 ////////////////////////////////////////////////////////////////////////////////
 // global variables
-julong os::Bsd::_physical_memory = 0;
+size_t os::Bsd::_physical_memory = 0;
 
 #ifdef __APPLE__
 mach_timebase_info_data_t os::Bsd::_timebase_info = {0, 0};
@@ -133,19 +133,19 @@ static volatile int processor_id_next = 0;
 ////////////////////////////////////////////////////////////////////////////////
 // utility functions
 
-julong os::available_memory() {
-  return Bsd::available_memory();
+bool os::available_memory(size_t& value) {
+  return Bsd::available_memory(value);
 }
 
-julong os::free_memory() {
-  return Bsd::available_memory();
+bool os::free_memory(size_t& value) {
+  return Bsd::available_memory(value);
 }
 
 // Available here means free. Note that this number is of no much use. As an estimate
 // for future memory pressure it is far too conservative, since MacOS will use a lot
 // of unused memory for caches, and return it willingly in case of needs.
-julong os::Bsd::available_memory() {
-  uint64_t available = physical_memory() >> 2;
+bool os::Bsd::available_memory(size_t& value) {
+  uint64_t available = static_cast<uint64_t>(physical_memory() >> 2);
 #ifdef __APPLE__
   mach_msg_type_number_t count = HOST_VM_INFO64_COUNT;
   vm_statistics64_data_t vmstat;
@@ -156,9 +156,12 @@ julong os::Bsd::available_memory() {
   if (kerr == KERN_SUCCESS) {
     // free_count is just a lowerbound, other page categories can be freed too and make memory available
     available = (vmstat.free_count + vmstat.inactive_count + vmstat.purgeable_count) * os::vm_page_size();
+  } else {
+    return false;
   }
 #endif
-  return available;
+  value = static_cast<size_t>(available);
+  return true;
 }
 
 // for more info see :
@@ -177,33 +180,35 @@ void os::Bsd::print_uptime_info(outputStream* st) {
   }
 }
 
-jlong os::total_swap_space() {
+bool os::total_swap_space(size_t& value) {
 #if defined(__APPLE__)
   struct xsw_usage vmusage;
   size_t size = sizeof(vmusage);
   if (sysctlbyname("vm.swapusage", &vmusage, &size, nullptr, 0) != 0) {
-    return -1;
+    return false;
   }
-  return (jlong)vmusage.xsu_total;
+  value = static_cast<size_t>(vmusage.xsu_total);
+  return true;
 #else
-  return -1;
+  return false;
 #endif
 }
 
-jlong os::free_swap_space() {
+bool os::free_swap_space(size_t& value) {
 #if defined(__APPLE__)
   struct xsw_usage vmusage;
   size_t size = sizeof(vmusage);
   if (sysctlbyname("vm.swapusage", &vmusage, &size, nullptr, 0) != 0) {
-    return -1;
+    return false;
   }
-  return (jlong)vmusage.xsu_avail;
+  value = static_cast<size_t>(vmusage.xsu_avail);
+  return true;
 #else
-  return -1;
+  return false;
 #endif
 }
 
-julong os::physical_memory() {
+size_t os::physical_memory() {
   return Bsd::physical_memory();
 }
 
@@ -281,7 +286,7 @@ void os::Bsd::initialize_system_info() {
   len = sizeof(mem_val);
   if (sysctl(mib, 2, &mem_val, &len, nullptr, 0) != -1) {
     assert(len == sizeof(mem_val), "unexpected data size");
-    _physical_memory = mem_val;
+    _physical_memory = static_cast<size_t>(mem_val);
   } else {
     _physical_memory = 256 * 1024 * 1024;       // fallback (XXXBSD?)
   }
@@ -292,7 +297,7 @@ void os::Bsd::initialize_system_info() {
     // datasize rlimit restricts us anyway.
     struct rlimit limits;
     getrlimit(RLIMIT_DATA, &limits);
-    _physical_memory = MIN2(_physical_memory, (julong)limits.rlim_cur);
+    _physical_memory = MIN2(_physical_memory, static_cast<size_t>(limits.rlim_cur));
   }
 #endif
 }
@@ -1464,11 +1469,13 @@ void os::print_memory_info(outputStream* st) {
 
   st->print("Memory:");
   st->print(" %zuk page", os::vm_page_size()>>10);
-
-  st->print(", physical " UINT64_FORMAT "k",
-            os::physical_memory() >> 10);
-  st->print("(" UINT64_FORMAT "k free)",
-            os::available_memory() >> 10);
+  size_t phys_mem = os::physical_memory();
+  st->print(", physical %zuk",
+            phys_mem >> 10);
+  size_t avail_mem = 0;
+  (void)os::available_memory(avail_mem);
+  st->print("(%zuk free)",
+            avail_mem >> 10);
 
   if((sysctlbyname("vm.swapusage", &swap_usage, &size, nullptr, 0) == 0) || (errno == ENOMEM)) {
     if (size >= offset_of(xsw_usage, xsu_used)) {

src/hotspot/os/bsd/os_bsd.hpp

@@ -42,12 +42,12 @@ class os::Bsd {
 
  protected:
 
-  static julong _physical_memory;
+  static size_t _physical_memory;
   static pthread_t _main_thread;
 
-  static julong available_memory();
-  static julong free_memory();
-  static julong physical_memory() { return _physical_memory; }
+  static bool available_memory(size_t& value);
+  static bool free_memory(size_t& value);
+  static size_t physical_memory() { return _physical_memory; }
   static void initialize_system_info();
 
   static void rebuild_cpu_to_node_map();

src/hotspot/os/linux/cgroupSubsystem_linux.cpp

@@ -670,8 +670,8 @@ jlong CgroupSubsystem::memory_limit_in_bytes() {
   if (!memory_limit->should_check_metric()) {
     return memory_limit->value();
   }
-  jlong phys_mem = os::Linux::physical_memory();
-  log_trace(os, container)("total physical memory: " JLONG_FORMAT, phys_mem);
+  julong phys_mem = static_cast<julong>(os::Linux::physical_memory());
+  log_trace(os, container)("total physical memory: " JULONG_FORMAT, phys_mem);
   jlong mem_limit = contrl->controller()->read_memory_limit_in_bytes(phys_mem);
   // Update cached metric to avoid re-reading container settings too often
   memory_limit->set_value(mem_limit, OSCONTAINER_CACHE_TIMEOUT);
@@ -841,19 +841,19 @@ jlong CgroupController::limit_from_str(char* limit_str) {
 // CgroupSubsystem implementations
 
 jlong CgroupSubsystem::memory_and_swap_limit_in_bytes() {
-  julong phys_mem = os::Linux::physical_memory();
+  julong phys_mem = static_cast<julong>(os::Linux::physical_memory());
   julong host_swap = os::Linux::host_swap();
   return memory_controller()->controller()->memory_and_swap_limit_in_bytes(phys_mem, host_swap);
 }
 
 jlong CgroupSubsystem::memory_and_swap_usage_in_bytes() {
-  julong phys_mem = os::Linux::physical_memory();
+  julong phys_mem = static_cast<julong>(os::Linux::physical_memory());
   julong host_swap = os::Linux::host_swap();
   return memory_controller()->controller()->memory_and_swap_usage_in_bytes(phys_mem, host_swap);
 }
 
 jlong CgroupSubsystem::memory_soft_limit_in_bytes() {
-  julong phys_mem = os::Linux::physical_memory();
+  julong phys_mem = static_cast<julong>(os::Linux::physical_memory());
   return memory_controller()->controller()->memory_soft_limit_in_bytes(phys_mem);
 }
 
@@ -894,6 +894,6 @@ jlong CgroupSubsystem::cpu_usage_in_micros() {
 }
 
 void CgroupSubsystem::print_version_specific_info(outputStream* st) {
-  julong phys_mem = os::Linux::physical_memory();
+  julong phys_mem = static_cast<julong>(os::Linux::physical_memory());
   memory_controller()->controller()->print_version_specific_info(st, phys_mem);
 }

src/hotspot/os/linux/cgroupUtil_linux.cpp

@@ -65,7 +65,7 @@ void CgroupUtil::adjust_controller(CgroupMemoryController* mem) {
   char* cg_path = os::strdup(orig);
   char* last_slash;
   assert(cg_path[0] == '/', "cgroup path must start with '/'");
-  julong phys_mem = os::Linux::physical_memory();
+  julong phys_mem = static_cast<julong>(os::Linux::physical_memory());
   char* limit_cg_path = nullptr;
   jlong limit = mem->read_memory_limit_in_bytes(phys_mem);
   jlong lowest_limit = limit < 0 ? phys_mem : limit;