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 MetadataAwareOopClosure {
40 private:
41 ShenandoahObjToScanQueue* _queue;
42 ShenandoahStrDedupQueue* _dedup_queue;
43 ShenandoahHeap* _heap;
44 public:
45 ShenandoahMarkRefsSuperClosure(ShenandoahObjToScanQueue* q, ReferenceProcessor* rp);
46 ShenandoahMarkRefsSuperClosure(ShenandoahObjToScanQueue* q, ShenandoahStrDedupQueue* dq, ReferenceProcessor* rp);
47
48 template <class T, UpdateRefsMode UPDATE_MODE, bool STRING_DEDUP>
49 void work(T *p);
50 };
51
52 class ShenandoahMarkUpdateRefsClosure : public ShenandoahMarkRefsSuperClosure {
53 public:
54 ShenandoahMarkUpdateRefsClosure(ShenandoahObjToScanQueue* q, ReferenceProcessor* rp) :
55 ShenandoahMarkRefsSuperClosure(q, rp) {};
56
57 template <class T>
58 inline void do_oop_nv(T* p) { work<T, CONCURRENT, false /* string dedup */>(p); }
59 virtual void do_oop(narrowOop* p) { do_oop_nv(p); }
60 virtual void do_oop(oop* p) { do_oop_nv(p); }
61 inline bool do_metadata_nv() { return false; }
62 virtual bool do_metadata() { return false; }
63 };
64
65 class ShenandoahMarkUpdateRefsDedupClosure : public ShenandoahMarkRefsSuperClosure {
66 public:
67 ShenandoahMarkUpdateRefsDedupClosure(ShenandoahObjToScanQueue* q, ShenandoahStrDedupQueue* dq, ReferenceProcessor* rp) :
68 ShenandoahMarkRefsSuperClosure(q, dq, rp) {};
69
70 template <class T>
71 inline void do_oop_nv(T* p) { work<T, CONCURRENT, true /* string dedup */>(p); }
72 virtual void do_oop(narrowOop* p) { do_oop_nv(p); }
73 virtual void do_oop(oop* p) { do_oop_nv(p); }
74 inline bool do_metadata_nv() { return false; }
75 virtual bool do_metadata() { return false; }
76 };
77
78 class ShenandoahMarkUpdateRefsMetadataClosure : public ShenandoahMarkRefsSuperClosure {
79 public:
80 ShenandoahMarkUpdateRefsMetadataClosure(ShenandoahObjToScanQueue* q, ReferenceProcessor* rp) :
81 ShenandoahMarkRefsSuperClosure(q, rp) {};
82
83 template <class T>
84 inline void do_oop_nv(T* p) { work<T, CONCURRENT, false /* string dedup */>(p); }
85 virtual void do_oop(narrowOop* p) { do_oop_nv(p); }
86 virtual void do_oop(oop* p) { do_oop_nv(p); }
87 inline bool do_metadata_nv() { return true; }
88 virtual bool do_metadata() { return true; }
89 };
90
91 class ShenandoahMarkUpdateRefsMetadataDedupClosure : public ShenandoahMarkRefsSuperClosure {
92 public:
93 ShenandoahMarkUpdateRefsMetadataDedupClosure(ShenandoahObjToScanQueue* q, ShenandoahStrDedupQueue* dq, ReferenceProcessor* rp) :
94 ShenandoahMarkRefsSuperClosure(q, dq, rp) {};
95
96 template <class T>
97 inline void do_oop_nv(T* p) { work<T, CONCURRENT, true /* string dedup */>(p); }
98 virtual void do_oop(narrowOop* p) { do_oop_nv(p); }
99 virtual void do_oop(oop* p) { do_oop_nv(p); }
100 inline bool do_metadata_nv() { return true; }
101 virtual bool do_metadata() { return true; }
102 };
103
104 class ShenandoahMarkRefsClosure : public ShenandoahMarkRefsSuperClosure {
105 public:
106 ShenandoahMarkRefsClosure(ShenandoahObjToScanQueue* q, ReferenceProcessor* rp) :
107 ShenandoahMarkRefsSuperClosure(q, rp) {};
108
109 template <class T>
110 inline void do_oop_nv(T* p) { work<T, NONE, false /* string dedup */>(p); }
111 virtual void do_oop(narrowOop* p) { do_oop_nv(p); }
112 virtual void do_oop(oop* p) { do_oop_nv(p); }
113 inline bool do_metadata_nv() { return false; }
114 virtual bool do_metadata() { return false; }
115 };
116
117 class ShenandoahMarkRefsDedupClosure : public ShenandoahMarkRefsSuperClosure {
118 public:
119 ShenandoahMarkRefsDedupClosure(ShenandoahObjToScanQueue* q, ShenandoahStrDedupQueue* dq, ReferenceProcessor* rp) :
120 ShenandoahMarkRefsSuperClosure(q, dq, rp) {};
121
122 template <class T>
123 inline void do_oop_nv(T* p) { work<T, NONE, true /* string dedup */>(p); }
124 virtual void do_oop(narrowOop* p) { do_oop_nv(p); }
125 virtual void do_oop(oop* p) { do_oop_nv(p); }
126 inline bool do_metadata_nv() { return false; }
127 virtual bool do_metadata() { return false; }
128 };
129
130 class ShenandoahMarkResolveRefsClosure : public ShenandoahMarkRefsSuperClosure {
131 public:
132 ShenandoahMarkResolveRefsClosure(ShenandoahObjToScanQueue* q, ReferenceProcessor* rp) :
133 ShenandoahMarkRefsSuperClosure(q, rp) {};
134
135 template <class T>
136 inline void do_oop_nv(T* p) { work<T, RESOLVE, false /* string dedup */>(p); }
137 virtual void do_oop(narrowOop* p) { do_oop_nv(p); }
138 virtual void do_oop(oop* p) { do_oop_nv(p); }
139 inline bool do_metadata_nv() { return false; }
140 virtual bool do_metadata() { return false; }
141 };
142
143 class ShenandoahMarkResolveRefsDedupClosure : public ShenandoahMarkRefsSuperClosure {
144 public:
145 ShenandoahMarkResolveRefsDedupClosure(ShenandoahObjToScanQueue* q, ShenandoahStrDedupQueue* dq, ReferenceProcessor* rp) :
146 ShenandoahMarkRefsSuperClosure(q, dq, rp) {};
147
148 template <class T>
149 inline void do_oop_nv(T* p) { work<T, RESOLVE, true /* string dedup */>(p); }
150 virtual void do_oop(narrowOop* p) { do_oop_nv(p); }
151 virtual void do_oop(oop* p) { do_oop_nv(p); }
152 inline bool do_metadata_nv() { return false; }
153 virtual bool do_metadata() { return false; }
154 };
155
156 class ShenandoahMarkRefsMetadataClosure : public ShenandoahMarkRefsSuperClosure {
157 public:
158 ShenandoahMarkRefsMetadataClosure(ShenandoahObjToScanQueue* q, ReferenceProcessor* rp) :
159 ShenandoahMarkRefsSuperClosure(q, rp) {};
160
161 template <class T>
162 inline void do_oop_nv(T* p) { work<T, NONE, false /* string dedup */>(p); }
163 virtual void do_oop(narrowOop* p) { do_oop_nv(p); }
164 virtual void do_oop(oop* p) { do_oop_nv(p); }
165 inline bool do_metadata_nv() { return true; }
166 virtual bool do_metadata() { return true; }
167 };
168
169 class ShenandoahMarkRefsMetadataDedupClosure : public ShenandoahMarkRefsSuperClosure {
170 public:
171 ShenandoahMarkRefsMetadataDedupClosure(ShenandoahObjToScanQueue* q, ShenandoahStrDedupQueue* dq, ReferenceProcessor* rp) :
172 ShenandoahMarkRefsSuperClosure(q, dq, rp) {};
173
174 template <class T>
175 inline void do_oop_nv(T* p) { work<T, NONE, true /* string dedup */>(p); }
176 virtual void do_oop(narrowOop* p) { do_oop_nv(p); }
177 virtual void do_oop(oop* p) { do_oop_nv(p); }
178 inline bool do_metadata_nv() { return true; }
179 virtual bool do_metadata() { return true; }
180 };
181
182 class ShenandoahUpdateHeapRefsSuperClosure : public ExtendedOopClosure {
183 private:
184 ShenandoahHeap* _heap;
185 public:
186 ShenandoahUpdateHeapRefsSuperClosure() :
187 _heap(ShenandoahHeap::heap()) {}
188
189 template <class T, bool UPDATE_MATRIX>
190 void work(T *p);
191 };
192
193 class ShenandoahUpdateHeapRefsClosure : public ShenandoahUpdateHeapRefsSuperClosure {
194 public:
195 ShenandoahUpdateHeapRefsClosure() : ShenandoahUpdateHeapRefsSuperClosure() {}
196
197 template <class T>
198 inline void do_oop_nv(T* p) { work<T, false>(p); }
199 virtual void do_oop(narrowOop* p) { do_oop_nv(p); }
200 virtual void do_oop(oop* p) { do_oop_nv(p); }
201 };
202
203 class ShenandoahUpdateHeapRefsMatrixClosure : public ShenandoahUpdateHeapRefsSuperClosure {
204 public:
205 ShenandoahUpdateHeapRefsMatrixClosure() : ShenandoahUpdateHeapRefsSuperClosure() {}
206
207 template <class T>
208 inline void do_oop_nv(T* p) { work<T, true>(p); }
209 virtual void do_oop(narrowOop* p) { do_oop_nv(p); }
210 virtual void do_oop(oop* p) { do_oop_nv(p); }
211 };
212
213 class ShenandoahPartialEvacuateUpdateHeapClosure : public ExtendedOopClosure {
214 private:
215 ShenandoahPartialGC* _partial_gc;
216 Thread* _thread;
217 ShenandoahObjToScanQueue* _queue;
218 public:
219 ShenandoahPartialEvacuateUpdateHeapClosure(ShenandoahObjToScanQueue* q) :
220 _partial_gc(ShenandoahHeap::heap()->partial_gc()),
221 _thread(Thread::current()), _queue(q) {}
222
223 template <class T>
224 void do_oop_nv(T* p);
225
226 void do_oop(oop* p) { do_oop_nv(p); }
227 void do_oop(narrowOop* p) { do_oop_nv(p); }
228 };
229
230 class ShenandoahTraversalSuperClosure : public MetadataAwareOopClosure {
231 private:
232 ShenandoahTraversalGC* _traversal_gc;
233 Thread* _thread;
234 ShenandoahObjToScanQueue* _queue;
235 ShenandoahStrDedupQueue* _dedup_queue;
236
237 protected:
238 ShenandoahTraversalSuperClosure(ShenandoahObjToScanQueue* q, ReferenceProcessor* rp) :
239 MetadataAwareOopClosure(rp),
240 _traversal_gc(ShenandoahHeap::heap()->traversal_gc()),
241 _thread(Thread::current()), _queue(q), _dedup_queue(NULL) {
242 }
243
244 ShenandoahTraversalSuperClosure(ShenandoahObjToScanQueue* q, ReferenceProcessor* rp, ShenandoahStrDedupQueue* dq) :
245 MetadataAwareOopClosure(rp),
246 _traversal_gc(ShenandoahHeap::heap()->traversal_gc()),
247 _thread(Thread::current()), _queue(q), _dedup_queue(dq) {
248 }
249
250 template <class T, bool STRING_DEDUP, bool DEGEN>
251 void work(T* p);
252 };
253
254 class ShenandoahTraversalClosure : public ShenandoahTraversalSuperClosure {
255 public:
256 ShenandoahTraversalClosure(ShenandoahObjToScanQueue* q, ReferenceProcessor* rp) :
257 ShenandoahTraversalSuperClosure(q, rp) {}
258
259 template <class T>
260 inline void do_oop_nv(T* p) { work<T, false, false>(p); }
261
262 virtual void do_oop(narrowOop* p) { do_oop_nv(p); }
263 virtual void do_oop(oop* p) { do_oop_nv(p); }
264
265 inline bool do_metadata_nv() { return false; }
266 virtual bool do_metadata() { return false; }
267 };
268
269 class ShenandoahTraversalMetadataClosure : public ShenandoahTraversalSuperClosure {
270 public:
271 ShenandoahTraversalMetadataClosure(ShenandoahObjToScanQueue* q, ReferenceProcessor* rp) :
272 ShenandoahTraversalSuperClosure(q, rp) {}
273
274 template <class T>
275 inline void do_oop_nv(T* p) { work<T, false, false>(p); }
276
277 virtual void do_oop(narrowOop* p) { do_oop_nv(p); }
278 virtual void do_oop(oop* p) { do_oop_nv(p); }
279
280 inline bool do_metadata_nv() { return true; }
281 virtual bool do_metadata() { return true; }
282 };
283
284 class ShenandoahTraversalDedupClosure : public ShenandoahTraversalSuperClosure {
285 public:
286 ShenandoahTraversalDedupClosure(ShenandoahObjToScanQueue* q, ReferenceProcessor* rp, ShenandoahStrDedupQueue* dq) :
287 ShenandoahTraversalSuperClosure(q, rp, dq) {}
288
289 template <class T>
290 inline void do_oop_nv(T* p) { work<T, true, false>(p); }
291
292 virtual void do_oop(narrowOop* p) { do_oop_nv(p); }
293 virtual void do_oop(oop* p) { do_oop_nv(p); }
294
295 inline bool do_metadata_nv() { return false; }
296 virtual bool do_metadata() { return false; }
297 };
298
299 class ShenandoahTraversalMetadataDedupClosure : public ShenandoahTraversalSuperClosure {
300 public:
301 ShenandoahTraversalMetadataDedupClosure(ShenandoahObjToScanQueue* q, ReferenceProcessor* rp, ShenandoahStrDedupQueue* dq) :
302 ShenandoahTraversalSuperClosure(q, rp, dq) {}
303
304 template <class T>
305 inline void do_oop_nv(T* p) { work<T, true, false>(p); }
306
307 virtual void do_oop(narrowOop* p) { do_oop_nv(p); }
308 virtual void do_oop(oop* p) { do_oop_nv(p); }
309
310 inline bool do_metadata_nv() { return true; }
311 virtual bool do_metadata() { return true; }
312 };
313
314 class ShenandoahTraversalDegenClosure : public ShenandoahTraversalSuperClosure {
315 public:
316 ShenandoahTraversalDegenClosure(ShenandoahObjToScanQueue* q, ReferenceProcessor* rp) :
317 ShenandoahTraversalSuperClosure(q, rp) {}
318
319 template <class T>
320 inline void do_oop_nv(T* p) { work<T, false, true>(p); }
321
322 virtual void do_oop(narrowOop* p) { do_oop_nv(p); }
323 virtual void do_oop(oop* p) { do_oop_nv(p); }
324
325 inline bool do_metadata_nv() { return false; }
326 virtual bool do_metadata() { return false; }
327 };
328
329 class ShenandoahTraversalMetadataDegenClosure : public ShenandoahTraversalSuperClosure {
330 public:
331 ShenandoahTraversalMetadataDegenClosure(ShenandoahObjToScanQueue* q, ReferenceProcessor* rp) :
332 ShenandoahTraversalSuperClosure(q, rp) {}
333
334 template <class T>
335 inline void do_oop_nv(T* p) { work<T, false, true>(p); }
336
337 virtual void do_oop(narrowOop* p) { do_oop_nv(p); }
338 virtual void do_oop(oop* p) { do_oop_nv(p); }
339
340 inline bool do_metadata_nv() { return true; }
341 virtual bool do_metadata() { return true; }
342 };
343
344 class ShenandoahTraversalDedupDegenClosure : public ShenandoahTraversalSuperClosure {
345 public:
346 ShenandoahTraversalDedupDegenClosure(ShenandoahObjToScanQueue* q, ReferenceProcessor* rp, ShenandoahStrDedupQueue* dq) :
347 ShenandoahTraversalSuperClosure(q, rp, dq) {}
348
349 template <class T>
350 inline void do_oop_nv(T* p) { work<T, true, true>(p); }
351
352 virtual void do_oop(narrowOop* p) { do_oop_nv(p); }
353 virtual void do_oop(oop* p) { do_oop_nv(p); }
354
355 inline bool do_metadata_nv() { return false; }
356 virtual bool do_metadata() { return false; }
357 };
358
359 class ShenandoahTraversalMetadataDedupDegenClosure : public ShenandoahTraversalSuperClosure {
360 public:
361 ShenandoahTraversalMetadataDedupDegenClosure(ShenandoahObjToScanQueue* q, ReferenceProcessor* rp, ShenandoahStrDedupQueue* dq) :
362 ShenandoahTraversalSuperClosure(q, rp, dq) {}
363
364 template <class T>
365 inline void do_oop_nv(T* p) { work<T, true, true>(p); }
366
367 virtual void do_oop(narrowOop* p) { do_oop_nv(p); }
368 virtual void do_oop(oop* p) { do_oop_nv(p); }
369
370 inline bool do_metadata_nv() { return true; }
371 virtual bool do_metadata() { return true; }
372 };
373
374 #endif // SHARE_VM_GC_SHENANDOAH_SHENANDOAHOOPCLOSURES_HPP