8293313: NMT: Rework MallocLimit

8293292: Remove MallocMaxTestWords

Reviewed-by: jsjolen, gziemski, lucy, mbaesken

Author: tstuefe

src/hotspot/share/memory/arena.cpp

@@ -1,5 +1,6 @@
 /*
  * Copyright (c) 2017, 2023, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2019, 2023 SAP SE. 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 +30,7 @@
 #include "runtime/os.hpp"
 #include "runtime/task.hpp"
 #include "runtime/threadCritical.hpp"
-#include "services/memTracker.hpp"
+#include "services/memTracker.inline.hpp"
 #include "utilities/align.hpp"
 #include "utilities/debug.hpp"
 #include "utilities/ostream.hpp"
@@ -309,6 +310,10 @@ void* Arena::grow(size_t x, AllocFailType alloc_failmode) {
   // (Note: all chunk sizes have to be 64-bit aligned)
   size_t len = MAX2(ARENA_ALIGN(x), (size_t) Chunk::size);
 
+  if (MemTracker::check_exceeds_limit(x, _flags)) {
+    return nullptr;
+  }
+
   Chunk *k = _chunk;            // Get filled-up chunk address
   _chunk = new (alloc_failmode, len) Chunk(len);
 

src/hotspot/share/runtime/arguments.cpp

@@ -4263,78 +4263,3 @@ bool Arguments::copy_expand_pid(const char* src, size_t srclen,
   *b = '\0';
   return (p == src_end); // return false if not all of the source was copied
 }
-
-bool Arguments::parse_malloc_limit_size(const char* s, size_t* out) {
-  julong limit = 0;
-  Arguments::ArgsRange range = parse_memory_size(s, &limit, 1, SIZE_MAX);
-  switch (range) {
-  case ArgsRange::arg_in_range:
-    *out = (size_t)limit;
-    return true;
-  case ArgsRange::arg_too_big: // only possible on 32-bit
-    vm_exit_during_initialization("MallocLimit: too large", s);
-    break;
-  case ArgsRange::arg_too_small:
-    vm_exit_during_initialization("MallocLimit: limit must be > 0");
-    break;
-  default:
-    break;
-  }
-  return false;
-}
-
-// Helper for parse_malloc_limits
-void Arguments::parse_single_category_limit(char* expression, size_t limits[mt_number_of_types]) {
-  // <category>:<limit>
-  char* colon = ::strchr(expression, ':');
-  if (colon == nullptr) {
-    vm_exit_during_initialization("MallocLimit: colon missing", expression);
-  }
-  *colon = '\0';
-  MEMFLAGS f = NMTUtil::string_to_flag(expression);
-  if (f == mtNone) {
-    vm_exit_during_initialization("MallocLimit: invalid nmt category", expression);
-  }
-  if (parse_malloc_limit_size(colon + 1, limits + (int)f) == false) {
-    vm_exit_during_initialization("Invalid MallocLimit size", colon + 1);
-  }
-}
-
-void Arguments::parse_malloc_limits(size_t* total_limit, size_t limits[mt_number_of_types]) {
-
-  // Reset output to 0
-  *total_limit = 0;
-  for (int i = 0; i < mt_number_of_types; i ++) {
-    limits[i] = 0;
-  }
-
-  // We are done if the option is not given.
-  if (MallocLimit == nullptr) {
-    return;
-  }
-
-  // Global form?
-  if (parse_malloc_limit_size(MallocLimit, total_limit)) {
-    return;
-  }
-
-  // No. So it must be in category-specific form: MallocLimit=<nmt category>:<size>[,<nmt category>:<size> ..]
-  char* copy = os::strdup(MallocLimit);
-  if (copy == nullptr) {
-    vm_exit_out_of_memory(strlen(MallocLimit), OOM_MALLOC_ERROR, "MallocLimit");
-  }
-
-  char* p = copy, *q;
-  do {
-    q = p;
-    p = ::strchr(q, ',');
-    if (p != nullptr) {
-      *p = '\0';
-      p ++;
-    }
-    parse_single_category_limit(q, limits);
-  } while (p != nullptr);
-
-  os::free(copy);
-
-}

src/hotspot/share/runtime/arguments.hpp

@@ -477,10 +477,6 @@ class Arguments : AllStatic {
                                          char** base_archive_path,
                                          char** top_archive_path) NOT_CDS_RETURN;
 
-  // Helpers for parse_malloc_limits
-  static bool parse_malloc_limit_size(const char* s, size_t* out);
-  static void parse_single_category_limit(char* expression, size_t limits[mt_number_of_types]);
-
  public:
   static int num_archives(const char* archive_path) NOT_CDS_RETURN_(0);
   // Parses the arguments, first phase
@@ -651,16 +647,6 @@ class Arguments : AllStatic {
     assert(Arguments::is_dumping_archive(), "dump time only");
   }
 
-  // Parse diagnostic NMT switch "MallocLimit" and return the found limits.
-  // 1) If option is not given, it will set all limits to 0 (aka "no limit").
-  // 2) If option is given in the global form (-XX:MallocLimit=<size>), it
-  //    will return the size in *total_limit.
-  // 3) If option is given in its per-NMT-category form (-XX:MallocLimit=<category>:<size>[,<category>:<size>]),
-  //    it will return all found limits in the limits array.
-  // 4) If option is malformed, it will exit the VM.
-  // For (2) and (3), limits not affected by the switch will be set to 0.
-  static void parse_malloc_limits(size_t* total_limit, size_t limits[mt_number_of_types]);
-
   DEBUG_ONLY(static bool verify_special_jvm_flags(bool check_globals);)
 };
 

src/hotspot/share/runtime/globals.hpp

@@ -1341,20 +1341,22 @@ const int ObjectAlignmentInBytes = 8;
   notproduct(intx, ZombieALotInterval,     5,                               \
           "Number of exits until ZombieALot kicks in")                      \
                                                                             \
-  product(uintx, MallocMaxTestWords,     0, DIAGNOSTIC,                     \
-          "If non-zero, maximum number of words that malloc/realloc can "   \
-          "allocate (for testing only)")                                    \
-          range(0, max_uintx)                                               \
-                                                                            \
   product(ccstr, MallocLimit, nullptr, DIAGNOSTIC,                          \
-          "Limit malloc allocation size from VM. Reaching the limit will "  \
-          "trigger a fatal error. This feature requires "                   \
+          "Limit malloc allocation size from VM. Reaching a limit will "    \
+          "trigger an action (see flag). This feature requires "            \
           "NativeMemoryTracking=summary or NativeMemoryTracking=detail."    \
           "Usage:"                                                          \
-          "- MallocLimit=<size> to set a total limit. "                     \
-          "- MallocLimit=<NMT category>:<size>[,<NMT category>:<size>...] " \
-          "  to set one or more category-specific limits."                  \
-          "Example: -XX:MallocLimit=compiler:500m")                         \
+          "\"-XX:MallocLimit=<size>[:<flag>]\" sets a total limit."         \
+          "\"-XX:MallocLimit=<category>:<size>[:<flag>][,<category>:<size>[:<flag>] ...]\"" \
+          "sets one or more category-specific limits."                      \
+          "<flag> defines the action upon reaching the limit:"              \
+          "\"fatal\": end VM with a fatal error at the allocation site"     \
+          "\"oom\"  : will mimic a native OOM"                              \
+          "If <flag> is omitted, \"fatal\" is the default."                 \
+          "Examples:\n"                                                     \
+          "-XX:MallocLimit=2g"                                              \
+          "-XX:MallocLimit=2g:oom"                                          \
+          "-XX:MallocLimit=compiler:200m:oom,code:100m")                    \
                                                                             \
   product(intx, TypeProfileWidth, 2,                                        \
           "Number of receiver types to record in call/cast profile")        \

src/hotspot/share/runtime/os.cpp

@@ -64,7 +64,7 @@
 #include "services/attachListener.hpp"
 #include "services/mallocTracker.hpp"
 #include "services/mallocHeader.inline.hpp"
-#include "services/memTracker.hpp"
+#include "services/memTracker.inline.hpp"
 #include "services/nmtPreInit.hpp"
 #include "services/nmtCommon.hpp"
 #include "services/threadService.hpp"
@@ -87,8 +87,6 @@ int               os::_processor_count    = 0;
 int               os::_initial_active_processor_count = 0;
 os::PageSizes     os::_page_sizes;
 
-static size_t cur_malloc_words = 0;  // current size for MallocMaxTestWords
-
 DEBUG_ONLY(bool os::_mutex_init_done = false;)
 
 int os::snprintf(char* buf, size_t len, const char* fmt, ...) {
@@ -607,23 +605,6 @@ char* os::strdup_check_oom(const char* str, MEMFLAGS flags) {
   return p;
 }
 
-//
-// This function supports testing of the malloc out of memory
-// condition without really running the system out of memory.
-//
-
-static bool has_reached_max_malloc_test_peak(size_t alloc_size) {
-  if (MallocMaxTestWords > 0) {
-    size_t words = (alloc_size / BytesPerWord);
-
-    if ((cur_malloc_words + words) > MallocMaxTestWords) {
-      return true;
-    }
-    Atomic::add(&cur_malloc_words, words);
-  }
-  return false;
-}
-
 #ifdef ASSERT
 static void check_crash_protection() {
   assert(!ThreadCrashProtection::is_crash_protected(Thread::current_or_null()),
@@ -658,8 +639,8 @@ void* os::malloc(size_t size, MEMFLAGS memflags, const NativeCallStack& stack) {
   // we chose the latter.
   size = MAX2((size_t)1, size);
 
-  // For the test flag -XX:MallocMaxTestWords
-  if (has_reached_max_malloc_test_peak(size)) {
+  // Observe MallocLimit
+  if (MemTracker::check_exceeds_limit(size, memflags)) {
     return nullptr;
   }
 
@@ -710,11 +691,6 @@ void* os::realloc(void *memblock, size_t size, MEMFLAGS memflags, const NativeCa
   // we chose the latter.
   size = MAX2((size_t)1, size);
 
-  // For the test flag -XX:MallocMaxTestWords
-  if (has_reached_max_malloc_test_peak(size)) {
-    return nullptr;
-  }
-
   if (MemTracker::enabled()) {
     // NMT realloc handling
 
@@ -725,12 +701,20 @@ void* os::realloc(void *memblock, size_t size, MEMFLAGS memflags, const NativeCa
       return nullptr;
     }
 
+    const size_t old_size = MallocTracker::malloc_header(memblock)->size();
+
+    // Observe MallocLimit
+    if ((size > old_size) && MemTracker::check_exceeds_limit(size - old_size, memflags)) {
+      return nullptr;
+    }
+
     // Perform integrity checks on and mark the old block as dead *before* calling the real realloc(3) since it
     // may invalidate the old block, including its header.
     MallocHeader* header = MallocHeader::resolve_checked(memblock);
     assert(memflags == header->flags(), "weird NMT flags mismatch (new:\"%s\" != old:\"%s\")\n",
            NMTUtil::flag_to_name(memflags), NMTUtil::flag_to_name(header->flags()));
     const MallocHeader::FreeInfo free_info = header->free_info();
+
     header->mark_block_as_dead();
 
     // the real realloc
@@ -750,7 +734,7 @@ void* os::realloc(void *memblock, size_t size, MEMFLAGS memflags, const NativeCa
     void* const new_inner_ptr = MemTracker::record_malloc(new_outer_ptr, size, memflags, stack);
 
 #ifdef ASSERT
-    size_t old_size = free_info.size;
+    assert(old_size == free_info.size, "Sanity");
     if (old_size < size) {
       // We also zap the newly extended region.
       ::memset((char*)new_inner_ptr + old_size, uninitBlockPad, size - old_size);