57 bool apply_to_weak_ref_discovered_field() { return true; } |
58 bool apply_to_weak_ref_discovered_field() { return true; } |
58 }; |
59 }; |
59 |
60 |
60 class G1ParPushHeapRSClosure : public G1ParClosureSuper { |
61 class G1ParPushHeapRSClosure : public G1ParClosureSuper { |
61 public: |
62 public: |
62 G1ParPushHeapRSClosure(G1CollectedHeap* g1, G1ParScanThreadState* par_scan_state) : |
63 G1ParPushHeapRSClosure(G1CollectedHeap* g1, |
63 G1ParClosureSuper(g1, par_scan_state) { } |
64 G1ParScanThreadState* par_scan_state, |
|
65 ReferenceProcessor* rp) : |
|
66 G1ParClosureSuper(g1, par_scan_state) |
|
67 { |
|
68 assert(_ref_processor == NULL, "sanity"); |
|
69 _ref_processor = rp; |
|
70 } |
|
71 |
64 template <class T> void do_oop_nv(T* p); |
72 template <class T> void do_oop_nv(T* p); |
65 virtual void do_oop(oop* p) { do_oop_nv(p); } |
73 virtual void do_oop(oop* p) { do_oop_nv(p); } |
66 virtual void do_oop(narrowOop* p) { do_oop_nv(p); } |
74 virtual void do_oop(narrowOop* p) { do_oop_nv(p); } |
67 }; |
75 }; |
68 |
76 |
69 class G1ParScanClosure : public G1ParClosureSuper { |
77 class G1ParScanClosure : public G1ParClosureSuper { |
70 public: |
78 public: |
71 G1ParScanClosure(G1CollectedHeap* g1, G1ParScanThreadState* par_scan_state) : |
79 G1ParScanClosure(G1CollectedHeap* g1, G1ParScanThreadState* par_scan_state, ReferenceProcessor* rp) : |
72 G1ParClosureSuper(g1, par_scan_state) { } |
80 G1ParClosureSuper(g1, par_scan_state) |
|
81 { |
|
82 assert(_ref_processor == NULL, "sanity"); |
|
83 _ref_processor = rp; |
|
84 } |
|
85 |
73 template <class T> void do_oop_nv(T* p); |
86 template <class T> void do_oop_nv(T* p); |
74 virtual void do_oop(oop* p) { do_oop_nv(p); } |
87 virtual void do_oop(oop* p) { do_oop_nv(p); } |
75 virtual void do_oop(narrowOop* p) { do_oop_nv(p); } |
88 virtual void do_oop(narrowOop* p) { do_oop_nv(p); } |
76 }; |
89 }; |
77 |
90 |
90 return oop((intptr_t)ref & ~G1_PARTIAL_ARRAY_MASK); |
103 return oop((intptr_t)ref & ~G1_PARTIAL_ARRAY_MASK); |
91 } |
104 } |
92 |
105 |
93 class G1ParScanPartialArrayClosure : public G1ParClosureSuper { |
106 class G1ParScanPartialArrayClosure : public G1ParClosureSuper { |
94 G1ParScanClosure _scanner; |
107 G1ParScanClosure _scanner; |
95 public: |
108 |
96 G1ParScanPartialArrayClosure(G1CollectedHeap* g1, G1ParScanThreadState* par_scan_state) : |
109 public: |
97 G1ParClosureSuper(g1, par_scan_state), _scanner(g1, par_scan_state) { } |
110 G1ParScanPartialArrayClosure(G1CollectedHeap* g1, G1ParScanThreadState* par_scan_state, ReferenceProcessor* rp) : |
|
111 G1ParClosureSuper(g1, par_scan_state), _scanner(g1, par_scan_state, rp) |
|
112 { |
|
113 assert(_ref_processor == NULL, "sanity"); |
|
114 } |
|
115 |
|
116 G1ParScanClosure* scanner() { |
|
117 return &_scanner; |
|
118 } |
|
119 |
98 template <class T> void do_oop_nv(T* p); |
120 template <class T> void do_oop_nv(T* p); |
99 virtual void do_oop(oop* p) { do_oop_nv(p); } |
121 virtual void do_oop(oop* p) { do_oop_nv(p); } |
100 virtual void do_oop(narrowOop* p) { do_oop_nv(p); } |
122 virtual void do_oop(narrowOop* p) { do_oop_nv(p); } |
101 }; |
123 }; |
102 |
124 |
115 |
137 |
116 template<bool do_gen_barrier, G1Barrier barrier, |
138 template<bool do_gen_barrier, G1Barrier barrier, |
117 bool do_mark_object> |
139 bool do_mark_object> |
118 class G1ParCopyClosure : public G1ParCopyHelper { |
140 class G1ParCopyClosure : public G1ParCopyHelper { |
119 G1ParScanClosure _scanner; |
141 G1ParScanClosure _scanner; |
|
142 |
120 template <class T> void do_oop_work(T* p); |
143 template <class T> void do_oop_work(T* p); |
121 public: |
144 |
122 G1ParCopyClosure(G1CollectedHeap* g1, G1ParScanThreadState* par_scan_state) : |
145 public: |
123 _scanner(g1, par_scan_state), G1ParCopyHelper(g1, par_scan_state, &_scanner) { } |
146 G1ParCopyClosure(G1CollectedHeap* g1, G1ParScanThreadState* par_scan_state, |
|
147 ReferenceProcessor* rp) : |
|
148 _scanner(g1, par_scan_state, rp), |
|
149 G1ParCopyHelper(g1, par_scan_state, &_scanner) |
|
150 { |
|
151 assert(_ref_processor == NULL, "sanity"); |
|
152 } |
|
153 |
|
154 G1ParScanClosure* scanner() { return &_scanner; } |
|
155 |
124 template <class T> void do_oop_nv(T* p) { |
156 template <class T> void do_oop_nv(T* p) { |
125 do_oop_work(p); |
157 do_oop_work(p); |
126 } |
158 } |
127 virtual void do_oop(oop* p) { do_oop_nv(p); } |
159 virtual void do_oop(oop* p) { do_oop_nv(p); } |
128 virtual void do_oop(narrowOop* p) { do_oop_nv(p); } |
160 virtual void do_oop(narrowOop* p) { do_oop_nv(p); } |
129 }; |
161 }; |
130 |
162 |
131 typedef G1ParCopyClosure<false, G1BarrierNone, false> G1ParScanExtRootClosure; |
163 typedef G1ParCopyClosure<false, G1BarrierNone, false> G1ParScanExtRootClosure; |
132 typedef G1ParCopyClosure<true, G1BarrierNone, false> G1ParScanPermClosure; |
164 typedef G1ParCopyClosure<true, G1BarrierNone, false> G1ParScanPermClosure; |
133 typedef G1ParCopyClosure<false, G1BarrierRS, false> G1ParScanHeapRSClosure; |
165 |
134 typedef G1ParCopyClosure<false, G1BarrierNone, true> G1ParScanAndMarkExtRootClosure; |
166 typedef G1ParCopyClosure<false, G1BarrierNone, true> G1ParScanAndMarkExtRootClosure; |
135 typedef G1ParCopyClosure<true, G1BarrierNone, true> G1ParScanAndMarkPermClosure; |
167 typedef G1ParCopyClosure<true, G1BarrierNone, true> G1ParScanAndMarkPermClosure; |
136 typedef G1ParCopyClosure<false, G1BarrierRS, true> G1ParScanAndMarkHeapRSClosure; |
168 |
137 |
169 // The following closure types are no longer used but are retained |
138 // This is the only case when we set skip_cset_test. Basically, this |
170 // for historical reasons: |
139 // closure is (should?) only be called directly while we're draining |
171 // typedef G1ParCopyClosure<false, G1BarrierRS, false> G1ParScanHeapRSClosure; |
140 // the overflow and task queues. In that case we know that the |
172 // typedef G1ParCopyClosure<false, G1BarrierRS, true> G1ParScanAndMarkHeapRSClosure; |
141 // reference in question points into the collection set, otherwise we |
173 |
142 // would not have pushed it on the queue. The following is defined in |
174 // The following closure type is defined in g1_specialized_oop_closures.hpp: |
143 // g1_specialized_oop_closures.hpp. |
175 // |
144 // typedef G1ParCopyClosure<false, G1BarrierEvac, false, true> G1ParScanHeapEvacClosure; |
176 // typedef G1ParCopyClosure<false, G1BarrierEvac, false> G1ParScanHeapEvacClosure; |
145 // We need a separate closure to handle references during evacuation |
177 |
146 // failure processing, as we cannot asume that the reference already |
178 // We use a separate closure to handle references during evacuation |
147 // points into the collection set (like G1ParScanHeapEvacClosure does). |
179 // failure processing. |
|
180 // We could have used another instance of G1ParScanHeapEvacClosure |
|
181 // (since that closure no longer assumes that the references it |
|
182 // handles point into the collection set). |
|
183 |
148 typedef G1ParCopyClosure<false, G1BarrierEvac, false> G1ParScanHeapEvacFailureClosure; |
184 typedef G1ParCopyClosure<false, G1BarrierEvac, false> G1ParScanHeapEvacFailureClosure; |
149 |
185 |
150 class FilterIntoCSClosure: public OopClosure { |
186 class FilterIntoCSClosure: public OopClosure { |
151 G1CollectedHeap* _g1; |
187 G1CollectedHeap* _g1; |
152 OopClosure* _oc; |
188 OopClosure* _oc; |
153 DirtyCardToOopClosure* _dcto_cl; |
189 DirtyCardToOopClosure* _dcto_cl; |
154 public: |
190 public: |
155 FilterIntoCSClosure( DirtyCardToOopClosure* dcto_cl, |
191 FilterIntoCSClosure( DirtyCardToOopClosure* dcto_cl, |
156 G1CollectedHeap* g1, OopClosure* oc) : |
192 G1CollectedHeap* g1, |
|
193 OopClosure* oc, |
|
194 ReferenceProcessor* rp) : |
157 _dcto_cl(dcto_cl), _g1(g1), _oc(oc) |
195 _dcto_cl(dcto_cl), _g1(g1), _oc(oc) |
158 {} |
196 { |
|
197 assert(_ref_processor == NULL, "sanity"); |
|
198 _ref_processor = rp; |
|
199 } |
|
200 |
159 template <class T> void do_oop_nv(T* p); |
201 template <class T> void do_oop_nv(T* p); |
160 virtual void do_oop(oop* p) { do_oop_nv(p); } |
202 virtual void do_oop(oop* p) { do_oop_nv(p); } |
161 virtual void do_oop(narrowOop* p) { do_oop_nv(p); } |
203 virtual void do_oop(narrowOop* p) { do_oop_nv(p); } |
162 bool apply_to_weak_ref_discovered_field() { return true; } |
204 bool apply_to_weak_ref_discovered_field() { return true; } |
163 bool do_header() { return false; } |
205 bool do_header() { return false; } |