src/hotspot/share/gc/shenandoah/shenandoahRootProcessor.inline.hpp

rev 59534 : 8245961: Shenandoah: move some root marking to concurrent phase

*** 179,188 ****
--- 179,232 ----
      }
      t->oops_do(_f, _cf);
    }
  };
  
+ template <bool CONCURRENT, bool SINGLE_THREADED>
+ ShenandoahConcurrentRootScanner<CONCURRENT, SINGLE_THREADED>::ShenandoahConcurrentRootScanner(ShenandoahPhaseTimings::Phase phase) :
+   _vm_roots(phase),
+   _cld_roots(phase),
+   _codecache_snapshot(NULL),
+   _phase(phase) {
+   if (!ShenandoahHeap::heap()->unload_classes()) {
+     if (CONCURRENT) {
+       CodeCache_lock->lock_without_safepoint_check();
+     } else {
+       assert(SafepointSynchronize::is_at_safepoint(), "Must be at a safepoint");
+     }
+     _codecache_snapshot = ShenandoahCodeRoots::table()->snapshot_for_iteration();
+   }
+   assert(!CONCURRENT || !ShenandoahHeap::heap()->has_forwarded_objects(), "Not expecting forwarded pointers during concurrent marking");
+ }
+ 
+ template <bool CONCURRENT, bool SINGLE_THREADED>
+ ShenandoahConcurrentRootScanner<CONCURRENT, SINGLE_THREADED>::~ShenandoahConcurrentRootScanner() {
+   if (!ShenandoahHeap::heap()->unload_classes()) {
+     ShenandoahCodeRoots::table()->finish_iteration(_codecache_snapshot);
+     if (CONCURRENT) {
+       CodeCache_lock->unlock();
+     }
+   }
+ }
+ 
+ template <bool CONCURRENT, bool SINGLE_THREADED>
+ void ShenandoahConcurrentRootScanner<CONCURRENT, SINGLE_THREADED>::oops_do(OopClosure* oops, uint worker_id) {
+   ShenandoahHeap* const heap = ShenandoahHeap::heap();
+   CLDToOopClosure clds_cl(oops, CONCURRENT ? ClassLoaderData::_claim_strong : ClassLoaderData::_claim_none);
+   _vm_roots.oops_do(oops, worker_id);
+ 
+   if (!heap->unload_classes()) {
+     _cld_roots.cld_do(&clds_cl, worker_id);
+ 
+     ShenandoahWorkerTimingsTracker timer(_phase, ShenandoahPhaseTimings::CodeCacheRoots, worker_id);
+     CodeBlobToOopClosure blobs(oops, !CodeBlobToOopClosure::FixRelocations);
+     _codecache_snapshot->parallel_blobs_do(&blobs);
+   } else {
+     _cld_roots.always_strong_cld_do(&clds_cl, worker_id);
+   }
+ }
+ 
  template <typename IsAlive, typename KeepAlive>
  void ShenandoahRootUpdater::roots_do(uint worker_id, IsAlive* is_alive, KeepAlive* keep_alive) {
    CodeBlobToOopClosure update_blobs(keep_alive, CodeBlobToOopClosure::FixRelocations);
    ShenandoahCodeBlobAndDisarmClosure blobs_and_disarm_Cl(keep_alive);
    CodeBlobToOopClosure* codes_cl = ShenandoahConcurrentRoots::can_do_concurrent_class_unloading() ?