1.1 --- a/src/share/vm/gc_implementation/concurrentMarkSweep/cmsOopClosures.hpp Fri Sep 18 09:57:47 2009 -0700
1.2 +++ b/src/share/vm/gc_implementation/concurrentMarkSweep/cmsOopClosures.hpp Wed Sep 23 23:56:15 2009 -0700
1.3 @@ -88,17 +88,50 @@
1.4 }
1.5 };
1.6
1.7 +// KlassRememberingOopClosure is used when marking of the permanent generation
1.8 +// is being done. It adds fields to support revisiting of klasses
1.9 +// for class unloading. _should_remember_klasses should be set to
1.10 +// indicate if klasses should be remembered. Currently that is whenever
1.11 +// CMS class unloading is turned on. The _revisit_stack is used
1.12 +// to save the klasses for later processing.
1.13 +class KlassRememberingOopClosure : public OopClosure {
1.14 + protected:
1.15 + CMSCollector* _collector;
1.16 + CMSMarkStack* _revisit_stack;
1.17 + bool const _should_remember_klasses;
1.18 + public:
1.19 + void check_remember_klasses() const PRODUCT_RETURN;
1.20 + virtual const bool should_remember_klasses() const {
1.21 + check_remember_klasses();
1.22 + return _should_remember_klasses;
1.23 + }
1.24 + virtual void remember_klass(Klass* k);
1.25 +
1.26 + KlassRememberingOopClosure(CMSCollector* collector,
1.27 + ReferenceProcessor* rp,
1.28 + CMSMarkStack* revisit_stack);
1.29 +};
1.30 +
1.31 +// Similar to KlassRememberingOopClosure for use when multiple
1.32 +// GC threads will execute the closure.
1.33 +
1.34 +class Par_KlassRememberingOopClosure : public KlassRememberingOopClosure {
1.35 + public:
1.36 + Par_KlassRememberingOopClosure(CMSCollector* collector,
1.37 + ReferenceProcessor* rp,
1.38 + CMSMarkStack* revisit_stack):
1.39 + KlassRememberingOopClosure(collector, rp, revisit_stack) {}
1.40 + virtual void remember_klass(Klass* k);
1.41 +};
1.42 +
1.43 // The non-parallel version (the parallel version appears further below).
1.44 -class PushAndMarkClosure: public OopClosure {
1.45 +class PushAndMarkClosure: public KlassRememberingOopClosure {
1.46 private:
1.47 - CMSCollector* _collector;
1.48 MemRegion _span;
1.49 CMSBitMap* _bit_map;
1.50 CMSBitMap* _mod_union_table;
1.51 CMSMarkStack* _mark_stack;
1.52 - CMSMarkStack* _revisit_stack;
1.53 bool _concurrent_precleaning;
1.54 - bool const _should_remember_klasses;
1.55 protected:
1.56 DO_OOP_WORK_DEFN
1.57 public:
1.58 @@ -118,10 +151,12 @@
1.59 Prefetch::style prefetch_style() {
1.60 return Prefetch::do_read;
1.61 }
1.62 - virtual const bool should_remember_klasses() const {
1.63 - return _should_remember_klasses;
1.64 + // In support of class unloading
1.65 + virtual const bool should_remember_mdo() const {
1.66 + return false;
1.67 + // return _should_remember_klasses;
1.68 }
1.69 - virtual void remember_klass(Klass* k);
1.70 + virtual void remember_mdo(DataLayout* v);
1.71 };
1.72
1.73 // In the parallel case, the revisit stack, the bit map and the
1.74 @@ -130,14 +165,11 @@
1.75 // synchronization (for instance, via CAS). The marking stack
1.76 // used in the non-parallel case above is here replaced with
1.77 // an OopTaskQueue structure to allow efficient work stealing.
1.78 -class Par_PushAndMarkClosure: public OopClosure {
1.79 +class Par_PushAndMarkClosure: public Par_KlassRememberingOopClosure {
1.80 private:
1.81 - CMSCollector* _collector;
1.82 MemRegion _span;
1.83 CMSBitMap* _bit_map;
1.84 OopTaskQueue* _work_queue;
1.85 - CMSMarkStack* _revisit_stack;
1.86 - bool const _should_remember_klasses;
1.87 protected:
1.88 DO_OOP_WORK_DEFN
1.89 public:
1.90 @@ -155,10 +187,12 @@
1.91 Prefetch::style prefetch_style() {
1.92 return Prefetch::do_read;
1.93 }
1.94 - virtual const bool should_remember_klasses() const {
1.95 - return _should_remember_klasses;
1.96 + // In support of class unloading
1.97 + virtual const bool should_remember_mdo() const {
1.98 + return false;
1.99 + // return _should_remember_klasses;
1.100 }
1.101 - virtual void remember_klass(Klass* k);
1.102 + virtual void remember_mdo(DataLayout* v);
1.103 };
1.104
1.105 // The non-parallel version (the parallel version appears further below).
1.106 @@ -196,6 +230,12 @@
1.107 void set_freelistLock(Mutex* m) {
1.108 _freelistLock = m;
1.109 }
1.110 + virtual const bool should_remember_klasses() const {
1.111 + return _pushAndMarkClosure.should_remember_klasses();
1.112 + }
1.113 + virtual void remember_klass(Klass* k) {
1.114 + _pushAndMarkClosure.remember_klass(k);
1.115 + }
1.116
1.117 private:
1.118 inline void do_yield_check();
1.119 @@ -229,6 +269,16 @@
1.120 inline void do_oop_nv(narrowOop* p) { Par_MarkRefsIntoAndScanClosure::do_oop_work(p); }
1.121 bool do_header() { return true; }
1.122 virtual const bool do_nmethods() const { return true; }
1.123 + // When ScanMarkedObjectsAgainClosure is used,
1.124 + // it passes [Par_]MarkRefsIntoAndScanClosure to oop_oop_iterate(),
1.125 + // and this delegation is used.
1.126 + virtual const bool should_remember_klasses() const {
1.127 + return _par_pushAndMarkClosure.should_remember_klasses();
1.128 + }
1.129 + // See comment on should_remember_klasses() above.
1.130 + virtual void remember_klass(Klass* k) {
1.131 + _par_pushAndMarkClosure.remember_klass(k);
1.132 + }
1.133 Prefetch::style prefetch_style() {
1.134 return Prefetch::do_read;
1.135 }
1.136 @@ -238,17 +288,14 @@
1.137 // This closure is used during the concurrent marking phase
1.138 // following the first checkpoint. Its use is buried in
1.139 // the closure MarkFromRootsClosure.
1.140 -class PushOrMarkClosure: public OopClosure {
1.141 +class PushOrMarkClosure: public KlassRememberingOopClosure {
1.142 private:
1.143 - CMSCollector* _collector;
1.144 MemRegion _span;
1.145 CMSBitMap* _bitMap;
1.146 CMSMarkStack* _markStack;
1.147 - CMSMarkStack* _revisitStack;
1.148 HeapWord* const _finger;
1.149 MarkFromRootsClosure* const
1.150 _parent;
1.151 - bool const _should_remember_klasses;
1.152 protected:
1.153 DO_OOP_WORK_DEFN
1.154 public:
1.155 @@ -263,10 +310,13 @@
1.156 virtual void do_oop(narrowOop* p);
1.157 inline void do_oop_nv(oop* p) { PushOrMarkClosure::do_oop_work(p); }
1.158 inline void do_oop_nv(narrowOop* p) { PushOrMarkClosure::do_oop_work(p); }
1.159 - virtual const bool should_remember_klasses() const {
1.160 - return _should_remember_klasses;
1.161 + // In support of class unloading
1.162 + virtual const bool should_remember_mdo() const {
1.163 + return false;
1.164 + // return _should_remember_klasses;
1.165 }
1.166 - virtual void remember_klass(Klass* k);
1.167 + virtual void remember_mdo(DataLayout* v);
1.168 +
1.169 // Deal with a stack overflow condition
1.170 void handle_stack_overflow(HeapWord* lost);
1.171 private:
1.172 @@ -277,20 +327,17 @@
1.173 // This closure is used during the concurrent marking phase
1.174 // following the first checkpoint. Its use is buried in
1.175 // the closure Par_MarkFromRootsClosure.
1.176 -class Par_PushOrMarkClosure: public OopClosure {
1.177 +class Par_PushOrMarkClosure: public Par_KlassRememberingOopClosure {
1.178 private:
1.179 - CMSCollector* _collector;
1.180 MemRegion _whole_span;
1.181 MemRegion _span; // local chunk
1.182 CMSBitMap* _bit_map;
1.183 OopTaskQueue* _work_queue;
1.184 CMSMarkStack* _overflow_stack;
1.185 - CMSMarkStack* _revisit_stack;
1.186 HeapWord* const _finger;
1.187 HeapWord** const _global_finger_addr;
1.188 Par_MarkFromRootsClosure* const
1.189 _parent;
1.190 - bool const _should_remember_klasses;
1.191 protected:
1.192 DO_OOP_WORK_DEFN
1.193 public:
1.194 @@ -307,10 +354,13 @@
1.195 virtual void do_oop(narrowOop* p);
1.196 inline void do_oop_nv(oop* p) { Par_PushOrMarkClosure::do_oop_work(p); }
1.197 inline void do_oop_nv(narrowOop* p) { Par_PushOrMarkClosure::do_oop_work(p); }
1.198 - virtual const bool should_remember_klasses() const {
1.199 - return _should_remember_klasses;
1.200 + // In support of class unloading
1.201 + virtual const bool should_remember_mdo() const {
1.202 + return false;
1.203 + // return _should_remember_klasses;
1.204 }
1.205 - virtual void remember_klass(Klass* k);
1.206 + virtual void remember_mdo(DataLayout* v);
1.207 +
1.208 // Deal with a stack overflow condition
1.209 void handle_stack_overflow(HeapWord* lost);
1.210 private:
1.211 @@ -323,9 +373,8 @@
1.212 // processing phase of the CMS final checkpoint step, as
1.213 // well as during the concurrent precleaning of the discovered
1.214 // reference lists.
1.215 -class CMSKeepAliveClosure: public OopClosure {
1.216 +class CMSKeepAliveClosure: public KlassRememberingOopClosure {
1.217 private:
1.218 - CMSCollector* _collector;
1.219 const MemRegion _span;
1.220 CMSMarkStack* _mark_stack;
1.221 CMSBitMap* _bit_map;
1.222 @@ -335,14 +384,7 @@
1.223 public:
1.224 CMSKeepAliveClosure(CMSCollector* collector, MemRegion span,
1.225 CMSBitMap* bit_map, CMSMarkStack* mark_stack,
1.226 - bool cpc):
1.227 - _collector(collector),
1.228 - _span(span),
1.229 - _bit_map(bit_map),
1.230 - _mark_stack(mark_stack),
1.231 - _concurrent_precleaning(cpc) {
1.232 - assert(!_span.is_empty(), "Empty span could spell trouble");
1.233 - }
1.234 + CMSMarkStack* revisit_stack, bool cpc);
1.235 bool concurrent_precleaning() const { return _concurrent_precleaning; }
1.236 virtual void do_oop(oop* p);
1.237 virtual void do_oop(narrowOop* p);
1.238 @@ -350,9 +392,8 @@
1.239 inline void do_oop_nv(narrowOop* p) { CMSKeepAliveClosure::do_oop_work(p); }
1.240 };
1.241
1.242 -class CMSInnerParMarkAndPushClosure: public OopClosure {
1.243 +class CMSInnerParMarkAndPushClosure: public Par_KlassRememberingOopClosure {
1.244 private:
1.245 - CMSCollector* _collector;
1.246 MemRegion _span;
1.247 OopTaskQueue* _work_queue;
1.248 CMSBitMap* _bit_map;
1.249 @@ -361,11 +402,8 @@
1.250 public:
1.251 CMSInnerParMarkAndPushClosure(CMSCollector* collector,
1.252 MemRegion span, CMSBitMap* bit_map,
1.253 - OopTaskQueue* work_queue):
1.254 - _collector(collector),
1.255 - _span(span),
1.256 - _bit_map(bit_map),
1.257 - _work_queue(work_queue) { }
1.258 + CMSMarkStack* revisit_stack,
1.259 + OopTaskQueue* work_queue);
1.260 virtual void do_oop(oop* p);
1.261 virtual void do_oop(narrowOop* p);
1.262 inline void do_oop_nv(oop* p) { CMSInnerParMarkAndPushClosure::do_oop_work(p); }
1.263 @@ -375,9 +413,8 @@
1.264 // A parallel (MT) version of the above, used when
1.265 // reference processing is parallel; the only difference
1.266 // is in the do_oop method.
1.267 -class CMSParKeepAliveClosure: public OopClosure {
1.268 +class CMSParKeepAliveClosure: public Par_KlassRememberingOopClosure {
1.269 private:
1.270 - CMSCollector* _collector;
1.271 MemRegion _span;
1.272 OopTaskQueue* _work_queue;
1.273 CMSBitMap* _bit_map;
1.274 @@ -389,7 +426,8 @@
1.275 DO_OOP_WORK_DEFN
1.276 public:
1.277 CMSParKeepAliveClosure(CMSCollector* collector, MemRegion span,
1.278 - CMSBitMap* bit_map, OopTaskQueue* work_queue);
1.279 + CMSBitMap* bit_map, CMSMarkStack* revisit_stack,
1.280 + OopTaskQueue* work_queue);
1.281 virtual void do_oop(oop* p);
1.282 virtual void do_oop(narrowOop* p);
1.283 inline void do_oop_nv(oop* p) { CMSParKeepAliveClosure::do_oop_work(p); }
