extract cpu_time, add to noop demo

Author: nikomatsakis

rayon-demo/src/cpu_time/mod.rs

@@ -0,0 +1,55 @@
+use time::{self, Duration};
+
+#[cfg(windows)]
+mod win;
+#[cfg(windows)]
+pub use self::win::get_cpu_time;
+
+#[cfg(unix)]
+mod unix;
+#[cfg(unix)]
+pub use self::unix::get_cpu_time;
+
+#[cfg(not(any(unix, windows)))]
+pub fn get_cpu_time() -> Option<u64> {
+    None
+}
+
+pub fn get_cpu_duration(start: Option<u64>, stop: Option<u64>) -> Option<Duration> {
+    start.and_then(|start| stop.and_then(|stop| Some(Duration::nanoseconds((stop - start) as i64))))
+}
+
+#[derive(Copy, Clone)]
+pub struct CpuMeasure {
+    /// number of ns
+    pub time_duration: u64,
+
+    /// percentage (0-100) of that as cpu time
+    pub cpu_usage_percent: Option<f64>,
+}
+
+pub fn measure_cpu(op: impl FnOnce()) -> CpuMeasure {
+    let time_start = time::precise_time_ns();
+    let cpu_start = get_cpu_time();
+
+    op();
+
+    let cpu_stop = get_cpu_time();
+    let time_duration = time::precise_time_ns() - time_start;
+
+    CpuMeasure {
+        time_duration,
+        cpu_usage_percent: get_cpu_duration(cpu_start, cpu_stop)
+            .and_then(|cpu| cpu.num_nanoseconds())
+            .and_then(|cpu| Some(100.0 * cpu as f64 / time_duration as f64)),
+    }
+}
+
+pub fn print_time(m: CpuMeasure) {
+    println!("    wallclock: {} ns", m.time_duration);
+    if let Some(cpu_usage) = m.cpu_usage_percent {
+        println!("    cpu usage: {:3.1}%", cpu_usage);
+    } else {
+        println!("    cpu usage: N/A");
+    }
+}

rayon-demo/src/life/cpu_time/unix.rs renamed to rayon-demo/src/cpu_time/unix.rs

@@ -14,6 +14,7 @@ Options:
     -h, --help      Show this message.
 ";
 
+use cpu_time::{self, CpuMeasure};
 use rand::distributions::Standard;
 use rand::{thread_rng, Rng};
 use std::iter::repeat;
@@ -28,7 +29,6 @@ use rayon::prelude::*;
 
 #[cfg(test)]
 mod bench;
-mod cpu_time;
 
 #[derive(Deserialize)]
 pub struct Args {
@@ -249,19 +249,14 @@ fn measure_cpu(f: fn(Board, usize, u64) -> (), args: &Args) -> CpuResult {
     let (n, gens, rate) = (args.flag_size, args.flag_gens, args.flag_fps);
     let interval = 1_000_000_000 / rate as u64;
     let brd = Board::new(n, n).random();
-    let start = time::precise_time_ns();
-    let cpu_start = cpu_time::get_cpu_time();
-
-    f(brd, gens, interval);
 
-    let cpu_stop = cpu_time::get_cpu_time();
-    let duration = time::precise_time_ns() - start;
+    let CpuMeasure { time_duration, cpu_usage_percent } = cpu_time::measure_cpu(|| {
+        f(brd, gens, interval)
+    });
 
     CpuResult {
-        actual_fps: (1_000_000_000.0 * gens as f64) / duration as f64,
-        cpu_usage_percent: cpu_time::get_cpu_duration(cpu_start, cpu_stop)
-            .and_then(|cpu| cpu.num_nanoseconds())
-            .and_then(|cpu| Some(100.0 * cpu as f64 / duration as f64)),
+        actual_fps: (1_000_000_000.0 * gens as f64) / time_duration as f64,
+        cpu_usage_percent,
     }
 }
 

rayon-demo/src/life/cpu_time/win.rs renamed to rayon-demo/src/cpu_time/win.rs

@@ -5,6 +5,7 @@ use std::io;
 use std::io::prelude::*;
 use std::process::exit;
 
+mod cpu_time;
 mod life;
 mod matmul;
 mod mergesort;

rayon-demo/src/life/cpu_time/mod.rs

@@ -8,6 +8,7 @@ Options:
     --iters N        Total time to execution (in millis). [default: 100]
 ";
 
+use cpu_time;
 use docopt::Docopt;
 
 #[derive(Deserialize)]
@@ -21,8 +22,12 @@ pub fn main(args: &[String]) {
         .and_then(|d| d.argv(args).deserialize())
         .unwrap_or_else(|e| e.exit());
 
-    for _ in 1..args.flag_iters {
-        std::thread::sleep(std::time::Duration::from_millis(args.flag_sleep));
-        rayon::spawn(move || {  } );
-    }
+    let m = cpu_time::measure_cpu(|| {
+        for _ in 1..args.flag_iters {
+            std::thread::sleep(std::time::Duration::from_millis(args.flag_sleep));
+            rayon::spawn(move || {  } );
+        }
+    });
+    println!("noop --iters={} --sleep={}", args.flag_iters, args.flag_sleep);
+    cpu_time::print_time(m);
 }