src/share/vm/gc/serial/markSweep.hpp
Print this page
*** 37,70 ****
class ReferenceProcessor;
class DataLayout;
class SerialOldTracer;
class STWGCTimer;
// MarkSweep takes care of global mark-compact garbage collection for a
// GenCollectedHeap using a four-phase pointer forwarding algorithm. All
// generations are assumed to support marking; those that can also support
// compaction.
//
// Class unloading will only occur when a full gc is invoked.
// declared at end
class PreservedMark;
- class MarkAndPushClosure;
! class MarkSweep : AllStatic {
//
// Inline closure decls
//
class FollowRootClosure: public OopsInGenClosure {
public:
virtual void do_oop(oop* p);
virtual void do_oop(narrowOop* p);
};
class FollowStackClosure: public VoidClosure {
public:
virtual void do_void();
};
class AdjustPointerClosure: public OopsInGenClosure {
public:
--- 37,96 ----
class ReferenceProcessor;
class DataLayout;
class SerialOldTracer;
class STWGCTimer;
+ class MarkSweep;
+
+ class MarkAndPushClosure: public ExtendedOopClosure {
+ MarkSweep* _ms;
+ public:
+ MarkAndPushClosure(MarkSweep* ms) : _ms(ms) {}
+ template <typename T> void do_oop_nv(T* p);
+ virtual void do_oop(oop* p);
+ virtual void do_oop(narrowOop* p);
+
+ virtual bool do_metadata();
+ bool do_metadata_nv();
+
+ virtual void do_klass(Klass* k);
+ void do_klass_nv(Klass* k);
+
+ virtual void do_cld(ClassLoaderData* cld);
+ void do_cld_nv(ClassLoaderData* cld);
+
+ void set_ref_processor(ReferenceProcessor* rp) {
+ set_ref_processor_internal(rp);
+ }
+ };
// MarkSweep takes care of global mark-compact garbage collection for a
// GenCollectedHeap using a four-phase pointer forwarding algorithm. All
// generations are assumed to support marking; those that can also support
// compaction.
//
// Class unloading will only occur when a full gc is invoked.
// declared at end
class PreservedMark;
! class MarkSweep : public StackObj {
//
// Inline closure decls
//
class FollowRootClosure: public OopsInGenClosure {
+ MarkSweep* _ms;
public:
+ FollowRootClosure(MarkSweep* ms) : _ms(ms) {}
virtual void do_oop(oop* p);
virtual void do_oop(narrowOop* p);
};
class FollowStackClosure: public VoidClosure {
+ MarkSweep* _ms;
public:
+ FollowStackClosure(MarkSweep* ms) : _ms(ms) {}
virtual void do_void();
};
class AdjustPointerClosure: public OopsInGenClosure {
public:
*** 76,93 ****
--- 102,123 ----
debug_only(virtual bool should_verify_oops() { return false; })
};
// Used for java/lang/ref handling
class IsAliveClosure: public BoolObjectClosure {
+ MarkSweep* _ms;
public:
+ IsAliveClosure(MarkSweep* ms) : _ms(ms) {}
virtual bool do_object_b(oop p);
};
class KeepAliveClosure: public OopClosure {
+ MarkSweep* _ms;
protected:
template <class T> void do_oop_work(T* p);
public:
+ KeepAliveClosure(MarkSweep* ms) : _ms(ms) {}
virtual void do_oop(oop* p);
virtual void do_oop(narrowOop* p);
};
//
*** 104,206 ****
protected:
// Total invocations of a MarkSweep collection
static uint _total_invocations;
// Traversal stacks used during phase1
! static Stack<oop, mtGC> _marking_stack;
! static Stack<ObjArrayTask, mtGC> _objarray_stack;
// Space for storing/restoring mark word
! static Stack<markOop, mtGC> _preserved_mark_stack;
! static Stack<oop, mtGC> _preserved_oop_stack;
! static size_t _preserved_count;
! static size_t _preserved_count_max;
! static PreservedMark* _preserved_marks;
// Reference processing (used in ...follow_contents)
! static ReferenceProcessor* _ref_processor;
static STWGCTimer* _gc_timer;
static SerialOldTracer* _gc_tracer;
// Non public closures
! static KeepAliveClosure keep_alive;
public:
// Public closures
! static IsAliveClosure is_alive;
! static FollowRootClosure follow_root_closure;
! static MarkAndPushClosure mark_and_push_closure;
! static FollowStackClosure follow_stack_closure;
! static CLDToOopClosure follow_cld_closure;
! static AdjustPointerClosure adjust_pointer_closure;
! static CLDToOopClosure adjust_cld_closure;
// Accessors
static uint total_invocations() { return _total_invocations; }
// Reference Processing
! static ReferenceProcessor* const ref_processor() { return _ref_processor; }
! static void set_ref_processor(ReferenceProcessor* rp);
// Archive Object handling
static inline bool is_archive_object(oop object);
static STWGCTimer* gc_timer() { return _gc_timer; }
static SerialOldTracer* gc_tracer() { return _gc_tracer; }
! static void preserve_mark(oop p, markOop mark);
// Save the mark word so it can be restored later
! static void adjust_marks(); // Adjust the pointers in the preserved marks table
! static void restore_marks(); // Restore the marks that we saved in preserve_mark
! static int adjust_pointers(oop obj);
! static void follow_stack(); // Empty marking stack.
! static void follow_klass(Klass* klass);
! static void follow_cld(ClassLoaderData* cld);
template <class T> static inline void adjust_pointer(T* p);
// Check mark and maybe push on marking stack
! template <class T> static void mark_and_push(T* p);
private:
// Call backs for marking
! static void mark_object(oop obj);
// Mark pointer and follow contents. Empty marking stack afterwards.
! template <class T> static inline void follow_root(T* p);
!
! static inline void push_objarray(oop obj, size_t index);
! static void follow_object(oop obj);
! static void follow_array(objArrayOop array);
! static void follow_array_chunk(objArrayOop array, int index);
! };
! class MarkAndPushClosure: public ExtendedOopClosure {
! public:
! template <typename T> void do_oop_nv(T* p);
! virtual void do_oop(oop* p);
! virtual void do_oop(narrowOop* p);
!
! virtual bool do_metadata();
! bool do_metadata_nv();
!
! virtual void do_klass(Klass* k);
! void do_klass_nv(Klass* k);
!
! virtual void do_cld(ClassLoaderData* cld);
! void do_cld_nv(ClassLoaderData* cld);
!
! void set_ref_processor(ReferenceProcessor* rp) {
! set_ref_processor_internal(rp);
! }
};
class PreservedMark VALUE_OBJ_CLASS_SPEC {
private:
oop _obj;
--- 134,222 ----
protected:
// Total invocations of a MarkSweep collection
static uint _total_invocations;
// Traversal stacks used during phase1
! Stack<oop, mtGC> _marking_stack;
! Stack<ObjArrayTask, mtGC> _objarray_stack;
// Space for storing/restoring mark word
! Stack<markOop, mtGC> _preserved_mark_stack;
! Stack<oop, mtGC> _preserved_oop_stack;
! size_t _preserved_count;
! size_t _preserved_count_max;
! PreservedMark* _preserved_marks;
// Reference processing (used in ...follow_contents)
! ReferenceProcessor* _ref_processor;
static STWGCTimer* _gc_timer;
static SerialOldTracer* _gc_tracer;
// Non public closures
! KeepAliveClosure keep_alive;
public:
+ // Constructor
+ MarkSweep();
+
+ // Destructor
+ ~MarkSweep();
+
// Public closures
! IsAliveClosure is_alive;
! FollowRootClosure follow_root_closure;
! MarkAndPushClosure mark_and_push_closure;
! FollowStackClosure follow_stack_closure;
! CLDToOopClosure follow_cld_closure;
! AdjustPointerClosure adjust_pointer_closure;
! CLDToOopClosure adjust_cld_closure;
// Accessors
static uint total_invocations() { return _total_invocations; }
// Reference Processing
! ReferenceProcessor* const ref_processor() { return _ref_processor; }
! void set_ref_processor(ReferenceProcessor* rp);
// Archive Object handling
static inline bool is_archive_object(oop object);
static STWGCTimer* gc_timer() { return _gc_timer; }
static SerialOldTracer* gc_tracer() { return _gc_tracer; }
! void preserve_mark(oop p, markOop mark);
// Save the mark word so it can be restored later
! void adjust_marks(); // Adjust the pointers in the preserved marks table
! void restore_marks(); // Restore the marks that we saved in preserve_mark
! int adjust_pointers(oop obj);
! void follow_stack(); // Empty marking stack.
! void follow_klass(Klass* klass);
! void follow_cld(ClassLoaderData* cld);
template <class T> static inline void adjust_pointer(T* p);
// Check mark and maybe push on marking stack
! template <class T> void mark_and_push(T* p);
private:
// Call backs for marking
! void mark_object(oop obj);
// Mark pointer and follow contents. Empty marking stack afterwards.
! template <class T> inline void follow_root(T* p);
! inline void push_objarray(oop obj, size_t index);
! void follow_object(oop obj);
! void follow_array(objArrayOop array);
! void follow_array_chunk(objArrayOop array, int index);
};
class PreservedMark VALUE_OBJ_CLASS_SPEC {
private:
oop _obj;