86 Prefetch::style prefetch_style() { |
86 Prefetch::style prefetch_style() { |
87 return Prefetch::do_read; |
87 return Prefetch::do_read; |
88 } |
88 } |
89 }; |
89 }; |
90 |
90 |
|
91 // KlassRememberingOopClosure is used when marking of the permanent generation |
|
92 // is being done. It adds fields to support revisiting of klasses |
|
93 // for class unloading. _should_remember_klasses should be set to |
|
94 // indicate if klasses should be remembered. Currently that is whenever |
|
95 // CMS class unloading is turned on. The _revisit_stack is used |
|
96 // to save the klasses for later processing. |
|
97 class KlassRememberingOopClosure : public OopClosure { |
|
98 protected: |
|
99 CMSCollector* _collector; |
|
100 CMSMarkStack* _revisit_stack; |
|
101 bool const _should_remember_klasses; |
|
102 public: |
|
103 void check_remember_klasses() const PRODUCT_RETURN; |
|
104 virtual const bool should_remember_klasses() const { |
|
105 check_remember_klasses(); |
|
106 return _should_remember_klasses; |
|
107 } |
|
108 virtual void remember_klass(Klass* k); |
|
109 |
|
110 KlassRememberingOopClosure(CMSCollector* collector, |
|
111 ReferenceProcessor* rp, |
|
112 CMSMarkStack* revisit_stack); |
|
113 }; |
|
114 |
|
115 // Similar to KlassRememberingOopClosure for use when multiple |
|
116 // GC threads will execute the closure. |
|
117 |
|
118 class Par_KlassRememberingOopClosure : public KlassRememberingOopClosure { |
|
119 public: |
|
120 Par_KlassRememberingOopClosure(CMSCollector* collector, |
|
121 ReferenceProcessor* rp, |
|
122 CMSMarkStack* revisit_stack): |
|
123 KlassRememberingOopClosure(collector, rp, revisit_stack) {} |
|
124 virtual void remember_klass(Klass* k); |
|
125 }; |
|
126 |
91 // The non-parallel version (the parallel version appears further below). |
127 // The non-parallel version (the parallel version appears further below). |
92 class PushAndMarkClosure: public OopClosure { |
128 class PushAndMarkClosure: public KlassRememberingOopClosure { |
93 private: |
129 private: |
94 CMSCollector* _collector; |
|
95 MemRegion _span; |
130 MemRegion _span; |
96 CMSBitMap* _bit_map; |
131 CMSBitMap* _bit_map; |
97 CMSBitMap* _mod_union_table; |
132 CMSBitMap* _mod_union_table; |
98 CMSMarkStack* _mark_stack; |
133 CMSMarkStack* _mark_stack; |
99 CMSMarkStack* _revisit_stack; |
|
100 bool _concurrent_precleaning; |
134 bool _concurrent_precleaning; |
101 bool const _should_remember_klasses; |
|
102 protected: |
135 protected: |
103 DO_OOP_WORK_DEFN |
136 DO_OOP_WORK_DEFN |
104 public: |
137 public: |
105 PushAndMarkClosure(CMSCollector* collector, |
138 PushAndMarkClosure(CMSCollector* collector, |
106 MemRegion span, |
139 MemRegion span, |
116 inline void do_oop_nv(narrowOop* p) { PushAndMarkClosure::do_oop_work(p); } |
149 inline void do_oop_nv(narrowOop* p) { PushAndMarkClosure::do_oop_work(p); } |
117 bool do_header() { return true; } |
150 bool do_header() { return true; } |
118 Prefetch::style prefetch_style() { |
151 Prefetch::style prefetch_style() { |
119 return Prefetch::do_read; |
152 return Prefetch::do_read; |
120 } |
153 } |
121 virtual const bool should_remember_klasses() const { |
154 // In support of class unloading |
122 return _should_remember_klasses; |
155 virtual const bool should_remember_mdo() const { |
123 } |
156 return false; |
124 virtual void remember_klass(Klass* k); |
157 // return _should_remember_klasses; |
|
158 } |
|
159 virtual void remember_mdo(DataLayout* v); |
125 }; |
160 }; |
126 |
161 |
127 // In the parallel case, the revisit stack, the bit map and the |
162 // In the parallel case, the revisit stack, the bit map and the |
128 // reference processor are currently all shared. Access to |
163 // reference processor are currently all shared. Access to |
129 // these shared mutable structures must use appropriate |
164 // these shared mutable structures must use appropriate |
130 // synchronization (for instance, via CAS). The marking stack |
165 // synchronization (for instance, via CAS). The marking stack |
131 // used in the non-parallel case above is here replaced with |
166 // used in the non-parallel case above is here replaced with |
132 // an OopTaskQueue structure to allow efficient work stealing. |
167 // an OopTaskQueue structure to allow efficient work stealing. |
133 class Par_PushAndMarkClosure: public OopClosure { |
168 class Par_PushAndMarkClosure: public Par_KlassRememberingOopClosure { |
134 private: |
169 private: |
135 CMSCollector* _collector; |
|
136 MemRegion _span; |
170 MemRegion _span; |
137 CMSBitMap* _bit_map; |
171 CMSBitMap* _bit_map; |
138 OopTaskQueue* _work_queue; |
172 OopTaskQueue* _work_queue; |
139 CMSMarkStack* _revisit_stack; |
|
140 bool const _should_remember_klasses; |
|
141 protected: |
173 protected: |
142 DO_OOP_WORK_DEFN |
174 DO_OOP_WORK_DEFN |
143 public: |
175 public: |
144 Par_PushAndMarkClosure(CMSCollector* collector, |
176 Par_PushAndMarkClosure(CMSCollector* collector, |
145 MemRegion span, |
177 MemRegion span, |
153 inline void do_oop_nv(narrowOop* p) { Par_PushAndMarkClosure::do_oop_work(p); } |
185 inline void do_oop_nv(narrowOop* p) { Par_PushAndMarkClosure::do_oop_work(p); } |
154 bool do_header() { return true; } |
186 bool do_header() { return true; } |
155 Prefetch::style prefetch_style() { |
187 Prefetch::style prefetch_style() { |
156 return Prefetch::do_read; |
188 return Prefetch::do_read; |
157 } |
189 } |
158 virtual const bool should_remember_klasses() const { |
190 // In support of class unloading |
159 return _should_remember_klasses; |
191 virtual const bool should_remember_mdo() const { |
160 } |
192 return false; |
161 virtual void remember_klass(Klass* k); |
193 // return _should_remember_klasses; |
|
194 } |
|
195 virtual void remember_mdo(DataLayout* v); |
162 }; |
196 }; |
163 |
197 |
164 // The non-parallel version (the parallel version appears further below). |
198 // The non-parallel version (the parallel version appears further below). |
165 class MarkRefsIntoAndScanClosure: public OopsInGenClosure { |
199 class MarkRefsIntoAndScanClosure: public OopsInGenClosure { |
166 private: |
200 private: |
227 virtual void do_oop(narrowOop* p); |
267 virtual void do_oop(narrowOop* p); |
228 inline void do_oop_nv(oop* p) { Par_MarkRefsIntoAndScanClosure::do_oop_work(p); } |
268 inline void do_oop_nv(oop* p) { Par_MarkRefsIntoAndScanClosure::do_oop_work(p); } |
229 inline void do_oop_nv(narrowOop* p) { Par_MarkRefsIntoAndScanClosure::do_oop_work(p); } |
269 inline void do_oop_nv(narrowOop* p) { Par_MarkRefsIntoAndScanClosure::do_oop_work(p); } |
230 bool do_header() { return true; } |
270 bool do_header() { return true; } |
231 virtual const bool do_nmethods() const { return true; } |
271 virtual const bool do_nmethods() const { return true; } |
|
272 // When ScanMarkedObjectsAgainClosure is used, |
|
273 // it passes [Par_]MarkRefsIntoAndScanClosure to oop_oop_iterate(), |
|
274 // and this delegation is used. |
|
275 virtual const bool should_remember_klasses() const { |
|
276 return _par_pushAndMarkClosure.should_remember_klasses(); |
|
277 } |
|
278 // See comment on should_remember_klasses() above. |
|
279 virtual void remember_klass(Klass* k) { |
|
280 _par_pushAndMarkClosure.remember_klass(k); |
|
281 } |
232 Prefetch::style prefetch_style() { |
282 Prefetch::style prefetch_style() { |
233 return Prefetch::do_read; |
283 return Prefetch::do_read; |
234 } |
284 } |
235 void trim_queue(uint size); |
285 void trim_queue(uint size); |
236 }; |
286 }; |
237 |
287 |
238 // This closure is used during the concurrent marking phase |
288 // This closure is used during the concurrent marking phase |
239 // following the first checkpoint. Its use is buried in |
289 // following the first checkpoint. Its use is buried in |
240 // the closure MarkFromRootsClosure. |
290 // the closure MarkFromRootsClosure. |
241 class PushOrMarkClosure: public OopClosure { |
291 class PushOrMarkClosure: public KlassRememberingOopClosure { |
242 private: |
292 private: |
243 CMSCollector* _collector; |
|
244 MemRegion _span; |
293 MemRegion _span; |
245 CMSBitMap* _bitMap; |
294 CMSBitMap* _bitMap; |
246 CMSMarkStack* _markStack; |
295 CMSMarkStack* _markStack; |
247 CMSMarkStack* _revisitStack; |
|
248 HeapWord* const _finger; |
296 HeapWord* const _finger; |
249 MarkFromRootsClosure* const |
297 MarkFromRootsClosure* const |
250 _parent; |
298 _parent; |
251 bool const _should_remember_klasses; |
|
252 protected: |
299 protected: |
253 DO_OOP_WORK_DEFN |
300 DO_OOP_WORK_DEFN |
254 public: |
301 public: |
255 PushOrMarkClosure(CMSCollector* cms_collector, |
302 PushOrMarkClosure(CMSCollector* cms_collector, |
256 MemRegion span, |
303 MemRegion span, |
261 MarkFromRootsClosure* parent); |
308 MarkFromRootsClosure* parent); |
262 virtual void do_oop(oop* p); |
309 virtual void do_oop(oop* p); |
263 virtual void do_oop(narrowOop* p); |
310 virtual void do_oop(narrowOop* p); |
264 inline void do_oop_nv(oop* p) { PushOrMarkClosure::do_oop_work(p); } |
311 inline void do_oop_nv(oop* p) { PushOrMarkClosure::do_oop_work(p); } |
265 inline void do_oop_nv(narrowOop* p) { PushOrMarkClosure::do_oop_work(p); } |
312 inline void do_oop_nv(narrowOop* p) { PushOrMarkClosure::do_oop_work(p); } |
266 virtual const bool should_remember_klasses() const { |
313 // In support of class unloading |
267 return _should_remember_klasses; |
314 virtual const bool should_remember_mdo() const { |
268 } |
315 return false; |
269 virtual void remember_klass(Klass* k); |
316 // return _should_remember_klasses; |
|
317 } |
|
318 virtual void remember_mdo(DataLayout* v); |
|
319 |
270 // Deal with a stack overflow condition |
320 // Deal with a stack overflow condition |
271 void handle_stack_overflow(HeapWord* lost); |
321 void handle_stack_overflow(HeapWord* lost); |
272 private: |
322 private: |
273 inline void do_yield_check(); |
323 inline void do_yield_check(); |
274 }; |
324 }; |
275 |
325 |
276 // A parallel (MT) version of the above. |
326 // A parallel (MT) version of the above. |
277 // This closure is used during the concurrent marking phase |
327 // This closure is used during the concurrent marking phase |
278 // following the first checkpoint. Its use is buried in |
328 // following the first checkpoint. Its use is buried in |
279 // the closure Par_MarkFromRootsClosure. |
329 // the closure Par_MarkFromRootsClosure. |
280 class Par_PushOrMarkClosure: public OopClosure { |
330 class Par_PushOrMarkClosure: public Par_KlassRememberingOopClosure { |
281 private: |
331 private: |
282 CMSCollector* _collector; |
|
283 MemRegion _whole_span; |
332 MemRegion _whole_span; |
284 MemRegion _span; // local chunk |
333 MemRegion _span; // local chunk |
285 CMSBitMap* _bit_map; |
334 CMSBitMap* _bit_map; |
286 OopTaskQueue* _work_queue; |
335 OopTaskQueue* _work_queue; |
287 CMSMarkStack* _overflow_stack; |
336 CMSMarkStack* _overflow_stack; |
288 CMSMarkStack* _revisit_stack; |
|
289 HeapWord* const _finger; |
337 HeapWord* const _finger; |
290 HeapWord** const _global_finger_addr; |
338 HeapWord** const _global_finger_addr; |
291 Par_MarkFromRootsClosure* const |
339 Par_MarkFromRootsClosure* const |
292 _parent; |
340 _parent; |
293 bool const _should_remember_klasses; |
|
294 protected: |
341 protected: |
295 DO_OOP_WORK_DEFN |
342 DO_OOP_WORK_DEFN |
296 public: |
343 public: |
297 Par_PushOrMarkClosure(CMSCollector* cms_collector, |
344 Par_PushOrMarkClosure(CMSCollector* cms_collector, |
298 MemRegion span, |
345 MemRegion span, |
305 Par_MarkFromRootsClosure* parent); |
352 Par_MarkFromRootsClosure* parent); |
306 virtual void do_oop(oop* p); |
353 virtual void do_oop(oop* p); |
307 virtual void do_oop(narrowOop* p); |
354 virtual void do_oop(narrowOop* p); |
308 inline void do_oop_nv(oop* p) { Par_PushOrMarkClosure::do_oop_work(p); } |
355 inline void do_oop_nv(oop* p) { Par_PushOrMarkClosure::do_oop_work(p); } |
309 inline void do_oop_nv(narrowOop* p) { Par_PushOrMarkClosure::do_oop_work(p); } |
356 inline void do_oop_nv(narrowOop* p) { Par_PushOrMarkClosure::do_oop_work(p); } |
310 virtual const bool should_remember_klasses() const { |
357 // In support of class unloading |
311 return _should_remember_klasses; |
358 virtual const bool should_remember_mdo() const { |
312 } |
359 return false; |
313 virtual void remember_klass(Klass* k); |
360 // return _should_remember_klasses; |
|
361 } |
|
362 virtual void remember_mdo(DataLayout* v); |
|
363 |
314 // Deal with a stack overflow condition |
364 // Deal with a stack overflow condition |
315 void handle_stack_overflow(HeapWord* lost); |
365 void handle_stack_overflow(HeapWord* lost); |
316 private: |
366 private: |
317 inline void do_yield_check(); |
367 inline void do_yield_check(); |
318 }; |
368 }; |
321 // given objects (transitively) as being reachable/live. |
371 // given objects (transitively) as being reachable/live. |
322 // This is currently used during the (weak) reference object |
372 // This is currently used during the (weak) reference object |
323 // processing phase of the CMS final checkpoint step, as |
373 // processing phase of the CMS final checkpoint step, as |
324 // well as during the concurrent precleaning of the discovered |
374 // well as during the concurrent precleaning of the discovered |
325 // reference lists. |
375 // reference lists. |
326 class CMSKeepAliveClosure: public OopClosure { |
376 class CMSKeepAliveClosure: public KlassRememberingOopClosure { |
327 private: |
377 private: |
328 CMSCollector* _collector; |
|
329 const MemRegion _span; |
378 const MemRegion _span; |
330 CMSMarkStack* _mark_stack; |
379 CMSMarkStack* _mark_stack; |
331 CMSBitMap* _bit_map; |
380 CMSBitMap* _bit_map; |
332 bool _concurrent_precleaning; |
381 bool _concurrent_precleaning; |
333 protected: |
382 protected: |
334 DO_OOP_WORK_DEFN |
383 DO_OOP_WORK_DEFN |
335 public: |
384 public: |
336 CMSKeepAliveClosure(CMSCollector* collector, MemRegion span, |
385 CMSKeepAliveClosure(CMSCollector* collector, MemRegion span, |
337 CMSBitMap* bit_map, CMSMarkStack* mark_stack, |
386 CMSBitMap* bit_map, CMSMarkStack* mark_stack, |
338 bool cpc): |
387 CMSMarkStack* revisit_stack, bool cpc); |
339 _collector(collector), |
|
340 _span(span), |
|
341 _bit_map(bit_map), |
|
342 _mark_stack(mark_stack), |
|
343 _concurrent_precleaning(cpc) { |
|
344 assert(!_span.is_empty(), "Empty span could spell trouble"); |
|
345 } |
|
346 bool concurrent_precleaning() const { return _concurrent_precleaning; } |
388 bool concurrent_precleaning() const { return _concurrent_precleaning; } |
347 virtual void do_oop(oop* p); |
389 virtual void do_oop(oop* p); |
348 virtual void do_oop(narrowOop* p); |
390 virtual void do_oop(narrowOop* p); |
349 inline void do_oop_nv(oop* p) { CMSKeepAliveClosure::do_oop_work(p); } |
391 inline void do_oop_nv(oop* p) { CMSKeepAliveClosure::do_oop_work(p); } |
350 inline void do_oop_nv(narrowOop* p) { CMSKeepAliveClosure::do_oop_work(p); } |
392 inline void do_oop_nv(narrowOop* p) { CMSKeepAliveClosure::do_oop_work(p); } |
351 }; |
393 }; |
352 |
394 |
353 class CMSInnerParMarkAndPushClosure: public OopClosure { |
395 class CMSInnerParMarkAndPushClosure: public Par_KlassRememberingOopClosure { |
354 private: |
396 private: |
355 CMSCollector* _collector; |
|
356 MemRegion _span; |
397 MemRegion _span; |
357 OopTaskQueue* _work_queue; |
398 OopTaskQueue* _work_queue; |
358 CMSBitMap* _bit_map; |
399 CMSBitMap* _bit_map; |
359 protected: |
400 protected: |
360 DO_OOP_WORK_DEFN |
401 DO_OOP_WORK_DEFN |
361 public: |
402 public: |
362 CMSInnerParMarkAndPushClosure(CMSCollector* collector, |
403 CMSInnerParMarkAndPushClosure(CMSCollector* collector, |
363 MemRegion span, CMSBitMap* bit_map, |
404 MemRegion span, CMSBitMap* bit_map, |
364 OopTaskQueue* work_queue): |
405 CMSMarkStack* revisit_stack, |
365 _collector(collector), |
406 OopTaskQueue* work_queue); |
366 _span(span), |
|
367 _bit_map(bit_map), |
|
368 _work_queue(work_queue) { } |
|
369 virtual void do_oop(oop* p); |
407 virtual void do_oop(oop* p); |
370 virtual void do_oop(narrowOop* p); |
408 virtual void do_oop(narrowOop* p); |
371 inline void do_oop_nv(oop* p) { CMSInnerParMarkAndPushClosure::do_oop_work(p); } |
409 inline void do_oop_nv(oop* p) { CMSInnerParMarkAndPushClosure::do_oop_work(p); } |
372 inline void do_oop_nv(narrowOop* p) { CMSInnerParMarkAndPushClosure::do_oop_work(p); } |
410 inline void do_oop_nv(narrowOop* p) { CMSInnerParMarkAndPushClosure::do_oop_work(p); } |
373 }; |
411 }; |
374 |
412 |
375 // A parallel (MT) version of the above, used when |
413 // A parallel (MT) version of the above, used when |
376 // reference processing is parallel; the only difference |
414 // reference processing is parallel; the only difference |
377 // is in the do_oop method. |
415 // is in the do_oop method. |
378 class CMSParKeepAliveClosure: public OopClosure { |
416 class CMSParKeepAliveClosure: public Par_KlassRememberingOopClosure { |
379 private: |
417 private: |
380 CMSCollector* _collector; |
|
381 MemRegion _span; |
418 MemRegion _span; |
382 OopTaskQueue* _work_queue; |
419 OopTaskQueue* _work_queue; |
383 CMSBitMap* _bit_map; |
420 CMSBitMap* _bit_map; |
384 CMSInnerParMarkAndPushClosure |
421 CMSInnerParMarkAndPushClosure |
385 _mark_and_push; |
422 _mark_and_push; |
387 void trim_queue(uint max); |
424 void trim_queue(uint max); |
388 protected: |
425 protected: |
389 DO_OOP_WORK_DEFN |
426 DO_OOP_WORK_DEFN |
390 public: |
427 public: |
391 CMSParKeepAliveClosure(CMSCollector* collector, MemRegion span, |
428 CMSParKeepAliveClosure(CMSCollector* collector, MemRegion span, |
392 CMSBitMap* bit_map, OopTaskQueue* work_queue); |
429 CMSBitMap* bit_map, CMSMarkStack* revisit_stack, |
|
430 OopTaskQueue* work_queue); |
393 virtual void do_oop(oop* p); |
431 virtual void do_oop(oop* p); |
394 virtual void do_oop(narrowOop* p); |
432 virtual void do_oop(narrowOop* p); |
395 inline void do_oop_nv(oop* p) { CMSParKeepAliveClosure::do_oop_work(p); } |
433 inline void do_oop_nv(oop* p) { CMSParKeepAliveClosure::do_oop_work(p); } |
396 inline void do_oop_nv(narrowOop* p) { CMSParKeepAliveClosure::do_oop_work(p); } |
434 inline void do_oop_nv(narrowOop* p) { CMSParKeepAliveClosure::do_oop_work(p); } |
397 }; |
435 }; |