116 template <class T> void do_oop_nv(T* p); |
116 template <class T> void do_oop_nv(T* p); |
117 virtual void do_oop(oop* p) { do_oop_nv(p); } |
117 virtual void do_oop(oop* p) { do_oop_nv(p); } |
118 virtual void do_oop(narrowOop* p) { do_oop_nv(p); } |
118 virtual void do_oop(narrowOop* p) { do_oop_nv(p); } |
119 }; |
119 }; |
120 |
120 |
|
121 // Add back base class for metadata |
|
122 class G1ParCopyHelper : public G1ParClosureSuper { |
|
123 Klass* _scanned_klass; |
|
124 |
|
125 public: |
|
126 G1ParCopyHelper(G1CollectedHeap* g1, G1ParScanThreadState* par_scan_state) : |
|
127 _scanned_klass(NULL), |
|
128 G1ParClosureSuper(g1, par_scan_state) {} |
|
129 |
|
130 void set_scanned_klass(Klass* k) { _scanned_klass = k; } |
|
131 template <class T> void do_klass_barrier(T* p, oop new_obj); |
|
132 }; |
|
133 |
121 template <bool do_gen_barrier, G1Barrier barrier, bool do_mark_object> |
134 template <bool do_gen_barrier, G1Barrier barrier, bool do_mark_object> |
122 class G1ParCopyClosure : public G1ParClosureSuper { |
135 class G1ParCopyClosure : public G1ParCopyHelper { |
123 G1ParScanClosure _scanner; |
136 G1ParScanClosure _scanner; |
124 template <class T> void do_oop_work(T* p); |
137 template <class T> void do_oop_work(T* p); |
125 |
138 |
126 protected: |
139 protected: |
127 // Mark the object if it's not already marked. This is used to mark |
140 // Mark the object if it's not already marked. This is used to mark |
138 |
151 |
139 public: |
152 public: |
140 G1ParCopyClosure(G1CollectedHeap* g1, G1ParScanThreadState* par_scan_state, |
153 G1ParCopyClosure(G1CollectedHeap* g1, G1ParScanThreadState* par_scan_state, |
141 ReferenceProcessor* rp) : |
154 ReferenceProcessor* rp) : |
142 _scanner(g1, par_scan_state, rp), |
155 _scanner(g1, par_scan_state, rp), |
143 G1ParClosureSuper(g1, par_scan_state) { |
156 G1ParCopyHelper(g1, par_scan_state) { |
144 assert(_ref_processor == NULL, "sanity"); |
157 assert(_ref_processor == NULL, "sanity"); |
145 } |
158 } |
146 |
159 |
147 G1ParScanClosure* scanner() { return &_scanner; } |
160 G1ParScanClosure* scanner() { return &_scanner; } |
148 |
161 |
152 virtual void do_oop(oop* p) { do_oop_nv(p); } |
165 virtual void do_oop(oop* p) { do_oop_nv(p); } |
153 virtual void do_oop(narrowOop* p) { do_oop_nv(p); } |
166 virtual void do_oop(narrowOop* p) { do_oop_nv(p); } |
154 }; |
167 }; |
155 |
168 |
156 typedef G1ParCopyClosure<false, G1BarrierNone, false> G1ParScanExtRootClosure; |
169 typedef G1ParCopyClosure<false, G1BarrierNone, false> G1ParScanExtRootClosure; |
157 typedef G1ParCopyClosure<true, G1BarrierNone, false> G1ParScanPermClosure; |
170 typedef G1ParCopyClosure<false, G1BarrierKlass, false> G1ParScanMetadataClosure; |
|
171 |
158 |
172 |
159 typedef G1ParCopyClosure<false, G1BarrierNone, true> G1ParScanAndMarkExtRootClosure; |
173 typedef G1ParCopyClosure<false, G1BarrierNone, true> G1ParScanAndMarkExtRootClosure; |
160 typedef G1ParCopyClosure<true, G1BarrierNone, true> G1ParScanAndMarkPermClosure; |
174 typedef G1ParCopyClosure<true, G1BarrierNone, true> G1ParScanAndMarkClosure; |
|
175 typedef G1ParCopyClosure<false, G1BarrierKlass, true> G1ParScanAndMarkMetadataClosure; |
161 |
176 |
162 // The following closure types are no longer used but are retained |
177 // The following closure types are no longer used but are retained |
163 // for historical reasons: |
178 // for historical reasons: |
164 // typedef G1ParCopyClosure<false, G1BarrierRS, false> G1ParScanHeapRSClosure; |
179 // typedef G1ParCopyClosure<false, G1BarrierRS, false> G1ParScanHeapRSClosure; |
165 // typedef G1ParCopyClosure<false, G1BarrierRS, true> G1ParScanAndMarkHeapRSClosure; |
180 // typedef G1ParCopyClosure<false, G1BarrierRS, true> G1ParScanAndMarkHeapRSClosure; |
174 // (since that closure no longer assumes that the references it |
189 // (since that closure no longer assumes that the references it |
175 // handles point into the collection set). |
190 // handles point into the collection set). |
176 |
191 |
177 typedef G1ParCopyClosure<false, G1BarrierEvac, false> G1ParScanHeapEvacFailureClosure; |
192 typedef G1ParCopyClosure<false, G1BarrierEvac, false> G1ParScanHeapEvacFailureClosure; |
178 |
193 |
179 class FilterIntoCSClosure: public OopClosure { |
194 class FilterIntoCSClosure: public ExtendedOopClosure { |
180 G1CollectedHeap* _g1; |
195 G1CollectedHeap* _g1; |
181 OopClosure* _oc; |
196 OopClosure* _oc; |
182 DirtyCardToOopClosure* _dcto_cl; |
197 DirtyCardToOopClosure* _dcto_cl; |
183 public: |
198 public: |
184 FilterIntoCSClosure( DirtyCardToOopClosure* dcto_cl, |
199 FilterIntoCSClosure( DirtyCardToOopClosure* dcto_cl, |
188 |
203 |
189 template <class T> void do_oop_nv(T* p); |
204 template <class T> void do_oop_nv(T* p); |
190 virtual void do_oop(oop* p) { do_oop_nv(p); } |
205 virtual void do_oop(oop* p) { do_oop_nv(p); } |
191 virtual void do_oop(narrowOop* p) { do_oop_nv(p); } |
206 virtual void do_oop(narrowOop* p) { do_oop_nv(p); } |
192 bool apply_to_weak_ref_discovered_field() { return true; } |
207 bool apply_to_weak_ref_discovered_field() { return true; } |
193 bool do_header() { return false; } |
208 }; |
194 }; |
209 |
195 |
210 class FilterOutOfRegionClosure: public ExtendedOopClosure { |
196 class FilterOutOfRegionClosure: public OopClosure { |
|
197 HeapWord* _r_bottom; |
211 HeapWord* _r_bottom; |
198 HeapWord* _r_end; |
212 HeapWord* _r_end; |
199 OopClosure* _oc; |
213 OopClosure* _oc; |
200 public: |
214 public: |
201 FilterOutOfRegionClosure(HeapRegion* r, OopClosure* oc); |
215 FilterOutOfRegionClosure(HeapRegion* r, OopClosure* oc); |
202 template <class T> void do_oop_nv(T* p); |
216 template <class T> void do_oop_nv(T* p); |
203 virtual void do_oop(oop* p) { do_oop_nv(p); } |
217 virtual void do_oop(oop* p) { do_oop_nv(p); } |
204 virtual void do_oop(narrowOop* p) { do_oop_nv(p); } |
218 virtual void do_oop(narrowOop* p) { do_oop_nv(p); } |
205 bool apply_to_weak_ref_discovered_field() { return true; } |
219 bool apply_to_weak_ref_discovered_field() { return true; } |
206 bool do_header() { return false; } |
|
207 }; |
220 }; |
208 |
221 |
209 // Closure for iterating over object fields during concurrent marking |
222 // Closure for iterating over object fields during concurrent marking |
210 class G1CMOopClosure : public OopClosure { |
223 class G1CMOopClosure : public ExtendedOopClosure { |
211 private: |
224 private: |
212 G1CollectedHeap* _g1h; |
225 G1CollectedHeap* _g1h; |
213 ConcurrentMark* _cm; |
226 ConcurrentMark* _cm; |
214 CMTask* _task; |
227 CMTask* _task; |
215 public: |
228 public: |
218 virtual void do_oop( oop* p) { do_oop_nv(p); } |
231 virtual void do_oop( oop* p) { do_oop_nv(p); } |
219 virtual void do_oop(narrowOop* p) { do_oop_nv(p); } |
232 virtual void do_oop(narrowOop* p) { do_oop_nv(p); } |
220 }; |
233 }; |
221 |
234 |
222 // Closure to scan the root regions during concurrent marking |
235 // Closure to scan the root regions during concurrent marking |
223 class G1RootRegionScanClosure : public OopClosure { |
236 class G1RootRegionScanClosure : public ExtendedOopClosure { |
224 private: |
237 private: |
225 G1CollectedHeap* _g1h; |
238 G1CollectedHeap* _g1h; |
226 ConcurrentMark* _cm; |
239 ConcurrentMark* _cm; |
227 uint _worker_id; |
240 uint _worker_id; |
228 public: |
241 public: |
237 // Closure that applies the given two closures in sequence. |
250 // Closure that applies the given two closures in sequence. |
238 // Used by the RSet refinement code (when updating RSets |
251 // Used by the RSet refinement code (when updating RSets |
239 // during an evacuation pause) to record cards containing |
252 // during an evacuation pause) to record cards containing |
240 // pointers into the collection set. |
253 // pointers into the collection set. |
241 |
254 |
242 class G1Mux2Closure : public OopClosure { |
255 class G1Mux2Closure : public ExtendedOopClosure { |
243 OopClosure* _c1; |
256 OopClosure* _c1; |
244 OopClosure* _c2; |
257 OopClosure* _c2; |
245 public: |
258 public: |
246 G1Mux2Closure(OopClosure *c1, OopClosure *c2); |
259 G1Mux2Closure(OopClosure *c1, OopClosure *c2); |
247 template <class T> void do_oop_nv(T* p); |
260 template <class T> void do_oop_nv(T* p); |
263 }; |
276 }; |
264 |
277 |
265 // A closure which uses a triggering closure to determine |
278 // A closure which uses a triggering closure to determine |
266 // whether to apply an oop closure. |
279 // whether to apply an oop closure. |
267 |
280 |
268 class G1InvokeIfNotTriggeredClosure: public OopClosure { |
281 class G1InvokeIfNotTriggeredClosure: public ExtendedOopClosure { |
269 G1TriggerClosure* _trigger_cl; |
282 G1TriggerClosure* _trigger_cl; |
270 OopClosure* _oop_cl; |
283 OopClosure* _oop_cl; |
271 public: |
284 public: |
272 G1InvokeIfNotTriggeredClosure(G1TriggerClosure* t, OopClosure* oc); |
285 G1InvokeIfNotTriggeredClosure(G1TriggerClosure* t, OopClosure* oc); |
273 template <class T> void do_oop_nv(T* p); |
286 template <class T> void do_oop_nv(T* p); |
274 virtual void do_oop(oop* p) { do_oop_nv(p); } |
287 virtual void do_oop(oop* p) { do_oop_nv(p); } |
275 virtual void do_oop(narrowOop* p) { do_oop_nv(p); } |
288 virtual void do_oop(narrowOop* p) { do_oop_nv(p); } |
276 }; |
289 }; |
277 |
290 |
278 class G1UpdateRSOrPushRefOopClosure: public OopClosure { |
291 class G1UpdateRSOrPushRefOopClosure: public ExtendedOopClosure { |
279 G1CollectedHeap* _g1; |
292 G1CollectedHeap* _g1; |
280 G1RemSet* _g1_rem_set; |
293 G1RemSet* _g1_rem_set; |
281 HeapRegion* _from; |
294 HeapRegion* _from; |
282 OopsInHeapRegionClosure* _push_ref_cl; |
295 OopsInHeapRegionClosure* _push_ref_cl; |
283 bool _record_refs_into_cset; |
296 bool _record_refs_into_cset; |