1 /*
2 * Copyright (c) 2019, Red Hat, Inc. All rights reserved.
3 *
4 * This code is free software; you can redistribute it and/or modify it
5 * under the terms of the GNU General Public License version 2 only, as
6 * published by the Free Software Foundation.
7 *
8 * This code is distributed in the hope that it will be useful, but WITHOUT
9 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
10 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
11 * version 2 for more details (a copy is included in the LICENSE file that
12 * accompanied this code).
13 *
14 * You should have received a copy of the GNU General Public License version
15 * 2 along with this work; if not, write to the Free Software Foundation,
16 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
17 *
18 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
19 * or visit www.oracle.com if you need additional information or have any
20 * questions.
21 *
22 */
23
24 #ifndef SHARE_GC_SHENANDOAH_SHENANDOAHROOTPROCESSOR_INLINE_HPP
25 #define SHARE_GC_SHENANDOAH_SHENANDOAHROOTPROCESSOR_INLINE_HPP
26
27 #include "classfile/classLoaderDataGraph.hpp"
28 #include "gc/shared/oopStorageParState.inline.hpp"
29 #include "gc/shenandoah/shenandoahHeuristics.hpp"
30 #include "gc/shenandoah/shenandoahRootProcessor.hpp"
31 #include "gc/shenandoah/shenandoahTimingTracker.hpp"
32 #include "gc/shenandoah/shenandoahUtils.hpp"
33 #include "memory/resourceArea.hpp"
34
35 template <bool CONCURRENT>
36 ShenandoahJNIHandleRoots<CONCURRENT>::ShenandoahJNIHandleRoots() :
37 _claimed(false),
38 _itr(JNIHandles::global_handles()) {
39 }
40
41 template <bool CONCURRENT>
42 template <typename T>
43 void ShenandoahJNIHandleRoots<CONCURRENT>::oops_do(T* cl, uint worker_id) {
44 if (CONCURRENT) {
45 _itr.oops_do(cl);
46 } else {
47 if (!_claimed && Atomic::cmpxchg(true, &_claimed, false) == false) {
48 ShenandoahWorkerTimings* worker_times = ShenandoahHeap::heap()->phase_timings()->worker_times();
49 ShenandoahWorkerTimingsTracker timer(worker_times, ShenandoahPhaseTimings::JNIRoots, worker_id);
50 _itr.oops_do(cl);
51 }
52 }
53 }
54
55 template <typename IsAlive, typename KeepAlive>
56 void ShenandoahWeakRoots::oops_do(IsAlive* is_alive, KeepAlive* keep_alive, uint worker_id) {
57 _task.work<IsAlive, KeepAlive>(worker_id, is_alive, keep_alive);
58 }
59
60 template <bool CONCURRENT>
61 ShenandoahClassLoaderDataRoots<CONCURRENT>::ShenandoahClassLoaderDataRoots() {
62 ClassLoaderDataGraph::clear_claimed_marks();
63 if (CONCURRENT) {
64 ClassLoaderDataGraph_lock->lock();
65 }
66 }
67
68 template <bool CONCURRENT>
69 ShenandoahClassLoaderDataRoots<CONCURRENT>::~ShenandoahClassLoaderDataRoots() {
70 if (CONCURRENT) {
71 ClassLoaderDataGraph_lock->unlock();
72 }
73 }
74
75 template <bool CONCURRENT>
76 void ShenandoahClassLoaderDataRoots<CONCURRENT>::always_strong_cld_do(CLDClosure* clds, uint worker_id) {
77 if (CONCURRENT) {
78 ClassLoaderDataGraph::always_strong_cld_do(clds);
79 } else {
80 ShenandoahWorkerTimings* worker_times = ShenandoahHeap::heap()->phase_timings()->worker_times();
81 ShenandoahWorkerTimingsTracker timer(worker_times, ShenandoahPhaseTimings::CLDGRoots, worker_id);
82 ClassLoaderDataGraph::always_strong_cld_do(clds);
83 }
84 }
85
86 template <bool CONCURRENT>
87 void ShenandoahClassLoaderDataRoots<CONCURRENT>::cld_do(CLDClosure* clds, uint worker_id) {
88 if (CONCURRENT) {
89 ClassLoaderDataGraph::cld_do(clds);
90 } else {
91 ShenandoahWorkerTimings* worker_times = ShenandoahHeap::heap()->phase_timings()->worker_times();
92 ShenandoahWorkerTimingsTracker timer(worker_times, ShenandoahPhaseTimings::CLDGRoots, worker_id);
93 ClassLoaderDataGraph::cld_do(clds);
94 }
95 }
96
97 template <typename ITR>
98 ShenandoahCodeCacheRoots<ITR>::ShenandoahCodeCacheRoots() {
99 nmethod::oops_do_marking_prologue();
100 }
101
102 template <typename ITR>
103 void ShenandoahCodeCacheRoots<ITR>::code_blobs_do(CodeBlobClosure* blob_cl, uint worker_id) {
104 ShenandoahWorkerTimings* worker_times = ShenandoahHeap::heap()->phase_timings()->worker_times();
105 ShenandoahWorkerTimingsTracker timer(worker_times, ShenandoahPhaseTimings::CodeCacheRoots, worker_id);
106 _coderoots_iterator.possibly_parallel_blobs_do(blob_cl);
107 }
108
109 template <typename ITR>
110 ShenandoahCodeCacheRoots<ITR>::~ShenandoahCodeCacheRoots() {
111 nmethod::oops_do_marking_epilogue();
112 }
113
114 class ShenandoahParallelOopsDoThreadClosure : public ThreadClosure {
115 private:
116 OopClosure* _f;
117 CodeBlobClosure* _cf;
118 ThreadClosure* _thread_cl;
119 public:
120 ShenandoahParallelOopsDoThreadClosure(OopClosure* f, CodeBlobClosure* cf, ThreadClosure* thread_cl) :
121 _f(f), _cf(cf), _thread_cl(thread_cl) {}
122
123 void do_thread(Thread* t) {
124 if (_thread_cl != NULL) {
125 _thread_cl->do_thread(t);
126 }
127 t->oops_do(_f, _cf);
128 }
129 };
130
131 template <typename ITR>
132 ShenandoahRootScanner<ITR>::ShenandoahRootScanner(uint n_workers, ShenandoahPhaseTimings::Phase phase) :
133 ShenandoahRootProcessor(phase),
134 _thread_roots(n_workers > 1) {
135 }
136
137 template <typename ITR>
138 void ShenandoahRootScanner<ITR>::roots_do(uint worker_id, OopClosure* oops) {
139 CLDToOopClosure clds_cl(oops, ClassLoaderData::_claim_strong);
140 MarkingCodeBlobClosure blobs_cl(oops, !CodeBlobToOopClosure::FixRelocations);
141 roots_do(worker_id, oops, &clds_cl, &blobs_cl);
142 }
143
144 template <typename ITR>
145 void ShenandoahRootScanner<ITR>::strong_roots_do(uint worker_id, OopClosure* oops) {
146 CLDToOopClosure clds_cl(oops, ClassLoaderData::_claim_strong);
147 MarkingCodeBlobClosure blobs_cl(oops, !CodeBlobToOopClosure::FixRelocations);
148 strong_roots_do(worker_id, oops, &clds_cl, &blobs_cl);
149 }
150
151 template <typename ITR>
152 void ShenandoahRootScanner<ITR>::roots_do(uint worker_id, OopClosure* oops, CLDClosure* clds, CodeBlobClosure* code, ThreadClosure *tc) {
153 assert(!ShenandoahSafepoint::is_at_shenandoah_safepoint() ||
154 !ShenandoahHeap::heap()->unload_classes() ||
155 ShenandoahHeap::heap()->heuristics()->can_do_traversal_gc(),
156 "Expect class unloading or traversal when Shenandoah cycle is running");
157 ShenandoahParallelOopsDoThreadClosure tc_cl(oops, code, tc);
158 ResourceMark rm;
159
160 _serial_roots.oops_do(oops, worker_id);
161 _jni_roots.oops_do(oops, worker_id);
162
163 if (clds != NULL) {
164 _cld_roots.cld_do(clds, worker_id);
165 } else {
166 assert(ShenandoahHeap::heap()->is_concurrent_traversal_in_progress(), "Only possible with traversal GC");
167 }
168
169 _thread_roots.threads_do(&tc_cl, worker_id);
170
171 // With ShenandoahConcurrentScanCodeRoots, we avoid scanning the entire code cache here,
172 // and instead do that in concurrent phase under the relevant lock. This saves init mark
173 // pause time.
174 if (code != NULL && !ShenandoahConcurrentScanCodeRoots) {
175 _code_roots.code_blobs_do(code, worker_id);
176 }
177 }
178
179 template <typename ITR>
180 void ShenandoahRootScanner<ITR>::roots_do_unchecked(OopClosure* oops) {
181 CLDToOopClosure clds(oops, ClassLoaderData::_claim_strong);
182 MarkingCodeBlobClosure code(oops, !CodeBlobToOopClosure::FixRelocations);
183 ShenandoahParallelOopsDoThreadClosure tc_cl(oops, &code, NULL);
184 ResourceMark rm;
185
186 _serial_roots.oops_do(oops, 0);
187 _jni_roots.oops_do(oops, 0);
188 _cld_roots.cld_do(&clds, 0);
189 _thread_roots.threads_do(&tc_cl, 0);
190 _code_roots.code_blobs_do(&code, 0);
191 }
192
193 template <typename ITR>
194 void ShenandoahRootScanner<ITR>::strong_roots_do_unchecked(OopClosure* oops) {
195 CLDToOopClosure clds(oops, ClassLoaderData::_claim_strong);
196 MarkingCodeBlobClosure code(oops, !CodeBlobToOopClosure::FixRelocations);
197 ShenandoahParallelOopsDoThreadClosure tc_cl(oops, &code, NULL);
198 ResourceMark rm;
199
200 _serial_roots.oops_do(oops, 0);
201 _jni_roots.oops_do(oops, 0);
202 _cld_roots.always_strong_cld_do(&clds, 0);
203 _thread_roots.threads_do(&tc_cl, 0);
204 }
205
206 template <typename ITR>
207 void ShenandoahRootScanner<ITR>::strong_roots_do(uint worker_id, OopClosure* oops, CLDClosure* clds, CodeBlobClosure* code, ThreadClosure* tc) {
208 assert(ShenandoahHeap::heap()->unload_classes(), "Should be used during class unloading");
209 ShenandoahParallelOopsDoThreadClosure tc_cl(oops, code, tc);
210 ResourceMark rm;
211
212 _serial_roots.oops_do(oops, worker_id);
213 _jni_roots.oops_do(oops, worker_id);
214 _cld_roots.always_strong_cld_do(clds, worker_id);
215 _thread_roots.threads_do(&tc_cl, worker_id);
216 }
217
218 template <typename IsAlive, typename KeepAlive>
219 void ShenandoahRootUpdater::roots_do(uint worker_id, IsAlive* is_alive, KeepAlive* keep_alive) {
220 CodeBlobToOopClosure update_blobs(keep_alive, CodeBlobToOopClosure::FixRelocations);
221 CLDToOopClosure clds(keep_alive, ClassLoaderData::_claim_strong);
222
223 _serial_roots.oops_do(keep_alive, worker_id);
224 _jni_roots.oops_do(keep_alive, worker_id);
225
226 _thread_roots.oops_do(keep_alive, NULL, worker_id);
227 _cld_roots.cld_do(&clds, worker_id);
228
229 if(_update_code_cache) {
230 _code_roots.code_blobs_do(&update_blobs, worker_id);
231 }
232
233 _weak_roots.oops_do<IsAlive, KeepAlive>(is_alive, keep_alive, worker_id);
234 _dedup_roots.oops_do(is_alive, keep_alive, worker_id);
235 }
236
237 #endif // SHARE_GC_SHENANDOAH_SHENANDOAHROOTPROCESSOR_INLINE_HPP