archive/jdk
1
0
Fork 0
mirror of https://github.com/openjdk/jdk.git synced 2025-08-28 15:24:43 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

8198760: Move global lock SpaceManager::_expand_lock to MutexLocker.cpp

Browse source 
We should avoid having global locks buried in cpp files

Reviewed-by: tschatzl, lfoltan, gtriantafill, stuefe
This commit is contained in:
Coleen Phillimore 2018-03-26 09:35:20 -04:00
parent c450333748
commit c892f948e0
3 changed files with 52 additions and 61 deletions
Download patch file Download diff file Expand all files Collapse all files

106
src/hotspot/share/memory/metaspace.cpp
View file

@ -1260,11 +1260,6 @@ class SpaceManager : public CHeapObj<mtClass> {
// 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 @@ class SpaceManager : public CHeapObj<mtClass> {
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 @@ class SpaceManager : public CHeapObj<mtClass> {
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 @@ bool VirtualSpaceNode::expand_by(size_t min_words, size_t preferred_words) {
}
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 @@ VirtualSpaceList::~VirtualSpaceList() {
}
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 @@ void VirtualSpaceList::dec_reserved_words(size_t v) {
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 @@ void ChunkManager::remove_chunk(Metachunk* chunk) {
}
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 @@ int ChunkManager::remove_chunks_in_area(MetaWord* p, size_t word_size) {
// 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 @@ bool VirtualSpaceList::contains(const void* ptr) {
}
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 @@ VirtualSpaceList::VirtualSpaceList(size_t word_size) :
_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 @@ VirtualSpaceList::VirtualSpaceList(ReservedSpace rs) :
_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 @@ size_t VirtualSpaceList::free_bytes() {
// 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 @@ size_t ChunkManager::free_chunks_total_bytes() {
// 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 @@ void ChunkManager::account_for_removed_chunk(const Metachunk* c) {
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 @@ size_t ChunkManager::size_by_index(ChunkIndex index) const {
}
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::locked_verify_free_chunks_total() {
}
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::locked_verify_free_chunks_count() {
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_verify() {
}
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 @@ ChunkList* ChunkManager::free_chunks(ChunkIndex index) {
// 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() {
}
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::split_chunk(size_t target_chunk_word_size, Metachunk* l
}
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::free_chunks_get(size_t word_size) {
}
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 @@ Metachunk* ChunkManager::chunk_freelist_allocate(size_t word_size) {
}
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::print_on(outputStream* out) const {
}
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::locked_get_statistics(ChunkManagerStatistics* stat) const {
}
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 @@ MetaWord* SpaceManager::grow_and_allocate(size_t word_size) {
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 @@ SpaceManager::SpaceManager(Metaspace::MetadataType mdtype,
}
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 @@ void SpaceManager::initialize() {
}
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 @@ size_t MetaspaceUtils::free_bytes() {
}
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::dec_capacity(Metaspace::MetadataType mdtype, size_t words)
}
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 @@ void MetaspaceUtils::dec_used(Metaspace::MetadataType mdtype, size_t words) {
" 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 @@ void MetaspaceUtils::dump(outputStream* out) {
// 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(MetadataType mdtype) {
}
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 @@ void ClassLoaderMetaspace::initialize(Mutex* lock, Metaspace::MetaspaceType type
_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 @@ class TestMetaspaceUtilsTest : AllStatic {
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 @@ class TestVirtualSpaceNodeTest {
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;

4
src/hotspot/share/runtime/mutexLocker.cpp
View file

@ -138,6 +138,8 @@ Mutex* JfrStream_lock = NULL;
Mutex* UnsafeJlong_lock = NULL;
#endif
Mutex* MetaspaceExpand_lock = NULL;
#define MAX_NUM_MUTEX 128
static Monitor * _mutex_array[MAX_NUM_MUTEX];
static int _num_mutex;
@ -210,6 +212,8 @@ void mutex_init() {
def(RawMonitor_lock , PaddedMutex , special, true, Monitor::_safepoint_check_never);
def(OopMapCacheAlloc_lock , PaddedMutex , leaf, true, Monitor::_safepoint_check_always); // used for oop_map_cache allocation.
def(MetaspaceExpand_lock , PaddedMutex , leaf-1, true, Monitor::_safepoint_check_never);
def(Patching_lock , PaddedMutex , special, true, Monitor::_safepoint_check_never); // used for safepointing and code patching.
def(Service_lock , PaddedMonitor, special, true, Monitor::_safepoint_check_never); // used for service thread operations
def(JmethodIdCreation_lock , PaddedMutex , leaf, true, Monitor::_safepoint_check_always); // used for creating jmethodIDs.

3
src/hotspot/share/runtime/mutexLocker.hpp
View file

@ -137,6 +137,9 @@ extern Mutex* JfrStream_lock; // protects JFR stream access
extern Mutex* UnsafeJlong_lock; // provides Unsafe atomic updates to jlongs on platforms that don't support cx8
#endif
extern Mutex* MetaspaceExpand_lock; // protects Metaspace virtualspace and chunk expansions
// A MutexLocker provides mutual exclusion with respect to a given mutex
// for the scope which contains the locker. The lock is an OS lock, not
// an object lock, and the two do not interoperate. Do not use Mutex-based