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

rev 55920 : 8229206: Shenandoah: ShenandoahWeakRoot::oops_do() uses wrong timing phase
rev 55921 : 8229213: Shenandoah: Allow VM global oop storage to be processed concurrently

@@ -35,26 +35,31 @@
 #include "memory/resourceArea.hpp"
 #include "prims/resolvedMethodTable.hpp"
 #include "runtime/safepoint.hpp"
 
 template <bool CONCURRENT>
-inline ShenandoahWeakRoot<CONCURRENT>::ShenandoahWeakRoot(OopStorage* storage, ShenandoahPhaseTimings::GCParPhases phase) :
+inline ShenandoahVMRoot<CONCURRENT>::ShenandoahVMRoot(OopStorage* storage, ShenandoahPhaseTimings::GCParPhases phase) :
   _itr(storage), _phase(phase) {
 }
 
 template <bool CONCURRENT>
 template <typename Closure>
-inline void ShenandoahWeakRoot<CONCURRENT>::oops_do(Closure* cl, uint worker_id) {
+inline void ShenandoahVMRoot<CONCURRENT>::oops_do(Closure* cl, uint worker_id) {
   if (CONCURRENT) {
     _itr.oops_do(cl);
   } else {
     ShenandoahWorkerTimings* worker_times = ShenandoahHeap::heap()->phase_timings()->worker_times();
-    ShenandoahWorkerTimingsTracker timer(worker_times, ShenandoahPhaseTimings::ThreadRoots, worker_id);
+    ShenandoahWorkerTimingsTracker timer(worker_times, _phase, worker_id);
     _itr.oops_do(cl);
   }
 }
 
+template <bool CONCURRENT>
+inline ShenandoahWeakRoot<CONCURRENT>::ShenandoahWeakRoot(OopStorage* storage, ShenandoahPhaseTimings::GCParPhases phase) :
+  ShenandoahVMRoot<CONCURRENT>(storage, phase) {
+}
+
 inline ShenandoahWeakRoot<false>::ShenandoahWeakRoot(OopStorage* storage, ShenandoahPhaseTimings::GCParPhases phase) :
   _itr(storage), _phase(phase) {
 }
 
 template <typename IsAliveClosure, typename KeepAliveClosure>

@@ -101,24 +106,20 @@
   AlwaysTrueClosure always_true;
   weak_oops_do<AlwaysTrueClosure, Closure>(&always_true, cl, worker_id);
 }
 
 template <bool CONCURRENT>
-ShenandoahJNIHandleRoots<CONCURRENT>::ShenandoahJNIHandleRoots() :
-  _itr(JNIHandles::global_handles()) {
+ShenandoahVMRoots<CONCURRENT>::ShenandoahVMRoots() :
+  _jni_handle_roots(JNIHandles::global_handles(), ShenandoahPhaseTimings::JNIRoots),
+  _vm_global_roots(SystemDictionary::vm_global_oop_storage(), ShenandoahPhaseTimings::VMGlobalRoots) {
 }
 
 template <bool CONCURRENT>
 template <typename T>
-void ShenandoahJNIHandleRoots<CONCURRENT>::oops_do(T* cl, uint worker_id) {
-  if (CONCURRENT) {
-    _itr.oops_do(cl);
-  } else {
-    ShenandoahWorkerTimings* worker_times = ShenandoahHeap::heap()->phase_timings()->worker_times();
-    ShenandoahWorkerTimingsTracker timer(worker_times, ShenandoahPhaseTimings::JNIRoots, worker_id);
-    _itr.oops_do(cl);
-  }
+void ShenandoahVMRoots<CONCURRENT>::oops_do(T* cl, uint worker_id) {
+  _jni_handle_roots.oops_do(cl, worker_id);
+  _vm_global_roots.oops_do(cl, worker_id);
 }
 
 template <bool CONCURRENT, bool SINGLE_THREADED>
 ShenandoahClassLoaderDataRoots<CONCURRENT, SINGLE_THREADED>::ShenandoahClassLoaderDataRoots() {
   if (!SINGLE_THREADED) {

@@ -229,11 +230,11 @@
           "Expect class unloading or traversal when Shenandoah cycle is running");
   ShenandoahParallelOopsDoThreadClosure tc_cl(oops, code, tc);
   ResourceMark rm;
 
   _serial_roots.oops_do(oops, worker_id);
-  _jni_roots.oops_do(oops, worker_id);
+  _vm_roots.oops_do(oops, worker_id);
 
   if (clds != NULL) {
     _cld_roots.cld_do(clds, worker_id);
   } else {
     assert(ShenandoahHeap::heap()->is_concurrent_traversal_in_progress(), "Only possible with traversal GC");

@@ -254,22 +255,22 @@
   assert(ShenandoahHeap::heap()->unload_classes(), "Should be used during class unloading");
   ShenandoahParallelOopsDoThreadClosure tc_cl(oops, code, tc);
   ResourceMark rm;
 
   _serial_roots.oops_do(oops, worker_id);
-  _jni_roots.oops_do(oops, worker_id);
+  _vm_roots.oops_do(oops, worker_id);
   _cld_roots.always_strong_cld_do(clds, worker_id);
   _thread_roots.threads_do(&tc_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);
   CLDToOopClosure clds(keep_alive, ClassLoaderData::_claim_strong);
 
   _serial_roots.oops_do(keep_alive, worker_id);
-  _jni_roots.oops_do(keep_alive, worker_id);
+  _vm_roots.oops_do(keep_alive, worker_id);
 
   _thread_roots.oops_do(keep_alive, NULL, worker_id);
   _cld_roots.cld_do(&clds, worker_id);
 
   if(_update_code_cache) {