src/share/vm/gc/serial/markSweep.cpp
Print this page
*** 44,70 ****
#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;
! MarkAndPushClosure MarkSweep::mark_and_push_closure;
! CLDToOopClosure MarkSweep::follow_cld_closure(&mark_and_push_closure);
! CLDToOopClosure MarkSweep::adjust_cld_closure(&adjust_pointer_closure);
inline void MarkSweep::mark_object(oop obj) {
#if INCLUDE_ALL_GCS
if (G1StringDedup::is_enabled()) {
// We must enqueue the object before it is marked
--- 44,79 ----
#include "gc/g1/g1StringDedup.hpp"
#endif // INCLUDE_ALL_GCS
uint MarkSweep::_total_invocations = 0;
STWGCTimer* MarkSweep::_gc_timer = NULL;
SerialOldTracer* MarkSweep::_gc_tracer = NULL;
! 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)
! {
! }
! 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,145 ****
}
}
inline void MarkSweep::follow_klass(Klass* klass) {
oop op = klass->klass_holder();
! MarkSweep::mark_and_push(&op);
}
inline void MarkSweep::follow_cld(ClassLoaderData* cld) {
! MarkSweep::follow_cld_closure.do_cld(cld);
}
template <typename T>
! inline void MarkAndPushClosure::do_oop_nv(T* p) { MarkSweep::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); }
void MarkAndPushClosure::do_klass(Klass* k) { do_klass_nv(k); }
! inline void MarkAndPushClosure::do_cld_nv(ClassLoaderData* cld) { MarkSweep::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);
}
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());
// Don't push empty arrays to avoid unnecessary work.
if (array->length() > 0) {
! MarkSweep::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);
} else {
obj->oop_iterate(&mark_and_push_closure);
}
}
--- 103,154 ----
}
}
inline void MarkSweep::follow_klass(Klass* klass) {
oop op = klass->klass_holder();
! mark_and_push(&op);
}
inline void MarkSweep::follow_cld(ClassLoaderData* cld) {
! follow_cld_closure.do_cld(cld);
}
template <typename T>
! 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) { _ms->follow_klass(k); }
void MarkAndPushClosure::do_klass(Klass* k) { do_klass_nv(k); }
! 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) {
! _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) {
! follow_klass(array->klass());
// Don't push empty arrays to avoid unnecessary work.
if (array->length() > 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.
! follow_array((objArrayOop)obj);
} else {
obj->oop_iterate(&mark_and_push_closure);
}
}
*** 152,162 ****
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.
}
}
void MarkSweep::follow_stack() {
do {
--- 161,171 ----
const int end_index = beg_index + stride;
array->oop_iterate_range(&mark_and_push_closure, beg_index, end_index);
if (end_index < len) {
! push_objarray(array, end_index); // Push the continuation.
}
}
void MarkSweep::follow_stack() {
do {
*** 171,183 ****
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(); }
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);
--- 180,190 ----
follow_array_chunk(objArrayOop(task.obj()), task.index());
}
} while (!_marking_stack.is_empty() || !_objarray_stack.is_empty());
}
! 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,201 ****
}
}
follow_stack();
}
! void MarkSweep::FollowRootClosure::do_oop(oop* p) { follow_root(p); }
! void MarkSweep::FollowRootClosure::do_oop(narrowOop* p) { follow_root(p); }
void PreservedMark::adjust_pointer() {
MarkSweep::adjust_pointer(&_obj);
}
--- 197,208 ----
}
}
follow_stack();
}
! 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,233 ****
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); }
--- 229,238 ----
*** 264,303 ****
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_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 size = size_helper();
! oop_oop_iterate_oop_maps<true>(obj, &MarkSweep::adjust_pointer_closure);
return size;
}
! int InstanceMirrorKlass::oop_ms_adjust_pointers(oop obj) {
int size = oop_size(obj);
! InstanceKlass::oop_ms_adjust_pointers(obj);
! oop_oop_iterate_statics<true>(obj, &MarkSweep::adjust_pointer_closure);
return size;
}
! int InstanceClassLoaderKlass::oop_ms_adjust_pointers(oop obj) {
! return InstanceKlass::oop_ms_adjust_pointers(obj);
}
#ifdef ASSERT
template <class T> static void trace_reference_gc(const char *s, oop obj,
T* referent_addr,
--- 269,304 ----
markOop mark = _preserved_mark_stack.pop();
obj->set_mark(mark);
}
}
bool MarkSweep::IsAliveClosure::do_object_b(oop p) { return p->is_gc_marked() || is_archive_object(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, MarkSweep* ms) {
int size = size_helper();
! oop_oop_iterate_oop_maps<true>(obj, &ms->adjust_pointer_closure);
return size;
}
! int InstanceMirrorKlass::oop_ms_adjust_pointers(oop obj, MarkSweep* ms) {
int size = oop_size(obj);
! InstanceKlass::oop_ms_adjust_pointers(obj, ms);
! oop_oop_iterate_statics<true>(obj, &ms->adjust_pointer_closure);
return size;
}
! 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,354 ****
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 size = size_helper();
! InstanceKlass::oop_ms_adjust_pointers(obj);
if (UseCompressedOops) {
adjust_object_specialized<narrowOop>(obj);
} else {
adjust_object_specialized<oop>(obj);
}
return size;
}
! int ObjArrayKlass::oop_ms_adjust_pointers(oop obj) {
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);
return size;
}
! int TypeArrayKlass::oop_ms_adjust_pointers(oop obj) {
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();
--- 323,355 ----
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, MarkSweep* ms) {
int size = size_helper();
! 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, 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, &ms->adjust_pointer_closure);
return size;
}
! 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();