8366865: Allocation GC Pauses Triggered after JVM has started shutdown

Reviewed-by: ayang, tschatzl

Author: Ivan Walulya

src/hotspot/share/gc/g1/g1CollectedHeap.cpp

@@ -480,6 +480,11 @@ HeapWord* G1CollectedHeap::attempt_allocation_slow(uint node_index, size_t word_
       log_warning(gc, alloc)("%s:  Retried allocation %u times for %zu words",
                              Thread::current()->name(), try_count, word_size);
     }
+
+    if (is_shutting_down()) {
+      stall_for_vm_shutdown();
+      return nullptr;
+    }
   }
 
   ShouldNotReachHere();
@@ -714,6 +719,11 @@ HeapWord* G1CollectedHeap::attempt_allocation_humongous(size_t word_size) {
       log_warning(gc, alloc)("%s: Retried allocation %u times for %zu words",
                              Thread::current()->name(), try_count, word_size);
     }
+
+    if (is_shutting_down()) {
+      stall_for_vm_shutdown();
+      return nullptr;
+    }
   }
 
   ShouldNotReachHere();
@@ -1551,10 +1561,6 @@ jint G1CollectedHeap::initialize() {
   return JNI_OK;
 }
 
-bool G1CollectedHeap::concurrent_mark_is_terminating() const {
-  return _cm_thread->should_terminate();
-}
-
 void G1CollectedHeap::stop() {
   // Stop all concurrent threads. We do this to make sure these threads
   // do not continue to execute and access resources (e.g. logging)
@@ -1881,7 +1887,7 @@ bool G1CollectedHeap::try_collect_concurrently(GCCause::Cause cause,
 
     // If VMOp skipped initiating concurrent marking cycle because
     // we're terminating, then we're done.
-    if (op.terminating()) {
+    if (is_shutting_down()) {
       LOG_COLLECT_CONCURRENTLY(cause, "skipped: terminating");
       return false;
     }

src/hotspot/share/gc/g1/g1CollectedHeap.hpp

@@ -914,9 +914,6 @@ class G1CollectedHeap : public CollectedHeap {
   // specified by the policy object.
   jint initialize() override;
 
-  // Returns whether concurrent mark threads (and the VM) are about to terminate.
-  bool concurrent_mark_is_terminating() const;
-
   void safepoint_synchronize_begin() override;
   void safepoint_synchronize_end() override;
 

src/hotspot/share/gc/g1/g1ConcurrentMark.cpp

@@ -1884,7 +1884,7 @@ bool G1ConcurrentMark::concurrent_cycle_abort() {
   // nothing, but this situation should be extremely rare (a full gc after shutdown
   // has been signalled is already rare), and this work should be negligible compared
   // to actual full gc work.
-  if (!cm_thread()->in_progress() && !_g1h->concurrent_mark_is_terminating()) {
+  if (!cm_thread()->in_progress() && !_g1h->is_shutting_down()) {
     return false;
   }
 

src/hotspot/share/gc/g1/g1Policy.cpp

@@ -669,6 +669,7 @@ bool G1Policy::should_retain_evac_failed_region(uint index) const {
 }
 
 void G1Policy::record_pause_start_time() {
+  assert(!_g1h->is_shutting_down(), "Invariant!");
   Ticks now = Ticks::now();
   _cur_pause_start_sec = now.seconds();
 
@@ -1275,7 +1276,7 @@ void G1Policy::decide_on_concurrent_start_pause() {
 
   // We should not be starting a concurrent start pause if the concurrent mark
   // thread is terminating.
-  if (_g1h->concurrent_mark_is_terminating()) {
+  if (_g1h->is_shutting_down()) {
     return;
   }
 

src/hotspot/share/gc/g1/g1RemSet.cpp

@@ -1024,7 +1024,7 @@ class G1MergeHeapRootsTask : public WorkerTask {
       // There might actually have been scheduled multiple collections, but at that point we do
       // not care that much about performance and just do the work multiple times if needed.
       return (_g1h->collector_state()->clear_bitmap_in_progress() ||
-              _g1h->concurrent_mark_is_terminating()) &&
+              _g1h->is_shutting_down()) &&
               hr->is_old();
     }
 

src/hotspot/share/gc/g1/g1VMOperations.cpp

@@ -64,7 +64,6 @@ VM_G1TryInitiateConcMark::VM_G1TryInitiateConcMark(uint gc_count_before,
   _mark_in_progress(false),
   _cycle_already_in_progress(false),
   _whitebox_attached(false),
-  _terminating(false),
   _gc_succeeded(false)
 {}
 
@@ -83,19 +82,10 @@ void VM_G1TryInitiateConcMark::doit() {
 
   GCCauseSetter x(g1h, _gc_cause);
 
-  // Record for handling by caller.
-  _terminating = g1h->concurrent_mark_is_terminating();
-
   _mark_in_progress = g1h->collector_state()->mark_in_progress();
   _cycle_already_in_progress = g1h->concurrent_mark()->cm_thread()->in_progress();
 
-  if (_terminating && GCCause::is_user_requested_gc(_gc_cause)) {
-    // When terminating, the request to initiate a concurrent cycle will be
-    // ignored by do_collection_pause_at_safepoint; instead it will just do
-    // a young-only or mixed GC (depending on phase).  For a user request
-    // there's no point in even doing that much, so done.  For some non-user
-    // requests the alternative GC might still be needed.
-  } else if (!g1h->policy()->force_concurrent_start_if_outside_cycle(_gc_cause)) {
+  if (!g1h->policy()->force_concurrent_start_if_outside_cycle(_gc_cause)) {
     // Failure to force the next GC pause to be a concurrent start indicates
     // there is already a concurrent marking cycle in progress. Flags to indicate
     // that were already set, so return immediately.
@@ -119,7 +109,6 @@ VM_G1CollectForAllocation::VM_G1CollectForAllocation(size_t         word_size,
 
 void VM_G1CollectForAllocation::doit() {
   G1CollectedHeap* g1h = G1CollectedHeap::heap();
-
   GCCauseSetter x(g1h, _gc_cause);
   // Try a partial collection of some kind.
   g1h->do_collection_pause_at_safepoint();
@@ -156,6 +145,14 @@ void VM_G1PauseConcurrent::doit() {
 
 bool VM_G1PauseConcurrent::doit_prologue() {
   Heap_lock->lock();
+  G1CollectedHeap* g1h = G1CollectedHeap::heap();
+  if (g1h->is_shutting_down()) {
+    Heap_lock->unlock();
+    // JVM shutdown has started. This ensures that any further operations will be properly aborted
+    // and will not interfere with the shutdown process.
+    g1h->concurrent_mark()->abort_marking_threads();
+    return false;
+  }
   return true;
 }
 

src/hotspot/share/gc/g1/g1VMOperations.hpp

@@ -48,7 +48,6 @@ class VM_G1TryInitiateConcMark : public VM_GC_Collect_Operation {
   bool _mark_in_progress;
   bool _cycle_already_in_progress;
   bool _whitebox_attached;
-  bool _terminating;
   // The concurrent start pause may be cancelled for some reasons. Keep track of
   // this.
   bool _gc_succeeded;
@@ -63,7 +62,6 @@ class VM_G1TryInitiateConcMark : public VM_GC_Collect_Operation {
   bool mark_in_progress() const { return _mark_in_progress; }
   bool cycle_already_in_progress() const { return _cycle_already_in_progress; }
   bool whitebox_attached() const { return _whitebox_attached; }
-  bool terminating() const { return _terminating; }
   bool gc_succeeded() const { return _gc_succeeded && VM_GC_Operation::gc_succeeded(); }
 };
 

src/hotspot/share/gc/parallel/parallelScavengeHeap.cpp

@@ -326,6 +326,11 @@ HeapWord* ParallelScavengeHeap::mem_allocate_work(size_t size, bool is_tlab) {
         assert(is_in_or_null(op.result()), "result not in heap");
         return op.result();
       }
+
+      if (is_shutting_down()) {
+        stall_for_vm_shutdown();
+        return nullptr;
+      }
     }
 
     // Was the gc-overhead reached inside the safepoint? If so, this mutator

src/hotspot/share/gc/serial/serialHeap.cpp

@@ -340,6 +340,11 @@ HeapWord* SerialHeap::mem_allocate_work(size_t size, bool is_tlab) {
       break;
     }
 
+    if (is_shutting_down()) {
+      stall_for_vm_shutdown();
+      return nullptr;
+    }
+
     // Give a warning if we seem to be looping forever.
     if ((QueuedAllocationWarningCount > 0) &&
         (try_count % QueuedAllocationWarningCount == 0)) {

src/hotspot/share/gc/shared/collectedHeap.cpp

@@ -385,6 +385,12 @@ MetaWord* CollectedHeap::satisfy_failed_metadata_allocation(ClassLoaderData* loa
     if (op.gc_succeeded()) {
       return op.result();
     }
+
+    if (is_shutting_down()) {
+      stall_for_vm_shutdown();
+      return nullptr;
+    }
+
     loop_count++;
     if ((QueuedAllocationWarningCount > 0) &&
         (loop_count % QueuedAllocationWarningCount == 0)) {
@@ -603,6 +609,23 @@ void CollectedHeap::post_initialize() {
   initialize_serviceability();
 }
 
+bool CollectedHeap::is_shutting_down() const {
+  return Universe::is_shutting_down();
+}
+
+void CollectedHeap::stall_for_vm_shutdown() {
+  assert(is_shutting_down(), "Precondition");
+  // Stall the thread (2 seconds) instead of an indefinite wait to avoid deadlock
+  // if the VM shutdown triggers a GC.
+  // The 2-seconds sleep is:
+  //   - long enough to keep daemon threads stalled, while the shutdown
+  //     sequence completes in the common case.
+  //   - short enough to avoid excessive stall time if the shutdown itself
+  //     triggers a GC.
+  JavaThread::current()->sleep(2 * MILLIUNITS);
+  log_warning(gc, alloc)("%s: Stall for VM-Shutdown timed out; allocation may fail with OOME", Thread::current()->name());
+}
+
 void CollectedHeap::before_exit() {
   print_tracing_info();