8023476: Metaspace capacity > reserved
Reviewed-by: stefank, hseigel, mgerdin
This commit is contained in:
Erik Helin
parent
2317db6d5a
commit
dfd2d9a574
@ -87,15 +87,15 @@ MetaspaceSummary CollectedHeap::create_metaspace_summary() {
|
||||
const MetaspaceSizes meta_space(
|
||||
MetaspaceAux::allocated_capacity_bytes(),
|
||||
MetaspaceAux::allocated_used_bytes(),
|
||||
MetaspaceAux::reserved_in_bytes());
|
||||
MetaspaceAux::reserved_bytes());
|
||||
const MetaspaceSizes data_space(
|
||||
MetaspaceAux::allocated_capacity_bytes(Metaspace::NonClassType),
|
||||
MetaspaceAux::allocated_used_bytes(Metaspace::NonClassType),
|
||||
MetaspaceAux::reserved_in_bytes(Metaspace::NonClassType));
|
||||
MetaspaceAux::reserved_bytes(Metaspace::NonClassType));
|
||||
const MetaspaceSizes class_space(
|
||||
MetaspaceAux::allocated_capacity_bytes(Metaspace::ClassType),
|
||||
MetaspaceAux::allocated_used_bytes(Metaspace::ClassType),
|
||||
MetaspaceAux::reserved_in_bytes(Metaspace::ClassType));
|
||||
MetaspaceAux::reserved_bytes(Metaspace::ClassType));
|
||||
|
||||
return MetaspaceSummary(meta_space, data_space, class_space);
|
||||
}
|
||||
|
||||
@ -177,8 +177,8 @@ class ChunkManager VALUE_OBJ_CLASS_SPEC {
|
||||
void return_chunks(ChunkIndex index, Metachunk* chunks);
|
||||
|
||||
// Total of the space in the free chunks list
|
||||
size_t free_chunks_total();
|
||||
size_t free_chunks_total_in_bytes();
|
||||
size_t free_chunks_total_words();
|
||||
size_t free_chunks_total_bytes();
|
||||
|
||||
// Number of chunks in the free chunks list
|
||||
size_t free_chunks_count();
|
||||
@ -1080,12 +1080,12 @@ size_t VirtualSpaceList::used_words_sum() {
|
||||
// Sum used region [bottom, top) in each virtualspace
|
||||
allocated_by_vs += vsl->used_words_in_vs();
|
||||
}
|
||||
assert(allocated_by_vs >= chunk_manager()->free_chunks_total(),
|
||||
assert(allocated_by_vs >= chunk_manager()->free_chunks_total_words(),
|
||||
err_msg("Total in free chunks " SIZE_FORMAT
|
||||
" greater than total from virtual_spaces " SIZE_FORMAT,
|
||||
allocated_by_vs, chunk_manager()->free_chunks_total()));
|
||||
allocated_by_vs, chunk_manager()->free_chunks_total_words()));
|
||||
size_t used =
|
||||
allocated_by_vs - chunk_manager()->free_chunks_total();
|
||||
allocated_by_vs - chunk_manager()->free_chunks_total_words();
|
||||
return used;
|
||||
}
|
||||
|
||||
@ -1526,7 +1526,7 @@ void Metadebug::deallocate_chunk_a_lot(SpaceManager* sm,
|
||||
sm->sum_count_in_chunks_in_use());
|
||||
dummy_chunk->print_on(gclog_or_tty);
|
||||
gclog_or_tty->print_cr(" Free chunks total %d count %d",
|
||||
vsl->chunk_manager()->free_chunks_total(),
|
||||
vsl->chunk_manager()->free_chunks_total_words(),
|
||||
vsl->chunk_manager()->free_chunks_count());
|
||||
}
|
||||
}
|
||||
@ -1583,12 +1583,12 @@ bool Metadebug::test_metadata_failure() {
|
||||
|
||||
// ChunkManager methods
|
||||
|
||||
size_t ChunkManager::free_chunks_total() {
|
||||
size_t ChunkManager::free_chunks_total_words() {
|
||||
return _free_chunks_total;
|
||||
}
|
||||
|
||||
size_t ChunkManager::free_chunks_total_in_bytes() {
|
||||
return free_chunks_total() * BytesPerWord;
|
||||
size_t ChunkManager::free_chunks_total_bytes() {
|
||||
return free_chunks_total_words() * BytesPerWord;
|
||||
}
|
||||
|
||||
size_t ChunkManager::free_chunks_count() {
|
||||
@ -2567,13 +2567,13 @@ size_t MetaspaceAux::used_bytes_slow(Metaspace::MetadataType mdtype) {
|
||||
return used * BytesPerWord;
|
||||
}
|
||||
|
||||
size_t MetaspaceAux::free_in_bytes(Metaspace::MetadataType mdtype) {
|
||||
size_t MetaspaceAux::free_bytes_slow(Metaspace::MetadataType mdtype) {
|
||||
size_t free = 0;
|
||||
ClassLoaderDataGraphMetaspaceIterator iter;
|
||||
while (iter.repeat()) {
|
||||
Metaspace* msp = iter.get_next();
|
||||
if (msp != NULL) {
|
||||
free += msp->free_words(mdtype);
|
||||
free += msp->free_words_slow(mdtype);
|
||||
}
|
||||
}
|
||||
return free * BytesPerWord;
|
||||
@ -2596,34 +2596,51 @@ size_t MetaspaceAux::capacity_bytes_slow(Metaspace::MetadataType mdtype) {
|
||||
return capacity * BytesPerWord;
|
||||
}
|
||||
|
||||
size_t MetaspaceAux::reserved_in_bytes(Metaspace::MetadataType mdtype) {
|
||||
VirtualSpaceList* list = Metaspace::get_space_list(mdtype);
|
||||
return list == NULL ? 0 : list->virtual_space_total();
|
||||
size_t MetaspaceAux::capacity_bytes_slow() {
|
||||
#ifdef PRODUCT
|
||||
// Use allocated_capacity_bytes() in PRODUCT instead of this function.
|
||||
guarantee(false, "Should not call capacity_bytes_slow() in the PRODUCT");
|
||||
#endif
|
||||
size_t class_capacity = capacity_bytes_slow(Metaspace::ClassType);
|
||||
size_t non_class_capacity = capacity_bytes_slow(Metaspace::NonClassType);
|
||||
assert(allocated_capacity_bytes() == class_capacity + non_class_capacity,
|
||||
err_msg("bad accounting: allocated_capacity_bytes() " SIZE_FORMAT
|
||||
" class_capacity + non_class_capacity " SIZE_FORMAT
|
||||
" class_capacity " SIZE_FORMAT " non_class_capacity " SIZE_FORMAT,
|
||||
allocated_capacity_bytes(), class_capacity + non_class_capacity,
|
||||
class_capacity, non_class_capacity));
|
||||
|
||||
return class_capacity + non_class_capacity;
|
||||
}
|
||||
|
||||
size_t MetaspaceAux::min_chunk_size() { return Metaspace::first_chunk_word_size(); }
|
||||
size_t MetaspaceAux::reserved_bytes(Metaspace::MetadataType mdtype) {
|
||||
VirtualSpaceList* list = Metaspace::get_space_list(mdtype);
|
||||
return list == NULL ? 0 : list->virtual_space_total() * BytesPerWord;
|
||||
}
|
||||
|
||||
size_t MetaspaceAux::free_chunks_total(Metaspace::MetadataType mdtype) {
|
||||
size_t MetaspaceAux::min_chunk_size_words() { return Metaspace::first_chunk_word_size(); }
|
||||
|
||||
size_t MetaspaceAux::free_chunks_total_words(Metaspace::MetadataType mdtype) {
|
||||
VirtualSpaceList* list = Metaspace::get_space_list(mdtype);
|
||||
if (list == NULL) {
|
||||
return 0;
|
||||
}
|
||||
ChunkManager* chunk = list->chunk_manager();
|
||||
chunk->slow_verify();
|
||||
return chunk->free_chunks_total();
|
||||
return chunk->free_chunks_total_words();
|
||||
}
|
||||
|
||||
size_t MetaspaceAux::free_chunks_total_in_bytes(Metaspace::MetadataType mdtype) {
|
||||
return free_chunks_total(mdtype) * BytesPerWord;
|
||||
size_t MetaspaceAux::free_chunks_total_bytes(Metaspace::MetadataType mdtype) {
|
||||
return free_chunks_total_words(mdtype) * BytesPerWord;
|
||||
}
|
||||
|
||||
size_t MetaspaceAux::free_chunks_total() {
|
||||
return free_chunks_total(Metaspace::ClassType) +
|
||||
free_chunks_total(Metaspace::NonClassType);
|
||||
size_t MetaspaceAux::free_chunks_total_words() {
|
||||
return free_chunks_total_words(Metaspace::ClassType) +
|
||||
free_chunks_total_words(Metaspace::NonClassType);
|
||||
}
|
||||
|
||||
size_t MetaspaceAux::free_chunks_total_in_bytes() {
|
||||
return free_chunks_total() * BytesPerWord;
|
||||
size_t MetaspaceAux::free_chunks_total_bytes() {
|
||||
return free_chunks_total_words() * BytesPerWord;
|
||||
}
|
||||
|
||||
void MetaspaceAux::print_metaspace_change(size_t prev_metadata_used) {
|
||||
@ -2634,14 +2651,14 @@ void MetaspaceAux::print_metaspace_change(size_t prev_metadata_used) {
|
||||
"(" SIZE_FORMAT ")",
|
||||
prev_metadata_used,
|
||||
allocated_used_bytes(),
|
||||
reserved_in_bytes());
|
||||
reserved_bytes());
|
||||
} else {
|
||||
gclog_or_tty->print(" " SIZE_FORMAT "K"
|
||||
"->" SIZE_FORMAT "K"
|
||||
"(" SIZE_FORMAT "K)",
|
||||
prev_metadata_used/K,
|
||||
allocated_used_bytes()/K,
|
||||
reserved_in_bytes()/ K);
|
||||
reserved_bytes()/K);
|
||||
}
|
||||
|
||||
gclog_or_tty->print("]");
|
||||
@ -2654,14 +2671,14 @@ void MetaspaceAux::print_on(outputStream* out) {
|
||||
out->print_cr(" Metaspace total "
|
||||
SIZE_FORMAT "K, used " SIZE_FORMAT "K,"
|
||||
" reserved " SIZE_FORMAT "K",
|
||||
allocated_capacity_bytes()/K, allocated_used_bytes()/K, reserved_in_bytes()/K);
|
||||
allocated_capacity_bytes()/K, allocated_used_bytes()/K, reserved_bytes()/K);
|
||||
|
||||
out->print_cr(" data space "
|
||||
SIZE_FORMAT "K, used " SIZE_FORMAT "K,"
|
||||
" reserved " SIZE_FORMAT "K",
|
||||
allocated_capacity_bytes(nct)/K,
|
||||
allocated_used_bytes(nct)/K,
|
||||
reserved_in_bytes(nct)/K);
|
||||
reserved_bytes(nct)/K);
|
||||
if (Metaspace::using_class_space()) {
|
||||
Metaspace::MetadataType ct = Metaspace::ClassType;
|
||||
out->print_cr(" class space "
|
||||
@ -2669,17 +2686,17 @@ void MetaspaceAux::print_on(outputStream* out) {
|
||||
" reserved " SIZE_FORMAT "K",
|
||||
allocated_capacity_bytes(ct)/K,
|
||||
allocated_used_bytes(ct)/K,
|
||||
reserved_in_bytes(ct)/K);
|
||||
reserved_bytes(ct)/K);
|
||||
}
|
||||
}
|
||||
|
||||
// Print information for class space and data space separately.
|
||||
// This is almost the same as above.
|
||||
void MetaspaceAux::print_on(outputStream* out, Metaspace::MetadataType mdtype) {
|
||||
size_t free_chunks_capacity_bytes = free_chunks_total_in_bytes(mdtype);
|
||||
size_t free_chunks_capacity_bytes = free_chunks_total_bytes(mdtype);
|
||||
size_t capacity_bytes = capacity_bytes_slow(mdtype);
|
||||
size_t used_bytes = used_bytes_slow(mdtype);
|
||||
size_t free_bytes = free_in_bytes(mdtype);
|
||||
size_t free_bytes = free_bytes_slow(mdtype);
|
||||
size_t used_and_free = used_bytes + free_bytes +
|
||||
free_chunks_capacity_bytes;
|
||||
out->print_cr(" Chunk accounting: used in chunks " SIZE_FORMAT
|
||||
@ -3132,7 +3149,7 @@ size_t Metaspace::used_words_slow(MetadataType mdtype) const {
|
||||
}
|
||||
}
|
||||
|
||||
size_t Metaspace::free_words(MetadataType mdtype) const {
|
||||
size_t Metaspace::free_words_slow(MetadataType mdtype) const {
|
||||
if (mdtype == ClassType) {
|
||||
return using_class_space() ? class_vsm()->sum_free_in_chunks_in_use() : 0;
|
||||
} else {
|
||||
|
||||
@ -182,9 +182,8 @@ class Metaspace : public CHeapObj<mtClass> {
|
||||
|
||||
char* bottom() const;
|
||||
size_t used_words_slow(MetadataType mdtype) const;
|
||||
size_t free_words(MetadataType mdtype) const;
|
||||
size_t free_words_slow(MetadataType mdtype) const;
|
||||
size_t capacity_words_slow(MetadataType mdtype) const;
|
||||
size_t waste_words(MetadataType mdtype) const;
|
||||
|
||||
size_t used_bytes_slow(MetadataType mdtype) const;
|
||||
size_t capacity_bytes_slow(MetadataType mdtype) const;
|
||||
@ -221,19 +220,14 @@ class Metaspace : public CHeapObj<mtClass> {
|
||||
};
|
||||
|
||||
class MetaspaceAux : AllStatic {
|
||||
static size_t free_chunks_total(Metaspace::MetadataType mdtype);
|
||||
|
||||
public:
|
||||
// Statistics for class space and data space in metaspace.
|
||||
static size_t free_chunks_total_words(Metaspace::MetadataType mdtype);
|
||||
|
||||
// These methods iterate over the classloader data graph
|
||||
// for the given Metaspace type. These are slow.
|
||||
static size_t used_bytes_slow(Metaspace::MetadataType mdtype);
|
||||
static size_t free_in_bytes(Metaspace::MetadataType mdtype);
|
||||
static size_t free_bytes_slow(Metaspace::MetadataType mdtype);
|
||||
static size_t capacity_bytes_slow(Metaspace::MetadataType mdtype);
|
||||
|
||||
// Iterates over the virtual space list.
|
||||
static size_t reserved_in_bytes(Metaspace::MetadataType mdtype);
|
||||
static size_t capacity_bytes_slow();
|
||||
|
||||
// Running sum of space in all Metachunks that has been
|
||||
// allocated to a Metaspace. This is used instead of
|
||||
@ -263,17 +257,16 @@ class MetaspaceAux : AllStatic {
|
||||
}
|
||||
|
||||
// Used by MetaspaceCounters
|
||||
static size_t free_chunks_total();
|
||||
static size_t free_chunks_total_in_bytes();
|
||||
static size_t free_chunks_total_in_bytes(Metaspace::MetadataType mdtype);
|
||||
static size_t free_chunks_total_words();
|
||||
static size_t free_chunks_total_bytes();
|
||||
static size_t free_chunks_total_bytes(Metaspace::MetadataType mdtype);
|
||||
|
||||
static size_t allocated_capacity_words(Metaspace::MetadataType mdtype) {
|
||||
return _allocated_capacity_words[mdtype];
|
||||
}
|
||||
static size_t allocated_capacity_words() {
|
||||
return _allocated_capacity_words[Metaspace::NonClassType] +
|
||||
(Metaspace::using_class_space() ?
|
||||
_allocated_capacity_words[Metaspace::ClassType] : 0);
|
||||
return allocated_capacity_words(Metaspace::NonClassType) +
|
||||
allocated_capacity_words(Metaspace::ClassType);
|
||||
}
|
||||
static size_t allocated_capacity_bytes(Metaspace::MetadataType mdtype) {
|
||||
return allocated_capacity_words(mdtype) * BytesPerWord;
|
||||
@ -286,9 +279,8 @@ class MetaspaceAux : AllStatic {
|
||||
return _allocated_used_words[mdtype];
|
||||
}
|
||||
static size_t allocated_used_words() {
|
||||
return _allocated_used_words[Metaspace::NonClassType] +
|
||||
(Metaspace::using_class_space() ?
|
||||
_allocated_used_words[Metaspace::ClassType] : 0);
|
||||
return allocated_used_words(Metaspace::NonClassType) +
|
||||
allocated_used_words(Metaspace::ClassType);
|
||||
}
|
||||
static size_t allocated_used_bytes(Metaspace::MetadataType mdtype) {
|
||||
return allocated_used_words(mdtype) * BytesPerWord;
|
||||
@ -301,31 +293,17 @@ class MetaspaceAux : AllStatic {
|
||||
static size_t free_bytes(Metaspace::MetadataType mdtype);
|
||||
|
||||
// Total capacity in all Metaspaces
|
||||
static size_t capacity_bytes_slow() {
|
||||
#ifdef PRODUCT
|
||||
// Use allocated_capacity_bytes() in PRODUCT instead of this function.
|
||||
guarantee(false, "Should not call capacity_bytes_slow() in the PRODUCT");
|
||||
#endif
|
||||
size_t class_capacity = capacity_bytes_slow(Metaspace::ClassType);
|
||||
size_t non_class_capacity = capacity_bytes_slow(Metaspace::NonClassType);
|
||||
assert(allocated_capacity_bytes() == class_capacity + non_class_capacity,
|
||||
err_msg("bad accounting: allocated_capacity_bytes() " SIZE_FORMAT
|
||||
" class_capacity + non_class_capacity " SIZE_FORMAT
|
||||
" class_capacity " SIZE_FORMAT " non_class_capacity " SIZE_FORMAT,
|
||||
allocated_capacity_bytes(), class_capacity + non_class_capacity,
|
||||
class_capacity, non_class_capacity));
|
||||
|
||||
return class_capacity + non_class_capacity;
|
||||
static size_t reserved_bytes(Metaspace::MetadataType mdtype);
|
||||
static size_t reserved_bytes() {
|
||||
return reserved_bytes(Metaspace::ClassType) +
|
||||
reserved_bytes(Metaspace::NonClassType);
|
||||
}
|
||||
|
||||
// Total space reserved in all Metaspaces
|
||||
static size_t reserved_in_bytes() {
|
||||
return reserved_in_bytes(Metaspace::ClassType) +
|
||||
reserved_in_bytes(Metaspace::NonClassType);
|
||||
static size_t min_chunk_size_words();
|
||||
static size_t min_chunk_size_bytes() {
|
||||
return min_chunk_size_words() * BytesPerWord;
|
||||
}
|
||||
|
||||
static size_t min_chunk_size();
|
||||
|
||||
// Print change in used metadata.
|
||||
static void print_metaspace_change(size_t prev_metadata_used);
|
||||
static void print_on(outputStream * out);
|
||||
|
||||
@ -71,7 +71,7 @@ size_t MetaspaceCounters::calculate_capacity() {
|
||||
// 2) unused space at the end of each Metachunk
|
||||
// 3) space in the freelist
|
||||
size_t total_capacity = MetaspaceAux::allocated_capacity_bytes()
|
||||
+ MetaspaceAux::free_bytes() + MetaspaceAux::free_chunks_total_in_bytes();
|
||||
+ MetaspaceAux::free_bytes() + MetaspaceAux::free_chunks_total_bytes();
|
||||
return total_capacity;
|
||||
}
|
||||
|
||||
@ -79,9 +79,9 @@ void MetaspaceCounters::initialize_performance_counters() {
|
||||
if (UsePerfData) {
|
||||
assert(_perf_counters == NULL, "Should only be initialized once");
|
||||
|
||||
size_t min_capacity = MetaspaceAux::min_chunk_size();
|
||||
size_t min_capacity = MetaspaceAux::min_chunk_size_bytes();
|
||||
size_t capacity = calculate_capacity();
|
||||
size_t max_capacity = MetaspaceAux::reserved_in_bytes();
|
||||
size_t max_capacity = MetaspaceAux::reserved_bytes();
|
||||
size_t used = MetaspaceAux::allocated_used_bytes();
|
||||
|
||||
_perf_counters = new MetaspacePerfCounters("metaspace", min_capacity, capacity, max_capacity, used);
|
||||
@ -93,7 +93,7 @@ void MetaspaceCounters::update_performance_counters() {
|
||||
assert(_perf_counters != NULL, "Should be initialized");
|
||||
|
||||
size_t capacity = calculate_capacity();
|
||||
size_t max_capacity = MetaspaceAux::reserved_in_bytes();
|
||||
size_t max_capacity = MetaspaceAux::reserved_bytes();
|
||||
size_t used = MetaspaceAux::allocated_used_bytes();
|
||||
|
||||
_perf_counters->update(capacity, max_capacity, used);
|
||||
@ -105,7 +105,7 @@ MetaspacePerfCounters* CompressedClassSpaceCounters::_perf_counters = NULL;
|
||||
size_t CompressedClassSpaceCounters::calculate_capacity() {
|
||||
return MetaspaceAux::allocated_capacity_bytes(_class_type) +
|
||||
MetaspaceAux::free_bytes(_class_type) +
|
||||
MetaspaceAux::free_chunks_total_in_bytes(_class_type);
|
||||
MetaspaceAux::free_chunks_total_bytes(_class_type);
|
||||
}
|
||||
|
||||
void CompressedClassSpaceCounters::update_performance_counters() {
|
||||
@ -113,7 +113,7 @@ void CompressedClassSpaceCounters::update_performance_counters() {
|
||||
assert(_perf_counters != NULL, "Should be initialized");
|
||||
|
||||
size_t capacity = calculate_capacity();
|
||||
size_t max_capacity = MetaspaceAux::reserved_in_bytes(_class_type);
|
||||
size_t max_capacity = MetaspaceAux::reserved_bytes(_class_type);
|
||||
size_t used = MetaspaceAux::allocated_used_bytes(_class_type);
|
||||
|
||||
_perf_counters->update(capacity, max_capacity, used);
|
||||
@ -126,9 +126,9 @@ void CompressedClassSpaceCounters::initialize_performance_counters() {
|
||||
const char* ns = "compressedclassspace";
|
||||
|
||||
if (UseCompressedClassPointers) {
|
||||
size_t min_capacity = MetaspaceAux::min_chunk_size();
|
||||
size_t min_capacity = MetaspaceAux::min_chunk_size_bytes();
|
||||
size_t capacity = calculate_capacity();
|
||||
size_t max_capacity = MetaspaceAux::reserved_in_bytes(_class_type);
|
||||
size_t max_capacity = MetaspaceAux::reserved_bytes(_class_type);
|
||||
size_t used = MetaspaceAux::allocated_used_bytes(_class_type);
|
||||
|
||||
_perf_counters = new MetaspacePerfCounters(ns, min_capacity, capacity, max_capacity, used);
|
||||
|
||||
Loading…
Reference in New Issue
Block a user