jdk8-mips64-public/hotspot: comparison src/share/vm/gc_implementation/concurrentMarkSweep/compactibleFreeListSpace.cpp

-:3c91f2c9fd21
+:9f059abe8cf2
 }
 // Constructor
 CompactibleFreeListSpace::CompactibleFreeListSpace(BlockOffsetSharedArray* bs,
 MemRegion mr, bool use_adaptive_freelists,
-FreeBlockDictionary::DictionaryChoice dictionaryChoice) :
+FreeBlockDictionary<FreeChunk>::DictionaryChoice dictionaryChoice) :
 _dictionaryChoice(dictionaryChoice),
 _adaptive_freelists(use_adaptive_freelists),
 _bt(bs, mr),
 // free list locks are in the range of values taken by _lockRank
 // This range currently is [_leaf+2, _leaf+3]
 CMSRescanMultiple),
 _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::dictionarySplayTree:
+case FreeBlockDictionary<FreeChunk>::dictionarySplayTree:
-case FreeBlockDictionary::dictionarySkipList:
+case FreeBlockDictionary<FreeChunk>::dictionarySkipList:
 default:
 warning("dictionaryChoice: selected option not understood; using"
 " default BinaryTreeDictionary implementation instead.");
-case FreeBlockDictionary::dictionaryBinaryTree:
+case FreeBlockDictionary<FreeChunk>::dictionaryBinaryTree:
-_dictionary = new BinaryTreeDictionary(mr);
+_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.
 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::print_labels_on(st, "size");
+FreeList<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* fl = &_indexedFreeList[i];
+FreeList<FreeChunk>* fl = &_indexedFreeList[i];
 if (fl->head()) {
 ret = getFromListGreater(fl, numWords);
 assert(ret == NULL || ret->isFree(), "Should be returning a free chunk");
 return ret;
 }
 // adjust _unallocated_block downward, as necessary
 _bt.freed((HeapWord*)chunk, size);
 _dictionary->returnChunk(chunk);
 #ifndef PRODUCT
 if (CMSCollector::abstract_state() != CMSCollector::Sweeping) {
-TreeChunk::as_TreeChunk(chunk)->list()->verify_stats();
+TreeChunk<FreeChunk>::as_TreeChunk(chunk)->list()->verify_stats();
 }
 #endif // PRODUCT
 }
 void
 /* 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* it   = _indexedFreeList;
+FreeList<FreeChunk>* it   = _indexedFreeList;
 size_t    hint = _indexedFreeList[start].hint();
 while (hint < IndexSetSize) {
 assert(hint % MinObjAlignment == 0, "hint should be aligned");
-FreeList *fl = &_indexedFreeList[hint];
+FreeList<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* fl,
+FreeChunk* CompactibleFreeListSpace::getFromListGreater(FreeList<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* fl    = &_indexedFreeList[i];
+FreeList<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_coalDesired((ssize_t)((double)fl->desired() * CMSSmallCoalSurplusPercent));
 void CompactibleFreeListSpace::setFLSurplus() {
 assert_locked();
 size_t i;
 for (i = IndexSetStart; i < IndexSetSize; i += IndexSetStride) {
-FreeList *fl = &_indexedFreeList[i];
+FreeList<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 *fl = &_indexedFreeList[i];
+FreeList<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 *fl = &_indexedFreeList[i];
+FreeList<FreeChunk> *fl = &_indexedFreeList[i];
 fl->set_prevSweep(fl->count());
 fl->set_coalBirths(0);
 fl->set_coalDeaths(0);
 fl->set_splitBirths(0);
 fl->set_splitDeaths(0);
 _dictionary->endSweepDictCensus(CMSLargeSplitSurplusPercent);
 }
 bool CompactibleFreeListSpace::coalOverPopulated(size_t size) {
 if (size < SmallForDictionary) {
-FreeList *fl = &_indexedFreeList[size];
+FreeList<FreeChunk> *fl = &_indexedFreeList[size];
 return (fl->coalDesired() < 0) ||
 ((int)fl->count() > fl->coalDesired());
 } else {
 return dictionary()->coalDictOverPopulated(size);
 }
 }
 void CompactibleFreeListSpace::smallCoalBirth(size_t size) {
 assert(size < SmallForDictionary, "Size too large for indexed list");
-FreeList *fl = &_indexedFreeList[size];
+FreeList<FreeChunk> *fl = &_indexedFreeList[size];
 fl->increment_coalBirths();
 fl->increment_surplus();
 }
 void CompactibleFreeListSpace::smallCoalDeath(size_t size) {
 assert(size < SmallForDictionary, "Size too large for indexed list");
-FreeList *fl = &_indexedFreeList[size];
+FreeList<FreeChunk> *fl = &_indexedFreeList[size];
 fl->increment_coalDeaths();
 fl->decrement_surplus();
 }
 void CompactibleFreeListSpace::coalBirth(size_t size) {
 }
 }
 void CompactibleFreeListSpace::smallSplitBirth(size_t size) {
 assert(size < SmallForDictionary, "Size too large for indexed list");
-FreeList *fl = &_indexedFreeList[size];
+FreeList<FreeChunk> *fl = &_indexedFreeList[size];
 fl->increment_splitBirths();
 fl->increment_surplus();
 }
 void CompactibleFreeListSpace::smallSplitDeath(size_t size) {
 assert(size < SmallForDictionary, "Size too large for indexed list");
-FreeList *fl = &_indexedFreeList[size];
+FreeList<FreeChunk> *fl = &_indexedFreeList[size];
 fl->increment_splitDeaths();
 fl->decrement_surplus();
 }
 void CompactibleFreeListSpace::splitBirth(size_t size) {
 #ifndef PRODUCT
 void CompactibleFreeListSpace::check_free_list_consistency() const {
 assert(_dictionary->minSize() <= IndexSetSize,
 "Some sizes can't be allocated without recourse to"
 " linear allocation buffers");
-assert(MIN_TREE_CHUNK_SIZE*HeapWordSize == sizeof(TreeChunk),
+assert(BinaryTreeDictionary<FreeChunk>::min_tree_chunk_size*HeapWordSize == sizeof(TreeChunk<FreeChunk>),
 "else MIN_TREE_CHUNK_SIZE is wrong");
 assert((IndexSetStride == 2 && IndexSetStart == 4) ||                   // 32-bit
 (IndexSetStride == 1 && IndexSetStart == 3), "just checking");   // 64-bit
 assert((IndexSetStride != 2) || (IndexSetStart % 2 == 0),
 "Some for-loops may be incorrectly initialized");
 }
 #endif
 void CompactibleFreeListSpace::printFLCensus(size_t sweep_count) const {
 assert_lock_strong(&_freelistLock);
-FreeList total;
+FreeList<FreeChunk> total;
 gclog_or_tty->print("end sweep# " SIZE_FORMAT "\n", sweep_count);
-FreeList::print_labels_on(gclog_or_tty, "size");
+FreeList<FreeChunk>::print_labels_on(gclog_or_tty, "size");
 size_t totalFree = 0;
 for (size_t i = IndexSetStart; i < IndexSetSize; i += IndexSetStride) {
-const FreeList *fl = &_indexedFreeList[i];
+const FreeList<FreeChunk> *fl = &_indexedFreeList[i];
 totalFree += fl->count() * fl->size();
 if (i % (40*IndexSetStride) == 0) {
-FreeList::print_labels_on(gclog_or_tty, "size");
+FreeList<FreeChunk>::print_labels_on(gclog_or_tty, "size");
 }
 fl->print_on(gclog_or_tty);
 total.set_bfrSurp(    total.bfrSurp()     + fl->bfrSurp()    );
 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* fl = &_indexedFreeList[word_sz];
+FreeList<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* fl) {
+void CFLS_LAB::get_from_global_pool(size_t word_sz, FreeList<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();
+_indexedFreeList[i] = FreeList<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* fl) {
+void CompactibleFreeListSpace:: par_get_chunk_of_blocks(size_t word_sz, size_t n, FreeList<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 fl_for_cur_sz;  // Empty.
+FreeList<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* gfl = &_indexedFreeList[cur_sz];
+FreeList<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);
 MutexLockerEx x(parDictionaryAllocLock(),
 Mutex::_no_safepoint_check_flag);
 while (n > 0) {
 fc = dictionary()->getChunk(MAX2(n * word_sz,
 _dictionary->minSize()),
-FreeBlockDictionary::atLeast);
+FreeBlockDictionary<FreeChunk>::atLeast);
 if (fc != NULL) {
 _bt.allocated((HeapWord*)fc, fc->size(), true /* reducing */);  // update _unallocated_blk
 dictionary()->dictCensusUpdate(fc->size(),
 true /*split*/,
 false /*birth*/);

Mercurial > jdk8-mips64-public > hotspot / file comparison

comparison: src/share/vm/gc_implementation/concurrentMarkSweep/compactibleFreeListSpace.cpp

src/share/vm/gc_implementation/concurrentMarkSweep/compactibleFreeListSpace.cpp