graal-jvmci-8: src/share/vm/gc_implementation/g1/concurrentMark.cpp comparison

comparison src/share/vm/gc_implementation/g1/concurrentMark.cpp @ 5988:2a0172480595

7127697: G1: remove dead code after recent concurrent mark changes Summary: Removed lots of dead code after some recent conc mark changes. Reviewed-by: brutisso, johnc

author	tonyp
date	Thu, 05 Apr 2012 13:57:23 -0400
parents	eff609af17d7
children	5c86f8211d1e

comparison

equal deleted inserted replaced

-:748051fd24ce
+:2a0172480595
 int CMBitMapRO::heapWordDiffToOffsetDiff(size_t diff) const {
 assert((diff & ((1 << _shifter) - 1)) == 0, "argument check");
 return (int) (diff >> _shifter);
 }
-void CMBitMapRO::mostly_disjoint_range_union(BitMap*   from_bitmap,
-size_t    from_start_index,
-HeapWord* to_start_word,
-size_t    word_num) {
-_bm.mostly_disjoint_range_union(from_bitmap,
-from_start_index,
-heapWordToOffset(to_start_word),
-word_num);
-}
 #ifndef PRODUCT
 bool CMBitMapRO::covers(ReservedSpace rs) const {
 // assert(_bm.map() == _virtual_space.low(), "map inconsistency");
 assert(((size_t)_bm.size() * (size_t)(1 << _shifter)) == _bmWordSize,
 "size inconsistency");
 }
 _index = new_ind;
 *n = k;
 return true;
 }
-}
-CMRegionStack::CMRegionStack() : _base(NULL) {}
-void CMRegionStack::allocate(size_t size) {
-_base = NEW_C_HEAP_ARRAY(MemRegion, size);
-if (_base == NULL) {
-vm_exit_during_initialization("Failed to allocate CM region mark stack");
-}
-_index = 0;
-_capacity = (jint) size;
-}
-CMRegionStack::~CMRegionStack() {
-if (_base != NULL) {
-FREE_C_HEAP_ARRAY(oop, _base);
-}
-}
-void CMRegionStack::push_lock_free(MemRegion mr) {
-guarantee(false, "push_lock_free(): don't call this any more");
-assert(mr.word_size() > 0, "Precondition");
-while (true) {
-jint index = _index;
-if (index >= _capacity) {
-_overflow = true;
-return;
-}
-// Otherwise...
-jint next_index = index+1;
-jint res = Atomic::cmpxchg(next_index, &_index, index);
-if (res == index) {
-_base[index] = mr;
-return;
-}
-// Otherwise, we need to try again.
-}
-}
-// Lock-free pop of the region stack. Called during the concurrent
-// marking / remark phases. Should only be called in tandem with
-// other lock-free pops.
-MemRegion CMRegionStack::pop_lock_free() {
-guarantee(false, "pop_lock_free(): don't call this any more");
-while (true) {
-jint index = _index;
-if (index == 0) {
-return MemRegion();
-}
-// Otherwise...
-jint next_index = index-1;
-jint res = Atomic::cmpxchg(next_index, &_index, index);
-if (res == index) {
-MemRegion mr = _base[next_index];
-if (mr.start() != NULL) {
-assert(mr.end() != NULL, "invariant");
-assert(mr.word_size() > 0, "invariant");
-return mr;
-} else {
-// that entry was invalidated... let's skip it
-assert(mr.end() == NULL, "invariant");
-}
-}
-// Otherwise, we need to try again.
-}
-}
-#if 0
-// The routines that manipulate the region stack with a lock are
-// not currently used. They should be retained, however, as a
-// diagnostic aid.
-void CMRegionStack::push_with_lock(MemRegion mr) {
-assert(mr.word_size() > 0, "Precondition");
-MutexLockerEx x(CMRegionStack_lock, Mutex::_no_safepoint_check_flag);
-if (isFull()) {
-_overflow = true;
-return;
-}
-_base[_index] = mr;
-_index += 1;
-}
-MemRegion CMRegionStack::pop_with_lock() {
-MutexLockerEx x(CMRegionStack_lock, Mutex::_no_safepoint_check_flag);
-while (true) {
-if (_index == 0) {
-return MemRegion();
-}
-_index -= 1;
-MemRegion mr = _base[_index];
-if (mr.start() != NULL) {
-assert(mr.end() != NULL, "invariant");
-assert(mr.word_size() > 0, "invariant");
-return mr;
-} else {
-// that entry was invalidated... let's skip it
-assert(mr.end() == NULL, "invariant");
-}
-}
-}
-#endif
-bool CMRegionStack::invalidate_entries_into_cset() {
-guarantee(false, "invalidate_entries_into_cset(): don't call this any more");
-bool result = false;
-G1CollectedHeap* g1h = G1CollectedHeap::heap();
-for (int i = 0; i < _oops_do_bound; ++i) {
-MemRegion mr = _base[i];
-if (mr.start() != NULL) {
-assert(mr.end() != NULL, "invariant");
-assert(mr.word_size() > 0, "invariant");
-HeapRegion* hr = g1h->heap_region_containing(mr.start());
-assert(hr != NULL, "invariant");
-if (hr->in_collection_set()) {
-// The region points into the collection set
-_base[i] = MemRegion();
-result = true;
-}
-} else {
-// that entry was invalidated... let's skip it
-assert(mr.end() == NULL, "invariant");
-}
-}
-return result;
 }
 template<class OopClosureClass>
 bool CMMarkStack::drain(OopClosureClass* cl, CMBitMap* bm, bool yield_after) {
 assert(!_drain_in_progress || !_drain_in_progress_yields || yield_after
 CardTableModRefBS::card_shift,
 false /* in_resource_area*/),
 _prevMarkBitMap(&_markBitMap1),
 _nextMarkBitMap(&_markBitMap2),
-_at_least_one_mark_complete(false),
 _markStack(this),
-_regionStack(),
 // _finger set in set_non_marking_state
 _max_task_num(MAX2((uint)ParallelGCThreads, 1U)),
 // _active_tasks set in set_non_marking_state
 // _tasks set inside the constructor
 _has_overflown(false),
 _concurrent(false),
 _has_aborted(false),
 _restart_for_overflow(false),
 _concurrent_marking_in_progress(false),
-_should_gray_objects(false),
 // _verbose_level set below
 _init_times(),
 _remark_times(), _remark_mark_times(), _remark_weak_ref_times(),
 gclog_or_tty->print_cr("[global] init, heap start = "PTR_FORMAT", "
 "heap end = "PTR_FORMAT, _heap_start, _heap_end);
 }
 _markStack.allocate(MarkStackSize);
-_regionStack.allocate(G1MarkRegionStackSize);
 // Create & start a ConcurrentMark thread.
 _cmThread = new ConcurrentMarkThread(this);
 assert(cmThread() != NULL, "CM Thread should have been created");
 assert(cmThread()->cm() != NULL, "CM Thread should refer to this cm");
 set_non_marking_state();
 }
 void ConcurrentMark::update_g1_committed(bool force) {
 // If concurrent marking is not in progress, then we do not need to
-// update _heap_end. This has a subtle and important
+// update _heap_end.
-// side-effect. Imagine that two evacuation pauses happen between
-// marking completion and remark. The first one can grow the
-// heap (hence now the finger is below the heap end). Then, the
-// second one could unnecessarily push regions on the region
-// stack. This causes the invariant that the region stack is empty
-// at the beginning of remark to be false. By ensuring that we do
-// not observe heap expansions after marking is complete, then we do
-// not have this problem.
 if (!concurrent_marking_in_progress() && !force) return;
 MemRegion committed = _g1h->g1_committed();
 assert(committed.start() == _heap_start, "start shouldn't change");
 HeapWord* new_end = committed.end();
 } else {
 return false;
 }
 }
 #endif // !PRODUCT
-void ConcurrentMark::grayRegionIfNecessary(MemRegion mr) {
-guarantee(false, "grayRegionIfNecessary(): don't call this any more");
-// The objects on the region have already been marked "in bulk" by
-// the caller. We only need to decide whether to push the region on
-// the region stack or not.
-if (!concurrent_marking_in_progress() || !_should_gray_objects) {
-// We're done with marking and waiting for remark. We do not need to
-// push anything else on the region stack.
-return;
-}
-HeapWord* finger = _finger;
-if (verbose_low()) {
-gclog_or_tty->print_cr("[global] attempting to push "
-"region ["PTR_FORMAT", "PTR_FORMAT"), finger is at "
-PTR_FORMAT, mr.start(), mr.end(), finger);
-}
-if (mr.start() < finger) {
-// The finger is always heap region aligned and it is not possible
-// for mr to span heap regions.
-assert(mr.end() <= finger, "invariant");
-// Separated the asserts so that we know which one fires.
-assert(mr.start() <= mr.end(),
-"region boundaries should fall within the committed space");
-assert(_heap_start <= mr.start(),
-"region boundaries should fall within the committed space");
-assert(mr.end() <= _heap_end,
-"region boundaries should fall within the committed space");
-if (verbose_low()) {
-gclog_or_tty->print_cr("[global] region ["PTR_FORMAT", "PTR_FORMAT") "
-"below the finger, pushing it",
-mr.start(), mr.end());
-}
-if (!region_stack_push_lock_free(mr)) {
-if (verbose_low()) {
-gclog_or_tty->print_cr("[global] region stack has overflown.");
-}
-}
-}
-}
-void ConcurrentMark::markAndGrayObjectIfNecessary(oop p) {
-guarantee(false, "markAndGrayObjectIfNecessary(): don't call this any more");
-// The object is not marked by the caller. We need to at least mark
-// it and maybe push in on the stack.
-HeapWord* addr = (HeapWord*)p;
-if (!_nextMarkBitMap->isMarked(addr)) {
-// We definitely need to mark it, irrespective whether we bail out
-// because we're done with marking.
-if (_nextMarkBitMap->parMark(addr)) {
-if (!concurrent_marking_in_progress() || !_should_gray_objects) {
-// If we're done with concurrent marking and we're waiting for
-// remark, then we're not pushing anything on the stack.
-return;
-}
-// No OrderAccess:store_load() is needed. It is implicit in the
-// CAS done in parMark(addr) above
-HeapWord* finger = _finger;
-if (addr < finger) {
-if (!mark_stack_push(oop(addr))) {
-if (verbose_low()) {
-gclog_or_tty->print_cr("[global] global stack overflow "
-"during parMark");
-}
-}
-}
-}
-}
-}
 class CMConcurrentMarkingTask: public AbstractGangTask {
 private:
 ConcurrentMark*       _cm;
 ConcurrentMarkThread* _cmt;
 size_t known_garbage_bytes =
 g1_par_count_task.used_bytes() - g1_par_count_task.live_bytes();
 g1p->set_known_garbage_bytes(known_garbage_bytes);
 size_t start_used_bytes = g1h->used();
-_at_least_one_mark_complete = true;
 g1h->set_marking_complete();
 ergo_verbose4(ErgoConcCycles,
 "finish cleanup",
 ergo_format_byte("occupancy")
 gclog_or_tty->print_cr("  done");
 gclog_or_tty->flush();
 }
 #endif // PRODUCT
-// This note is for drainAllSATBBuffers and the code in between.
-// In the future we could reuse a task to do this work during an
-// evacuation pause (since now tasks are not active and can be claimed
-// during an evacuation pause). This was a late change to the code and
-// is currently not being taken advantage of.
-void ConcurrentMark::deal_with_reference(oop obj) {
-if (verbose_high()) {
-gclog_or_tty->print_cr("[global] we're dealing with reference "PTR_FORMAT,
-(void*) obj);
-}
-HeapWord* objAddr = (HeapWord*) obj;
-assert(obj->is_oop_or_null(true /* ignore mark word */), "Error");
-if (_g1h->is_in_g1_reserved(objAddr)) {
-assert(obj != NULL, "null check is implicit");
-if (!_nextMarkBitMap->isMarked(objAddr)) {
-// Only get the containing region if the object is not marked on the
-// bitmap (otherwise, it's a waste of time since we won't do
-// anything with it).
-HeapRegion* hr = _g1h->heap_region_containing_raw(obj);
-if (!hr->obj_allocated_since_next_marking(obj)) {
-if (verbose_high()) {
-gclog_or_tty->print_cr("[global] "PTR_FORMAT" is not considered "
-"marked", (void*) obj);
-}
-// we need to mark it first
-if (_nextMarkBitMap->parMark(objAddr)) {
-// No OrderAccess:store_load() is needed. It is implicit in the
-// CAS done in parMark(objAddr) above
-HeapWord* finger = _finger;
-if (objAddr < finger) {
-if (verbose_high()) {
-gclog_or_tty->print_cr("[global] below the global finger "
-"("PTR_FORMAT"), pushing it", finger);
-}
-if (!mark_stack_push(obj)) {
-if (verbose_low()) {
-gclog_or_tty->print_cr("[global] global stack overflow during "
-"deal_with_reference");
-}
-}
-}
-}
-}
-}
-}
-}
-class CMGlobalObjectClosure : public ObjectClosure {
-private:
-ConcurrentMark* _cm;
-public:
-void do_object(oop obj) {
-_cm->deal_with_reference(obj);
-}
-CMGlobalObjectClosure(ConcurrentMark* cm) : _cm(cm) { }
-};
-void ConcurrentMark::drainAllSATBBuffers() {
-guarantee(false, "drainAllSATBBuffers(): don't call this any more");
-CMGlobalObjectClosure oc(this);
-SATBMarkQueueSet& satb_mq_set = JavaThread::satb_mark_queue_set();
-satb_mq_set.set_closure(&oc);
-while (satb_mq_set.apply_closure_to_completed_buffer()) {
-if (verbose_medium()) {
-gclog_or_tty->print_cr("[global] processed an SATB buffer");
-}
-}
-// no need to check whether we should do this, as this is only
-// called during an evacuation pause
-satb_mq_set.iterate_closure_all_threads();
-satb_mq_set.set_closure(NULL);
-assert(satb_mq_set.completed_buffers_num() == 0, "invariant");
-}
 void ConcurrentMark::clearRangePrevBitmap(MemRegion mr) {
 // Note we are overriding the read-only view of the prev map here, via
 // the cast.
 ((CMBitMap*)_prevMarkBitMap)->clearRange(mr);
 }
 return NULL;
 }
-bool ConcurrentMark::invalidate_aborted_regions_in_cset() {
-guarantee(false, "invalidate_aborted_regions_in_cset(): "
-"don't call this any more");
-bool result = false;
-for (int i = 0; i < (int)_max_task_num; ++i) {
-CMTask* the_task = _tasks[i];
-MemRegion mr = the_task->aborted_region();
-if (mr.start() != NULL) {
-assert(mr.end() != NULL, "invariant");
-assert(mr.word_size() > 0, "invariant");
-HeapRegion* hr = _g1h->heap_region_containing(mr.start());
-assert(hr != NULL, "invariant");
-if (hr->in_collection_set()) {
-// The region points into the collection set
-the_task->set_aborted_region(MemRegion());
-result = true;
-}
-}
-}
-return result;
-}
-bool ConcurrentMark::has_aborted_regions() {
-for (int i = 0; i < (int)_max_task_num; ++i) {
-CMTask* the_task = _tasks[i];
-MemRegion mr = the_task->aborted_region();
-if (mr.start() != NULL) {
-assert(mr.end() != NULL, "invariant");
-assert(mr.word_size() > 0, "invariant");
-return true;
-}
-}
-return false;
-}
-void ConcurrentMark::oops_do(OopClosure* cl) {
-if (_markStack.size() > 0 && verbose_low()) {
-gclog_or_tty->print_cr("[global] scanning the global marking stack, "
-"size = %d", _markStack.size());
-}
-// we first iterate over the contents of the mark stack...
-_markStack.oops_do(cl);
-for (int i = 0; i < (int)_max_task_num; ++i) {
-OopTaskQueue* queue = _task_queues->queue((int)i);
-if (queue->size() > 0 && verbose_low()) {
-gclog_or_tty->print_cr("[global] scanning task queue of task %d, "
-"size = %d", i, queue->size());
-}
-// ...then over the contents of the all the task queues.
-queue->oops_do(cl);
-}
-}
 #ifndef PRODUCT
 enum VerifyNoCSetOopsPhase {
 VerifyNoCSetOopsStack,
 VerifyNoCSetOopsQueues,
 VerifyNoCSetOopsSATBCompleted,
 #endif // PRODUCT
 void ConcurrentMark::clear_marking_state(bool clear_overflow) {
 _markStack.setEmpty();
 _markStack.clear_overflow();
-_regionStack.setEmpty();
-_regionStack.clear_overflow();
 if (clear_overflow) {
 clear_has_overflown();
 } else {
 assert(has_overflown(), "pre-condition");
 }
 _finger = _heap_start;
 for (int i = 0; i < (int)_max_task_num; ++i) {
 OopTaskQueue* queue = _task_queues->queue(i);
 queue->set_empty();
-// Clear any partial regions from the CMTasks
-_tasks[i]->clear_aborted_region();
 }
 }
 // Aggregate the counting data that was constructed concurrently
 // with marking.
 if (verbose_stats()) {
 gclog_or_tty->print_cr("---------------------------------------------------------------------");
 for (size_t i = 0; i < _active_tasks; ++i) {
 _tasks[i]->print_stats();
 gclog_or_tty->print_cr("---------------------------------------------------------------------");
-}
-}
-}
-// Closures used by ConcurrentMark::complete_marking_in_collection_set().
-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;
-uint             _worker_id;
-bool push(oop obj, int arr_ind = 0) {
-if (_ms_ind == _ms_size) {
-gclog_or_tty->print_cr("Mark stack is full.");
-return false;
-}
-_ms[_ms_ind] = obj;
-if (obj->is_objArray()) {
-_array_ind_stack[_ms_ind] = arr_ind;
-}
-_ms_ind++;
-return true;
-}
-oop pop() {
-if (_ms_ind == 0) {
-return NULL;
-} else {
-_ms_ind--;
-return _ms[_ms_ind];
-}
-}
-template <class T> bool drain() {
-while (_ms_ind > 0) {
-oop obj = pop();
-assert(obj != NULL, "Since index was non-zero.");
-if (obj->is_objArray()) {
-jint arr_ind = _array_ind_stack[_ms_ind];
-objArrayOop aobj = objArrayOop(obj);
-jint len = aobj->length();
-jint next_arr_ind = arr_ind + _array_increment;
-if (next_arr_ind < len) {
-push(obj, next_arr_ind);
-}
-// 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:
-CSetMarkOopClosure(ConcurrentMark* cm, int ms_size, uint worker_id) :
-_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)),
-_worker_id(worker_id) { }
-~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); }
-virtual void do_oop(      oop* p) { do_oop_work(p); }
-template <class T> void do_oop_work(T* p) {
-T heap_oop = oopDesc::load_heap_oop(p);
-if (oopDesc::is_null(heap_oop)) return;
-oop obj = oopDesc::decode_heap_oop_not_null(heap_oop);
-if (obj->is_forwarded()) {
-// If the object has already been forwarded, we have to make sure
-// that it's marked.  So follow the forwarding pointer.  Note that
-// this does the right thing for self-forwarding pointers in the
-// evacuation failure case.
-obj = obj->forwardee();
-}
-HeapRegion* hr = _g1h->heap_region_containing(obj);
-if (hr != NULL) {
-if (hr->in_collection_set()) {
-if (_g1h->is_obj_ill(obj)) {
-if (_bm->parMark((HeapWord*)obj)) {
-if (!push(obj)) {
-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 CSetMarkBitMapClosure: public BitMapClosure {
-G1CollectedHeap*   _g1h;
-CMBitMap*          _bitMap;
-ConcurrentMark*    _cm;
-CSetMarkOopClosure _oop_cl;
-uint               _worker_id;
-public:
-CSetMarkBitMapClosure(ConcurrentMark* cm, int ms_size, int worker_id) :
-_g1h(G1CollectedHeap::heap()),
-_bitMap(cm->nextMarkBitMap()),
-_oop_cl(cm, ms_size, worker_id),
-_worker_id(worker_id) { }
-bool do_bit(size_t offset) {
-// convert offset into a HeapWord*
-HeapWord* addr = _bitMap->offsetToHeapWord(offset);
-assert(_bitMap->endWord() && addr < _bitMap->endWord(),
-"address out of range");
-assert(_bitMap->isMarked(addr), "tautology");
-oop obj = oop(addr);
-if (!obj->is_forwarded()) {
-if (!_oop_cl.push(obj)) return false;
-if (UseCompressedOops) {
-if (!_oop_cl.drain<narrowOop>()) return false;
-} else {
-if (!_oop_cl.drain<oop>()) return false;
-}
-}
-// Otherwise...
-return true;
-}
-};
-class CompleteMarkingInCSetHRClosure: public HeapRegionClosure {
-CMBitMap*             _bm;
-CSetMarkBitMapClosure _bit_cl;
-uint                  _worker_id;
-enum SomePrivateConstants {
-MSSize = 1000
-};
-public:
-CompleteMarkingInCSetHRClosure(ConcurrentMark* cm, int worker_id) :
-_bm(cm->nextMarkBitMap()),
-_bit_cl(cm, MSSize, worker_id),
-_worker_id(worker_id) { }
-bool doHeapRegion(HeapRegion* hr) {
-if (hr->claimHeapRegion(HeapRegion::CompleteMarkCSetClaimValue)) {
-// The current worker has successfully claimed the region.
-if (!hr->evacuation_failed()) {
-MemRegion mr = MemRegion(hr->bottom(), hr->next_top_at_mark_start());
-if (!mr.is_empty()) {
-bool done = false;
-while (!done) {
-done = _bm->iterate(&_bit_cl, mr);
-}
-}
-}
-}
-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(uint worker_id) {
-CompleteMarkingInCSetHRClosure cmplt(_cm, worker_id);
-HeapRegion* hr = _g1h->start_cset_region_for_worker(worker_id);
-_g1h->collection_set_iterate_from(hr, &cmplt);
-}
-};
-void ConcurrentMark::complete_marking_in_collection_set() {
-guarantee(false, "complete_marking_in_collection_set(): "
-"don't call this any more");
-G1CollectedHeap* g1h =  G1CollectedHeap::heap();
-if (!g1h->mark_in_progress()) {
-g1h->g1_policy()->record_mark_closure_time(0.0);
-return;
-}
-double start = os::elapsedTime();
-G1ParCompleteMarkInCSetTask complete_mark_task(g1h, this);
-assert(g1h->check_cset_heap_region_claim_values(HeapRegion::InitialClaimValue), "sanity");
-if (G1CollectedHeap::use_parallel_gc_threads()) {
-int n_workers = g1h->workers()->active_workers();
-g1h->set_par_threads(n_workers);
-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");
-// Reset the claim values in the regions in the collection set.
-g1h->reset_cset_heap_region_claim_values();
-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);
-}
-// The next two methods deal with the following optimisation. Some
-// objects are gray by being marked and located above the finger. If
-// they are copied, during an evacuation pause, below the finger then
-// the need to be pushed on the stack. The observation is that, if
-// there are no regions in the collection set located above the
-// finger, then the above cannot happen, hence we do not need to
-// explicitly gray any objects when copying them to below the
-// finger. The global stack will be scanned to ensure that, if it
-// points to objects being copied, it will update their
-// location. There is a tricky situation with the gray objects in
-// region stack that are being coped, however. See the comment in
-// newCSet().
-void ConcurrentMark::newCSet() {
-guarantee(false, "newCSet(): don't call this any more");
-if (!concurrent_marking_in_progress()) {
-// nothing to do if marking is not in progress
-return;
-}
-// find what the lowest finger is among the global and local fingers
-_min_finger = _finger;
-for (int i = 0; i < (int)_max_task_num; ++i) {
-CMTask* task = _tasks[i];
-HeapWord* task_finger = task->finger();
-if (task_finger != NULL && task_finger < _min_finger) {
-_min_finger = task_finger;
-}
-}
-_should_gray_objects = false;
-// This fixes a very subtle and fustrating bug. It might be the case
-// that, during en evacuation pause, heap regions that contain
-// objects that are gray (by being in regions contained in the
-// region stack) are included in the collection set. Since such gray
-// objects will be moved, and because it's not easy to redirect
-// region stack entries to point to a new location (because objects
-// in one region might be scattered to multiple regions after they
-// are copied), one option is to ensure that all marked objects
-// copied during a pause are pushed on the stack. Notice, however,
-// that this problem can only happen when the region stack is not
-// empty during an evacuation pause. So, we make the fix a bit less
-// conservative and ensure that regions are pushed on the stack,
-// irrespective whether all collection set regions are below the
-// finger, if the region stack is not empty. This is expected to be
-// a rare case, so I don't think it's necessary to be smarted about it.
-if (!region_stack_empty() || has_aborted_regions()) {
-_should_gray_objects = true;
-}
-}
-void ConcurrentMark::registerCSetRegion(HeapRegion* hr) {
-guarantee(false, "registerCSetRegion(): don't call this any more");
-if (!concurrent_marking_in_progress()) return;
-HeapWord* region_end = hr->end();
-if (region_end > _min_finger) {
-_should_gray_objects = true;
-}
-}
-// Resets the region fields of active CMTasks whose values point
-// into the collection set.
-void ConcurrentMark::reset_active_task_region_fields_in_cset() {
-guarantee(false, "reset_active_task_region_fields_in_cset(): "
-"don't call this any more");
-assert(SafepointSynchronize::is_at_safepoint(), "should be in STW");
-assert(parallel_marking_threads() <= _max_task_num, "sanity");
-for (int i = 0; i < (int)parallel_marking_threads(); i += 1) {
-CMTask* task = _tasks[i];
-HeapWord* task_finger = task->finger();
-if (task_finger != NULL) {
-assert(_g1h->is_in_g1_reserved(task_finger), "not in heap");
-HeapRegion* finger_region = _g1h->heap_region_containing(task_finger);
-if (finger_region->in_collection_set()) {
-// The task's current region is in the collection set.
-// This region will be evacuated in the current GC and
-// the region fields in the task will be stale.
-task->giveup_current_region();
-}
 }
 }
 }
 // abandon current marking iteration due to a Full GC
 private:
 // the bitmap that is being iterated over
 CMBitMap*                   _nextMarkBitMap;
 ConcurrentMark*             _cm;
 CMTask*                     _task;
-// true if we're scanning a heap region claimed by the task (so that
-// we move the finger along), false if we're not, i.e. currently when
-// scanning a heap region popped from the region stack (so that we
-// do not move the task finger along; it'd be a mistake if we did so).
-bool                        _scanning_heap_region;
 public:
-CMBitMapClosure(CMTask *task,
+CMBitMapClosure(CMTask *task, ConcurrentMark* cm, CMBitMap* nextMarkBitMap) :
-ConcurrentMark* cm,
+_task(task), _cm(cm), _nextMarkBitMap(nextMarkBitMap) { }
-CMBitMap* nextMarkBitMap)
-:  _task(task), _cm(cm), _nextMarkBitMap(nextMarkBitMap) { }
-void set_scanning_heap_region(bool scanning_heap_region) {
-_scanning_heap_region = scanning_heap_region;
-}
 bool do_bit(size_t offset) {
 HeapWord* addr = _nextMarkBitMap->offsetToHeapWord(offset);
 assert(_nextMarkBitMap->isMarked(addr), "invariant");
 assert( addr < _cm->finger(), "invariant");
-if (_scanning_heap_region) {
+statsOnly( _task->increase_objs_found_on_bitmap() );
-statsOnly( _task->increase_objs_found_on_bitmap() );
+assert(addr >= _task->finger(), "invariant");
-assert(addr >= _task->finger(), "invariant");
 // We move that task's local finger along.
 _task->move_finger_to(addr);
-} else {
-// We move the task's region finger along.
-_task->move_region_finger_to(addr);
-}
 _task->scan_object(oop(addr));
 // we only partially drain the local queue and global stack
 _task->drain_local_queue(true);
 _task->drain_global_stack(true);
 // Values for these three fields that indicate that we're not
 // holding on to a region.
 _curr_region   = NULL;
 _finger        = NULL;
 _region_limit  = NULL;
-_region_finger = NULL;
 }
 void CMTask::set_cm_oop_closure(G1CMOopClosure* cm_oop_closure) {
 if (cm_oop_closure == NULL) {
 assert(_cm_oop_closure != NULL, "invariant");
 gclog_or_tty->print_cr("[%d] resetting", _task_id);
 }
 _nextMarkBitMap                = nextMarkBitMap;
 clear_region_fields();
-assert(_aborted_region.is_empty(), "should have been cleared");
 _calls                         = 0;
 _elapsed_time_ms               = 0.0;
 _termination_time_ms           = 0.0;
 _termination_start_time_ms     = 0.0;
 _global_pushes                 = 0;
 _global_pops                   = 0;
 _global_max_size               = 0;
 _global_transfers_to           = 0;
 _global_transfers_from         = 0;
-_region_stack_pops             = 0;
 _regions_claimed               = 0;
 _objs_found_on_bitmap          = 0;
 _satb_buffers_processed        = 0;
 _steal_attempts                = 0;
 _steals                        = 0;
 }
 // again, this was a potentially expensive operation, decrease the
 // limits to get the regular clock call early
 decrease_limits();
-}
-void CMTask::drain_region_stack(BitMapClosure* bc) {
-assert(_cm->region_stack_empty(), "region stack should be empty");
-assert(_aborted_region.is_empty(), "aborted region should be empty");
-return;
-if (has_aborted()) return;
-assert(_region_finger == NULL,
-"it should be NULL when we're not scanning a region");
-if (!_cm->region_stack_empty() || !_aborted_region.is_empty()) {
-if (_cm->verbose_low()) {
-gclog_or_tty->print_cr("[%d] draining region stack, size = %d",
-_task_id, _cm->region_stack_size());
-}
-MemRegion mr;
-if (!_aborted_region.is_empty()) {
-mr = _aborted_region;
-_aborted_region = MemRegion();
-if (_cm->verbose_low()) {
-gclog_or_tty->print_cr("[%d] scanning aborted region "
-"[ " PTR_FORMAT ", " PTR_FORMAT " )",
-_task_id, mr.start(), mr.end());
-}
-} else {
-mr = _cm->region_stack_pop_lock_free();
-// it returns MemRegion() if the pop fails
-statsOnly(if (mr.start() != NULL) ++_region_stack_pops );
-}
-while (mr.start() != NULL) {
-if (_cm->verbose_medium()) {
-gclog_or_tty->print_cr("[%d] we are scanning region "
-"["PTR_FORMAT", "PTR_FORMAT")",
-_task_id, mr.start(), mr.end());
-}
-assert(mr.end() <= _cm->finger(),
-"otherwise the region shouldn't be on the stack");
-assert(!mr.is_empty(), "Only non-empty regions live on the region stack");
-if (_nextMarkBitMap->iterate(bc, mr)) {
-assert(!has_aborted(),
-"cannot abort the task without aborting the bitmap iteration");
-// We finished iterating over the region without aborting.
-regular_clock_call();
-if (has_aborted()) {
-mr = MemRegion();
-} else {
-mr = _cm->region_stack_pop_lock_free();
-// it returns MemRegion() if the pop fails
-statsOnly(if (mr.start() != NULL) ++_region_stack_pops );
-}
-} else {
-assert(has_aborted(), "currently the only way to do so");
-// The only way to abort the bitmap iteration is to return
-// false from the do_bit() method. However, inside the
-// do_bit() method we move the _region_finger to point to the
-// object currently being looked at. So, if we bail out, we
-// have definitely set _region_finger to something non-null.
-assert(_region_finger != NULL, "invariant");
-// Make sure that any previously aborted region has been
-// cleared.
-assert(_aborted_region.is_empty(), "aborted region not cleared");
-// The iteration was actually aborted. So now _region_finger
-// points to the address of the object we last scanned. If we
-// leave it there, when we restart this task, we will rescan
-// the object. It is easy to avoid this. We move the finger by
-// enough to point to the next possible object header (the
-// bitmap knows by how much we need to move it as it knows its
-// granularity).
-MemRegion newRegion =
-MemRegion(_nextMarkBitMap->nextWord(_region_finger), mr.end());
-if (!newRegion.is_empty()) {
-if (_cm->verbose_low()) {
-gclog_or_tty->print_cr("[%d] recording unscanned region"
-"[" PTR_FORMAT "," PTR_FORMAT ") in CMTask",
-_task_id,
-newRegion.start(), newRegion.end());
-}
-// Now record the part of the region we didn't scan to
-// make sure this task scans it later.
-_aborted_region = newRegion;
-}
-// break from while
-mr = MemRegion();
-}
-_region_finger = NULL;
-}
-if (_cm->verbose_low()) {
-gclog_or_tty->print_cr("[%d] drained region stack, size = %d",
-_task_id, _cm->region_stack_size());
-}
-}
 }
 void CMTask::print_stats() {
 gclog_or_tty->print_cr("Marking Stats, task = %d, calls = %d",
 _task_id, _calls);
 _local_pushes, _local_pops, _local_max_size);
 gclog_or_tty->print_cr("  Global Stack: pushes = %d, pops = %d, max size = %d",
 _global_pushes, _global_pops, _global_max_size);
 gclog_or_tty->print_cr("                transfers to = %d, transfers from = %d",
 _global_transfers_to,_global_transfers_from);
-gclog_or_tty->print_cr("  Regions: claimed = %d, Region Stack: pops = %d",
+gclog_or_tty->print_cr("  Regions: claimed = %d", _regions_claimed);
-_regions_claimed, _region_stack_pops);
 gclog_or_tty->print_cr("  SATB buffers: processed = %d", _satb_buffers_processed);
 gclog_or_tty->print_cr("  Steals: attempts = %d, successes = %d",
 _steal_attempts, _steals);
 gclog_or_tty->print_cr("  Aborted: %d, due to", _aborted);
 gclog_or_tty->print_cr("    overflow: %d, global abort: %d, yield: %d",
 phase, tasks attempt to keep the global mark stack at a small
 length but not totally empty, so that entries are available for
 popping by other tasks. Only when there is no more work, tasks
 will totally drain the global mark stack.
-(4) Global Region Stack. Entries on it correspond to areas of
+(4) SATB Buffer Queue. This is where completed SATB buffers are
-the bitmap that need to be scanned since they contain gray
-objects. Pushes on the region stack only happen during
-evacuation pauses and typically correspond to areas covered by
-GC LABS. If it overflows, then the marking phase should restart
-and iterate over the bitmap to identify gray objects. Tasks will
-try to totally drain the region stack as soon as possible.
-(5) SATB Buffer Queue. This is where completed SATB buffers are
 made available. Buffers are regularly removed from this queue
 and scanned for roots, so that the queue doesn't get too
 long. During remark, all completed buffers are processed, as
 well as the filled in parts of any uncompleted buffers.
 has been reached. There are a few other cases when the
 do_marking_step() method also aborts:
 (1) When the marking phase has been aborted (after a Full GC).
-(2) When a global overflow (either on the global stack or the
+(2) When a global overflow (on the global stack) has been
-region stack) has been triggered. Before the task aborts, it
+triggered. Before the task aborts, it will actually sync up with
-will actually sync up with the other tasks to ensure that all
+the other tasks to ensure that all the marking data structures
-the marking data structures (local queues, stacks, fingers etc.)
+(local queues, stacks, fingers etc.)  are re-initialised so that
-are re-initialised so that when do_marking_step() completes,
+when do_marking_step() completes, the marking phase can
-the marking phase can immediately restart.
+immediately restart.
 (3) When enough completed SATB buffers are available. The
 do_marking_step() method only tries to drain SATB buffers right
 at the beginning. So, if enough buffers are available, the
 marking step aborts and the SATB buffers are processed at
 bool do_stealing,
 bool do_termination) {
 assert(time_target_ms >= 1.0, "minimum granularity is 1ms");
 assert(concurrent() == _cm->concurrent(), "they should be the same");
-assert(concurrent() || _cm->region_stack_empty(),
-"the region stack should have been cleared before remark");
-assert(concurrent() || !_cm->has_aborted_regions(),
-"aborted regions should have been cleared before remark");
-assert(_region_finger == NULL,
-"this should be non-null only when a region is being scanned");
 G1CollectorPolicy* g1_policy = _g1h->g1_policy();
 assert(_task_queues != NULL, "invariant");
 assert(_task_queue != NULL, "invariant");
 assert(_task_queues->queue(_task_id) == _task_queue, "invariant");
 CMBitMapClosure bitmap_closure(this, _cm, _nextMarkBitMap);
 G1CMOopClosure  cm_oop_closure(_g1h, _cm, this);
 set_cm_oop_closure(&cm_oop_closure);
 if (_cm->has_overflown()) {
-// This can happen if the region stack or the mark stack overflows
+// This can happen if the mark stack overflows during a GC pause
-// during a GC pause and this task, after a yield point,
+// and this task, after a yield point, restarts. We have to abort
-// restarts. We have to abort as we need to get into the overflow
+// as we need to get into the overflow protocol which happens
-// protocol which happens right at the end of this task.
+// right at the end of this task.
 set_has_aborted();
 }
 // First drain any available SATB buffers. After this, we will not
 // look at SATB buffers before the next invocation of this method.
 // If enough completed SATB buffers are queued up, the regular clock
 // will abort this task so that it restarts.
 drain_satb_buffers();
-// ...then partially drain the local queue and the global stack
-drain_local_queue(true);
-drain_global_stack(true);
-// Then totally drain the region stack.  We will not look at
-// it again before the next invocation of this method. Entries on
-// the region stack are only added during evacuation pauses, for
-// which we have to yield. When we do, we abort the task anyway so
-// it will look at the region stack again when it restarts.
-bitmap_closure.set_scanning_heap_region(false);
-drain_region_stack(&bitmap_closure);
 // ...then partially drain the local queue and the global stack
 drain_local_queue(true);
 drain_global_stack(true);
 do {
 _task_id, _finger, _region_limit, _curr_region);
 }
 // Let's iterate over the bitmap of the part of the
 // region that is left.
-bitmap_closure.set_scanning_heap_region(true);
+if (mr.is_empty() || _nextMarkBitMap->iterate(&bitmap_closure, mr)) {
-if (mr.is_empty() ||
-_nextMarkBitMap->iterate(&bitmap_closure, mr)) {
 // We successfully completed iterating over the region. Now,
 // let's give up the region.
 giveup_current_region();
 regular_clock_call();
 } else {
 // granularity).
 assert(_finger < _region_limit, "invariant");
 HeapWord* new_finger = _nextMarkBitMap->nextWord(_finger);
 // Check if bitmap iteration was aborted while scanning the last object
 if (new_finger >= _region_limit) {
 giveup_current_region();
 } else {
 move_finger_to(new_finger);
 }
 }
 }
 // At this point we have either completed iterating over the
 // region we were holding on to, or we have aborted.
 }
 } while ( _curr_region != NULL && !has_aborted());
 if (!has_aborted()) {
 // We cannot check whether the global stack is empty, since other
-// tasks might be pushing objects to it concurrently. We also cannot
+// tasks might be pushing objects to it concurrently.
-// check if the region stack is empty because if a thread is aborting
-// it can push a partially done region back.
 assert(_cm->out_of_regions(),
 "at this point we should be out of regions");
 if (_cm->verbose_low()) {
 gclog_or_tty->print_cr("[%d] all regions claimed", _task_id);
 if (do_stealing && !has_aborted()) {
 // We have not aborted. This means that we have finished all that
 // we could. Let's try to do some stealing...
 // We cannot check whether the global stack is empty, since other
-// tasks might be pushing objects to it concurrently. We also cannot
+// tasks might be pushing objects to it concurrently.
-// check if the region stack is empty because if a thread is aborting
-// it can push a partially done region back.
 assert(_cm->out_of_regions() && _task_queue->size() == 0,
 "only way to reach here");
 if (_cm->verbose_low()) {
 gclog_or_tty->print_cr("[%d] starting to steal", _task_id);
 // We still haven't aborted. Now, let's try to get into the
 // termination protocol.
 if (do_termination && !has_aborted()) {
 // We cannot check whether the global stack is empty, since other
-// tasks might be concurrently pushing objects on it. We also cannot
+// tasks might be concurrently pushing objects on it.
-// check if the region stack is empty because if a thread is aborting
-// it can push a partially done region back.
 // Separated the asserts so that we know which one fires.
 assert(_cm->out_of_regions(), "only way to reach here");
 assert(_task_queue->size() == 0, "only way to reach here");
 if (_cm->verbose_low()) {
 // We can now guarantee that the global stack is empty, since
 // all other tasks have finished. We separated the guarantees so
 // that, if a condition is false, we can immediately find out
 // which one.
 guarantee(_cm->out_of_regions(), "only way to reach here");
-guarantee(_aborted_region.is_empty(), "only way to reach here");
-guarantee(_cm->region_stack_empty(), "only way to reach here");
 guarantee(_cm->mark_stack_empty(), "only way to reach here");
 guarantee(_task_queue->size() == 0, "only way to reach here");
 guarantee(!_cm->has_overflown(), "only way to reach here");
 guarantee(!_cm->mark_stack_overflow(), "only way to reach here");
-guarantee(!_cm->region_stack_overflow(), "only way to reach here");
 if (_cm->verbose_low()) {
 gclog_or_tty->print_cr("[%d] all tasks terminated", _task_id);
 }
 } else {
 _claimed(false),
 _nextMarkBitMap(NULL), _hash_seed(17),
 _task_queue(task_queue),
 _task_queues(task_queues),
 _cm_oop_closure(NULL),
-_aborted_region(MemRegion()),
 _marked_bytes_array(marked_bytes),
 _card_bm(card_bm) {
 guarantee(task_queue != NULL, "invariant");
 guarantee(task_queues != NULL, "invariant");

Mercurial > hg > graal-jvmci-8

comparison src/share/vm/gc_implementation/g1/concurrentMark.cpp @ 5988:2a0172480595