truffle: src/share/vm/gc_implementation/g1/concurrentMark.cpp comparison

comparison src/share/vm/gc_implementation/g1/concurrentMark.cpp @ 4097:dc467e8b2c5e

7112743: G1: Reduce overhead of marking closure during evacuation pauses Summary: Parallelize the serial code that was used to mark objects reachable from survivor objects in the collection set. Some minor improvments in the timers used to track the freeing of the collection set along with some tweaks to PrintGCDetails. Reviewed-by: tonyp, brutisso

author	johnc
date	Thu, 17 Nov 2011 12:40:15 -0800
parents	bca17e38de00
children	adedfbbf0360

comparison

equal deleted inserted replaced

-:00dd86e542eb
+:dc467e8b2c5e
 gclog_or_tty->print_cr("---------------------------------------------------------------------");
 }
 }
 }
-class CSMarkOopClosure: public OopClosure {
+// Closures used by ConcurrentMark::complete_marking_in_collection_set().
-friend class CSMarkBitMapClosure;
+class CSetMarkOopClosure: public OopClosure {
+friend class CSetMarkBitMapClosure;
 G1CollectedHeap* _g1h;
 CMBitMap*        _bm;
 ConcurrentMark*  _cm;
 oop*             _ms;
 jint*            _array_ind_stack;
 int              _ms_size;
 int              _ms_ind;
 int              _array_increment;
+int              _worker_i;
 bool push(oop obj, int arr_ind = 0) {
 if (_ms_ind == _ms_size) {
 gclog_or_tty->print_cr("Mark stack is full.");
 return false;
 // Now process this portion of this one.
 int lim = MIN2(next_arr_ind, len);
 for (int j = arr_ind; j < lim; j++) {
 do_oop(aobj->objArrayOopDesc::obj_at_addr<T>(j));
 }
 } else {
 obj->oop_iterate(this);
 }
 if (abort()) return false;
 }
 return true;
 }
 public:
-CSMarkOopClosure(ConcurrentMark* cm, int ms_size) :
+CSetMarkOopClosure(ConcurrentMark* cm, int ms_size, int worker_i) :
 _g1h(G1CollectedHeap::heap()),
 _cm(cm),
 _bm(cm->nextMarkBitMap()),
 _ms_size(ms_size), _ms_ind(0),
 _ms(NEW_C_HEAP_ARRAY(oop, ms_size)),
 _array_ind_stack(NEW_C_HEAP_ARRAY(jint, ms_size)),
-_array_increment(MAX2(ms_size/8, 16))
+_array_increment(MAX2(ms_size/8, 16)),
-{}
+_worker_i(worker_i) { }
-~CSMarkOopClosure() {
+~CSetMarkOopClosure() {
 FREE_C_HEAP_ARRAY(oop, _ms);
 FREE_C_HEAP_ARRAY(jint, _array_ind_stack);
 }
 virtual void do_oop(narrowOop* p) { do_oop_work(p); }
 }
 HeapRegion* hr = _g1h->heap_region_containing(obj);
 if (hr != NULL) {
 if (hr->in_collection_set()) {
 if (_g1h->is_obj_ill(obj)) {
-_bm->mark((HeapWord*)obj);
+if (_bm->parMark((HeapWord*)obj)) {
 if (!push(obj)) {
-gclog_or_tty->print_cr("Setting abort in CSMarkOopClosure because push failed.");
+gclog_or_tty->print_cr("Setting abort in CSetMarkOopClosure because push failed.");
 set_abort();
+}
 }
 }
 } else {
 // Outside the collection set; we need to gray it
 _cm->deal_with_reference(obj);
 }
 }
 }
 };
-class CSMarkBitMapClosure: public BitMapClosure {
+class CSetMarkBitMapClosure: public BitMapClosure {
-G1CollectedHeap* _g1h;
+G1CollectedHeap*   _g1h;
-CMBitMap*        _bitMap;
+CMBitMap*          _bitMap;
-ConcurrentMark*  _cm;
+ConcurrentMark*    _cm;
-CSMarkOopClosure _oop_cl;
+CSetMarkOopClosure _oop_cl;
+int                _worker_i;
 public:
-CSMarkBitMapClosure(ConcurrentMark* cm, int ms_size) :
+CSetMarkBitMapClosure(ConcurrentMark* cm, int ms_size, int worker_i) :
 _g1h(G1CollectedHeap::heap()),
 _bitMap(cm->nextMarkBitMap()),
-_oop_cl(cm, ms_size)
+_oop_cl(cm, ms_size, worker_i),
-{}
+_worker_i(worker_i) { }
-~CSMarkBitMapClosure() {}
 bool do_bit(size_t offset) {
 // convert offset into a HeapWord*
 HeapWord* addr = _bitMap->offsetToHeapWord(offset);
 assert(_bitMap->endWord() && addr < _bitMap->endWord(),
 // Otherwise...
 return true;
 }
 };
+class CompleteMarkingInCSetHRClosure: public HeapRegionClosure {
-class CompleteMarkingInCSHRClosure: public HeapRegionClosure {
+CMBitMap*             _bm;
-CMBitMap* _bm;
+CSetMarkBitMapClosure _bit_cl;
-CSMarkBitMapClosure _bit_cl;
+int                   _worker_i;
 enum SomePrivateConstants {
 MSSize = 1000
 };
-bool _completed;
 public:
-CompleteMarkingInCSHRClosure(ConcurrentMark* cm) :
+CompleteMarkingInCSetHRClosure(ConcurrentMark* cm, int worker_i) :
 _bm(cm->nextMarkBitMap()),
-_bit_cl(cm, MSSize),
+_bit_cl(cm, MSSize, worker_i),
-_completed(true)
+_worker_i(worker_i) { }
-{}
+bool doHeapRegion(HeapRegion* hr) {
-~CompleteMarkingInCSHRClosure() {}
+if (hr->claimHeapRegion(HeapRegion::CompleteMarkCSetClaimValue)) {
+// The current worker has successfully claimed the region.
-bool doHeapRegion(HeapRegion* r) {
+if (!hr->evacuation_failed()) {
-if (!r->evacuation_failed()) {
+MemRegion mr = MemRegion(hr->bottom(), hr->next_top_at_mark_start());
-MemRegion mr = MemRegion(r->bottom(), r->next_top_at_mark_start());
+if (!mr.is_empty()) {
-if (!mr.is_empty()) {
+bool done = false;
-if (!_bm->iterate(&_bit_cl, mr)) {
+while (!done) {
-_completed = false;
+done = _bm->iterate(&_bit_cl, mr);
-return true;
+}
 }
 }
 }
 return false;
 }
-bool completed() { return _completed; }
 };
-class ClearMarksInHRClosure: public HeapRegionClosure {
+class SetClaimValuesInCSetHRClosure: public HeapRegionClosure {
-CMBitMap* _bm;
+jint _claim_value;
 public:
-ClearMarksInHRClosure(CMBitMap* bm): _bm(bm) { }
+SetClaimValuesInCSetHRClosure(jint claim_value) :
+_claim_value(claim_value) { }
-bool doHeapRegion(HeapRegion* r) {
-if (!r->used_region().is_empty() && !r->evacuation_failed()) {
+bool doHeapRegion(HeapRegion* hr) {
-MemRegion usedMR = r->used_region();
+hr->set_claim_value(_claim_value);
-_bm->clearRange(r->used_region());
-}
 return false;
+}
+};
+class G1ParCompleteMarkInCSetTask: public AbstractGangTask {
+protected:
+G1CollectedHeap* _g1h;
+ConcurrentMark*  _cm;
+public:
+G1ParCompleteMarkInCSetTask(G1CollectedHeap* g1h,
+ConcurrentMark* cm) :
+AbstractGangTask("Complete Mark in CSet"),
+_g1h(g1h), _cm(cm) { }
+void work(int worker_i) {
+CompleteMarkingInCSetHRClosure cmplt(_cm, worker_i);
+HeapRegion* hr = _g1h->start_cset_region_for_worker(worker_i);
+_g1h->collection_set_iterate_from(hr, &cmplt);
 }
 };
 void ConcurrentMark::complete_marking_in_collection_set() {
 G1CollectedHeap* g1h =  G1CollectedHeap::heap();
 if (!g1h->mark_in_progress()) {
 g1h->g1_policy()->record_mark_closure_time(0.0);
 return;
 }
-int i = 1;
 double start = os::elapsedTime();
-while (true) {
+int n_workers = g1h->workers()->total_workers();
-i++;
-CompleteMarkingInCSHRClosure cmplt(this);
+G1ParCompleteMarkInCSetTask complete_mark_task(g1h, this);
-g1h->collection_set_iterate(&cmplt);
-if (cmplt.completed()) break;
+assert(g1h->check_cset_heap_region_claim_values(HeapRegion::InitialClaimValue), "sanity");
-}
+if (G1CollectedHeap::use_parallel_gc_threads()) {
-ClearMarksInHRClosure clr(nextMarkBitMap());
+g1h->set_par_threads(n_workers);
-g1h->collection_set_iterate(&clr);
+g1h->workers()->run_task(&complete_mark_task);
+g1h->set_par_threads(0);
+} else {
+complete_mark_task.work(0);
+}
+assert(g1h->check_cset_heap_region_claim_values(HeapRegion::CompleteMarkCSetClaimValue), "sanity");
+// Now reset the claim values in the regions in the collection set.
+SetClaimValuesInCSetHRClosure set_cv_cl(HeapRegion::InitialClaimValue);
+g1h->collection_set_iterate(&set_cv_cl);
+assert(g1h->check_cset_heap_region_claim_values(HeapRegion::InitialClaimValue), "sanity");
 double end_time = os::elapsedTime();
 double elapsed_time_ms = (end_time - start) * 1000.0;
 g1h->g1_policy()->record_mark_closure_time(elapsed_time_ms);
 }

Mercurial > hg > truffle

comparison src/share/vm/gc_implementation/g1/concurrentMark.cpp @ 4097:dc467e8b2c5e