jdk-sandbox: comparison hotspot/src/share/vm/gc_implementation/concurrentMarkSweep/compactibleFreeListSpace.cpp

equal deleted inserted replaced

-:f5e31fb61738
+:944e56f74fba
 _marking_task_size(CardTableModRefBS::card_size_in_words * BitsPerWord *
 CMSConcMarkMultiple),
 _collector(NULL)
 {
 assert(sizeof(FreeChunk) / BytesPerWord <= MinChunkSize,
 "FreeChunk is larger than expected");
 _bt.set_space(this);
 initialize(mr, SpaceDecorator::Clear, SpaceDecorator::Mangle);
 // We have all of "mr", all of which we place in the dictionary
 // as one big chunk. We'll need to decide here which of several
 // possible alternative dictionary implementations to use. For
 // now the choice is easy, since we have only one working
 // implementation, namely, the simple binary tree (splaying
 // temporarily disabled).
 switch (dictionaryChoice) {
+case FreeBlockDictionary<FreeChunk>::dictionaryBinaryTree:
+_dictionary = new BinaryTreeDictionary<FreeChunk, AdaptiveFreeList>(mr);
+break;
 case FreeBlockDictionary<FreeChunk>::dictionarySplayTree:
 case FreeBlockDictionary<FreeChunk>::dictionarySkipList:
 default:
 warning("dictionaryChoice: selected option not understood; using"
 " default BinaryTreeDictionary implementation instead.");
-case FreeBlockDictionary<FreeChunk>::dictionaryBinaryTree:
-_dictionary = new BinaryTreeDictionary<FreeChunk>(mr, use_adaptive_freelists);
-break;
 }
 assert(_dictionary != NULL, "CMS dictionary initialization");
 // The indexed free lists are initially all empty and are lazily
 // filled in on demand. Initialize the array elements to NULL.
 initializeIndexedFreeListArray();
 void CompactibleFreeListSpace::print_indexed_free_lists(outputStream* st)
 const {
 reportIndexedFreeListStatistics();
 gclog_or_tty->print_cr("Layout of Indexed Freelists");
 gclog_or_tty->print_cr("---------------------------");
-FreeList<FreeChunk>::print_labels_on(st, "size");
+AdaptiveFreeList<FreeChunk>::print_labels_on(st, "size");
 for (size_t i = IndexSetStart; i < IndexSetSize; i += IndexSetStride) {
 _indexedFreeList[i].print_on(gclog_or_tty);
 for (FreeChunk* fc = _indexedFreeList[i].head(); fc != NULL;
 fc = fc->next()) {
 gclog_or_tty->print_cr("\t[" PTR_FORMAT "," PTR_FORMAT ")  %s",
 size_t i;
 size_t currSize = numWords + MinChunkSize;
 assert(currSize % MinObjAlignment == 0, "currSize should be aligned");
 for (i = currSize; i < IndexSetSize; i += IndexSetStride) {
-FreeList<FreeChunk>* fl = &_indexedFreeList[i];
+AdaptiveFreeList<FreeChunk>* fl = &_indexedFreeList[i];
 if (fl->head()) {
 ret = getFromListGreater(fl, numWords);
 assert(ret == NULL || ret->is_free(), "Should be returning a free chunk");
 return ret;
 }
 // adjust _unallocated_block downward, as necessary
 _bt.freed((HeapWord*)chunk, size);
 _dictionary->return_chunk(chunk);
 #ifndef PRODUCT
 if (CMSCollector::abstract_state() != CMSCollector::Sweeping) {
-TreeChunk<FreeChunk>::as_TreeChunk(chunk)->list()->verify_stats();
+TreeChunk<FreeChunk, AdaptiveFreeList>* tc = TreeChunk<FreeChunk, AdaptiveFreeList>::as_TreeChunk(chunk);
+TreeList<FreeChunk, AdaptiveFreeList>* tl = tc->list();
+tl->verify_stats();
 }
 #endif // PRODUCT
 }
 void
 }
 FreeChunk* ec;
 {
 MutexLockerEx x(lock, Mutex::_no_safepoint_check_flag);
 ec = dictionary()->find_largest_dict();  // get largest block
-if (ec != NULL && ec->end() == chunk) {
+if (ec != NULL && ec->end() == (uintptr_t*) chunk) {
 // It's a coterminal block - we can coalesce.
 size_t old_size = ec->size();
 coalDeath(old_size);
 removeChunkFromDictionary(ec);
 size += old_size;
 /* A hint is the next larger size that has a surplus.
 Start search at a size large enough to guarantee that
 the excess is >= MIN_CHUNK. */
 size_t start = align_object_size(numWords + MinChunkSize);
 if (start < IndexSetSize) {
-FreeList<FreeChunk>* it   = _indexedFreeList;
+AdaptiveFreeList<FreeChunk>* it   = _indexedFreeList;
 size_t    hint = _indexedFreeList[start].hint();
 while (hint < IndexSetSize) {
 assert(hint % MinObjAlignment == 0, "hint should be aligned");
-FreeList<FreeChunk> *fl = &_indexedFreeList[hint];
+AdaptiveFreeList<FreeChunk> *fl = &_indexedFreeList[hint];
 if (fl->surplus() > 0 && fl->head() != NULL) {
 // Found a list with surplus, reset original hint
 // and split out a free chunk which is returned.
 _indexedFreeList[start].set_hint(hint);
 FreeChunk* res = getFromListGreater(fl, numWords);
 }
 return NULL;
 }
 /* Requires fl->size >= numWords + MinChunkSize */
-FreeChunk* CompactibleFreeListSpace::getFromListGreater(FreeList<FreeChunk>* fl,
+FreeChunk* CompactibleFreeListSpace::getFromListGreater(AdaptiveFreeList<FreeChunk>* fl,
 size_t numWords) {
 FreeChunk *curr = fl->head();
 size_t oldNumWords = curr->size();
 assert(numWords >= MinChunkSize, "Word size is too small");
 assert(curr != NULL, "List is empty");
 float inter_sweep_estimate,
 float intra_sweep_estimate) {
 assert_locked();
 size_t i;
 for (i = IndexSetStart; i < IndexSetSize; i += IndexSetStride) {
-FreeList<FreeChunk>* fl = &_indexedFreeList[i];
+AdaptiveFreeList<FreeChunk>* fl    = &_indexedFreeList[i];
 if (PrintFLSStatistics > 1) {
 gclog_or_tty->print("size[%d] : ", i);
 }
 fl->compute_desired(inter_sweep_current, inter_sweep_estimate, intra_sweep_estimate);
 fl->set_coal_desired((ssize_t)((double)fl->desired() * CMSSmallCoalSurplusPercent));
 void CompactibleFreeListSpace::setFLSurplus() {
 assert_locked();
 size_t i;
 for (i = IndexSetStart; i < IndexSetSize; i += IndexSetStride) {
-FreeList<FreeChunk> *fl = &_indexedFreeList[i];
+AdaptiveFreeList<FreeChunk> *fl = &_indexedFreeList[i];
 fl->set_surplus(fl->count() -
 (ssize_t)((double)fl->desired() * CMSSmallSplitSurplusPercent));
 }
 }
 void CompactibleFreeListSpace::setFLHints() {
 assert_locked();
 size_t i;
 size_t h = IndexSetSize;
 for (i = IndexSetSize - 1; i != 0; i -= IndexSetStride) {
-FreeList<FreeChunk> *fl = &_indexedFreeList[i];
+AdaptiveFreeList<FreeChunk> *fl = &_indexedFreeList[i];
 fl->set_hint(h);
 if (fl->surplus() > 0) {
 h = i;
 }
 }
 void CompactibleFreeListSpace::clearFLCensus() {
 assert_locked();
 size_t i;
 for (i = IndexSetStart; i < IndexSetSize; i += IndexSetStride) {
-FreeList<FreeChunk> *fl = &_indexedFreeList[i];
+AdaptiveFreeList<FreeChunk> *fl = &_indexedFreeList[i];
 fl->set_prev_sweep(fl->count());
 fl->set_coal_births(0);
 fl->set_coal_deaths(0);
 fl->set_split_births(0);
 fl->set_split_deaths(0);
 _dictionary->end_sweep_dict_census(CMSLargeSplitSurplusPercent);
 }
 bool CompactibleFreeListSpace::coalOverPopulated(size_t size) {
 if (size < SmallForDictionary) {
-FreeList<FreeChunk> *fl = &_indexedFreeList[size];
+AdaptiveFreeList<FreeChunk> *fl = &_indexedFreeList[size];
 return (fl->coal_desired() < 0) ||
 ((int)fl->count() > fl->coal_desired());
 } else {
 return dictionary()->coal_dict_over_populated(size);
 }
 }
 void CompactibleFreeListSpace::smallCoalBirth(size_t size) {
 assert(size < SmallForDictionary, "Size too large for indexed list");
-FreeList<FreeChunk> *fl = &_indexedFreeList[size];
+AdaptiveFreeList<FreeChunk> *fl = &_indexedFreeList[size];
 fl->increment_coal_births();
 fl->increment_surplus();
 }
 void CompactibleFreeListSpace::smallCoalDeath(size_t size) {
 assert(size < SmallForDictionary, "Size too large for indexed list");
-FreeList<FreeChunk> *fl = &_indexedFreeList[size];
+AdaptiveFreeList<FreeChunk> *fl = &_indexedFreeList[size];
 fl->increment_coal_deaths();
 fl->decrement_surplus();
 }
 void CompactibleFreeListSpace::coalBirth(size_t size) {
 if (size  < SmallForDictionary) {
 smallCoalBirth(size);
 } else {
-dictionary()->dict_census_udpate(size,
+dictionary()->dict_census_update(size,
 false /* split */,
 true /* birth */);
 }
 }
 void CompactibleFreeListSpace::coalDeath(size_t size) {
 if(size  < SmallForDictionary) {
 smallCoalDeath(size);
 } else {
-dictionary()->dict_census_udpate(size,
+dictionary()->dict_census_update(size,
 false /* split */,
 false /* birth */);
 }
 }
 void CompactibleFreeListSpace::smallSplitBirth(size_t size) {
 assert(size < SmallForDictionary, "Size too large for indexed list");
-FreeList<FreeChunk> *fl = &_indexedFreeList[size];
+AdaptiveFreeList<FreeChunk> *fl = &_indexedFreeList[size];
 fl->increment_split_births();
 fl->increment_surplus();
 }
 void CompactibleFreeListSpace::smallSplitDeath(size_t size) {
 assert(size < SmallForDictionary, "Size too large for indexed list");
-FreeList<FreeChunk> *fl = &_indexedFreeList[size];
+AdaptiveFreeList<FreeChunk> *fl = &_indexedFreeList[size];
 fl->increment_split_deaths();
 fl->decrement_surplus();
 }
 void CompactibleFreeListSpace::split_birth(size_t size) {
 if (size  < SmallForDictionary) {
 smallSplitBirth(size);
 } else {
-dictionary()->dict_census_udpate(size,
+dictionary()->dict_census_update(size,
 true /* split */,
 true /* birth */);
 }
 }
 void CompactibleFreeListSpace::splitDeath(size_t size) {
 if (size  < SmallForDictionary) {
 smallSplitDeath(size);
 } else {
-dictionary()->dict_census_udpate(size,
+dictionary()->dict_census_update(size,
 true /* split */,
 false /* birth */);
 }
 }
 guarantee(n == num, "Incorrect count");
 }
 #ifndef PRODUCT
 void CompactibleFreeListSpace::check_free_list_consistency() const {
-assert(_dictionary->min_size() <= IndexSetSize,
+assert((TreeChunk<FreeChunk, AdaptiveFreeList>::min_size() <= IndexSetSize),
 "Some sizes can't be allocated without recourse to"
 " linear allocation buffers");
-assert(BinaryTreeDictionary<FreeChunk>::min_tree_chunk_size*HeapWordSize == sizeof(TreeChunk<FreeChunk>),
+assert((TreeChunk<FreeChunk, AdaptiveFreeList>::min_size()*HeapWordSize == sizeof(TreeChunk<FreeChunk, AdaptiveFreeList>)),
 "else MIN_TREE_CHUNK_SIZE is wrong");
 assert(IndexSetStart != 0, "IndexSetStart not initialized");
 assert(IndexSetStride != 0, "IndexSetStride not initialized");
 }
 #endif
 void CompactibleFreeListSpace::printFLCensus(size_t sweep_count) const {
 assert_lock_strong(&_freelistLock);
-FreeList<FreeChunk> total;
+AdaptiveFreeList<FreeChunk> total;
 gclog_or_tty->print("end sweep# " SIZE_FORMAT "\n", sweep_count);
-FreeList<FreeChunk>::print_labels_on(gclog_or_tty, "size");
+AdaptiveFreeList<FreeChunk>::print_labels_on(gclog_or_tty, "size");
 size_t total_free = 0;
 for (size_t i = IndexSetStart; i < IndexSetSize; i += IndexSetStride) {
-const FreeList<FreeChunk> *fl = &_indexedFreeList[i];
+const AdaptiveFreeList<FreeChunk> *fl = &_indexedFreeList[i];
 total_free += fl->count() * fl->size();
 if (i % (40*IndexSetStride) == 0) {
-FreeList<FreeChunk>::print_labels_on(gclog_or_tty, "size");
+AdaptiveFreeList<FreeChunk>::print_labels_on(gclog_or_tty, "size");
 }
 fl->print_on(gclog_or_tty);
 total.set_bfr_surp(    total.bfr_surp()     + fl->bfr_surp()    );
 total.set_surplus(    total.surplus()     + fl->surplus()    );
 total.set_desired(    total.desired()     + fl->desired()    );
 MutexLockerEx x(_cfls->parDictionaryAllocLock(),
 Mutex::_no_safepoint_check_flag);
 res = _cfls->getChunkFromDictionaryExact(word_sz);
 if (res == NULL) return NULL;
 } else {
-FreeList<FreeChunk>* fl = &_indexedFreeList[word_sz];
+AdaptiveFreeList<FreeChunk>* fl = &_indexedFreeList[word_sz];
 if (fl->count() == 0) {
 // Attempt to refill this local free list.
 get_from_global_pool(word_sz, fl);
 // If it didn't work, give up.
 if (fl->count() == 0) return NULL;
 return (HeapWord*)res;
 }
 // Get a chunk of blocks of the right size and update related
 // book-keeping stats
-void CFLS_LAB::get_from_global_pool(size_t word_sz, FreeList<FreeChunk>* fl) {
+void CFLS_LAB::get_from_global_pool(size_t word_sz, AdaptiveFreeList<FreeChunk>* fl) {
 // Get the #blocks we want to claim
 size_t n_blks = (size_t)_blocks_to_claim[word_sz].average();
 assert(n_blks > 0, "Error");
 assert(ResizePLAB || n_blks == OldPLABSize, "Error");
 // In some cases, when the application has a phase change,
 _global_num_workers[i]++;
 assert(_global_num_workers[i] <= ParallelGCThreads, "Too big");
 if (num_retire > 0) {
 _cfls->_indexedFreeList[i].prepend(&_indexedFreeList[i]);
 // Reset this list.
-_indexedFreeList[i] = FreeList<FreeChunk>();
+_indexedFreeList[i] = AdaptiveFreeList<FreeChunk>();
 _indexedFreeList[i].set_size(i);
 }
 }
 if (PrintOldPLAB) {
 gclog_or_tty->print_cr("%d[%d]: %d/%d/%d",
 _num_blocks[i]         = 0;
 }
 }
 }
-void CompactibleFreeListSpace:: par_get_chunk_of_blocks(size_t word_sz, size_t n, FreeList<FreeChunk>* fl) {
+void CompactibleFreeListSpace:: par_get_chunk_of_blocks(size_t word_sz, size_t n, AdaptiveFreeList<FreeChunk>* fl) {
 assert(fl->count() == 0, "Precondition.");
 assert(word_sz < CompactibleFreeListSpace::IndexSetSize,
 "Precondition");
 // We'll try all multiples of word_sz in the indexed set, starting with
 size_t cur_sz;
 for (k = 1, cur_sz = k * word_sz, found = false;
 (cur_sz < CompactibleFreeListSpace::IndexSetSize) &&
 (CMSSplitIndexedFreeListBlocks || k <= 1);
 k++, cur_sz = k * word_sz) {
-FreeList<FreeChunk> fl_for_cur_sz;  // Empty.
+AdaptiveFreeList<FreeChunk> fl_for_cur_sz;  // Empty.
 fl_for_cur_sz.set_size(cur_sz);
 {
 MutexLockerEx x(_indexedFreeListParLocks[cur_sz],
 Mutex::_no_safepoint_check_flag);
-FreeList<FreeChunk>* gfl = &_indexedFreeList[cur_sz];
+AdaptiveFreeList<FreeChunk>* gfl = &_indexedFreeList[cur_sz];
 if (gfl->count() != 0) {
 // nn is the number of chunks of size cur_sz that
 // we'd need to split k-ways each, in order to create
 // "n" chunks of size word_sz each.
 const size_t nn = MAX2(n/k, (size_t)1);
 size_t rem;
 {
 MutexLockerEx x(parDictionaryAllocLock(),
 Mutex::_no_safepoint_check_flag);
 while (n > 0) {
-fc = dictionary()->get_chunk(MAX2(n * word_sz,
+fc = dictionary()->get_chunk(MAX2(n * word_sz, _dictionary->min_size()),
-_dictionary->min_size()),
 FreeBlockDictionary<FreeChunk>::atLeast);
 if (fc != NULL) {
 _bt.allocated((HeapWord*)fc, fc->size(), true /* reducing */);  // update _unallocated_blk
-dictionary()->dict_census_udpate(fc->size(),
+dictionary()->dict_census_update(fc->size(),
 true /*split*/,
 false /*birth*/);
 break;
 } else {
 n--;
 _bt.split_block((HeapWord*)fc, fc->size(), prefix_size);
 assert(fc->is_free(), "Error");
 fc->set_size(prefix_size);
 if (rem >= IndexSetSize) {
 returnChunkToDictionary(rem_fc);
-dictionary()->dict_census_udpate(rem, true /*split*/, true /*birth*/);
+dictionary()->dict_census_update(rem, true /*split*/, true /*birth*/);
 rem_fc = NULL;
 }
 // Otherwise, return it to the small list below.
 }
 }

changeset 14123	944e56f74fba
parent 13728	882756847a04
child 15088	8875e774f1a3
child 15228	e92acc84ade3