Mercurial > hg > truffle
annotate src/share/vm/gc_implementation/concurrentMarkSweep/cmsOopClosures.hpp @ 1972:f95d63e2154a
6989984: Use standard include model for Hospot
Summary: Replaced MakeDeps and the includeDB files with more standardized solutions.
Reviewed-by: coleenp, kvn, kamg
| author | stefank |
|---|---|
| date | Tue, 23 Nov 2010 13:22:55 -0800 |
| parents | c18cbe5936b8 |
| children | da91efe96a93 |
| rev | line source |
|---|---|
| 0 | 1 /* |
| 1972 | 2 * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved. |
| 0 | 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| 4 * | |
| 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 | |
| 7 * published by the Free Software Foundation. | |
| 8 * | |
| 9 * This code is distributed in the hope that it will be useful, but WITHOUT | |
| 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
| 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
| 12 * version 2 for more details (a copy is included in the LICENSE file that | |
| 13 * accompanied this code). | |
| 14 * | |
| 15 * You should have received a copy of the GNU General Public License version | |
| 16 * 2 along with this work; if not, write to the Free Software Foundation, | |
| 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. | |
| 18 * | |
|
1552
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
994
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
994
diff
changeset
|
20 * or visit www.oracle.com if you need additional information or have any |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
994
diff
changeset
|
21 * questions. |
| 0 | 22 * |
| 23 */ | |
| 24 | |
| 1972 | 25 #ifndef SHARE_VM_GC_IMPLEMENTATION_CONCURRENTMARKSWEEP_CMSOOPCLOSURES_HPP |
| 26 #define SHARE_VM_GC_IMPLEMENTATION_CONCURRENTMARKSWEEP_CMSOOPCLOSURES_HPP | |
| 27 | |
| 28 #include "memory/genOopClosures.hpp" | |
| 29 | |
| 0 | 30 ///////////////////////////////////////////////////////////////// |
| 31 // Closures used by ConcurrentMarkSweepGeneration's collector | |
| 32 ///////////////////////////////////////////////////////////////// | |
| 33 class ConcurrentMarkSweepGeneration; | |
| 34 class CMSBitMap; | |
| 35 class CMSMarkStack; | |
| 36 class CMSCollector; | |
| 37 class MarkFromRootsClosure; | |
| 38 class Par_MarkFromRootsClosure; | |
| 39 | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
40 // Decode the oop and call do_oop on it. |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
41 #define DO_OOP_WORK_DEFN \ |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
42 void do_oop(oop obj); \ |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
43 template <class T> inline void do_oop_work(T* p) { \ |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
44 T heap_oop = oopDesc::load_heap_oop(p); \ |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
45 if (!oopDesc::is_null(heap_oop)) { \ |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
46 oop obj = oopDesc::decode_heap_oop_not_null(heap_oop); \ |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
47 do_oop(obj); \ |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
48 } \ |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
49 } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
50 |
| 0 | 51 class MarkRefsIntoClosure: public OopsInGenClosure { |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
52 private: |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
53 const MemRegion _span; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
54 CMSBitMap* _bitMap; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
55 protected: |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
56 DO_OOP_WORK_DEFN |
| 0 | 57 public: |
|
994
753cf9794df9
6885169: merge of 4957990 and 6863023 causes conflict on do_nmethods
jrose
parents:
993
diff
changeset
|
58 MarkRefsIntoClosure(MemRegion span, CMSBitMap* bitMap); |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
59 virtual void do_oop(oop* p); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
60 virtual void do_oop(narrowOop* p); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
61 inline void do_oop_nv(oop* p) { MarkRefsIntoClosure::do_oop_work(p); } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
62 inline void do_oop_nv(narrowOop* p) { MarkRefsIntoClosure::do_oop_work(p); } |
| 0 | 63 bool do_header() { return true; } |
| 64 Prefetch::style prefetch_style() { | |
| 65 return Prefetch::do_read; | |
| 66 } | |
| 67 }; | |
| 68 | |
| 69 // A variant of the above used in certain kinds of CMS | |
| 70 // marking verification. | |
| 71 class MarkRefsIntoVerifyClosure: public OopsInGenClosure { | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
72 private: |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
73 const MemRegion _span; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
74 CMSBitMap* _verification_bm; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
75 CMSBitMap* _cms_bm; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
76 protected: |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
77 DO_OOP_WORK_DEFN |
| 0 | 78 public: |
| 79 MarkRefsIntoVerifyClosure(MemRegion span, CMSBitMap* verification_bm, | |
|
994
753cf9794df9
6885169: merge of 4957990 and 6863023 causes conflict on do_nmethods
jrose
parents:
993
diff
changeset
|
80 CMSBitMap* cms_bm); |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
81 virtual void do_oop(oop* p); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
82 virtual void do_oop(narrowOop* p); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
83 inline void do_oop_nv(oop* p) { MarkRefsIntoVerifyClosure::do_oop_work(p); } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
84 inline void do_oop_nv(narrowOop* p) { MarkRefsIntoVerifyClosure::do_oop_work(p); } |
| 0 | 85 bool do_header() { return true; } |
| 86 Prefetch::style prefetch_style() { | |
| 87 return Prefetch::do_read; | |
| 88 } | |
| 89 }; | |
| 90 | |
| 935 | 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 | |
| 0 | 127 // The non-parallel version (the parallel version appears further below). |
| 935 | 128 class PushAndMarkClosure: public KlassRememberingOopClosure { |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
129 private: |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
130 MemRegion _span; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
131 CMSBitMap* _bit_map; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
132 CMSBitMap* _mod_union_table; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
133 CMSMarkStack* _mark_stack; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
134 bool _concurrent_precleaning; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
135 protected: |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
136 DO_OOP_WORK_DEFN |
| 0 | 137 public: |
| 138 PushAndMarkClosure(CMSCollector* collector, | |
| 139 MemRegion span, | |
| 140 ReferenceProcessor* rp, | |
| 141 CMSBitMap* bit_map, | |
| 142 CMSBitMap* mod_union_table, | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
143 CMSMarkStack* mark_stack, |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
144 CMSMarkStack* revisit_stack, |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
145 bool concurrent_precleaning); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
146 virtual void do_oop(oop* p); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
147 virtual void do_oop(narrowOop* p); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
148 inline void do_oop_nv(oop* p) { PushAndMarkClosure::do_oop_work(p); } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
149 inline void do_oop_nv(narrowOop* p) { PushAndMarkClosure::do_oop_work(p); } |
| 0 | 150 bool do_header() { return true; } |
| 151 Prefetch::style prefetch_style() { | |
| 152 return Prefetch::do_read; | |
| 153 } | |
| 941 | 154 // In support of class unloading |
| 155 virtual const bool should_remember_mdo() const { | |
| 156 return false; | |
| 157 // return _should_remember_klasses; | |
| 158 } | |
| 159 virtual void remember_mdo(DataLayout* v); | |
| 0 | 160 }; |
| 161 | |
| 162 // In the parallel case, the revisit stack, the bit map and the | |
| 163 // reference processor are currently all shared. Access to | |
| 164 // these shared mutable structures must use appropriate | |
| 165 // synchronization (for instance, via CAS). The marking stack | |
| 166 // used in the non-parallel case above is here replaced with | |
| 167 // an OopTaskQueue structure to allow efficient work stealing. | |
| 935 | 168 class Par_PushAndMarkClosure: public Par_KlassRememberingOopClosure { |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
169 private: |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
170 MemRegion _span; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
171 CMSBitMap* _bit_map; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
172 OopTaskQueue* _work_queue; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
173 protected: |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
174 DO_OOP_WORK_DEFN |
| 0 | 175 public: |
| 176 Par_PushAndMarkClosure(CMSCollector* collector, | |
| 177 MemRegion span, | |
| 178 ReferenceProcessor* rp, | |
| 179 CMSBitMap* bit_map, | |
| 180 OopTaskQueue* work_queue, | |
| 181 CMSMarkStack* revisit_stack); | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
182 virtual void do_oop(oop* p); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
183 virtual void do_oop(narrowOop* p); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
184 inline void do_oop_nv(oop* p) { Par_PushAndMarkClosure::do_oop_work(p); } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
185 inline void do_oop_nv(narrowOop* p) { Par_PushAndMarkClosure::do_oop_work(p); } |
| 0 | 186 bool do_header() { return true; } |
| 187 Prefetch::style prefetch_style() { | |
| 188 return Prefetch::do_read; | |
| 189 } | |
| 941 | 190 // In support of class unloading |
| 191 virtual const bool should_remember_mdo() const { | |
| 192 return false; | |
| 193 // return _should_remember_klasses; | |
| 194 } | |
| 195 virtual void remember_mdo(DataLayout* v); | |
| 0 | 196 }; |
| 197 | |
| 198 // The non-parallel version (the parallel version appears further below). | |
| 199 class MarkRefsIntoAndScanClosure: public OopsInGenClosure { | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
200 private: |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
201 MemRegion _span; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
202 CMSBitMap* _bit_map; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
203 CMSMarkStack* _mark_stack; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
204 PushAndMarkClosure _pushAndMarkClosure; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
205 CMSCollector* _collector; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
206 Mutex* _freelistLock; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
207 bool _yield; |
| 0 | 208 // Whether closure is being used for concurrent precleaning |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
209 bool _concurrent_precleaning; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
210 protected: |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
211 DO_OOP_WORK_DEFN |
| 0 | 212 public: |
| 213 MarkRefsIntoAndScanClosure(MemRegion span, | |
| 214 ReferenceProcessor* rp, | |
| 215 CMSBitMap* bit_map, | |
| 216 CMSBitMap* mod_union_table, | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
217 CMSMarkStack* mark_stack, |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
218 CMSMarkStack* revisit_stack, |
| 0 | 219 CMSCollector* collector, |
| 220 bool should_yield, | |
| 221 bool concurrent_precleaning); | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
222 virtual void do_oop(oop* p); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
223 virtual void do_oop(narrowOop* p); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
224 inline void do_oop_nv(oop* p) { MarkRefsIntoAndScanClosure::do_oop_work(p); } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
225 inline void do_oop_nv(narrowOop* p) { MarkRefsIntoAndScanClosure::do_oop_work(p); } |
| 0 | 226 bool do_header() { return true; } |
| 227 Prefetch::style prefetch_style() { | |
| 228 return Prefetch::do_read; | |
| 229 } | |
| 230 void set_freelistLock(Mutex* m) { | |
| 231 _freelistLock = m; | |
| 232 } | |
| 935 | 233 virtual const bool should_remember_klasses() const { |
| 234 return _pushAndMarkClosure.should_remember_klasses(); | |
| 235 } | |
| 236 virtual void remember_klass(Klass* k) { | |
| 237 _pushAndMarkClosure.remember_klass(k); | |
| 238 } | |
| 0 | 239 |
| 240 private: | |
| 241 inline void do_yield_check(); | |
| 242 void do_yield_work(); | |
| 243 bool take_from_overflow_list(); | |
| 244 }; | |
| 245 | |
| 246 // Tn this, the parallel avatar of MarkRefsIntoAndScanClosure, the revisit | |
| 247 // stack and the bitMap are shared, so access needs to be suitably | |
| 248 // sycnhronized. An OopTaskQueue structure, supporting efficient | |
| 249 // workstealing, replaces a CMSMarkStack for storing grey objects. | |
| 250 class Par_MarkRefsIntoAndScanClosure: public OopsInGenClosure { | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
251 private: |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
252 MemRegion _span; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
253 CMSBitMap* _bit_map; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
254 OopTaskQueue* _work_queue; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
255 const uint _low_water_mark; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
256 Par_PushAndMarkClosure _par_pushAndMarkClosure; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
257 protected: |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
258 DO_OOP_WORK_DEFN |
| 0 | 259 public: |
| 260 Par_MarkRefsIntoAndScanClosure(CMSCollector* collector, | |
| 261 MemRegion span, | |
| 262 ReferenceProcessor* rp, | |
| 263 CMSBitMap* bit_map, | |
| 264 OopTaskQueue* work_queue, | |
| 265 CMSMarkStack* revisit_stack); | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
266 virtual void do_oop(oop* p); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
267 virtual void do_oop(narrowOop* p); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
268 inline void do_oop_nv(oop* p) { Par_MarkRefsIntoAndScanClosure::do_oop_work(p); } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
269 inline void do_oop_nv(narrowOop* p) { Par_MarkRefsIntoAndScanClosure::do_oop_work(p); } |
| 0 | 270 bool do_header() { return true; } |
| 935 | 271 // When ScanMarkedObjectsAgainClosure is used, |
| 272 // it passes [Par_]MarkRefsIntoAndScanClosure to oop_oop_iterate(), | |
| 273 // and this delegation is used. | |
| 274 virtual const bool should_remember_klasses() const { | |
| 275 return _par_pushAndMarkClosure.should_remember_klasses(); | |
| 276 } | |
| 277 // See comment on should_remember_klasses() above. | |
| 278 virtual void remember_klass(Klass* k) { | |
| 279 _par_pushAndMarkClosure.remember_klass(k); | |
| 280 } | |
| 0 | 281 Prefetch::style prefetch_style() { |
| 282 return Prefetch::do_read; | |
| 283 } | |
| 284 void trim_queue(uint size); | |
| 285 }; | |
| 286 | |
| 287 // This closure is used during the concurrent marking phase | |
| 288 // following the first checkpoint. Its use is buried in | |
| 289 // the closure MarkFromRootsClosure. | |
| 935 | 290 class PushOrMarkClosure: public KlassRememberingOopClosure { |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
291 private: |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
292 MemRegion _span; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
293 CMSBitMap* _bitMap; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
294 CMSMarkStack* _markStack; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
295 HeapWord* const _finger; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
296 MarkFromRootsClosure* const |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
297 _parent; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
298 protected: |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
299 DO_OOP_WORK_DEFN |
| 0 | 300 public: |
| 301 PushOrMarkClosure(CMSCollector* cms_collector, | |
| 302 MemRegion span, | |
| 303 CMSBitMap* bitMap, | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
304 CMSMarkStack* markStack, |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
305 CMSMarkStack* revisitStack, |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
306 HeapWord* finger, |
| 0 | 307 MarkFromRootsClosure* parent); |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
308 virtual void do_oop(oop* p); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
309 virtual void do_oop(narrowOop* p); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
310 inline void do_oop_nv(oop* p) { PushOrMarkClosure::do_oop_work(p); } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
311 inline void do_oop_nv(narrowOop* p) { PushOrMarkClosure::do_oop_work(p); } |
| 941 | 312 // In support of class unloading |
| 313 virtual const bool should_remember_mdo() const { | |
| 314 return false; | |
| 315 // return _should_remember_klasses; | |
| 316 } | |
| 317 virtual void remember_mdo(DataLayout* v); | |
| 318 | |
| 0 | 319 // Deal with a stack overflow condition |
| 320 void handle_stack_overflow(HeapWord* lost); | |
| 321 private: | |
| 322 inline void do_yield_check(); | |
| 323 }; | |
| 324 | |
| 325 // A parallel (MT) version of the above. | |
| 326 // This closure is used during the concurrent marking phase | |
| 327 // following the first checkpoint. Its use is buried in | |
| 328 // the closure Par_MarkFromRootsClosure. | |
| 935 | 329 class Par_PushOrMarkClosure: public Par_KlassRememberingOopClosure { |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
330 private: |
| 0 | 331 MemRegion _whole_span; |
| 332 MemRegion _span; // local chunk | |
| 333 CMSBitMap* _bit_map; | |
| 334 OopTaskQueue* _work_queue; | |
| 335 CMSMarkStack* _overflow_stack; | |
| 336 HeapWord* const _finger; | |
| 337 HeapWord** const _global_finger_addr; | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
338 Par_MarkFromRootsClosure* const |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
339 _parent; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
340 protected: |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
341 DO_OOP_WORK_DEFN |
| 0 | 342 public: |
| 343 Par_PushOrMarkClosure(CMSCollector* cms_collector, | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
344 MemRegion span, |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
345 CMSBitMap* bit_map, |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
346 OopTaskQueue* work_queue, |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
347 CMSMarkStack* mark_stack, |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
348 CMSMarkStack* revisit_stack, |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
349 HeapWord* finger, |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
350 HeapWord** global_finger_addr, |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
351 Par_MarkFromRootsClosure* parent); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
352 virtual void do_oop(oop* p); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
353 virtual void do_oop(narrowOop* p); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
354 inline void do_oop_nv(oop* p) { Par_PushOrMarkClosure::do_oop_work(p); } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
355 inline void do_oop_nv(narrowOop* p) { Par_PushOrMarkClosure::do_oop_work(p); } |
| 941 | 356 // In support of class unloading |
| 357 virtual const bool should_remember_mdo() const { | |
| 358 return false; | |
| 359 // return _should_remember_klasses; | |
| 360 } | |
| 361 virtual void remember_mdo(DataLayout* v); | |
| 362 | |
| 0 | 363 // Deal with a stack overflow condition |
| 364 void handle_stack_overflow(HeapWord* lost); | |
| 365 private: | |
| 366 inline void do_yield_check(); | |
| 367 }; | |
| 368 | |
| 369 // For objects in CMS generation, this closure marks | |
| 370 // given objects (transitively) as being reachable/live. | |
| 371 // This is currently used during the (weak) reference object | |
|
452
00b023ae2d78
6722113: CMS: Incorrect overflow handling during precleaning of Reference lists
ysr
parents:
143
diff
changeset
|
372 // processing phase of the CMS final checkpoint step, as |
|
00b023ae2d78
6722113: CMS: Incorrect overflow handling during precleaning of Reference lists
ysr
parents:
143
diff
changeset
|
373 // well as during the concurrent precleaning of the discovered |
|
00b023ae2d78
6722113: CMS: Incorrect overflow handling during precleaning of Reference lists
ysr
parents:
143
diff
changeset
|
374 // reference lists. |
| 935 | 375 class CMSKeepAliveClosure: public KlassRememberingOopClosure { |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
376 private: |
|
143
b5489bb705c9
6662086: 6u4+, 7b11+: CMS never clears referents when -XX:+ParallelRefProcEnabled
ysr
parents:
113
diff
changeset
|
377 const MemRegion _span; |
| 0 | 378 CMSMarkStack* _mark_stack; |
| 379 CMSBitMap* _bit_map; | |
|
452
00b023ae2d78
6722113: CMS: Incorrect overflow handling during precleaning of Reference lists
ysr
parents:
143
diff
changeset
|
380 bool _concurrent_precleaning; |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
381 protected: |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
382 DO_OOP_WORK_DEFN |
| 0 | 383 public: |
| 384 CMSKeepAliveClosure(CMSCollector* collector, MemRegion span, | |
|
452
00b023ae2d78
6722113: CMS: Incorrect overflow handling during precleaning of Reference lists
ysr
parents:
143
diff
changeset
|
385 CMSBitMap* bit_map, CMSMarkStack* mark_stack, |
| 935 | 386 CMSMarkStack* revisit_stack, bool cpc); |
|
452
00b023ae2d78
6722113: CMS: Incorrect overflow handling during precleaning of Reference lists
ysr
parents:
143
diff
changeset
|
387 bool concurrent_precleaning() const { return _concurrent_precleaning; } |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
388 virtual void do_oop(oop* p); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
389 virtual void do_oop(narrowOop* p); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
390 inline void do_oop_nv(oop* p) { CMSKeepAliveClosure::do_oop_work(p); } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
391 inline void do_oop_nv(narrowOop* p) { CMSKeepAliveClosure::do_oop_work(p); } |
| 0 | 392 }; |
| 393 | |
| 935 | 394 class CMSInnerParMarkAndPushClosure: public Par_KlassRememberingOopClosure { |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
395 private: |
| 0 | 396 MemRegion _span; |
| 397 OopTaskQueue* _work_queue; | |
| 398 CMSBitMap* _bit_map; | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
399 protected: |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
400 DO_OOP_WORK_DEFN |
| 0 | 401 public: |
| 402 CMSInnerParMarkAndPushClosure(CMSCollector* collector, | |
| 403 MemRegion span, CMSBitMap* bit_map, | |
| 935 | 404 CMSMarkStack* revisit_stack, |
| 405 OopTaskQueue* work_queue); | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
406 virtual void do_oop(oop* p); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
407 virtual void do_oop(narrowOop* p); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
408 inline void do_oop_nv(oop* p) { CMSInnerParMarkAndPushClosure::do_oop_work(p); } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
409 inline void do_oop_nv(narrowOop* p) { CMSInnerParMarkAndPushClosure::do_oop_work(p); } |
| 0 | 410 }; |
| 411 | |
| 412 // A parallel (MT) version of the above, used when | |
| 413 // reference processing is parallel; the only difference | |
| 414 // is in the do_oop method. | |
| 935 | 415 class CMSParKeepAliveClosure: public Par_KlassRememberingOopClosure { |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
416 private: |
| 0 | 417 MemRegion _span; |
| 418 OopTaskQueue* _work_queue; | |
| 419 CMSBitMap* _bit_map; | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
420 CMSInnerParMarkAndPushClosure |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
421 _mark_and_push; |
| 0 | 422 const uint _low_water_mark; |
| 423 void trim_queue(uint max); | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
424 protected: |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
425 DO_OOP_WORK_DEFN |
| 0 | 426 public: |
| 427 CMSParKeepAliveClosure(CMSCollector* collector, MemRegion span, | |
| 935 | 428 CMSBitMap* bit_map, CMSMarkStack* revisit_stack, |
| 429 OopTaskQueue* work_queue); | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
430 virtual void do_oop(oop* p); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
431 virtual void do_oop(narrowOop* p); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
432 inline void do_oop_nv(oop* p) { CMSParKeepAliveClosure::do_oop_work(p); } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
433 inline void do_oop_nv(narrowOop* p) { CMSParKeepAliveClosure::do_oop_work(p); } |
| 0 | 434 }; |
| 1972 | 435 |
| 436 #endif // SHARE_VM_GC_IMPLEMENTATION_CONCURRENTMARKSWEEP_CMSOOPCLOSURES_HPP |