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

-: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 > jdk8-mips64-public > hotspot / file comparison

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

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