8366241: NMT: Consolidate [Virtual/Committed/Reserved]Regions into one structure

Reviewed-by: phubner, jsjolen

Author: Afshin Zafari

src/hotspot/share/nmt/memBaseline.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012, 2025, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2012, 2026, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -168,12 +168,13 @@ int compare_allocation_site(const VirtualMemoryAllocationSite& s1,
 }
 
 bool MemBaseline::aggregate_virtual_memory_allocation_sites() {
+
   SortedLinkedList<VirtualMemoryAllocationSite, compare_allocation_site> allocation_sites;
 
   VirtualMemoryAllocationSite* site;
   bool failed_oom = false;
-  _vma_allocations->visit_reserved_regions([&](ReservedMemoryRegion& rgn) {
-    VirtualMemoryAllocationSite tmp(*rgn.call_stack(), rgn.mem_tag());
+  _vma_allocations->visit_reserved_regions([&](VirtualMemoryRegion& rgn) {
+    VirtualMemoryAllocationSite tmp(*rgn.reserved_call_stack(), rgn.mem_tag());
     site = allocation_sites.find(tmp);
     if (site == nullptr) {
       LinkedListNode<VirtualMemoryAllocationSite>* node =

src/hotspot/share/nmt/memMapPrinter.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2023, 2025, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2023, 2026, Oracle and/or its affiliates. All rights reserved.
  * Copyright (c) 2023, 2024, Red Hat, Inc. and/or its affiliates.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
@@ -149,7 +149,7 @@ class CachedNMTInformation : public VirtualMemoryWalker {
     }
   }
 
-  bool do_allocation_site(const ReservedMemoryRegion* rgn) override {
+  bool do_allocation_site(const VirtualMemoryRegion* rgn) override {
     // Cancel iteration if we run out of memory (add returns false);
     return add(rgn->base(), rgn->end(), rgn->mem_tag());
   }

src/hotspot/share/nmt/memReporter.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012, 2025, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2012, 2026, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -395,14 +395,14 @@ int MemDetailReporter::report_virtual_memory_allocation_sites()  {
 void MemDetailReporter::report_virtual_memory_map() {
   // Virtual memory map always in base address order
   output()->print_cr("Virtual memory map:");
-  _baseline.virtual_memory_allocations()->visit_reserved_regions([&](ReservedMemoryRegion& rgn) {
+  _baseline.virtual_memory_allocations()->visit_reserved_regions([&](VirtualMemoryRegion& rgn) {
     report_virtual_memory_region(&rgn);
     return true;
   });
 }
 
-void MemDetailReporter::report_virtual_memory_region(const ReservedMemoryRegion* reserved_rgn) {
-  assert(reserved_rgn != nullptr, "null pointer");
+void MemDetailReporter::report_virtual_memory_region(const VirtualMemoryRegion* rgn) {
+  assert(rgn != nullptr, "null pointer");
 
   // We don't bother about reporting peaks here.
   // That is because peaks - in the context of virtual memory, peak of committed areas - make little sense
@@ -414,16 +414,16 @@ void MemDetailReporter::report_virtual_memory_region(const ReservedMemoryRegion*
   // usage *by callsite*.
 
   // Don't report if size is too small.
-  if (amount_in_current_scale(reserved_rgn->size()) == 0) return;
+  if (amount_in_current_scale(rgn->size()) == 0) return;
 
   outputStream* out = output();
   const char* scale = current_scale();
-  const NativeCallStack*  stack = reserved_rgn->call_stack();
-  bool all_committed = reserved_rgn->size() == _baseline.virtual_memory_allocations()->committed_size(*reserved_rgn);
+  const NativeCallStack*  stack = rgn->reserved_call_stack();
+  bool all_committed = rgn->size() == _baseline.virtual_memory_allocations()->committed_size(*rgn);
   const char* region_type = (all_committed ? "reserved and committed" : "reserved");
   out->cr();
-  print_virtual_memory_region(region_type, reserved_rgn->base(), reserved_rgn->size());
-  out->print(" for %s", NMTUtil::tag_to_name(reserved_rgn->mem_tag()));
+  print_virtual_memory_region(region_type, rgn->base(), rgn->size());
+  out->print(" for %s", NMTUtil::tag_to_name(rgn->mem_tag()));
   if (stack->is_empty()) {
     out->cr();
   } else {
@@ -433,9 +433,9 @@ void MemDetailReporter::report_virtual_memory_region(const ReservedMemoryRegion*
 
   if (all_committed) {
     bool reserved_and_committed = false;
-    _baseline.virtual_memory_allocations()->visit_committed_regions(*reserved_rgn,
-                                                                  [&](CommittedMemoryRegion& committed_rgn) {
-      if (committed_rgn.equals(*reserved_rgn)) {
+    _baseline.virtual_memory_allocations()->visit_committed_regions(*rgn,
+                                                                  [&](VirtualMemoryRegion& committed_rgn) {
+      if (committed_rgn.equals(*rgn)) {
         // One region spanning the entire reserved region, with the same stack trace.
         // Don't print this regions because the "reserved and committed" line above
         // already indicates that the region is committed.
@@ -450,13 +450,13 @@ void MemDetailReporter::report_virtual_memory_region(const ReservedMemoryRegion*
     }
   }
 
-  auto print_committed_rgn = [&](const CommittedMemoryRegion& crgn) {
+  auto print_committed_rgn = [&](const VirtualMemoryRegion& rgn) {
     // Don't report if size is too small
-    if (amount_in_current_scale(crgn.size()) == 0) return;
-    stack = crgn.call_stack();
+    if (amount_in_current_scale(rgn.size()) == 0) return;
+    stack = rgn.committed_call_stack();
     out->cr();
     INDENT_BY(8,
-      print_virtual_memory_region("committed", crgn.base(), crgn.size());
+      print_virtual_memory_region("committed", rgn.base(), rgn.size());
       if (stack->is_empty()) {
         out->cr();
       } else {
@@ -466,9 +466,9 @@ void MemDetailReporter::report_virtual_memory_region(const ReservedMemoryRegion*
     )
   };
 
-  _baseline.virtual_memory_allocations()->visit_committed_regions(*reserved_rgn,
-                                                                  [&](CommittedMemoryRegion& crgn) {
-    print_committed_rgn(crgn);
+  _baseline.virtual_memory_allocations()->visit_committed_regions(*rgn,
+                                                                  [&](VirtualMemoryRegion& committed_rgn) {
+    print_committed_rgn(committed_rgn);
     return true;
   });
 }

src/hotspot/share/nmt/memReporter.hpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012, 2025, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2012, 2026, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -178,7 +178,7 @@ class MemDetailReporter : public MemSummaryReporter {
   int report_virtual_memory_allocation_sites();
 
   // Report a virtual memory region
-  void report_virtual_memory_region(const ReservedMemoryRegion* rgn);
+  void report_virtual_memory_region(const VirtualMemoryRegion* rgn);
 };
 
 /*

src/hotspot/share/nmt/regionsTree.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2025, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2025, 2026, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -58,9 +58,9 @@ void RegionsTree::print_on(outputStream* st) {
 }
 #endif
 
-size_t RegionsTree::committed_size(const ReservedMemoryRegion& rgn) {
+size_t RegionsTree::committed_size(const VirtualMemoryRegion& rgn) {
   size_t result = 0;
-  visit_committed_regions(rgn, [&](CommittedMemoryRegion& crgn) {
+  visit_committed_regions(rgn, [&](VirtualMemoryRegion& crgn) {
     result += crgn.size();
     return true;
   });

src/hotspot/share/nmt/regionsTree.hpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2025, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2025, 2026, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -29,8 +29,7 @@
 #include "nmt/vmatree.hpp"
 
 
-class ReservedMemoryRegion;
-class CommittedMemoryRegion;
+class VirtualMemoryRegion;
 // RegionsTree extends VMATree to add some more specific API and also defines a helper
 // for processing the tree nodes in a shorter and more meaningful way.
 class RegionsTree : public VMATree {
@@ -46,7 +45,7 @@ class RegionsTree : public VMATree {
     _with_storage(other._with_storage) {}
   RegionsTree& operator=(const RegionsTree& other) = delete;
 
-  ReservedMemoryRegion find_reserved_region(address addr);
+  VirtualMemoryRegion find_reserved_region(address addr);
 
   void commit_region(address addr, size_t size, const NativeCallStack& stack, SummaryDiff& diff);
   void uncommit_region(address addr, size_t size, SummaryDiff& diff);
@@ -71,6 +70,7 @@ class RegionsTree : public VMATree {
         return position() - other.position();
       }
       inline NativeCallStackStorage::StackIndex out_stack_index() const { return _node->val().out.reserved_stack(); }
+      inline NativeCallStackStorage::StackIndex out_committed_stack_index() const { return _node->val().out.committed_stack(); }
       inline MemTag in_tag() const { return _node->val().in.mem_tag(); }
       inline MemTag out_tag() const { return _node->val().out.mem_tag(); }
       inline void set_in_tag(MemTag tag) { _node->val().in.set_tag(tag); }
@@ -81,7 +81,7 @@ class RegionsTree : public VMATree {
   DEBUG_ONLY(void print_on(outputStream* st);)
 
   template<typename F>
-  void visit_committed_regions(const ReservedMemoryRegion& rgn, F func);
+  void visit_committed_regions(const VirtualMemoryRegion& rgn, F func);
 
   template<typename F>
   void visit_reserved_regions(F func);
@@ -90,15 +90,23 @@ class RegionsTree : public VMATree {
     return RegionData(_ncs_storage.push(ncs), tag);
   }
 
-  inline const NativeCallStack stack(NodeHelper& node) {
+  inline const NativeCallStack reserved_stack(NodeHelper& node) {
     if (!_with_storage) {
       return NativeCallStack::empty_stack();
     }
     NativeCallStackStorage::StackIndex si = node.out_stack_index();
     return _ncs_storage.get(si);
   }
 
-  size_t committed_size(const ReservedMemoryRegion& rgn);
+  inline const NativeCallStack committed_stack(NodeHelper& node) {
+    if (!_with_storage) {
+      return NativeCallStack::empty_stack();
+    }
+    NativeCallStackStorage::StackIndex si = node.out_committed_stack_index();
+    return _ncs_storage.get(si);
+  }
+
+  size_t committed_size(const VirtualMemoryRegion& rgn);
 };
 
 #endif // NMT_REGIONSTREE_HPP

src/hotspot/share/nmt/regionsTree.inline.hpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2025, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2025, 2026, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -29,7 +29,7 @@
 #include "nmt/virtualMemoryTracker.hpp"
 
 template<typename F>
-void RegionsTree::visit_committed_regions(const ReservedMemoryRegion& rgn, F func) {
+void RegionsTree::visit_committed_regions(const VirtualMemoryRegion& rgn, F func) {
   position start = (position)rgn.base();
   size_t end = reinterpret_cast<size_t>(rgn.end()) + 1;
   size_t comm_size = 0;
@@ -38,8 +38,12 @@ void RegionsTree::visit_committed_regions(const ReservedMemoryRegion& rgn, F fun
   visit_range_in_order(start, end, [&](Node* node) {
     NodeHelper curr(node);
     if (prev.is_valid() && prev.is_committed_begin()) {
-      CommittedMemoryRegion cmr((address)prev.position(), curr.distance_from(prev), stack(prev));
-      if (!func(cmr)) {
+      VirtualMemoryRegion rgn((address)prev.position(),
+                              curr.distance_from(prev),
+                              reserved_stack(prev),
+                              committed_stack(prev),
+                              prev.out_tag());
+      if (!func(rgn)) {
         return false;
       }
     }
@@ -63,13 +67,13 @@ void RegionsTree::visit_reserved_regions(F func) {
     }
     prev = curr;
     if (curr.is_released_begin() || begin_node.out_tag() != curr.out_tag()) {
-      auto st = stack(begin_node);
+      auto st = reserved_stack(begin_node);
       if (rgn_size == 0) {
         prev.clear_node();
         return true;
       }
-      ReservedMemoryRegion rmr((address)begin_node.position(), rgn_size, st, begin_node.out_tag());
-      if (!func(rmr)) {
+      VirtualMemoryRegion rgn((address)begin_node.position(), rgn_size, st, begin_node.out_tag());
+      if (!func(rgn)) {
         return false;
       }
       rgn_size = 0;

src/hotspot/share/nmt/virtualMemoryTracker.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2013, 2025, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2013, 2026, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -193,14 +193,14 @@ bool VirtualMemoryTracker::Instance::print_containing_region(const void* p, outp
 }
 
 bool VirtualMemoryTracker::print_containing_region(const void* p, outputStream* st) {
-  ReservedMemoryRegion rmr = tree()->find_reserved_region((address)p);
-  if (!rmr.contain_address((address)p)) {
+  VirtualMemoryRegion rgn = tree()->find_reserved_region((address)p);
+  if (!rgn.is_valid() || !rgn.contain_address((address)p)) {
     return false;
   }
   st->print_cr(PTR_FORMAT " in mmap'd memory region [" PTR_FORMAT " - " PTR_FORMAT "], tag %s",
-               p2i(p), p2i(rmr.base()), p2i(rmr.end()), NMTUtil::tag_to_enum_name(rmr.mem_tag()));
+               p2i(p), p2i(rgn.base()), p2i(rgn.end()), NMTUtil::tag_to_enum_name(rgn.mem_tag()));
   if (MemTracker::tracking_level() == NMT_detail) {
-    rmr.call_stack()->print_on(st);
+    rgn.reserved_call_stack()->print_on(st);
   }
   st->cr();
   return true;
@@ -213,7 +213,7 @@ bool VirtualMemoryTracker::Instance::walk_virtual_memory(VirtualMemoryWalker* wa
 
 bool VirtualMemoryTracker::walk_virtual_memory(VirtualMemoryWalker* walker) {
   bool ret = true;
-  tree()->visit_reserved_regions([&](ReservedMemoryRegion& rgn) {
+  tree()->visit_reserved_regions([&](VirtualMemoryRegion& rgn) {
     if (!walker->do_allocation_site(&rgn)) {
       ret = false;
       return false;
@@ -223,29 +223,29 @@ bool VirtualMemoryTracker::walk_virtual_memory(VirtualMemoryWalker* walker) {
   return ret;
 }
 
-size_t VirtualMemoryTracker::committed_size(const ReservedMemoryRegion* rmr) {
+size_t VirtualMemoryTracker::committed_size(const VirtualMemoryRegion* rgn) {
   size_t result = 0;
-  tree()->visit_committed_regions(*rmr, [&](CommittedMemoryRegion& crgn) {
+  tree()->visit_committed_regions(*rgn, [&](VirtualMemoryRegion& crgn) {
     result += crgn.size();
     return true;
   });
   return result;
 }
 
-size_t VirtualMemoryTracker::Instance::committed_size(const ReservedMemoryRegion* rmr) {
+size_t VirtualMemoryTracker::Instance::committed_size(const VirtualMemoryRegion* rgn) {
   assert(_tracker != nullptr, "Sanity check");
-  return _tracker->committed_size(rmr);
+  return _tracker->committed_size(rgn);
 }
 
-address VirtualMemoryTracker::Instance::thread_stack_uncommitted_bottom(const ReservedMemoryRegion* rmr) {
+address VirtualMemoryTracker::Instance::thread_stack_uncommitted_bottom(const VirtualMemoryRegion* rgn) {
   assert(_tracker != nullptr, "Sanity check");
-  return _tracker->thread_stack_uncommitted_bottom(rmr);
+  return _tracker->thread_stack_uncommitted_bottom(rgn);
 }
 
-address VirtualMemoryTracker::thread_stack_uncommitted_bottom(const ReservedMemoryRegion* rmr) {
-  address bottom = rmr->base();
-  address top = rmr->end();
-    tree()->visit_committed_regions(*rmr, [&](CommittedMemoryRegion& crgn) {
+address VirtualMemoryTracker::thread_stack_uncommitted_bottom(const VirtualMemoryRegion* rgn) {
+  address bottom = rgn->base();
+  address top = rgn->end();
+    tree()->visit_committed_regions(*rgn, [&](VirtualMemoryRegion& crgn) {
     address committed_top = crgn.base() + crgn.size();
     if (committed_top < top) {
       // committed stack guard pages, skip them
@@ -299,7 +299,7 @@ class SnapshotThreadStackWalker : public VirtualMemoryWalker {
 public:
   SnapshotThreadStackWalker() {}
 
-  bool do_allocation_site(const ReservedMemoryRegion* rgn) {
+  bool do_allocation_site(const VirtualMemoryRegion* rgn) {
     if (MemTracker::NmtVirtualMemoryLocker::is_safe_to_use()) {
       assert_lock_strong(NmtVirtualMemory_lock);
     }
@@ -340,19 +340,19 @@ void VirtualMemoryTracker::Instance::snapshot_thread_stacks() {
   walk_virtual_memory(&walker);
 }
 
-ReservedMemoryRegion RegionsTree::find_reserved_region(address addr) {
-    ReservedMemoryRegion rmr;
-    auto contain_region = [&](ReservedMemoryRegion& region_in_tree) {
+VirtualMemoryRegion RegionsTree::find_reserved_region(address addr) {
+    VirtualMemoryRegion rgn;
+    auto contain_region = [&](VirtualMemoryRegion& region_in_tree) {
       if (region_in_tree.contain_address(addr)) {
-        rmr = region_in_tree;
+        rgn = region_in_tree;
         return false;
       }
       return true;
     };
     visit_reserved_regions(contain_region);
-    return rmr;
+    return rgn;
 }
 
-bool CommittedMemoryRegion::equals(const ReservedMemoryRegion& rmr) const {
-  return size() == rmr.size() && call_stack()->equals(*(rmr.call_stack()));
+bool VirtualMemoryRegion::equals_including_stacks(const VirtualMemoryRegion& rgn) const {
+  return size() == rgn.size() && committed_call_stack()->equals(*(rgn.reserved_call_stack()));
 }