Changeset 751e2eb for benchmark/readyQ/locality.rs

Timestamp:

Dec 18, 2020, 2:53:20 PM (2 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

arm-eh, enum, forall-pointer-decay, jacob/cs343-translation, master, new-ast-unique-expr, pthread-emulation, qualifiedEnum

Children:

5d369c7

Parents:

49ce636

Message:

Added bench.rs for common benchmark rust code

File:

• benchmark/readyQ/locality.rs (modified) (8 diffs)

benchmark/readyQ/locality.rs

@@ -1 @@
-use std::io::{self, Write};
 use std::ptr;
 use std::sync::Arc;
-use std::sync::atomic::{AtomicU64, AtomicBool, Ordering};
-use std::time::{Instant,Duration};
+use std::sync::atomic::{AtomicU64, Ordering};
+use std::time::Instant;
 use std::thread::{self, ThreadId};
 
 use tokio::runtime::Builder;
 use tokio::sync;
-use tokio::time;
-
-use clap::{Arg, App, ArgMatches};
-use isatty::stdout_isatty;
+
+use clap::{App, Arg};
 use num_format::{Locale, ToFormattedString};
 use rand::Rng;
 
-// ==================================================
-struct BenchData {
-        clock_mode: bool,
-        stop: AtomicBool,
-        stop_count: u64,
-        duration: f64,
-        threads_left: AtomicU64,
-}
-
-impl BenchData {
-        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),
-                }
-        }
-}
-
-async fn wait(bench: &BenchData, start: &Instant, is_tty: bool) {
-        loop {
-                time::sleep(Duration::from_micros(100000)).await;
-                let delta = start.elapsed();
-                if is_tty {
-                        print!(" {:.1}\r", delta.as_secs_f32());
-                        io::stdout().flush().unwrap();
-                }
-                if bench.clock_mode && delta >= Duration::from_secs_f64(bench.duration)  {
-                        break;
-                }
-                else if !bench.clock_mode && bench.threads_left.load(Ordering::Relaxed) == 0 {
-                        break;
-                }
-        }
-}
+#[path = "../bench.rs"]
+mod bench;
 
 // ==================================================
@@ -240 +192 @@
 }
 
-async fn local(start: Arc<sync::Barrier>, idata: MyDataPtr, spots : Arc<Vec<MySpot>>, cnt: u64, share: bool, id: usize, bench: Arc<BenchData>) -> Result{
+async fn local(start: Arc<sync::Barrier>, idata: MyDataPtr, spots : Arc<Vec<MySpot>>, cnt: u64, share: bool, id: usize, exp: Arc<bench::BenchData>) -> Result{
         let mut state = rand::thread_rng().gen::<u64>();
         let mut data = idata;
@@ -267 +219 @@
                 // Check if the experiment is over
                 if closed { break }                                                   // yes, spot was closed
-                if  bench.clock_mode && bench.stop.load(Ordering::Relaxed) { break }  // yes, time's up
-                if !bench.clock_mode && r.count >= bench.stop_count { break }         // yes, iterations reached
+                if  exp.clock_mode && exp.stop.load(Ordering::Relaxed) { break }  // yes, time's up
+                if !exp.clock_mode && r.count >= exp.stop_count { break }         // yes, iterations reached
 
                 assert_ne!(data.ptr as *const MyData, ptr::null());
@@ -284 +236 @@
         }
 
-        bench.threads_left.fetch_sub(1, Ordering::SeqCst);
+        exp.threads_left.fetch_sub(1, Ordering::SeqCst);
         r
 }
@@ -292 +244 @@
 fn main() {
         let options = App::new("Locality Tokio")
-                .arg(Arg::with_name("duration")  .short("d").long("duration")  .takes_value(true).default_value("5").help("Duration of the experiments in seconds"))
-                .arg(Arg::with_name("iterations").short("i").long("iterations").takes_value(true).conflicts_with("duration").help("Number of iterations of the experiments"))
-                .arg(Arg::with_name("nthreads")  .short("t").long("nthreads")  .takes_value(true).default_value("1").help("Number of threads to use"))
-                .arg(Arg::with_name("nprocs")    .short("p").long("nprocs")    .takes_value(true).default_value("1").help("Number of processors to use"))
+                .args(&bench::args())
                 .arg(Arg::with_name("size")      .short("w").long("worksize")  .takes_value(true).default_value("2").help("Size of the array for each threads, in words (64bit)"))
                 .arg(Arg::with_name("work")      .short("c").long("workcnt")   .takes_value(true).default_value("2").help("Number of words to touch when working (random pick, cells can be picked more than once)"))
@@ -315 +264 @@
         assert_eq!(&s, "1,000,000");
 
-        let bench = Arc::new(BenchData::new(options, nprocs));
+        let exp = Arc::new(bench::BenchData::new(options, nprocs));
         let mut results = Result::new();
 
@@ -342 +291 @@
                                         share,
                                         i,
-                                        bench.clone(),
+                                        exp.clone(),
                                 ))
                         }).collect();
@@ -349 +298 @@
                         println!("Starting");
 
-                        let is_tty = stdout_isatty();
                         let start = Instant::now();
                         barr.wait().await;
 
-                        wait(&bench, &start, is_tty).await;
-
-                        bench.stop.store(true, Ordering::SeqCst);
-                        elapsed = start.elapsed();
+                        elapsed = exp.wait(&start).await;
 
                         println!("\nDone");