Refactor out work counters

Author: caizixian

src/scheduler/mod.rs

@@ -35,3 +35,5 @@ pub use gc_work::ProcessEdgesWork;
 // We should do some refactoring related to Scanning::SCAN_MUTATORS_IN_SAFEPOINT
 // to make sure this type is not exposed to the bindings.
 pub use gc_work::ScanStackRoot;
+
+mod work_counter;

src/scheduler/stat.rs

@@ -1,7 +1,7 @@
+use super::work_counter::{WorkCounter, WorkCounterBase, WorkDuration};
 use std::any::TypeId;
 use std::collections::HashMap;
 use std::sync::atomic::{AtomicBool, Ordering};
-use std::time::SystemTime;
 
 #[derive(Default)]
 pub struct SchedulerStat {
@@ -10,110 +10,6 @@ pub struct SchedulerStat {
     work_counters: HashMap<TypeId, Vec<Vec<Box<dyn WorkCounter>>>>,
 }
 
-#[derive(Copy, Clone)]
-struct WorkCounterBase {
-    total: f64,
-    min: f64,
-    max: f64,
-}
-
-impl Default for WorkCounterBase {
-    fn default() -> Self {
-        WorkCounterBase {
-            total: 0.0,
-            min: f64::INFINITY,
-            max: f64::NEG_INFINITY,
-        }
-    }
-}
-
-impl WorkCounterBase {
-    fn merge(&self, other: &Self) -> Self {
-        let min = self.min.min(other.min);
-        let max = self.max.max(other.max);
-        let total = self.total + other.total;
-        WorkCounterBase { total, min, max }
-    }
-
-    fn merge_inplace(&mut self, other: &Self) {
-        self.min = self.min.min(other.min);
-        self.max = self.max.max(other.max);
-        self.total += other.total;
-    }
-
-    fn merge_val(&mut self, val: f64) {
-        self.min = self.min.min(val);
-        self.max = self.max.max(val);
-        self.total += val;
-    }
-}
-
-trait WorkCounter: WorkCounterClone {
-    // TODO: consolidate with crate::util::statistics::counter::Counter;
-    fn start(&mut self);
-    fn stop(&mut self);
-    fn name(&self) -> &'static str;
-    fn get_base(&self) -> &WorkCounterBase;
-    fn get_base_mut(&mut self) -> &mut WorkCounterBase;
-}
-
-trait WorkCounterClone {
-    fn clone_box(&self) -> Box<dyn WorkCounter>;
-}
-
-impl<T: 'static + WorkCounter + Clone> WorkCounterClone for T {
-    fn clone_box(&self) -> Box<dyn WorkCounter> {
-        Box::new(self.clone())
-    }
-}
-
-impl Clone for Box<dyn WorkCounter> {
-    fn clone(&self) -> Box<dyn WorkCounter> {
-        self.clone_box()
-    }
-}
-
-#[derive(Copy, Clone)]
-struct WorkDuration {
-    base: WorkCounterBase,
-    start_value: Option<SystemTime>,
-    running: bool,
-}
-
-impl WorkDuration {
-    fn new() -> Self {
-        WorkDuration {
-            base: Default::default(),
-            start_value: None,
-            running: false,
-        }
-    }
-}
-
-impl WorkCounter for WorkDuration {
-    fn start(&mut self) {
-        self.start_value = Some(SystemTime::now());
-        self.running = true;
-    }
-
-    fn stop(&mut self) {
-        let duration = self.start_value.unwrap().elapsed().unwrap().as_nanos() as f64;
-        self.base.merge_val(duration);
-    }
-
-    fn name(&self) -> &'static str {
-        "time"
-    }
-
-    fn get_base(&self) -> &WorkCounterBase {
-        &self.base
-    }
-
-    fn get_base_mut(&mut self) -> &mut WorkCounterBase {
-        &mut self.base
-    }
-}
-
 impl SchedulerStat {
     /// Extract the work-packet name from the full type name.
     /// i.e. simplifies `crate::scheduler::gc_work::SomeWorkPacket<Semispace>` to `SomeWorkPacket`.

src/scheduler/work_counter.rs

@@ -0,0 +1,105 @@
+use std::time::SystemTime;
+
+#[derive(Copy, Clone)]
+pub(super) struct WorkCounterBase {
+    pub(super) total: f64,
+    pub(super) min: f64,
+    pub(super) max: f64,
+}
+
+pub(super) trait WorkCounterClone {
+    fn clone_box(&self) -> Box<dyn WorkCounter>;
+}
+
+impl<T: 'static + WorkCounter + Clone> WorkCounterClone for T {
+    fn clone_box(&self) -> Box<dyn WorkCounter> {
+        Box::new(self.clone())
+    }
+}
+
+pub(super) trait WorkCounter: WorkCounterClone {
+    // TODO: consolidate with crate::util::statistics::counter::Counter;
+    fn start(&mut self);
+    fn stop(&mut self);
+    fn name(&self) -> &'static str;
+    fn get_base(&self) -> &WorkCounterBase;
+    fn get_base_mut(&mut self) -> &mut WorkCounterBase;
+}
+
+impl Clone for Box<dyn WorkCounter> {
+    fn clone(&self) -> Box<dyn WorkCounter> {
+        self.clone_box()
+    }
+}
+
+impl Default for WorkCounterBase {
+    fn default() -> Self {
+        WorkCounterBase {
+            total: 0.0,
+            min: f64::INFINITY,
+            max: f64::NEG_INFINITY,
+        }
+    }
+}
+
+impl WorkCounterBase {
+    pub(super) fn merge(&self, other: &Self) -> Self {
+        let min = self.min.min(other.min);
+        let max = self.max.max(other.max);
+        let total = self.total + other.total;
+        WorkCounterBase { total, min, max }
+    }
+
+    pub(super) fn merge_inplace(&mut self, other: &Self) {
+        self.min = self.min.min(other.min);
+        self.max = self.max.max(other.max);
+        self.total += other.total;
+    }
+
+    pub(super) fn merge_val(&mut self, val: f64) {
+        self.min = self.min.min(val);
+        self.max = self.max.max(val);
+        self.total += val;
+    }
+}
+
+#[derive(Copy, Clone)]
+pub(super) struct WorkDuration {
+    base: WorkCounterBase,
+    start_value: Option<SystemTime>,
+    running: bool,
+}
+
+impl WorkDuration {
+    pub(super) fn new() -> Self {
+        WorkDuration {
+            base: Default::default(),
+            start_value: None,
+            running: false,
+        }
+    }
+}
+
+impl WorkCounter for WorkDuration {
+    fn start(&mut self) {
+        self.start_value = Some(SystemTime::now());
+        self.running = true;
+    }
+
+    fn stop(&mut self) {
+        let duration = self.start_value.unwrap().elapsed().unwrap().as_nanos() as f64;
+        self.base.merge_val(duration);
+    }
+
+    fn name(&self) -> &'static str {
+        "time"
+    }
+
+    fn get_base(&self) -> &WorkCounterBase {
+        &self.base
+    }
+
+    fn get_base_mut(&mut self) -> &mut WorkCounterBase {
+        &mut self.base
+    }
+}