source: benchmark/bench.rs @ 660665f

use std::io::{self, Write};
use std::sync::atomic::{AtomicU64, AtomicBool, Ordering};
use std::time::{Instant,Duration};

use clap::{Arg, ArgMatches};
use isatty::stdout_isatty;

use tokio::time;


// ==================================================
pub fn args<'a, 'b>() -> [Arg<'a, 'b>; 4] {[
        Arg::with_name("duration")  .short("d").long("duration")  .takes_value(true).default_value("5").help("Duration of the experiments in seconds"),
        Arg::with_name("iterations").short("i").long("iterations").takes_value(true).conflicts_with("duration").help("Number of iterations of the experiments"),
        Arg::with_name("nthreads")  .short("t").long("nthreads")  .takes_value(true).default_value("1").help("Number of threads to use"),
        Arg::with_name("nprocs")    .short("p").long("nprocs")    .takes_value(true).default_value("1").help("Number of processors to use")
]}

pub struct BenchData {
        pub clock_mode: bool,
        pub stop: AtomicBool,
        pub stop_count: u64,
        pub duration: f64,
        pub threads_left: AtomicU64,
        is_tty: bool,
}

impl BenchData {
        pub fn new(options: ArgMatches, nthreads: usize) -> BenchData {
                let (clock_mode, stop_count, duration) = if options.is_present("iterations") {
                        (false,
                        options.value_of("iterations").unwrap().parse::<u64>().unwrap(),
                        -1.0)
                } else {
                        (true,
                        std::u64::MAX,
                        options.value_of("duration").unwrap().parse::<f64>().unwrap())
                };

                BenchData{
                        clock_mode: clock_mode,
                        stop: AtomicBool::new(false),
                        stop_count: stop_count,
                        duration: duration,
                        threads_left: AtomicU64::new(nthreads as u64),
                        is_tty: stdout_isatty(),
                }
        }

        pub async fn wait(&self, start: &Instant) -> Duration{
                loop {
                        time::sleep(Duration::from_micros(100000)).await;
                        let delta = start.elapsed();
                        if self.is_tty {
                                print!(" {:.1}\r", delta.as_secs_f32());
                                io::stdout().flush().unwrap();
                        }
                        if self.clock_mode && delta >= Duration::from_secs_f64(self.duration)  {
                                break;
                        }
                        else if !self.clock_mode && self.threads_left.load(Ordering::Relaxed) == 0 {
                                break;
                        }
                }

                self.stop.store(true, Ordering::SeqCst);
                return start.elapsed();
        }
}