45 HeapRegion* _from; |
46 HeapRegion* _from; |
46 public: |
47 public: |
47 void set_region(HeapRegion* from) { _from = from; } |
48 void set_region(HeapRegion* from) { _from = from; } |
48 }; |
49 }; |
49 |
50 |
50 class G1ParClosureSuper : public OopsInHeapRegionClosure { |
51 class G1ScanClosureBase : public OopsInHeapRegionClosure { |
51 protected: |
52 protected: |
52 G1CollectedHeap* _g1; |
53 G1CollectedHeap* _g1; |
53 G1ParScanThreadState* _par_scan_state; |
54 G1ParScanThreadState* _par_scan_state; |
54 |
55 |
55 G1ParClosureSuper(G1CollectedHeap* g1, G1ParScanThreadState* par_scan_state); |
56 G1ScanClosureBase(G1CollectedHeap* g1, G1ParScanThreadState* par_scan_state); |
56 ~G1ParClosureSuper() { } |
57 ~G1ScanClosureBase() { } |
57 |
58 |
|
59 template <class T> |
|
60 inline void prefetch_and_push(T* p, oop const obj); |
|
61 |
|
62 template <class T> |
|
63 inline void handle_non_cset_obj_common(InCSetState const state, T* p, oop const obj); |
58 public: |
64 public: |
59 // This closure needs special handling for InstanceRefKlass. |
65 // This closure needs special handling for InstanceRefKlass. |
60 virtual ReferenceIterationMode reference_iteration_mode() { return DO_DISCOVERED_AND_DISCOVERY; } |
66 virtual ReferenceIterationMode reference_iteration_mode() { return DO_DISCOVERED_AND_DISCOVERY; } |
61 }; |
67 }; |
62 |
68 |
63 class G1ParPushHeapRSClosure : public G1ParClosureSuper { |
69 // Used during the Update RS phase to refine remaining cards in the DCQ during garbage collection. |
64 public: |
70 class G1ScanObjsDuringUpdateRSClosure: public G1ScanClosureBase { |
65 G1ParPushHeapRSClosure(G1CollectedHeap* g1, |
71 uint _worker_i; |
66 G1ParScanThreadState* par_scan_state): |
72 bool _has_refs_into_cset; |
67 G1ParClosureSuper(g1, par_scan_state) { } |
73 |
|
74 public: |
|
75 G1ScanObjsDuringUpdateRSClosure(G1CollectedHeap* g1h, |
|
76 G1ParScanThreadState* pss, |
|
77 uint worker_i) : |
|
78 G1ScanClosureBase(g1h, pss), _has_refs_into_cset(false), _worker_i(worker_i) { } |
|
79 |
|
80 void reset_has_refs_into_cset() { _has_refs_into_cset = false; } |
|
81 bool has_refs_into_cset() const { return _has_refs_into_cset; } |
|
82 |
|
83 template <class T> void do_oop_nv(T* p); |
|
84 virtual void do_oop(narrowOop* p) { do_oop_nv(p); } |
|
85 virtual void do_oop(oop* p) { do_oop_nv(p); } |
|
86 }; |
|
87 |
|
88 // Used during the Scan RS phase to scan cards from the remembered set during garbage collection. |
|
89 class G1ScanObjsDuringScanRSClosure : public G1ScanClosureBase { |
|
90 public: |
|
91 G1ScanObjsDuringScanRSClosure(G1CollectedHeap* g1, |
|
92 G1ParScanThreadState* par_scan_state): |
|
93 G1ScanClosureBase(g1, par_scan_state) { } |
68 |
94 |
69 template <class T> void do_oop_nv(T* p); |
95 template <class T> void do_oop_nv(T* p); |
70 virtual void do_oop(oop* p) { do_oop_nv(p); } |
96 virtual void do_oop(oop* p) { do_oop_nv(p); } |
71 virtual void do_oop(narrowOop* p) { do_oop_nv(p); } |
97 virtual void do_oop(narrowOop* p) { do_oop_nv(p); } |
72 }; |
98 }; |
73 |
99 |
74 class G1ParScanClosure : public G1ParClosureSuper { |
100 // This closure is applied to the fields of the objects that have just been copied during evacuation. |
75 public: |
101 class G1ScanEvacuatedObjClosure : public G1ScanClosureBase { |
76 G1ParScanClosure(G1CollectedHeap* g1, G1ParScanThreadState* par_scan_state) : |
102 public: |
77 G1ParClosureSuper(g1, par_scan_state) { } |
103 G1ScanEvacuatedObjClosure(G1CollectedHeap* g1, G1ParScanThreadState* par_scan_state) : |
|
104 G1ScanClosureBase(g1, par_scan_state) { } |
78 |
105 |
79 template <class T> void do_oop_nv(T* p); |
106 template <class T> void do_oop_nv(T* p); |
80 virtual void do_oop(oop* p) { do_oop_nv(p); } |
107 virtual void do_oop(oop* p) { do_oop_nv(p); } |
81 virtual void do_oop(narrowOop* p) { do_oop_nv(p); } |
108 virtual void do_oop(narrowOop* p) { do_oop_nv(p); } |
82 |
109 |
184 // This closure needs special handling for InstanceRefKlass. |
211 // This closure needs special handling for InstanceRefKlass. |
185 virtual ReferenceIterationMode reference_iteration_mode() { return DO_DISCOVERED_AND_DISCOVERY; } |
212 virtual ReferenceIterationMode reference_iteration_mode() { return DO_DISCOVERED_AND_DISCOVERY; } |
186 |
213 |
187 template <class T> void do_oop_nv(T* p); |
214 template <class T> void do_oop_nv(T* p); |
188 virtual void do_oop(narrowOop* p) { do_oop_nv(p); } |
215 virtual void do_oop(narrowOop* p) { do_oop_nv(p); } |
189 virtual void do_oop(oop* p) { do_oop_nv(p); } |
216 virtual void do_oop(oop* p) { do_oop_nv(p); } |
190 }; |
|
191 |
|
192 class G1UpdateRSOrPushRefOopClosure: public ExtendedOopClosure { |
|
193 G1CollectedHeap* _g1; |
|
194 HeapRegion* _from; |
|
195 G1ParPushHeapRSClosure* _push_ref_cl; |
|
196 bool _record_refs_into_cset; |
|
197 uint _worker_i; |
|
198 bool _has_refs_into_cset; |
|
199 |
|
200 public: |
|
201 G1UpdateRSOrPushRefOopClosure(G1CollectedHeap* g1h, |
|
202 G1ParPushHeapRSClosure* push_ref_cl, |
|
203 bool record_refs_into_cset, |
|
204 uint worker_i = 0); |
|
205 |
|
206 void set_from(HeapRegion* from) { |
|
207 assert(from != NULL, "from region must be non-NULL"); |
|
208 _from = from; |
|
209 } |
|
210 |
|
211 bool self_forwarded(oop obj) { |
|
212 markOop m = obj->mark(); |
|
213 bool result = (m->is_marked() && ((oop)m->decode_pointer() == obj)); |
|
214 return result; |
|
215 } |
|
216 |
|
217 bool has_refs_into_cset() const { return _has_refs_into_cset; } |
|
218 |
|
219 template <class T> inline void do_oop_nv(T* p); |
|
220 virtual inline void do_oop(narrowOop* p); |
|
221 virtual inline void do_oop(oop* p); |
|
222 |
|
223 // This closure needs special handling for InstanceRefKlass. |
|
224 virtual ReferenceIterationMode reference_iteration_mode() { return DO_DISCOVERED_AND_DISCOVERY; } |
|
225 }; |
217 }; |
226 |
218 |
227 #endif // SHARE_VM_GC_G1_G1OOPCLOSURES_HPP |
219 #endif // SHARE_VM_GC_G1_G1OOPCLOSURES_HPP |