8324829: Uniform use of synchronizations in NMT

Reviewed-by: stuefe, jsjolen

src/hotspot/os/posix/perfMemory_posix.cpp

@@ -1086,11 +1086,10 @@ static char* mmap_create_shared(size_t size) {
 static void unmap_shared(char* addr, size_t bytes) {
   int res;
   if (MemTracker::enabled()) {
-    // Note: Tracker contains a ThreadCritical.
-    Tracker tkr(Tracker::release);
+    ThreadCritical tc;
     res = ::munmap(addr, bytes);
     if (res == 0) {
-      tkr.record((address)addr, bytes);
+      MemTracker::record_virtual_memory_release((address)addr, bytes);
     }
   } else {
     res = ::munmap(addr, bytes);

src/hotspot/os/windows/perfMemory_windows.cpp

@@ -1803,9 +1803,9 @@ void PerfMemory::detach(char* addr, size_t bytes) {
 
   if (MemTracker::enabled()) {
     // it does not go through os api, the operation has to record from here
-    Tracker tkr(Tracker::release);
+    ThreadCritical tc;
     remove_file_mapping(addr);
-    tkr.record((address)addr, bytes);
+    MemTracker::record_virtual_memory_release((address)addr, bytes);
   } else {
     remove_file_mapping(addr);
   }

src/hotspot/share/gc/x/xPhysicalMemory.cpp

@@ -283,11 +283,9 @@ void XPhysicalMemoryManager::nmt_commit(uintptr_t offset, size_t size) const {
 }
 
 void XPhysicalMemoryManager::nmt_uncommit(uintptr_t offset, size_t size) const {
-  if (MemTracker::enabled()) {
-    const uintptr_t addr = XAddress::marked0(offset);
-    Tracker tracker(Tracker::uncommit);
-    tracker.record((address)addr, size);
-  }
+  const uintptr_t addr = XAddress::marked0(offset);
+  ThreadCritical tc;
+  MemTracker::record_virtual_memory_uncommit((address)addr, size);
 }
 
 void XPhysicalMemoryManager::alloc(XPhysicalMemory& pmem, size_t size) {

src/hotspot/share/gc/z/zNMT.cpp

@@ -73,10 +73,8 @@ void ZNMT::process_fake_mapping(zoffset offset, size_t size, bool commit) {
     if (commit) {
       MemTracker::record_virtual_memory_commit((void*)sub_range_addr, sub_range_size, CALLER_PC);
     } else {
-      if (MemTracker::enabled()) {
-        Tracker tracker(Tracker::uncommit);
-        tracker.record((address)sub_range_addr, sub_range_size);
-      }
+      ThreadCritical tc;
+      MemTracker::record_virtual_memory_uncommit((address)sub_range_addr, sub_range_size);
     }
 
     left_to_process -= sub_range_size;

src/hotspot/share/nmt/memTracker.cpp

@@ -95,20 +95,6 @@ void MemTracker::initialize() {
   }
 }
 
-void Tracker::record(address addr, size_t size) {
-  if (MemTracker::tracking_level() < NMT_summary) return;
-  switch(_type) {
-    case uncommit:
-      VirtualMemoryTracker::remove_uncommitted_region(addr, size);
-      break;
-    case release:
-      VirtualMemoryTracker::remove_released_region(addr, size);
-        break;
-    default:
-      ShouldNotReachHere();
-  }
-}
-
 // Report during error reporting.
 void MemTracker::error_report(outputStream* output) {
   if (enabled()) {

src/hotspot/share/nmt/memTracker.hpp

@@ -41,25 +41,6 @@
 
 class MemBaseline;
 
-// Tracker is used for guarding 'release' semantics of virtual memory operation, to avoid
-// the other thread obtains and records the same region that is just 'released' by current
-// thread but before it can record the operation.
-class Tracker : public StackObj {
- public:
-  enum TrackerType {
-     uncommit,
-     release
-  };
-
- public:
-  Tracker(enum TrackerType type) : _type(type) { }
-  void record(address addr, size_t size);
- private:
-  enum TrackerType  _type;
-  // Virtual memory tracking data structures are protected by ThreadCritical lock.
-  ThreadCritical    _tc;
-};
-
 class MemTracker : AllStatic {
   friend class VirtualMemoryTrackerTest;
 
@@ -148,6 +129,22 @@ class MemTracker : AllStatic {
     }
   }
 
+  static inline void record_virtual_memory_release(address addr, size_t size) {
+    assert_post_init();
+    if (!enabled()) return;
+    if (addr != nullptr) {
+      VirtualMemoryTracker::remove_released_region((address)addr, size);
+    }
+  }
+
+  static inline void record_virtual_memory_uncommit(address addr, size_t size) {
+    assert_post_init();
+    if (!enabled()) return;
+    if (addr != nullptr) {
+      VirtualMemoryTracker::remove_uncommitted_region((address)addr, size);
+    }
+  }
+
   static inline void record_virtual_memory_reserve_and_commit(void* addr, size_t size,
     const NativeCallStack& stack, MEMFLAGS flag = mtNone) {
     assert_post_init();

src/hotspot/share/runtime/os.cpp

@@ -2062,10 +2062,10 @@ bool os::uncommit_memory(char* addr, size_t bytes, bool executable) {
   assert_nonempty_range(addr, bytes);
   bool res;
   if (MemTracker::enabled()) {
-    Tracker tkr(Tracker::uncommit);
+    ThreadCritical tc;
     res = pd_uncommit_memory(addr, bytes, executable);
     if (res) {
-      tkr.record((address)addr, bytes);
+      MemTracker::record_virtual_memory_uncommit((address)addr, bytes);
     }
   } else {
     res = pd_uncommit_memory(addr, bytes, executable);
@@ -2077,11 +2077,10 @@ bool os::release_memory(char* addr, size_t bytes) {
   assert_nonempty_range(addr, bytes);
   bool res;
   if (MemTracker::enabled()) {
-    // Note: Tracker contains a ThreadCritical.
-    Tracker tkr(Tracker::release);
+    ThreadCritical tc;
     res = pd_release_memory(addr, bytes);
     if (res) {
-      tkr.record((address)addr, bytes);
+      MemTracker::record_virtual_memory_release((address)addr, bytes);
     }
   } else {
     res = pd_release_memory(addr, bytes);
@@ -2161,10 +2160,10 @@ char* os::map_memory(int fd, const char* file_name, size_t file_offset,
 bool os::unmap_memory(char *addr, size_t bytes) {
   bool result;
   if (MemTracker::enabled()) {
-    Tracker tkr(Tracker::release);
+    ThreadCritical tc;
     result = pd_unmap_memory(addr, bytes);
     if (result) {
-      tkr.record((address)addr, bytes);
+      MemTracker::record_virtual_memory_release((address)addr, bytes);
     }
   } else {
     result = pd_unmap_memory(addr, bytes);
@@ -2197,11 +2196,10 @@ char* os::reserve_memory_special(size_t size, size_t alignment, size_t page_size
 bool os::release_memory_special(char* addr, size_t bytes) {
   bool res;
   if (MemTracker::enabled()) {
-    // Note: Tracker contains a ThreadCritical.
-    Tracker tkr(Tracker::release);
+    ThreadCritical tc;
     res = pd_release_memory_special(addr, bytes);
     if (res) {
-      tkr.record((address)addr, bytes);
+      MemTracker::record_virtual_memory_release((address)addr, bytes);
     }
   } else {
     res = pd_release_memory_special(addr, bytes);