Mercurial > hg > graal-jvmci-8

comparison src/share/vm/gc_implementation/g1/g1RemSet.cpp @ 1861:c32059ef4dc0

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
6971296: G1: simplify G1RemSet class hierarchy Summary: Remove G1RemSet base class and StupidG1RemSet class; rename HRInto_G1RemSet to just G1RemSet. Reviewed-by: ysr, tonyp
author johnc
date Tue, 12 Oct 2010 09:36:48 -0700
parents 8b10f48633dc
children 878b57474103
comparison
equal deleted inserted replaced
1843:0715f0cf171d 1861:c32059ef4dc0
95 } 95 }
96 return false; 96 return false;
97 } 97 }
98 }; 98 };
99 99
100 void
101 StupidG1RemSet::oops_into_collection_set_do(OopsInHeapRegionClosure* oc,
102 int worker_i) {
103 IntoCSRegionClosure rc(_g1, oc);
104 _g1->heap_region_iterate(&rc);
105 }
106
107 class VerifyRSCleanCardOopClosure: public OopClosure { 100 class VerifyRSCleanCardOopClosure: public OopClosure {
108 G1CollectedHeap* _g1; 101 G1CollectedHeap* _g1;
109 public: 102 public:
110 VerifyRSCleanCardOopClosure(G1CollectedHeap* g1) : _g1(g1) {} 103 VerifyRSCleanCardOopClosure(G1CollectedHeap* g1) : _g1(g1) {}
111 104
117 guarantee(to == NULL || !to->in_collection_set(), 110 guarantee(to == NULL || !to->in_collection_set(),
118 "Missed a rem set member."); 111 "Missed a rem set member.");
119 } 112 }
120 }; 113 };
121 114
122 HRInto_G1RemSet::HRInto_G1RemSet(G1CollectedHeap* g1, CardTableModRefBS* ct_bs) 115 G1RemSet::G1RemSet(G1CollectedHeap* g1, CardTableModRefBS* ct_bs)
123 : G1RemSet(g1), _ct_bs(ct_bs), _g1p(_g1->g1_policy()), 116 : _g1(g1), _conc_refine_cards(0),
117 _ct_bs(ct_bs), _g1p(_g1->g1_policy()),
124 _cg1r(g1->concurrent_g1_refine()), 118 _cg1r(g1->concurrent_g1_refine()),
125 _traversal_in_progress(false), 119 _traversal_in_progress(false),
126 _cset_rs_update_cl(NULL), 120 _cset_rs_update_cl(NULL),
127 _cards_scanned(NULL), _total_cards_scanned(0) 121 _cards_scanned(NULL), _total_cards_scanned(0)
128 { 122 {
132 for (uint i = 0; i < n_workers(); i++) { 126 for (uint i = 0; i < n_workers(); i++) {
133 _cset_rs_update_cl[i] = NULL; 127 _cset_rs_update_cl[i] = NULL;
134 } 128 }
135 } 129 }
136 130
137 HRInto_G1RemSet::~HRInto_G1RemSet() { 131 G1RemSet::~G1RemSet() {
138 delete _seq_task; 132 delete _seq_task;
139 for (uint i = 0; i < n_workers(); i++) { 133 for (uint i = 0; i < n_workers(); i++) {
140 assert(_cset_rs_update_cl[i] == NULL, "it should be"); 134 assert(_cset_rs_update_cl[i] == NULL, "it should be");
141 } 135 }
142 FREE_C_HEAP_ARRAY(OopsInHeapRegionClosure*, _cset_rs_update_cl); 136 FREE_C_HEAP_ARRAY(OopsInHeapRegionClosure*, _cset_rs_update_cl);
275 // If we have: 269 // If we have:
276 // n collection set regions 270 // n collection set regions
277 // p threads 271 // p threads
278 // Then thread t will start at region t * floor (n/p) 272 // Then thread t will start at region t * floor (n/p)
279 273
280 HeapRegion* HRInto_G1RemSet::calculateStartRegion(int worker_i) { 274 HeapRegion* G1RemSet::calculateStartRegion(int worker_i) {
281 HeapRegion* result = _g1p->collection_set(); 275 HeapRegion* result = _g1p->collection_set();
282 if (ParallelGCThreads > 0) { 276 if (ParallelGCThreads > 0) {
283 size_t cs_size = _g1p->collection_set_size(); 277 size_t cs_size = _g1p->collection_set_size();
284 int n_workers = _g1->workers()->total_workers(); 278 int n_workers = _g1->workers()->total_workers();
285 size_t cs_spans = cs_size / n_workers; 279 size_t cs_spans = cs_size / n_workers;
288 result = result->next_in_collection_set(); 282 result = result->next_in_collection_set();
289 } 283 }
290 return result; 284 return result;
291 } 285 }
292 286
293 void HRInto_G1RemSet::scanRS(OopsInHeapRegionClosure* oc, int worker_i) { 287 void G1RemSet::scanRS(OopsInHeapRegionClosure* oc, int worker_i) {
294 double rs_time_start = os::elapsedTime(); 288 double rs_time_start = os::elapsedTime();
295 HeapRegion *startRegion = calculateStartRegion(worker_i); 289 HeapRegion *startRegion = calculateStartRegion(worker_i);
296 290
297 ScanRSClosure scanRScl(oc, worker_i); 291 ScanRSClosure scanRScl(oc, worker_i);
298 _g1->collection_set_iterate_from(startRegion, &scanRScl); 292 _g1->collection_set_iterate_from(startRegion, &scanRScl);
338 } 332 }
339 return true; 333 return true;
340 } 334 }
341 }; 335 };
342 336
343 void HRInto_G1RemSet::updateRS(DirtyCardQueue* into_cset_dcq, int worker_i) { 337 void G1RemSet::updateRS(DirtyCardQueue* into_cset_dcq, int worker_i) {
344 double start = os::elapsedTime(); 338 double start = os::elapsedTime();
345 // Apply the given closure to all remaining log entries. 339 // Apply the given closure to all remaining log entries.
346 RefineRecordRefsIntoCSCardTableEntryClosure into_cset_update_rs_cl(_g1, into_cset_dcq); 340 RefineRecordRefsIntoCSCardTableEntryClosure into_cset_update_rs_cl(_g1, into_cset_dcq);
347 _g1->iterate_dirty_card_closure(&into_cset_update_rs_cl, into_cset_dcq, false, worker_i); 341 _g1->iterate_dirty_card_closure(&into_cset_update_rs_cl, into_cset_dcq, false, worker_i);
348 342
437 } 431 }
438 gclog_or_tty->print_cr(" > %8d %8d", (1 << (MIN+mx-2))+1, _histo[mx-1]); 432 gclog_or_tty->print_cr(" > %8d %8d", (1 << (MIN+mx-2))+1, _histo[mx-1]);
439 } 433 }
440 }; 434 };
441 435
442 void HRInto_G1RemSet::cleanupHRRS() { 436 void G1RemSet::cleanupHRRS() {
443 HeapRegionRemSet::cleanup(); 437 HeapRegionRemSet::cleanup();
444 } 438 }
445 439
446 void 440 void G1RemSet::oops_into_collection_set_do(OopsInHeapRegionClosure* oc,
447 HRInto_G1RemSet::oops_into_collection_set_do(OopsInHeapRegionClosure* oc,
448 int worker_i) { 441 int worker_i) {
449 #if CARD_REPEAT_HISTO 442 #if CARD_REPEAT_HISTO
450 ct_freq_update_histo_and_reset(); 443 ct_freq_update_histo_and_reset();
451 #endif 444 #endif
452 if (worker_i == 0) { 445 if (worker_i == 0) {
506 499
507 // We now clear the cached values of _cset_rs_update_cl for this worker 500 // We now clear the cached values of _cset_rs_update_cl for this worker
508 _cset_rs_update_cl[worker_i] = NULL; 501 _cset_rs_update_cl[worker_i] = NULL;
509 } 502 }
510 503
511 void HRInto_G1RemSet:: 504 void G1RemSet::prepare_for_oops_into_collection_set_do() {
512 prepare_for_oops_into_collection_set_do() {
513 #if G1_REM_SET_LOGGING 505 #if G1_REM_SET_LOGGING
514 PrintRSClosure cl; 506 PrintRSClosure cl;
515 _g1->collection_set_iterate(&cl); 507 _g1->collection_set_iterate(&cl);
516 #endif 508 #endif
517 cleanupHRRS(); 509 cleanupHRRS();
579 // * the DCQS to which this closure is applied is used to hold 571 // * the DCQS to which this closure is applied is used to hold
580 // references that point into the collection set from the prior 572 // references that point into the collection set from the prior
581 // RSet updating, 573 // RSet updating,
582 // * the post-write barrier shouldn't be logging updates to young 574 // * the post-write barrier shouldn't be logging updates to young
583 // regions (but there is a situation where this can happen - see 575 // regions (but there is a situation where this can happen - see
584 // the comment in HRInto_G1RemSet::concurrentRefineOneCard below - 576 // the comment in G1RemSet::concurrentRefineOneCard below -
585 // that should not be applicable here), and 577 // that should not be applicable here), and
586 // * during actual RSet updating, the filtering of cards in young 578 // * during actual RSet updating, the filtering of cards in young
587 // regions in HeapRegion::oops_on_card_seq_iterate_careful is 579 // regions in HeapRegion::oops_on_card_seq_iterate_careful is
588 // employed. 580 // employed.
589 // As a result, when this closure is applied to "refs into cset" 581 // As a result, when this closure is applied to "refs into cset"
599 assert(stop_point == NULL, "saw an unallocated region"); 591 assert(stop_point == NULL, "saw an unallocated region");
600 return true; 592 return true;
601 } 593 }
602 }; 594 };
603 595
604 void HRInto_G1RemSet::cleanup_after_oops_into_collection_set_do() { 596 void G1RemSet::cleanup_after_oops_into_collection_set_do() {
605 guarantee( _cards_scanned != NULL, "invariant" ); 597 guarantee( _cards_scanned != NULL, "invariant" );
606 _total_cards_scanned = 0; 598 _total_cards_scanned = 0;
607 for (uint i = 0; i < n_workers(); ++i) 599 for (uint i = 0; i < n_workers(); ++i)
608 _total_cards_scanned += _cards_scanned[i]; 600 _total_cards_scanned += _cards_scanned[i];
609 FREE_C_HEAP_ARRAY(size_t, _cards_scanned); 601 FREE_C_HEAP_ARRAY(size_t, _cards_scanned);
690 } 682 }
691 return false; 683 return false;
692 } 684 }
693 }; 685 };
694 686
695 void HRInto_G1RemSet::scrub(BitMap* region_bm, BitMap* card_bm) { 687 void G1RemSet::scrub(BitMap* region_bm, BitMap* card_bm) {
696 ScrubRSClosure scrub_cl(region_bm, card_bm); 688 ScrubRSClosure scrub_cl(region_bm, card_bm);
697 _g1->heap_region_iterate(&scrub_cl); 689 _g1->heap_region_iterate(&scrub_cl);
698 } 690 }
699 691
700 void HRInto_G1RemSet::scrub_par(BitMap* region_bm, BitMap* card_bm, 692 void G1RemSet::scrub_par(BitMap* region_bm, BitMap* card_bm,
701 int worker_num, int claim_val) { 693 int worker_num, int claim_val) {
702 ScrubRSClosure scrub_cl(region_bm, card_bm); 694 ScrubRSClosure scrub_cl(region_bm, card_bm);
703 _g1->heap_region_par_iterate_chunked(&scrub_cl, worker_num, claim_val); 695 _g1->heap_region_par_iterate_chunked(&scrub_cl, worker_num, claim_val);
704 } 696 }
705 697
739 } 731 }
740 virtual void do_oop(oop* p) { do_oop_nv(p); } 732 virtual void do_oop(oop* p) { do_oop_nv(p); }
741 virtual void do_oop(narrowOop* p) { do_oop_nv(p); } 733 virtual void do_oop(narrowOop* p) { do_oop_nv(p); }
742 }; 734 };
743 735
744 bool HRInto_G1RemSet::concurrentRefineOneCard_impl(jbyte* card_ptr, int worker_i, 736 bool G1RemSet::concurrentRefineOneCard_impl(jbyte* card_ptr, int worker_i,
745 bool check_for_refs_into_cset) { 737 bool check_for_refs_into_cset) {
746 // Construct the region representing the card. 738 // Construct the region representing the card.
747 HeapWord* start = _ct_bs->addr_for(card_ptr); 739 HeapWord* start = _ct_bs->addr_for(card_ptr);
748 // And find the region containing it. 740 // And find the region containing it.
749 HeapRegion* r = _g1->heap_region_containing(start); 741 HeapRegion* r = _g1->heap_region_containing(start);
818 } 810 }
819 811
820 return trigger_cl.value(); 812 return trigger_cl.value();
821 } 813 }
822 814
823 bool HRInto_G1RemSet::concurrentRefineOneCard(jbyte* card_ptr, int worker_i, 815 bool G1RemSet::concurrentRefineOneCard(jbyte* card_ptr, int worker_i,
824 bool check_for_refs_into_cset) { 816 bool check_for_refs_into_cset) {
825 // If the card is no longer dirty, nothing to do. 817 // If the card is no longer dirty, nothing to do.
826 if (*card_ptr != CardTableModRefBS::dirty_card_val()) { 818 if (*card_ptr != CardTableModRefBS::dirty_card_val()) {
827 // No need to return that this card contains refs that point 819 // No need to return that this card contains refs that point
828 // into the collection set. 820 // into the collection set.
993 ConcurrentG1RefineThread* crt = (ConcurrentG1RefineThread*) t; 985 ConcurrentG1RefineThread* crt = (ConcurrentG1RefineThread*) t;
994 gclog_or_tty->print(" %5.2f", crt->vtime_accum()); 986 gclog_or_tty->print(" %5.2f", crt->vtime_accum());
995 } 987 }
996 }; 988 };
997 989
998 void HRInto_G1RemSet::print_summary_info() { 990 void G1RemSet::print_summary_info() {
999 G1CollectedHeap* g1 = G1CollectedHeap::heap(); 991 G1CollectedHeap* g1 = G1CollectedHeap::heap();
1000 992
1001 #if CARD_REPEAT_HISTO 993 #if CARD_REPEAT_HISTO
1002 gclog_or_tty->print_cr("\nG1 card_repeat count histogram: "); 994 gclog_or_tty->print_cr("\nG1 card_repeat count histogram: ");
1003 gclog_or_tty->print_cr(" # of repeats --> # of cards with that number."); 995 gclog_or_tty->print_cr(" # of repeats --> # of cards with that number.");
1027 PrintRSThreadVTimeClosure p; 1019 PrintRSThreadVTimeClosure p;
1028 gclog_or_tty->print(" "); 1020 gclog_or_tty->print(" ");
1029 g1->concurrent_g1_refine()->threads_do(&p); 1021 g1->concurrent_g1_refine()->threads_do(&p);
1030 gclog_or_tty->print_cr(""); 1022 gclog_or_tty->print_cr("");
1031 1023
1032 if (G1UseHRIntoRS) { 1024 HRRSStatsIter blk;
1033 HRRSStatsIter blk; 1025 g1->heap_region_iterate(&blk);
1034 g1->heap_region_iterate(&blk); 1026 gclog_or_tty->print_cr(" Total heap region rem set sizes = " SIZE_FORMAT "K."
1035 gclog_or_tty->print_cr(" Total heap region rem set sizes = " SIZE_FORMAT "K." 1027 " Max = " SIZE_FORMAT "K.",
1036 " Max = " SIZE_FORMAT "K.", 1028 blk.total_mem_sz()/K, blk.max_mem_sz()/K);
1037 blk.total_mem_sz()/K, blk.max_mem_sz()/K); 1029 gclog_or_tty->print_cr(" Static structures = " SIZE_FORMAT "K,"
1038 gclog_or_tty->print_cr(" Static structures = " SIZE_FORMAT "K," 1030 " free_lists = " SIZE_FORMAT "K.",
1039 " free_lists = " SIZE_FORMAT "K.", 1031 HeapRegionRemSet::static_mem_size()/K,
1040 HeapRegionRemSet::static_mem_size()/K, 1032 HeapRegionRemSet::fl_mem_size()/K);
1041 HeapRegionRemSet::fl_mem_size()/K); 1033 gclog_or_tty->print_cr(" %d occupied cards represented.",
1042 gclog_or_tty->print_cr(" %d occupied cards represented.", 1034 blk.occupied());
1043 blk.occupied()); 1035 gclog_or_tty->print_cr(" Max sz region = [" PTR_FORMAT ", " PTR_FORMAT " )"
1044 gclog_or_tty->print_cr(" Max sz region = [" PTR_FORMAT ", " PTR_FORMAT " )" 1036 ", cap = " SIZE_FORMAT "K, occ = " SIZE_FORMAT "K.",
1045 ", cap = " SIZE_FORMAT "K, occ = " SIZE_FORMAT "K.", 1037 blk.max_mem_sz_region()->bottom(), blk.max_mem_sz_region()->end(),
1046 blk.max_mem_sz_region()->bottom(), blk.max_mem_sz_region()->end(), 1038 (blk.max_mem_sz_region()->rem_set()->mem_size() + K - 1)/K,
1047 (blk.max_mem_sz_region()->rem_set()->mem_size() + K - 1)/K, 1039 (blk.max_mem_sz_region()->rem_set()->occupied() + K - 1)/K);
1048 (blk.max_mem_sz_region()->rem_set()->occupied() + K - 1)/K); 1040 gclog_or_tty->print_cr(" Did %d coarsenings.", HeapRegionRemSet::n_coarsenings());
1049 gclog_or_tty->print_cr(" Did %d coarsenings.", 1041 }
1050 HeapRegionRemSet::n_coarsenings()); 1042
1051 1043 void G1RemSet::prepare_for_verify() {
1052 }
1053 }
1054
1055 void HRInto_G1RemSet::prepare_for_verify() {
1056 if (G1HRRSFlushLogBuffersOnVerify && 1044 if (G1HRRSFlushLogBuffersOnVerify &&
1057 (VerifyBeforeGC || VerifyAfterGC) 1045 (VerifyBeforeGC || VerifyAfterGC)
1058 && !_g1->full_collection()) { 1046 && !_g1->full_collection()) {
1059 cleanupHRRS(); 1047 cleanupHRRS();
1060 _g1->set_refine_cte_cl_concurrency(false); 1048 _g1->set_refine_cte_cl_concurrency(false);