Implement dynamic MemTag creation

Author: jdksjolen

src/hotspot/os/posix/perfMemory_posix.cpp

@@ -1085,7 +1085,7 @@ static char* mmap_create_shared(size_t size) {
 static void unmap_shared(char* addr, size_t bytes) {
   int res;
   if (MemTracker::enabled()) {
-    MemTracker::NmtVirtualMemoryLocker nvml;
+    NmtVirtualMemoryLocker nvml;
     res = ::munmap(addr, bytes);
     if (res == 0) {
       MemTracker::record_virtual_memory_release(addr, bytes);

src/hotspot/os/windows/perfMemory_windows.cpp

@@ -1800,7 +1800,7 @@ 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
-    MemTracker::NmtVirtualMemoryLocker nvml;
+    NmtVirtualMemoryLocker nvml;
     remove_file_mapping(addr);
     MemTracker::record_virtual_memory_release(addr, bytes);
   } else {

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

@@ -47,7 +47,7 @@ void ZNMT::unreserve(zaddress_unsafe start, size_t size) {
     // We are the owner of the reserved memory, and any failure to unreserve
     // are fatal, so so we don't need to hold a lock while unreserving memory.
 
-    MemTracker::NmtVirtualMemoryLocker nvml;
+    NmtVirtualMemoryLocker nvml;
 
     // The current NMT implementation does not support unreserving a memory
     // region that was built up from smaller memory reservations. Workaround

src/hotspot/share/jfr/periodic/jfrNativeMemoryEvent.cpp

@@ -78,7 +78,7 @@ void JfrNativeMemoryEvent::send_type_events(const Ticks& timestamp) {
 
   NMTUsage* usage = get_usage(timestamp);
 
-  for (int index = 0; index < mt_number_of_tags; index ++) {
+  for (int index = 0; index < MemTagFactory::number_of_tags(); index ++) {
     MemTag mem_tag = NMTUtil::index_to_tag(index);
     if (mem_tag == mtNone) {
       // Skip mtNone since it is not really used.

src/hotspot/share/jfr/recorder/checkpoint/types/jfrType.cpp

@@ -348,10 +348,14 @@ void CompilerTypeConstant::serialize(JfrCheckpointWriter& writer) {
 }
 
 void NMTTypeConstant::serialize(JfrCheckpointWriter& writer) {
-  writer.write_count(mt_number_of_tags);
-  for (int i = 0; i < mt_number_of_tags; ++i) {
+  writer.write_count(MemTagFactory::number_of_tags());
+  for (int i = 0; i < MemTagFactory::number_of_tags(); ++i) {
     writer.write_key(i);
     MemTag mem_tag = NMTUtil::index_to_tag(i);
-    writer.write(NMTUtil::tag_to_name(mem_tag));
+    const char* name = MemTagFactory::human_readable_name_of(mem_tag);
+    if (name == nullptr) {
+      name = MemTagFactory::name_of(mem_tag);
+    }
+    writer.write(name);
   }
 }

src/hotspot/share/nmt/mallocLimit.cpp

@@ -25,14 +25,15 @@
 
 #include "nmt/mallocLimit.hpp"
 #include "nmt/memTag.hpp"
+#include "nmt/memTagFactory.hpp"
 #include "nmt/nmtCommon.hpp"
 #include "runtime/java.hpp"
 #include "runtime/globals.hpp"
 #include "utilities/globalDefinitions.hpp"
 #include "utilities/parseInteger.hpp"
 #include "utilities/ostream.hpp"
 
-MallocLimitSet MallocLimitHandler::_limits;
+Deferred<MallocLimitSet> MallocLimitHandler::_limits;
 bool MallocLimitHandler::_have_limit = false;
 
 static const char* const MODE_OOM = "oom";
@@ -89,7 +90,7 @@ class ParserHelper {
     }
     stringStream ss;
     ss.print("%.*s", (int)(end - _p), _p);
-    MemTag mem_tag = NMTUtil::string_to_mem_tag(ss.base());
+    MemTag mem_tag = MemTagFactory::tag(ss.freeze());
     if (mem_tag != mtNone) {
       *out = mem_tag;
       _p = end;
@@ -132,28 +133,29 @@ void MallocLimitSet::set_global_limit(size_t s, MallocLimitMode flag) {
 
 void MallocLimitSet::set_category_limit(MemTag mem_tag, size_t s, MallocLimitMode flag) {
   const int i = NMTUtil::tag_to_index(mem_tag);
-  _cat[i].sz = s; _cat[i].mode = flag;
+  malloclimit& tag_limit = _cat.at_grow(i);
+  tag_limit.sz = s; tag_limit.mode = flag;
 }
 
 void MallocLimitSet::reset() {
   set_global_limit(0, MallocLimitMode::trigger_fatal);
   _glob.sz = 0; _glob.mode = MallocLimitMode::trigger_fatal;
-  for (int i = 0; i < mt_number_of_tags; i++) {
+  for (int i = 0; i < MemTagFactory::number_of_tags(); i++) {
     set_category_limit(NMTUtil::index_to_tag(i), 0, MallocLimitMode::trigger_fatal);
   }
 }
 
-void MallocLimitSet::print_on(outputStream* st) const {
+void MallocLimitSet::print_on(outputStream* st) {
   static const char* flagnames[] = { MODE_FATAL, MODE_OOM };
   if (_glob.sz > 0) {
     st->print_cr("MallocLimit: total limit: " PROPERFMT " (%s)", PROPERFMTARGS(_glob.sz),
                  mode_to_name(_glob.mode));
   } else {
-    for (int i = 0; i < mt_number_of_tags; i++) {
-      if (_cat[i].sz > 0) {
+    for (int i = 0; i < MemTagFactory::number_of_tags(); i++) {
+      if (_cat.at_grow(i).sz > 0) {
         st->print_cr("MallocLimit: category \"%s\" limit: " PROPERFMT " (%s)",
-                     NMTUtil::tag_to_enum_name(NMTUtil::index_to_tag(i)),
-                     PROPERFMTARGS(_cat[i].sz), mode_to_name(_cat[i].mode));
+                     MemTagFactory::name_of(NMTUtil::index_to_tag(i)),
+                     PROPERFMTARGS(_cat.at_grow(i).sz), mode_to_name(_cat.at_grow(i).mode));
       }
     }
   }
@@ -192,7 +194,7 @@ bool MallocLimitSet::parse_malloclimit_option(const char* v, const char** err) {
       BAIL_UNLESS(sst.match_category(&mem_tag), "Expected category name");
       BAIL_UNLESS(sst.match_char(':'), "Expected colon following category");
 
-      malloclimit* const modified_limit = &_cat[NMTUtil::tag_to_index(mem_tag)];
+      malloclimit* const modified_limit = &_cat.at_grow(NMTUtil::tag_to_index(mem_tag));
 
       // Match size
       BAIL_UNLESS(sst.match_size(&modified_limit->sz), "Expected size");
@@ -213,9 +215,10 @@ bool MallocLimitSet::parse_malloclimit_option(const char* v, const char** err) {
 
 void MallocLimitHandler::initialize(const char* options) {
   _have_limit = false;
+  _limits.initialize();
   if (options != nullptr && options[0] != '\0') {
     const char* err = nullptr;
-    if (!_limits.parse_malloclimit_option(options, &err)) {
+    if (!_limits->parse_malloclimit_option(options, &err)) {
       vm_exit_during_initialization("Failed to parse MallocLimit", err);
     }
     _have_limit = true;
@@ -224,7 +227,7 @@ void MallocLimitHandler::initialize(const char* options) {
 
 void MallocLimitHandler::print_on(outputStream* st) {
   if (have_limit()) {
-    _limits.print_on(st);
+    _limits->print_on(st);
   } else {
     st->print_cr("MallocLimit: unset");
   }

src/hotspot/share/nmt/mallocLimit.hpp

@@ -28,8 +28,11 @@
 
 #include "memory/allStatic.hpp"
 #include "nmt/memTag.hpp"
+#include "nmt/nmtCommon.hpp"
 #include "utilities/debug.hpp"
+#include "utilities/deferred.hpp"
 #include "utilities/globalDefinitions.hpp"
+#include "utilities/growableArray.hpp"
 
 enum class MallocLimitMode {
   trigger_fatal = 0,
@@ -39,14 +42,23 @@ enum class MallocLimitMode {
 struct malloclimit {
   size_t sz;            // Limit size
   MallocLimitMode mode; // Behavior flags
+
+  malloclimit() : sz(0), mode(MallocLimitMode::trigger_fatal) {}
+  malloclimit& operator=(const malloclimit& other) {
+    this->sz = other.sz; this->mode = other.mode;
+    return *this;
+  }
+  malloclimit(const malloclimit& other) {
+    *this = other;
+  }
 };
 
 // forward declaration
 class outputStream;
 
 class MallocLimitSet {
-  malloclimit _glob;                    // global limit
-  malloclimit _cat[mt_number_of_tags]; // per-category limit
+  malloclimit _glob; // global limit
+  GrowableArrayCHeap<malloclimit, mtNMT> _cat; // per-category limit
 public:
   MallocLimitSet();
 
@@ -57,19 +69,22 @@ class MallocLimitSet {
   void set_category_limit(MemTag mem_tag, size_t s, MallocLimitMode mode);
 
   const malloclimit* global_limit() const             { return &_glob; }
-  const malloclimit* category_limit(MemTag mem_tag) const { return &_cat[(int)mem_tag]; }
+  const malloclimit* category_limit(MemTag mem_tag) {
+    _cat.at_grow(NMTUtil::tag_to_index(mem_tag));
+    return &_cat.at(NMTUtil::tag_to_index(mem_tag));
+  }
 
-  void print_on(outputStream* st) const;
+  void print_on(outputStream* st);
 };
 
 class MallocLimitHandler : public AllStatic {
-  static MallocLimitSet _limits;
+  static Deferred<MallocLimitSet> _limits;
   static bool _have_limit; // shortcut
 
 public:
 
-  static const malloclimit* global_limit()             { return _limits.global_limit(); }
-  static const malloclimit* category_limit(MemTag mem_tag) { return _limits.category_limit(mem_tag); }
+  static const malloclimit* global_limit()             { return _limits->global_limit(); }
+  static const malloclimit* category_limit(MemTag mem_tag) { return _limits->category_limit(mem_tag); }
 
   static void initialize(const char* options);
   static void print_on(outputStream* st);

src/hotspot/share/nmt/mallocTracker.cpp

@@ -63,27 +63,29 @@ void MemoryCounter::update_peak(size_t size, size_t cnt) {
   }
 }
 
-void MallocMemorySnapshot::copy_to(MallocMemorySnapshot* s) {
+void MallocMemorySnapshot::copy_to(MallocMemorySnapshot** result) {
   // Use lock to make sure that mtChunks don't get deallocated while the
   // copy is going on, because their size is adjusted using this
   // buffer in make_adjustment().
+  MallocMemorySnapshot* s = new MallocMemorySnapshot(*this);
   ChunkPoolLocker lock;
   s->_all_mallocs = _all_mallocs;
   size_t total_size = 0;
   size_t total_count = 0;
-  for (int index = 0; index < mt_number_of_tags; index ++) {
+  for (int index = 0; index <MemTagFactory::number_of_tags(); index ++) {
     s->_malloc[index] = _malloc[index];
     total_size += s->_malloc[index].malloc_size();
     total_count += s->_malloc[index].malloc_count();
   }
   // malloc counters may be updated concurrently
   s->_all_mallocs.set_size_and_count(total_size, total_count);
+  *result = s;
 }
 
 // Total malloc'd memory used by arenas
 size_t MallocMemorySnapshot::total_arena() const {
   size_t amount = 0;
-  for (int index = 0; index < mt_number_of_tags; index ++) {
+  for (int index = 0; index < MemTagFactory::number_of_tags(); index ++) {
     amount += _malloc[index].arena_size();
   }
   return amount;
@@ -137,7 +139,7 @@ bool MallocMemorySummary::category_limit_reached(MemTag mem_tag, size_t s, size_
 
 #define FORMATTED \
   "MallocLimit: reached category \"%s\" limit (triggering allocation size: " PROPERFMT ", allocated so far: " PROPERFMT ", limit: " PROPERFMT ") ", \
-  NMTUtil::tag_to_enum_name(mem_tag), PROPERFMTARGS(s), PROPERFMTARGS(so_far), PROPERFMTARGS(limit->sz)
+  MemTagFactory::name_of(mem_tag), PROPERFMTARGS(s), PROPERFMTARGS(so_far), PROPERFMTARGS(limit->sz)
 
   // If we hit the limit during error reporting, we print a short warning but otherwise ignore it.
   // We don't want to risk recursive assertion or torn hs-err logs.
@@ -306,7 +308,7 @@ bool MallocTracker::print_pointer_information(const void* p, outputStream* st) {
                  p2i(p), where,
                  (block->is_dead() ? "dead" : "live"),
                  p2i(block + 1), // lets print the payload start, not the header
-                 block->size(), NMTUtil::tag_to_enum_name(block->mem_tag()));
+                 block->size(), MemTagFactory::name_of(block->mem_tag()));
     if (MemTracker::tracking_level() == NMT_detail) {
       NativeCallStack ncs;
       if (MallocSiteTable::access_stack(ncs, *block)) {

src/hotspot/share/nmt/mallocTracker.hpp

@@ -228,7 +228,7 @@ class MallocMemorySnapshot : public CHeapObj<mtNMT> {
   // Total malloc'd memory used by arenas
   size_t total_arena() const;
 
-  void copy_to(MallocMemorySnapshot* s);
+  void copy_to(MallocMemorySnapshot** s);
 
   // Make adjustment by subtracting chunks used by arenas
   // from total chunks to get total free chunk size
@@ -283,7 +283,7 @@ class MallocMemorySummary : AllStatic {
 
    static void snapshot(MallocMemorySnapshot** s) {
      *s = new MallocMemorySnapshot(*as_snapshot());
-     as_snapshot()->copy_to(*s);
+     as_snapshot()->copy_to(s);
      (*s)->make_adjustment();
    }
 

src/hotspot/share/nmt/memBaseline.cpp

@@ -140,7 +140,7 @@ void MemBaseline::baseline_summary() {
   MallocMemorySummary::snapshot(&_malloc_memory_snapshot);
   VirtualMemorySummary::snapshot(&_virtual_memory_snapshot);
   {
-    MemTracker::NmtVirtualMemoryLocker nvml;
+    NmtVirtualMemoryLocker nvml;
     MemoryFileTracker::Instance::summary_snapshot(&_virtual_memory_snapshot);
   }
 

src/hotspot/share/nmt/memMapPrinter.cpp

@@ -70,7 +70,7 @@ static const char* get_shortname_for_mem_tag(MemTag mem_tag) {
 #define DO(t, shortname, text) if (t == mem_tag) return shortname;
   NMT_FLAGS_DO(DO)
 #undef DO
-  return NMTUtil::tag_to_enum_name(mem_tag);
+  return MemTagFactory::name_of(mem_tag);
 }
 
 /// NMT virtual memory
@@ -249,7 +249,7 @@ bool MappingPrintSession::print_nmt_info_for_region(const void* vma_from, const
     // Correlate vma region (from, to) with NMT region(s) we collected previously.
     const MemTagBitmap flags = _nmt_info.lookup(vma_from, vma_to);
     if (flags.has_any()) {
-      for (int i = 0; i < mt_number_of_tags; i++) {
+      for (int i = 0; i < MemTagFactory::number_of_tags(); i++) {
         const MemTag mem_tag = (MemTag)i;
         if (flags.has_tag(mem_tag)) {
           if (num_printed > 0) {

src/hotspot/share/nmt/memReporter.cpp

@@ -80,7 +80,7 @@ void MemReporterBase::print_malloc(const MemoryCounter* c, MemTag mem_tag) const
 
   if (mem_tag != mtNone) {
     out->print("(%s%zu%s tag=%s", alloc_type,
-      amount_in_current_scale(amount), scale, NMTUtil::tag_to_name(mem_tag));
+      amount_in_current_scale(amount), scale, MemTagFactory::human_readable_name_of(mem_tag));
   } else {
     out->print("(%s%zu%s", alloc_type,
       amount_in_current_scale(amount), scale);
@@ -177,7 +177,7 @@ void MemSummaryReporter::report() {
   out->cr();
 
   // Summary by memory tag
-  for (int index = 0; index < mt_number_of_tags; index ++) {
+  for (int index = 0; index < MemTagFactory::number_of_tags(); index ++) {
     MemTag mem_tag = NMTUtil::index_to_tag(index);
     // thread stack is reported as part of thread category
     if (mem_tag == mtThreadStack) continue;
@@ -219,7 +219,7 @@ void MemSummaryReporter::report_summary_of_tag(MemTag mem_tag,
   outputStream* out   = output();
   const char*   scale = current_scale();
   constexpr int indent = 28;
-  out->print("-%*s (", indent - 2, NMTUtil::tag_to_name(mem_tag));
+  out->print("-%*s (", indent - 2, MemTagFactory::human_readable_name_of(mem_tag));
   print_total(reserved_amount, committed_amount);
 #if INCLUDE_CDS
   if (mem_tag == mtClassShared) {
@@ -380,7 +380,7 @@ int MemDetailReporter::report_virtual_memory_allocation_sites()  {
       print_total(virtual_memory_site->reserved(), virtual_memory_site->committed());
       const MemTag mem_tag = virtual_memory_site->mem_tag();
       if (mem_tag != mtNone) {
-        out->print(" Tag=%s", NMTUtil::tag_to_name(mem_tag));
+        out->print(" Tag=%s", MemTagFactory::human_readable_name_of(mem_tag));
       }
       out->print_cr(")");
     )
@@ -423,7 +423,7 @@ void MemDetailReporter::report_virtual_memory_region(const ReservedMemoryRegion*
   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()));
+  out->print(" for %s", MemTagFactory::human_readable_name_of(reserved_rgn->mem_tag()));
   if (stack->is_empty()) {
     out->cr();
   } else {
@@ -465,7 +465,7 @@ void MemDetailReporter::report_virtual_memory_region(const ReservedMemoryRegion*
 void MemDetailReporter::report_memory_file_allocations() {
   stringStream st;
   {
-    MemTracker::NmtVirtualMemoryLocker nvml;
+    NmtVirtualMemoryLocker nvml;
     MemoryFileTracker::Instance::print_all_reports_on(&st, scale());
   }
   output()->print_raw(st.freeze());
@@ -520,7 +520,7 @@ void MemSummaryDiffReporter::report_diff() {
   out->cr();
 
   // Summary diff by memory tag
-  for (int index = 0; index < mt_number_of_tags; index ++) {
+  for (int index = 0; index < MemTagFactory::number_of_tags(); index ++) {
     MemTag mem_tag = NMTUtil::index_to_tag(index);
     // thread stack is reported as part of thread category
     if (mem_tag == mtThreadStack) continue;
@@ -543,7 +543,7 @@ void MemSummaryDiffReporter::print_malloc_diff(size_t current_amount, size_t cur
   out->print("%s%zu%s", alloc_tag, amount_in_current_scale(current_amount), scale);
   // Report type only if it is valid and not under "thread" category
   if (mem_tag != mtNone && mem_tag != mtThread) {
-    out->print(" type=%s", NMTUtil::tag_to_name(mem_tag));
+    out->print(" type=%s", MemTagFactory::human_readable_name_of(mem_tag));
   }
 
   int64_t amount_diff = diff_in_current_scale(current_amount, early_amount);
@@ -636,7 +636,7 @@ void MemSummaryDiffReporter::diff_summary_of_tag(MemTag mem_tag,
       diff_in_current_scale(current_reserved_amount, early_reserved_amount) != 0) {
 
     // print summary line
-    out->print("-%*s (", indent - 2, NMTUtil::tag_to_name(mem_tag));
+    out->print("-%*s (", indent - 2, MemTagFactory::human_readable_name_of(mem_tag));
     print_virtual_memory_diff(current_reserved_amount, current_committed_amount,
       early_reserved_amount, early_committed_amount);
     out->print_cr(")");
@@ -937,7 +937,7 @@ void MemDetailDiffReporter::diff_virtual_memory_site(const NativeCallStack* stac
     out->print("(mmap: ");
     print_virtual_memory_diff(current_reserved, current_committed, early_reserved, early_committed);
     if (mem_tag != mtNone) {
-      out->print(" Type=%s", NMTUtil::tag_to_name(mem_tag));
+      out->print(" Type=%s", MemTagFactory::human_readable_name_of(mem_tag));
     }
     out->print_cr(")");
   )