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 ShenandoahConnectionMatrix;
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 SCMObjToScanQueue* _queue;
42 ShenandoahHeap* _heap;
43 ShenandoahConnectionMatrix* _conn_matrix;
44 public:
45 ShenandoahMarkRefsSuperClosure(SCMObjToScanQueue* q, ReferenceProcessor* rp);
46
47 template <class T, UpdateRefsMode UPDATE_MODE, bool UPDATE_MATRIX>
48 void work(T *p);
49 };
50
51 class ShenandoahMarkUpdateRefsClosure : public ShenandoahMarkRefsSuperClosure {
52 public:
53 ShenandoahMarkUpdateRefsClosure(SCMObjToScanQueue* q, ReferenceProcessor* rp) :
54 ShenandoahMarkRefsSuperClosure(q, rp) {};
55
56 template <class T>
57 inline void do_oop_nv(T* p) { work<T, CONCURRENT, false>(p); }
58 virtual void do_oop(narrowOop* p) { do_oop_nv(p); }
59 virtual void do_oop(oop* p) { do_oop_nv(p); }
60 inline bool do_metadata_nv() { return false; }
61 virtual bool do_metadata() { return false; }
62 };
63
64 class ShenandoahMarkUpdateRefsMetadataClosure : public ShenandoahMarkRefsSuperClosure {
65 public:
66 ShenandoahMarkUpdateRefsMetadataClosure(SCMObjToScanQueue* q, ReferenceProcessor* rp) :
67 ShenandoahMarkRefsSuperClosure(q, rp) {};
68
69 template <class T>
70 inline void do_oop_nv(T* p) { work<T, CONCURRENT, false>(p); }
71 virtual void do_oop(narrowOop* p) { do_oop_nv(p); }
72 virtual void do_oop(oop* p) { do_oop_nv(p); }
73 inline bool do_metadata_nv() { return true; }
74 virtual bool do_metadata() { return true; }
75 };
76
77 class ShenandoahMarkRefsClosure : public ShenandoahMarkRefsSuperClosure {
78 public:
79 ShenandoahMarkRefsClosure(SCMObjToScanQueue* q, ReferenceProcessor* rp) :
80 ShenandoahMarkRefsSuperClosure(q, rp) {};
81
82 template <class T>
83 inline void do_oop_nv(T* p) { work<T, NONE, false>(p); }
84 virtual void do_oop(narrowOop* p) { do_oop_nv(p); }
85 virtual void do_oop(oop* p) { do_oop_nv(p); }
86 inline bool do_metadata_nv() { return false; }
87 virtual bool do_metadata() { return false; }
88 };
89
90 class ShenandoahMarkResolveRefsClosure : public ShenandoahMarkRefsSuperClosure {
91 public:
92 ShenandoahMarkResolveRefsClosure(SCMObjToScanQueue* q, ReferenceProcessor* rp) :
93 ShenandoahMarkRefsSuperClosure(q, rp) {};
94
95 template <class T>
96 inline void do_oop_nv(T* p) { work<T, RESOLVE, false>(p); }
97 virtual void do_oop(narrowOop* p) { do_oop_nv(p); }
98 virtual void do_oop(oop* p) { do_oop_nv(p); }
99 inline bool do_metadata_nv() { return false; }
100 virtual bool do_metadata() { return false; }
101 };
102
103 class ShenandoahMarkRefsMetadataClosure : public ShenandoahMarkRefsSuperClosure {
104 public:
105 ShenandoahMarkRefsMetadataClosure(SCMObjToScanQueue* q, ReferenceProcessor* rp) :
106 ShenandoahMarkRefsSuperClosure(q, rp) {};
107
108 template <class T>
109 inline void do_oop_nv(T* p) { work<T, NONE, false>(p); }
110 virtual void do_oop(narrowOop* p) { do_oop_nv(p); }
111 virtual void do_oop(oop* p) { do_oop_nv(p); }
112 inline bool do_metadata_nv() { return true; }
113 virtual bool do_metadata() { return true; }
114 };
115
116 class ShenandoahMarkUpdateRefsMatrixClosure : public ShenandoahMarkRefsSuperClosure {
117 public:
118 ShenandoahMarkUpdateRefsMatrixClosure(SCMObjToScanQueue* q, ReferenceProcessor* rp) :
119 ShenandoahMarkRefsSuperClosure(q, rp) {};
120
121 template <class T>
122 inline void do_oop_nv(T* p) { work<T, CONCURRENT, true>(p); }
123 virtual void do_oop(narrowOop* p) { do_oop_nv(p); }
124 virtual void do_oop(oop* p) { do_oop_nv(p); }
125 inline bool do_metadata_nv() { return false; }
126 virtual bool do_metadata() { return false; }
127 };
128
129 class ShenandoahMarkUpdateRefsMetadataMatrixClosure : public ShenandoahMarkRefsSuperClosure {
130 public:
131 ShenandoahMarkUpdateRefsMetadataMatrixClosure(SCMObjToScanQueue* q, ReferenceProcessor* rp) :
132 ShenandoahMarkRefsSuperClosure(q, rp) {};
133
134 template <class T>
135 inline void do_oop_nv(T* p) { work<T, CONCURRENT, true>(p); }
136 virtual void do_oop(narrowOop* p) { do_oop_nv(p); }
137 virtual void do_oop(oop* p) { do_oop_nv(p); }
138 inline bool do_metadata_nv() { return true; }
139 virtual bool do_metadata() { return true; }
140 };
141
142 class ShenandoahMarkRefsMatrixClosure : public ShenandoahMarkRefsSuperClosure {
143 public:
144 ShenandoahMarkRefsMatrixClosure(SCMObjToScanQueue* q, ReferenceProcessor* rp) :
145 ShenandoahMarkRefsSuperClosure(q, rp) {};
146
147 template <class T>
148 inline void do_oop_nv(T* p) { work<T, NONE, true>(p); }
149 virtual void do_oop(narrowOop* p) { do_oop_nv(p); }
150 virtual void do_oop(oop* p) { do_oop_nv(p); }
151 inline bool do_metadata_nv() { return false; }
152 virtual bool do_metadata() { return false; }
153 };
154
155 class ShenandoahMarkRefsMetadataMatrixClosure : public ShenandoahMarkRefsSuperClosure {
156 public:
157 ShenandoahMarkRefsMetadataMatrixClosure(SCMObjToScanQueue* q, ReferenceProcessor* rp) :
158 ShenandoahMarkRefsSuperClosure(q, rp) {};
159
160 template <class T>
161 inline void do_oop_nv(T* p) { work<T, NONE, true>(p); }
162 virtual void do_oop(narrowOop* p) { do_oop_nv(p); }
163 virtual void do_oop(oop* p) { do_oop_nv(p); }
164 inline bool do_metadata_nv() { return true; }
165 virtual bool do_metadata() { return true; }
166 };
167
168 class ShenandoahUpdateHeapRefsSuperClosure : public ExtendedOopClosure {
169 private:
170 ShenandoahHeap* _heap;
171 public:
172 ShenandoahUpdateHeapRefsSuperClosure() :
173 _heap(ShenandoahHeap::heap()) {}
174
175 template <class T, bool UPDATE_MATRIX>
176 void work(T *p);
177 };
178
179 class ShenandoahUpdateHeapRefsClosure : public ShenandoahUpdateHeapRefsSuperClosure {
180 public:
181 ShenandoahUpdateHeapRefsClosure() : ShenandoahUpdateHeapRefsSuperClosure() {}
182
183 template <class T>
184 inline void do_oop_nv(T* p) { work<T, false>(p); }
185 virtual void do_oop(narrowOop* p) { do_oop_nv(p); }
186 virtual void do_oop(oop* p) { do_oop_nv(p); }
187 };
188
189 class ShenandoahUpdateHeapRefsMatrixClosure : public ShenandoahUpdateHeapRefsSuperClosure {
190 private:
191 ShenandoahHeap* _heap;
192 public:
193 ShenandoahUpdateHeapRefsMatrixClosure() : ShenandoahUpdateHeapRefsSuperClosure() {}
194
195 template <class T>
196 inline void do_oop_nv(T* p) { work<T, true>(p); }
197 virtual void do_oop(narrowOop* p) { do_oop_nv(p); }
198 virtual void do_oop(oop* p) { do_oop_nv(p); }
199 };
200
201 class PartialEvacuateUpdateHeapClosure : public ExtendedOopClosure {
202 ShenandoahPartialGC* _partial_gc;
203 Thread* _thread;
204 SCMObjToScanQueue* _queue;
205 public:
206 PartialEvacuateUpdateHeapClosure(SCMObjToScanQueue* q) :
207 _partial_gc(ShenandoahHeap::heap()->partial_gc()),
208 _thread(Thread::current()), _queue(q) {}
209
210 template <class T>
211 void do_oop_nv(T* p);
212
213 void do_oop(oop* p) { do_oop_nv(p); }
214 void do_oop(narrowOop* p) { do_oop_nv(p); }
215 };
216
217
218 #endif // SHARE_VM_GC_SHENANDOAH_SHENANDOAHOOPCLOSURES_HPP