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

equal deleted inserted replaced

-:2cecbd566968
+:a5f523f2ff91
 }
 return byte_size / BytesPerWord;
 }
 // Given a requested word size, will allocate a chunk large enough to at least fit that
-// size, but may be larger according to the rules in the ChunkAllocSequence.
+// size, but may be larger according to internal heuristics.
-// Updates counters and adds the chunk to the head of the chunk list.
+//
-Metachunk* SpaceManager::allocate_chunk_to_fit(size_t requested_word_size) {
+// On success, it will replace the current chunk with the newly allocated one, which will
+// become the current chunk. The old current chunk should be retired beforehand.
+//
+// May fail if we could not allocate a new chunk. In that case the current chunk remains
+// unchanged and false is returned.
+bool SpaceManager::allocate_new_current_chunk(size_t requested_word_size) {
 assert_lock_strong(lock());
 guarantee(requested_word_size < chklvl::MAX_CHUNK_WORD_SIZE,
 "Requested size too large (" SIZE_FORMAT ").", requested_word_size);
+// If we have a current chunk, it should have been retired (almost empty) beforehand.
+// See: retire_current_chunk().
+assert(current_chunk() == NULL || current_chunk()->free_below_committed_words() <= 10, "Must retire chunk beforehand");
 const chklvl_t min_level = chklvl::level_fitting_word_size(requested_word_size);
 chklvl_t pref_level = _chunk_alloc_sequence->get_next_chunk_level(_chunks.size());
 if (pref_level > min_level) {
 pref_level = min_level;
 }
 Metachunk* c = _chunk_manager->get_chunk(min_level, pref_level);
-assert(c != NULL, "Could not get a chunk");
+if (c == NULL) {
+log_debug(metaspace)("SpaceManager %s: failed to allocate new chunk for requested word size " SIZE_FORMAT ".",
+_name, requested_word_size);
+return false;
+}
 assert(c->is_in_use(), "Wrong chunk state.");
 assert(c->level() <= min_level && c->level() >= pref_level, "Sanity");
 _chunks.add(c);
 }
 SpaceManager::~SpaceManager() {
 MutexLocker fcl(lock(), Mutex::_no_safepoint_check_flag);
-// Return all chunks to our chunk manager.
-// Note: this destroys the _chunks list.
 Metachunk* c = _chunks.first();
 Metachunk* c2 = NULL;
 while(c) {
 // c may become invalid. Take care while iterating.
 c2 = c->next();
 delete _block_freelist;
 }
-// The current chunk is unable to service a request. The remainder of the chunk is
+// The remaining committed free space in the current chunk is chopped up and stored in the block
-// chopped into blocks and fed into the _block_freelists, in the hope of later reuse.
+// free list for later use. As a result, the current chunk will remain current but completely
+// used up. This is a preparation for calling allocate_new_current_chunk().
 void SpaceManager::retire_current_chunk() {
 assert_lock_strong(lock());
 Metachunk* c = current_chunk();
 assert(c != NULL, "Sanity");
 log_debug(metaspace)("SpaceManager %s: retiring chunk " METACHUNK_FULL_FORMAT ".",
 _name, METACHUNK_FULL_FORMAT_ARGS(c));
-// We can run into very rare situations where we would retire a completely empty chunk.
+// Side note:
-// This should be exceedingly rare: the chunk was created to fit a prior, smaller, allocation,
+// In theory it could happen that we are asked to retire a completely empty chunk. This may be the
-// and then the allocation did not go thru since we hit the commit limit, or was immediately
+// result of rolled back allocations (see deallocate in place) and a lot of luck.
-// immediately deallocated and that hit the fast path (see Metachunk::attempt_roll_back_allocation()).
+// But since these cases should be exceedingly rare, we do not handle them special in order to keep
-// Then, that allocation was followed by a larger allocation which is too small for the still
+// the code simple.
-// empty current chunk.
-if (c->used_words() == 0) {
+size_t raw_remaining_words = c->free_below_committed_words();
-// (A)
+size_t net_remaining_words = get_net_allocation_word_size(raw_remaining_words);
-log_trace(metaspace)("SpaceManager %s: ... completely empty, return to freelist: chunk" METACHUNK_FORMAT ".",
+if (net_remaining_words > 0) {
-_name, METACHUNK_FORMAT_ARGS(c));
+bool did_hit_limit = false;
+MetaWord* ptr = c->allocate(net_remaining_words, &did_hit_limit);
-// Remove the current chunk from our list and return it to the chunk manager.
+assert(ptr != NULL && did_hit_limit == false, "Should have worked");
-_chunks.remove(c);
+add_allocation_to_block_freelist(ptr, net_remaining_words);
-_chunk_manager->return_chunk(c);
+_total_used_words_counter->increment_by(net_remaining_words);
-} else {
-// (B)
-size_t raw_remaining_words = c->free_below_committed_words();
-size_t net_remaining_words = get_net_allocation_word_size(raw_remaining_words);
-if (net_remaining_words > 0) {
-bool did_hit_limit = false;
-MetaWord* ptr = c->allocate(net_remaining_words, &did_hit_limit);
-assert(ptr != NULL && did_hit_limit == false, "Should have worked");
-add_allocation_to_block_freelist(ptr, net_remaining_words);
-_total_used_words_counter->increment_by(net_remaining_words);
-}
 }
 // After this operation: the current chunk should have (almost) no free committed space left.
-// It could also be NULL, if we hit case (A) and returned the only chunk in this space manager.
+assert(current_chunk()->free_below_committed_words() <= highest_possible_delta_between_raw_and_net_size,
-assert(current_chunk() == NULL ||
-current_chunk()->free_below_committed_words() <= highest_possible_delta_between_raw_and_net_size,
 "Chunk retiring did not work (current chunk " METACHUNK_FULL_FORMAT ").",
 METACHUNK_FULL_FORMAT_ARGS(current_chunk()));
 }
 bool did_hit_limit = false;
 // Allocate first chunk if needed.
 if (current_chunk() == NULL) {
-Metachunk* c = allocate_chunk_to_fit(raw_word_size);
+if (allocate_new_current_chunk(raw_word_size) == false) {
-assert(c != NULL && _chunks.size() == 1 && c == current_chunk(), "Should be");
+did_hit_limit = true;
+} else {
+assert(current_chunk() != NULL && current_chunk()->free_words() >= raw_word_size, "Sanity");
+}
 }
 // 1) Attempt to allocate from the dictionary of deallocated blocks.
 // Allocation from the dictionary is expensive in the sense that
 retire_current_chunk();
 DEBUG_ONLY(InternalStats::inc_num_chunks_retired();)
 // Allocate a new chunk.
-Metachunk* c = allocate_chunk_to_fit(raw_word_size);
+if (allocate_new_current_chunk(raw_word_size) == false) {
-assert(c != NULL && _chunks.size() > 0 && c == current_chunk(), "Should be");
+did_hit_limit = true;
+} else {
-p = current_chunk()->allocate(raw_word_size, &did_hit_limit);
+assert(current_chunk() != NULL && current_chunk()->free_words() >= raw_word_size, "Sanity");
-log_trace(metaspace)("SpaceManager %s: .. allocated new chunk " CHKLVL_FORMAT " and taken from that.",
+p = current_chunk()->allocate(raw_word_size, &did_hit_limit);
-_name, current_chunk()->level());
+log_trace(metaspace)("SpaceManager %s: .. allocated new chunk " CHKLVL_FORMAT " and taken from that.",
+_name, current_chunk()->level());
+}
 }
 assert(p != NULL || (p == NULL && did_hit_limit), "Sanity");
 if (p == NULL) {
 DEBUG_ONLY(InternalStats::inc_num_allocs_failed_limit();)
 } else {
 DEBUG_ONLY(InternalStats::inc_num_allocs();)
+_total_used_words_counter->increment_by(raw_word_size);
 }
 log_trace(metaspace)("SpaceManager %s: returned " PTR_FORMAT ".",
 _name, p2i(p));
-_total_used_words_counter->increment_by(raw_word_size);
 return p;
 }

branch	stuefe-new-metaspace-branch
changeset 58085	a5f523f2ff91
parent 58063	bdf136b8ae0e
child 58227	0e7d9a23261e