jdk-sandbox: comparison hotspot/src/share/vm/gc/g1/g1RemSet.cpp

equal deleted inserted replaced

-:c70b36f0730d
+:fef0d64b2263
 _card_live_data.pretouch();
 }
 }
 G1ScanRSClosure::G1ScanRSClosure(G1RemSetScanState* scan_state,
-G1ParPushHeapRSClosure* push_heap_cl,
+G1ScanObjsDuringScanRSClosure* scan_obj_on_card,
 CodeBlobClosure* code_root_cl,
 uint worker_i) :
 _scan_state(scan_state),
-_push_heap_cl(push_heap_cl),
+_scan_objs_on_card_cl(scan_obj_on_card),
 _code_root_cl(code_root_cl),
 _strong_code_root_scan_time_sec(0.0),
 _cards_claimed(0),
 _cards_scanned(0),
 _cards_skipped(0),
 if (!mr.is_empty() && !_ct_bs->is_card_claimed(index)) {
 // We make the card as "claimed" lazily (so races are possible
 // but they're benign), which reduces the number of duplicate
 // scans (the rsets of the regions in the cset can intersect).
 _ct_bs->set_card_claimed(index);
-_push_heap_cl->set_region(r);
+_scan_objs_on_card_cl->set_region(r);
-r->oops_on_card_seq_iterate_careful<true>(mr, _push_heap_cl);
+r->oops_on_card_seq_iterate_careful<true>(mr, _scan_objs_on_card_cl);
 _cards_scanned++;
 }
 }
 void G1ScanRSClosure::scan_strong_code_roots(HeapRegion* r) {
 scan_strong_code_roots(r);
 }
 return false;
 }
-void G1RemSet::scan_rem_set(G1ParPushHeapRSClosure* oops_in_heap_closure,
+void G1RemSet::scan_rem_set(G1ParScanThreadState* pss,
 CodeBlobClosure* heap_region_codeblobs,
 uint worker_i) {
 double rs_time_start = os::elapsedTime();
-G1ScanRSClosure cl(_scan_state, oops_in_heap_closure, heap_region_codeblobs, worker_i);
+G1ScanObjsDuringScanRSClosure scan_cl(_g1, pss);
+G1ScanRSClosure cl(_scan_state, &scan_cl, heap_region_codeblobs, worker_i);
 _g1->collection_set_iterate_from(&cl, worker_i);
 double scan_rs_time_sec = (os::elapsedTime() - rs_time_start) -
 cl.strong_code_root_scan_time_sec();
 // evacuation pause.
 class RefineRecordRefsIntoCSCardTableEntryClosure: public CardTableEntryClosure {
 G1RemSet* _g1rs;
 DirtyCardQueue* _into_cset_dcq;
-G1ParPushHeapRSClosure* _cl;
+G1ScanObjsDuringUpdateRSClosure* _update_rs_cl;
 public:
 RefineRecordRefsIntoCSCardTableEntryClosure(G1CollectedHeap* g1h,
 DirtyCardQueue* into_cset_dcq,
-G1ParPushHeapRSClosure* cl) :
+G1ScanObjsDuringUpdateRSClosure* update_rs_cl) :
-_g1rs(g1h->g1_rem_set()), _into_cset_dcq(into_cset_dcq), _cl(cl)
+_g1rs(g1h->g1_rem_set()), _into_cset_dcq(into_cset_dcq), _update_rs_cl(update_rs_cl)
 {}
 bool do_card_ptr(jbyte* card_ptr, uint worker_i) {
 // The only time we care about recording cards that
 // contain references that point into the collection set
 // is during RSet updating within an evacuation pause.
 // In this case worker_i should be the id of a GC worker thread.
 assert(SafepointSynchronize::is_at_safepoint(), "not during an evacuation pause");
-assert(worker_i < ParallelGCThreads, "should be a GC worker");
+if (_g1rs->refine_card_during_gc(card_ptr, _update_rs_cl)) {
-if (_g1rs->refine_card_during_gc(card_ptr, worker_i, _cl)) {
 // 'card_ptr' contains references that point into the collection
 // set. We need to record the card in the DCQS
 // (_into_cset_dirty_card_queue_set)
 // that's used for that purpose.
 //
 return true;
 }
 };
 void G1RemSet::update_rem_set(DirtyCardQueue* into_cset_dcq,
-G1ParPushHeapRSClosure* oops_in_heap_closure,
+G1ParScanThreadState* pss,
 uint worker_i) {
-RefineRecordRefsIntoCSCardTableEntryClosure into_cset_update_rs_cl(_g1, into_cset_dcq, oops_in_heap_closure);
+G1ScanObjsDuringUpdateRSClosure update_rs_cl(_g1, pss, worker_i);
+RefineRecordRefsIntoCSCardTableEntryClosure into_cset_update_rs_cl(_g1, into_cset_dcq, &update_rs_cl);
 G1GCParPhaseTimesTracker x(_g1p->phase_times(), G1GCPhaseTimes::UpdateRS, worker_i);
 if (G1HotCardCache::default_use_cache()) {
 // Apply the closure to the entries of the hot card cache.
 G1GCParPhaseTimesTracker y(_g1p->phase_times(), G1GCPhaseTimes::ScanHCC, worker_i);
 void G1RemSet::cleanupHRRS() {
 HeapRegionRemSet::cleanup();
 }
-void G1RemSet::oops_into_collection_set_do(G1ParPushHeapRSClosure* cl,
+void G1RemSet::oops_into_collection_set_do(G1ParScanThreadState* pss,
 CodeBlobClosure* heap_region_codeblobs,
 uint worker_i) {
 // A DirtyCardQueue that is used to hold cards containing references
 // that point into the collection set. This DCQ is associated with a
 // special DirtyCardQueueSet (see g1CollectedHeap.hpp).  Under normal
 // are wholly 'free' of live objects. In the event of an evacuation
 // failure the cards/buffers in this queue set are passed to the
 // DirtyCardQueueSet that is used to manage RSet updates
 DirtyCardQueue into_cset_dcq(&_into_cset_dirty_card_queue_set);
-update_rem_set(&into_cset_dcq, cl, worker_i);
+update_rem_set(&into_cset_dcq, pss, worker_i);
-scan_rem_set(cl, heap_region_codeblobs, worker_i);;
+scan_rem_set(pss, heap_region_codeblobs, worker_i);;
 }
 void G1RemSet::prepare_for_oops_into_collection_set_do() {
 _g1->set_refine_cte_cl_concurrency(false);
 DirtyCardQueueSet& dcqs = JavaThread::dirty_card_queue_set();
 ct_bs->index_for(ct_bs->addr_for(card_ptr)),
 p2i(ct_bs->addr_for(card_ptr)),
 g1->addr_to_region(ct_bs->addr_for(card_ptr)));
 #endif
 }
-G1UpdateRSOrPushRefOopClosure::G1UpdateRSOrPushRefOopClosure(G1CollectedHeap* g1h,
-G1ParPushHeapRSClosure* push_ref_cl,
-bool record_refs_into_cset,
-uint worker_i) :
-_g1(g1h),
-_from(NULL),
-_record_refs_into_cset(record_refs_into_cset),
-_has_refs_into_cset(false),
-_push_ref_cl(push_ref_cl),
-_worker_i(worker_i) { }
 void G1RemSet::refine_card_concurrently(jbyte* card_ptr,
 uint worker_i) {
 assert(!_g1->is_gc_active(), "Only call concurrently");
 _conc_refine_cards++;
 }
 }
 bool G1RemSet::refine_card_during_gc(jbyte* card_ptr,
-uint worker_i,
+G1ScanObjsDuringUpdateRSClosure* update_rs_cl) {
-G1ParPushHeapRSClosure*  oops_in_heap_closure) {
 assert(_g1->is_gc_active(), "Only call during GC");
 check_card_ptr(card_ptr, _ct_bs);
 // If the card is no longer dirty, nothing to do. This covers cards that were already
 // a card beyond the heap.
 HeapWord* card_end = card_start + CardTableModRefBS::card_size_in_words;
 MemRegion dirty_region(card_start, MIN2(scan_limit, card_end));
 assert(!dirty_region.is_empty(), "sanity");
-G1UpdateRSOrPushRefOopClosure update_rs_oop_cl(_g1,
+update_rs_cl->set_region(r);
-oops_in_heap_closure,
+update_rs_cl->reset_has_refs_into_cset();
-true,
-worker_i);
+bool card_processed = r->oops_on_card_seq_iterate_careful<true>(dirty_region, update_rs_cl);
-update_rs_oop_cl.set_from(r);
-bool card_processed =
-r->oops_on_card_seq_iterate_careful<true>(dirty_region,
-&update_rs_oop_cl);
 assert(card_processed, "must be");
 _conc_refine_cards++;
-return update_rs_oop_cl.has_refs_into_cset();
+return update_rs_cl->has_refs_into_cset();
 }
 void G1RemSet::print_periodic_summary_info(const char* header, uint period_count) {
 if ((G1SummarizeRSetStatsPeriod > 0) && log_is_enabled(Trace, gc, remset) &&
 (period_count % G1SummarizeRSetStatsPeriod == 0)) {

changeset 46572	fef0d64b2263
parent 46571	c70b36f0730d
child 46575	d6fb8a7a7843