jdk-sandbox: comparison hotspot/src/share/vm/gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.cpp

equal deleted inserted replaced

-:a5d8d1764e94
+:3aaaaad1ccb0
 {
 ReleaseForegroundGC x(this);
 VM_CMS_Final_Remark final_remark_op(this);
 VMThread::execute(&final_remark_op);
 }
 assert(_foregroundGCShouldWait, "block post-condition");
 break;
 case Sweeping:
 if (UseAdaptiveSizePolicy) {
 size_policy()->concurrent_sweeping_begin();
 // weak reference processing has not started yet.
 ref_processor()->set_enqueuing_is_done(false);
 {
+// This is not needed. DEBUG_ONLY(RememberKlassesChecker imx(true);)
 COMPILER2_PRESENT(DerivedPointerTableDeactivate dpt_deact;)
 gch->rem_set()->prepare_for_younger_refs_iterate(false); // Not parallel.
 gch->gen_process_strong_roots(_cmsGen->level(),
 true,   // younger gens are roots
 true,   // activate StrongRootsScope
 // obsolete contents from a short-circuited previous CMS cycle.
 _revisitStack.reset();
 verify_work_stacks_empty();
 verify_overflow_empty();
 assert(_revisitStack.isEmpty(), "tabula rasa");
+DEBUG_ONLY(RememberKlassesChecker cmx(CMSClassUnloadingEnabled);)
 bool result = false;
 if (CMSConcurrentMTEnabled && ParallelCMSThreads > 0) {
 result = do_marking_mt(asynch);
 } else {
 // have been bumped up by the thread that claimed the last
 // task.
 pst->all_tasks_completed();
 }
-class Par_ConcMarkingClosure: public OopClosure {
+class Par_ConcMarkingClosure: public Par_KlassRememberingOopClosure {
 private:
-CMSCollector* _collector;
 MemRegion     _span;
 CMSBitMap*    _bit_map;
 CMSMarkStack* _overflow_stack;
-CMSMarkStack* _revisit_stack;     // XXXXXX Check proper use
 OopTaskQueue* _work_queue;
 protected:
 DO_OOP_WORK_DEFN
 public:
 Par_ConcMarkingClosure(CMSCollector* collector, OopTaskQueue* work_queue,
-CMSBitMap* bit_map, CMSMarkStack* overflow_stack):
+CMSBitMap* bit_map, CMSMarkStack* overflow_stack,
-_collector(collector),
+CMSMarkStack* revisit_stack):
+Par_KlassRememberingOopClosure(collector, NULL, revisit_stack),
 _span(_collector->_span),
 _work_queue(work_queue),
 _bit_map(bit_map),
-_overflow_stack(overflow_stack) { }   // need to initialize revisit stack etc.
+_overflow_stack(overflow_stack)
+{ }
 virtual void do_oop(oop* p);
 virtual void do_oop(narrowOop* p);
 void trim_queue(size_t max);
 void handle_stack_overflow(HeapWord* lost);
 };
 void CMSConcMarkingTask::do_work_steal(int i) {
 OopTaskQueue* work_q = work_queue(i);
 oop obj_to_scan;
 CMSBitMap* bm = &(_collector->_markBitMap);
 CMSMarkStack* ovflw = &(_collector->_markStack);
+CMSMarkStack* revisit = &(_collector->_revisitStack);
 int* seed = _collector->hash_seed(i);
-Par_ConcMarkingClosure cl(_collector, work_q, bm, ovflw);
+Par_ConcMarkingClosure cl(_collector, work_q, bm, ovflw, revisit);
 while (true) {
 cl.trim_queue(0);
 assert(work_q->size() == 0, "Should have been emptied above");
 if (get_work_from_overflow_stack(ovflw, work_q)) {
 // Can't assert below because the work obtained from the
 // This is run by the CMS (coordinator) thread.
 void CMSConcMarkingTask::coordinator_yield() {
 assert(ConcurrentMarkSweepThread::cms_thread_has_cms_token(),
 "CMS thread should hold CMS token");
+DEBUG_ONLY(RememberKlassesChecker mux(false);)
 // First give up the locks, then yield, then re-lock
 // We should probably use a constructor/destructor idiom to
 // do this unlock/lock or modify the MutexUnlocker class to
 // serve our purpose. XXX
 assert_lock_strong(_bit_map_lock);
 // Refs discovery is already non-atomic.
 assert(!ref_processor()->discovery_is_atomic(), "Should be non-atomic");
 // Mutate the Refs discovery so it is MT during the
 // multi-threaded marking phase.
 ReferenceProcessorMTMutator mt(ref_processor(), num_workers > 1);
+DEBUG_ONLY(RememberKlassesChecker cmx(CMSClassUnloadingEnabled);)
 conc_workers()->start_task(&tsk);
 while (tsk.yielded()) {
 tsk.coordinator_yield();
 conc_workers()->continue_task(&tsk);
 if (clean_refs) {
 ReferenceProcessor* rp = ref_processor();
 CMSPrecleanRefsYieldClosure yield_cl(this);
 assert(rp->span().equals(_span), "Spans should be equal");
 CMSKeepAliveClosure keep_alive(this, _span, &_markBitMap,
-&_markStack, true /* preclean */);
+&_markStack, &_revisitStack,
+true /* preclean */);
 CMSDrainMarkingStackClosure complete_trace(this,
 _span, &_markBitMap, &_markStack,
 &keep_alive, true /* preclean */);
 // We don't want this step to interfere with a young
 stopTimer();
 CMSTokenSyncWithLocks x(true /* is cms thread */,
 bitMapLock());
 startTimer();
 sample_eden();
 // The following will yield to allow foreground
 // collection to proceed promptly. XXX YSR:
 // The code in this method may need further
 // tweaking for better performance and some restructuring
 // for cleaner interfaces.
 unsigned int before_count =
 GenCollectedHeap::heap()->total_collections();
 SurvivorSpacePrecleanClosure
 sss_cl(this, _span, &_markBitMap, &_markStack,
 &pam_cl, before_count, CMSYield);
+DEBUG_ONLY(RememberKlassesChecker mx(CMSClassUnloadingEnabled);)
 dng->from()->object_iterate_careful(&sss_cl);
 dng->to()->object_iterate_careful(&sss_cl);
 }
 MarkRefsIntoAndScanClosure
 mrias_cl(_span, ref_processor(), &_markBitMap, &_modUnionTable,
 ConcurrentMarkSweepGeneration* gen,
 ScanMarkedObjectsAgainCarefullyClosure* cl) {
 verify_work_stacks_empty();
 verify_overflow_empty();
+// Turn off checking for this method but turn it back on
+// selectively.  There are yield points in this method
+// but it is difficult to turn the checking off just around
+// the yield points.  It is simpler to selectively turn
+// it on.
+DEBUG_ONLY(RememberKlassesChecker mux(false);)
 // strategy: starting with the first card, accumulate contiguous
 // ranges of dirty cards; clear these cards, then scan the region
 // covered by these cards.
 // Since all of the MUT is committed ahead, we can just use
 HandleMark   hm;
 MemRegion dirtyRegion;
 {
 stopTimer();
+// Potential yield point
 CMSTokenSync ts(true);
 startTimer();
 sample_eden();
 // Get dirty region starting at nextOffset (inclusive),
 // simultaneously clearing it.
 // yields for foreground GC as needed).
 if (!dirtyRegion.is_empty()) {
 assert(numDirtyCards > 0, "consistency check");
 HeapWord* stop_point = NULL;
 stopTimer();
+// Potential yield point
 CMSTokenSyncWithLocks ts(true, gen->freelistLock(),
 bitMapLock());
 startTimer();
 {
 verify_work_stacks_empty();
 verify_overflow_empty();
 sample_eden();
+DEBUG_ONLY(RememberKlassesChecker mx(CMSClassUnloadingEnabled);)
 stop_point =
 gen->cmsSpace()->object_iterate_careful_m(dirtyRegion, cl);
 }
 if (stop_point != NULL) {
 // The careful iteration stopped early either because it found an
 CMSTokenSyncWithLocks ts(true, gen->freelistLock(), bitMapLock());
 startTimer();
 sample_eden();
 verify_work_stacks_empty();
 verify_overflow_empty();
+DEBUG_ONLY(RememberKlassesChecker mx(CMSClassUnloadingEnabled);)
 HeapWord* stop_point =
 gen->cmsSpace()->object_iterate_careful_m(dirtyRegion, cl);
 if (stop_point != NULL) {
 // The careful iteration stopped early because it found an
 // uninitialized object.  Redirty the bits corresponding to the
 CodeCache::gc_prologue();
 }
 assert(haveFreelistLocks(), "must have free list locks");
 assert_lock_strong(bitMapLock());
+DEBUG_ONLY(RememberKlassesChecker fmx(CMSClassUnloadingEnabled);)
 if (!init_mark_was_synchronous) {
 // We might assume that we need not fill TLAB's when
 // CMSScavengeBeforeRemark is set, because we may have just done
 // a scavenge which would have filled all TLAB's -- and besides
 // Eden would be empty. This however may not always be the case --
 _markStack.capacity());
 }
 }
 _markStack._hit_limit = 0;
 _markStack._failed_double = 0;
+// Check that all the klasses have been checked
+assert(_revisitStack.isEmpty(), "Not all klasses revisited");
 if ((VerifyAfterGC || VerifyDuringGC) &&
 GenCollectedHeap::heap()->total_collections() >= VerifyGCStartAt) {
 verify_after_remark();
 }
 };
 void CMSRefProcTaskProxy::work(int i) {
 assert(_collector->_span.equals(_span), "Inconsistency in _span");
 CMSParKeepAliveClosure par_keep_alive(_collector, _span,
-_mark_bit_map, work_queue(i));
+_mark_bit_map,
+&_collector->_revisitStack,
+work_queue(i));
 CMSParDrainMarkingStackClosure par_drain_stack(_collector, _span,
-_mark_bit_map, work_queue(i));
+_mark_bit_map,
+&_collector->_revisitStack,
+work_queue(i));
 CMSIsAliveClosure is_alive_closure(_span, _mark_bit_map);
 _task.work(i, is_alive_closure, par_keep_alive, par_drain_stack);
 if (_task.marks_oops_alive()) {
 do_work_steal(i, &par_drain_stack, &par_keep_alive,
 _collector->hash_seed(i));
 _task.work(i);
 }
 };
 CMSParKeepAliveClosure::CMSParKeepAliveClosure(CMSCollector* collector,
-MemRegion span, CMSBitMap* bit_map, OopTaskQueue* work_queue):
+MemRegion span, CMSBitMap* bit_map, CMSMarkStack* revisit_stack,
-_collector(collector),
+OopTaskQueue* work_queue):
+Par_KlassRememberingOopClosure(collector, NULL, revisit_stack),
 _span(span),
 _bit_map(bit_map),
 _work_queue(work_queue),
-_mark_and_push(collector, span, bit_map, work_queue),
+_mark_and_push(collector, span, bit_map, revisit_stack, work_queue),
 _low_water_mark(MIN2((uint)(work_queue->max_elems()/4),
 (uint)(CMSWorkQueueDrainThreshold * ParallelGCThreads)))
 { }
 // . see if we can share work_queues with ParNew? XXX
 // Process weak references.
 rp->setup_policy(clear_all_soft_refs);
 verify_work_stacks_empty();
 CMSKeepAliveClosure cmsKeepAliveClosure(this, _span, &_markBitMap,
-&_markStack, false /* !preclean */);
+&_markStack, &_revisitStack,
+false /* !preclean */);
 CMSDrainMarkingStackClosure cmsDrainMarkingStackClosure(this,
 _span, &_markBitMap, &_markStack,
 &cmsKeepAliveClosure, false /* !preclean */);
 {
 TraceTime t("weak refs processing", PrintGCDetails, false, gclog_or_tty);
 assert(ConcurrentMarkSweepThread::cms_thread_has_cms_token(),
 "CMS thread should hold CMS token");
 assert_lock_strong(_freelistLock);
 assert_lock_strong(_bit_map->lock());
 // relinquish the free_list_lock and bitMaplock()
+DEBUG_ONLY(RememberKlassesChecker mux(false);)
 _bit_map->lock()->unlock();
 _freelistLock->unlock();
 ConcurrentMarkSweepThread::desynchronize(true);
 ConcurrentMarkSweepThread::acknowledge_yield_request();
 _collector->stopTimer();
 void ScanMarkedObjectsAgainCarefullyClosure::do_yield_work() {
 assert(ConcurrentMarkSweepThread::cms_thread_has_cms_token(),
 "CMS thread should hold CMS token");
 assert_lock_strong(_freelistLock);
 assert_lock_strong(_bitMap->lock());
+DEBUG_ONLY(RememberKlassesChecker mux(false);)
 // relinquish the free_list_lock and bitMaplock()
 _bitMap->lock()->unlock();
 _freelistLock->unlock();
 ConcurrentMarkSweepThread::desynchronize(true);
 ConcurrentMarkSweepThread::acknowledge_yield_request();
 void SurvivorSpacePrecleanClosure::do_yield_work() {
 assert(ConcurrentMarkSweepThread::cms_thread_has_cms_token(),
 "CMS thread should hold CMS token");
 assert_lock_strong(_bit_map->lock());
+DEBUG_ONLY(RememberKlassesChecker smx(false);)
 // Relinquish the bit map lock
 _bit_map->lock()->unlock();
 ConcurrentMarkSweepThread::desynchronize(true);
 ConcurrentMarkSweepThread::acknowledge_yield_request();
 _collector->stopTimer();
 // do this unlock/lock or modify the MutexUnlocker class to
 // serve our purpose. XXX
 assert(ConcurrentMarkSweepThread::cms_thread_has_cms_token(),
 "CMS thread should hold CMS token");
 assert_lock_strong(_bitMap->lock());
+DEBUG_ONLY(RememberKlassesChecker mux(false);)
 _bitMap->lock()->unlock();
 ConcurrentMarkSweepThread::desynchronize(true);
 ConcurrentMarkSweepThread::acknowledge_yield_request();
 _collector->stopTimer();
 GCPauseTimer p(_collector->size_policy()->concurrent_timer_ptr());
 PushOrMarkClosure::PushOrMarkClosure(CMSCollector* collector,
 MemRegion span,
 CMSBitMap* bitMap, CMSMarkStack*  markStack,
 CMSMarkStack*  revisitStack,
 HeapWord* finger, MarkFromRootsClosure* parent) :
-OopClosure(collector->ref_processor()),
+KlassRememberingOopClosure(collector, collector->ref_processor(), revisitStack),
-_collector(collector),
 _span(span),
 _bitMap(bitMap),
 _markStack(markStack),
-_revisitStack(revisitStack),
 _finger(finger),
-_parent(parent),
+_parent(parent)
-_should_remember_klasses(collector->should_unload_classes())
 { }
 Par_PushOrMarkClosure::Par_PushOrMarkClosure(CMSCollector* collector,
 MemRegion span,
 CMSBitMap* bit_map,
 CMSMarkStack*  overflow_stack,
 CMSMarkStack*  revisit_stack,
 HeapWord* finger,
 HeapWord** global_finger_addr,
 Par_MarkFromRootsClosure* parent) :
-OopClosure(collector->ref_processor()),
+Par_KlassRememberingOopClosure(collector,
-_collector(collector),
+collector->ref_processor(),
+revisit_stack),
 _whole_span(collector->_span),
 _span(span),
 _bit_map(bit_map),
 _work_queue(work_queue),
 _overflow_stack(overflow_stack),
-_revisit_stack(revisit_stack),
 _finger(finger),
 _global_finger_addr(global_finger_addr),
-_parent(parent),
+_parent(parent)
-_should_remember_klasses(collector->should_unload_classes())
 { }
 // Assumes thread-safe access by callers, who are
 // responsible for mutual exclusion.
 void CMSCollector::lower_restart_addr(HeapWord* low) {
 }
 void Par_PushOrMarkClosure::do_oop(oop* p)       { Par_PushOrMarkClosure::do_oop_work(p); }
 void Par_PushOrMarkClosure::do_oop(narrowOop* p) { Par_PushOrMarkClosure::do_oop_work(p); }
+KlassRememberingOopClosure::KlassRememberingOopClosure(CMSCollector* collector,
+ReferenceProcessor* rp,
+CMSMarkStack* revisit_stack) :
+OopClosure(rp),
+_collector(collector),
+_revisit_stack(revisit_stack),
+_should_remember_klasses(collector->should_unload_classes()) {}
 PushAndMarkClosure::PushAndMarkClosure(CMSCollector* collector,
 MemRegion span,
 ReferenceProcessor* rp,
 CMSBitMap* bit_map,
 CMSBitMap* mod_union_table,
 CMSMarkStack*  mark_stack,
 CMSMarkStack*  revisit_stack,
 bool           concurrent_precleaning):
-OopClosure(rp),
+KlassRememberingOopClosure(collector, rp, revisit_stack),
-_collector(collector),
 _span(span),
 _bit_map(bit_map),
 _mod_union_table(mod_union_table),
 _mark_stack(mark_stack),
-_revisit_stack(revisit_stack),
+_concurrent_precleaning(concurrent_precleaning)
-_concurrent_precleaning(concurrent_precleaning),
-_should_remember_klasses(collector->should_unload_classes())
 {
 assert(_ref_processor != NULL, "_ref_processor shouldn't be NULL");
 }
 // Grey object rescan during pre-cleaning and second checkpoint phases --
 MemRegion span,
 ReferenceProcessor* rp,
 CMSBitMap* bit_map,
 OopTaskQueue* work_queue,
 CMSMarkStack* revisit_stack):
-OopClosure(rp),
+Par_KlassRememberingOopClosure(collector, rp, revisit_stack),
-_collector(collector),
 _span(span),
 _bit_map(bit_map),
-_work_queue(work_queue),
+_work_queue(work_queue)
-_revisit_stack(revisit_stack),
-_should_remember_klasses(collector->should_unload_classes())
 {
 assert(_ref_processor != NULL, "_ref_processor shouldn't be NULL");
 }
 void PushAndMarkClosure::do_oop(oop* p)       { PushAndMarkClosure::do_oop_work(p); }
 }
 void Par_PushAndMarkClosure::do_oop(oop* p)       { Par_PushAndMarkClosure::do_oop_work(p); }
 void Par_PushAndMarkClosure::do_oop(narrowOop* p) { Par_PushAndMarkClosure::do_oop_work(p); }
-void PushAndMarkClosure::remember_klass(Klass* k) {
+void PushAndMarkClosure::remember_mdo(DataLayout* v) {
-if (!_revisit_stack->push(oop(k))) {
+// TBD
-fatal("Revisit stack overflowed in PushAndMarkClosure");
+}
-}
-}
+void Par_PushAndMarkClosure::remember_mdo(DataLayout* v) {
+// TBD
-void Par_PushAndMarkClosure::remember_klass(Klass* k) {
-if (!_revisit_stack->par_push(oop(k))) {
-fatal("Revist stack overflowed in Par_PushAndMarkClosure");
-}
 }
 void CMSPrecleanRefsYieldClosure::do_yield_work() {
+DEBUG_ONLY(RememberKlassesChecker mux(false);)
 Mutex* bml = _collector->bitMapLock();
 assert_lock_strong(bml);
 assert(ConcurrentMarkSweepThread::cms_thread_has_cms_token(),
 "CMS thread should hold CMS token");
 HeapWord* addr = (HeapWord*)obj;
 return addr != NULL &&
 (!_span.contains(addr) || _bit_map->isMarked(addr));
 }
+CMSKeepAliveClosure::CMSKeepAliveClosure( CMSCollector* collector,
+MemRegion span,
+CMSBitMap* bit_map, CMSMarkStack* mark_stack,
+CMSMarkStack* revisit_stack, bool cpc):
+KlassRememberingOopClosure(collector, NULL, revisit_stack),
+_span(span),
+_bit_map(bit_map),
+_mark_stack(mark_stack),
+_concurrent_precleaning(cpc) {
+assert(!_span.is_empty(), "Empty span could spell trouble");
+}
 // CMSKeepAliveClosure: the serial version
 void CMSKeepAliveClosure::do_oop(oop obj) {
 HeapWord* addr = (HeapWord*)obj;
 if (_span.contains(addr) &&
 !_bit_map->isMarked(addr)) {
 new_oop->oop_iterate(&_mark_and_push);
 }
 }
 }
+CMSInnerParMarkAndPushClosure::CMSInnerParMarkAndPushClosure(
+CMSCollector* collector,
+MemRegion span, CMSBitMap* bit_map,
+CMSMarkStack* revisit_stack,
+OopTaskQueue* work_queue):
+Par_KlassRememberingOopClosure(collector, NULL, revisit_stack),
+_span(span),
+_bit_map(bit_map),
+_work_queue(work_queue) { }
 void CMSInnerParMarkAndPushClosure::do_oop(oop obj) {
 HeapWord* addr = (HeapWord*)obj;
 if (_span.contains(addr) &&
 !_bit_map->isMarked(addr)) {
 if (_bit_map->par_mark(addr)) {

changeset 3912	3aaaaad1ccb0
parent 3908	24b55ad4c228
parent 3696	9e5d9b5e1049
child 3913	e049e6b81e11