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