1 /*
  2  * Copyright (c) 2013, 2021, Red Hat, Inc. All rights reserved.
  3  * Copyright (C) 2022 THL A29 Limited, a Tencent company. 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 "gc/shenandoah/heuristics/shenandoahHeuristics.hpp"
 27 #include "gc/shenandoah/mode/shenandoahMode.hpp"
 28 #include "gc/shenandoah/shenandoahCollectorPolicy.hpp"
 29 #include "gc/shenandoah/shenandoahConcurrentGC.hpp"
 30 #include "gc/shenandoah/shenandoahControlThread.hpp"
 31 #include "gc/shenandoah/shenandoahDegeneratedGC.hpp"
 32 #include "gc/shenandoah/shenandoahFreeSet.hpp"
 33 #include "gc/shenandoah/shenandoahFullGC.hpp"
 34 #include "gc/shenandoah/shenandoahGeneration.hpp"
 35 #include "gc/shenandoah/shenandoahHeap.inline.hpp"
 36 #include "gc/shenandoah/shenandoahMonitoringSupport.hpp"
 37 #include "gc/shenandoah/shenandoahPacer.inline.hpp"
 38 #include "gc/shenandoah/shenandoahUtils.hpp"
 39 #include "logging/log.hpp"
 40 #include "memory/metaspaceStats.hpp"
 41 #include "memory/metaspaceUtils.hpp"
 42 
 43 ShenandoahControlThread::ShenandoahControlThread() :
 44   ShenandoahController(),
 45   _requested_gc_cause(GCCause::_no_cause_specified),
 46   _degen_point(ShenandoahGC::_degenerated_outside_cycle) {
 47   set_name("Shenandoah Control Thread");
 48   create_and_start();
 49 }
 50 
 51 void ShenandoahControlThread::run_service() {
 52   ShenandoahHeap* const heap = ShenandoahHeap::heap();
 53   const GCMode default_mode = concurrent_normal;
 54   const GCCause::Cause default_cause = GCCause::_shenandoah_concurrent_gc;
 55   int sleep = ShenandoahControlIntervalMin;
 56 
 57   double last_sleep_adjust_time = os::elapsedTime();
 58 
 59   ShenandoahCollectorPolicy* const policy = heap->shenandoah_policy();
 60   ShenandoahHeuristics* const heuristics = heap->heuristics();
 61   while (!should_terminate()) {
 62     const GCCause::Cause cancelled_cause = heap->cancelled_cause();
 63     if (cancelled_cause == GCCause::_shenandoah_stop_vm) {
 64       break;
 65     }
 66 
 67     // Figure out if we have pending requests.
 68     const bool alloc_failure_pending = ShenandoahCollectorPolicy::is_allocation_failure(cancelled_cause);
 69     const bool is_gc_requested = _gc_requested.is_set();
 70     const GCCause::Cause requested_gc_cause = _requested_gc_cause;
 71 
 72     // This control loop iteration has seen this much allocation.
 73     const size_t allocs_seen = reset_allocs_seen();
 74 
 75     // Choose which GC mode to run in. The block below should select a single mode.
 76     GCMode mode = none;
 77     GCCause::Cause cause = GCCause::_last_gc_cause;
 78     ShenandoahGC::ShenandoahDegenPoint degen_point = ShenandoahGC::_degenerated_unset;
 79 
 80     if (alloc_failure_pending) {
 81       // Allocation failure takes precedence: we have to deal with it first thing
 82       heuristics->log_trigger("Handle Allocation Failure");
 83 
 84       cause = GCCause::_allocation_failure;
 85 
 86       // Consume the degen point, and seed it with default value
 87       degen_point = _degen_point;
 88       _degen_point = ShenandoahGC::_degenerated_outside_cycle;
 89 
 90       if (ShenandoahDegeneratedGC && heuristics->should_degenerate_cycle()) {
 91         heuristics->record_allocation_failure_gc();
 92         policy->record_alloc_failure_to_degenerated(degen_point);
 93         mode = stw_degenerated;
 94       } else {
 95         heuristics->record_allocation_failure_gc();
 96         policy->record_alloc_failure_to_full();
 97         mode = stw_full;
 98       }
 99     } else if (is_gc_requested) {
100       cause = requested_gc_cause;
101       heuristics->log_trigger("GC request (%s)", GCCause::to_string(cause));
102       heuristics->record_requested_gc();
103 
104       if (ShenandoahCollectorPolicy::should_run_full_gc(cause)) {
105         mode = stw_full;
106       } else {
107         mode = default_mode;
108         // Unload and clean up everything
109         heap->set_unload_classes(heuristics->can_unload_classes());
110       }
111     } else {
112       // Potential normal cycle: ask heuristics if it wants to act
113       if (heuristics->should_start_gc()) {
114         mode = default_mode;
115         cause = default_cause;
116       }
117 
118       // Ask policy if this cycle wants to process references or unload classes
119       heap->set_unload_classes(heuristics->should_unload_classes());
120     }
121 
122     // Blow all soft references on this cycle, if handling allocation failure,
123     // either implicit or explicit GC request,  or we are requested to do so unconditionally.
124     if (alloc_failure_pending || is_gc_requested || ShenandoahAlwaysClearSoftRefs) {
125       heap->soft_ref_policy()->set_should_clear_all_soft_refs(true);
126     }
127 
128     const bool gc_requested = (mode != none);
129     assert (!gc_requested || cause != GCCause::_last_gc_cause, "GC cause should be set");
130 
131     if (gc_requested) {
132       // Cannot uncommit bitmap slices during concurrent reset
133       ShenandoahNoUncommitMark forbid_region_uncommit(heap);
134 
135       // GC is starting, bump the internal ID
136       update_gc_id();
137 
138       GCIdMark gc_id_mark;
139 
140       heuristics->cancel_trigger_request();
141 
142       heap->reset_bytes_allocated_since_gc_start();
143 
144       MetaspaceCombinedStats meta_sizes = MetaspaceUtils::get_combined_statistics();
145 
146       // If GC was requested, we are sampling the counters even without actual triggers
147       // from allocation machinery. This captures GC phases more accurately.
148       heap->set_forced_counters_update(true);
149 
150       // If GC was requested, we better dump freeset data for performance debugging
151       heap->free_set()->log_status_under_lock();
152 
153       switch (mode) {
154         case concurrent_normal:
155           service_concurrent_normal_cycle(cause);
156           break;
157         case stw_degenerated:
158           service_stw_degenerated_cycle(cause, degen_point);
159           break;
160         case stw_full:
161           service_stw_full_cycle(cause);
162           break;
163         default:
164           ShouldNotReachHere();
165       }
166 
167       // If this was the requested GC cycle, notify waiters about it
168       if (is_gc_requested) {
169         notify_gc_waiters();
170       }
171 
172       // If this cycle completed without being cancelled, notify waiters about it
173       if (!heap->cancelled_gc()) {
174         notify_alloc_failure_waiters();
175       }
176 
177       // Report current free set state at the end of cycle, whether
178       // it is a normal completion, or the abort.
179       heap->free_set()->log_status_under_lock();
180 
181       {
182         // Notify Universe about new heap usage. This has implications for
183         // global soft refs policy, and we better report it every time heap
184         // usage goes down.
185         ShenandoahHeapLocker locker(heap->lock());
186         heap->update_capacity_and_used_at_gc();
187       }
188 
189       // Signal that we have completed a visit to all live objects.
190       heap->record_whole_heap_examined_timestamp();
191 
192       // Disable forced counters update, and update counters one more time
193       // to capture the state at the end of GC session.
194       heap->handle_force_counters_update();
195       heap->set_forced_counters_update(false);
196 
197       // Retract forceful part of soft refs policy
198       heap->soft_ref_policy()->set_should_clear_all_soft_refs(false);
199 
200       // Clear metaspace oom flag, if current cycle unloaded classes
201       if (heap->unload_classes()) {
202         heuristics->clear_metaspace_oom();
203       }
204 
205       // Commit worker statistics to cycle data
206       heap->phase_timings()->flush_par_workers_to_cycle();
207       if (ShenandoahPacing) {
208         heap->pacer()->flush_stats_to_cycle();
209       }
210 
211       // Print GC stats for current cycle
212       {
213         LogTarget(Info, gc, stats) lt;
214         if (lt.is_enabled()) {
215           ResourceMark rm;
216           LogStream ls(lt);
217           heap->phase_timings()->print_cycle_on(&ls);
218           if (ShenandoahPacing) {
219             heap->pacer()->print_cycle_on(&ls);
220           }
221         }
222       }
223 
224       // Commit statistics to globals
225       heap->phase_timings()->flush_cycle_to_global();
226 
227       // Print Metaspace change following GC (if logging is enabled).
228       MetaspaceUtils::print_metaspace_change(meta_sizes);
229 
230       // GC is over, we are at idle now
231       if (ShenandoahPacing) {
232         heap->pacer()->setup_for_idle();
233       }
234     } else {
235       // Report to pacer that we have seen this many words allocated
236       if (ShenandoahPacing && (allocs_seen > 0)) {
237         heap->pacer()->report_alloc(allocs_seen);
238       }
239     }
240 
241     // Check if we have seen a new target for soft max heap size or if a gc was requested.
242     // Either of these conditions will attempt to uncommit regions.
243     if (ShenandoahUncommit) {
244       if (heap->check_soft_max_changed()) {
245         heap->notify_soft_max_changed();
246       } else if (is_gc_requested) {
247         heap->notify_explicit_gc_requested();
248       }
249     }
250 
251     // Wait before performing the next action. If allocation happened during this wait,
252     // we exit sooner, to let heuristics re-evaluate new conditions. If we are at idle,
253     // back off exponentially.
254     const double current = os::elapsedTime();
255     if (heap->has_changed()) {
256       sleep = ShenandoahControlIntervalMin;
257     } else if ((current - last_sleep_adjust_time) * 1000 > ShenandoahControlIntervalAdjustPeriod){
258       sleep = MIN2<int>(ShenandoahControlIntervalMax, MAX2(1, sleep * 2));
259       last_sleep_adjust_time = current;
260     }
261     os::naked_short_sleep(sleep);
262   }
263 }
264 
265 void ShenandoahControlThread::service_concurrent_normal_cycle(GCCause::Cause cause) {
266   // Normal cycle goes via all concurrent phases. If allocation failure (af) happens during
267   // any of the concurrent phases, it first degrades to Degenerated GC and completes GC there.
268   // If second allocation failure happens during Degenerated GC cycle (for example, when GC
269   // tries to evac something and no memory is available), cycle degrades to Full GC.
270   //
271   // There are also a shortcut through the normal cycle: immediate garbage shortcut, when
272   // heuristics says there are no regions to compact, and all the collection comes from immediately
273   // reclaimable regions.
274   //
275   // ................................................................................................
276   //
277   //                                    (immediate garbage shortcut)                Concurrent GC
278   //                             /-------------------------------------------\
279   //                             |                                           |
280   //                             |                                           |
281   //                             |                                           |
282   //                             |                                           v
283   // [START] ----> Conc Mark ----o----> Conc Evac --o--> Conc Update-Refs ---o----> [END]
284   //                   |                    |                 |              ^
285   //                   | (af)               | (af)            | (af)         |
286   // ..................|....................|.................|..............|.......................
287   //                   |                    |                 |              |
288   //                   |                    |                 |              |      Degenerated GC
289   //                   v                    v                 v              |
290   //               STW Mark ----------> STW Evac ----> STW Update-Refs ----->o
291   //                   |                    |                 |              ^
292   //                   | (af)               | (af)            | (af)         |
293   // ..................|....................|.................|..............|.......................
294   //                   |                    |                 |              |
295   //                   |                    v                 |              |      Full GC
296   //                   \------------------->o<----------------/              |
297   //                                        |                                |
298   //                                        v                                |
299   //                                      Full GC  --------------------------/
300   //
301   ShenandoahHeap* heap = ShenandoahHeap::heap();
302   if (check_cancellation_or_degen(ShenandoahGC::_degenerated_outside_cycle)) {
303     log_info(gc)("Cancelled");
304     return;
305   }
306 
307   ShenandoahGCSession session(cause, heap->global_generation());
308 
309   TraceCollectorStats tcs(heap->monitoring_support()->concurrent_collection_counters());
310 
311   ShenandoahConcurrentGC gc(heap->global_generation(), false);
312   if (gc.collect(cause)) {
313     // Cycle is complete.  There were no failed allocation requests and no degeneration, so count this as good progress.
314     heap->notify_gc_progress();
315     heap->global_generation()->heuristics()->record_success_concurrent();
316     heap->shenandoah_policy()->record_success_concurrent(false, gc.abbreviated());
317     heap->log_heap_status("At end of GC");
318   } else {
319     assert(heap->cancelled_gc(), "Must have been cancelled");
320     check_cancellation_or_degen(gc.degen_point());
321     heap->log_heap_status("At end of cancelled GC");
322   }
323 }
324 
325 bool ShenandoahControlThread::check_cancellation_or_degen(ShenandoahGC::ShenandoahDegenPoint point) {
326   ShenandoahHeap* heap = ShenandoahHeap::heap();
327   if (heap->cancelled_gc()) {
328     if (heap->cancelled_cause() == GCCause::_shenandoah_stop_vm) {
329       return true;
330     }
331 
332     if (ShenandoahCollectorPolicy::is_allocation_failure(heap->cancelled_cause())) {
333       assert (_degen_point == ShenandoahGC::_degenerated_outside_cycle,
334               "Should not be set yet: %s", ShenandoahGC::degen_point_to_string(_degen_point));
335       _degen_point = point;
336       return true;
337     }
338 
339     fatal("Unexpected reason for cancellation: %s", GCCause::to_string(heap->cancelled_cause()));
340   }
341   return false;
342 }
343 
344 void ShenandoahControlThread::stop_service() {
345   ShenandoahHeap::heap()->cancel_gc(GCCause::_shenandoah_stop_vm);
346 }
347 
348 void ShenandoahControlThread::service_stw_full_cycle(GCCause::Cause cause) {
349   ShenandoahHeap* const heap = ShenandoahHeap::heap();
350   ShenandoahGCSession session(cause, heap->global_generation());
351 
352   ShenandoahFullGC gc;
353   gc.collect(cause);
354 }
355 
356 void ShenandoahControlThread::service_stw_degenerated_cycle(GCCause::Cause cause, ShenandoahGC::ShenandoahDegenPoint point) {
357   assert (point != ShenandoahGC::_degenerated_unset, "Degenerated point should be set");
358   ShenandoahHeap* const heap = ShenandoahHeap::heap();
359   ShenandoahGCSession session(cause, heap->global_generation());
360 
361   ShenandoahDegenGC gc(point, heap->global_generation());
362   gc.collect(cause);
363 }
364 
365 void ShenandoahControlThread::request_gc(GCCause::Cause cause) {
366   if (ShenandoahCollectorPolicy::should_handle_requested_gc(cause)) {
367     handle_requested_gc(cause);
368   }
369 }
370 
371 void ShenandoahControlThread::handle_requested_gc(GCCause::Cause cause) {
372   if (should_terminate()) {
373     log_info(gc)("Control thread is terminating, no more GCs");
374     return;
375   }
376 
377   // For normal requested GCs (System.gc) we want to block the caller. However,
378   // for whitebox requested GC, we want to initiate the GC and return immediately.
379   // The whitebox caller thread will arrange for itself to wait until the GC notifies
380   // it that has reached the requested breakpoint (phase in the GC).
381   if (cause == GCCause::_wb_breakpoint) {
382     _requested_gc_cause = cause;
383     _gc_requested.set();
384     return;
385   }
386 
387   // Make sure we have at least one complete GC cycle before unblocking
388   // from the explicit GC request.
389   //
390   // This is especially important for weak references cleanup and/or native
391   // resources (e.g. DirectByteBuffers) machinery: when explicit GC request
392   // comes very late in the already running cycle, it would miss lots of new
393   // opportunities for cleanup that were made available before the caller
394   // requested the GC.
395 
396   MonitorLocker ml(&_gc_waiters_lock);
397   size_t current_gc_id = get_gc_id();
398   size_t required_gc_id = current_gc_id + 1;
399   while (current_gc_id < required_gc_id && !should_terminate()) {
400     // Although setting gc request is under _gc_waiters_lock, but read side (run_service())
401     // does not take the lock. We need to enforce following order, so that read side sees
402     // latest requested gc cause when the flag is set.
403     _requested_gc_cause = cause;
404     _gc_requested.set();
405 
406     ml.wait();
407     current_gc_id = get_gc_id();
408   }
409 }
410 
411 void ShenandoahControlThread::notify_gc_waiters() {
412   _gc_requested.unset();
413   MonitorLocker ml(&_gc_waiters_lock);
414   ml.notify_all();
415 }