stan/jdk-24
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

8251158: Implementation of JEP 387: Elastic Metaspace

Browse Source 
Reviewed-by: lkorinth, coleenp, iklam, rrich
This commit is contained in:
Thomas Stuefe 2020-10-20 06:48:09 +00:00
parent 5fedfa707e
commit 7ba6a6bf00
167 changed files with 15749 additions and 7987 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
src/hotspot/share/classfile/classLoaderData.cpp
View File

@ -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");

1
src/hotspot/share/classfile/classLoaderData.hpp
View File

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

18
src/hotspot/share/classfile/classLoaderDataGraph.cpp
View File

@ -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()) {

8
src/hotspot/share/classfile/classLoaderDataGraph.hpp
View File

@ -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

15
src/hotspot/share/classfile/classLoaderStats.cpp
View File

@ -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_block_sz += ms->allocated_blocks_bytes();
cls->_hidden_chunk_sz += capacity_bytes;
cls->_hidden_block_sz += used_bytes;
} else {
cls->_chunk_sz = ms->allocated_chunks_bytes();
cls->_block_sz = ms->allocated_blocks_bytes();
cls->_chunk_sz = capacity_bytes;
cls->_block_sz = used_bytes;
}
_total_chunk_sz += ms->allocated_chunks_bytes();
_total_block_sz += ms->allocated_blocks_bytes();
_total_chunk_sz += capacity_bytes;
_total_block_sz += used_bytes;
}
}

2
src/hotspot/share/gc/g1/g1CollectedHeap.cpp
View File

@ -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");

2
src/hotspot/share/gc/parallel/psParallelCompact.cpp
View File

@ -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();

2
src/hotspot/share/gc/shared/collectedHeap.cpp
View File

@ -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"

1
src/hotspot/share/gc/shared/gcVMOperations.cpp
View File

@ -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"

1
src/hotspot/share/gc/shared/gcVMOperations.hpp
View File

@ -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"

3
src/hotspot/share/gc/shared/genCollectedHeap.cpp
View File

@ -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();

3
src/hotspot/share/gc/shared/generationSpec.cpp
View File

@ -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"

14
src/hotspot/share/gc/shared/jvmFlagConstraintsGC.cpp
View File

@ -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));

1
src/hotspot/share/gc/shared/jvmFlagConstraintsGC.hpp
View File

@ -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) \

4
src/hotspot/share/gc/shenandoah/shenandoahHeap.cpp
View File

@ -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),

1
src/hotspot/share/gc/shenandoah/shenandoahHeap.hpp
View File

@ -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"

2
src/hotspot/share/gc/shenandoah/shenandoahUnload.cpp
View File

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

1
src/hotspot/share/gc/z/zCollectedHeap.cpp
View File

@ -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"

1
src/hotspot/share/gc/z/zCollectedHeap.hpp
View File

@ -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;

3
src/hotspot/share/gc/z/zStat.cpp
View File

@ -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);
}

2
src/hotspot/share/gc/z/zUnload.cpp
View File

@ -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();)
}

2
src/hotspot/share/jfr/recorder/checkpoint/types/jfrType.cpp
View File

@ -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"

1
src/hotspot/share/jvmci/jvmciCompilerToVM.hpp
View File

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

1
src/hotspot/share/memory/allocation.hpp
View File

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

393
src/hotspot/share/memory/binaryTreeDictionary.hpp
View File

@ -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

1004
src/hotspot/share/memory/binaryTreeDictionary.inline.hpp
View File

File diff suppressed because it is too large Load Diff

187
src/hotspot/share/memory/classLoaderMetaspace.cpp Normal file
View File

@ -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;
}
}

111
src/hotspot/share/memory/classLoaderMetaspace.hpp Normal file
View File

@ -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

175
src/hotspot/share/memory/freeList.hpp
View File

@ -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

330
src/hotspot/share/memory/freeList.inline.hpp
View File

@ -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

1
src/hotspot/share/memory/metadataFactory.hpp
View File

@ -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"

1235
src/hotspot/share/memory/metaspace.cpp
View File

File diff suppressed because it is too large Load Diff

390
src/hotspot/share/memory/metaspace.hpp
View File

@ -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"
// 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 | |
// ||---------- |
// || |
// |-------------------|
// | |
// | |
// +-------------------+
//
#include "utilities/globalDefinitions.hpp"
class ClassLoaderData;
class MetaspaceShared;
class MetaspaceTracer;
class Mutex;
class outputStream;
class CollectedHeap;
namespace metaspace {
class ChunkManager;
class ClassLoaderMetaspaceStatistics;
class Metablock;
class Metachunk;
class PrintCLDMetaspaceInfoClosure;
class SpaceManager;
class VirtualSpaceList;
class VirtualSpaceNode;
class MetaspaceSizesSnapshot;
}
// Metaspaces each have a SpaceManager and allocations
// 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.
////////////////// Metaspace ///////////////////////
// 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:
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();
}
public:
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; }
static size_t first_class_chunk_word_size() { return _first_class_chunk_word_size; }
// The granularity at which Metaspace is committed and uncommitted.
// (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; }
static size_t reserve_alignment_words() { return _reserve_alignment / BytesPerWord; }
static size_t commit_alignment() { return _commit_alignment; }
static size_t commit_alignment_words() { return _commit_alignment / BytesPerWord; }
// The largest possible single allocation
static size_t max_allocation_word_size();
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
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();
};
////////////////// MetaspaceGC ///////////////////////
// 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

116
src/hotspot/share/memory/metaspace/allocationGuard.hpp Normal file
View File

@ -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

200
src/hotspot/share/memory/metaspace/binList.hpp Normal file
View File

@ -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

109
src/hotspot/share/memory/metaspace/blockFreelist.cpp
View File

@ -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

92
src/hotspot/share/memory/metaspace/blockFreelist.hpp
View File

@ -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

198
src/hotspot/share/memory/metaspace/blockTree.cpp Normal file
View File

@ -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

379
src/hotspot/share/memory/metaspace/blockTree.hpp Normal file
View File

@ -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

92
src/hotspot/share/memory/metaspace/chunkHeaderPool.cpp Normal file
View File

@ -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

135
src/hotspot/share/memory/metaspace/chunkHeaderPool.hpp Normal file
View File

@ -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

928
src/hotspot/share/memory/metaspace/chunkManager.cpp
View File

@ -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)
: _is_class(is_class), _free_chunks_total(0), _free_chunks_count(0) {
_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));
_free_chunks[MediumIndex].set_size(get_size_for_nonhumongous_chunktype(MediumIndex, is_class));
#define LOGFMT "ChkMgr @" PTR_FORMAT " (%s)"
#define LOGFMT_ARGS p2i(this), this->_name
// Return a single chunk to the freelist and adjust accounting. No merge is attempted.
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) {
size_t word_size = chunk->word_size();
ChunkIndex index = list_index(word_size);
if (index != HumongousIndex) {
free_chunks(index)->remove_chunk(chunk);
// 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::ChunkManager(const char* name, VirtualSpaceList* space_list) :
_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");
}
// Chunk has been removed from the chunks free list, update counters.
account_for_removed_chunk(chunk);
}
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 ++;
c->verify();
verify_locked();
SOMETIMES(c->vsnode()->verify_locked();)
#endif
return true;
InternalStats::inc_num_chunk_splits();
}
// Remove all chunks in the given area - the chunks are supposed to be free -
// from their corresponding freelists. 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 ChunkManager::remove_chunks_in_area(MetaWord* p, size_t word_size) {
assert(p != NULL && word_size > 0, "Invalid range.");
const size_t smallest_chunk_size = get_size_for_nonhumongous_chunktype(SpecializedIndex, is_class());
assert_is_aligned(word_size, smallest_chunk_size);
// On success, returns a chunk of level of <preferred_level>, but at most <max_level>.
// The first 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* 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;
const Metachunk* const end = (Metachunk*)(p + word_size);
Metachunk* cur = start;
int num_removed = 0;
while (cur < end) {
Metachunk* next = (Metachunk*)(((MetaWord*)cur) + cur->word_size());
DEBUG_ONLY(do_verify_chunk(cur));
assert(cur->get_chunk_type() != HumongousIndex, "Unexpected humongous chunk found at %p.", cur);
assert(cur->is_tagged_free(), "Chunk expected to be free (%p)", cur);
log_trace(gc, metaspace, freelist)("%s: removing chunk %p, size " SIZE_FORMAT_HEX ".",
(is_class() ? "class space" : "metaspace"),
cur, cur->word_size() * sizeof(MetaWord));
cur->remove_sentinel();
// Note: cannot call ChunkManager::remove_chunk, because that
// modifies the counters in ChunkManager, which we do not want. So
// we call remove_chunk on the freelist directly (see also the
// splitting function which does the same).
ChunkList* const list = free_chunks(list_index(cur->word_size()));
list->remove_chunk(cur);
num_removed ++;
cur = next;
MutexLocker fcl(MetaspaceExpand_lock, Mutex::_no_safepoint_check_flag);
DEBUG_ONLY(verify_locked();)
DEBUG_ONLY(chunklevel::check_valid_level(max_level);)
DEBUG_ONLY(chunklevel::check_valid_level(preferred_level);)
UL2(debug, "requested chunk: pref_level: " CHKLVL_FORMAT
", max_level: " CHKLVL_FORMAT ", min committed size: " SIZE_FORMAT ".",
preferred_level, max_level, min_committed_words);
// First, optimistically look for a chunk which is already committed far enough to hold min_word_size.
// 1) Search best or smaller committed chunks (first attempt):
// Start at the preferred chunk size and work your way down (level up).
// But for now, only consider chunks larger than a certain threshold -
// this is to prevent large loaders (eg boot) from unnecessarily gobbling up
// all the tiny splinter chunks lambdas leave around.
Metachunk* c = NULL;
c = _chunks.search_chunk_ascending(preferred_level, MIN2((chunklevel_t)(preferred_level + 2), max_level), min_committed_words);
// 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
void ChunkManager::account_for_added_chunk(const Metachunk* c) {
// Return a single chunk to the ChunkManager and adjust accounting. May merge chunk
// 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 ++;
_free_chunks_total += c->word_size();
UL2(debug, ": returning chunk " METACHUNK_FORMAT ".", METACHUNK_FORMAT_ARGS(c));
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
void ChunkManager::account_for_removed_chunk(const Metachunk* c) {
assert_lock_strong(MetaspaceExpand_lock);
assert(_free_chunks_count >= 1,
"ChunkManager::_free_chunks_count: about to go negative (" SIZE_FORMAT ").", _free_chunks_count);
assert(_free_chunks_total >= c->word_size(),
"ChunkManager::_free_chunks_total: about to go negative"
"(now: " SIZE_FORMAT ", decrement value: " SIZE_FORMAT ").", _free_chunks_total, c->word_size());
_free_chunks_count --;
_free_chunks_total -= c->word_size();
// Given a chunk c, whose state 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 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) {
return get_chunk_type_by_size(size, is_class());
static void print_word_size_delta(outputStream* st, size_t word_size_1, size_t word_size_2) {
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 {
index_bounds_check(index);
assert(index != HumongousIndex, "Do not call for humongous chunks.");
return get_size_for_nonhumongous_chunktype(index, is_class());
}
void ChunkManager::purge() {
MutexLocker fcl(MetaspaceExpand_lock, Mutex::_no_safepoint_check_flag);
UL(info, ": reclaiming memory...");
#ifdef ASSERT
void ChunkManager::verify(bool slow) const {
MutexLocker cl(MetaspaceExpand_lock,
Mutex::_no_safepoint_check_flag);
locked_verify(slow);
}
const size_t reserved_before = _vslist->reserved_words();
const size_t committed_before = _vslist->committed_words();
int num_nodes_purged = 0;
void ChunkManager::locked_verify(bool slow) const {
log_trace(gc, metaspace, freelist)("verifying %s chunkmanager (%s).",
(is_class() ? "class space" : "metaspace"), (slow ? "slow" : "quick"));
// We purge to return unused memory to the Operating System. We do this in
// two independent steps.
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;
size_t wordsize_chunks_counted = 0;
for (ChunkIndex i = ZeroIndex; i < NumberOfFreeLists; i = next_chunk_index(i)) {
const ChunkList* list = _free_chunks + i;
if (list != NULL) {
Metachunk* chunk = list->head();
while (chunk) {
if (slow) {
do_verify_chunk(chunk);
}
assert(chunk->is_tagged_free(), "Chunk should be tagged as free.");
chunks_counted ++;
wordsize_chunks_counted += chunk->size();
chunk = chunk->next();
// 2) Since (1) is rather ineffective - it is rare that a whole node only contains
// free chunks - we now iterate over all remaining free chunks and
// and uncommit those which can be uncommitted (>= commit granule size).
if (Settings::uncommit_free_chunks()) {
const chunklevel_t max_level =
chunklevel::level_fitting_word_size(Settings::commit_granule_words());
for (chunklevel_t l = chunklevel::LOWEST_CHUNK_LEVEL;
l <= max_level;
l++) {
// Since we uncommit all chunks at this level, we do not break the "committed chunks are
// at the front of the list" condition.
for (Metachunk* c = _chunks.first_at_level(l); c != NULL; c = c->next()) {
c->uncommit_locked();
}
}
}
chunks_counted += humongous_dictionary()->total_free_blocks();
wordsize_chunks_counted += humongous_dictionary()->total_size();
const size_t reserved_after = _vslist->reserved_words();
const size_t committed_after = _vslist->committed_words();
assert(chunks_counted == _free_chunks_count && wordsize_chunks_counted == _free_chunks_total,
"freelist accounting mismatch: "
"we think: " SIZE_FORMAT " chunks, total " SIZE_FORMAT " words, "
"reality: " SIZE_FORMAT " chunks, total " SIZE_FORMAT " words.",
_free_chunks_count, _free_chunks_total,
chunks_counted, wordsize_chunks_counted);
// Print a nice report.
if (reserved_after == reserved_before && committed_after == committed_before) {
UL(info, "nothing reclaimed.");
} else {
LogTarget(Info, metaspace) lt;
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,
_free_chunks_total, _free_chunks_count);
}
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));
}
st->print_cr("cm %s: %d chunks, total word size: " SIZE_FORMAT ", committed word size: " SIZE_FORMAT, _name,
total_num_chunks(), total_word_size(), _chunks.committed_word_size());
_chunks.print_on(st);
}
} // namespace metaspace

258
src/hotspot/share/memory/metaspace/chunkManager.hpp
View File

@ -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/freeList.hpp"
#include "memory/metaspace/chunklevel.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;
typedef BinaryTreeDictionary<Metachunk, FreeList<Metachunk> > ChunkTreeDictionary;
class VirtualSpaceList;
struct ChunkManagerStats;
// Manages the global free lists of chunks.
class ChunkManager : public CHeapObj<mtInternal> {
friend class ::ChunkManagerTestAccessor;
// ChunkManager has a somewhat central role.
// Free list of chunks of different sizes.
// SpecializedChunk
// SmallChunk
// MediumChunk
ChunkList _free_chunks[NumberOfFreeLists];
// Arenas request chunks from it and, on death, return chunks back to it.
// It keeps freelists for chunks, one per chunk level, sorted by chunk
// commit state.
// To feed the freelists, it allocates root chunks from the associated
// 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.
const bool _is_class;
class ChunkManager : public CHeapObj<mtMetaspace> {
// Return non-humongous chunk list by its index.
ChunkList* free_chunks(ChunkIndex index);
// A chunk manager is connected to a virtual space list which is used
// 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.
ChunkList* find_free_chunks_list(size_t word_size);
// Name
const char* const _name;
// HumongousChunk
ChunkTreeDictionary _humongous_dictionary;
// Freelists
FreeChunkListVector _chunks;
// Returns the humongous chunk dictionary.
ChunkTreeDictionary* humongous_dictionary() { return &_humongous_dictionary; }
const ChunkTreeDictionary* humongous_dictionary() const { return &_humongous_dictionary; }
// Returns true if this manager contains the given chunk. Slow (walks free lists) and
// only needed for verifications.
DEBUG_ONLY(bool contains_chunk(Metachunk* c) const;)
// Size, in metaspace words, of all chunks managed by this ChunkManager
size_t _free_chunks_total;
// Number of chunks in this ChunkManager
size_t _free_chunks_count;
// Given a chunk, split it into a target chunk of a smaller size (target level)
// at least one, possible more splinter chunks. Splinter chunks are added to the
// freelist.
// 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.
void account_for_added_chunk(const Metachunk* c);
void account_for_removed_chunk(const Metachunk* c);
// See get_chunk(s,s,s)
Metachunk* get_chunk_locked(size_t preferred_word_size, size_t min_word_size, size_t min_committed_words);
// Given a pointer to a chunk, attempts to merge it with neighboring
// free chunks to form a bigger chunk. Returns true if successful.
bool attempt_to_coalesce_around_chunk(Metachunk* chunk, ChunkIndex target_chunk_type);
// Uncommit all chunks equal or below the given level.
void uncommit_free_chunks(chunklevel_t max_level);
// Helper for chunk merging:
// Given an address range with 1-n chunks which are all supposed to be
// 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);
// Return a single chunk to the freelist without doing any merging, and adjust accounting.
void return_chunk_simple_locked(Metachunk* c);
// 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* split_chunk(size_t target_chunk_word_size, Metachunk* chunk);
// See return_chunk().
void return_chunk_locked(Metachunk* c);
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.
Metachunk* chunk_freelist_allocate(size_t word_size);
// On success, returns a chunk of level of <preferred_level>, but at most <max_level>.
// 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
// for special, small, medium, and humongous chunks.
ChunkIndex list_index(size_t size);
// Convenience function - get a chunk of a given level, uncommitted.
Metachunk* get_chunk(chunklevel_t lvl) { return get_chunk(lvl, lvl, 0); }
// Map a given index to the chunk size.
size_t size_by_index(ChunkIndex index) const;
// Return a single chunk to the ChunkManager and adjust accounting. May merge chunk
// 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.
size_t medium_chunk_word_size() const { return size_by_index(MediumIndex); }
size_t small_chunk_word_size() const { return size_by_index(SmallIndex); }
size_t specialized_chunk_word_size() const { return size_by_index(SpecializedIndex); }
// Attempt to reclaim free areas in metaspace wholesale:
// - first, attempt to purge nodes of the backing virtual space list: nodes which are completely
// unused get unmapped and deleted completely.
// - 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
// the chunk manager (the freelist if non-humongous, the dictionary if
// humongous).
void remove_chunk(Metachunk* chunk);
// Run verifications. slow=true: verify chunk-internal integrity too.
DEBUG_ONLY(void verify() const;)
DEBUG_ONLY(void verify_locked() const;)
// Return a single chunk of type index to the ChunkManager.
void return_single_chunk(Metachunk* chunk);
// Returns the name of this chunk manager.
const char* name() const { return _name; }
// Add the simple linked list of chunks to the freelist of chunks
// of type index.
void return_chunk_list(Metachunk* chunk);
// Returns total number of chunks
int total_num_chunks() const { return _chunks.num_chunks(); }
// Total of the space in the free chunks list
size_t free_chunks_total_words() const { return _free_chunks_total; }
size_t free_chunks_total_bytes() const { return free_chunks_total_words() * BytesPerWord; }
// Returns number of words in all free chunks (regardless of commit state).
size_t total_word_size() const { return _chunks.word_size(); }
// Number of chunks in the free chunks list
size_t free_chunks_count() const { return _free_chunks_count; }
// Returns number of committed words in all free chunks.
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.
Metachunk* free_chunks_get(size_t chunk_word_size);
// Update statistics.
void add_to_statistics(ChunkManagerStats* out) const;
#define index_bounds_check(index) \
assert(is_valid_chunktype(index), "Bad index: %d", (int) index)
void print_on(outputStream* st) const;
void print_on_locked(outputStream* st) const;
size_t num_free_chunks(ChunkIndex index) const {
index_bounds_check(index);
if (index == HumongousIndex) {
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;
// Convenience methods to return the global class-space chunkmanager
// and non-class chunkmanager, respectively.
static ChunkManager* chunkmanager_class();
static ChunkManager* chunkmanager_nonclass();
};
} // namespace metaspace
#endif // SHARE_MEMORY_METASPACE_CHUNKMANAGER_HPP

45
src/hotspot/share/memory/metaspace/metaDebug.cpp → src/hotspot/share/memory/metaspace/chunklevel.cpp
View File

@ -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/metaDebug.hpp"
#include "runtime/os.hpp"
#include "runtime/thread.hpp"
#include "memory/metaspace/chunklevel.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() {
if (MetadataAllocationFailALot) {
_allocation_fail_alot_count =
1+(long)((double)MetadataAllocationFailALotInterval*os::random()/(max_jint+1.0));
chunklevel_t chunklevel::level_fitting_word_size(size_t word_size) {
assert(MAX_CHUNK_WORD_SIZE >= word_size,
SIZE_FORMAT " - too large allocation size.", word_size * BytesPerWord);
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
bool Metadebug::test_metadata_failure() {
if (MetadataAllocationFailALot &&
Threads::is_vm_complete()) {
if (_allocation_fail_alot_count > 0) {
_allocation_fail_alot_count--;
void chunklevel::print_chunk_size(outputStream* st, chunklevel_t lvl) {
if (chunklevel::is_valid_level(lvl)) {
const size_t s = chunklevel::word_size_for_level(lvl) * BytesPerWord;
if (s < 1 * M) {
st->print("%3uk", (unsigned)(s / K));
} else {
log_trace(gc, metaspace, freelist)("Metadata allocation failing for MetadataAllocationFailALot");
init_allocation_fail_alot_count();
return true;
st->print("%3um", (unsigned)(s / M));
}
} else {
st->print("?-?");
}
return false;
}
#endif
} // namespace metaspace

130
src/hotspot/share/memory/metaspace/chunklevel.hpp Normal file
View File

@ -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

48
src/hotspot/share/memory/metaspace/smallBlocks.cpp → src/hotspot/share/memory/metaspace/commitLimiter.cpp
View File

@ -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 {
st->print_cr("SmallBlocks:");
for (uint i = _small_block_min_size; i < _small_block_max_size; i++) {
uint k = i - _small_block_min_size;
st->print_cr("small_lists size " SIZE_FORMAT " count " SIZE_FORMAT, _small_lists[k].size(), _small_lists[k].count());
// 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 CommitLimiter::possible_expansion_words() const {
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.
size_t SmallBlocks::total_size() const {
size_t 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() * _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;
// Returns the global metaspace commit counter
CommitLimiter* CommitLimiter::globalLimiter() {
return &g_global_limiter;
}
} // namespace metaspace

84
src/hotspot/share/memory/metaspace/commitLimiter.hpp Normal file
View File

@ -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

97
src/hotspot/share/memory/metaspace/commitMask.cpp Normal file
View File

@ -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

165
src/hotspot/share/memory/metaspace/commitMask.hpp Normal file
View File

@ -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

173
src/hotspot/share/memory/metaspace/counters.hpp Normal file
View File

@ -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

64
src/hotspot/share/memory/metaspace/freeBlocks.cpp Normal file
View File

@ -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

113
src/hotspot/share/memory/metaspace/freeBlocks.hpp Normal file
View File

@ -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

173
src/hotspot/share/memory/metaspace/freeChunkList.cpp Normal file
View File

@ -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

270
src/hotspot/share/memory/metaspace/freeChunkList.hpp Normal file
View File

@ -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

39
src/hotspot/share/memory/metaspace/metablock.hpp → src/hotspot/share/memory/metaspace/internalStats.cpp
View File

@ -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
#define SHARE_MEMORY_METASPACE_METABLOCK_HPP
#include "memory/metaspace/metabase.hpp"
#include "precompiled.hpp"
#include "memory/metaspace/internalStats.hpp"
#include "utilities/globalDefinitions.hpp"
#include "utilities/ostream.hpp"
namespace metaspace {
// Metablock is the unit of allocation from a Chunk.
//
// A Metablock may be reused by its SpaceManager but are never moved between
// SpaceManagers. There is no explicit link to the Metachunk
// from which it was allocated. Metablock may be deallocated and
// 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.
#define MATERIALIZE_COUNTER(name) uintx InternalStats::_##name;
#define MATERIALIZE_ATOMIC_COUNTER(name) volatile uintx InternalStats::_##name;
ALL_MY_COUNTERS(MATERIALIZE_COUNTER, MATERIALIZE_ATOMIC_COUNTER)
#undef MATERIALIZE_COUNTER
#undef MATERIALIZE_ATOMIC_COUNTER
class Metablock : public Metabase<Metablock> {
friend class VMStructs;
public:
Metablock(size_t word_size) : Metabase<Metablock>(word_size) {}
};
void InternalStats::print_on(outputStream* st) {
#define xstr(s) str(s)
#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

127
src/hotspot/share/memory/metaspace/internalStats.hpp Normal file
View File

@ -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

80
src/hotspot/share/memory/metaspace/metabase.hpp
View File

@ -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

369
src/hotspot/share/memory/metaspace/metachunk.cpp
View File

@ -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() {
// Must align pointers and sizes to 8,
// so that 64 bit types get correctly aligned.
const size_t alignment = 8;
// Make sure that the Klass alignment also agree.
STATIC_ASSERT(alignment == (size_t)KlassAlignmentInBytes);
return alignment;
// Return a single char presentation of the state ('f', 'u', 'd')
char Metachunk::get_state_char() const {
switch (_state) {
case State::Free: return 'f';
case State::InUse: return 'u';
case State::Dead: return 'd';
}
return '?';
}
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);
verify();
void Metachunk::assert_have_expand_lock() {
assert_lock_strong(MetaspaceExpand_lock);
}
#endif
}
MetaWord* Metachunk::allocate(size_t word_size) {
MetaWord* result = NULL;
// If available, bump the pointer to allocate.
if (free_word_size() >= word_size) {
result = _top;
_top = _top + word_size;
// Commit uncommitted section of the chunk.
// Fails if we hit a commit limit.
bool Metachunk::commit_up_to(size_t new_committed_words) {
// Please note:
//
// 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.
size_t Metachunk::used_word_size() const {
return pointer_delta(_top, bottom(), sizeof(MetaWord));
}
// We should hold the expand lock at this point.
assert_lock_strong(MetaspaceExpand_lock);
size_t Metachunk::free_word_size() const {
return pointer_delta(end(), _top, sizeof(MetaWord));
}
void Metachunk::print_on(outputStream* st) const {
st->print_cr("Metachunk:"
" bottom " PTR_FORMAT " top " PTR_FORMAT
" end " PTR_FORMAT " size " SIZE_FORMAT " (%s)",
p2i(bottom()), p2i(_top), p2i(end()), word_size(),
chunk_size_name(get_chunk_type()));
if (Verbose) {
st->print_cr(" used " SIZE_FORMAT " free " SIZE_FORMAT,
used_word_size(), free_word_size());
const size_t commit_from = _committed_words;
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");
if (commit_to > commit_from) {
log_debug(metaspace)("Chunk " METACHUNK_FORMAT ": attempting to move commit line to "
SIZE_FORMAT " words.", METACHUNK_FORMAT_ARGS(this), commit_to);
if (!_vsnode->ensure_range_is_committed(base() + commit_from, commit_to - commit_from)) {
DEBUG_ONLY(verify();)
return false;
}
}
// 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
// maintain list of chunks.
HeapWord* start = (HeapWord*)initial_top();
size_t size = word_size() - overhead();
Copy::fill_to_words(start, size, word_value);
// Zap this structure.
void Metachunk::zap_header(uint8_t c) {
memset(this, c, sizeof(Metachunk));
}
// 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));
const ChunkIndex chunk_type = get_chunk_type();
assert(is_valid_chunktype(chunk_type), "Chunk " PTR_FORMAT ": Invalid chunk type.", p2i(this));
if (chunk_type != HumongousIndex) {
assert(word_size() == get_size_for_nonhumongous_chunktype(chunk_type, is_class()),
"Chunk " PTR_FORMAT ": wordsize " SIZE_FORMAT " does not fit chunk type %s.",
p2i(this), word_size(), chunk_size_name(chunk_type));
// Note. This should be called under CLD lock protection.
// We can verify everything except the _prev_in_vs/_next_in_vs pair.
// This is because neighbor chunks may be added concurrently, so we cannot rely
// on the content of _next_in_vs/_prev_in_vs unless we have the expand lock.
assert(!is_dead(), "Do not call on dead chunks.");
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
// to its chunk size. Humongous chunks start address is
// aligned to specialized chunk size.
const size_t required_alignment =
(chunk_type != HumongousIndex ? word_size() : get_size_for_nonhumongous_chunktype(SpecializedIndex, is_class())) * sizeof(MetaWord);
assert(is_aligned((address)this, required_alignment),
"Chunk " PTR_FORMAT ": (size " SIZE_FORMAT ") not aligned to " SIZE_FORMAT ".",
p2i(this), word_size() * sizeof(MetaWord), required_alignment);
// Note: only call this on a life Metachunk.
chunklevel::check_valid_level(level());
assert(base() != NULL, "No base ptr");
assert(committed_words() >= used_words(),
"mismatch: committed: " SIZE_FORMAT ", used: " SIZE_FORMAT ".",
committed_words(), used_words());
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.
const char* chunk_size_name(ChunkIndex index) {
switch (index) {
case SpecializedIndex:
return "specialized";
case SmallIndex:
return "small";
case MediumIndex:
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);
void Metachunk::print_on(outputStream* st) const {
// Note: must also work with invalid/random data. (e.g. do not call word_size())
st->print("Chunk @" PTR_FORMAT ", state %c, base " PTR_FORMAT ", "
"level " CHKLVL_FORMAT " (" SIZE_FORMAT " words), "
"used " SIZE_FORMAT " words, committed " SIZE_FORMAT " words.",
p2i(this), get_state_char(), p2i(base()), level(),
(chunklevel::is_valid_level(level()) ? chunklevel::word_size_for_level(level()) : (size_t)-1),
used_words(), committed_words());
}
} // namespace metaspace

411
src/hotspot/share/memory/metaspace/metachunk.hpp
View File

@ -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/metaspaceCommon.hpp"
#include "memory/metaspace/chunklevel.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
// Metachunks are reused (when freed are put on a global freelist) and
// have no permanent association to a SpaceManager.
// A Metachunk is a contiguous metaspace memory region. It is used by
// a MetaspaceArena to allocate from via pointer bump (somewhat similar
// 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 --+ --+
// | | | |
// | | | free |
// | | | |
// | | | | size | capacity
// | | | |
// | | <- top -- + |
// | | | |
// | | | used |
// | | | |
// | | | |
// +--------------+ <- bottom --+ --+
// +--------------+ <- end -----------+ ----------+
// | | | |
// | | | |
// | | | |
// | | | |
// | | | |
// | ----------- | <- committed_top -- + |
// | | | |
// | | | "free" |
// | | | | size
// | | "free_below_ | |
// | | 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 {
// 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,
class Metachunk {
origin_minimum = origin_normal,
origin_maximum = origin_split,
origins_count = origin_maximum + 1
};
// start of chunk memory; NULL if dead.
MetaWord* _base;
inline bool is_valid_chunkorigin(ChunkOrigin origin) {
return origin == origin_normal ||
origin == origin_pad ||
origin == origin_leftover ||
origin == origin_merge ||
origin == origin_split;
}
// Used words.
size_t _used_words;
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.
VirtualSpaceNode* const _container;
// Current allocation top.
MetaWord* _top;
// A 32bit sentinel for debugging purposes.
enum { CHUNK_SENTINEL = 0x4d4554EF, // "MET"
CHUNK_SENTINEL_INVALID = 0xFEEEEEEF
// state_free: free, owned by a ChunkManager
// state_in_use: in-use, owned by a MetaspaceArena
// dead: just a hollow chunk header without associated memory, owned
// by chunk header pool.
enum class State : uint8_t {
Free = 0,
InUse = 1,
Dead = 2
};
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;
const bool _is_class;
// Whether the chunk is free (in freelist) or in use by some class loader.
bool _is_tagged_free;
// A chunk header is kept in a list:
// 1 in the list of used chunks inside a MetaspaceArena, if it is in use
// 2 in the list of free chunks inside a ChunkManager, if it is 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;
int _use_count;
// Furthermore, we keep, per chunk, information about the neighboring chunks.
// 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(); }
MetaWord* top() const { return _top; }
// Commit uncommitted section of the chunk.
// Fails if we hit a commit limit.
bool commit_up_to(size_t new_committed_words);
public:
// 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.
DEBUG_ONLY(static void assert_have_expand_lock();)
// Alignment of each allocation in the chunks.
static size_t object_alignment();
public:
// Size of the Metachunk header, in words, including alignment.
static size_t overhead();
Metachunk() :
_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.
void reset_empty() { _top = initial_top(); clear_next(); clear_prev(); }
bool is_empty() { return _top == initial_top(); }
DEBUG_ONLY(bool in_list() const { return _prev != NULL || _next != NULL; })
// used (has been allocated)
// free (available for future allocations)
size_t word_size() const { return size(); }
size_t used_word_size() const;
size_t free_word_size() const;
// Physical neighbors wiring
void set_prev_in_vs(Metachunk* c) { DEBUG_ONLY(assert_have_expand_lock()); _prev_in_vs = c; }
Metachunk* prev_in_vs() const { DEBUG_ONLY(assert_have_expand_lock()); return _prev_in_vs; }
void set_next_in_vs(Metachunk* c) { DEBUG_ONLY(assert_have_expand_lock()); _next_in_vs = c; }
Metachunk* next_in_vs() const { DEBUG_ONLY(assert_have_expand_lock()); return _next_in_vs; }
bool is_tagged_free() { return _is_tagged_free; }
void set_is_tagged_free(bool v) { _is_tagged_free = v; }
bool is_free() const { return _state == State::Free; }
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.
DEBUG_ONLY(void do_verify_chunk(Metachunk* chunk);)
// 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);
#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
#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()
} // namespace metaspace

107
src/hotspot/share/memory/metaspace/metachunkList.cpp Normal file
View File

@ -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

103
src/hotspot/share/memory/metaspace/metachunkList.hpp Normal file
View File

@ -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

497
src/hotspot/share/memory/metaspace/metaspaceArena.cpp Normal file
View File

@ -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

180
src/hotspot/share/memory/metaspace/metaspaceArena.hpp Normal file
View File

@ -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

126
src/hotspot/share/memory/metaspace/metaspaceArenaGrowthPolicy.cpp Normal file
View File

@ -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

79
src/hotspot/share/memory/metaspace/metaspaceArenaGrowthPolicy.hpp Normal file
View File

@ -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

166
src/hotspot/share/memory/metaspace/metaspaceCommon.cpp
View File

@ -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) {
st->print("%*" PRIuPTR " bytes", width, byte_size);
} else if (scale == BytesPerWord) {
st->print("%*" PRIuPTR " words", width, byte_size / BytesPerWord);
} else {
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);
if (width == -1) {
if (scale == 1) {
st->print(SIZE_FORMAT " bytes", byte_size);
} else if (scale == BytesPerWord) {
st->print(SIZE_FORMAT " words", byte_size / BytesPerWord);
} 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

166
src/hotspot/share/memory/metaspace/metaspaceCommon.hpp
View File

@ -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.
ClassSpecializedChunk = 128,
SpecializedChunk = 128,
ClassSmallChunk = 256,
SmallChunk = 512,
ClassMediumChunk = 4 * K,
MediumChunk = 8 * K
};
// Metaspace allocation alignment:
// 1) Metaspace allocations have to be aligned such that 64bit values are aligned
// correctly.
//
// 2) Klass* structures allocated from Metaspace have to be aligned to KlassAlignmentInBytes.
//
// 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))
// Internal statistics.
#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;
SIZE_FORMAT_HEX, (size_t)(uintptr_t)value, (size_t)(alignment))
#else
#define assert_is_aligned(value, alignment)
#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

86
src/hotspot/share/memory/metaspace/metaspaceContext.cpp Normal file
View File

@ -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

111
src/hotspot/share/memory/metaspace/metaspaceContext.hpp Normal file
View File

@ -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

44
src/hotspot/share/memory/metaspace/metaspaceDCmd.cpp
View File

@ -1,6 +1,6 @@
/*
* Copyright (c) 2018, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2018, SAP and/or its affiliates.
* 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,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)
: DCmdWithParser(output, heap)
, _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")
, _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")
, _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) "
"or \"dynamic\" for a dynamically choosen scale.",
"STRING", false, "dynamic")
, _show_classes("show-classes", "If show-loaders is set, shows loaded classes for each loader.", "BOOLEAN", false, "false")
MetaspaceDCmd::MetaspaceDCmd(outputStream* output, bool heap) :
DCmdWithParser(output, heap),
_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"),
_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"),
_show_vslist("vslist", "Shows details about the underlying virtual space.", "BOOLEAN", false, "false"),
_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.",
"STRING", false, "dynamic"),
_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_classes.value()) flags |= MetaspaceUtils::rf_show_classes;
if (_by_chunktype.value()) flags |= MetaspaceUtils::rf_break_down_by_chunktype;
if (_by_spacetype.value()) flags |= MetaspaceUtils::rf_break_down_by_spacetype;
if (_show_vslist.value()) flags |= MetaspaceUtils::rf_show_vslist;
if (_show_vsmap.value()) flags |= MetaspaceUtils::rf_show_vsmap;
if (_show_loaders.value()) flags |= (int)MetaspaceReporter::Option::ShowLoaders;
if (_show_classes.value()) flags |= (int)MetaspaceReporter::Option::ShowClasses;
if (_by_chunktype.value()) flags |= (int)MetaspaceReporter::Option::BreakDownByChunkType;
if (_by_spacetype.value()) flags |= (int)MetaspaceReporter::Option::BreakDownBySpaceType;
if (_show_vslist.value()) flags |= (int)MetaspaceReporter::Option::ShowVSList;
VM_PrintMetadata op(output(), scale, flags);
VMThread::execute(&op);
}

5
src/hotspot/share/memory/metaspace/metaspaceDCmd.hpp
View File

@ -1,6 +1,6 @@
/*
* Copyright (c) 2018, 2019, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2018, SAP and/or its affiliates.
* 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
@ -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:

372
src/hotspot/share/memory/metaspace/metaspaceReporter.cpp Normal file
View File

@ -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

64
src/hotspot/share/memory/metaspace/metaspaceReporter.hpp Normal file
View File

@ -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

108
src/hotspot/share/memory/metaspace/metaspaceSettings.cpp Normal file
View File

@ -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

100
src/hotspot/share/memory/metaspace/metaspaceSettings.hpp Normal file
View File

@ -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

16
src/hotspot/share/memory/metaspace/metaspaceSizesSnapshot.cpp
View File

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

3
src/hotspot/share/memory/metaspace/metaspaceSizesSnapshot.hpp
View File

@ -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();

281
src/hotspot/share/memory/metaspace/metaspaceStatistics.cpp
View File

@ -1,6 +1,6 @@
/*
* Copyright (c) 2018, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2018 SAP SE. 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
@ -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
FreeChunksStatistics::FreeChunksStatistics()
: _num(0), _cap(0)
{}
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();
// Returns total word size of all chunks in this manager.
void ChunkManagerStats::add(const ChunkManagerStats& other) {
for (chunklevel_t l = chunklevel::LOWEST_CHUNK_LEVEL; l <= chunklevel::HIGHEST_CHUNK_LEVEL; l++) {
_num_chunks[l] += other._num_chunks[l];
_committed_word_size[l] += other._committed_word_size[l];
}
}
size_t ChunkManagerStatistics::total_capacity() const {
return _chunk_stats[SpecializedIndex].cap() +
_chunk_stats[SmallIndex].cap() +
_chunk_stats[MediumIndex].cap() +
_chunk_stats[HumongousIndex].cap();
// Returns total word size of all chunks in this manager.
size_t ChunkManagerStats::total_word_size() const {
size_t s = 0;
for (chunklevel_t l = chunklevel::LOWEST_CHUNK_LEVEL; l <= chunklevel::HIGHEST_CHUNK_LEVEL; l++) {
s += _num_chunks[l] * chunklevel::word_size_for_level(l);
}
return s;
}
void ChunkManagerStatistics::print_on(outputStream* st, size_t scale) const {
FreeChunksStatistics totals;
for (ChunkIndex i = ZeroIndex; i < NumberOfInUseLists; i = next_chunk_index(i)) {
// Returns total committed word size of all chunks in this manager.
size_t ChunkManagerStats::total_committed_word_size() const {
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));
if (_chunk_stats[i].num() > 0) {
st->print(UINTX_FORMAT_W(4) ", capacity ", _chunk_stats[i].num());
print_scaled_words(st, _chunk_stats[i].cap(), scale);
chunklevel::print_chunk_size(st, l);
st->print(": ");
if (_num_chunks[l] > 0) {
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());
print_scaled_words(st, totals.cap(), scale);
st->print("Total word size: ");
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 {
assert(_overhead == (Metachunk::overhead() * _num), "Sanity: Overhead.");
assert(_cap == _used + _free + _waste + _overhead, "Sanity: Capacity.");
void ChunkManagerStats::verify() const {
assert(total_committed_word_size() <= total_word_size(),
"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) {
_free_blocks_num += num;
_free_blocks_cap_words += cap;
#ifdef ASSERT
void InUseChunkStats::verify() const {
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) {
for (ChunkIndex i = ZeroIndex; i < NumberOfInUseLists; i = next_chunk_index(i)) {
_chunk_stats[i].add(other._chunk_stats[i]);
void ArenaStats::add(const ArenaStats& other) {
for (chunklevel_t l = chunklevel::LOWEST_CHUNK_LEVEL; l <= chunklevel::HIGHEST_CHUNK_LEVEL; l++) {
_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 {
UsedChunksStatistics stat;
for (ChunkIndex i = ZeroIndex; i < NumberOfInUseLists; i = next_chunk_index(i)) {
stat.add(_chunk_stats[i]);
InUseChunkStats ArenaStats::totals() const {
InUseChunkStats out;
for (chunklevel_t l = chunklevel::LOWEST_CHUNK_LEVEL; l <= chunklevel::HIGHEST_CHUNK_LEVEL; l++) {
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));
if (_chunk_stats[i].num() == 0) {
chunklevel::print_chunk_size(st, l);
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 ClassLoaderMetaspaceStatistics::reset() {
nonclass_sm_stats().reset();
if (Metaspace::using_class_space()) {
class_sm_stats().reset();
void ArenaStats::verify() const {
size_t total_used = 0;
for (chunklevel_t l = chunklevel::LOWEST_CHUNK_LEVEL; l <= chunklevel::HIGHEST_CHUNK_LEVEL; l++) {
_stats[l].verify();
total_used += _stats[l]._used_words;
}
// 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
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 {
void ClmsStats::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

200
src/hotspot/share/memory/metaspace/metaspaceStatistics.hpp
View File

@ -1,6 +1,6 @@
/*
* Copyright (c) 2018, 2019, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2018 SAP SE. 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,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.
class FreeChunksStatistics {
uintx _num; // Number of chunks
size_t _cap; // Total capacity, in words
// Contains a number of data output structures:
//
// - cm_stats_t
// - 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:
FreeChunksStatistics();
struct ChunkManagerStats {
void reset();
// How many chunks per level are checked in.
int _num_chunks[chunklevel::NUM_CHUNK_LEVELS];
uintx num() const { return _num; }
size_t cap() const { return _cap; }
// Size, in words, of the sum of all committed areas in this chunk manager, per level.
size_t _committed_word_size[chunklevel::NUM_CHUNK_LEVELS];
void add(uintx n, size_t s);
void add(const FreeChunksStatistics& other);
void print_on(outputStream* st, size_t scale) const;
ChunkManagerStats() : _num_chunks(), _committed_word_size() {}
}; // 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.
class ChunkManagerStatistics {
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;
// Returns total committed word size of all chunks in this manager.
size_t total_committed_word_size() 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
size_t cap() const { return _cap; }
// Total committed area, in words.
size_t _committed_words;
// Total used area, in words
size_t used() const { return _used; }
// Total used area, in words.
size_t _used_words;
// Total free area (unused portions of current chunks), in words
size_t free() const { return _free; }
// Total free committed area, in words.
size_t _free_words;
// Total waste area (unused portions of non-current chunks), in words
size_t waste() const { return _waste; }
// Total waste committed area, in words.
size_t _waste_words;
// Total area spent in overhead (chunk headers), in words
size_t overhead() const { return _overhead; }
InUseChunkStats() :
_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_cap(size_t s) { _cap += s; }
void add_used(size_t s) { _used += s; }
void add_free(size_t s) { _free += s; }
void add_waste(size_t s) { _waste += s; }
void add_overhead(size_t s) { _overhead += s; }
void add(const InUseChunkStats& other) {
_num += other._num;
_word_size += other._word_size;
_committed_words += other._committed_words;
_used_words += other._used_words;
_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
void check_sanity() const;
#endif
DEBUG_ONLY(void verify() const;)
}; // UsedChunksStatistics
};
// Class containing statistics for one or more space managers.
class SpaceManagerStatistics {
// Class containing statistics for one or more MetaspaceArena objects.
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
const UsedChunksStatistics& chunk_stats(ChunkIndex index) const { return _chunk_stats[index]; }
UsedChunksStatistics& chunk_stats(ChunkIndex index) { return _chunk_stats[index]; }
void print_on(outputStream* st, size_t scale = K, bool detailed = true) const;
uintx free_blocks_num () const { return _free_blocks_num; }
size_t free_blocks_cap_words () const { return _free_blocks_cap_words; }
InUseChunkStats totals() const;
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.
UsedChunksStatistics totals() const;
// Statistics for one or multiple ClassLoaderMetaspace objects
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
class ClassLoaderMetaspaceStatistics {
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 add(const ClmsStats& other) {
_arena_stats_nonclass.add(other._arena_stats_nonclass);
_arena_stats_class.add(other._arena_stats_class);
}
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

135
src/hotspot/share/memory/metaspace/occupancyMap.cpp
View File

@ -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

242
src/hotspot/share/memory/metaspace/occupancyMap.hpp
View File

@ -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

38
src/hotspot/share/memory/metaspace/printCLDMetaspaceInfoClosure.cpp
View File

@ -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)
: _out(out), _scale(scale), _do_print(do_print), _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)
bool do_print_classes, bool break_down_by_chunktype) :
_out(out),
_scale(scale),
_do_print(do_print),
_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

9
src/hotspot/share/memory/metaspace/printCLDMetaspaceInfoClosure.hpp
View File

@ -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);
};

6
src/hotspot/share/memory/metaspace/printMetaspaceInfoKlassClosure.cpp
View File

@ -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);

512
src/hotspot/share/memory/metaspace/rootChunkArea.cpp Normal file
View File

@ -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

207
src/hotspot/share/memory/metaspace/rootChunkArea.hpp Normal file
View File

@ -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

97
src/hotspot/share/memory/metaspace/runningCounters.cpp Normal file
View File

@ -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

76
src/hotspot/share/memory/metaspace/runningCounters.hpp Normal file
View File

@ -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

88
src/hotspot/share/memory/metaspace/smallBlocks.hpp
View File

@ -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

529
src/hotspot/share/memory/metaspace/spaceManager.cpp
View File

@ -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

233
src/hotspot/share/memory/metaspace/spaceManager.hpp
View File

@ -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

121
src/hotspot/share/memory/metaspace/testHelpers.cpp Normal file
View File

@ -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

119
src/hotspot/share/memory/metaspace/testHelpers.hpp Normal file
View File

@ -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

547
src/hotspot/share/memory/metaspace/virtualSpaceList.cpp
View File

@ -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());
while (iter.repeat()) {
VirtualSpaceNode* vsl = iter.get_next();
delete vsl;
assert_lock_strong(MetaspaceExpand_lock);
// Note: normally, there is no reason ever to delete a vslist since they are
// global objects, but for gtests it makes sense to allow this.
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;
}
void VirtualSpaceList::dec_reserved_words(size_t v) {
assert_lock_strong(MetaspaceExpand_lock);
_reserved_words = _reserved_words - v;
VirtualSpaceNode* vsn = VirtualSpaceNode::create_node(Settings::virtual_space_node_default_word_size(),
_commit_limiter,
&_reserved_words_counter, &_committed_words_counter);
vsn->set_next(_first_node);
_first_node = vsn;
_nodes_counter.increment();
}
#define assert_committed_below_limit() \
assert(MetaspaceUtils::committed_bytes() <= MaxMetaspaceSize, \
"Too much committed memory. Committed: " SIZE_FORMAT \
" limit (MaxMetaspaceSize): " SIZE_FORMAT, \
MetaspaceUtils::committed_bytes(), MaxMetaspaceSize);
void VirtualSpaceList::inc_committed_words(size_t v) {
// Allocate a root chunk from this list.
// Note: this just returns a chunk whose memory is reserved; no memory is committed yet.
// Hence, before using this chunk, it must be committed.
// Also, no limits are checked, since no committing takes place.
Metachunk* VirtualSpaceList::allocate_root_chunk() {
assert_lock_strong(MetaspaceExpand_lock);
_committed_words = _committed_words + v;
assert_committed_below_limit();
}
void VirtualSpaceList::dec_committed_words(size_t v) {
assert_lock_strong(MetaspaceExpand_lock);
_committed_words = _committed_words - v;
if (_first_node == NULL ||
_first_node->free_words() < chunklevel::MAX_CHUNK_WORD_SIZE) {
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() {
assert_lock_strong(MetaspaceExpand_lock);
_virtual_space_count++;
}
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 ++;
if (_can_expand) {
create_new_node();
UL2(debug, "added new node (now: %d).", num_nodes());
} else {
prev_vsl = vsl;
UL(debug, "list cannot expand.");
return NULL; // We cannot expand this list.
}
}
// Verify list
#ifdef ASSERT
if (num_purged_nodes > 0) {
verify(false);
}
#endif
Metachunk* c = _first_node->allocate_root_chunk();
assert(c != NULL, "This should have worked");
return c;
}
// 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.
// The chunks are added with store ordering and not deleted except for at
// unloading time during a safepoint.
VirtualSpaceNode* VirtualSpaceList::find_enclosing_space(const void* ptr) {
// List should be stable enough to use an iterator here because removing virtual
// space nodes is only allowed at a safepoint.
if (is_within_envelope((address)ptr)) {
VirtualSpaceListIterator iter(virtual_space_list());
while (iter.repeat()) {
VirtualSpaceNode* vsn = iter.get_next();
if (vsn->contains(ptr)) {
return vsn;
VirtualSpaceNode* vsn = _first_node;
VirtualSpaceNode* prev_vsn = NULL;
int num = 0, num_purged = 0;
while (vsn != NULL) {
VirtualSpaceNode* next_vsn = vsn->next();
bool purged = vsn->attempt_purge(freelists);
if (purged) {
// Note: from now on do not dereference vsn!
UL2(debug, "purged node @" PTR_FORMAT ".", p2i(vsn));
if (_first_node == vsn) {
_first_node = next_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;
}
}
return NULL;
}
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;
vsn = next_vsn;
num ++;
}
if (vs_word_size == 0) {
assert(false, "vs_word_size should always be at least _reserve_alignment large.");
return false;
}
// 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);)
UL2(debug, "purged %d nodes (before: %d, now: %d)",
num_purged, num, num_nodes());
return num_purged;
}
void VirtualSpaceList::link_vs(VirtualSpaceNode* new_entry) {
if (virtual_space_list() == NULL) {
set_virtual_space_list(new_entry);
} else {
current_virtual_space()->set_next(new_entry);
// Print all nodes in this space list.
void VirtualSpaceList::print_on(outputStream* st) const {
MutexLocker fcl(MetaspaceExpand_lock, Mutex::_no_safepoint_check_flag);
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);
inc_reserved_words(new_entry->reserved_words());
inc_committed_words(new_entry->committed_words());
inc_virtual_space_count();
st->print_cr("- total %d nodes, " SIZE_FORMAT " reserved words, " SIZE_FORMAT " committed words.",
n, reserved_words(), committed_words());
}
#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,
size_t min_words,
size_t preferred_words) {
size_t before = node->committed_words();
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.");
// Returns true if this pointer is contained in one of our nodes.
bool VirtualSpaceList::contains(const MetaWord* p) const {
const VirtualSpaceNode* vsn = _first_node;
while (vsn != NULL) {
if (vsn->contains(p)) {
return true;
}
return expand_node_by(current_virtual_space(),
min_words,
max_expansion_words);
vsn = vsn->next();
}
return false;
}
// Given a chunk, calculate the largest possible padding space which
// could be required when allocating it.
static size_t largest_possible_padding_size_for_chunk(size_t chunk_word_size, bool is_class) {
const ChunkIndex chunk_type = get_chunk_type_by_size(chunk_word_size, is_class);
if (chunk_type != HumongousIndex) {
// 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;
// Returns true if the vslist is not expandable and no more root chunks
// can be allocated.
bool VirtualSpaceList::is_full() const {
if (!_can_expand && _first_node != NULL && _first_node->free_words() == 0) {
return true;
}
return false;
}
Metachunk* VirtualSpaceList::get_new_chunk(size_t chunk_word_size, size_t suggested_commit_granularity) {
// Allocate a chunk out of the current virtual space.
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;
// Convenience methods to return the global class-space chunkmanager
// and non-class chunkmanager, respectively.
VirtualSpaceList* VirtualSpaceList::vslist_class() {
return MetaspaceContext::context_class() == NULL ? NULL : MetaspaceContext::context_class()->vslist();
}
void VirtualSpaceList::print_on(outputStream* st, size_t scale) const {
st->print_cr(SIZE_FORMAT " nodes, current node: " PTR_FORMAT,
_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);
}
VirtualSpaceList* VirtualSpaceList::vslist_nonclass() {
return MetaspaceContext::context_nonclass() == NULL ? NULL : MetaspaceContext::context_nonclass()->vslist();
}
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

183
src/hotspot/share/memory/metaspace/virtualSpaceList.hpp
View File

@ -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 {
VirtualSpaceSize = 256 * K
};
// Name
const char* const _name;
// Head of the list
VirtualSpaceNode* _virtual_space_list;
// virtual space currently being used for allocations
VirtualSpaceNode* _current_virtual_space;
// Head of the list.
VirtualSpaceNode* _first_node;
// Is this VirtualSpaceList used for the compressed class space
bool _is_class;
// Number of nodes (kept for statistics only).
IntCounter _nodes_counter;
// Sum of reserved and committed memory in the virtual spaces
size_t _reserved_words;
size_t _committed_words;
// Whether this list can expand by allocating new nodes.
const bool _can_expand;
// Number of virtual spaces
size_t _virtual_space_count;
// Used to check limits before committing memory.
CommitLimiter* const _commit_limiter;
// Optimization: we keep an address range to quickly exclude pointers
// which are clearly not pointing into metaspace. This is an optimization for
// VirtualSpaceList::contains().
address _envelope_lo;
address _envelope_hi;
// Statistics
bool is_within_envelope(address p) const {
return p >= _envelope_lo && p < _envelope_hi;
}
// Holds sum of reserved space, in words, over all list nodes.
SizeCounter _reserved_words_counter;
// Given a node, expand range such that it includes the node.
void expand_envelope_to_include_node(const VirtualSpaceNode* node);
// Holds sum of committed space, in words, over all list nodes.
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) {
_virtual_space_list = v;
}
void set_current_virtual_space(VirtualSpaceNode* v) {
_current_virtual_space = v;
}
// Create a new, empty, expandable list.
VirtualSpaceList(const char* name, CommitLimiter* commit_limiter);
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
// 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);
virtual ~VirtualSpaceList();
// Chunk up the unused committed space in the current
// virtual space and add the chunks to the free list.
void retire_current_virtual_space();
// Allocate a root chunk from this list.
// Note: this just returns a chunk whose memory is reserved; no memory is committed yet.
// 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:
VirtualSpaceList(size_t word_size);
VirtualSpaceList(ReservedSpace rs);
//// Statistics ////
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,
size_t suggested_commit_granularity);
// Return sum of committed words in all nodes.
size_t committed_words() const { return _committed_words_counter.get(); }
bool expand_node_by(VirtualSpaceNode* node,
size_t min_words,
size_t preferred_words);
// Return number of nodes in this list.
int num_nodes() const { return _nodes_counter.get(); }
bool expand_by(size_t min_words,
size_t preferred_words);
//// Debug stuff ////
DEBUG_ONLY(void verify() const;)
DEBUG_ONLY(void verify_locked() const;)
VirtualSpaceNode* current_virtual_space() {
return _current_virtual_space;
}
// Print all nodes in this space list.
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; }
size_t reserved_bytes() { return reserved_words() * BytesPerWord; }
size_t committed_words() { return _committed_words; }
size_t committed_bytes() { return committed_words() * BytesPerWord; }
// Convenience methods to return the global class-space vslist
// and non-class vslist, respectively.
static VirtualSpaceList* vslist_class();
static VirtualSpaceList* vslist_nonclass();
void inc_reserved_words(size_t v);
void dec_reserved_words(size_t v);
void inc_committed_words(size_t v);
void dec_committed_words(size_t v);
void inc_virtual_space_count();
void dec_virtual_space_count();
// These exist purely to print limits of the compressed class space;
// if we ever change the ccs to not use a degenerated-list-of-one-node this
// will go away.
MetaWord* base_of_first_node() const { return _first_node != NULL ? _first_node->base() : NULL; }
size_t word_size_of_first_node() const { return _first_node != NULL ? _first_node->word_size() : 0; }
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

931
src/hotspot/share/memory/metaspace/virtualSpaceNode.cpp
View File

@ -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/metaDebug.hpp"
#include "memory/metaspace/chunkHeaderPool.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/atomic.hpp"
#include "runtime/globals.hpp"
#include "runtime/mutexLocker.hpp"
#include "runtime/os.hpp"
#include "services/memTracker.hpp"
#include "utilities/copy.hpp"
#include "utilities/align.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.
static bool should_commit_large_pages_when_reserving(size_t bytes) {
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]);
}
}
#define LOGFMT "VsListNode @" PTR_FORMAT " base " PTR_FORMAT " "
#define LOGFMT_ARGS p2i(this), p2i(_base)
#ifdef ASSERT
// Verify counters, all chunks in this list node and the occupancy map.
void VirtualSpaceNode::verify(bool slow) {
log_trace(gc, metaspace, freelist)("verifying %s virtual space node (%s).",
(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_pointer_is_aligned_to_commit_granule(const MetaWord* p) {
assert(is_aligned(p, Settings::commit_granule_bytes()),
"Pointer not aligned to commit granule size: " PTR_FORMAT ".",
p2i(p));
}
// Verify that all free chunks in this node are ideally merged
// (there not should be multiple small chunks where a large chunk could exist.)
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;
}
void check_word_size_is_aligned_to_commit_granule(size_t word_size) {
assert(is_aligned(word_size, Settings::commit_granule_words()),
"Not aligned to commit granule size: " SIZE_FORMAT ".", word_size);
}
#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();
if (_occupancy_map != NULL) {
delete _occupancy_map;
DEBUG_ONLY(verify_locked();)
UL(debug, ": dies.");
if (_owns_rs) {
_rs.release();
}
#ifdef ASSERT
size_t word_size = sizeof(*this) / BytesPerWord;
Copy::fill_to_words((HeapWord*) this, word_size, 0xf1f1f1f1);
#endif
// Update counters in vslist
size_t committed = committed_words();
_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 {
return pointer_delta(top(), bottom(), sizeof(MetaWord));
}
//// Chunk allocation, splitting, merging /////
// Space committed in the VirtualSpace
size_t VirtualSpaceNode::capacity_words_in_vs() const {
return pointer_delta(end(), bottom(), sizeof(MetaWord));
}
size_t VirtualSpaceNode::free_words_in_vs() const {
return pointer_delta(end(), top(), sizeof(MetaWord));
}
// 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) {
// Allocate a root chunk from this node. Will fail and return NULL if the node is full
// - 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* VirtualSpaceNode::allocate_root_chunk() {
assert_lock_strong(MetaspaceExpand_lock);
Metachunk* result = take_from_committed(chunk_word_size);
return result;
assert_is_aligned(free_words(), chunklevel::MAX_CHUNK_WORD_SIZE);
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
// grows in steps of Metaspace::commit_alignment(). If both base and size are
// aligned only the middle alignment of the VirtualSpace is used.
assert_is_aligned(_rs.base(), Metaspace::commit_alignment());
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());
// First find out if all areas are empty. Since empty chunks collapse to root chunk
// size, if all chunks in this node are free root chunks we are good to go.
if (!_root_chunk_area_lut.is_free()) {
return false;
}
// Initialize Occupancy Map.
const size_t smallest_chunk_size = is_class() ? ClassSpecializedChunk : SpecializedChunk;
_occupancy_map = new OccupancyMap(bottom(), reserved_words(), smallest_chunk_size);
UL(debug, ": purging.");
return result;
}
void VirtualSpaceNode::print_on(outputStream* st, size_t scale) const {
size_t used_words = used_words_in_vs();
size_t commit_words = committed_words();
size_t res_words = reserved_words();
VirtualSpace* vs = virtual_space();
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);
// 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);
Metachunk* c = ra->first_chunk();
if (c != NULL) {
UL2(trace, "removing chunk from to-be-purged node: "
METACHUNK_FULL_FORMAT ".", METACHUNK_FULL_FORMAT_ARGS(c));
assert(c->is_free() && c->is_root_chunk(), "Sanity");
freelists->remove(c);
}
}
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

300
src/hotspot/share/memory/metaspace/virtualSpaceNode.hpp
View File

@ -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 ChunkManager;
class OccupancyMap;
class CommitLimiter;
class FreeChunkListVector;
// 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.
const bool _is_class;
// total in the VirtualSpace
// The underlying space. This has been either created by this node
// and is owned by it, or has been handed in from outside (e.g. in
// case of CompressedClassSpace).
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
char* low() const { return virtual_space()->low(); }
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(); }
// Start pointer of the area.
MetaWord* const _base;
// The first Metachunk will be allocated at the bottom of the
// VirtualSpace
Metachunk* first_chunk() { return (Metachunk*) bottom(); }
// Size, in words, of the whole node
const size_t _word_size;
// Committed but unused space in the virtual space
size_t free_words_in_vs() const;
// Size, in words, of the range of this node which has been handed out in
// the form of root chunks.
size_t _used_words;
// True if this node belongs to class metaspace.
bool is_class() const { return _is_class; }
// The bitmap describing the commit state of the region:
// Each bit covers a region of 64K (see constants::commit_granule_size).
CommitMask _commit_mask;
// Helper function for take_from_committed: allocate padding chunks
// until top is at the given address.
void allocate_padding_chunks_until_top_is_at(MetaWord* target_top);
// An array/lookup table of RootChunkArea objects. Each one describes a root chunk area.
RootChunkAreaLUT _root_chunk_area_lut;
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
MetaWord* bottom() const { return (MetaWord*) _virtual_space.low(); }
MetaWord* end() const { return (MetaWord*) _virtual_space.high(); }
// Note: public for gtests only, could be private.
MetaWord* base() const { return _base; }
const OccupancyMap* occupancy_map() const { return _occupancy_map; }
OccupancyMap* occupancy_map() { return _occupancy_map; }
// Reserved size of the whole node.
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; }
size_t committed_words() const { return _virtual_space.actual_committed_size() / BytesPerWord; }
// Allocate a root chunk from this node. Will fail and return NULL if the node is full
// - 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;
// Accessors
VirtualSpaceNode* next() { return _next; }
void set_next(VirtualSpaceNode* v) { _next = v; }
// 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);
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
VirtualSpace* virtual_space() const { return (VirtualSpace*) &_virtual_space; }
// 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 attempt_purge(FreeChunkListVector* freelists);
// Returns true if "word_size" is available in the VirtualSpace
bool is_available(size_t word_size) { return word_size <= pointer_delta(end(), _top, sizeof(MetaWord)); }
// Attempts to uncommit free areas according to the rules set in settings.
// Returns number of words uncommitted.
size_t uncommit_free_areas();
MetaWord* top() const { return _top; }
void inc_top(size_t word_size) { _top += word_size; }
/// misc /////
uintx container_count() { return _container_count; }
void inc_container_count();
void dec_container_count();
// Returns size, in words, of the used space in this node alone.
// (Notes:
// - 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
size_t used_words_in_vs() const;
size_t capacity_words_in_vs() const;
// Returns size, in words, of how much space is left in this node alone.
size_t free_words() const { return _word_size - _used_words; }
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
Metachunk* take_from_committed(size_t chunk_word_size);
//// Committing/uncommitting memory /////
// Allocate a chunk from the virtual space and return it.
Metachunk* get_chunk_vs(size_t chunk_word_size);
// 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
//
// 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.
bool expand_by(size_t min_words, size_t preferred_words);
// Given an address range (which has to be aligned to commit granule size):
// - 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
// in the node from any freelist.
void purge(ChunkManager* chunk_manager);
//// List stuff ////
VirtualSpaceNode* next() const { return _next; }
void set_next(VirtualSpaceNode* vsn) { _next = vsn; }
// If an allocation doesn't fit in the current node a new node is created.
// 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);
/// Debug stuff ////
void print_on(outputStream* st) const { print_on(st, K); }
void print_on(outputStream* st, size_t scale) const;
void print_map(outputStream* st, bool is_class) const;
// Print a description about this node.
void print_on(outputStream* st) const;
// Debug support
DEBUG_ONLY(void mangle();)
// Verify counters and basic structure. Slow mode: verify all chunks in depth and occupancy map.
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.)
DEBUG_ONLY(void verify_free_chunks_are_ideally_merged();)
// Verify counters and basic structure. Slow mode: verify all chunks in depth
bool contains(const MetaWord* p) const {
return p >= _base && p < _base + _used_words;
}
#ifdef ASSERT
void check_pointer(const MetaWord* p) const {
assert(contains(p), "invalid pointer");
}
void verify() const;
void verify_locked() const;
#endif
};

2
src/hotspot/share/memory/metaspaceChunkFreeListSummary.hpp
View File

@ -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;

2
src/hotspot/share/memory/metaspaceClosure.hpp
View File

@ -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;

4
src/hotspot/share/memory/metaspaceCounters.cpp
View File

@ -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;

Some files were not shown because too many files have changed in this diff Show More