graal-jvmci-8: src/share/vm/memory/metaspace.cpp comparison

comparison src/share/vm/memory/metaspace.cpp @ 12235:d6c266999345

8023476: Metaspace capacity > reserved Reviewed-by: stefank, hseigel, mgerdin

author	ehelin
date	Thu, 12 Sep 2013 10:15:30 +0200
parents	24e87613ee58
children	c4c768305a8f

comparison

equal deleted inserted replaced

-:b82260e84582
+:d6c266999345
 // Add the simple linked list of chunks to the freelist of chunks
 // of type index.
 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_words();
-size_t free_chunks_total_in_bytes();
+size_t free_chunks_total_bytes();
 // Number of chunks in the free chunks list
 size_t free_chunks_count();
 void inc_free_chunks_total(size_t v, size_t count = 1) {
 while (iter.repeat()) {
 VirtualSpaceNode* vsl = iter.get_next();
 // 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;
 }
 // Space available in all MetadataVirtualspaces allocated
 // for metadata.  This is the upper limit on the capacity
 if (TraceMetadataChunkAllocation && Verbose) {
 gclog_or_tty->print("Metadebug::deallocate_chunk_a_lot: %d) ",
 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());
 }
 }
 } else {
 Metadebug::inc_deallocate_chunk_a_lot_count();
 }
 #endif
 // 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() {
+size_t ChunkManager::free_chunks_total_bytes() {
-return free_chunks_total() * BytesPerWord;
+return free_chunks_total_words() * BytesPerWord;
 }
 size_t ChunkManager::free_chunks_count() {
 #ifdef ASSERT
 if (!UseConcMarkSweepGC && !SpaceManager::expand_lock()->is_locked()) {
 }
 }
 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;
 }
 }
 }
 return capacity * BytesPerWord;
 }
-size_t MetaspaceAux::reserved_in_bytes(Metaspace::MetadataType mdtype) {
+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::reserved_bytes(Metaspace::MetadataType mdtype) {
 VirtualSpaceList* list = Metaspace::get_space_list(mdtype);
-return list == NULL ? 0 : list->virtual_space_total();
+return list == NULL ? 0 : list->virtual_space_total() * BytesPerWord;
 }
-size_t MetaspaceAux::min_chunk_size() { return Metaspace::first_chunk_word_size(); }
+size_t MetaspaceAux::min_chunk_size_words() { return Metaspace::first_chunk_word_size(); }
-size_t MetaspaceAux::free_chunks_total(Metaspace::MetadataType mdtype) {
+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) {
+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) {
 gclog_or_tty->print(", [Metaspace:");
 if (PrintGCDetails && Verbose) {
 gclog_or_tty->print(" "  SIZE_FORMAT
 "->" SIZE_FORMAT
 "("  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,
+prev_metadata_used/K,
-allocated_used_bytes() / K,
+allocated_used_bytes()/K,
-reserved_in_bytes()/ K);
+reserved_bytes()/K);
 }
 gclog_or_tty->print("]");
 }
 Metaspace::MetadataType nct = Metaspace::NonClassType;
 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    "
 SIZE_FORMAT "K, used " SIZE_FORMAT "K,"
 " 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
 "K + unused in chunks " SIZE_FORMAT "K  + "
 " capacity in free chunks " SIZE_FORMAT "K = " SIZE_FORMAT
 } else {
 return vsm()->sum_used_in_chunks_in_use();  // includes overhead!
 }
 }
-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 {
 return vsm()->sum_free_in_chunks_in_use();
 }

Mercurial > hg > graal-jvmci-8

comparison src/share/vm/memory/metaspace.cpp @ 12235:d6c266999345