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