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

equal deleted inserted replaced

-:d9132bdf6c30
+:9d62da00bf15
 bool ConcurrentMarkSweepGeneration::no_allocs_since_save_marks() {
 return cmsSpace()->no_allocs_since_save_marks();
 }
 void
-ConcurrentMarkSweepGeneration::oop_iterate(ExtendedOopClosure* cl) {
+ConcurrentMarkSweepGeneration::oop_iterate(OopIterateClosure* cl) {
 if (freelistLock()->owned_by_self()) {
 Generation::oop_iterate(cl);
 } else {
 MutexLockerEx x(freelistLock(), Mutex::_no_safepoint_check_flag);
 Generation::oop_iterate(cl);
 // have been bumped up by the thread that claimed the last
 // task.
 pst->all_tasks_completed();
 }
-class ParConcMarkingClosure: public MetadataAwareOopClosure {
+class ParConcMarkingClosure: public MetadataVisitingOopIterateClosure {
 private:
 CMSCollector* _collector;
 CMSConcMarkingTask* _task;
 MemRegion     _span;
 CMSBitMap*    _bit_map;
 protected:
 DO_OOP_WORK_DEFN
 public:
 ParConcMarkingClosure(CMSCollector* collector, CMSConcMarkingTask* task, OopTaskQueue* work_queue,
 CMSBitMap* bit_map, CMSMarkStack* overflow_stack):
-MetadataAwareOopClosure(collector->ref_processor()),
+MetadataVisitingOopIterateClosure(collector->ref_processor()),
 _collector(collector),
 _task(task),
 _span(collector->_span),
 _work_queue(work_queue),
 _bit_map(bit_map),
 }
 } // Else, some other thread got there first
 do_yield_check();
 }
 }
-void ParConcMarkingClosure::do_oop(oop* p)       { ParConcMarkingClosure::do_oop_work(p); }
-void ParConcMarkingClosure::do_oop(narrowOop* p) { ParConcMarkingClosure::do_oop_work(p); }
 void ParConcMarkingClosure::trim_queue(size_t max) {
 while (_work_queue->size() > max) {
 oop new_oop;
 if (_work_queue->pop_local(new_oop)) {
 verify_overflow_empty();
 return cumNumDirtyCards;
 }
 class PrecleanCLDClosure : public CLDClosure {
-MetadataAwareOopsInGenClosure* _cm_closure;
+MetadataVisitingOopsInGenClosure* _cm_closure;
 public:
-PrecleanCLDClosure(MetadataAwareOopsInGenClosure* oop_closure) : _cm_closure(oop_closure) {}
+PrecleanCLDClosure(MetadataVisitingOopsInGenClosure* oop_closure) : _cm_closure(oop_closure) {}
 void do_cld(ClassLoaderData* cld) {
 if (cld->has_accumulated_modified_oops()) {
 cld->clear_accumulated_modified_oops();
 _cm_closure->do_cld(cld);
 // Scan all new class loader data objects and new dependencies that were
 // introduced during concurrent marking.
 ResourceMark rm;
 GrowableArray<ClassLoaderData*>* array = ClassLoaderDataGraph::new_clds();
 for (int i = 0; i < array->length(); i++) {
-par_mrias_cl.do_cld_nv(array->at(i));
+Devirtualizer::do_cld(&par_mrias_cl, array->at(i));
 }
 // We don't need to keep track of new CLDs anymore.
 ClassLoaderDataGraph::remember_new_clds(false);
 // Scan all class loader data objects that might have been introduced
 // during concurrent marking.
 ResourceMark rm;
 GrowableArray<ClassLoaderData*>* array = ClassLoaderDataGraph::new_clds();
 for (int i = 0; i < array->length(); i++) {
-mrias_cl.do_cld_nv(array->at(i));
+Devirtualizer::do_cld(&mrias_cl, array->at(i));
 }
 // We don't need to keep track of new CLDs anymore.
 ClassLoaderDataGraph::remember_new_clds(false);
 // this should be made more efficient
 _bitMap->mark(addr);
 }
 }
-void MarkRefsIntoClosure::do_oop(oop* p)       { MarkRefsIntoClosure::do_oop_work(p); }
-void MarkRefsIntoClosure::do_oop(narrowOop* p) { MarkRefsIntoClosure::do_oop_work(p); }
 ParMarkRefsIntoClosure::ParMarkRefsIntoClosure(
 MemRegion span, CMSBitMap* bitMap):
 _span(span),
 _bitMap(bitMap)
 {
 if (_span.contains(addr)) {
 // this should be made more efficient
 _bitMap->par_mark(addr);
 }
 }
-void ParMarkRefsIntoClosure::do_oop(oop* p)       { ParMarkRefsIntoClosure::do_oop_work(p); }
-void ParMarkRefsIntoClosure::do_oop(narrowOop* p) { ParMarkRefsIntoClosure::do_oop_work(p); }
 // A variant of the above, used for CMS marking verification.
 MarkRefsIntoVerifyClosure::MarkRefsIntoVerifyClosure(
 MemRegion span, CMSBitMap* verification_bm, CMSBitMap* cms_bm):
 _span(span),
 log.error(" (" INTPTR_FORMAT " should have been marked)", p2i(addr));
 fatal("... aborting");
 }
 }
 }
-void MarkRefsIntoVerifyClosure::do_oop(oop* p)       { MarkRefsIntoVerifyClosure::do_oop_work(p); }
-void MarkRefsIntoVerifyClosure::do_oop(narrowOop* p) { MarkRefsIntoVerifyClosure::do_oop_work(p); }
 //////////////////////////////////////////////////
 // MarkRefsIntoAndScanClosure
 //////////////////////////////////////////////////
 assert(_collector->no_preserved_marks(),
 "All preserved marks should have been restored above");
 }
 }
-void MarkRefsIntoAndScanClosure::do_oop(oop* p)       { MarkRefsIntoAndScanClosure::do_oop_work(p); }
-void MarkRefsIntoAndScanClosure::do_oop(narrowOop* p) { MarkRefsIntoAndScanClosure::do_oop_work(p); }
 void MarkRefsIntoAndScanClosure::do_yield_work() {
 assert(ConcurrentMarkSweepThread::cms_thread_has_cms_token(),
 "CMS thread should hold CMS token");
 assert_lock_strong(_freelistLock);
 assert_lock_strong(_bit_map->lock());
 trim_queue(_low_water_mark);
 } // Else, another thread claimed the object
 }
 }
 }
-void ParMarkRefsIntoAndScanClosure::do_oop(oop* p)       { ParMarkRefsIntoAndScanClosure::do_oop_work(p); }
-void ParMarkRefsIntoAndScanClosure::do_oop(narrowOop* p) { ParMarkRefsIntoAndScanClosure::do_oop_work(p); }
 // This closure is used to rescan the marked objects on the dirty cards
 // in the mod union table and the card table proper.
 size_t ScanMarkedObjectsAgainCarefullyClosure::do_object_careful_m(
 oop p, MemRegion mr) {
 PushAndMarkVerifyClosure::PushAndMarkVerifyClosure(
 CMSCollector* collector, MemRegion span,
 CMSBitMap* verification_bm, CMSBitMap* cms_bm,
 CMSMarkStack*  mark_stack):
-MetadataAwareOopClosure(collector->ref_processor()),
+MetadataVisitingOopIterateClosure(collector->ref_processor()),
 _collector(collector),
 _span(span),
 _verification_bm(verification_bm),
 _cms_bm(cms_bm),
 _mark_stack(mark_stack)
 PushOrMarkClosure::PushOrMarkClosure(CMSCollector* collector,
 MemRegion span,
 CMSBitMap* bitMap, CMSMarkStack*  markStack,
 HeapWord* finger, MarkFromRootsClosure* parent) :
-MetadataAwareOopClosure(collector->ref_processor()),
+MetadataVisitingOopIterateClosure(collector->ref_processor()),
 _collector(collector),
 _span(span),
 _bitMap(bitMap),
 _markStack(markStack),
 _finger(finger),
 OopTaskQueue* work_queue,
 CMSMarkStack*  overflow_stack,
 HeapWord* finger,
 HeapWord* volatile* global_finger_addr,
 ParMarkFromRootsClosure* parent) :
-MetadataAwareOopClosure(collector->ref_processor()),
+MetadataVisitingOopIterateClosure(collector->ref_processor()),
 _collector(collector),
 _whole_span(collector->_span),
 _span(span),
 _bit_map(bit_map),
 _work_queue(work_queue),
 // bit map
 do_yield_check();
 }
 }
-void PushOrMarkClosure::do_oop(oop* p)       { PushOrMarkClosure::do_oop_work(p); }
-void PushOrMarkClosure::do_oop(narrowOop* p) { PushOrMarkClosure::do_oop_work(p); }
 void ParPushOrMarkClosure::do_oop(oop obj) {
 // Ignore mark word because we are running concurrent with mutators.
 assert(oopDesc::is_oop_or_null(obj, true), "Expected an oop or NULL at " PTR_FORMAT, p2i(obj));
 HeapWord* addr = (HeapWord*)obj;
 if (_whole_span.contains(addr) && !_bit_map->isMarked(addr)) {
 }
 do_yield_check();
 }
 }
-void ParPushOrMarkClosure::do_oop(oop* p)       { ParPushOrMarkClosure::do_oop_work(p); }
-void ParPushOrMarkClosure::do_oop(narrowOop* p) { ParPushOrMarkClosure::do_oop_work(p); }
 PushAndMarkClosure::PushAndMarkClosure(CMSCollector* collector,
 MemRegion span,
 ReferenceDiscoverer* rd,
 CMSBitMap* bit_map,
 CMSBitMap* mod_union_table,
 CMSMarkStack*  mark_stack,
 bool           concurrent_precleaning):
-MetadataAwareOopClosure(rd),
+MetadataVisitingOopIterateClosure(rd),
 _collector(collector),
 _span(span),
 _bit_map(bit_map),
 _mod_union_table(mod_union_table),
 _mark_stack(mark_stack),
 ParPushAndMarkClosure::ParPushAndMarkClosure(CMSCollector* collector,
 MemRegion span,
 ReferenceDiscoverer* rd,
 CMSBitMap* bit_map,
 OopTaskQueue* work_queue):
-MetadataAwareOopClosure(rd),
+MetadataVisitingOopIterateClosure(rd),
 _collector(collector),
 _span(span),
 _bit_map(bit_map),
 _work_queue(work_queue)
 {
 assert(ref_discoverer() != NULL, "ref_discoverer shouldn't be NULL");
 }
-void PushAndMarkClosure::do_oop(oop* p)       { PushAndMarkClosure::do_oop_work(p); }
-void PushAndMarkClosure::do_oop(narrowOop* p) { PushAndMarkClosure::do_oop_work(p); }
 // Grey object rescan during second checkpoint phase --
 // the parallel version.
 void ParPushAndMarkClosure::do_oop(oop obj) {
 // In the assert below, we ignore the mark word because
 _collector->_par_pmc_remark_ovflw++; //  imprecise OK: no need to CAS
 }
 } // Else, some other thread got there first
 }
 }
-void ParPushAndMarkClosure::do_oop(oop* p)       { ParPushAndMarkClosure::do_oop_work(p); }
-void ParPushAndMarkClosure::do_oop(narrowOop* p) { ParPushAndMarkClosure::do_oop_work(p); }
 void CMSPrecleanRefsYieldClosure::do_yield_work() {
 Mutex* bml = _collector->bitMapLock();
 assert_lock_strong(bml);
 assert(ConcurrentMarkSweepThread::cms_thread_has_cms_token(),
 }
 }
 }
 }
-void CMSKeepAliveClosure::do_oop(oop* p)       { CMSKeepAliveClosure::do_oop_work(p); }
-void CMSKeepAliveClosure::do_oop(narrowOop* p) { CMSKeepAliveClosure::do_oop_work(p); }
 // CMSParKeepAliveClosure: a parallel version of the above.
 // The work queues are private to each closure (thread),
 // but (may be) available for stealing by other threads.
 void CMSParKeepAliveClosure::do_oop(oop obj) {
 HeapWord* addr = (HeapWord*)obj;
 // stack usage lower, but leave some oops for potential stealers
 trim_queue(_low_water_mark);
 } // Else, another thread got there first
 }
 }
-void CMSParKeepAliveClosure::do_oop(oop* p)       { CMSParKeepAliveClosure::do_oop_work(p); }
-void CMSParKeepAliveClosure::do_oop(narrowOop* p) { CMSParKeepAliveClosure::do_oop_work(p); }
 void CMSParKeepAliveClosure::trim_queue(uint max) {
 while (_work_queue->size() > max) {
 oop new_oop;
 if (_work_queue->pop_local(new_oop)) {
 _collector->_par_kac_ovflw++;
 }
 } // Else another thread got there already
 }
 }
-void CMSInnerParMarkAndPushClosure::do_oop(oop* p)       { CMSInnerParMarkAndPushClosure::do_oop_work(p); }
-void CMSInnerParMarkAndPushClosure::do_oop(narrowOop* p) { CMSInnerParMarkAndPushClosure::do_oop_work(p); }
 //////////////////////////////////////////////////////////////////
 //  CMSExpansionCause                /////////////////////////////
 //////////////////////////////////////////////////////////////////
 const char* CMSExpansionCause::to_string(CMSExpansionCause::Cause cause) {

changeset 50752	9d62da00bf15
parent 50635	5d3c5af82654
child 51292	0538a5cdb474