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

8023476: Metaspace capacity > reserved

Browse Source 
Reviewed-by: stefank, hseigel, mgerdin
This commit is contained in:
Erik Helin 2013-09-12 10:15:30 +02:00
parent 2317db6d5a
commit dfd2d9a574
4 changed files with 80 additions and 85 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
hotspot/src/share/vm/gc_interface/collectedHeap.cpp
View File

@ -87,15 +87,15 @@ MetaspaceSummary CollectedHeap::create_metaspace_summary() {
const MetaspaceSizes meta_space( const MetaspaceSizes meta_space(
MetaspaceAux::allocated_capacity_bytes(), MetaspaceAux::allocated_capacity_bytes(),
MetaspaceAux::allocated_used_bytes(), MetaspaceAux::allocated_used_bytes(),
MetaspaceAux::reserved_in_bytes()); MetaspaceAux::reserved_bytes());
const MetaspaceSizes data_space( const MetaspaceSizes data_space(
MetaspaceAux::allocated_capacity_bytes(Metaspace::NonClassType), MetaspaceAux::allocated_capacity_bytes(Metaspace::NonClassType),
MetaspaceAux::allocated_used_bytes(Metaspace::NonClassType), MetaspaceAux::allocated_used_bytes(Metaspace::NonClassType),
MetaspaceAux::reserved_in_bytes(Metaspace::NonClassType)); MetaspaceAux::reserved_bytes(Metaspace::NonClassType));
const MetaspaceSizes class_space( const MetaspaceSizes class_space(
MetaspaceAux::allocated_capacity_bytes(Metaspace::ClassType), MetaspaceAux::allocated_capacity_bytes(Metaspace::ClassType),
MetaspaceAux::allocated_used_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); return MetaspaceSummary(meta_space, data_space, class_space);
} }

81
hotspot/src/share/vm/memory/metaspace.cpp
View File

@ -177,8 +177,8 @@ class ChunkManager VALUE_OBJ_CLASS_SPEC {
void return_chunks(ChunkIndex index, Metachunk* chunks); void return_chunks(ChunkIndex index, Metachunk* chunks);
// Total of the space in the free chunks list // Total of the space in the free chunks list
size_t free_chunks_total(); size_t free_chunks_total_words();
size_t free_chunks_total_in_bytes(); size_t free_chunks_total_bytes();
// Number of chunks in the free chunks list // Number of chunks in the free chunks list
size_t free_chunks_count(); size_t free_chunks_count();
@ -1080,12 +1080,12 @@ size_t VirtualSpaceList::used_words_sum() {
// Sum used region [bottom, top) in each virtualspace // Sum used region [bottom, top) in each virtualspace
allocated_by_vs += vsl->used_words_in_vs(); 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 err_msg("Total in free chunks " SIZE_FORMAT
" greater than total from virtual_spaces " 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 = size_t used =
allocated_by_vs - chunk_manager()->free_chunks_total(); allocated_by_vs - chunk_manager()->free_chunks_total_words();
return used; return used;
} }
@ -1526,7 +1526,7 @@ void Metadebug::deallocate_chunk_a_lot(SpaceManager* sm,
sm->sum_count_in_chunks_in_use()); sm->sum_count_in_chunks_in_use());
dummy_chunk->print_on(gclog_or_tty); dummy_chunk->print_on(gclog_or_tty);
gclog_or_tty->print_cr(" Free chunks total %d count %d", 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()); vsl->chunk_manager()->free_chunks_count());
} }
} }
@ -1583,12 +1583,12 @@ bool Metadebug::test_metadata_failure() {
// ChunkManager methods // ChunkManager methods
size_t ChunkManager::free_chunks_total() { size_t ChunkManager::free_chunks_total_words() {
return _free_chunks_total; return _free_chunks_total;
} }
size_t ChunkManager::free_chunks_total_in_bytes() { size_t ChunkManager::free_chunks_total_bytes() {
return free_chunks_total() * BytesPerWord; return free_chunks_total_words() * BytesPerWord;
} }
size_t ChunkManager::free_chunks_count() { size_t ChunkManager::free_chunks_count() {
@ -2567,13 +2567,13 @@ size_t MetaspaceAux::used_bytes_slow(Metaspace::MetadataType mdtype) {
return used * BytesPerWord; 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; size_t free = 0;
ClassLoaderDataGraphMetaspaceIterator iter; ClassLoaderDataGraphMetaspaceIterator iter;
while (iter.repeat()) { while (iter.repeat()) {
Metaspace* msp = iter.get_next(); Metaspace* msp = iter.get_next();
if (msp != NULL) { if (msp != NULL) {
free += msp->free_words(mdtype); free += msp->free_words_slow(mdtype);
} }
} }
return free * BytesPerWord; return free * BytesPerWord;
@ -2596,34 +2596,51 @@ size_t MetaspaceAux::capacity_bytes_slow(Metaspace::MetadataType mdtype) {
return capacity * BytesPerWord; return capacity * BytesPerWord;
} }
size_t MetaspaceAux::reserved_in_bytes(Metaspace::MetadataType mdtype) { size_t MetaspaceAux::capacity_bytes_slow() {
VirtualSpaceList* list = Metaspace::get_space_list(mdtype); #ifdef PRODUCT
return list == NULL ? 0 : list->virtual_space_total(); // 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); VirtualSpaceList* list = Metaspace::get_space_list(mdtype);
if (list == NULL) { if (list == NULL) {
return 0; return 0;
} }
ChunkManager* chunk = list->chunk_manager(); ChunkManager* chunk = list->chunk_manager();
chunk->slow_verify(); 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) { size_t MetaspaceAux::free_chunks_total_bytes(Metaspace::MetadataType mdtype) {
return free_chunks_total(mdtype) * BytesPerWord; return free_chunks_total_words(mdtype) * BytesPerWord;
} }
size_t MetaspaceAux::free_chunks_total() { size_t MetaspaceAux::free_chunks_total_words() {
return free_chunks_total(Metaspace::ClassType) + return free_chunks_total_words(Metaspace::ClassType) +
free_chunks_total(Metaspace::NonClassType); free_chunks_total_words(Metaspace::NonClassType);
} }
size_t MetaspaceAux::free_chunks_total_in_bytes() { size_t MetaspaceAux::free_chunks_total_bytes() {
return free_chunks_total() * BytesPerWord; return free_chunks_total_words() * BytesPerWord;
} }
void MetaspaceAux::print_metaspace_change(size_t prev_metadata_used) { 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 ")", "(" SIZE_FORMAT ")",
prev_metadata_used, prev_metadata_used,
allocated_used_bytes(), allocated_used_bytes(),
reserved_in_bytes()); reserved_bytes());
} else { } else {
gclog_or_tty->print(" " SIZE_FORMAT "K" gclog_or_tty->print(" " SIZE_FORMAT "K"
"->" SIZE_FORMAT "K" "->" SIZE_FORMAT "K"
"(" SIZE_FORMAT "K)", "(" SIZE_FORMAT "K)",
prev_metadata_used/K, prev_metadata_used/K,
allocated_used_bytes()/K, allocated_used_bytes()/K,
reserved_in_bytes()/ K); reserved_bytes()/K);
} }
gclog_or_tty->print("]"); gclog_or_tty->print("]");
@ -2654,14 +2671,14 @@ void MetaspaceAux::print_on(outputStream* out) {
out->print_cr(" Metaspace total " out->print_cr(" Metaspace total "
SIZE_FORMAT "K, used " SIZE_FORMAT "K," SIZE_FORMAT "K, used " SIZE_FORMAT "K,"
" reserved " 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 " out->print_cr(" data space "
SIZE_FORMAT "K, used " SIZE_FORMAT "K," SIZE_FORMAT "K, used " SIZE_FORMAT "K,"
" reserved " SIZE_FORMAT "K", " reserved " SIZE_FORMAT "K",
allocated_capacity_bytes(nct)/K, allocated_capacity_bytes(nct)/K,
allocated_used_bytes(nct)/K, allocated_used_bytes(nct)/K,
reserved_in_bytes(nct)/K); reserved_bytes(nct)/K);
if (Metaspace::using_class_space()) { if (Metaspace::using_class_space()) {
Metaspace::MetadataType ct = Metaspace::ClassType; Metaspace::MetadataType ct = Metaspace::ClassType;
out->print_cr(" class space " out->print_cr(" class space "
@ -2669,17 +2686,17 @@ void MetaspaceAux::print_on(outputStream* out) {
" reserved " SIZE_FORMAT "K", " reserved " SIZE_FORMAT "K",
allocated_capacity_bytes(ct)/K, allocated_capacity_bytes(ct)/K,
allocated_used_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. // Print information for class space and data space separately.
// This is almost the same as above. // This is almost the same as above.
void MetaspaceAux::print_on(outputStream* out, Metaspace::MetadataType mdtype) { 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 capacity_bytes = capacity_bytes_slow(mdtype);
size_t used_bytes = used_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 + size_t used_and_free = used_bytes + free_bytes +
free_chunks_capacity_bytes; free_chunks_capacity_bytes;
out->print_cr(" Chunk accounting: used in chunks " SIZE_FORMAT 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) { if (mdtype == ClassType) {
return using_class_space() ? class_vsm()->sum_free_in_chunks_in_use() : 0; return using_class_space() ? class_vsm()->sum_free_in_chunks_in_use() : 0;
} else { } else {

58
hotspot/src/share/vm/memory/metaspace.hpp
View File

@ -182,9 +182,8 @@ class Metaspace : public CHeapObj<mtClass> {
char* bottom() const; char* bottom() const;
size_t used_words_slow(MetadataType mdtype) 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 capacity_words_slow(MetadataType mdtype) const;
size_t waste_words(MetadataType mdtype) const;
size_t used_bytes_slow(MetadataType mdtype) const; size_t used_bytes_slow(MetadataType mdtype) const;
size_t capacity_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 { class MetaspaceAux : AllStatic {
static size_t free_chunks_total(Metaspace::MetadataType mdtype); static size_t free_chunks_total_words(Metaspace::MetadataType mdtype);
public:
// Statistics for class space and data space in metaspace.
// These methods iterate over the classloader data graph // These methods iterate over the classloader data graph
// for the given Metaspace type. These are slow. // for the given Metaspace type. These are slow.
static size_t used_bytes_slow(Metaspace::MetadataType mdtype); 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); static size_t capacity_bytes_slow(Metaspace::MetadataType mdtype);
static size_t capacity_bytes_slow();
// Iterates over the virtual space list.
static size_t reserved_in_bytes(Metaspace::MetadataType mdtype);
// Running sum of space in all Metachunks that has been // Running sum of space in all Metachunks that has been
// allocated to a Metaspace. This is used instead of // allocated to a Metaspace. This is used instead of
@ -263,17 +257,16 @@ class MetaspaceAux : AllStatic {
} }
// Used by MetaspaceCounters // Used by MetaspaceCounters
static size_t free_chunks_total(); static size_t free_chunks_total_words();
static size_t free_chunks_total_in_bytes(); static size_t free_chunks_total_bytes();
static size_t free_chunks_total_in_bytes(Metaspace::MetadataType mdtype); static size_t free_chunks_total_bytes(Metaspace::MetadataType mdtype);
static size_t allocated_capacity_words(Metaspace::MetadataType mdtype) { static size_t allocated_capacity_words(Metaspace::MetadataType mdtype) {
return _allocated_capacity_words[mdtype]; return _allocated_capacity_words[mdtype];
} }
static size_t allocated_capacity_words() { static size_t allocated_capacity_words() {
return _allocated_capacity_words[Metaspace::NonClassType] + return allocated_capacity_words(Metaspace::NonClassType) +
(Metaspace::using_class_space() ? allocated_capacity_words(Metaspace::ClassType);
_allocated_capacity_words[Metaspace::ClassType] : 0);
} }
static size_t allocated_capacity_bytes(Metaspace::MetadataType mdtype) { static size_t allocated_capacity_bytes(Metaspace::MetadataType mdtype) {
return allocated_capacity_words(mdtype) * BytesPerWord; return allocated_capacity_words(mdtype) * BytesPerWord;
@ -286,9 +279,8 @@ class MetaspaceAux : AllStatic {
return _allocated_used_words[mdtype]; return _allocated_used_words[mdtype];
} }
static size_t allocated_used_words() { static size_t allocated_used_words() {
return _allocated_used_words[Metaspace::NonClassType] + return allocated_used_words(Metaspace::NonClassType) +
(Metaspace::using_class_space() ? allocated_used_words(Metaspace::ClassType);
_allocated_used_words[Metaspace::ClassType] : 0);
} }
static size_t allocated_used_bytes(Metaspace::MetadataType mdtype) { static size_t allocated_used_bytes(Metaspace::MetadataType mdtype) {
return allocated_used_words(mdtype) * BytesPerWord; return allocated_used_words(mdtype) * BytesPerWord;
@ -301,31 +293,17 @@ class MetaspaceAux : AllStatic {
static size_t free_bytes(Metaspace::MetadataType mdtype); static size_t free_bytes(Metaspace::MetadataType mdtype);
// Total capacity in all Metaspaces // Total capacity in all Metaspaces
static size_t capacity_bytes_slow() { static size_t reserved_bytes(Metaspace::MetadataType mdtype);
#ifdef PRODUCT static size_t reserved_bytes() {
// Use allocated_capacity_bytes() in PRODUCT instead of this function. return reserved_bytes(Metaspace::ClassType) +
guarantee(false, "Should not call capacity_bytes_slow() in the PRODUCT"); reserved_bytes(Metaspace::NonClassType);
#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;
} }
// Total space reserved in all Metaspaces static size_t min_chunk_size_words();
static size_t reserved_in_bytes() { static size_t min_chunk_size_bytes() {
return reserved_in_bytes(Metaspace::ClassType) + return min_chunk_size_words() * BytesPerWord;
reserved_in_bytes(Metaspace::NonClassType);
} }
static size_t min_chunk_size();
// Print change in used metadata. // Print change in used metadata.
static void print_metaspace_change(size_t prev_metadata_used); static void print_metaspace_change(size_t prev_metadata_used);
static void print_on(outputStream * out); static void print_on(outputStream * out);

16
hotspot/src/share/vm/memory/metaspaceCounters.cpp
View File

@ -71,7 +71,7 @@ size_t MetaspaceCounters::calculate_capacity() {
// 2) unused space at the end of each Metachunk // 2) unused space at the end of each Metachunk
// 3) space in the freelist // 3) space in the freelist
size_t total_capacity = MetaspaceAux::allocated_capacity_bytes() 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; return total_capacity;
} }
@ -79,9 +79,9 @@ void MetaspaceCounters::initialize_performance_counters() {
if (UsePerfData) { if (UsePerfData) {
assert(_perf_counters == NULL, "Should only be initialized once"); 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 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(); size_t used = MetaspaceAux::allocated_used_bytes();
_perf_counters = new MetaspacePerfCounters("metaspace", min_capacity, capacity, max_capacity, used); _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"); assert(_perf_counters != NULL, "Should be initialized");
size_t capacity = calculate_capacity(); 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(); size_t used = MetaspaceAux::allocated_used_bytes();
_perf_counters->update(capacity, max_capacity, used); _perf_counters->update(capacity, max_capacity, used);
@ -105,7 +105,7 @@ MetaspacePerfCounters* CompressedClassSpaceCounters::_perf_counters = NULL;
size_t CompressedClassSpaceCounters::calculate_capacity() { size_t CompressedClassSpaceCounters::calculate_capacity() {
return MetaspaceAux::allocated_capacity_bytes(_class_type) + return MetaspaceAux::allocated_capacity_bytes(_class_type) +
MetaspaceAux::free_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() { void CompressedClassSpaceCounters::update_performance_counters() {
@ -113,7 +113,7 @@ void CompressedClassSpaceCounters::update_performance_counters() {
assert(_perf_counters != NULL, "Should be initialized"); assert(_perf_counters != NULL, "Should be initialized");
size_t capacity = calculate_capacity(); 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); size_t used = MetaspaceAux::allocated_used_bytes(_class_type);
_perf_counters->update(capacity, max_capacity, used); _perf_counters->update(capacity, max_capacity, used);
@ -126,9 +126,9 @@ void CompressedClassSpaceCounters::initialize_performance_counters() {
const char* ns = "compressedclassspace"; const char* ns = "compressedclassspace";
if (UseCompressedClassPointers) { 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 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); size_t used = MetaspaceAux::allocated_used_bytes(_class_type);
_perf_counters = new MetaspacePerfCounters(ns, min_capacity, capacity, max_capacity, used); _perf_counters = new MetaspacePerfCounters(ns, min_capacity, capacity, max_capacity, used);