8337217: Port VirtualMemoryTracker to use VMATree

Reviewed-by: jsjolen, gziemski

Author: Afshin Zafari

src/hotspot/share/nmt/memBaseline.cpp

@@ -160,7 +160,7 @@ bool MemBaseline::baseline_allocation_sites() {
 
   // Virtual memory allocation sites
   VirtualMemoryAllocationWalker virtual_memory_walker;
-  if (!VirtualMemoryTracker::walk_virtual_memory(&virtual_memory_walker)) {
+  if (!VirtualMemoryTracker::Instance::walk_virtual_memory(&virtual_memory_walker)) {
     return false;
   }
 

src/hotspot/share/nmt/memMapPrinter.cpp

@@ -157,7 +157,7 @@ class CachedNMTInformation : public VirtualMemoryWalker {
 
   // Iterate all NMT virtual memory regions and fill this cache.
   bool fill_from_nmt() {
-    return VirtualMemoryTracker::walk_virtual_memory(this);
+    return VirtualMemoryTracker::Instance::walk_virtual_memory(this);
   }
 };
 

src/hotspot/share/nmt/memReporter.cpp

@@ -22,13 +22,16 @@
  *
  */
 #include "cds/filemap.hpp"
+#include "logging/log.hpp"
 #include "memory/metaspace.hpp"
 #include "memory/metaspaceUtils.hpp"
 #include "nmt/mallocTracker.hpp"
 #include "nmt/memTag.hpp"
 #include "nmt/memReporter.hpp"
 #include "nmt/memTracker.hpp"
 #include "nmt/memoryFileTracker.hpp"
+#include "nmt/regionsTree.hpp"
+#include "nmt/regionsTree.inline.hpp"
 #include "nmt/threadStackTracker.hpp"
 #include "nmt/virtualMemoryTracker.hpp"
 #include "utilities/debug.hpp"
@@ -432,34 +435,45 @@ void MemDetailReporter::report_virtual_memory_region(const ReservedMemoryRegion*
   }
 
   if (all_committed) {
-    CommittedRegionIterator itr = reserved_rgn->iterate_committed_regions();
-    const CommittedMemoryRegion* committed_rgn = itr.next();
-    if (committed_rgn->size() == reserved_rgn->size() && committed_rgn->call_stack()->equals(*stack)) {
-      // 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.
-      assert(itr.next() == nullptr, "Unexpectedly more than one regions");
+    bool reserved_and_committed = false;
+    VirtualMemoryTracker::Instance::tree()->visit_committed_regions(*reserved_rgn,
+                                                                  [&](CommittedMemoryRegion& committed_rgn) {
+      if (committed_rgn.equals(*reserved_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.
+        reserved_and_committed = true;
+        return false;
+      }
+      return true;
+    });
+
+    if (reserved_and_committed) {
       return;
     }
   }
 
-  CommittedRegionIterator itr = reserved_rgn->iterate_committed_regions();
-  const CommittedMemoryRegion* committed_rgn;
-  while ((committed_rgn = itr.next()) != nullptr) {
+  auto print_committed_rgn = [&](const CommittedMemoryRegion& crgn) {
     // Don't report if size is too small
-    if (amount_in_current_scale(committed_rgn->size()) == 0) continue;
-    stack = committed_rgn->call_stack();
+    if (amount_in_current_scale(crgn.size()) == 0) return;
+    stack = crgn.call_stack();
     out->cr();
     INDENT_BY(8,
-      print_virtual_memory_region("committed", committed_rgn->base(), committed_rgn->size());
+      print_virtual_memory_region("committed", crgn.base(), crgn.size());
       if (stack->is_empty()) {
         out->cr();
       } else {
         out->print_cr(" from");
-        INDENT_BY(4, stack->print_on(out);)
+        INDENT_BY(4, _stackprinter.print_stack(stack);)
       }
     )
-  }
+  };
+
+  VirtualMemoryTracker::Instance::tree()->visit_committed_regions(*reserved_rgn,
+                                                                  [&](CommittedMemoryRegion& crgn) {
+    print_committed_rgn(crgn);
+    return true;
+  });
 }
 
 void MemDetailReporter::report_memory_file_allocations() {

src/hotspot/share/nmt/memTracker.cpp

@@ -71,7 +71,7 @@ void MemTracker::initialize() {
     _baseline.initialize();
     if (!MallocTracker::initialize(level) ||
         !MemoryFileTracker::Instance::initialize(level) ||
-        !VirtualMemoryTracker::initialize(level)) {
+        !VirtualMemoryTracker::Instance::initialize(level)) {
       assert(false, "NMT initialization failed");
       level = NMT_off;
       log_warning(nmt)("NMT initialization failed. NMT disabled.");
@@ -126,7 +126,7 @@ void MemTracker::final_report(outputStream* output) {
 bool MemTracker::print_containing_region(const void* p, outputStream* out) {
   return enabled() &&
       (MallocTracker::print_pointer_information(p, out) ||
-       VirtualMemoryTracker::print_containing_region(p, out));
+       VirtualMemoryTracker::Instance::print_containing_region(p, out));
 }
 
 void MemTracker::report(bool summary_only, outputStream* output, size_t scale) {

src/hotspot/share/nmt/memTracker.hpp

@@ -132,23 +132,23 @@ class MemTracker : AllStatic {
     if (!enabled()) return;
     if (addr != nullptr) {
       NmtVirtualMemoryLocker nvml;
-      VirtualMemoryTracker::add_reserved_region((address)addr, size, stack, mem_tag);
+      VirtualMemoryTracker::Instance::add_reserved_region((address)addr, size, stack, mem_tag);
     }
   }
 
   static inline void record_virtual_memory_release(void* addr, size_t size) {
     assert_post_init();
     if (!enabled()) return;
     if (addr != nullptr) {
-      VirtualMemoryTracker::remove_released_region((address)addr, size);
+      VirtualMemoryTracker::Instance::remove_released_region((address)addr, size);
     }
   }
 
   static inline void record_virtual_memory_uncommit(void* addr, size_t size) {
     assert_post_init();
     if (!enabled()) return;
     if (addr != nullptr) {
-      VirtualMemoryTracker::remove_uncommitted_region((address)addr, size);
+      VirtualMemoryTracker::Instance::remove_uncommitted_region((address)addr, size);
     }
   }
 
@@ -158,8 +158,8 @@ class MemTracker : AllStatic {
     if (!enabled()) return;
     if (addr != nullptr) {
       NmtVirtualMemoryLocker nvml;
-      VirtualMemoryTracker::add_reserved_region((address)addr, size, stack, mem_tag);
-      VirtualMemoryTracker::add_committed_region((address)addr, size, stack);
+      VirtualMemoryTracker::Instance::add_reserved_region((address)addr, size, stack, mem_tag);
+      VirtualMemoryTracker::Instance::add_committed_region((address)addr, size, stack);
     }
   }
 
@@ -169,7 +169,7 @@ class MemTracker : AllStatic {
     if (!enabled()) return;
     if (addr != nullptr) {
       NmtVirtualMemoryLocker nvml;
-      VirtualMemoryTracker::add_committed_region((address)addr, size, stack);
+      VirtualMemoryTracker::Instance::add_committed_region((address)addr, size, stack);
     }
   }
 
@@ -217,7 +217,7 @@ class MemTracker : AllStatic {
     if (!enabled()) return;
     if (addr != nullptr) {
       NmtVirtualMemoryLocker nvml;
-      VirtualMemoryTracker::split_reserved_region((address)addr, size, split, mem_tag, split_tag);
+      VirtualMemoryTracker::Instance::split_reserved_region((address)addr, size, split, mem_tag, split_tag);
     }
   }
 
@@ -230,7 +230,7 @@ class MemTracker : AllStatic {
     if (!enabled()) return;
     if (addr != nullptr) {
       NmtVirtualMemoryLocker nvml;
-      VirtualMemoryTracker::set_reserved_region_type((address)addr, size, mem_tag);
+      VirtualMemoryTracker::Instance::set_reserved_region_tag((address)addr, size, mem_tag);
     }
   }
 

src/hotspot/share/nmt/memoryFileTracker.cpp

@@ -73,7 +73,7 @@ void MemoryFileTracker::print_report_on(const MemoryFile* file, outputStream* st
     if (prev == nullptr) {
       // Must be first node.
       prev = current;
-      return;
+      return true;
     }
 #ifdef ASSERT
     if (broken_start != nullptr && prev->val().out.mem_tag() != current->val().in.mem_tag()) {
@@ -96,6 +96,7 @@ void MemoryFileTracker::print_report_on(const MemoryFile* file, outputStream* st
       stream->cr();
     }
     prev = current;
+    return true;
   });
 #ifdef ASSERT
   if (broken_start != nullptr) {

src/hotspot/share/nmt/memoryFileTracker.hpp

@@ -28,8 +28,8 @@
 #include "memory/allocation.hpp"
 #include "nmt/nmtCommon.hpp"
 #include "nmt/nmtNativeCallStackStorage.hpp"
-#include "nmt/virtualMemoryTracker.hpp"
 #include "nmt/vmatree.hpp"
+#include "nmt/virtualMemoryTracker.hpp"
 #include "runtime/os.inline.hpp"
 #include "utilities/growableArray.hpp"
 #include "utilities/nativeCallStack.hpp"

src/hotspot/share/nmt/nmtTreap.hpp

@@ -55,6 +55,7 @@ template<typename K, typename V, typename COMPARATOR, typename ALLOCATOR>
 class Treap {
   friend class NMTVMATreeTest;
   friend class NMTTreapTest;
+  friend class VMTWithVMATreeTest;
 public:
   class TreapNode {
     friend Treap;
@@ -212,12 +213,13 @@ class Treap {
       seen_count++;
       if (last_seen == nullptr) {
         last_seen = node;
-        return;
+        return true;
       }
       if (COMPARATOR::cmp(last_seen->key(), node->key()) > 0) {
         failed = false;
       }
       last_seen = node;
+      return true;
     });
     assert(seen_count == _node_count, "the number of visited nodes do not match with the number of stored nodes");
     assert(!failed, "keys was not monotonically strongly increasing when visiting in order");
@@ -382,7 +384,9 @@ class Treap {
         head = head->left();
       }
       head = to_visit.pop();
-      f(head);
+      if (!f(head)) {
+        return;
+      }
       head = head->right();
     }
   }
@@ -409,7 +413,9 @@ class Treap {
       const int cmp_from = COMPARATOR::cmp(head->key(), from);
       const int cmp_to = COMPARATOR::cmp(head->key(), to);
       if (cmp_from >= 0 && cmp_to < 0) {
-        f(head);
+        if (!f(head)) {
+          return;
+        }
       }
       if (cmp_to < 0) {
         head = head->right();

src/hotspot/share/nmt/nmtUsage.cpp

@@ -29,7 +29,6 @@
 #include "nmt/nmtCommon.hpp"
 #include "nmt/nmtUsage.hpp"
 #include "nmt/threadStackTracker.hpp"
-#include "nmt/virtualMemoryTracker.hpp"
 
 // Enabled all options for snapshot.
 const NMTUsageOptions NMTUsage::OptionsAll = { true, true, true };
@@ -48,7 +47,7 @@ void NMTUsage::walk_thread_stacks() {
   // much memory had been committed if they are backed by virtual memory. This
   // needs to happen before we take the snapshot of the virtual memory since it
   // will update this information.
-  VirtualMemoryTracker::snapshot_thread_stacks();
+  VirtualMemoryTracker::Instance::snapshot_thread_stacks();
 }
 
 void NMTUsage::update_malloc_usage() {

src/hotspot/share/nmt/regionsTree.cpp

@@ -0,0 +1,57 @@
+/*
+ * Copyright (c) 2025, 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
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ *
+ */
+#include "nmt/regionsTree.hpp"
+
+VMATree::SummaryDiff RegionsTree::commit_region(address addr, size_t size, const NativeCallStack& stack) {
+  return commit_mapping((VMATree::position)addr, size, make_region_data(stack, mtNone), /*use tag inplace*/ true);
+}
+
+VMATree::SummaryDiff RegionsTree::uncommit_region(address addr, size_t size) {
+  return uncommit_mapping((VMATree::position)addr, size, make_region_data(NativeCallStack::empty_stack(), mtNone));
+}
+
+#ifdef ASSERT
+void RegionsTree::NodeHelper::print_on(outputStream* st) {
+  auto st_str = [&](VMATree::StateType s){
+    return s == VMATree::StateType::Released ? "Rl" :
+           s == VMATree::StateType::Reserved ? "Rv" : "Cm";
+  };
+  st->print_cr("pos: " INTPTR_FORMAT " "
+                "%s, %s <|> %s, %s",
+                p2i((address)position()),
+                st_str(in_state()),
+                NMTUtil::tag_to_name(in_tag()),
+                st_str(out_state()),
+                NMTUtil::tag_to_name(out_tag())
+                );
+}
+
+void RegionsTree::print_on(outputStream* st) {
+  visit_in_order([&](Node* node) {
+    NodeHelper curr(node);
+    curr.print_on(st);
+    return true;
+  });
+}
+#endif