graal-jvmci-8: src/share/vm/gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.cpp comparison

comparison src/share/vm/gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.cpp @ 1145:e018e6884bd8

6631166: CMS: better heuristics when combatting fragmentation Summary: Autonomic per-worker free block cache sizing, tunable coalition policies, fixes to per-size block statistics, retuned gain and bandwidth of some feedback loop filters to allow quicker reactivity to abrupt changes in ambient demand, and other heuristics to reduce fragmentation of the CMS old gen. Also tightened some assertions, including those related to locking. Reviewed-by: jmasa

author	ysr
date	Wed, 23 Dec 2009 09:23:54 -0800
parents	0e2d7ae2bc67
children	4788266644c1

comparison

equal deleted inserted replaced

-:44f61c24ddab
+:e018e6884bd8
 (double)(tr * MinHeapFreeRatio) / 100.0)
 / 100.0;
 }
 }
 void ConcurrentMarkSweepGeneration::ref_processor_init() {
 assert(collector() != NULL, "no collector");
 collector()->ref_processor_init();
 }
 _allow_duty_cycle_reduction = false;
 _valid_bits = 0;
 _icms_duty_cycle = CMSIncrementalDutyCycle;
 }
+double CMSStats::cms_free_adjustment_factor(size_t free) const {
+// TBD: CR 6909490
+return 1.0;
+}
+void CMSStats::adjust_cms_free_adjustment_factor(bool fail, size_t free) {
+}
 // If promotion failure handling is on use
 // the padded average size of the promotion for each
 // young generation collection.
 double CMSStats::time_until_cms_gen_full() const {
 size_t cms_free = _cms_gen->cmsSpace()->free();
 // a safety factor.
 cms_free -= expected_promotion;
 // Adjust by the safety factor.
 double cms_free_dbl = (double)cms_free;
-cms_free_dbl = cms_free_dbl * (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;
 if (PrintGCDetails && Verbose) {
 gclog_or_tty->print_cr("CMSStats::time_until_cms_gen_full: cms_free "
 SIZE_FORMAT " expected_promotion " SIZE_FORMAT,
 cms_free, expected_promotion);
 // in the query so as to avoid concurrent mode failures
 // due to starting the collection just a wee bit too
 // late.
 double work = cms_duration() + gc0_period();
 double deadline = time_until_cms_gen_full();
+// If a concurrent mode failure occurred recently, we want to be
+// more conservative and halve our expected time_until_cms_gen_full()
 if (work > deadline) {
 if (Verbose && PrintGCDetails) {
 gclog_or_tty->print(
 " CMSCollector: collect because of anticipated promotion "
 "before full %3.7f + %3.7f > %3.7f ", cms_duration(),
 _completed_initialization(false),
 _collector_policy(cp),
 _should_unload_classes(false),
 _concurrent_cycles_since_last_unload(0),
 _roots_scanning_options(0),
-_sweep_estimate(CMS_SweepWeight, CMS_SweepPadding)
+_inter_sweep_estimate(CMS_SweepWeight, CMS_SweepPadding),
+_intra_sweep_estimate(CMS_SweepWeight, CMS_SweepPadding)
 {
 if (ExplicitGCInvokesConcurrentAndUnloadsClasses) {
 ExplicitGCInvokesConcurrent = true;
 }
 // Now expand the span and allocate the collection support structures
 }
 NOT_PRODUCT(_overflow_counter = CMSMarkStackOverflowInterval;)
 _gc_counters = new CollectorCounters("CMS", 1);
 _completed_initialization = true;
-_sweep_timer.start();  // start of time
+_inter_sweep_timer.start();  // start of time
 }
 const char* ConcurrentMarkSweepGeneration::name() const {
 return "concurrent mark-sweep generation";
 }
 " adj_max_promo_bytes: " SIZE_FORMAT,
 max_contiguous_available(), (size_t)adjusted_max_promo_bytes);
 }
 }
 return result;
+}
+// At a promotion failure dump information on block layout in heap
+// (cms old generation).
+void ConcurrentMarkSweepGeneration::promotion_failure_occurred() {
+if (CMSDumpAtPromotionFailure) {
+cmsSpace()->dump_at_safepoint_with_locks(collector(), gclog_or_tty);
+}
 }
 CompactibleSpace*
 ConcurrentMarkSweepGeneration::first_compaction_space() const {
 return _cmsSpace;
 void
 ConcurrentMarkSweepGeneration::
 par_promote_alloc_done(int thread_num) {
 CMSParGCThreadState* ps = _par_gc_thread_states[thread_num];
-ps->lab.retire();
+ps->lab.retire(thread_num);
-#if CFLS_LAB_REFILL_STATS
-if (thread_num == 0) {
-_cmsSpace->print_par_alloc_stats();
-}
-#endif
 }
 void
 ConcurrentMarkSweepGeneration::
 par_oop_since_save_marks_iterate_done(int thread_num) {
 _modUnionTable.clear_all();
 // We must adjust the allocation statistics being maintained
 // in the free list space. We do so by reading and clearing
 // the sweep timer and updating the block flux rate estimates below.
-assert(_sweep_timer.is_active(), "We should never see the timer inactive");
+assert(!_intra_sweep_timer.is_active(), "_intra_sweep_timer should be inactive");
-_sweep_timer.stop();
+if (_inter_sweep_timer.is_active()) {
-// Note that we do not use this sample to update the _sweep_estimate.
+_inter_sweep_timer.stop();
-_cmsGen->cmsSpace()->beginSweepFLCensus((float)(_sweep_timer.seconds()),
+// Note that we do not use this sample to update the _inter_sweep_estimate.
-_sweep_estimate.padded_average());
+_cmsGen->cmsSpace()->beginSweepFLCensus((float)(_inter_sweep_timer.seconds()),
+_inter_sweep_estimate.padded_average(),
+_intra_sweep_estimate.padded_average());
+}
 GenMarkSweep::invoke_at_safepoint(_cmsGen->level(),
 ref_processor(), clear_all_soft_refs);
 #ifdef ASSERT
 CompactibleFreeListSpace* cms_space = _cmsGen->cmsSpace();
 if (_survivor_plab_array != NULL) {
 reset_survivor_plab_arrays();
 }
 // Adjust the per-size allocation stats for the next epoch.
-_cmsGen->cmsSpace()->endSweepFLCensus(sweepCount() /* fake */);
+_cmsGen->cmsSpace()->endSweepFLCensus(sweep_count() /* fake */);
-// Restart the "sweep timer" for next epoch.
+// Restart the "inter sweep timer" for the next epoch.
-_sweep_timer.reset();
+_inter_sweep_timer.reset();
-_sweep_timer.start();
+_inter_sweep_timer.start();
 // Sample collection pause time and reset for collection interval.
 if (UseAdaptiveSizePolicy) {
 size_policy()->msc_collection_end(gch->gc_cause());
 }
 collector()->gc_epilogue(full);
 // Also reset promotion tracking in par gc thread states.
 if (ParallelGCThreads > 0) {
 for (uint i = 0; i < ParallelGCThreads; i++) {
-_par_gc_thread_states[i]->promo.stopTrackingPromotions();
+_par_gc_thread_states[i]->promo.stopTrackingPromotions(i);
 }
 }
 }
 void ConcurrentMarkSweepGeneration::gc_epilogue_work(bool full) {
 VerifyMarkedClosure(CMSBitMap* bm): _marks(bm), _failed(false) {}
 bool do_bit(size_t offset) {
 HeapWord* addr = _marks->offsetToHeapWord(offset);
 if (!_marks->isMarked(addr)) {
-oop(addr)->print();
+oop(addr)->print_on(gclog_or_tty);
 gclog_or_tty->print_cr(" ("INTPTR_FORMAT" should have been marked)", addr);
 _failed = true;
 }
 return true;
 }
 COMPILER2_PRESENT(DerivedPointerTableDeactivate dpt_deact;)
 // Clear any marks from a previous round
 verification_mark_bm()->clear_all();
 assert(verification_mark_stack()->isEmpty(), "markStack should be empty");
-assert(overflow_list_is_empty(), "overflow list should be empty");
+verify_work_stacks_empty();
 GenCollectedHeap* gch = GenCollectedHeap::heap();
 gch->ensure_parsability(false);  // fill TLABs, but no need to retire them
 // Update the saved marks which may affect the root scans.
 gch->save_marks();
 // errors by printing corresponding objects.
 VerifyMarkedClosure vcl(markBitMap());
 verification_mark_bm()->iterate(&vcl);
 if (vcl.failed()) {
 gclog_or_tty->print("Verification failed");
-Universe::heap()->print();
+Universe::heap()->print_on(gclog_or_tty);
-fatal(" ... aborting");
+fatal("CMS: failed marking verification after remark");
 }
 }
 void CMSCollector::verify_after_remark_work_2() {
 ResourceMark rm;
 MemRegion mr(_cmsSpace->bottom(), new_word_size);
 _bts->resize(new_word_size);  // resize the block offset shared array
 Universe::heap()->barrier_set()->resize_covered_region(mr);
 // Hmmmm... why doesn't CFLS::set_end verify locking?
 // This is quite ugly; FIX ME XXX
-_cmsSpace->assert_locked();
+_cmsSpace->assert_locked(freelistLock());
 _cmsSpace->set_end((HeapWord*)_virtual_space.high());
 // update the space and generation capacity counters
 if (UsePerfData) {
 _space_counters->update_capacity();
 void CMSCollector::sweep(bool asynch) {
 assert(_collectorState == Sweeping, "just checking");
 check_correct_thread_executing();
 verify_work_stacks_empty();
 verify_overflow_empty();
-incrementSweepCount();
+increment_sweep_count();
-_sweep_timer.stop();
+_inter_sweep_timer.stop();
-_sweep_estimate.sample(_sweep_timer.seconds());
+_inter_sweep_estimate.sample(_inter_sweep_timer.seconds());
 size_policy()->avg_cms_free_at_sweep()->sample(_cmsGen->free());
 // PermGen verification support: If perm gen sweeping is disabled in
 // this cycle, we preserve the perm gen object "deadness" information
 // in the perm_gen_verify_bit_map. In order to do that we traverse
 // the requisite locks/tokens.
 _permGen->cmsSpace()->blk_iterate(&mdo);
 }
 }
+assert(!_intra_sweep_timer.is_active(), "Should not be active");
+_intra_sweep_timer.reset();
+_intra_sweep_timer.start();
 if (asynch) {
 TraceCPUTime tcpu(PrintGCDetails, true, gclog_or_tty);
 CMSPhaseAccounting pa(this, "sweep", !PrintGCDetails);
 // First sweep the old gen then the perm gen
 {
 _collectorState = Resizing;
 }
 verify_work_stacks_empty();
 verify_overflow_empty();
-_sweep_timer.reset();
+_intra_sweep_timer.stop();
-_sweep_timer.start();
+_intra_sweep_estimate.sample(_intra_sweep_timer.seconds());
+_inter_sweep_timer.reset();
+_inter_sweep_timer.start();
 update_time_of_last_gc(os::javaTimeMillis());
 // NOTE on abstract state transitions:
 // Mutators allocate-live and/or mark the mod-union table dirty
 }
 // FIX ME!!! Looks like this belongs in CFLSpace, with
 // CMSGen merely delegating to it.
 void ConcurrentMarkSweepGeneration::setNearLargestChunk() {
-double nearLargestPercent = 0.999;
+double nearLargestPercent = FLSLargestBlockCoalesceProximity;
 HeapWord*  minAddr        = _cmsSpace->bottom();
 HeapWord*  largestAddr    =
 (HeapWord*) _cmsSpace->dictionary()->findLargestDict();
-if (largestAddr == 0) {
+if (largestAddr == NULL) {
 // The dictionary appears to be empty.  In this case
 // try to coalesce at the end of the heap.
 largestAddr = _cmsSpace->end();
 }
 size_t largestOffset     = pointer_delta(largestAddr, minAddr);
 size_t nearLargestOffset =
 (size_t)((double)largestOffset * nearLargestPercent) - MinChunkSize;
+if (PrintFLSStatistics != 0) {
+gclog_or_tty->print_cr(
+"CMS: Large Block: " PTR_FORMAT ";"
+" Proximity: " PTR_FORMAT " -> " PTR_FORMAT,
+largestAddr,
+_cmsSpace->nearLargestChunk(), minAddr + nearLargestOffset);
+}
 _cmsSpace->set_nearLargestChunk(minAddr + nearLargestOffset);
 }
 bool ConcurrentMarkSweepGeneration::isNearLargestChunk(HeapWord* addr) {
 return addr >= _cmsSpace->nearLargestChunk();
 || (!asynch && ConcurrentMarkSweepThread::vm_thread_has_cms_token()),
 "Should possess CMS token to sweep");
 assert_lock_strong(gen->freelistLock());
 assert_lock_strong(bitMapLock());
-assert(!_sweep_timer.is_active(), "Was switched off in an outer context");
+assert(!_inter_sweep_timer.is_active(), "Was switched off in an outer context");
-gen->cmsSpace()->beginSweepFLCensus((float)(_sweep_timer.seconds()),
+assert(_intra_sweep_timer.is_active(),  "Was switched on  in an outer context");
-_sweep_estimate.padded_average());
+gen->cmsSpace()->beginSweepFLCensus((float)(_inter_sweep_timer.seconds()),
+_inter_sweep_estimate.padded_average(),
+_intra_sweep_estimate.padded_average());
 gen->setNearLargestChunk();
 {
 SweepClosure sweepClosure(this, gen, &_markBitMap,
 CMSYield && asynch);
 // 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();
-gen->cmsSpace()->endSweepFLCensus(sweepCount());
+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
 }

Mercurial > hg > graal-jvmci-8

comparison src/share/vm/gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.cpp @ 1145:e018e6884bd8