1 /* 2 * Copyright (c) 2013, 2021, Red Hat, Inc. All rights reserved. 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * This code is free software; you can redistribute it and/or modify it 6 * under the terms of the GNU General Public License version 2 only, as 7 * published by the Free Software Foundation. 8 * 9 * This code is distributed in the hope that it will be useful, but WITHOUT 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 12 * version 2 for more details (a copy is included in the LICENSE file that 13 * accompanied this code). 14 * 15 * You should have received a copy of the GNU General Public License version 16 * 2 along with this work; if not, write to the Free Software Foundation, 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 18 * 19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 20 * or visit www.oracle.com if you need additional information or have any 21 * questions. 22 * 23 */ 24 25 #ifndef SHARE_GC_SHENANDOAH_SHENANDOAHCONTROLTHREAD_HPP 26 #define SHARE_GC_SHENANDOAH_SHENANDOAHCONTROLTHREAD_HPP 27 28 #include "gc/shared/gcCause.hpp" 29 #include "gc/shared/concurrentGCThread.hpp" 30 #include "gc/shenandoah/shenandoahGC.hpp" 31 #include "gc/shenandoah/shenandoahHeap.hpp" 32 #include "gc/shenandoah/shenandoahPadding.hpp" 33 #include "gc/shenandoah/shenandoahSharedVariables.hpp" 34 #include "runtime/task.hpp" 35 #include "utilities/ostream.hpp" 36 37 // Periodic task is useful for doing asynchronous things that do not require (heap) locks, 38 // or synchronization with other parts of collector. These could run even when ShenandoahConcurrentThread 39 // is busy driving the GC cycle. 40 class ShenandoahPeriodicTask : public PeriodicTask { 41 private: 42 ShenandoahControlThread* _thread; 43 public: 44 ShenandoahPeriodicTask(ShenandoahControlThread* thread) : 45 PeriodicTask(100), _thread(thread) {} 46 virtual void task(); 47 }; 48 49 // Periodic task to notify blocked paced waiters. 50 class ShenandoahPeriodicPacerNotify : public PeriodicTask { 51 public: 52 ShenandoahPeriodicPacerNotify() : PeriodicTask(PeriodicTask::min_interval) {} 53 virtual void task(); 54 }; 55 56 class ShenandoahControlThread: public ConcurrentGCThread { 57 friend class VMStructs; 58 59 private: 60 // While we could have a single lock for these, it may risk unblocking 61 // GC waiters when alloc failure GC cycle finishes. We want instead 62 // to make complete explicit cycle for demanding customers. 63 Monitor _alloc_failure_waiters_lock; 64 Monitor _gc_waiters_lock; 65 Monitor _control_lock; 66 Monitor _regulator_lock; 67 ShenandoahPeriodicTask _periodic_task; 68 ShenandoahPeriodicPacerNotify _periodic_pacer_notify_task; 69 70 public: 71 typedef enum { 72 none, 73 concurrent_normal, 74 stw_degenerated, 75 stw_full, 76 servicing_old 77 } GCMode; 78 79 void run_service(); 80 void stop_service(); 81 82 size_t get_gc_id(); 83 84 private: 85 ShenandoahSharedFlag _allow_old_preemption; 86 ShenandoahSharedFlag _preemption_requested; 87 ShenandoahSharedFlag _gc_requested; 88 ShenandoahSharedFlag _alloc_failure_gc; 89 ShenandoahSharedFlag _graceful_shutdown; 90 ShenandoahSharedFlag _do_counters_update; 91 ShenandoahSharedFlag _force_counters_update; 92 GCCause::Cause _requested_gc_cause; 93 GenerationMode _requested_generation; 94 ShenandoahGC::ShenandoahDegenPoint _degen_point; 95 ShenandoahGeneration* _degen_generation; 96 97 shenandoah_padding(0); 98 volatile size_t _allocs_seen; 99 shenandoah_padding(1); 100 volatile size_t _gc_id; 101 shenandoah_padding(2); 102 volatile GCMode _mode; 103 shenandoah_padding(3); 104 105 // Returns true if the cycle has been cancelled or degenerated. 106 bool check_cancellation_or_degen(ShenandoahGC::ShenandoahDegenPoint point); 107 108 // Returns true if the old generation marking completed (i.e., final mark executed for old generation). 109 bool resume_concurrent_old_cycle(ShenandoahGeneration* generation, GCCause::Cause cause); 110 void service_concurrent_cycle(ShenandoahGeneration* generation, GCCause::Cause cause, bool reset_old_bitmap_specially); 111 void service_stw_full_cycle(GCCause::Cause cause); 112 113 // Return true if degenerated cycle finishes normally. Return false if the degenerated cycle transformed itself 114 // into a full GC. 115 bool service_stw_degenerated_cycle(GCCause::Cause cause, ShenandoahGC::ShenandoahDegenPoint point); 116 void service_uncommit(double shrink_before, size_t shrink_until); 117 118 // Return true if setting the flag which indicates allocation failure succeeds. 119 bool try_set_alloc_failure_gc(); 120 // Notify threads waiting for GC to complete. 121 void notify_alloc_failure_waiters(); 122 // True if allocation failure flag has been set. 123 bool is_alloc_failure_gc(); 124 125 void reset_gc_id(); 126 void update_gc_id(); 127 128 void notify_gc_waiters(); 129 130 // Handle GC request. 131 // Blocks until GC is over. 132 void handle_requested_gc(GCCause::Cause cause); 133 134 bool is_explicit_gc(GCCause::Cause cause) const; 135 bool is_implicit_gc(GCCause::Cause cause) const; 136 137 // Returns true if the old generation marking was interrupted to allow a young cycle. 138 bool preempt_old_marking(GenerationMode generation); 139 140 // Returns true if the soft maximum heap has been changed using management APIs. 141 bool check_soft_max_changed() const; 142 143 void process_phase_timings(const ShenandoahHeap* heap); 144 145 public: 146 // Constructor 147 ShenandoahControlThread(); 148 ~ShenandoahControlThread(); 149 150 // Handle allocation failure from normal allocation. 151 // Blocks until memory is available. 152 void handle_alloc_failure(ShenandoahAllocRequest& req); 153 154 // Handle allocation failure from evacuation path. 155 // Optionally blocks while collector is handling the failure. 156 void handle_alloc_failure_evac(size_t words); 157 158 void request_gc(GCCause::Cause cause); 159 // Return true if the request to start a concurrent GC for the given generation succeeded. 160 bool request_concurrent_gc(GenerationMode generation); 161 162 void handle_counters_update(); 163 void handle_force_counters_update(); 164 void set_forced_counters_update(bool value); 165 166 void notify_heap_changed(); 167 168 void pacing_notify_alloc(size_t words); 169 170 void start(); 171 void prepare_for_graceful_shutdown(); 172 bool in_graceful_shutdown(); 173 174 void service_concurrent_normal_cycle(const ShenandoahHeap* heap, 175 const GenerationMode generation, 176 GCCause::Cause cause); 177 178 void service_concurrent_old_cycle(const ShenandoahHeap* heap, 179 GCCause::Cause &cause); 180 181 void set_gc_mode(GCMode new_mode); 182 GCMode gc_mode() { 183 return _mode; 184 } 185 186 private: 187 static const char* gc_mode_name(GCMode mode); 188 void notify_control_thread(); 189 190 void service_concurrent_cycle(const ShenandoahHeap* heap, ShenandoahGeneration* generation, GCCause::Cause &cause, 191 bool do_old_gc_bootstrap); 192 193 }; 194 195 #endif // SHARE_GC_SHENANDOAH_SHENANDOAHCONTROLTHREAD_HPP