infernap12/jdk
1
0
Fork 0
mirror of https://github.com/openjdk/jdk.git synced 2026-03-14 18:03:44 +00:00
Code Issues Packages Projects Releases Wiki Activity

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

Browse Source 
Reviewed-by: stefank, dholmes
This commit is contained in:
Anton Artemov 2025-09-01 07:43:25 +00:00 committed by David Holmes
parent dbac620b99
commit d5d94db12a
22 changed files with 254 additions and 162 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

37
src/hotspot/os/aix/os_aix.cpp
View File

@ -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();

8
src/hotspot/os/aix/os_aix.hpp
View File

@ -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().

55
src/hotspot/os/bsd/os_bsd.cpp
View File

@ -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)) {

8
src/hotspot/os/bsd/os_bsd.hpp
View File

@ -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();

12
src/hotspot/os/linux/cgroupSubsystem_linux.cpp
View File

@ -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);
}

2
src/hotspot/os/linux/cgroupUtil_linux.cpp
View File

@ -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;

106
src/hotspot/os/linux/os_linux.cpp
View File

@ -157,7 +157,7 @@ enum CoredumpFilterBit {
////////////////////////////////////////////////////////////////////////////////
// global variables
julong os::Linux::_physical_memory = 0;
size_t os::Linux::_physical_memory = 0;
address os::Linux::_initial_thread_stack_bottom = nullptr;
uintptr_t os::Linux::_initial_thread_stack_size = 0;
@ -232,15 +232,16 @@ julong os::Linux::available_memory_in_container() {
return avail_mem;
}
julong os::available_memory() {
return Linux::available_memory();
bool os::available_memory(size_t& value) {
return Linux::available_memory(value);
}
julong os::Linux::available_memory() {
bool os::Linux::available_memory(size_t& value) {
julong avail_mem = available_memory_in_container();
if (avail_mem != static_cast<julong>(-1L)) {
log_trace(os)("available container memory: " JULONG_FORMAT, avail_mem);
return avail_mem;
value = static_cast<size_t>(avail_mem);
return true;
}
FILE *fp = os::fopen("/proc/meminfo", "r");
@ -255,66 +256,88 @@ julong os::Linux::available_memory() {
fclose(fp);
}
if (avail_mem == static_cast<julong>(-1L)) {
avail_mem = free_memory();
size_t free_mem = 0;
if (!free_memory(free_mem)) {
return false;
}
avail_mem = static_cast<julong>(free_mem);
}
log_trace(os)("available memory: " JULONG_FORMAT, avail_mem);
return avail_mem;
value = static_cast<size_t>(avail_mem);
return true;
}
julong os::free_memory() {
return Linux::free_memory();
bool os::free_memory(size_t& value) {
return Linux::free_memory(value);
}
julong os::Linux::free_memory() {
bool os::Linux::free_memory(size_t& value) {
// values in struct sysinfo are "unsigned long"
struct sysinfo si;
julong free_mem = available_memory_in_container();
if (free_mem != static_cast<julong>(-1L)) {
log_trace(os)("free container memory: " JULONG_FORMAT, free_mem);
return free_mem;
value = static_cast<size_t>(free_mem);
return true;
}
sysinfo(&si);
int ret = sysinfo(&si);
if (ret != 0) {
return false;
}
free_mem = (julong)si.freeram * si.mem_unit;
log_trace(os)("free memory: " JULONG_FORMAT, free_mem);
return free_mem;
value = static_cast<size_t>(free_mem);
return true;
}
jlong os::total_swap_space() {
bool os::total_swap_space(size_t& value) {
if (OSContainer::is_containerized()) {
if (OSContainer::memory_limit_in_bytes() > 0) {
return (jlong)(OSContainer::memory_and_swap_limit_in_bytes() - OSContainer::memory_limit_in_bytes());
jlong memory_and_swap_limit_in_bytes = OSContainer::memory_and_swap_limit_in_bytes();
jlong memory_limit_in_bytes = OSContainer::memory_limit_in_bytes();
if (memory_limit_in_bytes > 0 && memory_and_swap_limit_in_bytes > 0) {
value = static_cast<size_t>(memory_and_swap_limit_in_bytes - memory_limit_in_bytes);
return true;
}
}
} // fallback to the host swap space if the container did return the unbound value of -1
struct sysinfo si;
int ret = sysinfo(&si);
if (ret != 0) {
return -1;
assert(false, "sysinfo failed in total_swap_space(): %s", os::strerror(errno));
return false;
}
return (jlong)(si.totalswap * si.mem_unit);
value = static_cast<size_t>(si.totalswap * si.mem_unit);
return true;
}
static jlong host_free_swap() {
static bool host_free_swap_f(size_t& value) {
struct sysinfo si;
int ret = sysinfo(&si);
if (ret != 0) {
return -1;
assert(false, "sysinfo failed in host_free_swap_f(): %s", os::strerror(errno));
return false;
}
return (jlong)(si.freeswap * si.mem_unit);
value = static_cast<size_t>(si.freeswap * si.mem_unit);
return true;
}
jlong os::free_swap_space() {
bool os::free_swap_space(size_t& value) {
// os::total_swap_space() might return the containerized limit which might be
// less than host_free_swap(). The upper bound of free swap needs to be the lower of the two.
jlong host_free_swap_val = MIN2(os::total_swap_space(), host_free_swap());
assert(host_free_swap_val >= 0, "sysinfo failed?");
size_t total_swap_space = 0;
size_t host_free_swap = 0;
if (!os::total_swap_space(total_swap_space) || !host_free_swap_f(host_free_swap)) {
return false;
}
size_t host_free_swap_val = MIN2(total_swap_space, host_free_swap);
if (OSContainer::is_containerized()) {
jlong mem_swap_limit = OSContainer::memory_and_swap_limit_in_bytes();
jlong mem_limit = OSContainer::memory_limit_in_bytes();
if (mem_swap_limit >= 0 && mem_limit >= 0) {
jlong delta_limit = mem_swap_limit - mem_limit;
if (delta_limit <= 0) {
return 0;
value = 0;
return true;
}
jlong mem_swap_usage = OSContainer::memory_and_swap_usage_in_bytes();
jlong mem_usage = OSContainer::memory_usage_in_bytes();
@ -322,30 +345,31 @@ jlong os::free_swap_space() {
jlong delta_usage = mem_swap_usage - mem_usage;
if (delta_usage >= 0) {
jlong free_swap = delta_limit - delta_usage;
return free_swap >= 0 ? free_swap : 0;
value = free_swap >= 0 ? static_cast<size_t>(free_swap) : 0;
return true;
}
}
}
// unlimited or not supported. Fall through to return host value
log_trace(os,container)("os::free_swap_space: container_swap_limit=" JLONG_FORMAT
" container_mem_limit=" JLONG_FORMAT " returning host value: " JLONG_FORMAT,
" container_mem_limit=" JLONG_FORMAT " returning host value: %zu",
mem_swap_limit, mem_limit, host_free_swap_val);
}
return host_free_swap_val;
value = host_free_swap_val;
return true;
}
julong os::physical_memory() {
jlong phys_mem = 0;
size_t os::physical_memory() {
if (OSContainer::is_containerized()) {
jlong mem_limit;
if ((mem_limit = OSContainer::memory_limit_in_bytes()) > 0) {
log_trace(os)("total container memory: " JLONG_FORMAT, mem_limit);
return mem_limit;
return static_cast<size_t>(mem_limit);
}
}
phys_mem = Linux::physical_memory();
log_trace(os)("total system memory: " JLONG_FORMAT, phys_mem);
size_t phys_mem = Linux::physical_memory();
log_trace(os)("total system memory: %zu", phys_mem);
return phys_mem;
}
@ -520,7 +544,7 @@ void os::Linux::initialize_system_info() {
fclose(fp);
}
}
_physical_memory = (julong)sysconf(_SC_PHYS_PAGES) * (julong)sysconf(_SC_PAGESIZE);
_physical_memory = static_cast<size_t>(sysconf(_SC_PHYS_PAGES)) * static_cast<size_t>(sysconf(_SC_PAGESIZE));
assert(processor_count() > 0, "linux error");
}
@ -2548,11 +2572,13 @@ void os::print_memory_info(outputStream* st) {
// values in struct sysinfo are "unsigned long"
struct sysinfo si;
sysinfo(&si);
st->print(", physical " UINT64_FORMAT "k",
os::physical_memory() >> 10);
st->print("(" UINT64_FORMAT "k free)",
os::available_memory() >> 10);
size_t phys_mem = 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);
st->print(", swap " UINT64_FORMAT "k",
((jlong)si.totalswap * si.mem_unit) >> 10);
st->print("(" UINT64_FORMAT "k free)",

8
src/hotspot/os/linux/os_linux.hpp
View File

@ -50,11 +50,11 @@ class os::Linux {
protected:
static julong _physical_memory;
static size_t _physical_memory;
static pthread_t _main_thread;
static julong available_memory();
static julong free_memory();
static bool available_memory(size_t& value);
static bool free_memory(size_t& value);
static void initialize_system_info();
@ -117,7 +117,7 @@ class os::Linux {
static address initial_thread_stack_bottom(void) { return _initial_thread_stack_bottom; }
static uintptr_t initial_thread_stack_size(void) { return _initial_thread_stack_size; }
static julong physical_memory() { return _physical_memory; }
static size_t physical_memory() { return _physical_memory; }
static julong host_swap();
static intptr_t* ucontext_get_sp(const ucontext_t* uc);

56
src/hotspot/os/windows/os_windows.cpp
View File

@ -848,39 +848,56 @@ jlong os::elapsed_frequency() {
}
julong os::available_memory() {
return win32::available_memory();
bool os::available_memory(size_t& value) {
return win32::available_memory(value);
}
julong os::free_memory() {
return win32::available_memory();
bool os::free_memory(size_t& value) {
return win32::available_memory(value);
}
julong os::win32::available_memory() {
bool os::win32::available_memory(size_t& value) {
// Use GlobalMemoryStatusEx() because GlobalMemoryStatus() may return incorrect
// value if total memory is larger than 4GB
MEMORYSTATUSEX ms;
ms.dwLength = sizeof(ms);
GlobalMemoryStatusEx(&ms);
return (julong)ms.ullAvailPhys;
BOOL res = GlobalMemoryStatusEx(&ms);
if (res == TRUE) {
value = static_cast<size_t>(ms.ullAvailPhys);
return true;
} else {
assert(false, "GlobalMemoryStatusEx failed in os::win32::available_memory(): %lu", ::GetLastError());
return false;
}
}
jlong os::total_swap_space() {
bool os::total_swap_space(size_t& value) {
MEMORYSTATUSEX ms;
ms.dwLength = sizeof(ms);
GlobalMemoryStatusEx(&ms);
return (jlong) ms.ullTotalPageFile;
BOOL res = GlobalMemoryStatusEx(&ms);
if (res == TRUE) {
value = static_cast<size_t>(ms.ullTotalPageFile);
return true;
} else {
assert(false, "GlobalMemoryStatusEx failed in os::total_swap_space(): %lu", ::GetLastError());
return false;
}
}
jlong os::free_swap_space() {
bool os::free_swap_space(size_t& value) {
MEMORYSTATUSEX ms;
ms.dwLength = sizeof(ms);
GlobalMemoryStatusEx(&ms);
return (jlong) ms.ullAvailPageFile;
BOOL res = GlobalMemoryStatusEx(&ms);
if (res == TRUE) {
value = static_cast<size_t>(ms.ullAvailPageFile);
return true;
} else {
assert(false, "GlobalMemoryStatusEx failed in os::free_swap_space(): %lu", ::GetLastError());
return false;
}
}
julong os::physical_memory() {
size_t os::physical_memory() {
return win32::physical_memory();
}
@ -3948,7 +3965,7 @@ int os::current_process_id() {
int os::win32::_processor_type = 0;
// Processor level is not available on non-NT systems, use vm_version instead
int os::win32::_processor_level = 0;
julong os::win32::_physical_memory = 0;
size_t os::win32::_physical_memory = 0;
bool os::win32::_is_windows_server = false;
@ -4178,8 +4195,11 @@ void os::win32::initialize_system_info() {
// also returns dwAvailPhys (free physical memory bytes), dwTotalVirtual, dwAvailVirtual,
// dwMemoryLoad (% of memory in use)
GlobalMemoryStatusEx(&ms);
_physical_memory = ms.ullTotalPhys;
BOOL res = GlobalMemoryStatusEx(&ms);
if (res != TRUE) {
assert(false, "GlobalMemoryStatusEx failed in os::win32::initialize_system_info(): %lu", ::GetLastError());
}
_physical_memory = static_cast<size_t>(ms.ullTotalPhys);
if (FLAG_IS_DEFAULT(MaxRAM)) {
// Adjust MaxRAM according to the maximum virtual address space available.

8
src/hotspot/os/windows/os_windows.hpp
View File

@ -40,7 +40,7 @@ class os::win32 {
protected:
static int _processor_type;
static int _processor_level;
static julong _physical_memory;
static size_t _physical_memory;
static bool _is_windows_server;
static bool _has_exit_bug;
static bool _processor_group_warning_displayed;
@ -102,9 +102,9 @@ class os::win32 {
static int processor_level() {
return _processor_level;
}
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; }
// load dll from Windows system directory or Windows directory
static HINSTANCE load_Windows_dll(const char* name, char *ebuf, int ebuflen);

4
src/hotspot/share/compiler/compileBroker.cpp
View File

@ -1061,7 +1061,9 @@ void CompileBroker::possibly_add_compiler_threads(JavaThread* THREAD) {
if (new_c2_count <= old_c2_count && new_c1_count <= old_c1_count) return;
// Now, we do the more expensive operations.
julong free_memory = os::free_memory();
size_t free_memory = 0;
// Return value ignored - defaulting to 0 on failure.
(void)os::free_memory(free_memory);
// If SegmentedCodeCache is off, both values refer to the single heap (with type CodeBlobType::All).
size_t available_cc_np = CodeCache::unallocated_capacity(CodeBlobType::MethodNonProfiled),
available_cc_p = CodeCache::unallocated_capacity(CodeBlobType::MethodProfiled);

5
src/hotspot/share/gc/shared/gcInitLogger.cpp
View File

@ -62,9 +62,8 @@ void GCInitLogger::print_cpu() {
}
void GCInitLogger::print_memory() {
julong memory = os::physical_memory();
log_info_p(gc, init)("Memory: " JULONG_FORMAT "%s",
byte_size_in_proper_unit(memory), proper_unit_for_byte_size(memory));
size_t memory = os::physical_memory();
log_info_p(gc, init)("Memory: " PROPERFMT, PROPERFMTARGS(memory));
}
void GCInitLogger::print_large_pages() {

3
src/hotspot/share/gc/z/zLargePages.cpp
View File

@ -31,7 +31,8 @@ bool ZLargePages::_os_enforced_transparent_mode;
void ZLargePages::initialize() {
pd_initialize();
log_info_p(gc, init)("Memory: " JULONG_FORMAT "M", os::physical_memory() / M);
const size_t memory = os::physical_memory();
log_info_p(gc, init)("Memory: " PROPERFMT, PROPERFMTARGS(memory));
log_info_p(gc, init)("Large Page Support: %s", to_string());
}

9
src/hotspot/share/jfr/jni/jfrJniMethod.cpp
View File

@ -412,9 +412,9 @@ JVM_ENTRY_NO_ENV(jlong, jfr_host_total_memory(JNIEnv* env, jclass jvm))
#ifdef LINUX
// We want the host memory, not the container limit.
// os::physical_memory() would return the container limit.
return os::Linux::physical_memory();
return static_cast<jlong>(os::Linux::physical_memory());
#else
return os::physical_memory();
return static_cast<jlong>(os::physical_memory());
#endif
JVM_END
@ -423,7 +423,10 @@ JVM_ENTRY_NO_ENV(jlong, jfr_host_total_swap_memory(JNIEnv* env, jclass jvm))
// We want the host swap memory, not the container value.
return os::Linux::host_swap();
#else
return os::total_swap_space();
size_t total_swap_space = 0;
// Return value ignored - defaulting to 0 on failure.
(void)os::total_swap_space(total_swap_space);
return static_cast<jlong>(total_swap_space);
#endif
JVM_END

17
src/hotspot/share/jfr/periodic/jfrPeriodic.cpp
View File

@ -528,17 +528,26 @@ TRACE_REQUEST_FUNC(ThreadAllocationStatistics) {
* the total memory reported is the amount of memory configured for the guest OS by the hypervisor.
*/
TRACE_REQUEST_FUNC(PhysicalMemory) {
u8 totalPhysicalMemory = os::physical_memory();
u8 totalPhysicalMemory = static_cast<u8>(os::physical_memory());
EventPhysicalMemory event;
event.set_totalSize(totalPhysicalMemory);
event.set_usedSize(totalPhysicalMemory - os::available_memory());
size_t avail_mem = 0;
// Return value ignored - defaulting to 0 on failure.
(void)os::available_memory(avail_mem);
event.set_usedSize(totalPhysicalMemory - static_cast<u8>(avail_mem));
event.commit();
}
TRACE_REQUEST_FUNC(SwapSpace) {
EventSwapSpace event;
event.set_totalSize(os::total_swap_space());
event.set_freeSize(os::free_swap_space());
size_t total_swap_space = 0;
// Return value ignored - defaulting to 0 on failure.
(void)os::total_swap_space(total_swap_space);
event.set_totalSize(static_cast<s8>(total_swap_space));
size_t free_swap_space = 0;
// Return value ignored - defaulting to 0 on failure.
(void)os::free_swap_space(free_swap_space);
event.set_freeSize(static_cast<s8>(free_swap_space));
event.commit();
}

20
src/hotspot/share/prims/jvmtiRedefineClasses.cpp
View File

@ -1358,10 +1358,12 @@ jvmtiError VM_RedefineClasses::load_new_class_versions() {
// constant pools
HandleMark hm(current);
InstanceKlass* the_class = get_ik(_class_defs[i].klass);
size_t avail_mem = 0;
// Return value ignored - defaulting to 0 on failure.
(void)os::available_memory(avail_mem);
log_debug(redefine, class, load)
("loading name=%s kind=%d (avail_mem=" UINT64_FORMAT "K)",
the_class->external_name(), _class_load_kind, os::available_memory() >> 10);
("loading name=%s kind=%d (avail_mem=%zuK)",
the_class->external_name(), _class_load_kind, avail_mem >> 10);
ClassFileStream st((u1*)_class_defs[i].class_bytes,
_class_defs[i].class_byte_count,
@ -1525,9 +1527,10 @@ jvmtiError VM_RedefineClasses::load_new_class_versions() {
return JVMTI_ERROR_INTERNAL;
}
}
// Return value ignored - defaulting to 0 on failure.
(void)os::available_memory(avail_mem);
log_debug(redefine, class, load)
("loaded name=%s (avail_mem=" UINT64_FORMAT "K)", the_class->external_name(), os::available_memory() >> 10);
("loaded name=%s (avail_mem=%zuK)", the_class->external_name(), avail_mem >> 10);
}
return JVMTI_ERROR_NONE;
@ -4435,9 +4438,12 @@ void VM_RedefineClasses::redefine_single_class(Thread* current, jclass the_jclas
ResourceMark rm(current);
// increment the classRedefinedCount field in the_class and in any
// direct and indirect subclasses of the_class
size_t avail_mem = 0;
// Return value ignored - defaulting to 0 on failure.
(void)os::available_memory(avail_mem);
log_info(redefine, class, load)
("redefined name=%s, count=%d (avail_mem=" UINT64_FORMAT "K)",
the_class->external_name(), java_lang_Class::classRedefinedCount(the_class->java_mirror()), os::available_memory() >> 10);
("redefined name=%s, count=%d (avail_mem=%zuK)",
the_class->external_name(), java_lang_Class::classRedefinedCount(the_class->java_mirror()), avail_mem >> 10);
Events::log_redefinition(current, "redefined class name=%s, count=%d",
the_class->external_name(),
java_lang_Class::classRedefinedCount(the_class->java_mirror()));

9
src/hotspot/share/prims/whitebox.cpp
View File

@ -2505,13 +2505,16 @@ WB_END
// Physical memory of the host machine (including containers)
WB_ENTRY(jlong, WB_HostPhysicalMemory(JNIEnv* env, jobject o))
LINUX_ONLY(return os::Linux::physical_memory();)
return os::physical_memory();
LINUX_ONLY(return static_cast<jlong>(os::Linux::physical_memory());)
return static_cast<jlong>(os::physical_memory());
WB_END
// Available memory of the host machine (container-aware)
WB_ENTRY(jlong, WB_HostAvailableMemory(JNIEnv* env, jobject o))
return os::available_memory();
size_t avail_mem = 0;
// Return value ignored - defaulting to 0 on failure.
(void)os::available_memory(avail_mem);
return static_cast<jlong>(avail_mem);
WB_END
// Physical swap of the host machine (including containers), Linux only.

7
src/hotspot/share/runtime/arguments.cpp
View File

@ -1517,13 +1517,13 @@ void Arguments::set_heap_size() {
!FLAG_IS_DEFAULT(MaxRAM));
if (override_coop_limit) {
if (FLAG_IS_DEFAULT(MaxRAM)) {
phys_mem = os::physical_memory();
phys_mem = static_cast<julong>(os::physical_memory());
FLAG_SET_ERGO(MaxRAM, (uint64_t)phys_mem);
} else {
phys_mem = (julong)MaxRAM;
}
} else {
phys_mem = FLAG_IS_DEFAULT(MaxRAM) ? MIN2(os::physical_memory(), (julong)MaxRAM)
phys_mem = FLAG_IS_DEFAULT(MaxRAM) ? MIN2(static_cast<julong>(os::physical_memory()), (julong)MaxRAM)
: (julong)MaxRAM;
}
@ -1645,7 +1645,8 @@ jint Arguments::set_aggressive_heap_flags() {
// Thus, we need to make sure we're using a julong for intermediate
// calculations.
julong initHeapSize;
julong total_memory = os::physical_memory();
size_t phys_mem = os::physical_memory();
julong total_memory = static_cast<julong>(phys_mem);
if (total_memory < (julong) 256 * M) {
jio_fprintf(defaultStream::error_stream(),

23
src/hotspot/share/runtime/os.cpp
View File

@ -1184,9 +1184,10 @@ void os::print_summary_info(outputStream* st, char* buf, size_t buflen) {
#endif // PRODUCT
get_summary_cpu_info(buf, buflen);
st->print("%s, ", buf);
size_t mem = physical_memory()/G;
size_t phys_mem = physical_memory();
size_t mem = phys_mem/G;
if (mem == 0) { // for low memory systems
mem = physical_memory()/M;
mem = phys_mem/M;
st->print("%d cores, %zuM, ", processor_count(), mem);
} else {
st->print("%d cores, %zuG, ", processor_count(), mem);
@ -1941,10 +1942,10 @@ bool os::is_server_class_machine() {
// We allow some part (1/8?) of the memory to be "missing",
// based on the sizes of DIMMs, and maybe graphics cards.
const julong missing_memory = 256UL * M;
size_t phys_mem = os::physical_memory();
/* Is this a server class machine? */
if ((os::active_processor_count() >= (int)server_processors) &&
(os::physical_memory() >= (server_memory - missing_memory))) {
(phys_mem >= (server_memory - missing_memory))) {
const unsigned int logical_processors =
VM_Version::logical_processors_per_package();
if (logical_processors > 1) {
@ -2203,16 +2204,24 @@ static void assert_nonempty_range(const char* addr, size_t bytes) {
p2i(addr), p2i(addr) + bytes);
}
julong os::used_memory() {
bool os::used_memory(size_t& value) {
#ifdef LINUX
if (OSContainer::is_containerized()) {
jlong mem_usage = OSContainer::memory_usage_in_bytes();
if (mem_usage > 0) {
return mem_usage;
value = static_cast<size_t>(mem_usage);
return true;
} else {
return false;
}
}
#endif
return os::physical_memory() - os::available_memory();
size_t avail_mem = 0;
// Return value ignored - defaulting to 0 on failure.
(void)os::available_memory(avail_mem);
size_t phys_mem = os::physical_memory();
value = phys_mem - avail_mem;
return true;
}

12
src/hotspot/share/runtime/os.hpp
View File

@ -332,14 +332,14 @@ class os: AllStatic {
// For example, on Linux, "available" memory (`MemAvailable` in `/proc/meminfo`) is greater
// than "free" memory (`MemFree` in `/proc/meminfo`) because Linux can free memory
// aggressively (e.g. clear caches) so that it becomes available.
static julong available_memory();
static julong used_memory();
static julong free_memory();
[[nodiscard]] static bool available_memory(size_t& value);
[[nodiscard]] static bool used_memory(size_t& value);
[[nodiscard]] static bool free_memory(size_t& value);
static jlong total_swap_space();
static jlong free_swap_space();
[[nodiscard]] static bool total_swap_space(size_t& value);
[[nodiscard]] static bool free_swap_space(size_t& value);
static julong physical_memory();
static size_t physical_memory();
static bool is_server_class_machine();
static size_t rss();

5
src/hotspot/share/services/heapDumper.cpp
View File

@ -2612,7 +2612,10 @@ int HeapDumper::dump(const char* path, outputStream* out, int compression, bool
// (DumpWriter buffer, DumperClassCacheTable, GZipCompressor buffers).
// For the OOM handling we may already be limited in memory.
// Lets ensure we have at least 20MB per thread.
julong max_threads = os::free_memory() / (20 * M);
size_t free_memory = 0;
// Return value ignored - defaulting to 0 on failure.
(void)os::free_memory(free_memory);
julong max_threads = free_memory / (20 * M);
if (num_dump_threads > max_threads) {
num_dump_threads = MAX2<uint>(1, (uint)max_threads);
}

2
src/hotspot/share/services/management.cpp
View File

@ -975,7 +975,7 @@ static jlong get_long_attribute(jmmLongAttribute att) {
return ClassLoadingService::class_method_data_size();
case JMM_OS_MEM_TOTAL_PHYSICAL_BYTES:
return os::physical_memory();
return static_cast<jlong>(os::physical_memory());
default:
return -1;