--- a/hotspot/src/share/vm/gc_implementation/concurrentMarkSweep/cmsOopClosures.hpp Fri Apr 11 09:56:35 2008 -0400
+++ b/hotspot/src/share/vm/gc_implementation/concurrentMarkSweep/cmsOopClosures.hpp Sun Apr 13 17:43:42 2008 -0400
@@ -29,22 +29,34 @@
class CMSBitMap;
class CMSMarkStack;
class CMSCollector;
-template<class E> class GenericTaskQueue;
-typedef GenericTaskQueue<oop> OopTaskQueue;
-template<class E> class GenericTaskQueueSet;
-typedef GenericTaskQueueSet<oop> OopTaskQueueSet;
class MarkFromRootsClosure;
class Par_MarkFromRootsClosure;
+// Decode the oop and call do_oop on it.
+#define DO_OOP_WORK_DEFN \
+ void do_oop(oop obj); \
+ template <class T> inline void do_oop_work(T* p) { \
+ T heap_oop = oopDesc::load_heap_oop(p); \
+ if (!oopDesc::is_null(heap_oop)) { \
+ oop obj = oopDesc::decode_heap_oop_not_null(heap_oop); \
+ do_oop(obj); \
+ } \
+ }
+
class MarkRefsIntoClosure: public OopsInGenClosure {
- const MemRegion _span;
- CMSBitMap* _bitMap;
- const bool _should_do_nmethods;
+ private:
+ const MemRegion _span;
+ CMSBitMap* _bitMap;
+ const bool _should_do_nmethods;
+ protected:
+ DO_OOP_WORK_DEFN
public:
MarkRefsIntoClosure(MemRegion span, CMSBitMap* bitMap,
bool should_do_nmethods);
- void do_oop(oop* p);
- void do_oop_nv(oop* p) { MarkRefsIntoClosure::do_oop(p); }
+ virtual void do_oop(oop* p);
+ virtual void do_oop(narrowOop* p);
+ inline void do_oop_nv(oop* p) { MarkRefsIntoClosure::do_oop_work(p); }
+ inline void do_oop_nv(narrowOop* p) { MarkRefsIntoClosure::do_oop_work(p); }
bool do_header() { return true; }
virtual const bool do_nmethods() const {
return _should_do_nmethods;
@@ -57,15 +69,20 @@
// A variant of the above used in certain kinds of CMS
// marking verification.
class MarkRefsIntoVerifyClosure: public OopsInGenClosure {
- const MemRegion _span;
- CMSBitMap* _verification_bm;
- CMSBitMap* _cms_bm;
- const bool _should_do_nmethods;
+ private:
+ const MemRegion _span;
+ CMSBitMap* _verification_bm;
+ CMSBitMap* _cms_bm;
+ const bool _should_do_nmethods;
+ protected:
+ DO_OOP_WORK_DEFN
public:
MarkRefsIntoVerifyClosure(MemRegion span, CMSBitMap* verification_bm,
CMSBitMap* cms_bm, bool should_do_nmethods);
- void do_oop(oop* p);
- void do_oop_nv(oop* p) { MarkRefsIntoVerifyClosure::do_oop(p); }
+ virtual void do_oop(oop* p);
+ virtual void do_oop(narrowOop* p);
+ inline void do_oop_nv(oop* p) { MarkRefsIntoVerifyClosure::do_oop_work(p); }
+ inline void do_oop_nv(narrowOop* p) { MarkRefsIntoVerifyClosure::do_oop_work(p); }
bool do_header() { return true; }
virtual const bool do_nmethods() const {
return _should_do_nmethods;
@@ -75,37 +92,40 @@
}
};
-
// The non-parallel version (the parallel version appears further below).
class PushAndMarkClosure: public OopClosure {
- CMSCollector* _collector;
- MemRegion _span;
- CMSBitMap* _bit_map;
- CMSBitMap* _mod_union_table;
- CMSMarkStack* _mark_stack;
- CMSMarkStack* _revisit_stack;
- bool _concurrent_precleaning;
- bool const _should_remember_klasses;
+ private:
+ CMSCollector* _collector;
+ MemRegion _span;
+ CMSBitMap* _bit_map;
+ CMSBitMap* _mod_union_table;
+ CMSMarkStack* _mark_stack;
+ CMSMarkStack* _revisit_stack;
+ bool _concurrent_precleaning;
+ bool const _should_remember_klasses;
+ protected:
+ DO_OOP_WORK_DEFN
public:
PushAndMarkClosure(CMSCollector* collector,
MemRegion span,
ReferenceProcessor* rp,
CMSBitMap* bit_map,
CMSBitMap* mod_union_table,
- CMSMarkStack* mark_stack,
- CMSMarkStack* revisit_stack,
- bool concurrent_precleaning);
-
- void do_oop(oop* p);
- void do_oop_nv(oop* p) { PushAndMarkClosure::do_oop(p); }
+ CMSMarkStack* mark_stack,
+ CMSMarkStack* revisit_stack,
+ bool concurrent_precleaning);
+ virtual void do_oop(oop* p);
+ virtual void do_oop(narrowOop* p);
+ inline void do_oop_nv(oop* p) { PushAndMarkClosure::do_oop_work(p); }
+ inline void do_oop_nv(narrowOop* p) { PushAndMarkClosure::do_oop_work(p); }
bool do_header() { return true; }
Prefetch::style prefetch_style() {
return Prefetch::do_read;
}
- const bool should_remember_klasses() const {
+ virtual const bool should_remember_klasses() const {
return _should_remember_klasses;
}
- void remember_klass(Klass* k);
+ virtual void remember_klass(Klass* k);
};
// In the parallel case, the revisit stack, the bit map and the
@@ -115,12 +135,15 @@
// used in the non-parallel case above is here replaced with
// an OopTaskQueue structure to allow efficient work stealing.
class Par_PushAndMarkClosure: public OopClosure {
- CMSCollector* _collector;
- MemRegion _span;
- CMSBitMap* _bit_map;
- OopTaskQueue* _work_queue;
- CMSMarkStack* _revisit_stack;
- bool const _should_remember_klasses;
+ private:
+ CMSCollector* _collector;
+ MemRegion _span;
+ CMSBitMap* _bit_map;
+ OopTaskQueue* _work_queue;
+ CMSMarkStack* _revisit_stack;
+ bool const _should_remember_klasses;
+ protected:
+ DO_OOP_WORK_DEFN
public:
Par_PushAndMarkClosure(CMSCollector* collector,
MemRegion span,
@@ -128,43 +151,48 @@
CMSBitMap* bit_map,
OopTaskQueue* work_queue,
CMSMarkStack* revisit_stack);
-
- void do_oop(oop* p);
- void do_oop_nv(oop* p) { Par_PushAndMarkClosure::do_oop(p); }
+ virtual void do_oop(oop* p);
+ virtual void do_oop(narrowOop* p);
+ inline void do_oop_nv(oop* p) { Par_PushAndMarkClosure::do_oop_work(p); }
+ inline void do_oop_nv(narrowOop* p) { Par_PushAndMarkClosure::do_oop_work(p); }
bool do_header() { return true; }
Prefetch::style prefetch_style() {
return Prefetch::do_read;
}
- const bool should_remember_klasses() const {
+ virtual const bool should_remember_klasses() const {
return _should_remember_klasses;
}
- void remember_klass(Klass* k);
+ virtual void remember_klass(Klass* k);
};
-
// The non-parallel version (the parallel version appears further below).
class MarkRefsIntoAndScanClosure: public OopsInGenClosure {
- MemRegion _span;
- CMSBitMap* _bit_map;
- CMSMarkStack* _mark_stack;
- PushAndMarkClosure _pushAndMarkClosure;
- CMSCollector* _collector;
- bool _yield;
+ private:
+ MemRegion _span;
+ CMSBitMap* _bit_map;
+ CMSMarkStack* _mark_stack;
+ PushAndMarkClosure _pushAndMarkClosure;
+ CMSCollector* _collector;
+ Mutex* _freelistLock;
+ bool _yield;
// Whether closure is being used for concurrent precleaning
- bool _concurrent_precleaning;
- Mutex* _freelistLock;
+ bool _concurrent_precleaning;
+ protected:
+ DO_OOP_WORK_DEFN
public:
MarkRefsIntoAndScanClosure(MemRegion span,
ReferenceProcessor* rp,
CMSBitMap* bit_map,
CMSBitMap* mod_union_table,
- CMSMarkStack* mark_stack,
- CMSMarkStack* revisit_stack,
+ CMSMarkStack* mark_stack,
+ CMSMarkStack* revisit_stack,
CMSCollector* collector,
bool should_yield,
bool concurrent_precleaning);
- void do_oop(oop* p);
- void do_oop_nv(oop* p) { MarkRefsIntoAndScanClosure::do_oop(p); }
+ virtual void do_oop(oop* p);
+ virtual void do_oop(narrowOop* p);
+ inline void do_oop_nv(oop* p) { MarkRefsIntoAndScanClosure::do_oop_work(p); }
+ inline void do_oop_nv(narrowOop* p) { MarkRefsIntoAndScanClosure::do_oop_work(p); }
bool do_header() { return true; }
virtual const bool do_nmethods() const { return true; }
Prefetch::style prefetch_style() {
@@ -185,11 +213,14 @@
// sycnhronized. An OopTaskQueue structure, supporting efficient
// workstealing, replaces a CMSMarkStack for storing grey objects.
class Par_MarkRefsIntoAndScanClosure: public OopsInGenClosure {
- MemRegion _span;
- CMSBitMap* _bit_map;
- OopTaskQueue* _work_queue;
- const uint _low_water_mark;
- Par_PushAndMarkClosure _par_pushAndMarkClosure;
+ private:
+ MemRegion _span;
+ CMSBitMap* _bit_map;
+ OopTaskQueue* _work_queue;
+ const uint _low_water_mark;
+ Par_PushAndMarkClosure _par_pushAndMarkClosure;
+ protected:
+ DO_OOP_WORK_DEFN
public:
Par_MarkRefsIntoAndScanClosure(CMSCollector* collector,
MemRegion span,
@@ -197,8 +228,10 @@
CMSBitMap* bit_map,
OopTaskQueue* work_queue,
CMSMarkStack* revisit_stack);
- void do_oop(oop* p);
- void do_oop_nv(oop* p) { Par_MarkRefsIntoAndScanClosure::do_oop(p); }
+ virtual void do_oop(oop* p);
+ virtual void do_oop(narrowOop* p);
+ inline void do_oop_nv(oop* p) { Par_MarkRefsIntoAndScanClosure::do_oop_work(p); }
+ inline void do_oop_nv(narrowOop* p) { Par_MarkRefsIntoAndScanClosure::do_oop_work(p); }
bool do_header() { return true; }
virtual const bool do_nmethods() const { return true; }
Prefetch::style prefetch_style() {
@@ -211,28 +244,34 @@
// following the first checkpoint. Its use is buried in
// the closure MarkFromRootsClosure.
class PushOrMarkClosure: public OopClosure {
- CMSCollector* _collector;
- MemRegion _span;
- CMSBitMap* _bitMap;
- CMSMarkStack* _markStack;
- CMSMarkStack* _revisitStack;
- HeapWord* const _finger;
- MarkFromRootsClosure* const _parent;
- bool const _should_remember_klasses;
+ private:
+ CMSCollector* _collector;
+ MemRegion _span;
+ CMSBitMap* _bitMap;
+ CMSMarkStack* _markStack;
+ CMSMarkStack* _revisitStack;
+ HeapWord* const _finger;
+ MarkFromRootsClosure* const
+ _parent;
+ bool const _should_remember_klasses;
+ protected:
+ DO_OOP_WORK_DEFN
public:
PushOrMarkClosure(CMSCollector* cms_collector,
MemRegion span,
CMSBitMap* bitMap,
- CMSMarkStack* markStack,
- CMSMarkStack* revisitStack,
- HeapWord* finger,
+ CMSMarkStack* markStack,
+ CMSMarkStack* revisitStack,
+ HeapWord* finger,
MarkFromRootsClosure* parent);
- void do_oop(oop* p);
- void do_oop_nv(oop* p) { PushOrMarkClosure::do_oop(p); }
- const bool should_remember_klasses() const {
+ virtual void do_oop(oop* p);
+ virtual void do_oop(narrowOop* p);
+ inline void do_oop_nv(oop* p) { PushOrMarkClosure::do_oop_work(p); }
+ inline void do_oop_nv(narrowOop* p) { PushOrMarkClosure::do_oop_work(p); }
+ virtual const bool should_remember_klasses() const {
return _should_remember_klasses;
}
- void remember_klass(Klass* k);
+ virtual void remember_klass(Klass* k);
// Deal with a stack overflow condition
void handle_stack_overflow(HeapWord* lost);
private:
@@ -244,6 +283,7 @@
// following the first checkpoint. Its use is buried in
// the closure Par_MarkFromRootsClosure.
class Par_PushOrMarkClosure: public OopClosure {
+ private:
CMSCollector* _collector;
MemRegion _whole_span;
MemRegion _span; // local chunk
@@ -253,24 +293,29 @@
CMSMarkStack* _revisit_stack;
HeapWord* const _finger;
HeapWord** const _global_finger_addr;
- Par_MarkFromRootsClosure* const _parent;
- bool const _should_remember_klasses;
+ Par_MarkFromRootsClosure* const
+ _parent;
+ bool const _should_remember_klasses;
+ protected:
+ DO_OOP_WORK_DEFN
public:
Par_PushOrMarkClosure(CMSCollector* cms_collector,
- MemRegion span,
- CMSBitMap* bit_map,
- OopTaskQueue* work_queue,
- CMSMarkStack* mark_stack,
- CMSMarkStack* revisit_stack,
- HeapWord* finger,
- HeapWord** global_finger_addr,
- Par_MarkFromRootsClosure* parent);
- void do_oop(oop* p);
- void do_oop_nv(oop* p) { Par_PushOrMarkClosure::do_oop(p); }
- const bool should_remember_klasses() const {
+ MemRegion span,
+ CMSBitMap* bit_map,
+ OopTaskQueue* work_queue,
+ CMSMarkStack* mark_stack,
+ CMSMarkStack* revisit_stack,
+ HeapWord* finger,
+ HeapWord** global_finger_addr,
+ Par_MarkFromRootsClosure* parent);
+ virtual void do_oop(oop* p);
+ virtual void do_oop(narrowOop* p);
+ inline void do_oop_nv(oop* p) { Par_PushOrMarkClosure::do_oop_work(p); }
+ inline void do_oop_nv(narrowOop* p) { Par_PushOrMarkClosure::do_oop_work(p); }
+ virtual const bool should_remember_klasses() const {
return _should_remember_klasses;
}
- void remember_klass(Klass* k);
+ virtual void remember_klass(Klass* k);
// Deal with a stack overflow condition
void handle_stack_overflow(HeapWord* lost);
private:
@@ -282,10 +327,13 @@
// This is currently used during the (weak) reference object
// processing phase of the CMS final checkpoint step.
class CMSKeepAliveClosure: public OopClosure {
+ private:
CMSCollector* _collector;
MemRegion _span;
CMSMarkStack* _mark_stack;
CMSBitMap* _bit_map;
+ protected:
+ DO_OOP_WORK_DEFN
public:
CMSKeepAliveClosure(CMSCollector* collector, MemRegion span,
CMSBitMap* bit_map, CMSMarkStack* mark_stack):
@@ -293,16 +341,20 @@
_span(span),
_bit_map(bit_map),
_mark_stack(mark_stack) { }
-
- void do_oop(oop* p);
- void do_oop_nv(oop* p) { CMSKeepAliveClosure::do_oop(p); }
+ virtual void do_oop(oop* p);
+ virtual void do_oop(narrowOop* p);
+ inline void do_oop_nv(oop* p) { CMSKeepAliveClosure::do_oop_work(p); }
+ inline void do_oop_nv(narrowOop* p) { CMSKeepAliveClosure::do_oop_work(p); }
};
class CMSInnerParMarkAndPushClosure: public OopClosure {
+ private:
CMSCollector* _collector;
MemRegion _span;
OopTaskQueue* _work_queue;
CMSBitMap* _bit_map;
+ protected:
+ DO_OOP_WORK_DEFN
public:
CMSInnerParMarkAndPushClosure(CMSCollector* collector,
MemRegion span, CMSBitMap* bit_map,
@@ -311,24 +363,32 @@
_span(span),
_bit_map(bit_map),
_work_queue(work_queue) { }
- void do_oop(oop* p);
- void do_oop_nv(oop* p) { CMSInnerParMarkAndPushClosure::do_oop(p); }
+ virtual void do_oop(oop* p);
+ virtual void do_oop(narrowOop* p);
+ inline void do_oop_nv(oop* p) { CMSInnerParMarkAndPushClosure::do_oop_work(p); }
+ inline void do_oop_nv(narrowOop* p) { CMSInnerParMarkAndPushClosure::do_oop_work(p); }
};
// A parallel (MT) version of the above, used when
// reference processing is parallel; the only difference
// is in the do_oop method.
class CMSParKeepAliveClosure: public OopClosure {
+ private:
CMSCollector* _collector;
MemRegion _span;
OopTaskQueue* _work_queue;
CMSBitMap* _bit_map;
- CMSInnerParMarkAndPushClosure _mark_and_push;
+ CMSInnerParMarkAndPushClosure
+ _mark_and_push;
const uint _low_water_mark;
void trim_queue(uint max);
+ protected:
+ DO_OOP_WORK_DEFN
public:
CMSParKeepAliveClosure(CMSCollector* collector, MemRegion span,
CMSBitMap* bit_map, OopTaskQueue* work_queue);
- void do_oop(oop* p);
- void do_oop_nv(oop* p) { CMSParKeepAliveClosure::do_oop(p); }
+ virtual void do_oop(oop* p);
+ virtual void do_oop(narrowOop* p);
+ inline void do_oop_nv(oop* p) { CMSParKeepAliveClosure::do_oop_work(p); }
+ inline void do_oop_nv(narrowOop* p) { CMSParKeepAliveClosure::do_oop_work(p); }
};