1 /* 2 * Copyright (c) 2013, 2021, Red Hat, Inc. All rights reserved. 3 * Copyright Amazon.com Inc. or its affiliates. All Rights Reserved. 4 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 5 * 6 * This code is free software; you can redistribute it and/or modify it 7 * under the terms of the GNU General Public License version 2 only, as 8 * published by the Free Software Foundation. 9 * 10 * This code is distributed in the hope that it will be useful, but WITHOUT 11 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 12 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 13 * version 2 for more details (a copy is included in the LICENSE file that 14 * accompanied this code). 15 * 16 * You should have received a copy of the GNU General Public License version 17 * 2 along with this work; if not, write to the Free Software Foundation, 18 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 19 * 20 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 21 * or visit www.oracle.com if you need additional information or have any 22 * questions. 23 * 24 */ 25 26 #include "precompiled.hpp" 27 28 #include "gc/shenandoah/shenandoahCollectorPolicy.hpp" 29 #include "gc/shenandoah/shenandoahGC.hpp" 30 #include "gc/shenandoah/shenandoahHeap.inline.hpp" 31 #include "runtime/os.hpp" 32 33 ShenandoahCollectorPolicy::ShenandoahCollectorPolicy() : 34 _success_concurrent_gcs(0), 35 _abbreviated_concurrent_gcs(0), 36 _success_degenerated_gcs(0), 37 _abbreviated_degenerated_gcs(0), 38 _success_full_gcs(0), 39 _consecutive_degenerated_gcs(0), 40 _consecutive_young_gcs(0), 41 _mixed_gcs(0), 42 _success_old_gcs(0), 43 _interrupted_old_gcs(0), 44 _alloc_failure_degenerated(0), 45 _alloc_failure_degenerated_upgrade_to_full(0), 46 _alloc_failure_full(0) { 47 48 Copy::zero_to_bytes(_degen_point_counts, sizeof(size_t) * ShenandoahGC::_DEGENERATED_LIMIT); 49 Copy::zero_to_bytes(_collection_cause_counts, sizeof(size_t) * GCCause::_last_gc_cause); 50 51 _tracer = new ShenandoahTracer(); 52 } 53 54 void ShenandoahCollectorPolicy::record_collection_cause(GCCause::Cause cause) { 55 assert(cause < GCCause::_last_gc_cause, "Invalid GCCause"); 56 _collection_cause_counts[cause]++; 57 } 58 59 void ShenandoahCollectorPolicy::record_alloc_failure_to_full() { 60 _alloc_failure_full++; 61 } 62 63 void ShenandoahCollectorPolicy::record_alloc_failure_to_degenerated(ShenandoahGC::ShenandoahDegenPoint point) { 64 assert(point < ShenandoahGC::_DEGENERATED_LIMIT, "sanity"); 65 _alloc_failure_degenerated++; 66 _degen_point_counts[point]++; 67 } 68 69 void ShenandoahCollectorPolicy::record_degenerated_upgrade_to_full() { 70 _consecutive_degenerated_gcs = 0; 71 _alloc_failure_degenerated_upgrade_to_full++; 72 } 73 74 void ShenandoahCollectorPolicy::record_success_concurrent(bool is_young, bool is_abbreviated) { 75 update_young(is_young); 76 77 _consecutive_degenerated_gcs = 0; 78 _success_concurrent_gcs++; 79 if (is_abbreviated) { 80 _abbreviated_concurrent_gcs++; 81 } 82 } 83 84 void ShenandoahCollectorPolicy::record_mixed_cycle() { 85 _mixed_gcs++; 86 } 87 88 void ShenandoahCollectorPolicy::record_success_old() { 89 _consecutive_young_gcs = 0; 90 _success_old_gcs++; 91 } 92 93 void ShenandoahCollectorPolicy::record_interrupted_old() { 94 _consecutive_young_gcs = 0; 95 _interrupted_old_gcs++; 96 } 97 98 void ShenandoahCollectorPolicy::record_success_degenerated(bool is_young, bool is_abbreviated) { 99 update_young(is_young); 100 101 _success_degenerated_gcs++; 102 _consecutive_degenerated_gcs++; 103 if (is_abbreviated) { 104 _abbreviated_degenerated_gcs++; 105 } 106 } 107 108 void ShenandoahCollectorPolicy::update_young(bool is_young) { 109 if (is_young) { 110 _consecutive_young_gcs++; 111 } else { 112 _consecutive_young_gcs = 0; 113 } 114 } 115 116 void ShenandoahCollectorPolicy::record_success_full() { 117 _consecutive_degenerated_gcs = 0; 118 _consecutive_young_gcs = 0; 119 _success_full_gcs++; 120 } 121 122 void ShenandoahCollectorPolicy::record_shutdown() { 123 _in_shutdown.set(); 124 } 125 126 bool ShenandoahCollectorPolicy::is_at_shutdown() { 127 return _in_shutdown.is_set(); 128 } 129 130 bool is_explicit_gc(GCCause::Cause cause) { 131 return GCCause::is_user_requested_gc(cause) 132 || GCCause::is_serviceability_requested_gc(cause); 133 } 134 135 bool is_implicit_gc(GCCause::Cause cause) { 136 return cause != GCCause::_no_gc 137 && cause != GCCause::_shenandoah_concurrent_gc 138 && cause != GCCause::_allocation_failure 139 && !is_explicit_gc(cause); 140 } 141 142 #ifdef ASSERT 143 bool is_valid_request(GCCause::Cause cause) { 144 return is_explicit_gc(cause) 145 || cause == GCCause::_metadata_GC_clear_soft_refs 146 || cause == GCCause::_codecache_GC_aggressive 147 || cause == GCCause::_codecache_GC_threshold 148 || cause == GCCause::_full_gc_alot 149 || cause == GCCause::_wb_young_gc 150 || cause == GCCause::_wb_full_gc 151 || cause == GCCause::_wb_breakpoint 152 || cause == GCCause::_scavenge_alot; 153 } 154 #endif 155 156 bool ShenandoahCollectorPolicy::is_requested_gc(GCCause::Cause cause) { 157 return is_explicit_gc(cause) || is_implicit_gc(cause); 158 } 159 160 bool ShenandoahCollectorPolicy::should_run_full_gc(GCCause::Cause cause) { 161 return is_explicit_gc(cause) ? !ExplicitGCInvokesConcurrent : !ShenandoahImplicitGCInvokesConcurrent; 162 } 163 164 bool ShenandoahCollectorPolicy::should_handle_requested_gc(GCCause::Cause cause) { 165 assert(is_valid_request(cause), "only requested GCs here: %s", GCCause::to_string(cause)); 166 167 if (DisableExplicitGC) { 168 return !is_explicit_gc(cause); 169 } 170 return true; 171 } 172 173 void ShenandoahCollectorPolicy::print_gc_stats(outputStream* out) const { 174 out->print_cr("Under allocation pressure, concurrent cycles may cancel, and either continue cycle"); 175 out->print_cr("under stop-the-world pause or result in stop-the-world Full GC. Increase heap size,"); 176 out->print_cr("tune GC heuristics, set more aggressive pacing delay, or lower allocation rate"); 177 out->print_cr("to avoid Degenerated and Full GC cycles. Abbreviated cycles are those which found"); 178 out->print_cr("enough regions with no live objects to skip evacuation."); 179 out->cr(); 180 181 size_t completed_gcs = _success_full_gcs + _success_degenerated_gcs + _success_concurrent_gcs + _success_old_gcs; 182 out->print_cr(SIZE_FORMAT_W(5) " Completed GCs", completed_gcs); 183 184 size_t explicit_requests = 0; 185 size_t implicit_requests = 0; 186 for (int c = 0; c < GCCause::_last_gc_cause; c++) { 187 size_t cause_count = _collection_cause_counts[c]; 188 if (cause_count > 0) { 189 auto cause = (GCCause::Cause) c; 190 if (is_explicit_gc(cause)) { 191 explicit_requests += cause_count; 192 } else if (is_implicit_gc(cause)) { 193 implicit_requests += cause_count; 194 } 195 const char* desc = GCCause::to_string(cause); 196 out->print_cr(" " SIZE_FORMAT_W(5) " caused by %s (%.2f%%)", cause_count, desc, percent_of(cause_count, completed_gcs)); 197 } 198 } 199 200 out->cr(); 201 out->print_cr(SIZE_FORMAT_W(5) " Successful Concurrent GCs (%.2f%%)", _success_concurrent_gcs, percent_of(_success_concurrent_gcs, completed_gcs)); 202 if (ExplicitGCInvokesConcurrent) { 203 out->print_cr(" " SIZE_FORMAT_W(5) " invoked explicitly (%.2f%%)", explicit_requests, percent_of(explicit_requests, _success_concurrent_gcs)); 204 } 205 if (ShenandoahImplicitGCInvokesConcurrent) { 206 out->print_cr(" " SIZE_FORMAT_W(5) " invoked implicitly (%.2f%%)", implicit_requests, percent_of(implicit_requests, _success_concurrent_gcs)); 207 } 208 out->print_cr(" " SIZE_FORMAT_W(5) " abbreviated (%.2f%%)", _abbreviated_concurrent_gcs, percent_of(_abbreviated_concurrent_gcs, _success_concurrent_gcs)); 209 out->cr(); 210 211 if (ShenandoahHeap::heap()->mode()->is_generational()) { 212 out->print_cr(SIZE_FORMAT_W(5) " Completed Old GCs (%.2f%%)", _success_old_gcs, percent_of(_success_old_gcs, completed_gcs)); 213 out->print_cr(" " SIZE_FORMAT_W(5) " mixed", _mixed_gcs); 214 out->print_cr(" " SIZE_FORMAT_W(5) " interruptions", _interrupted_old_gcs); 215 out->cr(); 216 } 217 218 size_t degenerated_gcs = _alloc_failure_degenerated_upgrade_to_full + _success_degenerated_gcs; 219 out->print_cr(SIZE_FORMAT_W(5) " Degenerated GCs (%.2f%%)", degenerated_gcs, percent_of(degenerated_gcs, completed_gcs)); 220 out->print_cr(" " SIZE_FORMAT_W(5) " upgraded to Full GC (%.2f%%)", _alloc_failure_degenerated_upgrade_to_full, percent_of(_alloc_failure_degenerated_upgrade_to_full, degenerated_gcs)); 221 out->print_cr(" " SIZE_FORMAT_W(5) " caused by allocation failure (%.2f%%)", _alloc_failure_degenerated, percent_of(_alloc_failure_degenerated, degenerated_gcs)); 222 out->print_cr(" " SIZE_FORMAT_W(5) " abbreviated (%.2f%%)", _abbreviated_degenerated_gcs, percent_of(_abbreviated_degenerated_gcs, degenerated_gcs)); 223 for (int c = 0; c < ShenandoahGC::_DEGENERATED_LIMIT; c++) { 224 if (_degen_point_counts[c] > 0) { 225 const char* desc = ShenandoahGC::degen_point_to_string((ShenandoahGC::ShenandoahDegenPoint)c); 226 out->print_cr(" " SIZE_FORMAT_W(5) " happened at %s", _degen_point_counts[c], desc); 227 } 228 } 229 out->cr(); 230 231 out->print_cr(SIZE_FORMAT_W(5) " Full GCs (%.2f%%)", _success_full_gcs, percent_of(_success_full_gcs, completed_gcs)); 232 if (!ExplicitGCInvokesConcurrent) { 233 out->print_cr(" " SIZE_FORMAT_W(5) " invoked explicitly (%.2f%%)", explicit_requests, percent_of(explicit_requests, _success_concurrent_gcs)); 234 } 235 if (!ShenandoahImplicitGCInvokesConcurrent) { 236 out->print_cr(" " SIZE_FORMAT_W(5) " invoked implicitly (%.2f%%)", implicit_requests, percent_of(implicit_requests, _success_concurrent_gcs)); 237 } 238 out->print_cr(" " SIZE_FORMAT_W(5) " caused by allocation failure (%.2f%%)", _alloc_failure_full, percent_of(_alloc_failure_full, _success_full_gcs)); 239 out->print_cr(" " SIZE_FORMAT_W(5) " upgraded from Degenerated GC (%.2f%%)", _alloc_failure_degenerated_upgrade_to_full, percent_of(_alloc_failure_degenerated_upgrade_to_full, _success_full_gcs)); 240 } --- EOF ---