8251158: Implementation of JEP 387: Elastic Metaspace

Reviewed-by: lkorinth, coleenp, iklam, rrich

src/hotspot/share/classfile/classLoaderData.cpp

@@ -58,7 +58,9 @@
 #include "logging/log.hpp"
 #include "logging/logStream.hpp"
 #include "memory/allocation.inline.hpp"
+#include "memory/classLoaderMetaspace.hpp"
 #include "memory/metadataFactory.hpp"
+#include "memory/metaspace.hpp"
 #include "memory/resourceArea.hpp"
 #include "memory/universe.hpp"
 #include "oops/access.inline.hpp"
@@ -953,9 +955,11 @@ void ClassLoaderData::verify() {
   guarantee(cl != NULL || this == ClassLoaderData::the_null_class_loader_data() || has_class_mirror_holder(), "must be");
 
   // Verify the integrity of the allocated space.
+#ifdef ASSERT
   if (metaspace_or_null() != NULL) {
     metaspace_or_null()->verify();
   }
+#endif
 
   for (Klass* k = _klasses; k != NULL; k = k->next_link()) {
     guarantee(k->class_loader_data() == this, "Must be the same");

src/hotspot/share/classfile/classLoaderData.hpp

@@ -62,6 +62,7 @@ class ModuleEntryTable;
 class PackageEntryTable;
 class DictionaryEntry;
 class Dictionary;
+class ClassLoaderMetaspace;
 
 // ClassLoaderData class
 

src/hotspot/share/classfile/classLoaderDataGraph.cpp

@@ -661,24 +661,6 @@ Klass* ClassLoaderDataGraphKlassIteratorAtomic::next_klass() {
   return NULL;
 }
 
-ClassLoaderDataGraphMetaspaceIterator::ClassLoaderDataGraphMetaspaceIterator() {
-  assert(SafepointSynchronize::is_at_safepoint(), "must be at safepoint!");
-  _data = ClassLoaderDataGraph::_head;
-}
-
-ClassLoaderDataGraphMetaspaceIterator::~ClassLoaderDataGraphMetaspaceIterator() {}
-
-ClassLoaderMetaspace* ClassLoaderDataGraphMetaspaceIterator::get_next() {
-  assert(_data != NULL, "Should not be NULL in call to the iterator");
-  ClassLoaderMetaspace* result = _data->metaspace_or_null();
-  _data = _data->next();
-  // This result might be NULL for class loaders without metaspace
-  // yet.  It would be nice to return only non-null results but
-  // there is no guarantee that there will be a non-null result
-  // down the list so the caller is going to have to check.
-  return result;
-}
-
 void ClassLoaderDataGraph::verify() {
   ClassLoaderDataGraphIterator iter;
   while (ClassLoaderData* cld = iter.get_next()) {

src/hotspot/share/classfile/classLoaderDataGraph.hpp

@@ -162,12 +162,4 @@ class ClassLoaderDataGraphKlassIteratorAtomic : public StackObj {
   static Klass* next_klass_in_cldg(Klass* klass);
 };
 
-class ClassLoaderDataGraphMetaspaceIterator : public StackObj {
-  ClassLoaderData* _data;
- public:
-  ClassLoaderDataGraphMetaspaceIterator();
-  ~ClassLoaderDataGraphMetaspaceIterator();
-  bool repeat() { return _data != NULL; }
-  ClassLoaderMetaspace* get_next();
-};
 #endif // SHARE_CLASSFILE_CLASSLOADERDATAGRAPH_HPP

src/hotspot/share/classfile/classLoaderStats.cpp

@@ -26,6 +26,7 @@
 #include "classfile/classLoaderData.inline.hpp"
 #include "classfile/classLoaderDataGraph.hpp"
 #include "classfile/classLoaderStats.hpp"
+#include "memory/classLoaderMetaspace.hpp"
 #include "oops/objArrayKlass.hpp"
 #include "oops/oop.inline.hpp"
 #include "utilities/globalDefinitions.hpp"
@@ -80,15 +81,17 @@ void ClassLoaderStatsClosure::do_cld(ClassLoaderData* cld) {
 
   ClassLoaderMetaspace* ms = cld->metaspace_or_null();
   if (ms != NULL) {
+    size_t used_bytes, capacity_bytes;
+    ms->calculate_jfr_stats(&used_bytes, &capacity_bytes);
     if(cld->has_class_mirror_holder()) {
-      cls->_hidden_chunk_sz += ms->allocated_chunks_bytes();
+      cls->_hidden_chunk_sz += capacity_bytes;
-      cls->_hidden_block_sz += ms->allocated_blocks_bytes();
+      cls->_hidden_block_sz += used_bytes;
     } else {
-      cls->_chunk_sz = ms->allocated_chunks_bytes();
+      cls->_chunk_sz = capacity_bytes;
-      cls->_block_sz = ms->allocated_blocks_bytes();
+      cls->_block_sz = used_bytes;
     }
-    _total_chunk_sz += ms->allocated_chunks_bytes();
+    _total_chunk_sz += capacity_bytes;
-    _total_block_sz += ms->allocated_blocks_bytes();
+    _total_block_sz += used_bytes;
   }
 }
 

src/hotspot/share/gc/g1/g1CollectedHeap.cpp

@@ -1034,7 +1034,7 @@ void G1CollectedHeap::prepare_heap_for_mutators() {
 
   // Delete metaspaces for unloaded class loaders and clean up loader_data graph
   ClassLoaderDataGraph::purge(/*at_safepoint*/true);
-  MetaspaceUtils::verify_metrics();
+  DEBUG_ONLY(MetaspaceUtils::verify();)
 
   // Prepare heap for normal collections.
   assert(num_free_regions() == 0, "we should not have added any free regions");

src/hotspot/share/gc/parallel/psParallelCompact.cpp

@@ -1058,7 +1058,7 @@ void PSParallelCompact::post_compact()
 
   // Delete metaspaces for unloaded class loaders and clean up loader_data graph
   ClassLoaderDataGraph::purge(/*at_safepoint*/true);
-  MetaspaceUtils::verify_metrics();
+  DEBUG_ONLY(MetaspaceUtils::verify();)
 
   heap->prune_scavengable_nmethods();
 

src/hotspot/share/gc/shared/collectedHeap.cpp

@@ -37,7 +37,7 @@
 #include "gc/shared/memAllocator.hpp"
 #include "logging/log.hpp"
 #include "logging/logStream.hpp"
-#include "memory/metaspace.hpp"
+#include "memory/classLoaderMetaspace.hpp"
 #include "memory/resourceArea.hpp"
 #include "memory/universe.hpp"
 #include "oops/instanceMirrorKlass.hpp"

src/hotspot/share/gc/shared/gcVMOperations.cpp

@@ -32,6 +32,7 @@
 #include "gc/shared/genCollectedHeap.hpp"
 #include "interpreter/oopMapCache.hpp"
 #include "logging/log.hpp"
+#include "memory/classLoaderMetaspace.hpp"
 #include "memory/oopFactory.hpp"
 #include "memory/universe.hpp"
 #include "runtime/handles.inline.hpp"

src/hotspot/share/gc/shared/gcVMOperations.hpp

@@ -28,6 +28,7 @@
 #include "gc/shared/collectedHeap.hpp"
 #include "gc/shared/genCollectedHeap.hpp"
 #include "memory/heapInspection.hpp"
+#include "memory/metaspace.hpp"
 #include "prims/jvmtiExport.hpp"
 #include "runtime/handles.hpp"
 #include "runtime/jniHandles.hpp"

src/hotspot/share/gc/shared/genCollectedHeap.cpp

@@ -58,6 +58,7 @@
 #include "gc/shared/workgroup.hpp"
 #include "memory/filemap.hpp"
 #include "memory/iterator.hpp"
+#include "memory/metaspace/metaspaceSizesSnapshot.hpp"
 #include "memory/metaspaceCounters.hpp"
 #include "memory/resourceArea.hpp"
 #include "memory/universe.hpp"
@@ -662,7 +663,7 @@ void GenCollectedHeap::do_collection(bool           full,
 
     // Delete metaspaces for unloaded class loaders and clean up loader_data graph
     ClassLoaderDataGraph::purge(/*at_safepoint*/true);
-    MetaspaceUtils::verify_metrics();
+    DEBUG_ONLY(MetaspaceUtils::verify();)
     // Resize the metaspace capacity after full collections
     MetaspaceGC::compute_new_size();
     update_full_collections_completed();

src/hotspot/share/gc/shared/generationSpec.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2001, 2019, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2001, 2020, 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
@@ -25,7 +25,6 @@
 #include "precompiled.hpp"
 #include "gc/shared/cardTableRS.hpp"
 #include "gc/shared/generationSpec.hpp"
-#include "memory/binaryTreeDictionary.hpp"
 #include "memory/filemap.hpp"
 #include "runtime/java.hpp"
 #include "utilities/macros.hpp"

src/hotspot/share/gc/shared/jvmFlagConstraintsGC.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, 2019, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2015, 2020, 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
@@ -262,18 +262,6 @@ JVMFlag::Error GCPauseIntervalMillisConstraintFunc(uintx value, bool verbose) {
   return JVMFlag::SUCCESS;
 }
 
-JVMFlag::Error InitialBootClassLoaderMetaspaceSizeConstraintFunc(size_t value, bool verbose) {
-  size_t aligned_max = align_down(max_uintx/2, Metaspace::reserve_alignment_words());
-  if (value > aligned_max) {
-    JVMFlag::printError(verbose,
-                        "InitialBootClassLoaderMetaspaceSize (" SIZE_FORMAT ") must be "
-                        "less than or equal to aligned maximum value (" SIZE_FORMAT ")\n",
-                        value, aligned_max);
-    return JVMFlag::VIOLATES_CONSTRAINT;
-  }
-  return JVMFlag::SUCCESS;
-}
-
 // To avoid an overflow by 'align_up(value, alignment)'.
 static JVMFlag::Error MaxSizeForAlignment(const char* name, size_t value, size_t alignment, bool verbose) {
   size_t aligned_max = ((max_uintx - alignment) & ~(alignment-1));

src/hotspot/share/gc/shared/jvmFlagConstraintsGC.hpp

@@ -56,7 +56,6 @@
                                                                \
  f(uintx,  MaxGCPauseMillisConstraintFunc)                     \
  f(uintx,  GCPauseIntervalMillisConstraintFunc)                \
- f(size_t, InitialBootClassLoaderMetaspaceSizeConstraintFunc)  \
  f(size_t, MinHeapSizeConstraintFunc)                          \
  f(size_t, InitialHeapSizeConstraintFunc)                      \
  f(size_t, MaxHeapSizeConstraintFunc)                          \

src/hotspot/share/gc/shenandoah/shenandoahHeap.cpp

@@ -71,7 +71,7 @@
 #include "gc/shenandoah/shenandoahJfrSupport.hpp"
 #endif
 
-#include "memory/metaspace.hpp"
+#include "memory/classLoaderMetaspace.hpp"
 #include "oops/compressedOops.inline.hpp"
 #include "runtime/atomic.hpp"
 #include "runtime/globals.hpp"
@@ -2410,7 +2410,7 @@ void ShenandoahHeap::stw_unload_classes(bool full_gc) {
   }
   // Resize and verify metaspace
   MetaspaceGC::compute_new_size();
-  MetaspaceUtils::verify_metrics();
+  DEBUG_ONLY(MetaspaceUtils::verify();)
 }
 
 // Weak roots are either pre-evacuated (final mark) or updated (final updaterefs),

src/hotspot/share/gc/shenandoah/shenandoahHeap.hpp

@@ -35,6 +35,7 @@
 #include "gc/shenandoah/shenandoahPadding.hpp"
 #include "gc/shenandoah/shenandoahSharedVariables.hpp"
 #include "gc/shenandoah/shenandoahUnload.hpp"
+#include "memory/metaspace.hpp"
 #include "services/memoryManager.hpp"
 #include "utilities/globalDefinitions.hpp"
 #include "utilities/stack.hpp"

src/hotspot/share/gc/shenandoah/shenandoahUnload.cpp

@@ -197,5 +197,5 @@ void ShenandoahUnload::unload() {
 
 void ShenandoahUnload::finish() {
   MetaspaceGC::compute_new_size();
-  MetaspaceUtils::verify_metrics();
+  DEBUG_ONLY(MetaspaceUtils::verify();)
 }

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

@@ -35,6 +35,7 @@
 #include "gc/z/zServiceability.hpp"
 #include "gc/z/zStat.hpp"
 #include "gc/z/zUtils.inline.hpp"
+#include "memory/classLoaderMetaspace.hpp"
 #include "memory/iterator.hpp"
 #include "memory/universe.hpp"
 #include "utilities/align.hpp"

src/hotspot/share/gc/z/zCollectedHeap.hpp

@@ -30,6 +30,7 @@
 #include "gc/z/zHeap.hpp"
 #include "gc/z/zInitialize.hpp"
 #include "gc/z/zRuntimeWorkers.hpp"
+#include "memory/metaspace.hpp"
 
 class ZDirector;
 class ZDriver;

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

@@ -1186,10 +1186,9 @@ void ZStatNMethods::print() {
 //
 void ZStatMetaspace::print() {
   log_info(gc, metaspace)("Metaspace: "
-                          SIZE_FORMAT "M used, " SIZE_FORMAT "M capacity, "
+                          SIZE_FORMAT "M used, "
                           SIZE_FORMAT "M committed, " SIZE_FORMAT "M reserved",
                           MetaspaceUtils::used_bytes() / M,
-                          MetaspaceUtils::capacity_bytes() / M,
                           MetaspaceUtils::committed_bytes() / M,
                           MetaspaceUtils::reserved_bytes() / M);
 }

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

@@ -164,5 +164,5 @@ void ZUnload::purge() {
 void ZUnload::finish() {
   // Resize and verify metaspace
   MetaspaceGC::compute_new_size();
-  MetaspaceUtils::verify_metrics();
+  DEBUG_ONLY(MetaspaceUtils::verify();)
 }

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

@@ -41,7 +41,7 @@
 #include "jfr/writers/jfrJavaEventWriter.hpp"
 #include "jfr/utilities/jfrThreadIterator.hpp"
 #include "memory/iterator.hpp"
-#include "memory/metaspaceGCThresholdUpdater.hpp"
+#include "memory/metaspace.hpp"
 #include "memory/referenceType.hpp"
 #include "memory/universe.hpp"
 #include "oops/compressedOops.hpp"

src/hotspot/share/jvmci/jvmciCompilerToVM.hpp

@@ -29,6 +29,7 @@
 #include "runtime/javaCalls.hpp"
 #include "runtime/signature.hpp"
 
+class CollectedHeap;
 class JVMCIObjectArray;
 
 class CompilerToVM {

src/hotspot/share/memory/allocation.hpp

@@ -142,6 +142,7 @@ class AllocatedObj {
   f(mtSafepoint,      "Safepoint")                                                   \
   f(mtSynchronizer,   "Synchronization")                                             \
   f(mtServiceability, "Serviceability")                                              \
+  f(mtMetaspace,      "Metaspace")                                                   \
   f(mtNone,           "Unknown")                                                     \
   //end
 

src/hotspot/share/memory/binaryTreeDictionary.hpp

@@ -1,393 +0,0 @@
-/*
- * Copyright (c) 2001, 2020, 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.
- *
- */
-
-#ifndef SHARE_MEMORY_BINARYTREEDICTIONARY_HPP
-#define SHARE_MEMORY_BINARYTREEDICTIONARY_HPP
-
-#include "memory/freeList.hpp"
-#include "memory/memRegion.hpp"
-
-class Mutex;
-
-/*
- * A binary tree based search structure for free blocks.
- * This is currently used in the Concurrent Mark&Sweep implementation, but
- * will be used for free block management for metadata.
- */
-
-// A TreeList is a FreeList which can be used to maintain a
-// binary tree of free lists.
-
-template <class Chunk_t, class FreeList_t> class TreeChunk;
-template <class Chunk_t, class FreeList_t> class BinaryTreeDictionary;
-template <class Chunk_t, class FreeList_t> class AscendTreeCensusClosure;
-template <class Chunk_t, class FreeList_t> class DescendTreeCensusClosure;
-template <class Chunk_t, class FreeList_t> class DescendTreeSearchClosure;
-
-template <class Chunk_t, class FreeList_t>
-class TreeList : public FreeList_t {
-  friend class TreeChunk<Chunk_t, FreeList_t>;
-  friend class BinaryTreeDictionary<Chunk_t, FreeList_t>;
-  friend class AscendTreeCensusClosure<Chunk_t, FreeList_t>;
-  friend class DescendTreeCensusClosure<Chunk_t, FreeList_t>;
-  friend class DescendTreeSearchClosure<Chunk_t, FreeList_t>;
-
-  TreeList<Chunk_t, FreeList_t>* _parent;
-  TreeList<Chunk_t, FreeList_t>* _left;
-  TreeList<Chunk_t, FreeList_t>* _right;
-
- protected:
-
-  TreeList<Chunk_t, FreeList_t>* parent() const { return _parent; }
-  TreeList<Chunk_t, FreeList_t>* left()   const { return _left;   }
-  TreeList<Chunk_t, FreeList_t>* right()  const { return _right;  }
-
-  // Wrapper on call to base class, to get the template to compile.
-  Chunk_t* head() const { return FreeList_t::head(); }
-  Chunk_t* tail() const { return FreeList_t::tail(); }
-  void set_head(Chunk_t* head) { FreeList_t::set_head(head); }
-  void set_tail(Chunk_t* tail) { FreeList_t::set_tail(tail); }
-
-  size_t size() const { return FreeList_t::size(); }
-
-  // Accessors for links in tree.
-
-  void set_left(TreeList<Chunk_t, FreeList_t>* tl) {
-    _left   = tl;
-    if (tl != NULL)
-      tl->set_parent(this);
-  }
-  void set_right(TreeList<Chunk_t, FreeList_t>* tl) {
-    _right  = tl;
-    if (tl != NULL)
-      tl->set_parent(this);
-  }
-  void set_parent(TreeList<Chunk_t, FreeList_t>* tl)  { _parent = tl;   }
-
-  void clear_left()               { _left = NULL;   }
-  void clear_right()              { _right = NULL;  }
-  void clear_parent()             { _parent = NULL; }
-  void initialize()               { clear_left(); clear_right(), clear_parent(); FreeList_t::initialize(); }
-
-  // For constructing a TreeList from a Tree chunk or
-  // address and size.
-  TreeList();
-  static TreeList<Chunk_t, FreeList_t>*
-          as_TreeList(TreeChunk<Chunk_t, FreeList_t>* tc);
-  static TreeList<Chunk_t, FreeList_t>* as_TreeList(HeapWord* addr, size_t size);
-
-  // Returns the head of the free list as a pointer to a TreeChunk.
-  TreeChunk<Chunk_t, FreeList_t>* head_as_TreeChunk();
-
-  // Returns the first available chunk in the free list as a pointer
-  // to a TreeChunk.
-  TreeChunk<Chunk_t, FreeList_t>* first_available();
-
-  // Returns the block with the largest heap address amongst
-  // those in the list for this size; potentially slow and expensive,
-  // use with caution!
-  TreeChunk<Chunk_t, FreeList_t>* largest_address();
-
-  TreeList<Chunk_t, FreeList_t>* get_better_list(
-    BinaryTreeDictionary<Chunk_t, FreeList_t>* dictionary);
-
-  // remove_chunk_replace_if_needed() removes the given "tc" from the TreeList.
-  // If "tc" is the first chunk in the list, it is also the
-  // TreeList that is the node in the tree.  remove_chunk_replace_if_needed()
-  // returns the possibly replaced TreeList* for the node in
-  // the tree.  It also updates the parent of the original
-  // node to point to the new node.
-  TreeList<Chunk_t, FreeList_t>* remove_chunk_replace_if_needed(TreeChunk<Chunk_t, FreeList_t>* tc);
-  // See FreeList.
-  void return_chunk_at_tail(TreeChunk<Chunk_t, FreeList_t>* tc);
-};
-
-// A TreeChunk is a subclass of a Chunk that additionally
-// maintains a pointer to the free list on which it is currently
-// linked.
-// A TreeChunk is also used as a node in the binary tree.  This
-// allows the binary tree to be maintained without any additional
-// storage (the free chunks are used).  In a binary tree the first
-// chunk in the free list is also the tree node.  Note that the
-// TreeChunk has an embedded TreeList for this purpose.  Because
-// the first chunk in the list is distinguished in this fashion
-// (also is the node in the tree), it is the last chunk to be found
-// on the free list for a node in the tree and is only removed if
-// it is the last chunk on the free list.
-
-template <class Chunk_t, class FreeList_t>
-class TreeChunk : public Chunk_t {
-  friend class TreeList<Chunk_t, FreeList_t>;
-  TreeList<Chunk_t, FreeList_t>* _list;
-  TreeList<Chunk_t, FreeList_t> _embedded_list;  // if non-null, this chunk is on _list
-
-  static size_t _min_tree_chunk_size;
-
- protected:
-  TreeList<Chunk_t, FreeList_t>* embedded_list() const { return (TreeList<Chunk_t, FreeList_t>*) &_embedded_list; }
-  void set_embedded_list(TreeList<Chunk_t, FreeList_t>* v) { _embedded_list = *v; }
- public:
-  TreeList<Chunk_t, FreeList_t>* list() { return _list; }
-  void set_list(TreeList<Chunk_t, FreeList_t>* v) { _list = v; }
-  static TreeChunk<Chunk_t, FreeList_t>* as_TreeChunk(Chunk_t* fc);
-  // Initialize fields in a TreeChunk that should be
-  // initialized when the TreeChunk is being added to
-  // a free list in the tree.
-  void initialize() { embedded_list()->initialize(); }
-
-  Chunk_t* next() const { return Chunk_t::next(); }
-  Chunk_t* prev() const { return Chunk_t::prev(); }
-  size_t size() const { return Chunk_t::size(); }
-
-  static size_t min_size();
-
-  // debugging
-  void verify_tree_chunk_list() const;
-  void assert_is_mangled() const;
-};
-
-template <class Chunk_t, class FreeList_t>
-size_t TreeChunk<Chunk_t, FreeList_t>::_min_tree_chunk_size = sizeof(TreeChunk<Chunk_t, FreeList_t>)/HeapWordSize;
-template <class Chunk_t, class FreeList_t>
-size_t TreeChunk<Chunk_t, FreeList_t>::min_size() { return _min_tree_chunk_size; }
-
-template <class Chunk_t, class FreeList_t>
-class BinaryTreeDictionary: public CHeapObj<mtGC> {
-  friend class VMStructs;
-
- protected:
-  size_t     _total_size;
-  size_t     _total_free_blocks;
-  TreeList<Chunk_t, FreeList_t>* _root;
-
-  // private accessors
-  void set_total_size(size_t v) { _total_size = v; }
-  void inc_total_size(size_t v);
-  void dec_total_size(size_t v);
-  void set_total_free_blocks(size_t v) { _total_free_blocks = v; }
-  TreeList<Chunk_t, FreeList_t>* root() const { return _root; }
-  void set_root(TreeList<Chunk_t, FreeList_t>* v) { _root = v; }
-
-  // This field is added and can be set to point to the
-  // the Mutex used to synchronize access to the
-  // dictionary so that assertion checking can be done.
-  // For example it is set to point to _parDictionaryAllocLock.
-  NOT_PRODUCT(Mutex* _lock;)
-
-  // Remove a chunk of size "size" or larger from the tree and
-  // return it.  If the chunk
-  // is the last chunk of that size, remove the node for that size
-  // from the tree.
-  TreeChunk<Chunk_t, FreeList_t>* get_chunk_from_tree(size_t size);
-  // Remove this chunk from the tree.  If the removal results
-  // in an empty list in the tree, remove the empty list.
-  TreeChunk<Chunk_t, FreeList_t>* remove_chunk_from_tree(TreeChunk<Chunk_t, FreeList_t>* tc);
-  // Remove the node in the trees starting at tl that has the
-  // minimum value and return it.  Repair the tree as needed.
-  TreeList<Chunk_t, FreeList_t>* remove_tree_minimum(TreeList<Chunk_t, FreeList_t>* tl);
-  // Add this free chunk to the tree.
-  void       insert_chunk_in_tree(Chunk_t* freeChunk);
- public:
-
-  // Return a list of the specified size or NULL from the tree.
-  // The list is not removed from the tree.
-  TreeList<Chunk_t, FreeList_t>* find_list (size_t size) const;
-
-  void       verify_tree() const;
-  // verify that the given chunk is in the tree.
-  bool       verify_chunk_in_free_list(Chunk_t* tc) const;
- private:
-  void          verify_tree_helper(TreeList<Chunk_t, FreeList_t>* tl) const;
-  static size_t verify_prev_free_ptrs(TreeList<Chunk_t, FreeList_t>* tl);
-
-  // Returns the total number of chunks in the list.
-  size_t     total_list_length(TreeList<Chunk_t, FreeList_t>* tl) const;
-  // Returns the total number of words in the chunks in the tree
-  // starting at "tl".
-  size_t     total_size_in_tree(TreeList<Chunk_t, FreeList_t>* tl) const;
-  // Returns the sum of the square of the size of each block
-  // in the tree starting at "tl".
-  double     sum_of_squared_block_sizes(TreeList<Chunk_t, FreeList_t>* const tl) const;
-  // Returns the total number of free blocks in the tree starting
-  // at "tl".
-  size_t     total_free_blocks_in_tree(TreeList<Chunk_t, FreeList_t>* tl) const;
-  size_t     num_free_blocks()  const;
-  size_t     tree_height() const;
-  size_t     tree_height_helper(TreeList<Chunk_t, FreeList_t>* tl) const;
-  size_t     total_nodes_helper(TreeList<Chunk_t, FreeList_t>* tl) const;
-
- public:
-  // Constructor
-  BinaryTreeDictionary() :
-    _total_size(0), _total_free_blocks(0), _root(0) {}
-
-  BinaryTreeDictionary(MemRegion mr);
-
-  // Public accessors
-  size_t total_size() const { return _total_size; }
-  size_t total_free_blocks() const { return _total_free_blocks; }
-
-  // Reset the dictionary to the initial conditions with
-  // a single free chunk.
-  void       reset(MemRegion mr);
-  void       reset(HeapWord* addr, size_t size);
-  // Reset the dictionary to be empty.
-  void       reset();
-
-  // Return a chunk of size "size" or greater from
-  // the tree.
-  Chunk_t* get_chunk(size_t size) {
-    verify_par_locked();
-    Chunk_t* res = get_chunk_from_tree(size);
-    assert(res == NULL || res->is_free(),
-           "Should be returning a free chunk");
-    return res;
-  }
-
-  void return_chunk(Chunk_t* chunk) {
-    verify_par_locked();
-    insert_chunk_in_tree(chunk);
-  }
-
-  void remove_chunk(Chunk_t* chunk) {
-    verify_par_locked();
-    remove_chunk_from_tree((TreeChunk<Chunk_t, FreeList_t>*)chunk);
-    assert(chunk->is_free(), "Should still be a free chunk");
-  }
-
-  size_t     max_chunk_size() const;
-  inline size_t total_chunk_size(debug_only(const Mutex* lock)) const;
-
-  size_t     min_size() const {
-    return TreeChunk<Chunk_t, FreeList_t>::min_size();
-  }
-
-  double     sum_of_squared_block_sizes() const {
-    return sum_of_squared_block_sizes(root());
-  }
-
-  Chunk_t* find_chunk_ends_at(HeapWord* target) const;
-
-  // Return the largest free chunk in the tree.
-  Chunk_t* find_largest_dict() const;
-
-  void       print_free_lists(outputStream* st) const;
-
-  // For debugging.  Returns the sum of the _returned_bytes for
-  // all lists in the tree.
-  size_t     sum_dict_returned_bytes()     PRODUCT_RETURN0;
-  // Sets the _returned_bytes for all the lists in the tree to zero.
-  void       initialize_dict_returned_bytes()      PRODUCT_RETURN;
-  // For debugging.  Return the total number of chunks in the dictionary.
-  size_t     total_count()       PRODUCT_RETURN0;
-
-  void       report_statistics(outputStream* st) const;
-
-  void       verify() const;
-
-  Mutex*     par_lock()                const PRODUCT_RETURN0;
-  void       set_par_lock(Mutex* lock)       PRODUCT_RETURN;
-  void       verify_par_locked()       const PRODUCT_RETURN;
-};
-
-
-// Closures for walking the binary tree.
-//   do_list() walks the free list in a node applying the closure
-//     to each free chunk in the list
-//   do_tree() walks the nodes in the binary tree applying do_list()
-//     to each list at each node.
-
-template <class Chunk_t, class FreeList_t>
-class TreeCensusClosure : public StackObj {
- protected:
-  virtual void do_list(FreeList_t* fl) = 0;
- public:
-  virtual void do_tree(TreeList<Chunk_t, FreeList_t>* tl) = 0;
-};
-
-template <class Chunk_t, class FreeList_t>
-class AscendTreeCensusClosure : public TreeCensusClosure<Chunk_t, FreeList_t> {
- public:
-  void do_tree(TreeList<Chunk_t, FreeList_t>* tl) {
-    if (tl != NULL) {
-      do_tree(tl->left());
-      this->do_list(tl);
-      do_tree(tl->right());
-    }
-  }
-};
-
-template <class Chunk_t, class FreeList_t>
-class DescendTreeCensusClosure : public TreeCensusClosure<Chunk_t, FreeList_t> {
- public:
-  void do_tree(TreeList<Chunk_t, FreeList_t>* tl) {
-    if (tl != NULL) {
-      do_tree(tl->right());
-      this->do_list(tl);
-      do_tree(tl->left());
-    }
-  }
-};
-
-// Used to search the tree until a condition is met.
-// Similar to TreeCensusClosure but searches the
-// tree and returns promptly when found.
-
-template <class Chunk_t, class FreeList_t>
-class TreeSearchClosure : public StackObj {
- protected:
-  virtual bool do_list(FreeList_t* fl) = 0;
- public:
-  virtual bool do_tree(TreeList<Chunk_t, FreeList_t>* tl) = 0;
-};
-
-#if 0 //  Don't need this yet but here for symmetry.
-template <class Chunk_t, class FreeList_t>
-class AscendTreeSearchClosure : public TreeSearchClosure<Chunk_t> {
- public:
-  bool do_tree(TreeList<Chunk_t, FreeList_t>* tl) {
-    if (tl != NULL) {
-      if (do_tree(tl->left())) return true;
-      if (do_list(tl)) return true;
-      if (do_tree(tl->right())) return true;
-    }
-    return false;
-  }
-};
-#endif
-
-template <class Chunk_t, class FreeList_t>
-class DescendTreeSearchClosure : public TreeSearchClosure<Chunk_t, FreeList_t> {
- public:
-  bool do_tree(TreeList<Chunk_t, FreeList_t>* tl) {
-    if (tl != NULL) {
-      if (do_tree(tl->right())) return true;
-      if (this->do_list(tl)) return true;
-      if (do_tree(tl->left())) return true;
-    }
-    return false;
-  }
-};
-
-#endif // SHARE_MEMORY_BINARYTREEDICTIONARY_HPP

src/hotspot/share/memory/classLoaderMetaspace.cpp

@@ -0,0 +1,187 @@
+/*
+ * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2020 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
+ * 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 "precompiled.hpp"
+#include "logging/log.hpp"
+#include "memory/classLoaderMetaspace.hpp"
+#include "memory/metaspace.hpp"
+#include "memory/metaspace/chunkManager.hpp"
+#include "memory/metaspace/internalStats.hpp"
+#include "memory/metaspace/metaspaceArena.hpp"
+#include "memory/metaspace/metaspaceArenaGrowthPolicy.hpp"
+#include "memory/metaspace/metaspaceSettings.hpp"
+#include "memory/metaspace/metaspaceStatistics.hpp"
+#include "memory/metaspace/runningCounters.hpp"
+#include "memory/metaspaceTracer.hpp"
+#include "utilities/debug.hpp"
+
+using metaspace::ChunkManager;
+using metaspace::MetaspaceArena;
+using metaspace::ArenaGrowthPolicy;
+using metaspace::RunningCounters;
+using metaspace::InternalStats;
+
+#define LOGFMT         "CLMS @" PTR_FORMAT " "
+#define LOGFMT_ARGS    p2i(this)
+
+ClassLoaderMetaspace::ClassLoaderMetaspace(Mutex* lock, Metaspace::MetaspaceType space_type) :
+  _lock(lock),
+  _space_type(space_type),
+  _non_class_space_arena(NULL),
+  _class_space_arena(NULL)
+{
+  ChunkManager* const non_class_cm =
+          ChunkManager::chunkmanager_nonclass();
+
+  // Initialize non-class Arena
+  _non_class_space_arena = new MetaspaceArena(
+      non_class_cm,
+      ArenaGrowthPolicy::policy_for_space_type(space_type, false),
+      lock,
+      RunningCounters::used_nonclass_counter(),
+      "non-class sm");
+
+  // If needed, initialize class arena
+  if (Metaspace::using_class_space()) {
+    ChunkManager* const class_cm =
+            ChunkManager::chunkmanager_class();
+    _class_space_arena = new MetaspaceArena(
+        class_cm,
+        ArenaGrowthPolicy::policy_for_space_type(space_type, true),
+        lock,
+        RunningCounters::used_class_counter(),
+        "class sm");
+  }
+
+  UL2(debug, "born (nonclass arena: " PTR_FORMAT ", class arena: " PTR_FORMAT ".",
+      p2i(_non_class_space_arena), p2i(_class_space_arena));
+}
+
+ClassLoaderMetaspace::~ClassLoaderMetaspace() {
+  Metaspace::assert_not_frozen();
+
+  UL(debug, "dies.");
+
+  delete _non_class_space_arena;
+  delete _class_space_arena;
+
+}
+
+// Allocate word_size words from Metaspace.
+MetaWord* ClassLoaderMetaspace::allocate(size_t word_size, Metaspace::MetadataType mdType) {
+  Metaspace::assert_not_frozen();
+  if (Metaspace::is_class_space_allocation(mdType)) {
+    return class_space_arena()->allocate(word_size);
+  } else {
+    return non_class_space_arena()->allocate(word_size);
+  }
+}
+
+// Attempt to expand the GC threshold to be good for at least another word_size words
+// and allocate. Returns NULL if failure. Used during Metaspace GC.
+MetaWord* ClassLoaderMetaspace::expand_and_allocate(size_t word_size, Metaspace::MetadataType mdType) {
+  Metaspace::assert_not_frozen();
+  size_t delta_bytes = MetaspaceGC::delta_capacity_until_GC(word_size * BytesPerWord);
+  assert(delta_bytes > 0, "Must be");
+
+  size_t before = 0;
+  size_t after = 0;
+  bool can_retry = true;
+  MetaWord* res;
+  bool incremented;
+
+  // Each thread increments the HWM at most once. Even if the thread fails to increment
+  // the HWM, an allocation is still attempted. This is because another thread must then
+  // have incremented the HWM and therefore the allocation might still succeed.
+  do {
+    incremented = MetaspaceGC::inc_capacity_until_GC(delta_bytes, &after, &before, &can_retry);
+    res = allocate(word_size, mdType);
+  } while (!incremented && res == NULL && can_retry);
+
+  if (incremented) {
+    Metaspace::tracer()->report_gc_threshold(before, after,
+                                  MetaspaceGCThresholdUpdater::ExpandAndAllocate);
+    // Keeping both for now until I am sure the old variant (gc + metaspace) is not needed anymore
+    log_trace(gc, metaspace)("Increase capacity to GC from " SIZE_FORMAT " to " SIZE_FORMAT, before, after);
+    UL2(info, "GC threshold increased: " SIZE_FORMAT "->" SIZE_FORMAT ".", before, after);
+  }
+
+  return res;
+}
+
+// Prematurely returns a metaspace allocation to the _block_freelists
+// because it is not needed anymore.
+void ClassLoaderMetaspace::deallocate(MetaWord* ptr, size_t word_size, bool is_class) {
+  Metaspace::assert_not_frozen();
+  if (Metaspace::using_class_space() && is_class) {
+    class_space_arena()->deallocate(ptr, word_size);
+  } else {
+    non_class_space_arena()->deallocate(ptr, word_size);
+  }
+  DEBUG_ONLY(InternalStats::inc_num_deallocs();)
+}
+
+// Update statistics. This walks all in-use chunks.
+void ClassLoaderMetaspace::add_to_statistics(metaspace::ClmsStats* out) const {
+  if (non_class_space_arena() != NULL) {
+    non_class_space_arena()->add_to_statistics(&out->_arena_stats_nonclass);
+  }
+  if (class_space_arena() != NULL) {
+    class_space_arena()->add_to_statistics(&out->_arena_stats_class);
+  }
+}
+
+#ifdef ASSERT
+void ClassLoaderMetaspace::verify() const {
+  if (non_class_space_arena() != NULL) {
+    non_class_space_arena()->verify();
+  }
+  if (class_space_arena() != NULL) {
+    class_space_arena()->verify();
+  }
+}
+#endif // ASSERT
+
+// This only exists for JFR and jcmd VM.classloader_stats. We may want to
+//  change this. Capacity as a stat is of questionable use since it may
+//  contain committed and uncommitted areas. For now we do this to maintain
+//  backward compatibility with JFR.
+void ClassLoaderMetaspace::calculate_jfr_stats(size_t* p_used_bytes, size_t* p_capacity_bytes) const {
+  // Implement this using the standard statistics objects.
+  size_t used_c = 0, cap_c = 0, used_nc = 0, cap_nc = 0;
+  if (non_class_space_arena() != NULL) {
+    non_class_space_arena()->usage_numbers(&used_nc, NULL, &cap_nc);
+  }
+  if (class_space_arena() != NULL) {
+    class_space_arena()->usage_numbers(&used_c, NULL, &cap_c);
+  }
+  if (p_used_bytes != NULL) {
+    *p_used_bytes = used_c + used_nc;
+  }
+  if (p_capacity_bytes != NULL) {
+    *p_capacity_bytes = cap_c + cap_nc;
+  }
+}
+

src/hotspot/share/memory/classLoaderMetaspace.hpp

@@ -0,0 +1,111 @@
+/*
+ * Copyright (c) 2011, 2020, 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.
+ *
+ */
+#ifndef SHARE_MEMORY_CLASSLOADERMETASPACE_HPP
+#define SHARE_MEMORY_CLASSLOADERMETASPACE_HPP
+
+#include "memory/allocation.hpp"
+#include "memory/metaspace.hpp"
+#include "utilities/debug.hpp"
+#include "utilities/globalDefinitions.hpp"
+
+class outputStream;
+
+namespace metaspace {
+  struct ClmsStats;
+  class MetaspaceArena;
+}
+
+// A ClassLoaderMetaspace manages MetaspaceArena(s) for a CLD.
+//
+// A CLD owns one MetaspaceArena if UseCompressedClassPointers is false. Otherwise
+// it owns two - one for the Klass* objects from the class space, one for the other
+// types of MetaspaceObjs from the non-class space.
+//
+// +------+       +----------------------+       +-------------------+
+// | CLD  | --->  | ClassLoaderMetaspace | ----> | (non class) Arena |
+// +------+       +----------------------+  |    +-------------------+     allocation top
+//                                          |       |                        v
+//                                          |       + chunk -- chunk ... -- chunk
+//                                          |
+//                                          |    +-------------------+
+//                                          +--> | (class) Arena     |
+//                                               +-------------------+
+//                                                  |
+//                                                  + chunk ... chunk
+//                                                               ^
+//                                                               alloc top
+//
+class ClassLoaderMetaspace : public CHeapObj<mtClass> {
+
+  // A reference to an outside lock, held by the CLD.
+  Mutex* const _lock;
+
+  const Metaspace::MetaspaceType _space_type;
+
+  // Arena for allocations from non-class  metaspace
+  //  (resp. for all allocations if -XX:-UseCompressedClassPointers).
+  metaspace::MetaspaceArena* _non_class_space_arena;
+
+  // Arena for allocations from class space
+  //  (NULL if -XX:-UseCompressedClassPointers).
+  metaspace::MetaspaceArena* _class_space_arena;
+
+  Mutex* lock() const                             { return _lock; }
+  metaspace::MetaspaceArena* non_class_space_arena() const   { return _non_class_space_arena; }
+  metaspace::MetaspaceArena* class_space_arena() const       { return _class_space_arena; }
+
+public:
+
+  ClassLoaderMetaspace(Mutex* lock, Metaspace::MetaspaceType space_type);
+
+  ~ClassLoaderMetaspace();
+
+  Metaspace::MetaspaceType space_type() const { return _space_type; }
+
+  // Allocate word_size words from Metaspace.
+  MetaWord* allocate(size_t word_size, Metaspace::MetadataType mdType);
+
+  // Attempt to expand the GC threshold to be good for at least another word_size words
+  // and allocate. Returns NULL if failure. Used during Metaspace GC.
+  MetaWord* expand_and_allocate(size_t word_size, Metaspace::MetadataType mdType);
+
+  // Prematurely returns a metaspace allocation to the _block_freelists
+  // because it is not needed anymore.
+  void deallocate(MetaWord* ptr, size_t word_size, bool is_class);
+
+  // Update statistics. This walks all in-use chunks.
+  void add_to_statistics(metaspace::ClmsStats* out) const;
+
+  DEBUG_ONLY(void verify() const;)
+
+  // This only exists for JFR and jcmd VM.classloader_stats. We may want to
+  //  change this. Capacity as a stat is of questionable use since it may
+  //  contain committed and uncommitted areas. For now we do this to maintain
+  //  backward compatibility with JFR.
+  void calculate_jfr_stats(size_t* p_used_bytes, size_t* p_capacity_bytes) const;
+
+}; // end: ClassLoaderMetaspace
+
+
+#endif // SHARE_MEMORY_CLASSLOADERMETASPACE_HPP

src/hotspot/share/memory/freeList.hpp

@@ -1,175 +0,0 @@
-/*
- * Copyright (c) 2001, 2019, 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.
- *
- */
-
-#ifndef SHARE_MEMORY_FREELIST_HPP
-#define SHARE_MEMORY_FREELIST_HPP
-
-// A class for maintaining a free list of Chunk's.  The FreeList
-// maintains a the structure of the list (head, tail, etc.) plus
-// statistics for allocations from the list.  The links between items
-// are not part of FreeList.  The statistics are
-// used to make decisions about coalescing Chunk's when they
-// are swept during collection.
-//
-// See the corresponding .cpp file for a description of the specifics
-// for that implementation.
-
-class Mutex;
-
-template <class Chunk_t>
-class FreeList {
-  friend class VMStructs;
-
- private:
-  Chunk_t*      _head;          // Head of list of free chunks
-  Chunk_t*      _tail;          // Tail of list of free chunks
-  size_t        _size;          // Size in Heap words of each chunk
-  ssize_t       _count;         // Number of entries in list
-
- protected:
-
-#ifdef ASSERT
-  Mutex*        _protecting_lock;
-  void assert_proper_lock_protection_work() const;
-#endif
-
-  // Asserts false if the protecting lock (if any) is not held.
-  void assert_proper_lock_protection() const {
-    DEBUG_ONLY(assert_proper_lock_protection_work());
-  }
-
-  void increment_count()    {
-    _count++;
-  }
-
-  void decrement_count() {
-    _count--;
-    assert(_count >= 0, "Count should not be negative");
-  }
-
- public:
-  // Constructor
-  // Construct a list without any entries.
-  FreeList();
-
-  // Do initialization
-  void initialize();
-
-  // Reset the head, tail, and count of a free list.
-  void reset();
-
-  // Declare the current free list to be protected by the given lock.
-#ifdef ASSERT
-  Mutex* protecting_lock() const { return _protecting_lock; }
-  void set_protecting_lock(Mutex* v) {
-    _protecting_lock = v;
-  }
-#endif
-
-  // Accessors.
-  Chunk_t* head() const {
-    assert_proper_lock_protection();
-    return _head;
-  }
-  void set_head(Chunk_t* v) {
-    assert_proper_lock_protection();
-    _head = v;
-    assert(!_head || _head->size() == _size, "bad chunk size");
-  }
-  // Set the head of the list and set the prev field of non-null
-  // values to NULL.
-  void link_head(Chunk_t* v);
-
-  Chunk_t* tail() const {
-    assert_proper_lock_protection();
-    return _tail;
-  }
-  void set_tail(Chunk_t* v) {
-    assert_proper_lock_protection();
-    _tail = v;
-    assert(!_tail || _tail->size() == _size, "bad chunk size");
-  }
-  // Set the tail of the list and set the next field of non-null
-  // values to NULL.
-  void link_tail(Chunk_t* v) {
-    assert_proper_lock_protection();
-    set_tail(v);
-    if (v != NULL) {
-      v->clear_next();
-    }
-  }
-
-  // No locking checks in read-accessors: lock-free reads (only) are benign.
-  // Readers are expected to have the lock if they are doing work that
-  // requires atomicity guarantees in sections of code.
-  size_t size() const {
-    return _size;
-  }
-  void set_size(size_t v) {
-    assert_proper_lock_protection();
-    _size = v;
-  }
-  ssize_t count() const { return _count; }
-  void set_count(ssize_t v) { _count = v;}
-
-  size_t get_better_size() { return size(); }
-
-  size_t returned_bytes() const { ShouldNotReachHere(); return 0; }
-  void set_returned_bytes(size_t v) {}
-  void increment_returned_bytes_by(size_t v) {}
-
-  // Unlink head of list and return it.  Returns NULL if
-  // the list is empty.
-  Chunk_t* get_chunk_at_head();
-
-  // Remove the first "n" or "count", whichever is smaller, chunks from the
-  // list, setting "fl", which is required to be empty, to point to them.
-  void getFirstNChunksFromList(size_t n, FreeList<Chunk_t>* fl);
-
-  // Unlink this chunk from it's free list
-  void remove_chunk(Chunk_t* fc);
-
-  // Add this chunk to this free list.
-  void return_chunk_at_head(Chunk_t* fc);
-  void return_chunk_at_tail(Chunk_t* fc);
-
-  // Similar to returnChunk* but also records some diagnostic
-  // information.
-  void return_chunk_at_head(Chunk_t* fc, bool record_return);
-  void return_chunk_at_tail(Chunk_t* fc, bool record_return);
-
-  // Prepend "fl" (whose size is required to be the same as that of "this")
-  // to the front of "this" list.
-  void prepend(FreeList<Chunk_t>* fl);
-
-  // Verify that the chunk is in the list.
-  // found.  Return NULL if "fc" is not found.
-  bool verify_chunk_in_free_list(Chunk_t* fc) const;
-
-  // Printing support
-  static void print_labels_on(outputStream* st, const char* c);
-  void print_on(outputStream* st, const char* c = NULL) const;
-};
-
-#endif // SHARE_MEMORY_FREELIST_HPP

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

@@ -1,330 +0,0 @@
-/*
- * Copyright (c) 2001, 2017, 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.
- *
- */
-
-#ifndef SHARE_MEMORY_FREELIST_INLINE_HPP
-#define SHARE_MEMORY_FREELIST_INLINE_HPP
-
-#include "gc/shared/collectedHeap.hpp"
-#include "memory/freeList.hpp"
-#include "runtime/globals.hpp"
-#include "runtime/mutex.hpp"
-#include "runtime/vmThread.hpp"
-#include "utilities/macros.hpp"
-
-// Free list.  A FreeList is used to access a linked list of chunks
-// of space in the heap.  The head and tail are maintained so that
-// items can be (as in the current implementation) added at the
-// at the tail of the list and removed from the head of the list to
-// maintain a FIFO queue.
-
-template <class Chunk>
-FreeList<Chunk>::FreeList() :
-  _head(NULL), _tail(NULL)
-#ifdef ASSERT
-  , _protecting_lock(NULL)
-#endif
-{
-  _size         = 0;
-  _count        = 0;
-}
-
-template <class Chunk>
-void FreeList<Chunk>::link_head(Chunk* v) {
-  assert_proper_lock_protection();
-  set_head(v);
-  // If this method is not used (just set the head instead),
-  // this check can be avoided.
-  if (v != NULL) {
-    v->link_prev(NULL);
-  }
-}
-
-
-
-template <class Chunk>
-void FreeList<Chunk>::reset() {
-  // Don't set the _size to 0 because this method is
-  // used with a existing list that has a size but which has
-  // been emptied.
-  // Don't clear the _protecting_lock of an existing list.
-  set_count(0);
-  set_head(NULL);
-  set_tail(NULL);
-}
-
-template <class Chunk>
-void FreeList<Chunk>::initialize() {
-#ifdef ASSERT
-  // Needed early because it might be checked in other initializing code.
-  set_protecting_lock(NULL);
-#endif
-  reset();
-  set_size(0);
-}
-
-template <class Chunk_t>
-Chunk_t* FreeList<Chunk_t>::get_chunk_at_head() {
-  assert_proper_lock_protection();
-  assert(head() == NULL || head()->prev() == NULL, "list invariant");
-  assert(tail() == NULL || tail()->next() == NULL, "list invariant");
-  Chunk_t* fc = head();
-  if (fc != NULL) {
-    Chunk_t* nextFC = fc->next();
-    if (nextFC != NULL) {
-      // The chunk fc being removed has a "next".  Set the "next" to the
-      // "prev" of fc.
-      nextFC->link_prev(NULL);
-    } else { // removed tail of list
-      link_tail(NULL);
-    }
-    link_head(nextFC);
-    decrement_count();
-  }
-  assert(head() == NULL || head()->prev() == NULL, "list invariant");
-  assert(tail() == NULL || tail()->next() == NULL, "list invariant");
-  return fc;
-}
-
-
-template <class Chunk>
-void FreeList<Chunk>::getFirstNChunksFromList(size_t n, FreeList<Chunk>* fl) {
-  assert_proper_lock_protection();
-  assert(fl->count() == 0, "Precondition");
-  if (count() > 0) {
-    int k = 1;
-    fl->set_head(head()); n--;
-    Chunk* tl = head();
-    while (tl->next() != NULL && n > 0) {
-      tl = tl->next(); n--; k++;
-    }
-    assert(tl != NULL, "Loop Inv.");
-
-    // First, fix up the list we took from.
-    Chunk* new_head = tl->next();
-    set_head(new_head);
-    set_count(count() - k);
-    if (new_head == NULL) {
-      set_tail(NULL);
-    } else {
-      new_head->link_prev(NULL);
-    }
-    // Now we can fix up the tail.
-    tl->link_next(NULL);
-    // And return the result.
-    fl->set_tail(tl);
-    fl->set_count(k);
-  }
-}
-
-// Remove this chunk from the list
-template <class Chunk>
-void FreeList<Chunk>::remove_chunk(Chunk*fc) {
-   assert_proper_lock_protection();
-   assert(head() != NULL, "Remove from empty list");
-   assert(fc != NULL, "Remove a NULL chunk");
-   assert(size() == fc->size(), "Wrong list");
-   assert(head() == NULL || head()->prev() == NULL, "list invariant");
-   assert(tail() == NULL || tail()->next() == NULL, "list invariant");
-
-   Chunk* prevFC = fc->prev();
-   Chunk* nextFC = fc->next();
-   if (nextFC != NULL) {
-     // The chunk fc being removed has a "next".  Set the "next" to the
-     // "prev" of fc.
-     nextFC->link_prev(prevFC);
-   } else { // removed tail of list
-     link_tail(prevFC);
-   }
-   if (prevFC == NULL) { // removed head of list
-     link_head(nextFC);
-     assert(nextFC == NULL || nextFC->prev() == NULL,
-       "Prev of head should be NULL");
-   } else {
-     prevFC->link_next(nextFC);
-     assert(tail() != prevFC || prevFC->next() == NULL,
-       "Next of tail should be NULL");
-   }
-   decrement_count();
-   assert(((head() == NULL) + (tail() == NULL) + (count() == 0)) % 3 == 0,
-          "H/T/C Inconsistency");
-   // clear next and prev fields of fc, debug only
-   NOT_PRODUCT(
-     fc->link_prev(NULL);
-     fc->link_next(NULL);
-   )
-   assert(fc->is_free(), "Should still be a free chunk");
-   assert(head() == NULL || head()->prev() == NULL, "list invariant");
-   assert(tail() == NULL || tail()->next() == NULL, "list invariant");
-   assert(head() == NULL || head()->size() == size(), "wrong item on list");
-   assert(tail() == NULL || tail()->size() == size(), "wrong item on list");
-}
-
-// Add this chunk at the head of the list.
-template <class Chunk>
-void FreeList<Chunk>::return_chunk_at_head(Chunk* chunk, bool record_return) {
-  assert_proper_lock_protection();
-  assert(chunk != NULL, "insert a NULL chunk");
-  assert(size() == chunk->size(), "Wrong size");
-  assert(head() == NULL || head()->prev() == NULL, "list invariant");
-  assert(tail() == NULL || tail()->next() == NULL, "list invariant");
-
-  Chunk* oldHead = head();
-  assert(chunk != oldHead, "double insertion");
-  chunk->link_after(oldHead);
-  link_head(chunk);
-  if (oldHead == NULL) { // only chunk in list
-    assert(tail() == NULL, "inconsistent FreeList");
-    link_tail(chunk);
-  }
-  increment_count(); // of # of chunks in list
-  assert(head() == NULL || head()->prev() == NULL, "list invariant");
-  assert(tail() == NULL || tail()->next() == NULL, "list invariant");
-  assert(head() == NULL || head()->size() == size(), "wrong item on list");
-  assert(tail() == NULL || tail()->size() == size(), "wrong item on list");
-}
-
-template <class Chunk>
-void FreeList<Chunk>::return_chunk_at_head(Chunk* chunk) {
-  assert_proper_lock_protection();
-  return_chunk_at_head(chunk, true);
-}
-
-// Add this chunk at the tail of the list.
-template <class Chunk>
-void FreeList<Chunk>::return_chunk_at_tail(Chunk* chunk, bool record_return) {
-  assert_proper_lock_protection();
-  assert(head() == NULL || head()->prev() == NULL, "list invariant");
-  assert(tail() == NULL || tail()->next() == NULL, "list invariant");
-  assert(chunk != NULL, "insert a NULL chunk");
-  assert(size() == chunk->size(), "wrong size");
-
-  Chunk* oldTail = tail();
-  assert(chunk != oldTail, "double insertion");
-  if (oldTail != NULL) {
-    oldTail->link_after(chunk);
-  } else { // only chunk in list
-    assert(head() == NULL, "inconsistent FreeList");
-    link_head(chunk);
-  }
-  link_tail(chunk);
-  increment_count();  // of # of chunks in list
-  assert(head() == NULL || head()->prev() == NULL, "list invariant");
-  assert(tail() == NULL || tail()->next() == NULL, "list invariant");
-  assert(head() == NULL || head()->size() == size(), "wrong item on list");
-  assert(tail() == NULL || tail()->size() == size(), "wrong item on list");
-}
-
-template <class Chunk>
-void FreeList<Chunk>::return_chunk_at_tail(Chunk* chunk) {
-  return_chunk_at_tail(chunk, true);
-}
-
-template <class Chunk>
-void FreeList<Chunk>::prepend(FreeList<Chunk>* fl) {
-  assert_proper_lock_protection();
-  if (fl->count() > 0) {
-    if (count() == 0) {
-      set_head(fl->head());
-      set_tail(fl->tail());
-      set_count(fl->count());
-    } else {
-      // Both are non-empty.
-      Chunk* fl_tail = fl->tail();
-      Chunk* this_head = head();
-      assert(fl_tail->next() == NULL, "Well-formedness of fl");
-      fl_tail->link_next(this_head);
-      this_head->link_prev(fl_tail);
-      set_head(fl->head());
-      set_count(count() + fl->count());
-    }
-    fl->set_head(NULL);
-    fl->set_tail(NULL);
-    fl->set_count(0);
-  }
-}
-
-// verify_chunk_in_free_lists() is used to verify that an item is in this free list.
-// It is used as a debugging aid.
-template <class Chunk>
-bool FreeList<Chunk>::verify_chunk_in_free_list(Chunk* fc) const {
-  // This is an internal consistency check, not part of the check that the
-  // chunk is in the free lists.
-  guarantee(fc->size() == size(), "Wrong list is being searched");
-  Chunk* curFC = head();
-  while (curFC) {
-    // This is an internal consistency check.
-    guarantee(size() == curFC->size(), "Chunk is in wrong list.");
-    if (fc == curFC) {
-      return true;
-    }
-    curFC = curFC->next();
-  }
-  return false;
-}
-
-#ifdef ASSERT
-template <class Chunk>
-void FreeList<Chunk>::assert_proper_lock_protection_work() const {
-  // Nothing to do if the list has no assigned protecting lock
-  if (protecting_lock() == NULL) {
-    return;
-  }
-
-  Thread* thr = Thread::current();
-  if (thr->is_VM_thread() || thr->is_ConcurrentGC_thread()) {
-    // assert that we are holding the freelist lock
-  } else if (thr->is_GC_task_thread()) {
-    assert(protecting_lock()->owned_by_self(), "FreeList RACE DETECTED");
-  } else if (thr->is_Java_thread()) {
-    assert(!SafepointSynchronize::is_at_safepoint(), "Should not be executing");
-  } else {
-    ShouldNotReachHere();  // unaccounted thread type?
-  }
-}
-#endif
-
-// Print the "label line" for free list stats.
-template <class Chunk>
-void FreeList<Chunk>::print_labels_on(outputStream* st, const char* c) {
-  st->print("%16s\t", c);
-  st->print("%14s\t"    "%14s\t"    "%14s\t"    "%14s\t"    "%14s\t"
-            "%14s\t"    "%14s\t"    "%14s\t"    "%14s\t"    "%14s\t"    "\n",
-            "bfrsurp", "surplus", "desired", "prvSwep", "bfrSwep",
-            "count",   "cBirths", "cDeaths", "sBirths", "sDeaths");
-}
-
-// Print the AllocationStats for the given free list. If the second argument
-// to the call is a non-null string, it is printed in the first column;
-// otherwise, if the argument is null (the default), then the size of the
-// (free list) block is printed in the first column.
-template <class Chunk_t>
-void FreeList<Chunk_t>::print_on(outputStream* st, const char* c) const {
-  if (c != NULL) {
-    st->print("%16s", c);
-  } else {
-    st->print(SIZE_FORMAT_W(16), size());
-  }
-}
-
-#endif // SHARE_MEMORY_FREELIST_INLINE_HPP

src/hotspot/share/memory/metadataFactory.hpp

@@ -26,6 +26,7 @@
 #define SHARE_MEMORY_METADATAFACTORY_HPP
 
 #include "classfile/classLoaderData.hpp"
+#include "memory/classLoaderMetaspace.hpp"
 #include "oops/array.hpp"
 #include "utilities/exceptions.hpp"
 #include "utilities/globalDefinitions.hpp"

src/hotspot/share/memory/metaspace.hpp

@@ -28,65 +28,21 @@
 #include "memory/memRegion.hpp"
 #include "memory/metaspaceChunkFreeListSummary.hpp"
 #include "memory/virtualspace.hpp"
-#include "memory/metaspace/metaspaceSizesSnapshot.hpp"
 #include "runtime/globals.hpp"
 #include "utilities/exceptions.hpp"
-
+#include "utilities/globalDefinitions.hpp"
-// Metaspace
-//
-// Metaspaces are Arenas for the VM's metadata.
-// They are allocated one per class loader object, and one for the null
-// bootstrap class loader
-//
-//    block X ---+       +-------------------+
-//               |       |  Virtualspace     |
-//               |       |                   |
-//               |       |                   |
-//               |       |-------------------|
-//               |       || Chunk            |
-//               |       ||                  |
-//               |       ||----------        |
-//               +------>||| block 0 |       |
-//                       ||----------        |
-//                       ||| block 1 |       |
-//                       ||----------        |
-//                       ||                  |
-//                       |-------------------|
-//                       |                   |
-//                       |                   |
-//                       +-------------------+
-//
 
 class ClassLoaderData;
+class MetaspaceShared;
 class MetaspaceTracer;
 class Mutex;
 class outputStream;
 
-class CollectedHeap;
-
 namespace metaspace {
-  class ChunkManager;
+  class MetaspaceSizesSnapshot;
-  class ClassLoaderMetaspaceStatistics;
-  class Metablock;
-  class Metachunk;
-  class PrintCLDMetaspaceInfoClosure;
-  class SpaceManager;
-  class VirtualSpaceList;
-  class VirtualSpaceNode;
 }
 
-// Metaspaces each have a  SpaceManager and allocations
+////////////////// Metaspace ///////////////////////
-// are done by the SpaceManager.  Allocations are done
-// out of the current Metachunk.  When the current Metachunk
-// is exhausted, the SpaceManager gets a new one from
-// the current VirtualSpace.  When the VirtualSpace is exhausted
-// the SpaceManager gets a new one.  The SpaceManager
-// also manages freelists of available Chunks.
-//
-// Currently the space manager maintains the list of
-// virtual spaces and the list of chunks in use.  Its
-// allocate() method returns a block for use as a
-// quantum of metadata.
 
 // Namespace for important central static functions
 // (auxiliary stuff goes into MetaspaceUtils)
@@ -94,7 +50,7 @@ class Metaspace : public AllStatic {
 
   friend class MetaspaceShared;
 
- public:
+public:
   enum MetadataType {
     ClassType,
     NonClassType,
@@ -109,59 +65,15 @@ class Metaspace : public AllStatic {
     MetaspaceTypeCount
   };
 
- private:
+private:
 
-  // Align up the word size to the allocation word size
-  static size_t align_word_size_up(size_t);
-
-  // Aligned size of the metaspace.
-  static size_t _compressed_class_space_size;
-
-  static size_t compressed_class_space_size() {
-    return _compressed_class_space_size;
-  }
-
-  static void set_compressed_class_space_size(size_t size) {
-    _compressed_class_space_size = size;
-  }
-
-  static size_t _first_chunk_word_size;
-  static size_t _first_class_chunk_word_size;
-
-  static size_t _commit_alignment;
-  static size_t _reserve_alignment;
   DEBUG_ONLY(static bool   _frozen;)
 
-  // Virtual Space lists for both classes and other metadata
-  static metaspace::VirtualSpaceList* _space_list;
-  static metaspace::VirtualSpaceList* _class_space_list;
-
-  static metaspace::ChunkManager* _chunk_manager_metadata;
-  static metaspace::ChunkManager* _chunk_manager_class;
-
   static const MetaspaceTracer* _tracer;
 
   static bool _initialized;
 
- public:
+public:
-  static metaspace::VirtualSpaceList* space_list()       { return _space_list; }
-  static metaspace::VirtualSpaceList* class_space_list() { return _class_space_list; }
-  static metaspace::VirtualSpaceList* get_space_list(MetadataType mdtype) {
-    assert(mdtype != MetadataTypeCount, "MetadaTypeCount can't be used as mdtype");
-    return mdtype == ClassType ? class_space_list() : space_list();
-  }
-
-  static metaspace::ChunkManager* chunk_manager_metadata() { return _chunk_manager_metadata; }
-  static metaspace::ChunkManager* chunk_manager_class()    { return _chunk_manager_class; }
-  static metaspace::ChunkManager* get_chunk_manager(MetadataType mdtype) {
-    assert(mdtype != MetadataTypeCount, "MetadaTypeCount can't be used as mdtype");
-    return mdtype == ClassType ? chunk_manager_class() : chunk_manager_metadata();
-  }
-
-  // convenience function
-  static metaspace::ChunkManager* get_chunk_manager(bool is_class) {
-    return is_class ? chunk_manager_class() : chunk_manager_metadata();
-  }
 
   static const MetaspaceTracer* tracer() { return _tracer; }
   static void freeze() {
@@ -188,7 +100,7 @@ class Metaspace : public AllStatic {
   static void initialize_class_space(ReservedSpace rs);
 
   // Returns true if class space has been setup (initialize_class_space).
-  static bool class_space_is_initialized() { return _class_space_list != NULL; }
+  static bool class_space_is_initialized();
 
 #endif
 
@@ -198,15 +110,18 @@ class Metaspace : public AllStatic {
   static void global_initialize();
   static void post_initialize();
 
-  static void verify_global_initialization();
+  // Alignment, in bytes, of metaspace mappings
+  static size_t reserve_alignment()       { return reserve_alignment_words() * BytesPerWord; }
+  // Alignment, in words, of metaspace mappings
+  static size_t reserve_alignment_words();
 
-  static size_t first_chunk_word_size() { return _first_chunk_word_size; }
+  // The granularity at which Metaspace is committed and uncommitted.
-  static size_t first_class_chunk_word_size() { return _first_class_chunk_word_size; }
+  // (Todo: Why does this have to be exposed?)
+  static size_t commit_alignment()        { return commit_alignment_words() * BytesPerWord; }
+  static size_t commit_alignment_words();
 
-  static size_t reserve_alignment()       { return _reserve_alignment; }
+  // The largest possible single allocation
-  static size_t reserve_alignment_words() { return _reserve_alignment / BytesPerWord; }
+  static size_t max_allocation_word_size();
-  static size_t commit_alignment()        { return _commit_alignment; }
-  static size_t commit_alignment_words()  { return _commit_alignment / BytesPerWord; }
 
   static MetaWord* allocate(ClassLoaderData* loader_data, size_t word_size,
                             MetaspaceObj::Type type, TRAPS);
@@ -215,7 +130,6 @@ class Metaspace : public AllStatic {
   static bool contains_non_shared(const void* ptr);
 
   // Free empty virtualspaces
-  static void purge(MetadataType mdtype);
   static void purge();
 
   static void report_metadata_oome(ClassLoaderData* loader_data, size_t word_size,
@@ -234,212 +148,38 @@ class Metaspace : public AllStatic {
     return mdType == ClassType && using_class_space();
   }
 
-  static bool initialized() { return _initialized; }
+  static bool initialized();
 
 };
 
-// Manages the metaspace portion belonging to a class loader
+////////////////// MetaspaceGC ///////////////////////
-class ClassLoaderMetaspace : public CHeapObj<mtClass> {
-  friend class CollectedHeap; // For expand_and_allocate()
-  friend class ZCollectedHeap; // For expand_and_allocate()
-  friend class ShenandoahHeap; // For expand_and_allocate()
-  friend class Metaspace;
-  friend class MetaspaceUtils;
-  friend class metaspace::PrintCLDMetaspaceInfoClosure;
-  friend class VM_CollectForMetadataAllocation; // For expand_and_allocate()
-
- private:
-
-  void initialize(Mutex* lock, Metaspace::MetaspaceType type);
-
-  // Initialize the first chunk for a Metaspace.  Used for
-  // special cases such as the boot class loader, reflection
-  // class loader and hidden class loader.
-  void initialize_first_chunk(Metaspace::MetaspaceType type, Metaspace::MetadataType mdtype);
-  metaspace::Metachunk* get_initialization_chunk(Metaspace::MetaspaceType type, Metaspace::MetadataType mdtype);
-
-  const Metaspace::MetaspaceType _space_type;
-  Mutex* const  _lock;
-  metaspace::SpaceManager* _vsm;
-  metaspace::SpaceManager* _class_vsm;
-
-  metaspace::SpaceManager* vsm() const { return _vsm; }
-  metaspace::SpaceManager* class_vsm() const { return _class_vsm; }
-  metaspace::SpaceManager* get_space_manager(Metaspace::MetadataType mdtype) {
-    assert(mdtype != Metaspace::MetadataTypeCount, "MetadaTypeCount can't be used as mdtype");
-    return mdtype == Metaspace::ClassType ? class_vsm() : vsm();
-  }
-
-  Mutex* lock() const { return _lock; }
-
-  MetaWord* expand_and_allocate(size_t size, Metaspace::MetadataType mdtype);
-
-  size_t class_chunk_size(size_t word_size);
-
-  // Adds to the given statistic object. Must be locked with CLD metaspace lock.
-  void add_to_statistics_locked(metaspace::ClassLoaderMetaspaceStatistics* out) const;
-
-  Metaspace::MetaspaceType space_type() const { return _space_type; }
-
- public:
-
-  ClassLoaderMetaspace(Mutex* lock, Metaspace::MetaspaceType type);
-  ~ClassLoaderMetaspace();
-
-  // Allocate space for metadata of type mdtype. This is space
-  // within a Metachunk and is used by
-  //   allocate(ClassLoaderData*, size_t, bool, MetadataType, TRAPS)
-  MetaWord* allocate(size_t word_size, Metaspace::MetadataType mdtype);
-
-  size_t allocated_blocks_bytes() const;
-  size_t allocated_chunks_bytes() const;
-
-  void deallocate(MetaWord* ptr, size_t byte_size, bool is_class);
-
-  void print_on(outputStream* st) const;
-  // Debugging support
-  void verify();
-
-  // Adds to the given statistic object. Will lock with CLD metaspace lock.
-  void add_to_statistics(metaspace::ClassLoaderMetaspaceStatistics* out) const;
-
-}; // ClassLoaderMetaspace
-
-class MetaspaceUtils : AllStatic {
-
-  // Spacemanager updates running counters.
-  friend class metaspace::SpaceManager;
-
-  // Special access for error reporting (checks without locks).
-  friend class oopDesc;
-  friend class Klass;
-
-  // Running counters for statistics concerning in-use chunks.
-  // Note: capacity = used + free + waste + overhead. Note that we do not
-  // count free and waste. Their sum can be deduces from the three other values.
-  // For more details, one should call print_report() from within a safe point.
-  static size_t _capacity_words [Metaspace:: MetadataTypeCount];
-  static size_t _overhead_words [Metaspace:: MetadataTypeCount];
-  static volatile size_t _used_words [Metaspace:: MetadataTypeCount];
-
-  // Atomically decrement or increment in-use statistic counters
-  static void dec_capacity(Metaspace::MetadataType mdtype, size_t words);
-  static void inc_capacity(Metaspace::MetadataType mdtype, size_t words);
-  static void dec_used(Metaspace::MetadataType mdtype, size_t words);
-  static void inc_used(Metaspace::MetadataType mdtype, size_t words);
-  static void dec_overhead(Metaspace::MetadataType mdtype, size_t words);
-  static void inc_overhead(Metaspace::MetadataType mdtype, size_t words);
-
-
-  // Getters for the in-use counters.
-  static size_t capacity_words(Metaspace::MetadataType mdtype)        { return _capacity_words[mdtype]; }
-  static size_t used_words(Metaspace::MetadataType mdtype)            { return _used_words[mdtype]; }
-  static size_t overhead_words(Metaspace::MetadataType mdtype)        { return _overhead_words[mdtype]; }
-
-  static size_t free_chunks_total_words(Metaspace::MetadataType mdtype);
-
-  // Helper for print_xx_report.
-  static void print_vs(outputStream* out, size_t scale);
-
-public:
-
-  // Collect used metaspace statistics. This involves walking the CLDG. The resulting
-  // output will be the accumulated values for all live metaspaces.
-  // Note: method does not do any locking.
-  static void collect_statistics(metaspace::ClassLoaderMetaspaceStatistics* out);
-
-  // Used by MetaspaceCounters
-  static size_t free_chunks_total_words();
-  static size_t free_chunks_total_bytes();
-  static size_t free_chunks_total_bytes(Metaspace::MetadataType mdtype);
-
-  static size_t capacity_words() {
-    return capacity_words(Metaspace::NonClassType) +
-           capacity_words(Metaspace::ClassType);
-  }
-  static size_t capacity_bytes(Metaspace::MetadataType mdtype) {
-    return capacity_words(mdtype) * BytesPerWord;
-  }
-  static size_t capacity_bytes() {
-    return capacity_words() * BytesPerWord;
-  }
-
-  static size_t used_words() {
-    return used_words(Metaspace::NonClassType) +
-           used_words(Metaspace::ClassType);
-  }
-  static size_t used_bytes(Metaspace::MetadataType mdtype) {
-    return used_words(mdtype) * BytesPerWord;
-  }
-  static size_t used_bytes() {
-    return used_words() * BytesPerWord;
-  }
-
-  // Space committed but yet unclaimed by any class loader.
-  static size_t free_in_vs_bytes();
-  static size_t free_in_vs_bytes(Metaspace::MetadataType mdtype);
-
-  static size_t reserved_bytes(Metaspace::MetadataType mdtype);
-  static size_t reserved_bytes() {
-    return reserved_bytes(Metaspace::ClassType) +
-           reserved_bytes(Metaspace::NonClassType);
-  }
-
-  static size_t committed_bytes(Metaspace::MetadataType mdtype);
-  static size_t committed_bytes() {
-    return committed_bytes(Metaspace::ClassType) +
-           committed_bytes(Metaspace::NonClassType);
-  }
-
-  static size_t min_chunk_size_words();
-
-  // Flags for print_report().
-  enum ReportFlag {
-    // Show usage by class loader.
-    rf_show_loaders                 = (1 << 0),
-    // Breaks report down by chunk type (small, medium, ...).
-    rf_break_down_by_chunktype      = (1 << 1),
-    // Breaks report down by space type (hidden, reflection, ...).
-    rf_break_down_by_spacetype      = (1 << 2),
-    // Print details about the underlying virtual spaces.
-    rf_show_vslist                  = (1 << 3),
-    // Print metaspace map.
-    rf_show_vsmap                   = (1 << 4),
-    // If show_loaders: show loaded classes for each loader.
-    rf_show_classes                 = (1 << 5)
-  };
-
-  // This will print out a basic metaspace usage report but
-  // unlike print_report() is guaranteed not to lock or to walk the CLDG.
-  static void print_basic_report(outputStream* st, size_t scale);
-
-  // Prints a report about the current metaspace state.
-  // Optional parts can be enabled via flags.
-  // Function will walk the CLDG and will lock the expand lock; if that is not
-  // convenient, use print_basic_report() instead.
-  static void print_report(outputStream* out, size_t scale = 0, int flags = 0);
-
-  static bool has_chunk_free_list(Metaspace::MetadataType mdtype);
-  static MetaspaceChunkFreeListSummary chunk_free_list_summary(Metaspace::MetadataType mdtype);
-
-  // Log change in used metadata.
-  static void print_metaspace_change(const metaspace::MetaspaceSizesSnapshot& pre_meta_values);
-  static void print_on(outputStream * out);
-
-  // Prints an ASCII representation of the given space.
-  static void print_metaspace_map(outputStream* out, Metaspace::MetadataType mdtype);
-
-  static void dump(outputStream* out);
-  static void verify_free_chunks();
-  // Check internal counters (capacity, used).
-  static void verify_metrics();
-};
 
 // Metaspace are deallocated when their class loader are GC'ed.
 // This class implements a policy for inducing GC's to recover
 // Metaspaces.
 
-class MetaspaceGC : AllStatic {
+class MetaspaceGCThresholdUpdater : public AllStatic {
+ public:
+  enum Type {
+    ComputeNewSize,
+    ExpandAndAllocate,
+    Last
+  };
+
+  static const char* to_string(MetaspaceGCThresholdUpdater::Type updater) {
+    switch (updater) {
+      case ComputeNewSize:
+        return "compute_new_size";
+      case ExpandAndAllocate:
+        return "expand_and_allocate";
+      default:
+        assert(false, "Got bad updater: %d", (int) updater);
+        return NULL;
+    };
+  }
+};
+
+class MetaspaceGC : public AllStatic {
 
   // The current high-water-mark for inducing a GC.
   // When committed memory of all metaspaces reaches this value,
@@ -477,4 +217,50 @@ class MetaspaceGC : AllStatic {
   static void compute_new_size();
 };
 
+class MetaspaceUtils : AllStatic {
+public:
+
+  // Committed space actually in use by Metadata
+  static size_t used_words();
+  static size_t used_words(Metaspace::MetadataType mdtype);
+
+  // Space committed for Metaspace
+  static size_t committed_words();
+  static size_t committed_words(Metaspace::MetadataType mdtype);
+
+  // Space reserved for Metaspace
+  static size_t reserved_words();
+  static size_t reserved_words(Metaspace::MetadataType mdtype);
+
+  // _bytes() variants for convenience...
+  static size_t used_bytes()                                    { return used_words() * BytesPerWord; }
+  static size_t used_bytes(Metaspace::MetadataType mdtype)      { return used_words(mdtype) * BytesPerWord; }
+  static size_t committed_bytes()                               { return committed_words() * BytesPerWord; }
+  static size_t committed_bytes(Metaspace::MetadataType mdtype) { return committed_words(mdtype) * BytesPerWord; }
+  static size_t reserved_bytes()                                { return reserved_words() * BytesPerWord; }
+  static size_t reserved_bytes(Metaspace::MetadataType mdtype)  { return reserved_words(mdtype) * BytesPerWord; }
+
+  // (See JDK-8251342). Implement or Consolidate.
+  static MetaspaceChunkFreeListSummary chunk_free_list_summary(Metaspace::MetadataType mdtype) {
+    return MetaspaceChunkFreeListSummary(0,0,0,0,0,0,0,0);
+  }
+
+  // Log change in used metadata.
+  static void print_metaspace_change(const metaspace::MetaspaceSizesSnapshot& pre_meta_values);
+
+  // This will print out a basic metaspace usage report but
+  // unlike print_report() is guaranteed not to lock or to walk the CLDG.
+  static void print_basic_report(outputStream* st, size_t scale = 0);
+
+  // Prints a report about the current metaspace state.
+  // Function will walk the CLDG and will lock the expand lock; if that is not
+  // convenient, use print_basic_report() instead.
+  static void print_report(outputStream* out, size_t scale = 0);
+
+  static void print_on(outputStream * out);
+
+  DEBUG_ONLY(static void verify();)
+
+};
+
 #endif // SHARE_MEMORY_METASPACE_HPP

src/hotspot/share/memory/metaspace/allocationGuard.hpp

@@ -0,0 +1,116 @@
+/*
+ * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2020 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
+ * 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.
+ *
+ */
+
+#ifndef SHARE_MEMORY_METASPACE_ALLOCATIONGUARD_HPP
+#define SHARE_MEMORY_METASPACE_ALLOCATIONGUARD_HPP
+
+#include "memory/allocation.hpp"
+#include "memory/metaspace/chunklevel.hpp"
+#include "utilities/globalDefinitions.hpp"
+
+// In Debug builds, Metadata in Metaspace can be optionally guarded - enclosed in canaries -
+// to detect memory overwriters.
+//
+// These canaries are periodically checked, e.g. when the Metaspace is purged in a context
+// of a GC.
+
+// The canaries precede any allocated block...
+//
+// +---------------+
+// |  'METAMETA'   |
+// +---------------+
+// |  block size   |
+// +---------------+
+// |  block...     |
+// .               .
+// .               .
+// .               .
+// |               |
+// +---------------+
+// . <padding>     .
+// +---------------+
+// |  'METAMETA'   |
+// +---------------+
+// |  block size   |
+// +---------------+
+// |  block...     |
+
+// ... and since the blocks are allocated via pointer bump and closely follow each other,
+// one block's prefix is its predecessor's suffix, so apart from the last block all
+// blocks have an overwriter canary on both ends.
+//
+
+// Note: this feature is only available in debug, and is activated using
+//  -XX:+MetaspaceGuardAllocations. When active, it disables deallocation handling - since
+//  freeblock handling in the freeblock lists would get too complex - so one may run leaks
+//  in deallocation-heavy scenarios (e.g. lots of class redefinitions).
+//
+
+namespace metaspace {
+
+#ifdef ASSERT
+
+struct Prefix {
+  static const uintx EyeCatcher =
+      NOT_LP64(0x77698465) LP64_ONLY(0x7769846577698465ULL); // "META" resp "METAMETA"
+
+  const uintx _mark;
+  const size_t _word_size;   // raw word size including prefix
+  // MetaWord payload [0];   // varsized (but unfortunately not all our compilers understand that)
+
+  Prefix(size_t word_size) :
+    _mark(EyeCatcher),
+    _word_size(word_size)
+  {}
+
+  MetaWord* payload() const {
+    return (MetaWord*)(this + 1);
+  }
+
+  bool is_valid() const {
+    return _mark == EyeCatcher && _word_size > 0 && _word_size < chunklevel::MAX_CHUNK_WORD_SIZE;
+  }
+
+};
+
+// The prefix structure must be aligned to MetaWord size.
+STATIC_ASSERT((sizeof(Prefix) & WordAlignmentMask) == 0);
+
+inline size_t prefix_size() {
+  return sizeof(Prefix);
+}
+
+// Given a pointer to a memory area, establish the prefix at the start of that area and
+// return the starting pointer to the payload.
+inline MetaWord* establish_prefix(MetaWord* p_raw, size_t raw_word_size) {
+  const Prefix* pp = new(p_raw)Prefix(raw_word_size);
+  return pp->payload();
+}
+
+#endif
+
+} // namespace metaspace
+
+#endif // SHARE_MEMORY_METASPACE_ALLOCATIONGUARD_HPP

src/hotspot/share/memory/metaspace/binList.hpp

@@ -0,0 +1,200 @@
+/*
+ * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2020 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
+ * 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.
+ *
+ */
+
+#ifndef SHARE_MEMORY_METASPACE_BINLIST_HPP
+#define SHARE_MEMORY_METASPACE_BINLIST_HPP
+
+#include "memory/metaspace/counters.hpp"
+#include "memory/metaspace/metaspaceCommon.hpp"
+#include "utilities/align.hpp"
+#include "utilities/debug.hpp"
+#include "utilities/globalDefinitions.hpp"
+
+namespace metaspace {
+
+// BinList is a data structure to manage small to very small memory blocks
+// (only a few words). It is used to manage deallocated blocks - see
+// class FreeBlocks.
+
+// Memory blocks are kept in linked lists. Each list
+// contains blocks of only one size. There is a list for blocks of two words,
+// for blocks of three words, etc. The list heads are kept in a vector,
+// ordered by block size.
+//
+
+// wordsize
+//
+//       +---+   +---+   +---+      +---+
+//  1    |   |-->|   |-->|   |-...->|   |
+//       +---+   +---+   +---+      +---+
+//
+//       +----+   +----+   +----+      +----+
+//  2    |    |-->|    |-->|    |-...->|    |
+//       +----+   +----+   +----+      +----+
+//
+//       +-----+   +-----+   +-----+      +-----+
+//  3    |     |-->|     |-->|     |-...->|     |
+//       +-----+   +-----+   +-----+      +-----+
+//  .
+//  .
+//  .
+//
+//       +----------+   +----------+   +----------+      +----------+
+//  n    |          |-->|          |-->|          |-...->|          |
+//       +----------+   +----------+   +----------+      +----------+
+
+// Insertion is of course fast, O(1).
+//
+// On retrieval, we attempt to find the closest fit to a given size, walking the
+// list head vector (a bitmask is used to speed that part up).
+//
+// This structure is a bit expensive in memory costs (we pay one pointer per managed
+// block size) so we only use it for a small number of sizes.
+
+template <size_t smallest_word_size, int num_lists>
+class BinListImpl {
+
+  struct Block {
+    Block* const _next;
+    const size_t _word_size;
+    Block(Block* next, size_t word_size) :
+      _next(next),
+      _word_size(word_size)
+    {}
+  };
+
+  // Smallest block size must be large enough to hold a Block structure.
+  STATIC_ASSERT(smallest_word_size * sizeof(MetaWord) >= sizeof(Block));
+  STATIC_ASSERT(num_lists > 0);
+
+public:
+
+  // Minimal word size a block must have to be manageable by this structure.
+  const static size_t MinWordSize = smallest_word_size;
+
+  // Maximal (incl) word size a block can have to be manageable by this structure.
+  const static size_t MaxWordSize = MinWordSize + num_lists - 1;
+
+private:
+
+  Block* _blocks[num_lists];
+
+  MemRangeCounter _counter;
+
+  static int index_for_word_size(size_t word_size) {
+    int index = (int)(word_size - MinWordSize);
+    assert(index >= 0 && index < num_lists, "Invalid index %d", index);
+    return index;
+  }
+
+  static size_t word_size_for_index(int index) {
+    assert(index >= 0 && index < num_lists, "Invalid index %d", index);
+    return MinWordSize + index;
+  }
+
+  // Search the range [index, _num_lists) for the smallest non-empty list. Returns -1 on fail.
+  int index_for_next_non_empty_list(int index) {
+    assert(index >= 0 && index < num_lists, "Invalid index %d", index);
+    int i2 = index;
+    while (i2 < num_lists && _blocks[i2] == NULL) {
+      i2 ++;
+    }
+    return i2 == num_lists ? -1 : i2;
+  }
+
+public:
+
+  BinListImpl() {
+    for (int i = 0; i < num_lists; i++) {
+      _blocks[i] = NULL;
+    }
+  }
+
+  void add_block(MetaWord* p, size_t word_size) {
+    assert(word_size >= MinWordSize &&
+           word_size <= MaxWordSize, "bad block size");
+    const int index = index_for_word_size(word_size);
+    Block* old_head = _blocks[index];
+    Block* new_head = new(p)Block(old_head, word_size);
+    _blocks[index] = new_head;
+    _counter.add(word_size);
+  }
+
+  // Given a word_size, searches and returns a block of at least that size.
+  // Block may be larger. Real block size is returned in *p_real_word_size.
+  MetaWord* remove_block(size_t word_size, size_t* p_real_word_size) {
+    assert(word_size >= MinWordSize &&
+           word_size <= MaxWordSize, "bad block size " SIZE_FORMAT ".", word_size);
+    int index = index_for_word_size(word_size);
+    index = index_for_next_non_empty_list(index);
+    if (index != -1) {
+      assert(_blocks[index] != NULL &&
+             _blocks[index]->_word_size >= word_size, "sanity");
+
+      MetaWord* const p = (MetaWord*)_blocks[index];
+      const size_t real_word_size = word_size_for_index(index);
+
+      _blocks[index] = _blocks[index]->_next;
+
+      _counter.sub(real_word_size);
+      *p_real_word_size = real_word_size;
+
+      return p;
+
+    } else {
+      *p_real_word_size = 0;
+      return NULL;
+    }
+  }
+
+  // Returns number of blocks in this structure
+  unsigned count() const { return _counter.count(); }
+
+  // Returns total size, in words, of all elements.
+  size_t total_size() const { return _counter.total_size(); }
+
+  bool is_empty() const { return count() == 0; }
+
+#ifdef ASSERT
+  void verify() const {
+    MemRangeCounter local_counter;
+    for (int i = 0; i < num_lists; i++) {
+      const size_t s = MinWordSize + i;
+      for (Block* b = _blocks[i]; b != NULL; b = b->_next) {
+        assert(b->_word_size == s, "bad block size");
+        local_counter.add(s);
+      }
+    }
+    local_counter.check(_counter);
+  }
+#endif // ASSERT
+
+};
+
+typedef BinListImpl<2, 32> BinList32;
+
+} // namespace metaspace
+
+#endif // SHARE_MEMORY_METASPACE_BINLIST_HPP

src/hotspot/share/memory/metaspace/blockFreelist.cpp

@@ -1,109 +0,0 @@
-/*
- * Copyright (c) 2018, 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 "precompiled.hpp"
-
-#include "logging/log.hpp"
-#include "memory/binaryTreeDictionary.inline.hpp"
-#include "memory/metaspace/blockFreelist.hpp"
-#include "utilities/ostream.hpp"
-#include "utilities/globalDefinitions.hpp"
-
-
-namespace metaspace {
-
-
-BlockFreelist::BlockFreelist() : _dictionary(new BlockTreeDictionary()), _small_blocks(NULL) {}
-
-BlockFreelist::~BlockFreelist() {
-  delete _dictionary;
-  if (_small_blocks != NULL) {
-    delete _small_blocks;
-  }
-}
-
-void BlockFreelist::return_block(MetaWord* p, size_t word_size) {
-  assert(word_size >= SmallBlocks::small_block_min_size(), "never return dark matter");
-
-  Metablock* free_chunk = ::new (p) Metablock(word_size);
-  if (word_size < SmallBlocks::small_block_max_size()) {
-    small_blocks()->return_block(free_chunk, word_size);
-  } else {
-  dictionary()->return_chunk(free_chunk);
-}
-  log_trace(gc, metaspace, freelist, blocks)("returning block at " INTPTR_FORMAT " size = "
-            SIZE_FORMAT, p2i(free_chunk), word_size);
-}
-
-MetaWord* BlockFreelist::get_block(size_t word_size) {
-  assert(word_size >= SmallBlocks::small_block_min_size(), "never get dark matter");
-
-  // Try small_blocks first.
-  if (word_size < SmallBlocks::small_block_max_size()) {
-    // Don't create small_blocks() until needed.  small_blocks() allocates the small block list for
-    // this space manager.
-    MetaWord* new_block = (MetaWord*) small_blocks()->get_block(word_size);
-    if (new_block != NULL) {
-      log_trace(gc, metaspace, freelist, blocks)("getting block at " INTPTR_FORMAT " size = " SIZE_FORMAT,
-              p2i(new_block), word_size);
-      return new_block;
-    }
-  }
-
-  if (word_size < BlockFreelist::min_dictionary_size()) {
-    // If allocation in small blocks fails, this is Dark Matter.  Too small for dictionary.
-    return NULL;
-  }
-
-  Metablock* free_block = dictionary()->get_chunk(word_size);
-  if (free_block == NULL) {
-    return NULL;
-  }
-
-  const size_t block_size = free_block->size();
-  if (block_size > WasteMultiplier * word_size) {
-    return_block((MetaWord*)free_block, block_size);
-    return NULL;
-  }
-
-  MetaWord* new_block = (MetaWord*)free_block;
-  assert(block_size >= word_size, "Incorrect size of block from freelist");
-  const size_t unused = block_size - word_size;
-  if (unused >= SmallBlocks::small_block_min_size()) {
-    return_block(new_block + word_size, unused);
-  }
-
-  log_trace(gc, metaspace, freelist, blocks)("getting block at " INTPTR_FORMAT " size = " SIZE_FORMAT,
-            p2i(new_block), word_size);
-  return new_block;
-}
-
-void BlockFreelist::print_on(outputStream* st) const {
-  dictionary()->print_free_lists(st);
-  if (_small_blocks != NULL) {
-    _small_blocks->print_on(st);
-  }
-}
-
-} // namespace metaspace
-

src/hotspot/share/memory/metaspace/blockFreelist.hpp

@@ -1,92 +0,0 @@
-/*
- * Copyright (c) 2018, 2019, 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.
- *
- */
-
-#ifndef SHARE_MEMORY_METASPACE_BLOCKFREELIST_HPP
-#define SHARE_MEMORY_METASPACE_BLOCKFREELIST_HPP
-
-#include "memory/allocation.hpp"
-#include "memory/binaryTreeDictionary.hpp"
-#include "memory/freeList.hpp"
-#include "memory/metaspace/smallBlocks.hpp"
-#include "memory/metaspace/metablock.hpp"
-#include "utilities/globalDefinitions.hpp"
-
-namespace metaspace {
-
-typedef BinaryTreeDictionary<Metablock, FreeList<Metablock> > BlockTreeDictionary;
-
-// Used to manage the free list of Metablocks (a block corresponds
-// to the allocation of a quantum of metadata).
-class BlockFreelist : public CHeapObj<mtClass> {
-
-  BlockTreeDictionary* const _dictionary;
-  SmallBlocks* _small_blocks;
-
-  // Only allocate and split from freelist if the size of the allocation
-  // is at least 1/4th the size of the available block.
-  const static int WasteMultiplier = 4;
-
-  // Accessors
-  BlockTreeDictionary* dictionary() const { return _dictionary; }
-  SmallBlocks* small_blocks() {
-    if (_small_blocks == NULL) {
-      _small_blocks = new SmallBlocks();
-    }
-    return _small_blocks;
-  }
-
- public:
-
-  BlockFreelist();
-  ~BlockFreelist();
-
-  // Get and return a block to the free list
-  MetaWord* get_block(size_t word_size);
-  void return_block(MetaWord* p, size_t word_size);
-
-  // Returns the total size, in words, of all blocks kept in this structure.
-  size_t total_size() const  {
-    size_t result = dictionary()->total_size();
-    if (_small_blocks != NULL) {
-      result = result + _small_blocks->total_size();
-    }
-    return result;
-  }
-
-  // Returns the number of all blocks kept in this structure.
-  uintx num_blocks() const {
-    uintx result = dictionary()->total_free_blocks();
-    if (_small_blocks != NULL) {
-      result = result + _small_blocks->total_num_blocks();
-    }
-    return result;
-  }
-
-  static size_t min_dictionary_size()   { return TreeChunk<Metablock, FreeList<Metablock> >::min_size(); }
-  void print_on(outputStream* st) const;
-};
-
-} // namespace metaspace
-
-#endif // SHARE_MEMORY_METASPACE_BLOCKFREELIST_HPP

src/hotspot/share/memory/metaspace/blockTree.cpp

@@ -0,0 +1,198 @@
+/*
+ * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2020 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
+ * 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 "precompiled.hpp"
+#include "memory/metaspace/blockTree.hpp"
+#include "memory/resourceArea.hpp"
+#include "utilities/debug.hpp"
+#include "utilities/globalDefinitions.hpp"
+#include "utilities/growableArray.hpp"
+#include "utilities/ostream.hpp"
+
+namespace metaspace {
+
+// Needed to prevent linker errors on MacOS and AIX
+const size_t BlockTree::MinWordSize;
+
+#ifdef ASSERT
+
+// Tree verification
+
+// These asserts prints the tree, then asserts
+#define assrt(cond, format, ...) \
+  do { \
+    if (!(cond)) { \
+      print_tree(tty); \
+      assert(cond, format, __VA_ARGS__); \
+    } \
+  } while (0)
+
+  // This assert prints the tree, then stops (generic message)
+#define assrt0(cond) \
+  do { \
+    if (!(cond)) { \
+      print_tree(tty); \
+      assert(cond, "sanity"); \
+    } \
+  } while (0)
+
+// walkinfo keeps a node plus the size corridor it and its children
+//  are supposed to be in.
+struct BlockTree::walkinfo {
+  BlockTree::Node* n;
+  int depth;
+  size_t lim1; // (
+  size_t lim2; // )
+};
+
+void BlockTree::verify() const {
+  // Traverse the tree and test that all nodes are in the correct order.
+
+  MemRangeCounter counter;
+  int longest_edge = 0;
+
+  if (_root != NULL) {
+
+    ResourceMark rm;
+    GrowableArray<walkinfo> stack;
+
+    walkinfo info;
+    info.n = _root;
+    info.lim1 = 0;
+    info.lim2 = SIZE_MAX;
+    info.depth = 0;
+
+    stack.push(info);
+
+    while (stack.length() > 0) {
+      info = stack.pop();
+      const Node* n = info.n;
+
+      // Assume a (ridiculously large) edge limit to catch cases
+      //  of badly degenerated or circular trees.
+      assrt0(info.depth < 10000);
+      counter.add(n->_word_size);
+
+      // Verify node.
+      if (n == _root) {
+        assrt0(n->_parent == NULL);
+      } else {
+        assrt0(n->_parent != NULL);
+      }
+
+      // check size and ordering
+      assrt(n->_word_size >= MinWordSize, "bad node size " SIZE_FORMAT, n->_word_size);
+      assrt0(n->_word_size > info.lim1);
+      assrt0(n->_word_size < info.lim2);
+
+      // Check children
+      if (n->_left != NULL) {
+        assrt0(n->_left != n);
+        assrt0(n->_left->_parent == n);
+
+        walkinfo info2;
+        info2.n = n->_left;
+        info2.lim1 = info.lim1;
+        info2.lim2 = n->_word_size;
+        info2.depth = info.depth + 1;
+        stack.push(info2);
+      }
+
+      if (n->_right != NULL) {
+        assrt0(n->_right != n);
+        assrt0(n->_right->_parent == n);
+
+        walkinfo info2;
+        info2.n = n->_right;
+        info2.lim1 = n->_word_size;
+        info2.lim2 = info.lim2;
+        info2.depth = info.depth + 1;
+        stack.push(info2);
+      }
+
+      // If node has same-sized siblings check those too.
+      const Node* n2 = n->_next;
+      while (n2 != NULL) {
+        assrt0(n2 != n);
+        assrt0(n2->_word_size == n->_word_size);
+        counter.add(n2->_word_size);
+        n2 = n2->_next;
+      }
+    }
+  }
+
+  // At the end, check that counters match
+  _counter.check(counter);
+}
+
+void BlockTree::zap_range(MetaWord* p, size_t word_size) {
+  memset(p, 0xF3, word_size * sizeof(MetaWord));
+}
+
+#undef assrt
+#undef assrt0
+
+void BlockTree::print_tree(outputStream* st) const {
+  if (_root != NULL) {
+
+    ResourceMark rm;
+    GrowableArray<walkinfo> stack;
+
+    walkinfo info;
+    info.n = _root;
+    info.depth = 0;
+
+    stack.push(info);
+    while (stack.length() > 0) {
+      info = stack.pop();
+      const Node* n = info.n;
+      // Print node.
+      for (int i = 0; i < info.depth; i++) {
+         st->print("---");
+      }
+      st->print_cr("<" PTR_FORMAT " (size " SIZE_FORMAT ")", p2i(n), n->_word_size);
+      // Handle children.
+      if (n->_right != NULL) {
+        walkinfo info2;
+        info2.n = n->_right;
+        info2.depth = info.depth + 1;
+        stack.push(info2);
+      }
+      if (n->_left != NULL) {
+        walkinfo info2;
+        info2.n = n->_left;
+        info2.depth = info.depth + 1;
+        stack.push(info2);
+      }
+    }
+
+  } else {
+    st->print_cr("<no nodes>");
+  }
+}
+
+#endif // ASSERT
+
+} // namespace metaspace

src/hotspot/share/memory/metaspace/blockTree.hpp

@@ -0,0 +1,379 @@
+/*
+ * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2020 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
+ * 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.
+ *
+ */
+
+#ifndef SHARE_MEMORY_METASPACE_BLOCKTREE_HPP
+#define SHARE_MEMORY_METASPACE_BLOCKTREE_HPP
+
+#include "memory/allocation.hpp"
+#include "memory/metaspace/chunklevel.hpp"
+#include "memory/metaspace/counters.hpp"
+#include "utilities/debug.hpp"
+#include "utilities/globalDefinitions.hpp"
+
+namespace metaspace {
+
+// BlockTree is a rather simple binary search tree. It is used to
+//  manage small to medium free memory blocks (see class FreeBlocks).
+//
+// There is no separation between payload (managed blocks) and nodes: the
+//  memory blocks themselves are the nodes, with the block size being the key.
+//
+// We store node pointer information in these blocks when storing them. That
+//  imposes a minimum size to the managed memory blocks.
+//  See get_raw_word_size_for_requested_word_size() (msCommon.hpp).
+//
+// We want to manage many memory blocks of the same size, but we want
+//  to prevent the tree from blowing up and degenerating into a list. Therefore
+//  there is only one node for each unique block size; subsequent blocks of the
+//  same size are stacked below that first node:
+//
+//                   +-----+
+//                   | 100 |
+//                   +-----+
+//                  /       \
+//           +-----+
+//           | 80  |
+//           +-----+
+//          /   |   \
+//         / +-----+ \
+//  +-----+  | 80  |  +-----+
+//  | 70  |  +-----+  | 85  |
+//  +-----+     |     +-----+
+//           +-----+
+//           | 80  |
+//           +-----+
+//
+//
+// Todo: This tree is unbalanced. It would be a good fit for a red-black tree.
+//  In order to make this a red-black tree, we need an algorithm which can deal
+//  with nodes which are their own payload (most red-black tree implementations
+//  swap payloads of their nodes at some point, see e.g. j.u.TreeSet).
+// A good example is the Linux kernel rbtree, which is a clean, easy-to-read
+//  implementation.
+
+class BlockTree: public CHeapObj<mtMetaspace> {
+
+  struct Node {
+
+    // Normal tree node stuff...
+    Node* _parent;
+    Node* _left;
+    Node* _right;
+
+    // Blocks with the same size are put in a list with this node as head.
+    Node* _next;
+
+    // Word size of node. Note that size cannot be larger than max metaspace size,
+    // so this could be very well a 32bit value (in case we ever make this a balancing
+    // tree and need additional space for weighting information).
+    const size_t _word_size;
+
+    Node(size_t word_size) :
+      _parent(NULL),
+      _left(NULL),
+      _right(NULL),
+      _next(NULL),
+      _word_size(word_size)
+    {}
+
+  };
+
+  // Needed for verify() and print_tree()
+  struct walkinfo;
+
+public:
+
+  // Minimum word size a block has to be to be added to this structure (note ceil division).
+  const static size_t MinWordSize =
+      (sizeof(Node) + sizeof(MetaWord) - 1) / sizeof(MetaWord);
+
+private:
+
+  Node* _root;
+
+  MemRangeCounter _counter;
+
+  // Given a node n, add it to the list starting at head
+  static void add_to_list(Node* n, Node* head) {
+    assert(head->_word_size == n->_word_size, "sanity");
+    n->_next = head->_next;
+    head->_next = n;
+    DEBUG_ONLY(n->_left = n->_right = n->_parent = NULL;)
+  }
+
+  // Given a node list starting at head, remove one of the follow up nodes from
+  //  that list and return it. The head node gets not modified and remains in the
+  //  tree.
+  // List must contain at least one other node.
+  static Node* remove_from_list(Node* head) {
+    assert(head->_next != NULL, "sanity");
+    Node* n = head->_next;
+    head->_next = n->_next;
+    return n;
+  }
+
+  // Given a node c and a node p, wire up c as left child of p.
+  static void set_left_child(Node* p, Node* c) {
+    p->_left = c;
+    if (c != NULL) {
+      assert(c->_word_size < p->_word_size, "sanity");
+      c->_parent = p;
+    }
+  }
+
+  // Given a node c and a node p, wire up c as right child of p.
+  static void set_right_child(Node* p, Node* c) {
+    p->_right = c;
+    if (c != NULL) {
+      assert(c->_word_size > p->_word_size, "sanity");
+      c->_parent = p;
+    }
+  }
+
+  // Given a node n, return its successor in the tree
+  // (node with the next-larger size).
+  static Node* successor(Node* n) {
+    Node* succ = NULL;
+    if (n->_right != NULL) {
+      // If there is a right child, search the left-most
+      // child of that child.
+      succ = n->_right;
+      while (succ->_left != NULL) {
+        succ = succ->_left;
+      }
+    } else {
+      succ = n->_parent;
+      Node* n2 = n;
+      // As long as I am the right child of my parent, search upward
+      while (succ != NULL && n2 == succ->_right) {
+        n2 = succ;
+        succ = succ->_parent;
+      }
+    }
+    return succ;
+  }
+
+  // Given a node, replace it with a replacement node as a child for its parent.
+  // If the node is root and has no parent, sets it as root.
+  void replace_node_in_parent(Node* child, Node* replace) {
+    Node* parent = child->_parent;
+    if (parent != NULL) {
+      if (parent->_left == child) { // Child is left child
+        set_left_child(parent, replace);
+      } else {
+        set_right_child(parent, replace);
+      }
+    } else {
+      assert(child == _root, "must be root");
+      _root = replace;
+      if (replace != NULL) {
+        replace->_parent = NULL;
+      }
+    }
+    return;
+  }
+
+  // Given a node n and an insertion point, insert n under insertion point.
+  static void insert(Node* insertion_point, Node* n) {
+    assert(n->_parent == NULL, "Sanity");
+    for (;;) {
+      if (n->_word_size == insertion_point->_word_size) {
+        add_to_list(n, insertion_point); // parent stays NULL in this case.
+        break;
+      } else if (n->_word_size > insertion_point->_word_size) {
+        if (insertion_point->_right == NULL) {
+          set_right_child(insertion_point, n);
+          break;
+        } else {
+          insertion_point = insertion_point->_right;
+        }
+      } else {
+        if (insertion_point->_left == NULL) {
+          set_left_child(insertion_point, n);
+          break;
+        } else {
+          insertion_point = insertion_point->_left;
+        }
+      }
+    }
+  }
+
+  // Given a node and a wish size, search this node and all children for
+  // the node closest (equal or larger sized) to the size s.
+  static Node* find_closest_fit(Node* n, size_t s) {
+    Node* best_match = NULL;
+    while (n != NULL) {
+      if (n->_word_size >= s) {
+        best_match = n;
+        if (n->_word_size == s) {
+          break; // perfect match or max depth reached
+        }
+        n = n->_left;
+      } else {
+        n = n->_right;
+      }
+    }
+    return best_match;
+  }
+
+  // Given a wish size, search the whole tree for a
+  // node closest (equal or larger sized) to the size s.
+  Node* find_closest_fit(size_t s) {
+    if (_root != NULL) {
+      return find_closest_fit(_root, s);
+    }
+    return NULL;
+  }
+
+  // Given a node n, remove it from the tree and repair tree.
+  void remove_node_from_tree(Node* n) {
+    assert(n->_next == NULL, "do not delete a node which has a non-empty list");
+
+    if (n->_left == NULL && n->_right == NULL) {
+      replace_node_in_parent(n, NULL);
+
+    } else if (n->_left == NULL && n->_right != NULL) {
+      replace_node_in_parent(n, n->_right);
+
+    } else if (n->_left != NULL && n->_right == NULL) {
+      replace_node_in_parent(n, n->_left);
+
+    } else {
+      // Node has two children.
+
+      // 1) Find direct successor (the next larger node).
+      Node* succ = successor(n);
+
+      // There has to be a successor since n->right was != NULL...
+      assert(succ != NULL, "must be");
+
+      // ... and it should not have a left child since successor
+      //     is supposed to be the next larger node, so it must be the mostleft node
+      //     in the sub tree rooted at n->right
+      assert(succ->_left == NULL, "must be");
+      assert(succ->_word_size > n->_word_size, "sanity");
+
+      Node* successor_parent = succ->_parent;
+      Node* successor_right_child = succ->_right;
+
+      // Remove successor from its parent.
+      if (successor_parent == n) {
+
+        // special case: successor is a direct child of n. Has to be the right child then.
+        assert(n->_right == succ, "sanity");
+
+        // Just replace n with this successor.
+        replace_node_in_parent(n, succ);
+
+        // Take over n's old left child, too.
+        // We keep the successor's right child.
+        set_left_child(succ, n->_left);
+      } else {
+        // If the successors parent is not n, we are deeper in the tree,
+        //  the successor has to be the left child of its parent.
+        assert(successor_parent->_left == succ, "sanity");
+
+        // The right child of the successor (if there was one) replaces
+        //  the successor at its parent's left child.
+        set_left_child(successor_parent, succ->_right);
+
+        // and the successor replaces n at its parent
+        replace_node_in_parent(n, succ);
+
+        // and takes over n's old children
+        set_left_child(succ, n->_left);
+        set_right_child(succ, n->_right);
+      }
+    }
+  }
+
+#ifdef ASSERT
+  void zap_range(MetaWord* p, size_t word_size);
+#endif // ASSERT
+
+public:
+
+  BlockTree() : _root(NULL) {}
+
+  // Add a memory block to the tree. Its content will be overwritten.
+  void add_block(MetaWord* p, size_t word_size) {
+    DEBUG_ONLY(zap_range(p, word_size));
+    assert(word_size >= MinWordSize, "invalid block size " SIZE_FORMAT, word_size);
+    Node* n = new(p) Node(word_size);
+    if (_root == NULL) {
+      _root = n;
+    } else {
+      insert(_root, n);
+    }
+    _counter.add(word_size);
+  }
+
+  // Given a word_size, search and return the smallest block that is equal or
+  //  larger than that size. Upon return, *p_real_word_size contains the actual
+  //  block size.
+  MetaWord* remove_block(size_t word_size, size_t* p_real_word_size) {
+    assert(word_size >= MinWordSize, "invalid block size " SIZE_FORMAT, word_size);
+
+    Node* n = find_closest_fit(word_size);
+
+    if (n != NULL) {
+      assert(n->_word_size >= word_size, "sanity");
+
+      if (n->_next != NULL) {
+        // If the node is head of a chain of same sized nodes, we leave it alone
+        //  and instead remove one of the follow up nodes (which is simpler than
+        //  removing the chain head node and then having to graft the follow up
+        //  node into its place in the tree).
+        n = remove_from_list(n);
+      } else {
+        remove_node_from_tree(n);
+      }
+
+      MetaWord* p = (MetaWord*)n;
+      *p_real_word_size = n->_word_size;
+
+      _counter.sub(n->_word_size);
+
+      DEBUG_ONLY(zap_range(p, n->_word_size));
+      return p;
+    }
+    return NULL;
+  }
+
+  // Returns number of blocks in this structure
+  unsigned count() const { return _counter.count(); }
+
+  // Returns total size, in words, of all elements.
+  size_t total_size() const { return _counter.total_size(); }
+
+  bool is_empty() const { return _root == NULL; }
+
+  DEBUG_ONLY(void print_tree(outputStream* st) const;)
+  DEBUG_ONLY(void verify() const;)
+};
+
+} // namespace metaspace
+
+#endif // SHARE_MEMORY_METASPACE_BLOCKTREE_HPP

src/hotspot/share/memory/metaspace/chunkHeaderPool.cpp

@@ -0,0 +1,92 @@
+/*
+ * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2020 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
+ * 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 "precompiled.hpp"
+#include "memory/metaspace/chunkHeaderPool.hpp"
+#include "runtime/os.hpp"
+#include "utilities/debug.hpp"
+#include "utilities/globalDefinitions.hpp"
+
+namespace metaspace {
+
+// Returns reference to the one global chunk header pool.
+ChunkHeaderPool* ChunkHeaderPool::_chunkHeaderPool = NULL;
+
+ChunkHeaderPool::ChunkHeaderPool() :
+  _num_slabs(),
+  _first_slab(NULL),
+  _current_slab(NULL)
+{}
+
+// Note: the global chunk header pool gets never deleted; so this destructor only
+// exists for the sake of tests.
+ChunkHeaderPool::~ChunkHeaderPool() {
+  Slab* s = _first_slab;
+  while (s != NULL) {
+    Slab* next_slab = s->_next;
+    os::free(s);
+     s = next_slab;
+  }
+}
+
+void ChunkHeaderPool::allocate_new_slab() {
+  Slab* slab = new Slab();
+  if (_current_slab != NULL) {
+    _current_slab->_next = slab;
+  }
+  _current_slab = slab;
+  if (_first_slab == NULL) {
+    _first_slab = slab;
+  }
+  _num_slabs.increment();
+}
+
+// Returns size of memory used.
+size_t ChunkHeaderPool::memory_footprint_words() const {
+  return (_num_slabs.get() * sizeof(Slab)) / BytesPerWord;
+}
+
+void ChunkHeaderPool::initialize() {
+  assert(_chunkHeaderPool == NULL, "only once");
+  _chunkHeaderPool = new ChunkHeaderPool();
+}
+
+#ifdef ASSERT
+void ChunkHeaderPool::verify() const {
+  const Slab* s = _first_slab;
+  int num = 0;
+  while (s != NULL) {
+    assert(s->_top >= 0 && s->_top <= SlabCapacity,
+           "invalid slab at " PTR_FORMAT ", top: %d, slab cap: %d",
+           p2i(s), s->_top, SlabCapacity );
+    s = s->_next;
+    num++;
+  }
+  _num_slabs.check(num);
+}
+#endif
+
+} // namespace metaspace
+

src/hotspot/share/memory/metaspace/chunkHeaderPool.hpp

@@ -0,0 +1,135 @@
+/*
+ * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2020 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
+ * 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.
+ *
+ */
+
+#ifndef SHARE_MEMORY_METASPACE_CHUNKHEADERPOOL_HPP
+#define SHARE_MEMORY_METASPACE_CHUNKHEADERPOOL_HPP
+
+#include "memory/allocation.hpp"
+#include "memory/metaspace/counters.hpp"
+#include "memory/metaspace/metachunk.hpp"
+#include "memory/metaspace/metachunkList.hpp"
+#include "utilities/debug.hpp"
+#include "utilities/globalDefinitions.hpp"
+
+namespace metaspace {
+
+// Chunk headers (Metachunk objects) are separate entities from their payload.
+//  Since they are allocated and released frequently in the course of buddy allocation
+//  (splitting, merging chunks happens often) we want allocation of them fast. Therefore
+//  we keep them in a simple pool (somewhat like a primitive slab allocator).
+
+class ChunkHeaderPool : public CHeapObj<mtMetaspace> {
+
+  static const int SlabCapacity = 128;
+
+  struct Slab : public CHeapObj<mtMetaspace> {
+    Slab* _next;
+    int _top;
+    Metachunk _elems [SlabCapacity];
+    Slab() : _next(NULL), _top(0) {
+      for (int i = 0; i < SlabCapacity; i++) {
+        _elems[i].clear();
+      }
+    }
+  };
+
+  IntCounter _num_slabs;
+  Slab* _first_slab;
+  Slab* _current_slab;
+
+  IntCounter _num_handed_out;
+
+  MetachunkList _freelist;
+
+  void allocate_new_slab();
+
+  static ChunkHeaderPool* _chunkHeaderPool;
+
+public:
+
+  ChunkHeaderPool();
+
+  ~ChunkHeaderPool();
+
+  // Allocates a Metachunk structure. The structure is uninitialized.
+  Metachunk* allocate_chunk_header() {
+    DEBUG_ONLY(verify());
+
+    Metachunk* c = NULL;
+    c = _freelist.remove_first();
+    assert(c == NULL || c->is_dead(), "Not a freelist chunk header?");
+    if (c == NULL) {
+      if (_current_slab == NULL ||
+          _current_slab->_top == SlabCapacity) {
+        allocate_new_slab();
+        assert(_current_slab->_top < SlabCapacity, "Sanity");
+      }
+      c = _current_slab->_elems + _current_slab->_top;
+      _current_slab->_top++;
+    }
+    _num_handed_out.increment();
+    // By contract, the returned structure is uninitialized.
+    // Zap to make this clear.
+    DEBUG_ONLY(c->zap_header(0xBB);)
+
+    return c;
+  }
+
+  void return_chunk_header(Metachunk* c) {
+    // We only ever should return free chunks, since returning chunks
+    // happens only on merging and merging only works with free chunks.
+    assert(c != NULL && c->is_free(), "Sanity");
+#ifdef ASSERT
+    // In debug, fill dead header with pattern.
+    c->zap_header(0xCC);
+    c->set_next(NULL);
+    c->set_prev(NULL);
+#endif
+    c->set_dead();
+    _freelist.add(c);
+    _num_handed_out.decrement();
+  }
+
+  // Returns number of allocated elements.
+  int used() const                   { return _num_handed_out.get(); }
+
+  // Returns number of elements in free list.
+  int freelist_size() const          { return _freelist.count(); }
+
+  // Returns size of memory used.
+  size_t memory_footprint_words() const;
+
+  DEBUG_ONLY(void verify() const;)
+
+  static void initialize();
+
+  // Returns reference to the one global chunk header pool.
+  static ChunkHeaderPool* pool() { return _chunkHeaderPool; }
+
+};
+
+} // namespace metaspace
+
+#endif // SHARE_MEMORY_METASPACE_CHUNKHEADERPOOL_HPP

src/hotspot/share/memory/metaspace/chunkManager.cpp

@@ -1,5 +1,6 @@
 /*
- * Copyright (c) 2018, 2019, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2018, 2020, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2018, 2020 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
@@ -21,622 +22,405 @@
  * questions.
  *
  */
-#include "precompiled.hpp"
 
+#include "precompiled.hpp"
 #include "logging/log.hpp"
 #include "logging/logStream.hpp"
-#include "memory/binaryTreeDictionary.inline.hpp"
-#include "memory/freeList.inline.hpp"
 #include "memory/metaspace/chunkManager.hpp"
+#include "memory/metaspace/internalStats.hpp"
 #include "memory/metaspace/metachunk.hpp"
-#include "memory/metaspace/metaDebug.hpp"
+#include "memory/metaspace/metaspaceArenaGrowthPolicy.hpp"
 #include "memory/metaspace/metaspaceCommon.hpp"
+#include "memory/metaspace/metaspaceContext.hpp"
+#include "memory/metaspace/metaspaceSettings.hpp"
 #include "memory/metaspace/metaspaceStatistics.hpp"
-#include "memory/metaspace/occupancyMap.hpp"
+#include "memory/metaspace/virtualSpaceList.hpp"
 #include "memory/metaspace/virtualSpaceNode.hpp"
 #include "runtime/mutexLocker.hpp"
 #include "utilities/debug.hpp"
 #include "utilities/globalDefinitions.hpp"
-#include "utilities/ostream.hpp"
 
 namespace metaspace {
 
-ChunkManager::ChunkManager(bool is_class)
+#define LOGFMT         "ChkMgr @" PTR_FORMAT " (%s)"
-      : _is_class(is_class), _free_chunks_total(0), _free_chunks_count(0) {
+#define LOGFMT_ARGS    p2i(this), this->_name
-  _free_chunks[SpecializedIndex].set_size(get_size_for_nonhumongous_chunktype(SpecializedIndex, is_class));
+
-  _free_chunks[SmallIndex].set_size(get_size_for_nonhumongous_chunktype(SmallIndex, is_class));
+// Return a single chunk to the freelist and adjust accounting. No merge is attempted.
-  _free_chunks[MediumIndex].set_size(get_size_for_nonhumongous_chunktype(MediumIndex, is_class));
+void ChunkManager::return_chunk_simple_locked(Metachunk* c) {
+  assert_lock_strong(MetaspaceExpand_lock);
+  DEBUG_ONLY(c->verify());
+  _chunks.add(c);
+  c->reset_used_words();
+  // Tracing
+  log_debug(metaspace)("ChunkManager %s: returned chunk " METACHUNK_FORMAT ".",
+                       _name, METACHUNK_FORMAT_ARGS(c));
 }
 
-void ChunkManager::remove_chunk(Metachunk* chunk) {
+// Creates a chunk manager with a given name (which is for debug purposes only)
-  size_t word_size = chunk->word_size();
+// and an associated space list which will be used to request new chunks from
-  ChunkIndex index = list_index(word_size);
+// (see get_chunk())
-  if (index != HumongousIndex) {
+ChunkManager::ChunkManager(const char* name, VirtualSpaceList* space_list) :
-    free_chunks(index)->remove_chunk(chunk);
+  _vslist(space_list),
+  _name(name),
+  _chunks()
+{
+}
+
+// Given a chunk, split it into a target chunk of a smaller size (higher target level)
+//  and at least one, possible several splinter chunks.
+// The original chunk must be outside of the freelist and its state must be free.
+// The splinter chunks are added to the freelist.
+// The resulting target chunk will be located at the same address as the original
+//  chunk, but it will of course be smaller (of a higher level).
+// The committed areas within the original chunk carry over to the resulting
+//  chunks.
+void ChunkManager::split_chunk_and_add_splinters(Metachunk* c, chunklevel_t target_level) {
+  assert_lock_strong(MetaspaceExpand_lock);
+  assert(c->is_free(), "chunk to be split must be free.");
+  assert(c->level() < target_level, "Target level must be higher than current level.");
+  assert(c->prev() == NULL && c->next() == NULL, "Chunk must be outside of any list.");
+
+  DEBUG_ONLY(chunklevel::check_valid_level(target_level);)
+  DEBUG_ONLY(c->verify();)
+
+  UL2(debug, "splitting chunk " METACHUNK_FORMAT " to " CHKLVL_FORMAT ".",
+      METACHUNK_FORMAT_ARGS(c), target_level);
+
+  DEBUG_ONLY(size_t committed_words_before = c->committed_words();)
+
+  const chunklevel_t orig_level = c->level();
+  c->vsnode()->split(target_level, c, &_chunks);
+
+  // Splitting should never fail.
+  assert(c->level() == target_level, "Sanity");
+
+  // The size of the committed portion should not change (subject to the reduced chunk size of course)
+#ifdef ASSERT
+  if (committed_words_before > c->word_size()) {
+    assert(c->is_fully_committed(), "Sanity");
   } else {
-    humongous_dictionary()->remove_chunk(chunk);
+    assert(c->committed_words() == committed_words_before, "Sanity");
   }
-
+  c->verify();
-  // Chunk has been removed from the chunks free list, update counters.
+  verify_locked();
-  account_for_removed_chunk(chunk);
+  SOMETIMES(c->vsnode()->verify_locked();)
-}
-
-bool ChunkManager::attempt_to_coalesce_around_chunk(Metachunk* chunk, ChunkIndex target_chunk_type) {
-  assert_lock_strong(MetaspaceExpand_lock);
-  assert(chunk != NULL, "invalid chunk pointer");
-  // Check for valid merge combinations.
-  assert((chunk->get_chunk_type() == SpecializedIndex &&
-          (target_chunk_type == SmallIndex || target_chunk_type == MediumIndex)) ||
-         (chunk->get_chunk_type() == SmallIndex && target_chunk_type == MediumIndex),
-        "Invalid chunk merge combination.");
-
-  const size_t target_chunk_word_size =
-    get_size_for_nonhumongous_chunktype(target_chunk_type, this->is_class());
-
-  // [ prospective merge region )
-  MetaWord* const p_merge_region_start =
-    (MetaWord*) align_down(chunk, target_chunk_word_size * sizeof(MetaWord));
-  MetaWord* const p_merge_region_end =
-    p_merge_region_start + target_chunk_word_size;
-
-  // We need the VirtualSpaceNode containing this chunk and its occupancy map.
-  VirtualSpaceNode* const vsn = chunk->container();
-  OccupancyMap* const ocmap = vsn->occupancy_map();
-
-  // The prospective chunk merge range must be completely contained by the
-  // committed range of the virtual space node.
-  if (p_merge_region_start < vsn->bottom() || p_merge_region_end > vsn->top()) {
-    return false;
-  }
-
-  // Only attempt to merge this range if at its start a chunk starts and at its end
-  // a chunk ends. If a chunk (can only be humongous) straddles either start or end
-  // of that range, we cannot merge.
-  if (!ocmap->chunk_starts_at_address(p_merge_region_start)) {
-    return false;
-  }
-  if (p_merge_region_end < vsn->top() &&
-      !ocmap->chunk_starts_at_address(p_merge_region_end)) {
-    return false;
-  }
-
-  // Now check if the prospective merge area contains live chunks. If it does we cannot merge.
-  if (ocmap->is_region_in_use(p_merge_region_start, target_chunk_word_size)) {
-    return false;
-  }
-
-  // Success! Remove all chunks in this region...
-  log_trace(gc, metaspace, freelist)("%s: coalescing chunks in area [%p-%p)...",
-    (is_class() ? "class space" : "metaspace"),
-    p_merge_region_start, p_merge_region_end);
-
-  const int num_chunks_removed =
-    remove_chunks_in_area(p_merge_region_start, target_chunk_word_size);
-
-  // ... and create a single new bigger chunk.
-  Metachunk* const p_new_chunk =
-      ::new (p_merge_region_start) Metachunk(target_chunk_type, is_class(), target_chunk_word_size, vsn);
-  assert(p_new_chunk == (Metachunk*)p_merge_region_start, "Sanity");
-  p_new_chunk->set_origin(origin_merge);
-
-  log_trace(gc, metaspace, freelist)("%s: created coalesced chunk at %p, size " SIZE_FORMAT_HEX ".",
-    (is_class() ? "class space" : "metaspace"),
-    p_new_chunk, p_new_chunk->word_size() * sizeof(MetaWord));
-
-  // Fix occupancy map: remove old start bits of the small chunks and set new start bit.
-  ocmap->wipe_chunk_start_bits_in_region(p_merge_region_start, target_chunk_word_size);
-  ocmap->set_chunk_starts_at_address(p_merge_region_start, true);
-
-  // Mark chunk as free. Note: it is not necessary to update the occupancy
-  // map in-use map, because the old chunks were also free, so nothing
-  // should have changed.
-  p_new_chunk->set_is_tagged_free(true);
-
-  // Add new chunk to its freelist.
-  ChunkList* const list = free_chunks(target_chunk_type);
-  list->return_chunk_at_head(p_new_chunk);
-
-  // And adjust ChunkManager:: _free_chunks_count (_free_chunks_total
-  // should not have changed, because the size of the space should be the same)
-  _free_chunks_count -= num_chunks_removed;
-  _free_chunks_count ++;
-
-  // VirtualSpaceNode::chunk_count does not have to be modified:
-  // it means "number of active (non-free) chunks", so merging free chunks
-  // should not affect that count.
-
-  // At the end of a chunk merge, run verification tests.
-#ifdef ASSERT
-
-  EVERY_NTH(VerifyMetaspaceInterval)
-    locked_verify(true);
-    vsn->verify(true);
-  END_EVERY_NTH
-
-  g_internal_statistics.num_chunk_merges ++;
-
 #endif
-
+  InternalStats::inc_num_chunk_splits();
-  return true;
 }
 
-// Remove all chunks in the given area - the chunks are supposed to be free -
+// On success, returns a chunk of level of <preferred_level>, but at most <max_level>.
-// from their corresponding freelists. Mark them as invalid.
+//  The first first <min_committed_words> of the chunk are guaranteed to be committed.
-// - This does not correct the occupancy map.
+// On error, will return NULL.
-// - This does not adjust the counters in ChunkManager.
+//
-// - Does not adjust container count counter in containing VirtualSpaceNode
+// This function may fail for two reasons:
-// Returns number of chunks removed.
+// - Either we are unable to reserve space for a new chunk (if the underlying VirtualSpaceList
-int ChunkManager::remove_chunks_in_area(MetaWord* p, size_t word_size) {
+//   is non-expandable but needs expanding - aka out of compressed class space).
-  assert(p != NULL && word_size > 0, "Invalid range.");
+// - Or, if the necessary space cannot be committed because we hit a commit limit.
-  const size_t smallest_chunk_size = get_size_for_nonhumongous_chunktype(SpecializedIndex, is_class());
+//   This may be either the GC threshold or MaxMetaspaceSize.
-  assert_is_aligned(word_size, smallest_chunk_size);
+Metachunk* ChunkManager::get_chunk(chunklevel_t preferred_level, chunklevel_t max_level, size_t min_committed_words) {
+  assert(preferred_level <= max_level, "Sanity");
+  assert(chunklevel::level_fitting_word_size(min_committed_words) >= max_level, "Sanity");
 
-  Metachunk* const start = (Metachunk*) p;
+  MutexLocker fcl(MetaspaceExpand_lock, Mutex::_no_safepoint_check_flag);
-  const Metachunk* const end = (Metachunk*)(p + word_size);
+
-  Metachunk* cur = start;
+  DEBUG_ONLY(verify_locked();)
-  int num_removed = 0;
+  DEBUG_ONLY(chunklevel::check_valid_level(max_level);)
-  while (cur < end) {
+  DEBUG_ONLY(chunklevel::check_valid_level(preferred_level);)
-    Metachunk* next = (Metachunk*)(((MetaWord*)cur) + cur->word_size());
+
-    DEBUG_ONLY(do_verify_chunk(cur));
+  UL2(debug, "requested chunk: pref_level: " CHKLVL_FORMAT
-    assert(cur->get_chunk_type() != HumongousIndex, "Unexpected humongous chunk found at %p.", cur);
+     ", max_level: " CHKLVL_FORMAT ", min committed size: " SIZE_FORMAT ".",
-    assert(cur->is_tagged_free(), "Chunk expected to be free (%p)", cur);
+     preferred_level, max_level, min_committed_words);
-    log_trace(gc, metaspace, freelist)("%s: removing chunk %p, size " SIZE_FORMAT_HEX ".",
+
-      (is_class() ? "class space" : "metaspace"),
+  // First, optimistically look for a chunk which is already committed far enough to hold min_word_size.
-      cur, cur->word_size() * sizeof(MetaWord));
+
-    cur->remove_sentinel();
+  // 1) Search best or smaller committed chunks (first attempt):
-    // Note: cannot call ChunkManager::remove_chunk, because that
+  //    Start at the preferred chunk size and work your way down (level up).
-    // modifies the counters in ChunkManager, which we do not want. So
+  //    But for now, only consider chunks larger than a certain threshold -
-    // we call remove_chunk on the freelist directly (see also the
+  //    this is to prevent large loaders (eg boot) from unnecessarily gobbling up
-    // splitting function which does the same).
+  //    all the tiny splinter chunks lambdas leave around.
-    ChunkList* const list = free_chunks(list_index(cur->word_size()));
+  Metachunk* c = NULL;
-    list->remove_chunk(cur);
+  c = _chunks.search_chunk_ascending(preferred_level, MIN2((chunklevel_t)(preferred_level + 2), max_level), min_committed_words);
-    num_removed ++;
+
-    cur = next;
+  // 2) Search larger committed chunks:
+  //    If that did not yield anything, look at larger chunks, which may be committed. We would have to split
+  //    them first, of course.
+  if (c == NULL) {
+    c = _chunks.search_chunk_descending(preferred_level, min_committed_words);
   }
-  return num_removed;
+  // 3) Search best or smaller committed chunks (second attempt):
+  //    Repeat (1) but now consider even the tiniest chunks as long as they are large enough to hold the
+  //    committed min size.
+  if (c == NULL) {
+    c = _chunks.search_chunk_ascending(preferred_level, max_level, min_committed_words);
+  }
+  // if we did not get anything yet, there are no free chunks commmitted enough. Repeat search but look for uncommitted chunks too:
+  // 4) Search best or smaller chunks, can be uncommitted:
+  if (c == NULL) {
+    c = _chunks.search_chunk_ascending(preferred_level, max_level, 0);
+  }
+  // 5) Search a larger uncommitted chunk:
+  if (c == NULL) {
+    c = _chunks.search_chunk_descending(preferred_level, 0);
+  }
+
+  if (c != NULL) {
+    UL(trace, "taken from freelist.");
+  }
+
+  // Failing all that, allocate a new root chunk from the connected virtual space.
+  // This may fail if the underlying vslist cannot be expanded (e.g. compressed class space)
+  if (c == NULL) {
+    c = _vslist->allocate_root_chunk();
+    if (c == NULL) {
+      UL(info, "failed to get new root chunk.");
+    } else {
+      assert(c->level() == chunklevel::ROOT_CHUNK_LEVEL, "root chunk expected");
+      UL(debug, "allocated new root chunk.");
+    }
+  }
+  if (c == NULL) {
+    // If we end up here, we found no match in the freelists and were unable to get a new
+    // root chunk (so we used up all address space, e.g. out of CompressedClassSpace).
+    UL2(info, "failed to get chunk (preferred level: " CHKLVL_FORMAT
+       ", max level " CHKLVL_FORMAT ".", preferred_level, max_level);
+    c = NULL;
+  }
+  if (c != NULL) {
+    // Now we have a chunk.
+    //  It may be larger than what the caller wanted, so we may want to split it. This should
+    //  always work.
+    if (c->level() < preferred_level) {
+      split_chunk_and_add_splinters(c, preferred_level);
+      assert(c->level() == preferred_level, "split failed?");
+    }
+    // Attempt to commit the chunk (depending on settings, we either fully commit it or just
+    //  commit enough to get the caller going). That may fail if we hit a commit limit. In
+    //  that case put the chunk back to the freelist (re-merging it with its neighbors if we
+    //  did split it) and return NULL.
+    const size_t to_commit = Settings::new_chunks_are_fully_committed() ? c->word_size() : min_committed_words;
+    if (c->committed_words() < to_commit) {
+      if (c->ensure_committed_locked(to_commit) == false) {
+        UL2(info, "failed to commit " SIZE_FORMAT " words on chunk " METACHUNK_FORMAT ".",
+            to_commit,  METACHUNK_FORMAT_ARGS(c));
+        return_chunk_locked(c);
+        c = NULL;
+      }
+    }
+    if (c != NULL) {
+      // Still here? We have now a good chunk, all is well.
+      assert(c->committed_words() >= min_committed_words, "Sanity");
+
+      // Any chunk returned from ChunkManager shall be marked as in use.
+      c->set_in_use();
+
+      UL2(debug, "handing out chunk " METACHUNK_FORMAT ".", METACHUNK_FORMAT_ARGS(c));
+
+      InternalStats::inc_num_chunks_taken_from_freelist();
+
+      SOMETIMES(c->vsnode()->verify_locked();)
+    }
+  }
+
+  DEBUG_ONLY(verify_locked();)
+  return c;
 }
 
-// Update internal accounting after a chunk was added
+// Return a single chunk to the ChunkManager and adjust accounting. May merge chunk
-void ChunkManager::account_for_added_chunk(const Metachunk* c) {
+//  with neighbors.
+// As a side effect this removes the chunk from whatever list it has been in previously.
+// Happens after a Classloader was unloaded and releases its metaspace chunks.
+// !! Note: this may invalidate the chunk. Do not access the chunk after
+//    this function returns !!
+void ChunkManager::return_chunk(Metachunk* c) {
+  MutexLocker fcl(MetaspaceExpand_lock, Mutex::_no_safepoint_check_flag);
+  return_chunk_locked(c);
+}
+
+// See return_chunk().
+void ChunkManager::return_chunk_locked(Metachunk* c) {
   assert_lock_strong(MetaspaceExpand_lock);
-  _free_chunks_count ++;
+  UL2(debug, ": returning chunk " METACHUNK_FORMAT ".", METACHUNK_FORMAT_ARGS(c));
-  _free_chunks_total += c->word_size();
+  DEBUG_ONLY(c->verify();)
+  assert(contains_chunk(c) == false, "A chunk to be added to the freelist must not be in the freelist already.");
+  assert(c->is_in_use() || c->is_free(), "Unexpected chunk state");
+  assert(!c->in_list(), "Remove from list first");
+
+  c->set_free();
+  c->reset_used_words();
+  const chunklevel_t orig_lvl = c->level();
+
+  Metachunk* merged = NULL;
+  if (!c->is_root_chunk()) {
+    // Only attempt merging if we are not of the lowest level already.
+    merged = c->vsnode()->merge(c, &_chunks);
+  }
+
+  if (merged != NULL) {
+    InternalStats::inc_num_chunk_merges();
+    DEBUG_ONLY(merged->verify());
+    // We did merge chunks and now have a bigger chunk.
+    assert(merged->level() < orig_lvl, "Sanity");
+    UL2(debug, "merged into chunk " METACHUNK_FORMAT ".", METACHUNK_FORMAT_ARGS(merged));
+    c = merged;
+  }
+
+  if (Settings::uncommit_free_chunks() &&
+      c->word_size() >= Settings::commit_granule_words()) {
+    UL2(debug, "uncommitting free chunk " METACHUNK_FORMAT ".", METACHUNK_FORMAT_ARGS(c));
+    c->uncommit_locked();
+  }
+
+  return_chunk_simple_locked(c);
+  DEBUG_ONLY(verify_locked();)
+  SOMETIMES(c->vsnode()->verify_locked();)
+  InternalStats::inc_num_chunks_returned_to_freelist();
 }
 
-// Update internal accounting after a chunk was removed
+// Given a chunk c, whose state must be "in-use" and must not be a root chunk, attempt to
-void ChunkManager::account_for_removed_chunk(const Metachunk* c) {
+// enlarge it in place by claiming its trailing buddy.
-  assert_lock_strong(MetaspaceExpand_lock);
+//
-  assert(_free_chunks_count >= 1,
+// This will only work if c is the leader of the buddy pair and the trailing buddy is free.
-    "ChunkManager::_free_chunks_count: about to go negative (" SIZE_FORMAT ").", _free_chunks_count);
+//
-  assert(_free_chunks_total >= c->word_size(),
+// If successful, the follower chunk will be removed from the freelists, the leader chunk c will
-    "ChunkManager::_free_chunks_total: about to go negative"
+// double in size (level decreased by one).
-     "(now: " SIZE_FORMAT ", decrement value: " SIZE_FORMAT ").", _free_chunks_total, c->word_size());
+//
-  _free_chunks_count --;
+// On success, true is returned, false otherwise.
-  _free_chunks_total -= c->word_size();
+bool ChunkManager::attempt_enlarge_chunk(Metachunk* c) {
+  MutexLocker fcl(MetaspaceExpand_lock, Mutex::_no_safepoint_check_flag);
+  return c->vsnode()->attempt_enlarge_chunk(c, &_chunks);
 }
 
-ChunkIndex ChunkManager::list_index(size_t size) {
+static void print_word_size_delta(outputStream* st, size_t word_size_1, size_t word_size_2) {
-  return get_chunk_type_by_size(size, is_class());
+  if (word_size_1 == word_size_2) {
+    print_scaled_words(st, word_size_1);
+    st->print (" (no change)");
+  } else {
+    print_scaled_words(st, word_size_1);
+    st->print("->");
+    print_scaled_words(st, word_size_2);
+    st->print(" (");
+    if (word_size_2 <= word_size_1) {
+      st->print("-");
+      print_scaled_words(st, word_size_1 - word_size_2);
+    } else {
+      st->print("+");
+      print_scaled_words(st, word_size_2 - word_size_1);
+    }
+    st->print(")");
+  }
 }
 
-size_t ChunkManager::size_by_index(ChunkIndex index) const {
+void ChunkManager::purge() {
-  index_bounds_check(index);
+  MutexLocker fcl(MetaspaceExpand_lock, Mutex::_no_safepoint_check_flag);
-  assert(index != HumongousIndex, "Do not call for humongous chunks.");
+  UL(info, ": reclaiming memory...");
-  return get_size_for_nonhumongous_chunktype(index, is_class());
-}
 
-#ifdef ASSERT
+  const size_t reserved_before = _vslist->reserved_words();
-void ChunkManager::verify(bool slow) const {
+  const size_t committed_before = _vslist->committed_words();
-  MutexLocker cl(MetaspaceExpand_lock,
+  int num_nodes_purged = 0;
-                     Mutex::_no_safepoint_check_flag);
-  locked_verify(slow);
-}
 
-void ChunkManager::locked_verify(bool slow) const {
+  // We purge to return unused memory to the Operating System. We do this in
-  log_trace(gc, metaspace, freelist)("verifying %s chunkmanager (%s).",
+  //  two independent steps.
-    (is_class() ? "class space" : "metaspace"), (slow ? "slow" : "quick"));
 
-  assert_lock_strong(MetaspaceExpand_lock);
+  // 1) We purge the virtual space list: any memory mappings which are
+  //   completely deserted can be potentially unmapped. We iterate over the list
+  //   of mappings (VirtualSpaceList::purge) and delete every node whose memory
+  //   only contains free chunks. Deleting that node includes unmapping its memory,
+  //   so all chunk vanish automatically.
+  //   Of course we need to remove the chunk headers of those vanished chunks from
+  //   the ChunkManager freelist.
+  num_nodes_purged = _vslist->purge(&_chunks);
+  InternalStats::inc_num_purges();
 
-  size_t chunks_counted = 0;
+  // 2) Since (1) is rather ineffective - it is rare that a whole node only contains
-  size_t wordsize_chunks_counted = 0;
+  //   free chunks - we now iterate over all remaining free chunks and
-  for (ChunkIndex i = ZeroIndex; i < NumberOfFreeLists; i = next_chunk_index(i)) {
+  //   and uncommit those which can be uncommitted (>= commit granule size).
-    const ChunkList* list = _free_chunks + i;
+  if (Settings::uncommit_free_chunks()) {
-    if (list != NULL) {
+    const chunklevel_t max_level =
-      Metachunk* chunk = list->head();
+        chunklevel::level_fitting_word_size(Settings::commit_granule_words());
-      while (chunk) {
+    for (chunklevel_t l = chunklevel::LOWEST_CHUNK_LEVEL;
-        if (slow) {
+         l <= max_level;
-          do_verify_chunk(chunk);
+         l++) {
-        }
+      // Since we uncommit all chunks at this level, we do not break the "committed chunks are
-        assert(chunk->is_tagged_free(), "Chunk should be tagged as free.");
+      //  at the front of the list" condition.
-        chunks_counted ++;
+      for (Metachunk* c = _chunks.first_at_level(l); c != NULL; c = c->next()) {
-        wordsize_chunks_counted += chunk->size();
+        c->uncommit_locked();
-        chunk = chunk->next();
       }
     }
   }
 
-  chunks_counted += humongous_dictionary()->total_free_blocks();
+  const size_t reserved_after = _vslist->reserved_words();
-  wordsize_chunks_counted += humongous_dictionary()->total_size();
+  const size_t committed_after = _vslist->committed_words();
 
-  assert(chunks_counted == _free_chunks_count && wordsize_chunks_counted == _free_chunks_total,
+  // Print a nice report.
-         "freelist accounting mismatch: "
+  if (reserved_after == reserved_before && committed_after == committed_before) {
-         "we think: " SIZE_FORMAT " chunks, total " SIZE_FORMAT " words, "
+    UL(info, "nothing reclaimed.");
-         "reality: " SIZE_FORMAT " chunks, total " SIZE_FORMAT " words.",
+  } else {
-         _free_chunks_count, _free_chunks_total,
+    LogTarget(Info, metaspace) lt;
-         chunks_counted, wordsize_chunks_counted);
+    if (lt.is_enabled()) {
+      LogStream ls(lt);
+      ls.print_cr(LOGFMT ": finished reclaiming memory: ", LOGFMT_ARGS);
+      ls.print("reserved: ");
+      print_word_size_delta(&ls, reserved_before, reserved_after);
+      ls.cr();
+      ls.print("committed: ");
+      print_word_size_delta(&ls, committed_before, committed_after);
+      ls.cr();
+      ls.print_cr("full nodes purged: %d", num_nodes_purged);
+    }
+  }
+  DEBUG_ONLY(_vslist->verify_locked());
+  DEBUG_ONLY(verify_locked());
 }
+
+// Convenience methods to return the global class-space chunkmanager
+//  and non-class chunkmanager, respectively.
+ChunkManager* ChunkManager::chunkmanager_class() {
+  return MetaspaceContext::context_class() == NULL ? NULL : MetaspaceContext::context_class()->cm();
+}
+
+ChunkManager* ChunkManager::chunkmanager_nonclass() {
+  return MetaspaceContext::context_nonclass() == NULL ? NULL : MetaspaceContext::context_nonclass()->cm();
+}
+
+// Update statistics.
+void ChunkManager::add_to_statistics(ChunkManagerStats* out) const {
+  MutexLocker fcl(MetaspaceExpand_lock, Mutex::_no_safepoint_check_flag);
+  for (chunklevel_t l = chunklevel::ROOT_CHUNK_LEVEL; l <= chunklevel::HIGHEST_CHUNK_LEVEL; l++) {
+    out->_num_chunks[l] += _chunks.num_chunks_at_level(l);
+    out->_committed_word_size[l] += _chunks.committed_word_size_at_level(l);
+  }
+  DEBUG_ONLY(out->verify();)
+}
+
+#ifdef ASSERT
+
+void ChunkManager::verify() const {
+  MutexLocker fcl(MetaspaceExpand_lock, Mutex::_no_safepoint_check_flag);
+  verify_locked();
+}
+
+void ChunkManager::verify_locked() const {
+  assert_lock_strong(MetaspaceExpand_lock);
+  assert(_vslist != NULL, "No vslist");
+  _chunks.verify();
+}
+
+bool ChunkManager::contains_chunk(Metachunk* c) const {
+  return _chunks.contains(c);
+}
+
 #endif // ASSERT
 
-void ChunkManager::locked_print_free_chunks(outputStream* st) {
+void ChunkManager::print_on(outputStream* st) const {
+  MutexLocker fcl(MetaspaceExpand_lock, Mutex::_no_safepoint_check_flag);
+  print_on_locked(st);
+}
+
+void ChunkManager::print_on_locked(outputStream* st) const {
   assert_lock_strong(MetaspaceExpand_lock);
-  st->print_cr("Free chunk total " SIZE_FORMAT "  count " SIZE_FORMAT,
+  st->print_cr("cm %s: %d chunks, total word size: " SIZE_FORMAT ", committed word size: " SIZE_FORMAT, _name,
-                _free_chunks_total, _free_chunks_count);
+               total_num_chunks(), total_word_size(), _chunks.committed_word_size());
-}
+  _chunks.print_on(st);
-
-ChunkList* ChunkManager::free_chunks(ChunkIndex index) {
-  assert(index == SpecializedIndex || index == SmallIndex || index == MediumIndex,
-         "Bad index: %d", (int)index);
-  return &_free_chunks[index];
-}
-
-ChunkList* ChunkManager::find_free_chunks_list(size_t word_size) {
-  ChunkIndex index = list_index(word_size);
-  assert(index < HumongousIndex, "No humongous list");
-  return free_chunks(index);
-}
-
-// Helper for chunk splitting: given a target chunk size and a larger free chunk,
-// split up the larger chunk into n smaller chunks, at least one of which should be
-// the target chunk of target chunk size. The smaller chunks, including the target
-// chunk, are returned to the freelist. The pointer to the target chunk is returned.
-// Note that this chunk is supposed to be removed from the freelist right away.
-Metachunk* ChunkManager::split_chunk(size_t target_chunk_word_size, Metachunk* larger_chunk) {
-  assert(larger_chunk->word_size() > target_chunk_word_size, "Sanity");
-
-  const ChunkIndex larger_chunk_index = larger_chunk->get_chunk_type();
-  const ChunkIndex target_chunk_index = get_chunk_type_by_size(target_chunk_word_size, is_class());
-
-  MetaWord* const region_start = (MetaWord*)larger_chunk;
-  const size_t region_word_len = larger_chunk->word_size();
-  MetaWord* const region_end = region_start + region_word_len;
-  VirtualSpaceNode* const vsn = larger_chunk->container();
-  OccupancyMap* const ocmap = vsn->occupancy_map();
-
-  // Any larger non-humongous chunk size is a multiple of any smaller chunk size.
-  // Since non-humongous chunks are aligned to their chunk size, the larger chunk should start
-  // at an address suitable to place the smaller target chunk.
-  assert_is_aligned(region_start, target_chunk_word_size);
-
-  // Remove old chunk.
-  free_chunks(larger_chunk_index)->remove_chunk(larger_chunk);
-  larger_chunk->remove_sentinel();
-
-  // Prevent access to the old chunk from here on.
-  larger_chunk = NULL;
-  // ... and wipe it.
-  DEBUG_ONLY(memset(region_start, 0xfe, region_word_len * BytesPerWord));
-
-  // In its place create first the target chunk...
-  MetaWord* p = region_start;
-  Metachunk* target_chunk = ::new (p) Metachunk(target_chunk_index, is_class(), target_chunk_word_size, vsn);
-  assert(target_chunk == (Metachunk*)p, "Sanity");
-  target_chunk->set_origin(origin_split);
-
-  // Note: we do not need to mark its start in the occupancy map
-  // because it coincides with the old chunk start.
-
-  // Mark chunk as free and return to the freelist.
-  do_update_in_use_info_for_chunk(target_chunk, false);
-  free_chunks(target_chunk_index)->return_chunk_at_head(target_chunk);
-
-  // This chunk should now be valid and can be verified.
-  DEBUG_ONLY(do_verify_chunk(target_chunk));
-
-  // In the remaining space create the remainder chunks.
-  p += target_chunk->word_size();
-  assert(p < region_end, "Sanity");
-
-  while (p < region_end) {
-
-    // Find the largest chunk size which fits the alignment requirements at address p.
-    ChunkIndex this_chunk_index = prev_chunk_index(larger_chunk_index);
-    size_t this_chunk_word_size = 0;
-    for(;;) {
-      this_chunk_word_size = get_size_for_nonhumongous_chunktype(this_chunk_index, is_class());
-      if (is_aligned(p, this_chunk_word_size * BytesPerWord)) {
-        break;
-      } else {
-        this_chunk_index = prev_chunk_index(this_chunk_index);
-        assert(this_chunk_index >= target_chunk_index, "Sanity");
-      }
-    }
-
-    assert(this_chunk_word_size >= target_chunk_word_size, "Sanity");
-    assert(is_aligned(p, this_chunk_word_size * BytesPerWord), "Sanity");
-    assert(p + this_chunk_word_size <= region_end, "Sanity");
-
-    // Create splitting chunk.
-    Metachunk* this_chunk = ::new (p) Metachunk(this_chunk_index, is_class(), this_chunk_word_size, vsn);
-    assert(this_chunk == (Metachunk*)p, "Sanity");
-    this_chunk->set_origin(origin_split);
-    ocmap->set_chunk_starts_at_address(p, true);
-    do_update_in_use_info_for_chunk(this_chunk, false);
-
-    // This chunk should be valid and can be verified.
-    DEBUG_ONLY(do_verify_chunk(this_chunk));
-
-    // Return this chunk to freelist and correct counter.
-    free_chunks(this_chunk_index)->return_chunk_at_head(this_chunk);
-    _free_chunks_count ++;
-
-    log_trace(gc, metaspace, freelist)("Created chunk at " PTR_FORMAT ", word size "
-      SIZE_FORMAT_HEX " (%s), in split region [" PTR_FORMAT "..." PTR_FORMAT ").",
-      p2i(this_chunk), this_chunk->word_size(), chunk_size_name(this_chunk_index),
-      p2i(region_start), p2i(region_end));
-
-    p += this_chunk_word_size;
-
-  }
-
-  // Note: at this point, the VirtualSpaceNode is invalid since we split a chunk and
-  // did not yet hand out part of that split; so, vsn->verify_free_chunks_are_ideally_merged()
-  // would assert. Instead, do all verifications in the caller.
-
-  DEBUG_ONLY(g_internal_statistics.num_chunk_splits ++);
-
-  return target_chunk;
-}
-
-Metachunk* ChunkManager::free_chunks_get(size_t word_size) {
-  assert_lock_strong(MetaspaceExpand_lock);
-
-  Metachunk* chunk = NULL;
-  bool we_did_split_a_chunk = false;
-
-  if (list_index(word_size) != HumongousIndex) {
-
-    ChunkList* free_list = find_free_chunks_list(word_size);
-    assert(free_list != NULL, "Sanity check");
-
-    chunk = free_list->head();
-
-    if (chunk == NULL) {
-      // Split large chunks into smaller chunks if there are no smaller chunks, just large chunks.
-      // This is the counterpart of the coalescing-upon-chunk-return.
-
-      ChunkIndex target_chunk_index = get_chunk_type_by_size(word_size, is_class());
-
-      // Is there a larger chunk we could split?
-      Metachunk* larger_chunk = NULL;
-      ChunkIndex larger_chunk_index = next_chunk_index(target_chunk_index);
-      while (larger_chunk == NULL && larger_chunk_index < NumberOfFreeLists) {
-        larger_chunk = free_chunks(larger_chunk_index)->head();
-        if (larger_chunk == NULL) {
-          larger_chunk_index = next_chunk_index(larger_chunk_index);
-        }
-      }
-
-      if (larger_chunk != NULL) {
-        assert(larger_chunk->word_size() > word_size, "Sanity");
-        assert(larger_chunk->get_chunk_type() == larger_chunk_index, "Sanity");
-
-        // We found a larger chunk. Lets split it up:
-        // - remove old chunk
-        // - in its place, create new smaller chunks, with at least one chunk
-        //   being of target size, the others sized as large as possible. This
-        //   is to make sure the resulting chunks are "as coalesced as possible"
-        //   (similar to VirtualSpaceNode::retire()).
-        // Note: during this operation both ChunkManager and VirtualSpaceNode
-        //  are temporarily invalid, so be careful with asserts.
-
-        log_trace(gc, metaspace, freelist)("%s: splitting chunk " PTR_FORMAT
-           ", word size " SIZE_FORMAT_HEX " (%s), to get a chunk of word size " SIZE_FORMAT_HEX " (%s)...",
-          (is_class() ? "class space" : "metaspace"), p2i(larger_chunk), larger_chunk->word_size(),
-          chunk_size_name(larger_chunk_index), word_size, chunk_size_name(target_chunk_index));
-
-        chunk = split_chunk(word_size, larger_chunk);
-
-        // This should have worked.
-        assert(chunk != NULL, "Sanity");
-        assert(chunk->word_size() == word_size, "Sanity");
-        assert(chunk->is_tagged_free(), "Sanity");
-
-        we_did_split_a_chunk = true;
-
-      }
-    }
-
-    if (chunk == NULL) {
-      return NULL;
-    }
-
-    // Remove the chunk as the head of the list.
-    free_list->remove_chunk(chunk);
-
-    log_trace(gc, metaspace, freelist)("ChunkManager::free_chunks_get: free_list: " PTR_FORMAT " chunks left: " SSIZE_FORMAT ".",
-                                       p2i(free_list), free_list->count());
-
-  } else {
-    chunk = humongous_dictionary()->get_chunk(word_size);
-
-    if (chunk == NULL) {
-      return NULL;
-    }
-
-    log_trace(gc, metaspace, alloc)("Free list allocate humongous chunk size " SIZE_FORMAT " for requested size " SIZE_FORMAT " waste " SIZE_FORMAT,
-                                    chunk->word_size(), word_size, chunk->word_size() - word_size);
-  }
-
-  // Chunk has been removed from the chunk manager; update counters.
-  account_for_removed_chunk(chunk);
-  do_update_in_use_info_for_chunk(chunk, true);
-  chunk->container()->inc_container_count();
-  chunk->inc_use_count();
-
-  // Remove it from the links to this freelist
-  chunk->set_next(NULL);
-  chunk->set_prev(NULL);
-
-  // Run some verifications (some more if we did a chunk split)
-#ifdef ASSERT
-
-  EVERY_NTH(VerifyMetaspaceInterval)
-    // Be extra verify-y when chunk split happened.
-    locked_verify(true);
-    VirtualSpaceNode* const vsn = chunk->container();
-    vsn->verify(true);
-    if (we_did_split_a_chunk) {
-      vsn->verify_free_chunks_are_ideally_merged();
-    }
-  END_EVERY_NTH
-
-  g_internal_statistics.num_chunks_removed_from_freelist ++;
-
-#endif
-
-  return chunk;
-}
-
-Metachunk* ChunkManager::chunk_freelist_allocate(size_t word_size) {
-  assert_lock_strong(MetaspaceExpand_lock);
-
-  // Take from the beginning of the list
-  Metachunk* chunk = free_chunks_get(word_size);
-  if (chunk == NULL) {
-    return NULL;
-  }
-
-  assert((word_size <= chunk->word_size()) ||
-         (list_index(chunk->word_size()) == HumongousIndex),
-         "Non-humongous variable sized chunk");
-  LogTarget(Trace, gc, metaspace, freelist) lt;
-  if (lt.is_enabled()) {
-    size_t list_count;
-    if (list_index(word_size) < HumongousIndex) {
-      ChunkList* list = find_free_chunks_list(word_size);
-      list_count = list->count();
-    } else {
-      list_count = humongous_dictionary()->total_count();
-    }
-    LogStream ls(lt);
-    ls.print("ChunkManager::chunk_freelist_allocate: " PTR_FORMAT " chunk " PTR_FORMAT "  size " SIZE_FORMAT " count " SIZE_FORMAT " ",
-             p2i(this), p2i(chunk), chunk->word_size(), list_count);
-    ResourceMark rm;
-    locked_print_free_chunks(&ls);
-  }
-
-  return chunk;
-}
-
-void ChunkManager::return_single_chunk(Metachunk* chunk) {
-
-#ifdef ASSERT
-  EVERY_NTH(VerifyMetaspaceInterval)
-    this->locked_verify(false);
-    do_verify_chunk(chunk);
-  END_EVERY_NTH
-#endif
-
-  const ChunkIndex index = chunk->get_chunk_type();
-  assert_lock_strong(MetaspaceExpand_lock);
-  DEBUG_ONLY(g_internal_statistics.num_chunks_added_to_freelist ++;)
-  assert(chunk != NULL, "Expected chunk.");
-  assert(chunk->container() != NULL, "Container should have been set.");
-  assert(chunk->is_tagged_free() == false, "Chunk should be in use.");
-  index_bounds_check(index);
-
-  // Note: mangle *before* returning the chunk to the freelist or dictionary. It does not
-  // matter for the freelist (non-humongous chunks), but the humongous chunk dictionary
-  // keeps tree node pointers in the chunk payload area which mangle will overwrite.
-  DEBUG_ONLY(chunk->mangle(badMetaWordVal);)
-
-  // may need node for verification later after chunk may have been merged away.
-  DEBUG_ONLY(VirtualSpaceNode* vsn = chunk->container(); )
-
-  if (index != HumongousIndex) {
-    // Return non-humongous chunk to freelist.
-    ChunkList* list = free_chunks(index);
-    assert(list->size() == chunk->word_size(), "Wrong chunk type.");
-    list->return_chunk_at_head(chunk);
-    log_trace(gc, metaspace, freelist)("returned one %s chunk at " PTR_FORMAT " to freelist.",
-        chunk_size_name(index), p2i(chunk));
-  } else {
-    // Return humongous chunk to dictionary.
-    assert(chunk->word_size() > free_chunks(MediumIndex)->size(), "Wrong chunk type.");
-    assert(chunk->word_size() % free_chunks(SpecializedIndex)->size() == 0,
-           "Humongous chunk has wrong alignment.");
-    _humongous_dictionary.return_chunk(chunk);
-    log_trace(gc, metaspace, freelist)("returned one %s chunk at " PTR_FORMAT " (word size " SIZE_FORMAT ") to freelist.",
-        chunk_size_name(index), p2i(chunk), chunk->word_size());
-  }
-  chunk->container()->dec_container_count();
-  do_update_in_use_info_for_chunk(chunk, false);
-
-  // Chunk has been added; update counters.
-  account_for_added_chunk(chunk);
-
-  // Attempt coalesce returned chunks with its neighboring chunks:
-  // if this chunk is small or special, attempt to coalesce to a medium chunk.
-  if (index == SmallIndex || index == SpecializedIndex) {
-    if (!attempt_to_coalesce_around_chunk(chunk, MediumIndex)) {
-      // This did not work. But if this chunk is special, we still may form a small chunk?
-      if (index == SpecializedIndex) {
-        if (!attempt_to_coalesce_around_chunk(chunk, SmallIndex)) {
-          // give up.
-        }
-      }
-    }
-  }
-
-  // From here on do not access chunk anymore, it may have been merged with another chunk.
-
-#ifdef ASSERT
-  EVERY_NTH(VerifyMetaspaceInterval)
-    this->locked_verify(true);
-    vsn->verify(true);
-    vsn->verify_free_chunks_are_ideally_merged();
-  END_EVERY_NTH
-#endif
-
-}
-
-void ChunkManager::return_chunk_list(Metachunk* chunks) {
-  if (chunks == NULL) {
-    return;
-  }
-  LogTarget(Trace, gc, metaspace, freelist) log;
-  if (log.is_enabled()) { // tracing
-    log.print("returning list of chunks...");
-  }
-  unsigned num_chunks_returned = 0;
-  size_t size_chunks_returned = 0;
-  Metachunk* cur = chunks;
-  while (cur != NULL) {
-    // Capture the next link before it is changed
-    // by the call to return_chunk_at_head();
-    Metachunk* next = cur->next();
-    if (log.is_enabled()) { // tracing
-      num_chunks_returned ++;
-      size_chunks_returned += cur->word_size();
-    }
-    return_single_chunk(cur);
-    cur = next;
-  }
-  if (log.is_enabled()) { // tracing
-    log.print("returned %u chunks to freelist, total word size " SIZE_FORMAT ".",
-        num_chunks_returned, size_chunks_returned);
-  }
-}
-
-void ChunkManager::collect_statistics(ChunkManagerStatistics* out) const {
-  MutexLocker cl(MetaspaceExpand_lock, Mutex::_no_safepoint_check_flag);
-  for (ChunkIndex i = ZeroIndex; i < NumberOfInUseLists; i = next_chunk_index(i)) {
-    out->chunk_stats(i).add(num_free_chunks(i), size_free_chunks_in_bytes(i) / sizeof(MetaWord));
-  }
 }
 
 } // namespace metaspace
-
-
-

src/hotspot/share/memory/metaspace/chunkManager.hpp

@@ -1,5 +1,6 @@
 /*
- * Copyright (c) 2018, 2019, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2018, 2020, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2018, 2020 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
@@ -26,173 +27,162 @@
 #define SHARE_MEMORY_METASPACE_CHUNKMANAGER_HPP
 
 #include "memory/allocation.hpp"
-#include "memory/binaryTreeDictionary.hpp"
+#include "memory/metaspace/chunklevel.hpp"
-#include "memory/freeList.hpp"
+#include "memory/metaspace/counters.hpp"
+#include "memory/metaspace/freeChunkList.hpp"
 #include "memory/metaspace/metachunk.hpp"
-#include "memory/metaspace/metaspaceStatistics.hpp"
-#include "memory/metaspaceChunkFreeListSummary.hpp"
-#include "utilities/globalDefinitions.hpp"
-
-class ChunkManagerTestAccessor;
 
 namespace metaspace {
 
-typedef class FreeList<Metachunk> ChunkList;
+class VirtualSpaceList;
-typedef BinaryTreeDictionary<Metachunk, FreeList<Metachunk> > ChunkTreeDictionary;
+struct ChunkManagerStats;
 
-// Manages the global free lists of chunks.
+// ChunkManager has a somewhat central role.
-class ChunkManager : public CHeapObj<mtInternal> {
-  friend class ::ChunkManagerTestAccessor;
 
-  // Free list of chunks of different sizes.
+// Arenas request chunks from it and, on death, return chunks back to it.
-  //   SpecializedChunk
+//  It keeps freelists for chunks, one per chunk level, sorted by chunk
-  //   SmallChunk
+//  commit state.
-  //   MediumChunk
+//  To feed the freelists, it allocates root chunks from the associated
-  ChunkList _free_chunks[NumberOfFreeLists];
+//  VirtualSpace below it.
+//
+// ChunkManager directs splitting chunks, if a chunk request cannot be
+//  fulfilled directly. It also takes care of merging when chunks are
+//  returned to it, before they are added to the freelist.
+//
+// The freelists are double linked double headed; fully committed chunks
+//  are added to the front, others to the back.
+//
+// Level
+//          +--------------------+   +--------------------+
+//  0  +----|  free root chunk   |---|  free root chunk   |---...
+//     |    +--------------------+   +--------------------+
+//     |
+//     |    +----------+   +----------+
+//  1  +----|          |---|          |---...
+//     |    +----------+   +----------+
+//     |
+//  .
+//  .
+//  .
+//
+//     |    +-+   +-+
+//  12 +----| |---| |---...
+//          +-+   +-+
 
-  // Whether or not this is the class chunkmanager.
+class ChunkManager : public CHeapObj<mtMetaspace> {
-  const bool _is_class;
 
-  // Return non-humongous chunk list by its index.
+  // A chunk manager is connected to a virtual space list which is used
-  ChunkList* free_chunks(ChunkIndex index);
+  // to allocate new root chunks when no free chunks are found.
+  VirtualSpaceList* const _vslist;
 
-  // Returns non-humongous chunk list for the given chunk word size.
+  // Name
-  ChunkList* find_free_chunks_list(size_t word_size);
+  const char* const _name;
 
-  //   HumongousChunk
+  // Freelists
-  ChunkTreeDictionary _humongous_dictionary;
+  FreeChunkListVector _chunks;
 
-  // Returns the humongous chunk dictionary.
+  // Returns true if this manager contains the given chunk. Slow (walks free lists) and
-  ChunkTreeDictionary* humongous_dictionary() { return &_humongous_dictionary; }
+  // only needed for verifications.
-  const ChunkTreeDictionary* humongous_dictionary() const { return &_humongous_dictionary; }
+  DEBUG_ONLY(bool contains_chunk(Metachunk* c) const;)
 
-  // Size, in metaspace words, of all chunks managed by this ChunkManager
+  // Given a chunk, split it into a target chunk of a smaller size (target level)
-  size_t _free_chunks_total;
+  //  at least one, possible more splinter chunks. Splinter chunks are added to the
-  // Number of chunks in this ChunkManager
+  //  freelist.
-  size_t _free_chunks_count;
+  // The original chunk must be outside of the freelist and its state must be free.
+  // The resulting target chunk will be located at the same address as the original
+  //  chunk, but it will of course be smaller (of a higher level).
+  // The committed areas within the original chunk carry over to the resulting
+  //  chunks.
+  void split_chunk_and_add_splinters(Metachunk* c, chunklevel_t target_level);
 
-  // Update counters after a chunk was added or removed removed.
+  // See get_chunk(s,s,s)
-  void account_for_added_chunk(const Metachunk* c);
+  Metachunk* get_chunk_locked(size_t preferred_word_size, size_t min_word_size, size_t min_committed_words);
-  void account_for_removed_chunk(const Metachunk* c);
 
-  // Given a pointer to a chunk, attempts to merge it with neighboring
+  // Uncommit all chunks equal or below the given level.
-  // free chunks to form a bigger chunk. Returns true if successful.
+  void uncommit_free_chunks(chunklevel_t max_level);
-  bool attempt_to_coalesce_around_chunk(Metachunk* chunk, ChunkIndex target_chunk_type);
 
-  // Helper for chunk merging:
+  // Return a single chunk to the freelist without doing any merging, and adjust accounting.
-  //  Given an address range with 1-n chunks which are all supposed to be
+  void return_chunk_simple_locked(Metachunk* c);
-  //  free and hence currently managed by this ChunkManager, remove them
-  //  from this ChunkManager and mark them as invalid.
-  // - This does not correct the occupancy map.
-  // - This does not adjust the counters in ChunkManager.
-  // - Does not adjust container count counter in containing VirtualSpaceNode.
-  // Returns number of chunks removed.
-  int remove_chunks_in_area(MetaWord* p, size_t word_size);
 
-  // Helper for chunk splitting: given a target chunk size and a larger free chunk,
+  // See return_chunk().
-  // split up the larger chunk into n smaller chunks, at least one of which should be
+  void return_chunk_locked(Metachunk* c);
-  // the target chunk of target chunk size. The smaller chunks, including the target
-  // chunk, are returned to the freelist. The pointer to the target chunk is returned.
-  // Note that this chunk is supposed to be removed from the freelist right away.
-  Metachunk* split_chunk(size_t target_chunk_word_size, Metachunk* chunk);
 
- public:
+public:
 
-  ChunkManager(bool is_class);
+  // Creates a chunk manager with a given name (which is for debug purposes only)
+  // and an associated space list which will be used to request new chunks from
+  // (see get_chunk())
+  ChunkManager(const char* name, VirtualSpaceList* space_list);
 
-  // Add or delete (return) a chunk to the global freelist.
+  // On success, returns a chunk of level of <preferred_level>, but at most <max_level>.
-  Metachunk* chunk_freelist_allocate(size_t word_size);
+  //  The first <min_committed_words> of the chunk are guaranteed to be committed.
+  // On error, will return NULL.
+  //
+  // This function may fail for two reasons:
+  // - Either we are unable to reserve space for a new chunk (if the underlying VirtualSpaceList
+  //   is non-expandable but needs expanding - aka out of compressed class space).
+  // - Or, if the necessary space cannot be committed because we hit a commit limit.
+  //   This may be either the GC threshold or MaxMetaspaceSize.
+  Metachunk* get_chunk(chunklevel_t preferred_level, chunklevel_t max_level, size_t min_committed_words);
 
-  // Map a size to a list index assuming that there are lists
+  // Convenience function - get a chunk of a given level, uncommitted.
-  // for special, small, medium, and humongous chunks.
+  Metachunk* get_chunk(chunklevel_t lvl) { return get_chunk(lvl, lvl, 0); }
-  ChunkIndex list_index(size_t size);
 
-  // Map a given index to the chunk size.
+  // Return a single chunk to the ChunkManager and adjust accounting. May merge chunk
-  size_t size_by_index(ChunkIndex index) const;
+  //  with neighbors.
+  // Happens after a Classloader was unloaded and releases its metaspace chunks.
+  // !! Notes:
+  //    1) After this method returns, c may not be valid anymore. ** Do not access c after this function returns **.
+  //    2) This function will not remove c from its current chunk list. This has to be done by the caller prior to
+  //       calling this method.
+  void return_chunk(Metachunk* c);
 
-  bool is_class() const { return _is_class; }
+  // Given a chunk c, which must be "in use" and must not be a root chunk, attempt to
+  // enlarge it in place by claiming its trailing buddy.
+  //
+  // This will only work if c is the leader of the buddy pair and the trailing buddy is free.
+  //
+  // If successful, the follower chunk will be removed from the freelists, the leader chunk c will
+  // double in size (level decreased by one).
+  //
+  // On success, true is returned, false otherwise.
+  bool attempt_enlarge_chunk(Metachunk* c);
 
-  // Convenience accessors.
+  // Attempt to reclaim free areas in metaspace wholesale:
-  size_t medium_chunk_word_size() const { return size_by_index(MediumIndex); }
+  // - first, attempt to purge nodes of the backing virtual space list: nodes which are completely
-  size_t small_chunk_word_size() const { return size_by_index(SmallIndex); }
+  //   unused get unmapped and deleted completely.
-  size_t specialized_chunk_word_size() const { return size_by_index(SpecializedIndex); }
+  // - second, it will uncommit free chunks depending on commit granule size.
+  void purge();
 
-  // Take a chunk from the ChunkManager. The chunk is expected to be in
+  // Run verifications. slow=true: verify chunk-internal integrity too.
-  // the chunk manager (the freelist if non-humongous, the dictionary if
+  DEBUG_ONLY(void verify() const;)
-  // humongous).
+  DEBUG_ONLY(void verify_locked() const;)
-  void remove_chunk(Metachunk* chunk);
 
-  // Return a single chunk of type index to the ChunkManager.
+  // Returns the name of this chunk manager.
-  void return_single_chunk(Metachunk* chunk);
+  const char* name() const                  { return _name; }
 
-  // Add the simple linked list of chunks to the freelist of chunks
+  // Returns total number of chunks
-  // of type index.
+  int total_num_chunks() const              { return _chunks.num_chunks(); }
-  void return_chunk_list(Metachunk* chunk);
 
-  // Total of the space in the free chunks list
+  // Returns number of words in all free chunks (regardless of commit state).
-  size_t free_chunks_total_words() const { return _free_chunks_total; }
+  size_t total_word_size() const            { return _chunks.word_size(); }
-  size_t free_chunks_total_bytes() const { return free_chunks_total_words() * BytesPerWord; }
 
-  // Number of chunks in the free chunks list
+  // Returns number of committed words in all free chunks.
-  size_t free_chunks_count() const { return _free_chunks_count; }
+  size_t total_committed_word_size() const  { return _chunks.committed_word_size(); }
 
-  // Remove from a list by size.  Selects list based on size of chunk.
+  // Update statistics.
-  Metachunk* free_chunks_get(size_t chunk_word_size);
+  void add_to_statistics(ChunkManagerStats* out) const;
 
-#define index_bounds_check(index)                                         \
+  void print_on(outputStream* st) const;
-  assert(is_valid_chunktype(index), "Bad index: %d", (int) index)
+  void print_on_locked(outputStream* st) const;
 
-  size_t num_free_chunks(ChunkIndex index) const {
+  // Convenience methods to return the global class-space chunkmanager
-    index_bounds_check(index);
+  //  and non-class chunkmanager, respectively.
-
+  static ChunkManager* chunkmanager_class();
-    if (index == HumongousIndex) {
+  static ChunkManager* chunkmanager_nonclass();
-      return _humongous_dictionary.total_free_blocks();
-    }
-
-    ssize_t count = _free_chunks[index].count();
-    return count == -1 ? 0 : (size_t) count;
-  }
-
-  size_t size_free_chunks_in_bytes(ChunkIndex index) const {
-    index_bounds_check(index);
-
-    size_t word_size = 0;
-    if (index == HumongousIndex) {
-      word_size = _humongous_dictionary.total_size();
-    } else {
-      const size_t size_per_chunk_in_words = _free_chunks[index].size();
-      word_size = size_per_chunk_in_words * num_free_chunks(index);
-    }
-
-    return word_size * BytesPerWord;
-  }
-
-  MetaspaceChunkFreeListSummary chunk_free_list_summary() const {
-    return MetaspaceChunkFreeListSummary(num_free_chunks(SpecializedIndex),
-                                         num_free_chunks(SmallIndex),
-                                         num_free_chunks(MediumIndex),
-                                         num_free_chunks(HumongousIndex),
-                                         size_free_chunks_in_bytes(SpecializedIndex),
-                                         size_free_chunks_in_bytes(SmallIndex),
-                                         size_free_chunks_in_bytes(MediumIndex),
-                                         size_free_chunks_in_bytes(HumongousIndex));
-  }
-
-#ifdef ASSERT
-  // Debug support
-  // Verify free list integrity. slow=true: verify chunk-internal integrity too.
-  void verify(bool slow) const;
-  void locked_verify(bool slow) const;
-#endif
-
-  void locked_print_free_chunks(outputStream* st);
-
-  // Fill in current statistic values to the given statistics object.
-  void collect_statistics(ChunkManagerStatistics* out) const;
 
 };
 
 } // namespace metaspace
 
-
 #endif // SHARE_MEMORY_METASPACE_CHUNKMANAGER_HPP

src/hotspot/share/memory/metaspace/chunklevel.cpp

@@ -1,5 +1,6 @@
 /*
- * Copyright (c) 2018, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2020 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
@@ -23,41 +24,39 @@
  */
 
 #include "precompiled.hpp"
-#include "logging/log.hpp"
+#include "memory/metaspace/chunklevel.hpp"
-#include "memory/metaspace/metaDebug.hpp"
-#include "runtime/os.hpp"
-#include "runtime/thread.hpp"
 #include "utilities/debug.hpp"
 #include "utilities/globalDefinitions.hpp"
+#include "utilities/ostream.hpp"
+#include "utilities/powerOfTwo.hpp"
 
 namespace metaspace {
 
-int Metadebug::_allocation_fail_alot_count = 0;
+using namespace chunklevel;
 
-void Metadebug::init_allocation_fail_alot_count() {
+chunklevel_t chunklevel::level_fitting_word_size(size_t word_size) {
-  if (MetadataAllocationFailALot) {
+  assert(MAX_CHUNK_WORD_SIZE >= word_size,
-    _allocation_fail_alot_count =
+         SIZE_FORMAT " - too large allocation size.", word_size * BytesPerWord);
-      1+(long)((double)MetadataAllocationFailALotInterval*os::random()/(max_jint+1.0));
+  if (word_size <= MIN_CHUNK_WORD_SIZE) {
+    return HIGHEST_CHUNK_LEVEL;
   }
+  const size_t v_pow2 = round_up_power_of_2(word_size);
+  const chunklevel_t lvl =  (chunklevel_t)(exact_log2(MAX_CHUNK_WORD_SIZE) - exact_log2(v_pow2));
+  return lvl;
 }
 
-#ifdef ASSERT
+void chunklevel::print_chunk_size(outputStream* st, chunklevel_t lvl) {
-bool Metadebug::test_metadata_failure() {
+  if (chunklevel::is_valid_level(lvl)) {
-  if (MetadataAllocationFailALot &&
+    const size_t s = chunklevel::word_size_for_level(lvl) * BytesPerWord;
-      Threads::is_vm_complete()) {
+    if (s < 1 * M) {
-    if (_allocation_fail_alot_count > 0) {
+      st->print("%3uk", (unsigned)(s / K));
-      _allocation_fail_alot_count--;
     } else {
-      log_trace(gc, metaspace, freelist)("Metadata allocation failing for MetadataAllocationFailALot");
+      st->print("%3um", (unsigned)(s / M));
-      init_allocation_fail_alot_count();
-      return true;
     }
+  } else {
+    st->print("?-?");
   }
-  return false;
 }
-#endif
-
 
 } // namespace metaspace
 
-

src/hotspot/share/memory/metaspace/chunklevel.hpp

@@ -0,0 +1,130 @@
+/*
+ * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2020 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
+ * 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.
+ *
+ */
+
+#ifndef SHARE_MEMORY_METASPACE_CHUNKLEVEL_HPP
+#define SHARE_MEMORY_METASPACE_CHUNKLEVEL_HPP
+
+#include "utilities/globalDefinitions.hpp"
+
+// Constants for the chunk levels and some utility functions.
+
+class outputStream;
+
+namespace metaspace {
+
+// Chunks are managed by a binary buddy allocator.
+
+// Chunk sizes range from 1K to 4MB (64bit).
+//
+
+// Each chunk has a level; the level corresponds to its position in the tree
+// and describes its size.
+//
+// The largest chunks are called root chunks, of 4MB in size, and have level 0.
+// From there on it goes:
+//
+// size    level
+// 4MB     0
+// 2MB     1
+// 1MB     2
+// 512K    3
+// 256K    4
+// 128K    5
+// 64K     6
+// 32K     7
+// 16K     8
+// 8K      9
+// 4K      10
+// 2K      11
+// 1K      12
+
+// Metachunk level (must be signed)
+typedef signed char chunklevel_t;
+
+#define CHKLVL_FORMAT "lv%.2d"
+
+namespace chunklevel {
+
+static const size_t   MAX_CHUNK_BYTE_SIZE    = 4 * M;
+static const int      NUM_CHUNK_LEVELS       = 13;
+static const size_t   MIN_CHUNK_BYTE_SIZE    = (MAX_CHUNK_BYTE_SIZE >> ((size_t)NUM_CHUNK_LEVELS - 1));
+
+static const size_t   MIN_CHUNK_WORD_SIZE    = MIN_CHUNK_BYTE_SIZE / sizeof(MetaWord);
+static const size_t   MAX_CHUNK_WORD_SIZE    = MAX_CHUNK_BYTE_SIZE / sizeof(MetaWord);
+
+static const chunklevel_t ROOT_CHUNK_LEVEL       = 0;
+
+static const chunklevel_t HIGHEST_CHUNK_LEVEL    = NUM_CHUNK_LEVELS - 1;
+static const chunklevel_t LOWEST_CHUNK_LEVEL     = 0;
+
+static const chunklevel_t INVALID_CHUNK_LEVEL    = (chunklevel_t) -1;
+
+inline bool is_valid_level(chunklevel_t level) {
+  return level >= LOWEST_CHUNK_LEVEL &&
+         level <= HIGHEST_CHUNK_LEVEL;
+}
+
+inline void check_valid_level(chunklevel_t lvl) {
+  assert(is_valid_level(lvl), "invalid level (%d)", (int)lvl);
+}
+
+// Given a level return the chunk size, in words.
+inline size_t word_size_for_level(chunklevel_t level) {
+  return (MAX_CHUNK_BYTE_SIZE >> level) / BytesPerWord;
+}
+
+// Given an arbitrary word size smaller than the highest chunk size,
+// return the highest chunk level able to hold this size.
+// Returns INVALID_CHUNK_LEVEL if no fitting level can be found.
+chunklevel_t level_fitting_word_size(size_t word_size);
+
+// Shorthands to refer to exact sizes
+static const chunklevel_t CHUNK_LEVEL_4M =     ROOT_CHUNK_LEVEL;
+static const chunklevel_t CHUNK_LEVEL_2M =    (ROOT_CHUNK_LEVEL + 1);
+static const chunklevel_t CHUNK_LEVEL_1M =    (ROOT_CHUNK_LEVEL + 2);
+static const chunklevel_t CHUNK_LEVEL_512K =  (ROOT_CHUNK_LEVEL + 3);
+static const chunklevel_t CHUNK_LEVEL_256K =  (ROOT_CHUNK_LEVEL + 4);
+static const chunklevel_t CHUNK_LEVEL_128K =  (ROOT_CHUNK_LEVEL + 5);
+static const chunklevel_t CHUNK_LEVEL_64K =   (ROOT_CHUNK_LEVEL + 6);
+static const chunklevel_t CHUNK_LEVEL_32K =   (ROOT_CHUNK_LEVEL + 7);
+static const chunklevel_t CHUNK_LEVEL_16K =   (ROOT_CHUNK_LEVEL + 8);
+static const chunklevel_t CHUNK_LEVEL_8K =    (ROOT_CHUNK_LEVEL + 9);
+static const chunklevel_t CHUNK_LEVEL_4K =    (ROOT_CHUNK_LEVEL + 10);
+static const chunklevel_t CHUNK_LEVEL_2K =    (ROOT_CHUNK_LEVEL + 11);
+static const chunklevel_t CHUNK_LEVEL_1K =    (ROOT_CHUNK_LEVEL + 12);
+
+STATIC_ASSERT(CHUNK_LEVEL_1K == HIGHEST_CHUNK_LEVEL);
+STATIC_ASSERT(CHUNK_LEVEL_4M == LOWEST_CHUNK_LEVEL);
+STATIC_ASSERT(ROOT_CHUNK_LEVEL == LOWEST_CHUNK_LEVEL);
+
+/////////////////////////////////////////////////////////
+// print helpers
+void print_chunk_size(outputStream* st, chunklevel_t lvl);
+
+} // namespace chunklevel
+
+} // namespace metaspace
+
+#endif // SHARE_MEMORY_METASPACE_CHUNKLEVEL_HPP

src/hotspot/share/memory/metaspace/commitLimiter.cpp

@@ -1,5 +1,6 @@
 /*
- * Copyright (c) 2018, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2020 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
@@ -21,41 +22,34 @@
  * questions.
  *
  */
-#include "precompiled.hpp"
 
-#include "memory/metaspace/smallBlocks.hpp"
+#include "precompiled.hpp"
+#include "memory/metaspace.hpp"
+#include "memory/metaspace/commitLimiter.hpp"
+#include "utilities/debug.hpp"
 #include "utilities/globalDefinitions.hpp"
-#include "utilities/ostream.hpp"
 
 namespace metaspace {
 
-void SmallBlocks::print_on(outputStream* st) const {
+// Returns the size, in words, by which we may expand the metaspace committed area without:
-  st->print_cr("SmallBlocks:");
+// - _cap == 0: hitting GC threshold or the MaxMetaspaceSize
-  for (uint i = _small_block_min_size; i < _small_block_max_size; i++) {
+// - _cap > 0: hitting cap (this is just for testing purposes)
-    uint k = i - _small_block_min_size;
+size_t CommitLimiter::possible_expansion_words() const {
-    st->print_cr("small_lists size " SIZE_FORMAT " count " SIZE_FORMAT, _small_lists[k].size(), _small_lists[k].count());
+  if (_cap > 0) { // Testing.
+    assert(_cnt.get() <= _cap, "Beyond limit?");
+    return _cap - _cnt.get();
   }
+  assert(_cnt.get() * BytesPerWord <= MaxMetaspaceSize, "Beyond limit?");
+  const size_t words_left_below_max = MaxMetaspaceSize / BytesPerWord - _cnt.get();
+  const size_t words_left_below_gc_threshold = MetaspaceGC::allowed_expansion();
+  return MIN2(words_left_below_max, words_left_below_gc_threshold);
 }
 
+static CommitLimiter g_global_limiter(0);
 
-// Returns the total size, in words, of all blocks, across all block sizes.
+// Returns the global metaspace commit counter
-size_t SmallBlocks::total_size() const {
+CommitLimiter* CommitLimiter::globalLimiter() {
-  size_t result = 0;
+  return &g_global_limiter;
-  for (uint i = _small_block_min_size; i < _small_block_max_size; i++) {
-    uint k = i - _small_block_min_size;
-    result = result + _small_lists[k].count() * _small_lists[k].size();
-  }
-  return result;
-}
-
-// Returns the total number of all blocks across all block sizes.
-uintx SmallBlocks::total_num_blocks() const {
-  uintx result = 0;
-  for (uint i = _small_block_min_size; i < _small_block_max_size; i++) {
-    uint k = i - _small_block_min_size;
-    result = result + _small_lists[k].count();
-  }
-  return result;
 }
 
 } // namespace metaspace

src/hotspot/share/memory/metaspace/commitLimiter.hpp

@@ -0,0 +1,84 @@
+/*
+ * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2020 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
+ * 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.
+ *
+ */
+
+#ifndef SHARE_MEMORY_METASPACE_COMMITLIMITER_HPP
+#define SHARE_MEMORY_METASPACE_COMMITLIMITER_HPP
+
+#include "memory/allocation.hpp"
+#include "memory/metaspace/counters.hpp"
+
+namespace metaspace {
+
+// The CommitLimiter encapsulates a limit we may want to impose on how much
+//  memory can be committed. This is a matter of separation of concerns:
+//
+// In metaspace, we have two limits to committing memory: the absolute limit,
+//  MaxMetaspaceSize; and the GC threshold. In both cases an allocation should
+//  fail if it would require committing memory and hit one of these limits.
+//
+// However, the actual Metaspace allocator is a generic one and this
+//  GC- and classloading specific logic should be kept separate. Therefore
+//  it is hidden inside this interface.
+//
+// This allows us to:
+//  - more easily write tests for metaspace, by providing a different implementation
+//    of the commit limiter, thus keeping test logic separate from VM state.
+//  - (potentially) use the metaspace for things other than class metadata,
+//    where different commit rules would apply.
+//
+class CommitLimiter : public CHeapObj<mtMetaspace> {
+
+  // Counts total words committed for metaspace
+  SizeCounter _cnt;
+
+  // Purely for testing purposes: cap, in words.
+  const size_t _cap;
+
+public:
+
+  // Create a commit limiter. This is only useful for testing, with a cap != 0,
+  // since normal code should use the global commit limiter.
+  // If cap != 0 (word size), the cap replaces the internal logic of limiting.
+  CommitLimiter(size_t cap = 0) : _cnt(), _cap(cap) {}
+
+  // Returns the size, in words, by which we may expand the metaspace committed area without:
+  // - _cap == 0: hitting GC threshold or the MaxMetaspaceSize
+  // - _cap > 0: hitting cap (this is just for testing purposes)
+  size_t possible_expansion_words() const;
+
+  void increase_committed(size_t word_size)   { _cnt.increment_by(word_size); }
+  void decrease_committed(size_t word_size)   { _cnt.decrement_by(word_size); }
+
+  size_t committed_words() const              { return _cnt.get(); }
+  size_t cap() const                          { return _cap; }
+
+  // Returns the global metaspace commit counter
+  static CommitLimiter* globalLimiter();
+
+};
+
+} // namespace metaspace
+
+#endif // SHARE_MEMORY_METASPACE_COMMITLIMITER_HPP

src/hotspot/share/memory/metaspace/commitMask.cpp

@@ -0,0 +1,97 @@
+/*
+ * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2020 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
+ * 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 "precompiled.hpp"
+#include "memory/metaspace/commitMask.hpp"
+#include "memory/metaspace/metaspaceCommon.hpp"
+#include "memory/metaspace/metaspaceSettings.hpp"
+#include "runtime/stubRoutines.hpp"
+#include "utilities/align.hpp"
+#include "utilities/debug.hpp"
+
+namespace metaspace {
+
+CommitMask::CommitMask(const MetaWord* start, size_t word_size) :
+  CHeapBitMap(mask_size(word_size, Settings::commit_granule_words())),
+  _base(start),
+  _word_size(word_size),
+  _words_per_bit(Settings::commit_granule_words())
+{
+  assert(_word_size > 0 && _words_per_bit > 0 &&
+         is_aligned(_word_size, _words_per_bit), "Sanity");
+}
+
+#ifdef ASSERT
+
+// Given a pointer, check if it points into the range this bitmap covers.
+bool CommitMask::is_pointer_valid(const MetaWord* p) const {
+  return p >= _base && p < _base + _word_size;
+}
+
+// Given a pointer, check if it points into the range this bitmap covers.
+void CommitMask::check_pointer(const MetaWord* p) const {
+  assert(is_pointer_valid(p),
+         "Pointer " PTR_FORMAT " not in range of this bitmap [" PTR_FORMAT ", " PTR_FORMAT ").",
+         p2i(p), p2i(_base), p2i(_base + _word_size));
+}
+// Given a pointer, check if it points into the range this bitmap covers,
+// and if it is aligned to commit granule border.
+void CommitMask::check_pointer_aligned(const MetaWord* p) const {
+  check_pointer(p);
+  assert(is_aligned(p, _words_per_bit * BytesPerWord),
+         "Pointer " PTR_FORMAT " should be aligned to commit granule size " SIZE_FORMAT ".",
+         p2i(p), _words_per_bit * BytesPerWord);
+}
+// Given a range, check if it points into the range this bitmap covers,
+// and if its borders are aligned to commit granule border.
+void CommitMask::check_range(const MetaWord* start, size_t word_size) const {
+  check_pointer_aligned(start);
+  assert(is_aligned(word_size, _words_per_bit),
+         "Range " SIZE_FORMAT " should be aligned to commit granule size " SIZE_FORMAT ".",
+         word_size, _words_per_bit);
+  check_pointer(start + word_size - 1);
+}
+
+void CommitMask::verify() const {
+  // Walk the whole commit mask.
+  // For each 1 bit, check if the associated granule is accessible.
+  // For each 0 bit, check if the associated granule is not accessible. Slow mode only.
+  assert(_base != NULL && _word_size > 0 && _words_per_bit > 0, "Sanity");
+  assert_is_aligned(_base, _words_per_bit * BytesPerWord);
+  assert_is_aligned(_word_size, _words_per_bit);
+}
+
+#endif // ASSERT
+
+void CommitMask::print_on(outputStream* st) const {
+  st->print("commit mask, base " PTR_FORMAT ":", p2i(base()));
+  for (idx_t i = 0; i < size(); i++) {
+    st->print("%c", at(i) ? 'X' : '-');
+  }
+  st->cr();
+}
+
+} // namespace metaspace
+

src/hotspot/share/memory/metaspace/commitMask.hpp

@@ -0,0 +1,165 @@
+/*
+ * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2020 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
+ * 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.
+ *
+ */
+
+#ifndef SHARE_MEMORY_METASPACE_COMMITMASK_HPP
+#define SHARE_MEMORY_METASPACE_COMMITMASK_HPP
+
+#include "utilities/bitMap.hpp"
+#include "utilities/debug.hpp"
+#include "utilities/globalDefinitions.hpp"
+
+class outputStream;
+
+namespace metaspace {
+
+// The CommitMask is a bitmask used to store the commit state of commit granules.
+// It keeps one bit per granule; 1 means committed, 0 means uncommitted.
+
+class CommitMask : public CHeapBitMap {
+
+  const MetaWord* const _base;
+  const size_t _word_size;
+  const size_t _words_per_bit;
+
+  // Given an offset, in words, into the area, return the number of the bit
+  // covering it.
+  static idx_t bitno_for_word_offset(size_t offset, size_t words_per_bit) {
+    return offset / words_per_bit;
+  }
+
+  idx_t bitno_for_address(const MetaWord* p) const {
+    // Note: we allow one-beyond since this is a typical need.
+    assert(p >= _base && p <= _base + _word_size, "Invalid address");
+    const size_t off = p - _base;
+    return bitno_for_word_offset(off, _words_per_bit);
+  }
+
+  static idx_t mask_size(size_t word_size, size_t words_per_bit) {
+    return bitno_for_word_offset(word_size, words_per_bit);
+  }
+
+  // Marks a single commit granule as committed (value == true)
+  // or uncomitted (value == false) and returns
+  // its prior state.
+  bool mark_granule(idx_t bitno, bool value) {
+    bool b = at(bitno);
+    at_put(bitno, value);
+    return b;
+  }
+
+#ifdef ASSERT
+
+  // Given a pointer, check if it points into the range this bitmap covers.
+  bool is_pointer_valid(const MetaWord* p) const;
+
+  // Given a pointer, check if it points into the range this bitmap covers.
+  void check_pointer(const MetaWord* p) const;
+
+  // Given a pointer, check if it points into the range this bitmap covers,
+  // and if it is aligned to commit granule border.
+  void check_pointer_aligned(const MetaWord* p) const;
+
+  // Given a range, check if it points into the range this bitmap covers,
+  // and if its borders are aligned to commit granule border.
+  void check_range(const MetaWord* start, size_t word_size) const;
+
+#endif // ASSERT
+
+public:
+
+  // Create a commit mask covering a range [start, start + word_size).
+  CommitMask(const MetaWord* start, size_t word_size);
+
+  const MetaWord* base() const  { return _base; }
+  size_t word_size() const      { return _word_size; }
+  const MetaWord* end() const   { return _base + word_size(); }
+
+  // Given an address, returns true if the address is committed, false if not.
+  bool is_committed_address(const MetaWord* p) const {
+    DEBUG_ONLY(check_pointer(p));
+    const idx_t bitno = bitno_for_address(p);
+    return at(bitno);
+  }
+
+  // Given an address range, return size, in number of words, of committed area within that range.
+  size_t get_committed_size_in_range(const MetaWord* start, size_t word_size) const {
+    DEBUG_ONLY(check_range(start, word_size));
+    assert(word_size > 0, "zero range");
+    const idx_t b1 = bitno_for_address(start);
+    const idx_t b2 = bitno_for_address(start + word_size);
+    const idx_t num_bits = count_one_bits(b1, b2);
+    return num_bits * _words_per_bit;
+  }
+
+  // Return total committed size, in number of words.
+  size_t get_committed_size() const {
+    return count_one_bits() * _words_per_bit;
+  }
+
+  // Mark a whole address range [start, end) as committed.
+  // Return the number of words which had already been committed before this operation.
+  size_t mark_range_as_committed(const MetaWord* start, size_t word_size) {
+    DEBUG_ONLY(check_range(start, word_size));
+    assert(word_size > 0, "zero range");
+    const idx_t b1 = bitno_for_address(start);
+    const idx_t b2 = bitno_for_address(start + word_size);
+    if (b1 == b2) { // Simple case, 1 granule
+      bool was_committed = mark_granule(b1, true);
+      return was_committed ? _words_per_bit : 0;
+    }
+    const idx_t one_bits_in_range_before = count_one_bits(b1, b2);
+    set_range(b1, b2);
+    return one_bits_in_range_before * _words_per_bit;
+  }
+
+  // Mark a whole address range [start, end) as uncommitted.
+  // Return the number of words which had already been uncommitted before this operation.
+  size_t mark_range_as_uncommitted(const MetaWord* start, size_t word_size) {
+    DEBUG_ONLY(check_range(start, word_size));
+    assert(word_size > 0, "zero range");
+    const idx_t b1 = bitno_for_address(start);
+    const idx_t b2 = bitno_for_address(start + word_size);
+    if (b1 == b2) { // Simple case, 1 granule
+      bool was_committed = mark_granule(b1, false);
+      return was_committed ? 0 : _words_per_bit;
+    }
+    const idx_t zero_bits_in_range_before =
+        (b2 - b1) - count_one_bits(b1, b2);
+    clear_range(b1, b2);
+    return zero_bits_in_range_before * _words_per_bit;
+  }
+
+  //// Debug stuff ////
+
+  // Verify internals.
+  DEBUG_ONLY(void verify() const;)
+
+  void print_on(outputStream* st) const;
+
+};
+
+} // namespace metaspace
+
+#endif // SHARE_MEMORY_METASPACE_COMMITMASK_HPP

src/hotspot/share/memory/metaspace/counters.hpp

@@ -0,0 +1,173 @@
+/*
+ * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2020 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
+ * 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.
+ *
+ */
+
+#ifndef SHARE_MEMORY_METASPACE_COUNTERS_HPP
+#define SHARE_MEMORY_METASPACE_COUNTERS_HPP
+
+#include "metaprogramming/isSigned.hpp"
+#include "runtime/atomic.hpp"
+#include "utilities/debug.hpp"
+#include "utilities/globalDefinitions.hpp"
+
+namespace metaspace {
+
+// We seem to be counting a lot of things which makes it worthwhile to
+// make helper classes for all that boilerplate coding.
+
+// AbstractCounter counts something and asserts overflow and underflow.
+template <class T>
+class AbstractCounter {
+
+  T _c;
+
+  // Only allow unsigned values for now
+  STATIC_ASSERT(IsSigned<T>::value == false);
+
+public:
+
+  AbstractCounter() : _c(0) {}
+
+  T get() const           { return _c; }
+
+  void increment() { increment_by(1); }
+  void decrement() { decrement_by(1); }
+
+  void increment_by(T v) {
+#ifdef ASSERT
+    T old = _c;
+    assert(old + v >= old,
+        "overflow (" UINT64_FORMAT "+" UINT64_FORMAT ")", (uint64_t)old, (uint64_t)v);
+#endif
+    _c += v;
+  }
+
+  void decrement_by(T v) {
+    assert(_c >= v,
+           "underflow (" UINT64_FORMAT "-" UINT64_FORMAT ")",
+           (uint64_t)_c, (uint64_t)v);
+    _c -= v;
+  }
+
+  void reset()                { _c = 0; }
+
+#ifdef ASSERT
+  void check(T expected) const {
+    assert(_c == expected, "Counter mismatch: %d, expected: %d.",
+           (int)_c, (int)expected);
+    }
+#endif
+
+};
+
+// Atomic variant of AbstractCounter.
+template <class T>
+class AbstractAtomicCounter {
+
+  volatile T _c;
+
+  // Only allow unsigned values for now
+  STATIC_ASSERT(IsSigned<T>::value == false);
+
+public:
+
+  AbstractAtomicCounter() : _c(0) {}
+
+  T get() const               { return _c; }
+
+  void increment() {
+    Atomic::inc(&_c);
+  }
+
+  void decrement() {
+    Atomic::dec(&_c);
+  }
+
+  void increment_by(T v) {
+    Atomic::add(&_c, v);
+  }
+
+  void decrement_by(T v) {
+    Atomic::sub(&_c, v);
+  }
+
+#ifdef ASSERT
+  void check(T expected) const {
+    assert(_c == expected, "Counter mismatch: %d, expected: %d.",
+           (int)_c, (int)expected);
+    }
+#endif
+
+};
+
+typedef AbstractCounter<size_t>   SizeCounter;
+typedef AbstractCounter<unsigned> IntCounter;
+
+typedef AbstractAtomicCounter<size_t> SizeAtomicCounter;
+
+// We often count memory ranges (blocks, chunks etc).
+// Make a helper class for that.
+template <class T_num, class T_size>
+class AbstractMemoryRangeCounter {
+
+  AbstractCounter<T_num>  _count;
+  AbstractCounter<T_size> _total_size;
+
+public:
+
+  void add(T_size s) {
+    if(s > 0) {
+      _count.increment();
+      _total_size.increment_by(s);
+    }
+  }
+
+  void sub(T_size s) {
+    if(s > 0) {
+      _count.decrement();
+      _total_size.decrement_by(s);
+    }
+  }
+
+  T_num count() const       { return _count.get(); }
+  T_size total_size() const { return _total_size.get(); }
+
+#ifdef ASSERT
+  void check(T_num expected_count, T_size expected_size) const {
+    _count.check(expected_count);
+    _total_size.check(expected_size);
+  }
+  void check(const AbstractMemoryRangeCounter<T_num, T_size>& other) const {
+    check(other.count(), other.total_size());
+  }
+#endif
+
+};
+
+typedef AbstractMemoryRangeCounter<unsigned, size_t> MemRangeCounter;
+
+} // namespace metaspace
+
+#endif // SHARE_MEMORY_METASPACE_COUNTERS_HPP
+

src/hotspot/share/memory/metaspace/freeBlocks.cpp

@@ -0,0 +1,64 @@
+/*
+ * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2020 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
+ * 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 "precompiled.hpp"
+#include "memory/metaspace/freeBlocks.hpp"
+#include "utilities/debug.hpp"
+#include "utilities/globalDefinitions.hpp"
+
+namespace metaspace {
+
+void FreeBlocks::add_block(MetaWord* p, size_t word_size) {
+  assert(word_size >= MinWordSize, "sanity (" SIZE_FORMAT ")", word_size);
+  if (word_size > MaxSmallBlocksWordSize) {
+    _tree.add_block(p, word_size);
+  } else {
+    _small_blocks.add_block(p, word_size);
+  }
+}
+
+MetaWord* FreeBlocks::remove_block(size_t requested_word_size) {
+  assert(requested_word_size >= MinWordSize,
+      "requested_word_size too small (" SIZE_FORMAT ")", requested_word_size);
+  size_t real_size = 0;
+  MetaWord* p = NULL;
+  if (requested_word_size > MaxSmallBlocksWordSize) {
+    p = _tree.remove_block(requested_word_size, &real_size);
+  } else {
+    p = _small_blocks.remove_block(requested_word_size, &real_size);
+  }
+  if (p != NULL) {
+    // Blocks which are larger than a certain threshold are split and
+    //  the remainder is handed back to the manager.
+    const size_t waste = real_size - requested_word_size;
+    if (waste > MinWordSize) {
+      add_block(p + requested_word_size, waste);
+    }
+  }
+  return p;
+}
+
+} // namespace metaspace
+

src/hotspot/share/memory/metaspace/freeBlocks.hpp

@@ -0,0 +1,113 @@
+/*
+ * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2020 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
+ * 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.
+ *
+ */
+
+#ifndef SHARE_MEMORY_METASPACE_FREEBLOCKS_HPP
+#define SHARE_MEMORY_METASPACE_FREEBLOCKS_HPP
+
+#include "memory/allocation.hpp"
+#include "memory/metaspace/binList.hpp"
+#include "memory/metaspace/blockTree.hpp"
+#include "memory/metaspace/counters.hpp"
+#include "utilities/debug.hpp"
+#include "utilities/globalDefinitions.hpp"
+
+class outputStream;
+
+namespace metaspace {
+
+// Class FreeBlocks manages deallocated blocks in Metaspace.
+//
+// In Metaspace, allocated memory blocks may be release prematurely. This is
+//  uncommon (otherwise an arena-based allocation scheme would not make sense).
+//  It can happen e.g. when class loading fails or when bytecode gets rewritten.
+//
+// All these released blocks should be reused, so they are collected. Since these
+//  blocks are embedded into chunks which are still in use by a live arena,
+//  we cannot just give these blocks to anyone; only the owner of this arena can
+//  reuse these blocks. Therefore these blocks are kept at arena-level.
+//
+// The structure to manage these released blocks at arena level is class FreeBlocks.
+//
+// FreeBlocks is optimized toward the typical size and number of deallocated
+//  blocks. The vast majority of them (about 90%) are below 16 words in size,
+//  but there is a significant portion of memory blocks much larger than that,
+//  leftover space from retired chunks, see MetaspaceArena::retire_current_chunk().
+//
+// Since the vast majority of blocks are small or very small, FreeBlocks consists
+//  internally of two separate structures to keep very small blocks and other blocks.
+//  Very small blocks are kept in a bin list (see binlist.hpp) and larger blocks in
+//  a BST (see blocktree.hpp).
+
+class FreeBlocks : public CHeapObj<mtMetaspace> {
+
+  // _small_blocks takes care of small to very small blocks.
+  BinList32 _small_blocks;
+
+  // A BST for larger blocks, only for blocks which are too large
+  // to fit into _smallblocks.
+  BlockTree _tree;
+
+  // Cutoff point: blocks larger than this size are kept in the
+  // tree, blocks smaller than or equal to this size in the bin list.
+  const size_t MaxSmallBlocksWordSize = BinList32::MaxWordSize;
+
+public:
+
+  // Smallest blocks we can keep in this structure.
+  const static size_t MinWordSize = BinList32::MinWordSize;
+
+  // Add a block to the deallocation management.
+  void add_block(MetaWord* p, size_t word_size);
+
+  // Retrieve a block of at least requested_word_size.
+  MetaWord* remove_block(size_t requested_word_size);
+
+#ifdef ASSERT
+  void verify() const {
+    _tree.verify();
+    _small_blocks.verify();
+  };
+#endif
+
+  // Returns number of blocks.
+  int count() const {
+    return _small_blocks.count() + _tree.count();
+  }
+
+  // Returns total size, in words, of all elements.
+  size_t total_size() const {
+    return _small_blocks.total_size() + _tree.total_size();
+  }
+
+  // Returns true if empty.
+  bool is_empty() const {
+    return _small_blocks.is_empty() && _tree.is_empty();
+  }
+
+};
+
+} // namespace metaspace
+
+#endif // SHARE_MEMORY_METASPACE_FREEBLOCKS_HPP

src/hotspot/share/memory/metaspace/freeChunkList.cpp

@@ -0,0 +1,173 @@
+/*
+ * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2020 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
+ * 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 "precompiled.hpp"
+#include "memory/metaspace/freeChunkList.hpp"
+#include "utilities/debug.hpp"
+#include "utilities/globalDefinitions.hpp"
+#include "utilities/ostream.hpp"
+
+namespace metaspace {
+
+void FreeChunkList::print_on(outputStream* st) const {
+  if (_num_chunks.get() > 0) {
+    for (const Metachunk* c = _first; c != NULL; c = c->next()) {
+      st->print(" - <");
+      c->print_on(st);
+      st->print(">");
+    }
+    st->print(" - total : %d chunks.", _num_chunks.get());
+  } else {
+    st->print("empty");
+  }
+}
+
+#ifdef ASSERT
+
+bool FreeChunkList::contains(const Metachunk* c) const {
+  for (Metachunk* c2 = _first; c2 != NULL; c2 = c2->next()) {
+    if (c2 == c) {
+      return true;
+    }
+  }
+  return false;
+}
+
+void FreeChunkList::verify() const {
+  if (_first == NULL) {
+    assert(_last == NULL, "Sanity");
+  } else {
+    assert(_last != NULL, "Sanity");
+    size_t committed = 0;
+    int num = 0;
+    bool uncommitted = (_first->committed_words() == 0);
+    for (Metachunk* c = _first; c != NULL; c = c->next()) {
+      assert(c->is_free(), "Chunks in freelist should be free");
+      assert(c->used_words() == 0, "Chunk in freelist should have not used words.");
+      assert(c->level() == _first->level(), "wrong level");
+      assert(c->next() == NULL || c->next()->prev() == c, "front link broken");
+      assert(c->prev() == NULL || c->prev()->next() == c, "back link broken");
+      assert(c != c->prev() && c != c->next(), "circle");
+      c->verify();
+      committed += c->committed_words();
+      num++;
+    }
+    _num_chunks.check(num);
+    _committed_word_size.check(committed);
+  }
+}
+
+#endif // ASSERT
+
+// Returns total size in all lists (regardless of commit state of underlying memory)
+size_t FreeChunkListVector::word_size() const {
+  size_t sum = 0;
+  for (chunklevel_t l = chunklevel::LOWEST_CHUNK_LEVEL; l <= chunklevel::HIGHEST_CHUNK_LEVEL; l++) {
+    sum += list_for_level(l)->num_chunks() * chunklevel::word_size_for_level(l);
+  }
+  return sum;
+}
+
+// Returns total committed size in all lists
+size_t FreeChunkListVector::committed_word_size() const {
+  size_t sum = 0;
+  for (chunklevel_t l = chunklevel::LOWEST_CHUNK_LEVEL; l <= chunklevel::HIGHEST_CHUNK_LEVEL; l++) {
+    sum += list_for_level(l)->committed_word_size();
+  }
+  return sum;
+}
+
+// Returns total committed size in all lists
+int FreeChunkListVector::num_chunks() const {
+  int n = 0;
+  for (chunklevel_t l = chunklevel::LOWEST_CHUNK_LEVEL; l <= chunklevel::HIGHEST_CHUNK_LEVEL; l++) {
+    n += list_for_level(l)->num_chunks();
+  }
+  return n;
+}
+
+// Look for a chunk: starting at level, up to and including max_level,
+//  return the first chunk whose committed words >= min_committed_words.
+// Return NULL if no such chunk was found.
+Metachunk* FreeChunkListVector::search_chunk_ascending(chunklevel_t level, chunklevel_t max_level, size_t min_committed_words) {
+  assert(min_committed_words <= chunklevel::word_size_for_level(max_level),
+         "min chunk size too small to hold min_committed_words");
+  for (chunklevel_t l = level; l <= max_level; l++) {
+    FreeChunkList* list = list_for_level(l);
+    Metachunk* c = list->first_minimally_committed(min_committed_words);
+    if (c != NULL) {
+      list->remove(c);
+      return c;
+    }
+  }
+  return NULL;
+}
+
+// Look for a chunk: starting at level, down to (including) the root chunk level,
+// return the first chunk whose committed words >= min_committed_words.
+// Return NULL if no such chunk was found.
+Metachunk* FreeChunkListVector::search_chunk_descending(chunklevel_t level, size_t min_committed_words) {
+  for (chunklevel_t l = level; l >= chunklevel::LOWEST_CHUNK_LEVEL; l --) {
+    FreeChunkList* list = list_for_level(l);
+    Metachunk* c = list->first_minimally_committed(min_committed_words);
+    if (c != NULL) {
+      list->remove(c);
+      return c;
+    }
+  }
+  return NULL;
+}
+
+void FreeChunkListVector::print_on(outputStream* st) const {
+  for (chunklevel_t l = chunklevel::LOWEST_CHUNK_LEVEL; l <= chunklevel::HIGHEST_CHUNK_LEVEL; l++) {
+    st->print("-- List[" CHKLVL_FORMAT "]: ", l);
+    list_for_level(l)->print_on(st);
+    st->cr();
+  }
+  st->print_cr("total chunks: %d, total word size: " SIZE_FORMAT ", committed word size: " SIZE_FORMAT ".",
+               num_chunks(), word_size(), committed_word_size());
+}
+
+#ifdef ASSERT
+
+void FreeChunkListVector::verify() const {
+  for (chunklevel_t l = chunklevel::LOWEST_CHUNK_LEVEL; l <= chunklevel::HIGHEST_CHUNK_LEVEL; l++) {
+    list_for_level(l)->verify();
+  }
+}
+
+bool FreeChunkListVector::contains(const Metachunk* c) const {
+  for (chunklevel_t l = chunklevel::LOWEST_CHUNK_LEVEL; l <= chunklevel::HIGHEST_CHUNK_LEVEL; l++) {
+    if (list_for_level(l)->contains(c)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+#endif // ASSERT
+
+} // namespace metaspace
+

src/hotspot/share/memory/metaspace/freeChunkList.hpp

@@ -0,0 +1,270 @@
+/*
+ * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2020 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
+ * 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.
+ *
+ */
+
+#ifndef SHARE_MEMORY_METASPACE_FREECHUNKLIST_HPP
+#define SHARE_MEMORY_METASPACE_FREECHUNKLIST_HPP
+
+#include "memory/allocation.hpp"
+#include "memory/metaspace/chunklevel.hpp"
+#include "memory/metaspace/counters.hpp"
+#include "memory/metaspace/metachunk.hpp"
+#include "memory/metaspace/metachunkList.hpp"
+
+class outputStream;
+
+namespace metaspace {
+
+// This is the free list underlying the ChunkManager.
+//
+// Chunks are kept in a vector of double-linked double-headed lists
+//  (using Metachunk::prev/next). One list per chunk level exists.
+//
+// Chunks in these lists are roughly ordered: uncommitted chunks
+//  are added to the back of the list, fully or partially committed
+//  chunks to the front. We do not use a more elaborate sorting on
+//  insert since that path is used during class unloading, hence timing
+//  sensitive.
+//
+// During retrieval (at class loading), we search the list for a chunk
+//  of at least n committed words to satisfy the caller requested
+//  committed word size. We stop searching at the first fully uncommitted
+//  chunk.
+//
+// Note that even though this is an O(n) search, partially committed chunks are
+//  very rare. A partially committed chunk is one spanning multiple commit
+//  granules, of which some are committed and some are not.
+// If metaspace reclamation is on (MetaspaceReclaimPolicy=balanced|aggressive), these
+//  chunks will become uncommitted after they are returned to the ChunkManager.
+// If metaspace reclamation is off (MetaspaceReclaimPolicy=none) they are fully
+//  committed when handed out and will not be uncommitted when returned to the
+//  ChunkManager.
+//
+// Therefore in all likelihood the chunk lists only contain fully committed or
+// fully uncommitted chunks; either way search will stop at the first chunk.
+
+class FreeChunkList {
+
+  Metachunk* _first;
+  Metachunk* _last;
+
+  IntCounter _num_chunks;
+  SizeCounter _committed_word_size;
+
+  void add_front(Metachunk* c) {
+    if (_first == NULL) {
+      assert(_last == NULL, "Sanity");
+      _first = _last = c;
+      c->set_prev(NULL);
+      c->set_next(NULL);
+    } else {
+      assert(_last != NULL, "Sanity");
+      c->set_next(_first);
+      c->set_prev(NULL);
+      _first->set_prev(c);
+      _first = c;
+    }
+  }
+
+  // Add chunk to the back of the list.
+  void add_back(Metachunk* c) {
+    if (_last == NULL) {
+      assert(_first == NULL, "Sanity");
+      _last = _first = c;
+      c->set_prev(NULL);
+      c->set_next(NULL);
+    } else {
+      assert(_first != NULL, "Sanity");
+      c->set_next(NULL);
+      c->set_prev(_last);
+      _last->set_next(c);
+      _last = c;
+    }
+  }
+
+public:
+
+  FreeChunkList() :
+    _first(NULL),
+    _last(NULL)
+  {}
+
+  // Remove given chunk from anywhere in the list.
+  Metachunk* remove(Metachunk* c) {
+    assert(contains(c), "Must be contained here");
+    Metachunk* pred = c->prev();
+    Metachunk* succ = c->next();
+    if (pred) {
+      pred->set_next(succ);
+    }
+    if (succ) {
+      succ->set_prev(pred);
+    }
+    if (_first == c) {
+      _first = succ;
+    }
+    if (_last == c) {
+      _last = pred;
+    }
+    c->set_next(NULL);
+    c->set_prev(NULL);
+    _committed_word_size.decrement_by(c->committed_words());
+    _num_chunks.decrement();
+    return c;
+  }
+
+  void add(Metachunk* c) {
+    assert(contains(c) == false, "Chunk already in freelist");
+    assert(_first == NULL || _first->level() == c->level(),
+           "List should only contains chunks of the same level.");
+    // Uncomitted chunks go to the back, fully or partially committed to the front.
+    if (c->committed_words() == 0) {
+      add_back(c);
+    } else {
+      add_front(c);
+    }
+    _committed_word_size.increment_by(c->committed_words());
+    _num_chunks.increment();
+  }
+
+  // Removes the first chunk from the list and returns it. Returns NULL if list is empty.
+  Metachunk* remove_first() {
+    Metachunk* c = _first;
+    if (c != NULL) {
+      remove(c);
+    }
+    return c;
+  }
+
+  // Returns reference to the first chunk in the list, or NULL
+  Metachunk* first() const { return _first; }
+
+  // Returns reference to the fist chunk in the list with a committed word
+  // level >= min_committed_words, or NULL.
+  Metachunk* first_minimally_committed(size_t min_committed_words) const {
+    // Since uncommitted chunks are added to the back we can stop looking once
+    //  we encounter a fully uncommitted chunk.
+    Metachunk* c = first();
+    while (c != NULL &&
+           c->committed_words() < min_committed_words &&
+           c->committed_words() > 0) {
+      c = c->next();
+    }
+    if (c != NULL &&
+        c->committed_words() >= min_committed_words) {
+      return c;
+    }
+    return NULL;
+  }
+
+#ifdef ASSERT
+  bool contains(const Metachunk* c) const;
+  void verify() const;
+#endif
+
+  // Returns number of chunks
+  int num_chunks() const { return _num_chunks.get(); }
+
+  // Returns total committed word size
+  size_t committed_word_size() const { return _committed_word_size.get(); }
+
+  void print_on(outputStream* st) const;
+
+};
+
+// A vector of free chunk lists, one per chunk level
+class FreeChunkListVector {
+
+  FreeChunkList _lists[chunklevel::NUM_CHUNK_LEVELS];
+
+  const FreeChunkList* list_for_level(chunklevel_t lvl) const         { DEBUG_ONLY(chunklevel::check_valid_level(lvl)); return _lists + lvl; }
+  FreeChunkList* list_for_level(chunklevel_t lvl)                     { DEBUG_ONLY(chunklevel::check_valid_level(lvl)); return _lists + lvl; }
+
+  const FreeChunkList* list_for_chunk(const Metachunk* c) const       { return list_for_level(c->level()); }
+  FreeChunkList* list_for_chunk(const Metachunk* c)                   { return list_for_level(c->level()); }
+
+public:
+
+  // Remove given chunk from its list. List must contain that chunk.
+  void remove(Metachunk* c) {
+    list_for_chunk(c)->remove(c);
+  }
+
+  // Remove first node unless empty. Returns node or NULL.
+  Metachunk* remove_first(chunklevel_t lvl) {
+    Metachunk* c = list_for_level(lvl)->remove_first();
+    return c;
+  }
+
+  void add(Metachunk* c) {
+    list_for_chunk(c)->add(c);
+  }
+
+  // Returns number of chunks for a given level.
+  int num_chunks_at_level(chunklevel_t lvl) const {
+    return list_for_level(lvl)->num_chunks();
+  }
+
+  // Returns number of chunks for a given level.
+  size_t committed_word_size_at_level(chunklevel_t lvl) const {
+    return list_for_level(lvl)->committed_word_size();
+  }
+
+  // Returns reference to first chunk at this level, or NULL if sublist is empty.
+  Metachunk* first_at_level(chunklevel_t lvl) const {
+    return list_for_level(lvl)->first();
+  }
+
+  // Look for a chunk: starting at level, up to and including max_level,
+  //  return the first chunk whose committed words >= min_committed_words.
+  // Return NULL if no such chunk was found.
+  Metachunk* search_chunk_ascending(chunklevel_t level, chunklevel_t max_level,
+                                    size_t min_committed_words);
+
+  // Look for a chunk: starting at level, down to (including) the root chunk level,
+  // return the first chunk whose committed words >= min_committed_words.
+  // Return NULL if no such chunk was found.
+  Metachunk* search_chunk_descending(chunklevel_t level, size_t min_committed_words);
+
+  // Returns total size in all lists (regardless of commit state of underlying memory)
+  size_t word_size() const;
+
+  // Returns total committed size in all lists
+  size_t committed_word_size() const;
+
+  // Returns number of chunks in all lists
+  int num_chunks() const;
+
+#ifdef ASSERT
+  bool contains(const Metachunk* c) const;
+  void verify() const;
+#endif
+
+  void print_on(outputStream* st) const;
+
+};
+
+} // namespace metaspace
+
+#endif // SHARE_MEMORY_METASPACE_FREECHUNKLIST_HPP

src/hotspot/share/memory/metaspace/internalStats.cpp

@@ -1,5 +1,6 @@
 /*
- * Copyright (c) 2012, 2019, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2020 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
@@ -22,29 +23,29 @@
  *
  */
 
-#ifndef SHARE_MEMORY_METASPACE_METABLOCK_HPP
+#include "precompiled.hpp"
-#define SHARE_MEMORY_METASPACE_METABLOCK_HPP
+#include "memory/metaspace/internalStats.hpp"
-
-#include "memory/metaspace/metabase.hpp"
 #include "utilities/globalDefinitions.hpp"
+#include "utilities/ostream.hpp"
 
 namespace metaspace {
 
-// Metablock is the unit of allocation from a Chunk.
+#define MATERIALIZE_COUNTER(name)          uintx InternalStats::_##name;
-//
+#define MATERIALIZE_ATOMIC_COUNTER(name)   volatile uintx InternalStats::_##name;
-// A Metablock may be reused by its SpaceManager but are never moved between
+  ALL_MY_COUNTERS(MATERIALIZE_COUNTER, MATERIALIZE_ATOMIC_COUNTER)
-// SpaceManagers.  There is no explicit link to the Metachunk
+#undef MATERIALIZE_COUNTER
-// from which it was allocated.  Metablock may be deallocated and
+#undef MATERIALIZE_ATOMIC_COUNTER
-// put on a freelist but the space is never freed, rather
-// the Metachunk it is a part of will be deallocated when it's
-// associated class loader is collected.
 
-class Metablock : public Metabase<Metablock> {
+void InternalStats::print_on(outputStream* st) {
-  friend class VMStructs;
+
- public:
+#define xstr(s) str(s)
-  Metablock(size_t word_size) : Metabase<Metablock>(word_size) {}
+#define str(s) #s
-};
+
+#define PRINT_COUNTER(name)  st->print_cr("%s: " UINTX_FORMAT ".", xstr(name), _##name);
+  ALL_MY_COUNTERS(PRINT_COUNTER, PRINT_COUNTER)
+#undef PRINT_COUNTER
+
+}
 
 } // namespace metaspace
 
-#endif // SHARE_MEMORY_METASPACE_METABLOCK_HPP

src/hotspot/share/memory/metaspace/internalStats.hpp

@@ -0,0 +1,127 @@
+/*
+ * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2020 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
+ * 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.
+ *
+ */
+
+#ifndef SHARE_MEMORY_METASPACE_INTERNALSTATS_HPP
+#define SHARE_MEMORY_METASPACE_INTERNALSTATS_HPP
+
+#include "memory/allocation.hpp"
+#include "runtime/atomic.hpp"
+#include "utilities/globalDefinitions.hpp"
+
+class outputStream;
+
+namespace metaspace {
+
+// These are some counters useful for debugging and analyzing Metaspace problems.
+// They get printed as part of the Metaspace report (e.g. via jcmd VM.metaspace)
+
+class InternalStats : public AllStatic {
+
+  // Note: all counters which are modified on the classloader local allocation path
+  //   (not under ExpandLock protection) have to be atomic.
+
+#define ALL_MY_COUNTERS(x, x_atomic)                \
+                                                    \
+  /* Number of allocations. */                      \
+  DEBUG_ONLY(x_atomic(num_allocs))                  \
+                                                    \
+  /* Number of external deallocations */            \
+  /* (excluding retired chunk remains) */           \
+  DEBUG_ONLY(x_atomic(num_deallocs))                \
+                                                    \
+  /* Number of times an allocation was satisfied */ \
+  /*  from deallocated blocks. */                   \
+  DEBUG_ONLY(x_atomic(num_allocs_from_deallocated_blocks)) \
+                                                    \
+  /* Number of times an arena retired a chunk */    \
+  DEBUG_ONLY(x_atomic(num_chunks_retired))          \
+                                                    \
+  /* Number of times an allocation failed */        \
+  /*  because we hit a limit. */                    \
+  x_atomic(num_allocs_failed_limit)                 \
+                                                    \
+  /* Number of times an arena was born ... */       \
+  x_atomic(num_arena_births)                        \
+  /* ... and died. */                               \
+  x_atomic(num_arena_deaths)                        \
+                                                    \
+  /* Number of times VirtualSpaceNode were */       \
+  /*  born...  */                                   \
+  x(num_vsnodes_births)                             \
+  /* ... and died. */                               \
+  x(num_vsnodes_deaths)                             \
+                                                    \
+  /* Number of times we committed space. */         \
+  x(num_space_committed)                            \
+  /* Number of times we uncommitted space. */       \
+  x(num_space_uncommitted)                          \
+                                                    \
+  /* Number of times a chunk was returned to the */ \
+  /*  freelist (external only). */                  \
+  x(num_chunks_returned_to_freelist)                \
+  /* Number of times a chunk was taken from */      \
+  /*  freelist (external only) */                   \
+  x(num_chunks_taken_from_freelist)                 \
+                                                    \
+  /* Number of successful chunk merges */           \
+  x(num_chunk_merges)                               \
+  /* Number of chunk splits */                      \
+  x(num_chunk_splits)                               \
+  /* Number of chunk in place enlargements */       \
+  x(num_chunks_enlarged)                            \
+                                                    \
+  /* Number of times we did a purge */              \
+  x(num_purges)                                     \
+
+// Note: We use uintx since 32bit platforms lack 64bit atomic add; this increases
+//  the possibility of counter overflows but the probability is very low for any counter
+//  but num_allocs; note that these counters are for human eyes only.
+#define DEFINE_COUNTER(name)          static uintx _##name;
+#define DEFINE_ATOMIC_COUNTER(name)   static volatile uintx _##name;
+  ALL_MY_COUNTERS(DEFINE_COUNTER, DEFINE_ATOMIC_COUNTER)
+#undef DEFINE_COUNTER
+#undef DEFINE_ATOMIC_COUNTER
+
+public:
+
+// incrementors
+#define INCREMENTOR(name)           static void inc_##name() { _##name++; }
+#define INCREMENTOR_ATOMIC(name)    static void inc_##name() { Atomic::inc(&_##name); }
+  ALL_MY_COUNTERS(INCREMENTOR, INCREMENTOR_ATOMIC)
+#undef INCREMENTOR
+#undef INCREMENTOR_ATOMIC
+
+// getters
+#define GETTER(name)                static uint64_t name() { return _##name; }
+  ALL_MY_COUNTERS(GETTER, GETTER)
+#undef GETTER
+
+  static void print_on(outputStream* st);
+
+};
+
+} // namespace metaspace
+
+#endif // SHARE_MEMORY_METASPACE_INTERNALSTATS_HPP

src/hotspot/share/memory/metaspace/metabase.hpp

@@ -1,80 +0,0 @@
-/*
- * Copyright (c) 2012, 2020, 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.
- *
- */
-
-#ifndef SHARE_MEMORY_METASPACE_METABASE_HPP
-#define SHARE_MEMORY_METASPACE_METABASE_HPP
-
-#include "utilities/globalDefinitions.hpp"
-
-namespace metaspace {
-
-// Super class of Metablock and Metachunk to allow them to
-// be put on the FreeList and in the BinaryTreeDictionary.
-template <class T>
-class Metabase {
-  size_t _word_size;
-  T*     _next;
-  T*     _prev;
-
- protected:
-  Metabase(size_t word_size) : _word_size(word_size), _next(NULL), _prev(NULL) {}
-
- public:
-  T* next() const         { return _next; }
-  T* prev() const         { return _prev; }
-  void set_next(T* v)     { _next = v; assert(v != this, "Boom");}
-  void set_prev(T* v)     { _prev = v; assert(v != this, "Boom");}
-  void clear_next()       { set_next(NULL); }
-  void clear_prev()       { set_prev(NULL); }
-
-  size_t size() const     { return _word_size; }
-
-  void link_next(T* ptr)  { set_next(ptr); }
-  void link_prev(T* ptr)  { set_prev(ptr); }
-  void link_after(T* ptr) {
-    link_next(ptr);
-    if (ptr != NULL) ptr->link_prev((T*)this);
-  }
-
-  uintptr_t* end() const        { return ((uintptr_t*) this) + size(); }
-
-  bool cantCoalesce() const     { return false; }
-
-  // Debug support
-#ifdef ASSERT
-  void* prev_addr() const { return (void*)&_prev; }
-  void* next_addr() const { return (void*)&_next; }
-  void* size_addr() const { return (void*)&_word_size; }
-#endif
-  bool verify_chunk_in_free_list(T* tc) const { return true; }
-  bool verify_par_locked() { return true; }
-
-  void assert_is_mangled() const {/* Don't check "\*/}
-
-  bool is_free()                 { return true; }
-};
-
-} // namespace metaspace
-
-#endif // SHARE_MEMORY_METASPACE_METABASE_HPP

src/hotspot/share/memory/metaspace/metachunk.cpp

@@ -1,5 +1,6 @@
 /*
- * Copyright (c) 2012, 2016, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2012, 2020, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 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
@@ -23,149 +24,285 @@
  */
 
 #include "precompiled.hpp"
-#include "memory/allocation.hpp"
+#include "logging/log.hpp"
 #include "memory/metaspace/metachunk.hpp"
-#include "memory/metaspace/occupancyMap.hpp"
+#include "memory/metaspace/metaspaceCommon.hpp"
+#include "memory/metaspace/metaspaceSettings.hpp"
 #include "memory/metaspace/virtualSpaceNode.hpp"
+#include "runtime/mutexLocker.hpp"
 #include "utilities/align.hpp"
 #include "utilities/copy.hpp"
 #include "utilities/debug.hpp"
 
 namespace metaspace {
 
-size_t Metachunk::object_alignment() {
+// Return a single char presentation of the state ('f', 'u', 'd')
-  // Must align pointers and sizes to 8,
+char Metachunk::get_state_char() const {
-  // so that 64 bit types get correctly aligned.
+  switch (_state) {
-  const size_t alignment = 8;
+  case State::Free:   return 'f';
-
+  case State::InUse:  return 'u';
-  // Make sure that the Klass alignment also agree.
+  case State::Dead:   return 'd';
-  STATIC_ASSERT(alignment == (size_t)KlassAlignmentInBytes);
+  }
-
+  return '?';
-  return alignment;
 }
 
-size_t Metachunk::overhead() {
-  return align_up(sizeof(Metachunk), object_alignment()) / BytesPerWord;
-}
-
-// Metachunk methods
-
-Metachunk::Metachunk(ChunkIndex chunktype, bool is_class, size_t word_size,
-                     VirtualSpaceNode* container)
-    : Metabase<Metachunk>(word_size),
-    _container(container),
-    _top(NULL),
-    _sentinel(CHUNK_SENTINEL),
-    _chunk_type(chunktype),
-    _is_class(is_class),
-    _origin(origin_normal),
-    _use_count(0)
-{
-  _top = initial_top();
-  set_is_tagged_free(false);
 #ifdef ASSERT
-  mangle(uninitMetaWordVal);
+void Metachunk::assert_have_expand_lock() {
-  verify();
+  assert_lock_strong(MetaspaceExpand_lock);
+}
 #endif
-}
 
-MetaWord* Metachunk::allocate(size_t word_size) {
+// Commit uncommitted section of the chunk.
-  MetaWord* result = NULL;
+// Fails if we hit a commit limit.
-  // If available, bump the pointer to allocate.
+bool Metachunk::commit_up_to(size_t new_committed_words) {
-  if (free_word_size() >= word_size) {
+  // Please note:
-    result = _top;
+  //
-    _top = _top + word_size;
+  // VirtualSpaceNode::ensure_range_is_committed(), when called over a range containing both committed and uncommitted parts,
+  // will replace the whole range with a new mapping, thus erasing the existing content in the committed parts. Therefore
+  // we must make sure never to call VirtualSpaceNode::ensure_range_is_committed() over a range containing live data.
+  //
+  // Luckily, this cannot happen by design. We have two cases:
+  //
+  // 1) chunks equal or larger than a commit granule.
+  //    In this case, due to chunk geometry, the chunk should cover whole commit granules (in other words, a chunk equal or larger than
+  //    a commit granule will never share a granule with a neighbor). That means whatever we commit or uncommit here does not affect
+  //    neighboring chunks. We only have to take care not to re-commit used parts of ourself. We do this by moving the committed_words
+  //    limit in multiple of commit granules.
+  //
+  // 2) chunks smaller than a commit granule.
+  //    In this case, a chunk shares a single commit granule with its neighbors. But this never can be a problem:
+  //    - Either the commit granule is already committed (and maybe the neighbors contain live data). In that case calling
+  //      ensure_range_is_committed() will do nothing.
+  //    - Or the commit granule is not committed, but in this case, the neighbors are uncommitted too and cannot contain live data.
+
+#ifdef ASSERT
+  if (word_size() >= Settings::commit_granule_words()) {
+    // case (1)
+    assert(is_aligned(base(), Settings::commit_granule_bytes()) &&
+           is_aligned(end(), Settings::commit_granule_bytes()),
+           "Chunks larger than a commit granule must cover whole granules.");
+    assert(is_aligned(_committed_words, Settings::commit_granule_words()),
+           "The commit boundary must be aligned to commit granule size");
+    assert(_used_words <= _committed_words, "Sanity");
+  } else {
+    // case (2)
+    assert(_committed_words == 0 || _committed_words == word_size(), "Sanity");
   }
-  return result;
+#endif
-}
 
-// _bottom points to the start of the chunk including the overhead.
+  // We should hold the expand lock at this point.
-size_t Metachunk::used_word_size() const {
+  assert_lock_strong(MetaspaceExpand_lock);
-  return pointer_delta(_top, bottom(), sizeof(MetaWord));
-}
 
-size_t Metachunk::free_word_size() const {
+  const size_t commit_from = _committed_words;
-  return pointer_delta(end(), _top, sizeof(MetaWord));
+  const size_t commit_to =   MIN2(align_up(new_committed_words, Settings::commit_granule_words()), word_size());
-}
+  assert(commit_from >= used_words(), "Sanity");
-
+  assert(commit_to <= word_size(), "Sanity");
-void Metachunk::print_on(outputStream* st) const {
+  if (commit_to > commit_from) {
-  st->print_cr("Metachunk:"
+    log_debug(metaspace)("Chunk " METACHUNK_FORMAT ": attempting to move commit line to "
-               " bottom " PTR_FORMAT " top " PTR_FORMAT
+                         SIZE_FORMAT " words.", METACHUNK_FORMAT_ARGS(this), commit_to);
-               " end " PTR_FORMAT " size " SIZE_FORMAT " (%s)",
+    if (!_vsnode->ensure_range_is_committed(base() + commit_from, commit_to - commit_from)) {
-               p2i(bottom()), p2i(_top), p2i(end()), word_size(),
+      DEBUG_ONLY(verify();)
-               chunk_size_name(get_chunk_type()));
+      return false;
-  if (Verbose) {
+    }
-    st->print_cr("    used " SIZE_FORMAT " free " SIZE_FORMAT,
-                 used_word_size(), free_word_size());
   }
+
+  // Remember how far we have committed.
+  _committed_words = commit_to;
+  DEBUG_ONLY(verify();)
+  return true;
+}
+
+// Ensure that chunk is committed up to at least new_committed_words words.
+// Fails if we hit a commit limit.
+bool Metachunk::ensure_committed(size_t new_committed_words) {
+  bool rc = true;
+  if (new_committed_words > committed_words()) {
+    MutexLocker cl(MetaspaceExpand_lock, Mutex::_no_safepoint_check_flag);
+    rc = commit_up_to(new_committed_words);
+  }
+  return rc;
+}
+
+bool Metachunk::ensure_committed_locked(size_t new_committed_words) {
+  // the .._locked() variant should be called if we own the lock already.
+  assert_lock_strong(MetaspaceExpand_lock);
+  bool rc = true;
+  if (new_committed_words > committed_words()) {
+    rc = commit_up_to(new_committed_words);
+  }
+  return rc;
+}
+
+// Uncommit chunk area. The area must be a common multiple of the
+// commit granule size (in other words, we cannot uncommit chunks smaller than
+// a commit granule size).
+void Metachunk::uncommit() {
+  MutexLocker cl(MetaspaceExpand_lock, Mutex::_no_safepoint_check_flag);
+  uncommit_locked();
+}
+
+void Metachunk::uncommit_locked() {
+  // Only uncommit chunks which are free, have no used words set (extra precaution) and are equal or larger in size than a single commit granule.
+  assert_lock_strong(MetaspaceExpand_lock);
+  assert(_state == State::Free && _used_words == 0 && word_size() >= Settings::commit_granule_words(),
+         "Only free chunks equal or larger than commit granule size can be uncommitted "
+         "(chunk " METACHUNK_FULL_FORMAT ").", METACHUNK_FULL_FORMAT_ARGS(this));
+  if (word_size() >= Settings::commit_granule_words()) {
+    _vsnode->uncommit_range(base(), word_size());
+    _committed_words = 0;
+  }
+}
+void Metachunk::set_committed_words(size_t v) {
+  // Set committed words. Since we know that we only commit whole commit granules, we can round up v here.
+  v = MIN2(align_up(v, Settings::commit_granule_words()), word_size());
+ _committed_words = v;
+}
+
+// Allocate word_size words from this chunk (word_size must be aligned to
+//  allocation_alignment_words).
+//
+// Caller must make sure the chunk is both large enough and committed far enough
+// to hold the allocation. Will always work.
+//
+MetaWord* Metachunk::allocate(size_t request_word_size) {
+  // Caller must have made sure this works
+  assert(free_words() >= request_word_size, "Chunk too small.");
+  assert(free_below_committed_words() >= request_word_size, "Chunk not committed.");
+  MetaWord* const p = top();
+  _used_words += request_word_size;
+  SOMETIMES(verify();)
+  return p;
 }
 
 #ifdef ASSERT
-void Metachunk::mangle(juint word_value) {
+
-  // Overwrite the payload of the chunk and not the links that
+// Zap this structure.
-  // maintain list of chunks.
+void Metachunk::zap_header(uint8_t c) {
-  HeapWord* start = (HeapWord*)initial_top();
+  memset(this, c, sizeof(Metachunk));
-  size_t size = word_size() - overhead();
-  Copy::fill_to_words(start, size, word_value);
 }
 
+// Verifies linking with neighbors in virtual space.
+// Can only be done under expand lock protection.
+void Metachunk::verify_neighborhood() const {
+  assert_lock_strong(MetaspaceExpand_lock);
+  assert(!is_dead(), "Do not call on dead chunks.");
+  if (is_root_chunk()) {
+    // Root chunks are all alone in the world.
+    assert(next_in_vs() == NULL || prev_in_vs() == NULL, "Root chunks should have no neighbors");
+  } else {
+    // Non-root chunks have neighbors, at least one, possibly two.
+    assert(next_in_vs() != NULL || prev_in_vs() != NULL,
+           "A non-root chunk should have neighbors (chunk @" PTR_FORMAT
+           ", base " PTR_FORMAT ", level " CHKLVL_FORMAT ".",
+           p2i(this), p2i(base()), level());
+    if (prev_in_vs() != NULL) {
+      assert(prev_in_vs()->end() == base(),
+             "Chunk " METACHUNK_FULL_FORMAT ": should be adjacent to predecessor: " METACHUNK_FULL_FORMAT ".",
+             METACHUNK_FULL_FORMAT_ARGS(this), METACHUNK_FULL_FORMAT_ARGS(prev_in_vs()));
+      assert(prev_in_vs()->next_in_vs() == this,
+             "Chunk " METACHUNK_FULL_FORMAT ": broken link to left neighbor: " METACHUNK_FULL_FORMAT " (" PTR_FORMAT ").",
+             METACHUNK_FULL_FORMAT_ARGS(this), METACHUNK_FULL_FORMAT_ARGS(prev_in_vs()), p2i(prev_in_vs()->next_in_vs()));
+    }
+    if (next_in_vs() != NULL) {
+      assert(end() == next_in_vs()->base(),
+             "Chunk " METACHUNK_FULL_FORMAT ": should be adjacent to successor: " METACHUNK_FULL_FORMAT ".",
+             METACHUNK_FULL_FORMAT_ARGS(this), METACHUNK_FULL_FORMAT_ARGS(next_in_vs()));
+      assert(next_in_vs()->prev_in_vs() == this,
+             "Chunk " METACHUNK_FULL_FORMAT ": broken link to right neighbor: " METACHUNK_FULL_FORMAT " (" PTR_FORMAT ").",
+             METACHUNK_FULL_FORMAT_ARGS(this), METACHUNK_FULL_FORMAT_ARGS(next_in_vs()), p2i(next_in_vs()->prev_in_vs()));
+    }
+
+    // One of the neighbors must be the buddy. It can be whole or splintered.
+
+    // The chunk following us or preceeding us may be our buddy or a splintered part of it.
+    Metachunk* buddy = is_leader() ? next_in_vs() : prev_in_vs();
+    assert(buddy != NULL, "Missing neighbor.");
+    assert(!buddy->is_dead(), "Invalid buddy state.");
+
+    // This neighbor is either or buddy (same level) or a splinter of our buddy - hence
+    // the level can never be smaller (aka the chunk size cannot be larger).
+    assert(buddy->level() >= level(), "Wrong level.");
+
+    if (buddy->level() == level()) {
+      // If the buddy is of the same size as us, it is unsplintered.
+      assert(buddy->is_leader() == !is_leader(),
+             "Only one chunk can be leader in a pair");
+
+      // When direct buddies are neighbors, one or both should be in use, otherwise they should
+      // have been merged.
+      // But since we call this verification function from internal functions where we are about to merge or just did split,
+      // do not test this. We have RootChunkArea::verify_area_is_ideally_merged() for testing that.
+      if (is_leader()) {
+        assert(buddy->base() == end(), "Sanity");
+        assert(is_aligned(base(), word_size() * 2 * BytesPerWord), "Sanity");
+      } else {
+        assert(buddy->end() == base(), "Sanity");
+        assert(is_aligned(buddy->base(), word_size() * 2 * BytesPerWord), "Sanity");
+      }
+    } else {
+      // Buddy, but splintered, and this is a part of it.
+      if (is_leader()) {
+        assert(buddy->base() == end(), "Sanity");
+      } else {
+        assert(buddy->end() > (base() - word_size()), "Sanity");
+      }
+    }
+  }
+}
+
+volatile MetaWord dummy = 0;
+
 void Metachunk::verify() const {
-  assert(is_valid_sentinel(), "Chunk " PTR_FORMAT ": sentinel invalid", p2i(this));
+  // Note. This should be called under CLD lock protection.
-  const ChunkIndex chunk_type = get_chunk_type();
+
-  assert(is_valid_chunktype(chunk_type), "Chunk " PTR_FORMAT ": Invalid chunk type.", p2i(this));
+  // We can verify everything except the _prev_in_vs/_next_in_vs pair.
-  if (chunk_type != HumongousIndex) {
+  // This is because neighbor chunks may be added concurrently, so we cannot rely
-    assert(word_size() == get_size_for_nonhumongous_chunktype(chunk_type, is_class()),
+  //  on the content of _next_in_vs/_prev_in_vs unless we have the expand lock.
-           "Chunk " PTR_FORMAT ": wordsize " SIZE_FORMAT " does not fit chunk type %s.",
+  assert(!is_dead(), "Do not call on dead chunks.");
-           p2i(this), word_size(), chunk_size_name(chunk_type));
+  if (is_free()) {
+    assert(used_words() == 0, "free chunks are not used.");
   }
-  assert(is_valid_chunkorigin(get_origin()), "Chunk " PTR_FORMAT ": Invalid chunk origin.", p2i(this));
-  assert(bottom() <= _top && _top <= (MetaWord*)end(),
-         "Chunk " PTR_FORMAT ": Chunk top out of chunk bounds.", p2i(this));
 
-  // For non-humongous chunks, starting address shall be aligned
+  // Note: only call this on a life Metachunk.
-  // to its chunk size. Humongous chunks start address is
+  chunklevel::check_valid_level(level());
-  // aligned to specialized chunk size.
+
-  const size_t required_alignment =
+  assert(base() != NULL, "No base ptr");
-    (chunk_type != HumongousIndex ? word_size() : get_size_for_nonhumongous_chunktype(SpecializedIndex, is_class())) * sizeof(MetaWord);
+  assert(committed_words() >= used_words(),
-  assert(is_aligned((address)this, required_alignment),
+         "mismatch: committed: " SIZE_FORMAT ", used: " SIZE_FORMAT ".",
-         "Chunk " PTR_FORMAT ": (size " SIZE_FORMAT ") not aligned to " SIZE_FORMAT ".",
+         committed_words(), used_words());
-         p2i(this), word_size() * sizeof(MetaWord), required_alignment);
+  assert(word_size() >= committed_words(),
+         "mismatch: word_size: " SIZE_FORMAT ", committed: " SIZE_FORMAT ".",
+         word_size(), committed_words());
+
+  // Test base pointer
+  assert(base() != NULL, "Base pointer NULL");
+  assert(vsnode() != NULL, "No space");
+  vsnode()->check_pointer(base());
+
+  // Starting address shall be aligned to chunk size.
+  const size_t required_alignment = word_size() * sizeof(MetaWord);
+  assert_is_aligned(base(), required_alignment);
+
+  // Test accessing the committed area.
+  SOMETIMES(
+    if (_committed_words > 0) {
+      for (const MetaWord* p = _base; p < _base + _committed_words; p += os::vm_page_size()) {
+        dummy = *p;
+      }
+      dummy = *(_base + _committed_words - 1);
+    }
+  )
 }
-
 #endif // ASSERT
 
-// Helper, returns a descriptive name for the given index.
+void Metachunk::print_on(outputStream* st) const {
-const char* chunk_size_name(ChunkIndex index) {
+  // Note: must also work with invalid/random data. (e.g. do not call word_size())
-  switch (index) {
+  st->print("Chunk @" PTR_FORMAT ", state %c, base " PTR_FORMAT ", "
-    case SpecializedIndex:
+            "level " CHKLVL_FORMAT " (" SIZE_FORMAT " words), "
-      return "specialized";
+            "used " SIZE_FORMAT " words, committed " SIZE_FORMAT " words.",
-    case SmallIndex:
+            p2i(this), get_state_char(), p2i(base()), level(),
-      return "small";
+            (chunklevel::is_valid_level(level()) ? chunklevel::word_size_for_level(level()) : (size_t)-1),
-    case MediumIndex:
+            used_words(), committed_words());
-      return "medium";
-    case HumongousIndex:
-      return "humongous";
-    default:
-      return "Invalid index";
-  }
-}
-
-#ifdef ASSERT
-void do_verify_chunk(Metachunk* chunk) {
-  guarantee(chunk != NULL, "Sanity");
-  // Verify chunk itself; then verify that it is consistent with the
-  // occupany map of its containing node.
-  chunk->verify();
-  VirtualSpaceNode* const vsn = chunk->container();
-  OccupancyMap* const ocmap = vsn->occupancy_map();
-  ocmap->verify_for_chunk(chunk);
-}
-#endif
-
-void do_update_in_use_info_for_chunk(Metachunk* chunk, bool inuse) {
-  chunk->set_is_tagged_free(!inuse);
-  OccupancyMap* const ocmap = chunk->container()->occupancy_map();
-  ocmap->set_region_in_use((MetaWord*)chunk, chunk->word_size(), inuse);
 }
 
 } // namespace metaspace

src/hotspot/share/memory/metaspace/metachunk.hpp

@@ -1,5 +1,6 @@
 /*
- * Copyright (c) 2012, 2019, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2012, 2020, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2020 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
@@ -21,152 +22,348 @@
  * questions.
  *
  */
+
 #ifndef SHARE_MEMORY_METASPACE_METACHUNK_HPP
 #define SHARE_MEMORY_METASPACE_METACHUNK_HPP
 
-#include "memory/metaspace/metabase.hpp"
+#include "memory/metaspace/chunklevel.hpp"
-#include "memory/metaspace/metaspaceCommon.hpp"
+#include "memory/metaspace/counters.hpp"
 #include "utilities/debug.hpp"
 #include "utilities/globalDefinitions.hpp"
 
-class MetachunkTest;
+class outputStream;
 
 namespace metaspace {
 
 class VirtualSpaceNode;
 
-//  Metachunk - Quantum of allocation from a Virtualspace
+// A Metachunk is a contiguous metaspace memory region. It is used by
-//    Metachunks are reused (when freed are put on a global freelist) and
+// a MetaspaceArena to allocate from via pointer bump (somewhat similar
-//    have no permanent association to a SpaceManager.
+// to a TLAB in java heap.
+//
+// The Metachunk object itself (the "chunk header") is separated from
+//  the memory region (the chunk payload) it describes. It also can have
+//  no payload (a "dead" chunk). In itself it lives in C-heap, managed
+//  as part of a pool of Metachunk headers (ChunkHeaderPool).
+//
+//
+// +---------+                 +---------+                 +---------+
+// |MetaChunk| <--next/prev--> |MetaChunk| <--next/prev--> |MetaChunk|   Chunk headers
+// +---------+                 +---------+                 +---------+   in C-heap
+//     |                           |                          |
+//    base                        base                       base
+//     |                          /                           |
+//    /            ---------------                           /
+//   /            /              ----------------------------
+//  |            |              /
+//  v            v              v
+// +---------+  +---------+    +-------------------+
+// |         |  |         |    |                   |
+// |  chunk  |  |  chunk  |    |      chunk        |    The real chunks ("payload")
+// |         |  |         |    |                   |    live in Metaspace
+// +---------+  +---------+    +-------------------+
+//
+//
+// -- Metachunk state --
+//
+// A Metachunk is "in-use" if it is part of a MetaspaceArena. That means
+//  its memory is used - or will be used shortly - to hold VM metadata
+//  on behalf of a class loader.
+//
+// A Metachunk is "free" if its payload is currently unused. In that
+//  case it is managed by a chunk freelist (the ChunkManager).
+//
+// A Metachunk is "dead" if it does not have a corresponding payload.
+//  In that case it lives as part of a freelist-of-dead-chunk-headers
+//  in the ChunkHeaderPool.
+//
+// A Metachunk is always part of a linked list. In-use chunks are part of
+//  the chunk list of a MetaspaceArena. Free chunks are in a freelist in
+//  the ChunkManager. Dead chunk headers are in a linked list as part
+//  of the ChunkHeaderPool.
+//
+//
+// -- Level --
+//
+// Metachunks are managed as part of a buddy style allocation scheme.
+// Sized always in steps of power-of-2, ranging from the smallest chunk size
+// (1Kb) to the largest (4Mb) (see chunklevel.hpp).
+// Its size is encoded as level, with level 0 being the largest chunk
+// size ("root chunk").
+//
+//
+// -- Payload commit state --
+//
+// A Metachunk payload (the "real chunk") may be committed, partly committed
+//  or completely uncommitted. Technically, a payload may be committed
+//  "checkered" - i.e. committed and uncommitted parts may interleave - but the
+//  important part is how much contiguous space is committed starting
+//  at the base of the payload (since that's where we allocate).
+//
+// The Metachunk keeps track of how much space is committed starting
+//  at the base of the payload - which is a performace optimization -
+//  while underlying layers (VirtualSpaceNode->commitmask) keep track
+//  of the "real" commit state, aka which granules are committed,
+//  independent on what chunks reside above those granules.
 
-//            +--------------+ <- end    --+       --+
+//            +--------------+ <- end    -----------+ ----------+
-//            |              |             |         |
+//            |              |                      |           |
-//            |              |             | free    |
+//            |              |                      |           |
-//            |              |             |         |
+//            |              |                      |           |
-//            |              |             |         | size | capacity
+//            |              |                      |           |
-//            |              |             |         |
+//            |              |                      |           |
-//            |              | <- top   -- +         |
+//            | -----------  | <- committed_top  -- +           |
-//            |              |             |         |
+//            |              |                      |           |
-//            |              |             | used    |
+//            |              |                      | "free"    |
-//            |              |             |         |
+//            |              |                      |           | size
-//            |              |             |         |
+//            |              |     "free_below_     |           |
-//            +--------------+ <- bottom --+       --+
+//            |              |        committed"    |           |
+//            |              |                      |           |
+//            |              |                      |           |
+//            | -----------  | <- top     --------- + --------  |
+//            |              |                      |           |
+//            |              |     "used"           |           |
+//            |              |                      |           |
+//            +--------------+ <- start   ----------+ ----------+
+//
+//
+// -- Relationships --
+//
+// Chunks are managed by a binary buddy style allocator
+//  (see https://en.wikipedia.org/wiki/Buddy_memory_allocation).
+// Chunks which are not a root chunk always have an adjoining buddy.
+//  The first chunk in a buddy pair is called the leader, the second
+//  one the follower.
+//
+// +----------+----------+
+// | leader   | follower |
+// +----------+----------+
+//
+//
+// -- Layout in address space --
+//
+// In order to implement buddy style allocation, we need an easy way to get
+//  from one chunk to the Metachunk representing the neighboring chunks
+//  (preceding resp. following it in memory).
+// But Metachunk headers and chunks are physically separated, and it is not
+//  possible to get the Metachunk* from the start of the chunk. Therefore
+//  Metachunk headers are part of a second linked list, describing the order
+//  in which their payload appears in memory:
+//
+// +---------+                       +---------+                       +---------+
+// |MetaChunk| <--next/prev_in_vs--> |MetaChunk| <--next/prev_in_vs--> |MetaChunk|
+// +---------+                       +---------+                       +---------+
+//     |                                 |                                  |
+//    base                              base                               base
+//     |                                 /                                  |
+//    /        --------------------------                                  /
+//   /        /          --------------------------------------------------
+//  |         |         /
+//  v         v         v
+// +---------+---------+-------------------+
+// |  chunk  |  chunk  |      chunk        |
+// +---------+---------+-------------------+
+//
 
-enum ChunkOrigin {
+class Metachunk {
-  // Chunk normally born (via take_from_committed)
-  origin_normal = 1,
-  // Chunk was born as padding chunk
-  origin_pad = 2,
-  // Chunk was born as leftover chunk in VirtualSpaceNode::retire
-  origin_leftover = 3,
-  // Chunk was born as result of a merge of smaller chunks
-  origin_merge = 4,
-  // Chunk was born as result of a split of a larger chunk
-  origin_split = 5,
 
-  origin_minimum = origin_normal,
+  // start of chunk memory; NULL if dead.
-  origin_maximum = origin_split,
+  MetaWord* _base;
-  origins_count = origin_maximum + 1
-};
 
-inline bool is_valid_chunkorigin(ChunkOrigin origin) {
+  // Used words.
-  return origin == origin_normal ||
+  size_t _used_words;
-    origin == origin_pad ||
-    origin == origin_leftover ||
-    origin == origin_merge ||
-    origin == origin_split;
-}
 
-class Metachunk : public Metabase<Metachunk> {
+  // Size of the region, starting from base, which is guaranteed to be committed. In words.
+  //  The actual size of committed regions may actually be larger.
+  //
+  //  (This is a performance optimization. The underlying VirtualSpaceNode knows
+  //   which granules are committed; but we want to avoid having to ask.)
+  size_t _committed_words;
 
-  friend class ::MetachunkTest;
+  chunklevel_t _level; // aka size.
 
-  // The VirtualSpaceNode containing this chunk.
+  // state_free:    free, owned by a ChunkManager
-  VirtualSpaceNode* const _container;
+  // state_in_use:  in-use, owned by a MetaspaceArena
-
+  // dead:          just a hollow chunk header without associated memory, owned
-  // Current allocation top.
+  //                 by chunk header pool.
-  MetaWord* _top;
+  enum class State : uint8_t {
-
+    Free = 0,
-  // A 32bit sentinel for debugging purposes.
+    InUse = 1,
-  enum { CHUNK_SENTINEL = 0x4d4554EF,  // "MET"
+    Dead = 2
-         CHUNK_SENTINEL_INVALID = 0xFEEEEEEF
   };
+  State _state;
 
-  uint32_t _sentinel;
+  // We need unfortunately a back link to the virtual space node
+  // for splitting and merging nodes.
+  VirtualSpaceNode* _vsnode;
 
-  const ChunkIndex _chunk_type;
+  // A chunk header is kept in a list:
-  const bool _is_class;
+  // 1 in the list of used chunks inside a MetaspaceArena, if it is in use
-  // Whether the chunk is free (in freelist) or in use by some class loader.
+  // 2 in the list of free chunks inside a ChunkManager, if it is free
-  bool _is_tagged_free;
+  // 3 in the freelist of unused headers inside the ChunkHeaderPool,
+  //   if it is unused (e.g. result of chunk merging) and has no associated
+  //   memory area.
+  Metachunk* _prev;
+  Metachunk* _next;
 
-  ChunkOrigin _origin;
+  // Furthermore, we keep, per chunk, information about the neighboring chunks.
-  int _use_count;
+  // This is needed to split and merge chunks.
+  //
+  // Note: These members can be modified concurrently while a chunk is alive and in use.
+  // This can happen if a neighboring chunk is added or removed.
+  // This means only read or modify these members under expand lock protection.
+  Metachunk* _prev_in_vs;
+  Metachunk* _next_in_vs;
 
-  MetaWord* initial_top() const { return (MetaWord*)this + overhead(); }
+  // Commit uncommitted section of the chunk.
-  MetaWord* top() const         { return _top; }
+  // Fails if we hit a commit limit.
+  bool commit_up_to(size_t new_committed_words);
 
- public:
+  DEBUG_ONLY(static void assert_have_expand_lock();)
-  // Metachunks are allocated out of a MetadataVirtualSpace and
-  // and use some of its space to describe itself (plus alignment
-  // considerations).  Metadata is allocated in the rest of the chunk.
-  // This size is the overhead of maintaining the Metachunk within
-  // the space.
 
-  // Alignment of each allocation in the chunks.
+public:
-  static size_t object_alignment();
 
-  // Size of the Metachunk header, in words, including alignment.
+  Metachunk() :
-  static size_t overhead();
+    _base(NULL),
+    _used_words(0),
+    _committed_words(0),
+    _level(chunklevel::ROOT_CHUNK_LEVEL),
+    _state(State::Free),
+    _vsnode(NULL),
+    _prev(NULL), _next(NULL),
+    _prev_in_vs(NULL),
+    _next_in_vs(NULL)
+  {}
 
-  Metachunk(ChunkIndex chunktype, bool is_class, size_t word_size, VirtualSpaceNode* container);
+  void clear() {
+    _base = NULL;
+    _used_words = 0; _committed_words = 0;
+    _level = chunklevel::ROOT_CHUNK_LEVEL;
+    _state = State::Free;
+    _vsnode = NULL;
+    _prev = NULL; _next = NULL;
+    _prev_in_vs = NULL; _next_in_vs = NULL;
+  }
 
-  MetaWord* allocate(size_t word_size);
+  size_t word_size() const        { return chunklevel::word_size_for_level(_level); }
 
-  VirtualSpaceNode* container() const { return _container; }
+  MetaWord* base() const          { return _base; }
+  MetaWord* top() const           { return base() + _used_words; }
+  MetaWord* committed_top() const { return base() + _committed_words; }
+  MetaWord* end() const           { return base() + word_size(); }
 
-  MetaWord* bottom() const { return (MetaWord*) this; }
+  // Chunk list wiring
+  void set_prev(Metachunk* c)     { _prev = c; }
+  Metachunk* prev() const         { return _prev; }
+  void set_next(Metachunk* c)     { _next = c; }
+  Metachunk* next() const         { return _next; }
 
-  // Reset top to bottom so chunk can be reused.
+  DEBUG_ONLY(bool in_list() const { return _prev != NULL || _next != NULL; })
-  void reset_empty() { _top = initial_top(); clear_next(); clear_prev(); }
-  bool is_empty() { return _top == initial_top(); }
 
-  // used (has been allocated)
+  // Physical neighbors wiring
-  // free (available for future allocations)
+  void set_prev_in_vs(Metachunk* c) { DEBUG_ONLY(assert_have_expand_lock()); _prev_in_vs = c; }
-  size_t word_size() const { return size(); }
+  Metachunk* prev_in_vs() const     { DEBUG_ONLY(assert_have_expand_lock()); return _prev_in_vs; }
-  size_t used_word_size() const;
+  void set_next_in_vs(Metachunk* c) { DEBUG_ONLY(assert_have_expand_lock()); _next_in_vs = c; }
-  size_t free_word_size() const;
+  Metachunk* next_in_vs() const     { DEBUG_ONLY(assert_have_expand_lock()); return _next_in_vs; }
 
-  bool is_tagged_free() { return _is_tagged_free; }
+  bool is_free() const            { return _state == State::Free; }
-  void set_is_tagged_free(bool v) { _is_tagged_free = v; }
+  bool is_in_use() const          { return _state == State::InUse; }
+  bool is_dead() const            { return _state == State::Dead; }
+  void set_free()                 { _state = State::Free; }
+  void set_in_use()               { _state = State::InUse; }
+  void set_dead()                 { _state = State::Dead; }
 
-  bool contains(const void* ptr) { return bottom() <= ptr && ptr < _top; }
+  // Return a single char presentation of the state ('f', 'u', 'd')
+  char get_state_char() const;
+
+  void inc_level()                { _level++; DEBUG_ONLY(chunklevel::is_valid_level(_level);) }
+  void dec_level()                { _level --; DEBUG_ONLY(chunklevel::is_valid_level(_level);) }
+  chunklevel_t level() const      { return _level; }
+
+  // Convenience functions for extreme levels.
+  bool is_root_chunk() const      { return chunklevel::ROOT_CHUNK_LEVEL == _level; }
+  bool is_leaf_chunk() const      { return chunklevel::HIGHEST_CHUNK_LEVEL == _level; }
+
+  VirtualSpaceNode* vsnode() const        { return _vsnode; }
+
+  size_t used_words() const                   { return _used_words; }
+  size_t free_words() const                   { return word_size() - used_words(); }
+  size_t free_below_committed_words() const   { return committed_words() - used_words(); }
+  void reset_used_words()                     { _used_words = 0; }
+
+  size_t committed_words() const      { return _committed_words; }
+  void set_committed_words(size_t v);
+  bool is_fully_committed() const     { return committed_words() == word_size(); }
+  bool is_fully_uncommitted() const   { return committed_words() == 0; }
+
+  // Ensure that chunk is committed up to at least new_committed_words words.
+  // Fails if we hit a commit limit.
+  bool ensure_committed(size_t new_committed_words);
+  bool ensure_committed_locked(size_t new_committed_words);
+
+  // Ensure that the chunk is committed far enough to serve an additional allocation of word_size.
+  bool ensure_committed_additional(size_t additional_word_size)   {
+    return ensure_committed(used_words() + additional_word_size);
+  }
+
+  // Uncommit chunk area. The area must be a common multiple of the
+  // commit granule size (in other words, we cannot uncommit chunks smaller than
+  // a commit granule size).
+  void uncommit();
+  void uncommit_locked();
+
+  // Allocation from a chunk
+
+  // Allocate word_size words from this chunk (word_size must be aligned to
+  //  allocation_alignment_words).
+  //
+  // Caller must make sure the chunk is both large enough and committed far enough
+  // to hold the allocation. Will always work.
+  //
+  MetaWord* allocate(size_t request_word_size);
+
+  // Initialize structure for reuse.
+  void initialize(VirtualSpaceNode* node, MetaWord* base, chunklevel_t lvl) {
+    clear();
+    _vsnode = node; _base = base; _level = lvl;
+  }
+
+  // Returns true if this chunk is the leader in its buddy pair, false if not.
+  // Do not call for root chunks.
+  bool is_leader() const {
+    assert(!is_root_chunk(), "Root chunks have no buddy."); // Bit harsh?
+    return is_aligned(base(), chunklevel::word_size_for_level(level() - 1) * BytesPerWord);
+  }
+
+  //// Debug stuff ////
+#ifdef ASSERT
+  void verify() const;
+  // Verifies linking with neighbors in virtual space. Needs expand lock protection.
+  void verify_neighborhood() const;
+  void zap_header(uint8_t c = 0x17);
+
+  // Returns true if given pointer points into the payload area of this chunk.
+  bool is_valid_pointer(const MetaWord* p) const {
+    return base() <= p && p < top();
+  }
+
+  // Returns true if given pointer points into the commmitted payload area of this chunk.
+  bool is_valid_committed_pointer(const MetaWord* p) const {
+    return base() <= p && p < committed_top();
+  }
+
+#endif // ASSERT
 
   void print_on(outputStream* st) const;
 
-  bool is_valid_sentinel() const        { return _sentinel == CHUNK_SENTINEL; }
-  void remove_sentinel()                { _sentinel = CHUNK_SENTINEL_INVALID; }
-
-  int get_use_count() const             { return _use_count; }
-  void inc_use_count()                  { _use_count ++; }
-
-  ChunkOrigin get_origin() const        { return _origin; }
-  void set_origin(ChunkOrigin orig)     { _origin = orig; }
-
-  ChunkIndex get_chunk_type() const     { return _chunk_type; }
-  bool is_class() const                 { return _is_class; }
-
-  DEBUG_ONLY(void mangle(juint word_value);)
-  DEBUG_ONLY(void verify() const;)
-
 };
 
+// Little print helpers: since we often print out chunks, here some convenience macros
+#define METACHUNK_FORMAT                "@" PTR_FORMAT ", %c, base " PTR_FORMAT ", level " CHKLVL_FORMAT
+#define METACHUNK_FORMAT_ARGS(chunk)    p2i(chunk), chunk->get_state_char(), p2i(chunk->base()), chunk->level()
 
-// Helper function that does a bunch of checks for a chunk.
+#define METACHUNK_FULL_FORMAT                "@" PTR_FORMAT ", %c, base " PTR_FORMAT ", level " CHKLVL_FORMAT " (" SIZE_FORMAT "), used: " SIZE_FORMAT ", committed: " SIZE_FORMAT ", committed-free: " SIZE_FORMAT
-DEBUG_ONLY(void do_verify_chunk(Metachunk* chunk);)
+#define METACHUNK_FULL_FORMAT_ARGS(chunk)    p2i(chunk), chunk->get_state_char(), p2i(chunk->base()), chunk->level(), chunk->word_size(), chunk->used_words(), chunk->committed_words(), chunk->free_below_committed_words()
-
-// Given a Metachunk, update its in-use information (both in the
-// chunk and the occupancy map).
-void do_update_in_use_info_for_chunk(Metachunk* chunk, bool inuse);
 
 } // namespace metaspace
 

src/hotspot/share/memory/metaspace/metachunkList.cpp

@@ -0,0 +1,107 @@
+/*
+ * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2020 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
+ * 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 "precompiled.hpp"
+#include "memory/metaspace/metachunkList.hpp"
+#include "memory/metaspace/metaspaceCommon.hpp"
+#include "utilities/debug.hpp"
+#include "utilities/globalDefinitions.hpp"
+#include "utilities/ostream.hpp"
+
+namespace metaspace {
+
+#ifdef ASSERT
+
+void MetachunkList::verify_does_not_contain(const Metachunk* c) const {
+  SOMETIMES(assert(contains(c) == false, "List contains this chunk.");)
+}
+
+bool MetachunkList::contains(const Metachunk* c) const {
+  for (Metachunk* c2 = _first; c2 != NULL; c2 = c2->next()) {
+    if (c == c2) {
+      return true;
+    }
+  }
+  return false;
+}
+
+void MetachunkList::verify() const {
+  int num = 0;
+  const Metachunk* last_c = NULL;
+  for (const Metachunk* c = _first; c != NULL; c = c->next()) {
+    num++;
+    assert(c->prev() != c && c->next() != c, "circularity");
+    assert(c->prev() == last_c,
+           "Broken link to predecessor. Chunk " METACHUNK_FULL_FORMAT ".",
+           METACHUNK_FULL_FORMAT_ARGS(c));
+    c->verify();
+    last_c = c;
+  }
+  _num_chunks.check(num);
+}
+
+#endif // ASSERT
+
+size_t MetachunkList::calc_committed_word_size() const {
+  if (_first != NULL && _first->is_dead()) {
+    // list used for chunk header pool; dead chunks have no size.
+    return 0;
+  }
+  size_t s = 0;
+  for (Metachunk* c = _first; c != NULL; c = c->next()) {
+    assert(c->is_dead() == false, "Sanity");
+    s += c->committed_words();
+  }
+  return s;
+}
+
+size_t MetachunkList::calc_word_size() const {
+  if (_first != NULL && _first->is_dead()) {
+    // list used for chunk header pool; dead chunks have no size.
+    return 0;
+  }
+  size_t s = 0;
+  for (Metachunk* c = _first; c != NULL; c = c->next()) {
+    assert(c->is_dead() == false, "Sanity");
+    s += c->committed_words();
+  }
+  return s;
+}
+
+void MetachunkList::print_on(outputStream* st) const {
+  if (_num_chunks.get() > 0) {
+    for (const Metachunk* c = _first; c != NULL; c = c->next()) {
+      st->print(" - <");
+      c->print_on(st);
+      st->print(">");
+    }
+    st->print(" - total : %d chunks.", _num_chunks.get());
+  } else {
+    st->print("empty");
+  }
+}
+
+} // namespace metaspace
+

src/hotspot/share/memory/metaspace/metachunkList.hpp

@@ -0,0 +1,103 @@
+/*
+ * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2020 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
+ * 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.
+ *
+ */
+
+#ifndef SHARE_MEMORY_METASPACE_METACHUNKLIST_HPP
+#define SHARE_MEMORY_METASPACE_METACHUNKLIST_HPP
+
+#include "memory/metaspace/counters.hpp"
+#include "memory/metaspace/metachunk.hpp"
+#include "utilities/globalDefinitions.hpp"
+
+class outputStream;
+
+namespace metaspace {
+
+// A simple single-linked list of chunks, used in MetaspaceArena to keep
+//  a list of retired chunks, as well as in the ChunkHeaderPool to keep
+//  a cache of unused chunk headers.
+
+class MetachunkList {
+
+  Metachunk* _first;
+  IntCounter _num_chunks;
+
+  // Note: The chunks inside this list may be dead (->chunk header pool).
+  // So, do not call c->word size on them or anything else which may not
+  // work with dead chunks.
+
+  // Check that list does not contain the given chunk; Note that since that check
+  //  is expensive, it is subject to VerifyMetaspaceInterval.
+  DEBUG_ONLY(void verify_does_not_contain(const Metachunk* c) const;)
+
+public:
+
+  MetachunkList() : _first(NULL), _num_chunks() {}
+
+  int count() const { return _num_chunks.get(); }
+
+  void add(Metachunk* c) {
+    DEBUG_ONLY(verify_does_not_contain(c);)
+    c->set_next(_first);
+    if (_first) {
+      _first->set_prev(c);
+    }
+    _first = c;
+    _num_chunks.increment();
+  }
+
+  Metachunk* remove_first() {
+    if (_first) {
+      Metachunk* c = _first;
+      _first = _first->next();
+      if (_first) {
+        _first->set_prev(NULL);
+      }
+      _num_chunks.decrement();
+      c->set_prev(NULL);
+      c->set_next(NULL);
+      return c;
+    }
+    return NULL;
+  }
+
+  Metachunk* first()              { return _first; }
+  const Metachunk* first() const  { return _first; }
+
+#ifdef ASSERT
+  // Note: linear search
+  bool contains(const Metachunk* c) const;
+  void verify() const;
+#endif
+
+  size_t calc_committed_word_size() const;
+  size_t calc_word_size() const;
+
+  void print_on(outputStream* st) const;
+
+};
+
+} // namespace metaspace
+
+#endif // SHARE_MEMORY_METASPACE_METACHUNKLIST_HPP

src/hotspot/share/memory/metaspace/metaspaceArena.cpp

@@ -0,0 +1,497 @@
+/*
+ * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2020 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
+ * 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 "precompiled.hpp"
+#include "logging/log.hpp"
+#include "logging/logStream.hpp"
+#include "memory/metaspace/allocationGuard.hpp"
+#include "memory/metaspace/chunkManager.hpp"
+#include "memory/metaspace/counters.hpp"
+#include "memory/metaspace/freeBlocks.hpp"
+#include "memory/metaspace/internalStats.hpp"
+#include "memory/metaspace/metachunk.hpp"
+#include "memory/metaspace/metaspaceArena.hpp"
+#include "memory/metaspace/metaspaceArenaGrowthPolicy.hpp"
+#include "memory/metaspace/metaspaceCommon.hpp"
+#include "memory/metaspace/metaspaceSettings.hpp"
+#include "memory/metaspace/metaspaceStatistics.hpp"
+#include "memory/metaspace/virtualSpaceList.hpp"
+#include "runtime/atomic.hpp"
+#include "runtime/init.hpp"
+#include "runtime/mutexLocker.hpp"
+#include "services/memoryService.hpp"
+#include "utilities/align.hpp"
+#include "utilities/debug.hpp"
+#include "utilities/globalDefinitions.hpp"
+
+namespace metaspace {
+
+#define LOGFMT         "Arena @" PTR_FORMAT " (%s)"
+#define LOGFMT_ARGS    p2i(this), this->_name
+
+// Returns the level of the next chunk to be added, acc to growth policy.
+chunklevel_t MetaspaceArena::next_chunk_level() const {
+  const int growth_step = _chunks.count();
+  return _growth_policy->get_level_at_step(growth_step);
+}
+
+// Given a chunk, add its remaining free committed space to the free block list.
+void MetaspaceArena::salvage_chunk(Metachunk* c) {
+  if (Settings::handle_deallocations() == false) {
+    return;
+  }
+
+  assert_lock_strong(lock());
+  size_t remaining_words = c->free_below_committed_words();
+  if (remaining_words > FreeBlocks::MinWordSize) {
+
+    UL2(trace, "salvaging chunk " METACHUNK_FULL_FORMAT ".", METACHUNK_FULL_FORMAT_ARGS(c));
+
+    MetaWord* ptr = c->allocate(remaining_words);
+    assert(ptr != NULL, "Should have worked");
+    _total_used_words_counter->increment_by(remaining_words);
+
+    add_allocation_to_fbl(ptr, remaining_words);
+
+    // After this operation: the chunk should have no free committed space left.
+    assert(c->free_below_committed_words() == 0,
+           "Salvaging chunk failed (chunk " METACHUNK_FULL_FORMAT ").",
+           METACHUNK_FULL_FORMAT_ARGS(c));
+  }
+}
+
+// Allocate a new chunk from the underlying chunk manager able to hold at least
+// requested word size.
+Metachunk* MetaspaceArena::allocate_new_chunk(size_t requested_word_size) {
+  assert_lock_strong(lock());
+
+  // Should this ever happen, we need to increase the maximum possible chunk size.
+  guarantee(requested_word_size <= chunklevel::MAX_CHUNK_WORD_SIZE,
+            "Requested size too large (" SIZE_FORMAT ") - max allowed size per allocation is " SIZE_FORMAT ".",
+            requested_word_size, chunklevel::MAX_CHUNK_WORD_SIZE);
+
+  const chunklevel_t max_level = chunklevel::level_fitting_word_size(requested_word_size);
+  const chunklevel_t preferred_level = MIN2(max_level, next_chunk_level());
+
+  Metachunk* c = _chunk_manager->get_chunk(preferred_level, max_level, requested_word_size);
+  if (c == NULL) {
+    return NULL;
+  }
+
+  assert(c->is_in_use(), "Wrong chunk state.");
+  assert(c->free_below_committed_words() >= requested_word_size, "Chunk not committed");
+  return c;
+}
+
+void MetaspaceArena::add_allocation_to_fbl(MetaWord* p, size_t word_size) {
+  assert(Settings::handle_deallocations(), "Sanity");
+  if (_fbl == NULL) {
+    _fbl = new FreeBlocks(); // Create only on demand
+  }
+  _fbl->add_block(p, word_size);
+}
+
+MetaspaceArena::MetaspaceArena(ChunkManager* chunk_manager, const ArenaGrowthPolicy* growth_policy,
+                               Mutex* lock, SizeAtomicCounter* total_used_words_counter,
+                               const char* name) :
+  _lock(lock),
+  _chunk_manager(chunk_manager),
+  _growth_policy(growth_policy),
+  _chunks(),
+  _fbl(NULL),
+  _total_used_words_counter(total_used_words_counter),
+  _name(name)
+{
+  UL(debug, ": born.");
+
+  // Update statistics
+  InternalStats::inc_num_arena_births();
+}
+
+MetaspaceArena::~MetaspaceArena() {
+#ifdef ASSERT
+  verify();
+  if (Settings::use_allocation_guard()) {
+    verify_allocation_guards();
+  }
+#endif
+
+  MutexLocker fcl(lock(), Mutex::_no_safepoint_check_flag);
+  MemRangeCounter return_counter;
+
+  Metachunk* c = _chunks.first();
+  Metachunk* c2 = NULL;
+
+  while (c) {
+    c2 = c->next();
+    return_counter.add(c->used_words());
+    DEBUG_ONLY(c->set_prev(NULL);)
+    DEBUG_ONLY(c->set_next(NULL);)
+    UL2(debug, "return chunk: " METACHUNK_FORMAT ".", METACHUNK_FORMAT_ARGS(c));
+    _chunk_manager->return_chunk(c);
+    // c may be invalid after return_chunk(c) was called. Don't access anymore.
+    c = c2;
+  }
+
+  UL2(info, "returned %d chunks, total capacity " SIZE_FORMAT " words.",
+      return_counter.count(), return_counter.total_size());
+
+  _total_used_words_counter->decrement_by(return_counter.total_size());
+  DEBUG_ONLY(chunk_manager()->verify();)
+  delete _fbl;
+  UL(debug, ": dies.");
+
+  // Update statistics
+  InternalStats::inc_num_arena_deaths();
+}
+
+// Attempt to enlarge the current chunk to make it large enough to hold at least
+//  requested_word_size additional words.
+//
+// On success, true is returned, false otherwise.
+bool MetaspaceArena::attempt_enlarge_current_chunk(size_t requested_word_size) {
+  assert_lock_strong(lock());
+
+  Metachunk* c = current_chunk();
+  assert(c->free_words() < requested_word_size, "Sanity");
+
+  // Not if chunk enlargment is switched off...
+  if (Settings::enlarge_chunks_in_place() == false) {
+    return false;
+  }
+  // ... nor if we are already a root chunk ...
+  if (c->is_root_chunk()) {
+    return false;
+  }
+  // ... nor if the combined size of chunk content and new content would bring us above the size of a root chunk ...
+  if ((c->used_words() + requested_word_size) > metaspace::chunklevel::MAX_CHUNK_WORD_SIZE) {
+    return false;
+  }
+
+  const chunklevel_t new_level =
+      chunklevel::level_fitting_word_size(c->used_words() + requested_word_size);
+  assert(new_level < c->level(), "Sanity");
+
+  // Atm we only enlarge by one level (so, doubling the chunk in size). So, if the requested enlargement
+  // would require the chunk to more than double in size, we bail. But this covers about 99% of all cases,
+  // so this is good enough.
+  if (new_level < c->level() - 1) {
+    return false;
+  }
+  // This only works if chunk is the leader of its buddy pair (and also if buddy
+  // is free and unsplit, but that we cannot check outside of metaspace lock).
+  if (!c->is_leader()) {
+    return false;
+  }
+  // If the size added to the chunk would be larger than allowed for the next growth step
+  // dont enlarge.
+  if (next_chunk_level() > c->level()) {
+    return false;
+  }
+
+  bool success = _chunk_manager->attempt_enlarge_chunk(c);
+  assert(success == false || c->free_words() >= requested_word_size, "Sanity");
+  return success;
+}
+
+// Allocate memory from Metaspace.
+// 1) Attempt to allocate from the free block list.
+// 2) Attempt to allocate from the current chunk.
+// 3) Attempt to enlarge the current chunk in place if it is too small.
+// 4) Attempt to get a new chunk and allocate from that chunk.
+// At any point, if we hit a commit limit, we return NULL.
+MetaWord* MetaspaceArena::allocate(size_t requested_word_size) {
+  MutexLocker cl(lock(), Mutex::_no_safepoint_check_flag);
+  UL2(trace, "requested " SIZE_FORMAT " words.", requested_word_size);
+
+  MetaWord* p = NULL;
+  const size_t raw_word_size = get_raw_word_size_for_requested_word_size(requested_word_size);
+
+  // 1) Attempt to allocate from the free blocks list
+  //    (Note: to reduce complexity, deallocation handling is disabled if allocation guards
+  //     are enabled, see Settings::ergo_initialize())
+  if (Settings::handle_deallocations() && _fbl != NULL && !_fbl->is_empty()) {
+    p = _fbl->remove_block(raw_word_size);
+    if (p != NULL) {
+      DEBUG_ONLY(InternalStats::inc_num_allocs_from_deallocated_blocks();)
+      UL2(trace, "taken from fbl (now: %d, " SIZE_FORMAT ").",
+          _fbl->count(), _fbl->total_size());
+      // Note: Space which is kept in the freeblock dictionary still counts as used as far
+      //  as statistics go; therefore we skip the epilogue in this function to avoid double
+      //  accounting.
+      return p;
+    }
+  }
+
+  bool current_chunk_too_small = false;
+  bool commit_failure = false;
+
+  if (current_chunk() != NULL) {
+
+    // 2) Attempt to satisfy the allocation from the current chunk.
+
+    // If the current chunk is too small to hold the requested size, attempt to enlarge it.
+    // If that fails, retire the chunk.
+    if (current_chunk()->free_words() < raw_word_size) {
+      if (!attempt_enlarge_current_chunk(raw_word_size)) {
+        current_chunk_too_small = true;
+      } else {
+        DEBUG_ONLY(InternalStats::inc_num_chunks_enlarged();)
+        UL(debug, "enlarged chunk.");
+      }
+    }
+
+    // Commit the chunk far enough to hold the requested word size. If that fails, we
+    // hit a limit (either GC threshold or MaxMetaspaceSize). In that case retire the
+    // chunk.
+    if (!current_chunk_too_small) {
+      if (!current_chunk()->ensure_committed_additional(raw_word_size)) {
+        UL2(info, "commit failure (requested size: " SIZE_FORMAT ")", raw_word_size);
+        commit_failure = true;
+      }
+    }
+
+    // Allocate from the current chunk. This should work now.
+    if (!current_chunk_too_small && !commit_failure) {
+      p = current_chunk()->allocate(raw_word_size);
+      assert(p != NULL, "Allocation from chunk failed.");
+    }
+  }
+
+  if (p == NULL) {
+    // If we are here, we either had no current chunk to begin with or it was deemed insufficient.
+    assert(current_chunk() == NULL ||
+           current_chunk_too_small || commit_failure, "Sanity");
+
+    Metachunk* new_chunk = allocate_new_chunk(raw_word_size);
+    if (new_chunk != NULL) {
+      UL2(debug, "allocated new chunk " METACHUNK_FORMAT " for requested word size " SIZE_FORMAT ".",
+          METACHUNK_FORMAT_ARGS(new_chunk), requested_word_size);
+
+      assert(new_chunk->free_below_committed_words() >= raw_word_size, "Sanity");
+      if (Settings::new_chunks_are_fully_committed()) {
+        assert(new_chunk->is_fully_committed(), "Chunk should be fully committed.");
+      }
+
+      // We have a new chunk. Before making it the current chunk, retire the old one.
+      if (current_chunk() != NULL) {
+        salvage_chunk(current_chunk());
+        DEBUG_ONLY(InternalStats::inc_num_chunks_retired();)
+      }
+
+      _chunks.add(new_chunk);
+
+      // Now, allocate from that chunk. That should work.
+      p = current_chunk()->allocate(raw_word_size);
+      assert(p != NULL, "Allocation from chunk failed.");
+    } else {
+      UL2(info, "failed to allocate new chunk for requested word size " SIZE_FORMAT ".", requested_word_size);
+    }
+  }
+
+#ifdef ASSERT
+  // When using allocation guards, establish a prefix.
+  if (p != NULL && Settings::use_allocation_guard()) {
+    p = establish_prefix(p, raw_word_size);
+  }
+#endif
+
+  if (p == NULL) {
+    InternalStats::inc_num_allocs_failed_limit();
+  } else {
+    DEBUG_ONLY(InternalStats::inc_num_allocs();)
+    _total_used_words_counter->increment_by(raw_word_size);
+  }
+
+  SOMETIMES(verify_locked();)
+
+  if (p == NULL) {
+    UL(info, "allocation failed, returned NULL.");
+  } else {
+    UL2(trace, "after allocation: %u chunk(s), current:" METACHUNK_FULL_FORMAT,
+        _chunks.count(), METACHUNK_FULL_FORMAT_ARGS(current_chunk()));
+    UL2(trace, "returning " PTR_FORMAT ".", p2i(p));
+  }
+  return p;
+}
+
+// Prematurely returns a metaspace allocation to the _block_freelists
+// because it is not needed anymore (requires CLD lock to be active).
+void MetaspaceArena::deallocate_locked(MetaWord* p, size_t word_size) {
+  if (Settings::handle_deallocations() == false) {
+    return;
+  }
+
+  assert_lock_strong(lock());
+  // At this point a current chunk must exist since we only deallocate if we did allocate before.
+  assert(current_chunk() != NULL, "stray deallocation?");
+  assert(is_valid_area(p, word_size),
+         "Pointer range not part of this Arena and cannot be deallocated: (" PTR_FORMAT ".." PTR_FORMAT ").",
+         p2i(p), p2i(p + word_size));
+
+  UL2(trace, "deallocating " PTR_FORMAT ", word size: " SIZE_FORMAT ".",
+      p2i(p), word_size);
+
+  size_t raw_word_size = get_raw_word_size_for_requested_word_size(word_size);
+  add_allocation_to_fbl(p, raw_word_size);
+
+  DEBUG_ONLY(verify_locked();)
+}
+
+// Prematurely returns a metaspace allocation to the _block_freelists because it is not
+// needed anymore.
+void MetaspaceArena::deallocate(MetaWord* p, size_t word_size) {
+  MutexLocker cl(lock(), Mutex::_no_safepoint_check_flag);
+  deallocate_locked(p, word_size);
+}
+
+// Update statistics. This walks all in-use chunks.
+void MetaspaceArena::add_to_statistics(ArenaStats* out) const {
+  MutexLocker cl(lock(), Mutex::_no_safepoint_check_flag);
+
+  for (const Metachunk* c = _chunks.first(); c != NULL; c = c->next()) {
+    InUseChunkStats& ucs = out->_stats[c->level()];
+    ucs._num++;
+    ucs._word_size += c->word_size();
+    ucs._committed_words += c->committed_words();
+    ucs._used_words += c->used_words();
+    // Note: for free and waste, we only count what's committed.
+    if (c == current_chunk()) {
+      ucs._free_words += c->free_below_committed_words();
+    } else {
+      ucs._waste_words += c->free_below_committed_words();
+    }
+  }
+
+  if (_fbl != NULL) {
+    out->_free_blocks_num += _fbl->count();
+    out->_free_blocks_word_size += _fbl->total_size();
+  }
+
+  SOMETIMES(out->verify();)
+}
+
+// Convenience method to get the most important usage statistics.
+// For deeper analysis use add_to_statistics().
+void MetaspaceArena::usage_numbers(size_t* p_used_words, size_t* p_committed_words, size_t* p_capacity_words) const {
+  MutexLocker cl(lock(), Mutex::_no_safepoint_check_flag);
+  size_t used = 0, comm = 0, cap = 0;
+  for (const Metachunk* c = _chunks.first(); c != NULL; c = c->next()) {
+    used += c->used_words();
+    comm += c->committed_words();
+    cap += c->word_size();
+  }
+  if (p_used_words != NULL) {
+    *p_used_words = used;
+  }
+  if (p_committed_words != NULL) {
+    *p_committed_words = comm;
+  }
+  if (p_capacity_words != NULL) {
+    *p_capacity_words = cap;
+  }
+}
+
+#ifdef ASSERT
+
+void MetaspaceArena::verify_locked() const {
+  assert_lock_strong(lock());
+  assert(_growth_policy != NULL && _chunk_manager != NULL, "Sanity");
+  _chunks.verify();
+  if (_fbl != NULL) {
+    _fbl->verify();
+  }
+}
+
+void MetaspaceArena::verify_allocation_guards() const {
+  assert(Settings::use_allocation_guard(), "Don't call with guards disabled.");
+
+  // Verify canaries of all allocations.
+  // (We can walk all allocations since at the start of a chunk an allocation
+  //  must be present, and the allocation header contains its size, so we can
+  //  find the next one).
+  for (const Metachunk* c = _chunks.first(); c != NULL; c = c->next()) {
+    const Prefix* first_broken_block = NULL;
+    int num_broken_blocks = 0;
+    const MetaWord* p = c->base();
+    while (p < c->top()) {
+      const Prefix* pp = (const Prefix*)p;
+      if (!pp->is_valid()) {
+        UL2(error, "Corrupt block at " PTR_FORMAT " (chunk: " METACHUNK_FORMAT ").",
+            p2i(pp), METACHUNK_FORMAT_ARGS(c));
+        if (first_broken_block == NULL) {
+          first_broken_block = pp;
+        }
+        num_broken_blocks ++;
+      }
+      p += pp->_word_size;
+    }
+    // After examining all blocks in a chunk, assert if any of those blocks
+    // was found to be corrupted.
+    if (first_broken_block != NULL) {
+      assert(false, "Corrupt block: found at least %d corrupt metaspace block(s) - "
+             "first corrupted block at " PTR_FORMAT ".",
+             num_broken_blocks, p2i(first_broken_block));
+    }
+  }
+}
+
+void MetaspaceArena::verify() const {
+  MutexLocker cl(lock(), Mutex::_no_safepoint_check_flag);
+  verify_locked();
+}
+
+// Returns true if the area indicated by pointer and size have actually been allocated
+// from this arena.
+bool MetaspaceArena::is_valid_area(MetaWord* p, size_t word_size) const {
+  assert(p != NULL && word_size > 0, "Sanity");
+  bool found = false;
+  for (const Metachunk* c = _chunks.first(); c != NULL && !found; c = c->next()) {
+    assert(c->is_valid_committed_pointer(p) ==
+           c->is_valid_committed_pointer(p + word_size - 1), "range intersects");
+    found = c->is_valid_committed_pointer(p);
+  }
+  return found;
+}
+
+#endif // ASSERT
+
+void MetaspaceArena::print_on(outputStream* st) const {
+  MutexLocker fcl(_lock, Mutex::_no_safepoint_check_flag);
+  print_on_locked(st);
+}
+
+void MetaspaceArena::print_on_locked(outputStream* st) const {
+  assert_lock_strong(_lock);
+  st->print_cr("sm %s: %d chunks, total word size: " SIZE_FORMAT ", committed word size: " SIZE_FORMAT, _name,
+               _chunks.count(), _chunks.calc_word_size(), _chunks.calc_committed_word_size());
+  _chunks.print_on(st);
+  st->cr();
+  st->print_cr("growth-policy " PTR_FORMAT ", lock " PTR_FORMAT ", cm " PTR_FORMAT ", fbl " PTR_FORMAT,
+                p2i(_growth_policy), p2i(_lock), p2i(_chunk_manager), p2i(_fbl));
+}
+
+} // namespace metaspace
+

src/hotspot/share/memory/metaspace/metaspaceArena.hpp

@@ -0,0 +1,180 @@
+/*
+ * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2020 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
+ * 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.
+ *
+ */
+
+#ifndef SHARE_MEMORY_METASPACE_METASPACEARENA_HPP
+#define SHARE_MEMORY_METASPACE_METASPACEARENA_HPP
+
+#include "memory/allocation.hpp"
+#include "memory/metaspace.hpp"
+#include "memory/metaspace/chunkManager.hpp"
+#include "memory/metaspace/counters.hpp"
+#include "memory/metaspace/metachunk.hpp"
+#include "memory/metaspace/metachunkList.hpp"
+#include "memory/metaspace/metaspaceCommon.hpp"
+
+class outputStream;
+class Mutex;
+
+namespace metaspace {
+
+class ArenaGrowthPolicy;
+class FreeBlocks;
+
+struct ArenaStats;
+
+// The MetaspaceArena is a growable metaspace memory pool belonging to a CLD;
+//  internally it consists of a list of metaspace chunks, of which the head chunk
+//  is the current chunk from which we allocate via pointer bump.
+//
+//  +---------------+
+//  |     Arena     |
+//  +---------------+
+//            |
+//            | _chunks                                               commit top
+//            |                                                       v
+//        +----------+      +----------+      +----------+      +----------+
+//        | retired  | ---> | retired  | ---> | retired  | ---> | current  |
+//        | chunk    |      | chunk    |      | chunk    |      | chunk    |
+//        +----------+      +----------+      +----------+      +----------+
+//                                                                  ^
+//                                                                  used top
+//
+//        +------------+
+//        | FreeBlocks | --> O -> O -> O -> O
+//        +------------+
+//
+//
+
+// When the current chunk is used up, MetaspaceArena requestes a new chunk from
+//  the associated ChunkManager.
+//
+// MetaspaceArena also keeps a FreeBlocks structure to manage memory blocks which
+//  had been deallocated prematurely.
+//
+
+class MetaspaceArena : public CHeapObj<mtClass> {
+
+  // Reference to an outside lock to use for synchronizing access to this arena.
+  //  This lock is normally owned by the CLD which owns the ClassLoaderMetaspace which
+  //  owns this arena.
+  // Todo: This should be changed. Either the CLD should synchronize access to the
+  //       CLMS and its arenas itself, or the arena should have an own lock. The latter
+  //       would allow for more fine granular locking since it would allow access to
+  //       both class- and non-class arena in the CLMS independently.
+  Mutex* const _lock;
+
+  // Reference to the chunk manager to allocate chunks from.
+  ChunkManager* const _chunk_manager;
+
+  // Reference to the growth policy to use.
+  const ArenaGrowthPolicy* const _growth_policy;
+
+  // List of chunks. Head of the list is the current chunk.
+  MetachunkList _chunks;
+
+  // Structure to take care of leftover/deallocated space in used chunks.
+  // Owned by the Arena. Gets allocated on demand only.
+  FreeBlocks* _fbl;
+
+  Metachunk* current_chunk()              { return _chunks.first(); }
+  const Metachunk* current_chunk() const  { return _chunks.first(); }
+
+  // Reference to an outside counter to keep track of used space.
+  SizeAtomicCounter* const _total_used_words_counter;
+
+  // A name for purely debugging/logging purposes.
+  const char* const _name;
+
+  Mutex* lock() const                           { return _lock; }
+  ChunkManager* chunk_manager() const           { return _chunk_manager; }
+
+  // free block list
+  FreeBlocks* fbl() const                       { return _fbl; }
+  void add_allocation_to_fbl(MetaWord* p, size_t word_size);
+
+  // Given a chunk, add its remaining free committed space to the free block list.
+  void salvage_chunk(Metachunk* c);
+
+  // Allocate a new chunk from the underlying chunk manager able to hold at least
+  // requested word size.
+  Metachunk* allocate_new_chunk(size_t requested_word_size);
+
+  // Returns the level of the next chunk to be added, acc to growth policy.
+  chunklevel_t next_chunk_level() const;
+
+  // Attempt to enlarge the current chunk to make it large enough to hold at least
+  //  requested_word_size additional words.
+  //
+  // On success, true is returned, false otherwise.
+  bool attempt_enlarge_current_chunk(size_t requested_word_size);
+
+  // Prematurely returns a metaspace allocation to the _block_freelists
+  // because it is not needed anymore (requires CLD lock to be active).
+  void deallocate_locked(MetaWord* p, size_t word_size);
+
+  // Returns true if the area indicated by pointer and size have actually been allocated
+  // from this arena.
+  DEBUG_ONLY(bool is_valid_area(MetaWord* p, size_t word_size) const;)
+
+public:
+
+  MetaspaceArena(ChunkManager* chunk_manager, const ArenaGrowthPolicy* growth_policy,
+                 Mutex* lock, SizeAtomicCounter* total_used_words_counter,
+                 const char* name);
+
+  ~MetaspaceArena();
+
+  // Allocate memory from Metaspace.
+  // 1) Attempt to allocate from the dictionary of deallocated blocks.
+  // 2) Attempt to allocate from the current chunk.
+  // 3) Attempt to enlarge the current chunk in place if it is too small.
+  // 4) Attempt to get a new chunk and allocate from that chunk.
+  // At any point, if we hit a commit limit, we return NULL.
+  MetaWord* allocate(size_t word_size);
+
+  // Prematurely returns a metaspace allocation to the _block_freelists because it is not
+  // needed anymore.
+  void deallocate(MetaWord* p, size_t word_size);
+
+  // Update statistics. This walks all in-use chunks.
+  void add_to_statistics(ArenaStats* out) const;
+
+  // Convenience method to get the most important usage statistics.
+  // For deeper analysis use add_to_statistics().
+  void usage_numbers(size_t* p_used_words, size_t* p_committed_words, size_t* p_capacity_words) const;
+
+  DEBUG_ONLY(void verify() const;)
+  DEBUG_ONLY(void verify_locked() const;)
+  DEBUG_ONLY(void verify_allocation_guards() const;)
+
+  void print_on(outputStream* st) const;
+  void print_on_locked(outputStream* st) const;
+
+};
+
+} // namespace metaspace
+
+#endif // SHARE_MEMORY_METASPACE_METASPACEARENA_HPP
+

src/hotspot/share/memory/metaspace/metaspaceArenaGrowthPolicy.cpp

@@ -0,0 +1,126 @@
+/*
+ * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2020 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
+ * 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 "precompiled.hpp"
+#include "memory/metaspace/metaspaceArenaGrowthPolicy.hpp"
+#include "utilities/globalDefinitions.hpp"
+
+namespace metaspace {
+
+// hard-coded chunk allocation sequences for various space types
+//  (Note: when modifying this, don't add jumps of more than double the
+//   last chunk size. There is a gtest testing this, see test_arenagrowthpolicy.cpp)
+
+static const chunklevel_t g_sequ_standard_non_class[] = {
+    chunklevel::CHUNK_LEVEL_4K,
+    chunklevel::CHUNK_LEVEL_4K,
+    chunklevel::CHUNK_LEVEL_4K,
+    chunklevel::CHUNK_LEVEL_8K,
+    chunklevel::CHUNK_LEVEL_16K
+    // .. repeat last
+};
+
+static const chunklevel_t g_sequ_standard_class[] = {
+    chunklevel::CHUNK_LEVEL_2K,
+    chunklevel::CHUNK_LEVEL_2K,
+    chunklevel::CHUNK_LEVEL_4K,
+    chunklevel::CHUNK_LEVEL_8K,
+    chunklevel::CHUNK_LEVEL_16K
+    // .. repeat last
+};
+
+static const chunklevel_t g_sequ_anon_non_class[] = {
+   chunklevel::CHUNK_LEVEL_1K,
+   // .. repeat last
+};
+
+static const chunklevel_t g_sequ_anon_class[] = {
+    chunklevel::CHUNK_LEVEL_1K,
+    // .. repeat last
+};
+
+static const chunklevel_t g_sequ_refl_non_class[] = {
+    chunklevel::CHUNK_LEVEL_2K,
+    chunklevel::CHUNK_LEVEL_1K
+    // .. repeat last
+};
+
+static const chunklevel_t g_sequ_refl_class[] = {
+    chunklevel::CHUNK_LEVEL_1K,
+    // .. repeat last
+};
+
+// Boot class loader: give it large chunks: beyond commit granule size
+// (typically 64K) the costs for large chunks largely diminishes since
+// they are committed on the fly.
+static const chunklevel_t g_sequ_boot_non_class[] = {
+    chunklevel::CHUNK_LEVEL_4M,
+    chunklevel::CHUNK_LEVEL_1M
+    // .. repeat last
+};
+
+static const chunklevel_t g_sequ_boot_class[] = {
+    chunklevel::CHUNK_LEVEL_256K
+    // .. repeat last
+};
+
+const ArenaGrowthPolicy* ArenaGrowthPolicy::policy_for_space_type(Metaspace::MetaspaceType space_type, bool is_class) {
+
+#define DEFINE_CLASS_FOR_ARRAY(what) \
+  static ArenaGrowthPolicy chunk_alloc_sequence_##what (g_sequ_##what, sizeof(g_sequ_##what)/sizeof(chunklevel_t));
+
+  DEFINE_CLASS_FOR_ARRAY(standard_non_class)
+  DEFINE_CLASS_FOR_ARRAY(standard_class)
+  DEFINE_CLASS_FOR_ARRAY(anon_non_class)
+  DEFINE_CLASS_FOR_ARRAY(anon_class)
+  DEFINE_CLASS_FOR_ARRAY(refl_non_class)
+  DEFINE_CLASS_FOR_ARRAY(refl_class)
+  DEFINE_CLASS_FOR_ARRAY(boot_non_class)
+  DEFINE_CLASS_FOR_ARRAY(boot_class)
+
+  if (is_class) {
+    switch(space_type) {
+    case Metaspace::StandardMetaspaceType:          return &chunk_alloc_sequence_standard_class;
+    case Metaspace::ReflectionMetaspaceType:        return &chunk_alloc_sequence_refl_class;
+    case Metaspace::ClassMirrorHolderMetaspaceType: return &chunk_alloc_sequence_anon_class;
+    case Metaspace::BootMetaspaceType:              return &chunk_alloc_sequence_boot_class;
+    default: ShouldNotReachHere();
+    }
+  } else {
+    switch(space_type) {
+    case Metaspace::StandardMetaspaceType:          return &chunk_alloc_sequence_standard_non_class;
+    case Metaspace::ReflectionMetaspaceType:        return &chunk_alloc_sequence_refl_non_class;
+    case Metaspace::ClassMirrorHolderMetaspaceType: return &chunk_alloc_sequence_anon_non_class;
+    case Metaspace::BootMetaspaceType:              return &chunk_alloc_sequence_boot_non_class;
+    default: ShouldNotReachHere();
+    }
+  }
+
+  return NULL;
+
+}
+
+} // namespace
+

src/hotspot/share/memory/metaspace/metaspaceArenaGrowthPolicy.hpp

@@ -0,0 +1,79 @@
+/*
+ * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2020 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
+ * 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.
+ *
+ */
+
+#ifndef SHARE_MEMORY_METASPACE_METASPACEARENAGROWTHPOLICY_HPP
+#define SHARE_MEMORY_METASPACE_METASPACEARENAGROWTHPOLICY_HPP
+
+#include "memory/metaspace.hpp" // For Metaspace::MetaspaceType
+#include "memory/metaspace/chunklevel.hpp"
+#include "utilities/debug.hpp"
+
+namespace metaspace {
+
+// ArenaGrowthPolicy encodes the growth policy of a MetaspaceArena.
+//
+// These arenas grow in steps (by allocating new chunks). The coarseness of growth
+// (chunk size, level) depends on what the arena is used for. Used for a class loader
+// which is expected to load only one or very few classes should grow in tiny steps.
+// For normal classloaders, it can grow in coarser steps, and arenas used by
+// the boot loader will grow in even larger steps since we expect it to load a lot of
+// classes.
+// Note that when growing in large steps (in steps larger than a commit granule,
+// by default 64K), costs diminish somewhat since we do not commit the whole space
+// immediately.
+
+class ArenaGrowthPolicy {
+
+  // const array specifying chunk level allocation progression (growth steps). Last
+  //  chunk is to be an endlessly repeated allocation.
+  const chunklevel_t* const _entries;
+  const int _num_entries;
+
+public:
+
+  ArenaGrowthPolicy(const chunklevel_t* array, int num_entries) :
+    _entries(array),
+    _num_entries(num_entries)
+  {
+    assert(_num_entries > 0, "must not be empty.");
+  }
+
+  chunklevel_t get_level_at_step(int num_allocated) const {
+    if (num_allocated >= _num_entries) {
+      // Caller shall repeat last allocation
+      return _entries[_num_entries - 1];
+    }
+    return _entries[num_allocated];
+  }
+
+  // Given a space type, return the correct policy to use.
+  // The returned object is static and read only.
+  static const ArenaGrowthPolicy* policy_for_space_type(Metaspace::MetaspaceType space_type, bool is_class);
+
+};
+
+} // namespace metaspace
+
+#endif // SHARE_MEMORY_METASPACE_METASPACEARENAGROWTHPOLICY_HPP

src/hotspot/share/memory/metaspace/metaspaceCommon.cpp

@@ -1,5 +1,6 @@
 /*
- * Copyright (c) 2018, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2018, 2020, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2018, 2020 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
@@ -23,17 +24,18 @@
  */
 
 #include "precompiled.hpp"
-
+#include "memory/metaspace/allocationGuard.hpp"
+#include "memory/metaspace/freeBlocks.hpp"
 #include "memory/metaspace/metaspaceCommon.hpp"
+#include "memory/metaspace/metaspaceSettings.hpp"
 #include "memory/metaspace/virtualSpaceNode.hpp"
+#include "utilities/align.hpp"
 #include "utilities/debug.hpp"
 #include "utilities/globalDefinitions.hpp"
 #include "utilities/ostream.hpp"
 
 namespace metaspace {
 
-DEBUG_ONLY(internal_statistics_t g_internal_statistics;)
-
 // Print a size, in words, scaled.
 void print_scaled_words(outputStream* st, size_t word_size, size_t scale, int width) {
   print_human_readable_size(st, word_size * sizeof(MetaWord), scale, width);
@@ -47,6 +49,19 @@ void print_scaled_words_and_percentage(outputStream* st, size_t word_size, size_
   st->print(")");
 }
 
+static const char* display_unit_for_scale(size_t scale) {
+  const char* s = NULL;
+  switch(scale) {
+    case 1: s = "bytes"; break;
+    case BytesPerWord: s = "words"; break;
+    case K: s = "KB"; break;
+    case M: s = "MB"; break;
+    case G: s = "GB"; break;
+    default:
+      ShouldNotReachHere();
+  }
+  return s;
+}
 
 // Print a human readable size.
 // byte_size: size, in bytes, to be printed.
@@ -74,36 +89,45 @@ void print_human_readable_size(outputStream* st, size_t byte_size, size_t scale,
   }
 
 #ifdef ASSERT
-  assert(scale == 1 || scale == BytesPerWord || scale == K || scale == M || scale == G, "Invalid scale");
+  assert(scale == 1 || scale == BytesPerWord ||
+         scale == K || scale == M || scale == G, "Invalid scale");
   // Special case: printing wordsize should only be done with word-sized values
   if (scale == BytesPerWord) {
     assert(byte_size % BytesPerWord == 0, "not word sized");
   }
 #endif
 
-  if (scale == 1) {
+  if (width == -1) {
-    st->print("%*" PRIuPTR " bytes", width, byte_size);
+    if (scale == 1) {
-  } else if (scale == BytesPerWord) {
+      st->print(SIZE_FORMAT " bytes", byte_size);
-    st->print("%*" PRIuPTR " words", width, byte_size / BytesPerWord);
+    } else if (scale == BytesPerWord) {
-  } else {
+      st->print(SIZE_FORMAT " words", byte_size / BytesPerWord);
-    const char* display_unit = "";
-    switch(scale) {
-      case 1: display_unit = "bytes"; break;
-      case BytesPerWord: display_unit = "words"; break;
-      case K: display_unit = "KB"; break;
-      case M: display_unit = "MB"; break;
-      case G: display_unit = "GB"; break;
-      default:
-        ShouldNotReachHere();
-    }
-    float display_value = (float) byte_size / scale;
-    // Since we use width to display a number with two trailing digits, increase it a bit.
-    width += 3;
-    // Prevent very small but non-null values showing up as 0.00.
-    if (byte_size > 0 && display_value < 0.01f) {
-      st->print("%*s %s", width, "<0.01", display_unit);
     } else {
-      st->print("%*.2f %s", width, display_value, display_unit);
+      const char* display_unit = display_unit_for_scale(scale);
+      float display_value = (float) byte_size / scale;
+      // Prevent very small but non-null values showing up as 0.00.
+      if (byte_size > 0 && display_value < 0.01f) {
+        st->print("<0.01 %s", display_unit);
+      } else {
+        st->print("%.2f %s", display_value, display_unit);
+      }
+    }
+  } else {
+    if (scale == 1) {
+      st->print("%*" PRIuPTR " bytes", width, byte_size);
+    } else if (scale == BytesPerWord) {
+      st->print("%*" PRIuPTR " words", width, byte_size / BytesPerWord);
+    } else {
+      const char* display_unit = display_unit_for_scale(scale);
+      float display_value = (float) byte_size / scale;
+      // Since we use width to display a number with two trailing digits, increase it a bit.
+      width += 3;
+      // Prevent very small but non-null values showing up as 0.00.
+      if (byte_size > 0 && display_value < 0.01f) {
+        st->print("%*s %s", width, "<0.01", display_unit);
+      } else {
+        st->print("%*.2f %s", width, display_value, display_unit);
+      }
     }
   }
 }
@@ -130,70 +154,6 @@ void print_percentage(outputStream* st, size_t total, size_t part) {
   }
 }
 
-// Returns size of this chunk type.
-size_t get_size_for_nonhumongous_chunktype(ChunkIndex chunktype, bool is_class) {
-  assert(is_valid_nonhumongous_chunktype(chunktype), "invalid chunk type.");
-  size_t size = 0;
-  if (is_class) {
-    switch(chunktype) {
-      case SpecializedIndex: size = ClassSpecializedChunk; break;
-      case SmallIndex: size = ClassSmallChunk; break;
-      case MediumIndex: size = ClassMediumChunk; break;
-      default:
-        ShouldNotReachHere();
-    }
-  } else {
-    switch(chunktype) {
-      case SpecializedIndex: size = SpecializedChunk; break;
-      case SmallIndex: size = SmallChunk; break;
-      case MediumIndex: size = MediumChunk; break;
-      default:
-        ShouldNotReachHere();
-    }
-  }
-  return size;
-}
-
-ChunkIndex get_chunk_type_by_size(size_t size, bool is_class) {
-  if (is_class) {
-    if (size == ClassSpecializedChunk) {
-      return SpecializedIndex;
-    } else if (size == ClassSmallChunk) {
-      return SmallIndex;
-    } else if (size == ClassMediumChunk) {
-      return MediumIndex;
-    } else if (size > ClassMediumChunk) {
-      // A valid humongous chunk size is a multiple of the smallest chunk size.
-      assert(is_aligned(size, ClassSpecializedChunk), "Invalid chunk size");
-      return HumongousIndex;
-    }
-  } else {
-    if (size == SpecializedChunk) {
-      return SpecializedIndex;
-    } else if (size == SmallChunk) {
-      return SmallIndex;
-    } else if (size == MediumChunk) {
-      return MediumIndex;
-    } else if (size > MediumChunk) {
-      // A valid humongous chunk size is a multiple of the smallest chunk size.
-      assert(is_aligned(size, SpecializedChunk), "Invalid chunk size");
-      return HumongousIndex;
-    }
-  }
-  ShouldNotReachHere();
-  return (ChunkIndex)-1;
-}
-
-ChunkIndex next_chunk_index(ChunkIndex i) {
-  assert(i < NumberOfInUseLists, "Out of bound");
-  return (ChunkIndex) (i+1);
-}
-
-ChunkIndex prev_chunk_index(ChunkIndex i) {
-  assert(i > ZeroIndex, "Out of bound");
-  return (ChunkIndex) (i-1);
-}
-
 const char* loaders_plural(uintx num) {
   return num == 1 ? "loader" : "loaders";
 }
@@ -209,5 +169,29 @@ void print_number_of_classes(outputStream* out, uintx classes, uintx classes_sha
   }
 }
 
+// Given a net allocation word size, return the raw word size we actually allocate.
+// Note: externally visible for gtests.
+//static
+size_t get_raw_word_size_for_requested_word_size(size_t word_size) {
+  size_t byte_size = word_size * BytesPerWord;
+
+  // Deallocated metablocks are kept in a binlist which limits their minimal
+  //  size to at least the size of a binlist item (2 words).
+  byte_size = MAX2(byte_size, FreeBlocks::MinWordSize * BytesPerWord);
+
+  // Metaspace allocations are aligned to word size.
+  byte_size = align_up(byte_size, AllocationAlignmentByteSize);
+
+  // If we guard allocations, we need additional space for a prefix.
+#ifdef ASSERT
+  if (Settings::use_allocation_guard()) {
+    byte_size += align_up(prefix_size(), AllocationAlignmentByteSize);
+  }
+#endif
+  size_t raw_word_size = byte_size / BytesPerWord;
+  assert(raw_word_size * BytesPerWord == byte_size, "Sanity");
+  return raw_word_size;
+}
+
 } // namespace metaspace
 

src/hotspot/share/memory/metaspace/metaspaceCommon.hpp

@@ -1,5 +1,6 @@
 /*
- * Copyright (c) 2018, 2019, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2018, 2020, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2018, 2020 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
@@ -25,6 +26,7 @@
 #ifndef SHARE_MEMORY_METASPACE_METASPACECOMMON_HPP
 #define SHARE_MEMORY_METASPACE_METASPACECOMMON_HPP
 
+#include "runtime/globals.hpp"
 #include "utilities/align.hpp"
 #include "utilities/debug.hpp"
 #include "utilities/globalDefinitions.hpp"
@@ -33,14 +35,28 @@ class outputStream;
 
 namespace metaspace {
 
-enum ChunkSizes {    // in words.
+// Metaspace allocation alignment:
-  ClassSpecializedChunk = 128,
+
-  SpecializedChunk = 128,
+// 1) Metaspace allocations have to be aligned such that 64bit values are aligned
-  ClassSmallChunk = 256,
+//  correctly.
-  SmallChunk = 512,
+//
-  ClassMediumChunk = 4 * K,
+// 2) Klass* structures allocated from Metaspace have to be aligned to KlassAlignmentInBytes.
-  MediumChunk = 8 * K
+//
-};
+// At the moment LogKlassAlignmentInBytes is 3, so KlassAlignmentInBytes == 8,
+//  so (1) and (2) can both be fulfilled with an alignment of 8. Should we increase
+//  KlassAlignmentInBytes at any time this will increase the necessary alignment as well. In
+//  that case we may think about introducing a separate alignment just for the class space
+//  since that alignment would only be needed for Klass structures.
+
+static const size_t AllocationAlignmentByteSize = 8;
+STATIC_ASSERT(AllocationAlignmentByteSize == (size_t)KlassAlignmentInBytes);
+
+static const size_t AllocationAlignmentWordSize = AllocationAlignmentByteSize / BytesPerWord;
+
+// Returns the raw word size allocated for a given net allocation
+size_t get_raw_word_size_for_requested_word_size(size_t word_size);
+
+// Utility functions
 
 // Print a size, in words, scaled.
 void print_scaled_words(outputStream* st, size_t word_size, size_t scale = 0, int width = -1);
@@ -59,92 +75,72 @@ void print_human_readable_size(outputStream* st, size_t byte_size, size_t scale
 // larger than 99% but not 100% are displayed as ">100%".
 void print_percentage(outputStream* st, size_t total, size_t part);
 
-
+#ifdef ASSERT
 #define assert_is_aligned(value, alignment)                  \
   assert(is_aligned((value), (alignment)),                   \
          SIZE_FORMAT_HEX " is not aligned to "               \
-         SIZE_FORMAT, (size_t)(uintptr_t)value, (alignment))
+         SIZE_FORMAT_HEX, (size_t)(uintptr_t)value, (size_t)(alignment))
-
+#else
-// Internal statistics.
+#define assert_is_aligned(value, alignment)
-#ifdef ASSERT
-struct  internal_statistics_t {
-  // Number of allocations.
-  uintx num_allocs;
-  // Number of times a ClassLoaderMetaspace was born...
-  uintx num_metaspace_births;
-  // ... and died.
-  uintx num_metaspace_deaths;
-  // Number of times VirtualSpaceListNodes were created...
-  uintx num_vsnodes_created;
-  // ... and purged.
-  uintx num_vsnodes_purged;
-  // Number of times we expanded the committed section of the space.
-  uintx num_committed_space_expanded;
-  // Number of deallocations
-  uintx num_deallocs;
-  // Number of deallocations triggered from outside ("real" deallocations).
-  uintx num_external_deallocs;
-  // Number of times an allocation was satisfied from deallocated blocks.
-  uintx num_allocs_from_deallocated_blocks;
-  // Number of times a chunk was added to the freelist
-  uintx num_chunks_added_to_freelist;
-  // Number of times a chunk was removed from the freelist
-  uintx num_chunks_removed_from_freelist;
-  // Number of chunk merges
-  uintx num_chunk_merges;
-  // Number of chunk splits
-  uintx num_chunk_splits;
-};
-extern internal_statistics_t g_internal_statistics;
 #endif
 
-// ChunkIndex defines the type of chunk.
-// Chunk types differ by size: specialized < small < medium, chunks
-// larger than medium are humongous chunks of varying size.
-enum ChunkIndex {
-  ZeroIndex = 0,
-  SpecializedIndex = ZeroIndex,
-  SmallIndex = SpecializedIndex + 1,
-  MediumIndex = SmallIndex + 1,
-  HumongousIndex = MediumIndex + 1,
-  NumberOfFreeLists = 3,
-  NumberOfInUseLists = 4
-};
-
-// Utility functions.
-size_t get_size_for_nonhumongous_chunktype(ChunkIndex chunk_type, bool is_class);
-ChunkIndex get_chunk_type_by_size(size_t size, bool is_class);
-
-ChunkIndex next_chunk_index(ChunkIndex i);
-ChunkIndex prev_chunk_index(ChunkIndex i);
-// Returns a descriptive name for a chunk type.
-const char* chunk_size_name(ChunkIndex index);
-
-// Verify chunk sizes.
-inline bool is_valid_chunksize(bool is_class, size_t size) {
-  const size_t reasonable_maximum_humongous_chunk_size = 1 * G;
-  return is_aligned(size, sizeof(MetaWord)) &&
-         size < reasonable_maximum_humongous_chunk_size &&
-         is_class ?
-             (size == ClassSpecializedChunk || size == ClassSmallChunk || size >= ClassMediumChunk) :
-             (size == SpecializedChunk || size == SmallChunk || size >= MediumChunk);
-}
-
-// Verify chunk type.
-inline bool is_valid_chunktype(ChunkIndex index) {
-  return index == SpecializedIndex || index == SmallIndex ||
-         index == MediumIndex || index == HumongousIndex;
-}
-
-inline bool is_valid_nonhumongous_chunktype(ChunkIndex index) {
-  return is_valid_chunktype(index) && index != HumongousIndex;
-}
-
 // Pretty printing helpers
 const char* classes_plural(uintx num);
 const char* loaders_plural(uintx num);
 void print_number_of_classes(outputStream* out, uintx classes, uintx classes_shared);
 
+// Since Metaspace verifications are expensive, we want to do them at a reduced rate,
+// but not completely avoiding them.
+// For that we introduce the macros SOMETIMES() and ASSERT_SOMETIMES() which will
+// execute code or assert at intervals controlled via VerifyMetaspaceInterval.
+#ifdef ASSERT
+
+#define EVERY_NTH(n)          \
+{ static int counter_ = 0;    \
+  if (n > 0) {                \
+    counter_++;              \
+    if (counter_ >= n) {      \
+      counter_ = 0;           \
+
+#define END_EVERY_NTH         } } }
+
+#define SOMETIMES(code) \
+    EVERY_NTH(VerifyMetaspaceInterval) \
+    { code } \
+    END_EVERY_NTH
+
+#define ASSERT_SOMETIMES(condition, ...) \
+    EVERY_NTH(VerifyMetaspaceInterval) \
+    assert( (condition), __VA_ARGS__); \
+    END_EVERY_NTH
+
+#else
+
+#define SOMETIMES(code)
+#define ASSERT_SOMETIMES(condition, ...)
+
+#endif // ASSERT
+
+///////// Logging //////////////
+
+// What we log at which levels:
+
+// "info" : metaspace failed allocation, commit failure, reserve failure, metaspace oom, metaspace gc threshold changed, Arena created, destroyed, metaspace purged
+
+// "debug" : "info" + vslist extended, memory committed/uncommitted, chunk created/split/merged/enlarged, chunk returned
+
+// "trace" : "debug" + every single allocation and deallocation, internals
+
+#define HAVE_UL
+
+#ifdef HAVE_UL
+#define UL(level, message)        log_##level(metaspace)(LOGFMT ": " message, LOGFMT_ARGS);
+#define UL2(level, message, ...)  log_##level(metaspace)(LOGFMT ": " message, LOGFMT_ARGS, __VA_ARGS__);
+#else
+#define UL(level, ...)
+#define UL2(level, ...)
+#endif
+
 } // namespace metaspace
 
 #endif // SHARE_MEMORY_METASPACE_METASPACECOMMON_HPP

src/hotspot/share/memory/metaspace/metaspaceContext.cpp

@@ -0,0 +1,86 @@
+/*
+ * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2020 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
+ * 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 "precompiled.hpp"
+#include "memory/metaspace/chunkManager.hpp"
+#include "memory/metaspace/commitLimiter.hpp"
+#include "memory/metaspace/metaspaceContext.hpp"
+#include "memory/metaspace/virtualSpaceList.hpp"
+#include "utilities/debug.hpp"
+#include "utilities/globalDefinitions.hpp"
+#include "utilities/ostream.hpp"
+
+namespace metaspace {
+
+MetaspaceContext* MetaspaceContext::_class_space_context = NULL;
+MetaspaceContext* MetaspaceContext::_nonclass_space_context = NULL;
+
+// Destroys the context: deletes chunkmanager and virtualspacelist.
+//  If this is a non-expandable context over an existing space, that space remains
+//  untouched, otherwise all memory is unmapped.
+// Note: the standard metaspace contexts (non-class context and class context) are
+//  never deleted. This code only exists for the sake of tests and for future reuse
+//  of metaspace contexts in different scenarios.
+MetaspaceContext::~MetaspaceContext() {
+  delete _cm;
+  delete _vslist;
+}
+
+// Create a new, empty, expandable metaspace context.
+MetaspaceContext* MetaspaceContext::create_expandable_context(const char* name, CommitLimiter* commit_limiter) {
+  VirtualSpaceList* vsl = new VirtualSpaceList(name, commit_limiter);
+  ChunkManager* cm = new ChunkManager(name, vsl);
+  return new MetaspaceContext(name, vsl, cm);
+}
+
+// Create a new, empty, non-expandable metaspace context atop of an externally provided space.
+MetaspaceContext* MetaspaceContext::create_nonexpandable_context(const char* name, ReservedSpace rs, CommitLimiter* commit_limiter) {
+  VirtualSpaceList* vsl = new VirtualSpaceList(name, rs, commit_limiter);
+  ChunkManager* cm = new ChunkManager(name, vsl);
+  return new MetaspaceContext(name, vsl, cm);
+}
+
+void MetaspaceContext::initialize_class_space_context(ReservedSpace rs) {
+  _class_space_context = create_nonexpandable_context("class-space", rs, CommitLimiter::globalLimiter());
+}
+
+void MetaspaceContext::initialize_nonclass_space_context() {
+  _nonclass_space_context = create_expandable_context("non-class-space", CommitLimiter::globalLimiter());
+}
+
+void MetaspaceContext::print_on(outputStream* st) const {
+  _vslist->print_on(st);
+  _cm->print_on(st);
+}
+
+#ifdef ASSERT
+void MetaspaceContext::verify() const {
+  _vslist->verify();
+  _cm->verify();
+}
+#endif // ASSERT
+
+} // namespace metaspace
+

src/hotspot/share/memory/metaspace/metaspaceContext.hpp

@@ -0,0 +1,111 @@
+/*
+ * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2020 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
+ * 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.
+ *
+ */
+
+#ifndef SHARE_MEMORY_METASPACE_METASPACECONTEXT_HPP
+#define SHARE_MEMORY_METASPACE_METASPACECONTEXT_HPP
+
+#include "memory/allocation.hpp"
+#include "memory/virtualspace.hpp"
+#include "utilities/debug.hpp"
+
+class outputStream;
+
+namespace metaspace {
+
+class ChunkManager;
+class VirtualSpaceList;
+class CommitLimiter;
+
+// MetaspaceContext is a convenience bracket around:
+//
+// - a VirtualSpaceList managing a memory area used for Metaspace
+// - a ChunkManager sitting atop of that which manages chunk freelists
+//
+// In a normal VM only one or two of these contexts ever exist: one for the metaspace, and
+//  optionally another one for the compressed class space.
+//
+// For tests more contexts may be created, and this would also be a way to use Metaspace
+//  for things other than class metadata. We would have to work on the naming then.
+//
+// - (Future TODO): Context should own a lock to guard it. Currently this stuff is guarded
+//     by one global lock, the slightly misnamed Metaspace_expandlock, but that one
+//     should be split into one per context.
+// - (Future TODO): Context can/should have its own allocation alignment. That way we
+//     can have different alignment between class space and non-class metaspace. That could
+//     help optimize compressed class pointer encoding, see discussion for JDK-8244943).
+
+class MetaspaceContext : public CHeapObj<mtMetaspace> {
+
+  const char* const _name;
+  VirtualSpaceList* const _vslist;
+  ChunkManager* const _cm;
+
+  MetaspaceContext(const char* name, VirtualSpaceList* vslist, ChunkManager* cm) :
+    _name(name),
+    _vslist(vslist),
+    _cm(cm)
+  {}
+
+  static MetaspaceContext* _nonclass_space_context;
+  static MetaspaceContext* _class_space_context;
+
+public:
+
+  // Destroys the context: deletes chunkmanager and virtualspacelist.
+  // If this is a non-expandable context over an existing space, that space remains
+  // untouched, otherwise all memory is unmapped.
+  ~MetaspaceContext();
+
+  VirtualSpaceList* vslist() { return _vslist; }
+  ChunkManager* cm() { return _cm; }
+
+  // Create a new, empty, expandable metaspace context.
+  static MetaspaceContext* create_expandable_context(const char* name, CommitLimiter* commit_limiter);
+
+  // Create a new, empty, non-expandable metaspace context atop of an externally provided space.
+  static MetaspaceContext* create_nonexpandable_context(const char* name, ReservedSpace rs, CommitLimiter* commit_limiter);
+
+  void print_on(outputStream* st) const;
+
+  DEBUG_ONLY(void verify() const;)
+
+  static void initialize_class_space_context(ReservedSpace rs);
+  static void initialize_nonclass_space_context();
+
+  // Returns pointer to the global metaspace context.
+  // If compressed class space is active, this contains the non-class-space allocations.
+  // If compressed class space is inactive, this contains all metaspace allocations.
+  static MetaspaceContext* context_nonclass()     { return _nonclass_space_context; }
+
+  // Returns pointer to the global class space context, if compressed class space is active,
+  // NULL otherwise.
+  static MetaspaceContext* context_class()        { return _class_space_context; }
+
+};
+
+} // end namespace
+
+#endif // SHARE_MEMORY_METASPACE_METASPACECONTEXT_HPP
+

src/hotspot/share/memory/metaspace/metaspaceDCmd.cpp

@@ -1,6 +1,6 @@
 /*
- * Copyright (c) 2018, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2018, 2020, Oracle and/or its affiliates. All rights reserved.
- * Copyright (c) 2018, SAP and/or its affiliates.
+ * Copyright (c) 2018, 2020 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
@@ -22,27 +22,27 @@
  * questions.
  *
  */
+
 #include "precompiled.hpp"
-#include "memory/metaspace.hpp"
 #include "memory/metaspace/metaspaceDCmd.hpp"
+#include "memory/metaspace/metaspaceReporter.hpp"
 #include "memory/resourceArea.hpp"
 #include "services/diagnosticCommand.hpp"
 #include "services/nmtCommon.hpp"
 
 namespace metaspace {
 
-MetaspaceDCmd::MetaspaceDCmd(outputStream* output, bool heap)
+MetaspaceDCmd::MetaspaceDCmd(outputStream* output, bool heap) :
-  : DCmdWithParser(output, heap)
+  DCmdWithParser(output, heap),
-  , _basic("basic", "Prints a basic summary (does not need a safepoint).", "BOOLEAN", false, "false")
+  _basic("basic", "Prints a basic summary (does not need a safepoint).", "BOOLEAN", false, "false"),
-  , _show_loaders("show-loaders", "Shows usage by class loader.", "BOOLEAN", false, "false")
+  _show_loaders("show-loaders", "Shows usage by class loader.", "BOOLEAN", false, "false"),
-  , _by_spacetype("by-spacetype", "Break down numbers by loader type.", "BOOLEAN", false, "false")
+  _by_spacetype("by-spacetype", "Break down numbers by loader type.", "BOOLEAN", false, "false"),
-  , _by_chunktype("by-chunktype", "Break down numbers by chunk type.", "BOOLEAN", false, "false")
+  _by_chunktype("by-chunktype", "Break down numbers by chunk type.", "BOOLEAN", false, "false"),
-  , _show_vslist("vslist", "Shows details about the underlying virtual space.", "BOOLEAN", false, "false")
+  _show_vslist("vslist", "Shows details about the underlying virtual space.", "BOOLEAN", false, "false"),
-  , _show_vsmap("vsmap", "Shows chunk composition of the underlying virtual spaces", "BOOLEAN", false, "false")
+  _scale("scale", "Memory usage in which to scale. Valid values are: 1, KB, MB or GB (fixed scale) "
-  , _scale("scale", "Memory usage in which to scale. Valid values are: 1, KB, MB or GB (fixed scale) "
+         "or \"dynamic\" for a dynamically choosen scale.",
-           "or \"dynamic\" for a dynamically choosen scale.",
+         "STRING", false, "dynamic"),
-           "STRING", false, "dynamic")
+  _show_classes("show-classes", "If show-loaders is set, shows loaded classes for each loader.", "BOOLEAN", false, "false")
-  , _show_classes("show-classes", "If show-loaders is set, shows loaded classes for each loader.", "BOOLEAN", false, "false")
 {
   _dcmdparser.add_dcmd_option(&_basic);
   _dcmdparser.add_dcmd_option(&_show_loaders);
@@ -50,7 +50,6 @@ MetaspaceDCmd::MetaspaceDCmd(outputStream* output, bool heap)
   _dcmdparser.add_dcmd_option(&_by_chunktype);
   _dcmdparser.add_dcmd_option(&_by_spacetype);
   _dcmdparser.add_dcmd_option(&_show_vslist);
-  _dcmdparser.add_dcmd_option(&_show_vsmap);
   _dcmdparser.add_dcmd_option(&_scale);
 }
 
@@ -81,7 +80,7 @@ void MetaspaceDCmd::execute(DCmdSource source, TRAPS) {
   }
   if (_basic.value() == true) {
     if (_show_loaders.value() || _by_chunktype.value() || _by_spacetype.value() ||
-        _show_vslist.value() || _show_vsmap.value()) {
+        _show_vslist.value()) {
       // Basic mode. Just print essentials. Does not need to be at a safepoint.
       output()->print_cr("In basic mode, additional arguments are ignored.");
     }
@@ -89,12 +88,11 @@ void MetaspaceDCmd::execute(DCmdSource source, TRAPS) {
   } else {
     // Full mode. Requires safepoint.
     int flags = 0;
-    if (_show_loaders.value())         flags |= MetaspaceUtils::rf_show_loaders;
+    if (_show_loaders.value())         flags |= (int)MetaspaceReporter::Option::ShowLoaders;
-    if (_show_classes.value())         flags |= MetaspaceUtils::rf_show_classes;
+    if (_show_classes.value())         flags |= (int)MetaspaceReporter::Option::ShowClasses;
-    if (_by_chunktype.value())         flags |= MetaspaceUtils::rf_break_down_by_chunktype;
+    if (_by_chunktype.value())         flags |= (int)MetaspaceReporter::Option::BreakDownByChunkType;
-    if (_by_spacetype.value())         flags |= MetaspaceUtils::rf_break_down_by_spacetype;
+    if (_by_spacetype.value())         flags |= (int)MetaspaceReporter::Option::BreakDownBySpaceType;
-    if (_show_vslist.value())          flags |= MetaspaceUtils::rf_show_vslist;
+    if (_show_vslist.value())          flags |= (int)MetaspaceReporter::Option::ShowVSList;
-    if (_show_vsmap.value())           flags |= MetaspaceUtils::rf_show_vsmap;
     VM_PrintMetadata op(output(), scale, flags);
     VMThread::execute(&op);
   }

src/hotspot/share/memory/metaspace/metaspaceDCmd.hpp

@@ -1,6 +1,6 @@
 /*
- * Copyright (c) 2018, 2019, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2018, 2020, Oracle and/or its affiliates. All rights reserved.
- * Copyright (c) 2018, SAP and/or its affiliates.
+ * Copyright (c) 2018, 2020 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
@@ -38,7 +38,6 @@ class MetaspaceDCmd : public DCmdWithParser {
   DCmdArgument<bool> _by_spacetype;
   DCmdArgument<bool> _by_chunktype;
   DCmdArgument<bool> _show_vslist;
-  DCmdArgument<bool> _show_vsmap;
   DCmdArgument<char*> _scale;
   DCmdArgument<bool> _show_classes;
 public:

src/hotspot/share/memory/metaspace/metaspaceReporter.cpp

@@ -0,0 +1,372 @@
+/*
+ * Copyright (c) 2018, 2020, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2018, 2020 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
+ * 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 "precompiled.hpp"
+#include "classfile/classLoaderData.hpp"
+#include "classfile/classLoaderDataGraph.hpp"
+#include "memory/metaspace.hpp"
+#include "memory/metaspace/chunkHeaderPool.hpp"
+#include "memory/metaspace/chunkManager.hpp"
+#include "memory/metaspace/internalStats.hpp"
+#include "memory/metaspace/metaspaceCommon.hpp"
+#include "memory/metaspace/metaspaceReporter.hpp"
+#include "memory/metaspace/metaspaceSettings.hpp"
+#include "memory/metaspace/metaspaceStatistics.hpp"
+#include "memory/metaspace/printCLDMetaspaceInfoClosure.hpp"
+#include "memory/metaspace/runningCounters.hpp"
+#include "memory/metaspace/virtualSpaceList.hpp"
+#include "runtime/os.hpp"
+
+namespace metaspace {
+
+static const char* describe_spacetype(Metaspace::MetaspaceType st) {
+  const char* s = NULL;
+  switch (st) {
+    case Metaspace::StandardMetaspaceType: s = "Standard"; break;
+    case Metaspace::BootMetaspaceType: s = "Boot"; break;
+    case Metaspace::ClassMirrorHolderMetaspaceType: s = "ClassMirrorHolder"; break;
+    case Metaspace::ReflectionMetaspaceType: s = "Reflection"; break;
+    default: ShouldNotReachHere();
+  }
+  return s;
+}
+
+static void print_vs(outputStream* out, size_t scale) {
+  const size_t reserved_nc = RunningCounters::reserved_words_nonclass();
+  const size_t committed_nc = RunningCounters::committed_words_nonclass();
+  const int num_nodes_nc = VirtualSpaceList::vslist_nonclass()->num_nodes();
+
+  if (Metaspace::using_class_space()) {
+    const size_t reserved_c = RunningCounters::reserved_words_class();
+    const size_t committed_c = RunningCounters::committed_words_class();
+    const int num_nodes_c = VirtualSpaceList::vslist_class()->num_nodes();
+
+    out->print("  Non-class space:  ");
+    print_scaled_words(out, reserved_nc, scale, 7);
+    out->print(" reserved, ");
+    print_scaled_words_and_percentage(out, committed_nc, reserved_nc, scale, 7);
+    out->print(" committed, ");
+    out->print(" %d nodes.", num_nodes_nc);
+    out->cr();
+    out->print("      Class space:  ");
+    print_scaled_words(out, reserved_c, scale, 7);
+    out->print(" reserved, ");
+    print_scaled_words_and_percentage(out, committed_c, reserved_c, scale, 7);
+    out->print(" committed, ");
+    out->print(" %d nodes.", num_nodes_c);
+    out->cr();
+    out->print("              Both:  ");
+    print_scaled_words(out, reserved_c + reserved_nc, scale, 7);
+    out->print(" reserved, ");
+    print_scaled_words_and_percentage(out, committed_c + committed_nc, reserved_c + reserved_nc, scale, 7);
+    out->print(" committed. ");
+    out->cr();
+  } else {
+    print_scaled_words(out, reserved_nc, scale, 7);
+    out->print(" reserved, ");
+    print_scaled_words_and_percentage(out, committed_nc, reserved_nc, scale, 7);
+    out->print(" committed, ");
+    out->print(" %d nodes.", num_nodes_nc);
+    out->cr();
+  }
+}
+
+static void print_settings(outputStream* out, size_t scale) {
+  out->print("MaxMetaspaceSize: ");
+  if (MaxMetaspaceSize >= (max_uintx) - (2 * os::vm_page_size())) {
+    // aka "very big". Default is max_uintx, but due to rounding in arg parsing the real
+    // value is smaller.
+    out->print("unlimited");
+  } else {
+    print_human_readable_size(out, MaxMetaspaceSize, scale);
+  }
+  out->cr();
+  if (Metaspace::using_class_space()) {
+    out->print("CompressedClassSpaceSize: ");
+    print_human_readable_size(out, CompressedClassSpaceSize, scale);
+  }
+  out->cr();
+  Settings::print_on(out);
+}
+
+// This will print out a basic metaspace usage report but
+// unlike print_report() is guaranteed not to lock or to walk the CLDG.
+void MetaspaceReporter::print_basic_report(outputStream* out, size_t scale) {
+  if (!Metaspace::initialized()) {
+    out->print_cr("Metaspace not yet initialized.");
+    return;
+  }
+  out->cr();
+  out->print_cr("Usage:");
+  if (Metaspace::using_class_space()) {
+    out->print("  Non-class:  ");
+  }
+
+  // Note: since we want to purely rely on counters, without any locking or walking the CLDG,
+  // for Usage stats (statistics over in-use chunks) all we can print is the
+  // used words. We cannot print committed areas, or free/waste areas, of in-use chunks require
+  // walking.
+  const size_t used_nc = MetaspaceUtils::used_words(Metaspace::NonClassType);
+
+  print_scaled_words(out, used_nc, scale, 5);
+  out->print(" used.");
+  out->cr();
+  if (Metaspace::using_class_space()) {
+    const size_t used_c = MetaspaceUtils::used_words(Metaspace::ClassType);
+    out->print("      Class:  ");
+    print_scaled_words(out, used_c, scale, 5);
+    out->print(" used.");
+    out->cr();
+    out->print("       Both:  ");
+    const size_t used = used_nc + used_c;
+    print_scaled_words(out, used, scale, 5);
+    out->print(" used.");
+    out->cr();
+  }
+  out->cr();
+  out->print_cr("Virtual space:");
+  print_vs(out, scale);
+  out->cr();
+  out->print_cr("Chunk freelists:");
+  if (Metaspace::using_class_space()) {
+    out->print("   Non-Class:  ");
+  }
+  print_scaled_words(out, ChunkManager::chunkmanager_nonclass()->total_word_size(), scale);
+  out->cr();
+  if (Metaspace::using_class_space()) {
+    out->print("       Class:  ");
+    print_scaled_words(out, ChunkManager::chunkmanager_class()->total_word_size(), scale);
+    out->cr();
+    out->print("        Both:  ");
+    print_scaled_words(out, ChunkManager::chunkmanager_nonclass()->total_word_size() +
+                            ChunkManager::chunkmanager_class()->total_word_size(), scale);
+    out->cr();
+  }
+  out->cr();
+
+  // Print basic settings
+  print_settings(out, scale);
+  out->cr();
+  out->cr();
+  out->print_cr("Internal statistics:");
+  out->cr();
+  InternalStats::print_on(out);
+  out->cr();
+}
+
+void MetaspaceReporter::print_report(outputStream* out, size_t scale, int flags) {
+  if (!Metaspace::initialized()) {
+    out->print_cr("Metaspace not yet initialized.");
+    return;
+  }
+  const bool print_loaders = (flags & (int)Option::ShowLoaders) > 0;
+  const bool print_classes = (flags & (int)Option::ShowClasses) > 0;
+  const bool print_by_chunktype = (flags & (int)Option::BreakDownByChunkType) > 0;
+  const bool print_by_spacetype = (flags & (int)Option::BreakDownBySpaceType) > 0;
+
+  // Some report options require walking the class loader data graph.
+  metaspace::PrintCLDMetaspaceInfoClosure cl(out, scale, print_loaders, print_classes, print_by_chunktype);
+  if (print_loaders) {
+    out->cr();
+    out->print_cr("Usage per loader:");
+    out->cr();
+  }
+
+  ClassLoaderDataGraph::loaded_cld_do(&cl); // collect data and optionally print
+
+  // Print totals, broken up by space type.
+  if (print_by_spacetype) {
+    out->cr();
+    out->print_cr("Usage per space type:");
+    out->cr();
+    for (int space_type = (int)Metaspace::ZeroMetaspaceType;
+         space_type < (int)Metaspace::MetaspaceTypeCount; space_type++)
+    {
+      uintx num_loaders = cl._num_loaders_by_spacetype[space_type];
+      uintx num_classes = cl._num_classes_by_spacetype[space_type];
+      out->print("%s - " UINTX_FORMAT " %s",
+        describe_spacetype((Metaspace::MetaspaceType)space_type),
+        num_loaders, loaders_plural(num_loaders));
+      if (num_classes > 0) {
+        out->print(", ");
+
+        print_number_of_classes(out, num_classes, cl._num_classes_shared_by_spacetype[space_type]);
+        out->print(":");
+        cl._stats_by_spacetype[space_type].print_on(out, scale, print_by_chunktype);
+      } else {
+        out->print(".");
+        out->cr();
+      }
+      out->cr();
+    }
+  }
+
+  // Print totals for in-use data:
+  out->cr();
+  {
+    uintx num_loaders = cl._num_loaders;
+    out->print("Total Usage - " UINTX_FORMAT " %s, ",
+      num_loaders, loaders_plural(num_loaders));
+    print_number_of_classes(out, cl._num_classes, cl._num_classes_shared);
+    out->print(":");
+    cl._stats_total.print_on(out, scale, print_by_chunktype);
+    out->cr();
+  }
+
+  /////////////////////////////////////////////////
+  // -- Print Virtual space.
+  out->cr();
+  out->print_cr("Virtual space:");
+
+  print_vs(out, scale);
+
+  // -- Print VirtualSpaceList details.
+  if ((flags & (int)Option::ShowVSList) > 0) {
+    out->cr();
+    out->print_cr("Virtual space list%s:", Metaspace::using_class_space() ? "s" : "");
+
+    if (Metaspace::using_class_space()) {
+      out->print_cr("   Non-Class:");
+    }
+    VirtualSpaceList::vslist_nonclass()->print_on(out);
+    out->cr();
+    if (Metaspace::using_class_space()) {
+      out->print_cr("       Class:");
+      VirtualSpaceList::vslist_class()->print_on(out);
+      out->cr();
+    }
+  }
+  out->cr();
+
+  //////////// Freelists (ChunkManager) section ///////////////////////////
+
+  out->cr();
+  out->print_cr("Chunk freelist%s:", Metaspace::using_class_space() ? "s" : "");
+
+  ChunkManagerStats non_class_cm_stat;
+  ChunkManagerStats class_cm_stat;
+  ChunkManagerStats total_cm_stat;
+
+  ChunkManager::chunkmanager_nonclass()->add_to_statistics(&non_class_cm_stat);
+  if (Metaspace::using_class_space()) {
+    ChunkManager::chunkmanager_nonclass()->add_to_statistics(&non_class_cm_stat);
+    ChunkManager::chunkmanager_class()->add_to_statistics(&class_cm_stat);
+    total_cm_stat.add(non_class_cm_stat);
+    total_cm_stat.add(class_cm_stat);
+
+    out->print_cr("   Non-Class:");
+    non_class_cm_stat.print_on(out, scale);
+    out->cr();
+    out->print_cr("       Class:");
+    class_cm_stat.print_on(out, scale);
+    out->cr();
+    out->print_cr("        Both:");
+    total_cm_stat.print_on(out, scale);
+    out->cr();
+  } else {
+    ChunkManager::chunkmanager_nonclass()->add_to_statistics(&non_class_cm_stat);
+    non_class_cm_stat.print_on(out, scale);
+    out->cr();
+  }
+
+  //////////// Waste section ///////////////////////////
+  // As a convenience, print a summary of common waste.
+  out->cr();
+  out->print("Waste (unused committed space):");
+  // For all wastages, print percentages from total. As total use the total size of memory committed for metaspace.
+  const size_t committed_words = RunningCounters::committed_words();
+
+  out->print("(percentages refer to total committed size ");
+  print_scaled_words(out, committed_words, scale);
+  out->print_cr("):");
+
+  // Print waste for in-use chunks.
+  InUseChunkStats ucs_nonclass = cl._stats_total._arena_stats_nonclass.totals();
+  InUseChunkStats ucs_class = cl._stats_total._arena_stats_class.totals();
+  const size_t waste_in_chunks_in_use = ucs_nonclass._waste_words + ucs_class._waste_words;
+  const size_t free_in_chunks_in_use = ucs_nonclass._free_words + ucs_class._free_words;
+
+  out->print("        Waste in chunks in use: ");
+  print_scaled_words_and_percentage(out, waste_in_chunks_in_use, committed_words, scale, 6);
+  out->cr();
+  out->print("        Free in chunks in use: ");
+  print_scaled_words_and_percentage(out, free_in_chunks_in_use, committed_words, scale, 6);
+  out->cr();
+
+  // Print waste in free chunks.
+  const size_t committed_in_free_chunks = total_cm_stat.total_committed_word_size();
+  out->print("                In free chunks: ");
+  print_scaled_words_and_percentage(out, committed_in_free_chunks, committed_words, scale, 6);
+  out->cr();
+
+  // Print waste in deallocated blocks.
+  const uintx free_blocks_num =
+      cl._stats_total._arena_stats_nonclass._free_blocks_num +
+      cl._stats_total._arena_stats_class._free_blocks_num;
+  const size_t free_blocks_cap_words =
+      cl._stats_total._arena_stats_nonclass._free_blocks_word_size +
+      cl._stats_total._arena_stats_class._free_blocks_word_size;
+  out->print("Deallocated from chunks in use: ");
+  print_scaled_words_and_percentage(out, free_blocks_cap_words, committed_words, scale, 6);
+  out->print(" (" UINTX_FORMAT " blocks)", free_blocks_num);
+  out->cr();
+
+  // Print total waste.
+  const size_t total_waste =
+      waste_in_chunks_in_use +
+      free_in_chunks_in_use +
+      committed_in_free_chunks +
+      free_blocks_cap_words;
+  out->print("                       -total-: ");
+  print_scaled_words_and_percentage(out, total_waste, committed_words, scale, 6);
+  out->cr();
+
+  // Also print chunk header pool size.
+  out->cr();
+  out->print("chunk header pool: %u items, ", ChunkHeaderPool::pool()->used());
+  print_scaled_words(out, ChunkHeaderPool::pool()->memory_footprint_words(), scale);
+  out->print(".");
+  out->cr();
+
+  // Print internal statistics
+  out->cr();
+  out->print_cr("Internal statistics:");
+  out->cr();
+  InternalStats::print_on(out);
+  out->cr();
+
+  // Print some interesting settings
+  out->cr();
+  out->print_cr("Settings:");
+  print_settings(out, scale);
+
+  out->cr();
+  out->cr();
+
+  DEBUG_ONLY(MetaspaceUtils::verify();)
+} // MetaspaceUtils::print_report()
+
+} // namespace metaspace
+

src/hotspot/share/memory/metaspace/metaspaceReporter.hpp

@@ -0,0 +1,64 @@
+/*
+ * Copyright (c) 2018, 2020, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2018, 2020 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
+ * 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.
+ *
+ */
+
+#ifndef SHARE_MEMORY_METASPACE_METASPACEREPORTER_HPP
+#define SHARE_MEMORY_METASPACE_METASPACEREPORTER_HPP
+
+#include "memory/allocation.hpp"
+
+namespace metaspace {
+
+class MetaspaceReporter : public AllStatic {
+public:
+
+  // Flags for print_report().
+  enum class Option {
+    // Show usage by class loader.
+    ShowLoaders                 = (1 << 0),
+    // Breaks report down by chunk type (small, medium, ...).
+    BreakDownByChunkType        = (1 << 1),
+    // Breaks report down by space type (anonymous, reflection, ...).
+    BreakDownBySpaceType        = (1 << 2),
+    // Print details about the underlying virtual spaces.
+    ShowVSList                  = (1 << 3),
+    // If show_loaders: show loaded classes for each loader.
+    ShowClasses                 = (1 << 4)
+  };
+
+  // This will print out a basic metaspace usage report but
+  // unlike print_report() is guaranteed not to lock or to walk the CLDG.
+  static void print_basic_report(outputStream* st, size_t scale);
+
+  // Prints a report about the current metaspace state.
+  // Optional parts can be enabled via flags.
+  // Function will walk the CLDG and will lock the expand lock; if that is not
+  // convenient, use print_basic_report() instead.
+  static void print_report(outputStream* out, size_t scale = 0, int flags = 0);
+
+};
+
+} // namespace metaspace
+
+#endif // SHARE_MEMORY_METASPACE_METASPACEREPORTER_HPP

src/hotspot/share/memory/metaspace/metaspaceSettings.cpp

@@ -0,0 +1,108 @@
+/*
+ * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2020 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
+ * 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 "precompiled.hpp"
+#include "logging/log.hpp"
+#include "logging/logStream.hpp"
+#include "memory/metaspace/metaspaceSettings.hpp"
+#include "runtime/globals.hpp"
+#include "runtime/java.hpp"
+#include "utilities/debug.hpp"
+#include "utilities/globalDefinitions.hpp"
+#include "utilities/powerOfTwo.hpp"
+
+namespace metaspace {
+
+size_t Settings::_commit_granule_bytes = 0;
+size_t Settings::_commit_granule_words = 0;
+
+bool Settings::_new_chunks_are_fully_committed = false;
+bool Settings::_uncommit_free_chunks = false;
+
+DEBUG_ONLY(bool Settings::_use_allocation_guard = false;)
+DEBUG_ONLY(bool Settings::_handle_deallocations = true;)
+
+void Settings::ergo_initialize() {
+  if (strcmp(MetaspaceReclaimPolicy, "none") == 0) {
+    log_info(metaspace)("Initialized with strategy: no reclaim.");
+    _commit_granule_bytes = MAX2((size_t)os::vm_page_size(), 64 * K);
+    _commit_granule_words = _commit_granule_bytes / BytesPerWord;
+    // In "none" reclamation mode, we do not uncommit, and we commit new chunks fully;
+    // that very closely mimicks the behaviour of old Metaspace.
+    _new_chunks_are_fully_committed = true;
+    _uncommit_free_chunks = false;
+  } else if (strcmp(MetaspaceReclaimPolicy, "aggressive") == 0) {
+    log_info(metaspace)("Initialized with strategy: aggressive reclaim.");
+    // Set the granule size rather small; may increase
+    // mapping fragmentation but also increase chance to uncommit.
+    _commit_granule_bytes = MAX2((size_t)os::vm_page_size(), 16 * K);
+    _commit_granule_words = _commit_granule_bytes / BytesPerWord;
+    _new_chunks_are_fully_committed = false;
+    _uncommit_free_chunks = true;
+  } else if (strcmp(MetaspaceReclaimPolicy, "balanced") == 0) {
+    log_info(metaspace)("Initialized with strategy: balanced reclaim.");
+    _commit_granule_bytes = MAX2((size_t)os::vm_page_size(), 64 * K);
+    _commit_granule_words = _commit_granule_bytes / BytesPerWord;
+    _new_chunks_are_fully_committed = false;
+    _uncommit_free_chunks = true;
+  } else {
+    vm_exit_during_initialization("Invalid value for MetaspaceReclaimPolicy: \"%s\".", MetaspaceReclaimPolicy);
+  }
+
+  // Sanity checks.
+  assert(commit_granule_words() <= chunklevel::MAX_CHUNK_WORD_SIZE, "Too large granule size");
+  assert(is_power_of_2(commit_granule_words()), "granule size must be a power of 2");
+
+#ifdef ASSERT
+  // Off for release builds, and by default for debug builds, but can be switched on manually to aid
+  // error analysis.
+  _use_allocation_guard = MetaspaceGuardAllocations;
+
+  // Deallocations can be manually switched off to aid error analysis, since this removes one layer of complexity
+  //  from allocation.
+  _handle_deallocations = MetaspaceHandleDeallocations;
+
+  // We also switch it off automatically if we use allocation guards. This is to keep prefix handling in MetaspaceArena simple.
+  if (_use_allocation_guard) {
+    _handle_deallocations = false;
+  }
+#endif
+  LogStream ls(Log(metaspace)::info());
+  Settings::print_on(&ls);
+}
+
+void Settings::print_on(outputStream* st) {
+  st->print_cr(" - commit_granule_bytes: " SIZE_FORMAT ".", commit_granule_bytes());
+  st->print_cr(" - commit_granule_words: " SIZE_FORMAT ".", commit_granule_words());
+  st->print_cr(" - virtual_space_node_default_size: " SIZE_FORMAT ".", virtual_space_node_default_word_size());
+  st->print_cr(" - enlarge_chunks_in_place: %d.", (int)enlarge_chunks_in_place());
+  st->print_cr(" - new_chunks_are_fully_committed: %d.", (int)new_chunks_are_fully_committed());
+  st->print_cr(" - uncommit_free_chunks: %d.", (int)uncommit_free_chunks());
+  st->print_cr(" - use_allocation_guard: %d.", (int)use_allocation_guard());
+  st->print_cr(" - handle_deallocations: %d.", (int)handle_deallocations());
+}
+
+} // namespace metaspace
+

src/hotspot/share/memory/metaspace/metaspaceSettings.hpp

@@ -0,0 +1,100 @@
+/*
+ * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2020 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
+ * 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.
+ *
+ */
+
+#ifndef SHARE_MEMORY_METASPACE_METASPACESETTINGS_HPP
+#define SHARE_MEMORY_METASPACE_METASPACESETTINGS_HPP
+
+#include "memory/allocation.hpp"
+#include "memory/metaspace/chunklevel.hpp"
+#include "utilities/globalDefinitions.hpp"
+
+namespace metaspace {
+
+class Settings : public AllStatic {
+
+  // Granularity, in bytes, metaspace is committed with.
+  static size_t _commit_granule_bytes;
+
+  // Granularity, in words, metaspace is committed with.
+  static size_t _commit_granule_words;
+
+  // The default size of a VirtualSpaceNode, unless created with an explicitly specified size.
+  //  Must be a multiple of the root chunk size.
+  // Increasing this value decreases the number of mappings used for metadata,
+  //  at the cost of increased virtual size used for Metaspace (or, at least,
+  //  coarser growth steps). Matters mostly for 32bit platforms due to limited
+  //  address space.
+  // The default of two root chunks has been chosen on a whim but seems to work out okay
+  //  (coming to a mapping size of 8m per node).
+  static const size_t _virtual_space_node_default_word_size = chunklevel::MAX_CHUNK_WORD_SIZE * 2;
+
+  // Alignment of the base address of a virtual space node
+  static const size_t _virtual_space_node_reserve_alignment_words = chunklevel::MAX_CHUNK_WORD_SIZE;
+
+  // When allocating from a chunk, if the remaining area in the chunk is too small to hold
+  // the requested size, we attempt to double the chunk size in place...
+  static const bool _enlarge_chunks_in_place = true;
+
+  // Whether or not chunks handed out to an arena start out fully committed;
+  // if true, this deactivates committing-on-demand (regardless of whether
+  // we uncommit free chunks).
+  static bool _new_chunks_are_fully_committed;
+
+  // If true, chunks equal or larger than a commit granule are uncommitted
+  // after being returned to the freelist.
+  static bool _uncommit_free_chunks;
+
+  // If true, metablock allocations are guarded and periodically checked.
+  DEBUG_ONLY(static bool _use_allocation_guard;)
+
+  // This enables or disables premature deallocation of metaspace allocated blocks. Using
+  //  Metaspace::deallocate(), blocks can be returned prematurely (before the associated
+  //  Arena dies, e.g. after class unloading) and can be reused by the arena.
+  //  If disabled, those blocks will not be reused until the Arena dies.
+  // Note that premature deallocation is rare under normal circumstances.
+  // By default deallocation handling is enabled.
+  DEBUG_ONLY(static bool _handle_deallocations;)
+
+public:
+
+  static size_t commit_granule_bytes()                        { return _commit_granule_bytes; }
+  static size_t commit_granule_words()                        { return _commit_granule_words; }
+  static bool new_chunks_are_fully_committed()                { return _new_chunks_are_fully_committed; }
+  static size_t virtual_space_node_default_word_size()        { return _virtual_space_node_default_word_size; }
+  static size_t virtual_space_node_reserve_alignment_words()  { return _virtual_space_node_reserve_alignment_words; }
+  static bool enlarge_chunks_in_place()                       { return _enlarge_chunks_in_place; }
+  static bool uncommit_free_chunks()                          { return _uncommit_free_chunks; }
+  static bool use_allocation_guard()                          { return DEBUG_ONLY(_use_allocation_guard) NOT_DEBUG(false); }
+  static bool handle_deallocations()                          { return DEBUG_ONLY(_handle_deallocations) NOT_DEBUG(true); }
+
+  static void ergo_initialize();
+
+  static void print_on(outputStream* st);
+
+};
+
+} // namespace metaspace
+
+#endif // SHARE_MEMORY_METASPACE_METASPACESETTINGS_HPP

src/hotspot/share/memory/metaspace/metaspaceSizesSnapshot.cpp

@@ -24,18 +24,18 @@
  */
 
 #include "precompiled.hpp"
-
 #include "memory/metaspace.hpp"
 #include "memory/metaspace/metaspaceSizesSnapshot.hpp"
 
 namespace metaspace {
 
-MetaspaceSizesSnapshot::MetaspaceSizesSnapshot()
+MetaspaceSizesSnapshot::MetaspaceSizesSnapshot() :
-    : _used(MetaspaceUtils::used_bytes()),
+  _used(MetaspaceUtils::used_bytes()),
-      _committed(MetaspaceUtils::committed_bytes()),
+  _committed(MetaspaceUtils::committed_bytes()),
-      _non_class_used(MetaspaceUtils::used_bytes(Metaspace::NonClassType)),
+  _non_class_used(MetaspaceUtils::used_bytes(Metaspace::NonClassType)),
-      _non_class_committed(MetaspaceUtils::committed_bytes(Metaspace::NonClassType)),
+  _non_class_committed(MetaspaceUtils::committed_bytes(Metaspace::NonClassType)),
-      _class_used(MetaspaceUtils::used_bytes(Metaspace::ClassType)),
+  _class_used(MetaspaceUtils::used_bytes(Metaspace::ClassType)),
-      _class_committed(MetaspaceUtils::committed_bytes(Metaspace::ClassType)) { }
+  _class_committed(MetaspaceUtils::committed_bytes(Metaspace::ClassType))
+{}
 
 } // namespace metaspace

src/hotspot/share/memory/metaspace/metaspaceSizesSnapshot.hpp

@@ -26,8 +26,11 @@
 #ifndef SHARE_MEMORY_METASPACE_METASPACESIZESSNAPSHOT_HPP
 #define SHARE_MEMORY_METASPACE_METASPACESIZESSNAPSHOT_HPP
 
+#include "utilities/globalDefinitions.hpp"
+
 namespace metaspace {
 
+// Todo: clean up after jep387, see JDK-8251392
 class MetaspaceSizesSnapshot {
 public:
   MetaspaceSizesSnapshot();

src/hotspot/share/memory/metaspace/metaspaceStatistics.cpp

@@ -1,6 +1,6 @@
 /*
- * Copyright (c) 2018, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2018, 2020, Oracle and/or its affiliates. All rights reserved.
- * Copyright (c) 2018 SAP SE. All rights reserved.
+ * Copyright (c) 2018, 2020 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
@@ -22,9 +22,8 @@
  * questions.
  *
  */
-#include "precompiled.hpp"
 
-#include "memory/metaspace/metachunk.hpp"
+#include "precompiled.hpp"
 #include "memory/metaspace/metaspaceCommon.hpp"
 #include "memory/metaspace/metaspaceStatistics.hpp"
 #include "utilities/debug.hpp"
@@ -33,168 +32,139 @@
 
 namespace metaspace {
 
-// FreeChunksStatistics methods
+// Returns total word size of all chunks in this manager.
-
+void ChunkManagerStats::add(const ChunkManagerStats& other) {
-FreeChunksStatistics::FreeChunksStatistics()
+  for (chunklevel_t l = chunklevel::LOWEST_CHUNK_LEVEL; l <= chunklevel::HIGHEST_CHUNK_LEVEL; l++) {
-: _num(0), _cap(0)
+    _num_chunks[l] += other._num_chunks[l];
-{}
+    _committed_word_size[l] += other._committed_word_size[l];
-
-void FreeChunksStatistics::reset() {
-  _num = 0; _cap = 0;
-}
-
-void FreeChunksStatistics::add(uintx n, size_t s) {
-  _num += n; _cap += s;
-}
-
-void FreeChunksStatistics::add(const FreeChunksStatistics& other) {
-  _num += other._num;
-  _cap += other._cap;
-}
-
-void FreeChunksStatistics::print_on(outputStream* st, size_t scale) const {
-  st->print(UINTX_FORMAT, _num);
-  st->print(" chunks, total capacity ");
-  print_scaled_words(st, _cap, scale);
-}
-
-// ChunkManagerStatistics methods
-
-void ChunkManagerStatistics::reset() {
-  for (ChunkIndex i = ZeroIndex; i < NumberOfInUseLists; i = next_chunk_index(i)) {
-    _chunk_stats[i].reset();
   }
 }
 
-size_t ChunkManagerStatistics::total_capacity() const {
+// Returns total word size of all chunks in this manager.
-  return _chunk_stats[SpecializedIndex].cap() +
+size_t ChunkManagerStats::total_word_size() const {
-      _chunk_stats[SmallIndex].cap() +
+  size_t s = 0;
-      _chunk_stats[MediumIndex].cap() +
+  for (chunklevel_t l = chunklevel::LOWEST_CHUNK_LEVEL; l <= chunklevel::HIGHEST_CHUNK_LEVEL; l++) {
-      _chunk_stats[HumongousIndex].cap();
+    s += _num_chunks[l] * chunklevel::word_size_for_level(l);
+  }
+  return s;
 }
 
-void ChunkManagerStatistics::print_on(outputStream* st, size_t scale) const {
+// Returns total committed word size of all chunks in this manager.
-  FreeChunksStatistics totals;
+size_t ChunkManagerStats::total_committed_word_size() const {
-  for (ChunkIndex i = ZeroIndex; i < NumberOfInUseLists; i = next_chunk_index(i)) {
+  size_t s = 0;
+  for (chunklevel_t l = chunklevel::LOWEST_CHUNK_LEVEL; l <= chunklevel::HIGHEST_CHUNK_LEVEL; l++) {
+    s += _committed_word_size[l];
+  }
+  return s;
+}
+
+void ChunkManagerStats::print_on(outputStream* st, size_t scale) const {
+  // Note: used as part of MetaspaceReport so formatting matters.
+  size_t total_size = 0;
+  size_t total_committed_size = 0;
+  for (chunklevel_t l = chunklevel::LOWEST_CHUNK_LEVEL; l <= chunklevel::HIGHEST_CHUNK_LEVEL; l++) {
     st->cr();
-    st->print("%12s chunks: ", chunk_size_name(i));
+    chunklevel::print_chunk_size(st, l);
-    if (_chunk_stats[i].num() > 0) {
+    st->print(": ");
-      st->print(UINTX_FORMAT_W(4) ", capacity ", _chunk_stats[i].num());
+    if (_num_chunks[l] > 0) {
-      print_scaled_words(st, _chunk_stats[i].cap(), scale);
+      const size_t word_size = _num_chunks[l] * chunklevel::word_size_for_level(l);
+
+      st->print("%4d, capacity=", _num_chunks[l]);
+      print_scaled_words(st, word_size, scale);
+
+      st->print(", committed=");
+      print_scaled_words_and_percentage(st, _committed_word_size[l], word_size, scale);
+
+      total_size += word_size;
+      total_committed_size += _committed_word_size[l];
     } else {
       st->print("(none)");
     }
-    totals.add(_chunk_stats[i]);
   }
   st->cr();
-  st->print("%19s: " UINTX_FORMAT_W(4) ", capacity=", "Total", totals.num());
+  st->print("Total word size: ");
-  print_scaled_words(st, totals.cap(), scale);
+  print_scaled_words(st, total_size, scale);
+  st->print(", committed: ");
+  print_scaled_words_and_percentage(st, total_committed_size, total_size, scale);
   st->cr();
 }
 
-// UsedChunksStatistics methods
-
-UsedChunksStatistics::UsedChunksStatistics()
-: _num(0), _cap(0), _used(0), _free(0), _waste(0), _overhead(0)
-{}
-
-void UsedChunksStatistics::reset() {
-  _num = 0;
-  _cap = _overhead = _used = _free = _waste = 0;
-}
-
-void UsedChunksStatistics::add(const UsedChunksStatistics& other) {
-  _num += other._num;
-  _cap += other._cap;
-  _used += other._used;
-  _free += other._free;
-  _waste += other._waste;
-  _overhead += other._overhead;
-  DEBUG_ONLY(check_sanity());
-}
-
-void UsedChunksStatistics::print_on(outputStream* st, size_t scale) const {
-  int col = st->position();
-  st->print(UINTX_FORMAT_W(4) " chunk%s, ", _num, _num != 1 ? "s" : "");
-  if (_num > 0) {
-    col += 14; st->fill_to(col);
-
-    print_scaled_words(st, _cap, scale, 5);
-    st->print(" capacity, ");
-
-    col += 18; st->fill_to(col);
-    print_scaled_words_and_percentage(st, _used, _cap, scale, 5);
-    st->print(" used, ");
-
-    col += 20; st->fill_to(col);
-    print_scaled_words_and_percentage(st, _free, _cap, scale, 5);
-    st->print(" free, ");
-
-    col += 20; st->fill_to(col);
-    print_scaled_words_and_percentage(st, _waste, _cap, scale, 5);
-    st->print(" waste, ");
-
-    col += 20; st->fill_to(col);
-    print_scaled_words_and_percentage(st, _overhead, _cap, scale, 5);
-    st->print(" overhead");
-  }
-  DEBUG_ONLY(check_sanity());
-}
-
 #ifdef ASSERT
-void UsedChunksStatistics::check_sanity() const {
+void ChunkManagerStats::verify() const {
-  assert(_overhead == (Metachunk::overhead() * _num), "Sanity: Overhead.");
+  assert(total_committed_word_size() <= total_word_size(),
-  assert(_cap == _used + _free + _waste + _overhead, "Sanity: Capacity.");
+         "Sanity");
 }
 #endif
 
-// SpaceManagerStatistics methods
+void InUseChunkStats::print_on(outputStream* st, size_t scale) const {
+  int col = st->position();
+  st->print("%4d chunk%s, ", _num, _num != 1 ? "s" : "");
+  if (_num > 0) {
+    col += 14; st->fill_to(col);
 
-SpaceManagerStatistics::SpaceManagerStatistics() { reset(); }
+    print_scaled_words(st, _word_size, scale, 5);
+    st->print(" capacity,");
+
+    col += 20; st->fill_to(col);
+    print_scaled_words_and_percentage(st, _committed_words, _word_size, scale, 5);
+    st->print(" committed, ");
+
+    col += 18; st->fill_to(col);
+    print_scaled_words_and_percentage(st, _used_words, _word_size, scale, 5);
+    st->print(" used, ");
+
+    col += 20; st->fill_to(col);
+    print_scaled_words_and_percentage(st, _free_words, _word_size, scale, 5);
+    st->print(" free, ");
+
+    col += 20; st->fill_to(col);
+    print_scaled_words_and_percentage(st, _waste_words, _word_size, scale, 5);
+    st->print(" waste ");
 
-void SpaceManagerStatistics::reset() {
-  for (int i = 0; i < NumberOfInUseLists; i ++) {
-    _chunk_stats[i].reset();
-    _free_blocks_num = 0; _free_blocks_cap_words = 0;
   }
 }
 
-void SpaceManagerStatistics::add_free_blocks_info(uintx num, size_t cap) {
+#ifdef ASSERT
-  _free_blocks_num += num;
+void InUseChunkStats::verify() const {
-  _free_blocks_cap_words += cap;
+  assert(_word_size >= _committed_words &&
+      _committed_words == _used_words + _free_words + _waste_words,
+         "Sanity: cap " SIZE_FORMAT ", committed " SIZE_FORMAT ", used " SIZE_FORMAT ", free " SIZE_FORMAT ", waste " SIZE_FORMAT ".",
+         _word_size, _committed_words, _used_words, _free_words, _waste_words);
 }
+#endif
 
-void SpaceManagerStatistics::add(const SpaceManagerStatistics& other) {
+void ArenaStats::add(const ArenaStats& other) {
-  for (ChunkIndex i = ZeroIndex; i < NumberOfInUseLists; i = next_chunk_index(i)) {
+  for (chunklevel_t l = chunklevel::LOWEST_CHUNK_LEVEL; l <= chunklevel::HIGHEST_CHUNK_LEVEL; l++) {
-    _chunk_stats[i].add(other._chunk_stats[i]);
+    _stats[l].add(other._stats[l]);
   }
   _free_blocks_num += other._free_blocks_num;
-  _free_blocks_cap_words += other._free_blocks_cap_words;
+  _free_blocks_word_size += other._free_blocks_word_size;
 }
 
 // Returns total chunk statistics over all chunk types.
-UsedChunksStatistics SpaceManagerStatistics::totals() const {
+InUseChunkStats ArenaStats::totals() const {
-  UsedChunksStatistics stat;
+  InUseChunkStats out;
-  for (ChunkIndex i = ZeroIndex; i < NumberOfInUseLists; i = next_chunk_index(i)) {
+  for (chunklevel_t l = chunklevel::LOWEST_CHUNK_LEVEL; l <= chunklevel::HIGHEST_CHUNK_LEVEL; l++) {
-    stat.add(_chunk_stats[i]);
+    out.add(_stats[l]);
   }
-  return stat;
+  return out;
 }
 
-void SpaceManagerStatistics::print_on(outputStream* st, size_t scale,  bool detailed) const {
+void ArenaStats::print_on(outputStream* st, size_t scale,  bool detailed) const {
   streamIndentor sti(st);
   if (detailed) {
     st->cr_indent();
-    st->print("Usage by chunk type:");
+    st->print("Usage by chunk level:");
     {
       streamIndentor sti2(st);
-      for (ChunkIndex i = ZeroIndex; i < NumberOfInUseLists; i = next_chunk_index(i)) {
+      for (chunklevel_t l = chunklevel::LOWEST_CHUNK_LEVEL; l <= chunklevel::HIGHEST_CHUNK_LEVEL; l++) {
         st->cr_indent();
-        st->print("%15s: ", chunk_size_name(i));
+        chunklevel::print_chunk_size(st, l);
-        if (_chunk_stats[i].num() == 0) {
+        st->print(" chunks: ");
+        if (_stats[l]._num == 0) {
           st->print(" (none)");
         } else {
-          _chunk_stats[i].print_on(st, scale);
+          _stats[l].print_on(st, scale);
         }
       }
 
@@ -205,58 +175,52 @@ void SpaceManagerStatistics::print_on(outputStream* st, size_t scale,  bool deta
     if (_free_blocks_num > 0) {
       st->cr_indent();
       st->print("deallocated: " UINTX_FORMAT " blocks with ", _free_blocks_num);
-      print_scaled_words(st, _free_blocks_cap_words, scale);
+      print_scaled_words(st, _free_blocks_word_size, scale);
     }
   } else {
     totals().print_on(st, scale);
     st->print(", ");
     st->print("deallocated: " UINTX_FORMAT " blocks with ", _free_blocks_num);
-    print_scaled_words(st, _free_blocks_cap_words, scale);
+    print_scaled_words(st, _free_blocks_word_size, scale);
   }
 }
 
-// ClassLoaderMetaspaceStatistics methods
+#ifdef ASSERT
 
-ClassLoaderMetaspaceStatistics::ClassLoaderMetaspaceStatistics() { reset(); }
+void ArenaStats::verify() const {
-
+  size_t total_used = 0;
-void ClassLoaderMetaspaceStatistics::reset() {
+  for (chunklevel_t l = chunklevel::LOWEST_CHUNK_LEVEL; l <= chunklevel::HIGHEST_CHUNK_LEVEL; l++) {
-  nonclass_sm_stats().reset();
+    _stats[l].verify();
-  if (Metaspace::using_class_space()) {
+    total_used += _stats[l]._used_words;
-    class_sm_stats().reset();
   }
+  // Deallocated allocations still count as used
+  assert(total_used >= _free_blocks_word_size,
+         "Sanity");
+}
+#endif
+
+// Returns total arena statistics for both class and non-class metaspace
+ArenaStats ClmsStats::totals() const {
+  ArenaStats out;
+  out.add(_arena_stats_nonclass);
+  out.add(_arena_stats_class);
+  return out;
 }
 
-// Returns total space manager statistics for both class and non-class metaspace
+void ClmsStats::print_on(outputStream* st, size_t scale, bool detailed) const {
-SpaceManagerStatistics ClassLoaderMetaspaceStatistics::totals() const {
-  SpaceManagerStatistics stats;
-  stats.add(nonclass_sm_stats());
-  if (Metaspace::using_class_space()) {
-    stats.add(class_sm_stats());
-  }
-  return stats;
-}
-
-void ClassLoaderMetaspaceStatistics::add(const ClassLoaderMetaspaceStatistics& other) {
-  nonclass_sm_stats().add(other.nonclass_sm_stats());
-  if (Metaspace::using_class_space()) {
-    class_sm_stats().add(other.class_sm_stats());
-  }
-}
-
-void ClassLoaderMetaspaceStatistics::print_on(outputStream* st, size_t scale, bool detailed) const {
   streamIndentor sti(st);
   st->cr_indent();
   if (Metaspace::using_class_space()) {
     st->print("Non-Class: ");
   }
-  nonclass_sm_stats().print_on(st, scale, detailed);
+  _arena_stats_nonclass.print_on(st, scale, detailed);
   if (detailed) {
     st->cr();
   }
   if (Metaspace::using_class_space()) {
     st->cr_indent();
     st->print("    Class: ");
-    class_sm_stats().print_on(st, scale, detailed);
+    _arena_stats_class.print_on(st, scale, detailed);
     if (detailed) {
       st->cr();
     }
@@ -270,7 +234,12 @@ void ClassLoaderMetaspaceStatistics::print_on(outputStream* st, size_t scale, bo
   st->cr();
 }
 
+#ifdef ASSERT
+void ClmsStats::verify() const {
+  _arena_stats_nonclass.verify();
+  _arena_stats_class.verify();
+}
+#endif
+
 } // end namespace metaspace
 
-
-

src/hotspot/share/memory/metaspace/metaspaceStatistics.hpp

@@ -1,6 +1,6 @@
 /*
- * Copyright (c) 2018, 2019, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2018, 2020, Oracle and/or its affiliates. All rights reserved.
- * Copyright (c) 2018 SAP SE. All rights reserved.
+ * Copyright (c) 2018, 2020 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
@@ -26,162 +26,144 @@
 #ifndef SHARE_MEMORY_METASPACE_METASPACESTATISTICS_HPP
 #define SHARE_MEMORY_METASPACE_METASPACESTATISTICS_HPP
 
+#include "memory/metaspace.hpp"             // for MetadataType enum
+#include "memory/metaspace/chunklevel.hpp"
 #include "utilities/globalDefinitions.hpp"
-#include "memory/metaspace.hpp" // for MetadataType enum
-#include "memory/metaspace/metachunk.hpp" // for ChunkIndex enum
 
 class outputStream;
 
 namespace metaspace {
 
-// Contains statistics for a number of free chunks.
+// Contains a number of data output structures:
-class FreeChunksStatistics {
+//
-  uintx _num;         // Number of chunks
+// - cm_stats_t
-  size_t _cap;        // Total capacity, in words
+// - clms_stats_t -> arena_stats_t -> in_use_chunk_stats_t
+//
+// used for the various XXXX::add_to_statistic() methods in MetaspaceArena, ClassLoaderMetaspace
+//  and ChunkManager, respectively.
 
-public:
+struct ChunkManagerStats {
-  FreeChunksStatistics();
 
-  void reset();
+  // How many chunks per level are checked in.
+  int _num_chunks[chunklevel::NUM_CHUNK_LEVELS];
 
-  uintx num() const { return _num; }
+  // Size, in words, of the sum of all committed areas in this chunk manager, per level.
-  size_t cap() const { return _cap; }
+  size_t _committed_word_size[chunklevel::NUM_CHUNK_LEVELS];
 
-  void add(uintx n, size_t s);
+  ChunkManagerStats() : _num_chunks(), _committed_word_size() {}
-  void add(const FreeChunksStatistics& other);
-  void print_on(outputStream* st, size_t scale) const;
 
-}; // end: FreeChunksStatistics
+  void add(const ChunkManagerStats& other);
 
+  // Returns total word size of all chunks in this manager.
+  size_t total_word_size() const;
 
-// Contains statistics for a ChunkManager.
+  // Returns total committed word size of all chunks in this manager.
-class ChunkManagerStatistics {
+  size_t total_committed_word_size() const;
-
-  FreeChunksStatistics _chunk_stats[NumberOfInUseLists];
-
-public:
-
-  // Free chunk statistics, by chunk index.
-  const FreeChunksStatistics& chunk_stats(ChunkIndex index) const   { return _chunk_stats[index]; }
-  FreeChunksStatistics& chunk_stats(ChunkIndex index)               { return _chunk_stats[index]; }
-
-  void reset();
-  size_t total_capacity() const;
 
   void print_on(outputStream* st, size_t scale) const;
 
-}; // ChunkManagerStatistics
+  DEBUG_ONLY(void verify() const;)
 
-// Contains statistics for a number of chunks in use.
+};
-// Each chunk has a used and free portion; however, there are current chunks (serving
-// potential future metaspace allocations) and non-current chunks. Unused portion of the
-// former is counted as free, unused portion of the latter counts as waste.
-class UsedChunksStatistics {
-  uintx _num;     // Number of chunks
-  size_t _cap;    // Total capacity in words.
-  size_t _used;   // Total used area, in words
-  size_t _free;   // Total free area (unused portions of current chunks), in words
-  size_t _waste;  // Total waste area (unused portions of non-current chunks), in words
-  size_t _overhead; // Total sum of chunk overheads, in words.
 
-public:
+// Contains statistics for one or multiple chunks in use.
+struct InUseChunkStats {
 
-  UsedChunksStatistics();
+  // Number of chunks
+  int _num;
 
-  void reset();
+  // Note:
+  // capacity = committed + uncommitted
+  //            committed = used + free + waste
 
-  uintx num() const { return _num; }
+  // Capacity (total sum of all chunk sizes) in words.
+  // May contain committed and uncommitted space.
+  size_t _word_size;
 
-  // Total capacity, in words
+  // Total committed area, in words.
-  size_t cap() const { return _cap; }
+  size_t _committed_words;
 
-  // Total used area, in words
+  // Total used area, in words.
-  size_t used() const { return _used; }
+  size_t _used_words;
 
-  // Total free area (unused portions of current chunks), in words
+  // Total free committed area, in words.
-  size_t free() const { return _free; }
+  size_t _free_words;
 
-  // Total waste area (unused portions of non-current chunks), in words
+  // Total waste committed area, in words.
-  size_t waste() const { return _waste; }
+  size_t _waste_words;
 
-  // Total area spent in overhead (chunk headers), in words
+  InUseChunkStats() :
-  size_t overhead() const { return _overhead; }
+    _num(0),
+    _word_size(0),
+    _committed_words(0),
+    _used_words(0),
+    _free_words(0),
+    _waste_words(0)
+  {}
 
-  void add_num(uintx n) { _num += n; }
+  void add(const InUseChunkStats& other) {
-  void add_cap(size_t s) { _cap += s; }
+    _num += other._num;
-  void add_used(size_t s) { _used += s; }
+    _word_size += other._word_size;
-  void add_free(size_t s) { _free += s; }
+    _committed_words += other._committed_words;
-  void add_waste(size_t s) { _waste += s; }
+    _used_words += other._used_words;
-  void add_overhead(size_t s) { _overhead += s; }
+    _free_words += other._free_words;
+    _waste_words += other._waste_words;
 
-  void add(const UsedChunksStatistics& other);
+  }
 
   void print_on(outputStream* st, size_t scale) const;
 
-#ifdef ASSERT
+  DEBUG_ONLY(void verify() const;)
-  void check_sanity() const;
-#endif
 
-}; // UsedChunksStatistics
+};
 
-// Class containing statistics for one or more space managers.
+// Class containing statistics for one or more MetaspaceArena objects.
-class SpaceManagerStatistics {
+struct  ArenaStats {
 
-  UsedChunksStatistics _chunk_stats[NumberOfInUseLists];
+  // chunk statistics by chunk level
+  InUseChunkStats _stats[chunklevel::NUM_CHUNK_LEVELS];
   uintx _free_blocks_num;
-  size_t _free_blocks_cap_words;
+  size_t _free_blocks_word_size;
 
-public:
+  ArenaStats() :
+    _stats(),
+    _free_blocks_num(0),
+    _free_blocks_word_size(0)
+  {}
 
-  SpaceManagerStatistics();
+  void add(const ArenaStats& other);
 
-  // Chunk statistics by chunk index
+  void print_on(outputStream* st, size_t scale = K,  bool detailed = true) const;
-  const UsedChunksStatistics& chunk_stats(ChunkIndex index) const   { return _chunk_stats[index]; }
-  UsedChunksStatistics& chunk_stats(ChunkIndex index)               { return _chunk_stats[index]; }
 
-  uintx free_blocks_num () const                                    { return _free_blocks_num; }
+  InUseChunkStats totals() const;
-  size_t free_blocks_cap_words () const                             { return _free_blocks_cap_words; }
 
-  void reset();
+  DEBUG_ONLY(void verify() const;)
 
-  void add_free_blocks_info(uintx num, size_t cap);
+};
 
-  // Returns total chunk statistics over all chunk types.
+// Statistics for one or multiple ClassLoaderMetaspace objects
-  UsedChunksStatistics totals() const;
+struct ClmsStats {
 
-  void add(const SpaceManagerStatistics& other);
+  ArenaStats _arena_stats_nonclass;
+  ArenaStats _arena_stats_class;
 
-  void print_on(outputStream* st, size_t scale,  bool detailed) const;
+  ClmsStats() : _arena_stats_nonclass(), _arena_stats_class() {}
 
-}; // SpaceManagerStatistics
+  void add(const ClmsStats& other) {
-
+    _arena_stats_nonclass.add(other._arena_stats_nonclass);
-class ClassLoaderMetaspaceStatistics {
+    _arena_stats_class.add(other._arena_stats_class);
-
+  }
-  SpaceManagerStatistics _sm_stats[Metaspace::MetadataTypeCount];
-
-public:
-
-  ClassLoaderMetaspaceStatistics();
-
-  const SpaceManagerStatistics& sm_stats(Metaspace::MetadataType mdType) const { return _sm_stats[mdType]; }
-  SpaceManagerStatistics& sm_stats(Metaspace::MetadataType mdType)             { return _sm_stats[mdType]; }
-
-  const SpaceManagerStatistics& nonclass_sm_stats() const { return sm_stats(Metaspace::NonClassType); }
-  SpaceManagerStatistics& nonclass_sm_stats()             { return sm_stats(Metaspace::NonClassType); }
-  const SpaceManagerStatistics& class_sm_stats() const    { return sm_stats(Metaspace::ClassType); }
-  SpaceManagerStatistics& class_sm_stats()                { return sm_stats(Metaspace::ClassType); }
-
-  void reset();
-
-  void add(const ClassLoaderMetaspaceStatistics& other);
-
-  // Returns total space manager statistics for both class and non-class metaspace
-  SpaceManagerStatistics totals() const;
 
   void print_on(outputStream* st, size_t scale, bool detailed) const;
 
-}; // ClassLoaderMetaspaceStatistics
+  // Returns total statistics for both class and non-class metaspace
+  ArenaStats totals() const;
+
+  DEBUG_ONLY(void verify() const;)
+
+};
 
 } // namespace metaspace
 
 #endif // SHARE_MEMORY_METASPACE_METASPACESTATISTICS_HPP
+

src/hotspot/share/memory/metaspace/occupancyMap.cpp

@@ -1,135 +0,0 @@
-/*
- * Copyright (c) 2018, Oracle and/or its affiliates. All rights reserved.
- * Copyright (c) 2018 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
- * 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 "precompiled.hpp"
-#include "utilities/debug.hpp"
-#include "utilities/globalDefinitions.hpp"
-#include "memory/metaspace/metachunk.hpp"
-#include "memory/metaspace/occupancyMap.hpp"
-#include "runtime/os.hpp"
-
-namespace metaspace {
-
-OccupancyMap::OccupancyMap(const MetaWord* reference_address, size_t word_size, size_t smallest_chunk_word_size) :
-            _reference_address(reference_address), _word_size(word_size),
-            _smallest_chunk_word_size(smallest_chunk_word_size)
-{
-  assert(reference_address != NULL, "invalid reference address");
-  assert(is_aligned(reference_address, smallest_chunk_word_size),
-      "Reference address not aligned to smallest chunk size.");
-  assert(is_aligned(word_size, smallest_chunk_word_size),
-      "Word_size shall be a multiple of the smallest chunk size.");
-  // Calculate bitmap size: one bit per smallest_chunk_word_size'd area.
-  size_t num_bits = word_size / smallest_chunk_word_size;
-  _map_size = (num_bits + 7) / 8;
-  assert(_map_size * 8 >= num_bits, "sanity");
-  _map[0] = (uint8_t*) os::malloc(_map_size, mtInternal);
-  _map[1] = (uint8_t*) os::malloc(_map_size, mtInternal);
-  assert(_map[0] != NULL && _map[1] != NULL, "Occupancy Map: allocation failed.");
-  memset(_map[1], 0, _map_size);
-  memset(_map[0], 0, _map_size);
-  // Sanity test: the first respectively last possible chunk start address in
-  // the covered range shall map to the first and last bit in the bitmap.
-  assert(get_bitpos_for_address(reference_address) == 0,
-      "First chunk address in range must map to fist bit in bitmap.");
-  assert(get_bitpos_for_address(reference_address + word_size - smallest_chunk_word_size) == num_bits - 1,
-      "Last chunk address in range must map to last bit in bitmap.");
-}
-
-OccupancyMap::~OccupancyMap() {
-  os::free(_map[0]);
-  os::free(_map[1]);
-}
-
-#ifdef ASSERT
-// Verify occupancy map for the address range [from, to).
-// We need to tell it the address range, because the memory the
-// occupancy map is covering may not be fully comitted yet.
-void OccupancyMap::verify(MetaWord* from, MetaWord* to) {
-  Metachunk* chunk = NULL;
-  int nth_bit_for_chunk = 0;
-  MetaWord* chunk_end = NULL;
-  for (MetaWord* p = from; p < to; p += _smallest_chunk_word_size) {
-    const unsigned pos = get_bitpos_for_address(p);
-    // Check the chunk-starts-info:
-    if (get_bit_at_position(pos, layer_chunk_start_map)) {
-      // Chunk start marked in bitmap.
-      chunk = (Metachunk*) p;
-      if (chunk_end != NULL) {
-        assert(chunk_end == p, "Unexpected chunk start found at %p (expected "
-            "the next chunk to start at %p).", p, chunk_end);
-      }
-      assert(chunk->is_valid_sentinel(), "Invalid chunk at address %p.", p);
-      if (chunk->get_chunk_type() != HumongousIndex) {
-        guarantee(is_aligned(p, chunk->word_size()), "Chunk %p not aligned.", p);
-      }
-      chunk_end = p + chunk->word_size();
-      nth_bit_for_chunk = 0;
-      assert(chunk_end <= to, "Chunk end overlaps test address range.");
-    } else {
-      // No chunk start marked in bitmap.
-      assert(chunk != NULL, "Chunk should start at start of address range.");
-      assert(p < chunk_end, "Did not find expected chunk start at %p.", p);
-      nth_bit_for_chunk ++;
-    }
-    // Check the in-use-info:
-    const bool in_use_bit = get_bit_at_position(pos, layer_in_use_map);
-    if (in_use_bit) {
-      assert(!chunk->is_tagged_free(), "Chunk %p: marked in-use in map but is free (bit %u).",
-          chunk, nth_bit_for_chunk);
-    } else {
-      assert(chunk->is_tagged_free(), "Chunk %p: marked free in map but is in use (bit %u).",
-          chunk, nth_bit_for_chunk);
-    }
-  }
-}
-
-// Verify that a given chunk is correctly accounted for in the bitmap.
-void OccupancyMap::verify_for_chunk(Metachunk* chunk) {
-  assert(chunk_starts_at_address((MetaWord*) chunk),
-      "No chunk start marked in map for chunk %p.", chunk);
-  // For chunks larger than the minimal chunk size, no other chunk
-  // must start in its area.
-  if (chunk->word_size() > _smallest_chunk_word_size) {
-    assert(!is_any_bit_set_in_region(((MetaWord*) chunk) + _smallest_chunk_word_size,
-        chunk->word_size() - _smallest_chunk_word_size, layer_chunk_start_map),
-        "No chunk must start within another chunk.");
-  }
-  if (!chunk->is_tagged_free()) {
-    assert(is_region_in_use((MetaWord*)chunk, chunk->word_size()),
-        "Chunk %p is in use but marked as free in map (%d %d).",
-        chunk, chunk->get_chunk_type(), chunk->get_origin());
-  } else {
-    assert(!is_region_in_use((MetaWord*)chunk, chunk->word_size()),
-        "Chunk %p is free but marked as in-use in map (%d %d).",
-        chunk, chunk->get_chunk_type(), chunk->get_origin());
-  }
-}
-
-#endif // ASSERT
-
-} // namespace metaspace
-
-

src/hotspot/share/memory/metaspace/occupancyMap.hpp

@@ -1,242 +0,0 @@
-/*
- * Copyright (c) 2018, 2019, Oracle and/or its affiliates. All rights reserved.
- * Copyright (c) 2018 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
- * 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.
- *
- */
-
-#ifndef SHARE_MEMORY_METASPACE_OCCUPANCYMAP_HPP
-#define SHARE_MEMORY_METASPACE_OCCUPANCYMAP_HPP
-
-#include "memory/allocation.hpp"
-#include "utilities/debug.hpp"
-#include "utilities/globalDefinitions.hpp"
-
-
-namespace metaspace {
-
-class Metachunk;
-
-// Helper for Occupancy Bitmap. A type trait to give an all-bits-are-one-unsigned constant.
-template <typename T> struct all_ones  { static const T value; };
-template <> struct all_ones <uint64_t> { static const uint64_t value = 0xFFFFFFFFFFFFFFFFULL; };
-template <> struct all_ones <uint32_t> { static const uint32_t value = 0xFFFFFFFF; };
-
-// The OccupancyMap is a bitmap which, for a given VirtualSpaceNode,
-// keeps information about
-// - where a chunk starts
-// - whether a chunk is in-use or free
-// A bit in this bitmap represents one range of memory in the smallest
-// chunk size (SpecializedChunk or ClassSpecializedChunk).
-class OccupancyMap : public CHeapObj<mtInternal> {
-
-  // The address range this map covers.
-  const MetaWord* const _reference_address;
-  const size_t _word_size;
-
-  // The word size of a specialized chunk, aka the number of words one
-  // bit in this map represents.
-  const size_t _smallest_chunk_word_size;
-
-  // map data
-  // Data are organized in two bit layers:
-  // The first layer is the chunk-start-map. Here, a bit is set to mark
-  // the corresponding region as the head of a chunk.
-  // The second layer is the in-use-map. Here, a set bit indicates that
-  // the corresponding belongs to a chunk which is in use.
-  uint8_t* _map[2];
-
-  enum { layer_chunk_start_map = 0, layer_in_use_map = 1 };
-
-  // length, in bytes, of bitmap data
-  size_t _map_size;
-
-  // Returns true if bit at position pos at bit-layer layer is set.
-  bool get_bit_at_position(unsigned pos, unsigned layer) const {
-    assert(layer == 0 || layer == 1, "Invalid layer %d", layer);
-    const unsigned byteoffset = pos / 8;
-    assert(byteoffset < _map_size,
-           "invalid byte offset (%u), map size is " SIZE_FORMAT ".", byteoffset, _map_size);
-    const unsigned mask = 1 << (pos % 8);
-    return (_map[layer][byteoffset] & mask) > 0;
-  }
-
-  // Changes bit at position pos at bit-layer layer to value v.
-  void set_bit_at_position(unsigned pos, unsigned layer, bool v) {
-    assert(layer == 0 || layer == 1, "Invalid layer %d", layer);
-    const unsigned byteoffset = pos / 8;
-    assert(byteoffset < _map_size,
-           "invalid byte offset (%u), map size is " SIZE_FORMAT ".", byteoffset, _map_size);
-    const unsigned mask = 1 << (pos % 8);
-    if (v) {
-      _map[layer][byteoffset] |= mask;
-    } else {
-      _map[layer][byteoffset] &= ~mask;
-    }
-  }
-
-  // Optimized case of is_any_bit_set_in_region for 32/64bit aligned access:
-  // pos is 32/64 aligned and num_bits is 32/64.
-  // This is the typical case when coalescing to medium chunks, whose size is
-  // 32 or 64 times the specialized chunk size (depending on class or non class
-  // case), so they occupy 64 bits which should be 64bit aligned, because
-  // chunks are chunk-size aligned.
-  template <typename T>
-  bool is_any_bit_set_in_region_3264(unsigned pos, unsigned num_bits, unsigned layer) const {
-    assert(_map_size > 0, "not initialized");
-    assert(layer == 0 || layer == 1, "Invalid layer %d.", layer);
-    assert(pos % (sizeof(T) * 8) == 0, "Bit position must be aligned (%u).", pos);
-    assert(num_bits == (sizeof(T) * 8), "Number of bits incorrect (%u).", num_bits);
-    const size_t byteoffset = pos / 8;
-    assert(byteoffset <= (_map_size - sizeof(T)),
-           "Invalid byte offset (" SIZE_FORMAT "), map size is " SIZE_FORMAT ".", byteoffset, _map_size);
-    const T w = *(T*)(_map[layer] + byteoffset);
-    return w > 0 ? true : false;
-  }
-
-  // Returns true if any bit in region [pos1, pos1 + num_bits) is set in bit-layer layer.
-  bool is_any_bit_set_in_region(unsigned pos, unsigned num_bits, unsigned layer) const {
-    if (pos % 32 == 0 && num_bits == 32) {
-      return is_any_bit_set_in_region_3264<uint32_t>(pos, num_bits, layer);
-    } else if (pos % 64 == 0 && num_bits == 64) {
-      return is_any_bit_set_in_region_3264<uint64_t>(pos, num_bits, layer);
-    } else {
-      for (unsigned n = 0; n < num_bits; n ++) {
-        if (get_bit_at_position(pos + n, layer)) {
-          return true;
-        }
-      }
-    }
-    return false;
-  }
-
-  // Returns true if any bit in region [p, p+word_size) is set in bit-layer layer.
-  bool is_any_bit_set_in_region(MetaWord* p, size_t word_size, unsigned layer) const {
-    assert(word_size % _smallest_chunk_word_size == 0,
-        "Region size " SIZE_FORMAT " not a multiple of smallest chunk size.", word_size);
-    const unsigned pos = get_bitpos_for_address(p);
-    const unsigned num_bits = (unsigned) (word_size / _smallest_chunk_word_size);
-    return is_any_bit_set_in_region(pos, num_bits, layer);
-  }
-
-  // Optimized case of set_bits_of_region for 32/64bit aligned access:
-  // pos is 32/64 aligned and num_bits is 32/64.
-  // This is the typical case when coalescing to medium chunks, whose size
-  // is 32 or 64 times the specialized chunk size (depending on class or non
-  // class case), so they occupy 64 bits which should be 64bit aligned,
-  // because chunks are chunk-size aligned.
-  template <typename T>
-  void set_bits_of_region_T(unsigned pos, unsigned num_bits, unsigned layer, bool v) {
-    assert(pos % (sizeof(T) * 8) == 0, "Bit position must be aligned to %u (%u).",
-           (unsigned)(sizeof(T) * 8), pos);
-    assert(num_bits == (sizeof(T) * 8), "Number of bits incorrect (%u), expected %u.",
-           num_bits, (unsigned)(sizeof(T) * 8));
-    const size_t byteoffset = pos / 8;
-    assert(byteoffset <= (_map_size - sizeof(T)),
-           "invalid byte offset (" SIZE_FORMAT "), map size is " SIZE_FORMAT ".", byteoffset, _map_size);
-    T* const pw = (T*)(_map[layer] + byteoffset);
-    *pw = v ? all_ones<T>::value : (T) 0;
-  }
-
-  // Set all bits in a region starting at pos to a value.
-  void set_bits_of_region(unsigned pos, unsigned num_bits, unsigned layer, bool v) {
-    assert(_map_size > 0, "not initialized");
-    assert(layer == 0 || layer == 1, "Invalid layer %d.", layer);
-    if (pos % 32 == 0 && num_bits == 32) {
-      set_bits_of_region_T<uint32_t>(pos, num_bits, layer, v);
-    } else if (pos % 64 == 0 && num_bits == 64) {
-      set_bits_of_region_T<uint64_t>(pos, num_bits, layer, v);
-    } else {
-      for (unsigned n = 0; n < num_bits; n ++) {
-        set_bit_at_position(pos + n, layer, v);
-      }
-    }
-  }
-
-  // Helper: sets all bits in a region [p, p+word_size).
-  void set_bits_of_region(MetaWord* p, size_t word_size, unsigned layer, bool v) {
-    assert(word_size % _smallest_chunk_word_size == 0,
-        "Region size " SIZE_FORMAT " not a multiple of smallest chunk size.", word_size);
-    const unsigned pos = get_bitpos_for_address(p);
-    const unsigned num_bits = (unsigned) (word_size / _smallest_chunk_word_size);
-    set_bits_of_region(pos, num_bits, layer, v);
-  }
-
-  // Helper: given an address, return the bit position representing that address.
-  unsigned get_bitpos_for_address(const MetaWord* p) const {
-    assert(_reference_address != NULL, "not initialized");
-    assert(p >= _reference_address && p < _reference_address + _word_size,
-           "Address %p out of range for occupancy map [%p..%p).",
-            p, _reference_address, _reference_address + _word_size);
-    assert(is_aligned(p, _smallest_chunk_word_size * sizeof(MetaWord)),
-           "Address not aligned (%p).", p);
-    const ptrdiff_t d = (p - _reference_address) / _smallest_chunk_word_size;
-    assert(d >= 0 && (size_t)d < _map_size * 8, "Sanity.");
-    return (unsigned) d;
-  }
-
- public:
-
-  OccupancyMap(const MetaWord* reference_address, size_t word_size, size_t smallest_chunk_word_size);
-  ~OccupancyMap();
-
-  // Returns true if at address x a chunk is starting.
-  bool chunk_starts_at_address(MetaWord* p) const {
-    const unsigned pos = get_bitpos_for_address(p);
-    return get_bit_at_position(pos, layer_chunk_start_map);
-  }
-
-  void set_chunk_starts_at_address(MetaWord* p, bool v) {
-    const unsigned pos = get_bitpos_for_address(p);
-    set_bit_at_position(pos, layer_chunk_start_map, v);
-  }
-
-  // Removes all chunk-start-bits inside a region, typically as a
-  // result of a chunk merge.
-  void wipe_chunk_start_bits_in_region(MetaWord* p, size_t word_size) {
-    set_bits_of_region(p, word_size, layer_chunk_start_map, false);
-  }
-
-  // Returns true if there are life (in use) chunks in the region limited
-  // by [p, p+word_size).
-  bool is_region_in_use(MetaWord* p, size_t word_size) const {
-    return is_any_bit_set_in_region(p, word_size, layer_in_use_map);
-  }
-
-  // Marks the region starting at p with the size word_size as in use
-  // or free, depending on v.
-  void set_region_in_use(MetaWord* p, size_t word_size, bool v) {
-    set_bits_of_region(p, word_size, layer_in_use_map, v);
-  }
-
-  // Verify occupancy map for the address range [from, to).
-  // We need to tell it the address range, because the memory the
-  // occupancy map is covering may not be fully comitted yet.
-  DEBUG_ONLY(void verify(MetaWord* from, MetaWord* to);)
-
-  // Verify that a given chunk is correctly accounted for in the bitmap.
-  DEBUG_ONLY(void verify_for_chunk(Metachunk* chunk);)
-
-};
-
-} // namespace metaspace
-
-#endif // SHARE_MEMORY_METASPACE_OCCUPANCYMAP_HPP

src/hotspot/share/memory/metaspace/printCLDMetaspaceInfoClosure.cpp

@@ -1,5 +1,6 @@
 /*
  * Copyright (c) 2018, 2020, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2018, 2020 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
@@ -21,26 +22,32 @@
  * questions.
  *
  */
+
 #include "precompiled.hpp"
 #include "classfile/classLoaderData.inline.hpp"
 #include "classfile/javaClasses.hpp"
+#include "memory/classLoaderMetaspace.hpp"
+#include "memory/metaspace/metaspaceCommon.hpp"
 #include "memory/metaspace/printCLDMetaspaceInfoClosure.hpp"
 #include "memory/metaspace/printMetaspaceInfoKlassClosure.hpp"
-#include "memory/metaspaceShared.hpp"
 #include "memory/resourceArea.hpp"
 #include "runtime/safepoint.hpp"
 #include "utilities/globalDefinitions.hpp"
 #include "utilities/ostream.hpp"
 
-
 namespace metaspace {
 
 PrintCLDMetaspaceInfoClosure::PrintCLDMetaspaceInfoClosure(outputStream* out, size_t scale, bool do_print,
-    bool do_print_classes, bool break_down_by_chunktype)
+                                                           bool do_print_classes, bool break_down_by_chunktype) :
-: _out(out), _scale(scale), _do_print(do_print), _do_print_classes(do_print_classes)
+  _out(out),
-, _break_down_by_chunktype(break_down_by_chunktype)
+  _scale(scale),
-, _num_loaders(0), _num_loaders_without_metaspace(0), _num_loaders_unloading(0)
+  _do_print(do_print),
-,  _num_classes(0), _num_classes_shared(0)
+  _do_print_classes(do_print_classes),
+  _break_down_by_chunktype(break_down_by_chunktype),
+  _num_loaders(0),
+  _num_loaders_without_metaspace(0),
+  _num_loaders_unloading(0),
+  _num_classes(0), _num_classes_shared(0)
 {
   memset(_num_loaders_by_spacetype, 0, sizeof(_num_loaders_by_spacetype));
   memset(_num_classes_by_spacetype, 0, sizeof(_num_classes_by_spacetype));
@@ -56,36 +63,35 @@ public:
 
   CountKlassClosure() : _num_classes(0), _num_classes_shared(0) {}
   void do_klass(Klass* k) {
-    _num_classes ++;
+    _num_classes++;
     if (k->is_shared()) {
-      _num_classes_shared ++;
+      _num_classes_shared++;
     }
   }
 
 }; // end: PrintKlassInfoClosure
 
 void PrintCLDMetaspaceInfoClosure::do_cld(ClassLoaderData* cld) {
-
   assert(SafepointSynchronize::is_at_safepoint(), "Must be at a safepoint");
 
   if (cld->is_unloading()) {
-    _num_loaders_unloading ++;
+    _num_loaders_unloading++;
     return;
   }
 
   ClassLoaderMetaspace* msp = cld->metaspace_or_null();
   if (msp == NULL) {
-    _num_loaders_without_metaspace ++;
+    _num_loaders_without_metaspace++;
     return;
   }
 
   // Collect statistics for this class loader metaspace
-  ClassLoaderMetaspaceStatistics this_cld_stat;
+  ClmsStats this_cld_stat;
   msp->add_to_statistics(&this_cld_stat);
 
   // And add it to the running totals
   _stats_total.add(this_cld_stat);
-  _num_loaders ++;
+  _num_loaders++;
   _stats_by_spacetype[msp->space_type()].add(this_cld_stat);
   _num_loaders_by_spacetype[msp->space_type()] ++;
 
@@ -100,12 +106,10 @@ void PrintCLDMetaspaceInfoClosure::do_cld(ClassLoaderData* cld) {
 
   // Optionally, print
   if (_do_print) {
-
     _out->print(UINTX_FORMAT_W(4) ": ", _num_loaders);
 
     // Print "CLD for [<loader name>,] instance of <loader class name>"
     // or    "CLD for <hidden or anonymous class>, loaded by [<loader name>,] instance of <loader class name>"
-
     ResourceMark rm;
     const char* name = NULL;
     const char* class_name = NULL;
@@ -161,9 +165,7 @@ void PrintCLDMetaspaceInfoClosure::do_cld(ClassLoaderData* cld) {
     // Print statistics
     this_cld_stat.print_on(_out, _scale, _break_down_by_chunktype);
     _out->cr();
-
   }
-
 }
 
 } // namespace metaspace

src/hotspot/share/memory/metaspace/printCLDMetaspaceInfoClosure.hpp

@@ -1,5 +1,6 @@
 /*
- * Copyright (c) 2018, 2019, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2018, 2020, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2018, 2020 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
@@ -47,10 +48,10 @@ public:
   uintx                           _num_loaders;
   uintx                           _num_loaders_without_metaspace;
   uintx                           _num_loaders_unloading;
-  ClassLoaderMetaspaceStatistics  _stats_total;
+  ClmsStats                       _stats_total;
 
   uintx                           _num_loaders_by_spacetype [Metaspace::MetaspaceTypeCount];
-  ClassLoaderMetaspaceStatistics  _stats_by_spacetype [Metaspace::MetaspaceTypeCount];
+  ClmsStats                       _stats_by_spacetype [Metaspace::MetaspaceTypeCount];
 
   uintx                           _num_classes_by_spacetype [Metaspace::MetaspaceTypeCount];
   uintx                           _num_classes_shared_by_spacetype [Metaspace::MetaspaceTypeCount];
@@ -58,7 +59,7 @@ public:
   uintx                           _num_classes_shared;
 
   PrintCLDMetaspaceInfoClosure(outputStream* out, size_t scale, bool do_print,
-      bool do_print_classes, bool break_down_by_chunktype);
+                               bool do_print_classes, bool break_down_by_chunktype);
   void do_cld(ClassLoaderData* cld);
 
 };

src/hotspot/share/memory/metaspace/printMetaspaceInfoKlassClosure.cpp

@@ -23,15 +23,13 @@
  *
  */
 #include "precompiled.hpp"
-
-#include "memory/metaspaceShared.hpp"
 #include "memory/metaspace/printMetaspaceInfoKlassClosure.hpp"
+#include "memory/metaspaceShared.hpp"
 #include "memory/resourceArea.hpp"
 #include "oops/reflectionAccessorImplKlassHelper.hpp"
 #include "utilities/globalDefinitions.hpp"
 #include "utilities/ostream.hpp"
 
-
 namespace metaspace {
 
 PrintMetaspaceInfoKlassClosure::PrintMetaspaceInfoKlassClosure(outputStream* out, bool do_print)
@@ -39,7 +37,7 @@ PrintMetaspaceInfoKlassClosure::PrintMetaspaceInfoKlassClosure(outputStream* out
 {}
 
 void PrintMetaspaceInfoKlassClosure::do_klass(Klass* k) {
-  _cnt ++;
+  _cnt++;
   _out->cr_indent();
   _out->print(UINTX_FORMAT_W(4) ": ", _cnt);
 

src/hotspot/share/memory/metaspace/rootChunkArea.cpp

@@ -0,0 +1,512 @@
+/*
+ * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2020 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
+ * 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 "precompiled.hpp"
+#include "logging/log.hpp"
+#include "memory/allocation.hpp"
+#include "memory/metaspace/chunkHeaderPool.hpp"
+#include "memory/metaspace/chunkManager.hpp"
+#include "memory/metaspace/freeChunkList.hpp"
+#include "memory/metaspace/metachunk.hpp"
+#include "memory/metaspace/metaspaceCommon.hpp"
+#include "memory/metaspace/rootChunkArea.hpp"
+#include "runtime/mutexLocker.hpp"
+#include "utilities/debug.hpp"
+#include "utilities/globalDefinitions.hpp"
+
+namespace metaspace {
+
+RootChunkArea::RootChunkArea(const MetaWord* base) :
+  _base(base),
+  _first_chunk(NULL)
+{}
+
+RootChunkArea::~RootChunkArea() {
+  // This is called when a VirtualSpaceNode is destructed (purged).
+  // All chunks should be free of course. In fact, there should only
+  // be one chunk, since all free chunks should have been merged.
+  if (_first_chunk != NULL) {
+    assert(_first_chunk->is_root_chunk() && _first_chunk->is_free(),
+           "Cannot delete root chunk area if not all chunks are free.");
+    ChunkHeaderPool::pool()->return_chunk_header(_first_chunk);
+  }
+}
+
+// Initialize: allocate a root node and a root chunk header; return the
+// root chunk header. It will be partly initialized.
+// Note: this just allocates a memory-less header; memory itself is allocated inside VirtualSpaceNode.
+Metachunk* RootChunkArea::alloc_root_chunk_header(VirtualSpaceNode* node) {
+  assert(_first_chunk == 0, "already have a root");
+  Metachunk* c = ChunkHeaderPool::pool()->allocate_chunk_header();
+  c->initialize(node, const_cast<MetaWord*>(_base), chunklevel::ROOT_CHUNK_LEVEL);
+  _first_chunk = c;
+  return c;
+}
+
+// Given a chunk c, split it recursively until you get a chunk of the given target_level.
+//
+// The resulting target chunk resides at the same address as the original chunk.
+// The resulting splinters are added to freelists.
+//
+// Returns pointer to the result chunk; the splitted-off chunks are added as
+//  free chunks to the freelists.
+void RootChunkArea::split(chunklevel_t target_level, Metachunk* c, FreeChunkListVector* freelists) {
+  // Splitting a chunk once works like this:
+  //
+  // For a given chunk we want to split:
+  // - increase the chunk level (which halves its size)
+  // - (but leave base address as it is since it will be the leader of the newly
+  //    created chunk pair)
+  // - then create a new chunk header of the same level, set its memory range
+  //   to cover the second half of the old chunk.
+  // - wire them up (prev_in_vs/next_in_vs)
+  // - return the follower chunk as "splinter chunk" in the splinters array.
+
+  // Doing this multiple times will create a new free splinter chunk for every
+  // level we split:
+  //
+  // A  <- original chunk
+  //
+  // B B  <- split into two halves
+  //
+  // C C B  <- first half split again
+  //
+  // D D C B  <- first half split again ...
+  //
+
+  DEBUG_ONLY(check_pointer(c->base());)
+  DEBUG_ONLY(c->verify();)
+  assert(c->is_free(), "Can only split free chunks.");
+
+  DEBUG_ONLY(chunklevel::check_valid_level(target_level));
+  assert(target_level > c->level(), "Wrong target level");
+
+  const chunklevel_t starting_level = c->level();
+
+  while (c->level() < target_level) {
+
+    log_trace(metaspace)("Splitting chunk: " METACHUNK_FULL_FORMAT ".", METACHUNK_FULL_FORMAT_ARGS(c));
+
+    c->inc_level();
+    Metachunk* splinter_chunk = ChunkHeaderPool::pool()->allocate_chunk_header();
+    splinter_chunk->initialize(c->vsnode(), c->end(), c->level());
+
+    // Fix committed words info: If over the half of the original chunk was
+    // committed, committed area spills over into the follower chunk.
+    const size_t old_committed_words = c->committed_words();
+    if (old_committed_words > c->word_size()) {
+      c->set_committed_words(c->word_size());
+      splinter_chunk->set_committed_words(old_committed_words - c->word_size());
+    } else {
+      splinter_chunk->set_committed_words(0);
+    }
+
+    // Insert splinter chunk into vs list
+    if (c->next_in_vs() != NULL) {
+      c->next_in_vs()->set_prev_in_vs(splinter_chunk);
+    }
+    splinter_chunk->set_next_in_vs(c->next_in_vs());
+    splinter_chunk->set_prev_in_vs(c);
+    c->set_next_in_vs(splinter_chunk);
+
+    log_trace(metaspace)(".. Result chunk: " METACHUNK_FULL_FORMAT ".", METACHUNK_FULL_FORMAT_ARGS(c));
+    log_trace(metaspace)(".. Splinter chunk: " METACHUNK_FULL_FORMAT ".", METACHUNK_FULL_FORMAT_ARGS(splinter_chunk));
+
+    // Add splinter to free lists
+    freelists->add(splinter_chunk);
+  }
+
+  assert(c->level() == target_level, "Sanity");
+
+  DEBUG_ONLY(verify();)
+  DEBUG_ONLY(c->verify();)
+}
+
+// Given a chunk, attempt to merge it recursively with its neighboring chunks.
+//
+// If successful (merged at least once), returns address of
+// the merged chunk; NULL otherwise.
+//
+// The merged chunks are removed from the freelists.
+//
+// !!! Please note that if this method returns a non-NULL value, the
+// original chunk will be invalid and should not be accessed anymore! !!!
+Metachunk* RootChunkArea::merge(Metachunk* c, FreeChunkListVector* freelists) {
+  // Note rules:
+  //
+  // - a chunk always has a buddy, unless it is a root chunk.
+  // - In that buddy pair, a chunk is either leader or follower.
+  // - a chunk's base address is always aligned at its size.
+  // - if chunk is leader, its base address is also aligned to the size of the next
+  //   lower level, at least. A follower chunk is not.
+
+  // How we merge once:
+  //
+  // For a given chunk c, which has to be free and non-root, we do:
+  // - find out if we are the leader or the follower chunk
+  // - if we are leader, next_in_vs must be the follower; if we are follower,
+  //   prev_in_vs must be the leader. Now we have the buddy chunk.
+  // - However, if the buddy chunk itself is split (of a level higher than us)
+  //   we cannot merge.
+  // - we can only merge if the buddy is of the same level as we are and it is
+  //   free.
+  // - Then we merge by simply removing the follower chunk from the address range
+  //   linked list (returning the now useless header to the pool) and decreasing
+  //   the leader chunk level by one. That makes it double the size.
+
+  // Example:
+  // (lower case chunks are free, the * indicates the chunk we want to merge):
+  //
+  // ........................
+  // d d*c   b       A           <- we return the second (d*) chunk...
+  //
+  // c*  c   b       A           <- we merge it with its predecessor and decrease its level...
+  //
+  // b*      b       A           <- we merge it again, since its new neighbor was free too...
+  //
+  // a*              A           <- we merge it again, since its new neighbor was free too...
+  //
+  // And we are done, since its new neighbor, (A), is not free. We would also be done
+  // if the new neighbor itself is splintered.
+
+  DEBUG_ONLY(check_pointer(c->base());)
+  assert(!c->is_root_chunk(), "Cannot be merged further.");
+  assert(c->is_free(), "Can only merge free chunks.");
+
+  DEBUG_ONLY(c->verify();)
+
+  log_trace(metaspace)("Attempting to merge chunk " METACHUNK_FORMAT ".", METACHUNK_FORMAT_ARGS(c));
+
+  const chunklevel_t starting_level = c->level();
+
+  bool stop = false;
+  Metachunk* result = NULL;
+
+  do {
+
+    // First find out if this chunk is the leader of its pair
+    const bool is_leader = c->is_leader();
+
+    // Note: this is either our buddy or a splinter of the buddy.
+    Metachunk* const buddy = c->is_leader() ? c->next_in_vs() : c->prev_in_vs();
+    DEBUG_ONLY(buddy->verify();)
+
+    // A buddy chunk must be of the same or higher level (so, same size or smaller)
+    // never be larger.
+    assert(buddy->level() >= c->level(), "Sanity");
+
+    // Is this really my buddy (same level) or a splinter of it (higher level)?
+    // Also, is it free?
+    if (buddy->level() != c->level() || buddy->is_free() == false) {
+      log_trace(metaspace)("cannot merge with chunk " METACHUNK_FORMAT ".", METACHUNK_FORMAT_ARGS(buddy));
+      stop = true;
+    } else {
+      log_trace(metaspace)("will merge with chunk " METACHUNK_FORMAT ".", METACHUNK_FORMAT_ARGS(buddy));
+
+      // We can merge with the buddy.
+      // First, remove buddy from the chunk manager.
+      assert(buddy->is_free(), "Sanity");
+      freelists->remove(buddy);
+
+      // Determine current leader and follower
+      Metachunk* leader;
+      Metachunk* follower;
+      if (is_leader) {
+        leader = c; follower = buddy;
+      } else {
+        leader = buddy; follower = c;
+      }
+
+      // Last checkpoint
+      assert(leader->end() == follower->base() &&
+             leader->level() == follower->level() &&
+             leader->is_free() && follower->is_free(), "Sanity");
+
+      // The new merged chunk is as far committed as possible (if leader
+      // chunk is fully committed, as far as the follower chunk).
+      size_t merged_committed_words = leader->committed_words();
+      if (merged_committed_words == leader->word_size()) {
+        merged_committed_words += follower->committed_words();
+      }
+
+      // Leader survives, follower chunk is freed. Remove follower from vslist ..
+      leader->set_next_in_vs(follower->next_in_vs());
+      if (follower->next_in_vs() != NULL) {
+        follower->next_in_vs()->set_prev_in_vs(leader);
+      }
+
+      // .. and return follower chunk header to pool for reuse.
+      ChunkHeaderPool::pool()->return_chunk_header(follower);
+
+      // Leader level gets decreased (leader chunk doubles in size) but
+      // base address stays the same.
+      leader->dec_level();
+
+      // set commit boundary
+      leader->set_committed_words(merged_committed_words);
+
+      // If the leader is now of root chunk size, stop merging
+      if (leader->is_root_chunk()) {
+        stop = true;
+      }
+
+      result = c = leader;
+      DEBUG_ONLY(leader->verify();)
+    }
+  } while (!stop);
+
+#ifdef ASSERT
+  verify();
+  if (result != NULL) {
+    result->verify();
+  }
+#endif // ASSERT
+  return result;
+}
+
+// Given a chunk c, which must be "in use" and must not be a root chunk, attempt to
+// enlarge it in place by claiming its trailing buddy.
+//
+// This will only work if c is the leader of the buddy pair and the trailing buddy is free.
+//
+// If successful, the follower chunk will be removed from the freelists, the leader chunk c will
+// double in size (level decreased by one).
+//
+// On success, true is returned, false otherwise.
+bool RootChunkArea::attempt_enlarge_chunk(Metachunk* c, FreeChunkListVector* freelists) {
+  DEBUG_ONLY(check_pointer(c->base());)
+  assert(!c->is_root_chunk(), "Cannot be merged further.");
+
+  // There is no real reason for this limitation other than it is not
+  // needed on free chunks since they should be merged already:
+  assert(c->is_in_use(), "Can only enlarge in use chunks.");
+  DEBUG_ONLY(c->verify();)
+
+  if (!c->is_leader()) {
+    return false;
+  }
+
+  // We are the leader, so the buddy must follow us.
+  Metachunk* const buddy = c->next_in_vs();
+  DEBUG_ONLY(buddy->verify();)
+
+  // Of course buddy cannot be larger than us.
+  assert(buddy->level() >= c->level(), "Sanity");
+
+  // We cannot merge buddy in if it is not free...
+  if (!buddy->is_free()) {
+    return false;
+  }
+  // ... nor if it is splintered.
+  if (buddy->level() != c->level()) {
+    return false;
+  }
+
+  // Okay, lets enlarge c.
+  log_trace(metaspace)("Enlarging chunk " METACHUNK_FULL_FORMAT " by merging in follower " METACHUNK_FULL_FORMAT ".",
+                       METACHUNK_FULL_FORMAT_ARGS(c), METACHUNK_FULL_FORMAT_ARGS(buddy));
+
+  // the enlarged c is as far committed as possible:
+  size_t merged_committed_words = c->committed_words();
+  if (merged_committed_words == c->word_size()) {
+    merged_committed_words += buddy->committed_words();
+  }
+
+  // Remove buddy from vs list...
+  Metachunk* successor = buddy->next_in_vs();
+  if (successor != NULL) {
+    successor->set_prev_in_vs(c);
+  }
+  c->set_next_in_vs(successor);
+
+  // .. and from freelist ...
+  freelists->remove(buddy);
+
+  // .. and return its empty husk to the pool...
+  ChunkHeaderPool::pool()->return_chunk_header(buddy);
+
+  // Then decrease level of c.
+  c->dec_level();
+
+  // and correct committed words if needed.
+  c->set_committed_words(merged_committed_words);
+
+  log_debug(metaspace)("Enlarged chunk " METACHUNK_FULL_FORMAT ".", METACHUNK_FULL_FORMAT_ARGS(c));
+
+  DEBUG_ONLY(verify());
+  return true;
+}
+
+// Returns true if this root chunk area is completely free:
+//  In that case, it should only contain one chunk (maximally merged, so a root chunk)
+//  and it should be free.
+bool RootChunkArea::is_free() const {
+  return _first_chunk == NULL ||
+      (_first_chunk->is_root_chunk() && _first_chunk->is_free());
+}
+
+#ifdef ASSERT
+
+#define assrt_(cond, ...) \
+  if (!(cond)) { \
+    fdStream errst(2); \
+    this->print_on(&errst); \
+    vmassert(cond, __VA_ARGS__); \
+  }
+
+void RootChunkArea::verify() const {
+  assert_lock_strong(MetaspaceExpand_lock);
+  assert_is_aligned(_base, chunklevel::MAX_CHUNK_BYTE_SIZE);
+
+  // Iterate thru all chunks in this area. They must be ordered correctly,
+  // being adjacent to each other, and cover the complete area
+  int num_chunk = 0;
+
+  if (_first_chunk != NULL) {
+    assrt_(_first_chunk->prev_in_vs() == NULL, "Sanity");
+
+    const Metachunk* c = _first_chunk;
+    const MetaWord* expected_next_base = _base;
+    const MetaWord* const area_end = _base + word_size();
+
+    while (c != NULL) {
+      assrt_(c->is_free() || c->is_in_use(),
+          "Chunk No. %d " METACHUNK_FORMAT " - invalid state.",
+          num_chunk, METACHUNK_FORMAT_ARGS(c));
+      assrt_(c->base() == expected_next_base,
+             "Chunk No. %d " METACHUNK_FORMAT " - unexpected base.",
+             num_chunk, METACHUNK_FORMAT_ARGS(c));
+      assrt_(c->base() >= base() && c->end() <= end(),
+             "chunk %d " METACHUNK_FORMAT " oob for this root area [" PTR_FORMAT ".." PTR_FORMAT ").",
+             num_chunk, METACHUNK_FORMAT_ARGS(c), p2i(base()), p2i(end()));
+      assrt_(is_aligned(c->base(), c->word_size()),
+             "misaligned chunk %d " METACHUNK_FORMAT ".", num_chunk, METACHUNK_FORMAT_ARGS(c));
+
+      c->verify_neighborhood();
+      c->verify();
+      expected_next_base = c->end();
+      num_chunk++;
+      c = c->next_in_vs();
+    }
+    assrt_(expected_next_base == _base + word_size(), "Sanity");
+  }
+}
+
+void RootChunkArea::verify_area_is_ideally_merged() const {
+  SOMETIMES(assert_lock_strong(MetaspaceExpand_lock);)
+  int num_chunk = 0;
+  for (const Metachunk* c = _first_chunk; c != NULL; c = c->next_in_vs()) {
+    if (!c->is_root_chunk() && c->is_free()) {
+      // If a chunk is free, it must not have a buddy which is also free, because
+      // those chunks should have been merged.
+      // In other words, a buddy shall be either in-use or splintered
+      // (which in turn would mean part of it are in use).
+      Metachunk* const buddy = c->is_leader() ? c->next_in_vs() : c->prev_in_vs();
+      assrt_(buddy->is_in_use() || buddy->level() > c->level(),
+             "Chunk No. %d " METACHUNK_FORMAT " : missed merge opportunity with neighbor " METACHUNK_FORMAT ".",
+             num_chunk, METACHUNK_FORMAT_ARGS(c), METACHUNK_FORMAT_ARGS(buddy));
+    }
+    num_chunk++;
+  }
+}
+
+#endif
+
+void RootChunkArea::print_on(outputStream* st) const {
+  st->print(PTR_FORMAT ": ", p2i(base()));
+  if (_first_chunk != NULL) {
+    const Metachunk* c = _first_chunk;
+    //                                    01234567890123
+    const char* letters_for_levels_cap = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+    const char* letters_for_levels =     "abcdefghijklmnopqrstuvwxyz";
+    while (c != NULL) {
+      const chunklevel_t l = c->level();
+      if (l >= 0 && (size_t)l < strlen(letters_for_levels)) {
+        st->print("%c", c->is_free() ? letters_for_levels[c->level()] : letters_for_levels_cap[c->level()]);
+      } else {
+        // Obviously garbage, but lets not crash.
+        st->print("?");
+      }
+      c = c->next_in_vs();
+    }
+  } else {
+    st->print(" (no chunks)");
+  }
+  st->cr();
+}
+
+// Create an array of ChunkTree objects, all initialized to NULL, covering
+// a given memory range. Memory range must be a multiple of root chunk size.
+RootChunkAreaLUT::RootChunkAreaLUT(const MetaWord* base, size_t word_size) :
+  _base(base),
+  _num((int)(word_size / chunklevel::MAX_CHUNK_WORD_SIZE)),
+  _arr(NULL)
+{
+  assert_is_aligned(word_size, chunklevel::MAX_CHUNK_WORD_SIZE);
+  _arr = NEW_C_HEAP_ARRAY(RootChunkArea, _num, mtClass);
+  const MetaWord* this_base = _base;
+  for (int i = 0; i < _num; i++) {
+    RootChunkArea* rca = new(_arr + i) RootChunkArea(this_base);
+    assert(rca == _arr + i, "Sanity");
+    this_base += chunklevel::MAX_CHUNK_WORD_SIZE;
+  }
+}
+
+RootChunkAreaLUT::~RootChunkAreaLUT() {
+  for (int i = 0; i < _num; i++) {
+    _arr[i].~RootChunkArea();
+  }
+  FREE_C_HEAP_ARRAY(RootChunkArea, _arr);
+}
+
+// Returns true if all areas in this area table are free (only contain free chunks).
+bool RootChunkAreaLUT::is_free() const {
+  for (int i = 0; i < _num; i++) {
+    if (!_arr[i].is_free()) {
+      return false;
+    }
+  }
+  return true;
+}
+
+#ifdef ASSERT
+
+void RootChunkAreaLUT::verify() const {
+  for (int i = 0; i < _num; i++) {
+    check_pointer(_arr[i].base());
+    _arr[i].verify();
+  }
+}
+
+#endif
+
+void RootChunkAreaLUT::print_on(outputStream* st) const {
+  for (int i = 0; i < _num; i++) {
+    st->print("%2d:", i);
+    _arr[i].print_on(st);
+  }
+}
+
+} // end: namespace metaspace

src/hotspot/share/memory/metaspace/rootChunkArea.hpp

@@ -0,0 +1,207 @@
+/*
+ * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2020 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
+ * 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.
+ *
+ */
+
+#ifndef SHARE_MEMORY_METASPACE_ROOTCHUNKAREA_HPP
+#define SHARE_MEMORY_METASPACE_ROOTCHUNKAREA_HPP
+
+#include "memory/allocation.hpp"
+#include "memory/metaspace/chunklevel.hpp"
+#include "utilities/debug.hpp"
+#include "utilities/globalDefinitions.hpp"
+
+class outputStream;
+
+namespace metaspace {
+
+class Metachunk;
+class MetachunkClosure;
+class FreeChunkListVector;
+class VirtualSpaceNode;
+
+// RootChunkArea manages a memory area covering a single root chunk.
+//
+// Such an area may contain a single root chunk, or a number of chunks the
+//  root chunk was split into.
+//
+// RootChunkArea contains the functionality to merge and split chunks in
+//  buddy allocator fashion.
+//
+
+class RootChunkArea {
+
+  // The base address of this area.
+  // Todo: this may be somewhat superfluous since RootChunkArea only exist in the
+  //  context of a series of chunks, so the address is somewhat implicit. Remove?
+  const MetaWord* const _base;
+
+  // The first chunk in this area; if this area is maximally
+  // folded, this is the root chunk covering the whole area size.
+  Metachunk* _first_chunk;
+
+public:
+
+  RootChunkArea(const MetaWord* base);
+  ~RootChunkArea();
+
+  // Initialize: allocate a root node and a root chunk header; return the
+  // root chunk header. It will be partly initialized.
+  // Note: this just allocates a memory-less header; memory itself is allocated inside VirtualSpaceNode.
+  Metachunk* alloc_root_chunk_header(VirtualSpaceNode* node);
+
+  // Given a chunk c, split it recursively until you get a chunk of the given target_level.
+  //
+  // The resulting target chunk resides at the same address as the original chunk.
+  // The resulting splinters are added to freelists.
+  //
+  // Returns pointer to the result chunk; the splitted-off chunks are added as
+  //  free chunks to the freelists.
+  void split(chunklevel_t target_level, Metachunk* c, FreeChunkListVector* freelists);
+
+  // Given a chunk, attempt to merge it recursively with its neighboring chunks.
+  //
+  // If successful (merged at least once), returns address of
+  // the merged chunk; NULL otherwise.
+  //
+  // The merged chunks are removed from the freelists.
+  //
+  // !!! Please note that if this method returns a non-NULL value, the
+  // original chunk will be invalid and should not be accessed anymore! !!!
+  Metachunk* merge(Metachunk* c, FreeChunkListVector* freelists);
+
+  // Given a chunk c, which must be "in use" and must not be a root chunk, attempt to
+  // enlarge it in place by claiming its trailing buddy.
+  //
+  // This will only work if c is the leader of the buddy pair and the trailing buddy is free.
+  //
+  // If successful, the follower chunk will be removed from the freelists, the leader chunk c will
+  // double in size (level decreased by one).
+  //
+  // On success, true is returned, false otherwise.
+  bool attempt_enlarge_chunk(Metachunk* c, FreeChunkListVector* freelists);
+
+  /// range ///
+
+  const MetaWord* base() const  { return _base; }
+  size_t word_size() const      { return chunklevel::MAX_CHUNK_WORD_SIZE; }
+  const MetaWord* end() const   { return _base + word_size(); }
+
+  // Direct access to the first chunk (use with care)
+  Metachunk* first_chunk()              { return _first_chunk; }
+  const Metachunk* first_chunk() const  { return _first_chunk; }
+
+  // Returns true if this root chunk area is completely free:
+  //  In that case, it should only contain one chunk (maximally merged, so a root chunk)
+  //  and it should be free.
+  bool is_free() const;
+
+  //// Debug stuff ////
+
+#ifdef ASSERT
+  void check_pointer(const MetaWord* p) const {
+    assert(p >= _base && p < _base + word_size(),
+           "pointer " PTR_FORMAT " oob for this root area [" PTR_FORMAT ".." PTR_FORMAT ")",
+           p2i(p), p2i(_base), p2i(_base + word_size()));
+  }
+  void verify() const;
+
+  // This is a separate operation from verify(). We should be able to call verify()
+  // from almost anywhere, regardless of state, but verify_area_is_ideally_merged()
+  // can only be called outside split and merge ops.
+  void verify_area_is_ideally_merged() const;
+#endif // ASSERT
+
+  void print_on(outputStream* st) const;
+
+};
+
+// RootChunkAreaLUT (lookup table) manages a series of contiguous root chunk areas
+//  in memory (in the context of a VirtualSpaceNode). It allows finding the containing
+//  root chunk for any given memory address. It allows for easy iteration over all
+//  root chunks.
+// Beyond that it is unexciting.
+class RootChunkAreaLUT {
+
+  // Base address of the whole area.
+  const MetaWord* const _base;
+
+  // Number of root chunk areas.
+  const int _num;
+
+  // Array of RootChunkArea objects.
+  RootChunkArea* _arr;
+
+#ifdef ASSERT
+  void check_pointer(const MetaWord* p) const {
+    assert(p >= base() && p < base() + word_size(), "Invalid pointer");
+  }
+#endif
+
+  // Given an address into this range, return the index into the area array for the
+  // area this address falls into.
+  int index_by_address(const MetaWord* p) const {
+    DEBUG_ONLY(check_pointer(p);)
+    int idx = (int)((p - base()) / chunklevel::MAX_CHUNK_WORD_SIZE);
+    assert(idx >= 0 && idx < _num, "Sanity");
+    return idx;
+  }
+
+public:
+
+  RootChunkAreaLUT(const MetaWord* base, size_t word_size);
+  ~RootChunkAreaLUT();
+
+  // Given a memory address into the range this array covers, return the
+  // corresponding area object. If none existed at this position, create it
+  // on demand.
+  RootChunkArea* get_area_by_address(const MetaWord* p) const {
+    const int idx = index_by_address(p);
+    RootChunkArea* ra = _arr + idx;
+    DEBUG_ONLY(ra->check_pointer(p);)
+    return _arr + idx;
+  }
+
+  // Access area by its index
+  int number_of_areas() const                               { return _num; }
+  RootChunkArea* get_area_by_index(int index)               { assert(index >= 0 && index < _num, "oob"); return _arr + index; }
+  const RootChunkArea* get_area_by_index(int index) const   { assert(index >= 0 && index < _num, "oob"); return _arr + index; }
+
+  /// range ///
+
+  const MetaWord* base() const  { return _base; }
+  size_t word_size() const      { return _num * chunklevel::MAX_CHUNK_WORD_SIZE; }
+  const MetaWord* end() const   { return _base + word_size(); }
+
+  // Returns true if all areas in this area table are free (only contain free chunks).
+  bool is_free() const;
+
+  DEBUG_ONLY(void verify() const;)
+
+  void print_on(outputStream* st) const;
+
+};
+
+} // namespace metaspace
+
+#endif // SHARE_MEMORY_METASPACE_ROOTCHUNKAREA_HPP

src/hotspot/share/memory/metaspace/runningCounters.cpp

@@ -0,0 +1,97 @@
+/*
+ * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2020 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
+ * 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 "precompiled.hpp"
+#include "memory/metaspace/chunkManager.hpp"
+#include "memory/metaspace/counters.hpp"
+#include "memory/metaspace/runningCounters.hpp"
+#include "memory/metaspace/virtualSpaceList.hpp"
+
+namespace metaspace {
+
+SizeAtomicCounter RunningCounters::_used_class_counter;
+SizeAtomicCounter RunningCounters::_used_nonclass_counter;
+
+// Return reserved size, in words, for Metaspace
+size_t RunningCounters::reserved_words() {
+  return reserved_words_class() + reserved_words_nonclass();
+}
+
+size_t RunningCounters::reserved_words_class() {
+  VirtualSpaceList* vs = VirtualSpaceList::vslist_class();
+  return vs != NULL ? vs->reserved_words() : 0;
+}
+
+size_t RunningCounters::reserved_words_nonclass() {
+  return VirtualSpaceList::vslist_nonclass()->reserved_words();
+}
+
+// Return total committed size, in words, for Metaspace
+size_t RunningCounters::committed_words() {
+  return committed_words_class() + committed_words_nonclass();
+}
+
+size_t RunningCounters::committed_words_class() {
+  VirtualSpaceList* vs = VirtualSpaceList::vslist_class();
+  return vs != NULL ? vs->committed_words() : 0;
+}
+
+size_t RunningCounters::committed_words_nonclass() {
+  return VirtualSpaceList::vslist_nonclass()->committed_words();
+}
+
+// ---- used chunks -----
+
+// Returns size, in words, used for metadata.
+size_t RunningCounters::used_words() {
+  return used_words_class() + used_words_nonclass();
+}
+
+size_t RunningCounters::used_words_class() {
+  return _used_class_counter.get();
+}
+
+size_t RunningCounters::used_words_nonclass() {
+  return _used_nonclass_counter.get();
+}
+
+// ---- free chunks -----
+
+// Returns size, in words, of all chunks in all freelists.
+size_t RunningCounters::free_chunks_words() {
+  return free_chunks_words_class() + free_chunks_words_nonclass();
+}
+
+size_t RunningCounters::free_chunks_words_class() {
+  ChunkManager* cm = ChunkManager::chunkmanager_class();
+  return cm != NULL ? cm->total_word_size() : 0;
+}
+
+size_t RunningCounters::free_chunks_words_nonclass() {
+  return ChunkManager::chunkmanager_nonclass()->total_word_size();
+}
+
+} // namespace metaspace
+

src/hotspot/share/memory/metaspace/runningCounters.hpp

@@ -0,0 +1,76 @@
+/*
+ * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2020 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
+ * 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.
+ *
+ */
+
+#ifndef SHARE_MEMORY_METASPACE_RUNNINGCOUNTERS_HPP
+#define SHARE_MEMORY_METASPACE_RUNNINGCOUNTERS_HPP
+
+#include "memory/allocation.hpp"
+#include "memory/metaspace/counters.hpp"
+
+namespace metaspace {
+
+// This class is a convenience interface for accessing global metaspace counters.
+class RunningCounters : public AllStatic {
+
+  static SizeAtomicCounter _used_class_counter;
+  static SizeAtomicCounter _used_nonclass_counter;
+
+public:
+
+  // ---- virtual memory -----
+
+  // Return reserved size, in words, for Metaspace
+  static size_t reserved_words();
+  static size_t reserved_words_class();
+  static size_t reserved_words_nonclass();
+
+  // Return total committed size, in words, for Metaspace
+  static size_t committed_words();
+  static size_t committed_words_class();
+  static size_t committed_words_nonclass();
+
+  // ---- used chunks -----
+
+  // Returns size, in words, used for metadata.
+  static size_t used_words();
+  static size_t used_words_class();
+  static size_t used_words_nonclass();
+
+  // ---- free chunks -----
+
+  // Returns size, in words, of all chunks in all freelists.
+  static size_t free_chunks_words();
+  static size_t free_chunks_words_class();
+  static size_t free_chunks_words_nonclass();
+
+  // Direct access to the counters.
+  static SizeAtomicCounter* used_nonclass_counter()     { return &_used_nonclass_counter; }
+  static SizeAtomicCounter* used_class_counter()        { return &_used_class_counter; }
+
+};
+
+} // namespace metaspace
+
+#endif // SHARE_MEMORY_METASPACE_RUNNINGCOUNTERS_HPP

src/hotspot/share/memory/metaspace/smallBlocks.hpp

@@ -1,88 +0,0 @@
-/*
- * Copyright (c) 2018, 2019, 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.
- *
- */
-
-#ifndef SHARE_MEMORY_METASPACE_SMALLBLOCKS_HPP
-#define SHARE_MEMORY_METASPACE_SMALLBLOCKS_HPP
-
-#include "memory/allocation.hpp"
-#include "memory/binaryTreeDictionary.hpp"
-#include "memory/metaspace/metablock.hpp"
-#include "utilities/globalDefinitions.hpp"
-
-class outputStream;
-
-namespace metaspace {
-
-class SmallBlocks : public CHeapObj<mtClass> {
-
-  const static uint _small_block_max_size = sizeof(TreeChunk<Metablock,  FreeList<Metablock> >)/HeapWordSize;
-  // Note: this corresponds to the imposed miminum allocation size, see SpaceManager::get_allocation_word_size()
-  const static uint _small_block_min_size = sizeof(Metablock)/HeapWordSize;
-
-private:
-  FreeList<Metablock> _small_lists[_small_block_max_size - _small_block_min_size];
-
-  FreeList<Metablock>& list_at(size_t word_size) {
-    assert(word_size >= _small_block_min_size, "There are no metaspace objects less than %u words", _small_block_min_size);
-    return _small_lists[word_size - _small_block_min_size];
-  }
-
-public:
-  SmallBlocks() {
-    for (uint i = _small_block_min_size; i < _small_block_max_size; i++) {
-      uint k = i - _small_block_min_size;
-      _small_lists[k].set_size(i);
-    }
-  }
-
-  // Returns the total size, in words, of all blocks, across all block sizes.
-  size_t total_size() const;
-
-  // Returns the total number of all blocks across all block sizes.
-  uintx total_num_blocks() const;
-
-  static uint small_block_max_size() { return _small_block_max_size; }
-  static uint small_block_min_size() { return _small_block_min_size; }
-
-  MetaWord* get_block(size_t word_size) {
-    if (list_at(word_size).count() > 0) {
-      MetaWord* new_block = (MetaWord*) list_at(word_size).get_chunk_at_head();
-      return new_block;
-    } else {
-      return NULL;
-    }
-  }
-  void return_block(Metablock* free_chunk, size_t word_size) {
-    list_at(word_size).return_chunk_at_head(free_chunk, false);
-    assert(list_at(word_size).count() > 0, "Should have a chunk");
-  }
-
-  void print_on(outputStream* st) const;
-
-};
-
-} // namespace metaspace
-
-
-#endif // SHARE_MEMORY_METASPACE_SMALLBLOCKS_HPP

src/hotspot/share/memory/metaspace/spaceManager.cpp

@@ -1,529 +0,0 @@
-/*
- * Copyright (c) 2018, 2020, 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 "precompiled.hpp"
-
-#include "logging/log.hpp"
-#include "logging/logStream.hpp"
-#include "memory/metaspace/chunkManager.hpp"
-#include "memory/metaspace/metachunk.hpp"
-#include "memory/metaspace/metaDebug.hpp"
-#include "memory/metaspace/metaspaceCommon.hpp"
-#include "memory/metaspace/spaceManager.hpp"
-#include "memory/metaspace/virtualSpaceList.hpp"
-#include "memory/resourceArea.hpp"
-#include "runtime/atomic.hpp"
-#include "runtime/init.hpp"
-#include "services/memoryService.hpp"
-#include "utilities/debug.hpp"
-#include "utilities/globalDefinitions.hpp"
-
-namespace metaspace {
-
-#define assert_counter(expected_value, real_value, msg) \
-  assert( (expected_value) == (real_value),             \
-         "Counter mismatch (%s): expected " SIZE_FORMAT \
-         ", but got: " SIZE_FORMAT ".", msg, expected_value, \
-         real_value);
-
-// SpaceManager methods
-
-size_t SpaceManager::adjust_initial_chunk_size(size_t requested, bool is_class_space) {
-  size_t chunk_sizes[] = {
-      specialized_chunk_size(is_class_space),
-      small_chunk_size(is_class_space),
-      medium_chunk_size(is_class_space)
-  };
-
-  // Adjust up to one of the fixed chunk sizes ...
-  for (size_t i = 0; i < ARRAY_SIZE(chunk_sizes); i++) {
-    if (requested <= chunk_sizes[i]) {
-      return chunk_sizes[i];
-    }
-  }
-
-  // ... or return the size as a humongous chunk.
-  return requested;
-}
-
-size_t SpaceManager::adjust_initial_chunk_size(size_t requested) const {
-  return adjust_initial_chunk_size(requested, is_class());
-}
-
-size_t SpaceManager::get_initial_chunk_size(Metaspace::MetaspaceType type) const {
-  size_t requested;
-
-  if (is_class()) {
-    switch (type) {
-    case Metaspace::BootMetaspaceType:              requested = Metaspace::first_class_chunk_word_size(); break;
-    case Metaspace::ClassMirrorHolderMetaspaceType: requested = ClassSpecializedChunk; break;
-    case Metaspace::ReflectionMetaspaceType:        requested = ClassSpecializedChunk; break;
-    default:                                        requested = ClassSmallChunk; break;
-    }
-  } else {
-    switch (type) {
-    case Metaspace::BootMetaspaceType:              requested = Metaspace::first_chunk_word_size(); break;
-    case Metaspace::ClassMirrorHolderMetaspaceType: requested = SpecializedChunk; break;
-    case Metaspace::ReflectionMetaspaceType:        requested = SpecializedChunk; break;
-    default:                                        requested = SmallChunk; break;
-    }
-  }
-
-  // Adjust to one of the fixed chunk sizes (unless humongous)
-  const size_t adjusted = adjust_initial_chunk_size(requested);
-
-  assert(adjusted != 0, "Incorrect initial chunk size. Requested: "
-         SIZE_FORMAT " adjusted: " SIZE_FORMAT, requested, adjusted);
-
-  return adjusted;
-}
-
-void SpaceManager::locked_print_chunks_in_use_on(outputStream* st) const {
-
-  for (ChunkIndex i = ZeroIndex; i < NumberOfInUseLists; i = next_chunk_index(i)) {
-    st->print("SpaceManager: " UINTX_FORMAT " %s chunks.",
-        num_chunks_by_type(i), chunk_size_name(i));
-  }
-
-  chunk_manager()->locked_print_free_chunks(st);
-}
-
-size_t SpaceManager::calc_chunk_size(size_t word_size) {
-
-  // Decide between a small chunk and a medium chunk.  Up to
-  // _small_chunk_limit small chunks can be allocated.
-  // After that a medium chunk is preferred.
-  size_t chunk_word_size;
-
-  // Special case for hidden metadata space.
-  // ClassMirrorHolder metadata space is usually small since it is used for
-  // class loader data's whose life cycle is governed by one class such as a
-  // non-strong hidden class or unsafe anonymous class.  The majority within 1K - 2K range and
-  // rarely about 4K (64-bits JVM).
-  // Instead of jumping to SmallChunk after initial chunk exhausted, keeping allocation
-  // from SpecializeChunk up to _anon_or_delegating_metadata_specialize_chunk_limit (4)
-  // reduces space waste from 60+% to around 30%.
-  if ((_space_type == Metaspace::ClassMirrorHolderMetaspaceType || _space_type == Metaspace::ReflectionMetaspaceType) &&
-      _mdtype == Metaspace::NonClassType &&
-      num_chunks_by_type(SpecializedIndex) < anon_and_delegating_metadata_specialize_chunk_limit &&
-      word_size + Metachunk::overhead() <= SpecializedChunk) {
-    return SpecializedChunk;
-  }
-
-  if (num_chunks_by_type(MediumIndex) == 0 &&
-      num_chunks_by_type(SmallIndex) < small_chunk_limit) {
-    chunk_word_size = (size_t) small_chunk_size();
-    if (word_size + Metachunk::overhead() > small_chunk_size()) {
-      chunk_word_size = medium_chunk_size();
-    }
-  } else {
-    chunk_word_size = medium_chunk_size();
-  }
-
-  // Might still need a humongous chunk.  Enforce
-  // humongous allocations sizes to be aligned up to
-  // the smallest chunk size.
-  size_t if_humongous_sized_chunk =
-    align_up(word_size + Metachunk::overhead(),
-                  smallest_chunk_size());
-  chunk_word_size =
-    MAX2((size_t) chunk_word_size, if_humongous_sized_chunk);
-
-  assert(!SpaceManager::is_humongous(word_size) ||
-         chunk_word_size == if_humongous_sized_chunk,
-         "Size calculation is wrong, word_size " SIZE_FORMAT
-         " chunk_word_size " SIZE_FORMAT,
-         word_size, chunk_word_size);
-  Log(gc, metaspace, alloc) log;
-  if (log.is_trace() && SpaceManager::is_humongous(word_size)) {
-    log.trace("Metadata humongous allocation:");
-    log.trace("  word_size " PTR_FORMAT, word_size);
-    log.trace("  chunk_word_size " PTR_FORMAT, chunk_word_size);
-    log.trace("    chunk overhead " PTR_FORMAT, Metachunk::overhead());
-  }
-  return chunk_word_size;
-}
-
-void SpaceManager::track_metaspace_memory_usage() {
-  if (is_init_completed()) {
-    if (is_class()) {
-      MemoryService::track_compressed_class_memory_usage();
-    }
-    MemoryService::track_metaspace_memory_usage();
-  }
-}
-
-MetaWord* SpaceManager::grow_and_allocate(size_t word_size) {
-  assert_lock_strong(_lock);
-  assert(vs_list()->current_virtual_space() != NULL,
-         "Should have been set");
-  assert(current_chunk() == NULL ||
-         current_chunk()->allocate(word_size) == NULL,
-         "Don't need to expand");
-  MutexLocker cl(MetaspaceExpand_lock, Mutex::_no_safepoint_check_flag);
-
-  if (log_is_enabled(Trace, gc, metaspace, freelist)) {
-    size_t words_left = 0;
-    size_t words_used = 0;
-    if (current_chunk() != NULL) {
-      words_left = current_chunk()->free_word_size();
-      words_used = current_chunk()->used_word_size();
-    }
-    log_trace(gc, metaspace, freelist)("SpaceManager::grow_and_allocate for " SIZE_FORMAT " words " SIZE_FORMAT " words used " SIZE_FORMAT " words left",
-                                       word_size, words_used, words_left);
-  }
-
-  // Get another chunk
-  size_t chunk_word_size = calc_chunk_size(word_size);
-  Metachunk* next = get_new_chunk(chunk_word_size);
-
-  MetaWord* mem = NULL;
-
-  // If a chunk was available, add it to the in-use chunk list
-  // and do an allocation from it.
-  if (next != NULL) {
-    // Add to this manager's list of chunks in use.
-    // If the new chunk is humongous, it was created to serve a single large allocation. In that
-    // case it usually makes no sense to make it the current chunk, since the next allocation would
-    // need to allocate a new chunk anyway, while we would now prematurely retire a perfectly
-    // good chunk which could be used for more normal allocations.
-    bool make_current = true;
-    if (next->get_chunk_type() == HumongousIndex &&
-        current_chunk() != NULL) {
-      make_current = false;
-    }
-    add_chunk(next, make_current);
-    mem = next->allocate(word_size);
-  }
-
-  // Track metaspace memory usage statistic.
-  track_metaspace_memory_usage();
-
-  return mem;
-}
-
-void SpaceManager::print_on(outputStream* st) const {
-  SpaceManagerStatistics stat;
-  add_to_statistics(&stat); // will lock _lock.
-  stat.print_on(st, 1*K, false);
-}
-
-SpaceManager::SpaceManager(Metaspace::MetadataType mdtype,
-                           Metaspace::MetaspaceType space_type,//
-                           Mutex* lock) :
-  _lock(lock),
-  _mdtype(mdtype),
-  _space_type(space_type),
-  _chunk_list(NULL),
-  _current_chunk(NULL),
-  _overhead_words(0),
-  _capacity_words(0),
-  _used_words(0),
-  _block_freelists(NULL) {
-  Metadebug::init_allocation_fail_alot_count();
-  memset(_num_chunks_by_type, 0, sizeof(_num_chunks_by_type));
-  log_trace(gc, metaspace, freelist)("SpaceManager(): " PTR_FORMAT, p2i(this));
-}
-
-void SpaceManager::account_for_new_chunk(const Metachunk* new_chunk) {
-
-  assert_lock_strong(MetaspaceExpand_lock);
-
-  _capacity_words += new_chunk->word_size();
-  _overhead_words += Metachunk::overhead();
-  DEBUG_ONLY(new_chunk->verify());
-  _num_chunks_by_type[new_chunk->get_chunk_type()] ++;
-
-  // Adjust global counters:
-  MetaspaceUtils::inc_capacity(mdtype(), new_chunk->word_size());
-  MetaspaceUtils::inc_overhead(mdtype(), Metachunk::overhead());
-}
-
-void SpaceManager::account_for_allocation(size_t words) {
-  // Note: we should be locked with the ClassloaderData-specific metaspace lock.
-  // We may or may not be locked with the global metaspace expansion lock.
-  assert_lock_strong(lock());
-
-  // Add to the per SpaceManager totals. This can be done non-atomically.
-  _used_words += words;
-
-  // Adjust global counters. This will be done atomically.
-  MetaspaceUtils::inc_used(mdtype(), words);
-}
-
-void SpaceManager::account_for_spacemanager_death() {
-
-  assert_lock_strong(MetaspaceExpand_lock);
-
-  MetaspaceUtils::dec_capacity(mdtype(), _capacity_words);
-  MetaspaceUtils::dec_overhead(mdtype(), _overhead_words);
-  MetaspaceUtils::dec_used(mdtype(), _used_words);
-}
-
-SpaceManager::~SpaceManager() {
-
-  // This call this->_lock which can't be done while holding MetaspaceExpand_lock
-  DEBUG_ONLY(verify_metrics());
-
-  MutexLocker fcl(MetaspaceExpand_lock, Mutex::_no_safepoint_check_flag);
-
-  account_for_spacemanager_death();
-
-  Log(gc, metaspace, freelist) log;
-  if (log.is_trace()) {
-    log.trace("~SpaceManager(): " PTR_FORMAT, p2i(this));
-    ResourceMark rm;
-    LogStream ls(log.trace());
-    locked_print_chunks_in_use_on(&ls);
-    if (block_freelists() != NULL) {
-      block_freelists()->print_on(&ls);
-    }
-  }
-
-  // Add all the chunks in use by this space manager
-  // to the global list of free chunks.
-
-  // Follow each list of chunks-in-use and add them to the
-  // free lists.  Each list is NULL terminated.
-  chunk_manager()->return_chunk_list(chunk_list());
-#ifdef ASSERT
-  _chunk_list = NULL;
-  _current_chunk = NULL;
-#endif
-
-#ifdef ASSERT
-  EVERY_NTH(VerifyMetaspaceInterval)
-    chunk_manager()->locked_verify(true);
-  END_EVERY_NTH
-#endif
-
-  if (_block_freelists != NULL) {
-    delete _block_freelists;
-  }
-}
-
-void SpaceManager::deallocate(MetaWord* p, size_t word_size) {
-  assert_lock_strong(lock());
-  // Allocations and deallocations are in raw_word_size
-  size_t raw_word_size = get_allocation_word_size(word_size);
-  // Lazily create a block_freelist
-  if (block_freelists() == NULL) {
-    _block_freelists = new BlockFreelist();
-  }
-  block_freelists()->return_block(p, raw_word_size);
-  DEBUG_ONLY(Atomic::inc(&(g_internal_statistics.num_deallocs)));
-}
-
-// Adds a chunk to the list of chunks in use.
-void SpaceManager::add_chunk(Metachunk* new_chunk, bool make_current) {
-
-  assert_lock_strong(_lock);
-  assert(new_chunk != NULL, "Should not be NULL");
-  assert(new_chunk->next() == NULL, "Should not be on a list");
-
-  new_chunk->reset_empty();
-
-  // Find the correct list and and set the current
-  // chunk for that list.
-  ChunkIndex index = chunk_manager()->list_index(new_chunk->word_size());
-
-  if (make_current) {
-    // If we are to make the chunk current, retire the old current chunk and replace
-    // it with the new chunk.
-    retire_current_chunk();
-    set_current_chunk(new_chunk);
-  }
-
-  // Add the new chunk at the head of its respective chunk list.
-  new_chunk->set_next(_chunk_list);
-  _chunk_list = new_chunk;
-
-  // Adjust counters.
-  account_for_new_chunk(new_chunk);
-
-  assert(new_chunk->is_empty(), "Not ready for reuse");
-  Log(gc, metaspace, freelist) log;
-  if (log.is_trace()) {
-    log.trace("SpaceManager::added chunk: ");
-    ResourceMark rm;
-    LogStream ls(log.trace());
-    new_chunk->print_on(&ls);
-    chunk_manager()->locked_print_free_chunks(&ls);
-  }
-}
-
-void SpaceManager::retire_current_chunk() {
-  if (current_chunk() != NULL) {
-    size_t remaining_words = current_chunk()->free_word_size();
-    if (remaining_words >= SmallBlocks::small_block_min_size()) {
-      MetaWord* ptr = current_chunk()->allocate(remaining_words);
-      deallocate(ptr, remaining_words);
-      account_for_allocation(remaining_words);
-    }
-  }
-}
-
-Metachunk* SpaceManager::get_new_chunk(size_t chunk_word_size) {
-  // Get a chunk from the chunk freelist
-  Metachunk* next = chunk_manager()->chunk_freelist_allocate(chunk_word_size);
-
-  if (next == NULL) {
-    next = vs_list()->get_new_chunk(chunk_word_size,
-                                    medium_chunk_bunch());
-  }
-
-  Log(gc, metaspace, alloc) log;
-  if (log.is_trace() && next != NULL &&
-      SpaceManager::is_humongous(next->word_size())) {
-    log.trace("  new humongous chunk word size " PTR_FORMAT, next->word_size());
-  }
-
-  return next;
-}
-
-MetaWord* SpaceManager::allocate(size_t word_size) {
-  MutexLocker cl(lock(), Mutex::_no_safepoint_check_flag);
-  size_t raw_word_size = get_allocation_word_size(word_size);
-  BlockFreelist* fl =  block_freelists();
-  MetaWord* p = NULL;
-
-  // Allocation from the dictionary is expensive in the sense that
-  // the dictionary has to be searched for a size.  Don't allocate
-  // from the dictionary until it starts to get fat.  Is this
-  // a reasonable policy?  Maybe an skinny dictionary is fast enough
-  // for allocations.  Do some profiling.  JJJ
-  if (fl != NULL && fl->total_size() > allocation_from_dictionary_limit) {
-    p = fl->get_block(raw_word_size);
-    if (p != NULL) {
-      DEBUG_ONLY(Atomic::inc(&g_internal_statistics.num_allocs_from_deallocated_blocks));
-    }
-  }
-  if (p == NULL) {
-    p = allocate_work(raw_word_size);
-  }
-
-#ifdef ASSERT
-  EVERY_NTH(VerifyMetaspaceInterval)
-    verify_metrics_locked();
-  END_EVERY_NTH
-#endif
-
-  return p;
-}
-
-// Returns the address of spaced allocated for "word_size".
-// This methods does not know about blocks (Metablocks)
-MetaWord* SpaceManager::allocate_work(size_t word_size) {
-  assert_lock_strong(lock());
-#ifdef ASSERT
-  if (Metadebug::test_metadata_failure()) {
-    return NULL;
-  }
-#endif
-  // Is there space in the current chunk?
-  MetaWord* result = NULL;
-
-  if (current_chunk() != NULL) {
-    result = current_chunk()->allocate(word_size);
-  }
-
-  if (result == NULL) {
-    result = grow_and_allocate(word_size);
-  }
-
-  if (result != NULL) {
-    account_for_allocation(word_size);
-  }
-
-  return result;
-}
-
-void SpaceManager::verify() {
-  Metachunk* curr = chunk_list();
-  while (curr != NULL) {
-    DEBUG_ONLY(do_verify_chunk(curr);)
-    assert(curr->is_tagged_free() == false, "Chunk should be tagged as in use.");
-    curr = curr->next();
-  }
-}
-
-void SpaceManager::verify_chunk_size(Metachunk* chunk) {
-  assert(is_humongous(chunk->word_size()) ||
-         chunk->word_size() == medium_chunk_size() ||
-         chunk->word_size() == small_chunk_size() ||
-         chunk->word_size() == specialized_chunk_size(),
-         "Chunk size is wrong");
-  return;
-}
-
-void SpaceManager::add_to_statistics_locked(SpaceManagerStatistics* out) const {
-  assert_lock_strong(lock());
-  Metachunk* chunk = chunk_list();
-  while (chunk != NULL) {
-    UsedChunksStatistics& chunk_stat = out->chunk_stats(chunk->get_chunk_type());
-    chunk_stat.add_num(1);
-    chunk_stat.add_cap(chunk->word_size());
-    chunk_stat.add_overhead(Metachunk::overhead());
-    chunk_stat.add_used(chunk->used_word_size() - Metachunk::overhead());
-    if (chunk != current_chunk()) {
-      chunk_stat.add_waste(chunk->free_word_size());
-    } else {
-      chunk_stat.add_free(chunk->free_word_size());
-    }
-    chunk = chunk->next();
-  }
-  if (block_freelists() != NULL) {
-    out->add_free_blocks_info(block_freelists()->num_blocks(), block_freelists()->total_size());
-  }
-}
-
-void SpaceManager::add_to_statistics(SpaceManagerStatistics* out) const {
-  MutexLocker cl(lock(), Mutex::_no_safepoint_check_flag);
-  add_to_statistics_locked(out);
-}
-
-#ifdef ASSERT
-void SpaceManager::verify_metrics_locked() const {
-  assert_lock_strong(lock());
-
-  SpaceManagerStatistics stat;
-  add_to_statistics_locked(&stat);
-
-  UsedChunksStatistics chunk_stats = stat.totals();
-
-  DEBUG_ONLY(chunk_stats.check_sanity());
-
-  assert_counter(_capacity_words, chunk_stats.cap(), "SpaceManager::_capacity_words");
-  assert_counter(_used_words, chunk_stats.used(), "SpaceManager::_used_words");
-  assert_counter(_overhead_words, chunk_stats.overhead(), "SpaceManager::_overhead_words");
-}
-
-void SpaceManager::verify_metrics() const {
-  MutexLocker cl(lock(), Mutex::_no_safepoint_check_flag);
-  verify_metrics_locked();
-}
-#endif // ASSERT
-
-
-} // namespace metaspace
-

src/hotspot/share/memory/metaspace/spaceManager.hpp

@@ -1,233 +0,0 @@
-/*
- * Copyright (c) 2018, 2019, 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.
- *
- */
-
-#ifndef SHARE_MEMORY_METASPACE_SPACEMANAGER_HPP
-#define SHARE_MEMORY_METASPACE_SPACEMANAGER_HPP
-
-#include "memory/allocation.hpp"
-#include "memory/metaspace.hpp"
-#include "memory/metaspace/blockFreelist.hpp"
-#include "memory/metaspace/metaspaceCommon.hpp"
-#include "memory/metaspace/metachunk.hpp"
-#include "memory/metaspace/metaspaceStatistics.hpp"
-#include "utilities/debug.hpp"
-#include "utilities/globalDefinitions.hpp"
-
-class outputStream;
-class Mutex;
-
-namespace metaspace {
-
-//  SpaceManager - used by Metaspace to handle allocations
-class SpaceManager : public CHeapObj<mtClass> {
-  friend class ::ClassLoaderMetaspace;
-  friend class Metadebug;
-
- private:
-
-  // protects allocations
-  Mutex* const _lock;
-
-  // Type of metadata allocated.
-  const Metaspace::MetadataType   _mdtype;
-
-  // Type of metaspace
-  const Metaspace::MetaspaceType  _space_type;
-
-  // List of chunks in use by this SpaceManager.  Allocations
-  // are done from the current chunk.  The list is used for deallocating
-  // chunks when the SpaceManager is freed.
-  Metachunk* _chunk_list;
-  Metachunk* _current_chunk;
-
-  enum {
-
-    // Maximum number of small chunks to allocate to a SpaceManager
-    small_chunk_limit = 4,
-
-    // Maximum number of specialize chunks to allocate for anonymous and delegating
-    // metadata space to a SpaceManager
-    anon_and_delegating_metadata_specialize_chunk_limit = 4,
-
-    allocation_from_dictionary_limit = 4 * K
-
-  };
-
-  // Some running counters, but lets keep their number small to not add to much to
-  // the per-classloader footprint.
-  // Note: capacity = used + free + waste + overhead. We do not keep running counters for
-  // free and waste. Their sum can be deduced from the three other values.
-  size_t _overhead_words;
-  size_t _capacity_words;
-  size_t _used_words;
-  uintx _num_chunks_by_type[NumberOfInUseLists];
-
-  // Free lists of blocks are per SpaceManager since they
-  // are assumed to be in chunks in use by the SpaceManager
-  // and all chunks in use by a SpaceManager are freed when
-  // the class loader using the SpaceManager is collected.
-  BlockFreelist* _block_freelists;
-
- private:
-  // Accessors
-  Metachunk* chunk_list() const { return _chunk_list; }
-
-  BlockFreelist* block_freelists() const { return _block_freelists; }
-
-  Metaspace::MetadataType mdtype() { return _mdtype; }
-
-  VirtualSpaceList* vs_list()   const { return Metaspace::get_space_list(_mdtype); }
-  ChunkManager* chunk_manager() const { return Metaspace::get_chunk_manager(_mdtype); }
-
-  Metachunk* current_chunk() const { return _current_chunk; }
-  void set_current_chunk(Metachunk* v) {
-    _current_chunk = v;
-  }
-
-  Metachunk* find_current_chunk(size_t word_size);
-
-  // Add chunk to the list of chunks in use
-  void add_chunk(Metachunk* v, bool make_current);
-  void retire_current_chunk();
-
-  Mutex* lock() const { return _lock; }
-
-  // Adds to the given statistic object. Expects to be locked with lock().
-  void add_to_statistics_locked(SpaceManagerStatistics* out) const;
-
-  // Verify internal counters against the current state. Expects to be locked with lock().
-  DEBUG_ONLY(void verify_metrics_locked() const;)
-
- public:
-  SpaceManager(Metaspace::MetadataType mdtype,
-               Metaspace::MetaspaceType space_type,
-               Mutex* lock);
-  ~SpaceManager();
-
-  enum ChunkMultiples {
-    MediumChunkMultiple = 4
-  };
-
-  static size_t specialized_chunk_size(bool is_class) { return is_class ? ClassSpecializedChunk : SpecializedChunk; }
-  static size_t small_chunk_size(bool is_class)       { return is_class ? ClassSmallChunk : SmallChunk; }
-  static size_t medium_chunk_size(bool is_class)      { return is_class ? ClassMediumChunk : MediumChunk; }
-
-  static size_t smallest_chunk_size(bool is_class)    { return specialized_chunk_size(is_class); }
-
-  // Accessors
-  bool is_class() const { return _mdtype == Metaspace::ClassType; }
-
-  size_t specialized_chunk_size() const { return specialized_chunk_size(is_class()); }
-  size_t small_chunk_size()       const { return small_chunk_size(is_class()); }
-  size_t medium_chunk_size()      const { return medium_chunk_size(is_class()); }
-
-  size_t smallest_chunk_size()    const { return smallest_chunk_size(is_class()); }
-
-  size_t medium_chunk_bunch()     const { return medium_chunk_size() * MediumChunkMultiple; }
-
-  bool is_humongous(size_t word_size) { return word_size > medium_chunk_size(); }
-
-  size_t capacity_words() const     { return _capacity_words; }
-  size_t used_words() const         { return _used_words; }
-  size_t overhead_words() const     { return _overhead_words; }
-
-  // Adjust local, global counters after a new chunk has been added.
-  void account_for_new_chunk(const Metachunk* new_chunk);
-
-  // Adjust local, global counters after space has been allocated from the current chunk.
-  void account_for_allocation(size_t words);
-
-  // Adjust global counters just before the SpaceManager dies, after all its chunks
-  // have been returned to the freelist.
-  void account_for_spacemanager_death();
-
-  // Adjust the initial chunk size to match one of the fixed chunk list sizes,
-  // or return the unadjusted size if the requested size is humongous.
-  static size_t adjust_initial_chunk_size(size_t requested, bool is_class_space);
-  size_t adjust_initial_chunk_size(size_t requested) const;
-
-  // Get the initial chunks size for this metaspace type.
-  size_t get_initial_chunk_size(Metaspace::MetaspaceType type) const;
-
-  // Todo: remove this once we have counters by chunk type.
-  uintx num_chunks_by_type(ChunkIndex chunk_type) const       { return _num_chunks_by_type[chunk_type]; }
-
-  Metachunk* get_new_chunk(size_t chunk_word_size);
-
-  // Block allocation and deallocation.
-  // Allocates a block from the current chunk
-  MetaWord* allocate(size_t word_size);
-
-  // Helper for allocations
-  MetaWord* allocate_work(size_t word_size);
-
-  // Returns a block to the per manager freelist
-  void deallocate(MetaWord* p, size_t word_size);
-
-  // Based on the allocation size and a minimum chunk size,
-  // returned chunk size (for expanding space for chunk allocation).
-  size_t calc_chunk_size(size_t allocation_word_size);
-
-  // Called when an allocation from the current chunk fails.
-  // Gets a new chunk (may require getting a new virtual space),
-  // and allocates from that chunk.
-  MetaWord* grow_and_allocate(size_t word_size);
-
-  // Notify memory usage to MemoryService.
-  void track_metaspace_memory_usage();
-
-  // debugging support.
-
-  void print_on(outputStream* st) const;
-  void locked_print_chunks_in_use_on(outputStream* st) const;
-
-  void verify();
-  void verify_chunk_size(Metachunk* chunk);
-
-  // This adjusts the size given to be greater than the minimum allocation size in
-  // words for data in metaspace.  Esentially the minimum size is currently 3 words.
-  size_t get_allocation_word_size(size_t word_size) {
-    size_t byte_size = word_size * BytesPerWord;
-
-    size_t raw_bytes_size = MAX2(byte_size, sizeof(Metablock));
-    raw_bytes_size = align_up(raw_bytes_size, Metachunk::object_alignment());
-
-    size_t raw_word_size = raw_bytes_size / BytesPerWord;
-    assert(raw_word_size * BytesPerWord == raw_bytes_size, "Size problem");
-
-    return raw_word_size;
-  }
-
-  // Adds to the given statistic object.
-  void add_to_statistics(SpaceManagerStatistics* out) const;
-
-  // Verify internal counters against the current state.
-  DEBUG_ONLY(void verify_metrics() const;)
-
-};
-
-
-} // namespace metaspace
-
-#endif // SHARE_MEMORY_METASPACE_SPACEMANAGER_HPP

src/hotspot/share/memory/metaspace/testHelpers.cpp

@@ -0,0 +1,121 @@
+/*
+ * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2020 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
+ * 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 "precompiled.hpp"
+#include "memory/metaspace/metaspaceArena.hpp"
+#include "memory/metaspace/metaspaceArenaGrowthPolicy.hpp"
+#include "memory/metaspace/metaspaceContext.hpp"
+#include "memory/metaspace/testHelpers.hpp"
+#include "runtime/mutexLocker.hpp"
+#include "utilities/debug.hpp"
+#include "utilities/globalDefinitions.hpp"
+#include "utilities/ostream.hpp"
+
+namespace metaspace {
+
+///// MetaspaceTestArena //////
+
+MetaspaceTestArena::MetaspaceTestArena(Mutex* lock, MetaspaceArena* arena) :
+  _lock(lock),
+  _arena(arena)
+{}
+
+MetaspaceTestArena::~MetaspaceTestArena() {
+  delete _arena;
+  delete _lock;
+}
+
+MetaWord* MetaspaceTestArena::allocate(size_t word_size) {
+  return _arena->allocate(word_size);
+}
+
+void MetaspaceTestArena::deallocate(MetaWord* p, size_t word_size) {
+  return _arena->deallocate(p, word_size);
+}
+
+///// MetaspaceTestArea //////
+
+MetaspaceTestContext::MetaspaceTestContext(const char* name, size_t commit_limit, size_t reserve_limit) :
+  _name(name),
+  _reserve_limit(reserve_limit),
+  _commit_limit(commit_limit),
+  _context(NULL),
+  _commit_limiter(commit_limit == 0 ? max_uintx : commit_limit), // commit_limit == 0 -> no limit
+  _used_words_counter(),
+  _rs()
+{
+  assert(is_aligned(reserve_limit, Metaspace::reserve_alignment_words()), "reserve_limit (" SIZE_FORMAT ") "
+                    "not aligned to metaspace reserve alignment (" SIZE_FORMAT ")",
+                    reserve_limit, Metaspace::reserve_alignment_words());
+  if (reserve_limit > 0) {
+    // have reserve limit -> non-expandable context
+    _rs = ReservedSpace(reserve_limit * BytesPerWord, Metaspace::reserve_alignment(), false);
+    _context = MetaspaceContext::create_nonexpandable_context(name, _rs, &_commit_limiter);
+  } else {
+    // no reserve limit -> expandable vslist
+    _context = MetaspaceContext::create_expandable_context(name, &_commit_limiter);
+  }
+
+}
+
+MetaspaceTestContext::~MetaspaceTestContext() {
+  DEBUG_ONLY(verify();)
+  MutexLocker fcl(MetaspaceExpand_lock, Mutex::_no_safepoint_check_flag);
+  delete _context;
+  if (_rs.is_reserved()) {
+    _rs.release();
+  }
+}
+
+// Create an arena, feeding off this area.
+MetaspaceTestArena* MetaspaceTestContext::create_arena(Metaspace::MetaspaceType type) {
+  const ArenaGrowthPolicy* growth_policy = ArenaGrowthPolicy::policy_for_space_type(type, false);
+  Mutex* lock = new Mutex(Monitor::native, "MetaspaceTestArea-lock", false, Monitor::_safepoint_check_never);
+  MetaspaceArena* arena = NULL;
+  {
+    MutexLocker ml(lock,  Mutex::_no_safepoint_check_flag);
+    arena = new MetaspaceArena(_context->cm(), growth_policy, lock, &_used_words_counter, _name);
+  }
+  return new MetaspaceTestArena(lock, arena);
+}
+
+void MetaspaceTestContext::purge_area() {
+  _context->cm()->purge();
+}
+
+#ifdef ASSERT
+void MetaspaceTestContext::verify() const {
+  if (_context != NULL) {
+    _context->verify();
+  }
+}
+#endif
+
+void MetaspaceTestContext::print_on(outputStream* st) const {
+  _context->print_on(st);
+}
+
+} // namespace metaspace
+

src/hotspot/share/memory/metaspace/testHelpers.hpp

@@ -0,0 +1,119 @@
+/*
+ * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2020 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
+ * 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.
+ *
+ */
+
+#ifndef SHARE_MEMORY_METASPACE_TESTHELPERS_HPP
+#define SHARE_MEMORY_METASPACE_TESTHELPERS_HPP
+
+#include "memory/allocation.hpp"
+#include "memory/metaspace.hpp"
+#include "memory/metaspace/commitLimiter.hpp"
+#include "memory/metaspace/counters.hpp"
+#include "memory/metaspace/metaspaceContext.hpp"
+#include "memory/virtualspace.hpp"
+#include "utilities/globalDefinitions.hpp"
+
+// This is just convenience classes for metaspace-related tests
+//  (jtreg, via whitebox API, and gtests)
+
+class ReservedSpace;
+class Mutex;
+class outputStream;
+
+namespace metaspace {
+
+class MetaspaceContext;
+class MetaspaceArena;
+
+// Wraps a MetaspaceTestArena with its own lock for testing purposes.
+class MetaspaceTestArena : public CHeapObj<mtInternal> {
+
+  Mutex* const _lock;
+  MetaspaceArena* const _arena;
+
+public:
+
+  const MetaspaceArena* arena() const {
+    return _arena;
+  }
+
+  MetaspaceTestArena(Mutex* lock, MetaspaceArena* arena);
+  ~MetaspaceTestArena();
+
+  MetaWord* allocate(size_t word_size);
+  void deallocate(MetaWord* p, size_t word_size);
+
+};
+
+// Wraps an instance of a MetaspaceContext together with some side objects for easy use in test beds (whitebox, gtests)
+class MetaspaceTestContext : public CHeapObj<mtInternal> {
+
+  const char* const _name;
+  const size_t _reserve_limit;
+  const size_t _commit_limit;
+
+  MetaspaceContext* _context;
+  CommitLimiter _commit_limiter;
+  SizeAtomicCounter _used_words_counter;
+
+  // For non-expandable contexts we keep track of the space
+  // and delete it at destruction time.
+  ReservedSpace _rs;
+
+public:
+
+  // Note: limit == 0 means unlimited
+  // Reserve limit > 0 simulates a non-expandable VirtualSpaceList (like CompressedClassSpace)
+  // Commit limit > 0 simulates a limit to max commitable space (like MaxMetaspaceSize)
+  MetaspaceTestContext(const char* name, size_t commit_limit = 0, size_t reserve_limit = 0);
+  ~MetaspaceTestContext();
+
+  // Create an arena, feeding off this area.
+  MetaspaceTestArena* create_arena(Metaspace::MetaspaceType type);
+
+  void purge_area();
+
+  // Accessors
+  const CommitLimiter& commit_limiter() const { return _commit_limiter; }
+  const VirtualSpaceList& vslist() const      { return *(_context->vslist()); }
+  ChunkManager& cm()                          { return *(_context->cm()); }
+
+  // Returns reserve- and commit limit we run the test with (in the real world,
+  // these would be equivalent to CompressedClassSpaceSize resp MaxMetaspaceSize)
+  size_t reserve_limit() const    { return _reserve_limit == 0 ? max_uintx : 0; }
+  size_t commit_limit() const     { return _commit_limit == 0 ? max_uintx : 0; }
+
+  // Convenience function to retrieve total committed/used words
+  size_t used_words() const       { return _used_words_counter.get(); }
+  size_t committed_words() const  { return _commit_limiter.committed_words(); }
+
+  DEBUG_ONLY(void verify() const;)
+
+  void print_on(outputStream* st) const;
+
+};
+
+} // namespace metaspace
+
+#endif // SHARE_MEMORY_METASPACE_TESTHELPERS_HPP

src/hotspot/share/memory/metaspace/virtualSpaceList.cpp

@@ -1,5 +1,6 @@
 /*
  * Copyright (c) 2018, 2020, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2018, 2020 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
@@ -22,427 +23,233 @@
  *
  */
 
-
 #include "precompiled.hpp"
 #include "logging/log.hpp"
-#include "logging/logStream.hpp"
 #include "memory/metaspace.hpp"
 #include "memory/metaspace/chunkManager.hpp"
-#include "memory/metaspace/metachunk.hpp"
+#include "memory/metaspace/commitLimiter.hpp"
+#include "memory/metaspace/counters.hpp"
+#include "memory/metaspace/freeChunkList.hpp"
+#include "memory/metaspace/metaspaceContext.hpp"
 #include "memory/metaspace/metaspaceCommon.hpp"
 #include "memory/metaspace/virtualSpaceList.hpp"
 #include "memory/metaspace/virtualSpaceNode.hpp"
-#include "memory/resourceArea.hpp"
-#include "runtime/atomic.hpp"
-#include "runtime/orderAccess.hpp"
 #include "runtime/mutexLocker.hpp"
-#include "runtime/safepoint.hpp"
 
 namespace metaspace {
 
+#define LOGFMT         "VsList @" PTR_FORMAT " (%s)"
+#define LOGFMT_ARGS    p2i(this), this->_name
+
+// Create a new, empty, expandable list.
+VirtualSpaceList::VirtualSpaceList(const char* name, CommitLimiter* commit_limiter) :
+  _name(name),
+  _first_node(NULL),
+  _can_expand(true),
+  _commit_limiter(commit_limiter),
+  _reserved_words_counter(),
+  _committed_words_counter()
+{
+}
+
+// Create a new list. The list will contain one node only, which uses the given ReservedSpace.
+// It will be not expandable beyond that first node.
+VirtualSpaceList::VirtualSpaceList(const char* name, ReservedSpace rs, CommitLimiter* commit_limiter) :
+  _name(name),
+  _first_node(NULL),
+  _can_expand(false),
+  _commit_limiter(commit_limiter),
+  _reserved_words_counter(),
+  _committed_words_counter()
+{
+  // Create the first node spanning the existing ReservedSpace. This will be the only node created
+  // for this list since we cannot expand.
+  VirtualSpaceNode* vsn = VirtualSpaceNode::create_node(rs, _commit_limiter,
+                                                        &_reserved_words_counter, &_committed_words_counter);
+  assert(vsn != NULL, "node creation failed");
+  _first_node = vsn;
+  _first_node->set_next(NULL);
+  _nodes_counter.increment();
+}
 
 VirtualSpaceList::~VirtualSpaceList() {
-  VirtualSpaceListIterator iter(virtual_space_list());
+  assert_lock_strong(MetaspaceExpand_lock);
-  while (iter.repeat()) {
+  // Note: normally, there is no reason ever to delete a vslist since they are
-    VirtualSpaceNode* vsl = iter.get_next();
+  // global objects, but for gtests it makes sense to allow this.
-    delete vsl;
+  VirtualSpaceNode* vsn = _first_node;
+  VirtualSpaceNode* vsn2 = vsn;
+  while (vsn != NULL) {
+    vsn2 = vsn->next();
+    delete vsn;
+    vsn = vsn2;
   }
 }
 
-void VirtualSpaceList::inc_reserved_words(size_t v) {
+// Create a new node and append it to the list. After
+// this function, _current_node shall point to a new empty node.
+// List must be expandable for this to work.
+void VirtualSpaceList::create_new_node() {
+  assert(_can_expand, "List is not expandable");
   assert_lock_strong(MetaspaceExpand_lock);
-  _reserved_words = _reserved_words + v;
+
-}
+  VirtualSpaceNode* vsn = VirtualSpaceNode::create_node(Settings::virtual_space_node_default_word_size(),
-void VirtualSpaceList::dec_reserved_words(size_t v) {
+                                                        _commit_limiter,
-  assert_lock_strong(MetaspaceExpand_lock);
+                                                        &_reserved_words_counter, &_committed_words_counter);
-  _reserved_words = _reserved_words - v;
+  vsn->set_next(_first_node);
+  _first_node = vsn;
+  _nodes_counter.increment();
 }
 
-#define assert_committed_below_limit()                        \
+// Allocate a root chunk from this list.
-  assert(MetaspaceUtils::committed_bytes() <= MaxMetaspaceSize, \
+// Note: this just returns a chunk whose memory is reserved; no memory is committed yet.
-         "Too much committed memory. Committed: " SIZE_FORMAT \
+// Hence, before using this chunk, it must be committed.
-         " limit (MaxMetaspaceSize): " SIZE_FORMAT,           \
+// Also, no limits are checked, since no committing takes place.
-          MetaspaceUtils::committed_bytes(), MaxMetaspaceSize);
+Metachunk*  VirtualSpaceList::allocate_root_chunk() {
-
-void VirtualSpaceList::inc_committed_words(size_t v) {
   assert_lock_strong(MetaspaceExpand_lock);
-  _committed_words = _committed_words + v;
 
-  assert_committed_below_limit();
+  if (_first_node == NULL ||
-}
+      _first_node->free_words() < chunklevel::MAX_CHUNK_WORD_SIZE) {
-void VirtualSpaceList::dec_committed_words(size_t v) {
-  assert_lock_strong(MetaspaceExpand_lock);
-  _committed_words = _committed_words - v;
 
-  assert_committed_below_limit();
+#ifdef ASSERT
-}
+    // Since all allocations from a VirtualSpaceNode happen in
+    // root-chunk-size units, and the node size must be root-chunk-size aligned,
+    // we should never have left-over space.
+    if (_first_node != NULL) {
+      assert(_first_node->free_words() == 0, "Sanity");
+    }
+#endif
 
-void VirtualSpaceList::inc_virtual_space_count() {
+    if (_can_expand) {
-  assert_lock_strong(MetaspaceExpand_lock);
+      create_new_node();
-  _virtual_space_count++;
+      UL2(debug, "added new node (now: %d).", num_nodes());
-}
-
-void VirtualSpaceList::dec_virtual_space_count() {
-  assert_lock_strong(MetaspaceExpand_lock);
-  _virtual_space_count--;
-}
-
-// Walk the list of VirtualSpaceNodes and delete
-// nodes with a 0 container_count.  Remove Metachunks in
-// the node from their respective freelists.
-void VirtualSpaceList::purge(ChunkManager* chunk_manager) {
-  assert_lock_strong(MetaspaceExpand_lock);
-  // Don't use a VirtualSpaceListIterator because this
-  // list is being changed and a straightforward use of an iterator is not safe.
-  VirtualSpaceNode* prev_vsl = virtual_space_list();
-  VirtualSpaceNode* next_vsl = prev_vsl;
-  int num_purged_nodes = 0;
-  while (next_vsl != NULL) {
-    VirtualSpaceNode* vsl = next_vsl;
-    DEBUG_ONLY(vsl->verify(false);)
-    next_vsl = vsl->next();
-    // Don't free the current virtual space since it will likely
-    // be needed soon.
-    if (vsl->container_count() == 0 && vsl != current_virtual_space()) {
-      log_trace(gc, metaspace, freelist)("Purging VirtualSpaceNode " PTR_FORMAT " (capacity: " SIZE_FORMAT
-                                         ", used: " SIZE_FORMAT ").", p2i(vsl), vsl->capacity_words_in_vs(), vsl->used_words_in_vs());
-      DEBUG_ONLY(Atomic::inc(&g_internal_statistics.num_vsnodes_purged));
-      // Unlink it from the list
-      if (prev_vsl == vsl) {
-        // This is the case of the current node being the first node.
-        assert(vsl == virtual_space_list(), "Expected to be the first node");
-        set_virtual_space_list(vsl->next());
-      } else {
-        prev_vsl->set_next(vsl->next());
-      }
-
-      vsl->purge(chunk_manager);
-      dec_reserved_words(vsl->reserved_words());
-      dec_committed_words(vsl->committed_words());
-      dec_virtual_space_count();
-      delete vsl;
-      num_purged_nodes ++;
     } else {
-      prev_vsl = vsl;
+      UL(debug, "list cannot expand.");
+      return NULL; // We cannot expand this list.
     }
   }
 
-  // Verify list
+  Metachunk* c = _first_node->allocate_root_chunk();
-#ifdef ASSERT
+  assert(c != NULL, "This should have worked");
-  if (num_purged_nodes > 0) {
+
-    verify(false);
+  return c;
-  }
-#endif
 }
 
+// Attempts to purge nodes. This will remove and delete nodes which only contain free chunks.
+// The free chunks are removed from the freelists before the nodes are deleted.
+// Return number of purged nodes.
+int VirtualSpaceList::purge(FreeChunkListVector* freelists) {
+  assert_lock_strong(MetaspaceExpand_lock);
+  UL(debug, "purging.");
 
-// This function looks at the mmap regions in the metaspace without locking.
+  VirtualSpaceNode* vsn = _first_node;
-// The chunks are added with store ordering and not deleted except for at
+  VirtualSpaceNode* prev_vsn = NULL;
-// unloading time during a safepoint.
+  int num = 0, num_purged = 0;
-VirtualSpaceNode* VirtualSpaceList::find_enclosing_space(const void* ptr) {
+  while (vsn != NULL) {
-  // List should be stable enough to use an iterator here because removing virtual
+    VirtualSpaceNode* next_vsn = vsn->next();
-  // space nodes is only allowed at a safepoint.
+    bool purged = vsn->attempt_purge(freelists);
-  if (is_within_envelope((address)ptr)) {
+    if (purged) {
-    VirtualSpaceListIterator iter(virtual_space_list());
+      // Note: from now on do not dereference vsn!
-    while (iter.repeat()) {
+      UL2(debug, "purged node @" PTR_FORMAT ".", p2i(vsn));
-      VirtualSpaceNode* vsn = iter.get_next();
+      if (_first_node == vsn) {
-      if (vsn->contains(ptr)) {
+        _first_node = next_vsn;
-        return vsn;
       }
+      DEBUG_ONLY(vsn = (VirtualSpaceNode*)((uintptr_t)(0xdeadbeef));)
+      if (prev_vsn != NULL) {
+        prev_vsn->set_next(next_vsn);
+      }
+      num_purged++;
+      _nodes_counter.decrement();
+    } else {
+      prev_vsn = vsn;
     }
-  }
+    vsn = next_vsn;
-  return NULL;
+    num ++;
-}
-
-void VirtualSpaceList::retire_current_virtual_space() {
-  assert_lock_strong(MetaspaceExpand_lock);
-
-  VirtualSpaceNode* vsn = current_virtual_space();
-
-  ChunkManager* cm = is_class() ? Metaspace::chunk_manager_class() :
-                                  Metaspace::chunk_manager_metadata();
-
-  vsn->retire(cm);
-}
-
-VirtualSpaceList::VirtualSpaceList(size_t word_size) :
-                                   _virtual_space_list(NULL),
-                                   _current_virtual_space(NULL),
-                                   _is_class(false),
-                                   _reserved_words(0),
-                                   _committed_words(0),
-                                   _virtual_space_count(0),
-                                   _envelope_lo((address)max_uintx),
-                                   _envelope_hi(NULL) {
-  MutexLocker cl(MetaspaceExpand_lock, Mutex::_no_safepoint_check_flag);
-  create_new_virtual_space(word_size);
-}
-
-VirtualSpaceList::VirtualSpaceList(ReservedSpace rs) :
-                                   _virtual_space_list(NULL),
-                                   _current_virtual_space(NULL),
-                                   _is_class(true),
-                                   _reserved_words(0),
-                                   _committed_words(0),
-                                   _virtual_space_count(0),
-                                   _envelope_lo((address)max_uintx),
-                                   _envelope_hi(NULL) {
-  MutexLocker cl(MetaspaceExpand_lock, Mutex::_no_safepoint_check_flag);
-  VirtualSpaceNode* class_entry = new VirtualSpaceNode(is_class(), rs);
-  bool succeeded = class_entry->initialize();
-  if (succeeded) {
-    expand_envelope_to_include_node(class_entry);
-    // ensure lock-free iteration sees fully initialized node
-    OrderAccess::storestore();
-    link_vs(class_entry);
-  }
-}
-
-size_t VirtualSpaceList::free_bytes() {
-  return current_virtual_space()->free_words_in_vs() * BytesPerWord;
-}
-
-// Allocate another meta virtual space and add it to the list.
-bool VirtualSpaceList::create_new_virtual_space(size_t vs_word_size) {
-  assert_lock_strong(MetaspaceExpand_lock);
-
-  if (is_class()) {
-    assert(false, "We currently don't support more than one VirtualSpace for"
-                  " the compressed class space. The initialization of the"
-                  " CCS uses another code path and should not hit this path.");
-    return false;
   }
 
-  if (vs_word_size == 0) {
+  UL2(debug, "purged %d nodes (before: %d, now: %d)",
-    assert(false, "vs_word_size should always be at least _reserve_alignment large.");
+      num_purged, num, num_nodes());
-    return false;
+  return num_purged;
-  }
-
-  // Reserve the space
-  size_t vs_byte_size = vs_word_size * BytesPerWord;
-  assert_is_aligned(vs_byte_size, Metaspace::reserve_alignment());
-
-  // Allocate the meta virtual space and initialize it.
-  VirtualSpaceNode* new_entry = new VirtualSpaceNode(is_class(), vs_byte_size);
-  if (!new_entry->initialize()) {
-    delete new_entry;
-    return false;
-  } else {
-    assert(new_entry->reserved_words() == vs_word_size,
-        "Reserved memory size differs from requested memory size");
-    expand_envelope_to_include_node(new_entry);
-    // ensure lock-free iteration sees fully initialized node
-    OrderAccess::storestore();
-    link_vs(new_entry);
-    DEBUG_ONLY(Atomic::inc(&g_internal_statistics.num_vsnodes_created));
-    return true;
-  }
-
-  DEBUG_ONLY(verify(false);)
-
 }
 
-void VirtualSpaceList::link_vs(VirtualSpaceNode* new_entry) {
+// Print all nodes in this space list.
-  if (virtual_space_list() == NULL) {
+void VirtualSpaceList::print_on(outputStream* st) const {
-      set_virtual_space_list(new_entry);
+  MutexLocker fcl(MetaspaceExpand_lock, Mutex::_no_safepoint_check_flag);
-  } else {
+
-    current_virtual_space()->set_next(new_entry);
+  st->print_cr("vsl %s:", _name);
+  const VirtualSpaceNode* vsn = _first_node;
+  int n = 0;
+  while (vsn != NULL) {
+    st->print("- node #%d: ", n);
+    vsn->print_on(st);
+    vsn = vsn->next();
+    n++;
   }
-  set_current_virtual_space(new_entry);
+  st->print_cr("- total %d nodes, " SIZE_FORMAT " reserved words, " SIZE_FORMAT " committed words.",
-  inc_reserved_words(new_entry->reserved_words());
+               n, reserved_words(), committed_words());
-  inc_committed_words(new_entry->committed_words());
+}
-  inc_virtual_space_count();
+
 #ifdef ASSERT
-  new_entry->mangle();
+void VirtualSpaceList::verify_locked() const {
+  assert_lock_strong(MetaspaceExpand_lock);
+  assert(_name != NULL, "Sanity");
+
+  int n = 0;
+
+  if (_first_node != NULL) {
+    size_t total_reserved_words = 0;
+    size_t total_committed_words = 0;
+    const VirtualSpaceNode* vsn = _first_node;
+    while (vsn != NULL) {
+      n++;
+      vsn->verify_locked();
+      total_reserved_words += vsn->word_size();
+      total_committed_words += vsn->committed_words();
+      vsn = vsn->next();
+    }
+    _nodes_counter.check(n);
+    _reserved_words_counter.check(total_reserved_words);
+    _committed_words_counter.check(total_committed_words);
+  } else {
+    _reserved_words_counter.check(0);
+    _committed_words_counter.check(0);
+  }
+}
+
+void VirtualSpaceList::verify() const {
+  MutexLocker fcl(MetaspaceExpand_lock, Mutex::_no_safepoint_check_flag);
+  verify_locked();
+}
 #endif
-  LogTarget(Trace, gc, metaspace) lt;
-  if (lt.is_enabled()) {
-    LogStream ls(lt);
-    VirtualSpaceNode* vsl = current_virtual_space();
-    ResourceMark rm;
-    vsl->print_on(&ls);
-  }
-}
 
-bool VirtualSpaceList::expand_node_by(VirtualSpaceNode* node,
+// Returns true if this pointer is contained in one of our nodes.
-                                      size_t min_words,
+bool VirtualSpaceList::contains(const MetaWord* p) const {
-                                      size_t preferred_words) {
+  const VirtualSpaceNode* vsn = _first_node;
-  size_t before = node->committed_words();
+  while (vsn != NULL) {
-
+    if (vsn->contains(p)) {
-  bool result = node->expand_by(min_words, preferred_words);
-
-  size_t after = node->committed_words();
-
-  // after and before can be the same if the memory was pre-committed.
-  assert(after >= before, "Inconsistency");
-  inc_committed_words(after - before);
-
-  return result;
-}
-
-bool VirtualSpaceList::expand_by(size_t min_words, size_t preferred_words) {
-  assert_is_aligned(min_words,       Metaspace::commit_alignment_words());
-  assert_is_aligned(preferred_words, Metaspace::commit_alignment_words());
-  assert(min_words <= preferred_words, "Invalid arguments");
-
-  const char* const class_or_not = (is_class() ? "class" : "non-class");
-
-  if (!MetaspaceGC::can_expand(min_words, this->is_class())) {
-    log_trace(gc, metaspace, freelist)("Cannot expand %s virtual space list.",
-              class_or_not);
-    return  false;
-  }
-
-  size_t allowed_expansion_words = MetaspaceGC::allowed_expansion();
-  if (allowed_expansion_words < min_words) {
-    log_trace(gc, metaspace, freelist)("Cannot expand %s virtual space list (must try gc first).",
-              class_or_not);
-    return false;
-  }
-
-  size_t max_expansion_words = MIN2(preferred_words, allowed_expansion_words);
-
-  // Commit more memory from the the current virtual space.
-  bool vs_expanded = expand_node_by(current_virtual_space(),
-                                    min_words,
-                                    max_expansion_words);
-  if (vs_expanded) {
-     log_trace(gc, metaspace, freelist)("Expanded %s virtual space list.",
-               class_or_not);
-     return true;
-  }
-  log_trace(gc, metaspace, freelist)("%s virtual space list: retire current node.",
-            class_or_not);
-  retire_current_virtual_space();
-
-  // Get another virtual space.
-  size_t grow_vs_words = MAX2((size_t)VirtualSpaceSize, preferred_words);
-  grow_vs_words = align_up(grow_vs_words, Metaspace::reserve_alignment_words());
-
-  if (create_new_virtual_space(grow_vs_words)) {
-    if (current_virtual_space()->is_pre_committed()) {
-      // The memory was pre-committed, so we are done here.
-      assert(min_words <= current_virtual_space()->committed_words(),
-          "The new VirtualSpace was pre-committed, so it"
-          "should be large enough to fit the alloc request.");
       return true;
     }
-
+    vsn = vsn->next();
-    return expand_node_by(current_virtual_space(),
-                          min_words,
-                          max_expansion_words);
   }
-
   return false;
 }
 
-// Given a chunk, calculate the largest possible padding space which
+// Returns true if the vslist is not expandable and no more root chunks
-// could be required when allocating it.
+// can be allocated.
-static size_t largest_possible_padding_size_for_chunk(size_t chunk_word_size, bool is_class) {
+bool VirtualSpaceList::is_full() const {
-  const ChunkIndex chunk_type = get_chunk_type_by_size(chunk_word_size, is_class);
+  if (!_can_expand && _first_node != NULL && _first_node->free_words() == 0) {
-  if (chunk_type != HumongousIndex) {
+    return true;
-    // Normal, non-humongous chunks are allocated at chunk size
-    // boundaries, so the largest padding space required would be that
-    // minus the smallest chunk size.
-    const size_t smallest_chunk_size = is_class ? ClassSpecializedChunk : SpecializedChunk;
-    return chunk_word_size - smallest_chunk_size;
-  } else {
-    // Humongous chunks are allocated at smallest-chunksize
-    // boundaries, so there is no padding required.
-    return 0;
   }
+  return false;
 }
 
-
+// Convenience methods to return the global class-space chunkmanager
-Metachunk* VirtualSpaceList::get_new_chunk(size_t chunk_word_size, size_t suggested_commit_granularity) {
+//  and non-class chunkmanager, respectively.
-
+VirtualSpaceList* VirtualSpaceList::vslist_class() {
-  // Allocate a chunk out of the current virtual space.
+  return MetaspaceContext::context_class() == NULL ? NULL : MetaspaceContext::context_class()->vslist();
-  Metachunk* next = current_virtual_space()->get_chunk_vs(chunk_word_size);
-
-  if (next != NULL) {
-    return next;
-  }
-
-  // The expand amount is currently only determined by the requested sizes
-  // and not how much committed memory is left in the current virtual space.
-
-  // We must have enough space for the requested size and any
-  // additional reqired padding chunks.
-  const size_t size_for_padding = largest_possible_padding_size_for_chunk(chunk_word_size, this->is_class());
-
-  size_t min_word_size       = align_up(chunk_word_size + size_for_padding, Metaspace::commit_alignment_words());
-  size_t preferred_word_size = align_up(suggested_commit_granularity, Metaspace::commit_alignment_words());
-  if (min_word_size >= preferred_word_size) {
-    // Can happen when humongous chunks are allocated.
-    preferred_word_size = min_word_size;
-  }
-
-  bool expanded = expand_by(min_word_size, preferred_word_size);
-  if (expanded) {
-    next = current_virtual_space()->get_chunk_vs(chunk_word_size);
-    assert(next != NULL, "The allocation was expected to succeed after the expansion");
-  }
-
-   return next;
 }
 
-void VirtualSpaceList::print_on(outputStream* st, size_t scale) const {
+VirtualSpaceList* VirtualSpaceList::vslist_nonclass() {
-  st->print_cr(SIZE_FORMAT " nodes, current node: " PTR_FORMAT,
+  return MetaspaceContext::context_nonclass() == NULL ? NULL : MetaspaceContext::context_nonclass()->vslist();
-      _virtual_space_count, p2i(_current_virtual_space));
-  VirtualSpaceListIterator iter(virtual_space_list());
-  while (iter.repeat()) {
-    st->cr();
-    VirtualSpaceNode* node = iter.get_next();
-    node->print_on(st, scale);
-  }
 }
 
-void VirtualSpaceList::print_map(outputStream* st) const {
-  VirtualSpaceNode* list = virtual_space_list();
-  VirtualSpaceListIterator iter(list);
-  unsigned i = 0;
-  while (iter.repeat()) {
-    st->print_cr("Node %u:", i);
-    VirtualSpaceNode* node = iter.get_next();
-    node->print_map(st, this->is_class());
-    i ++;
-  }
-}
-
-// Given a node, expand range such that it includes the node.
-void VirtualSpaceList::expand_envelope_to_include_node(const VirtualSpaceNode* node) {
-  _envelope_lo = MIN2(_envelope_lo, (address)node->low_boundary());
-  _envelope_hi = MAX2(_envelope_hi, (address)node->high_boundary());
-}
-
-
-#ifdef ASSERT
-void VirtualSpaceList::verify(bool slow) {
-  VirtualSpaceNode* list = virtual_space_list();
-  VirtualSpaceListIterator iter(list);
-  size_t reserved = 0;
-  size_t committed = 0;
-  size_t node_count = 0;
-  while (iter.repeat()) {
-    VirtualSpaceNode* node = iter.get_next();
-    if (slow) {
-      node->verify(true);
-    }
-    // Check that the node resides fully within our envelope.
-    assert((address)node->low_boundary() >= _envelope_lo && (address)node->high_boundary() <= _envelope_hi,
-           "Node " SIZE_FORMAT " [" PTR_FORMAT ", " PTR_FORMAT ") outside envelope [" PTR_FORMAT ", " PTR_FORMAT ").",
-           node_count, p2i(node->low_boundary()), p2i(node->high_boundary()), p2i(_envelope_lo), p2i(_envelope_hi));
-    reserved += node->reserved_words();
-    committed += node->committed_words();
-    node_count ++;
-  }
-  assert(reserved == reserved_words() && committed == committed_words() && node_count == _virtual_space_count,
-      "Mismatch: reserved real: " SIZE_FORMAT " expected: " SIZE_FORMAT
-      ", committed real: " SIZE_FORMAT " expected: " SIZE_FORMAT
-      ", node count real: " SIZE_FORMAT " expected: " SIZE_FORMAT ".",
-      reserved, reserved_words(), committed, committed_words(),
-      node_count, _virtual_space_count);
-}
-#endif // ASSERT
-
 } // namespace metaspace

src/hotspot/share/memory/metaspace/virtualSpaceList.hpp

@@ -1,5 +1,6 @@
 /*
- * Copyright (c) 2018, 2019, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2018, 2020, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2018, 2020 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
@@ -26,141 +27,121 @@
 #define SHARE_MEMORY_METASPACE_VIRTUALSPACELIST_HPP
 
 #include "memory/allocation.hpp"
+#include "memory/metaspace/commitLimiter.hpp"
+#include "memory/metaspace/counters.hpp"
 #include "memory/metaspace/virtualSpaceNode.hpp"
+#include "memory/virtualspace.hpp"
 #include "utilities/globalDefinitions.hpp"
 
+class outputStream;
 
 namespace metaspace {
 
 class Metachunk;
-class ChunkManager;
+class FreeChunkListVector;
+
+// VirtualSpaceList manages a single (if its non-expandable) or
+//  a series of (if its expandable) virtual memory regions used
+//  for metaspace.
+//
+// Internally it holds a list of nodes (VirtualSpaceNode) each
+//  managing a single contiguous memory region. The first node of
+//  this list is the current node and used for allocation of new
+//  root chunks.
+//
+// Beyond access to those nodes and the ability to grow new nodes
+//  (if expandable) it allows for purging: purging this list means
+//  removing and unmapping all memory regions which are unused.
 
-// List of VirtualSpaces for metadata allocation.
 class VirtualSpaceList : public CHeapObj<mtClass> {
-  friend class VirtualSpaceNode;
 
-  enum VirtualSpaceSizes {
+  // Name
-    VirtualSpaceSize = 256 * K
+  const char* const _name;
-  };
 
-  // Head of the list
+  // Head of the list.
-  VirtualSpaceNode* _virtual_space_list;
+  VirtualSpaceNode* _first_node;
-  // virtual space currently being used for allocations
-  VirtualSpaceNode* _current_virtual_space;
 
-  // Is this VirtualSpaceList used for the compressed class space
+  // Number of nodes (kept for statistics only).
-  bool _is_class;
+  IntCounter _nodes_counter;
 
-  // Sum of reserved and committed memory in the virtual spaces
+  // Whether this list can expand by allocating new nodes.
-  size_t _reserved_words;
+  const bool _can_expand;
-  size_t _committed_words;
 
-  // Number of virtual spaces
+  // Used to check limits before committing memory.
-  size_t _virtual_space_count;
+  CommitLimiter* const _commit_limiter;
 
-  // Optimization: we keep an address range to quickly exclude pointers
+  // Statistics
-  // which are clearly not pointing into metaspace. This is an optimization for
-  // VirtualSpaceList::contains().
-  address _envelope_lo;
-  address _envelope_hi;
 
-  bool is_within_envelope(address p) const {
+  // Holds sum of reserved space, in words, over all list nodes.
-    return p >= _envelope_lo && p < _envelope_hi;
+  SizeCounter _reserved_words_counter;
-  }
 
-  // Given a node, expand range such that it includes the node.
+  // Holds sum of committed space, in words, over all list nodes.
-  void expand_envelope_to_include_node(const VirtualSpaceNode* node);
+  SizeCounter _committed_words_counter;
 
-  ~VirtualSpaceList();
+  // Create a new node and append it to the list. After
+  // this function, _current_node shall point to a new empty node.
+  // List must be expandable for this to work.
+  void create_new_node();
 
-  VirtualSpaceNode* virtual_space_list() const { return _virtual_space_list; }
+public:
 
-  void set_virtual_space_list(VirtualSpaceNode* v) {
+  // Create a new, empty, expandable list.
-    _virtual_space_list = v;
+  VirtualSpaceList(const char* name, CommitLimiter* commit_limiter);
-  }
-  void set_current_virtual_space(VirtualSpaceNode* v) {
-    _current_virtual_space = v;
-  }
 
-  void link_vs(VirtualSpaceNode* new_entry);
+  // Create a new list. The list will contain one node only, which uses the given ReservedSpace.
+  // It will be not expandable beyond that first node.
+  VirtualSpaceList(const char* name, ReservedSpace rs, CommitLimiter* commit_limiter);
 
-  // Get another virtual space and add it to the list.  This
+  virtual ~VirtualSpaceList();
-  // is typically prompted by a failed attempt to allocate a chunk
-  // and is typically followed by the allocation of a chunk.
-  bool create_new_virtual_space(size_t vs_word_size);
 
-  // Chunk up the unused committed space in the current
+  // Allocate a root chunk from this list.
-  // virtual space and add the chunks to the free list.
+  // Note: this just returns a chunk whose memory is reserved; no memory is committed yet.
-  void retire_current_virtual_space();
+  // Hence, before using this chunk, it must be committed.
+  // May return NULL if vslist would need to be expanded to hold the new root node but
+  // the list cannot be expanded (in practice this means we reached CompressedClassSpaceSize).
+  Metachunk* allocate_root_chunk();
 
-  DEBUG_ONLY(bool contains_node(const VirtualSpaceNode* node) const;)
+  // Attempts to purge nodes. This will remove and delete nodes which only contain free chunks.
+  // The free chunks are removed from the freelists before the nodes are deleted.
+  // Return number of purged nodes.
+  int purge(FreeChunkListVector* freelists);
 
- public:
+  //// Statistics ////
-  VirtualSpaceList(size_t word_size);
-  VirtualSpaceList(ReservedSpace rs);
 
-  size_t free_bytes();
+  // Return sum of reserved words in all nodes.
+  size_t reserved_words() const     { return _reserved_words_counter.get(); }
 
-  Metachunk* get_new_chunk(size_t chunk_word_size,
+  // Return sum of committed words in all nodes.
-                           size_t suggested_commit_granularity);
+  size_t committed_words() const    { return _committed_words_counter.get(); }
 
-  bool expand_node_by(VirtualSpaceNode* node,
+  // Return number of nodes in this list.
-                      size_t min_words,
+  int num_nodes() const             { return _nodes_counter.get(); }
-                      size_t preferred_words);
 
-  bool expand_by(size_t min_words,
+  //// Debug stuff ////
-                 size_t preferred_words);
+  DEBUG_ONLY(void verify() const;)
+  DEBUG_ONLY(void verify_locked() const;)
 
-  VirtualSpaceNode* current_virtual_space() {
+  // Print all nodes in this space list.
-    return _current_virtual_space;
+  void print_on(outputStream* st) const;
-  }
 
-  bool is_class() const { return _is_class; }
+  // Returns true if this pointer is contained in one of our nodes.
+  bool contains(const MetaWord* p) const;
 
-  bool initialization_succeeded() { return _virtual_space_list != NULL; }
+  // Returns true if the list is not expandable and no more root chunks
+  // can be allocated.
+  bool is_full() const;
 
-  size_t reserved_words()  { return _reserved_words; }
+  // Convenience methods to return the global class-space vslist
-  size_t reserved_bytes()  { return reserved_words() * BytesPerWord; }
+  //  and non-class vslist, respectively.
-  size_t committed_words() { return _committed_words; }
+  static VirtualSpaceList* vslist_class();
-  size_t committed_bytes() { return committed_words() * BytesPerWord; }
+  static VirtualSpaceList* vslist_nonclass();
 
-  void inc_reserved_words(size_t v);
+  // These exist purely to print limits of the compressed class space;
-  void dec_reserved_words(size_t v);
+  // if we ever change the ccs to not use a degenerated-list-of-one-node this
-  void inc_committed_words(size_t v);
+  // will go away.
-  void dec_committed_words(size_t v);
+  MetaWord* base_of_first_node() const { return _first_node != NULL ? _first_node->base() : NULL; }
-  void inc_virtual_space_count();
+  size_t word_size_of_first_node() const { return _first_node != NULL ? _first_node->word_size() : 0; }
-  void dec_virtual_space_count();
 
-  VirtualSpaceNode* find_enclosing_space(const void* ptr);
-  bool contains(const void* ptr) { return find_enclosing_space(ptr) != NULL; }
-
-  // Unlink empty VirtualSpaceNodes and free it.
-  void purge(ChunkManager* chunk_manager);
-
-  void print_on(outputStream* st) const                 { print_on(st, K); }
-  void print_on(outputStream* st, size_t scale) const;
-  void print_map(outputStream* st) const;
-
-  DEBUG_ONLY(void verify(bool slow);)
-
-  class VirtualSpaceListIterator : public StackObj {
-    VirtualSpaceNode* _virtual_spaces;
-   public:
-    VirtualSpaceListIterator(VirtualSpaceNode* virtual_spaces) :
-      _virtual_spaces(virtual_spaces) {}
-
-    bool repeat() {
-      return _virtual_spaces != NULL;
-    }
-
-    VirtualSpaceNode* get_next() {
-      VirtualSpaceNode* result = _virtual_spaces;
-      if (_virtual_spaces != NULL) {
-        _virtual_spaces = _virtual_spaces->next();
-      }
-      return result;
-    }
-  };
 };
 
 } // namespace metaspace

src/hotspot/share/memory/metaspace/virtualSpaceNode.cpp

@@ -1,5 +1,6 @@
 /*
- * Copyright (c) 2018, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2018, 2020, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2018, 2020 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
@@ -23,566 +24,450 @@
  */
 
 #include "precompiled.hpp"
-
 #include "logging/log.hpp"
-#include "logging/logStream.hpp"
-#include "memory/metaspace/metachunk.hpp"
 #include "memory/metaspace.hpp"
-#include "memory/metaspace/chunkManager.hpp"
+#include "memory/metaspace/chunkHeaderPool.hpp"
-#include "memory/metaspace/metaDebug.hpp"
+#include "memory/metaspace/chunklevel.hpp"
+#include "memory/metaspace/commitLimiter.hpp"
+#include "memory/metaspace/counters.hpp"
+#include "memory/metaspace/freeChunkList.hpp"
+#include "memory/metaspace/internalStats.hpp"
+#include "memory/metaspace/metachunk.hpp"
 #include "memory/metaspace/metaspaceCommon.hpp"
-#include "memory/metaspace/occupancyMap.hpp"
+#include "memory/metaspace/metaspaceSettings.hpp"
+#include "memory/metaspace/rootChunkArea.hpp"
+#include "memory/metaspace/runningCounters.hpp"
 #include "memory/metaspace/virtualSpaceNode.hpp"
-#include "memory/virtualspace.hpp"
+#include "runtime/globals.hpp"
-#include "runtime/atomic.hpp"
+#include "runtime/mutexLocker.hpp"
 #include "runtime/os.hpp"
-#include "services/memTracker.hpp"
+#include "utilities/align.hpp"
-#include "utilities/copy.hpp"
 #include "utilities/debug.hpp"
 #include "utilities/globalDefinitions.hpp"
+#include "utilities/ostream.hpp"
 
 namespace metaspace {
 
-// Decide if large pages should be committed when the memory is reserved.
+#define LOGFMT         "VsListNode @" PTR_FORMAT " base " PTR_FORMAT " "
-static bool should_commit_large_pages_when_reserving(size_t bytes) {
+#define LOGFMT_ARGS    p2i(this), p2i(_base)
-  if (UseLargePages && UseLargePagesInMetaspace && !os::can_commit_large_page_memory()) {
-    size_t words = bytes / BytesPerWord;
-    bool is_class = false; // We never reserve large pages for the class space.
-    if (MetaspaceGC::can_expand(words, is_class) &&
-        MetaspaceGC::allowed_expansion() >= words) {
-      return true;
-    }
-  }
-
-  return false;
-}
-
-// byte_size is the size of the associated virtualspace.
-VirtualSpaceNode::VirtualSpaceNode(bool is_class, size_t bytes) :
-    _next(NULL), _is_class(is_class), _rs(), _top(NULL), _container_count(0), _occupancy_map(NULL) {
-  assert_is_aligned(bytes, Metaspace::reserve_alignment());
-  bool large_pages = should_commit_large_pages_when_reserving(bytes);
-  _rs = ReservedSpace(bytes, Metaspace::reserve_alignment(), large_pages);
-
-  if (_rs.is_reserved()) {
-    assert(_rs.base() != NULL, "Catch if we get a NULL address");
-    assert(_rs.size() != 0, "Catch if we get a 0 size");
-    assert_is_aligned(_rs.base(), Metaspace::reserve_alignment());
-    assert_is_aligned(_rs.size(), Metaspace::reserve_alignment());
-
-    MemTracker::record_virtual_memory_type((address)_rs.base(), mtClass);
-  }
-}
-
-void VirtualSpaceNode::purge(ChunkManager* chunk_manager) {
-  // When a node is purged, lets give it a thorough examination.
-  DEBUG_ONLY(verify(true);)
-  Metachunk* chunk = first_chunk();
-  Metachunk* invalid_chunk = (Metachunk*) top();
-  while (chunk < invalid_chunk ) {
-    assert(chunk->is_tagged_free(), "Should be tagged free");
-    MetaWord* next = ((MetaWord*)chunk) + chunk->word_size();
-    chunk_manager->remove_chunk(chunk);
-    chunk->remove_sentinel();
-    assert(chunk->next() == NULL &&
-        chunk->prev() == NULL,
-        "Was not removed from its list");
-    chunk = (Metachunk*) next;
-  }
-}
-
-void VirtualSpaceNode::print_map(outputStream* st, bool is_class) const {
-
-  if (bottom() == top()) {
-    return;
-  }
-
-  const size_t spec_chunk_size = is_class ? ClassSpecializedChunk : SpecializedChunk;
-  const size_t small_chunk_size = is_class ? ClassSmallChunk : SmallChunk;
-  const size_t med_chunk_size = is_class ? ClassMediumChunk : MediumChunk;
-
-  int line_len = 100;
-  const size_t section_len = align_up(spec_chunk_size * line_len, med_chunk_size);
-  line_len = (int)(section_len / spec_chunk_size);
-
-  static const int NUM_LINES = 4;
-
-  char* lines[NUM_LINES];
-  for (int i = 0; i < NUM_LINES; i ++) {
-    lines[i] = (char*)os::malloc(line_len, mtInternal);
-  }
-  int pos = 0;
-  const MetaWord* p = bottom();
-  const Metachunk* chunk = (const Metachunk*)p;
-  const MetaWord* chunk_end = p + chunk->word_size();
-  while (p < top()) {
-    if (pos == line_len) {
-      pos = 0;
-      for (int i = 0; i < NUM_LINES; i ++) {
-        st->fill_to(22);
-        st->print_raw(lines[i], line_len);
-        st->cr();
-      }
-    }
-    if (pos == 0) {
-      st->print(PTR_FORMAT ":", p2i(p));
-    }
-    if (p == chunk_end) {
-      chunk = (Metachunk*)p;
-      chunk_end = p + chunk->word_size();
-    }
-    // line 1: chunk starting points (a dot if that area is a chunk start).
-    lines[0][pos] = p == (const MetaWord*)chunk ? '.' : ' ';
-
-    // Line 2: chunk type (x=spec, s=small, m=medium, h=humongous), uppercase if
-    // chunk is in use.
-    const bool chunk_is_free = ((Metachunk*)chunk)->is_tagged_free();
-    if (chunk->word_size() == spec_chunk_size) {
-      lines[1][pos] = chunk_is_free ? 'x' : 'X';
-    } else if (chunk->word_size() == small_chunk_size) {
-      lines[1][pos] = chunk_is_free ? 's' : 'S';
-    } else if (chunk->word_size() == med_chunk_size) {
-      lines[1][pos] = chunk_is_free ? 'm' : 'M';
-    } else if (chunk->word_size() > med_chunk_size) {
-      lines[1][pos] = chunk_is_free ? 'h' : 'H';
-    } else {
-      ShouldNotReachHere();
-    }
-
-    // Line 3: chunk origin
-    const ChunkOrigin origin = chunk->get_origin();
-    lines[2][pos] = origin == origin_normal ? ' ' : '0' + (int) origin;
-
-    // Line 4: Virgin chunk? Virgin chunks are chunks created as a byproduct of padding or splitting,
-    //         but were never used.
-    lines[3][pos] = chunk->get_use_count() > 0 ? ' ' : 'v';
-
-    p += spec_chunk_size;
-    pos ++;
-  }
-  if (pos > 0) {
-    for (int i = 0; i < NUM_LINES; i ++) {
-      st->fill_to(22);
-      st->print_raw(lines[i], line_len);
-      st->cr();
-    }
-  }
-  for (int i = 0; i < NUM_LINES; i ++) {
-    os::free(lines[i]);
-  }
-}
-
 
 #ifdef ASSERT
-
+void check_pointer_is_aligned_to_commit_granule(const MetaWord* p) {
-// Verify counters, all chunks in this list node and the occupancy map.
+  assert(is_aligned(p, Settings::commit_granule_bytes()),
-void VirtualSpaceNode::verify(bool slow) {
+         "Pointer not aligned to commit granule size: " PTR_FORMAT ".",
-  log_trace(gc, metaspace, freelist)("verifying %s virtual space node (%s).",
+         p2i(p));
-    (is_class() ? "class space" : "metaspace"), (slow ? "slow" : "quick"));
-  // Fast mode: just verify chunk counters and basic geometry
-  // Slow mode: verify chunks and occupancy map
-  uintx num_in_use_chunks = 0;
-  Metachunk* chunk = first_chunk();
-  Metachunk* invalid_chunk = (Metachunk*) top();
-
-  // Iterate the chunks in this node and verify each chunk.
-  while (chunk < invalid_chunk ) {
-    if (slow) {
-      do_verify_chunk(chunk);
-    }
-    if (!chunk->is_tagged_free()) {
-      num_in_use_chunks ++;
-    }
-    const size_t s = chunk->word_size();
-    // Prevent endless loop on invalid chunk size.
-    assert(is_valid_chunksize(is_class(), s), "Invalid chunk size: " SIZE_FORMAT ".", s);
-    MetaWord* next = ((MetaWord*)chunk) + s;
-    chunk = (Metachunk*) next;
-  }
-  assert(_container_count == num_in_use_chunks, "Container count mismatch (real: " UINTX_FORMAT
-      ", counter: " UINTX_FORMAT ".", num_in_use_chunks, _container_count);
-  // Also verify the occupancy map.
-  if (slow) {
-    occupancy_map()->verify(bottom(), top());
-  }
 }
-
+void check_word_size_is_aligned_to_commit_granule(size_t word_size) {
-// Verify that all free chunks in this node are ideally merged
+  assert(is_aligned(word_size, Settings::commit_granule_words()),
-// (there not should be multiple small chunks where a large chunk could exist.)
+         "Not aligned to commit granule size: " SIZE_FORMAT ".", word_size);
-void VirtualSpaceNode::verify_free_chunks_are_ideally_merged() {
-  Metachunk* chunk = first_chunk();
-  Metachunk* invalid_chunk = (Metachunk*) top();
-  // Shorthands.
-  const size_t size_med = (is_class() ? ClassMediumChunk : MediumChunk) * BytesPerWord;
-  const size_t size_small = (is_class() ? ClassSmallChunk : SmallChunk) * BytesPerWord;
-  int num_free_chunks_since_last_med_boundary = -1;
-  int num_free_chunks_since_last_small_boundary = -1;
-  bool error = false;
-  char err[256];
-  while (!error && chunk < invalid_chunk ) {
-    // Test for missed chunk merge opportunities: count number of free chunks since last chunk boundary.
-    // Reset the counter when encountering a non-free chunk.
-    if (chunk->get_chunk_type() != HumongousIndex) {
-      if (chunk->is_tagged_free()) {
-        // Count successive free, non-humongous chunks.
-        if (is_aligned(chunk, size_small)) {
-          if (num_free_chunks_since_last_small_boundary > 0) {
-            error = true;
-            jio_snprintf(err, sizeof(err), "Missed chunk merge opportunity to merge a small chunk preceding " PTR_FORMAT ".", p2i(chunk));
-          } else {
-            num_free_chunks_since_last_small_boundary = 0;
-          }
-        } else if (num_free_chunks_since_last_small_boundary != -1) {
-          num_free_chunks_since_last_small_boundary ++;
-        }
-        if (is_aligned(chunk, size_med)) {
-          if (num_free_chunks_since_last_med_boundary > 0) {
-            error = true;
-            jio_snprintf(err, sizeof(err), "Missed chunk merge opportunity to merge a medium chunk preceding " PTR_FORMAT ".", p2i(chunk));
-          } else {
-            num_free_chunks_since_last_med_boundary = 0;
-          }
-        } else if (num_free_chunks_since_last_med_boundary != -1) {
-          num_free_chunks_since_last_med_boundary ++;
-        }
-      } else {
-        // Encountering a non-free chunk, reset counters.
-        num_free_chunks_since_last_med_boundary = -1;
-        num_free_chunks_since_last_small_boundary = -1;
-      }
-    } else {
-      // One cannot merge areas with a humongous chunk in the middle. Reset counters.
-      num_free_chunks_since_last_med_boundary = -1;
-      num_free_chunks_since_last_small_boundary = -1;
-    }
-
-    if (error) {
-      print_map(tty, is_class());
-      fatal("%s", err);
-    }
-
-    MetaWord* next = ((MetaWord*)chunk) + chunk->word_size();
-    chunk = (Metachunk*) next;
-  }
 }
-#endif // ASSERT
+#endif
 
-void VirtualSpaceNode::inc_container_count() {
+// Given an address range, ensure it is committed.
+//
+// The range has to be aligned to granule size.
+//
+// Function will:
+// - check how many granules in that region are uncommitted; If all are committed, it
+//    returns true immediately.
+// - check if committing those uncommitted granules would bring us over the commit limit
+//    (GC threshold, MaxMetaspaceSize). If true, it returns false.
+// - commit the memory.
+// - mark the range as committed in the commit mask
+//
+// Returns true if success, false if it did hit a commit limit.
+bool VirtualSpaceNode::commit_range(MetaWord* p, size_t word_size) {
+  DEBUG_ONLY(check_pointer_is_aligned_to_commit_granule(p);)
+  DEBUG_ONLY(check_word_size_is_aligned_to_commit_granule(word_size);)
   assert_lock_strong(MetaspaceExpand_lock);
-  _container_count++;
+
+  // First calculate how large the committed regions in this range are
+  const size_t committed_words_in_range = _commit_mask.get_committed_size_in_range(p, word_size);
+  DEBUG_ONLY(check_word_size_is_aligned_to_commit_granule(committed_words_in_range);)
+
+  // By how much words we would increase commit charge
+  //  were we to commit the given address range completely.
+  const size_t commit_increase_words = word_size - committed_words_in_range;
+
+  UL2(debug, "committing range " PTR_FORMAT ".." PTR_FORMAT "(" SIZE_FORMAT " words)",
+      p2i(p), p2i(p + word_size), word_size);
+
+  if (commit_increase_words == 0) {
+    UL(debug, "... already fully committed.");
+    return true; // Already fully committed, nothing to do.
+  }
+
+  // Before committing any more memory, check limits.
+  if (_commit_limiter->possible_expansion_words() < commit_increase_words) {
+    UL(debug, "... cannot commit (limit).");
+    return false;
+  }
+
+  // Commit...
+  if (os::commit_memory((char*)p, word_size * BytesPerWord, false) == false) {
+    vm_exit_out_of_memory(word_size * BytesPerWord, OOM_MMAP_ERROR, "Failed to commit metaspace.");
+  }
+
+  if (AlwaysPreTouch) {
+    os::pretouch_memory(p, p + word_size);
+  }
+
+  UL2(debug, "... committed " SIZE_FORMAT " additional words.", commit_increase_words);
+
+  // ... tell commit limiter...
+  _commit_limiter->increase_committed(commit_increase_words);
+
+  // ... update counters in containing vslist ...
+  _total_committed_words_counter->increment_by(commit_increase_words);
+
+  // ... and update the commit mask.
+  _commit_mask.mark_range_as_committed(p, word_size);
+
+#ifdef ASSERT
+  // The commit boundary maintained in the CommitLimiter should be equal the sum of committed words
+  // in both class and non-class vslist (outside gtests).
+  if (_commit_limiter == CommitLimiter::globalLimiter()) {
+    assert(_commit_limiter->committed_words() == RunningCounters::committed_words(), "counter mismatch");
+  }
+#endif
+
+  InternalStats::inc_num_space_committed();
+  return true;
 }
 
-void VirtualSpaceNode::dec_container_count() {
+// Given an address range, ensure it is committed.
+//
+// The range does not have to be aligned to granule size. However, the function will always commit
+// whole granules.
+//
+// Function will:
+// - check how many granules in that region are uncommitted; If all are committed, it
+//    returns true immediately.
+// - check if committing those uncommitted granules would bring us over the commit limit
+//    (GC threshold, MaxMetaspaceSize). If true, it returns false.
+// - commit the memory.
+// - mark the range as committed in the commit mask
+//
+// !! Careful:
+//    calling ensure_range_is_committed on a range which contains both committed and uncommitted
+//    areas will commit the whole area, thus erase the content in the existing committed parts.
+//    Make sure you never call this on an address range containing live data. !!
+//
+// Returns true if success, false if it did hit a commit limit.
+bool VirtualSpaceNode::ensure_range_is_committed(MetaWord* p, size_t word_size) {
   assert_lock_strong(MetaspaceExpand_lock);
-  _container_count--;
+  assert(p != NULL && word_size > 0, "Sanity");
+  MetaWord* p_start = align_down(p, Settings::commit_granule_bytes());
+  MetaWord* p_end = align_up(p + word_size, Settings::commit_granule_bytes());
+  return commit_range(p_start, p_end - p_start);
+}
+
+// Given an address range (which has to be aligned to commit granule size):
+//  - uncommit it
+//  - mark it as uncommitted in the commit mask
+void VirtualSpaceNode::uncommit_range(MetaWord* p, size_t word_size) {
+  DEBUG_ONLY(check_pointer_is_aligned_to_commit_granule(p);)
+  DEBUG_ONLY(check_word_size_is_aligned_to_commit_granule(word_size);)
+  assert_lock_strong(MetaspaceExpand_lock);
+
+  // First calculate how large the committed regions in this range are
+  const size_t committed_words_in_range = _commit_mask.get_committed_size_in_range(p, word_size);
+  DEBUG_ONLY(check_word_size_is_aligned_to_commit_granule(committed_words_in_range);)
+
+  UL2(debug, "uncommitting range " PTR_FORMAT ".." PTR_FORMAT "(" SIZE_FORMAT " words)",
+      p2i(p), p2i(p + word_size), word_size);
+
+  if (committed_words_in_range == 0) {
+    UL(debug, "... already fully uncommitted.");
+    return; // Already fully uncommitted, nothing to do.
+  }
+
+  // Uncommit...
+  if (os::uncommit_memory((char*)p, word_size * BytesPerWord) == false) {
+    // Note: this can actually happen, since uncommit may increase the number of mappings.
+    fatal("Failed to uncommit metaspace.");
+  }
+
+  UL2(debug, "... uncommitted " SIZE_FORMAT " words.", committed_words_in_range);
+
+  // ... tell commit limiter...
+  _commit_limiter->decrease_committed(committed_words_in_range);
+
+  // ... and global counters...
+  _total_committed_words_counter->decrement_by(committed_words_in_range);
+
+   // ... and update the commit mask.
+  _commit_mask.mark_range_as_uncommitted(p, word_size);
+
+#ifdef ASSERT
+  // The commit boundary maintained in the CommitLimiter should be equal the sum of committed words
+  // in both class and non-class vslist (outside gtests).
+  if (_commit_limiter == CommitLimiter::globalLimiter()) { // We are outside a test scenario
+    assert(_commit_limiter->committed_words() == RunningCounters::committed_words(), "counter mismatch");
+  }
+#endif
+  InternalStats::inc_num_space_uncommitted();
+}
+
+//// creation, destruction ////
+
+VirtualSpaceNode::VirtualSpaceNode(ReservedSpace rs, bool owns_rs, CommitLimiter* limiter,
+                                   SizeCounter* reserve_counter, SizeCounter* commit_counter) :
+  _next(NULL),
+  _rs(rs),
+  _owns_rs(owns_rs),
+  _base((MetaWord*)rs.base()),
+  _word_size(rs.size() / BytesPerWord),
+  _used_words(0),
+  _commit_mask((MetaWord*)rs.base(), rs.size() / BytesPerWord),
+  _root_chunk_area_lut((MetaWord*)rs.base(), rs.size() / BytesPerWord),
+  _commit_limiter(limiter),
+  _total_reserved_words_counter(reserve_counter),
+  _total_committed_words_counter(commit_counter)
+{
+  UL2(debug, "born (word_size " SIZE_FORMAT ").", _word_size);
+
+  // Update reserved counter in vslist
+  _total_reserved_words_counter->increment_by(_word_size);
+
+  assert_is_aligned(_base, chunklevel::MAX_CHUNK_BYTE_SIZE);
+  assert_is_aligned(_word_size, chunklevel::MAX_CHUNK_WORD_SIZE);
+}
+
+// Create a node of a given size (it will create its own space).
+VirtualSpaceNode* VirtualSpaceNode::create_node(size_t word_size,
+                                                CommitLimiter* limiter, SizeCounter* reserve_words_counter,
+                                                SizeCounter* commit_words_counter)
+{
+  DEBUG_ONLY(assert_is_aligned(word_size, chunklevel::MAX_CHUNK_WORD_SIZE);)
+  ReservedSpace rs(word_size * BytesPerWord,
+                   Settings::virtual_space_node_reserve_alignment_words() * BytesPerWord,
+                   false // large
+                   );
+  if (!rs.is_reserved()) {
+    vm_exit_out_of_memory(word_size * BytesPerWord, OOM_MMAP_ERROR, "Failed to reserve memory for metaspace");
+  }
+  assert_is_aligned(rs.base(), chunklevel::MAX_CHUNK_BYTE_SIZE);
+  InternalStats::inc_num_vsnodes_births();
+  return new VirtualSpaceNode(rs, true, limiter, reserve_words_counter, commit_words_counter);
+}
+
+// Create a node over an existing space
+VirtualSpaceNode* VirtualSpaceNode::create_node(ReservedSpace rs, CommitLimiter* limiter,
+                                                SizeCounter* reserve_words_counter, SizeCounter* commit_words_counter)
+{
+  InternalStats::inc_num_vsnodes_births();
+  return new VirtualSpaceNode(rs, false, limiter, reserve_words_counter, commit_words_counter);
 }
 
 VirtualSpaceNode::~VirtualSpaceNode() {
-  _rs.release();
+  DEBUG_ONLY(verify_locked();)
-  if (_occupancy_map != NULL) {
+
-    delete _occupancy_map;
+  UL(debug, ": dies.");
+  if (_owns_rs) {
+    _rs.release();
   }
-#ifdef ASSERT
+
-  size_t word_size = sizeof(*this) / BytesPerWord;
+  // Update counters in vslist
-  Copy::fill_to_words((HeapWord*) this, word_size, 0xf1f1f1f1);
+  size_t committed = committed_words();
-#endif
+  _total_committed_words_counter->decrement_by(committed);
+  _total_reserved_words_counter->decrement_by(_word_size);
+
+  // ... and tell commit limiter
+  _commit_limiter->decrease_committed(committed);
+
+  InternalStats::inc_num_vsnodes_deaths();
 }
 
-size_t VirtualSpaceNode::used_words_in_vs() const {
+//// Chunk allocation, splitting, merging /////
-  return pointer_delta(top(), bottom(), sizeof(MetaWord));
-}
 
-// Space committed in the VirtualSpace
+// Allocate a root chunk from this node. Will fail and return NULL if the node is full
-size_t VirtualSpaceNode::capacity_words_in_vs() const {
+//  - if we used up the whole address space of this node's memory region.
-  return pointer_delta(end(), bottom(), sizeof(MetaWord));
+//    (in case this node backs compressed class space, this is how we hit
-}
+//     CompressedClassSpaceSize).
-
+// Note that this just returns reserved memory; caller must take care of committing this
-size_t VirtualSpaceNode::free_words_in_vs() const {
+//  chunk before using it.
-  return pointer_delta(end(), top(), sizeof(MetaWord));
+Metachunk* VirtualSpaceNode::allocate_root_chunk() {
-}
-
-// Given an address larger than top(), allocate padding chunks until top is at the given address.
-void VirtualSpaceNode::allocate_padding_chunks_until_top_is_at(MetaWord* target_top) {
-
-  assert(target_top > top(), "Sanity");
-
-  // Padding chunks are added to the freelist.
-  ChunkManager* const chunk_manager = Metaspace::get_chunk_manager(is_class());
-
-  // shorthands
-  const size_t spec_word_size = chunk_manager->specialized_chunk_word_size();
-  const size_t small_word_size = chunk_manager->small_chunk_word_size();
-  const size_t med_word_size = chunk_manager->medium_chunk_word_size();
-
-  while (top() < target_top) {
-
-    // We could make this coding more generic, but right now we only deal with two possible chunk sizes
-    // for padding chunks, so it is not worth it.
-    size_t padding_chunk_word_size = small_word_size;
-    if (is_aligned(top(), small_word_size * sizeof(MetaWord)) == false) {
-      assert_is_aligned(top(), spec_word_size * sizeof(MetaWord)); // Should always hold true.
-      padding_chunk_word_size = spec_word_size;
-    }
-    MetaWord* here = top();
-    assert_is_aligned(here, padding_chunk_word_size * sizeof(MetaWord));
-    inc_top(padding_chunk_word_size);
-
-    // Create new padding chunk.
-    ChunkIndex padding_chunk_type = get_chunk_type_by_size(padding_chunk_word_size, is_class());
-    assert(padding_chunk_type == SpecializedIndex || padding_chunk_type == SmallIndex, "sanity");
-
-    Metachunk* const padding_chunk =
-        ::new (here) Metachunk(padding_chunk_type, is_class(), padding_chunk_word_size, this);
-    assert(padding_chunk == (Metachunk*)here, "Sanity");
-    DEBUG_ONLY(padding_chunk->set_origin(origin_pad);)
-    log_trace(gc, metaspace, freelist)("Created padding chunk in %s at "
-        PTR_FORMAT ", size " SIZE_FORMAT_HEX ".",
-        (is_class() ? "class space " : "metaspace"),
-        p2i(padding_chunk), padding_chunk->word_size() * sizeof(MetaWord));
-
-    // Mark chunk start in occupancy map.
-    occupancy_map()->set_chunk_starts_at_address((MetaWord*)padding_chunk, true);
-
-    // Chunks are born as in-use (see MetaChunk ctor). So, before returning
-    // the padding chunk to its chunk manager, mark it as in use (ChunkManager
-    // will assert that).
-    do_update_in_use_info_for_chunk(padding_chunk, true);
-
-    // Return Chunk to freelist.
-    inc_container_count();
-    chunk_manager->return_single_chunk(padding_chunk);
-    // Please note: at this point, ChunkManager::return_single_chunk()
-    // may already have merged the padding chunk with neighboring chunks, so
-    // it may have vanished at this point. Do not reference the padding
-    // chunk beyond this point.
-  }
-
-  assert(top() == target_top, "Sanity");
-
-} // allocate_padding_chunks_until_top_is_at()
-
-// Allocates the chunk from the virtual space only.
-// This interface is also used internally for debugging.  Not all
-// chunks removed here are necessarily used for allocation.
-Metachunk* VirtualSpaceNode::take_from_committed(size_t chunk_word_size) {
-  // Non-humongous chunks are to be allocated aligned to their chunk
-  // size. So, start addresses of medium chunks are aligned to medium
-  // chunk size, those of small chunks to small chunk size and so
-  // forth. This facilitates merging of free chunks and reduces
-  // fragmentation. Chunk sizes are spec < small < medium, with each
-  // larger chunk size being a multiple of the next smaller chunk
-  // size.
-  // Because of this alignment, me may need to create a number of padding
-  // chunks. These chunks are created and added to the freelist.
-
-  // The chunk manager to which we will give our padding chunks.
-  ChunkManager* const chunk_manager = Metaspace::get_chunk_manager(is_class());
-
-  // shorthands
-  const size_t spec_word_size = chunk_manager->specialized_chunk_word_size();
-  const size_t small_word_size = chunk_manager->small_chunk_word_size();
-  const size_t med_word_size = chunk_manager->medium_chunk_word_size();
-
-  assert(chunk_word_size == spec_word_size || chunk_word_size == small_word_size ||
-      chunk_word_size >= med_word_size, "Invalid chunk size requested.");
-
-  // Chunk alignment (in bytes) == chunk size unless humongous.
-  // Humongous chunks are aligned to the smallest chunk size (spec).
-  const size_t required_chunk_alignment = (chunk_word_size > med_word_size ?
-      spec_word_size : chunk_word_size) * sizeof(MetaWord);
-
-  // Do we have enough space to create the requested chunk plus
-  // any padding chunks needed?
-  MetaWord* const next_aligned =
-      static_cast<MetaWord*>(align_up(top(), required_chunk_alignment));
-  if (!is_available((next_aligned - top()) + chunk_word_size)) {
-    return NULL;
-  }
-
-  // Before allocating the requested chunk, allocate padding chunks if necessary.
-  // We only need to do this for small or medium chunks: specialized chunks are the
-  // smallest size, hence always aligned. Homungous chunks are allocated unaligned
-  // (implicitly, also aligned to smallest chunk size).
-  if ((chunk_word_size == med_word_size || chunk_word_size == small_word_size) && next_aligned > top())  {
-    log_trace(gc, metaspace, freelist)("Creating padding chunks in %s between %p and %p...",
-        (is_class() ? "class space " : "metaspace"),
-        top(), next_aligned);
-    allocate_padding_chunks_until_top_is_at(next_aligned);
-    // Now, top should be aligned correctly.
-    assert_is_aligned(top(), required_chunk_alignment);
-  }
-
-  // Now, top should be aligned correctly.
-  assert_is_aligned(top(), required_chunk_alignment);
-
-  // Bottom of the new chunk
-  MetaWord* chunk_limit = top();
-  assert(chunk_limit != NULL, "Not safe to call this method");
-
-  // The virtual spaces are always expanded by the
-  // commit granularity to enforce the following condition.
-  // Without this the is_available check will not work correctly.
-  assert(_virtual_space.committed_size() == _virtual_space.actual_committed_size(),
-      "The committed memory doesn't match the expanded memory.");
-
-  if (!is_available(chunk_word_size)) {
-    LogTarget(Trace, gc, metaspace, freelist) lt;
-    if (lt.is_enabled()) {
-      LogStream ls(lt);
-      ls.print("VirtualSpaceNode::take_from_committed() not available " SIZE_FORMAT " words ", chunk_word_size);
-      // Dump some information about the virtual space that is nearly full
-      print_on(&ls);
-    }
-    return NULL;
-  }
-
-  // Take the space  (bump top on the current virtual space).
-  inc_top(chunk_word_size);
-
-  // Initialize the chunk
-  ChunkIndex chunk_type = get_chunk_type_by_size(chunk_word_size, is_class());
-  Metachunk* result = ::new (chunk_limit) Metachunk(chunk_type, is_class(), chunk_word_size, this);
-  assert(result == (Metachunk*)chunk_limit, "Sanity");
-  occupancy_map()->set_chunk_starts_at_address((MetaWord*)result, true);
-  do_update_in_use_info_for_chunk(result, true);
-
-  inc_container_count();
-
-#ifdef ASSERT
-  EVERY_NTH(VerifyMetaspaceInterval)
-    chunk_manager->locked_verify(true);
-    verify(true);
-  END_EVERY_NTH
-  do_verify_chunk(result);
-#endif
-
-  result->inc_use_count();
-
-  return result;
-}
-
-
-// Expand the virtual space (commit more of the reserved space)
-bool VirtualSpaceNode::expand_by(size_t min_words, size_t preferred_words) {
-  size_t min_bytes = min_words * BytesPerWord;
-  size_t preferred_bytes = preferred_words * BytesPerWord;
-
-  size_t uncommitted = virtual_space()->reserved_size() - virtual_space()->actual_committed_size();
-
-  if (uncommitted < min_bytes) {
-    return false;
-  }
-
-  size_t commit = MIN2(preferred_bytes, uncommitted);
-  bool result = virtual_space()->expand_by(commit, false);
-
-  if (result) {
-    log_trace(gc, metaspace, freelist)("Expanded %s virtual space list node by " SIZE_FORMAT " words.",
-        (is_class() ? "class" : "non-class"), commit);
-    DEBUG_ONLY(Atomic::inc(&g_internal_statistics.num_committed_space_expanded));
-  } else {
-    log_trace(gc, metaspace, freelist)("Failed to expand %s virtual space list node by " SIZE_FORMAT " words.",
-        (is_class() ? "class" : "non-class"), commit);
-  }
-
-  assert(result, "Failed to commit memory");
-
-  return result;
-}
-
-Metachunk* VirtualSpaceNode::get_chunk_vs(size_t chunk_word_size) {
   assert_lock_strong(MetaspaceExpand_lock);
-  Metachunk* result = take_from_committed(chunk_word_size);
+  assert_is_aligned(free_words(), chunklevel::MAX_CHUNK_WORD_SIZE);
-  return result;
+
+  if (free_words() >= chunklevel::MAX_CHUNK_WORD_SIZE) {
+
+    MetaWord* loc = _base + _used_words;
+    _used_words += chunklevel::MAX_CHUNK_WORD_SIZE;
+
+    RootChunkArea* rca = _root_chunk_area_lut.get_area_by_address(loc);
+
+    // Create a root chunk header and initialize it;
+    Metachunk* c = rca->alloc_root_chunk_header(this);
+    assert(c->base() == loc && c->vsnode() == this &&
+           c->is_free(), "Sanity");
+    DEBUG_ONLY(c->verify();)
+
+    UL2(debug, "new root chunk " METACHUNK_FORMAT ".", METACHUNK_FORMAT_ARGS(c));
+    return c;
+  }
+  return NULL; // Node is full.
 }
 
-bool VirtualSpaceNode::initialize() {
+// Given a chunk c, split it recursively until you get a chunk of the given target_level.
+//
+// The resulting target chunk resides at the same address as the original chunk.
+// The resulting splinters are added to freelists.
+void VirtualSpaceNode::split(chunklevel_t target_level, Metachunk* c, FreeChunkListVector* freelists) {
+  assert_lock_strong(MetaspaceExpand_lock);
+  // Get the area associated with this chunk and let it handle the splitting
+  RootChunkArea* rca = _root_chunk_area_lut.get_area_by_address(c->base());
+  DEBUG_ONLY(rca->verify_area_is_ideally_merged();)
+  rca->split(target_level, c, freelists);
+}
 
-  if (!_rs.is_reserved()) {
+// Given a chunk, attempt to merge it recursively with its neighboring chunks.
+//
+// If successful (merged at least once), returns address of
+// the merged chunk; NULL otherwise.
+//
+// The merged chunks are removed from the freelists.
+//
+// !!! Please note that if this method returns a non-NULL value, the
+// original chunk will be invalid and should not be accessed anymore! !!!
+Metachunk* VirtualSpaceNode::merge(Metachunk* c, FreeChunkListVector* freelists) {
+  assert(c != NULL && c->is_free(), "Sanity");
+  assert_lock_strong(MetaspaceExpand_lock);
+
+  // Get the rca associated with this chunk and let it handle the merging
+  RootChunkArea* rca = _root_chunk_area_lut.get_area_by_address(c->base());
+  Metachunk* c2 = rca->merge(c, freelists);
+  DEBUG_ONLY(rca->verify_area_is_ideally_merged();)
+  return c2;
+}
+
+// Given a chunk c, which must be "in use" and must not be a root chunk, attempt to
+// enlarge it in place by claiming its trailing buddy.
+//
+// This will only work if c is the leader of the buddy pair and the trailing buddy is free.
+//
+// If successful, the follower chunk will be removed from the freelists, the leader chunk c will
+// double in size (level decreased by one).
+//
+// On success, true is returned, false otherwise.
+bool VirtualSpaceNode::attempt_enlarge_chunk(Metachunk* c, FreeChunkListVector* freelists) {
+  assert(c != NULL && c->is_in_use() && !c->is_root_chunk(), "Sanity");
+  assert_lock_strong(MetaspaceExpand_lock);
+
+  // Get the rca associated with this chunk and let it handle the merging
+  RootChunkArea* rca = _root_chunk_area_lut.get_area_by_address(c->base());
+
+  bool rc = rca->attempt_enlarge_chunk(c, freelists);
+  DEBUG_ONLY(rca->verify_area_is_ideally_merged();)
+  if (rc) {
+    InternalStats::inc_num_chunks_enlarged();
+  }
+
+  return rc;
+}
+
+// Attempts to purge the node:
+//
+// If all chunks living in this node are free, they will all be removed from
+//  the freelist they currently reside in. Then, the node will be deleted.
+//
+// Returns true if the node has been deleted, false if not.
+// !! If this returns true, do not access the node from this point on. !!
+bool VirtualSpaceNode::attempt_purge(FreeChunkListVector* freelists) {
+  assert_lock_strong(MetaspaceExpand_lock);
+
+  if (!_owns_rs) {
+    // We do not allow purging of nodes if we do not own the
+    // underlying ReservedSpace (CompressClassSpace case).
     return false;
   }
 
-  // These are necessary restriction to make sure that the virtual space always
+  // First find out if all areas are empty. Since empty chunks collapse to root chunk
-  // grows in steps of Metaspace::commit_alignment(). If both base and size are
+  // size, if all chunks in this node are free root chunks we are good to go.
-  // aligned only the middle alignment of the VirtualSpace is used.
+  if (!_root_chunk_area_lut.is_free()) {
-  assert_is_aligned(_rs.base(), Metaspace::commit_alignment());
+    return false;
-  assert_is_aligned(_rs.size(), Metaspace::commit_alignment());
-
-  // ReservedSpaces marked as special will have the entire memory
-  // pre-committed. Setting a committed size will make sure that
-  // committed_size and actual_committed_size agrees.
-  size_t pre_committed_size = _rs.special() ? _rs.size() : 0;
-
-  bool result = virtual_space()->initialize_with_granularity(_rs, pre_committed_size,
-      Metaspace::commit_alignment());
-  if (result) {
-    assert(virtual_space()->committed_size() == virtual_space()->actual_committed_size(),
-        "Checking that the pre-committed memory was registered by the VirtualSpace");
-
-    set_top((MetaWord*)virtual_space()->low());
   }
 
-  // Initialize Occupancy Map.
+  UL(debug, ": purging.");
-  const size_t smallest_chunk_size = is_class() ? ClassSpecializedChunk : SpecializedChunk;
-  _occupancy_map = new OccupancyMap(bottom(), reserved_words(), smallest_chunk_size);
 
-  return result;
+  // Okay, we can purge. Before we can do this, we need to remove all chunks from the freelist.
-}
+  for (int narea = 0; narea < _root_chunk_area_lut.number_of_areas(); narea++) {
-
+    RootChunkArea* ra = _root_chunk_area_lut.get_area_by_index(narea);
-void VirtualSpaceNode::print_on(outputStream* st, size_t scale) const {
+    Metachunk* c = ra->first_chunk();
-  size_t used_words = used_words_in_vs();
+    if (c != NULL) {
-  size_t commit_words = committed_words();
+      UL2(trace, "removing chunk from to-be-purged node: "
-  size_t res_words = reserved_words();
+          METACHUNK_FULL_FORMAT ".", METACHUNK_FULL_FORMAT_ARGS(c));
-  VirtualSpace* vs = virtual_space();
+      assert(c->is_free() && c->is_root_chunk(), "Sanity");
-
+      freelists->remove(c);
-  st->print("node @" PTR_FORMAT ": ", p2i(this));
-  st->print("reserved=");
-  print_scaled_words(st, res_words, scale);
-  st->print(", committed=");
-  print_scaled_words_and_percentage(st, commit_words, res_words, scale);
-  st->print(", used=");
-  print_scaled_words_and_percentage(st, used_words, res_words, scale);
-  st->cr();
-  st->print("   [" PTR_FORMAT ", " PTR_FORMAT ", "
-      PTR_FORMAT ", " PTR_FORMAT ")",
-      p2i(bottom()), p2i(top()), p2i(end()),
-      p2i(vs->high_boundary()));
-}
-
-#ifdef ASSERT
-void VirtualSpaceNode::mangle() {
-  size_t word_size = capacity_words_in_vs();
-  Copy::fill_to_words((HeapWord*) low(), word_size, 0xf1f1f1f1);
-}
-#endif // ASSERT
-
-void VirtualSpaceNode::retire(ChunkManager* chunk_manager) {
-  assert(is_class() == chunk_manager->is_class(), "Wrong ChunkManager?");
-#ifdef ASSERT
-  verify(false);
-  EVERY_NTH(VerifyMetaspaceInterval)
-    verify(true);
-  END_EVERY_NTH
-#endif
-  for (int i = (int)MediumIndex; i >= (int)ZeroIndex; --i) {
-    ChunkIndex index = (ChunkIndex)i;
-    size_t chunk_size = chunk_manager->size_by_index(index);
-
-    while (free_words_in_vs() >= chunk_size) {
-      Metachunk* chunk = get_chunk_vs(chunk_size);
-      // Chunk will be allocated aligned, so allocation may require
-      // additional padding chunks. That may cause above allocation to
-      // fail. Just ignore the failed allocation and continue with the
-      // next smaller chunk size. As the VirtualSpaceNode comitted
-      // size should be a multiple of the smallest chunk size, we
-      // should always be able to fill the VirtualSpace completely.
-      if (chunk == NULL) {
-        break;
-      }
-      chunk_manager->return_single_chunk(chunk);
     }
   }
-  assert(free_words_in_vs() == 0, "should be empty now");
+
+  // Now, delete the node, then right away return since this object is invalid.
+  delete this;
+
+  return true;
 }
 
+void VirtualSpaceNode::print_on(outputStream* st) const {
+  size_t scale = K;
+
+  st->print("base " PTR_FORMAT ": ", p2i(base()));
+  st->print("reserved=");
+  print_scaled_words(st, word_size(), scale);
+  st->print(", committed=");
+  print_scaled_words_and_percentage(st, committed_words(), word_size(), scale);
+  st->print(", used=");
+  print_scaled_words_and_percentage(st, used_words(), word_size(), scale);
+
+  st->cr();
+  _root_chunk_area_lut.print_on(st);
+  _commit_mask.print_on(st);
+}
+
+// Returns size, in words, of committed space in this node alone.
+// Note: iterates over commit mask and hence may be a tad expensive on large nodes.
+size_t VirtualSpaceNode::committed_words() const {
+  return _commit_mask.get_committed_size();
+}
+
+#ifdef ASSERT
+void VirtualSpaceNode::verify() const {
+  MutexLocker fcl(MetaspaceExpand_lock, Mutex::_no_safepoint_check_flag);
+  verify_locked();
+}
+
+volatile int test_access = 0;
+
+// Verify counters and basic structure. Slow mode: verify all chunks in depth
+void VirtualSpaceNode::verify_locked() const {
+  assert_lock_strong(MetaspaceExpand_lock);
+  assert(base() != NULL, "Invalid base");
+  assert(base() == (MetaWord*)_rs.base() &&
+         word_size() == _rs.size() / BytesPerWord,
+         "Sanity");
+  assert_is_aligned(base(), chunklevel::MAX_CHUNK_BYTE_SIZE);
+  assert(used_words() <= word_size(), "Sanity");
+  // Since we only ever hand out root chunks from a vsnode, top should always be aligned
+  // to root chunk size.
+  assert_is_aligned(used_words(), chunklevel::MAX_CHUNK_WORD_SIZE);
+
+  _commit_mask.verify();
+
+  // Verify memory against commit mask.
+  SOMETIMES(
+    for (MetaWord* p = base(); p < base() + used_words(); p += os::vm_page_size()) {
+      if (_commit_mask.is_committed_address(p)) {
+        test_access += *(int*)p;
+      }
+    }
+  )
+
+  assert(committed_words() <= word_size(), "Sanity");
+  assert_is_aligned(committed_words(), Settings::commit_granule_words());
+  _root_chunk_area_lut.verify();
+}
+
+#endif
+
 } // namespace metaspace

src/hotspot/share/memory/metaspace/virtualSpaceNode.hpp

@@ -1,5 +1,6 @@
 /*
- * Copyright (c) 2018, 2019, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2018, 2020, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2018, 2020 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
@@ -25,8 +26,14 @@
 #ifndef SHARE_MEMORY_METASPACE_VIRTUALSPACENODE_HPP
 #define SHARE_MEMORY_METASPACE_VIRTUALSPACENODE_HPP
 
-#include "memory/virtualspace.hpp"
+#include "memory/allocation.hpp"
 #include "memory/memRegion.hpp"
+#include "memory/metaspace/commitMask.hpp"
+#include "memory/metaspace/counters.hpp"
+#include "memory/metaspace/metaspaceSettings.hpp"
+#include "memory/metaspace/rootChunkArea.hpp"
+#include "memory/virtualspace.hpp"
+#include "utilities/bitMap.hpp"
 #include "utilities/debug.hpp"
 #include "utilities/globalDefinitions.hpp"
 
@@ -34,127 +41,246 @@ class outputStream;
 
 namespace metaspace {
 
-class Metachunk;
+class CommitLimiter;
-class ChunkManager;
+class FreeChunkListVector;
-class OccupancyMap;
+
+// VirtualSpaceNode manages a single contiguous address range of metaspace. Logically that memory
+//  region is split up into a sequence of "root chunk areas", each one containing one root chunk
+//  or splinters of a root chunk.
+//
+// The underlying memory is also logically divided into a number of "commit granules", units of memory
+//  which may be committed or uncommitted independently from each other.
+//
+// (Both root chunk areas and commit granules have not much to do with each other - one is a way to
+//   reserve memory for the upper regions, see ChunkManager. One is a way to manage commited memory.)
+//
+// VirtualSpaceNode:
+//  - exposes a function to allocate a new root chunk (see VirtualSpaceNode::allocate_root_chunk()).
+//
+//  - knows about the commit state of the memory region - which commit granule are committed, which
+//    are not. It exposes functions to commit and uncommit regions (without actively committing
+//    itself)
+//
+//  - It has a reference to a "CommitLimiter", an interface to query whether committing is
+//    possible. That interface hides the various ways committing may be limited (GC threshold,
+//    MaxMetaspaceSize, ...)
+//
+//  - It uses ReservedSpace to reserve its memory. It either owns the ReservedSpace or that
+//    space got handed in from outside (ccs).
+//
+//
+//
+//
+// | root chunk area               | root chunk area               | root chunk area               | <-- root chunk areas
+//
+// +-----------------------------------------------------------------------------------------------+
+// |                                                                                               |
+// |                                   `VirtualSpaceNode` memory                                   |
+// |                                                                                               |
+// +-----------------------------------------------------------------------------------------------+
+//
+// |x| |x|x|x| | | | |x|x|x| | | |x|x| | | |x|x|x|x| | | | | | | | |x| | | |x|x|x|x| | | |x| | | |x| <-- commit granules
+//
+// (x = committed)
+//
 
-// A VirtualSpaceList node.
 class VirtualSpaceNode : public CHeapObj<mtClass> {
-  friend class VirtualSpaceList;
 
   // Link to next VirtualSpaceNode
   VirtualSpaceNode* _next;
 
-  // Whether this node is contained in class or metaspace.
+  // The underlying space. This has been either created by this node
-  const bool _is_class;
+  //  and is owned by it, or has been handed in from outside (e.g. in
-
+  //  case of CompressedClassSpace).
-  // total in the VirtualSpace
   ReservedSpace _rs;
-  VirtualSpace _virtual_space;
-  MetaWord* _top;
-  // count of chunks contained in this VirtualSpace
-  uintx _container_count;
 
-  OccupancyMap* _occupancy_map;
+  // True if the node owns the reserved space, false if not.
+  const bool _owns_rs;
 
-  // Convenience functions to access the _virtual_space
+  // Start pointer of the area.
-  char* low()  const { return virtual_space()->low(); }
+  MetaWord* const _base;
-  char* high() const { return virtual_space()->high(); }
-  char* low_boundary()  const { return virtual_space()->low_boundary(); }
-  char* high_boundary() const { return virtual_space()->high_boundary(); }
 
-  // The first Metachunk will be allocated at the bottom of the
+  // Size, in words, of the whole node
-  // VirtualSpace
+  const size_t _word_size;
-  Metachunk* first_chunk() { return (Metachunk*) bottom(); }
 
-  // Committed but unused space in the virtual space
+  // Size, in words, of the range of this node which has been handed out in
-  size_t free_words_in_vs() const;
+  // the form of root chunks.
+  size_t _used_words;
 
-  // True if this node belongs to class metaspace.
+  // The bitmap describing the commit state of the region:
-  bool is_class() const { return _is_class; }
+  // Each bit covers a region of 64K (see constants::commit_granule_size).
+  CommitMask _commit_mask;
 
-  // Helper function for take_from_committed: allocate padding chunks
+  // An array/lookup table of RootChunkArea objects. Each one describes a root chunk area.
-  // until top is at the given address.
+  RootChunkAreaLUT _root_chunk_area_lut;
-  void allocate_padding_chunks_until_top_is_at(MetaWord* target_top);
 
- public:
+  // Limiter object to ask before expanding the committed size of this node.
+  CommitLimiter* const _commit_limiter;
+
+  // Points to outside size counters which we are to increase/decrease when we commit/uncommit
+  // space from this node.
+  SizeCounter* const _total_reserved_words_counter;
+  SizeCounter* const _total_committed_words_counter;
+
+  /// committing, uncommitting ///
+
+  // Given a pointer into this node, calculate the start of the commit granule
+  // the pointer points into.
+  MetaWord* calc_start_of_granule(MetaWord* p) const {
+    DEBUG_ONLY(check_pointer(p));
+    return align_down(p, Settings::commit_granule_bytes());
+  }
+
+  // Given an address range, ensure it is committed.
+  //
+  // The range has to be aligned to granule size.
+  //
+  // Function will:
+  // - check how many granules in that region are uncommitted; If all are committed, it
+  //    returns true immediately.
+  // - check if committing those uncommitted granules would bring us over the commit limit
+  //    (GC threshold, MaxMetaspaceSize). If true, it returns false.
+  // - commit the memory.
+  // - mark the range as committed in the commit mask
+  //
+  // Returns true if success, false if it did hit a commit limit.
+  bool commit_range(MetaWord* p, size_t word_size);
+
+  //// creation ////
+
+  // Create a new empty node spanning the given given reserved space.
+  VirtualSpaceNode(ReservedSpace rs, bool owns_rs, CommitLimiter* limiter,
+                   SizeCounter* reserve_counter, SizeCounter* commit_counter);
+
+public:
+
+  // Create a node of a given size (it will create its own space).
+  static VirtualSpaceNode* create_node(size_t word_size, CommitLimiter* limiter, SizeCounter* reserve_words_counter,
+                                       SizeCounter* commit_words_counter);
+
+  // Create a node over an existing space
+  static VirtualSpaceNode* create_node(ReservedSpace rs, CommitLimiter* limiter, SizeCounter* reserve_words_counter,
+                                       SizeCounter* commit_words_counter);
 
-  VirtualSpaceNode(bool is_class, size_t byte_size);
-  VirtualSpaceNode(bool is_class, ReservedSpace rs) :
-    _next(NULL), _is_class(is_class), _rs(rs), _top(NULL), _container_count(0), _occupancy_map(NULL) {}
   ~VirtualSpaceNode();
 
-  // Convenience functions for logical bottom and (committed) end
+  // Note: public for gtests only, could be private.
-  MetaWord* bottom() const { return (MetaWord*) _virtual_space.low(); }
+  MetaWord* base() const        { return _base; }
-  MetaWord* end() const { return (MetaWord*) _virtual_space.high(); }
 
-  const OccupancyMap* occupancy_map() const { return _occupancy_map; }
+  // Reserved size of the whole node.
-  OccupancyMap* occupancy_map() { return _occupancy_map; }
+  size_t word_size() const      { return _word_size; }
 
-  bool contains(const void* ptr) { return ptr >= low() && ptr < high(); }
+  //// Chunk allocation, splitting, merging /////
 
-  size_t reserved_words() const  { return _virtual_space.reserved_size() / BytesPerWord; }
+  // Allocate a root chunk from this node. Will fail and return NULL if the node is full
-  size_t committed_words() const { return _virtual_space.actual_committed_size() / BytesPerWord; }
+  //  - if we used up the whole address space of this node's memory region.
+  //    (in case this node backs compressed class space, this is how we hit
+  //     CompressedClassSpaceSize).
+  // Note that this just returns reserved memory; caller must take care of committing this
+  //  chunk before using it.
+  Metachunk* allocate_root_chunk();
 
-  bool is_pre_committed() const { return _virtual_space.special(); }
+  // Given a chunk c, split it recursively until you get a chunk of the given target_level.
+  //
+  // The resulting target chunk resides at the same address as the original chunk.
+  // The resulting splinters are added to freelists.
+  void split(chunklevel_t target_level, Metachunk* c, FreeChunkListVector* freelists);
 
-  // address of next available space in _virtual_space;
+  // Given a chunk, attempt to merge it recursively with its neighboring chunks.
-  // Accessors
+  //
-  VirtualSpaceNode* next() { return _next; }
+  // If successful (merged at least once), returns address of
-  void set_next(VirtualSpaceNode* v) { _next = v; }
+  // the merged chunk; NULL otherwise.
+  //
+  // The merged chunks are removed from the freelists.
+  //
+  // !!! Please note that if this method returns a non-NULL value, the
+  // original chunk will be invalid and should not be accessed anymore! !!!
+  Metachunk* merge(Metachunk* c, FreeChunkListVector* freelists);
 
-  void set_top(MetaWord* v) { _top = v; }
+  // Given a chunk c, which must be "in use" and must not be a root chunk, attempt to
+  // enlarge it in place by claiming its trailing buddy.
+  //
+  // This will only work if c is the leader of the buddy pair and the trailing buddy is free.
+  //
+  // If successful, the follower chunk will be removed from the freelists, the leader chunk c will
+  // double in size (level decreased by one).
+  //
+  // On success, true is returned, false otherwise.
+  bool attempt_enlarge_chunk(Metachunk* c, FreeChunkListVector* freelists);
 
-  // Accessors
+  // Attempts to purge the node:
-  VirtualSpace* virtual_space() const { return (VirtualSpace*) &_virtual_space; }
+  //
+  // If all chunks living in this node are free, they will all be removed from
+  //  the freelist they currently reside in. Then, the node will be deleted.
+  //
+  // Returns true if the node has been deleted, false if not.
+  // !! If this returns true, do not access the node from this point on. !!
+  bool attempt_purge(FreeChunkListVector* freelists);
 
-  // Returns true if "word_size" is available in the VirtualSpace
+  // Attempts to uncommit free areas according to the rules set in settings.
-  bool is_available(size_t word_size) { return word_size <= pointer_delta(end(), _top, sizeof(MetaWord)); }
+  // Returns number of words uncommitted.
+  size_t uncommit_free_areas();
 
-  MetaWord* top() const { return _top; }
+  /// misc /////
-  void inc_top(size_t word_size) { _top += word_size; }
 
-  uintx container_count() { return _container_count; }
+  // Returns size, in words, of the used space in this node alone.
-  void inc_container_count();
+  // (Notes:
-  void dec_container_count();
+  //  - This is the space handed out to the ChunkManager, so it is "used" from the viewpoint of this node,
+  //    but not necessarily used for Metadata.
+  //  - This may or may not be committed memory.
+  size_t used_words() const             { return _used_words; }
 
-  // used and capacity in this single entry in the list
+  // Returns size, in words, of how much space is left in this node alone.
-  size_t used_words_in_vs() const;
+  size_t free_words() const             { return _word_size - _used_words; }
-  size_t capacity_words_in_vs() const;
 
-  bool initialize();
+  // Returns size, in words, of committed space in this node alone.
+  // Note: iterates over commit mask and hence may be a tad expensive on large nodes.
+  size_t committed_words() const;
 
-  // get space from the virtual space
+  //// Committing/uncommitting memory /////
-  Metachunk* take_from_committed(size_t chunk_word_size);
 
-  // Allocate a chunk from the virtual space and return it.
+  // Given an address range, ensure it is committed.
-  Metachunk* get_chunk_vs(size_t chunk_word_size);
+  //
+  // The range does not have to be aligned to granule size. However, the function will always commit
+  // whole granules.
+  //
+  // Function will:
+  // - check how many granules in that region are uncommitted; If all are committed, it
+  //    returns true immediately.
+  // - check if committing those uncommitted granules would bring us over the commit limit
+  //    (GC threshold, MaxMetaspaceSize). If true, it returns false.
+  // - commit the memory.
+  // - mark the range as committed in the commit mask
+  //
+  // Returns true if success, false if it did hit a commit limit.
+  bool ensure_range_is_committed(MetaWord* p, size_t word_size);
 
-  // Expands the committed space by at least min_words words.
+  // Given an address range (which has to be aligned to commit granule size):
-  bool expand_by(size_t min_words, size_t preferred_words);
+  //  - uncommit it
+  //  - mark it as uncommitted in the commit mask
+  void uncommit_range(MetaWord* p, size_t word_size);
 
-  // In preparation for deleting this node, remove all the chunks
+  //// List stuff ////
-  // in the node from any freelist.
+  VirtualSpaceNode* next() const        { return _next; }
-  void purge(ChunkManager* chunk_manager);
+  void set_next(VirtualSpaceNode* vsn)  { _next = vsn; }
 
-  // If an allocation doesn't fit in the current node a new node is created.
+  /// Debug stuff ////
-  // Allocate chunks out of the remaining committed space in this node
-  // to avoid wasting that memory.
-  // This always adds up because all the chunk sizes are multiples of
-  // the smallest chunk size.
-  void retire(ChunkManager* chunk_manager);
 
-  void print_on(outputStream* st) const                 { print_on(st, K); }
+  // Print a description about this node.
-  void print_on(outputStream* st, size_t scale) const;
+  void print_on(outputStream* st) const;
-  void print_map(outputStream* st, bool is_class) const;
 
-  // Debug support
+  // Verify counters and basic structure. Slow mode: verify all chunks in depth
-  DEBUG_ONLY(void mangle();)
+  bool contains(const MetaWord* p) const {
-  // Verify counters and basic structure. Slow mode: verify all chunks in depth and occupancy map.
+    return p >= _base && p < _base + _used_words;
-  DEBUG_ONLY(void verify(bool slow);)
+  }
-  // Verify that all free chunks in this node are ideally merged
+
-  // (there should not be multiple small chunks where a large chunk could exist.)
+#ifdef ASSERT
-  DEBUG_ONLY(void verify_free_chunks_are_ideally_merged();)
+  void check_pointer(const MetaWord* p) const {
+    assert(contains(p), "invalid pointer");
+  }
+  void verify() const;
+  void verify_locked() const;
+#endif
 
 };
 

src/hotspot/share/memory/metaspaceChunkFreeListSummary.hpp

@@ -25,7 +25,9 @@
 #ifndef SHARE_MEMORY_METASPACECHUNKFREELISTSUMMARY_HPP
 #define SHARE_MEMORY_METASPACECHUNKFREELISTSUMMARY_HPP
 
+#include "utilities/globalDefinitions.hpp"
 
+// Todo: will need to rework this, see JDK-8251342
 class MetaspaceChunkFreeListSummary {
   size_t _num_specialized_chunks;
   size_t _num_small_chunks;

src/hotspot/share/memory/metaspaceClosure.hpp

@@ -105,7 +105,7 @@ public:
   //         Symbol*     bar() { return (Symbol*)    _obj; }
   //
   // [2] All Array<T> dimensions are statically declared.
-  class Ref : public CHeapObj<mtInternal> {
+  class Ref : public CHeapObj<mtMetaspace> {
     Writability _writability;
     bool _keep_after_pushing;
     Ref* _next;

src/hotspot/share/memory/metaspaceCounters.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012, 2013, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2012, 2020, 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
@@ -29,7 +29,7 @@
 #include "runtime/perfData.hpp"
 #include "utilities/exceptions.hpp"
 
-class MetaspacePerfCounters: public CHeapObj<mtInternal> {
+class MetaspacePerfCounters: public CHeapObj<mtMetaspace> {
   friend class VMStructs;
   PerfVariable*      _capacity;
   PerfVariable*      _used;