8246100: Shenandoah: walk roots in more efficient order

Reviewed-by: zgu

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

@@ -179,13 +179,18 @@ void ShenandoahRootEvacuator::roots_do(uint worker_id, OopClosure* oops) {
                                    static_cast<CodeBlobToOopClosure*>(&blobsCl);
   AlwaysTrueClosure always_true;
 
+  // Process serial-claiming roots first
   _serial_roots.oops_do(oops, worker_id);
   _serial_weak_roots.weak_oops_do(oops, worker_id);
+
+  // Process light-weight/limited parallel roots then
   if (_stw_roots_processing) {
     _vm_roots.oops_do<OopClosure>(oops, worker_id);
     _weak_roots.oops_do<OopClosure>(oops, worker_id);
   }
+  _dedup_roots.oops_do(&always_true, oops, worker_id);
 
+  // Process heavy-weight/fully parallel roots the last
   if (_stw_class_unloading) {
     CLDToOopClosure clds(oops, ClassLoaderData::_claim_strong);
     _cld_roots.cld_do(&clds, worker_id);
@@ -194,8 +199,6 @@ void ShenandoahRootEvacuator::roots_do(uint worker_id, OopClosure* oops) {
   } else {
     _thread_roots.oops_do(oops, codes_cl, worker_id);
   }
-
-  _dedup_roots.oops_do(&always_true, oops, worker_id);
 }
 
 ShenandoahRootUpdater::ShenandoahRootUpdater(uint n_workers, ShenandoahPhaseTimings::Phase phase) :
@@ -232,16 +235,19 @@ void ShenandoahRootAdjuster::roots_do(uint worker_id, OopClosure* oops) {
   CLDToOopClosure adjust_cld_closure(oops, ClassLoaderData::_claim_strong);
   AlwaysTrueClosure always_true;
 
+  // Process serial-claiming roots first
   _serial_roots.oops_do(oops, worker_id);
-  _vm_roots.oops_do(oops, worker_id);
-
-  _thread_roots.oops_do(oops, NULL, worker_id);
-  _cld_roots.cld_do(&adjust_cld_closure, worker_id);
-  _code_roots.code_blobs_do(adjust_code_closure, worker_id);
-
   _serial_weak_roots.weak_oops_do(oops, worker_id);
+
+  // Process light-weight/limited parallel roots then
+  _vm_roots.oops_do(oops, worker_id);
   _weak_roots.oops_do<OopClosure>(oops, worker_id);
   _dedup_roots.oops_do(&always_true, oops, worker_id);
+
+  // Process heavy-weight/fully parallel roots the last
+  _cld_roots.cld_do(&adjust_cld_closure, worker_id);
+  _code_roots.code_blobs_do(adjust_code_closure, worker_id);
+  _thread_roots.oops_do(oops, NULL, worker_id);
 }
 
 ShenandoahHeapIterationRootScanner::ShenandoahHeapIterationRootScanner() :
@@ -263,15 +269,20 @@ ShenandoahHeapIterationRootScanner::ShenandoahHeapIterationRootScanner() :
    MarkingCodeBlobClosure code(oops, !CodeBlobToOopClosure::FixRelocations);
    ShenandoahParallelOopsDoThreadClosure tc_cl(oops, &code, NULL);
    AlwaysTrueClosure always_true;
+
    ResourceMark rm;
 
+   // Process serial-claiming roots first
    _serial_roots.oops_do(oops, 0);
-   _vm_roots.oops_do(oops, 0);
-   _cld_roots.cld_do(&clds, 0);
-   _thread_roots.threads_do(&tc_cl, 0);
-   _code_roots.code_blobs_do(&code, 0);
-
    _serial_weak_roots.weak_oops_do(oops, 0);
+
+   // Process light-weight/limited parallel roots then
+   _vm_roots.oops_do(oops, 0);
    _weak_roots.oops_do<OopClosure>(oops, 0);
    _dedup_roots.oops_do(&always_true, oops, 0);
+
+   // Process heavy-weight/fully parallel roots the last
+   _cld_roots.cld_do(&clds, 0);
+   _code_roots.code_blobs_do(&code, 0);
+   _thread_roots.threads_do(&tc_cl, 0);
  }

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

@@ -226,19 +226,23 @@ void ShenandoahRootScanner<ITR>::roots_do(uint worker_id, OopClosure* oops, CLDC
   assert(!ShenandoahSafepoint::is_at_shenandoah_safepoint() ||
          !ShenandoahHeap::heap()->unload_classes(),
           "Expect class unloading when Shenandoah cycle is running");
-  ResourceMark rm;
-
-  _serial_roots.oops_do(oops, worker_id);
-  _vm_roots.oops_do(oops, worker_id);
-
   assert(clds != NULL, "Only possible with CLD closure");
-  _cld_roots.cld_do(clds, worker_id);
-
-  ShenandoahParallelOopsDoThreadClosure tc_cl(oops, code, tc);
-  _thread_roots.threads_do(&tc_cl, worker_id);
 
   AlwaysTrueClosure always_true;
+  ShenandoahParallelOopsDoThreadClosure tc_cl(oops, code, tc);
+
+  ResourceMark rm;
+
+  // Process serial-claiming roots first
+  _serial_roots.oops_do(oops, worker_id);
+
+  // Process light-weight/limited parallel roots then
+  _vm_roots.oops_do(oops, worker_id);
   _dedup_roots.oops_do(&always_true, oops, worker_id);
+
+  // Process heavy-weight/fully parallel roots the last
+  _cld_roots.cld_do(clds, worker_id);
+  _thread_roots.threads_do(&tc_cl, worker_id);
 }
 
 template <typename ITR>
@@ -247,8 +251,13 @@ void ShenandoahRootScanner<ITR>::strong_roots_do(uint worker_id, OopClosure* oop
   ShenandoahParallelOopsDoThreadClosure tc_cl(oops, code, tc);
   ResourceMark rm;
 
+  // Process serial-claiming roots first
   _serial_roots.oops_do(oops, worker_id);
+
+  // Process light-weight/limited parallel roots then
   _vm_roots.oops_do(oops, worker_id);
+
+  // Process heavy-weight/fully parallel roots the last
   _cld_roots.always_strong_cld_do(clds, worker_id);
   _thread_roots.threads_do(&tc_cl, worker_id);
 }
@@ -263,16 +272,20 @@ void ShenandoahRootUpdater::roots_do(uint worker_id, IsAlive* is_alive, KeepAliv
 
   CLDToOopClosure clds(keep_alive, ClassLoaderData::_claim_strong);
 
+  // Process serial-claiming roots first
   _serial_roots.oops_do(keep_alive, worker_id);
-  _vm_roots.oops_do(keep_alive, worker_id);
+  _serial_weak_roots.weak_oops_do(is_alive, keep_alive, worker_id);
 
+  // Process light-weight/limited parallel roots then
+  _vm_roots.oops_do(keep_alive, worker_id);
+  _weak_roots.weak_oops_do(is_alive, keep_alive, worker_id);
+  _dedup_roots.oops_do(is_alive, keep_alive, worker_id);
+
+  // Process heavy-weight/fully parallel roots the last
   _cld_roots.cld_do(&clds, worker_id);
   _code_roots.code_blobs_do(codes_cl, worker_id);
   _thread_roots.oops_do(keep_alive, NULL, worker_id);
 
-  _serial_weak_roots.weak_oops_do(is_alive, keep_alive, worker_id);
-  _weak_roots.weak_oops_do(is_alive, keep_alive, worker_id);
-  _dedup_roots.oops_do(is_alive, keep_alive, worker_id);
 }
 
 #endif // SHARE_GC_SHENANDOAH_SHENANDOAHROOTPROCESSOR_INLINE_HPP