From 0da480a91d31ee8dc2532cfec76bbf5b1d6c4eeb Mon Sep 17 00:00:00 2001 From: Gerard Ziemski Date: Mon, 14 Apr 2025 18:47:59 +0000 Subject: [PATCH] 8354535: [BACKOUT] Force clients to explicitly pass mem_tag value, even if it is mtNone Reviewed-by: stefank, jsjolen --- .../cpu/aarch64/compressedKlass_aarch64.cpp | 4 +-- .../bsd/gc/z/zPhysicalMemoryBacking_bsd.cpp | 2 +- src/hotspot/os/linux/os_linux.cpp | 4 +-- src/hotspot/os/posix/os_posix.cpp | 4 +-- src/hotspot/os/posix/perfMemory_posix.cpp | 2 +- src/hotspot/os/windows/os_windows.cpp | 20 ++++++------- src/hotspot/os/windows/perfMemory_windows.cpp | 2 +- src/hotspot/share/cds/archiveBuilder.cpp | 3 +- src/hotspot/share/cds/filemap.cpp | 10 +++---- src/hotspot/share/cds/metaspaceShared.cpp | 12 +++----- .../share/classfile/compactHashtable.cpp | 2 +- src/hotspot/share/gc/g1/g1CollectedHeap.cpp | 3 +- .../share/gc/parallel/parMarkBitMap.cpp | 3 +- .../share/gc/parallel/psParallelCompact.cpp | 3 +- src/hotspot/share/gc/shared/cardTable.cpp | 2 +- .../gc/shenandoah/shenandoahCardTable.cpp | 4 +-- .../share/gc/shenandoah/shenandoahHeap.cpp | 6 ++-- .../jfr/recorder/storage/jfrVirtualMemory.cpp | 3 +- .../share/memory/allocation.inline.hpp | 4 +-- src/hotspot/share/memory/memoryReserver.cpp | 8 +++--- src/hotspot/share/memory/memoryReserver.hpp | 4 +-- src/hotspot/share/memory/metaspace.cpp | 5 ++-- .../share/memory/metaspace/testHelpers.cpp | 3 +- .../memory/metaspace/virtualSpaceNode.cpp | 2 +- src/hotspot/share/nmt/memReporter.cpp | 2 +- src/hotspot/share/nmt/memReporter.hpp | 2 +- src/hotspot/share/nmt/memTracker.hpp | 4 +-- .../share/nmt/virtualMemoryTracker.hpp | 4 +-- src/hotspot/share/prims/jni.cpp | 2 +- src/hotspot/share/prims/whitebox.cpp | 6 ++-- src/hotspot/share/runtime/os.cpp | 12 ++++---- src/hotspot/share/runtime/os.hpp | 16 +++++------ .../share/runtime/safepointMechanism.cpp | 2 +- src/hotspot/share/utilities/debug.cpp | 2 +- .../gtest/gc/g1/test_stressCommitUncommit.cpp | 10 +++---- test/hotspot/gtest/gc/z/test_zForwarding.cpp | 2 +- .../gtest/memory/test_virtualspace.cpp | 24 ++++++---------- .../gtest/nmt/test_nmt_locationprinting.cpp | 2 +- .../runtime/test_committed_virtualmemory.cpp | 6 ++-- test/hotspot/gtest/runtime/test_os.cpp | 28 +++++++++---------- test/hotspot/gtest/runtime/test_os_aix.cpp | 4 +-- test/hotspot/gtest/runtime/test_os_linux.cpp | 2 +- .../gtest/runtime/test_os_reserve_between.cpp | 6 ++-- .../runtime/NMT/MallocRoundingReportTest.java | 4 +-- .../jtreg/runtime/NMT/MallocTestType.java | 6 ++-- .../runtime/NMT/MallocTrackingVerify.java | 4 +-- .../runtime/NMT/ThreadedMallocTestType.java | 4 +-- 47 files changed, 126 insertions(+), 143 deletions(-) diff --git a/src/hotspot/cpu/aarch64/compressedKlass_aarch64.cpp b/src/hotspot/cpu/aarch64/compressedKlass_aarch64.cpp index 3874c8cd54e..0c2d9a32c8c 100644 --- a/src/hotspot/cpu/aarch64/compressedKlass_aarch64.cpp +++ b/src/hotspot/cpu/aarch64/compressedKlass_aarch64.cpp @@ -70,7 +70,7 @@ static char* reserve_at_eor_compatible_address(size_t size, bool aslr) { const uint64_t immediate = ((uint64_t)immediates[index]) << 32; assert(immediate > 0 && Assembler::operand_valid_for_logical_immediate(/*is32*/false, immediate), "Invalid immediate %d " UINT64_FORMAT, index, immediate); - result = os::attempt_reserve_memory_at((char*)immediate, size, mtNone); + result = os::attempt_reserve_memory_at((char*)immediate, size, false); if (result == nullptr) { log_trace(metaspace, map)("Failed to attach at " UINT64_FORMAT_X, immediate); } @@ -114,7 +114,7 @@ char* CompressedKlassPointers::reserve_address_space_for_compressed_classes(size if (result == nullptr) { constexpr size_t alignment = nth_bit(32); log_debug(metaspace, map)("Trying to reserve at a 32-bit-aligned address"); - result = os::reserve_memory_aligned(size, alignment, mtNone); + result = os::reserve_memory_aligned(size, alignment, false); } return result; diff --git a/src/hotspot/os/bsd/gc/z/zPhysicalMemoryBacking_bsd.cpp b/src/hotspot/os/bsd/gc/z/zPhysicalMemoryBacking_bsd.cpp index 861fda7a71d..86549e878cb 100644 --- a/src/hotspot/os/bsd/gc/z/zPhysicalMemoryBacking_bsd.cpp +++ b/src/hotspot/os/bsd/gc/z/zPhysicalMemoryBacking_bsd.cpp @@ -77,7 +77,7 @@ ZPhysicalMemoryBacking::ZPhysicalMemoryBacking(size_t max_capacity) _initialized(false) { // Reserve address space for backing memory - _base = (uintptr_t)os::reserve_memory(max_capacity, mtJavaHeap); + _base = (uintptr_t)os::reserve_memory(max_capacity, false, mtJavaHeap); if (_base == 0) { // Failed ZInitialize::error("Failed to reserve address space for backing memory"); diff --git a/src/hotspot/os/linux/os_linux.cpp b/src/hotspot/os/linux/os_linux.cpp index a8dce39ce5d..4e26797cd5b 100644 --- a/src/hotspot/os/linux/os_linux.cpp +++ b/src/hotspot/os/linux/os_linux.cpp @@ -4577,7 +4577,7 @@ static void workaround_expand_exec_shield_cs_limit() { */ char* hint = (char*)(os::Linux::initial_thread_stack_bottom() - (StackOverflow::stack_guard_zone_size() + page_size)); - char* codebuf = os::attempt_reserve_memory_at(hint, page_size, mtThread); + char* codebuf = os::attempt_reserve_memory_at(hint, page_size, false, mtThread); if (codebuf == nullptr) { // JDK-8197429: There may be a stack gap of one megabyte between @@ -4585,7 +4585,7 @@ static void workaround_expand_exec_shield_cs_limit() { // Linux kernel workaround for CVE-2017-1000364. If we failed to // map our codebuf, try again at an address one megabyte lower. hint -= 1 * M; - codebuf = os::attempt_reserve_memory_at(hint, page_size, mtThread); + codebuf = os::attempt_reserve_memory_at(hint, page_size, false, mtThread); } if ((codebuf == nullptr) || (!os::commit_memory(codebuf, page_size, true))) { diff --git a/src/hotspot/os/posix/os_posix.cpp b/src/hotspot/os/posix/os_posix.cpp index 8df488768be..a36d6b87641 100644 --- a/src/hotspot/os/posix/os_posix.cpp +++ b/src/hotspot/os/posix/os_posix.cpp @@ -491,9 +491,9 @@ static char* chop_extra_memory(size_t size, size_t alignment, char* extra_base, // Multiple threads can race in this code, and can remap over each other with MAP_FIXED, // so on posix, unmap the section at the start and at the end of the chunk that we mapped // rather than unmapping and remapping the whole chunk to get requested alignment. -char* os::reserve_memory_aligned(size_t size, size_t alignment, MemTag mem_tag, bool exec) { +char* os::reserve_memory_aligned(size_t size, size_t alignment, bool exec) { size_t extra_size = calculate_aligned_extra_size(size, alignment); - char* extra_base = os::reserve_memory(extra_size, mem_tag, exec); + char* extra_base = os::reserve_memory(extra_size, exec); if (extra_base == nullptr) { return nullptr; } diff --git a/src/hotspot/os/posix/perfMemory_posix.cpp b/src/hotspot/os/posix/perfMemory_posix.cpp index cbbecea3a6a..4d6fc1e4b8c 100644 --- a/src/hotspot/os/posix/perfMemory_posix.cpp +++ b/src/hotspot/os/posix/perfMemory_posix.cpp @@ -64,7 +64,7 @@ static char* backing_store_file_name = nullptr; // name of the backing store static char* create_standard_memory(size_t size) { // allocate an aligned chuck of memory - char* mapAddress = os::reserve_memory(size, mtInternal); + char* mapAddress = os::reserve_memory(size); if (mapAddress == nullptr) { return nullptr; diff --git a/src/hotspot/os/windows/os_windows.cpp b/src/hotspot/os/windows/os_windows.cpp index 843272f57b5..84e89334feb 100644 --- a/src/hotspot/os/windows/os_windows.cpp +++ b/src/hotspot/os/windows/os_windows.cpp @@ -3019,7 +3019,7 @@ static char* allocate_pages_individually(size_t bytes, char* addr, DWORD flags, PAGE_READWRITE); // If reservation failed, return null if (p_buf == nullptr) return nullptr; - MemTracker::record_virtual_memory_reserve((address)p_buf, size_of_reserve, CALLER_PC, mtNone); + MemTracker::record_virtual_memory_reserve((address)p_buf, size_of_reserve, CALLER_PC); os::release_memory(p_buf, bytes + chunk_size); // we still need to round up to a page boundary (in case we are using large pages) @@ -3080,7 +3080,7 @@ static char* allocate_pages_individually(size_t bytes, char* addr, DWORD flags, // need to create a dummy 'reserve' record to match // the release. MemTracker::record_virtual_memory_reserve((address)p_buf, - bytes_to_release, CALLER_PC, mtNone); + bytes_to_release, CALLER_PC); os::release_memory(p_buf, bytes_to_release); } #ifdef ASSERT @@ -3098,9 +3098,9 @@ static char* allocate_pages_individually(size_t bytes, char* addr, DWORD flags, // Although the memory is allocated individually, it is returned as one. // NMT records it as one block. if ((flags & MEM_COMMIT) != 0) { - MemTracker::record_virtual_memory_reserve_and_commit((address)p_buf, bytes, CALLER_PC, mtNone); + MemTracker::record_virtual_memory_reserve_and_commit((address)p_buf, bytes, CALLER_PC); } else { - MemTracker::record_virtual_memory_reserve((address)p_buf, bytes, CALLER_PC, mtNone); + MemTracker::record_virtual_memory_reserve((address)p_buf, bytes, CALLER_PC); } // made it this far, success @@ -3240,7 +3240,7 @@ char* os::replace_existing_mapping_with_file_mapping(char* base, size_t size, in // Multiple threads can race in this code but it's not possible to unmap small sections of // virtual space to get requested alignment, like posix-like os's. // Windows prevents multiple thread from remapping over each other so this loop is thread-safe. -static char* map_or_reserve_memory_aligned(size_t size, size_t alignment, int file_desc, MemTag mem_tag) { +static char* map_or_reserve_memory_aligned(size_t size, size_t alignment, int file_desc, MemTag mem_tag = mtNone) { assert(is_aligned(alignment, os::vm_allocation_granularity()), "Alignment must be a multiple of allocation granularity (page size)"); assert(is_aligned(size, os::vm_allocation_granularity()), @@ -3254,7 +3254,7 @@ static char* map_or_reserve_memory_aligned(size_t size, size_t alignment, int fi for (int attempt = 0; attempt < max_attempts && aligned_base == nullptr; attempt ++) { char* extra_base = file_desc != -1 ? os::map_memory_to_file(extra_size, file_desc, mem_tag) : - os::reserve_memory(extra_size, mem_tag); + os::reserve_memory(extra_size, false, mem_tag); if (extra_base == nullptr) { return nullptr; } @@ -3271,7 +3271,7 @@ static char* map_or_reserve_memory_aligned(size_t size, size_t alignment, int fi // Attempt to map, into the just vacated space, the slightly smaller aligned area. // Which may fail, hence the loop. aligned_base = file_desc != -1 ? os::attempt_map_memory_to_file_at(aligned_base, size, file_desc, mem_tag) : - os::attempt_reserve_memory_at(aligned_base, size, mem_tag); + os::attempt_reserve_memory_at(aligned_base, size, false, mem_tag); } assert(aligned_base != nullptr, @@ -3280,9 +3280,9 @@ static char* map_or_reserve_memory_aligned(size_t size, size_t alignment, int fi return aligned_base; } -char* os::reserve_memory_aligned(size_t size, size_t alignment, MemTag mem_tag, bool exec) { +char* os::reserve_memory_aligned(size_t size, size_t alignment, bool exec) { // exec can be ignored - return map_or_reserve_memory_aligned(size, alignment, -1/* file_desc */, mem_tag); + return map_or_reserve_memory_aligned(size, alignment, -1 /* file_desc */); } char* os::map_memory_to_file_aligned(size_t size, size_t alignment, int fd, MemTag mem_tag) { @@ -5187,7 +5187,7 @@ char* os::pd_map_memory(int fd, const char* file_name, size_t file_offset, } // Record virtual memory allocation - MemTracker::record_virtual_memory_reserve_and_commit((address)addr, bytes, CALLER_PC, mtNone); + MemTracker::record_virtual_memory_reserve_and_commit((address)addr, bytes, CALLER_PC); DWORD bytes_read; OVERLAPPED overlapped; diff --git a/src/hotspot/os/windows/perfMemory_windows.cpp b/src/hotspot/os/windows/perfMemory_windows.cpp index 322b844f413..dda0acde793 100644 --- a/src/hotspot/os/windows/perfMemory_windows.cpp +++ b/src/hotspot/os/windows/perfMemory_windows.cpp @@ -54,7 +54,7 @@ typedef BOOL (WINAPI *SetSecurityDescriptorControlFnPtr)( static char* create_standard_memory(size_t size) { // allocate an aligned chuck of memory - char* mapAddress = os::reserve_memory(size, mtInternal); + char* mapAddress = os::reserve_memory(size); if (mapAddress == nullptr) { return nullptr; diff --git a/src/hotspot/share/cds/archiveBuilder.cpp b/src/hotspot/share/cds/archiveBuilder.cpp index fa65d7d27bf..c309de17b4c 100644 --- a/src/hotspot/share/cds/archiveBuilder.cpp +++ b/src/hotspot/share/cds/archiveBuilder.cpp @@ -309,8 +309,7 @@ address ArchiveBuilder::reserve_buffer() { size_t buffer_size = LP64_ONLY(CompressedClassSpaceSize) NOT_LP64(256 * M); ReservedSpace rs = MemoryReserver::reserve(buffer_size, MetaspaceShared::core_region_alignment(), - os::vm_page_size(), - mtClassShared); + os::vm_page_size()); if (!rs.is_reserved()) { log_error(cds)("Failed to reserve %zu bytes of output buffer.", buffer_size); MetaspaceShared::unrecoverable_writing_error(); diff --git a/src/hotspot/share/cds/filemap.cpp b/src/hotspot/share/cds/filemap.cpp index 1b5d455485c..580699b60b5 100644 --- a/src/hotspot/share/cds/filemap.cpp +++ b/src/hotspot/share/cds/filemap.cpp @@ -1066,10 +1066,10 @@ void FileMapInfo::close() { */ static char* map_memory(int fd, const char* file_name, size_t file_offset, char *addr, size_t bytes, bool read_only, - bool allow_exec, MemTag mem_tag) { + bool allow_exec, MemTag mem_tag = mtNone) { char* mem = os::map_memory(fd, file_name, file_offset, addr, bytes, - mem_tag, AlwaysPreTouch ? false : read_only, - allow_exec); + AlwaysPreTouch ? false : read_only, + allow_exec, mem_tag); if (mem != nullptr && AlwaysPreTouch) { os::pretouch_memory(mem, mem + bytes); } @@ -1094,7 +1094,7 @@ bool FileMapInfo::remap_shared_readonly_as_readwrite() { assert(WINDOWS_ONLY(false) NOT_WINDOWS(true), "Don't call on Windows"); // Replace old mapping with new one that is writable. char *base = os::map_memory(_fd, _full_path, r->file_offset(), - addr, size, mtNone, false /* !read_only */, + addr, size, false /* !read_only */, r->allow_exec()); close(); // These have to be errors because the shared region is now unmapped. @@ -1620,7 +1620,7 @@ bool FileMapInfo::map_heap_region_impl() { } else { base = map_memory(_fd, _full_path, r->file_offset(), addr, _mapped_heap_memregion.byte_size(), r->read_only(), - r->allow_exec(), mtJavaHeap); + r->allow_exec()); if (base == nullptr || base != addr) { dealloc_heap_region(); log_info(cds)("UseSharedSpaces: Unable to map at required address in java heap. " diff --git a/src/hotspot/share/cds/metaspaceShared.cpp b/src/hotspot/share/cds/metaspaceShared.cpp index 3ca19858430..ef2a6dcb8e6 100644 --- a/src/hotspot/share/cds/metaspaceShared.cpp +++ b/src/hotspot/share/cds/metaspaceShared.cpp @@ -1537,8 +1537,7 @@ char* MetaspaceShared::reserve_address_space_for_archives(FileMapInfo* static_ma archive_space_rs = MemoryReserver::reserve((char*)base_address, archive_space_size, archive_space_alignment, - os::vm_page_size(), - mtNone); + os::vm_page_size()); if (archive_space_rs.is_reserved()) { assert(base_address == nullptr || (address)archive_space_rs.base() == base_address, "Sanity"); @@ -1606,13 +1605,11 @@ char* MetaspaceShared::reserve_address_space_for_archives(FileMapInfo* static_ma archive_space_rs = MemoryReserver::reserve((char*)base_address, archive_space_size, archive_space_alignment, - os::vm_page_size(), - mtNone); + os::vm_page_size()); class_space_rs = MemoryReserver::reserve((char*)ccs_base, class_space_size, class_space_alignment, - os::vm_page_size(), - mtNone); + os::vm_page_size()); } if (!archive_space_rs.is_reserved() || !class_space_rs.is_reserved()) { release_reserved_spaces(total_space_rs, archive_space_rs, class_space_rs); @@ -1625,8 +1622,7 @@ char* MetaspaceShared::reserve_address_space_for_archives(FileMapInfo* static_ma total_space_rs = MemoryReserver::reserve((char*) base_address, total_range_size, base_address_alignment, - os::vm_page_size(), - mtNone); + os::vm_page_size()); } else { // We did not manage to reserve at the preferred address, or were instructed to relocate. In that // case we reserve wherever possible, but the start address needs to be encodable as narrow Klass diff --git a/src/hotspot/share/classfile/compactHashtable.cpp b/src/hotspot/share/classfile/compactHashtable.cpp index 15ae5ba8013..8d50e8136a3 100644 --- a/src/hotspot/share/classfile/compactHashtable.cpp +++ b/src/hotspot/share/classfile/compactHashtable.cpp @@ -226,7 +226,7 @@ HashtableTextDump::HashtableTextDump(const char* filename) : _fd(-1) { if (_fd < 0) { quit("Unable to open hashtable dump file", filename); } - _base = os::map_memory(_fd, filename, 0, nullptr, _size, mtNone, true, false); + _base = os::map_memory(_fd, filename, 0, nullptr, _size, true, false); if (_base == nullptr) { quit("Unable to map hashtable dump file", filename); } diff --git a/src/hotspot/share/gc/g1/g1CollectedHeap.cpp b/src/hotspot/share/gc/g1/g1CollectedHeap.cpp index 44fb790f705..31f0cc12aa5 100644 --- a/src/hotspot/share/gc/g1/g1CollectedHeap.cpp +++ b/src/hotspot/share/gc/g1/g1CollectedHeap.cpp @@ -1230,8 +1230,7 @@ G1RegionToSpaceMapper* G1CollectedHeap::create_aux_memory_mapper(const char* des // Allocate a new reserved space, preferring to use large pages. ReservedSpace rs = MemoryReserver::reserve(size, alignment, - preferred_page_size, - mtGC); + preferred_page_size); size_t page_size = rs.page_size(); G1RegionToSpaceMapper* result = diff --git a/src/hotspot/share/gc/parallel/parMarkBitMap.cpp b/src/hotspot/share/gc/parallel/parMarkBitMap.cpp index d2d168cc2c0..f33d7f93f1d 100644 --- a/src/hotspot/share/gc/parallel/parMarkBitMap.cpp +++ b/src/hotspot/share/gc/parallel/parMarkBitMap.cpp @@ -48,8 +48,7 @@ ParMarkBitMap::initialize(MemRegion covered_region) ReservedSpace rs = MemoryReserver::reserve(_reserved_byte_size, rs_align, - page_sz, - mtGC); + page_sz); if (!rs.is_reserved()) { // Failed to reserve memory for the bitmap, diff --git a/src/hotspot/share/gc/parallel/psParallelCompact.cpp b/src/hotspot/share/gc/parallel/psParallelCompact.cpp index 84ed7798691..99b975c282a 100644 --- a/src/hotspot/share/gc/parallel/psParallelCompact.cpp +++ b/src/hotspot/share/gc/parallel/psParallelCompact.cpp @@ -246,8 +246,7 @@ ParallelCompactData::create_vspace(size_t count, size_t element_size) ReservedSpace rs = MemoryReserver::reserve(_reserved_byte_size, rs_align, - page_sz, - mtGC); + page_sz); if (!rs.is_reserved()) { // Failed to reserve memory. diff --git a/src/hotspot/share/gc/shared/cardTable.cpp b/src/hotspot/share/gc/shared/cardTable.cpp index 24546618edb..3236d73933c 100644 --- a/src/hotspot/share/gc/shared/cardTable.cpp +++ b/src/hotspot/share/gc/shared/cardTable.cpp @@ -80,7 +80,7 @@ void CardTable::initialize(void* region0_start, void* region1_start) { HeapWord* high_bound = _whole_heap.end(); const size_t rs_align = MAX2(_page_size, os::vm_allocation_granularity()); - ReservedSpace rs = MemoryReserver::reserve(_byte_map_size, rs_align, _page_size, mtGC); + ReservedSpace rs = MemoryReserver::reserve(_byte_map_size, rs_align, _page_size); if (!rs.is_reserved()) { vm_exit_during_initialization("Could not reserve enough space for the " diff --git a/src/hotspot/share/gc/shenandoah/shenandoahCardTable.cpp b/src/hotspot/share/gc/shenandoah/shenandoahCardTable.cpp index e9e52475fb9..00f11938489 100644 --- a/src/hotspot/share/gc/shenandoah/shenandoahCardTable.cpp +++ b/src/hotspot/share/gc/shenandoah/shenandoahCardTable.cpp @@ -45,7 +45,7 @@ void ShenandoahCardTable::initialize() { // ReservedSpace constructor would assert rs_align >= os::vm_page_size(). const size_t rs_align = MAX2(_page_size, granularity); - ReservedSpace write_space = MemoryReserver::reserve(_byte_map_size, rs_align, _page_size, mtGC); + ReservedSpace write_space = MemoryReserver::reserve(_byte_map_size, rs_align, _page_size); initialize(write_space); // The assembler store_check code will do an unsigned shift of the oop, @@ -60,7 +60,7 @@ void ShenandoahCardTable::initialize() { _write_byte_map = _byte_map; _write_byte_map_base = _byte_map_base; - ReservedSpace read_space = MemoryReserver::reserve(_byte_map_size, rs_align, _page_size, mtGC); + ReservedSpace read_space = MemoryReserver::reserve(_byte_map_size, rs_align, _page_size); initialize(read_space); _read_byte_map = (CardValue*) read_space.base(); diff --git a/src/hotspot/share/gc/shenandoah/shenandoahHeap.cpp b/src/hotspot/share/gc/shenandoah/shenandoahHeap.cpp index ce4b9fc2406..045f485090d 100644 --- a/src/hotspot/share/gc/shenandoah/shenandoahHeap.cpp +++ b/src/hotspot/share/gc/shenandoah/shenandoahHeap.cpp @@ -166,7 +166,7 @@ static ReservedSpace reserve(size_t size, size_t preferred_page_size) { size = align_up(size, alignment); } - const ReservedSpace reserved = MemoryReserver::reserve(size, alignment, preferred_page_size, mtGC); + const ReservedSpace reserved = MemoryReserver::reserve(size, alignment, preferred_page_size); if (!reserved.is_reserved()) { vm_exit_during_initialization("Could not reserve space"); } @@ -380,7 +380,7 @@ jint ShenandoahHeap::initialize() { for (uintptr_t addr = min; addr <= max; addr <<= 1u) { char* req_addr = (char*)addr; assert(is_aligned(req_addr, cset_align), "Should be aligned"); - cset_rs = MemoryReserver::reserve(req_addr, cset_size, cset_align, cset_page_size, mtGC); + cset_rs = MemoryReserver::reserve(req_addr, cset_size, cset_align, cset_page_size); if (cset_rs.is_reserved()) { assert(cset_rs.base() == req_addr, "Allocated where requested: " PTR_FORMAT ", " PTR_FORMAT, p2i(cset_rs.base()), addr); _collection_set = new ShenandoahCollectionSet(this, cset_rs, sh_rs.base()); @@ -389,7 +389,7 @@ jint ShenandoahHeap::initialize() { } if (_collection_set == nullptr) { - cset_rs = MemoryReserver::reserve(cset_size, cset_align, os::vm_page_size(), mtGC); + cset_rs = MemoryReserver::reserve(cset_size, cset_align, os::vm_page_size()); if (!cset_rs.is_reserved()) { vm_exit_during_initialization("Cannot reserve memory for collection set"); } diff --git a/src/hotspot/share/jfr/recorder/storage/jfrVirtualMemory.cpp b/src/hotspot/share/jfr/recorder/storage/jfrVirtualMemory.cpp index 0ba54fc79be..97f2b8a1990 100644 --- a/src/hotspot/share/jfr/recorder/storage/jfrVirtualMemory.cpp +++ b/src/hotspot/share/jfr/recorder/storage/jfrVirtualMemory.cpp @@ -106,8 +106,7 @@ bool JfrVirtualMemorySegment::initialize(size_t reservation_size_request_bytes) assert(is_aligned(reservation_size_request_bytes, os::vm_allocation_granularity()), "invariant"); _rs = MemoryReserver::reserve(reservation_size_request_bytes, os::vm_allocation_granularity(), - os::vm_page_size(), - mtTracing); + os::vm_page_size()); if (!_rs.is_reserved()) { return false; } diff --git a/src/hotspot/share/memory/allocation.inline.hpp b/src/hotspot/share/memory/allocation.inline.hpp index 01af1616ce1..8d531c6dd23 100644 --- a/src/hotspot/share/memory/allocation.inline.hpp +++ b/src/hotspot/share/memory/allocation.inline.hpp @@ -58,7 +58,7 @@ template E* MmapArrayAllocator::allocate_or_null(size_t length, MemTag mem_tag) { size_t size = size_for(length); - char* addr = os::reserve_memory(size, mem_tag); + char* addr = os::reserve_memory(size, !ExecMem, mem_tag); if (addr == nullptr) { return nullptr; } @@ -75,7 +75,7 @@ template E* MmapArrayAllocator::allocate(size_t length, MemTag mem_tag) { size_t size = size_for(length); - char* addr = os::reserve_memory(size, mem_tag); + char* addr = os::reserve_memory(size, !ExecMem, mem_tag); if (addr == nullptr) { vm_exit_out_of_memory(size, OOM_MMAP_ERROR, "Allocator (reserve)"); } diff --git a/src/hotspot/share/memory/memoryReserver.cpp b/src/hotspot/share/memory/memoryReserver.cpp index 457818139cd..43cc71355ff 100644 --- a/src/hotspot/share/memory/memoryReserver.cpp +++ b/src/hotspot/share/memory/memoryReserver.cpp @@ -90,13 +90,13 @@ static char* reserve_memory_inner(char* requested_address, assert(is_aligned(requested_address, alignment), "Requested address " PTR_FORMAT " must be aligned to %zu", p2i(requested_address), alignment); - return os::attempt_reserve_memory_at(requested_address, size, mem_tag, exec); + return os::attempt_reserve_memory_at(requested_address, size, exec, mem_tag); } // Optimistically assume that the OS returns an aligned base pointer. // When reserving a large address range, most OSes seem to align to at // least 64K. - char* base = os::reserve_memory(size, mem_tag, exec); + char* base = os::reserve_memory(size, exec, mem_tag); if (is_aligned(base, alignment)) { return base; } @@ -107,7 +107,7 @@ static char* reserve_memory_inner(char* requested_address, } // Map using the requested alignment. - return os::reserve_memory_aligned(size, alignment, mem_tag, exec); + return os::reserve_memory_aligned(size, alignment, exec); } ReservedSpace MemoryReserver::reserve_memory(char* requested_address, @@ -261,7 +261,7 @@ static char* map_memory_to_file(char* requested_address, // Optimistically assume that the OS returns an aligned base pointer. // When reserving a large address range, most OSes seem to align to at // least 64K. - char* base = os::map_memory_to_file(size, fd, mem_tag); + char* base = os::map_memory_to_file(size, fd); if (is_aligned(base, alignment)) { return base; } diff --git a/src/hotspot/share/memory/memoryReserver.hpp b/src/hotspot/share/memory/memoryReserver.hpp index f8f642cca95..1e16ec252a9 100644 --- a/src/hotspot/share/memory/memoryReserver.hpp +++ b/src/hotspot/share/memory/memoryReserver.hpp @@ -58,12 +58,12 @@ public: size_t size, size_t alignment, size_t page_size, - MemTag mem_tag); + MemTag mem_tag = mtNone); static ReservedSpace reserve(size_t size, size_t alignment, size_t page_size, - MemTag mem_tag); + MemTag mem_tag = mtNone); static ReservedSpace reserve(size_t size, MemTag mem_tag); diff --git a/src/hotspot/share/memory/metaspace.cpp b/src/hotspot/share/memory/metaspace.cpp index 33cd4a75d7e..04e5d807f32 100644 --- a/src/hotspot/share/memory/metaspace.cpp +++ b/src/hotspot/share/memory/metaspace.cpp @@ -594,7 +594,7 @@ ReservedSpace Metaspace::reserve_address_space_for_compressed_classes(size_t siz if (result == nullptr) { // Fallback: reserve anywhere log_debug(metaspace, map)("Trying anywhere..."); - result = os::reserve_memory_aligned(size, Metaspace::reserve_alignment(), mtClass); + result = os::reserve_memory_aligned(size, Metaspace::reserve_alignment(), false); } // Wrap resulting range in ReservedSpace @@ -767,8 +767,7 @@ void Metaspace::global_initialize() { rs = MemoryReserver::reserve((char*)base, size, Metaspace::reserve_alignment(), - os::vm_page_size(), - mtClass); + os::vm_page_size()); if (rs.is_reserved()) { log_info(metaspace)("Successfully forced class space address to " PTR_FORMAT, p2i(base)); diff --git a/src/hotspot/share/memory/metaspace/testHelpers.cpp b/src/hotspot/share/memory/metaspace/testHelpers.cpp index f06f6c855be..76fa1e36c45 100644 --- a/src/hotspot/share/memory/metaspace/testHelpers.cpp +++ b/src/hotspot/share/memory/metaspace/testHelpers.cpp @@ -82,7 +82,7 @@ MetaspaceTestContext::MetaspaceTestContext(const char* name, size_t commit_limit reserve_limit, Metaspace::reserve_alignment_words()); if (reserve_limit > 0) { // have reserve limit -> non-expandable context - _rs = MemoryReserver::reserve(reserve_limit * BytesPerWord, Metaspace::reserve_alignment(), os::vm_page_size(), mtTest); + _rs = MemoryReserver::reserve(reserve_limit * BytesPerWord, Metaspace::reserve_alignment(), os::vm_page_size()); _context = MetaspaceContext::create_nonexpandable_context(name, _rs, &_commit_limiter); } else { // no reserve limit -> expandable vslist @@ -142,3 +142,4 @@ size_t MetaspaceTestContext::reserved_words() const { } } // namespace metaspace + diff --git a/src/hotspot/share/memory/metaspace/virtualSpaceNode.cpp b/src/hotspot/share/memory/metaspace/virtualSpaceNode.cpp index bb59192cf16..66644c805a9 100644 --- a/src/hotspot/share/memory/metaspace/virtualSpaceNode.cpp +++ b/src/hotspot/share/memory/metaspace/virtualSpaceNode.cpp @@ -256,7 +256,7 @@ VirtualSpaceNode* VirtualSpaceNode::create_node(size_t word_size, ReservedSpace rs = MemoryReserver::reserve(word_size * BytesPerWord, Settings::virtual_space_node_reserve_alignment_words() * BytesPerWord, - os::vm_page_size(), mtMetaspace); + os::vm_page_size()); if (!rs.is_reserved()) { vm_exit_out_of_memory(word_size * BytesPerWord, OOM_MMAP_ERROR, "Failed to reserve memory for metaspace"); } diff --git a/src/hotspot/share/nmt/memReporter.cpp b/src/hotspot/share/nmt/memReporter.cpp index 512e1975929..c7327782a4a 100644 --- a/src/hotspot/share/nmt/memReporter.cpp +++ b/src/hotspot/share/nmt/memReporter.cpp @@ -249,7 +249,7 @@ void MemSummaryReporter::report_summary_of_tag(MemTag mem_tag, // report malloc'd memory if (amount_in_current_scale(MAX2(malloc_memory->malloc_size(), pk_malloc)) > 0) { - print_malloc(malloc_memory->malloc_counter(), mem_tag); + print_malloc(malloc_memory->malloc_counter()); out->cr(); } diff --git a/src/hotspot/share/nmt/memReporter.hpp b/src/hotspot/share/nmt/memReporter.hpp index 2238d42f15f..05b1588f38b 100644 --- a/src/hotspot/share/nmt/memReporter.hpp +++ b/src/hotspot/share/nmt/memReporter.hpp @@ -108,7 +108,7 @@ class MemReporterBase : public StackObj { // Print summary total, malloc and virtual memory void print_total(size_t reserved, size_t committed, size_t peak = 0) const; - void print_malloc(const MemoryCounter* c, MemTag mem_tag) const; + void print_malloc(const MemoryCounter* c, MemTag mem_tag = mtNone) const; void print_virtual_memory(size_t reserved, size_t committed, size_t peak) const; void print_arena(const MemoryCounter* c) const; diff --git a/src/hotspot/share/nmt/memTracker.hpp b/src/hotspot/share/nmt/memTracker.hpp index 3918e81dab7..981e991a41e 100644 --- a/src/hotspot/share/nmt/memTracker.hpp +++ b/src/hotspot/share/nmt/memTracker.hpp @@ -127,7 +127,7 @@ class MemTracker : AllStatic { // (we do not do any reservations before that). static inline void record_virtual_memory_reserve(void* addr, size_t size, const NativeCallStack& stack, - MemTag mem_tag) { + MemTag mem_tag = mtNone) { assert_post_init(); if (!enabled()) return; if (addr != nullptr) { @@ -153,7 +153,7 @@ class MemTracker : AllStatic { } static inline void record_virtual_memory_reserve_and_commit(void* addr, size_t size, - const NativeCallStack& stack, MemTag mem_tag) { + const NativeCallStack& stack, MemTag mem_tag = mtNone) { assert_post_init(); if (!enabled()) return; if (addr != nullptr) { diff --git a/src/hotspot/share/nmt/virtualMemoryTracker.hpp b/src/hotspot/share/nmt/virtualMemoryTracker.hpp index 2b3b5722571..74d299e6637 100644 --- a/src/hotspot/share/nmt/virtualMemoryTracker.hpp +++ b/src/hotspot/share/nmt/virtualMemoryTracker.hpp @@ -297,7 +297,7 @@ class ReservedMemoryRegion : public VirtualMemoryRegion { public: ReservedMemoryRegion(address base, size_t size, const NativeCallStack& stack, - MemTag mem_tag) : + MemTag mem_tag = mtNone) : VirtualMemoryRegion(base, size), _stack(stack), _mem_tag(mem_tag) { } @@ -380,7 +380,7 @@ class VirtualMemoryTracker : AllStatic { public: static bool initialize(NMT_TrackingLevel level); - static bool add_reserved_region (address base_addr, size_t size, const NativeCallStack& stack, MemTag mem_tag); + static bool add_reserved_region (address base_addr, size_t size, const NativeCallStack& stack, MemTag mem_tag = mtNone); static bool add_committed_region (address base_addr, size_t size, const NativeCallStack& stack); static bool remove_uncommitted_region (address base_addr, size_t size); diff --git a/src/hotspot/share/prims/jni.cpp b/src/hotspot/share/prims/jni.cpp index c988745f7b6..d2916fad185 100644 --- a/src/hotspot/share/prims/jni.cpp +++ b/src/hotspot/share/prims/jni.cpp @@ -2400,7 +2400,7 @@ static char* get_bad_address() { static char* bad_address = nullptr; if (bad_address == nullptr) { size_t size = os::vm_allocation_granularity(); - bad_address = os::reserve_memory(size, mtInternal); + bad_address = os::reserve_memory(size, false, mtInternal); if (bad_address != nullptr) { os::protect_memory(bad_address, size, os::MEM_PROT_READ, /*is_committed*/false); diff --git a/src/hotspot/share/prims/whitebox.cpp b/src/hotspot/share/prims/whitebox.cpp index 884fbf98138..e08a5ba5ebd 100644 --- a/src/hotspot/share/prims/whitebox.cpp +++ b/src/hotspot/share/prims/whitebox.cpp @@ -728,11 +728,11 @@ WB_ENTRY(void, WB_NMTFree(JNIEnv* env, jobject o, jlong mem)) WB_END WB_ENTRY(jlong, WB_NMTReserveMemory(JNIEnv* env, jobject o, jlong size)) - return (jlong)(uintptr_t)os::reserve_memory(size, mtTest); + return (jlong)(uintptr_t)os::reserve_memory(size, false, mtTest); WB_END WB_ENTRY(jlong, WB_NMTAttemptReserveMemoryAt(JNIEnv* env, jobject o, jlong addr, jlong size)) - return (jlong)(uintptr_t)os::attempt_reserve_memory_at((char*)(uintptr_t)addr, (size_t)size, mtTest); + return (jlong)(uintptr_t)os::attempt_reserve_memory_at((char*)(uintptr_t)addr, (size_t)size, false, mtTest); WB_END WB_ENTRY(void, WB_NMTCommitMemory(JNIEnv* env, jobject o, jlong addr, jlong size)) @@ -1524,7 +1524,7 @@ WB_ENTRY(void, WB_ReadReservedMemory(JNIEnv* env, jobject o)) static char c; static volatile char* p; - p = os::reserve_memory(os::vm_allocation_granularity(), mtTest); + p = os::reserve_memory(os::vm_allocation_granularity()); if (p == nullptr) { THROW_MSG(vmSymbols::java_lang_OutOfMemoryError(), "Failed to reserve memory"); } diff --git a/src/hotspot/share/runtime/os.cpp b/src/hotspot/share/runtime/os.cpp index 7695fed564d..cbe40ca214b 100644 --- a/src/hotspot/share/runtime/os.cpp +++ b/src/hotspot/share/runtime/os.cpp @@ -1916,7 +1916,7 @@ bool os::create_stack_guard_pages(char* addr, size_t bytes) { return os::pd_create_stack_guard_pages(addr, bytes); } -char* os::reserve_memory(size_t bytes, MemTag mem_tag, bool executable) { +char* os::reserve_memory(size_t bytes, bool executable, MemTag mem_tag) { char* result = pd_reserve_memory(bytes, executable); if (result != nullptr) { MemTracker::record_virtual_memory_reserve(result, bytes, CALLER_PC, mem_tag); @@ -1927,7 +1927,7 @@ char* os::reserve_memory(size_t bytes, MemTag mem_tag, bool executable) { return result; } -char* os::attempt_reserve_memory_at(char* addr, size_t bytes, MemTag mem_tag, bool executable) { +char* os::attempt_reserve_memory_at(char* addr, size_t bytes, bool executable, MemTag mem_tag) { char* result = SimulateFullAddressSpace ? nullptr : pd_attempt_reserve_memory_at(addr, bytes, executable); if (result != nullptr) { MemTracker::record_virtual_memory_reserve((address)result, bytes, CALLER_PC, mem_tag); @@ -2133,7 +2133,7 @@ char* os::attempt_reserve_memory_between(char* min, char* max, size_t bytes, siz assert(is_aligned(result, alignment), "alignment invalid (" ERRFMT ")", ERRFMTARGS); log_trace(os, map)(ERRFMT, ERRFMTARGS); log_debug(os, map)("successfully attached at " PTR_FORMAT, p2i(result)); - MemTracker::record_virtual_memory_reserve((address)result, bytes, CALLER_PC, mtNone); + MemTracker::record_virtual_memory_reserve((address)result, bytes, CALLER_PC); } else { log_debug(os, map)("failed to attach anywhere in [" PTR_FORMAT "-" PTR_FORMAT ")", p2i(min), p2i(max)); } @@ -2300,8 +2300,8 @@ char* os::attempt_map_memory_to_file_at(char* addr, size_t bytes, int file_desc, } char* os::map_memory(int fd, const char* file_name, size_t file_offset, - char *addr, size_t bytes, MemTag mem_tag, - bool read_only, bool allow_exec) { + char *addr, size_t bytes, bool read_only, + bool allow_exec, MemTag mem_tag) { char* result = pd_map_memory(fd, file_name, file_offset, addr, bytes, read_only, allow_exec); if (result != nullptr) { MemTracker::record_virtual_memory_reserve_and_commit((address)result, bytes, CALLER_PC, mem_tag); @@ -2339,7 +2339,7 @@ char* os::reserve_memory_special(size_t size, size_t alignment, size_t page_size char* result = pd_reserve_memory_special(size, alignment, page_size, addr, executable); if (result != nullptr) { // The memory is committed - MemTracker::record_virtual_memory_reserve_and_commit((address)result, size, CALLER_PC, mtNone); + MemTracker::record_virtual_memory_reserve_and_commit((address)result, size, CALLER_PC); log_debug(os, map)("Reserved and committed " RANGEFMT, RANGEFMTARGS(result, size)); } else { log_info(os, map)("Reserve and commit failed (%zu bytes)", size); diff --git a/src/hotspot/share/runtime/os.hpp b/src/hotspot/share/runtime/os.hpp index b9a3bf564f7..242959034af 100644 --- a/src/hotspot/share/runtime/os.hpp +++ b/src/hotspot/share/runtime/os.hpp @@ -457,14 +457,14 @@ class os: AllStatic { inline static size_t cds_core_region_alignment(); // Reserves virtual memory. - static char* reserve_memory(size_t bytes, MemTag mem_tag, bool executable = false); + static char* reserve_memory(size_t bytes, bool executable = false, MemTag mem_tag = mtNone); // Reserves virtual memory that starts at an address that is aligned to 'alignment'. - static char* reserve_memory_aligned(size_t size, size_t alignment, MemTag mem_tag, bool executable = false); + static char* reserve_memory_aligned(size_t size, size_t alignment, bool executable = false); // Attempts to reserve the virtual memory at [addr, addr + bytes). // Does not overwrite existing mappings. - static char* attempt_reserve_memory_at(char* addr, size_t bytes, MemTag mem_tag, bool executable = false); + static char* attempt_reserve_memory_at(char* addr, size_t bytes, bool executable = false, MemTag mem_tag = mtNone); // Given an address range [min, max), attempts to reserve memory within this area, with the given alignment. // If randomize is true, the location will be randomized. @@ -516,16 +516,16 @@ class os: AllStatic { static int create_file_for_heap(const char* dir); // Map memory to the file referred by fd. This function is slightly different from map_memory() // and is added to be used for implementation of -XX:AllocateHeapAt - static char* map_memory_to_file(size_t size, int fd, MemTag mem_tag); - static char* map_memory_to_file_aligned(size_t size, size_t alignment, int fd, MemTag mem_tag); + static char* map_memory_to_file(size_t size, int fd, MemTag mem_tag = mtNone); + static char* map_memory_to_file_aligned(size_t size, size_t alignment, int fd, MemTag mem_tag = mtNone); static char* map_memory_to_file(char* base, size_t size, int fd); - static char* attempt_map_memory_to_file_at(char* base, size_t size, int fd, MemTag mem_tag); + static char* attempt_map_memory_to_file_at(char* base, size_t size, int fd, MemTag mem_tag = mtNone); // Replace existing reserved memory with file mapping static char* replace_existing_mapping_with_file_mapping(char* base, size_t size, int fd); static char* map_memory(int fd, const char* file_name, size_t file_offset, - char *addr, size_t bytes, MemTag mem_tag, bool read_only = false, - bool allow_exec = false); + char *addr, size_t bytes, bool read_only = false, + bool allow_exec = false, MemTag mem_tag = mtNone); static bool unmap_memory(char *addr, size_t bytes); static void disclaim_memory(char *addr, size_t bytes); static void realign_memory(char *addr, size_t bytes, size_t alignment_hint); diff --git a/src/hotspot/share/runtime/safepointMechanism.cpp b/src/hotspot/share/runtime/safepointMechanism.cpp index 71224bbff4c..51038d764bb 100644 --- a/src/hotspot/share/runtime/safepointMechanism.cpp +++ b/src/hotspot/share/runtime/safepointMechanism.cpp @@ -57,7 +57,7 @@ void SafepointMechanism::default_initialize() { // Polling page const size_t page_size = os::vm_page_size(); const size_t allocation_size = 2 * page_size; - char* polling_page = os::reserve_memory(allocation_size, mtSafepoint); + char* polling_page = os::reserve_memory(allocation_size, !ExecMem, mtSafepoint); os::commit_memory_or_exit(polling_page, allocation_size, !ExecMem, "Unable to commit Safepoint polling page"); char* bad_page = polling_page; diff --git a/src/hotspot/share/utilities/debug.cpp b/src/hotspot/share/utilities/debug.cpp index abe3d6757b5..9413f1f72d7 100644 --- a/src/hotspot/share/utilities/debug.cpp +++ b/src/hotspot/share/utilities/debug.cpp @@ -712,7 +712,7 @@ struct TestMultipleStaticAssertFormsInClassScope { // Support for showing register content on asserts/guarantees. #ifdef CAN_SHOW_REGISTERS_ON_ASSERT void initialize_assert_poison() { - char* page = os::reserve_memory(os::vm_page_size(), mtInternal); + char* page = os::reserve_memory(os::vm_page_size(), !ExecMem, mtInternal); if (page) { if (os::commit_memory(page, os::vm_page_size(), !ExecMem) && os::protect_memory(page, os::vm_page_size(), os::MEM_PROT_NONE)) { diff --git a/test/hotspot/gtest/gc/g1/test_stressCommitUncommit.cpp b/test/hotspot/gtest/gc/g1/test_stressCommitUncommit.cpp index 45da22ce116..bc0ed0f3c59 100644 --- a/test/hotspot/gtest/gc/g1/test_stressCommitUncommit.cpp +++ b/test/hotspot/gtest/gc/g1/test_stressCommitUncommit.cpp @@ -82,8 +82,7 @@ TEST_VM(G1RegionToSpaceMapper, smallStressAdjacent) { ReservedSpace rs = MemoryReserver::reserve(size, os::vm_allocation_granularity(), - os::vm_page_size(), - mtTest); + os::vm_page_size()); G1RegionToSpaceMapper* small_mapper = G1RegionToSpaceMapper::create_mapper(rs, @@ -91,7 +90,7 @@ TEST_VM(G1RegionToSpaceMapper, smallStressAdjacent) { page_size, region_size, G1BlockOffsetTable::heap_map_factor(), - mtTest); + mtGC); @@ -109,15 +108,14 @@ TEST_VM(G1RegionToSpaceMapper, largeStressAdjacent) { ReservedSpace rs = MemoryReserver::reserve(size, os::vm_allocation_granularity(), - os::vm_page_size(), - mtTest); + os::vm_page_size()); G1RegionToSpaceMapper* large_mapper = G1RegionToSpaceMapper::create_mapper(rs, size, page_size, region_size, G1BlockOffsetTable::heap_map_factor(), - mtTest); + mtGC); G1TestCommitUncommit task(large_mapper); G1MapperWorkers::run_task(&task); diff --git a/test/hotspot/gtest/gc/z/test_zForwarding.cpp b/test/hotspot/gtest/gc/z/test_zForwarding.cpp index f22eef50858..71fb83827c7 100644 --- a/test/hotspot/gtest/gc/z/test_zForwarding.cpp +++ b/test/hotspot/gtest/gc/z/test_zForwarding.cpp @@ -56,7 +56,7 @@ public: const size_t increment = MAX2(align_up(unused / 100, ZGranuleSize), ZGranuleSize); for (uintptr_t start = 0; start + ZGranuleSize <= ZAddressOffsetMax; start += increment) { - char* const reserved = os::attempt_reserve_memory_at((char*)ZAddressHeapBase + start, ZGranuleSize, mtTest); + char* const reserved = os::attempt_reserve_memory_at((char*)ZAddressHeapBase + start, ZGranuleSize, false /* executable */); if (reserved != nullptr) { // Success return reserved; diff --git a/test/hotspot/gtest/memory/test_virtualspace.cpp b/test/hotspot/gtest/memory/test_virtualspace.cpp index d2f8927ba28..d3fed31da0b 100644 --- a/test/hotspot/gtest/memory/test_virtualspace.cpp +++ b/test/hotspot/gtest/memory/test_virtualspace.cpp @@ -73,7 +73,7 @@ namespace { static void test_reserved_size_alignment(size_t size, size_t alignment) { ASSERT_PRED2(is_size_aligned, size, alignment) << "Incorrect input parameters"; size_t page_size = UseLargePages ? os::large_page_size() : os::vm_page_size(); - ReservedSpace rs = MemoryReserver::reserve(size, alignment, page_size, mtTest); + ReservedSpace rs = MemoryReserver::reserve(size, alignment, page_size); ASSERT_TRUE(rs.base() != nullptr) << "rs.special = " << rs.special(); ASSERT_EQ(size, rs.size()) << "rs.special = " << rs.special(); @@ -101,7 +101,7 @@ namespace { bool large = maybe_large && UseLargePages && size >= os::large_page_size(); size_t page_size = large ? os::large_page_size() : os::vm_page_size(); - ReservedSpace rs = MemoryReserver::reserve(size, alignment, page_size, mtTest); + ReservedSpace rs = MemoryReserver::reserve(size, alignment, page_size); MemoryReleaser releaser(&rs); EXPECT_TRUE(rs.base() != nullptr) << "rs.special: " << rs.special(); @@ -217,8 +217,7 @@ namespace { case Commit: return MemoryReserver::reserve(reserve_size_aligned, os::vm_allocation_granularity(), - os::vm_page_size(), - mtTest); + os::vm_page_size()); } } @@ -297,7 +296,7 @@ TEST_VM(VirtualSpace, actual_committed_space_one_large_page) { size_t large_page_size = os::large_page_size(); - ReservedSpace reserved = MemoryReserver::reserve(large_page_size, large_page_size, large_page_size, mtTest); + ReservedSpace reserved = MemoryReserver::reserve(large_page_size, large_page_size, large_page_size); ReservedSpaceReleaser releaser(&reserved); ASSERT_TRUE(reserved.is_reserved()); @@ -366,8 +365,7 @@ class TestReservedSpace : AllStatic { size_t page_size = UseLargePages ? os::large_page_size() : os::vm_page_size(); ReservedSpace rs = MemoryReserver::reserve(size, alignment, - page_size, - mtTest); + page_size); EXPECT_TRUE(rs.base() != nullptr); EXPECT_EQ(rs.size(), size) << "rs.size: " << rs.size(); @@ -412,8 +410,7 @@ class TestReservedSpace : AllStatic { ReservedSpace rs = MemoryReserver::reserve(size, alignment, - page_size, - mtTest); + page_size); EXPECT_TRUE(rs.base() != nullptr); EXPECT_EQ(rs.size(), size) << "rs.size: " << rs.size(); @@ -517,14 +514,12 @@ class TestVirtualSpace : AllStatic { default: case Default: case Reserve: - return MemoryReserver::reserve(reserve_size_aligned, - mtTest); + return MemoryReserver::reserve(reserve_size_aligned, mtTest); case Disable: case Commit: return MemoryReserver::reserve(reserve_size_aligned, os::vm_allocation_granularity(), - os::vm_page_size(), - mtTest); + os::vm_page_size()); } } @@ -581,8 +576,7 @@ class TestVirtualSpace : AllStatic { ReservedSpace reserved = MemoryReserver::reserve(large_page_size, large_page_size, - large_page_size, - mtTest); + large_page_size); ASSERT_TRUE(reserved.is_reserved()); diff --git a/test/hotspot/gtest/nmt/test_nmt_locationprinting.cpp b/test/hotspot/gtest/nmt/test_nmt_locationprinting.cpp index c8711004f10..e0e3c289102 100644 --- a/test/hotspot/gtest/nmt/test_nmt_locationprinting.cpp +++ b/test/hotspot/gtest/nmt/test_nmt_locationprinting.cpp @@ -113,7 +113,7 @@ TEST_VM(NMT, DISABLED_location_printing_cheap_dead_7) { test_for_dead_c_heap_blo #endif static void test_for_mmap(size_t sz, ssize_t offset) { - char* addr = os::reserve_memory(sz, mtTest); + char* addr = os::reserve_memory(sz, false, mtTest); if (MemTracker::enabled()) { test_pointer(addr + offset, true, "in mmap'd memory region"); } else { diff --git a/test/hotspot/gtest/runtime/test_committed_virtualmemory.cpp b/test/hotspot/gtest/runtime/test_committed_virtualmemory.cpp index f07b45bc32d..de63e1807c1 100644 --- a/test/hotspot/gtest/runtime/test_committed_virtualmemory.cpp +++ b/test/hotspot/gtest/runtime/test_committed_virtualmemory.cpp @@ -91,7 +91,7 @@ public: static void test_committed_region_impl(size_t num_pages, size_t touch_pages, int* page_num) { const size_t page_sz = os::vm_page_size(); const size_t size = num_pages * page_sz; - char* base = os::reserve_memory(size, mtThreadStack); + char* base = os::reserve_memory(size, !ExecMem, mtThreadStack); bool result = os::commit_memory(base, size, !ExecMem); size_t index; ASSERT_NE(base, (char*)nullptr); @@ -159,7 +159,7 @@ public: const size_t page_sz = os::vm_page_size(); const size_t num_pages = 4; const size_t size = num_pages * page_sz; - char* base = os::reserve_memory(size, mtTest); + char* base = os::reserve_memory(size, !ExecMem, mtTest); ASSERT_NE(base, (char*)nullptr); result = os::commit_memory(base, size, !ExecMem); @@ -205,7 +205,7 @@ public: const size_t page_sz = os::vm_page_size(); const size_t size = num_pages * page_sz; - char* base = os::reserve_memory(size, mtTest); + char* base = os::reserve_memory(size, !ExecMem, mtTest); ASSERT_NE(base, (char*)nullptr); result = os::commit_memory(base, size, !ExecMem); diff --git a/test/hotspot/gtest/runtime/test_os.cpp b/test/hotspot/gtest/runtime/test_os.cpp index 6b7653f5eec..ee6d1427d0b 100644 --- a/test/hotspot/gtest/runtime/test_os.cpp +++ b/test/hotspot/gtest/runtime/test_os.cpp @@ -258,7 +258,7 @@ TEST_VM(os, test_print_hex_dump) { // two pages, first one protected. const size_t ps = os::vm_page_size(); - char* two_pages = os::reserve_memory(ps * 2, mtTest); + char* two_pages = os::reserve_memory(ps * 2, false, mtTest); os::commit_memory(two_pages, ps * 2, false); os::protect_memory(two_pages, ps, os::MEM_PROT_NONE, true); @@ -492,7 +492,7 @@ TEST_VM(os, realpath) { static inline bool can_reserve_executable_memory(void) { bool executable = true; size_t len = 128; - char* p = os::reserve_memory(len, mtTest, executable); + char* p = os::reserve_memory(len, executable); bool exec_supported = (p != nullptr); if (exec_supported) { os::release_memory(p, len); @@ -530,7 +530,7 @@ static address reserve_multiple(int num_stripes, size_t stripe_len) { for (int tries = 0; tries < 256 && p == nullptr; tries ++) { size_t total_range_len = num_stripes * stripe_len; // Reserve a large contiguous area to get the address space... - p = (address)os::reserve_memory(total_range_len, mtTest); + p = (address)os::reserve_memory(total_range_len); EXPECT_NE(p, (address)nullptr); // .. release it... EXPECT_TRUE(os::release_memory((char*)p, total_range_len)); @@ -544,7 +544,7 @@ static address reserve_multiple(int num_stripes, size_t stripe_len) { #else const bool executable = stripe % 2 == 0; #endif - q = (address)os::attempt_reserve_memory_at((char*)q, stripe_len, mtTest, executable); + q = (address)os::attempt_reserve_memory_at((char*)q, stripe_len, executable); if (q == nullptr) { // Someone grabbed that area concurrently. Cleanup, then retry. tty->print_cr("reserve_multiple: retry (%d)...", stripe); @@ -564,7 +564,7 @@ static address reserve_multiple(int num_stripes, size_t stripe_len) { static address reserve_one_commit_multiple(int num_stripes, size_t stripe_len) { assert(is_aligned(stripe_len, os::vm_allocation_granularity()), "Sanity"); size_t total_range_len = num_stripes * stripe_len; - address p = (address)os::reserve_memory(total_range_len, mtTest); + address p = (address)os::reserve_memory(total_range_len); EXPECT_NE(p, (address)nullptr); for (int stripe = 0; stripe < num_stripes; stripe++) { address q = p + (stripe * stripe_len); @@ -631,7 +631,7 @@ TEST_VM(os, release_multi_mappings) { PRINT_MAPPINGS("B"); // ...re-reserve the middle stripes. This should work unless release silently failed. - address p2 = (address)os::attempt_reserve_memory_at((char*)p_middle_stripes, middle_stripe_len, mtTest); + address p2 = (address)os::attempt_reserve_memory_at((char*)p_middle_stripes, middle_stripe_len); ASSERT_EQ(p2, p_middle_stripes); @@ -654,7 +654,7 @@ TEST_VM_ASSERT_MSG(os, release_bad_ranges, ".*bad release") { #else TEST_VM(os, release_bad_ranges) { #endif - char* p = os::reserve_memory(4 * M, mtTest); + char* p = os::reserve_memory(4 * M); ASSERT_NE(p, (char*)nullptr); // Release part of range ASSERT_FALSE(os::release_memory(p, M)); @@ -689,7 +689,7 @@ TEST_VM(os, release_one_mapping_multi_commits) { // // make things even more difficult by trying to reserve at the border of the region address border = p + num_stripes * stripe_len; - address p2 = (address)os::attempt_reserve_memory_at((char*)border, stripe_len, mtTest); + address p2 = (address)os::attempt_reserve_memory_at((char*)border, stripe_len); PRINT_MAPPINGS("B"); ASSERT_TRUE(p2 == nullptr || p2 == border); @@ -730,7 +730,7 @@ TEST_VM(os, show_mappings_small_range) { TEST_VM(os, show_mappings_full_range) { // Reserve a small range and fill it with a marker string, should show up // on implementations displaying range snippets - char* p = os::reserve_memory(1 * M, mtTest); + char* p = os::reserve_memory(1 * M, false, mtInternal); if (p != nullptr) { if (os::commit_memory(p, 1 * M, false)) { strcpy(p, "ABCDEFGHIJKLMNOPQRSTUVWXYZ"); @@ -754,7 +754,7 @@ TEST_VM(os, find_mapping_simple) { // A simple allocation { - address p = (address)os::reserve_memory(total_range_len, mtTest); + address p = (address)os::reserve_memory(total_range_len); ASSERT_NE(p, (address)nullptr); PRINT_MAPPINGS("A"); for (size_t offset = 0; offset < total_range_len; offset += 4711) { @@ -1059,9 +1059,9 @@ TEST_VM(os, open_O_CLOEXEC) { } TEST_VM(os, reserve_at_wish_address_shall_not_replace_mappings_smallpages) { - char* p1 = os::reserve_memory(M, mtTest); + char* p1 = os::reserve_memory(M, false, mtTest); ASSERT_NE(p1, nullptr); - char* p2 = os::attempt_reserve_memory_at(p1, M, mtTest); + char* p2 = os::attempt_reserve_memory_at(p1, M); ASSERT_EQ(p2, nullptr); // should have failed os::release_memory(p1, M); } @@ -1069,7 +1069,7 @@ TEST_VM(os, reserve_at_wish_address_shall_not_replace_mappings_smallpages) { TEST_VM(os, reserve_at_wish_address_shall_not_replace_mappings_largepages) { if (UseLargePages && !os::can_commit_large_page_memory()) { // aka special const size_t lpsz = os::large_page_size(); - char* p1 = os::reserve_memory_aligned(lpsz, lpsz, mtTest); + char* p1 = os::reserve_memory_aligned(lpsz, lpsz, false); ASSERT_NE(p1, nullptr); char* p2 = os::reserve_memory_special(lpsz, lpsz, lpsz, p1, false); ASSERT_EQ(p2, nullptr); // should have failed @@ -1095,7 +1095,7 @@ TEST_VM(os, free_without_uncommit) { const size_t pages = 64; const size_t size = pages * page_sz; - char* base = os::reserve_memory(size, mtTest); + char* base = os::reserve_memory(size, false, mtTest); ASSERT_NE(base, (char*) nullptr); ASSERT_TRUE(os::commit_memory(base, size, false)); diff --git a/test/hotspot/gtest/runtime/test_os_aix.cpp b/test/hotspot/gtest/runtime/test_os_aix.cpp index 73ed55dc3ce..9fcb2f9c691 100644 --- a/test/hotspot/gtest/runtime/test_os_aix.cpp +++ b/test/hotspot/gtest/runtime/test_os_aix.cpp @@ -34,9 +34,9 @@ TEST_VM(os_aix, aix_reserve_at_non_shmlba_aligned_address) { if (os::vm_page_size() != 4*K && !os::Aix::supports_64K_mmap_pages()) { // With this condition true shmget() is used inside - char* p = os::attempt_reserve_memory_at((char*)0x1f00000, M, mtTest); + char* p = os::attempt_reserve_memory_at((char*)0x1f00000, M); ASSERT_EQ(p, nullptr); // should have failed - p = os::attempt_reserve_memory_at((char*)((64 * G) + M), M, mtTest); + p = os::attempt_reserve_memory_at((char*)((64 * G) + M), M); ASSERT_EQ(p, nullptr); // should have failed } } diff --git a/test/hotspot/gtest/runtime/test_os_linux.cpp b/test/hotspot/gtest/runtime/test_os_linux.cpp index 21133788a36..caa227c5e35 100644 --- a/test/hotspot/gtest/runtime/test_os_linux.cpp +++ b/test/hotspot/gtest/runtime/test_os_linux.cpp @@ -354,7 +354,7 @@ TEST_VM(os_linux, pretouch_thp_and_use_concurrent) { const size_t size = 1 * G; const bool useThp = UseTransparentHugePages; UseTransparentHugePages = true; - char* const heap = os::reserve_memory(size, mtTest); + char* const heap = os::reserve_memory(size, false, mtInternal); EXPECT_NE(heap, nullptr); EXPECT_TRUE(os::commit_memory(heap, size, false)); diff --git a/test/hotspot/gtest/runtime/test_os_reserve_between.cpp b/test/hotspot/gtest/runtime/test_os_reserve_between.cpp index ee91ff49ded..34dd26dcf17 100644 --- a/test/hotspot/gtest/runtime/test_os_reserve_between.cpp +++ b/test/hotspot/gtest/runtime/test_os_reserve_between.cpp @@ -157,7 +157,7 @@ public: // the hole. const uintptr_t candidate = nth_bit(i); if ((candidate + _len) <= ARMB_constants::absolute_max) { - _base = os::attempt_reserve_memory_at((char*)candidate, _len, mtTest); + _base = os::attempt_reserve_memory_at((char*)candidate, _len); } } if (_base == nullptr) { @@ -165,8 +165,8 @@ public: } // Release total mapping, remap the individual non-holy parts os::release_memory(_base, _len); - _p1 = os::attempt_reserve_memory_at(_base + _p1_offset, _p1_size, mtTest); - _p2 = os::attempt_reserve_memory_at(_base + _p2_offset, _p2_size, mtTest); + _p1 = os::attempt_reserve_memory_at(_base + _p1_offset, _p1_size); + _p2 = os::attempt_reserve_memory_at(_base + _p2_offset, _p2_size); if (_p1 == nullptr || _p2 == nullptr) { return false; } diff --git a/test/hotspot/jtreg/runtime/NMT/MallocRoundingReportTest.java b/test/hotspot/jtreg/runtime/NMT/MallocRoundingReportTest.java index a0c14d70831..30a03f973bf 100644 --- a/test/hotspot/jtreg/runtime/NMT/MallocRoundingReportTest.java +++ b/test/hotspot/jtreg/runtime/NMT/MallocRoundingReportTest.java @@ -57,7 +57,7 @@ public class MallocRoundingReportTest { // NMT does not track memory allocations less than 1KB, and rounds to the nearest KB NMTTestUtils.runJcmdSummaryReportAndCheckOutput( "Test (reserved=" + numKB + "KB, committed=" + numKB + "KB)", - "(malloc=" + numKB + "KB tag=Test #1) (at peak)" // (malloc=1KB tag=Test #1) (at peak) + "(malloc=" + numKB + "KB #1) (at peak)" ); wb.NMTFree(mallocd_total); @@ -65,7 +65,7 @@ public class MallocRoundingReportTest { // Run 'jcmd VM.native_memory summary', check for expected output NMTTestUtils.runJcmdSummaryReportAndCheckOutput( "Test (reserved=0KB, committed=0KB)", - "(malloc=0KB tag=Test) (peak=" + numKB + "KB #1)" + "(malloc=0KB) (peak=" + numKB + "KB #1)" ); } } diff --git a/test/hotspot/jtreg/runtime/NMT/MallocTestType.java b/test/hotspot/jtreg/runtime/NMT/MallocTestType.java index 1612cbd81c0..67df864e7b4 100644 --- a/test/hotspot/jtreg/runtime/NMT/MallocTestType.java +++ b/test/hotspot/jtreg/runtime/NMT/MallocTestType.java @@ -46,7 +46,7 @@ public class MallocTestType { NMTTestUtils.runJcmdSummaryReportAndCheckOutput( new String[]{"Test (reserved=384KB, committed=384KB)", - "(malloc=384KB tag=Test #2) (at peak)"}); + "(malloc=384KB #2) (at peak)"}); wb.NMTFree(memAlloc3); // current +256K #1 peak +384K #2 long memAlloc1 = wb.NMTMalloc(512 * 1024); // current +768K #2 peak +768K #2 @@ -54,13 +54,13 @@ public class MallocTestType { NMTTestUtils.runJcmdSummaryReportAndCheckOutput( new String[]{"Test (reserved=512KB, committed=512KB)", - "(malloc=512KB tag=Test #1) (peak=768KB #2)"}); + "(malloc=512KB #1) (peak=768KB #2)"}); // Free the memory allocated by NMTAllocTest wb.NMTFree(memAlloc1); // current 0K #0 peak +768K #2 NMTTestUtils.runJcmdSummaryReportAndCheckOutput( new String[]{"Test (reserved=0KB, committed=0KB)", - "(malloc=0KB tag=Test) (peak=768KB #2)"}); + "(malloc=0KB) (peak=768KB #2)"}); } } diff --git a/test/hotspot/jtreg/runtime/NMT/MallocTrackingVerify.java b/test/hotspot/jtreg/runtime/NMT/MallocTrackingVerify.java index 141ef9f2ac3..0c08e07fd25 100644 --- a/test/hotspot/jtreg/runtime/NMT/MallocTrackingVerify.java +++ b/test/hotspot/jtreg/runtime/NMT/MallocTrackingVerify.java @@ -72,7 +72,7 @@ public class MallocTrackingVerify { NMTTestUtils.runJcmdSummaryReportAndCheckOutput( "Test (reserved=4KB, committed=4KB)", - "(malloc=4KB tag=Test #" + mallocd_memory.size() + ") (at peak)" + "(malloc=4KB #" + mallocd_memory.size() + ") (at peak)" ); // Free @@ -83,7 +83,7 @@ public class MallocTrackingVerify { // Run 'jcmd VM.native_memory summary', check for expected output NMTTestUtils.runJcmdSummaryReportAndCheckOutput( "Test (reserved=0KB, committed=0KB)", - "(malloc=0KB tag=Test) (peak=4KB #" + + mallocd_memory.size() + ")" + "(malloc=0KB) (peak=4KB #" + + mallocd_memory.size() + ")" ); } diff --git a/test/hotspot/jtreg/runtime/NMT/ThreadedMallocTestType.java b/test/hotspot/jtreg/runtime/NMT/ThreadedMallocTestType.java index f6b0f3baf04..290984c4185 100644 --- a/test/hotspot/jtreg/runtime/NMT/ThreadedMallocTestType.java +++ b/test/hotspot/jtreg/runtime/NMT/ThreadedMallocTestType.java @@ -61,7 +61,7 @@ public class ThreadedMallocTestType { // Run 'jcmd VM.native_memory summary' NMTTestUtils.runJcmdSummaryReportAndCheckOutput( "Test (reserved=896KB, committed=896KB)", - "(malloc=896KB tag=Test #3) (at peak)" + "(malloc=896KB #3) (at peak)" ); Thread freeThread = new Thread() { @@ -78,7 +78,7 @@ public class ThreadedMallocTestType { NMTTestUtils.runJcmdSummaryReportAndCheckOutput( "Test (reserved=0KB, committed=0KB)", - "(malloc=0KB tag=Test) (peak=896KB #3)" + "(malloc=0KB) (peak=896KB #3)" ); } }