Changeset f03209d3

Timestamp:

Jan 5, 2021, 5:51:30 PM (4 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

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

Children:

4468a70, 587a608

Parents:

ed1a6374

Message:

Locality benchmark now supports explicit number of spots instead of using nthreads - nprocs

Location:

benchmark/readyQ

Files:

• locality.cfa (modified) (5 diffs)
• locality.cpp (modified) (7 diffs)
• locality.go (modified) (3 diffs)
• locality.rs (modified) (3 diffs)

benchmark/readyQ/locality.cfa

@@ -184 +184 @@
         unsigned wsize = 2;
         unsigned wcnt  = 2;
+        unsigned nspots = 0;
         bool share = false;
         cfa_option opt[] = {
                 BENCH_OPT,
+                { 'n', "nspots", "Number of spots where threads sleep (nthreads - nspots are active at the same time)", nspots},
                 { 'w', "worksize", "Size of the array for each threads, in words (64bit)", wsize},
                 { 'c', "workcnt" , "Number of words to touch when working (random pick, cells can be picked more than once)", wcnt },
@@ -196 +198 @@
         unsigned long long global_gmigs = 0;
         unsigned long long global_dmigs = 0;
+
+        if( nspots == 0 ) { nspots = nthreads - nprocs; }
 
         Time start, end;
@@ -205 +209 @@
                 }
 
-                MySpot * spots[nthreads - nprocs];
-                for(i; nthreads - nprocs) {
+                MySpot * spots[nspots];
+                for(i; nspots) {
                         spots[i] = malloc();
                         (*spots[i]){ i };
@@ -220 +224 @@
                                         data_arrays[i],
                                         spots,
-                                        nthreads - nprocs,
+                                        nspots,
                                         wcnt,
                                         share,
@@ -258 +262 @@
                 }
 
-                for(i; nthreads - nprocs) {
+                for(i; nspots) {
                         ^( *spots[i] ){};
                         free( spots[i] );

benchmark/readyQ/locality.cpp

@@ -201 +201 @@
 
 void thread_main( MyCtx & ctx ) {
-        uint64_t state;
+        uint64_t state = ctx.id;
 
         // Wait for start
@@ -237 +237 @@
         unsigned wsize = 2;
         unsigned wcnt  = 2;
+        unsigned nspots = 0;
         bool share = false;
         option_t opt[] = {
                 BENCH_OPT,
+                { 'n', "nspots", "Number of spots where threads sleep (nthreads - nspots are active at the same time)", nspots},
                 { 'w', "worksize", "Size of the array for each threads, in words (64bit)", wsize},
                 { 'c', "workcnt" , "Number of words to touch when working (random pick, cells can be picked more than once)", wcnt },
@@ -252 +254 @@
         unsigned long long global_gmigs = 0;
         unsigned long long global_dmigs = 0;
+
+        if( nspots == 0 ) { nspots = nthreads - nprocs; }
 
         uint64_t start, end;
@@ -261 +265 @@
                 }
 
-                MySpot * spots[nthreads - nprocs];
-                for(size_t i = 0; i < (nthreads - nprocs); i++) {
+                MySpot * spots[nspots];
+                for(unsigned i = 0; i < nspots; i++) {
                         spots[i] = new MySpot{ i };
                 }
 
-                threads_left = nthreads;
+                threads_left = nthreads - nspots;
                 Fibre * threads[nthreads];
                 MyCtx * thddata[nthreads];
@@ -274 +278 @@
                                         data_arrays[i],
                                         spots,
-                                        nthreads - nprocs,
+                                        nspots,
                                         wcnt,
                                         share,
@@ -307 +311 @@
                 }
 
-                for(size_t i = 0; i < (nthreads - nprocs); i++) {
+                for(size_t i = 0; i < nspots; i++) {
                         delete( spots[i] );
                 }
@@ -315 +319 @@
         printf("Number of processors   : %'d\n", nprocs);
         printf("Number of threads      : %'d\n", nthreads);
-        printf("Total Operations(ops)  : %'15llu\n", global_count);
+        printf("Number of spots        : %'d\n", nspots);
         printf("Work size (64bit words): %'15u\n", wsize);
         printf("Total Operations(ops)  : %'15llu\n", global_count);
         printf("Total G Migrations     : %'15llu\n", global_gmigs);
         printf("Total D Migrations     : %'15llu\n", global_dmigs);
-        printf("Ops per second       : %'18.2lf\n", ((double)global_count) / to_fseconds(end - start));
-        printf("ns per ops           : %'18.2lf\n", ((double)(end - start)) / global_count);
-        printf("Ops per threads      : %'15llu\n", global_count / nthreads);
-        printf("Ops per procs        : %'15llu\n", global_count / nprocs);
-        printf("Ops/sec/procs        : %'18.2lf\n", (((double)global_count) / nprocs) / to_fseconds(end - start));
-        printf("ns per ops/procs     : %'18.2lf\n", ((double)(end - start)) / (global_count / nprocs));
+        printf("Ops per second         : %'18.2lf\n", ((double)global_count) / to_fseconds(end - start));
+        printf("ns per ops             : %'18.2lf\n", ((double)(end - start)) / global_count);
+        printf("Ops per threads        : %'15llu\n", global_count / nthreads);
+        printf("Ops per procs          : %'15llu\n", global_count / nprocs);
+        printf("Ops/sec/procs          : %'18.2lf\n", (((double)global_count) / nprocs) / to_fseconds(end - start));
+        printf("ns per ops/procs       : %'18.2lf\n", ((double)(end - start)) / (global_count / nprocs));
         fflush(stdout);
 }

benchmark/readyQ/locality.go

@@ -221 +221 @@
 func main() {
         // Benchmark specific command line arguments
+        nspotsOpt    := flag.Int   ("n", 0    , "Number of spots where threads sleep (nthreads - nspots are active at the same time)")
         work_sizeOpt := flag.Uint64("w", 2    , "Size of the array for each threads, in words (64bit)")
         countOpt     := flag.Uint64("c", 2    , "Number of words to touch when working (random pick, cells can be picked more than once)")
@@ -229 +230 @@
 
         // Eval command line arguments
+        nspots:= *nspotsOpt
         size  := *work_sizeOpt
         cnt   := *countOpt
         share := *shareOpt
+
+        if nspots == 0 { nspots = nthreads - nprocs; }
 
         // Check params
@@ -241 +245 @@
         // Make global data
         barrierStart := make(chan struct{})         // Barrier used at the start
-        threads_left = int64(nprocs)                // Counter for active threads (not 'nthreads' because at all times 'nthreads - nprocs' are blocked)
+        threads_left = int64(nthreads - nspots)                // Counter for active threads (not 'nthreads' because at all times 'nthreads - nprocs' are blocked)
         result  := make(chan Result)                // Channel for results
-        channels := make([]Spot, nthreads - nprocs) // Number of spots
+        channels := make([]Spot, nspots) // Number of spots
         for i := range channels {
                 channels[i] = Spot{[16]uint64{0},uintptr(0), i,[16]uint64{0}}     // init spots

benchmark/readyQ/locality.rs

@@ -257 +257 @@
         let options = App::new("Locality Tokio")
                 .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)"))
-                .arg(Arg::with_name("share").short("s").long("share")   .takes_value(true).default_value("true").help("Pass the work data to the next thread when blocking"))
+                .arg(Arg::with_name("nspots").short("n").long("nspots")  .takes_value(true).default_value("0").help("Number of spots where threads sleep (nthreads - nspots are active at the same time)"))
+                .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)"))
+                .arg(Arg::with_name("share") .short("s").long("share")   .takes_value(true).default_value("true").help("Pass the work data to the next thread when blocking"))
                 .get_matches();
 
@@ -267 +268 @@
         let wcnt       = options.value_of("work").unwrap().parse::<u64>().unwrap();
         let share      = options.value_of("share").unwrap().parse::<bool>().unwrap();
+        let nspots = {
+                let val = options.value_of("nspots").unwrap().parse::<usize>().unwrap();
+                if val != 0 {
+                        val
+                } else {
+                        nthreads - nprocs
+                }
+        };
 
         // Check params
@@ -282 +291 @@
 
         let mut data_arrays : Vec<MyData> = (0..nthreads).map(|i| MyData::new(i, wsize)).rev().collect();
-        let spots : Arc<Vec<MySpot>> = Arc::new((0..nthreads - nprocs).map(|i| MySpot::new(i)).rev().collect());
+        let spots : Arc<Vec<MySpot>> = Arc::new((0..nspots).map(|i| MySpot::new(i)).rev().collect());
         let barr = Arc::new(sync::Barrier::new(nthreads + 1));