209
210 template <typename ITR>
211 void ShenandoahRootScanner<ITR>::roots_do(uint worker_id, OopClosure* oops) {
212 CLDToOopClosure clds_cl(oops, ClassLoaderData::_claim_strong);
213 MarkingCodeBlobClosure blobs_cl(oops, !CodeBlobToOopClosure::FixRelocations);
214 roots_do(worker_id, oops, &clds_cl, &blobs_cl);
215 }
216
217 template <typename ITR>
218 void ShenandoahRootScanner<ITR>::strong_roots_do(uint worker_id, OopClosure* oops) {
219 CLDToOopClosure clds_cl(oops, ClassLoaderData::_claim_strong);
220 MarkingCodeBlobClosure blobs_cl(oops, !CodeBlobToOopClosure::FixRelocations);
221 strong_roots_do(worker_id, oops, &clds_cl, &blobs_cl);
222 }
223
224 template <typename ITR>
225 void ShenandoahRootScanner<ITR>::roots_do(uint worker_id, OopClosure* oops, CLDClosure* clds, CodeBlobClosure* code, ThreadClosure *tc) {
226 assert(!ShenandoahSafepoint::is_at_shenandoah_safepoint() ||
227 !ShenandoahHeap::heap()->unload_classes(),
228 "Expect class unloading when Shenandoah cycle is running");
229 ResourceMark rm;
230
231 _serial_roots.oops_do(oops, worker_id);
232 _vm_roots.oops_do(oops, worker_id);
233
234 assert(clds != NULL, "Only possible with CLD closure");
235 _cld_roots.cld_do(clds, worker_id);
236
237 ShenandoahParallelOopsDoThreadClosure tc_cl(oops, code, tc);
238 _thread_roots.threads_do(&tc_cl, worker_id);
239
240 AlwaysTrueClosure always_true;
241 _dedup_roots.oops_do(&always_true, oops, worker_id);
242 }
243
244 template <typename ITR>
245 void ShenandoahRootScanner<ITR>::strong_roots_do(uint worker_id, OopClosure* oops, CLDClosure* clds, CodeBlobClosure* code, ThreadClosure* tc) {
246 assert(ShenandoahHeap::heap()->unload_classes(), "Should be used during class unloading");
247 ShenandoahParallelOopsDoThreadClosure tc_cl(oops, code, tc);
248 ResourceMark rm;
249
250 _serial_roots.oops_do(oops, worker_id);
251 _vm_roots.oops_do(oops, worker_id);
252 _cld_roots.always_strong_cld_do(clds, worker_id);
253 _thread_roots.threads_do(&tc_cl, worker_id);
254 }
255
256 template <typename IsAlive, typename KeepAlive>
257 void ShenandoahRootUpdater::roots_do(uint worker_id, IsAlive* is_alive, KeepAlive* keep_alive) {
258 CodeBlobToOopClosure update_blobs(keep_alive, CodeBlobToOopClosure::FixRelocations);
259 ShenandoahCodeBlobAndDisarmClosure blobs_and_disarm_Cl(keep_alive);
260 CodeBlobToOopClosure* codes_cl = ShenandoahConcurrentRoots::can_do_concurrent_class_unloading() ?
261 static_cast<CodeBlobToOopClosure*>(&blobs_and_disarm_Cl) :
262 static_cast<CodeBlobToOopClosure*>(&update_blobs);
263
264 CLDToOopClosure clds(keep_alive, ClassLoaderData::_claim_strong);
265
266 _serial_roots.oops_do(keep_alive, worker_id);
267 _vm_roots.oops_do(keep_alive, worker_id);
268
269 _cld_roots.cld_do(&clds, worker_id);
270 _code_roots.code_blobs_do(codes_cl, worker_id);
271 _thread_roots.oops_do(keep_alive, NULL, worker_id);
272
273 _serial_weak_roots.weak_oops_do(is_alive, keep_alive, worker_id);
274 _weak_roots.weak_oops_do(is_alive, keep_alive, worker_id);
275 _dedup_roots.oops_do(is_alive, keep_alive, worker_id);
276 }
277
278 #endif // SHARE_GC_SHENANDOAH_SHENANDOAHROOTPROCESSOR_INLINE_HPP
|
209
210 template <typename ITR>
211 void ShenandoahRootScanner<ITR>::roots_do(uint worker_id, OopClosure* oops) {
212 CLDToOopClosure clds_cl(oops, ClassLoaderData::_claim_strong);
213 MarkingCodeBlobClosure blobs_cl(oops, !CodeBlobToOopClosure::FixRelocations);
214 roots_do(worker_id, oops, &clds_cl, &blobs_cl);
215 }
216
217 template <typename ITR>
218 void ShenandoahRootScanner<ITR>::strong_roots_do(uint worker_id, OopClosure* oops) {
219 CLDToOopClosure clds_cl(oops, ClassLoaderData::_claim_strong);
220 MarkingCodeBlobClosure blobs_cl(oops, !CodeBlobToOopClosure::FixRelocations);
221 strong_roots_do(worker_id, oops, &clds_cl, &blobs_cl);
222 }
223
224 template <typename ITR>
225 void ShenandoahRootScanner<ITR>::roots_do(uint worker_id, OopClosure* oops, CLDClosure* clds, CodeBlobClosure* code, ThreadClosure *tc) {
226 assert(!ShenandoahSafepoint::is_at_shenandoah_safepoint() ||
227 !ShenandoahHeap::heap()->unload_classes(),
228 "Expect class unloading when Shenandoah cycle is running");
229 assert(clds != NULL, "Only possible with CLD closure");
230
231 AlwaysTrueClosure always_true;
232 ShenandoahParallelOopsDoThreadClosure tc_cl(oops, code, tc);
233
234 ResourceMark rm;
235
236 // Process serial-claiming roots first
237 _serial_roots.oops_do(oops, worker_id);
238
239 // Process light-weight/limited parallel roots then
240 _vm_roots.oops_do(oops, worker_id);
241 _dedup_roots.oops_do(&always_true, oops, worker_id);
242
243 // Process heavy-weight/fully parallel roots the last
244 _cld_roots.cld_do(clds, worker_id);
245 _thread_roots.threads_do(&tc_cl, worker_id);
246 }
247
248 template <typename ITR>
249 void ShenandoahRootScanner<ITR>::strong_roots_do(uint worker_id, OopClosure* oops, CLDClosure* clds, CodeBlobClosure* code, ThreadClosure* tc) {
250 assert(ShenandoahHeap::heap()->unload_classes(), "Should be used during class unloading");
251 ShenandoahParallelOopsDoThreadClosure tc_cl(oops, code, tc);
252 ResourceMark rm;
253
254 // Process serial-claiming roots first
255 _serial_roots.oops_do(oops, worker_id);
256
257 // Process light-weight/limited parallel roots then
258 _vm_roots.oops_do(oops, worker_id);
259
260 // Process heavy-weight/fully parallel roots the last
261 _cld_roots.always_strong_cld_do(clds, worker_id);
262 _thread_roots.threads_do(&tc_cl, worker_id);
263 }
264
265 template <typename IsAlive, typename KeepAlive>
266 void ShenandoahRootUpdater::roots_do(uint worker_id, IsAlive* is_alive, KeepAlive* keep_alive) {
267 CodeBlobToOopClosure update_blobs(keep_alive, CodeBlobToOopClosure::FixRelocations);
268 ShenandoahCodeBlobAndDisarmClosure blobs_and_disarm_Cl(keep_alive);
269 CodeBlobToOopClosure* codes_cl = ShenandoahConcurrentRoots::can_do_concurrent_class_unloading() ?
270 static_cast<CodeBlobToOopClosure*>(&blobs_and_disarm_Cl) :
271 static_cast<CodeBlobToOopClosure*>(&update_blobs);
272
273 CLDToOopClosure clds(keep_alive, ClassLoaderData::_claim_strong);
274
275 // Process serial-claiming roots first
276 _serial_roots.oops_do(keep_alive, worker_id);
277 _serial_weak_roots.weak_oops_do(is_alive, keep_alive, worker_id);
278
279 // Process light-weight/limited parallel roots then
280 _vm_roots.oops_do(keep_alive, worker_id);
281 _weak_roots.weak_oops_do(is_alive, keep_alive, worker_id);
282 _dedup_roots.oops_do(is_alive, keep_alive, worker_id);
283
284 // Process heavy-weight/fully parallel roots the last
285 _cld_roots.cld_do(&clds, worker_id);
286 _code_roots.code_blobs_do(codes_cl, worker_id);
287 _thread_roots.oops_do(keep_alive, NULL, worker_id);
288
289 }
290
291 #endif // SHARE_GC_SHENANDOAH_SHENANDOAHROOTPROCESSOR_INLINE_HPP
|