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

comparison src/share/vm/gc_implementation/g1/g1CollectedHeap.cpp @ 4910:caa4652b4414

7129892: G1: explicit marking cycle initiation might fail to initiate a marking cycle Summary: If we try to schedule an initial-mark GC in order to explicit start a conc mark cycle and it gets pre-empted by antoher GC, we should retry the attempt as long as it's appropriate for the GC cause. Reviewed-by: brutisso, johnc

author	tonyp
date	Tue, 14 Feb 2012 08:21:08 -0500
parents	379b22e03c32
children	a9647476d1a4

comparison

equal deleted inserted replaced

-:95f6641e38e0
+:caa4652b4414
 }
 }
 should_try_gc = false;
 } else {
 // Read the GC count while still holding the Heap_lock.
-gc_count_before = SharedHeap::heap()->total_collections();
+gc_count_before = total_collections();
 should_try_gc = true;
 }
 }
 if (should_try_gc) {
 if (succeeded) {
 // If we get here we successfully scheduled a collection which
 // failed to allocate. No point in trying to allocate
 // further. We'll just return NULL.
 MutexLockerEx x(Heap_lock);
-*gc_count_before_ret = SharedHeap::heap()->total_collections();
+*gc_count_before_ret = total_collections();
 return NULL;
 }
 } else {
 GC_locker::stall_until_clear();
 }
 // Humongous objects can exhaust the heap quickly, so we should check if we
 // need to start a marking cycle at each humongous object allocation. We do
 // the check before we do the actual allocation. The reason for doing it
 // before the allocation is that we avoid having to keep track of the newly
 // allocated memory while we do a GC.
-if (g1_policy()->need_to_start_conc_mark("concurrent humongous allocation", word_size)) {
+if (g1_policy()->need_to_start_conc_mark("concurrent humongous allocation",
+word_size)) {
 collect(GCCause::_g1_humongous_allocation);
 }
 // We will loop until a) we manage to successfully perform the
 // allocation or b) we successfully schedule a collection which
 if (GC_locker::is_active_and_needs_gc()) {
 should_try_gc = false;
 } else {
 // Read the GC count while still holding the Heap_lock.
-gc_count_before = SharedHeap::heap()->total_collections();
+gc_count_before = total_collections();
 should_try_gc = true;
 }
 }
 if (should_try_gc) {
 if (succeeded) {
 // If we get here we successfully scheduled a collection which
 // failed to allocate. No point in trying to allocate
 // further. We'll just return NULL.
 MutexLockerEx x(Heap_lock);
-*gc_count_before_ret = SharedHeap::heap()->total_collections();
+*gc_count_before_ret = total_collections();
 return NULL;
 }
 } else {
 GC_locker::stall_until_clear();
 }
 }
 return hr->free();
 }
 bool G1CollectedHeap::should_do_concurrent_full_gc(GCCause::Cause cause) {
-return
+switch (cause) {
-((cause == GCCause::_gc_locker           && GCLockerInvokesConcurrent) ||
+case GCCause::_gc_locker:               return GCLockerInvokesConcurrent;
-(cause == GCCause::_java_lang_system_gc && ExplicitGCInvokesConcurrent) ||
+case GCCause::_java_lang_system_gc:     return ExplicitGCInvokesConcurrent;
-cause == GCCause::_g1_humongous_allocation);
+case GCCause::_g1_humongous_allocation: return true;
+default:                                return false;
+}
 }
 #ifndef PRODUCT
 void G1CollectedHeap::allocate_dummy_regions() {
 // Let's fill up most of the region
 ShouldNotReachHere(); // Unexpected use of this function
 }
 }
 void G1CollectedHeap::collect(GCCause::Cause cause) {
-// The caller doesn't have the Heap_lock
+assert_heap_not_locked();
-assert(!Heap_lock->owned_by_self(), "this thread should not own the Heap_lock");
 unsigned int gc_count_before;
 unsigned int full_gc_count_before;
-{
+bool retry_gc;
-MutexLocker ml(Heap_lock);
+do {
-// Read the GC count while holding the Heap_lock
+retry_gc = false;
-gc_count_before = SharedHeap::heap()->total_collections();
-full_gc_count_before = SharedHeap::heap()->total_full_collections();
+{
-}
+MutexLocker ml(Heap_lock);
-if (should_do_concurrent_full_gc(cause)) {
+// Read the GC count while holding the Heap_lock
-// Schedule an initial-mark evacuation pause that will start a
+gc_count_before = total_collections();
-// concurrent cycle. We're setting word_size to 0 which means that
+full_gc_count_before = total_full_collections();
-// we are not requesting a post-GC allocation.
+}
-VM_G1IncCollectionPause op(gc_count_before,
-0,     /* word_size */
+if (should_do_concurrent_full_gc(cause)) {
-true,  /* should_initiate_conc_mark */
+// Schedule an initial-mark evacuation pause that will start a
-g1_policy()->max_pause_time_ms(),
+// concurrent cycle. We're setting word_size to 0 which means that
-cause);
+// we are not requesting a post-GC allocation.
-VMThread::execute(&op);
-} else {
-if (cause == GCCause::_gc_locker
-DEBUG_ONLY(|| cause == GCCause::_scavenge_alot)) {
-// Schedule a standard evacuation pause. We're setting word_size
-// to 0 which means that we are not requesting a post-GC allocation.
 VM_G1IncCollectionPause op(gc_count_before,
 0,     /* word_size */
-false, /* should_initiate_conc_mark */
+true,  /* should_initiate_conc_mark */
 g1_policy()->max_pause_time_ms(),
 cause);
 VMThread::execute(&op);
+if (!op.pause_succeeded()) {
+// Another GC got scheduled and prevented us from scheduling
+// the initial-mark GC. It's unlikely that the GC that
+// pre-empted us was also an initial-mark GC. So, we'll retry
+// the initial-mark GC.
+if (full_gc_count_before == total_full_collections()) {
+retry_gc = true;
+} else {
+// A Full GC happened while we were trying to schedule the
+// initial-mark GC. No point in starting a new cycle given
+// that the whole heap was collected anyway.
+}
+}
 } else {
-// Schedule a Full GC.
+if (cause == GCCause::_gc_locker
-VM_G1CollectFull op(gc_count_before, full_gc_count_before, cause);
+DEBUG_ONLY(|| cause == GCCause::_scavenge_alot)) {
-VMThread::execute(&op);
-}
+// Schedule a standard evacuation pause. We're setting word_size
-}
+// to 0 which means that we are not requesting a post-GC allocation.
+VM_G1IncCollectionPause op(gc_count_before,
+0,     /* word_size */
+false, /* should_initiate_conc_mark */
+g1_policy()->max_pause_time_ms(),
+cause);
+VMThread::execute(&op);
+} else {
+// Schedule a Full GC.
+VM_G1CollectFull op(gc_count_before, full_gc_count_before, cause);
+VMThread::execute(&op);
+}
+}
+} while (retry_gc);
 }
 bool G1CollectedHeap::is_in(const void* p) const {
 if (_g1_committed.contains(p)) {
 // Given that we know that p is in the committed space,
 CodeBlobToOopClosure blobsCl(&rootsCl, /*do_marking=*/ false);
 // We apply the relevant closures to all the oops in the
 // system dictionary, the string table and the code cache.
-const int so = SharedHeap::SO_AllClasses | SharedHeap::SO_Strings | SharedHeap::SO_CodeCache;
+const int so = SO_AllClasses | SO_Strings | SO_CodeCache;
 process_strong_roots(true,      // activate StrongRootsScope
 true,      // we set "collecting perm gen" to true,
 // so we don't reset the dirty cards in the perm gen.
-SharedHeap::ScanningOption(so),  // roots scanning options
+ScanningOption(so),  // roots scanning options
 &rootsCl,
 &blobsCl,
 &rootsCl);
 // If we're verifying after the marking phase of a Full GC then we can't
 // This method is run in a GC worker.
 void
 G1CollectedHeap::
 g1_process_strong_roots(bool collecting_perm_gen,
-SharedHeap::ScanningOption so,
+ScanningOption so,
 OopClosure* scan_non_heap_roots,
 OopsInHeapRegionClosure* scan_rs,
 OopsInGenClosure* scan_perm,
 int worker_i) {

Mercurial > hg > graal-jvmci-8

comparison src/share/vm/gc_implementation/g1/g1CollectedHeap.cpp @ 4910:caa4652b4414