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

comparison src/share/vm/gc_implementation/g1/concurrentMark.cpp @ 23029:0f8f1250fed5

8078023: verify_no_cset_oops found reclaimed humongous object in SATB buffer Summary: Removed no longer valid checking of SATB buffers Reviewed-by: jmasa, pliden

author	kbarrett
date	Wed, 22 Apr 2015 14:06:49 -0400
parents	b5d14ef905b5
children	399885e13e90

comparison

equal deleted inserted replaced

-:b5d14ef905b5
+:0f8f1250fed5
 }
 #ifndef PRODUCT
 enum VerifyNoCSetOopsPhase {
 VerifyNoCSetOopsStack,
-VerifyNoCSetOopsQueues,
+VerifyNoCSetOopsQueues
-VerifyNoCSetOopsSATBCompleted,
-VerifyNoCSetOopsSATBThread
 };
 class VerifyNoCSetOopsClosure : public OopClosure, public ObjectClosure  {
 private:
 G1CollectedHeap* _g1h;
 const char* phase_str() {
 switch (_phase) {
 case VerifyNoCSetOopsStack:         return "Stack";
 case VerifyNoCSetOopsQueues:        return "Queue";
-case VerifyNoCSetOopsSATBCompleted: return "Completed SATB Buffers";
-case VerifyNoCSetOopsSATBThread:    return "Thread SATB Buffers";
 default:                            ShouldNotReachHere();
 }
 return NULL;
 }
 do_object_work(obj);
 }
 virtual void do_oop(narrowOop* p) {
 // We should not come across narrow oops while scanning marking
-// stacks and SATB buffers.
+// stacks
 ShouldNotReachHere();
 }
 virtual void do_object(oop obj) {
 do_object_work(obj);
 }
 };
-void ConcurrentMark::verify_no_cset_oops(bool verify_stacks,
+void ConcurrentMark::verify_no_cset_oops() {
-bool verify_enqueued_buffers,
-bool verify_thread_buffers,
-bool verify_fingers) {
 assert(SafepointSynchronize::is_at_safepoint(), "should be at a safepoint");
 if (!G1CollectedHeap::heap()->mark_in_progress()) {
 return;
 }
 VerifyNoCSetOopsClosure cl;
-if (verify_stacks) {
+// Verify entries on the global mark stack
-// Verify entries on the global mark stack
+cl.set_phase(VerifyNoCSetOopsStack);
-cl.set_phase(VerifyNoCSetOopsStack);
+_markStack.oops_do(&cl);
-_markStack.oops_do(&cl);
+// Verify entries on the task queues
-// Verify entries on the task queues
+for (uint i = 0; i < _max_worker_id; i += 1) {
-for (uint i = 0; i < _max_worker_id; i += 1) {
+cl.set_phase(VerifyNoCSetOopsQueues, i);
-cl.set_phase(VerifyNoCSetOopsQueues, i);
+CMTaskQueue* queue = _task_queues->queue(i);
-CMTaskQueue* queue = _task_queues->queue(i);
+queue->oops_do(&cl);
-queue->oops_do(&cl);
+}
-}
-}
+// Verify the global finger
+HeapWord* global_finger = finger();
-SATBMarkQueueSet& satb_qs = JavaThread::satb_mark_queue_set();
+if (global_finger != NULL && global_finger < _heap_end) {
+// The global finger always points to a heap region boundary. We
-// Verify entries on the enqueued SATB buffers
+// use heap_region_containing_raw() to get the containing region
-if (verify_enqueued_buffers) {
+// given that the global finger could be pointing to a free region
-cl.set_phase(VerifyNoCSetOopsSATBCompleted);
+// which subsequently becomes continues humongous. If that
-satb_qs.iterate_completed_buffers_read_only(&cl);
+// happens, heap_region_containing() will return the bottom of the
-}
+// corresponding starts humongous region and the check below will
+// not hold any more.
-// Verify entries on the per-thread SATB buffers
+// Since we always iterate over all regions, we might get a NULL HeapRegion
-if (verify_thread_buffers) {
+// here.
-cl.set_phase(VerifyNoCSetOopsSATBThread);
+HeapRegion* global_hr = _g1h->heap_region_containing_raw(global_finger);
-satb_qs.iterate_thread_buffers_read_only(&cl);
+guarantee(global_hr == NULL || global_finger == global_hr->bottom(),
-}
+err_msg("global finger: "PTR_FORMAT" region: "HR_FORMAT,
+p2i(global_finger), HR_FORMAT_PARAMS(global_hr)));
-if (verify_fingers) {
+}
-// Verify the global finger
-HeapWord* global_finger = finger();
+// Verify the task fingers
-if (global_finger != NULL && global_finger < _heap_end) {
+assert(parallel_marking_threads() <= _max_worker_id, "sanity");
-// The global finger always points to a heap region boundary. We
+for (int i = 0; i < (int) parallel_marking_threads(); i += 1) {
-// use heap_region_containing_raw() to get the containing region
+CMTask* task = _tasks[i];
-// given that the global finger could be pointing to a free region
+HeapWord* task_finger = task->finger();
-// which subsequently becomes continues humongous. If that
+if (task_finger != NULL && task_finger < _heap_end) {
-// happens, heap_region_containing() will return the bottom of the
+// See above note on the global finger verification.
-// corresponding starts humongous region and the check below will
+HeapRegion* task_hr = _g1h->heap_region_containing_raw(task_finger);
-// not hold any more.
+guarantee(task_hr == NULL || task_finger == task_hr->bottom() ||
-// Since we always iterate over all regions, we might get a NULL HeapRegion
+!task_hr->in_collection_set(),
-// here.
+err_msg("task finger: "PTR_FORMAT" region: "HR_FORMAT,
-HeapRegion* global_hr = _g1h->heap_region_containing_raw(global_finger);
+p2i(task_finger), HR_FORMAT_PARAMS(task_hr)));
-guarantee(global_hr == NULL || global_finger == global_hr->bottom(),
-err_msg("global finger: "PTR_FORMAT" region: "HR_FORMAT,
-p2i(global_finger), HR_FORMAT_PARAMS(global_hr)));
-}
-// Verify the task fingers
-assert(parallel_marking_threads() <= _max_worker_id, "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 && task_finger < _heap_end) {
-// See above note on the global finger verification.
-HeapRegion* task_hr = _g1h->heap_region_containing_raw(task_finger);
-guarantee(task_hr == NULL || task_finger == task_hr->bottom() ||
-!task_hr->in_collection_set(),
-err_msg("task finger: "PTR_FORMAT" region: "HR_FORMAT,
-p2i(task_finger), HR_FORMAT_PARAMS(task_hr)));
-}
 }
 }
 }
 #endif // PRODUCT

Mercurial > hg > graal-jvmci-8

comparison src/share/vm/gc_implementation/g1/concurrentMark.cpp @ 23029:0f8f1250fed5