jdk-sandbox: comparison hotspot/src/share/vm/memory/metaspace.cpp

equal deleted inserted replaced

-:bd4290e6d0a5
+:8ec26d2d9339
 Chunk::aligned_overhead_size(sizeof(Metablock)) / BytesPerWord;
 #else
 size_t Metablock::_overhead = 0;
 #endif
 // Pointer to list of Metachunks.
 class ChunkList VALUE_OBJ_CLASS_SPEC {
 // List of free chunks
 Metachunk* _head;
 // Expands/shrinks the committed space in a virtual space.  Delegates
 // to Virtualspace
 bool expand_by(size_t words, bool pre_touch = false);
 bool shrink_by(size_t words);
+#ifdef ASSERT
 // Debug support
 static void verify_virtual_space_total();
 static void verify_virtual_space_count();
 void mangle();
+#endif
 void print_on(outputStream* st) const;
 };
 // byte_size is the size of the associated virtualspace.
 void dump(outputStream* const out) const;
 void print_on(outputStream* st) const;
 void locked_print_chunks_in_use_on(outputStream* st) const;
 void verify();
+NOT_PRODUCT(void mangle_freed_chunks();)
 #ifdef ASSERT
-void mangle_freed_chunks();
 void verify_allocation_total();
 #endif
 };
 uint const SpaceManager::_small_chunk_limit = 4;
 " bottom " PTR_FORMAT " top " PTR_FORMAT
 " end " PTR_FORMAT " size " SIZE_FORMAT,
 bottom(), top(), end(), word_size());
 }
-#ifdef ASSERT
+#ifndef PRODUCT
 void Metachunk::mangle() {
 // Mangle the payload of the chunk and not the links that
 // maintain list of chunks.
 HeapWord* start = (HeapWord*)(bottom() + overhead());
 size_t word_size = capacity_word_size() - overhead();
 Copy::fill_to_words(start, word_size, metadata_chunk_initialize);
 }
-#endif // ASSERT
+#endif // PRODUCT
 void Metachunk::verify() {
 #ifdef ASSERT
 // Cannot walk through the blocks unless the blocks have
 // headers with sizes.
 vs, capacity / K, used * 100 / capacity,
 bottom(), top(), end(),
 vs->high_boundary());
 }
+#ifdef ASSERT
 void VirtualSpaceNode::mangle() {
 size_t word_size = capacity_words_in_vs();
 Copy::fill_to_words((HeapWord*) low(), word_size, 0xf1f1f1f1);
 }
+#endif // ASSERT
 // VirtualSpaceList methods
 // Space allocated from the VirtualSpace
 VirtualSpaceList::~VirtualSpaceList() {
 if (TraceMetadataChunkAllocation && Verbose) {
 gclog_or_tty->print_cr("~SpaceManager(): " PTR_FORMAT, this);
 locked_print_chunks_in_use_on(gclog_or_tty);
 }
+// Mangle freed memory.
+NOT_PRODUCT(mangle_freed_chunks();)
 // Have to update before the chunks_in_use lists are emptied
 // below.
 chunk_manager->inc_free_chunks_total(sum_capacity_in_chunks_in_use(),
 sum_count_in_chunks_in_use());
-#ifdef ASSERT
-// Mangle freed memory.
-mangle_freed_chunks();
-#endif // ASSERT
 // Add all the chunks in use by this space manager
 // to the global list of free chunks.
 // Small chunks.  There is one _current_chunk for each
 out->print_cr("total of all chunks "  SIZE_FORMAT " used " SIZE_FORMAT
 " free " SIZE_FORMAT " capacity " SIZE_FORMAT
 " waste " SIZE_FORMAT, curr_total, used, free, capacity, waste);
 }
-#ifdef ASSERT
+#ifndef PRODUCT
 void SpaceManager::mangle_freed_chunks() {
 for (ChunkIndex index = SmallIndex;
 index < NumberOfInUseLists;
 index = next_chunk_index(index)) {
 for (Metachunk* curr = chunks_in_use(index);
 curr, chunks_in_use(MediumIndex)));
 curr->mangle();
 }
 }
 }
-#endif // ASSERT
+#endif // PRODUCT
 // MetaspaceAux
+size_t MetaspaceAux::used_in_bytes() {
+return (Metaspace::class_space_list()->used_words_sum() +
+Metaspace::space_list()->used_words_sum()) * BytesPerWord;
+}
 size_t MetaspaceAux::used_in_bytes(Metaspace::MetadataType mdtype) {
 size_t used = 0;
 ClassLoaderDataGraphMetaspaceIterator iter;
 while (iter.repeat()) {
 }
 // The total words available for metadata allocation.  This
 // uses Metaspace capacity_words() which is the total words
 // in chunks allocated for a Metaspace.
+size_t MetaspaceAux::capacity_in_bytes() {
+return (Metaspace::class_space_list()->capacity_words_sum() +
+Metaspace::space_list()->capacity_words_sum()) * BytesPerWord;
+}
 size_t MetaspaceAux::capacity_in_bytes(Metaspace::MetadataType mdtype) {
 size_t capacity = free_chunks_total(mdtype);
 ClassLoaderDataGraphMetaspaceIterator iter;
 while (iter.repeat()) {
 Metaspace* msp = iter.get_next();
 if (msp != NULL) {
 capacity += msp->capacity_words(mdtype);
 }
 }
 return capacity * BytesPerWord;
+}
+size_t MetaspaceAux::reserved_in_bytes() {
+return (Metaspace::class_space_list()->virtual_space_total() +
+Metaspace::space_list()->virtual_space_total()) * BytesPerWord;
 }
 size_t MetaspaceAux::reserved_in_bytes(Metaspace::MetadataType mdtype) {
 size_t reserved = (mdtype == Metaspace::ClassType) ?
 Metaspace::class_space_list()->virtual_space_total() :

changeset 14588	8ec26d2d9339
parent 14474	4154f1817a75
child 14590	7d6b69f12b36