equal
deleted
inserted
replaced
1 /* |
1 /* |
2 * Copyright (c) 2007, 2015, Oracle and/or its affiliates. All rights reserved. |
2 * Copyright (c) 2007, 2016, Oracle and/or its affiliates. All rights reserved. |
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
4 * |
4 * |
5 * This code is free software; you can redistribute it and/or modify it |
5 * This code is free software; you can redistribute it and/or modify it |
6 * under the terms of the GNU General Public License version 2 only, as |
6 * under the terms of the GNU General Public License version 2 only, as |
7 * published by the Free Software Foundation. |
7 * published by the Free Software Foundation. |
38 class CMSCollector; |
38 class CMSCollector; |
39 class MarkFromRootsClosure; |
39 class MarkFromRootsClosure; |
40 class ParMarkFromRootsClosure; |
40 class ParMarkFromRootsClosure; |
41 |
41 |
42 // Decode the oop and call do_oop on it. |
42 // Decode the oop and call do_oop on it. |
43 #define DO_OOP_WORK_DEFN \ |
43 #define DO_OOP_WORK_DEFN \ |
44 void do_oop(oop obj); \ |
44 void do_oop(oop obj); \ |
45 template <class T> inline void do_oop_work(T* p) { \ |
45 template <class T> inline void do_oop_work(T* p); |
46 T heap_oop = oopDesc::load_heap_oop(p); \ |
|
47 if (!oopDesc::is_null(heap_oop)) { \ |
|
48 oop obj = oopDesc::decode_heap_oop_not_null(heap_oop); \ |
|
49 do_oop(obj); \ |
|
50 } \ |
|
51 } |
|
52 |
46 |
53 // TODO: This duplication of the MetadataAwareOopClosure class is only needed |
47 // TODO: This duplication of the MetadataAwareOopClosure class is only needed |
54 // because some CMS OopClosures derive from OopsInGenClosure. It would be |
48 // because some CMS OopClosures derive from OopsInGenClosure. It would be |
55 // good to get rid of them completely. |
49 // good to get rid of them completely. |
56 class MetadataAwareOopsInGenClosure: public OopsInGenClosure { |
50 class MetadataAwareOopsInGenClosure: public OopsInGenClosure { |
129 CMSBitMap* mod_union_table, |
123 CMSBitMap* mod_union_table, |
130 CMSMarkStack* mark_stack, |
124 CMSMarkStack* mark_stack, |
131 bool concurrent_precleaning); |
125 bool concurrent_precleaning); |
132 virtual void do_oop(oop* p); |
126 virtual void do_oop(oop* p); |
133 virtual void do_oop(narrowOop* p); |
127 virtual void do_oop(narrowOop* p); |
134 inline void do_oop_nv(oop* p) { PushAndMarkClosure::do_oop_work(p); } |
128 inline void do_oop_nv(oop* p); |
135 inline void do_oop_nv(narrowOop* p) { PushAndMarkClosure::do_oop_work(p); } |
129 inline void do_oop_nv(narrowOop* p); |
136 }; |
130 }; |
137 |
131 |
138 // In the parallel case, the bit map and the |
132 // In the parallel case, the bit map and the |
139 // reference processor are currently all shared. Access to |
133 // reference processor are currently all shared. Access to |
140 // these shared mutable structures must use appropriate |
134 // these shared mutable structures must use appropriate |
155 ReferenceProcessor* rp, |
149 ReferenceProcessor* rp, |
156 CMSBitMap* bit_map, |
150 CMSBitMap* bit_map, |
157 OopTaskQueue* work_queue); |
151 OopTaskQueue* work_queue); |
158 virtual void do_oop(oop* p); |
152 virtual void do_oop(oop* p); |
159 virtual void do_oop(narrowOop* p); |
153 virtual void do_oop(narrowOop* p); |
160 inline void do_oop_nv(oop* p) { ParPushAndMarkClosure::do_oop_work(p); } |
154 inline void do_oop_nv(oop* p); |
161 inline void do_oop_nv(narrowOop* p) { ParPushAndMarkClosure::do_oop_work(p); } |
155 inline void do_oop_nv(narrowOop* p); |
162 }; |
156 }; |
163 |
157 |
164 // The non-parallel version (the parallel version appears further below). |
158 // The non-parallel version (the parallel version appears further below). |
165 class MarkRefsIntoAndScanClosure: public MetadataAwareOopsInGenClosure { |
159 class MarkRefsIntoAndScanClosure: public MetadataAwareOopsInGenClosure { |
166 private: |
160 private: |
184 CMSCollector* collector, |
178 CMSCollector* collector, |
185 bool should_yield, |
179 bool should_yield, |
186 bool concurrent_precleaning); |
180 bool concurrent_precleaning); |
187 virtual void do_oop(oop* p); |
181 virtual void do_oop(oop* p); |
188 virtual void do_oop(narrowOop* p); |
182 virtual void do_oop(narrowOop* p); |
189 inline void do_oop_nv(oop* p) { MarkRefsIntoAndScanClosure::do_oop_work(p); } |
183 inline void do_oop_nv(oop* p); |
190 inline void do_oop_nv(narrowOop* p) { MarkRefsIntoAndScanClosure::do_oop_work(p); } |
184 inline void do_oop_nv(narrowOop* p); |
191 |
185 |
192 void set_freelistLock(Mutex* m) { |
186 void set_freelistLock(Mutex* m) { |
193 _freelistLock = m; |
187 _freelistLock = m; |
194 } |
188 } |
195 |
189 |
218 ReferenceProcessor* rp, |
212 ReferenceProcessor* rp, |
219 CMSBitMap* bit_map, |
213 CMSBitMap* bit_map, |
220 OopTaskQueue* work_queue); |
214 OopTaskQueue* work_queue); |
221 virtual void do_oop(oop* p); |
215 virtual void do_oop(oop* p); |
222 virtual void do_oop(narrowOop* p); |
216 virtual void do_oop(narrowOop* p); |
223 inline void do_oop_nv(oop* p) { ParMarkRefsIntoAndScanClosure::do_oop_work(p); } |
217 inline void do_oop_nv(oop* p); |
224 inline void do_oop_nv(narrowOop* p) { ParMarkRefsIntoAndScanClosure::do_oop_work(p); } |
218 inline void do_oop_nv(narrowOop* p); |
225 |
219 |
226 void trim_queue(uint size); |
220 void trim_queue(uint size); |
227 }; |
221 }; |
228 |
222 |
229 // This closure is used during the concurrent marking phase |
223 // This closure is used during the concurrent marking phase |
247 CMSMarkStack* markStack, |
241 CMSMarkStack* markStack, |
248 HeapWord* finger, |
242 HeapWord* finger, |
249 MarkFromRootsClosure* parent); |
243 MarkFromRootsClosure* parent); |
250 virtual void do_oop(oop* p); |
244 virtual void do_oop(oop* p); |
251 virtual void do_oop(narrowOop* p); |
245 virtual void do_oop(narrowOop* p); |
252 inline void do_oop_nv(oop* p) { PushOrMarkClosure::do_oop_work(p); } |
246 inline void do_oop_nv(oop* p); |
253 inline void do_oop_nv(narrowOop* p) { PushOrMarkClosure::do_oop_work(p); } |
247 inline void do_oop_nv(narrowOop* p); |
254 |
248 |
255 // Deal with a stack overflow condition |
249 // Deal with a stack overflow condition |
256 void handle_stack_overflow(HeapWord* lost); |
250 void handle_stack_overflow(HeapWord* lost); |
257 private: |
251 private: |
258 inline void do_yield_check(); |
252 inline void do_yield_check(); |
285 HeapWord* finger, |
279 HeapWord* finger, |
286 HeapWord** global_finger_addr, |
280 HeapWord** global_finger_addr, |
287 ParMarkFromRootsClosure* parent); |
281 ParMarkFromRootsClosure* parent); |
288 virtual void do_oop(oop* p); |
282 virtual void do_oop(oop* p); |
289 virtual void do_oop(narrowOop* p); |
283 virtual void do_oop(narrowOop* p); |
290 inline void do_oop_nv(oop* p) { ParPushOrMarkClosure::do_oop_work(p); } |
284 inline void do_oop_nv(oop* p); |
291 inline void do_oop_nv(narrowOop* p) { ParPushOrMarkClosure::do_oop_work(p); } |
285 inline void do_oop_nv(narrowOop* p); |
292 |
286 |
293 // Deal with a stack overflow condition |
287 // Deal with a stack overflow condition |
294 void handle_stack_overflow(HeapWord* lost); |
288 void handle_stack_overflow(HeapWord* lost); |
295 private: |
289 private: |
296 inline void do_yield_check(); |
290 inline void do_yield_check(); |
316 CMSBitMap* bit_map, CMSMarkStack* mark_stack, |
310 CMSBitMap* bit_map, CMSMarkStack* mark_stack, |
317 bool cpc); |
311 bool cpc); |
318 bool concurrent_precleaning() const { return _concurrent_precleaning; } |
312 bool concurrent_precleaning() const { return _concurrent_precleaning; } |
319 virtual void do_oop(oop* p); |
313 virtual void do_oop(oop* p); |
320 virtual void do_oop(narrowOop* p); |
314 virtual void do_oop(narrowOop* p); |
321 inline void do_oop_nv(oop* p) { CMSKeepAliveClosure::do_oop_work(p); } |
315 inline void do_oop_nv(oop* p); |
322 inline void do_oop_nv(narrowOop* p) { CMSKeepAliveClosure::do_oop_work(p); } |
316 inline void do_oop_nv(narrowOop* p); |
323 }; |
317 }; |
324 |
318 |
325 class CMSInnerParMarkAndPushClosure: public MetadataAwareOopClosure { |
319 class CMSInnerParMarkAndPushClosure: public MetadataAwareOopClosure { |
326 private: |
320 private: |
327 CMSCollector* _collector; |
321 CMSCollector* _collector; |
334 CMSInnerParMarkAndPushClosure(CMSCollector* collector, |
328 CMSInnerParMarkAndPushClosure(CMSCollector* collector, |
335 MemRegion span, CMSBitMap* bit_map, |
329 MemRegion span, CMSBitMap* bit_map, |
336 OopTaskQueue* work_queue); |
330 OopTaskQueue* work_queue); |
337 virtual void do_oop(oop* p); |
331 virtual void do_oop(oop* p); |
338 virtual void do_oop(narrowOop* p); |
332 virtual void do_oop(narrowOop* p); |
339 inline void do_oop_nv(oop* p) { CMSInnerParMarkAndPushClosure::do_oop_work(p); } |
333 inline void do_oop_nv(oop* p); |
340 inline void do_oop_nv(narrowOop* p) { CMSInnerParMarkAndPushClosure::do_oop_work(p); } |
334 inline void do_oop_nv(narrowOop* p); |
341 }; |
335 }; |
342 |
336 |
343 // A parallel (MT) version of the above, used when |
337 // A parallel (MT) version of the above, used when |
344 // reference processing is parallel; the only difference |
338 // reference processing is parallel; the only difference |
345 // is in the do_oop method. |
339 // is in the do_oop method. |