1 /*
2 * Copyright (c) 2015, 2018, 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_VM_GC_SHENANDOAH_SHENANDOAHOOPCLOSURES_HPP
25 #define SHARE_VM_GC_SHENANDOAH_SHENANDOAHOOPCLOSURES_HPP
26
27 #include "gc/shared/referenceProcessor.hpp"
28 #include "gc/shenandoah/shenandoahHeap.hpp"
29 #include "gc/shenandoah/shenandoahStrDedupQueue.hpp"
30 #include "gc/shenandoah/shenandoahTaskqueue.hpp"
31 #include "gc/shenandoah/shenandoahTraversalGC.hpp"
32 #include "memory/iterator.hpp"
33 #include "runtime/thread.hpp"
34
35 enum UpdateRefsMode {
36 NONE, // No reference updating
37 RESOLVE, // Only a read-barrier (no reference updating)
38 SIMPLE, // Reference updating using simple store
39 CONCURRENT // Reference updating using CAS
40 };
41
42 enum StringDedupMode {
43 NO_DEDUP, // Do not do anything for String deduplication
44 ENQUEUE_DEDUP, // Enqueue candidate Strings for deduplication
45 };
46
47 class ShenandoahMarkRefsSuperClosure : public MetadataVisitingOopIterateClosure {
48 private:
49 ShenandoahObjToScanQueue* _queue;
50 ShenandoahHeap* _heap;
51 ShenandoahMarkingContext* const _mark_context;
52
53 protected:
54 template <class T, UpdateRefsMode UPDATE_MODE, StringDedupMode STRING_DEDUP>
55 void work(T *p);
56
57 public:
58 ShenandoahMarkRefsSuperClosure(ShenandoahObjToScanQueue* q, ReferenceProcessor* rp);
59 };
60
61 class ShenandoahMarkUpdateRefsClosure : public ShenandoahMarkRefsSuperClosure {
62 private:
63 template <class T>
64 inline void do_oop_work(T* p) { work<T, CONCURRENT, NO_DEDUP>(p); }
65
66 public:
67 ShenandoahMarkUpdateRefsClosure(ShenandoahObjToScanQueue* q, ReferenceProcessor* rp) :
68 ShenandoahMarkRefsSuperClosure(q, rp) {};
69
70 virtual void do_oop(narrowOop* p) { do_oop_work(p); }
71 virtual void do_oop(oop* p) { do_oop_work(p); }
72 virtual bool do_metadata() { return false; }
73 };
74
75 class ShenandoahMarkUpdateRefsDedupClosure : public ShenandoahMarkRefsSuperClosure {
76 private:
77 template <class T>
78 inline void do_oop_work(T* p) { work<T, CONCURRENT, ENQUEUE_DEDUP>(p); }
79
80 public:
81 ShenandoahMarkUpdateRefsDedupClosure(ShenandoahObjToScanQueue* q, ReferenceProcessor* rp) :
82 ShenandoahMarkRefsSuperClosure(q, rp) {};
83
84 virtual void do_oop(narrowOop* p) { do_oop_work(p); }
85 virtual void do_oop(oop* p) { do_oop_work(p); }
86 virtual bool do_metadata() { return false; }
87 };
88
89 class ShenandoahMarkUpdateRefsMetadataClosure : public ShenandoahMarkRefsSuperClosure {
90 private:
91 template <class T>
92 inline void do_oop_work(T* p) { work<T, CONCURRENT, NO_DEDUP>(p); }
93
94 public:
95 ShenandoahMarkUpdateRefsMetadataClosure(ShenandoahObjToScanQueue* q, ReferenceProcessor* rp) :
96 ShenandoahMarkRefsSuperClosure(q, rp) {};
97
98 virtual void do_oop(narrowOop* p) { do_oop_work(p); }
99 virtual void do_oop(oop* p) { do_oop_work(p); }
100 virtual bool do_metadata() { return true; }
101 };
102
103 class ShenandoahMarkUpdateRefsMetadataDedupClosure : public ShenandoahMarkRefsSuperClosure {
104 private:
105 template <class T>
106 inline void do_oop_work(T* p) { work<T, CONCURRENT, ENQUEUE_DEDUP>(p); }
107
108 public:
109 ShenandoahMarkUpdateRefsMetadataDedupClosure(ShenandoahObjToScanQueue* q, ReferenceProcessor* rp) :
110 ShenandoahMarkRefsSuperClosure(q, rp) {};
111
112 virtual void do_oop(narrowOop* p) { do_oop_work(p); }
113 virtual void do_oop(oop* p) { do_oop_work(p); }
114 virtual bool do_metadata() { return true; }
115 };
116
117 class ShenandoahMarkRefsClosure : public ShenandoahMarkRefsSuperClosure {
118 private:
119 template <class T>
120 inline void do_oop_work(T* p) { work<T, NONE, NO_DEDUP>(p); }
121
122 public:
123 ShenandoahMarkRefsClosure(ShenandoahObjToScanQueue* q, ReferenceProcessor* rp) :
124 ShenandoahMarkRefsSuperClosure(q, rp) {};
125
126 virtual void do_oop(narrowOop* p) { do_oop_work(p); }
127 virtual void do_oop(oop* p) { do_oop_work(p); }
128 virtual bool do_metadata() { return false; }
129 };
130
131 class ShenandoahMarkRefsDedupClosure : public ShenandoahMarkRefsSuperClosure {
132 private:
133 template <class T>
134 inline void do_oop_work(T* p) { work<T, NONE, ENQUEUE_DEDUP>(p); }
135
136 public:
137 ShenandoahMarkRefsDedupClosure(ShenandoahObjToScanQueue* q, ReferenceProcessor* rp) :
138 ShenandoahMarkRefsSuperClosure(q, rp) {};
139
140 virtual void do_oop(narrowOop* p) { do_oop_work(p); }
141 virtual void do_oop(oop* p) { do_oop_work(p); }
142 virtual bool do_metadata() { return false; }
143 };
144
145 class ShenandoahMarkResolveRefsClosure : public ShenandoahMarkRefsSuperClosure {
146 private:
147 template <class T>
148 inline void do_oop_work(T* p) { work<T, RESOLVE, NO_DEDUP>(p); }
149
150 public:
151 ShenandoahMarkResolveRefsClosure(ShenandoahObjToScanQueue* q, ReferenceProcessor* rp) :
152 ShenandoahMarkRefsSuperClosure(q, rp) {};
153
154 virtual void do_oop(narrowOop* p) { do_oop_work(p); }
155 virtual void do_oop(oop* p) { do_oop_work(p); }
156 virtual bool do_metadata() { return false; }
157 };
158
159 class ShenandoahMarkRefsMetadataClosure : public ShenandoahMarkRefsSuperClosure {
160 private:
161 template <class T>
162 inline void do_oop_work(T* p) { work<T, NONE, NO_DEDUP>(p); }
163
164 public:
165 ShenandoahMarkRefsMetadataClosure(ShenandoahObjToScanQueue* q, ReferenceProcessor* rp) :
166 ShenandoahMarkRefsSuperClosure(q, rp) {};
167
168 virtual void do_oop(narrowOop* p) { do_oop_work(p); }
169 virtual void do_oop(oop* p) { do_oop_work(p); }
170 virtual bool do_metadata() { return true; }
171 };
172
173 class ShenandoahMarkRefsMetadataDedupClosure : public ShenandoahMarkRefsSuperClosure {
174 private:
175 template <class T>
176 inline void do_oop_work(T* p) { work<T, NONE, ENQUEUE_DEDUP>(p); }
177
178 public:
179 ShenandoahMarkRefsMetadataDedupClosure(ShenandoahObjToScanQueue* q, ReferenceProcessor* rp) :
180 ShenandoahMarkRefsSuperClosure(q, rp) {};
181
182 virtual void do_oop(narrowOop* p) { do_oop_work(p); }
183 virtual void do_oop(oop* p) { do_oop_work(p); }
184 virtual bool do_metadata() { return true; }
185 };
186
187 class ShenandoahUpdateHeapRefsSuperClosure : public BasicOopIterateClosure {
188 private:
189 ShenandoahHeap* _heap;
190 public:
191 ShenandoahUpdateHeapRefsSuperClosure() :
192 _heap(ShenandoahHeap::heap()) {}
193
194 template <class T>
195 void work(T *p);
196 };
197
198 class ShenandoahUpdateHeapRefsClosure : public ShenandoahUpdateHeapRefsSuperClosure {
199 private:
200 template <class T>
201 inline void do_oop_work(T* p) { work<T>(p); }
202
203 public:
204 ShenandoahUpdateHeapRefsClosure() : ShenandoahUpdateHeapRefsSuperClosure() {}
205
206 virtual void do_oop(narrowOop* p) { do_oop_work(p); }
207 virtual void do_oop(oop* p) { do_oop_work(p); }
208 };
209
210 class ShenandoahTraversalSuperClosure : public MetadataVisitingOopIterateClosure {
211 private:
212 ShenandoahTraversalGC* const _traversal_gc;
213 Thread* const _thread;
214 ShenandoahObjToScanQueue* const _queue;
215 ShenandoahMarkingContext* const _mark_context;
216 protected:
217 ShenandoahTraversalSuperClosure(ShenandoahObjToScanQueue* q, ReferenceProcessor* rp) :
218 MetadataVisitingOopIterateClosure(rp),
219 _traversal_gc(ShenandoahHeap::heap()->traversal_gc()),
220 _thread(Thread::current()),
221 _queue(q),
222 _mark_context(ShenandoahHeap::heap()->marking_context()) {
223 }
224
225 template <class T, bool STRING_DEDUP, bool DEGEN>
226 void work(T* p);
227
228 };
229
230 class ShenandoahTraversalClosure : public ShenandoahTraversalSuperClosure {
231 private:
232 template <class T>
233 inline void do_oop_work(T* p) { work<T, false, false>(p); }
234
235 public:
236 ShenandoahTraversalClosure(ShenandoahObjToScanQueue* q, ReferenceProcessor* rp) :
237 ShenandoahTraversalSuperClosure(q, rp) {}
238
239 virtual void do_oop(narrowOop* p) { do_oop_work(p); }
240 virtual void do_oop(oop* p) { do_oop_work(p); }
241
242 virtual bool do_metadata() { return false; }
243 };
244
245 class ShenandoahTraversalMetadataClosure : public ShenandoahTraversalSuperClosure {
246 private:
247 template <class T>
248 inline void do_oop_work(T* p) { work<T, false, false>(p); }
249
250 public:
251 ShenandoahTraversalMetadataClosure(ShenandoahObjToScanQueue* q, ReferenceProcessor* rp) :
252 ShenandoahTraversalSuperClosure(q, rp) {}
253
254 virtual void do_oop(narrowOop* p) { do_oop_work(p); }
255 virtual void do_oop(oop* p) { do_oop_work(p); }
256
257 virtual bool do_metadata() { return true; }
258 };
259
260 class ShenandoahTraversalDedupClosure : public ShenandoahTraversalSuperClosure {
261 private:
262 template <class T>
263 inline void do_oop_work(T* p) { work<T, true, false>(p); }
264
265 public:
266 ShenandoahTraversalDedupClosure(ShenandoahObjToScanQueue* q, ReferenceProcessor* rp) :
267 ShenandoahTraversalSuperClosure(q, rp) {}
268
269 virtual void do_oop(narrowOop* p) { do_oop_work(p); }
270 virtual void do_oop(oop* p) { do_oop_work(p); }
271
272 virtual bool do_metadata() { return false; }
273 };
274
275 class ShenandoahTraversalMetadataDedupClosure : public ShenandoahTraversalSuperClosure {
276 private:
277 template <class T>
278 inline void do_oop_work(T* p) { work<T, true, false>(p); }
279
280 public:
281 ShenandoahTraversalMetadataDedupClosure(ShenandoahObjToScanQueue* q, ReferenceProcessor* rp) :
282 ShenandoahTraversalSuperClosure(q, rp) {}
283
284 virtual void do_oop(narrowOop* p) { do_oop_work(p); }
285 virtual void do_oop(oop* p) { do_oop_work(p); }
286
287 virtual bool do_metadata() { return true; }
288 };
289
290 class ShenandoahTraversalDegenClosure : public ShenandoahTraversalSuperClosure {
291 private:
292 template <class T>
293 inline void do_oop_work(T* p) { work<T, false, true>(p); }
294
295 public:
296 ShenandoahTraversalDegenClosure(ShenandoahObjToScanQueue* q, ReferenceProcessor* rp) :
297 ShenandoahTraversalSuperClosure(q, rp) {}
298
299 virtual void do_oop(narrowOop* p) { do_oop_work(p); }
300 virtual void do_oop(oop* p) { do_oop_work(p); }
301
302 virtual bool do_metadata() { return false; }
303 };
304
305 class ShenandoahTraversalMetadataDegenClosure : public ShenandoahTraversalSuperClosure {
306 private:
307 template <class T>
308 inline void do_oop_work(T* p) { work<T, false, true>(p); }
309
310 public:
311 ShenandoahTraversalMetadataDegenClosure(ShenandoahObjToScanQueue* q, ReferenceProcessor* rp) :
312 ShenandoahTraversalSuperClosure(q, rp) {}
313
314 virtual void do_oop(narrowOop* p) { do_oop_work(p); }
315 virtual void do_oop(oop* p) { do_oop_work(p); }
316
317 virtual bool do_metadata() { return true; }
318 };
319
320 class ShenandoahTraversalDedupDegenClosure : public ShenandoahTraversalSuperClosure {
321 private:
322 template <class T>
323 inline void do_oop_work(T* p) { work<T, true, true>(p); }
324
325 public:
326 ShenandoahTraversalDedupDegenClosure(ShenandoahObjToScanQueue* q, ReferenceProcessor* rp) :
327 ShenandoahTraversalSuperClosure(q, rp) {}
328
329 virtual void do_oop(narrowOop* p) { do_oop_work(p); }
330 virtual void do_oop(oop* p) { do_oop_work(p); }
331
332 virtual bool do_metadata() { return false; }
333 };
334
335 class ShenandoahTraversalMetadataDedupDegenClosure : public ShenandoahTraversalSuperClosure {
336 private:
337 template <class T>
338 inline void do_oop_work(T* p) { work<T, true, true>(p); }
339
340 public:
341 ShenandoahTraversalMetadataDedupDegenClosure(ShenandoahObjToScanQueue* q, ReferenceProcessor* rp) :
342 ShenandoahTraversalSuperClosure(q, rp) {}
343
344 virtual void do_oop(narrowOop* p) { do_oop_work(p); }
345 virtual void do_oop(oop* p) { do_oop_work(p); }
346
347 virtual bool do_metadata() { return true; }
348 };
349
350 #endif // SHARE_VM_GC_SHENANDOAH_SHENANDOAHOOPCLOSURES_HPP