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 if (UseShenandoahGC) {
89 obj = ShenandoahBarrierSet::resolve_and_update_oop_static(p, obj);
90 }
91 if (!obj->mark()->is_marked() &&
92 !is_archive_object(obj)) {
93 mark_object(obj);
94 _marking_stack.push(obj);
95 }
96 }
97 }
98
99 inline void MarkSweep::follow_klass(Klass* klass) {
100 oop op = klass->klass_holder();
101 MarkSweep::mark_and_push(&op);
102 }
103
104 inline void MarkSweep::follow_cld(ClassLoaderData* cld) {
105 MarkSweep::follow_cld_closure.do_cld(cld);
106 }
107
108 template <typename T>
109 inline void MarkAndPushClosure::do_oop_nv(T* p) { MarkSweep::mark_and_push(p); }
110 void MarkAndPushClosure::do_oop(oop* p) { do_oop_nv(p); }
168 follow_object(obj);
169 }
170 // Process ObjArrays one at a time to avoid marking stack bloat.
171 if (!_objarray_stack.is_empty()) {
172 ObjArrayTask task = _objarray_stack.pop();
173 follow_array_chunk(objArrayOop(task.obj()), task.index());
174 }
175 } while (!_marking_stack.is_empty() || !_objarray_stack.is_empty());
176 }
177
178 MarkSweep::FollowStackClosure MarkSweep::follow_stack_closure;
179
180 void MarkSweep::FollowStackClosure::do_void() { follow_stack(); }
181
182 template <class T> inline void MarkSweep::follow_root(T* p) {
183 assert(!Universe::heap()->is_in_reserved(p),
184 "roots shouldn't be things within the heap");
185 T heap_oop = oopDesc::load_heap_oop(p);
186 if (!oopDesc::is_null(heap_oop)) {
187 oop obj = oopDesc::decode_heap_oop_not_null(heap_oop);
188 if (UseShenandoahGC) {
189 obj = ShenandoahBarrierSet::resolve_and_update_oop_static(p, obj);
190 }
191 if (!obj->mark()->is_marked() &&
192 !is_archive_object(obj)) {
193 mark_object(obj);
194 follow_object(obj);
195 }
196 }
197 follow_stack();
198 }
199
200 void MarkSweep::FollowRootClosure::do_oop(oop* p) { follow_root(p); }
201 void MarkSweep::FollowRootClosure::do_oop(narrowOop* p) { follow_root(p); }
202
203 void PreservedMark::adjust_pointer() {
204 MarkSweep::adjust_pointer(&_obj);
205 }
206
207 void PreservedMark::restore() {
208 _obj->set_mark(_mark);
209 }
210
|