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

equal deleted inserted replaced

-:29c97629997e
+:4a4a482298a6
 #include "memory/collectorPolicy.hpp"
 #include "memory/gcLocker.inline.hpp"
 #include "memory/genCollectedHeap.hpp"
 #include "memory/genMarkSweep.hpp"
 #include "memory/genOopClosures.inline.hpp"
-#include "memory/iterator.hpp"
+#include "memory/iterator.inline.hpp"
 #include "memory/padded.hpp"
 #include "memory/referencePolicy.hpp"
 #include "memory/resourceArea.hpp"
 #include "memory/tenuredGeneration.hpp"
 #include "oops/oop.inline.hpp"
 ClassLoaderDataGraph::clear_claimed_marks();
 // Mark from roots one level into CMS
 MarkRefsIntoVerifyClosure notOlder(_span, verification_mark_bm(),
 markBitMap());
-CMKlassClosure klass_closure(&notOlder);
+KlassToOopClosure klass_closure(&notOlder);
 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
 tsk.work(0);
 }
 gch->set_par_threads(0);
 } else {
 // The serial version.
-CMKlassClosure klass_closure(&notOlder);
+KlassToOopClosure klass_closure(&notOlder);
 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
 SharedHeap::ScanningOption(roots_scanning_options()),
 // have been bumped up by the thread that claimed the last
 // task.
 pst->all_tasks_completed();
 }
-class Par_ConcMarkingClosure: public CMSOopClosure {
+class Par_ConcMarkingClosure: public MetadataAwareOopClosure {
 private:
 CMSCollector* _collector;
 CMSConcMarkingTask* _task;
 MemRegion     _span;
 CMSBitMap*    _bit_map;
 protected:
 DO_OOP_WORK_DEFN
 public:
 Par_ConcMarkingClosure(CMSCollector* collector, CMSConcMarkingTask* task, OopTaskQueue* work_queue,
 CMSBitMap* bit_map, CMSMarkStack* overflow_stack):
-CMSOopClosure(collector->ref_processor()),
+MetadataAwareOopClosure(collector->ref_processor()),
 _collector(collector),
 _task(task),
 _span(collector->_span),
 _work_queue(work_queue),
 _bit_map(bit_map),
 verify_overflow_empty();
 return cumNumDirtyCards;
 }
 class PrecleanKlassClosure : public KlassClosure {
-CMKlassClosure _cm_klass_closure;
+KlassToOopClosure _cm_klass_closure;
 public:
 PrecleanKlassClosure(OopClosure* oop_closure) : _cm_klass_closure(oop_closure) {}
 void do_klass(Klass* k) {
 if (k->has_accumulated_modified_oops()) {
 k->clear_accumulated_modified_oops();
 // ---------- scan from roots --------------
 _timer.start();
 GenCollectedHeap* gch = GenCollectedHeap::heap();
 Par_MarkRefsIntoClosure par_mri_cl(_collector->_span, &(_collector->_markBitMap));
-CMKlassClosure klass_closure(&par_mri_cl);
+KlassToOopClosure klass_closure(&par_mri_cl);
 // ---------- young gen roots --------------
 {
 work_on_young_gen_roots(worker_id, &par_mri_cl);
 _timer.stop();
 // ... work stealing for the above
 void do_work_steal(int i, Par_MarkRefsIntoAndScanClosure* cl, int* seed);
 };
 class RemarkKlassClosure : public KlassClosure {
-CMKlassClosure _cm_klass_closure;
+KlassToOopClosure _cm_klass_closure;
 public:
 RemarkKlassClosure(OopClosure* oop_closure) : _cm_klass_closure(oop_closure) {}
 void do_klass(Klass* k) {
 // Check if we have modified any oops in the Klass during the concurrent marking.
 if (k->has_accumulated_modified_oops()) {
 PushAndMarkVerifyClosure::PushAndMarkVerifyClosure(
 CMSCollector* collector, MemRegion span,
 CMSBitMap* verification_bm, CMSBitMap* cms_bm,
 CMSMarkStack*  mark_stack):
-CMSOopClosure(collector->ref_processor()),
+MetadataAwareOopClosure(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) :
-CMSOopClosure(collector->ref_processor()),
+MetadataAwareOopClosure(collector->ref_processor()),
 _collector(collector),
 _span(span),
 _bitMap(bitMap),
 _markStack(markStack),
 _finger(finger),
 OopTaskQueue* work_queue,
 CMSMarkStack*  overflow_stack,
 HeapWord* finger,
 HeapWord** global_finger_addr,
 Par_MarkFromRootsClosure* parent) :
-CMSOopClosure(collector->ref_processor()),
+MetadataAwareOopClosure(collector->ref_processor()),
 _collector(collector),
 _whole_span(collector->_span),
 _span(span),
 _bit_map(bit_map),
 _work_queue(work_queue),
 // Remember the least grey address discarded
 HeapWord* ra = (HeapWord*)_overflow_stack->least_value(lost);
 _collector->lower_restart_addr(ra);
 _overflow_stack->reset();  // discard stack contents
 _overflow_stack->expand(); // expand the stack if possible
-}
-void CMKlassClosure::do_klass(Klass* k) {
-assert(_oop_closure != NULL, "Not initialized?");
-k->oops_do(_oop_closure);
 }
 void PushOrMarkClosure::do_oop(oop obj) {
 // Ignore mark word because we are running concurrent with mutators.
 assert(obj->is_oop_or_null(true), "expected an oop or NULL");
 ReferenceProcessor* rp,
 CMSBitMap* bit_map,
 CMSBitMap* mod_union_table,
 CMSMarkStack*  mark_stack,
 bool           concurrent_precleaning):
-CMSOopClosure(rp),
+MetadataAwareOopClosure(rp),
 _collector(collector),
 _span(span),
 _bit_map(bit_map),
 _mod_union_table(mod_union_table),
 _mark_stack(mark_stack),
 Par_PushAndMarkClosure::Par_PushAndMarkClosure(CMSCollector* collector,
 MemRegion span,
 ReferenceProcessor* rp,
 CMSBitMap* bit_map,
 OopTaskQueue* work_queue):
-CMSOopClosure(rp),
+MetadataAwareOopClosure(rp),
 _collector(collector),
 _span(span),
 _bit_map(bit_map),
 _work_queue(work_queue)
 {

changeset 25356	4a4a482298a6
parent 25351	7c198a690050
child 25485	9c3d427eed01