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

equal deleted inserted replaced

-:714474295e0a
+:b537e6386306
 */
 #include "precompiled.hpp"
 #include "logging/log.hpp"
 #include "logging/logStream.hpp"
+#include "memory/metaspace/blockFreelist.hpp"
 #include "memory/metaspace/chunkManager.hpp"
 #include "memory/metaspace/internStat.hpp"
+#include "memory/metaspace/leftOverBins.inline.hpp"
 #include "memory/metaspace/metachunk.hpp"
 #include "memory/metaspace/metaDebug.hpp"
 #include "memory/metaspace/metaspaceCommon.hpp"
 #include "memory/metaspace/metaspaceStatistics.hpp"
 #include "memory/metaspace/smallBlocks.hpp"
 _block_freelist = new BlockFreelist(); // Create only on demand
 }
 _block_freelist->return_block(p, word_size);
 }
+void SpaceManager::create_lom() {
+assert(_lom == NULL, "Only call once");
+_lom = new LeftOverManager();
+}
+void SpaceManager::add_allocation_to_lom(MetaWord* p, size_t word_size) {
+if (_lom == NULL) {
+_lom = new LeftOverManager(); // Create only on demand
+}
+_lom->add_block(p, word_size);
+}
 SpaceManager::SpaceManager(ChunkManager* chunk_manager,
 const ChunkAllocSequence* alloc_sequence,
 Mutex* lock,
 SizeAtomicCounter* total_used_words_counter,
 const char* name,
 bool is_micro_loader)
 : _lock(lock),
 _chunk_manager(chunk_manager),
 _chunk_alloc_sequence(alloc_sequence),
 _chunks(),
-_block_freelist(NULL),
+_block_freelist(NULL), _lom(NULL),
 _total_used_words_counter(total_used_words_counter),
 _name(name),
 _is_micro_loader(is_micro_loader)
 {
 }
 }
 DEBUG_ONLY(chunk_manager()->verify(true);)
 delete _block_freelist;
+delete _lom;
 }
 // The remaining committed free space in the current chunk is chopped up and stored in the block
 // free list for later use. As a result, the current chunk will remain current but completely
 LOGFMT_SPCMGR_ARGS, p2i(this), METACHUNK_FULL_FORMAT_ARGS(c));
 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);
+if (Settings::use_lom()) {
+add_allocation_to_lom(ptr, net_remaining_words);
+} else {
+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.
 assert(current_chunk()->free_below_committed_words() <= highest_possible_delta_between_raw_and_net_size,
 "Chunk retiring did not work (current chunk " METACHUNK_FULL_FORMAT ").",
 // Allocation from the dictionary is expensive in the sense that
 // the dictionary has to be searched for a size.  Don't allocate
 // from the dictionary until it starts to get fat.  Is this
 // a reasonable policy?  Maybe an skinny dictionary is fast enough
 // for allocations.  Do some profiling.  JJJ
+if (Settings::use_lom()) {
+if (_lom != NULL) {
+p = _lom->get_block(raw_word_size);
+if (p != NULL) {
+DEBUG_ONLY(InternalStats::inc_num_allocs_from_deallocated_blocks();)
+log_trace(metaspace)(LOGFMT_SPCMGR ": .. taken from freelist.", LOGFMT_SPCMGR_ARGS);
+// Note: space in the freeblock dictionary counts as used (see retire_current_chunk()) -
+// that means that we must not increase the used counter again when allocating from the dictionary.
+// Therefore we return here.
+return p;
+}
+}
+} else {
 if (_block_freelist != NULL && _block_freelist->total_size() > Settings::allocation_from_dictionary_limit()) {
 p = _block_freelist->get_block(raw_word_size);
 if (p != NULL) {
 DEBUG_ONLY(InternalStats::inc_num_allocs_from_deallocated_blocks();)
 // that means that we must not increase the used counter again when allocating from the dictionary.
 // Therefore we return here.
 return p;
 }
+}
 }
 // 2) Failing that, attempt to allocate from the current chunk. If we hit commit limit, return NULL.
 if (p == NULL && !did_hit_limit) {
 p = current_chunk()->allocate(raw_word_size, &did_hit_limit);
 if (current_chunk()->attempt_rollback_allocation(p, raw_word_size)) {
 log_trace(metaspace)(LOGFMT_SPCMGR ": ... rollback succeeded.", LOGFMT_SPCMGR_ARGS);
 return;
 }
-add_allocation_to_block_freelist(p, raw_word_size);
+if (Settings::use_lom()) {
+add_allocation_to_lom(p, raw_word_size);
+} else {
+add_allocation_to_block_freelist(p, raw_word_size);
+}
 DEBUG_ONLY(verify_locked();)
 }
 } else {
 ucs.waste_words += c->free_below_committed_words();
 }
 }
-if (block_freelist() != NULL) {
+if (Settings::use_lom()) {
-out->free_blocks_num += block_freelist()->num_blocks();
+if (lom() != NULL) {
-out->free_blocks_word_size += block_freelist()->total_size();
+block_stats_t s;
+lom()->statistics(&s);
+out->free_blocks_num += s.num_blocks;
+out->free_blocks_word_size += s.word_size;
+}
+} else {
+if (block_freelist() != NULL) {
+out->free_blocks_num += block_freelist()->num_blocks();
+out->free_blocks_word_size += block_freelist()->total_size();
+}
 }
 SOMETIMES(out->verify();)
 }
 assert_lock_strong(lock());
 assert(_chunk_alloc_sequence != NULL && _chunk_manager != NULL, "Sanity");
 _chunks.verify();
+if (Settings::use_lom()) {
+if (lom() != NULL) {
+lom()->verify();
+}
+}
 }
 void SpaceManager::verify() const {

branch	stuefe-new-metaspace-branch
changeset 59155	b537e6386306
parent 59107	245a39d9e24d