8299915: Remove ArrayAllocatorMallocLimit and associated code

Reviewed-by: dholmes, coleenp

Author: Afshin Zafari

src/hotspot/share/gc/shared/taskqueue.inline.hpp

@@ -99,13 +99,13 @@ inline void GenericTaskQueueSet<T, F>::print_and_reset_taskqueue_stats(const cha
 
 template<class E, MEMFLAGS F, unsigned int N>
 inline GenericTaskQueue<E, F, N>::GenericTaskQueue() :
-  _elems(ArrayAllocator<E>::allocate(N, F)),
+  _elems(MallocArrayAllocator<E>::allocate(N, F)),
   _last_stolen_queue_id(InvalidQueueId),
   _seed(17 /* random number */) {}
 
 template<class E, MEMFLAGS F, unsigned int N>
 inline GenericTaskQueue<E, F, N>::~GenericTaskQueue() {
-  ArrayAllocator<E>::free(_elems, N);
+  MallocArrayAllocator<E>::free(_elems);
 }
 
 template<class E, MEMFLAGS F, unsigned int N> inline bool

src/hotspot/share/memory/allocation.hpp

@@ -616,32 +616,6 @@ class ReallocMark: public StackObj {
   void check()    PRODUCT_RETURN;
 };
 
-// Helper class to allocate arrays that may become large.
-// Uses the OS malloc for allocations smaller than ArrayAllocatorMallocLimit
-// and uses mapped memory for larger allocations.
-// Most OS mallocs do something similar but Solaris malloc does not revert
-// to mapped memory for large allocations. By default ArrayAllocatorMallocLimit
-// is set so that we always use malloc except for Solaris where we set the
-// limit to get mapped memory.
-template <class E>
-class ArrayAllocator : public AllStatic {
- private:
-  static bool should_use_malloc(size_t length);
-
-  static E* allocate_malloc(size_t length, MEMFLAGS flags);
-  static E* allocate_mmap(size_t length, MEMFLAGS flags);
-
-  static E* reallocate_malloc(E* addr, size_t new_length, MEMFLAGS flags);
-
-  static void free_malloc(E* addr, size_t length);
-  static void free_mmap(E* addr, size_t length);
-
- public:
-  static E* allocate(size_t length, MEMFLAGS flags);
-  static E* reallocate(E* old_addr, size_t old_length, size_t new_length, MEMFLAGS flags);
-  static void free(E* addr, size_t length);
-};
-
 // Uses mmapped memory for all allocations. All allocations are initially
 // zero-filled. No pre-touching.
 template <class E>

src/hotspot/share/memory/allocation.inline.hpp

@@ -111,75 +111,4 @@ void MallocArrayAllocator<E>::free(E* addr) {
   FreeHeap(addr);
 }
 
-template <class E>
-bool ArrayAllocator<E>::should_use_malloc(size_t length) {
-  return MallocArrayAllocator<E>::size_for(length) < ArrayAllocatorMallocLimit;
-}
-
-template <class E>
-E* ArrayAllocator<E>::allocate_malloc(size_t length, MEMFLAGS flags) {
-  return MallocArrayAllocator<E>::allocate(length, flags);
-}
-
-template <class E>
-E* ArrayAllocator<E>::allocate_mmap(size_t length, MEMFLAGS flags) {
-  return MmapArrayAllocator<E>::allocate(length, flags);
-}
-
-template <class E>
-E* ArrayAllocator<E>::allocate(size_t length, MEMFLAGS flags) {
-  if (should_use_malloc(length)) {
-    return allocate_malloc(length, flags);
-  }
-
-  return allocate_mmap(length, flags);
-}
-
-template <class E>
-E* ArrayAllocator<E>::reallocate_malloc(E* addr, size_t new_length, MEMFLAGS flags) {
-  return MallocArrayAllocator<E>::reallocate(addr, new_length, flags);
-}
-
-template <class E>
-E* ArrayAllocator<E>::reallocate(E* old_addr, size_t old_length, size_t new_length, MEMFLAGS flags) {
-  if (should_use_malloc(old_length) && should_use_malloc(new_length)) {
-    return reallocate_malloc(old_addr, new_length, flags);
-  }
-
-  E* new_addr = (new_length > 0)
-      ? allocate(new_length, flags)
-      : nullptr;
-
-  if (new_addr != nullptr && old_addr != nullptr) {
-    memcpy(new_addr, old_addr, MIN2(old_length, new_length) * sizeof(E));
-  }
-
-  if (old_addr != nullptr) {
-    free(old_addr, old_length);
-  }
-
-  return new_addr;
-}
-
-template <class E>
-void ArrayAllocator<E>::free_malloc(E* addr, size_t length) {
-  MallocArrayAllocator<E>::free(addr);
-}
-
-template <class E>
-void ArrayAllocator<E>::free_mmap(E* addr, size_t length) {
-  MmapArrayAllocator<E>::free(addr, length);
-}
-
-template <class E>
-void ArrayAllocator<E>::free(E* addr, size_t length) {
-  if (addr != nullptr) {
-    if (should_use_malloc(length)) {
-      free_malloc(addr, length);
-    } else {
-      free_mmap(addr, length);
-    }
-  }
-}
-
 #endif // SHARE_MEMORY_ALLOCATION_INLINE_HPP

src/hotspot/share/runtime/globals.hpp

@@ -1888,10 +1888,6 @@ const int ObjectAlignmentInBytes = 8;
   product(bool, WhiteBoxAPI, false, DIAGNOSTIC,                             \
           "Enable internal testing APIs")                                   \
                                                                             \
-  product(size_t, ArrayAllocatorMallocLimit, SIZE_MAX, EXPERIMENTAL,        \
-          "Allocation less than this value will be allocated "              \
-          "using malloc. Larger allocations will use mmap.")                \
-                                                                            \
   product(bool, AlwaysAtomicAccesses, false, EXPERIMENTAL,                  \
           "Accesses to all variables should always be atomic")              \
                                                                             \

src/hotspot/share/utilities/bitMap.cpp

@@ -135,15 +135,17 @@ CHeapBitMap::~CHeapBitMap() {
 }
 
 bm_word_t* CHeapBitMap::allocate(idx_t size_in_words) const {
-  return ArrayAllocator<bm_word_t>::allocate(size_in_words, _flags);
+  return MallocArrayAllocator<bm_word_t>::allocate(size_in_words, _flags);
 }
 
+// GrowableBitMap<T>::resize uses free(ptr, size) for T as CHeapBitMap, ArenaBitMap and ResourceBitMap allocators.
+// The free(ptr, size) signature is kept but the size parameter is ignored.
 void CHeapBitMap::free(bm_word_t* map, idx_t size_in_words) const {
-  ArrayAllocator<bm_word_t>::free(map, size_in_words);
+  MallocArrayAllocator<bm_word_t>::free(map);
 }
 
 bm_word_t* CHeapBitMap::reallocate(bm_word_t* map, size_t old_size_in_words, size_t new_size_in_words) const {
-  return ArrayAllocator<bm_word_t>::reallocate(map, old_size_in_words, new_size_in_words, _flags);
+  return MallocArrayAllocator<bm_word_t>::reallocate(map, new_size_in_words, _flags);
 }
 
 #ifdef ASSERT

test/hotspot/jtreg/gc/arguments/TestArrayAllocatorMallocLimit.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2014, 2021, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2014, 2023, 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
@@ -59,8 +59,7 @@ public static void main(String... args) throws Exception {
 
     // Test a non-manageable size_t flag.
     // Since it is not manageable, we can't test the setFlag functionality.
-    testGetFlag("ArrayAllocatorMallocLimit", "128");
-    // testSetFlag("ArrayAllocatorMallocLimit", "64", "128");
+    testGetFlag("MetaspaceSize", "65536");
 
     // Test a uint flag.
     testGetFlag("ParallelGCThreads", "10");

test/hotspot/jtreg/serviceability/attach/AttachSetGetFlag.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2014, 2021, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2014, 2023, 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
@@ -35,7 +35,7 @@
 import jdk.test.lib.Platform;
 
 public class SizeTTest {
-    private static final String FLAG_NAME = "ArrayAllocatorMallocLimit";
+    private static final String FLAG_NAME = "LargePageSizeInBytes";
     private static final Long[] TESTS = {0L, 100L, (long) Integer.MAX_VALUE,
         (1L << 32L) - 1L, 1L << 32L};
     private static final Long[] EXPECTED_64 = TESTS;