1 /*
  2  * Copyright (c) 2017, 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 #ifndef SHARE_GC_SHENANDOAH_SHENANDOAHUTILS_HPP
 27 #define SHARE_GC_SHENANDOAH_SHENANDOAHUTILS_HPP
 28 
 29 #include "gc/shared/gcCause.hpp"
 30 #include "gc/shared/gcTraceTime.inline.hpp"
 31 #include "gc/shared/gcVMOperations.hpp"
 32 #include "gc/shared/isGCActiveMark.hpp"
 33 #include "gc/shared/suspendibleThreadSet.hpp"
 34 #include "gc/shared/workerThread.hpp"
 35 #include "gc/shenandoah/shenandoahPhaseTimings.hpp"
 36 #include "gc/shenandoah/shenandoahThreadLocalData.hpp"
 37 #include "jfr/jfrEvents.hpp"
 38 #include "memory/allocation.hpp"
 39 #include "runtime/safepoint.hpp"
 40 #include "runtime/vmThread.hpp"
 41 #include "runtime/vmOperations.hpp"
 42 #include "services/memoryService.hpp"
 43 
 44 class GCTimer;
 45 class ShenandoahGeneration;
 46 
 47 #define SHENANDOAH_RETURN_EVENT_MESSAGE(generation_type, prefix, postfix) \
 48   switch (generation_type) {                                              \
 49     case NON_GEN:                                                         \
 50       return prefix " (NON-GENERATIONAL)" postfix;                        \
 51     case GLOBAL:                                                          \
 52       return prefix " (GLOBAL)" postfix;                                  \
 53     case YOUNG:                                                           \
 54       return prefix " (YOUNG)" postfix;                                   \
 55     case OLD:                                                             \
 56       return prefix " (OLD)" postfix;                                     \
 57     default:                                                              \
 58       ShouldNotReachHere();                                               \
 59       return prefix " (UNKNOWN)" postfix;                                 \
 60   }                                                                       \
 61 
 62 class ShenandoahGCSession : public StackObj {
 63 private:
 64   ShenandoahHeap* const _heap;
 65   ShenandoahGeneration* const _generation;
 66   GCTimer*  const _timer;
 67   GCTracer* const _tracer;
 68 
 69   TraceMemoryManagerStats _trace_cycle;
 70 public:
 71   ShenandoahGCSession(GCCause::Cause cause, ShenandoahGeneration* generation);
 72   ~ShenandoahGCSession();
 73 };
 74 
 75 /*
 76  * ShenandoahGCPhaseTiming tracks Shenandoah specific timing information
 77  * of a GC phase
 78  */
 79 class ShenandoahTimingsTracker : public StackObj {
 80 private:
 81   static ShenandoahPhaseTimings::Phase  _current_phase;
 82 
 83   ShenandoahPhaseTimings* const         _timings;
 84   const ShenandoahPhaseTimings::Phase   _phase;
 85   const bool                            _should_aggregate;
 86   ShenandoahPhaseTimings::Phase         _parent_phase;
 87   double _start;
 88 
 89 public:
 90   ShenandoahTimingsTracker(ShenandoahPhaseTimings::Phase phase, bool should_aggregate = false);
 91   ~ShenandoahTimingsTracker();
 92 
 93   static ShenandoahPhaseTimings::Phase current_phase() { return _current_phase; }
 94 
 95   static bool is_current_phase_valid();
 96 };
 97 
 98 /*
 99  * ShenandoahPausePhase tracks a STW pause and emits Shenandoah timing and
100  * a corresponding JFR event
101  */
102 class ShenandoahPausePhase : public ShenandoahTimingsTracker {
103 private:
104   GCTraceTimeWrapper<LogLevel::Info, LOG_TAGS(gc)> _tracer;
105   ConcurrentGCTimer* const _timer;
106 
107 public:
108   ShenandoahPausePhase(const char* title, ShenandoahPhaseTimings::Phase phase, bool log_heap_usage = false);
109   ~ShenandoahPausePhase();
110 };
111 
112 /*
113  * ShenandoahConcurrentPhase tracks a concurrent GC phase and emits Shenandoah timing and
114  * a corresponding JFR event
115  */
116 class ShenandoahConcurrentPhase : public ShenandoahTimingsTracker {
117 private:
118   GCTraceTimeWrapper<LogLevel::Info, LOG_TAGS(gc)> _tracer;
119   ConcurrentGCTimer* const _timer;
120 
121 public:
122   ShenandoahConcurrentPhase(const char* title, ShenandoahPhaseTimings::Phase phase, bool log_heap_usage = false);
123   ~ShenandoahConcurrentPhase();
124 };
125 
126 /*
127  * ShenandoahGCPhase tracks Shenandoah specific timing information
128  * and emits a corresponding JFR event of a GC phase
129  */
130 class ShenandoahGCPhase : public ShenandoahTimingsTracker {
131 private:
132   ConcurrentGCTimer* const _timer;
133 
134 public:
135   ShenandoahGCPhase(ShenandoahPhaseTimings::Phase phase);
136   ~ShenandoahGCPhase();
137 };
138 
139 class ShenandoahGCWorkerPhase : public StackObj {
140 private:
141   ShenandoahPhaseTimings* const       _timings;
142   const ShenandoahPhaseTimings::Phase _phase;
143 public:
144   ShenandoahGCWorkerPhase(ShenandoahPhaseTimings::Phase phase);
145   ~ShenandoahGCWorkerPhase();
146 };
147 
148 // Aggregates all the things that should happen before/after the pause.
149 class ShenandoahGCPauseMark : public StackObj {
150 private:
151   ShenandoahHeap* const _heap;
152   const GCIdMark                _gc_id_mark;
153   const SvcGCMarker             _svc_gc_mark;
154   const IsSTWGCActiveMark       _is_gc_active_mark;
155   TraceMemoryManagerStats       _trace_pause;
156 
157 public:
158   ShenandoahGCPauseMark(uint gc_id, const char* notification_action, SvcGCMarker::reason_type type);
159 };
160 
161 class ShenandoahSafepoint : public AllStatic {
162 public:
163   // Check if Shenandoah GC safepoint is in progress. This is nominally
164   // equivalent to calling SafepointSynchronize::is_at_safepoint(), but
165   // it also checks the Shenandoah specifics, when it can.
166   static inline bool is_at_shenandoah_safepoint() {
167     if (!SafepointSynchronize::is_at_safepoint()) return false;
168 
169     Thread* const thr = Thread::current();
170     // Shenandoah GC specific safepoints are scheduled by control thread.
171     // So if we are enter here from control thread, then we are definitely not
172     // at Shenandoah safepoint, but at something else.
173     if (thr == ShenandoahHeap::heap()->control_thread()) return false;
174 
175     // This is not VM thread, cannot see what VM thread is doing,
176     // so pretend this is a proper Shenandoah safepoint
177     if (!thr->is_VM_thread()) return true;
178 
179     // Otherwise check we are at proper operation type
180     VM_Operation* vm_op = VMThread::vm_operation();
181     if (vm_op == nullptr) return false;
182 
183     VM_Operation::VMOp_Type type = vm_op->type();
184     return type == VM_Operation::VMOp_ShenandoahInitMark ||
185            type == VM_Operation::VMOp_ShenandoahFinalMarkStartEvac ||
186            type == VM_Operation::VMOp_ShenandoahInitUpdateRefs ||
187            type == VM_Operation::VMOp_ShenandoahFinalUpdateRefs ||
188            type == VM_Operation::VMOp_ShenandoahFinalRoots ||
189            type == VM_Operation::VMOp_ShenandoahFullGC ||
190            type == VM_Operation::VMOp_ShenandoahDegeneratedGC;
191   }
192 };
193 
194 class ShenandoahWorkerSession : public StackObj {
195 protected:
196   ShenandoahWorkerSession(uint worker_id);
197 public:
198   static inline uint worker_id() {
199     return WorkerThread::worker_id();
200   }
201 };
202 
203 class ShenandoahConcurrentWorkerSession : public ShenandoahWorkerSession {
204 private:
205   EventGCPhaseConcurrent _event;
206 
207 public:
208   ShenandoahConcurrentWorkerSession(uint worker_id) : ShenandoahWorkerSession(worker_id) { }
209   ~ShenandoahConcurrentWorkerSession();
210 };
211 
212 class ShenandoahParallelWorkerSession : public ShenandoahWorkerSession {
213 private:
214   EventGCPhaseParallel _event;
215 
216 public:
217   ShenandoahParallelWorkerSession(uint worker_id) : ShenandoahWorkerSession(worker_id) { }
218   ~ShenandoahParallelWorkerSession();
219 };
220 
221 class ShenandoahSuspendibleThreadSetJoiner {
222 private:
223   SuspendibleThreadSetJoiner _joiner;
224 public:
225   ShenandoahSuspendibleThreadSetJoiner(bool active = true) : _joiner(active) {
226     assert(!ShenandoahThreadLocalData::is_evac_allowed(Thread::current()), "STS should be joined before evac scope");
227   }
228   ~ShenandoahSuspendibleThreadSetJoiner() {
229     assert(!ShenandoahThreadLocalData::is_evac_allowed(Thread::current()), "STS should be left after evac scope");
230   }
231 };
232 
233 class ShenandoahSuspendibleThreadSetLeaver {
234 private:
235   SuspendibleThreadSetLeaver _leaver;
236 public:
237   ShenandoahSuspendibleThreadSetLeaver(bool active = true) : _leaver(active) {
238     assert(!ShenandoahThreadLocalData::is_evac_allowed(Thread::current()), "STS should be left after evac scope");
239   }
240   ~ShenandoahSuspendibleThreadSetLeaver() {
241     assert(!ShenandoahThreadLocalData::is_evac_allowed(Thread::current()), "STS should be joined before evac scope");
242   }
243 };
244 
245 #endif // SHARE_GC_SHENANDOAH_SHENANDOAHUTILS_HPP
--- EOF ---