--- a/src/hotspot/share/memory/metaspace.cpp Wed Jul 10 05:12:23 2019 +0100
+++ b/src/hotspot/share/memory/metaspace.cpp Mon Jul 08 22:30:19 2019 +0200
@@ -32,7 +32,7 @@
#include "memory/metaspace.hpp"
#include "memory/metaspace/chunkManager.hpp"
#include "memory/metaspace/metachunk.hpp"
-#include "memory/metaspace/metaspaceCommon.hpp"
+#include "memory/metaspace/chunkLevel.hpp"
#include "memory/metaspace/printCLDMetaspaceInfoClosure.hpp"
#include "memory/metaspace/spaceManager.hpp"
#include "memory/metaspace/virtualSpaceList.hpp"
@@ -957,12 +957,6 @@
// Metaspace methods
-size_t Metaspace::_first_chunk_word_size = 0;
-size_t Metaspace::_first_class_chunk_word_size = 0;
-
-size_t Metaspace::_commit_alignment = 0;
-size_t Metaspace::_reserve_alignment = 0;
-
VirtualSpaceList* Metaspace::_space_list = NULL;
VirtualSpaceList* Metaspace::_class_space_list = NULL;
@@ -1178,12 +1172,9 @@
assert(rs.size() >= CompressedClassSpaceSize,
SIZE_FORMAT " != " SIZE_FORMAT, rs.size(), CompressedClassSpaceSize);
assert(using_class_space(), "Must be using class space");
- _class_space_list = new VirtualSpaceList(rs);
- _chunk_manager_class = new ChunkManager(true/*is_class*/);
+ _class_space_list = new VirtualSpaceList("class space list", rs);
+ _chunk_manager_class = new ChunkManager("class space chunk manager", _class_space_list);
- if (!_class_space_list->initialization_succeeded()) {
- vm_exit_during_initialization("Failed to setup compressed class space virtual space list.");
- }
}
#endif
@@ -1200,7 +1191,12 @@
}
_commit_alignment = page_size;
- _reserve_alignment = MAX2(page_size, (size_t)os::vm_allocation_granularity());
+
+ // Reserve alignment: all Metaspace memory mappings are to be aligned to the size of a root chunk.
+ assert(is_aligned_to((int)MAX_CHUNK_BYTE_SIZE, os::vm_allocation_granularity()),
+ "root chunk size must be a multiple of alloc granularity");
+
+ _reserve_alignment = MAX2(page_size, (size_t)MAX_CHUNK_BYTE_SIZE);
// Do not use FLAG_SET_ERGO to update MaxMetaspaceSize, since this will
// override if MaxMetaspaceSize was set on the command line or not.
@@ -1246,7 +1242,7 @@
}
void Metaspace::global_initialize() {
- MetaspaceGC::initialize();
+ MetaspaceGC::initialize(); // <- since we do not prealloc init chunks anymore is this still needed?
#if INCLUDE_CDS
if (DumpSharedSpaces) {
@@ -1262,10 +1258,10 @@
if (DynamicDumpSharedSpaces && !UseSharedSpaces) {
vm_exit_during_initialization("DynamicDumpSharedSpaces is unsupported when base CDS archive is not loaded", NULL);
}
+#endif // INCLUDE_CDS
- if (!DumpSharedSpaces && !UseSharedSpaces)
-#endif // INCLUDE_CDS
- {
+ // Initialize class space:
+ if (CDS_ONLY(!DumpSharedSpaces && !UseSharedSpaces) NOT_CDS(true)) {
#ifdef _LP64
if (using_class_space()) {
char* base = (char*)align_up(Universe::heap()->reserved_region().end(), _reserve_alignment);
@@ -1274,27 +1270,9 @@
#endif // _LP64
}
- // Initialize these before initializing the VirtualSpaceList
- _first_chunk_word_size = InitialBootClassLoaderMetaspaceSize / BytesPerWord;
- _first_chunk_word_size = align_word_size_up(_first_chunk_word_size);
- // Make the first class chunk bigger than a medium chunk so it's not put
- // on the medium chunk list. The next chunk will be small and progress
- // from there. This size calculated by -version.
- _first_class_chunk_word_size = MIN2((size_t)MediumChunk*6,
- (CompressedClassSpaceSize/BytesPerWord)*2);
- _first_class_chunk_word_size = align_word_size_up(_first_class_chunk_word_size);
- // Arbitrarily set the initial virtual space to a multiple
- // of the boot class loader size.
- size_t word_size = VIRTUALSPACEMULTIPLIER * _first_chunk_word_size;
- word_size = align_up(word_size, Metaspace::reserve_alignment_words());
-
- // Initialize the list of virtual spaces.
- _space_list = new VirtualSpaceList(word_size);
- _chunk_manager_metadata = new ChunkManager(false/*metaspace*/);
-
- if (!_space_list->initialization_succeeded()) {
- vm_exit_during_initialization("Unable to setup metadata virtual space list.", NULL);
- }
+ // Initialize non-class virtual space list, and its chunk manager:
+ _space_list = new VirtualSpaceList("Non-Class VirtualSpaceList");
+ _chunk_manager_metadata = new ChunkManager("Non-Class ChunkManager", _space_list);
_tracer = new MetaspaceTracer();
@@ -1460,174 +1438,6 @@
return get_space_list(NonClassType)->contains(ptr);
}
-// ClassLoaderMetaspace
-
-ClassLoaderMetaspace::ClassLoaderMetaspace(Mutex* lock, Metaspace::MetaspaceType type)
- : _space_type(type)
- , _lock(lock)
- , _vsm(NULL)
- , _class_vsm(NULL)
-{
- initialize(lock, type);
-}
-
-ClassLoaderMetaspace::~ClassLoaderMetaspace() {
- Metaspace::assert_not_frozen();
- DEBUG_ONLY(Atomic::inc(&g_internal_statistics.num_metaspace_deaths));
- delete _vsm;
- if (Metaspace::using_class_space()) {
- delete _class_vsm;
- }
-}
-
-void ClassLoaderMetaspace::initialize_first_chunk(Metaspace::MetaspaceType type, Metaspace::MetadataType mdtype) {
- Metachunk* chunk = get_initialization_chunk(type, mdtype);
- if (chunk != NULL) {
- // Add to this manager's list of chunks in use and make it the current_chunk().
- get_space_manager(mdtype)->add_chunk(chunk, true);
- }
-}
-
-Metachunk* ClassLoaderMetaspace::get_initialization_chunk(Metaspace::MetaspaceType type, Metaspace::MetadataType mdtype) {
- size_t chunk_word_size = get_space_manager(mdtype)->get_initial_chunk_size(type);
-
- // Get a chunk from the chunk freelist
- Metachunk* chunk = Metaspace::get_chunk_manager(mdtype)->chunk_freelist_allocate(chunk_word_size);
-
- if (chunk == NULL) {
- chunk = Metaspace::get_space_list(mdtype)->get_new_chunk(chunk_word_size,
- get_space_manager(mdtype)->medium_chunk_bunch());
- }
-
- return chunk;
-}
-
-void ClassLoaderMetaspace::initialize(Mutex* lock, Metaspace::MetaspaceType type) {
- Metaspace::verify_global_initialization();
-
- DEBUG_ONLY(Atomic::inc(&g_internal_statistics.num_metaspace_births));
-
- // Allocate SpaceManager for metadata objects.
- _vsm = new SpaceManager(Metaspace::NonClassType, type, lock);
-
- if (Metaspace::using_class_space()) {
- // Allocate SpaceManager for classes.
- _class_vsm = new SpaceManager(Metaspace::ClassType, type, lock);
- }
-
- MutexLocker cl(MetaspaceExpand_lock, Mutex::_no_safepoint_check_flag);
-
- // Allocate chunk for metadata objects
- initialize_first_chunk(type, Metaspace::NonClassType);
-
- // Allocate chunk for class metadata objects
- if (Metaspace::using_class_space()) {
- initialize_first_chunk(type, Metaspace::ClassType);
- }
-}
-
-MetaWord* ClassLoaderMetaspace::allocate(size_t word_size, Metaspace::MetadataType mdtype) {
- Metaspace::assert_not_frozen();
-
- DEBUG_ONLY(Atomic::inc(&g_internal_statistics.num_allocs));
-
- // Don't use class_vsm() unless UseCompressedClassPointers is true.
- if (Metaspace::is_class_space_allocation(mdtype)) {
- return class_vsm()->allocate(word_size);
- } else {
- return vsm()->allocate(word_size);
- }
-}
-
-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);
- log_trace(gc, metaspace)("Increase capacity to GC from " SIZE_FORMAT " to " SIZE_FORMAT, before, after);
- }
-
- return res;
-}
-
-size_t ClassLoaderMetaspace::allocated_blocks_bytes() const {
- return (vsm()->used_words() +
- (Metaspace::using_class_space() ? class_vsm()->used_words() : 0)) * BytesPerWord;
-}
-
-size_t ClassLoaderMetaspace::allocated_chunks_bytes() const {
- return (vsm()->capacity_words() +
- (Metaspace::using_class_space() ? class_vsm()->capacity_words() : 0)) * BytesPerWord;
-}
-
-void ClassLoaderMetaspace::deallocate(MetaWord* ptr, size_t word_size, bool is_class) {
- Metaspace::assert_not_frozen();
- assert(!SafepointSynchronize::is_at_safepoint()
- || Thread::current()->is_VM_thread(), "should be the VM thread");
-
- DEBUG_ONLY(Atomic::inc(&g_internal_statistics.num_external_deallocs));
-
- MutexLocker ml(vsm()->lock(), Mutex::_no_safepoint_check_flag);
-
- if (is_class && Metaspace::using_class_space()) {
- class_vsm()->deallocate(ptr, word_size);
- } else {
- vsm()->deallocate(ptr, word_size);
- }
-}
-
-size_t ClassLoaderMetaspace::class_chunk_size(size_t word_size) {
- assert(Metaspace::using_class_space(), "Has to use class space");
- return class_vsm()->calc_chunk_size(word_size);
-}
-
-void ClassLoaderMetaspace::print_on(outputStream* out) const {
- // Print both class virtual space counts and metaspace.
- if (Verbose) {
- vsm()->print_on(out);
- if (Metaspace::using_class_space()) {
- class_vsm()->print_on(out);
- }
- }
-}
-
-void ClassLoaderMetaspace::verify() {
- vsm()->verify();
- if (Metaspace::using_class_space()) {
- class_vsm()->verify();
- }
-}
-
-void ClassLoaderMetaspace::add_to_statistics_locked(ClassLoaderMetaspaceStatistics* out) const {
- assert_lock_strong(lock());
- vsm()->add_to_statistics_locked(&out->nonclass_sm_stats());
- if (Metaspace::using_class_space()) {
- class_vsm()->add_to_statistics_locked(&out->class_sm_stats());
- }
-}
-
-void ClassLoaderMetaspace::add_to_statistics(ClassLoaderMetaspaceStatistics* out) const {
- MutexLocker cl(lock(), Mutex::_no_safepoint_check_flag);
- add_to_statistics_locked(out);
-}
-
/////////////// Unit tests ///////////////
struct chunkmanager_statistics_t {
--- a/src/hotspot/share/memory/metaspace.hpp Wed Jul 10 05:12:23 2019 +0100
+++ b/src/hotspot/share/memory/metaspace.hpp Mon Jul 08 22:30:19 2019 +0200
@@ -193,9 +193,6 @@
static void verify_global_initialization();
- 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; }
-
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; }
@@ -231,73 +228,6 @@
};
-// 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 anonymous 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.
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/src/hotspot/share/memory/metaspace/chunkAllocSequence.cpp Mon Jul 08 22:30:19 2019 +0200
@@ -0,0 +1,176 @@
+/*
+ * 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 "memory/metaspace/chunkAllocSequence.hpp"
+#include "memory/metaspace/chunkLevel.hpp"
+#include "utilities/globalDefinitions.hpp"
+
+namespace metaspace {
+
+
+// A chunk allocation sequence which can be encoded with a simple const array.
+class ConstantChunkAllocSequence : public ChunkAllocSequence {
+
+ // integer array specifying chunk level allocation progression.
+ // Last chunk is to be an endlessly repeated allocation.
+ const chklvl_t* const _entries;
+ const int _num_entries;
+
+public:
+
+ ConstantChunkAllocSequence(const chklvl_t* array, int num_entries)
+ : _entries(array)
+ , _num_entries(num_entries)
+ {
+ assert(_num_entries > 0, "must not be empty.");
+ }
+
+ chklvl_t get_next_chunk_level(int num_allocated) const {
+ if (num_allocated >= _num_entries) {
+ // Caller shall repeat last allocation
+ return _entries[_num_entries - 1];
+ }
+ return _entries[_num_entries];
+ }
+
+};
+
+// hard-coded chunk allocation sequences for various space types
+
+///////////////////////////
+// chunk allocation sequences for normal loaders:
+static const chklvl_t g_sequ_standard_nonclass[] = {
+ CHUNK_LEVEL_4K, CHUNK_LEVEL_4K, CHUNK_LEVEL_4K, CHUNK_LEVEL_4K,
+ CHUNK_LEVEL_64K,
+ -1 // .. repeat last
+};
+
+static const chklvl_t g_sequ_standard_class[] = {
+ CHUNK_LEVEL_4K, CHUNK_LEVEL_4K, CHUNK_LEVEL_4K, CHUNK_LEVEL_4K,
+ CHUNK_LEVEL_32K,
+ -1 // .. repeat last
+};
+
+///////////////////////////
+// chunk allocation sequences for reflection/anonymous loaders:
+// We allocate four smallish chunks before progressing to bigger chunks.
+static const chklvl_t g_sequ_anon_nonclass[] = {
+ CHUNK_LEVEL_1K, CHUNK_LEVEL_1K, CHUNK_LEVEL_1K, CHUNK_LEVEL_1K,
+ CHUNK_LEVEL_4K,
+ -1 // .. repeat last
+};
+
+static const chklvl_t g_sequ_anon_class[] = {
+ CHUNK_LEVEL_1K, CHUNK_LEVEL_1K, CHUNK_LEVEL_1K, CHUNK_LEVEL_1K,
+ CHUNK_LEVEL_4K,
+ -1 // .. repeat last
+};
+
+#define DEFINE_CLASS_FOR_ARRAY(what) \
+ static ConstantChunkAllocSequence g_chunk_alloc_sequence_##what (g_sequ_##what, sizeof(g_sequ_##what)/sizeof(int));
+
+DEFINE_CLASS_FOR_ARRAY(standard_nonclass)
+DEFINE_CLASS_FOR_ARRAY(standard_class)
+DEFINE_CLASS_FOR_ARRAY(anon_nonclass)
+DEFINE_CLASS_FOR_ARRAY(anon_class)
+
+
+class BootLoaderChunkAllocSequence : public ChunkAllocSequence {
+
+ // For now, this mirrors what the old code did
+ // (see SpaceManager::get_initial_chunk_size() and SpaceManager::calc_chunk_size).
+
+ // Not sure how much sense this still makes, especially with CDS - by default we
+ // now load JDK classes from CDS and therefore most of the boot loader
+ // chunks remain unoccupied.
+
+ // Also, InitialBootClassLoaderMetaspaceSize was/is confusing since it only applies
+ // to the non-class chunk.
+
+ const bool _is_class;
+
+ static chklvl_t calc_initial_chunk_level(bool is_class) {
+
+ size_t word_size = 0;
+ if (is_class) {
+ // In the old version first class space chunk for boot loader was always medium class chunk size * 6.
+ word_size = 32 * K * 6;
+
+ } else {
+ assert(InitialBootClassLoaderMetaspaceSize < MAX_CHUNK_BYTE_SIZE,
+ "InitialBootClassLoaderMetaspaceSize too large");
+ word_size = InitialBootClassLoaderMetaspaceSize / BytesPerWord;
+ }
+ return level_fitting_word_size(word_size);
+ }
+
+public:
+
+ BootLoaderChunkAllocSequence(bool is_class)
+ : _is_class(is_class)
+ {}
+
+ chklvl_t get_next_chunk_level(int num_allocated) const {
+ if (num_allocated == 0) {
+ return calc_initial_chunk_level(_is_class);
+ }
+ // bit arbitrary, but this is what the old code did. Can tweak later if needed.
+ return CHUNK_LEVEL_64K;
+ }
+
+};
+
+static BootLoaderChunkAllocSequence g_chunk_alloc_sequence_boot_non_class(false);
+static BootLoaderChunkAllocSequence g_chunk_alloc_sequence_boot_class(true);
+
+
+const ChunkAllocSequence* ChunkAllocSequence::alloc_sequence_by_space_type(Metaspace::MetaspaceType space_type, bool is_class) {
+
+ if (is_class) {
+ switch(space_type) {
+ case Metaspace::StandardMetaspaceType: return &g_chunk_alloc_sequence_standard_class;
+ case Metaspace::ReflectionMetaspaceType:
+ case Metaspace::UnsafeAnonymousMetaspaceType: return &g_chunk_alloc_sequence_anon_class;
+ case Metaspace::BootMetaspaceType: return &g_chunk_alloc_sequence_boot_non_class;
+ default: ShouldNotReachHere();
+ }
+ } else {
+ switch(space_type) {
+ case Metaspace::StandardMetaspaceType: return &g_chunk_alloc_sequence_standard_class;
+ case Metaspace::ReflectionMetaspaceType:
+ case Metaspace::UnsafeAnonymousMetaspaceType: return &g_chunk_alloc_sequence_anon_class;
+ case Metaspace::BootMetaspaceType: return &g_chunk_alloc_sequence_boot_class;
+ default: ShouldNotReachHere();
+ }
+ }
+
+ return NULL;
+
+}
+
+
+
+} // namespace metaspace
+
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/src/hotspot/share/memory/metaspace/chunkAllocSequence.hpp Mon Jul 08 22:30:19 2019 +0200
@@ -0,0 +1,48 @@
+/*
+ * 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_CHUNKALLOCSEQUENCE_HPP
+#define SHARE_MEMORY_METASPACE_CHUNKALLOCSEQUENCE_HPP
+
+#include "memory/metaspace.hpp" // For Metaspace::MetaspaceType
+#include "memory/metaspace/chunkLevel.hpp"
+
+namespace metaspace {
+
+
+class ChunkAllocSequence {
+public:
+
+ virtual chklvl_t get_next_chunk_level(int num_allocated) const = 0;
+
+ // Given a space type, return the correct allocation sequence to use.
+ // The returned object is static and read only.
+ static const ChunkAllocSequence* alloc_sequence_by_space_type(Metaspace::MetaspaceType space_type, bool is_class);
+
+};
+
+
+} // namespace metaspace
+
+#endif // SHARE_MEMORY_METASPACE_CHUNKALLOCSEQUENCE_HPP
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/src/hotspot/share/memory/metaspace/chunkLevel.cpp Mon Jul 08 22:30:19 2019 +0200
@@ -0,0 +1,33 @@
+/*
+ * Copyright (c) 2019, SAP and/or its affiliates. All rights reserved.
+ * 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.
+ *
+ */
+#include "precompiled.hpp"
+
+namespace metaspace {
+
+
+
+} // namespace metaspace
+
+
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/src/hotspot/share/memory/metaspace/chunkLevel.hpp Mon Jul 08 22:30:19 2019 +0200
@@ -0,0 +1,91 @@
+/*
+ * 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_CHUNKLEVEL_HPP
+#define SHARE_MEMORY_METASPACE_CHUNKLEVEL_HPP
+
+#include "utilities/globalDefinitions.hpp"
+
+// Constants for the chunk levels and some utility functions.
+
+namespace metaspace {
+
+// Metachunk level
+typedef int chklvl_t;
+
+// Large enough to hold 99% of InstanceKlass.
+static const size_t MIN_CHUNK_BYTE_SIZE = 1 * K;
+
+// Let MAX_CHUNK_SIZE be large enough to hold the largest possible InstanceKlass.
+static const int NUM_CHUNK_LEVELS = 13;
+static const size_t MAX_CHUNK_BYTE_SIZE = MIN_CHUNK_BYTE_SIZE << NUM_CHUNK_LEVELS;
+
+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 chklvl_t HIGHEST_CHUNK_LEVEL = NUM_CHUNK_LEVELS - 1;
+static const chklvl_t LOWEST_CHUNK_LEVEL = 0;
+
+inline bool is_valid_level(chklvl_t level) {
+ return level >= LOWEST_CHUNK_LEVEL && level <= HIGHEST_CHUNK_LEVEL;
+}
+
+#ifdef ASSERT
+inline void check_valid_level(chklvl_t lvl) {
+ assert(is_valid_level(lvl), "invalid level (%d)", (int)lvl);
+}
+#else
+inline void check_valid_level(chklvl_t lvl) {}
+#endif
+
+// Given a level return the chunk size, in words.
+inline size_t word_size_for_level(chklvl_t level) {
+ assert(is_valid_level(level), "invalid chunk level (%d)", level);
+ return MAX_CHUNK_WORD_SIZE << level;
+}
+
+// Given an arbitrary word size smaller than the highest chunk size,
+// return the smallest chunk level able to hold this size.
+chklvl_t level_fitting_word_size(size_t word_size);
+
+// Shorthands to refer to exact sizes
+const chklvl_t CHUNK_LEVEL_1K = LOWEST_CHUNK_LEVEL;
+const chklvl_t CHUNK_LEVEL_2K = (LOWEST_CHUNK_LEVEL + 1);
+const chklvl_t CHUNK_LEVEL_4K = (LOWEST_CHUNK_LEVEL + 2);
+const chklvl_t CHUNK_LEVEL_8K = (LOWEST_CHUNK_LEVEL + 3);
+const chklvl_t CHUNK_LEVEL_16K = (LOWEST_CHUNK_LEVEL + 4);
+const chklvl_t CHUNK_LEVEL_32K = (LOWEST_CHUNK_LEVEL + 5);
+const chklvl_t CHUNK_LEVEL_64K = (LOWEST_CHUNK_LEVEL + 6);
+const chklvl_t CHUNK_LEVEL_128K = (LOWEST_CHUNK_LEVEL + 7);
+const chklvl_t CHUNK_LEVEL_256K = (LOWEST_CHUNK_LEVEL + 8);
+const chklvl_t CHUNK_LEVEL_512K = (LOWEST_CHUNK_LEVEL + 9);
+const chklvl_t CHUNK_LEVEL_1M = (LOWEST_CHUNK_LEVEL + 10);
+const chklvl_t CHUNK_LEVEL_2M = (LOWEST_CHUNK_LEVEL + 11);
+const chklvl_t CHUNK_LEVEL_4M = (LOWEST_CHUNK_LEVEL + 12);
+
+STATIC_ASSERT(CHUNK_LEVEL_4M == HIGHEST_CHUNK_LEVEL);
+
+} // namespace metaspace
+
+#endif // SHARE_MEMORY_METASPACE_BLOCKFREELIST_HPP
--- a/src/hotspot/share/memory/metaspace/chunkManager.cpp Wed Jul 10 05:12:23 2019 +0100
+++ b/src/hotspot/share/memory/metaspace/chunkManager.cpp Mon Jul 08 22:30:19 2019 +0200
@@ -23,618 +23,96 @@
*/
#include "precompiled.hpp"
-#include "logging/log.hpp"
-#include "logging/logStream.hpp"
-#include "memory/binaryTreeDictionary.inline.hpp"
-#include "memory/freeList.inline.hpp"
+
+#include "memory/metaspace/chunkAllocSequence.hpp"
+#include "memory/metaspace/chunkLevel.hpp"
#include "memory/metaspace/chunkManager.hpp"
#include "memory/metaspace/metachunk.hpp"
-#include "memory/metaspace/metaDebug.hpp"
-#include "memory/metaspace/metaspaceCommon.hpp"
-#include "memory/metaspace/metaspaceStatistics.hpp"
-#include "memory/metaspace/occupancyMap.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));
+// 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)
+ : _vs_list(space_list)
+ , _name(name)
+ , _chunks {}
+ , _num_chunks {}
+ , _total_word_size(0)
+ , _total_num_chunks(0)
+{
+}
+
+void ChunkManager::account_for_added_chunk(const Metachunk* c) {
+ assert_lock_strong(MetaspaceExpand_lock);
+
+ const chklvl_t lvl = c->level();
+ check_valid_level(lvl);
+
+ _total_num_chunks ++;
+ _total_word_size += word_size_for_level(lvl);
+ _num_chunks[lvl] ++;
}
+void ChunkManager::account_for_removed_chunk(const Metachunk* c) {
+ assert_lock_strong(MetaspaceExpand_lock);
+
+ const chklvl_t lvl = c->level();
+ check_valid_level(lvl);
+
+ assert(_total_num_chunks > 0, "Sanity.");
+ _total_num_chunks --;
+ const size_t word_size = word_size_for_level(lvl);
+ assert(_total_word_size >= word_size, "Sanity.");
+ _total_word_size -= word_size_for_level(lvl);
+ assert(_num_chunks[lvl] > 0, "Sanity.");
+ _num_chunks[lvl] --;
+}
+
+
+// Remove a chunk of the given level from its freelist, and adjust accounting.
+// If no chunk of this given level is free, return NULL.
+Metachunk* ChunkManager::get_chunk_simple(chklvl_t level) {
+
+ assert_lock_strong(MetaspaceExpand_lock);
+ check_valid_level(level);
+
+ Metachunk* c = _chunks[level];
+ if (c != NULL) {
+ account_for_removed_chunk(c);
+ }
+ return c;
+
+}
+
+
+
+
+// Return a chunk to the ChunkManager and adjust accounting. May merge chunk
+// with neighbors.
+// 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* chunk) {
+
+
+}
+
+
+// Remove the given chunk from its free list and adjust accounting.
+// (Called during VirtualSpaceNode purging which happens during a Metaspace GC.)
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);
- } else {
- humongous_dictionary()->remove_chunk(chunk);
- }
-
- // Chunk has been removed from the chunks free list, update counters.
+ assert_lock_strong(MetaspaceExpand_lock);
+ chunk->remove_from_list();
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 ++;
-
-#endif
-
- return true;
-}
-
-// 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);
-
- 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;
- }
- return num_removed;
-}
-
-// Update internal accounting after a chunk was added
-void ChunkManager::account_for_added_chunk(const Metachunk* c) {
- assert_lock_strong(MetaspaceExpand_lock);
- _free_chunks_count ++;
- _free_chunks_total += c->word_size();
-}
-
-// 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();
-}
-
-ChunkIndex ChunkManager::list_index(size_t size) {
- return get_chunk_type_by_size(size, is_class());
-}
-
-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());
-}
-
-#ifdef ASSERT
-void ChunkManager::verify(bool slow) const {
- MutexLocker cl(MetaspaceExpand_lock,
- Mutex::_no_safepoint_check_flag);
- locked_verify(slow);
-}
-
-void ChunkManager::locked_verify(bool slow) const {
- log_trace(gc, metaspace, freelist)("verifying %s chunkmanager (%s).",
- (is_class() ? "class space" : "metaspace"), (slow ? "slow" : "quick"));
-
- assert_lock_strong(MetaspaceExpand_lock);
-
- 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();
- }
- }
- }
-
- chunks_counted += humongous_dictionary()->total_free_blocks();
- wordsize_chunks_counted += humongous_dictionary()->total_size();
-
- 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);
-}
-#endif // ASSERT
-
-void ChunkManager::locked_print_free_chunks(outputStream* st) {
- 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));
- }
-}
} // namespace metaspace
--- a/src/hotspot/share/memory/metaspace/chunkManager.hpp Wed Jul 10 05:12:23 2019 +0100
+++ b/src/hotspot/share/memory/metaspace/chunkManager.hpp Mon Jul 08 22:30:19 2019 +0200
@@ -26,173 +26,91 @@
#define SHARE_MEMORY_METASPACE_CHUNKMANAGER_HPP
#include "memory/allocation.hpp"
-#include "memory/binaryTreeDictionary.hpp"
-#include "memory/freeList.hpp"
-#include "memory/metaspace/metachunk.hpp"
-#include "memory/metaspace/metaspaceStatistics.hpp"
-#include "memory/metaspaceChunkFreeListSummary.hpp"
-#include "utilities/globalDefinitions.hpp"
-
-class ChunkManagerTestAccessor;
+#include "memory/metaspace/chunkLevel.hpp"
namespace metaspace {
-typedef class FreeList<Metachunk> ChunkList;
-typedef BinaryTreeDictionary<Metachunk, FreeList<Metachunk> > ChunkTreeDictionary;
+class VirtualSpaceList;
+class Metachunk;
-// Manages the global free lists of chunks.
-class ChunkManager : public CHeapObj<mtInternal> {
- friend class ::ChunkManagerTestAccessor;
- // Free list of chunks of different sizes.
- // SpecializedChunk
- // SmallChunk
- // MediumChunk
- ChunkList _free_chunks[NumberOfFreeLists];
+// class ChunkManager
+//
+// The ChunkManager has a central role. Callers request chunks from it.
+// It keeps the freelists for chunks. If the freelist is exhausted it
+// allocates new chunks from a connected VirtualSpaceList.
+//
+class ChunkManager : public CHeapObj<mtInternal> {
- // Whether or not this is the class chunkmanager.
- const bool _is_class;
+ // 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 _vs_list;
- // Return non-humongous chunk list by its index.
- ChunkList* free_chunks(ChunkIndex index);
+ // Name
+ const char* const _name;
- // Returns non-humongous chunk list for the given chunk word size.
- ChunkList* find_free_chunks_list(size_t word_size);
+ // Freelist
+ Metachunk* _chunks [NUM_CHUNK_LEVELS];
- // HumongousChunk
- ChunkTreeDictionary _humongous_dictionary;
+ // Statistics.
+ // Number of counters per level.
+ int _num_chunks [NUM_CHUNK_LEVELS];
- // Returns the humongous chunk dictionary.
- ChunkTreeDictionary* humongous_dictionary() { return &_humongous_dictionary; }
- const ChunkTreeDictionary* humongous_dictionary() const { return &_humongous_dictionary; }
+ // Total size in all chunks, and total number of chunks.
+ size_t _total_word_size;
+ int _total_num_chunks;
- // 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;
+ // Remove a chunk of the given level from its freelist, and adjust accounting.
+ // If no chunk of this given level is free, return NULL.
+ Metachunk* get_chunk_simple(chklvl_t level);
- // Update counters after a chunk was added or removed removed.
+ // Update counters after a chunk has been added or removed.
void account_for_added_chunk(const Metachunk* c);
void account_for_removed_chunk(const Metachunk* c);
- // 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);
+ // Returns true if this manager contains the given chunk. Slow (walks free list) and
+ // only needed for verifications.
+ DEBUG_ONLY(bool contains_chunk(Metachunk* metachunk) const;)
- // 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);
+public:
- // 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);
-
- public:
+ // 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);
- ChunkManager(bool is_class);
-
- // Add or delete (return) a chunk to the global freelist.
- Metachunk* chunk_freelist_allocate(size_t word_size);
-
- // 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);
+ // Get a chunk and be smart about it.
+ // - Attempt to find a free chunk of exactly the pref_level level
+ // - Failing that, attempt to find a chunk smaller or equal the minimal level.
+ // - Failing that, attempt to find a free chunk of larger size and split it.
+ // - Failing that, attempt to allocate a new chunk from the connected virtual space.
+ // This may fail if we hit GC threshold or metaspace limit.
+ // - Failing that, give up and return NULL.
+ Metachunk* get_chunk(chklvl_t min_level, chklvl_t pref_level);
- // Map a given index to the chunk size.
- size_t size_by_index(ChunkIndex index) const;
-
- bool is_class() const { return _is_class; }
-
- // 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); }
-
- // 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).
+ // Remove the given chunk from its free list and adjust accounting.
+ // (Called during VirtualSpaceNode purging which happens during a Metaspace GC.)
void remove_chunk(Metachunk* chunk);
- // Return a single chunk of type index to the ChunkManager.
- void return_single_chunk(Metachunk* chunk);
-
- // Add the simple linked list of chunks to the freelist of chunks
- // of type index.
- void return_chunk_list(Metachunk* chunk);
-
- // 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; }
-
- // Number of chunks in the free chunks list
- size_t free_chunks_count() const { return _free_chunks_count; }
-
- // Remove from a list by size. Selects list based on size of chunk.
- Metachunk* free_chunks_get(size_t chunk_word_size);
-
-#define index_bounds_check(index) \
- assert(is_valid_chunktype(index), "Bad index: %d", (int) index)
-
- 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);
+ // Return a chunk to the ChunkManager and adjust accounting. May merge chunk
+ // with neighbors.
+ // 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 return_chunk(Metachunk* chunk);
- 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;
- }
+ // Uncommit payload area of free chunks. Will be called during Metaspace GC.
+ void uncommit_free_chunks();
- 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));
- }
+ // Run verifications. slow=true: verify chunk-internal integrity too.
+ DEBUG_ONLY(void verify(bool slow) const;)
+ DEBUG_ONLY(void locked_verify(bool slow) const;)
-#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;
+ // Returns the name of this chunk manager.
+ const char* name() const { return _name; }
};
} // namespace metaspace
-
#endif // SHARE_MEMORY_METASPACE_CHUNKMANAGER_HPP
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/src/hotspot/share/memory/metaspace/classLoaderMetaspace.cpp Mon Jul 08 22:30:19 2019 +0200
@@ -0,0 +1,128 @@
+/*
+ * 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.
+ *
+ */
+#include "precompiled.hpp"
+
+#include "logging/log.hpp"
+#include "memory/metaspace.hpp"
+#include "memory/metaspace/chunkAllocSequence.hpp"
+#include "memory/metaspace/classLoaderMetaspace.hpp"
+#include "memory/metaspace/metaspaceCommon.hpp"
+#include "runtime/atomic.hpp"
+#include "utilities/debug.hpp"
+
+namespace metaspace {
+
+ClassLoaderMetaspace::ClassLoaderMetaspace(Mutex* lock, Metaspace::MetaspaceType space_type)
+ : _lock(lock)
+ , _space_type(space_type)
+ , _non_class_space_manager(NULL)
+ , _class_space_manager(NULL)
+{
+ DEBUG_ONLY(Atomic::inc(&g_internal_statistics.num_metaspace_births));
+
+ // Initialize non-class spacemanager
+ _non_class_space_manager = new SpaceManager(
+ Metaspace::chunk_manager_metadata(),
+ ChunkAllocSequence::alloc_sequence_by_space_type(space_type, false),
+ lock);
+
+ // If needed, initialize class spacemanager
+ if (Metaspace::using_class_space()) {
+ _class_space_manager = new SpaceManager(
+ Metaspace::chunk_manager_class(),
+ ChunkAllocSequence::alloc_sequence_by_space_type(space_type, true),
+ lock);
+ }
+
+}
+
+ClassLoaderMetaspace::~ClassLoaderMetaspace() {
+ Metaspace::assert_not_frozen();
+ DEBUG_ONLY(Atomic::inc(&g_internal_statistics.num_metaspace_deaths));
+ delete _non_class_space_manager;
+ delete _class_space_manager;
+}
+
+// Allocate word_size words from Metaspace.
+MetaWord* ClassLoaderMetaspace::allocate(size_t word_size, bool is_class) {
+ Metaspace::assert_not_frozen();
+ DEBUG_ONLY(Atomic::inc(&g_internal_statistics.num_allocs));
+ if (is_class && Metaspace::using_class_space()) {
+ return class_space_manager()->allocate(word_size);
+ } else {
+ return non_class_space_manager()->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_GC_threshold_and_allocate(size_t word_size, bool is_class) {
+ 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, is_class);
+ } while (!incremented && res == NULL && can_retry);
+
+ if (incremented) {
+ Metaspace::tracer()->report_gc_threshold(before, after,
+ MetaspaceGCThresholdUpdater::ExpandAndAllocate);
+ log_trace(gc, metaspace)("Increase capacity to GC from " SIZE_FORMAT " to " 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();
+ DEBUG_ONLY(Atomic::inc(&g_internal_statistics.num_external_deallocs));
+
+ if (is_class && Metaspace::using_class_space()) {
+ class_space_manager()->deallocate(ptr, word_size);
+ } else {
+ non_class_space_manager()->deallocate(ptr, word_size);
+ }
+
+}
+
+
+
+
+
+
+
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/src/hotspot/share/memory/metaspace/classLoaderMetaspace.hpp Mon Jul 08 22:30:19 2019 +0200
@@ -0,0 +1,77 @@
+/*
+ * 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_CHUNKMANAGER_HPP
+#define SHARE_MEMORY_METASPACE_CHUNKMANAGER_HPP
+
+#include "memory/allocation.hpp"
+#include "memory/metaspace/metaspaceCommon.hpp"
+#include "memory/metaspace/spaceManager.hpp"
+
+namespace metaspace {
+
+
+class ClassLoaderMetaspace : public CHeapObj<mtClass> {
+
+ // The CLD lock.
+ Mutex* const _lock;
+
+ const Metaspace::MetaspaceType _space_type;
+
+ metaspace::SpaceManager* _non_class_space_manager;
+ metaspace::SpaceManager* _class_space_manager;
+
+ Mutex* lock() const { return _lock; }
+ metaspace::SpaceManager* non_class_space_manager() const { return _non_class_space_manager; }
+ metaspace::SpaceManager* class_space_manager() const { return _class_space_manager; }
+
+ metaspace::SpaceManager* get_space_manager(bool is_class) {
+ return is_class ? class_space_manager() : non_class_space_manager();
+ }
+
+public:
+
+ ClassLoaderMetaspace(Mutex* lock, Metaspace::MetaspaceType space_type);
+
+ ~ClassLoaderMetaspace();
+
+ // Allocate word_size words from Metaspace.
+ MetaWord* allocate(size_t word_size, bool is_class);
+
+ // 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_GC_threshold_and_allocate(size_t word_size, bool is_class);
+
+ // 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);
+
+
+ DEBUG_ONLY(void verify(bool slow) const;)
+
+};
+
+} // namespace metaspace
+
+#endif // SHARE_MEMORY_METASPACE_CHUNKMANAGER_HPP
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/src/hotspot/share/memory/metaspace/commitLimit.cpp Mon Jul 08 22:30:19 2019 +0200
@@ -0,0 +1,31 @@
+/*
+ * 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"
+
+
+namespace metaspace {
+
+
+} // namespace metaspace
+
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/src/hotspot/share/memory/metaspace/commitLimit.hpp Mon Jul 08 22:30:19 2019 +0200
@@ -0,0 +1,61 @@
+/*
+ * 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"
+
+namespace metaspace {
+
+class CommitLimit : public AllStatic {
+
+ static size_t _committed;
+
+public:
+
+ // Attempt to increase committed size counters. Caller specifies a mininum expansion size and
+ // a preferred one, in bytes.
+ //
+ // Before increasing the committed counters, function checks two limits:
+ // - the current GC threshold beyond which no expansion may happen without triggering a GC
+ // - MaxMetaspaceSize which limits the total sum of committed space.
+ //
+ // If increase is possible by either preferred_wordsize or at least min_wordsize, counters are
+ // increased by that amount and the increase size is returned.
+ //
+ // Otherwise, 0 is returned.
+ //
+ // This function is used from outside the expansion lock. If caller owns expansion lock, use
+ // attempt_increase_committed_locked() instead.
+ static size_t attempt_increase_committed(size_t min_size, size_t preferred_size);
+
+ // Decrease the commit counter by size bytes.
+ static void decrease_committed(size_t size);
+
+};
+
+} // namespace metaspace
+
+#endif // SHARE_MEMORY_METASPACE_BLOCKFREELIST_HPP
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/src/hotspot/share/memory/metaspace/constants.hpp Mon Jul 08 22:30:19 2019 +0200
@@ -0,0 +1,46 @@
+/*
+ * 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_CONSTANTS_HPP
+#define SHARE_MEMORY_METASPACE_CONSTANTS_HPP
+
+#include "utilities/globalDefinitions.hpp"
+#include "memory/metaspace/chunkLevel.hpp"
+
+namespace metaspace {
+
+// Constants to be used throughout metaspace
+
+
+// The size for a VirtualSpaceNode (unless created differently).
+static size_t VSNODE_DEFAULT_BYTE_SIZE = MAX_CHUNK_BYTE_SIZE * 4;
+
+
+// When expanding the committed region of a metachunk (see Metachunk::allocate()), the preferred commit granularity, in bytes
+static size_t metachunk_commit_granularity = 16 * K;
+
+
+} // namespace metaspace
+
+#endif // SHARE_MEMORY_METASPACE_BLOCKFREELIST_HPP
--- a/src/hotspot/share/memory/metaspace/metachunk.cpp Wed Jul 10 05:12:23 2019 +0100
+++ b/src/hotspot/share/memory/metaspace/metachunk.cpp Mon Jul 08 22:30:19 2019 +0200
@@ -23,10 +23,13 @@
*/
#include "precompiled.hpp"
+
#include "memory/allocation.hpp"
+#include "memory/metaspace/chunkLevel.hpp"
+#include "memory/metaspace/commitLimit.hpp"
+#include "memory/metaspace/constants.hpp"
#include "memory/metaspace/metachunk.hpp"
-#include "memory/metaspace/occupancyMap.hpp"
-#include "memory/metaspace/virtualSpaceNode.hpp"
+
#include "utilities/align.hpp"
#include "utilities/copy.hpp"
#include "utilities/debug.hpp"
@@ -50,123 +53,247 @@
// 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)
+void Metachunk::remove_from_list() {
+ if (_prev != NULL) {
+ _prev->set_next(_next);
+ }
+ if (_next != NULL) {
+ _next->set_prev(_prev);
+ }
+ _prev = _next = NULL;
+}
+
+
+// Create a chunk with a given level and a given commit size.
+Metachunk::Metachunk(chklvl_t level, size_t committed_words)
+ : _prev(NULL), _next(NULL)
+ , _level(level)
+ , _is_free(true)
+ , _committed_words(committed_words)
+ , _used_words(overhead())
+ , _abandoned_committed_words(0)
{
- _top = initial_top();
- set_is_tagged_free(false);
#ifdef ASSERT
mangle(uninitMetaWordVal);
verify();
#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;
+// expand the committed range of this chunk to hold at least word_size additional words;
+// Returns false if failed, which may be e.g. due to hitting a limit.
+bool Metachunk::expand_committed(size_t requested_word_size, bool& did_hit_commit_limit) {
+
+ assert(free_word_size_no_commit() >= requested_word_size, "why did you call me");
+
+ const size_t needed = (requested_word_size - free_word_size_no_commit()) * BytesPerWord;
+
+ const size_t alloc_granularity = (size_t)os::vm_allocation_granularity();
+
+ size_t min_expansion = align_up(needed * BytesPerWord, alloc_granularity);
+ size_t preferred_expansion = align_up(metachunk_commit_granularity, alloc_granularity);
+
+ const size_t bytes_left_in_chunk = free_word_size_total() * BytesPerWord;
+ if (preferred_expansion > bytes_left_in_chunk) {
+ // Do not commit beyond chunk limits
+ preferred_expansion = bytes_left_in_chunk;
}
- return result;
+
+ if (min_expansion > preferred_expansion) {
+ preferred_expansion = min_expansion;
+
+ }
+
+ // We are not locked under the metaspace expand lock.
+ {
+ MutexLocker cl(MetaspaceExpand_lock, Mutex::_no_safepoint_check_flag);
+ const size_t word_size_possible = CommitLimit::attempt_increase_committed(min_expansion, preferred_expansion);
+ if (word_size_possible < min_expansion) {
+ // No such luck.
+ did_hit_commit_limit = false;
+ return NULL;
+ }
+
+//blabla
+ }
+ //blabla
+
+
}
-// _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));
+
+// Allocate from chunk.
+// This may fail and return NULL due to the following reasons:
+// - the chunk may be too small to hold the allocation (did_hit_commit_limit will be false).
+// - chunk needed to expand his commit top to hold the allocation, but that failed because we hit a
+// limit (GC threshold or metaspace limit) (did_hit_commit_limit will be true).
+// Returns pointer to allocation, or NULL.
+MetaWord* Metachunk::allocate(size_t requested_word_size, bool& did_hit_commit_limit) {
+
+ MetaWord* result = NULL;
+
+ // Can we fit this allocation into the chunk at all?
+ if (requested_word_size > free_word_size_total()) {
+ did_hit_commit_limit = false;
+ return NULL;
+ }
+
+ // If yes, do we need to commit more pages?
+ if (requested_word_size > free_word_size_no_commit()) {
+ if (expand_committed(requested_word_size, did_hit_commit_limit) == false) {
+ return NULL;
+ }
+ }
+
+ assert(free_word_size_no_commit() >= requested_word_size, "Sanity");
+
+ result = base() + _used_words;
+ _used_words += requested_word_size;
+
+ assert(_used_words <= _committed_words, "Sanity");
+
+ return result;
+
}
-size_t Metachunk::free_word_size() const {
- return pointer_delta(end(), _top, sizeof(MetaWord));
+
+/////////////
+// Merging
+
+// Chunk merging means a chunk is merged with its buddy. The resulting
+// chunk occupies the area of both former chunks (x marks the header):
+//
+// before: |x |x |
+//
+// after: |x |
+//
+// The result chunk size is obviously double the size the merged chunks, and
+// its level is one increased.
+//
+// The result chunk will be committed according to following rules:
+// 1) if the first chunk was completely committed, result chunk will be as far committed
+// as the second chunk was committed
+// (dash marks the committed area):
+//
+// before: |-------|---- |
+//
+// after: |------------ |
+//
+// Obviously, this means that if the second chunk was completely committed, the
+// result chunk will be completely committed too:
+//
+// before: |-------|-------|
+//
+// after: |---------------|
+//
+// 2) if the first chunk was not completely committed, result chunk will be as far committed
+// as the first chunk, and will carry over the size of the committed area in
+// "_abandoned_committed_words"
+//
+// before: |--- |------ |
+//
+// after: |--- | with _abandoned_committed_words += sizeof(------)
+//
+// _abandoned_committed_words accumulates with each subsequent merge. After a sequence of merges,
+// it carries over the sum of all committed "abandoned" regions in the follower chunks.
+//
+//
+
+// Attempt to merge this chunk with its buddy.
+// This succeeds if:
+// - the chunk is not of the highest level (root chunks have no buddies).
+// - the buddy is free
+// If successful, a pointer to the new chunk is returned. !! In that case, the original this
+// will be invalid; do not access it anymore!!
+// If failed, will return NULL.
+Metachunk* Metachunk::try_merge() {
+
+ DEBUG_ONLY(verify();)
+ assert(is_free(), "Can only merge free chunks.");
+
+ Metachunk* buddy = get_buddy_address();
+
+ if (buddy) {
+
+ DEBUG_ONLY(buddy->verify();)
+ assert(buddy->level() <= level(), "Weird geometry");
+
+ // Can only merge with buddy if it is not splintered and free.
+ if (buddy->level() == level() && buddy->is_free()) {
+
+ assert(buddy->word_size() == word_size(), "Sanity");
+
+ // find out who is the leader.
+ Metachunk* leader = this;
+ Metachunk* follower = buddy;
+ if (buddy < this) {
+ Metachunk* tmp = leader;
+ leader = follower;
+ follower = tmp;
+ }
+
+ assert(leader->base() + leader->word_size() == follower->base(),
+ "weird buddy address");
+
+ // Calc committed region of the merged chunk. See lengthy comment in header.
+ size_t merged_committed_words = 0;
+ size_t merged_abandoned_committed_words = 0;
+ if (leader->is_fully_committed()) {
+ merged_committed_words = leader->_committed_words + follower->_committed_words;
+ merged_abandoned_committed_words = follower->_abandoned_committed_words;
+ } else {
+ merged_committed_words = leader->_committed_words;
+ merged_abandoned_committed_words = follower->_committed_words + follower->_abandoned_committed_words;
+ }
+
+ Metachunk* const merged = leader;
+ merged->_level ++;
+ merged->_committed_words = merged_committed_words;
+ merged->_abandoned_committed_words = merged_abandoned_committed_words;
+
+ // Mark follower as invalid.
+ follower->remove_sentinel();
+
+ DEBUG_ONLY(merged->verify());
+
+ return merged;
+
+ }
+
+ }
+
+ return NULL;
+
}
-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());
- }
-}
#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);
+ assert(_words_committed >= overhead, "sanity");
+ size_t mangle_size = _words_committed - overhead();
+ Copy::fill_to_words((HeapWord*)start(), size, word_value);
}
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));
- }
- 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));
+ assert(is_valid_level(_level), "Invalid level (%d)", _level);
- // 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);
+ // Starting address shall be aligned to chunk size.
+ const size_t required_alignment = word_size() * sizeof(MetaWord);
assert(is_aligned((address)this, required_alignment),
- "Chunk " PTR_FORMAT ": (size " SIZE_FORMAT ") not aligned to " SIZE_FORMAT ".",
+ "Chunk " PTR_FORMAT ": (size " SIZE_FORMAT ") not aligned correctly to " SIZE_FORMAT ".",
p2i(this), word_size() * sizeof(MetaWord), required_alignment);
-}
-
-#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";
- }
-}
+ assert(base() == (MetaWord*) this, "sanity");
+ assert(end() == base() + word_size(), "sanity");
+ assert(top() >= start() && top() <= end(), "sanity");
+ assert(commit_top() >= top() && commit_top() <= end(), "sanity");
-#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);
+ assert(_container != NULL, "sanity");
+
}
-#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);
-}
+#endif // ASSERT
} // namespace metaspace
--- a/src/hotspot/share/memory/metaspace/metachunk.hpp Wed Jul 10 05:12:23 2019 +0100
+++ b/src/hotspot/share/memory/metaspace/metachunk.hpp Mon Jul 08 22:30:19 2019 +0200
@@ -26,6 +26,7 @@
#include "memory/metaspace/metabase.hpp"
#include "memory/metaspace/metaspaceCommon.hpp"
+#include "memory/metaspace/chunkLevel.hpp"
#include "utilities/debug.hpp"
#include "utilities/globalDefinitions.hpp"
@@ -39,78 +40,74 @@
// Metachunks are reused (when freed are put on a global freelist) and
// have no permanent association to a SpaceManager.
-// +--------------+ <- end --+ --+
-// | | | |
-// | | | free |
-// | | | |
-// | | | | size | capacity
-// | | | |
-// | | <- top -- + |
-// | | | |
-// | | | used |
-// | | | |
-// | | | |
-// +--------------+ <- bottom --+ --+
+// +--------------+ <- end ----+ --+
+// | | | |
+// | | | free |
+// | ----------- | <- commit_top | |
+// | | | | size (aka capacity)
+// | | | |
+// | ----------- | <- top -- + |
+// | | | |
+// | | | used |
+// +--------------+ <- start -- + |
+// | header | | overhead |
+// +--------------+ <- base ----+ --+
-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,
- origin_minimum = origin_normal,
- origin_maximum = origin_split,
- origins_count = origin_maximum + 1
-};
-
-inline bool is_valid_chunkorigin(ChunkOrigin origin) {
- return origin == origin_normal ||
- origin == origin_pad ||
- origin == origin_leftover ||
- origin == origin_merge ||
- origin == origin_split;
-}
-
-class Metachunk : public Metabase<Metachunk> {
+class Metachunk {
friend class ::MetachunkTest;
- // The VirtualSpaceNode containing this chunk.
- VirtualSpaceNode* const _container;
+ // A metachunk is kept in a list
+ Metachunk* _prev;
+ Metachunk* _next;
- // Current allocation top.
- MetaWord* _top;
+ chklvl_t _level; // aka size.
+
+ bool _is_free;
- // A 32bit sentinel for debugging purposes.
- enum { CHUNK_SENTINEL = 0x4d4554EF, // "MET"
- CHUNK_SENTINEL_INVALID = 0xFEEEEEEF
- };
+ // Committed words, including header.
+ size_t _committed_words;
+
+ // Used words, including header.
+ size_t _used_words;
- uint32_t _sentinel;
+ // "abandoned" committed words
+ // Number of words committed beyond the commit_top(). This
+ // can be the result of merging two half-committed chunks.
+ // We need to track the number, but not the exact location
+ // (see merging/splitting)
+ size_t _abandoned_committed_words;
- 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;
+#ifdef ASSERT
+ // A 32bit sentinel for debugging purposes.
+ static const uint32_t CHUNK_SENTINEL = 0x4d4554EF; // "MET"
+ static const uint32_t CHUNK_SENTINEL_INVALID = 0xFEEEEEEF;
+ uint32_t _sentinel;
+#endif
- ChunkOrigin _origin;
- int _use_count;
+ MetaWord* base() const { return (MetaWord*)this; }
+ MetaWord* start() const { return (MetaWord*)this + overhead(); }
+ MetaWord* top() const { return base() + _used_words; }
+ MetaWord* commit_top() const { return base() + _committed_words; }
+ MetaWord* end() const { return (MetaWord*)this + word_size(); }
- MetaWord* initial_top() const { return (MetaWord*)this + overhead(); }
- MetaWord* top() const { return _top; }
+ // A "root chunk" is a chunk of the highest level. It cannot coalesce further
+ // and has no buddy.
+ bool is_root_chunk() const { return _level == HIGHEST_CHUNK_LEVEL; }
+
+ // expand the committed range of this chunk to hold at least word_size additional words;
+ // Returns false if failed, which may be e.g. due to hitting a limit.
+ bool expand_committed(size_t requested_word_size, bool& did_hit_commit_limit);
- 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.
+ // Returns the location of the buddy, or NULL if this is a root chunk which
+ // has no buddy.
+ Metachunk* get_buddy_address() const;
+
+public:
+
+ // Create a chunk with a given level and a given commit size.
+ Metachunk(chklvl_t level, size_t committed_words);
// Alignment of each allocation in the chunks.
static size_t object_alignment();
@@ -118,56 +115,145 @@
// Size of the Metachunk header, in words, including alignment.
static size_t overhead();
- Metachunk(ChunkIndex chunktype, bool is_class, size_t word_size, VirtualSpaceNode* container);
-
- MetaWord* allocate(size_t word_size);
+ chklvl_t level() const { return _level; }
- VirtualSpaceNode* container() const { return _container; }
+ // Returns size, in bytes, of this chunk including the header.
+ size_t size() const {
+ return MIN_CHUNK_BYTE_SIZE << _level;
+ }
- MetaWord* bottom() const { return (MetaWord*) this; }
// 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(); }
+ void reset() { _used_words = 0; }
+
+
+ // Returns the total word size of this chunk, including header.
+ size_t word_size() const { return size() / sizeof(MetaWord); }
+
+ // Returns the used words in this chunk, including header.
+ size_t used_word_size() const { return _used_words; }
+
+ // Returns the number of free words below the commit top
+ // (how much can be allocated from this chunk without commit).
+ size_t free_word_size_no_commit() const { return _committed_words - _used_words; }
+
+ // Returns the number of free words in total, including uncommitted area.
+ size_t free_word_size_total() const { return word_size() - _used_words; }
+
+ bool is_empty() const { return _used_words == 0; }
+ bool is_fully_committed() const { return _committed_words == word_size(); }
+
+ /////////////
+ // Allocation, commit, uncommit
+
+ // Allocate from chunk.
+ // This may fail and return NULL due to the following reasons:
+ // - the chunk may be too small to hold the allocation (did_hit_commit_limit will be false).
+ // - chunk needed to expand his commit top to hold the allocation, but that failed because we hit a
+ // limit (GC threshold or metaspace limit) (did_hit_commit_limit will be true).
+ // Returns pointer to allocation, or NULL.
+ MetaWord* allocate(size_t requested_word_size, bool& did_hit_commit_limit);
+
+ /////////////
+ // Splitting
+
+ // Given a chunk c, split it two chunks.
+ // - chunk must be free
+ // - chunk must be committed far enough to include the header of the new
+ // buddy chunk
+ // - if chunk is of the smallest size already and cannot split anymore,
+ // false is ret
+ // Returns true if success.
+ // This operation succeeds unless the chunk is of the smallest level already
+ // in which case NULL is returned.
+ static bool split(Metachunk* c, Metachunk** p_leader, Metachunk** p_follower);
+
+ /////////////
+ // Merging
- // 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;
+ // Chunk merging means a chunk is merged with its buddy. The resulting
+ // chunk occupies the area of both former chunks. Its level will be increased by 1.
+ // (x marks the header):
+ //
+ // before: |x |x |
+ //
+ // after: |x |
+ //
+ // The result chunk will be committed according to following rules:
+ // 1) if the first chunk was completely committed, result chunk will be as far committed
+ // as the second chunk was committed (dashes mark the committed area):
+ //
+ // before: |-------|---- |
+ //
+ // after: |------------ |
+ //
+ // Obviously, this means that if the second chunk was completely committed, the
+ // result chunk will be completely committed too:
+ //
+ // before: |-------|-------|
+ //
+ // after: |---------------|
+ //
+ // 2) if the first chunk was not completely committed, result chunk will be as far committed
+ // as the first chunk, and will carry over the size of the committed area of the second chunk
+ // in the "_abandoned_committed_words" member:
+ //
+ // before: |--- |------ | _abandoned_committed_words = 0
+ //
+ // after: |--- | _abandoned_committed_words = sizeof(------)
+ //
+ // _abandoned_committed_words accumulates with each subsequent merge. After a sequence of merges,
+ // it carries over the sum of all committed "abandoned" regions in the follower chunks.
+ //
+ //
- bool is_tagged_free() { return _is_tagged_free; }
- void set_is_tagged_free(bool v) { _is_tagged_free = v; }
+ // Attempt to merge this chunk with its buddy.
+ // This succeeds if:
+ // - the chunk is not of the highest level (root chunks have no buddies).
+ // - the buddy is free
+ // If successful, a pointer to the new chunk is returned.
+ // !! In that case, the original "this" pointer will be invalid; do not access it anymore !!
+ // If failed, will return NULL.
+ Metachunk* try_merge();
+
+ /////////////
+ // Free/in use
+
+ bool is_free() const { return _is_free; }
+ void set_free() { _is_free = true; }
+ void set_in_use() { _is_free = false; }
+
- bool contains(const void* ptr) { return bottom() <= ptr && ptr < _top; }
+ /////////////
+ // List stuff
+
+ void set_prev(Metachunk* c) { _prev = c; }
+ void set_next(Metachunk* c) { _next = c; }
+ Metachunk* prev() const { return _prev; }
+ Metachunk* next() const { return _next; }
+ // Remove chunk from whatever list it lives in by wiring next with previous.
+ // In debug case, zeros out _next, _prev.
+ void remove_from_list();
+
+ //////////////
+ // Debugging aids
+
+ bool contains(const void* ptr) const {
+ return base() <= ptr && ptr < top();
+ }
void print_on(outputStream* st) const;
+#ifdef ASSERT
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; }
+#endif
DEBUG_ONLY(void mangle(juint word_value);)
DEBUG_ONLY(void verify() const;)
};
-
-// 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);
-
} // namespace metaspace
#endif // SHARE_MEMORY_METASPACE_METACHUNK_HPP
--- a/src/hotspot/share/memory/metaspace/metaspaceCommon.cpp Wed Jul 10 05:12:23 2019 +0100
+++ b/src/hotspot/share/memory/metaspace/metaspaceCommon.cpp Mon Jul 08 22:30:19 2019 +0200
@@ -130,70 +130,6 @@
}
}
-// 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";
}
--- a/src/hotspot/share/memory/metaspace/metaspaceCommon.hpp Wed Jul 10 05:12:23 2019 +0100
+++ b/src/hotspot/share/memory/metaspace/metaspaceCommon.hpp Mon Jul 08 22:30:19 2019 +0200
@@ -33,14 +33,6 @@
namespace metaspace {
-enum ChunkSizes { // in words.
- ClassSpecializedChunk = 128,
- SpecializedChunk = 128,
- ClassSmallChunk = 256,
- SmallChunk = 512,
- ClassMediumChunk = 4 * K,
- MediumChunk = 8 * K
-};
// Print a size, in words, scaled.
void print_scaled_words(outputStream* st, size_t word_size, size_t scale = 0, int width = -1);
@@ -98,48 +90,6 @@
extern internal_statistics_t g_internal_statistics;
#endif
-// ChunkIndex defines the type of chunk.
-// Chunk types differ by size: specialized < small < medium, chunks
-// larger than medium are humongous chunks of varying size.
-enum ChunkIndex {
- ZeroIndex = 0,
- SpecializedIndex = ZeroIndex,
- SmallIndex = SpecializedIndex + 1,
- MediumIndex = SmallIndex + 1,
- HumongousIndex = MediumIndex + 1,
- NumberOfFreeLists = 3,
- NumberOfInUseLists = 4
-};
-
-// Utility functions.
-size_t get_size_for_nonhumongous_chunktype(ChunkIndex chunk_type, bool is_class);
-ChunkIndex get_chunk_type_by_size(size_t size, bool is_class);
-
-ChunkIndex next_chunk_index(ChunkIndex i);
-ChunkIndex prev_chunk_index(ChunkIndex i);
-// Returns a descriptive name for a chunk type.
-const char* chunk_size_name(ChunkIndex index);
-
-// Verify chunk sizes.
-inline bool is_valid_chunksize(bool is_class, size_t size) {
- const size_t reasonable_maximum_humongous_chunk_size = 1 * G;
- return is_aligned(size, sizeof(MetaWord)) &&
- size < reasonable_maximum_humongous_chunk_size &&
- is_class ?
- (size == ClassSpecializedChunk || size == ClassSmallChunk || size >= ClassMediumChunk) :
- (size == SpecializedChunk || size == SmallChunk || size >= MediumChunk);
-}
-
-// Verify chunk type.
-inline bool is_valid_chunktype(ChunkIndex index) {
- return index == SpecializedIndex || index == SmallIndex ||
- index == MediumIndex || index == HumongousIndex;
-}
-
-inline bool is_valid_nonhumongous_chunktype(ChunkIndex index) {
- return is_valid_chunktype(index) && index != HumongousIndex;
-}
-
// Pretty printing helpers
const char* classes_plural(uintx num);
const char* loaders_plural(uintx num);
--- a/src/hotspot/share/memory/metaspace/occupancyMap.cpp Wed Jul 10 05:12:23 2019 +0100
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -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
-
-
--- a/src/hotspot/share/memory/metaspace/occupancyMap.hpp Wed Jul 10 05:12:23 2019 +0100
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -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
--- a/src/hotspot/share/memory/metaspace/spaceManager.cpp Wed Jul 10 05:12:23 2019 +0100
+++ b/src/hotspot/share/memory/metaspace/spaceManager.cpp Mon Jul 08 22:30:19 2019 +0200
@@ -39,489 +39,24 @@
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::UnsafeAnonymousMetaspaceType: 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::UnsafeAnonymousMetaspaceType: 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 unsafe anonymous metadata space.
- // UnsafeAnonymous metadata space is usually small since it is used for
- // class loader data's whose life cycle is governed by one class such as an
- // 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::UnsafeAnonymousMetaspaceType || _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);
+SpaceManager::SpaceManager(ChunkManager* chunk_manager, const ChunkAllocSequence* alloc_sequence, Mutex* lock)
+ : _lock(lock)
+ , _chunk_manager(chunk_manager)
+ , _chunk_alloc_sequence(alloc_sequence)
+ , _first_chunk(NULL)
+ , _current_chunk(NULL)
+ , _block_freelist(NULL)
+ , _overhead_words(0)
+ , _capacity_words(0)
+ , _used_words(0)
+ , _num_chunks_by_type {}
+{
- 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
--- a/src/hotspot/share/memory/metaspace/spaceManager.hpp Wed Jul 10 05:12:23 2019 +0100
+++ b/src/hotspot/share/memory/metaspace/spaceManager.hpp Mon Jul 08 22:30:19 2019 +0200
@@ -28,206 +28,87 @@
#include "memory/allocation.hpp"
#include "memory/metaspace.hpp"
#include "memory/metaspace/blockFreelist.hpp"
+#include "memory/metaspace/chunkAllocSequence.hpp"
+#include "memory/metaspace/chunkManager.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
+
+// The SpaceManager:
+// - keeps a list of chunks-in-use by the class loader, as well as a current chunk used
+// to allocate from
+// - keeps a dictionary of free MetaBlocks. Those can be remnants of a retired chunk or
+// allocations which were not needed anymore for some reason (e.g. releasing half-allocated
+// structures when class loading fails)
+
class SpaceManager : public CHeapObj<mtClass> {
- friend class ::ClassLoaderMetaspace;
- friend class Metadebug;
- private:
-
- // protects allocations
+ // Lock handed down from the associated ClassLoaderData.
+ // Protects allocations from this space.
Mutex* const _lock;
- // Type of metadata allocated.
- const Metaspace::MetadataType _mdtype;
+ // The chunk manager to allocate chunks from.
+ ChunkManager* const _chunk_manager;
- // Type of metaspace
- const Metaspace::MetaspaceType _space_type;
+ // The chunk allocation strategy to use.
+ const ChunkAllocSequence* const _chunk_alloc_sequence;
// 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* _first_chunk;
Metachunk* _current_chunk;
- enum {
+ // Prematurely released metablocks.
+ BlockFreelist* _block_freelist;
- // 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,
+ // Statistics
- 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.
+ // Running counters.
// 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];
+ uint32_t _num_chunks_by_type[NUM_CHUNK_LEVELS];
- // 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); }
+ Mutex* lock() const { return _lock; }
+ ChunkManager* chunk_manager() const { return _chunk_manager; }
+ const ChunkAllocSequence* chunk_alloc_sequence() const { return _chunk_alloc_sequence; }
- Metachunk* current_chunk() const { return _current_chunk; }
- void set_current_chunk(Metachunk* v) {
- _current_chunk = v;
- }
+ Metachunk* first_chunk() { return _first_chunk; }
+ BlockFreelist* block_freelist(); // created on demand only
- 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);
+ // The current chunk is unable to service a request. The remainder of the chunk is
+ // chopped into blocks and fed into the _block_freelists, in the hope of later reuse.
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;
+public:
- // Verify internal counters against the current state. Expects to be locked with lock().
- DEBUG_ONLY(void verify_metrics_locked() const;)
+ SpaceManager(ChunkManager* chunk_manager, const ChunkAllocSequence* alloc_sequence, Mutex* lock);
- 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
+ // Allocate memory from Metaspace. Will attempt to allocate from the _block_freelists,
+ // failing that, from the current chunk; failing that, attempt to get a new chunk from
+ // the associated ChunkManager.
MetaWord* allocate(size_t word_size);
- // Helper for allocations
- MetaWord* allocate_work(size_t word_size);
-
- // Returns a block to the per manager freelist
+ // Prematurely returns a metaspace allocation to the _block_freelists because it is not
+ // needed anymore.
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;)
+ // Run verifications. slow=true: verify chunk-internal integrity too.
+ DEBUG_ONLY(void locked_verify(bool slow) const;)
};
-
} // namespace metaspace
#endif // SHARE_MEMORY_METASPACE_SPACEMANAGER_HPP
--- a/src/hotspot/share/memory/metaspace/virtualSpaceList.cpp Wed Jul 10 05:12:23 2019 +0100
+++ b/src/hotspot/share/memory/metaspace/virtualSpaceList.cpp Mon Jul 08 22:30:19 2019 +0200
@@ -103,7 +103,7 @@
// 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());
+ ", used: " SIZE_FORMAT ").", p2i(vsl), vsl->committed_words(), vsl->used_words());
DEBUG_ONLY(Atomic::inc(&g_internal_statistics.num_vsnodes_purged));
// Unlink it from the list
if (prev_vsl == vsl) {
--- a/src/hotspot/share/memory/metaspace/virtualSpaceList.hpp Wed Jul 10 05:12:23 2019 +0100
+++ b/src/hotspot/share/memory/metaspace/virtualSpaceList.hpp Mon Jul 08 22:30:19 2019 +0200
@@ -33,134 +33,53 @@
namespace metaspace {
class Metachunk;
-class ChunkManager;
+
+class VirtualSpaceList : public public CHeapObj<mtClass> {
-// List of VirtualSpaces for metadata allocation.
-class VirtualSpaceList : public CHeapObj<mtClass> {
- friend class VirtualSpaceNode;
+ // Name
+ const char* const _name;
- enum VirtualSpaceSizes {
- VirtualSpaceSize = 256 * K
- };
+ // Head of the list.
+ VirtualSpaceNode* _nodes;
- // Head of the list
- VirtualSpaceNode* _virtual_space_list;
- // virtual space currently being used for allocations
- VirtualSpaceNode* _current_virtual_space;
+ // Node currently being used for allocations.
+ VirtualSpaceNode* _current_node;
- // Is this VirtualSpaceList used for the compressed class space
- bool _is_class;
+ // Whether this list can expand by allocating new nodes.
+ const bool _can_expand;
- // Sum of reserved and committed memory in the virtual spaces
+ // Statistics:
+
+ // Sum of reserved and committed words in all nodes
size_t _reserved_words;
size_t _committed_words;
// Number of virtual spaces
- size_t _virtual_space_count;
+ int _count;
+
+public:
- // 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;
+ // Create a new, empty, expandable list.
+ VirtualSpaceList(const char* name);
- bool is_within_envelope(address p) const {
- return p >= _envelope_lo && p < _envelope_hi;
- }
-
- // Given a node, expand range such that it includes the node.
- void expand_envelope_to_include_node(const VirtualSpaceNode* node);
+ // Create a new list. The list will contain one node, which uses the given ReservedSpace.
+ // It will be not expandable beyond that first node.
+ VirtualSpaceList(const char* name, ReservedSpace* rs);
~VirtualSpaceList();
- VirtualSpaceNode* virtual_space_list() const { return _virtual_space_list; }
-
- void set_virtual_space_list(VirtualSpaceNode* v) {
- _virtual_space_list = v;
- }
- void set_current_virtual_space(VirtualSpaceNode* v) {
- _current_virtual_space = v;
- }
-
- void link_vs(VirtualSpaceNode* new_entry);
-
- // 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);
-
- // Chunk up the unused committed space in the current
- // virtual space and add the chunks to the free list.
- void retire_current_virtual_space();
-
- DEBUG_ONLY(bool contains_node(const VirtualSpaceNode* node) const;)
-
- public:
- VirtualSpaceList(size_t word_size);
- VirtualSpaceList(ReservedSpace rs);
-
- size_t free_bytes();
-
- Metachunk* get_new_chunk(size_t chunk_word_size,
- size_t suggested_commit_granularity);
+ // Allocate a root chunk from the current node in this list.
+ // - If the node is full and the list is expandable, a new node may be created.
+ // - This may fail if we either hit the GC threshold or the metaspace limits.
+ // Returns NULL if it failed.
+ Metachunk* allocate_root_chunk();
- bool expand_node_by(VirtualSpaceNode* node,
- size_t min_words,
- size_t preferred_words);
-
- bool expand_by(size_t min_words,
- size_t preferred_words);
-
- VirtualSpaceNode* current_virtual_space() {
- return _current_virtual_space;
- }
-
- bool is_class() const { return _is_class; }
-
- bool initialization_succeeded() { return _virtual_space_list != NULL; }
-
- 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; }
-
- 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();
-
- 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;
+ // Remove all nodes which only contain empty chunks from the list,
+ // remove the chunks from the ChunkManager, and unmap those nodes.
+ void purge();
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
--- a/src/hotspot/share/memory/metaspace/virtualSpaceNode.cpp Wed Jul 10 05:12:23 2019 +0100
+++ b/src/hotspot/share/memory/metaspace/virtualSpaceNode.cpp Mon Jul 08 22:30:19 2019 +0200
@@ -42,6 +42,35 @@
namespace metaspace {
+
+// Create a new empty node of the given size. Memory will be reserved but
+// completely uncommitted.
+VirtualSpaceNode::VirtualSpaceNode(size_t wordsize)
+ : _next(NULL)
+ , _rs()
+ , _virtual_space()
+ , _top(NULL)
+{
+}
+
+// Create a new empty node spanning the given reserved space.
+VirtualSpaceNode::VirtualSpaceNode(ReservedSpace rs)
+ : _next(NULL)
+ , _rs(rs)
+ , _virtual_space()
+ , _top(NULL)
+{}
+
+
+
+
+
+
+
+
+
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
// 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()) {
@@ -56,9 +85,10 @@
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) {
+VirtualSpaceNode::VirtualSpaceNode(size_t bytes) :
+ _next(NULL), _rs(), _top(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);
@@ -73,16 +103,36 @@
}
}
+VirtualSpaceNode::VirtualSpaceNode(ReservedSpace rs) : _next(NULL), _rs(rs), _top(NULL) {}
+
+// Checks if the node can be purged.
+// This iterates through the chunks and checks if all are free.
+// This should be quite fast since if all chunks are free they should have been crystallized to 1-2 root chunks
+// (a non-class node is only a few MB itself). For class space, it makes no sense to call this since it cannot
+// be purged anyway.
+bool VirtualSpaceNode::purgable() const {
+ Metachunk* chunk = first_chunk();
+ Metachunk* invalid_chunk = (Metachunk*) top();
+ while (chunk < invalid_chunk ) {
+ if (chunk->is_free() == false) {
+ return false;
+ }
+ MetaWord* next = ((MetaWord*)chunk) + chunk->word_size();
+ chunk = (Metachunk*) next;
+ }
+ return true;
+}
+
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");
+ assert(chunk->is_free(), "Should be free");
MetaWord* next = ((MetaWord*)chunk) + chunk->word_size();
chunk_manager->remove_chunk(chunk);
- chunk->remove_sentinel();
+ DEBUG_ONLY(chunk->remove_sentinel();)
assert(chunk->next() == NULL &&
chunk->prev() == NULL,
"Was not removed from its list");
@@ -91,7 +141,7 @@
}
void VirtualSpaceNode::print_map(outputStream* st, bool is_class) const {
-
+/*
if (bottom() == top()) {
return;
}
@@ -168,7 +218,7 @@
}
for (int i = 0; i < NUM_LINES; i ++) {
os::free(lines[i]);
- }
+ }*/
}
@@ -266,235 +316,60 @@
}
#endif // ASSERT
-void VirtualSpaceNode::inc_container_count() {
- assert_lock_strong(MetaspaceExpand_lock);
- _container_count++;
-}
-
-void VirtualSpaceNode::dec_container_count() {
- assert_lock_strong(MetaspaceExpand_lock);
- _container_count--;
-}
-
VirtualSpaceNode::~VirtualSpaceNode() {
_rs.release();
- if (_occupancy_map != NULL) {
- delete _occupancy_map;
- }
-#ifdef ASSERT
- size_t word_size = sizeof(*this) / BytesPerWord;
- Copy::fill_to_words((HeapWord*) this, word_size, 0xf1f1f1f1);
-#endif
-}
-
-size_t VirtualSpaceNode::used_words_in_vs() const {
- return pointer_delta(top(), bottom(), sizeof(MetaWord));
-}
-
-// 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");
+// Allocate a root chunk (a chunk of max. size) from the the virtual space and add it to the
+// specified chunk manager as free chunk.
+void VirtualSpaceNode::allocate_new_chunk(ChunkManager* chunk_manager) {
- // 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();
+ assert_is_aligned(top(), MAX_CHUNK_BYTE_SIZE);
- while (top() < target_top) {
+ assert_is_aligned(uncommitted_words(), MAX_CHUNK_WORD_SIZE);
+ assert_is_aligned(unused_words(), MAX_CHUNK_WORD_SIZE);
+ assert_is_aligned(used_words(), MAX_CHUNK_WORD_SIZE);
- // 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);
+ // Caller must check, before calling this method, if node needs expansion.
+ assert(unused_words() >= MAX_CHUNK_WORD_SIZE, "Needs expansion.");
+
+ // Create new root chunk
+ MetaWord* loc = top();
+ inc_top(MAX_CHUNK_WORD_SIZE);
+ Metachunk* new_chunk = ::new (loc) Metachunk(HIGHEST_CHUNK_LEVEL, this, true);
- // 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");
+ // Add it to the chunk manager
+ new_chunk->set_in_use();
+ chunk_manager->return_chunk(new_chunk);
- 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));
+}
+
+// Expands the committed portion of this node by the size of a root chunk. Will assert
+// if expansion is impossible.
+bool VirtualSpaceNode::expand() {
- // Mark chunk start in occupancy map.
- occupancy_map()->set_chunk_starts_at_address((MetaWord*)padding_chunk, true);
+ assert_is_aligned(uncommitted_words(), MAX_CHUNK_WORD_SIZE);
- // 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);
+ // Caller must check, before calling this method, if node needs expansion.
+ assert(uncommitted_words() >= MAX_CHUNK_WORD_SIZE, "Node used up completely.");
- // 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.
+ bool result = virtual_space()->expand_by(MAX_CHUNK_BYTE_SIZE, false);
+
+ if (result) {
+ log_trace(gc, metaspace, freelist)("Expanded virtual space list node by " SIZE_FORMAT " words.", MAX_CHUNK_BYTE_SIZE);
+ DEBUG_ONLY(Atomic::inc(&g_internal_statistics.num_committed_space_expanded));
+ } else {
+ log_trace(gc, metaspace, freelist)("Failed to expand virtual space list node by " SIZE_FORMAT " words.", MAX_CHUNK_BYTE_SIZE);
}
- 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;
- }
+ assert(result, "Failed to commit memory");
- // 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();
+ assert(unused_words() >= MAX_CHUNK_WORD_SIZE, "sanity");
return result;
}
-// Expand the virtual space (commit more of the reserved space)
-bool VirtualSpaceNode::expand_by(size_t min_words, size_t preferred_words) {
- size_t min_bytes = min_words * BytesPerWord;
- size_t preferred_bytes = preferred_words * BytesPerWord;
-
- size_t uncommitted = virtual_space()->reserved_size() - virtual_space()->actual_committed_size();
-
- if (uncommitted < min_bytes) {
- return false;
- }
-
- size_t commit = MIN2(preferred_bytes, uncommitted);
- bool result = virtual_space()->expand_by(commit, false);
-
- if (result) {
- log_trace(gc, metaspace, freelist)("Expanded %s virtual space list node by " SIZE_FORMAT " words.",
- (is_class() ? "class" : "non-class"), commit);
- DEBUG_ONLY(Atomic::inc(&g_internal_statistics.num_committed_space_expanded));
- } else {
- log_trace(gc, metaspace, freelist)("Failed to expand %s virtual space list node by " SIZE_FORMAT " words.",
- (is_class() ? "class" : "non-class"), commit);
- }
-
- assert(result, "Failed to commit memory");
-
- return result;
-}
-
-Metachunk* VirtualSpaceNode::get_chunk_vs(size_t chunk_word_size) {
- assert_lock_strong(MetaspaceExpand_lock);
- Metachunk* result = take_from_committed(chunk_word_size);
- return result;
-}
-
bool VirtualSpaceNode::initialize() {
if (!_rs.is_reserved()) {
@@ -521,10 +396,6 @@
set_top((MetaWord*)virtual_space()->low());
}
- // Initialize Occupancy Map.
- const size_t smallest_chunk_size = is_class() ? ClassSpecializedChunk : SpecializedChunk;
- _occupancy_map = new OccupancyMap(bottom(), reserved_words(), smallest_chunk_size);
-
return result;
}
--- a/src/hotspot/share/memory/metaspace/virtualSpaceNode.hpp Wed Jul 10 05:12:23 2019 +0100
+++ b/src/hotspot/share/memory/metaspace/virtualSpaceNode.hpp Mon Jul 08 22:30:19 2019 +0200
@@ -35,129 +35,97 @@
namespace metaspace {
class Metachunk;
-class ChunkManager;
-class OccupancyMap;
+
+
+
+// A node in the VirtualSpaceList.
+//
+// VirtualSpaceNodes manage a single address range and a commit high water mark.
+//
+// The address range start and end are aligned to the highest Metachunk size (root chunk size)
+// and memory is only ever requested in units of one root chunk size.
+//
+class VirtualSpaceNode : public CHeapObj<mtClass> {
-// A VirtualSpaceList node.
-class VirtualSpaceNode : public CHeapObj<mtClass> {
- friend class VirtualSpaceList;
+ /////////////////////////////////
+ //
+ // |--------------------- end()
+ // |
+ // | (uncommitted) = words_uncommitted()
+ // |
+ // |--------------------- commit_top()
+ // |
+ // | (committed unused) = words_committed_unused()
+ // |
+ // |--------------------- top()
+ // |
+ // | (committed used) = words_used()
+ // |
+ // |
+ // |
+ // |-------------------- start()
+ //
// Link to next VirtualSpaceNode
VirtualSpaceNode* _next;
- // Whether this node is contained in class or metaspace.
- const bool _is_class;
-
- // total in the VirtualSpace
ReservedSpace _rs;
VirtualSpace _virtual_space;
- MetaWord* _top;
- // count of chunks contained in this VirtualSpace
- uintx _container_count;
- OccupancyMap* _occupancy_map;
+ // Current allocated words
+ size_t _used_words;
+
+ // Current committed words
+ size_t _committed_words;
- // 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(); }
+ VirtualSpace* virtual_space() const { return _virtual_space; }
- // The first Metachunk will be allocated at the bottom of the
- // VirtualSpace
- Metachunk* first_chunk() { return (Metachunk*) bottom(); }
+ MetaWord* start() const {
+ assert(virtual_space()->low() == virtual_space()->low_boundary(), "sanity");
+ return (MetaWord*) virtual_space()->low_boundary();
+ }
+
+ // End of the used area.
+ MetaWord* top() const { return start() + _used_words; }
- // Committed but unused space in the virtual space
- size_t free_words_in_vs() const;
+ // End of the committed area.
+ MetaWord* commit_top() const {
+ assert(virtual_space()->high() == start() + _committed_words, "sanity");
+ return start() + _committed_words;
+ }
- // True if this node belongs to class metaspace.
- bool is_class() const { return _is_class; }
+ // End of the reserved space; highest address in this node.
+ MetaWord* end() const { return virtual_space()->high_boundary(); }
- // 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);
+public:
- public:
+ // Create a new empty node of the given size. Memory will be reserved but
+ // completely uncommitted.
+ VirtualSpaceNode(size_t wordsize);
- 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) {}
+ // Create a new empty node spanning the given reserved space.
+ VirtualSpaceNode(ReservedSpace rs);
+
+ // Releases the node memory.
~VirtualSpaceNode();
- // Convenience functions for logical bottom and end
- MetaWord* bottom() const { return (MetaWord*) _virtual_space.low(); }
- MetaWord* end() const { return (MetaWord*) _virtual_space.high(); }
-
- const OccupancyMap* occupancy_map() const { return _occupancy_map; }
- OccupancyMap* occupancy_map() { return _occupancy_map; }
-
- bool contains(const void* ptr) { return ptr >= low() && ptr < high(); }
-
- size_t reserved_words() const { return _virtual_space.reserved_size() / BytesPerWord; }
- size_t committed_words() const { return _virtual_space.actual_committed_size() / BytesPerWord; }
-
- bool is_pre_committed() const { return _virtual_space.special(); }
-
- // address of next available space in _virtual_space;
- // Accessors
- VirtualSpaceNode* next() { return _next; }
- void set_next(VirtualSpaceNode* v) { _next = v; }
-
- void set_top(MetaWord* v) { _top = v; }
-
- // Accessors
- VirtualSpace* virtual_space() const { return (VirtualSpace*) &_virtual_space; }
+ // Allocate a root chunk from this node. Will fail and return NULL
+ // if the node is full.
+ Metachunk* allocate_root_chunk();
- // 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)); }
-
- MetaWord* top() const { return _top; }
- void inc_top(size_t word_size) { _top += word_size; }
-
- uintx container_count() { return _container_count; }
- void inc_container_count();
- void dec_container_count();
-
- // 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 true if this node can be purged (all chunks are free).
+ bool can_be_purged() const;
- bool initialize();
-
- // get space from the virtual space
- Metachunk* take_from_committed(size_t chunk_word_size);
-
- // Allocate a chunk from the virtual space and return it.
- Metachunk* get_chunk_vs(size_t chunk_word_size);
-
- // Expands the committed space by at least min_words words.
- bool expand_by(size_t min_words, size_t preferred_words);
-
- // In preparation for deleting this node, remove all the chunks
- // in the node from any freelist.
+ // Purge this node: remove all the chunks in the node from the given chunk manager.
+ // Assumption: all chunks are free (see can_be_purged()).
void purge(ChunkManager* chunk_manager);
- // 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);
-
- 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;
-
- // Debug support
- DEBUG_ONLY(void mangle();)
- // Verify counters and basic structure. Slow mode: verify all chunks in depth and occupancy map.
+ // Verify counters and basic structure. Slow mode: verify all chunks in depth
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();)
};
+
} // namespace metaspace
#endif // SHARE_MEMORY_METASPACE_VIRTUALSPACENODE_HPP