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

-:9a7135d0a309
+:7386b3a385ac
 }
 size_t
 ConcurrentMarkSweepGeneration::unsafe_max_alloc_nogc() const {
 return _cmsSpace->max_alloc_in_words() * HeapWordSize;
+}
+size_t ConcurrentMarkSweepGeneration::used_stable() const {
+return cmsSpace()->used_stable();
 }
 size_t ConcurrentMarkSweepGeneration::max_available() const {
 return free() + _virtual_space.uncommitted_size();
 }
 void CMSCollector::compute_new_size() {
 assert_locked_or_safepoint(Heap_lock);
 FreelistLocker z(this);
 MetaspaceGC::compute_new_size();
 _cmsGen->compute_new_size_free_list();
+// recalculate CMS used space after CMS collection
+_cmsGen->cmsSpace()->recalculate_used_stable();
 }
 // A work method used by foreground collection to determine
 // what type of collection (compacting or not, continuing or fresh)
 // it should do.
 void ConcurrentMarkSweepGeneration::gc_prologue(bool full) {
 _capacity_at_prologue = capacity();
 _used_at_prologue = used();
+_cmsSpace->recalculate_used_stable();
 // Delegate to CMScollector which knows how to coordinate between
 // this and any other CMS generations that it is responsible for
 // collecting.
 collector()->gc_prologue(full);
 }
 // reset _eden_chunk_array so sampling starts afresh
 _eden_chunk_index = 0;
 size_t cms_used   = _cmsGen->cmsSpace()->used();
+_cmsGen->cmsSpace()->recalculate_used_stable();
 // update performance counters - this uses a special version of
 // update_counters() that allows the utilization to be passed as a
 // parameter, avoiding multiple calls to used().
 //
 // now enable ("weak") refs discovery
 rp->enable_discovery(true /*verify_disabled*/, false /*verify_no_refs*/);
 _collectorState = Marking;
 }
 SpecializationStats::print();
+_cmsGen->cmsSpace()->recalculate_used_stable();
 }
 void CMSCollector::checkpointRootsInitialWork(bool asynch) {
 assert(SafepointSynchronize::is_at_safepoint(), "world should be stopped");
 assert(_collectorState == InitialMarking, "just checking");
 FreelistLocker x(this);
 MutexLockerEx y(bitMapLock(),
 Mutex::_no_safepoint_check_flag);
 assert(!init_mark_was_synchronous, "but that's impossible!");
 checkpointRootsFinalWork(asynch, clear_all_soft_refs, false);
+_cmsGen->cmsSpace()->recalculate_used_stable();
 } else {
 // already have all the locks
 checkpointRootsFinalWork(asynch, clear_all_soft_refs,
 init_mark_was_synchronous);
+_cmsGen->cmsSpace()->recalculate_used_stable();
 }
 verify_work_stacks_empty();
 verify_overflow_empty();
 SpecializationStats::print();
 }
 {
 CMSTokenSyncWithLocks ts(true, _cmsGen->freelistLock());
 // Update heap occupancy information which is used as
 // input to soft ref clearing policy at the next gc.
 Universe::update_heap_info_at_gc();
+// recalculate CMS used space after CMS collection
+_cmsGen->cmsSpace()->recalculate_used_stable();
 _collectorState = Resizing;
 }
 } else {
 // already have needed locks
 sweepWork(_cmsGen,  asynch);
 // that are of interest at this point.
 if (!full && (current_level + 1) == level()) {
 // Gather statistics on the young generation collection.
 collector()->stats().record_gc0_end(used());
 }
+_cmsSpace->recalculate_used_stable();
 }
 CMSAdaptiveSizePolicy* ConcurrentMarkSweepGeneration::size_policy() {
 GenCollectedHeap* gch = GenCollectedHeap::heap();
 assert(gch->kind() == CollectedHeap::GenCollectedHeap,

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

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

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