Mercurial > hg > truffle

comparison src/share/vm/gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.cpp @ 20268:4c1b88a53c74

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
8046670: Make CMS metadata aware closures applicable for other collectors Reviewed-by: ehelin, mgerdin
author stefank
date Tue, 24 Jun 2014 16:20:15 +0200
parents 30c99d8e0f02
children 2c6ef90f030a
comparison
equal deleted inserted replaced
20267:ff1e37e7eb83 20268:4c1b88a53c74
47 #include "memory/collectorPolicy.hpp" 47 #include "memory/collectorPolicy.hpp"
48 #include "memory/gcLocker.inline.hpp" 48 #include "memory/gcLocker.inline.hpp"
49 #include "memory/genCollectedHeap.hpp" 49 #include "memory/genCollectedHeap.hpp"
50 #include "memory/genMarkSweep.hpp" 50 #include "memory/genMarkSweep.hpp"
51 #include "memory/genOopClosures.inline.hpp" 51 #include "memory/genOopClosures.inline.hpp"
52 #include "memory/iterator.hpp" 52 #include "memory/iterator.inline.hpp"
53 #include "memory/padded.hpp" 53 #include "memory/padded.hpp"
54 #include "memory/referencePolicy.hpp" 54 #include "memory/referencePolicy.hpp"
55 #include "memory/resourceArea.hpp" 55 #include "memory/resourceArea.hpp"
56 #include "memory/tenuredGeneration.hpp" 56 #include "memory/tenuredGeneration.hpp"
57 #include "oops/oop.inline.hpp" 57 #include "oops/oop.inline.hpp"
3096 ClassLoaderDataGraph::clear_claimed_marks(); 3096 ClassLoaderDataGraph::clear_claimed_marks();
3097 3097
3098 // Mark from roots one level into CMS 3098 // Mark from roots one level into CMS
3099 MarkRefsIntoVerifyClosure notOlder(_span, verification_mark_bm(), 3099 MarkRefsIntoVerifyClosure notOlder(_span, verification_mark_bm(),
3100 markBitMap()); 3100 markBitMap());
3101 CMKlassClosure klass_closure(&notOlder); 3101 KlassToOopClosure klass_closure(&notOlder);
3102 3102
3103 gch->rem_set()->prepare_for_younger_refs_iterate(false); // Not parallel. 3103 gch->rem_set()->prepare_for_younger_refs_iterate(false); // Not parallel.
3104 gch->gen_process_strong_roots(_cmsGen->level(), 3104 gch->gen_process_strong_roots(_cmsGen->level(),
3105 true, // younger gens are roots 3105 true, // younger gens are roots
3106 true, // activate StrongRootsScope 3106 true, // activate StrongRootsScope
3717 tsk.work(0); 3717 tsk.work(0);
3718 } 3718 }
3719 gch->set_par_threads(0); 3719 gch->set_par_threads(0);
3720 } else { 3720 } else {
3721 // The serial version. 3721 // The serial version.
3722 CMKlassClosure klass_closure(&notOlder); 3722 KlassToOopClosure klass_closure(&notOlder);
3723 gch->rem_set()->prepare_for_younger_refs_iterate(false); // Not parallel. 3723 gch->rem_set()->prepare_for_younger_refs_iterate(false); // Not parallel.
3724 gch->gen_process_strong_roots(_cmsGen->level(), 3724 gch->gen_process_strong_roots(_cmsGen->level(),
3725 true, // younger gens are roots 3725 true, // younger gens are roots
3726 true, // activate StrongRootsScope 3726 true, // activate StrongRootsScope
3727 SharedHeap::ScanningOption(roots_scanning_options()), 3727 SharedHeap::ScanningOption(roots_scanning_options()),
4179 // have been bumped up by the thread that claimed the last 4179 // have been bumped up by the thread that claimed the last
4180 // task. 4180 // task.
4181 pst->all_tasks_completed(); 4181 pst->all_tasks_completed();
4182 } 4182 }
4183 4183
4184 class Par_ConcMarkingClosure: public CMSOopClosure { 4184 class Par_ConcMarkingClosure: public MetadataAwareOopClosure {
4185 private: 4185 private:
4186 CMSCollector* _collector; 4186 CMSCollector* _collector;
4187 CMSConcMarkingTask* _task; 4187 CMSConcMarkingTask* _task;
4188 MemRegion _span; 4188 MemRegion _span;
4189 CMSBitMap* _bit_map; 4189 CMSBitMap* _bit_map;
4192 protected: 4192 protected:
4193 DO_OOP_WORK_DEFN 4193 DO_OOP_WORK_DEFN
4194 public: 4194 public:
4195 Par_ConcMarkingClosure(CMSCollector* collector, CMSConcMarkingTask* task, OopTaskQueue* work_queue, 4195 Par_ConcMarkingClosure(CMSCollector* collector, CMSConcMarkingTask* task, OopTaskQueue* work_queue,
4196 CMSBitMap* bit_map, CMSMarkStack* overflow_stack): 4196 CMSBitMap* bit_map, CMSMarkStack* overflow_stack):
4197 CMSOopClosure(collector->ref_processor()), 4197 MetadataAwareOopClosure(collector->ref_processor()),
4198 _collector(collector), 4198 _collector(collector),
4199 _task(task), 4199 _task(task),
4200 _span(collector->_span), 4200 _span(collector->_span),
4201 _work_queue(work_queue), 4201 _work_queue(work_queue),
4202 _bit_map(bit_map), 4202 _bit_map(bit_map),
4963 verify_overflow_empty(); 4963 verify_overflow_empty();
4964 return cumNumDirtyCards; 4964 return cumNumDirtyCards;
4965 } 4965 }
4966 4966
4967 class PrecleanKlassClosure : public KlassClosure { 4967 class PrecleanKlassClosure : public KlassClosure {
4968 CMKlassClosure _cm_klass_closure; 4968 KlassToOopClosure _cm_klass_closure;
4969 public: 4969 public:
4970 PrecleanKlassClosure(OopClosure* oop_closure) : _cm_klass_closure(oop_closure) {} 4970 PrecleanKlassClosure(OopClosure* oop_closure) : _cm_klass_closure(oop_closure) {}
4971 void do_klass(Klass* k) { 4971 void do_klass(Klass* k) {
4972 if (k->has_accumulated_modified_oops()) { 4972 if (k->has_accumulated_modified_oops()) {
4973 k->clear_accumulated_modified_oops(); 4973 k->clear_accumulated_modified_oops();
5201 5201
5202 // ---------- scan from roots -------------- 5202 // ---------- scan from roots --------------
5203 _timer.start(); 5203 _timer.start();
5204 GenCollectedHeap* gch = GenCollectedHeap::heap(); 5204 GenCollectedHeap* gch = GenCollectedHeap::heap();
5205 Par_MarkRefsIntoClosure par_mri_cl(_collector->_span, &(_collector->_markBitMap)); 5205 Par_MarkRefsIntoClosure par_mri_cl(_collector->_span, &(_collector->_markBitMap));
5206 CMKlassClosure klass_closure(&par_mri_cl); 5206 KlassToOopClosure klass_closure(&par_mri_cl);
5207 5207
5208 // ---------- young gen roots -------------- 5208 // ---------- young gen roots --------------
5209 { 5209 {
5210 work_on_young_gen_roots(worker_id, &par_mri_cl); 5210 work_on_young_gen_roots(worker_id, &par_mri_cl);
5211 _timer.stop(); 5211 _timer.stop();
5275 // ... work stealing for the above 5275 // ... work stealing for the above
5276 void do_work_steal(int i, Par_MarkRefsIntoAndScanClosure* cl, int* seed); 5276 void do_work_steal(int i, Par_MarkRefsIntoAndScanClosure* cl, int* seed);
5277 }; 5277 };
5278 5278
5279 class RemarkKlassClosure : public KlassClosure { 5279 class RemarkKlassClosure : public KlassClosure {
5280 CMKlassClosure _cm_klass_closure; 5280 KlassToOopClosure _cm_klass_closure;
5281 public: 5281 public:
5282 RemarkKlassClosure(OopClosure* oop_closure) : _cm_klass_closure(oop_closure) {} 5282 RemarkKlassClosure(OopClosure* oop_closure) : _cm_klass_closure(oop_closure) {}
5283 void do_klass(Klass* k) { 5283 void do_klass(Klass* k) {
5284 // Check if we have modified any oops in the Klass during the concurrent marking. 5284 // Check if we have modified any oops in the Klass during the concurrent marking.
5285 if (k->has_accumulated_modified_oops()) { 5285 if (k->has_accumulated_modified_oops()) {
7714 7714
7715 PushAndMarkVerifyClosure::PushAndMarkVerifyClosure( 7715 PushAndMarkVerifyClosure::PushAndMarkVerifyClosure(
7716 CMSCollector* collector, MemRegion span, 7716 CMSCollector* collector, MemRegion span,
7717 CMSBitMap* verification_bm, CMSBitMap* cms_bm, 7717 CMSBitMap* verification_bm, CMSBitMap* cms_bm,
7718 CMSMarkStack* mark_stack): 7718 CMSMarkStack* mark_stack):
7719 CMSOopClosure(collector->ref_processor()), 7719 MetadataAwareOopClosure(collector->ref_processor()),
7720 _collector(collector), 7720 _collector(collector),
7721 _span(span), 7721 _span(span),
7722 _verification_bm(verification_bm), 7722 _verification_bm(verification_bm),
7723 _cms_bm(cms_bm), 7723 _cms_bm(cms_bm),
7724 _mark_stack(mark_stack) 7724 _mark_stack(mark_stack)
7767 7767
7768 PushOrMarkClosure::PushOrMarkClosure(CMSCollector* collector, 7768 PushOrMarkClosure::PushOrMarkClosure(CMSCollector* collector,
7769 MemRegion span, 7769 MemRegion span,
7770 CMSBitMap* bitMap, CMSMarkStack* markStack, 7770 CMSBitMap* bitMap, CMSMarkStack* markStack,
7771 HeapWord* finger, MarkFromRootsClosure* parent) : 7771 HeapWord* finger, MarkFromRootsClosure* parent) :
7772 CMSOopClosure(collector->ref_processor()), 7772 MetadataAwareOopClosure(collector->ref_processor()),
7773 _collector(collector), 7773 _collector(collector),
7774 _span(span), 7774 _span(span),
7775 _bitMap(bitMap), 7775 _bitMap(bitMap),
7776 _markStack(markStack), 7776 _markStack(markStack),
7777 _finger(finger), 7777 _finger(finger),
7784 OopTaskQueue* work_queue, 7784 OopTaskQueue* work_queue,
7785 CMSMarkStack* overflow_stack, 7785 CMSMarkStack* overflow_stack,
7786 HeapWord* finger, 7786 HeapWord* finger,
7787 HeapWord** global_finger_addr, 7787 HeapWord** global_finger_addr,
7788 Par_MarkFromRootsClosure* parent) : 7788 Par_MarkFromRootsClosure* parent) :
7789 CMSOopClosure(collector->ref_processor()), 7789 MetadataAwareOopClosure(collector->ref_processor()),
7790 _collector(collector), 7790 _collector(collector),
7791 _whole_span(collector->_span), 7791 _whole_span(collector->_span),
7792 _span(span), 7792 _span(span),
7793 _bit_map(bit_map), 7793 _bit_map(bit_map),
7794 _work_queue(work_queue), 7794 _work_queue(work_queue),
7831 // Remember the least grey address discarded 7831 // Remember the least grey address discarded
7832 HeapWord* ra = (HeapWord*)_overflow_stack->least_value(lost); 7832 HeapWord* ra = (HeapWord*)_overflow_stack->least_value(lost);
7833 _collector->lower_restart_addr(ra); 7833 _collector->lower_restart_addr(ra);
7834 _overflow_stack->reset(); // discard stack contents 7834 _overflow_stack->reset(); // discard stack contents
7835 _overflow_stack->expand(); // expand the stack if possible 7835 _overflow_stack->expand(); // expand the stack if possible
7836 }
7837
7838 void CMKlassClosure::do_klass(Klass* k) {
7839 assert(_oop_closure != NULL, "Not initialized?");
7840 k->oops_do(_oop_closure);
7841 } 7836 }
7842 7837
7843 void PushOrMarkClosure::do_oop(oop obj) { 7838 void PushOrMarkClosure::do_oop(oop obj) {
7844 // Ignore mark word because we are running concurrent with mutators. 7839 // Ignore mark word because we are running concurrent with mutators.
7845 assert(obj->is_oop_or_null(true), "expected an oop or NULL"); 7840 assert(obj->is_oop_or_null(true), "expected an oop or NULL");
7935 ReferenceProcessor* rp, 7930 ReferenceProcessor* rp,
7936 CMSBitMap* bit_map, 7931 CMSBitMap* bit_map,
7937 CMSBitMap* mod_union_table, 7932 CMSBitMap* mod_union_table,
7938 CMSMarkStack* mark_stack, 7933 CMSMarkStack* mark_stack,
7939 bool concurrent_precleaning): 7934 bool concurrent_precleaning):
7940 CMSOopClosure(rp), 7935 MetadataAwareOopClosure(rp),
7941 _collector(collector), 7936 _collector(collector),
7942 _span(span), 7937 _span(span),
7943 _bit_map(bit_map), 7938 _bit_map(bit_map),
7944 _mod_union_table(mod_union_table), 7939 _mod_union_table(mod_union_table),
7945 _mark_stack(mark_stack), 7940 _mark_stack(mark_stack),
8008 Par_PushAndMarkClosure::Par_PushAndMarkClosure(CMSCollector* collector, 8003 Par_PushAndMarkClosure::Par_PushAndMarkClosure(CMSCollector* collector,
8009 MemRegion span, 8004 MemRegion span,
8010 ReferenceProcessor* rp, 8005 ReferenceProcessor* rp,
8011 CMSBitMap* bit_map, 8006 CMSBitMap* bit_map,
8012 OopTaskQueue* work_queue): 8007 OopTaskQueue* work_queue):
8013 CMSOopClosure(rp), 8008 MetadataAwareOopClosure(rp),
8014 _collector(collector), 8009 _collector(collector),
8015 _span(span), 8010 _span(span),
8016 _bit_map(bit_map), 8011 _bit_map(bit_map),
8017 _work_queue(work_queue) 8012 _work_queue(work_queue)
8018 { 8013 {