src/hotspot/share/gc/shenandoah/shenandoahRootProcessor.cpp

rev 55401 : 8225582: Shenandoah: Enable concurrent evacuation of JNIHandles
rev 55402 : 8226311: Shenandoah: Concurrent evacuation of OopStorage backed weak roots

*** 33,43 ****
  #include "gc/shenandoah/shenandoahHeuristics.hpp"
  #include "gc/shenandoah/shenandoahPhaseTimings.hpp"
  #include "gc/shenandoah/shenandoahStringDedup.hpp"
  #include "gc/shenandoah/shenandoahTimingTracker.hpp"
  #include "gc/shenandoah/shenandoahVMOperations.hpp"
! #include "gc/shared/weakProcessor.inline.hpp"
  #include "memory/allocation.inline.hpp"
  #include "memory/iterator.hpp"
  #include "memory/resourceArea.hpp"
  #include "memory/universe.hpp"
  #include "runtime/thread.hpp"
--- 33,43 ----
  #include "gc/shenandoah/shenandoahHeuristics.hpp"
  #include "gc/shenandoah/shenandoahPhaseTimings.hpp"
  #include "gc/shenandoah/shenandoahStringDedup.hpp"
  #include "gc/shenandoah/shenandoahTimingTracker.hpp"
  #include "gc/shenandoah/shenandoahVMOperations.hpp"
! #include "jfr/jfr.hpp"
  #include "memory/allocation.inline.hpp"
  #include "memory/iterator.hpp"
  #include "memory/resourceArea.hpp"
  #include "memory/universe.hpp"
  #include "runtime/thread.hpp"
*** 69,78 ****
--- 69,112 ----
    _management_root.oops_do(cl, worker_id);
    _system_dictionary_root.oops_do(cl, worker_id);
    _jvmti_root.oops_do(cl, worker_id);
  }
  
+ ShenandoahWeakSerialRoot::ShenandoahWeakSerialRoot(ShenandoahWeakSerialRoot::WeakOopsDo weak_oops_do, ShenandoahPhaseTimings::GCParPhases phase) :
+   _claimed(false), _weak_oops_do(weak_oops_do), _phase(phase) {
+ }
+ 
+ void ShenandoahWeakSerialRoot::weak_oops_do(BoolObjectClosure* is_alive, OopClosure* keep_alive, uint worker_id) {
+   if (!_claimed && Atomic::cmpxchg(true, &_claimed, false) == false) {
+     ShenandoahWorkerTimings* worker_times = ShenandoahHeap::heap()->phase_timings()->worker_times();
+     ShenandoahWorkerTimingsTracker timer(worker_times, _phase, worker_id);
+     _weak_oops_do(is_alive, keep_alive);
+   }
+ }
+ 
+ #if INCLUDE_JVMTI
+ ShenandoahJVMTIWeakRoot::ShenandoahJVMTIWeakRoot() :
+   ShenandoahWeakSerialRoot(&JvmtiExport::weak_oops_do, ShenandoahPhaseTimings::JVMTIWeakRoots) {
+ }
+ #endif // INCLUDE_JVMTI
+ 
+ #if INCLUDE_JFR
+ ShenandoahJFRWeakRoot::ShenandoahJFRWeakRoot() :
+   ShenandoahWeakSerialRoot(&Jfr::weak_oops_do, ShenandoahPhaseTimings::JFRWeakRoots) {
+ }
+ #endif // INCLUDE_JFR
+ 
+ void ShenandoahSerialWeakRoots::weak_oops_do(BoolObjectClosure* is_alive, OopClosure* keep_alive, uint worker_id) {
+   JVMTI_ONLY(_jvmti_weak_roots.weak_oops_do(is_alive, keep_alive, worker_id);)
+   JFR_ONLY(_jfr_weak_roots.weak_oops_do(is_alive, keep_alive, worker_id);)
+ }
+ 
+ void ShenandoahSerialWeakRoots::weak_oops_do(OopClosure* cl, uint worker_id) {
+   AlwaysTrueClosure always_true;
+   weak_oops_do(&always_true, cl, worker_id);
+ }
+ 
  ShenandoahThreadRoots::ShenandoahThreadRoots(bool is_par) : _is_par(is_par) {
    Threads::change_thread_claim_token();
  }
  
  void ShenandoahThreadRoots::oops_do(OopClosure* oops_cl, CodeBlobClosure* code_cl, uint worker_id) {
*** 91,111 ****
  
  ShenandoahThreadRoots::~ShenandoahThreadRoots() {
    Threads::assert_all_threads_claimed();
  }
  
- ShenandoahWeakRoots::ShenandoahWeakRoots(uint n_workers) :
-   _process_timings(n_workers),
-   _task(&_process_timings, n_workers) {
- }
- 
- ShenandoahWeakRoots::~ShenandoahWeakRoots() {
-   ShenandoahWorkerTimings* worker_times = ShenandoahHeap::heap()->phase_timings()->worker_times();
-   ShenandoahTimingConverter::weak_processing_timing_to_shenandoah_timing(&_process_timings,
-                                                                          worker_times);
- }
- 
  ShenandoahStringDedupRoots::ShenandoahStringDedupRoots() {
    if (ShenandoahStringDedup::is_enabled()) {
      StringDedup::gc_prologue(false);
    }
  }
--- 125,134 ----
*** 145,187 ****
  }
  
  ShenandoahRootEvacuator::ShenandoahRootEvacuator(uint n_workers, ShenandoahPhaseTimings::Phase phase, bool include_concurrent_roots) :
    ShenandoahRootProcessor(phase),
    _thread_roots(n_workers > 1),
-   _weak_roots(n_workers),
    _include_concurrent_roots(include_concurrent_roots) {
  }
  
  void ShenandoahRootEvacuator::roots_do(uint worker_id, OopClosure* oops) {
    MarkingCodeBlobClosure blobsCl(oops, CodeBlobToOopClosure::FixRelocations);
    CLDToOopClosure clds(oops, ClassLoaderData::_claim_strong);
    AlwaysTrueClosure always_true;
  
    _serial_roots.oops_do(oops, worker_id);
    if (_include_concurrent_roots) {
      _jni_roots.oops_do<OopClosure>(oops, worker_id);
    }
  
    _thread_roots.oops_do(oops, NULL, worker_id);
    _cld_roots.clds_do(&clds, &clds, worker_id);
    _code_roots.code_blobs_do(&blobsCl, worker_id);
  
-   _weak_roots.oops_do<AlwaysTrueClosure, OopClosure>(&always_true, oops, worker_id);
    _dedup_roots.oops_do(&always_true, oops, worker_id);
  }
  
  ShenandoahRootUpdater::ShenandoahRootUpdater(uint n_workers, ShenandoahPhaseTimings::Phase phase, bool update_code_cache) :
    ShenandoahRootProcessor(phase),
    _thread_roots(n_workers > 1),
-   _weak_roots(n_workers),
    _update_code_cache(update_code_cache) {
  }
  
  ShenandoahRootAdjuster::ShenandoahRootAdjuster(uint n_workers, ShenandoahPhaseTimings::Phase phase) :
    ShenandoahRootProcessor(phase),
!   _thread_roots(n_workers > 1),
!   _weak_roots(n_workers) {
    assert(ShenandoahHeap::heap()->is_full_gc_in_progress(), "Full GC only");
  }
  
  void ShenandoahRootAdjuster::roots_do(uint worker_id, OopClosure* oops) {
    CodeBlobToOopClosure adjust_code_closure(oops, CodeBlobToOopClosure::FixRelocations);
--- 168,208 ----
  }
  
  ShenandoahRootEvacuator::ShenandoahRootEvacuator(uint n_workers, ShenandoahPhaseTimings::Phase phase, bool include_concurrent_roots) :
    ShenandoahRootProcessor(phase),
    _thread_roots(n_workers > 1),
    _include_concurrent_roots(include_concurrent_roots) {
  }
  
  void ShenandoahRootEvacuator::roots_do(uint worker_id, OopClosure* oops) {
    MarkingCodeBlobClosure blobsCl(oops, CodeBlobToOopClosure::FixRelocations);
    CLDToOopClosure clds(oops, ClassLoaderData::_claim_strong);
    AlwaysTrueClosure always_true;
  
    _serial_roots.oops_do(oops, worker_id);
+   _serial_weak_roots.weak_oops_do(oops, worker_id);
    if (_include_concurrent_roots) {
      _jni_roots.oops_do<OopClosure>(oops, worker_id);
+     _weak_roots.oops_do<OopClosure>(oops, worker_id);
    }
  
    _thread_roots.oops_do(oops, NULL, worker_id);
    _cld_roots.clds_do(&clds, &clds, worker_id);
    _code_roots.code_blobs_do(&blobsCl, worker_id);
  
    _dedup_roots.oops_do(&always_true, oops, worker_id);
  }
  
  ShenandoahRootUpdater::ShenandoahRootUpdater(uint n_workers, ShenandoahPhaseTimings::Phase phase, bool update_code_cache) :
    ShenandoahRootProcessor(phase),
    _thread_roots(n_workers > 1),
    _update_code_cache(update_code_cache) {
  }
  
  ShenandoahRootAdjuster::ShenandoahRootAdjuster(uint n_workers, ShenandoahPhaseTimings::Phase phase) :
    ShenandoahRootProcessor(phase),
!   _thread_roots(n_workers > 1) {
    assert(ShenandoahHeap::heap()->is_full_gc_in_progress(), "Full GC only");
  }
  
  void ShenandoahRootAdjuster::roots_do(uint worker_id, OopClosure* oops) {
    CodeBlobToOopClosure adjust_code_closure(oops, CodeBlobToOopClosure::FixRelocations);
*** 193,200 ****
  
    _thread_roots.oops_do(oops, NULL, worker_id);
    _cld_roots.clds_do(&adjust_cld_closure, NULL, worker_id);
    _code_roots.code_blobs_do(&adjust_code_closure, worker_id);
  
!   _weak_roots.oops_do<AlwaysTrueClosure, OopClosure>(&always_true, oops, worker_id);
    _dedup_roots.oops_do(&always_true, oops, worker_id);
  }
--- 214,222 ----
  
    _thread_roots.oops_do(oops, NULL, worker_id);
    _cld_roots.clds_do(&adjust_cld_closure, NULL, worker_id);
    _code_roots.code_blobs_do(&adjust_code_closure, worker_id);
  
!   _serial_weak_roots.weak_oops_do(oops, worker_id);
!   _weak_roots.oops_do<OopClosure>(oops, worker_id);
    _dedup_roots.oops_do(&always_true, oops, worker_id);
  }