89 assert(_heap->is_traversal_mode(), "Why we here?");
90 }
91
92 template <class T>
93 void ShenandoahTraversalUpdateRefsClosure::do_oop_work(T* p) {
94 T o = RawAccess<>::oop_load(p);
95 if (!CompressedOops::is_null(o)) {
96 oop obj = CompressedOops::decode_not_null(o);
97 if (_heap->in_collection_set(obj) || _traversal_set->is_in((HeapWord*)obj)) {
98 obj = ShenandoahBarrierSet::resolve_forwarded_not_null(obj);
99 RawAccess<IS_NOT_NULL>::oop_store(p, obj);
100 } else {
101 shenandoah_assert_not_forwarded(p, obj);
102 }
103 }
104 }
105
106 void ShenandoahTraversalUpdateRefsClosure::do_oop(oop* p) { do_oop_work(p); }
107 void ShenandoahTraversalUpdateRefsClosure::do_oop(narrowOop* p) { do_oop_work(p); }
108
109 ShenandoahEvacuateUpdateRootsClosure::ShenandoahEvacuateUpdateRootsClosure() :
110 _heap(ShenandoahHeap::heap()), _thread(Thread::current()) {
111 }
112
113 template <class T>
114 void ShenandoahEvacuateUpdateRootsClosure::do_oop_work(T* p) {
115 assert(_heap->is_concurrent_root_in_progress(), "Only do this when evacuation is in progress");
116
117 T o = RawAccess<>::oop_load(p);
118 if (! CompressedOops::is_null(o)) {
119 oop obj = CompressedOops::decode_not_null(o);
120 if (_heap->in_collection_set(obj)) {
121 assert(_heap->is_evacuation_in_progress(), "Only do this when evacuation is in progress");
122 shenandoah_assert_marked(p, obj);
123 oop resolved = ShenandoahBarrierSet::resolve_forwarded_not_null(obj);
124 if (resolved == obj) {
125 resolved = _heap->evacuate_object(obj, _thread);
126 }
127 RawAccess<IS_NOT_NULL>::oop_store(p, resolved);
128 }
129 }
130 }
131 void ShenandoahEvacuateUpdateRootsClosure::do_oop(oop* p) {
132 do_oop_work(p);
133 }
134
135 void ShenandoahEvacuateUpdateRootsClosure::do_oop(narrowOop* p) {
136 do_oop_work(p);
137 }
138
139 ShenandoahEvacUpdateOopStorageRootsClosure::ShenandoahEvacUpdateOopStorageRootsClosure() :
140 _heap(ShenandoahHeap::heap()), _thread(Thread::current()) {
141 }
142
143 void ShenandoahEvacUpdateOopStorageRootsClosure::do_oop(oop* p) {
144 assert(_heap->is_concurrent_root_in_progress(), "Only do this when evacuation is in progress");
145
146 oop obj = RawAccess<>::oop_load(p);
147 if (! CompressedOops::is_null(obj)) {
148 if (_heap->in_collection_set(obj)) {
149 assert(_heap->is_evacuation_in_progress(), "Only do this when evacuation is in progress");
150 shenandoah_assert_marked(p, obj);
151 oop resolved = ShenandoahBarrierSet::resolve_forwarded_not_null(obj);
152 if (resolved == obj) {
153 resolved = _heap->evacuate_object(obj, _thread);
154 }
155
|
89 assert(_heap->is_traversal_mode(), "Why we here?");
90 }
91
92 template <class T>
93 void ShenandoahTraversalUpdateRefsClosure::do_oop_work(T* p) {
94 T o = RawAccess<>::oop_load(p);
95 if (!CompressedOops::is_null(o)) {
96 oop obj = CompressedOops::decode_not_null(o);
97 if (_heap->in_collection_set(obj) || _traversal_set->is_in((HeapWord*)obj)) {
98 obj = ShenandoahBarrierSet::resolve_forwarded_not_null(obj);
99 RawAccess<IS_NOT_NULL>::oop_store(p, obj);
100 } else {
101 shenandoah_assert_not_forwarded(p, obj);
102 }
103 }
104 }
105
106 void ShenandoahTraversalUpdateRefsClosure::do_oop(oop* p) { do_oop_work(p); }
107 void ShenandoahTraversalUpdateRefsClosure::do_oop(narrowOop* p) { do_oop_work(p); }
108
109 template <DecoratorSet MO>
110 ShenandoahEvacuateUpdateRootsClosure<MO>::ShenandoahEvacuateUpdateRootsClosure() :
111 _heap(ShenandoahHeap::heap()), _thread(Thread::current()) {
112 }
113
114 template <DecoratorSet MO>
115 template <class T>
116 void ShenandoahEvacuateUpdateRootsClosure<MO>::do_oop_work(T* p) {
117 assert(_heap->is_concurrent_root_in_progress(), "Only do this when evacuation is in progress");
118
119 T o = RawAccess<>::oop_load(p);
120 if (! CompressedOops::is_null(o)) {
121 oop obj = CompressedOops::decode_not_null(o);
122 if (_heap->in_collection_set(obj)) {
123 assert(_heap->is_evacuation_in_progress(), "Only do this when evacuation is in progress");
124 shenandoah_assert_marked(p, obj);
125 oop resolved = ShenandoahBarrierSet::resolve_forwarded_not_null(obj);
126 if (resolved == obj) {
127 resolved = _heap->evacuate_object(obj, _thread);
128 }
129 RawAccess<IS_NOT_NULL | MO>::oop_store(p, resolved);
130 }
131 }
132 }
133 template <DecoratorSet MO>
134 void ShenandoahEvacuateUpdateRootsClosure<MO>::do_oop(oop* p) {
135 do_oop_work(p);
136 }
137
138 template <DecoratorSet MO>
139 void ShenandoahEvacuateUpdateRootsClosure<MO>::do_oop(narrowOop* p) {
140 do_oop_work(p);
141 }
142
143 ShenandoahEvacUpdateOopStorageRootsClosure::ShenandoahEvacUpdateOopStorageRootsClosure() :
144 _heap(ShenandoahHeap::heap()), _thread(Thread::current()) {
145 }
146
147 void ShenandoahEvacUpdateOopStorageRootsClosure::do_oop(oop* p) {
148 assert(_heap->is_concurrent_root_in_progress(), "Only do this when evacuation is in progress");
149
150 oop obj = RawAccess<>::oop_load(p);
151 if (! CompressedOops::is_null(obj)) {
152 if (_heap->in_collection_set(obj)) {
153 assert(_heap->is_evacuation_in_progress(), "Only do this when evacuation is in progress");
154 shenandoah_assert_marked(p, obj);
155 oop resolved = ShenandoahBarrierSet::resolve_forwarded_not_null(obj);
156 if (resolved == obj) {
157 resolved = _heap->evacuate_object(obj, _thread);
158 }
159
|