diff -r d7c83c8e4e65 -r bfc70d5d291a src/hotspot/share/memory/metaspace.cpp --- a/src/hotspot/share/memory/metaspace.cpp Tue Mar 20 15:38:00 2018 +0100 +++ b/src/hotspot/share/memory/metaspace.cpp Mon Mar 26 09:35:20 2018 -0400 @@ -1260,11 +1260,6 @@ // the class loader using the SpaceManager is collected. BlockFreelist* _block_freelists; - // protects virtualspace and chunk expansions - static const char* _expand_lock_name; - static const int _expand_lock_rank; - static Mutex* const _expand_lock; - private: // Accessors Metachunk* chunks_in_use(ChunkIndex index) const { return _chunks_in_use[index]; } @@ -1330,8 +1325,6 @@ bool is_humongous(size_t word_size) { return word_size > medium_chunk_size(); } - static Mutex* expand_lock() { return _expand_lock; } - // Increment the per Metaspace and global running sums for Metachunks // by the given size. This is used when a Metachunk to added to // the in-use list. @@ -1415,22 +1408,13 @@ uint const SpaceManager::_small_chunk_limit = 4; uint const SpaceManager::_anon_and_delegating_metadata_specialize_chunk_limit = 4; -const char* SpaceManager::_expand_lock_name = - "SpaceManager chunk allocation lock"; -const int SpaceManager::_expand_lock_rank = Monitor::leaf - 1; -Mutex* const SpaceManager::_expand_lock = - new Mutex(SpaceManager::_expand_lock_rank, - SpaceManager::_expand_lock_name, - Mutex::_allow_vm_block_flag, - Monitor::_safepoint_check_never); - void VirtualSpaceNode::inc_container_count() { - assert_lock_strong(SpaceManager::expand_lock()); + assert_lock_strong(MetaspaceExpand_lock); _container_count++; } void VirtualSpaceNode::dec_container_count() { - assert_lock_strong(SpaceManager::expand_lock()); + assert_lock_strong(MetaspaceExpand_lock); _container_count--; } @@ -1730,7 +1714,7 @@ } Metachunk* VirtualSpaceNode::get_chunk_vs(size_t chunk_word_size) { - assert_lock_strong(SpaceManager::expand_lock()); + assert_lock_strong(MetaspaceExpand_lock); Metachunk* result = take_from_committed(chunk_word_size); return result; } @@ -1810,11 +1794,11 @@ } void VirtualSpaceList::inc_reserved_words(size_t v) { - assert_lock_strong(SpaceManager::expand_lock()); + assert_lock_strong(MetaspaceExpand_lock); _reserved_words = _reserved_words + v; } void VirtualSpaceList::dec_reserved_words(size_t v) { - assert_lock_strong(SpaceManager::expand_lock()); + assert_lock_strong(MetaspaceExpand_lock); _reserved_words = _reserved_words - v; } @@ -1825,24 +1809,24 @@ MetaspaceUtils::committed_bytes(), MaxMetaspaceSize); void VirtualSpaceList::inc_committed_words(size_t v) { - assert_lock_strong(SpaceManager::expand_lock()); + assert_lock_strong(MetaspaceExpand_lock); _committed_words = _committed_words + v; assert_committed_below_limit(); } void VirtualSpaceList::dec_committed_words(size_t v) { - assert_lock_strong(SpaceManager::expand_lock()); + assert_lock_strong(MetaspaceExpand_lock); _committed_words = _committed_words - v; assert_committed_below_limit(); } void VirtualSpaceList::inc_virtual_space_count() { - assert_lock_strong(SpaceManager::expand_lock()); + assert_lock_strong(MetaspaceExpand_lock); _virtual_space_count++; } void VirtualSpaceList::dec_virtual_space_count() { - assert_lock_strong(SpaceManager::expand_lock()); + assert_lock_strong(MetaspaceExpand_lock); _virtual_space_count--; } @@ -1860,7 +1844,7 @@ } bool ChunkManager::attempt_to_coalesce_around_chunk(Metachunk* chunk, ChunkIndex target_chunk_type) { - assert_lock_strong(SpaceManager::expand_lock()); + assert_lock_strong(MetaspaceExpand_lock); assert(chunk != NULL, "invalid chunk pointer"); // Check for valid merge combinations. assert((chunk->get_chunk_type() == SpecializedIndex && @@ -1993,7 +1977,7 @@ // the node from their respective freelists. void VirtualSpaceList::purge(ChunkManager* chunk_manager) { assert(SafepointSynchronize::is_at_safepoint(), "must be called at safepoint for contains to work"); - assert_lock_strong(SpaceManager::expand_lock()); + assert_lock_strong(MetaspaceExpand_lock); // Don't use a VirtualSpaceListIterator because this // list is being changed and a straightforward use of an iterator is not safe. VirtualSpaceNode* purged_vsl = NULL; @@ -2057,7 +2041,7 @@ } void VirtualSpaceList::retire_current_virtual_space() { - assert_lock_strong(SpaceManager::expand_lock()); + assert_lock_strong(MetaspaceExpand_lock); VirtualSpaceNode* vsn = current_virtual_space(); @@ -2099,7 +2083,7 @@ _reserved_words(0), _committed_words(0), _virtual_space_count(0) { - MutexLockerEx cl(SpaceManager::expand_lock(), + MutexLockerEx cl(MetaspaceExpand_lock, Mutex::_no_safepoint_check_flag); create_new_virtual_space(word_size); } @@ -2111,7 +2095,7 @@ _reserved_words(0), _committed_words(0), _virtual_space_count(0) { - MutexLockerEx cl(SpaceManager::expand_lock(), + MutexLockerEx cl(MetaspaceExpand_lock, Mutex::_no_safepoint_check_flag); VirtualSpaceNode* class_entry = new VirtualSpaceNode(is_class(), rs); bool succeeded = class_entry->initialize(); @@ -2126,7 +2110,7 @@ // Allocate another meta virtual space and add it to the list. bool VirtualSpaceList::create_new_virtual_space(size_t vs_word_size) { - assert_lock_strong(SpaceManager::expand_lock()); + assert_lock_strong(MetaspaceExpand_lock); if (is_class()) { assert(false, "We currently don't support more than one VirtualSpace for" @@ -2615,14 +2599,14 @@ // Update internal accounting after a chunk was added void ChunkManager::account_for_added_chunk(const Metachunk* c) { - assert_lock_strong(SpaceManager::expand_lock()); + assert_lock_strong(MetaspaceExpand_lock); _free_chunks_count ++; _free_chunks_total += c->word_size(); } // Update internal accounting after a chunk was removed void ChunkManager::account_for_removed_chunk(const Metachunk* c) { - assert_lock_strong(SpaceManager::expand_lock()); + assert_lock_strong(MetaspaceExpand_lock); assert(_free_chunks_count >= 1, "ChunkManager::_free_chunks_count: about to go negative (" SIZE_FORMAT ").", _free_chunks_count); assert(_free_chunks_total >= c->word_size(), @@ -2634,8 +2618,8 @@ size_t ChunkManager::free_chunks_count() { #ifdef ASSERT - if (!UseConcMarkSweepGC && !SpaceManager::expand_lock()->is_locked()) { - MutexLockerEx cl(SpaceManager::expand_lock(), + if (!UseConcMarkSweepGC && !MetaspaceExpand_lock->is_locked()) { + MutexLockerEx cl(MetaspaceExpand_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 @@ -2656,7 +2640,7 @@ } void ChunkManager::locked_verify_free_chunks_total() { - assert_lock_strong(SpaceManager::expand_lock()); + assert_lock_strong(MetaspaceExpand_lock); assert(sum_free_chunks() == _free_chunks_total, "_free_chunks_total " SIZE_FORMAT " is not the" " same as sum " SIZE_FORMAT, _free_chunks_total, @@ -2664,13 +2648,13 @@ } void ChunkManager::verify_free_chunks_total() { - MutexLockerEx cl(SpaceManager::expand_lock(), + MutexLockerEx cl(MetaspaceExpand_lock, Mutex::_no_safepoint_check_flag); locked_verify_free_chunks_total(); } void ChunkManager::locked_verify_free_chunks_count() { - assert_lock_strong(SpaceManager::expand_lock()); + assert_lock_strong(MetaspaceExpand_lock); assert(sum_free_chunks_count() == _free_chunks_count, "_free_chunks_count " SIZE_FORMAT " is not the" " same as sum " SIZE_FORMAT, _free_chunks_count, @@ -2679,14 +2663,14 @@ void ChunkManager::verify_free_chunks_count() { #ifdef ASSERT - MutexLockerEx cl(SpaceManager::expand_lock(), + MutexLockerEx cl(MetaspaceExpand_lock, Mutex::_no_safepoint_check_flag); locked_verify_free_chunks_count(); #endif } void ChunkManager::verify() { - MutexLockerEx cl(SpaceManager::expand_lock(), + MutexLockerEx cl(MetaspaceExpand_lock, Mutex::_no_safepoint_check_flag); locked_verify(); } @@ -2708,13 +2692,13 @@ } void ChunkManager::locked_print_free_chunks(outputStream* st) { - assert_lock_strong(SpaceManager::expand_lock()); + assert_lock_strong(MetaspaceExpand_lock); st->print_cr("Free chunk total " SIZE_FORMAT " count " SIZE_FORMAT, _free_chunks_total, _free_chunks_count); } void ChunkManager::locked_print_sum_free_chunks(outputStream* st) { - assert_lock_strong(SpaceManager::expand_lock()); + assert_lock_strong(MetaspaceExpand_lock); st->print_cr("Sum free chunk total " SIZE_FORMAT " count " SIZE_FORMAT, sum_free_chunks(), sum_free_chunks_count()); } @@ -2729,7 +2713,7 @@ // These methods that sum the free chunk lists are used in printing // methods that are used in product builds. size_t ChunkManager::sum_free_chunks() { - assert_lock_strong(SpaceManager::expand_lock()); + assert_lock_strong(MetaspaceExpand_lock); size_t result = 0; for (ChunkIndex i = ZeroIndex; i < NumberOfFreeLists; i = next_chunk_index(i)) { ChunkList* list = free_chunks(i); @@ -2745,7 +2729,7 @@ } size_t ChunkManager::sum_free_chunks_count() { - assert_lock_strong(SpaceManager::expand_lock()); + assert_lock_strong(MetaspaceExpand_lock); size_t count = 0; for (ChunkIndex i = ZeroIndex; i < NumberOfFreeLists; i = next_chunk_index(i)) { ChunkList* list = free_chunks(i); @@ -2861,7 +2845,7 @@ } Metachunk* ChunkManager::free_chunks_get(size_t word_size) { - assert_lock_strong(SpaceManager::expand_lock()); + assert_lock_strong(MetaspaceExpand_lock); slow_locked_verify(); @@ -2968,7 +2952,7 @@ } Metachunk* ChunkManager::chunk_freelist_allocate(size_t word_size) { - assert_lock_strong(SpaceManager::expand_lock()); + assert_lock_strong(MetaspaceExpand_lock); slow_locked_verify(); // Take from the beginning of the list @@ -3000,7 +2984,7 @@ } void ChunkManager::return_single_chunk(ChunkIndex index, Metachunk* chunk) { - assert_lock_strong(SpaceManager::expand_lock()); + assert_lock_strong(MetaspaceExpand_lock); DEBUG_ONLY(do_verify_chunk(chunk);) assert(chunk->get_chunk_type() == index, "Chunk does not match expected index."); assert(chunk != NULL, "Expected chunk."); @@ -3089,7 +3073,7 @@ } void ChunkManager::locked_get_statistics(ChunkManagerStatistics* stat) const { - assert_lock_strong(SpaceManager::expand_lock()); + assert_lock_strong(MetaspaceExpand_lock); for (ChunkIndex i = ZeroIndex; i < NumberOfFreeLists; i = next_chunk_index(i)) { stat->num_by_type[i] = num_free_chunks(i); stat->single_size_by_type[i] = size_by_index(i); @@ -3100,7 +3084,7 @@ } void ChunkManager::get_statistics(ChunkManagerStatistics* stat) const { - MutexLockerEx cl(SpaceManager::expand_lock(), + MutexLockerEx cl(MetaspaceExpand_lock, Mutex::_no_safepoint_check_flag); locked_get_statistics(stat); } @@ -3399,7 +3383,7 @@ assert(current_chunk() == NULL || current_chunk()->allocate(word_size) == NULL, "Don't need to expand"); - MutexLockerEx cl(SpaceManager::expand_lock(), Mutex::_no_safepoint_check_flag); + MutexLockerEx cl(MetaspaceExpand_lock, Mutex::_no_safepoint_check_flag); if (log_is_enabled(Trace, gc, metaspace, freelist)) { size_t words_left = 0; @@ -3468,7 +3452,7 @@ } void SpaceManager::inc_size_metrics(size_t words) { - assert_lock_strong(SpaceManager::expand_lock()); + assert_lock_strong(MetaspaceExpand_lock); // Total of allocated Metachunks and allocated Metachunks count // for each SpaceManager _allocated_chunks_words = _allocated_chunks_words + words; @@ -3507,13 +3491,13 @@ } SpaceManager::~SpaceManager() { - // This call this->_lock which can't be done while holding expand_lock() + // This call this->_lock which can't be done while holding MetaspaceExpand_lock assert(sum_capacity_in_chunks_in_use() == allocated_chunks_words(), "sum_capacity_in_chunks_in_use() " SIZE_FORMAT " allocated_chunks_words() " SIZE_FORMAT, sum_capacity_in_chunks_in_use(), allocated_chunks_words()); - MutexLockerEx fcl(SpaceManager::expand_lock(), + MutexLockerEx fcl(MetaspaceExpand_lock, Mutex::_no_safepoint_check_flag); assert(sum_count_in_chunks_in_use() == allocated_chunks_count(), @@ -3778,7 +3762,7 @@ } void MetaspaceUtils::dec_capacity(Metaspace::MetadataType mdtype, size_t words) { - assert_lock_strong(SpaceManager::expand_lock()); + assert_lock_strong(MetaspaceExpand_lock); assert(words <= capacity_words(mdtype), "About to decrement below 0: words " SIZE_FORMAT " is greater than _capacity_words[%u] " SIZE_FORMAT, @@ -3787,7 +3771,7 @@ } void MetaspaceUtils::inc_capacity(Metaspace::MetadataType mdtype, size_t words) { - assert_lock_strong(SpaceManager::expand_lock()); + assert_lock_strong(MetaspaceExpand_lock); // Needs to be atomic _capacity_words[mdtype] += words; } @@ -3798,7 +3782,7 @@ " is greater than _used_words[%u] " SIZE_FORMAT, words, mdtype, used_words(mdtype)); // For CMS deallocation of the Metaspaces occurs during the - // sweep which is a concurrent phase. Protection by the expand_lock() + // sweep which is a concurrent phase. Protection by the MetaspaceExpand_lock // is not enough since allocation is on a per Metaspace basis // and protected by the Metaspace lock. Atomic::sub(words, &_used_words[mdtype]); @@ -4227,7 +4211,7 @@ // Prints an ASCII representation of the given space. void MetaspaceUtils::print_metaspace_map(outputStream* out, Metaspace::MetadataType mdtype) { - MutexLockerEx cl(SpaceManager::expand_lock(), Mutex::_no_safepoint_check_flag); + MutexLockerEx cl(MetaspaceExpand_lock, Mutex::_no_safepoint_check_flag); const bool for_class = mdtype == Metaspace::ClassType ? true : false; VirtualSpaceList* const vsl = for_class ? Metaspace::class_space_list() : Metaspace::space_list(); if (vsl != NULL) { @@ -4774,7 +4758,7 @@ } void Metaspace::purge() { - MutexLockerEx cl(SpaceManager::expand_lock(), + MutexLockerEx cl(MetaspaceExpand_lock, Mutex::_no_safepoint_check_flag); purge(NonClassType); if (using_class_space()) { @@ -4842,7 +4826,7 @@ _class_vsm = new SpaceManager(Metaspace::ClassType, type, lock); } - MutexLockerEx cl(SpaceManager::expand_lock(), Mutex::_no_safepoint_check_flag); + MutexLockerEx cl(MetaspaceExpand_lock, Mutex::_no_safepoint_check_flag); // Allocate chunk for metadata objects initialize_first_chunk(type, Metaspace::NonClassType); @@ -5049,7 +5033,7 @@ static void test_virtual_space_list_large_chunk() { VirtualSpaceList* vs_list = new VirtualSpaceList(os::vm_allocation_granularity()); - MutexLockerEx cl(SpaceManager::expand_lock(), Mutex::_no_safepoint_check_flag); + MutexLockerEx cl(MetaspaceExpand_lock, Mutex::_no_safepoint_check_flag); // A size larger than VirtualSpaceSize (256k) and add one page to make it _not_ be // vm_allocation_granularity aligned on Windows. size_t large_size = (size_t)(2*256*K + (os::vm_page_size()/BytesPerWord)); @@ -5084,7 +5068,7 @@ public: static void test() { - MutexLockerEx ml(SpaceManager::expand_lock(), Mutex::_no_safepoint_check_flag); + MutexLockerEx ml(MetaspaceExpand_lock, Mutex::_no_safepoint_check_flag); const size_t vsn_test_size_words = MediumChunk * 4; const size_t vsn_test_size_bytes = vsn_test_size_words * BytesPerWord;