jdk-sandbox: comparison hotspot/src/share/vm/gc_implementation/g1/concurrentMark.cpp

equal deleted inserted replaced

-:607a56c8880f
+:30d1c247fc25
 _markStack.allocate(G1MarkStackSize);
 _regionStack.allocate(G1MarkRegionStackSize);
 // Create & start a ConcurrentMark thread.
-if (G1ConcMark) {
+_cmThread = new ConcurrentMarkThread(this);
-_cmThread = new ConcurrentMarkThread(this);
+assert(cmThread() != NULL, "CM Thread should have been created");
-assert(cmThread() != NULL, "CM Thread should have been created");
+assert(cmThread()->cm() != NULL, "CM Thread should refer to this cm");
-assert(cmThread()->cm() != NULL, "CM Thread should refer to this cm");
-} else {
-_cmThread = NULL;
-}
 _g1h = G1CollectedHeap::heap();
 assert(CGC_lock != NULL, "Where's the CGC_lock?");
 assert(_markBitMap1.covers(rs), "_markBitMap1 inconsistency");
 assert(_markBitMap2.covers(rs), "_markBitMap2 inconsistency");
 CMMarkRootsClosure(ConcurrentMark* cm,
 G1CollectedHeap* g1h,
 bool do_barrier) : _cm(cm), _g1h(g1h),
 _do_barrier(do_barrier) { }
-virtual void do_oop(narrowOop* p) {
+virtual void do_oop(narrowOop* p) { do_oop_work(p); }
-guarantee(false, "NYI");
+virtual void do_oop(      oop* p) { do_oop_work(p); }
-}
+template <class T> void do_oop_work(T* p) {
-virtual void do_oop(oop* p) {
+T heap_oop = oopDesc::load_heap_oop(p);
-oop thisOop = *p;
+if (!oopDesc::is_null(heap_oop)) {
-if (thisOop != NULL) {
+oop obj = oopDesc::decode_heap_oop_not_null(heap_oop);
-assert(thisOop->is_oop() || thisOop->mark() == NULL,
+assert(obj->is_oop() || obj->mark() == NULL,
 "expected an oop, possibly with mark word displaced");
-HeapWord* addr = (HeapWord*)thisOop;
+HeapWord* addr = (HeapWord*)obj;
 if (_g1h->is_in_g1_reserved(addr)) {
-_cm->grayRoot(thisOop);
+_cm->grayRoot(obj);
 }
 }
 if (_do_barrier) {
 assert(!_g1h->is_in_g1_reserved(p),
 "Should be called on external roots");
 assert(SafepointSynchronize::is_at_safepoint(), "world should be stopped");
 G1CollectedHeap* g1h = G1CollectedHeap::heap();
 double start = os::elapsedTime();
 GCOverheadReporter::recordSTWStart(start);
-// If there has not been a GC[n-1] since last GC[n] cycle completed,
-// precede our marking with a collection of all
-// younger generations to keep floating garbage to a minimum.
-// YSR: we won't do this for now -- it's an optimization to be
-// done post-beta.
-// YSR:    ignoring weak refs for now; will do at bug fixing stage
-// EVM:    assert(discoveredRefsAreClear());
 G1CollectorPolicy* g1p = G1CollectedHeap::heap()->g1_policy();
 g1p->record_concurrent_mark_init_start();
 checkpointRootsInitialPre();
 if (has_aborted()) {
 g1h->set_marking_complete(); // So bitmap clearing isn't confused
 return;
 }
+if (VerifyDuringGC) {
+HandleMark hm;  // handle scope
+gclog_or_tty->print(" VerifyDuringGC:(before)");
+Universe::heap()->prepare_for_verify();
+Universe::verify(true, false, true);
+}
 G1CollectorPolicy* g1p = g1h->g1_policy();
 g1p->record_concurrent_mark_remark_start();
 double start = os::elapsedTime();
 GCOverheadReporter::recordSTWStart(start);
 } else {
 // We're done with marking.
 JavaThread::satb_mark_queue_set().set_active_all_threads(false);
 if (VerifyDuringGC) {
-g1h->prepare_for_verify();
+HandleMark hm;  // handle scope
-g1h->verify(/* allow_dirty */      true,
+gclog_or_tty->print(" VerifyDuringGC:(after)");
-/* silent */           false,
+Universe::heap()->prepare_for_verify();
-/* use_prev_marking */ false);
+Universe::heap()->verify(/* allow_dirty */      true,
+/* silent */           false,
+/* use_prev_marking */ false);
 }
 }
 #if VERIFY_OBJS_PROCESSED
 _scan_obj_cl.objs_processed = 0;
 if (has_aborted()) {
 g1h->set_marking_complete(); // So bitmap clearing isn't confused
 return;
 }
+if (VerifyDuringGC) {
+HandleMark hm;  // handle scope
+gclog_or_tty->print(" VerifyDuringGC:(before)");
+Universe::heap()->prepare_for_verify();
+Universe::verify(/* allow dirty  */ true,
+/* silent       */ false,
+/* prev marking */ true);
+}
 _cleanup_co_tracker.disable();
 G1CollectorPolicy* g1p = G1CollectedHeap::heap()->g1_policy();
 g1p->record_concurrent_mark_cleanup_start();
 // We need to make this be a "collection" so any collection pause that
 // races with it goes around and waits for completeCleanup to finish.
 g1h->increment_total_collections();
 if (VerifyDuringGC) {
-g1h->prepare_for_verify();
+HandleMark hm;  // handle scope
-g1h->verify(/* allow_dirty */      true,
+gclog_or_tty->print(" VerifyDuringGC:(after)");
-/* silent */           false,
+Universe::heap()->prepare_for_verify();
-/* use_prev_marking */ true);
+Universe::verify(/* allow dirty  */ true,
+/* silent       */ false,
+/* prev marking */ true);
 }
 }
 void ConcurrentMark::completeCleanup() {
 // A full collection intervened.
 G1CMKeepAliveClosure(G1CollectedHeap* g1, ConcurrentMark* cm,
 CMBitMap* bitMap) :
 _g1(g1), _cm(cm),
 _bitMap(bitMap) {}
-void do_oop(narrowOop* p) {
+virtual void do_oop(narrowOop* p) { do_oop_work(p); }
-guarantee(false, "NYI");
+virtual void do_oop(      oop* p) { do_oop_work(p); }
-}
+template <class T> void do_oop_work(T* p) {
-void do_oop(oop* p) {
+oop thisOop = oopDesc::load_decode_heap_oop(p);
-oop thisOop = *p;
 HeapWord* addr = (HeapWord*)thisOop;
 if (_g1->is_in_g1_reserved(addr) && _g1->is_obj_ill(thisOop)) {
 _bitMap->mark(addr);
 _cm->mark_stack_push(thisOop);
 }
 public:
 ReachablePrinterOopClosure(CMBitMapRO* bitmap, outputStream* out) :
 _bitmap(bitmap), _g1h(G1CollectedHeap::heap()), _out(out) { }
-void do_oop(narrowOop* p) {
+void do_oop(narrowOop* p) { do_oop_work(p); }
-guarantee(false, "NYI");
+void do_oop(      oop* p) { do_oop_work(p); }
-}
+template <class T> void do_oop_work(T* p) {
-void do_oop(oop* p) {
+oop         obj = oopDesc::load_decode_heap_oop(p);
-oop         obj = *p;
 const char* str = NULL;
 const char* str2 = "";
 if (!_g1h->is_in_g1_reserved(obj))
 str = "outside G1 reserved";
 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)) {
 tmp_guarantee_CM( obj != NULL, "is_in_g1_reserved should ensure this" );
 HeapRegion* hr = _g1h->heap_region_containing(obj);
 if (_g1h->is_obj_ill(obj, hr)) {
 if (verbose_high())
 _ms_ind--;
 return _ms[_ms_ind];
 }
 }
-bool drain() {
+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];
 if (next_arr_ind < len) {
 push(obj, next_arr_ind);
 }
 // Now process this portion of this one.
 int lim = MIN2(next_arr_ind, len);
-assert(!UseCompressedOops, "This needs to be fixed");
 for (int j = arr_ind; j < lim; j++) {
-do_oop(aobj->obj_at_addr<oop>(j));
+do_oop(aobj->obj_at_addr<T>(j));
 }
 } else {
 obj->oop_iterate(this);
 }
 ~CSMarkOopClosure() {
 FREE_C_HEAP_ARRAY(oop, _ms);
 FREE_C_HEAP_ARRAY(jint, _array_ind_stack);
 }
-void do_oop(narrowOop* p) {
+virtual void do_oop(narrowOop* p) { do_oop_work(p); }
-guarantee(false, "NYI");
+virtual void do_oop(      oop* p) { do_oop_work(p); }
-}
+template <class T> void do_oop_work(T* p) {
-void do_oop(oop* p) {
+T heap_oop = oopDesc::load_heap_oop(p);
-oop obj = *p;
+if (oopDesc::is_null(heap_oop)) return;
-if (obj == NULL) 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.
 "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 (!_oop_cl.drain()) return false;
+if (UseCompressedOops) {
+if (!_oop_cl.drain<narrowOop>()) return false;
+} else {
+if (!_oop_cl.drain<oop>()) return false;
+}
 }
 // Otherwise...
 return true;
 }
 };
 }
 }
 // abandon current marking iteration due to a Full GC
 void ConcurrentMark::abort() {
-// If we're not marking, nothing to do.
-if (!G1ConcMark) return;
 // Clear all marks to force marking thread to do nothing
 _nextMarkBitMap->clearAll();
 // Empty mark stack
 clear_marking_state();
 for (int i = 0; i < (int)_max_task_num; ++i)
 G1CollectedHeap*   _g1h;
 ConcurrentMark*    _cm;
 CMTask*            _task;
 public:
-void do_oop(narrowOop* p) {
+virtual void do_oop(narrowOop* p) { do_oop_work(p); }
-guarantee(false, "NYI");
+virtual void do_oop(      oop* p) { do_oop_work(p); }
-}
+template <class T> void do_oop_work(T* p) {
-void do_oop(oop* p) {
 tmp_guarantee_CM( _g1h->is_in_g1_reserved((HeapWord*) p), "invariant" );
+tmp_guarantee_CM( !_g1h->heap_region_containing((HeapWord*) p)->is_on_free_list(), "invariant" );
-oop obj = *p;
+oop obj = oopDesc::load_decode_heap_oop(p);
 if (_cm->verbose_high())
 gclog_or_tty->print_cr("[%d] we're looking at location "
 "*"PTR_FORMAT" = "PTR_FORMAT,
 _task->task_id(), p, (void*) obj);
 _task->deal_with_reference(obj);
 _task_id, (void*) obj);
 ++_refs_reached;
 HeapWord* objAddr = (HeapWord*) obj;
+assert(obj->is_oop_or_null(true /* ignore mark word */), "Error");
 if (_g1h->is_in_g1_reserved(objAddr)) {
 tmp_guarantee_CM( obj != NULL, "is_in_g1_reserved should ensure this" );
 HeapRegion* hr =  _g1h->heap_region_containing(obj);
 if (_g1h->is_obj_ill(obj, hr)) {
 if (_cm->verbose_high())
 }
 void CMTask::push(oop obj) {
 HeapWord* objAddr = (HeapWord*) obj;
 tmp_guarantee_CM( _g1h->is_in_g1_reserved(objAddr), "invariant" );
+tmp_guarantee_CM( !_g1h->heap_region_containing(objAddr)->is_on_free_list(), "invariant" );
 tmp_guarantee_CM( !_g1h->is_obj_ill(obj), "invariant" );
 tmp_guarantee_CM( _nextMarkBitMap->isMarked(objAddr), "invariant" );
 if (_cm->verbose_high())
 gclog_or_tty->print_cr("[%d] pushing "PTR_FORMAT, _task_id, (void*) obj);
 if (_cm->verbose_high())
 gclog_or_tty->print_cr("[%d] popped "PTR_FORMAT, _task_id,
 (void*) obj);
 tmp_guarantee_CM( _g1h->is_in_g1_reserved((HeapWord*) obj),
+"invariant" );
+tmp_guarantee_CM( !_g1h->heap_region_containing(obj)->is_on_free_list(),
 "invariant" );
 scan_object(obj);
 if (_task_queue->size() <= target_size || has_aborted())

changeset 3262	30d1c247fc25
parent 3184	b92e28cc020b
child 3283	c8b1b0aecdfe