Minor changes to the ProcessRootNode work packet (#1327)

Renamed `ProcessRootNode` to `ProcessRootNodes` because it obviously
processes multiple roots.

If no objects are enqueued, we do not blindly create empty `ScanObjects`
work packets. During nursery GC, it is likely that many root edges point
to mature nodes, and mature objects are not enqueued during nursery GC.

We also added eBPF trace points to show how many roots are there in a
ProcessRootNodes work packet, and how many objects are actually
enqueued.

Author: wks

src/scheduler/gc_work.rs

@@ -756,7 +756,7 @@ impl<VM: VMBinding, DPE: ProcessEdgesWork<VM = VM>, PPE: ProcessEdgesWork<VM = V
         crate::memory_manager::add_work_packet(
             self.mmtk,
             WorkBucketStage::PinningRootsTrace,
-            ProcessRootNode::<VM, PPE, DPE>::new(nodes, WorkBucketStage::Closure),
+            ProcessRootNodes::<VM, PPE, DPE>::new(nodes, WorkBucketStage::Closure),
         );
     }
 
@@ -765,7 +765,7 @@ impl<VM: VMBinding, DPE: ProcessEdgesWork<VM = VM>, PPE: ProcessEdgesWork<VM = V
         crate::memory_manager::add_work_packet(
             self.mmtk,
             WorkBucketStage::TPinningClosure,
-            ProcessRootNode::<VM, PPE, PPE>::new(nodes, WorkBucketStage::TPinningClosure),
+            ProcessRootNodes::<VM, PPE, PPE>::new(nodes, WorkBucketStage::TPinningClosure),
         );
     }
 }
@@ -1071,7 +1071,7 @@ impl<E: ProcessEdgesWork, P: Plan<VM = E::VM> + PlanTraceObject<E::VM>> GCWork<E
 /// -   If `O2OPE` may move objects, then this `ProcessRootsNode<VM, R2OPE, O2OPE>` work packet
 ///     will only pin the objects in `roots` (because `R2OPE` must not move objects anyway), but
 ///     not their descendents.
-pub(crate) struct ProcessRootNode<
+pub(crate) struct ProcessRootNodes<
     VM: VMBinding,
     R2OPE: ProcessEdgesWork<VM = VM>,
     O2OPE: ProcessEdgesWork<VM = VM>,
@@ -1082,7 +1082,7 @@ pub(crate) struct ProcessRootNode<
 }
 
 impl<VM: VMBinding, R2OPE: ProcessEdgesWork<VM = VM>, O2OPE: ProcessEdgesWork<VM = VM>>
-    ProcessRootNode<VM, R2OPE, O2OPE>
+    ProcessRootNodes<VM, R2OPE, O2OPE>
 {
     pub fn new(nodes: Vec<ObjectReference>, bucket: WorkBucketStage) -> Self {
         Self {
@@ -1094,10 +1094,10 @@ impl<VM: VMBinding, R2OPE: ProcessEdgesWork<VM = VM>, O2OPE: ProcessEdgesWork<VM
 }
 
 impl<VM: VMBinding, R2OPE: ProcessEdgesWork<VM = VM>, O2OPE: ProcessEdgesWork<VM = VM>> GCWork<VM>
-    for ProcessRootNode<VM, R2OPE, O2OPE>
+    for ProcessRootNodes<VM, R2OPE, O2OPE>
 {
     fn do_work(&mut self, worker: &mut GCWorker<VM>, mmtk: &'static MMTK<VM>) {
-        trace!("ProcessRootNode");
+        trace!("ProcessRootNodes");
 
         #[cfg(feature = "sanity")]
         {
@@ -1109,15 +1109,17 @@ impl<VM: VMBinding, R2OPE: ProcessEdgesWork<VM = VM>, O2OPE: ProcessEdgesWork<VM
             }
         }
 
+        let num_roots = self.roots.len();
+
         // This step conceptually traces the edges from root slots to the objects they point to.
         // However, VMs that deliver root objects instead of root slots are incapable of updating
         // root slots.  Therefore, we call `trace_object` on those objects, and assert the GC
         // doesn't move those objects because we cannot store the updated references back to the
         // slots.
         //
-        // The `scanned_root_objects` variable will hold those root objects which are traced for the
+        // The `root_objects_to_scan` variable will hold those root objects which are traced for the
         // first time.  We will create a work packet for scanning those roots.
-        let scanned_root_objects = {
+        let root_objects_to_scan = {
             // We create an instance of E to use its `trace_object` method and its object queue.
             let mut process_edges_work =
                 R2OPE::new(vec![], true, mmtk, WorkBucketStage::PinningRootsTrace);
@@ -1137,11 +1139,16 @@ impl<VM: VMBinding, R2OPE: ProcessEdgesWork<VM = VM>, O2OPE: ProcessEdgesWork<VM
             process_edges_work.nodes.take()
         };
 
-        let process_edges_work = O2OPE::new(vec![], false, mmtk, self.bucket);
-        let work = process_edges_work.create_scan_work(scanned_root_objects);
-        crate::memory_manager::add_work_packet(mmtk, self.bucket, work);
+        let num_enqueued_nodes = root_objects_to_scan.len();
+        probe!(mmtk, process_root_nodes, num_roots, num_enqueued_nodes);
+
+        if !root_objects_to_scan.is_empty() {
+            let process_edges_work = O2OPE::new(vec![], false, mmtk, self.bucket);
+            let work = process_edges_work.create_scan_work(root_objects_to_scan);
+            crate::memory_manager::add_work_packet(mmtk, self.bucket, work);
+        }
 
-        trace!("ProcessRootNode End");
+        trace!("ProcessRootNodes End");
     }
 }
 

src/util/sanity/sanity_checker.rs

@@ -96,7 +96,7 @@ impl<P: Plan> GCWork<P::VM> for ScheduleSanityGC<P> {
                 );
             }
             for roots in &sanity_checker.root_nodes {
-                scheduler.work_buckets[WorkBucketStage::Closure].add(ProcessRootNode::<
+                scheduler.work_buckets[WorkBucketStage::Closure].add(ProcessRootNodes::<
                     P::VM,
                     SanityGCProcessEdges<P::VM>,
                     SanityGCProcessEdges<P::VM>,

tools/tracing/README.md

@@ -35,6 +35,8 @@ Currently, the core provides the following tracepoints.
 -   `mmtk:roots(kind: int, len: int)`: reporing roots to mmtk-core during root scanning.  `kind` can
     be 0, 1 or 2 for normal roots, pinning roots and transitively pinning roots, respectively.
     `len` is the number of slots or nodes reported.
+-   `mmtk:process_root_nodes(num_roots: int, num_enqueued_nodes: int)`: a ProcessRootNodes work
+    packet which processes root edges represented as object references to the target objects.
 -   `mmtk:process_slots(num_slots: int, is_roots: bool)`: an invocation of the `process_slots`
     method. The first argument is the number of slots to be processed, and the second argument is
     whether these slots are root slots.

tools/tracing/timeline/capture.bt

@@ -87,6 +87,12 @@ usdt:$MMTK:mmtk:roots {
     }
 }
 
+usdt:$MMTK:mmtk:process_root_nodes {
+    if (@enable_print) {
+        printf("process_root_nodes,meta,%d,%lu,%lu,%lu\n", tid, nsecs, arg0, arg1);
+    }
+}
+
 usdt:$MMTK:mmtk:process_slots {
     if (@enable_print) {
         printf("process_slots,meta,%d,%lu,%lu,%lu\n", tid, nsecs, arg0, arg1);

tools/tracing/timeline/visualize.py

@@ -212,6 +212,12 @@ def enrich_meta(self, name, tid, ts, gc, wp, args):
 
                     roots_list.append(root_dict)
 
+                case "process_root_nodes":
+                    wp["args"] |= {
+                        "num_roots": int(args[0]),
+                        "num_enqueued_nodes": int(args[1]),
+                    }
+
                 case "process_slots":
                     wp["args"] |= {
                         # Group args by "process_slots" and "scan_objects" because a ProcessEdgesWork