23 */ |
23 */ |
24 |
24 |
25 #include "precompiled.hpp" |
25 #include "precompiled.hpp" |
26 #include "compiler/compileBroker.hpp" |
26 #include "compiler/compileBroker.hpp" |
27 #include "gc/serial/markSweep.inline.hpp" |
27 #include "gc/serial/markSweep.inline.hpp" |
28 #include "gc/serial/serial_specialized_oop_closures.hpp" |
|
29 #include "gc/shared/collectedHeap.inline.hpp" |
28 #include "gc/shared/collectedHeap.inline.hpp" |
30 #include "gc/shared/gcTimer.hpp" |
29 #include "gc/shared/gcTimer.hpp" |
31 #include "gc/shared/gcTrace.hpp" |
30 #include "gc/shared/gcTrace.hpp" |
32 #include "memory/iterator.inline.hpp" |
31 #include "memory/iterator.inline.hpp" |
33 #include "oops/access.inline.hpp" |
32 #include "oops/access.inline.hpp" |
61 |
60 |
62 MarkAndPushClosure MarkSweep::mark_and_push_closure; |
61 MarkAndPushClosure MarkSweep::mark_and_push_closure; |
63 CLDToOopClosure MarkSweep::follow_cld_closure(&mark_and_push_closure); |
62 CLDToOopClosure MarkSweep::follow_cld_closure(&mark_and_push_closure); |
64 CLDToOopClosure MarkSweep::adjust_cld_closure(&adjust_pointer_closure); |
63 CLDToOopClosure MarkSweep::adjust_cld_closure(&adjust_pointer_closure); |
65 |
64 |
66 inline void MarkSweep::mark_object(oop obj) { |
|
67 // some marks may contain information we need to preserve so we store them away |
|
68 // and overwrite the mark. We'll restore it at the end of markSweep. |
|
69 markOop mark = obj->mark_raw(); |
|
70 obj->set_mark_raw(markOopDesc::prototype()->set_marked()); |
|
71 |
|
72 if (mark->must_be_preserved(obj)) { |
|
73 preserve_mark(obj, mark); |
|
74 } |
|
75 } |
|
76 |
|
77 template <class T> inline void MarkSweep::mark_and_push(T* p) { |
|
78 T heap_oop = RawAccess<>::oop_load(p); |
|
79 if (!CompressedOops::is_null(heap_oop)) { |
|
80 oop obj = CompressedOops::decode_not_null(heap_oop); |
|
81 if (!obj->mark_raw()->is_marked()) { |
|
82 mark_object(obj); |
|
83 _marking_stack.push(obj); |
|
84 } |
|
85 } |
|
86 } |
|
87 |
|
88 inline void MarkSweep::follow_klass(Klass* klass) { |
|
89 oop op = klass->klass_holder(); |
|
90 MarkSweep::mark_and_push(&op); |
|
91 } |
|
92 |
|
93 inline void MarkSweep::follow_cld(ClassLoaderData* cld) { |
|
94 MarkSweep::follow_cld_closure.do_cld(cld); |
|
95 } |
|
96 |
|
97 template <typename T> |
|
98 inline void MarkAndPushClosure::do_oop_nv(T* p) { MarkSweep::mark_and_push(p); } |
|
99 void MarkAndPushClosure::do_oop(oop* p) { do_oop_nv(p); } |
|
100 void MarkAndPushClosure::do_oop(narrowOop* p) { do_oop_nv(p); } |
|
101 inline bool MarkAndPushClosure::do_metadata_nv() { return true; } |
|
102 bool MarkAndPushClosure::do_metadata() { return do_metadata_nv(); } |
|
103 inline void MarkAndPushClosure::do_klass_nv(Klass* k) { MarkSweep::follow_klass(k); } |
|
104 void MarkAndPushClosure::do_klass(Klass* k) { do_klass_nv(k); } |
|
105 inline void MarkAndPushClosure::do_cld_nv(ClassLoaderData* cld) { MarkSweep::follow_cld(cld); } |
|
106 void MarkAndPushClosure::do_cld(ClassLoaderData* cld) { do_cld_nv(cld); } |
|
107 |
|
108 template <class T> inline void MarkSweep::KeepAliveClosure::do_oop_work(T* p) { |
65 template <class T> inline void MarkSweep::KeepAliveClosure::do_oop_work(T* p) { |
109 mark_and_push(p); |
66 mark_and_push(p); |
110 } |
67 } |
111 |
68 |
112 void MarkSweep::push_objarray(oop obj, size_t index) { |
69 void MarkSweep::push_objarray(oop obj, size_t index) { |
214 mark_and_push_closure.set_ref_discoverer(_ref_processor); |
171 mark_and_push_closure.set_ref_discoverer(_ref_processor); |
215 } |
172 } |
216 |
173 |
217 AdjustPointerClosure MarkSweep::adjust_pointer_closure; |
174 AdjustPointerClosure MarkSweep::adjust_pointer_closure; |
218 |
175 |
219 template <typename T> |
|
220 void AdjustPointerClosure::do_oop_nv(T* p) { MarkSweep::adjust_pointer(p); } |
|
221 void AdjustPointerClosure::do_oop(oop* p) { do_oop_nv(p); } |
|
222 void AdjustPointerClosure::do_oop(narrowOop* p) { do_oop_nv(p); } |
|
223 |
|
224 void MarkSweep::adjust_marks() { |
176 void MarkSweep::adjust_marks() { |
225 assert( _preserved_oop_stack.size() == _preserved_mark_stack.size(), |
177 assert( _preserved_oop_stack.size() == _preserved_mark_stack.size(), |
226 "inconsistent preserved oop stacks"); |
178 "inconsistent preserved oop stacks"); |
227 |
179 |
228 // adjust the oops we saved earlier |
180 // adjust the oops we saved earlier |
267 |
219 |
268 void MarkSweep::initialize() { |
220 void MarkSweep::initialize() { |
269 MarkSweep::_gc_timer = new (ResourceObj::C_HEAP, mtGC) STWGCTimer(); |
221 MarkSweep::_gc_timer = new (ResourceObj::C_HEAP, mtGC) STWGCTimer(); |
270 MarkSweep::_gc_tracer = new (ResourceObj::C_HEAP, mtGC) SerialOldTracer(); |
222 MarkSweep::_gc_tracer = new (ResourceObj::C_HEAP, mtGC) SerialOldTracer(); |
271 } |
223 } |
272 |
|
273 // Generate MS specialized oop_oop_iterate functions. |
|
274 SPECIALIZED_OOP_OOP_ITERATE_CLOSURES_MS(ALL_KLASS_OOP_OOP_ITERATE_DEFN) |
|