113 StringDedup::gc_prologue(false);
114 }
115 }
116
117 ShenandoahStringDedupRoots::~ShenandoahStringDedupRoots() {
118 if (ShenandoahStringDedup::is_enabled()) {
119 StringDedup::gc_epilogue();
120 }
121 }
122
123 void ShenandoahStringDedupRoots::oops_do(BoolObjectClosure* is_alive, OopClosure* keep_alive, uint worker_id) {
124 if (ShenandoahStringDedup::is_enabled()) {
125 ShenandoahStringDedup::parallel_oops_do(is_alive, keep_alive, worker_id);
126 }
127 }
128
129 ShenandoahClassLoaderDataRoots::ShenandoahClassLoaderDataRoots() {
130 ClassLoaderDataGraph::clear_claimed_marks();
131 }
132
133 void ShenandoahClassLoaderDataRoots::clds_do(CLDClosure* strong_clds, CLDClosure* weak_clds, uint worker_id) {
134 ShenandoahWorkerTimings* worker_times = ShenandoahHeap::heap()->phase_timings()->worker_times();
135 ShenandoahWorkerTimingsTracker timer(worker_times, ShenandoahPhaseTimings::CLDGRoots, worker_id);
136 ClassLoaderDataGraph::roots_cld_do(strong_clds, weak_clds);
137 }
138
139 ShenandoahRootProcessor::ShenandoahRootProcessor(ShenandoahPhaseTimings::Phase phase) :
140 _heap(ShenandoahHeap::heap()),
141 _phase(phase) {
142 assert(SafepointSynchronize::is_at_safepoint(), "Must at safepoint");
143 _heap->phase_timings()->record_workers_start(_phase);
144 }
145
146 ShenandoahRootProcessor::~ShenandoahRootProcessor() {
147 assert(SafepointSynchronize::is_at_safepoint(), "Must at safepoint");
148 _heap->phase_timings()->record_workers_end(_phase);
149 }
150
151 ShenandoahRootEvacuator::ShenandoahRootEvacuator(uint n_workers, ShenandoahPhaseTimings::Phase phase) :
152 ShenandoahRootProcessor(phase),
153 _thread_roots(n_workers > 1),
154 _weak_roots(n_workers) {
155 }
156
157 void ShenandoahRootEvacuator::roots_do(uint worker_id, OopClosure* oops) {
158 MarkingCodeBlobClosure blobsCl(oops, CodeBlobToOopClosure::FixRelocations);
159 CLDToOopClosure clds(oops, ClassLoaderData::_claim_strong);
160 CLDToOopClosure* weak_clds = ShenandoahHeap::heap()->unload_classes() ? NULL : &clds;
161
162 AlwaysTrueClosure always_true;
163
164 _serial_roots.oops_do(oops, worker_id);
165 _jni_roots.oops_do(oops, worker_id);
166
167 _thread_roots.oops_do(oops, NULL, worker_id);
168 _cld_roots.clds_do(&clds, &clds, worker_id);
169 _code_roots.code_blobs_do(&blobsCl, worker_id);
170
171 _weak_roots.oops_do<AlwaysTrueClosure, OopClosure>(&always_true, oops, worker_id);
172 _dedup_roots.oops_do(&always_true, oops, worker_id);
173 }
174
175 ShenandoahRootUpdater::ShenandoahRootUpdater(uint n_workers, ShenandoahPhaseTimings::Phase phase, bool update_code_cache) :
176 ShenandoahRootProcessor(phase),
177 _thread_roots(n_workers > 1),
178 _weak_roots(n_workers),
179 _update_code_cache(update_code_cache) {
180 }
181
182 ShenandoahRootAdjuster::ShenandoahRootAdjuster(uint n_workers, ShenandoahPhaseTimings::Phase phase) :
183 ShenandoahRootProcessor(phase),
184 _thread_roots(n_workers > 1),
185 _weak_roots(n_workers) {
186 assert(ShenandoahHeap::heap()->is_full_gc_in_progress(), "Full GC only");
187 }
188
189 void ShenandoahRootAdjuster::roots_do(uint worker_id, OopClosure* oops) {
190 CodeBlobToOopClosure adjust_code_closure(oops, CodeBlobToOopClosure::FixRelocations);
191 CLDToOopClosure adjust_cld_closure(oops, ClassLoaderData::_claim_strong);
192 AlwaysTrueClosure always_true;
193
194 _serial_roots.oops_do(oops, worker_id);
195 _jni_roots.oops_do(oops, worker_id);
196
197 _thread_roots.oops_do(oops, NULL, worker_id);
198 _cld_roots.clds_do(&adjust_cld_closure, NULL, worker_id);
199 _code_roots.code_blobs_do(&adjust_code_closure, worker_id);
200
201 _weak_roots.oops_do<AlwaysTrueClosure, OopClosure>(&always_true, oops, worker_id);
202 _dedup_roots.oops_do(&always_true, oops, worker_id);
203 }
|
113 StringDedup::gc_prologue(false);
114 }
115 }
116
117 ShenandoahStringDedupRoots::~ShenandoahStringDedupRoots() {
118 if (ShenandoahStringDedup::is_enabled()) {
119 StringDedup::gc_epilogue();
120 }
121 }
122
123 void ShenandoahStringDedupRoots::oops_do(BoolObjectClosure* is_alive, OopClosure* keep_alive, uint worker_id) {
124 if (ShenandoahStringDedup::is_enabled()) {
125 ShenandoahStringDedup::parallel_oops_do(is_alive, keep_alive, worker_id);
126 }
127 }
128
129 ShenandoahClassLoaderDataRoots::ShenandoahClassLoaderDataRoots() {
130 ClassLoaderDataGraph::clear_claimed_marks();
131 }
132
133 void ShenandoahClassLoaderDataRoots::always_strong_cld_do(CLDClosure* clds, uint worker_id) {
134 ShenandoahWorkerTimings* worker_times = ShenandoahHeap::heap()->phase_timings()->worker_times();
135 ShenandoahWorkerTimingsTracker timer(worker_times, ShenandoahPhaseTimings::CLDGRoots, worker_id);
136 ClassLoaderDataGraph::always_strong_cld_do(clds);
137 }
138
139 void ShenandoahClassLoaderDataRoots::cld_do(CLDClosure* clds, uint worker_id) {
140 ShenandoahWorkerTimings* worker_times = ShenandoahHeap::heap()->phase_timings()->worker_times();
141 ShenandoahWorkerTimingsTracker timer(worker_times, ShenandoahPhaseTimings::CLDGRoots, worker_id);
142 ClassLoaderDataGraph::cld_do(clds);
143 }
144
145 ShenandoahRootProcessor::ShenandoahRootProcessor(ShenandoahPhaseTimings::Phase phase) :
146 _heap(ShenandoahHeap::heap()),
147 _phase(phase) {
148 assert(SafepointSynchronize::is_at_safepoint(), "Must at safepoint");
149 _heap->phase_timings()->record_workers_start(_phase);
150 }
151
152 ShenandoahRootProcessor::~ShenandoahRootProcessor() {
153 assert(SafepointSynchronize::is_at_safepoint(), "Must at safepoint");
154 _heap->phase_timings()->record_workers_end(_phase);
155 }
156
157 ShenandoahRootEvacuator::ShenandoahRootEvacuator(uint n_workers, ShenandoahPhaseTimings::Phase phase) :
158 ShenandoahRootProcessor(phase),
159 _thread_roots(n_workers > 1),
160 _weak_roots(n_workers) {
161 }
162
163 void ShenandoahRootEvacuator::roots_do(uint worker_id, OopClosure* oops) {
164 MarkingCodeBlobClosure blobsCl(oops, CodeBlobToOopClosure::FixRelocations);
165 CLDToOopClosure clds(oops, ClassLoaderData::_claim_strong);
166 CLDToOopClosure* weak_clds = ShenandoahHeap::heap()->unload_classes() ? NULL : &clds;
167
168 AlwaysTrueClosure always_true;
169
170 _serial_roots.oops_do(oops, worker_id);
171 _jni_roots.oops_do(oops, worker_id);
172
173 _thread_roots.oops_do(oops, NULL, worker_id);
174 _cld_roots.cld_do(&clds, worker_id);
175 _code_roots.code_blobs_do(&blobsCl, worker_id);
176
177 _weak_roots.oops_do<AlwaysTrueClosure, OopClosure>(&always_true, oops, worker_id);
178 _dedup_roots.oops_do(&always_true, oops, worker_id);
179 }
180
181 ShenandoahRootUpdater::ShenandoahRootUpdater(uint n_workers, ShenandoahPhaseTimings::Phase phase, bool update_code_cache) :
182 ShenandoahRootProcessor(phase),
183 _thread_roots(n_workers > 1),
184 _weak_roots(n_workers),
185 _update_code_cache(update_code_cache) {
186 }
187
188 ShenandoahRootAdjuster::ShenandoahRootAdjuster(uint n_workers, ShenandoahPhaseTimings::Phase phase) :
189 ShenandoahRootProcessor(phase),
190 _thread_roots(n_workers > 1),
191 _weak_roots(n_workers) {
192 assert(ShenandoahHeap::heap()->is_full_gc_in_progress(), "Full GC only");
193 }
194
195 void ShenandoahRootAdjuster::roots_do(uint worker_id, OopClosure* oops) {
196 CodeBlobToOopClosure adjust_code_closure(oops, CodeBlobToOopClosure::FixRelocations);
197 CLDToOopClosure adjust_cld_closure(oops, ClassLoaderData::_claim_strong);
198 AlwaysTrueClosure always_true;
199
200 _serial_roots.oops_do(oops, worker_id);
201 _jni_roots.oops_do(oops, worker_id);
202
203 _thread_roots.oops_do(oops, NULL, worker_id);
204 _cld_roots.cld_do(&adjust_cld_closure, worker_id);
205 _code_roots.code_blobs_do(&adjust_code_closure, worker_id);
206
207 _weak_roots.oops_do<AlwaysTrueClosure, OopClosure>(&always_true, oops, worker_id);
208 _dedup_roots.oops_do(&always_true, oops, worker_id);
209 }
|