68 if (G1StringDedup::is_enabled()) {
69 // We must enqueue the object before it is marked
70 // as we otherwise can't read the object's age.
71 G1StringDedup::enqueue_from_mark(obj);
72 }
73 #endif
74 // some marks may contain information we need to preserve so we store them away
75 // and overwrite the mark. We'll restore it at the end of markSweep.
76 markOop mark = obj->mark();
77 obj->set_mark(markOopDesc::prototype()->set_marked());
78
79 if (mark->must_be_preserved(obj)) {
80 preserve_mark(obj, mark);
81 }
82 }
83
84 template <class T> inline void MarkSweep::mark_and_push(T* p) {
85 T heap_oop = oopDesc::load_heap_oop(p);
86 if (!oopDesc::is_null(heap_oop)) {
87 oop obj = oopDesc::decode_heap_oop_not_null(heap_oop);
88 if (!obj->mark()->is_marked() &&
89 !is_archive_object(obj)) {
90 mark_object(obj);
91 _marking_stack.push(obj);
92 }
93 }
94 }
95
96 inline void MarkSweep::follow_klass(Klass* klass) {
97 oop op = klass->klass_holder();
98 MarkSweep::mark_and_push(&op);
99 }
100
101 inline void MarkSweep::follow_cld(ClassLoaderData* cld) {
102 MarkSweep::follow_cld_closure.do_cld(cld);
103 }
104
105 template <typename T>
106 inline void MarkAndPushClosure::do_oop_nv(T* p) { MarkSweep::mark_and_push(p); }
107 void MarkAndPushClosure::do_oop(oop* p) { do_oop_nv(p); }
165 follow_object(obj);
166 }
167 // Process ObjArrays one at a time to avoid marking stack bloat.
168 if (!_objarray_stack.is_empty()) {
169 ObjArrayTask task = _objarray_stack.pop();
170 follow_array_chunk(objArrayOop(task.obj()), task.index());
171 }
172 } while (!_marking_stack.is_empty() || !_objarray_stack.is_empty());
173 }
174
175 MarkSweep::FollowStackClosure MarkSweep::follow_stack_closure;
176
177 void MarkSweep::FollowStackClosure::do_void() { follow_stack(); }
178
179 template <class T> inline void MarkSweep::follow_root(T* p) {
180 assert(!Universe::heap()->is_in_reserved(p),
181 "roots shouldn't be things within the heap");
182 T heap_oop = oopDesc::load_heap_oop(p);
183 if (!oopDesc::is_null(heap_oop)) {
184 oop obj = oopDesc::decode_heap_oop_not_null(heap_oop);
185 if (!obj->mark()->is_marked() &&
186 !is_archive_object(obj)) {
187 mark_object(obj);
188 follow_object(obj);
189 }
190 }
191 follow_stack();
192 }
193
194 void MarkSweep::FollowRootClosure::do_oop(oop* p) { follow_root(p); }
195 void MarkSweep::FollowRootClosure::do_oop(narrowOop* p) { follow_root(p); }
196
197 void PreservedMark::adjust_pointer() {
198 MarkSweep::adjust_pointer(&_obj);
199 }
200
201 void PreservedMark::restore() {
202 _obj->set_mark(_mark);
203 }
204
|
68 if (G1StringDedup::is_enabled()) {
69 // We must enqueue the object before it is marked
70 // as we otherwise can't read the object's age.
71 G1StringDedup::enqueue_from_mark(obj);
72 }
73 #endif
74 // some marks may contain information we need to preserve so we store them away
75 // and overwrite the mark. We'll restore it at the end of markSweep.
76 markOop mark = obj->mark();
77 obj->set_mark(markOopDesc::prototype()->set_marked());
78
79 if (mark->must_be_preserved(obj)) {
80 preserve_mark(obj, mark);
81 }
82 }
83
84 template <class T> inline void MarkSweep::mark_and_push(T* p) {
85 T heap_oop = oopDesc::load_heap_oop(p);
86 if (!oopDesc::is_null(heap_oop)) {
87 oop obj = oopDesc::decode_heap_oop_not_null(heap_oop);
88 obj = oopDesc::bs()->resolve_and_update_oop(p, obj);
89 if (!obj->mark()->is_marked() &&
90 !is_archive_object(obj)) {
91 mark_object(obj);
92 _marking_stack.push(obj);
93 }
94 }
95 }
96
97 inline void MarkSweep::follow_klass(Klass* klass) {
98 oop op = klass->klass_holder();
99 MarkSweep::mark_and_push(&op);
100 }
101
102 inline void MarkSweep::follow_cld(ClassLoaderData* cld) {
103 MarkSweep::follow_cld_closure.do_cld(cld);
104 }
105
106 template <typename T>
107 inline void MarkAndPushClosure::do_oop_nv(T* p) { MarkSweep::mark_and_push(p); }
108 void MarkAndPushClosure::do_oop(oop* p) { do_oop_nv(p); }
166 follow_object(obj);
167 }
168 // Process ObjArrays one at a time to avoid marking stack bloat.
169 if (!_objarray_stack.is_empty()) {
170 ObjArrayTask task = _objarray_stack.pop();
171 follow_array_chunk(objArrayOop(task.obj()), task.index());
172 }
173 } while (!_marking_stack.is_empty() || !_objarray_stack.is_empty());
174 }
175
176 MarkSweep::FollowStackClosure MarkSweep::follow_stack_closure;
177
178 void MarkSweep::FollowStackClosure::do_void() { follow_stack(); }
179
180 template <class T> inline void MarkSweep::follow_root(T* p) {
181 assert(!Universe::heap()->is_in_reserved(p),
182 "roots shouldn't be things within the heap");
183 T heap_oop = oopDesc::load_heap_oop(p);
184 if (!oopDesc::is_null(heap_oop)) {
185 oop obj = oopDesc::decode_heap_oop_not_null(heap_oop);
186 obj = oopDesc::bs()->resolve_and_update_oop(p, obj);
187 if (!obj->mark()->is_marked() &&
188 !is_archive_object(obj)) {
189 mark_object(obj);
190 follow_object(obj);
191 }
192 }
193 follow_stack();
194 }
195
196 void MarkSweep::FollowRootClosure::do_oop(oop* p) { follow_root(p); }
197 void MarkSweep::FollowRootClosure::do_oop(narrowOop* p) { follow_root(p); }
198
199 void PreservedMark::adjust_pointer() {
200 MarkSweep::adjust_pointer(&_obj);
201 }
202
203 void PreservedMark::restore() {
204 _obj->set_mark(_mark);
205 }
206
|