1.1 --- a/src/share/vm/gc_implementation/concurrentMarkSweep/cmsOopClosures.hpp Fri Apr 11 09:56:35 2008 -0400
1.2 +++ b/src/share/vm/gc_implementation/concurrentMarkSweep/cmsOopClosures.hpp Sun Apr 13 17:43:42 2008 -0400
1.3 @@ -29,22 +29,34 @@
1.4 class CMSBitMap;
1.5 class CMSMarkStack;
1.6 class CMSCollector;
1.7 -template<class E> class GenericTaskQueue;
1.8 -typedef GenericTaskQueue<oop> OopTaskQueue;
1.9 -template<class E> class GenericTaskQueueSet;
1.10 -typedef GenericTaskQueueSet<oop> OopTaskQueueSet;
1.11 class MarkFromRootsClosure;
1.12 class Par_MarkFromRootsClosure;
1.13
1.14 +// Decode the oop and call do_oop on it.
1.15 +#define DO_OOP_WORK_DEFN \
1.16 + void do_oop(oop obj); \
1.17 + template <class T> inline void do_oop_work(T* p) { \
1.18 + T heap_oop = oopDesc::load_heap_oop(p); \
1.19 + if (!oopDesc::is_null(heap_oop)) { \
1.20 + oop obj = oopDesc::decode_heap_oop_not_null(heap_oop); \
1.21 + do_oop(obj); \
1.22 + } \
1.23 + }
1.24 +
1.25 class MarkRefsIntoClosure: public OopsInGenClosure {
1.26 - const MemRegion _span;
1.27 - CMSBitMap* _bitMap;
1.28 - const bool _should_do_nmethods;
1.29 + private:
1.30 + const MemRegion _span;
1.31 + CMSBitMap* _bitMap;
1.32 + const bool _should_do_nmethods;
1.33 + protected:
1.34 + DO_OOP_WORK_DEFN
1.35 public:
1.36 MarkRefsIntoClosure(MemRegion span, CMSBitMap* bitMap,
1.37 bool should_do_nmethods);
1.38 - void do_oop(oop* p);
1.39 - void do_oop_nv(oop* p) { MarkRefsIntoClosure::do_oop(p); }
1.40 + virtual void do_oop(oop* p);
1.41 + virtual void do_oop(narrowOop* p);
1.42 + inline void do_oop_nv(oop* p) { MarkRefsIntoClosure::do_oop_work(p); }
1.43 + inline void do_oop_nv(narrowOop* p) { MarkRefsIntoClosure::do_oop_work(p); }
1.44 bool do_header() { return true; }
1.45 virtual const bool do_nmethods() const {
1.46 return _should_do_nmethods;
1.47 @@ -57,15 +69,20 @@
1.48 // A variant of the above used in certain kinds of CMS
1.49 // marking verification.
1.50 class MarkRefsIntoVerifyClosure: public OopsInGenClosure {
1.51 - const MemRegion _span;
1.52 - CMSBitMap* _verification_bm;
1.53 - CMSBitMap* _cms_bm;
1.54 - const bool _should_do_nmethods;
1.55 + private:
1.56 + const MemRegion _span;
1.57 + CMSBitMap* _verification_bm;
1.58 + CMSBitMap* _cms_bm;
1.59 + const bool _should_do_nmethods;
1.60 + protected:
1.61 + DO_OOP_WORK_DEFN
1.62 public:
1.63 MarkRefsIntoVerifyClosure(MemRegion span, CMSBitMap* verification_bm,
1.64 CMSBitMap* cms_bm, bool should_do_nmethods);
1.65 - void do_oop(oop* p);
1.66 - void do_oop_nv(oop* p) { MarkRefsIntoVerifyClosure::do_oop(p); }
1.67 + virtual void do_oop(oop* p);
1.68 + virtual void do_oop(narrowOop* p);
1.69 + inline void do_oop_nv(oop* p) { MarkRefsIntoVerifyClosure::do_oop_work(p); }
1.70 + inline void do_oop_nv(narrowOop* p) { MarkRefsIntoVerifyClosure::do_oop_work(p); }
1.71 bool do_header() { return true; }
1.72 virtual const bool do_nmethods() const {
1.73 return _should_do_nmethods;
1.74 @@ -75,37 +92,40 @@
1.75 }
1.76 };
1.77
1.78 -
1.79 // The non-parallel version (the parallel version appears further below).
1.80 class PushAndMarkClosure: public OopClosure {
1.81 - CMSCollector* _collector;
1.82 - MemRegion _span;
1.83 - CMSBitMap* _bit_map;
1.84 - CMSBitMap* _mod_union_table;
1.85 - CMSMarkStack* _mark_stack;
1.86 - CMSMarkStack* _revisit_stack;
1.87 - bool _concurrent_precleaning;
1.88 - bool const _should_remember_klasses;
1.89 + private:
1.90 + CMSCollector* _collector;
1.91 + MemRegion _span;
1.92 + CMSBitMap* _bit_map;
1.93 + CMSBitMap* _mod_union_table;
1.94 + CMSMarkStack* _mark_stack;
1.95 + CMSMarkStack* _revisit_stack;
1.96 + bool _concurrent_precleaning;
1.97 + bool const _should_remember_klasses;
1.98 + protected:
1.99 + DO_OOP_WORK_DEFN
1.100 public:
1.101 PushAndMarkClosure(CMSCollector* collector,
1.102 MemRegion span,
1.103 ReferenceProcessor* rp,
1.104 CMSBitMap* bit_map,
1.105 CMSBitMap* mod_union_table,
1.106 - CMSMarkStack* mark_stack,
1.107 - CMSMarkStack* revisit_stack,
1.108 - bool concurrent_precleaning);
1.109 -
1.110 - void do_oop(oop* p);
1.111 - void do_oop_nv(oop* p) { PushAndMarkClosure::do_oop(p); }
1.112 + CMSMarkStack* mark_stack,
1.113 + CMSMarkStack* revisit_stack,
1.114 + bool concurrent_precleaning);
1.115 + virtual void do_oop(oop* p);
1.116 + virtual void do_oop(narrowOop* p);
1.117 + inline void do_oop_nv(oop* p) { PushAndMarkClosure::do_oop_work(p); }
1.118 + inline void do_oop_nv(narrowOop* p) { PushAndMarkClosure::do_oop_work(p); }
1.119 bool do_header() { return true; }
1.120 Prefetch::style prefetch_style() {
1.121 return Prefetch::do_read;
1.122 }
1.123 - const bool should_remember_klasses() const {
1.124 + virtual const bool should_remember_klasses() const {
1.125 return _should_remember_klasses;
1.126 }
1.127 - void remember_klass(Klass* k);
1.128 + virtual void remember_klass(Klass* k);
1.129 };
1.130
1.131 // In the parallel case, the revisit stack, the bit map and the
1.132 @@ -115,12 +135,15 @@
1.133 // used in the non-parallel case above is here replaced with
1.134 // an OopTaskQueue structure to allow efficient work stealing.
1.135 class Par_PushAndMarkClosure: public OopClosure {
1.136 - CMSCollector* _collector;
1.137 - MemRegion _span;
1.138 - CMSBitMap* _bit_map;
1.139 - OopTaskQueue* _work_queue;
1.140 - CMSMarkStack* _revisit_stack;
1.141 - bool const _should_remember_klasses;
1.142 + private:
1.143 + CMSCollector* _collector;
1.144 + MemRegion _span;
1.145 + CMSBitMap* _bit_map;
1.146 + OopTaskQueue* _work_queue;
1.147 + CMSMarkStack* _revisit_stack;
1.148 + bool const _should_remember_klasses;
1.149 + protected:
1.150 + DO_OOP_WORK_DEFN
1.151 public:
1.152 Par_PushAndMarkClosure(CMSCollector* collector,
1.153 MemRegion span,
1.154 @@ -128,43 +151,48 @@
1.155 CMSBitMap* bit_map,
1.156 OopTaskQueue* work_queue,
1.157 CMSMarkStack* revisit_stack);
1.158 -
1.159 - void do_oop(oop* p);
1.160 - void do_oop_nv(oop* p) { Par_PushAndMarkClosure::do_oop(p); }
1.161 + virtual void do_oop(oop* p);
1.162 + virtual void do_oop(narrowOop* p);
1.163 + inline void do_oop_nv(oop* p) { Par_PushAndMarkClosure::do_oop_work(p); }
1.164 + inline void do_oop_nv(narrowOop* p) { Par_PushAndMarkClosure::do_oop_work(p); }
1.165 bool do_header() { return true; }
1.166 Prefetch::style prefetch_style() {
1.167 return Prefetch::do_read;
1.168 }
1.169 - const bool should_remember_klasses() const {
1.170 + virtual const bool should_remember_klasses() const {
1.171 return _should_remember_klasses;
1.172 }
1.173 - void remember_klass(Klass* k);
1.174 + virtual void remember_klass(Klass* k);
1.175 };
1.176
1.177 -
1.178 // The non-parallel version (the parallel version appears further below).
1.179 class MarkRefsIntoAndScanClosure: public OopsInGenClosure {
1.180 - MemRegion _span;
1.181 - CMSBitMap* _bit_map;
1.182 - CMSMarkStack* _mark_stack;
1.183 - PushAndMarkClosure _pushAndMarkClosure;
1.184 - CMSCollector* _collector;
1.185 - bool _yield;
1.186 + private:
1.187 + MemRegion _span;
1.188 + CMSBitMap* _bit_map;
1.189 + CMSMarkStack* _mark_stack;
1.190 + PushAndMarkClosure _pushAndMarkClosure;
1.191 + CMSCollector* _collector;
1.192 + Mutex* _freelistLock;
1.193 + bool _yield;
1.194 // Whether closure is being used for concurrent precleaning
1.195 - bool _concurrent_precleaning;
1.196 - Mutex* _freelistLock;
1.197 + bool _concurrent_precleaning;
1.198 + protected:
1.199 + DO_OOP_WORK_DEFN
1.200 public:
1.201 MarkRefsIntoAndScanClosure(MemRegion span,
1.202 ReferenceProcessor* rp,
1.203 CMSBitMap* bit_map,
1.204 CMSBitMap* mod_union_table,
1.205 - CMSMarkStack* mark_stack,
1.206 - CMSMarkStack* revisit_stack,
1.207 + CMSMarkStack* mark_stack,
1.208 + CMSMarkStack* revisit_stack,
1.209 CMSCollector* collector,
1.210 bool should_yield,
1.211 bool concurrent_precleaning);
1.212 - void do_oop(oop* p);
1.213 - void do_oop_nv(oop* p) { MarkRefsIntoAndScanClosure::do_oop(p); }
1.214 + virtual void do_oop(oop* p);
1.215 + virtual void do_oop(narrowOop* p);
1.216 + inline void do_oop_nv(oop* p) { MarkRefsIntoAndScanClosure::do_oop_work(p); }
1.217 + inline void do_oop_nv(narrowOop* p) { MarkRefsIntoAndScanClosure::do_oop_work(p); }
1.218 bool do_header() { return true; }
1.219 virtual const bool do_nmethods() const { return true; }
1.220 Prefetch::style prefetch_style() {
1.221 @@ -185,11 +213,14 @@
1.222 // sycnhronized. An OopTaskQueue structure, supporting efficient
1.223 // workstealing, replaces a CMSMarkStack for storing grey objects.
1.224 class Par_MarkRefsIntoAndScanClosure: public OopsInGenClosure {
1.225 - MemRegion _span;
1.226 - CMSBitMap* _bit_map;
1.227 - OopTaskQueue* _work_queue;
1.228 - const uint _low_water_mark;
1.229 - Par_PushAndMarkClosure _par_pushAndMarkClosure;
1.230 + private:
1.231 + MemRegion _span;
1.232 + CMSBitMap* _bit_map;
1.233 + OopTaskQueue* _work_queue;
1.234 + const uint _low_water_mark;
1.235 + Par_PushAndMarkClosure _par_pushAndMarkClosure;
1.236 + protected:
1.237 + DO_OOP_WORK_DEFN
1.238 public:
1.239 Par_MarkRefsIntoAndScanClosure(CMSCollector* collector,
1.240 MemRegion span,
1.241 @@ -197,8 +228,10 @@
1.242 CMSBitMap* bit_map,
1.243 OopTaskQueue* work_queue,
1.244 CMSMarkStack* revisit_stack);
1.245 - void do_oop(oop* p);
1.246 - void do_oop_nv(oop* p) { Par_MarkRefsIntoAndScanClosure::do_oop(p); }
1.247 + virtual void do_oop(oop* p);
1.248 + virtual void do_oop(narrowOop* p);
1.249 + inline void do_oop_nv(oop* p) { Par_MarkRefsIntoAndScanClosure::do_oop_work(p); }
1.250 + inline void do_oop_nv(narrowOop* p) { Par_MarkRefsIntoAndScanClosure::do_oop_work(p); }
1.251 bool do_header() { return true; }
1.252 virtual const bool do_nmethods() const { return true; }
1.253 Prefetch::style prefetch_style() {
1.254 @@ -211,28 +244,34 @@
1.255 // following the first checkpoint. Its use is buried in
1.256 // the closure MarkFromRootsClosure.
1.257 class PushOrMarkClosure: public OopClosure {
1.258 - CMSCollector* _collector;
1.259 - MemRegion _span;
1.260 - CMSBitMap* _bitMap;
1.261 - CMSMarkStack* _markStack;
1.262 - CMSMarkStack* _revisitStack;
1.263 - HeapWord* const _finger;
1.264 - MarkFromRootsClosure* const _parent;
1.265 - bool const _should_remember_klasses;
1.266 + private:
1.267 + CMSCollector* _collector;
1.268 + MemRegion _span;
1.269 + CMSBitMap* _bitMap;
1.270 + CMSMarkStack* _markStack;
1.271 + CMSMarkStack* _revisitStack;
1.272 + HeapWord* const _finger;
1.273 + MarkFromRootsClosure* const
1.274 + _parent;
1.275 + bool const _should_remember_klasses;
1.276 + protected:
1.277 + DO_OOP_WORK_DEFN
1.278 public:
1.279 PushOrMarkClosure(CMSCollector* cms_collector,
1.280 MemRegion span,
1.281 CMSBitMap* bitMap,
1.282 - CMSMarkStack* markStack,
1.283 - CMSMarkStack* revisitStack,
1.284 - HeapWord* finger,
1.285 + CMSMarkStack* markStack,
1.286 + CMSMarkStack* revisitStack,
1.287 + HeapWord* finger,
1.288 MarkFromRootsClosure* parent);
1.289 - void do_oop(oop* p);
1.290 - void do_oop_nv(oop* p) { PushOrMarkClosure::do_oop(p); }
1.291 - const bool should_remember_klasses() const {
1.292 + virtual void do_oop(oop* p);
1.293 + virtual void do_oop(narrowOop* p);
1.294 + inline void do_oop_nv(oop* p) { PushOrMarkClosure::do_oop_work(p); }
1.295 + inline void do_oop_nv(narrowOop* p) { PushOrMarkClosure::do_oop_work(p); }
1.296 + virtual const bool should_remember_klasses() const {
1.297 return _should_remember_klasses;
1.298 }
1.299 - void remember_klass(Klass* k);
1.300 + virtual void remember_klass(Klass* k);
1.301 // Deal with a stack overflow condition
1.302 void handle_stack_overflow(HeapWord* lost);
1.303 private:
1.304 @@ -244,6 +283,7 @@
1.305 // following the first checkpoint. Its use is buried in
1.306 // the closure Par_MarkFromRootsClosure.
1.307 class Par_PushOrMarkClosure: public OopClosure {
1.308 + private:
1.309 CMSCollector* _collector;
1.310 MemRegion _whole_span;
1.311 MemRegion _span; // local chunk
1.312 @@ -253,24 +293,29 @@
1.313 CMSMarkStack* _revisit_stack;
1.314 HeapWord* const _finger;
1.315 HeapWord** const _global_finger_addr;
1.316 - Par_MarkFromRootsClosure* const _parent;
1.317 - bool const _should_remember_klasses;
1.318 + Par_MarkFromRootsClosure* const
1.319 + _parent;
1.320 + bool const _should_remember_klasses;
1.321 + protected:
1.322 + DO_OOP_WORK_DEFN
1.323 public:
1.324 Par_PushOrMarkClosure(CMSCollector* cms_collector,
1.325 - MemRegion span,
1.326 - CMSBitMap* bit_map,
1.327 - OopTaskQueue* work_queue,
1.328 - CMSMarkStack* mark_stack,
1.329 - CMSMarkStack* revisit_stack,
1.330 - HeapWord* finger,
1.331 - HeapWord** global_finger_addr,
1.332 - Par_MarkFromRootsClosure* parent);
1.333 - void do_oop(oop* p);
1.334 - void do_oop_nv(oop* p) { Par_PushOrMarkClosure::do_oop(p); }
1.335 - const bool should_remember_klasses() const {
1.336 + MemRegion span,
1.337 + CMSBitMap* bit_map,
1.338 + OopTaskQueue* work_queue,
1.339 + CMSMarkStack* mark_stack,
1.340 + CMSMarkStack* revisit_stack,
1.341 + HeapWord* finger,
1.342 + HeapWord** global_finger_addr,
1.343 + Par_MarkFromRootsClosure* parent);
1.344 + virtual void do_oop(oop* p);
1.345 + virtual void do_oop(narrowOop* p);
1.346 + inline void do_oop_nv(oop* p) { Par_PushOrMarkClosure::do_oop_work(p); }
1.347 + inline void do_oop_nv(narrowOop* p) { Par_PushOrMarkClosure::do_oop_work(p); }
1.348 + virtual const bool should_remember_klasses() const {
1.349 return _should_remember_klasses;
1.350 }
1.351 - void remember_klass(Klass* k);
1.352 + virtual void remember_klass(Klass* k);
1.353 // Deal with a stack overflow condition
1.354 void handle_stack_overflow(HeapWord* lost);
1.355 private:
1.356 @@ -282,10 +327,13 @@
1.357 // This is currently used during the (weak) reference object
1.358 // processing phase of the CMS final checkpoint step.
1.359 class CMSKeepAliveClosure: public OopClosure {
1.360 + private:
1.361 CMSCollector* _collector;
1.362 MemRegion _span;
1.363 CMSMarkStack* _mark_stack;
1.364 CMSBitMap* _bit_map;
1.365 + protected:
1.366 + DO_OOP_WORK_DEFN
1.367 public:
1.368 CMSKeepAliveClosure(CMSCollector* collector, MemRegion span,
1.369 CMSBitMap* bit_map, CMSMarkStack* mark_stack):
1.370 @@ -293,16 +341,20 @@
1.371 _span(span),
1.372 _bit_map(bit_map),
1.373 _mark_stack(mark_stack) { }
1.374 -
1.375 - void do_oop(oop* p);
1.376 - void do_oop_nv(oop* p) { CMSKeepAliveClosure::do_oop(p); }
1.377 + virtual void do_oop(oop* p);
1.378 + virtual void do_oop(narrowOop* p);
1.379 + inline void do_oop_nv(oop* p) { CMSKeepAliveClosure::do_oop_work(p); }
1.380 + inline void do_oop_nv(narrowOop* p) { CMSKeepAliveClosure::do_oop_work(p); }
1.381 };
1.382
1.383 class CMSInnerParMarkAndPushClosure: public OopClosure {
1.384 + private:
1.385 CMSCollector* _collector;
1.386 MemRegion _span;
1.387 OopTaskQueue* _work_queue;
1.388 CMSBitMap* _bit_map;
1.389 + protected:
1.390 + DO_OOP_WORK_DEFN
1.391 public:
1.392 CMSInnerParMarkAndPushClosure(CMSCollector* collector,
1.393 MemRegion span, CMSBitMap* bit_map,
1.394 @@ -311,24 +363,32 @@
1.395 _span(span),
1.396 _bit_map(bit_map),
1.397 _work_queue(work_queue) { }
1.398 - void do_oop(oop* p);
1.399 - void do_oop_nv(oop* p) { CMSInnerParMarkAndPushClosure::do_oop(p); }
1.400 + virtual void do_oop(oop* p);
1.401 + virtual void do_oop(narrowOop* p);
1.402 + inline void do_oop_nv(oop* p) { CMSInnerParMarkAndPushClosure::do_oop_work(p); }
1.403 + inline void do_oop_nv(narrowOop* p) { CMSInnerParMarkAndPushClosure::do_oop_work(p); }
1.404 };
1.405
1.406 // A parallel (MT) version of the above, used when
1.407 // reference processing is parallel; the only difference
1.408 // is in the do_oop method.
1.409 class CMSParKeepAliveClosure: public OopClosure {
1.410 + private:
1.411 CMSCollector* _collector;
1.412 MemRegion _span;
1.413 OopTaskQueue* _work_queue;
1.414 CMSBitMap* _bit_map;
1.415 - CMSInnerParMarkAndPushClosure _mark_and_push;
1.416 + CMSInnerParMarkAndPushClosure
1.417 + _mark_and_push;
1.418 const uint _low_water_mark;
1.419 void trim_queue(uint max);
1.420 + protected:
1.421 + DO_OOP_WORK_DEFN
1.422 public:
1.423 CMSParKeepAliveClosure(CMSCollector* collector, MemRegion span,
1.424 CMSBitMap* bit_map, OopTaskQueue* work_queue);
1.425 - void do_oop(oop* p);
1.426 - void do_oop_nv(oop* p) { CMSParKeepAliveClosure::do_oop(p); }
1.427 + virtual void do_oop(oop* p);
1.428 + virtual void do_oop(narrowOop* p);
1.429 + inline void do_oop_nv(oop* p) { CMSParKeepAliveClosure::do_oop_work(p); }
1.430 + inline void do_oop_nv(narrowOop* p) { CMSParKeepAliveClosure::do_oop_work(p); }
1.431 };
