src/share/vm/gc/serial/markSweep.cpp
Print this page
@@ -44,27 +44,36 @@
#include "gc/g1/g1StringDedup.hpp"
#endif // INCLUDE_ALL_GCS
uint MarkSweep::_total_invocations = 0;
-Stack<oop, mtGC> MarkSweep::_marking_stack;
-Stack<ObjArrayTask, mtGC> MarkSweep::_objarray_stack;
-
-Stack<oop, mtGC> MarkSweep::_preserved_oop_stack;
-Stack<markOop, mtGC> MarkSweep::_preserved_mark_stack;
-size_t MarkSweep::_preserved_count = 0;
-size_t MarkSweep::_preserved_count_max = 0;
-PreservedMark* MarkSweep::_preserved_marks = NULL;
-ReferenceProcessor* MarkSweep::_ref_processor = NULL;
STWGCTimer* MarkSweep::_gc_timer = NULL;
SerialOldTracer* MarkSweep::_gc_tracer = NULL;
-MarkSweep::FollowRootClosure MarkSweep::follow_root_closure;
+MarkSweep::MarkSweep() :
+ _marking_stack(),
+ _objarray_stack(),
+ _preserved_mark_stack(),
+ _preserved_oop_stack(),
+ _preserved_count(0),
+ _preserved_count_max(0),
+ _preserved_marks(NULL),
+ _ref_processor(NULL),
+ keep_alive(this),
+ is_alive(this),
+ follow_root_closure(this),
+ mark_and_push_closure(this),
+ follow_stack_closure(this),
+ follow_cld_closure(&mark_and_push_closure),
+ adjust_pointer_closure(),
+ adjust_cld_closure(&adjust_pointer_closure)
+{
+}
-MarkAndPushClosure MarkSweep::mark_and_push_closure;
-CLDToOopClosure MarkSweep::follow_cld_closure(&mark_and_push_closure);
-CLDToOopClosure MarkSweep::adjust_cld_closure(&adjust_pointer_closure);
+MarkSweep::~MarkSweep()
+{
+}
inline void MarkSweep::mark_object(oop obj) {
#if INCLUDE_ALL_GCS
if (G1StringDedup::is_enabled()) {
// We must enqueue the object before it is marked
@@ -94,52 +103,52 @@
}
}
inline void MarkSweep::follow_klass(Klass* klass) {
oop op = klass->klass_holder();
- MarkSweep::mark_and_push(&op);
+ mark_and_push(&op);
}
inline void MarkSweep::follow_cld(ClassLoaderData* cld) {
- MarkSweep::follow_cld_closure.do_cld(cld);
+ follow_cld_closure.do_cld(cld);
}
template <typename T>
-inline void MarkAndPushClosure::do_oop_nv(T* p) { MarkSweep::mark_and_push(p); }
+inline void MarkAndPushClosure::do_oop_nv(T* p) { _ms->mark_and_push(p); }
void MarkAndPushClosure::do_oop(oop* p) { do_oop_nv(p); }
void MarkAndPushClosure::do_oop(narrowOop* p) { do_oop_nv(p); }
inline bool MarkAndPushClosure::do_metadata_nv() { return true; }
bool MarkAndPushClosure::do_metadata() { return do_metadata_nv(); }
-inline void MarkAndPushClosure::do_klass_nv(Klass* k) { MarkSweep::follow_klass(k); }
+inline void MarkAndPushClosure::do_klass_nv(Klass* k) { _ms->follow_klass(k); }
void MarkAndPushClosure::do_klass(Klass* k) { do_klass_nv(k); }
-inline void MarkAndPushClosure::do_cld_nv(ClassLoaderData* cld) { MarkSweep::follow_cld(cld); }
+inline void MarkAndPushClosure::do_cld_nv(ClassLoaderData* cld) { _ms->follow_cld(cld); }
void MarkAndPushClosure::do_cld(ClassLoaderData* cld) { do_cld_nv(cld); }
template <class T> inline void MarkSweep::KeepAliveClosure::do_oop_work(T* p) {
- mark_and_push(p);
+ _ms->mark_and_push(p);
}
void MarkSweep::push_objarray(oop obj, size_t index) {
ObjArrayTask task(obj, index);
assert(task.is_valid(), "bad ObjArrayTask");
_objarray_stack.push(task);
}
inline void MarkSweep::follow_array(objArrayOop array) {
- MarkSweep::follow_klass(array->klass());
+ follow_klass(array->klass());
// Don't push empty arrays to avoid unnecessary work.
if (array->length() > 0) {
- MarkSweep::push_objarray(array, 0);
+ push_objarray(array, 0);
}
}
inline void MarkSweep::follow_object(oop obj) {
assert(obj->is_gc_marked(), "should be marked");
if (obj->is_objArray()) {
// Handle object arrays explicitly to allow them to
// be split into chunks if needed.
- MarkSweep::follow_array((objArrayOop)obj);
+ follow_array((objArrayOop)obj);
} else {
obj->oop_iterate(&mark_and_push_closure);
}
}
@@ -152,11 +161,11 @@
const int end_index = beg_index + stride;
array->oop_iterate_range(&mark_and_push_closure, beg_index, end_index);
if (end_index < len) {
- MarkSweep::push_objarray(array, end_index); // Push the continuation.
+ push_objarray(array, end_index); // Push the continuation.
}
}
void MarkSweep::follow_stack() {
do {
@@ -171,13 +180,11 @@
follow_array_chunk(objArrayOop(task.obj()), task.index());
}
} while (!_marking_stack.is_empty() || !_objarray_stack.is_empty());
}
-MarkSweep::FollowStackClosure MarkSweep::follow_stack_closure;
-
-void MarkSweep::FollowStackClosure::do_void() { follow_stack(); }
+void MarkSweep::FollowStackClosure::do_void() { _ms->follow_stack(); }
template <class T> inline void MarkSweep::follow_root(T* p) {
assert(!Universe::heap()->is_in_reserved(p),
"roots shouldn't be things within the heap");
T heap_oop = oopDesc::load_heap_oop(p);
@@ -190,12 +197,12 @@
}
}
follow_stack();
}
-void MarkSweep::FollowRootClosure::do_oop(oop* p) { follow_root(p); }
-void MarkSweep::FollowRootClosure::do_oop(narrowOop* p) { follow_root(p); }
+void MarkSweep::FollowRootClosure::do_oop(oop* p) { _ms->follow_root(p); }
+void MarkSweep::FollowRootClosure::do_oop(narrowOop* p) { _ms->follow_root(p); }
void PreservedMark::adjust_pointer() {
MarkSweep::adjust_pointer(&_obj);
}
@@ -222,12 +229,10 @@
void MarkSweep::set_ref_processor(ReferenceProcessor* rp) {
_ref_processor = rp;
mark_and_push_closure.set_ref_processor(_ref_processor);
}
-MarkSweep::AdjustPointerClosure MarkSweep::adjust_pointer_closure;
-
template <typename T>
void MarkSweep::AdjustPointerClosure::do_oop_nv(T* p) { adjust_pointer(p); }
void MarkSweep::AdjustPointerClosure::do_oop(oop* p) { do_oop_nv(p); }
void MarkSweep::AdjustPointerClosure::do_oop(narrowOop* p) { do_oop_nv(p); }
@@ -264,40 +269,36 @@
markOop mark = _preserved_mark_stack.pop();
obj->set_mark(mark);
}
}
-MarkSweep::IsAliveClosure MarkSweep::is_alive;
-
bool MarkSweep::IsAliveClosure::do_object_b(oop p) { return p->is_gc_marked() || is_archive_object(p); }
-MarkSweep::KeepAliveClosure MarkSweep::keep_alive;
-
-void MarkSweep::KeepAliveClosure::do_oop(oop* p) { MarkSweep::KeepAliveClosure::do_oop_work(p); }
-void MarkSweep::KeepAliveClosure::do_oop(narrowOop* p) { MarkSweep::KeepAliveClosure::do_oop_work(p); }
+void MarkSweep::KeepAliveClosure::do_oop(oop* p) { do_oop_work(p); }
+void MarkSweep::KeepAliveClosure::do_oop(narrowOop* p) { do_oop_work(p); }
void marksweep_init() {
MarkSweep::_gc_timer = new (ResourceObj::C_HEAP, mtGC) STWGCTimer();
MarkSweep::_gc_tracer = new (ResourceObj::C_HEAP, mtGC) SerialOldTracer();
}
-int InstanceKlass::oop_ms_adjust_pointers(oop obj) {
+int InstanceKlass::oop_ms_adjust_pointers(oop obj, MarkSweep* ms) {
int size = size_helper();
- oop_oop_iterate_oop_maps<true>(obj, &MarkSweep::adjust_pointer_closure);
+ oop_oop_iterate_oop_maps<true>(obj, &ms->adjust_pointer_closure);
return size;
}
-int InstanceMirrorKlass::oop_ms_adjust_pointers(oop obj) {
+int InstanceMirrorKlass::oop_ms_adjust_pointers(oop obj, MarkSweep* ms) {
int size = oop_size(obj);
- InstanceKlass::oop_ms_adjust_pointers(obj);
+ InstanceKlass::oop_ms_adjust_pointers(obj, ms);
- oop_oop_iterate_statics<true>(obj, &MarkSweep::adjust_pointer_closure);
+ oop_oop_iterate_statics<true>(obj, &ms->adjust_pointer_closure);
return size;
}
-int InstanceClassLoaderKlass::oop_ms_adjust_pointers(oop obj) {
- return InstanceKlass::oop_ms_adjust_pointers(obj);
+int InstanceClassLoaderKlass::oop_ms_adjust_pointers(oop obj, MarkSweep* ms) {
+ return InstanceKlass::oop_ms_adjust_pointers(obj, ms);
}
#ifdef ASSERT
template <class T> static void trace_reference_gc(const char *s, oop obj,
T* referent_addr,
@@ -322,33 +323,33 @@
MarkSweep::adjust_pointer(discovered_addr);
debug_only(trace_reference_gc("InstanceRefKlass::oop_ms_adjust_pointers", obj,
referent_addr, next_addr, discovered_addr);)
}
-int InstanceRefKlass::oop_ms_adjust_pointers(oop obj) {
+int InstanceRefKlass::oop_ms_adjust_pointers(oop obj, MarkSweep* ms) {
int size = size_helper();
- InstanceKlass::oop_ms_adjust_pointers(obj);
+ InstanceKlass::oop_ms_adjust_pointers(obj, ms);
if (UseCompressedOops) {
adjust_object_specialized<narrowOop>(obj);
} else {
adjust_object_specialized<oop>(obj);
}
return size;
}
-int ObjArrayKlass::oop_ms_adjust_pointers(oop obj) {
+int ObjArrayKlass::oop_ms_adjust_pointers(oop obj, MarkSweep* ms) {
assert(obj->is_objArray(), "obj must be obj array");
objArrayOop a = objArrayOop(obj);
// Get size before changing pointers.
// Don't call size() or oop_size() since that is a virtual call.
int size = a->object_size();
- oop_oop_iterate_elements<true>(a, &MarkSweep::adjust_pointer_closure);
+ oop_oop_iterate_elements<true>(a, &ms->adjust_pointer_closure);
return size;
}
-int TypeArrayKlass::oop_ms_adjust_pointers(oop obj) {
+int TypeArrayKlass::oop_ms_adjust_pointers(oop obj, MarkSweep* /* ms */) {
assert(obj->is_typeArray(), "must be a type array");
typeArrayOop t = typeArrayOop(obj);
// Performance tweak: We skip iterating over the klass pointer since we
// know that Universe::TypeArrayKlass never moves.
return t->object_size();