1 /*
2 * Copyright (c) 2015, Red Hat, Inc. and/or its affiliates.
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/shenandoah/shenandoahTaskqueue.hpp"
28
29 class ShenandoahHeap;
30 class ShenandoahStrDedupQueue;
31
32 enum UpdateRefsMode {
33 NONE, // No reference updating
34 RESOLVE, // Only a read-barrier (no reference updating)
35 SIMPLE, // Reference updating using simple store
36 CONCURRENT // Reference updating using CAS
37 };
38
39 class ShenandoahMarkRefsSuperClosure : public MetadataVisitingOopIterateClosure {
40 private:
41 ShenandoahObjToScanQueue* _queue;
42 ShenandoahHeap* _heap;
43 ShenandoahMarkingContext* const _mark_context;
44
45 protected:
46 template <class T, UpdateRefsMode UPDATE_MODE, bool STRING_DEDUP>
47 void work(T *p);
48
49 public:
50 ShenandoahMarkRefsSuperClosure(ShenandoahObjToScanQueue* q, ReferenceProcessor* rp);
51
52 inline void set_base_object(oop obj) { /* Not needed */ }
53 };
54
55 class ShenandoahMarkUpdateRefsClosure : public ShenandoahMarkRefsSuperClosure {
56 private:
57 template <class T>
58 inline void do_oop_work(T* p) { work<T, CONCURRENT, false /* string dedup */>(p); }
59
60 public:
61 ShenandoahMarkUpdateRefsClosure(ShenandoahObjToScanQueue* q, ReferenceProcessor* rp) :
62 ShenandoahMarkRefsSuperClosure(q, rp) {};
63
64 virtual void do_oop(narrowOop* p) { do_oop_work(p); }
65 virtual void do_oop(oop* p) { do_oop_work(p); }
66 virtual bool do_metadata() { return false; }
67 };
68
69 class ShenandoahMarkUpdateRefsDedupClosure : public ShenandoahMarkRefsSuperClosure {
70 private:
71 template <class T>
72 inline void do_oop_work(T* p) { work<T, CONCURRENT, true /* string dedup */>(p); }
73
74 public:
75 ShenandoahMarkUpdateRefsDedupClosure(ShenandoahObjToScanQueue* q, ReferenceProcessor* rp) :
76 ShenandoahMarkRefsSuperClosure(q, rp) {};
77
78 virtual void do_oop(narrowOop* p) { do_oop_work(p); }
79 virtual void do_oop(oop* p) { do_oop_work(p); }
80 virtual bool do_metadata() { return false; }
81 };
82
83 class ShenandoahMarkUpdateRefsMetadataClosure : public ShenandoahMarkRefsSuperClosure {
84 private:
85 template <class T>
86 inline void do_oop_work(T* p) { work<T, CONCURRENT, false /* string dedup */>(p); }
87
88 public:
89 ShenandoahMarkUpdateRefsMetadataClosure(ShenandoahObjToScanQueue* q, ReferenceProcessor* rp) :
90 ShenandoahMarkRefsSuperClosure(q, rp) {};
91
92 virtual void do_oop(narrowOop* p) { do_oop_work(p); }
93 virtual void do_oop(oop* p) { do_oop_work(p); }
94 virtual bool do_metadata() { return true; }
95 };
96
97 class ShenandoahMarkUpdateRefsMetadataDedupClosure : public ShenandoahMarkRefsSuperClosure {
98 private:
99 template <class T>
100 inline void do_oop_work(T* p) { work<T, CONCURRENT, true /* string dedup */>(p); }
101
102 public:
103 ShenandoahMarkUpdateRefsMetadataDedupClosure(ShenandoahObjToScanQueue* q, ReferenceProcessor* rp) :
104 ShenandoahMarkRefsSuperClosure(q, rp) {};
105
106 virtual void do_oop(narrowOop* p) { do_oop_work(p); }
107 virtual void do_oop(oop* p) { do_oop_work(p); }
108 virtual bool do_metadata() { return true; }
109 };
110
111 class ShenandoahMarkRefsClosure : public ShenandoahMarkRefsSuperClosure {
112 private:
113 template <class T>
114 inline void do_oop_work(T* p) { work<T, NONE, false /* string dedup */>(p); }
115
116 public:
117 ShenandoahMarkRefsClosure(ShenandoahObjToScanQueue* q, ReferenceProcessor* rp) :
118 ShenandoahMarkRefsSuperClosure(q, rp) {};
119
120 virtual void do_oop(narrowOop* p) { do_oop_work(p); }
121 virtual void do_oop(oop* p) { do_oop_work(p); }
122 virtual bool do_metadata() { return false; }
123 };
124
125 class ShenandoahMarkRefsDedupClosure : public ShenandoahMarkRefsSuperClosure {
126 private:
127 template <class T>
128 inline void do_oop_work(T* p) { work<T, NONE, true /* string dedup */>(p); }
129
130 public:
131 ShenandoahMarkRefsDedupClosure(ShenandoahObjToScanQueue* q, ReferenceProcessor* rp) :
132 ShenandoahMarkRefsSuperClosure(q, rp) {};
133
134 virtual void do_oop(narrowOop* p) { do_oop_work(p); }
135 virtual void do_oop(oop* p) { do_oop_work(p); }
136 virtual bool do_metadata() { return false; }
137 };
138
139 class ShenandoahMarkResolveRefsClosure : public ShenandoahMarkRefsSuperClosure {
140 private:
141 template <class T>
142 inline void do_oop_work(T* p) { work<T, RESOLVE, false /* string dedup */>(p); }
143
144 public:
145 ShenandoahMarkResolveRefsClosure(ShenandoahObjToScanQueue* q, ReferenceProcessor* rp) :
146 ShenandoahMarkRefsSuperClosure(q, rp) {};
147
148 virtual void do_oop(narrowOop* p) { do_oop_work(p); }
149 virtual void do_oop(oop* p) { do_oop_work(p); }
150 virtual bool do_metadata() { return false; }
151 };
152
153 class ShenandoahMarkResolveRefsDedupClosure : public ShenandoahMarkRefsSuperClosure {
154 private:
155 template <class T>
156 inline void do_oop_work(T* p) { work<T, RESOLVE, true /* string dedup */>(p); }
157
158 public:
159 ShenandoahMarkResolveRefsDedupClosure(ShenandoahObjToScanQueue* q, ReferenceProcessor* rp) :
160 ShenandoahMarkRefsSuperClosure(q, rp) {};
161
162 virtual void do_oop(narrowOop* p) { do_oop_work(p); }
163 virtual void do_oop(oop* p) { do_oop_work(p); }
164 virtual bool do_metadata() { return false; }
165 };
166
167 class ShenandoahMarkRefsMetadataClosure : public ShenandoahMarkRefsSuperClosure {
168 private:
169 template <class T>
170 inline void do_oop_work(T* p) { work<T, NONE, false /* string dedup */>(p); }
171
172 public:
173 ShenandoahMarkRefsMetadataClosure(ShenandoahObjToScanQueue* q, ReferenceProcessor* rp) :
174 ShenandoahMarkRefsSuperClosure(q, rp) {};
175
176 virtual void do_oop(narrowOop* p) { do_oop_work(p); }
177 virtual void do_oop(oop* p) { do_oop_work(p); }
178 virtual bool do_metadata() { return true; }
179 };
180
181 class ShenandoahMarkRefsMetadataDedupClosure : public ShenandoahMarkRefsSuperClosure {
182 private:
183 template <class T>
184 inline void do_oop_work(T* p) { work<T, NONE, true /* string dedup */>(p); }
185
186 public:
187 ShenandoahMarkRefsMetadataDedupClosure(ShenandoahObjToScanQueue* q, ReferenceProcessor* rp) :
188 ShenandoahMarkRefsSuperClosure(q, rp) {};
189
190 virtual void do_oop(narrowOop* p) { do_oop_work(p); }
191 virtual void do_oop(oop* p) { do_oop_work(p); }
192 virtual bool do_metadata() { return true; }
193 };
194
195 class ShenandoahUpdateHeapRefsSuperClosure : public BasicOopIterateClosure {
196 private:
197 ShenandoahHeap* _heap;
198 public:
199 ShenandoahUpdateHeapRefsSuperClosure() :
200 _heap(ShenandoahHeap::heap()) {}
201
202 template <class T, bool UPDATE_MATRIX>
203 void work(T *p);
204 };
205
206 class ShenandoahUpdateHeapRefsClosure : public ShenandoahUpdateHeapRefsSuperClosure {
207 private:
208 template <class T>
209 inline void do_oop_work(T* p) { work<T, false>(p); }
210
211 public:
212 ShenandoahUpdateHeapRefsClosure() : ShenandoahUpdateHeapRefsSuperClosure() {}
213
214 virtual void do_oop(narrowOop* p) { do_oop_work(p); }
215 virtual void do_oop(oop* p) { do_oop_work(p); }
216 };
217
218 class ShenandoahUpdateHeapRefsMatrixClosure : public ShenandoahUpdateHeapRefsSuperClosure {
219 public:
220 ShenandoahUpdateHeapRefsMatrixClosure() : ShenandoahUpdateHeapRefsSuperClosure() {}
221
222 template <class T>
223 inline void do_oop_work(T* p) { work<T, true>(p); }
224 virtual void do_oop(narrowOop* p) { do_oop_work(p); }
225 virtual void do_oop(oop* p) { do_oop_work(p); }
226 };
227
228 class ShenandoahTraversalSuperClosure : public MetadataVisitingOopIterateClosure {
229 private:
230 ShenandoahTraversalGC* const _traversal_gc;
231 Thread* const _thread;
232 ShenandoahObjToScanQueue* const _queue;
233 ShenandoahMarkingContext* const _mark_context;
234 oop _base_obj;
235 protected:
236 ShenandoahTraversalSuperClosure(ShenandoahObjToScanQueue* q, ReferenceProcessor* rp) :
237 MetadataVisitingOopIterateClosure(rp),
238 _traversal_gc(ShenandoahHeap::heap()->traversal_gc()),
239 _thread(Thread::current()), _queue(q),
240 _mark_context(ShenandoahHeap::heap()->next_marking_context()),
241 _base_obj(NULL) {
242 }
243
244 template <class T, bool STRING_DEDUP, bool DEGEN, bool MATRIX>
245 void work(T* p);
246
247 public:
248 inline void set_base_object(oop obj) {
249 _base_obj = obj;
250 }
251 };
252
253 class ShenandoahTraversalClosure : public ShenandoahTraversalSuperClosure {
254 private:
255 template <class T>
256 inline void do_oop_work(T* p) { work<T, false, false, false>(p); }
257
258 public:
259 ShenandoahTraversalClosure(ShenandoahObjToScanQueue* q, ReferenceProcessor* rp) :
260 ShenandoahTraversalSuperClosure(q, rp) {}
261
262 virtual void do_oop(narrowOop* p) { do_oop_work(p); }
263 virtual void do_oop(oop* p) { do_oop_work(p); }
264
265 virtual bool do_metadata() { return false; }
266 };
267
268 class ShenandoahTraversalMetadataClosure : public ShenandoahTraversalSuperClosure {
269 private:
270 template <class T>
271 inline void do_oop_work(T* p) { work<T, false, false, false>(p); }
272
273 public:
274 ShenandoahTraversalMetadataClosure(ShenandoahObjToScanQueue* q, ReferenceProcessor* rp) :
275 ShenandoahTraversalSuperClosure(q, rp) {}
276
277 virtual void do_oop(narrowOop* p) { do_oop_work(p); }
278 virtual void do_oop(oop* p) { do_oop_work(p); }
279
280 virtual bool do_metadata() { return true; }
281 };
282
283 class ShenandoahTraversalDedupClosure : public ShenandoahTraversalSuperClosure {
284 private:
285 template <class T>
286 inline void do_oop_work(T* p) { work<T, true, false, false>(p); }
287
288 public:
289 ShenandoahTraversalDedupClosure(ShenandoahObjToScanQueue* q, ReferenceProcessor* rp) :
290 ShenandoahTraversalSuperClosure(q, rp) {}
291
292 virtual void do_oop(narrowOop* p) { do_oop_work(p); }
293 virtual void do_oop(oop* p) { do_oop_work(p); }
294
295 virtual bool do_metadata() { return false; }
296 };
297
298 class ShenandoahTraversalMetadataDedupClosure : public ShenandoahTraversalSuperClosure {
299 private:
300 template <class T>
301 inline void do_oop_work(T* p) { work<T, true, false, false>(p); }
302
303 public:
304 ShenandoahTraversalMetadataDedupClosure(ShenandoahObjToScanQueue* q, ReferenceProcessor* rp) :
305 ShenandoahTraversalSuperClosure(q, rp) {}
306
307 virtual void do_oop(narrowOop* p) { do_oop_work(p); }
308 virtual void do_oop(oop* p) { do_oop_work(p); }
309
310 virtual bool do_metadata() { return true; }
311 };
312
313 class ShenandoahTraversalDegenClosure : public ShenandoahTraversalSuperClosure {
314 private:
315 template <class T>
316 inline void do_oop_work(T* p) { work<T, false, true, false>(p); }
317
318 public:
319 ShenandoahTraversalDegenClosure(ShenandoahObjToScanQueue* q, ReferenceProcessor* rp) :
320 ShenandoahTraversalSuperClosure(q, rp) {}
321
322 virtual void do_oop(narrowOop* p) { do_oop_work(p); }
323 virtual void do_oop(oop* p) { do_oop_work(p); }
324
325 virtual bool do_metadata() { return false; }
326 };
327
328 class ShenandoahTraversalMetadataDegenClosure : public ShenandoahTraversalSuperClosure {
329 private:
330 template <class T>
331 inline void do_oop_work(T* p) { work<T, false, true, false>(p); }
332
333 public:
334 ShenandoahTraversalMetadataDegenClosure(ShenandoahObjToScanQueue* q, ReferenceProcessor* rp) :
335 ShenandoahTraversalSuperClosure(q, rp) {}
336
337 virtual void do_oop(narrowOop* p) { do_oop_work(p); }
338 virtual void do_oop(oop* p) { do_oop_work(p); }
339
340 virtual bool do_metadata() { return true; }
341 };
342
343 class ShenandoahTraversalDedupDegenClosure : public ShenandoahTraversalSuperClosure {
344 private:
345 template <class T>
346 inline void do_oop_work(T* p) { work<T, true, true, false>(p); }
347
348 public:
349 ShenandoahTraversalDedupDegenClosure(ShenandoahObjToScanQueue* q, ReferenceProcessor* rp) :
350 ShenandoahTraversalSuperClosure(q, rp) {}
351
352 virtual void do_oop(narrowOop* p) { do_oop_work(p); }
353 virtual void do_oop(oop* p) { do_oop_work(p); }
354
355 virtual bool do_metadata() { return false; }
356 };
357
358 class ShenandoahTraversalMetadataDedupDegenClosure : public ShenandoahTraversalSuperClosure {
359 private:
360 template <class T>
361 inline void do_oop_work(T* p) { work<T, true, true, false>(p); }
362
363 public:
364 ShenandoahTraversalMetadataDedupDegenClosure(ShenandoahObjToScanQueue* q, ReferenceProcessor* rp) :
365 ShenandoahTraversalSuperClosure(q, rp) {}
366
367 virtual void do_oop(narrowOop* p) { do_oop_work(p); }
368 virtual void do_oop(oop* p) { do_oop_work(p); }
369
370 virtual bool do_metadata() { return true; }
371 };
372
373 class ShenandoahTraversalMatrixClosure : public ShenandoahTraversalSuperClosure {
374 private:
375 template <class T>
376 inline void do_oop_work(T* p) { work<T, false, false, true>(p); }
377
378 public:
379 ShenandoahTraversalMatrixClosure(ShenandoahObjToScanQueue* q, ReferenceProcessor* rp) :
380 ShenandoahTraversalSuperClosure(q, rp) {}
381
382 virtual void do_oop(narrowOop* p) { do_oop_work(p); }
383 virtual void do_oop(oop* p) { do_oop_work(p); }
384
385 virtual bool do_metadata() { return false; }
386 };
387
388 class ShenandoahTraversalMetadataMatrixClosure : public ShenandoahTraversalSuperClosure {
389 private:
390 template <class T>
391 inline void do_oop_work(T* p) { work<T, false, false, true>(p); }
392
393 public:
394 ShenandoahTraversalMetadataMatrixClosure(ShenandoahObjToScanQueue* q, ReferenceProcessor* rp) :
395 ShenandoahTraversalSuperClosure(q, rp) {}
396
397 virtual void do_oop(narrowOop* p) { do_oop_work(p); }
398 virtual void do_oop(oop* p) { do_oop_work(p); }
399
400 virtual bool do_metadata() { return true; }
401 };
402
403 class ShenandoahTraversalDedupMatrixClosure : public ShenandoahTraversalSuperClosure {
404 private:
405 template <class T>
406 inline void do_oop_work(T* p) { work<T, true, false, true>(p); }
407
408 public:
409 ShenandoahTraversalDedupMatrixClosure(ShenandoahObjToScanQueue* q, ReferenceProcessor* rp) :
410 ShenandoahTraversalSuperClosure(q, rp) {}
411
412 virtual void do_oop(narrowOop* p) { do_oop_work(p); }
413 virtual void do_oop(oop* p) { do_oop_work(p); }
414
415 virtual bool do_metadata() { return false; }
416 };
417
418 class ShenandoahTraversalMetadataDedupMatrixClosure : public ShenandoahTraversalSuperClosure {
419 private:
420 template <class T>
421 inline void do_oop_work(T* p) { work<T, true, false, true>(p); }
422
423 public:
424 ShenandoahTraversalMetadataDedupMatrixClosure(ShenandoahObjToScanQueue* q, ReferenceProcessor* rp) :
425 ShenandoahTraversalSuperClosure(q, rp) {}
426
427 virtual void do_oop(narrowOop* p) { do_oop_work(p); }
428 virtual void do_oop(oop* p) { do_oop_work(p); }
429
430 virtual bool do_metadata() { return true; }
431 };
432
433 class ShenandoahTraversalDegenMatrixClosure : public ShenandoahTraversalSuperClosure {
434 private:
435 template <class T>
436 inline void do_oop_work(T* p) { work<T, false, true, true>(p); }
437
438 public:
439 ShenandoahTraversalDegenMatrixClosure(ShenandoahObjToScanQueue* q, ReferenceProcessor* rp) :
440 ShenandoahTraversalSuperClosure(q, rp) {}
441
442 virtual void do_oop(narrowOop* p) { do_oop_work(p); }
443 virtual void do_oop(oop* p) { do_oop_work(p); }
444
445 virtual bool do_metadata() { return false; }
446 };
447
448 class ShenandoahTraversalMetadataDegenMatrixClosure : public ShenandoahTraversalSuperClosure {
449 private:
450 template <class T>
451 inline void do_oop_work(T* p) { work<T, false, true, true>(p); }
452
453 public:
454 ShenandoahTraversalMetadataDegenMatrixClosure(ShenandoahObjToScanQueue* q, ReferenceProcessor* rp) :
455 ShenandoahTraversalSuperClosure(q, rp) {}
456
457 virtual void do_oop(narrowOop* p) { do_oop_work(p); }
458 virtual void do_oop(oop* p) { do_oop_work(p); }
459
460 virtual bool do_metadata() { return true; }
461 };
462
463 class ShenandoahTraversalDedupDegenMatrixClosure : public ShenandoahTraversalSuperClosure {
464 private:
465 template <class T>
466 inline void do_oop_work(T* p) { work<T, true, true, true>(p); }
467
468 public:
469 ShenandoahTraversalDedupDegenMatrixClosure(ShenandoahObjToScanQueue* q, ReferenceProcessor* rp) :
470 ShenandoahTraversalSuperClosure(q, rp) {}
471
472 virtual void do_oop(narrowOop* p) { do_oop_work(p); }
473 virtual void do_oop(oop* p) { do_oop_work(p); }
474
475 virtual bool do_metadata() { return false; }
476 };
477
478 class ShenandoahTraversalMetadataDedupDegenMatrixClosure : public ShenandoahTraversalSuperClosure {
479 private:
480 template <class T>
481 inline void do_oop_work(T* p) { work<T, true, true, true>(p); }
482
483 public:
484 ShenandoahTraversalMetadataDedupDegenMatrixClosure(ShenandoahObjToScanQueue* q, ReferenceProcessor* rp) :
485 ShenandoahTraversalSuperClosure(q, rp) {}
486
487 virtual void do_oop(narrowOop* p) { do_oop_work(p); }
488 virtual void do_oop(oop* p) { do_oop_work(p); }
489
490 virtual bool do_metadata() { return true; }
491 };
492
493 #endif // SHARE_VM_GC_SHENANDOAH_SHENANDOAHOOPCLOSURES_HPP