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_implementation/shenandoah/shenandoahTaskqueue.hpp"
28
29 class ShenandoahHeap;
30 class ShenandoahStrDedupQueue;
31 class ShenandoahMarkingContext;
32
33 enum UpdateRefsMode {
34 NONE, // No reference updating
35 RESOLVE, // Only a read-barrier (no reference updating)
36 SIMPLE, // Reference updating using simple store
37 CONCURRENT // Reference updating using CAS
38 };
39
40 enum StringDedupMode {
41 NO_DEDUP, // Do not do anything for String deduplication
42 ENQUEUE_DEDUP, // Enqueue candidate Strings for deduplication
43 };
44
45 class ShenandoahMarkRefsSuperClosure : public MetadataAwareOopClosure {
46 private:
47 ShenandoahObjToScanQueue* _queue;
48 ShenandoahStrDedupQueue* _dedup_queue;
49 ShenandoahHeap* _heap;
50 ShenandoahMarkingContext* const _mark_context;
51
52 public:
53 ShenandoahMarkRefsSuperClosure(ShenandoahObjToScanQueue* q, ReferenceProcessor* rp);
54 ShenandoahMarkRefsSuperClosure(ShenandoahObjToScanQueue* q, ShenandoahStrDedupQueue* dq, ReferenceProcessor* rp);
55
56 template <class T, UpdateRefsMode UPDATE_MODE, StringDedupMode STRING_DEDUP>
57 void work(T *p);
58 };
59
60 class ShenandoahMarkUpdateRefsClosure : public ShenandoahMarkRefsSuperClosure {
61 public:
62 ShenandoahMarkUpdateRefsClosure(ShenandoahObjToScanQueue* q, ReferenceProcessor* rp) :
63 ShenandoahMarkRefsSuperClosure(q, rp) {};
64
65 template <class T>
66 inline void do_oop_nv(T* p) { work<T, CONCURRENT, NO_DEDUP>(p); }
67 virtual void do_oop(narrowOop* p) { do_oop_nv(p); }
68 virtual void do_oop(oop* p) { do_oop_nv(p); }
69 inline bool do_metadata_nv() { return false; }
70 virtual bool do_metadata() { return false; }
71 };
72
73 class ShenandoahMarkUpdateRefsDedupClosure : public ShenandoahMarkRefsSuperClosure {
74 public:
75 ShenandoahMarkUpdateRefsDedupClosure(ShenandoahObjToScanQueue* q, ShenandoahStrDedupQueue* dq, ReferenceProcessor* rp) :
76 ShenandoahMarkRefsSuperClosure(q, dq, rp) {};
77
78 template <class T>
79 inline void do_oop_nv(T* p) { work<T, CONCURRENT, ENQUEUE_DEDUP>(p); }
80 virtual void do_oop(narrowOop* p) { do_oop_nv(p); }
81 virtual void do_oop(oop* p) { do_oop_nv(p); }
82 inline bool do_metadata_nv() { return false; }
83 virtual bool do_metadata() { return false; }
84 };
85
86 class ShenandoahMarkUpdateRefsMetadataClosure : public ShenandoahMarkRefsSuperClosure {
87 public:
88 ShenandoahMarkUpdateRefsMetadataClosure(ShenandoahObjToScanQueue* q, ReferenceProcessor* rp) :
89 ShenandoahMarkRefsSuperClosure(q, rp) {};
90
91 template <class T>
92 inline void do_oop_nv(T* p) { work<T, CONCURRENT, NO_DEDUP>(p); }
93 virtual void do_oop(narrowOop* p) { do_oop_nv(p); }
94 virtual void do_oop(oop* p) { do_oop_nv(p); }
95 inline bool do_metadata_nv() { return true; }
96 virtual bool do_metadata() { return true; }
97 };
98
99 class ShenandoahMarkUpdateRefsMetadataDedupClosure : public ShenandoahMarkRefsSuperClosure {
100 public:
101 ShenandoahMarkUpdateRefsMetadataDedupClosure(ShenandoahObjToScanQueue* q, ShenandoahStrDedupQueue* dq, ReferenceProcessor* rp) :
102 ShenandoahMarkRefsSuperClosure(q, dq, rp) {};
103
104 template <class T>
105 inline void do_oop_nv(T* p) { work<T, CONCURRENT, ENQUEUE_DEDUP>(p); }
106 virtual void do_oop(narrowOop* p) { do_oop_nv(p); }
107 virtual void do_oop(oop* p) { do_oop_nv(p); }
108 inline bool do_metadata_nv() { return true; }
109 virtual bool do_metadata() { return true; }
110 };
111
112 class ShenandoahMarkRefsClosure : public ShenandoahMarkRefsSuperClosure {
113 public:
114 ShenandoahMarkRefsClosure(ShenandoahObjToScanQueue* q, ReferenceProcessor* rp) :
115 ShenandoahMarkRefsSuperClosure(q, rp) {};
116
117 template <class T>
118 inline void do_oop_nv(T* p) { work<T, NONE, NO_DEDUP>(p); }
119 virtual void do_oop(narrowOop* p) { do_oop_nv(p); }
120 virtual void do_oop(oop* p) { do_oop_nv(p); }
121 inline bool do_metadata_nv() { return false; }
122 virtual bool do_metadata() { return false; }
123 };
124
125 class ShenandoahMarkRefsDedupClosure : public ShenandoahMarkRefsSuperClosure {
126 public:
127 ShenandoahMarkRefsDedupClosure(ShenandoahObjToScanQueue* q, ShenandoahStrDedupQueue* dq, ReferenceProcessor* rp) :
128 ShenandoahMarkRefsSuperClosure(q, dq, rp) {};
129
130 template <class T>
131 inline void do_oop_nv(T* p) { work<T, NONE, ENQUEUE_DEDUP>(p); }
132 virtual void do_oop(narrowOop* p) { do_oop_nv(p); }
133 virtual void do_oop(oop* p) { do_oop_nv(p); }
134 inline bool do_metadata_nv() { return false; }
135 virtual bool do_metadata() { return false; }
136 };
137
138 class ShenandoahMarkResolveRefsClosure : public ShenandoahMarkRefsSuperClosure {
139 public:
140 ShenandoahMarkResolveRefsClosure(ShenandoahObjToScanQueue* q, ReferenceProcessor* rp) :
141 ShenandoahMarkRefsSuperClosure(q, rp) {};
142
143 template <class T>
144 inline void do_oop_nv(T* p) { work<T, RESOLVE, NO_DEDUP>(p); }
145 virtual void do_oop(narrowOop* p) { do_oop_nv(p); }
146 virtual void do_oop(oop* p) { do_oop_nv(p); }
147 inline bool do_metadata_nv() { return false; }
148 virtual bool do_metadata() { return false; }
149 };
150
151 class ShenandoahMarkResolveRefsDedupClosure : public ShenandoahMarkRefsSuperClosure {
152 public:
153 ShenandoahMarkResolveRefsDedupClosure(ShenandoahObjToScanQueue* q, ShenandoahStrDedupQueue* dq, ReferenceProcessor* rp) :
154 ShenandoahMarkRefsSuperClosure(q, dq, rp) {};
155
156 template <class T>
157 inline void do_oop_nv(T* p) { work<T, RESOLVE, ENQUEUE_DEDUP>(p); }
158 virtual void do_oop(narrowOop* p) { do_oop_nv(p); }
159 virtual void do_oop(oop* p) { do_oop_nv(p); }
160 inline bool do_metadata_nv() { return false; }
161 virtual bool do_metadata() { return false; }
162 };
163
164 class ShenandoahMarkRefsMetadataClosure : public ShenandoahMarkRefsSuperClosure {
165 public:
166 ShenandoahMarkRefsMetadataClosure(ShenandoahObjToScanQueue* q, ReferenceProcessor* rp) :
167 ShenandoahMarkRefsSuperClosure(q, rp) {};
168
169 template <class T>
170 inline void do_oop_nv(T* p) { work<T, NONE, NO_DEDUP>(p); }
171 virtual void do_oop(narrowOop* p) { do_oop_nv(p); }
172 virtual void do_oop(oop* p) { do_oop_nv(p); }
173 inline bool do_metadata_nv() { return true; }
174 virtual bool do_metadata() { return true; }
175 };
176
177 class ShenandoahMarkRefsMetadataDedupClosure : public ShenandoahMarkRefsSuperClosure {
178 public:
179 ShenandoahMarkRefsMetadataDedupClosure(ShenandoahObjToScanQueue* q, ShenandoahStrDedupQueue* dq, ReferenceProcessor* rp) :
180 ShenandoahMarkRefsSuperClosure(q, dq, rp) {};
181
182 template <class T>
183 inline void do_oop_nv(T* p) { work<T, NONE, ENQUEUE_DEDUP>(p); }
184 virtual void do_oop(narrowOop* p) { do_oop_nv(p); }
185 virtual void do_oop(oop* p) { do_oop_nv(p); }
186 inline bool do_metadata_nv() { return true; }
187 virtual bool do_metadata() { return true; }
188 };
189
190 class ShenandoahUpdateHeapRefsClosure : public ExtendedOopClosure {
191 private:
192 ShenandoahHeap* _heap;
193 public:
194 ShenandoahUpdateHeapRefsClosure();
195
196 template <class T>
197 void do_oop_nv(T* p);
198
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 #endif // SHARE_VM_GC_SHENANDOAH_SHENANDOAHOOPCLOSURES_HPP