jdk-sandbox: comparison hotspot/src/share/vm/gc/cms/concurrentMarkSweepGeneration.cpp

equal deleted inserted replaced

-:7ed47d0b888a
+:390a27af5657
 _cmsSpace = new CompactibleFreeListSpace(_bts, MemRegion(bottom, end),
 use_adaptive_freelists,
 dictionaryChoice);
 NOT_PRODUCT(debug_cms_space = _cmsSpace;)
-_cmsSpace->_gen = this;
+_cmsSpace->_old_gen = this;
 _gc_stats = new CMSGCStats();
 // Verify the assumption that FreeChunk::_prev and OopDesc::_klass
 // offsets match. The ability to tell free chunks from objects
 GenCollectedHeap* gch = GenCollectedHeap::heap();
 size_t expected_promotion = MIN2(gch->young_gen()->capacity(),
 (size_t) _cms_gen->gc_stats()->avg_promoted()->padded_average());
 if (cms_free > expected_promotion) {
 // Start a cms collection if there isn't enough space to promote
-// for the next minor collection.  Use the padded average as
+// for the next young collection.  Use the padded average as
 // a safety factor.
 cms_free -= expected_promotion;
 // Adjust by the safety factor.
 double cms_free_dbl = (double)cms_free;
-double cms_adjustment = (100.0 - CMSIncrementalSafetyFactor)/100.0;
+double cms_adjustment = (100.0 - CMSIncrementalSafetyFactor) / 100.0;
 // Apply a further correction factor which tries to adjust
 // for recent occurance of concurrent mode failures.
 cms_adjustment = cms_adjustment * cms_free_adjustment_factor(cms_free);
 cms_free_dbl = cms_free_dbl * cms_adjustment;
 // Support for multi-threaded concurrent phases
 if (CMSConcurrentMTEnabled) {
 if (FLAG_IS_DEFAULT(ConcGCThreads)) {
 // just for now
-FLAG_SET_DEFAULT(ConcGCThreads, (ParallelGCThreads + 3)/4);
+FLAG_SET_DEFAULT(ConcGCThreads, (ParallelGCThreads + 3) / 4);
 }
 if (ConcGCThreads > 1) {
 _conc_workers = new YieldingFlexibleWorkGang("CMS Thread",
 ConcGCThreads, true);
 if (_conc_workers == NULL) {
 }
 _cmsGen ->init_initiating_occupancy(CMSInitiatingOccupancyFraction, CMSTriggerRatio);
 // Clip CMSBootstrapOccupancy between 0 and 100.
-_bootstrap_occupancy = ((double)CMSBootstrapOccupancy)/(double)100;
+_bootstrap_occupancy = CMSBootstrapOccupancy / 100.0;
 // Now tell CMS generations the identity of their collector
 ConcurrentMarkSweepGeneration::set_collector(this);
 // Create & start a CMS thread for this CMS collector
 if (gch->supports_inline_contig_alloc()) {
 _top_addr = gch->top_addr();
 _end_addr = gch->end_addr();
 assert(_young_gen != NULL, "no _young_gen");
 _eden_chunk_index = 0;
-_eden_chunk_capacity = (_young_gen->max_capacity()+CMSSamplingGrain)/CMSSamplingGrain;
+_eden_chunk_capacity = (_young_gen->max_capacity() + CMSSamplingGrain) / CMSSamplingGrain;
 _eden_chunk_array = NEW_C_HEAP_ARRAY(HeapWord*, _eden_chunk_capacity, mtGC);
 }
 // Support for parallelizing survivor space rescan
 if ((CMSParallelRemarkEnabled && CMSParallelSurvivorRemarkEnabled) || CMSParallelInitialMarkEnabled) {
 size_t expand_bytes = MAX2(desired_capacity - capacity(), MinHeapDeltaBytes);
 if (PrintGCDetails && Verbose) {
 size_t desired_capacity = (size_t)(used() / ((double) 1 - desired_free_percentage));
 gclog_or_tty->print_cr("\nFrom compute_new_size: ");
 gclog_or_tty->print_cr("  Free fraction %f", free_percentage);
-gclog_or_tty->print_cr("  Desired free fraction %f",
+gclog_or_tty->print_cr("  Desired free fraction %f", desired_free_percentage);
-desired_free_percentage);
+gclog_or_tty->print_cr("  Maximum free fraction %f", maximum_free_percentage);
-gclog_or_tty->print_cr("  Maximum free fraction %f",
+gclog_or_tty->print_cr("  Capacity " SIZE_FORMAT, capacity() / 1000);
-maximum_free_percentage);
+gclog_or_tty->print_cr("  Desired capacity " SIZE_FORMAT, desired_capacity / 1000);
-gclog_or_tty->print_cr("  Capacity " SIZE_FORMAT, capacity()/1000);
-gclog_or_tty->print_cr("  Desired capacity " SIZE_FORMAT,
-desired_capacity/1000);
 GenCollectedHeap* gch = GenCollectedHeap::heap();
 assert(gch->is_old_gen(this), "The CMS generation should always be the old generation");
 size_t young_size = gch->young_gen()->capacity();
 gclog_or_tty->print_cr("  Young gen size " SIZE_FORMAT, young_size / 1000);
-gclog_or_tty->print_cr("  unsafe_max_alloc_nogc " SIZE_FORMAT,
+gclog_or_tty->print_cr("  unsafe_max_alloc_nogc " SIZE_FORMAT, unsafe_max_alloc_nogc() / 1000);
-unsafe_max_alloc_nogc()/1000);
+gclog_or_tty->print_cr("  contiguous available " SIZE_FORMAT, contiguous_available() / 1000);
-gclog_or_tty->print_cr("  contiguous available " SIZE_FORMAT,
+gclog_or_tty->print_cr("  Expand by " SIZE_FORMAT " (bytes)", expand_bytes);
-contiguous_available()/1000);
-gclog_or_tty->print_cr("  Expand by " SIZE_FORMAT " (bytes)",
-expand_bytes);
 }
 // safe if expansion fails
 expand_for_gc_cause(expand_bytes, 0, CMSExpansionCause::_satisfy_free_ratio);
 if (PrintGCDetails && Verbose) {
-gclog_or_tty->print_cr("  Expanded free fraction %f",
+gclog_or_tty->print_cr("  Expanded free fraction %f", ((double) free()) / capacity());
-((double) free()) / capacity());
 }
 } else {
 size_t desired_capacity = (size_t)(used() / ((double) 1 - desired_free_percentage));
 assert(desired_capacity <= capacity(), "invalid expansion size");
 size_t shrink_bytes = capacity() - desired_capacity;
 Mutex* ConcurrentMarkSweepGeneration::freelistLock() const {
 return cmsSpace()->freelistLock();
 }
-HeapWord* ConcurrentMarkSweepGeneration::allocate(size_t size,
+HeapWord* ConcurrentMarkSweepGeneration::allocate(size_t size, bool tlab) {
-bool   tlab) {
 CMSSynchronousYieldRequest yr;
-MutexLockerEx x(freelistLock(),
+MutexLockerEx x(freelistLock(), Mutex::_no_safepoint_check_flag);
-Mutex::_no_safepoint_check_flag);
 return have_lock_and_allocate(size, tlab);
 }
 HeapWord* ConcurrentMarkSweepGeneration::have_lock_and_allocate(size_t size,
 bool   tlab /* ignored */) {
 assert_lock_strong(freelistLock());
 size_t adjustedSize = CompactibleFreeListSpace::adjustObjectSize(size);
 HeapWord* res = cmsSpace()->allocate(adjustedSize);
 // Allocate the object live (grey) if the background collector has
 // started marking. This is necessary because the marker may
 {
 StrongRootsScope srs(1);
 gch->gen_process_roots(&srs,
 GenCollectedHeap::OldGen,
-true,   // younger gens are roots
+true,   // young gen as roots
 GenCollectedHeap::ScanningOption(roots_scanning_options()),
 should_unload_classes(),
 &notOlder,
 NULL,
 NULL);
 {
 StrongRootsScope srs(1);
 gch->gen_process_roots(&srs,
 GenCollectedHeap::OldGen,
-true,   // younger gens are roots
+true,   // young gen as roots
 GenCollectedHeap::ScanningOption(roots_scanning_options()),
 should_unload_classes(),
 &notOlder,
 NULL,
 &cld_closure);
 void CMSCollector::checkpointRootsInitialWork() {
 assert(SafepointSynchronize::is_at_safepoint(), "world should be stopped");
 assert(_collectorState == InitialMarking, "just checking");
-// If there has not been a GC[n-1] since last GC[n] cycle completed,
+// Already have locks.
-// precede our marking with a collection of all
-// younger generations to keep floating garbage to a minimum.
-// XXX: we won't do this for now -- it's an optimization to be done later.
-// already have locks
 assert_lock_strong(bitMapLock());
 assert(_markBitMap.isAllClear(), "was reset at end of previous cycle");
 // Setup the verification and class unloading state for this
 // CMS collection cycle.
 StrongRootsScope srs(1);
 gch->gen_process_roots(&srs,
 GenCollectedHeap::OldGen,
-true,   // younger gens are roots
+true,   // young gen as roots
 GenCollectedHeap::ScanningOption(roots_scanning_options()),
 should_unload_classes(),
 &notOlder,
 NULL,
 &cld_closure);
 }
 }
 // Clear mod-union table; it will be dirtied in the prologue of
-// CMS generation per each younger generation collection.
+// CMS generation per each young generation collection.
 assert(_modUnionTable.isAllClear(),
 "Was cleared in most recent final checkpoint phase"
 " or no bits are set in the gc_prologue before the start of the next "
 "subsequent marking phase.");
 bool CMSCollector::markFromRoots() {
 // we might be tempted to assert that:
 // assert(!SafepointSynchronize::is_at_safepoint(),
 //        "inconsistent argument?");
 // However that wouldn't be right, because it's possible that
-// a safepoint is indeed in progress as a younger generation
+// a safepoint is indeed in progress as a young generation
 // stop-the-world GC happens even as we mark in this generation.
 assert(_collectorState == Marking, "inconsistent state?");
 check_correct_thread_executing();
 verify_overflow_empty();
 // Weak ref discovery note: We may be discovering weak
 // refs in this generation concurrent (but interleaved) with
-// weak ref discovery by a younger generation collector.
+// weak ref discovery by the young generation collector.
 CMSTokenSyncWithLocks ts(true, bitMapLock());
 TraceCPUTime tcpu(PrintGCDetails, true, gclog_or_tty);
 CMSPhaseAccounting pa(this, "mark", _gc_tracer_cm->gc_id(), !PrintGCDetails);
 bool res = markFromRootsWork();
 //   push oop on marking stack
 // . drain the marking stack
 // Note that when we do a marking step we need to hold the
 // bit map lock -- recall that direct allocation (by mutators)
-// and promotion (by younger generation collectors) is also
+// and promotion (by the young generation collector) is also
 // marking the bit map. [the so-called allocate live policy.]
 // Because the implementation of bit map marking is not
 // robust wrt simultaneous marking of bits in the same word,
 // we need to make sure that there is no such interference
 // between concurrent such updates.
 // NOTE: preclean_mod_union_table() and preclean_card_table()
 // further below are largely identical; if you need to modify
 // one of these methods, please check the other method too.
 size_t CMSCollector::preclean_mod_union_table(
-ConcurrentMarkSweepGeneration* gen,
+ConcurrentMarkSweepGeneration* old_gen,
 ScanMarkedObjectsAgainCarefullyClosure* cl) {
 verify_work_stacks_empty();
 verify_overflow_empty();
 // strategy: starting with the first card, accumulate contiguous
 // that, in case the generations expand while we are precleaning.
 // It might also be fine to just use the committed part of the
 // generation, but we might potentially miss cards when the
 // generation is rapidly expanding while we are in the midst
 // of precleaning.
-HeapWord* startAddr = gen->reserved().start();
+HeapWord* startAddr = old_gen->reserved().start();
-HeapWord* endAddr   = gen->reserved().end();
+HeapWord* endAddr   = old_gen->reserved().end();
-cl->setFreelistLock(gen->freelistLock());   // needed for yielding
+cl->setFreelistLock(old_gen->freelistLock());   // needed for yielding
 size_t numDirtyCards, cumNumDirtyCards;
 HeapWord *nextAddr, *lastAddr;
 for (cumNumDirtyCards = numDirtyCards = 0,
 nextAddr = lastAddr = startAddr;
 if (!dirtyRegion.is_empty()) {
 assert(numDirtyCards > 0, "consistency check");
 HeapWord* stop_point = NULL;
 stopTimer();
 // Potential yield point
-CMSTokenSyncWithLocks ts(true, gen->freelistLock(),
+CMSTokenSyncWithLocks ts(true, old_gen->freelistLock(),
 bitMapLock());
 startTimer();
 {
 verify_work_stacks_empty();
 verify_overflow_empty();
 sample_eden();
 stop_point =
-gen->cmsSpace()->object_iterate_careful_m(dirtyRegion, cl);
+old_gen->cmsSpace()->object_iterate_careful_m(dirtyRegion, cl);
 }
 if (stop_point != NULL) {
 // The careful iteration stopped early either because it found an
 // uninitialized object, or because we were in the midst of an
 // "abortable preclean", which should now be aborted. Redirty
 // NOTE: preclean_mod_union_table() above and preclean_card_table()
 // below are largely identical; if you need to modify
 // one of these methods, please check the other method too.
-size_t CMSCollector::preclean_card_table(ConcurrentMarkSweepGeneration* gen,
+size_t CMSCollector::preclean_card_table(ConcurrentMarkSweepGeneration* old_gen,
 ScanMarkedObjectsAgainCarefullyClosure* cl) {
 // strategy: it's similar to precleamModUnionTable above, in that
 // we accumulate contiguous ranges of dirty cards, mark these cards
 // precleaned, then scan the region covered by these cards.
-HeapWord* endAddr   = (HeapWord*)(gen->_virtual_space.high());
+HeapWord* endAddr   = (HeapWord*)(old_gen->_virtual_space.high());
-HeapWord* startAddr = (HeapWord*)(gen->_virtual_space.low());
+HeapWord* startAddr = (HeapWord*)(old_gen->_virtual_space.low());
-cl->setFreelistLock(gen->freelistLock());   // needed for yielding
+cl->setFreelistLock(old_gen->freelistLock());   // needed for yielding
 size_t numDirtyCards, cumNumDirtyCards;
 HeapWord *lastAddr, *nextAddr;
 for (cumNumDirtyCards = numDirtyCards = 0,
 numDirtyCards =
 dirtyRegion.word_size()/CardTableModRefBS::card_size_in_words;
 if (!dirtyRegion.is_empty()) {
 stopTimer();
-CMSTokenSyncWithLocks ts(true, gen->freelistLock(), bitMapLock());
+CMSTokenSyncWithLocks ts(true, old_gen->freelistLock(), bitMapLock());
 startTimer();
 sample_eden();
 verify_work_stacks_empty();
 verify_overflow_empty();
 HeapWord* stop_point =
-gen->cmsSpace()->object_iterate_careful_m(dirtyRegion, cl);
+old_gen->cmsSpace()->object_iterate_careful_m(dirtyRegion, cl);
 if (stop_point != NULL) {
 assert((_collectorState == AbortablePreclean && should_abort_preclean()),
 "Should only be AbortablePreclean.");
 _ct->ct_bs()->invalidate(MemRegion(stop_point, dirtyRegion.end()));
 if (should_abort_preclean()) {
 // parallelize such a scan), but rather will be broken up into
 // a set of parallel tasks (via the sampling that the [abortable]
 // preclean phase did of eden, plus the [two] tasks of
 // scanning the [two] survivor spaces. Further fine-grain
 // parallelization of the scanning of the survivor spaces
-// themselves, and of precleaning of the younger gen itself
+// themselves, and of precleaning of the young gen itself
 // is deferred to the future.
 initialize_sequential_subtasks_for_young_gen_rescan(n_workers);
 // The dirty card rescan work is broken up into a "sequence"
 // of parallel tasks (per constituent space) that are dynamically
 gch->rem_set()->prepare_for_younger_refs_iterate(false); // Not parallel.
 StrongRootsScope srs(1);
 gch->gen_process_roots(&srs,
 GenCollectedHeap::OldGen,
-true,  // younger gens as roots
+true,  // young gen as roots
 GenCollectedHeap::ScanningOption(roots_scanning_options()),
 should_unload_classes(),
 &mrias_cl,
 NULL,
 NULL); // The dirty klasses will be handled below
 // Gather statistics on the young generation collection.
 collector()->stats().record_gc0_end(used());
 }
 }
-void CMSCollector::sweepWork(ConcurrentMarkSweepGeneration* gen) {
+void CMSCollector::sweepWork(ConcurrentMarkSweepGeneration* old_gen) {
 // We iterate over the space(s) underlying this generation,
 // checking the mark bit map to see if the bits corresponding
 // to specific blocks are marked or not. Blocks that are
 // marked are live and are not swept up. All remaining blocks
 // are swept up, with coalescing on-the-fly as we sweep up
 // as well take the bit map lock for the entire duration
 // check that we hold the requisite locks
 assert(have_cms_token(), "Should hold cms token");
 assert(ConcurrentMarkSweepThread::cms_thread_has_cms_token(), "Should possess CMS token to sweep");
-assert_lock_strong(gen->freelistLock());
+assert_lock_strong(old_gen->freelistLock());
 assert_lock_strong(bitMapLock());
 assert(!_inter_sweep_timer.is_active(), "Was switched off in an outer context");
 assert(_intra_sweep_timer.is_active(),  "Was switched on  in an outer context");
-gen->cmsSpace()->beginSweepFLCensus((float)(_inter_sweep_timer.seconds()),
+old_gen->cmsSpace()->beginSweepFLCensus((float)(_inter_sweep_timer.seconds()),
 _inter_sweep_estimate.padded_average(),
 _intra_sweep_estimate.padded_average());
-gen->setNearLargestChunk();
+old_gen->setNearLargestChunk();
 {
-SweepClosure sweepClosure(this, gen, &_markBitMap, CMSYield);
+SweepClosure sweepClosure(this, old_gen, &_markBitMap, CMSYield);
-gen->cmsSpace()->blk_iterate_careful(&sweepClosure);
+old_gen->cmsSpace()->blk_iterate_careful(&sweepClosure);
 // We need to free-up/coalesce garbage/blocks from a
 // co-terminal free run. This is done in the SweepClosure
 // destructor; so, do not remove this scope, else the
 // end-of-sweep-census below will be off by a little bit.
 }
-gen->cmsSpace()->sweep_completed();
+old_gen->cmsSpace()->sweep_completed();
-gen->cmsSpace()->endSweepFLCensus(sweep_count());
+old_gen->cmsSpace()->endSweepFLCensus(sweep_count());
 if (should_unload_classes()) {                // unloaded classes this cycle,
 _concurrent_cycles_since_last_unload = 0;   // ... reset count
 } else {                                      // did not unload classes,
 _concurrent_cycles_since_last_unload++;     // ... increment count
 }

changeset 32623	390a27af5657
parent 32606	fdaa30d06ada
child 32735	c6063d028c3c