8319342: GenShen: Reset the count of degenerated cycles in a row following Full GC

Reviewed-by: wkemper, ysr

Author: kdnilsen

Diff for: src/hotspot/share/gc/shenandoah/heuristics/shenandoahHeuristics.cpp

@@ -46,8 +46,6 @@ int ShenandoahHeuristics::compare_by_garbage(RegionData a, RegionData b) {
 ShenandoahHeuristics::ShenandoahHeuristics(ShenandoahSpaceInfo* space_info) :
   _space_info(space_info),
   _region_data(nullptr),
-  _degenerated_cycles_in_a_row(0),
-  _successful_cycles_in_a_row(0),
   _guaranteed_gc_interval(0),
   _cycle_start(os::elapsedTime()),
   _last_cycle_end(0),
@@ -211,7 +209,7 @@ bool ShenandoahHeuristics::should_start_gc() {
 }
 
 bool ShenandoahHeuristics::should_degenerate_cycle() {
-  return _degenerated_cycles_in_a_row <= ShenandoahFullGCThreshold;
+  return ShenandoahHeap::heap()->shenandoah_policy()->consecutive_degenerated_gc_count() <= ShenandoahFullGCThreshold;
 }
 
 void ShenandoahHeuristics::adjust_penalty(intx step) {
@@ -232,8 +230,6 @@ void ShenandoahHeuristics::adjust_penalty(intx step) {
 }
 
 void ShenandoahHeuristics::record_success_concurrent(bool abbreviated) {
-  _degenerated_cycles_in_a_row = 0;
-  _successful_cycles_in_a_row++;
   _gc_times_learned++;
 
   adjust_penalty(Concurrent_Adjust);
@@ -244,16 +240,10 @@ void ShenandoahHeuristics::record_success_concurrent(bool abbreviated) {
 }
 
 void ShenandoahHeuristics::record_success_degenerated() {
-  _degenerated_cycles_in_a_row++;
-  _successful_cycles_in_a_row = 0;
-
   adjust_penalty(Degenerated_Penalty);
 }
 
 void ShenandoahHeuristics::record_success_full() {
-  _degenerated_cycles_in_a_row = 0;
-  _successful_cycles_in_a_row++;
-
   adjust_penalty(Full_Penalty);
 }
 

Diff for: src/hotspot/share/gc/shenandoah/heuristics/shenandoahHeuristics.hpp

@@ -97,9 +97,6 @@ class ShenandoahHeuristics : public CHeapObj<mtGC> {
   // have negligible cost unless proven otherwise.
   RegionData* _region_data;
 
-  uint _degenerated_cycles_in_a_row;
-  uint _successful_cycles_in_a_row;
-
   size_t _guaranteed_gc_interval;
 
   double _cycle_start;

Diff for: src/hotspot/share/gc/shenandoah/shenandoahCollectorPolicy.cpp

@@ -33,12 +33,13 @@
 ShenandoahCollectorPolicy::ShenandoahCollectorPolicy() :
   _success_concurrent_gcs(0),
   _mixed_gcs(0),
-  _abbreviated_cycles(0),
+  _abbreviated_gcs(0),
   _success_old_gcs(0),
   _interrupted_old_gcs(0),
   _success_degenerated_gcs(0),
   _success_full_gcs(0),
   _consecutive_young_gcs(0),
+  _consecutive_degenerated_gcs(0),
   _alloc_failure_degenerated(0),
   _alloc_failure_degenerated_upgrade_to_full(0),
   _alloc_failure_full(0),
@@ -82,10 +83,12 @@ void ShenandoahCollectorPolicy::record_alloc_failure_to_degenerated(ShenandoahGC
 
 void ShenandoahCollectorPolicy::record_degenerated_upgrade_to_full() {
   ShenandoahHeap::heap()->record_upgrade_to_full();
+  _consecutive_degenerated_gcs = 0;
   _alloc_failure_degenerated_upgrade_to_full++;
 }
 
 void ShenandoahCollectorPolicy::record_success_concurrent(bool is_young) {
+  _consecutive_degenerated_gcs = 0;
   if (is_young) {
     _consecutive_young_gcs++;
   } else {
@@ -99,7 +102,7 @@ void ShenandoahCollectorPolicy::record_mixed_cycle() {
 }
 
 void ShenandoahCollectorPolicy::record_abbreviated_cycle() {
-  _abbreviated_cycles++;
+  _abbreviated_gcs++;
 }
 
 void ShenandoahCollectorPolicy::record_success_old() {
@@ -112,7 +115,10 @@ void ShenandoahCollectorPolicy::record_interrupted_old() {
   _interrupted_old_gcs++;
 }
 
-void ShenandoahCollectorPolicy::record_success_degenerated(bool is_young) {
+void ShenandoahCollectorPolicy::record_success_degenerated(bool is_young, bool is_upgraded_to_full) {
+  if (!is_upgraded_to_full) {
+    _consecutive_degenerated_gcs++;
+  }
   if (is_young) {
     _consecutive_young_gcs++;
   } else {
@@ -122,6 +128,7 @@ void ShenandoahCollectorPolicy::record_success_degenerated(bool is_young) {
 }
 
 void ShenandoahCollectorPolicy::record_success_full() {
+  _consecutive_degenerated_gcs = 0;
   _consecutive_young_gcs = 0;
   _success_full_gcs++;
 }
@@ -142,7 +149,6 @@ bool ShenandoahCollectorPolicy::is_at_shutdown() {
   return _in_shutdown.is_set();
 }
 
-
 void ShenandoahCollectorPolicy::print_gc_stats(outputStream* out) const {
   out->print_cr("Under allocation pressure, concurrent cycles may cancel, and either continue cycle");
   out->print_cr("under stop-the-world pause or result in stop-the-world Full GC. Increase heap size,");
@@ -172,7 +178,7 @@ void ShenandoahCollectorPolicy::print_gc_stats(outputStream* out) const {
   out->print_cr("  " SIZE_FORMAT_W(5) " upgraded to Full GC",          _alloc_failure_degenerated_upgrade_to_full);
   out->cr();
 
-  out->print_cr(SIZE_FORMAT_W(5) " Abbreviated GCs",                   _abbreviated_cycles);
+  out->print_cr(SIZE_FORMAT_W(5) " Abbreviated GCs",                   _abbreviated_gcs);
   out->cr();
 
   out->print_cr(SIZE_FORMAT_W(5) " Full GCs",                          _success_full_gcs + _alloc_failure_degenerated_upgrade_to_full);

Diff for: src/hotspot/share/gc/shenandoah/shenandoahCollectorPolicy.hpp

@@ -41,13 +41,14 @@ class ShenandoahCollectorPolicy : public CHeapObj<mtGC> {
 private:
   size_t _success_concurrent_gcs;
   size_t _mixed_gcs;
-  size_t _abbreviated_cycles;
+  size_t _abbreviated_gcs;
   size_t _success_old_gcs;
   size_t _interrupted_old_gcs;
   size_t _success_degenerated_gcs;
   // Written by control thread, read by mutators
   volatile size_t _success_full_gcs;
   volatile size_t _consecutive_young_gcs;
+  uint _consecutive_degenerated_gcs;
   size_t _alloc_failure_degenerated;
   size_t _alloc_failure_degenerated_upgrade_to_full;
   size_t _alloc_failure_full;
@@ -61,6 +62,7 @@ class ShenandoahCollectorPolicy : public CHeapObj<mtGC> {
   ShenandoahSharedFlag _in_shutdown;
   ShenandoahTracer* _tracer;
 
+
 public:
   ShenandoahCollectorPolicy();
 
@@ -73,7 +75,7 @@ class ShenandoahCollectorPolicy : public CHeapObj<mtGC> {
   void record_success_concurrent(bool is_young);
   void record_success_old();
   void record_interrupted_old();
-  void record_success_degenerated(bool is_young);
+  void record_success_degenerated(bool is_young, bool is_upgraded_to_full);
   void record_success_full();
   void record_alloc_failure_to_degenerated(ShenandoahGC::ShenandoahDegenPoint point);
   void record_alloc_failure_to_full();
@@ -99,6 +101,10 @@ class ShenandoahCollectorPolicy : public CHeapObj<mtGC> {
   inline size_t consecutive_young_gc_count() const {
     return _consecutive_young_gcs;
   }
+
+  inline size_t consecutive_degenerated_gc_count() const {
+    return _consecutive_degenerated_gcs;
+  }
 };
 
 #endif // SHARE_GC_SHENANDOAH_SHENANDOAHCOLLECTORPOLICY_HPP

Diff for: src/hotspot/share/gc/shenandoah/shenandoahControlThread.cpp

@@ -817,7 +817,7 @@ bool ShenandoahControlThread::service_stw_degenerated_cycle(GCCause::Cause cause
   }
 
   _degen_generation->heuristics()->record_success_degenerated();
-  heap->shenandoah_policy()->record_success_degenerated(_degen_generation->is_young());
+  heap->shenandoah_policy()->record_success_degenerated(_degen_generation->is_young(), gc.upgraded_to_full());
   return !gc.upgraded_to_full();
 }
 

Diff for: src/hotspot/share/gc/shenandoah/shenandoahGeneration.cpp

@@ -1018,8 +1018,3 @@ void ShenandoahGeneration::record_success_concurrent(bool abbreviated) {
   heuristics()->record_success_concurrent(abbreviated);
   ShenandoahHeap::heap()->shenandoah_policy()->record_success_concurrent(is_young());
 }
-
-void ShenandoahGeneration::record_success_degenerated() {
-  heuristics()->record_success_degenerated();
-  ShenandoahHeap::heap()->shenandoah_policy()->record_success_degenerated(is_young());
-}

Diff for: src/hotspot/share/gc/shenandoah/shenandoahGeneration.hpp

@@ -213,7 +213,6 @@ class ShenandoahGeneration : public CHeapObj<mtGC>, public ShenandoahSpaceInfo {
   void confirm_heuristics_mode();
 
   virtual void record_success_concurrent(bool abbreviated);
-  virtual void record_success_degenerated();
 };
 
 #endif // SHARE_VM_GC_SHENANDOAH_SHENANDOAHGENERATION_HPP