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

equal deleted inserted replaced

-:5e86124b835d
+:4154f1817a75
 #include "utilities/copy.hpp"
 #include "utilities/debug.hpp"
 typedef BinaryTreeDictionary<Metablock, FreeList> BlockTreeDictionary;
 typedef BinaryTreeDictionary<Metachunk, FreeList> ChunkTreeDictionary;
+// Define this macro to enable slow integrity checking of
+// the free chunk lists
+const bool metaspace_slow_verify = false;
 // Parameters for stress mode testing
 const uint metadata_deallocate_a_lot_block = 10;
 const uint metadata_deallocate_a_lock_chunk = 3;
 size_t const allocation_from_dictionary_limit = 64 * K;
 size_t sum_free_chunks();
 size_t sum_free_chunks_count();
 void locked_verify_free_chunks_total();
+void slow_locked_verify_free_chunks_total() {
+if (metaspace_slow_verify) {
+locked_verify_free_chunks_total();
+}
+}
 void locked_verify_free_chunks_count();
+void slow_locked_verify_free_chunks_count() {
+if (metaspace_slow_verify) {
+locked_verify_free_chunks_count();
+}
+}
 void verify_free_chunks_count();
 public:
 ChunkManager() : _free_chunks_total(0), _free_chunks_count(0) {}
 void free_chunks_put(Metachunk* chuck);
 Metachunk* free_chunks_get(size_t chunk_word_size);
 // Debug support
 void verify();
+void slow_verify() {
+if (metaspace_slow_verify) {
+verify();
+}
+}
 void locked_verify();
+void slow_locked_verify() {
+if (metaspace_slow_verify) {
+locked_verify();
+}
+}
 void verify_free_chunks_total();
 void locked_print_free_chunks(outputStream* st);
 void locked_print_sum_free_chunks(outputStream* st);
 size_t ChunkManager::free_chunks_total() {
 #ifdef ASSERT
 if (!UseConcMarkSweepGC && !SpaceManager::expand_lock()->is_locked()) {
 MutexLockerEx cl(SpaceManager::expand_lock(),
 Mutex::_no_safepoint_check_flag);
-locked_verify_free_chunks_total();
+slow_locked_verify_free_chunks_total();
 }
 #endif
 return _free_chunks_total;
 }
 if (!UseConcMarkSweepGC && !SpaceManager::expand_lock()->is_locked()) {
 MutexLockerEx cl(SpaceManager::expand_lock(),
 Mutex::_no_safepoint_check_flag);
 // This lock is only needed in debug because the verification
 // of the _free_chunks_totals walks the list of free chunks
-locked_verify_free_chunks_count();
+slow_locked_verify_free_chunks_count();
 }
 #endif
 return _free_chunks_count;
 }
 void ChunkManager::locked_verify_free_chunks_total() {
 assert_lock_strong(SpaceManager::expand_lock());
 assert(sum_free_chunks() == _free_chunks_total,
 locked_verify_free_chunks_count();
 #endif
 }
 void ChunkManager::verify() {
-#ifdef ASSERT
+MutexLockerEx cl(SpaceManager::expand_lock(),
-if (!UseConcMarkSweepGC) {
+Mutex::_no_safepoint_check_flag);
-MutexLockerEx cl(SpaceManager::expand_lock(),
+locked_verify();
-Mutex::_no_safepoint_check_flag);
-locked_verify_free_chunks_total();
-locked_verify_free_chunks_count();
-}
-#endif
 }
 void ChunkManager::locked_verify() {
 locked_verify_free_chunks_count();
 locked_verify_free_chunks_total();
 ChunkList* free_list = find_free_chunks_list(chunk->word_size());
 chunk->set_next(free_list->head());
 free_list->set_head(chunk);
 // chunk is being returned to the chunk free list
 inc_free_chunks_total(chunk->capacity_word_size());
-locked_verify();
+slow_locked_verify();
 }
 void ChunkManager::chunk_freelist_deallocate(Metachunk* chunk) {
 // The deallocation of a chunk originates in the freelist
 // manangement code for a Metaspace and does not hold the
 // lock.
 assert(chunk != NULL, "Deallocating NULL");
-// MutexLockerEx fcl(SpaceManager::expand_lock(), Mutex::_no_safepoint_check_flag);
+assert_lock_strong(SpaceManager::expand_lock());
-locked_verify();
+slow_locked_verify();
 if (TraceMetadataChunkAllocation) {
 tty->print_cr("ChunkManager::chunk_freelist_deallocate: chunk "
 PTR_FORMAT "  size " SIZE_FORMAT,
 chunk, chunk->word_size());
 }
 }
 Metachunk* ChunkManager::free_chunks_get(size_t word_size) {
 assert_lock_strong(SpaceManager::expand_lock());
-locked_verify();
+slow_locked_verify();
 Metachunk* chunk = NULL;
 if (!SpaceManager::is_humongous(word_size)) {
 ChunkList* free_list = find_free_chunks_list(word_size);
 assert(free_list != NULL, "Sanity check");
 #ifdef ASSERT
 chunk->set_is_free(false);
 #endif
 }
 }
-locked_verify();
+slow_locked_verify();
 return chunk;
 }
 Metachunk* ChunkManager::chunk_freelist_allocate(size_t word_size) {
 assert_lock_strong(SpaceManager::expand_lock());
-locked_verify();
+slow_locked_verify();
 // Take from the beginning of the list
 Metachunk* chunk = free_chunks_get(word_size);
 if (chunk == NULL) {
 return NULL;
 MutexLockerEx fcl(SpaceManager::expand_lock(),
 Mutex::_no_safepoint_check_flag);
 ChunkManager* chunk_manager = vs_list()->chunk_manager();
-chunk_manager->locked_verify();
+chunk_manager->slow_locked_verify();
 if (TraceMetadataChunkAllocation && Verbose) {
 gclog_or_tty->print_cr("~SpaceManager(): " PTR_FORMAT, this);
 locked_print_chunks_in_use_on(gclog_or_tty);
 }
 Metachunk* next_humongous_chunks = humongous_chunks->next();
 chunk_manager->humongous_dictionary()->return_chunk(humongous_chunks);
 humongous_chunks = next_humongous_chunks;
 }
 set_chunks_in_use(HumongousIndex, NULL);
-chunk_manager->locked_verify();
+chunk_manager->slow_locked_verify();
 }
 void SpaceManager::deallocate(MetaWord* p, size_t word_size) {
 assert_lock_strong(_lock);
 size_t min_size = TreeChunk<Metablock, FreeList>::min_size();
 size_t MetaspaceAux::free_chunks_total(Metaspace::MetadataType mdtype) {
 ChunkManager* chunk = (mdtype == Metaspace::ClassType) ?
 Metaspace::class_space_list()->chunk_manager() :
 Metaspace::space_list()->chunk_manager();
+chunk->slow_verify();
-chunk->verify_free_chunks_total();
 return chunk->free_chunks_total();
 }
 size_t MetaspaceAux::free_chunks_total_in_bytes(Metaspace::MetadataType mdtype) {
 return free_chunks_total(mdtype) * BytesPerWord;
 out->print("data space: "); print_on(out, Metaspace::NonClassType);
 out->print("class space: "); print_on(out, Metaspace::ClassType);
 print_waste(out);
 }
+void MetaspaceAux::verify_free_chunks() {
+Metaspace::space_list()->chunk_manager()->verify();
+Metaspace::class_space_list()->chunk_manager()->verify();
+}
 // Metaspace methods
 size_t Metaspace::_first_chunk_word_size = 0;
 Metaspace::Metaspace(Mutex* lock, size_t word_size) {

changeset 14474	4154f1817a75
parent 14123	944e56f74fba
child 14588	8ec26d2d9339
child 14579	7f6ce6e3dd80