Changeset 9cf2b0f for benchmark


Ignore:
Timestamp:
May 3, 2022, 1:31:25 PM (2 years ago)
Author:
Thierry Delisle <tdelisle@…>
Branches:
ADT, ast-experimental, master, pthread-emulation, qualifiedEnum
Children:
8197ca5
Parents:
db89655
Message:

Updated yield benchmarks to be more consistents.

Location:
benchmark/readyQ
Files:
3 edited

Legend:

Unmodified
Added
Removed

  • benchmark/readyQ/yield.cfa

    rdb89655 r9cf2b0f  
    1 #include <stdlib.h>
    2 #include <stdio.h>
    3 #include <string.h>
    4 #include <limits.h>
    5 
    6 extern "C" {
    7         #include <locale.h>
    8         #include <getopt.h>
    9 }
    10 
    11 #include <unistd.h>
    12 
    13 #include <clock.hfa>
    14 #include <time.hfa>
    15 #include <stats.hfa>
    16 
    17 #include "../benchcltr.hfa"
     1#include "rq_bench.hfa"
    182
    193extern bool traceHeapOn();
    … …  
    2812void ?{}( Yielder & this ) {
    2913        this.counter = 0;
    30         ((thread&)this){ "Yielder Thread", *the_benchmark_cluster };
     14        ((thread&)this){ "Yielder Thread" };
    3115}
    3216
    … …  
    4327
    4428int main(int argc, char * argv[]) {
    45         unsigned num_io = 1;
    46         io_context_params params;
    47 
    4829        cfa_option opt[] = {
    49                 BENCH_OPT_CFA
     30                BENCH_OPT
    5031        };
    51         int opt_cnt = sizeof(opt) / sizeof(cfa_option);
    52 
    53         char **left;
    54         parse_args( argc, argv, opt, opt_cnt, "[OPTIONS]...\ncforall yield benchmark", left );
     32        BENCH_OPT_PARSE("cforall yield benchmark");
    5533
    5634        {
    … …  
    5836
    5937                Time start, end;
    60                 BenchCluster cl = { num_io, params, CFA_STATS_READY_Q };
     38                BenchCluster bc = { nprocs };
    6139                {
    62                         BenchProc procs[nprocs];
    63                         {
    64                                 Yielder threads[nthreads];
    65                                 printf("Starting\n");
     40                        Yielder threads[nthreads];
     41                        printf("Starting\n");
    6642
    67                                 bool is_tty = isatty(STDOUT_FILENO);
    68                                 start = timeHiRes();
    69                                 run = true;
     43                        bool is_tty = isatty(STDOUT_FILENO);
     44                        start = timeHiRes();
     45                        run = true;
    7046
    71                                 for(i; nthreads) {
    72                                         unpark( threads[i] );
    73                                 }
    74                                 wait(duration, start, end, is_tty);
     47                        for(i; nthreads) {
     48                                unpark( threads[i] );
     49                        }
     50                        wait(start, is_tty);
    7551
    76                                 run = false;
    77                                 end = timeHiRes();
    78                                 printf("\nDone\n");
    79                         }
     52                        run = false;
     53                        end = timeHiRes();
     54                        printf("\nDone\n");
    8055                }
    8156
    82                 printf("Duration (ms)       : %'ld\n", (end - start)`dms);
    83                 printf("Number of processors: %'d\n", nprocs);
    84                 printf("Number of threads   : %'d\n", nthreads);
    85                 printf("Total yields        : %'15llu\n", global_counter);
    86                 printf("Yields per second   : %'18.2lf\n", ((double)global_counter) / (end - start)`s);
    87                 printf("ns per yields       : %'18.2lf\n", ((double)(end - start)`ns) / global_counter);
    88                 printf("Yields per procs    : %'15llu\n", global_counter / nprocs);
    89                 printf("Yields/sec/procs    : %'18.2lf\n", (((double)global_counter) / nprocs) / (end - start)`s);
    90                 printf("ns per yields/procs : %'18.2lf\n", ((double)(end - start)`ns) / (global_counter / nprocs));
     57                printf("Duration (ms)        : %'ld\n", (end - start)`dms);
     58                printf("Number of processors : %'d\n", nprocs);
     59                printf("Number of threads    : %'d\n", nthreads);
     60                printf("Total Operations(ops): %'15llu\n", global_counter);
     61                printf("Ops per second       : %'18.2lf\n", ((double)global_counter) / (end - start)`s);
     62                printf("ns per ops           : %'18.2lf\n", (end - start)`dns / global_counter);
     63                printf("Ops per threads      : %'15llu\n", global_counter / nthreads);
     64                printf("Ops per procs        : %'15llu\n", global_counter / nprocs);
     65                printf("Ops/sec/procs        : %'18.2lf\n", (((double)global_counter) / nprocs) / (end - start)`s);
     66                printf("ns per ops/procs     : %'18.2lf\n", (end - start)`dns / (global_counter / nprocs));
    9167                fflush(stdout);
    9268        }

  • benchmark/readyQ/yield.cpp

    rdb89655 r9cf2b0f  
    1 #include <cassert>
    2 #include <cstdlib>
    3 #include <cstdio>
    4 #include <cstring>
    5 #include <climits>
    6 
    7 extern "C" {
    8         #include <locale.h>
    9         #include <getopt.h>
    10 }
    11 
    12 #include <unistd.h>
    13 
    14 #include <chrono>
    15 
    16 using Clock = std::chrono::high_resolution_clock;
    17 using duration_t = std::chrono::duration<double>;
    18 using std::chrono::nanoseconds;
    19 
    20 
    21 template<typename Ratio, typename T>
    22 T duration_cast(T seconds) {
    23         return std::chrono::duration_cast<std::chrono::duration<T, Ratio>>(std::chrono::duration<T>(seconds)).count();
    24 }
     1#include "rq_bench.hpp"
     2#include <libfibre/fibre.h>
    253
    264volatile bool run = false;
    275volatile unsigned long long global_counter;
    286
    29 #include "libfibre/fibre.h"
    307
    31 FredBarrier * barrier;
    32 struct __attribute__((aligned(128))) counter_t {
    33         int value = 0;
    34 };
     8void fibre_main() {
     9        fibre_park();
     10        unsigned long long count = 0;
     11        for(;;) {
     12                Fibre::forceYield();
     13                count++;
     14                if( clock_mode && stop) break;
     15                if(!clock_mode && count >= stop_count) break;
     16        }
    3517
    36 void fibre_main( counter_t * counter ) {
    37         barrier->wait();
    38         // /* paranoid */ assert( true == __atomic_load_n(&run, __ATOMIC_RELAXED) );
    39 
    40         while(__atomic_load_n(&run, __ATOMIC_RELAXED)) {
    41                 Fibre::forceYield();
    42                 // fibre_yield();
    43                 counter->value++;
    44         }
    45         __atomic_fetch_add(&global_counter, counter->value, __ATOMIC_SEQ_CST);
     18        __atomic_fetch_add(&global_counter, count, __ATOMIC_SEQ_CST);
     19        __atomic_fetch_add(&threads_left, -1, __ATOMIC_SEQ_CST);
    4620}
    4721
    4822int main(int argc, char * argv[]) {
    49         double duration = 5;
    50         int nprocs = 1;
    51         int nthreads = 1;
    52 
    53         std::cout.imbue(std::locale(""));
    54         setlocale(LC_ALL, "");
    55 
    56         for(;;) {
    57                 static struct option options[] = {
    58                         {"duration",  required_argument, 0, 'd'},
    59                         {"nprocs",    required_argument, 0, 'p'},
    60                         {"nthreads",  required_argument, 0, 't'},
    61                         {0, 0, 0, 0}
    62                 };
    63 
    64                 int idx = 0;
    65                 int opt = getopt_long(argc, argv, "d:p:t:", options, &idx);
    66 
    67                 const char * arg = optarg ? optarg : "";
    68                 char * end;
    69                 switch(opt) {
    70                         case -1:
    71                                 goto run;
    72                         // Numeric Arguments
    73                         case 'd':
    74                                 duration = strtod(arg, &end);
    75                                 if(*end != '\0') {
    76                                         fprintf(stderr, "Duration must be a valid double, was %s\n", arg);
    77                                         goto usage;
    78                                 }
    79                                 break;
    80                         case 't':
    81                                 nthreads = strtoul(arg, &end, 10);
    82                                 if(*end != '\0' || nthreads < 1) {
    83                                         fprintf(stderr, "Number of threads must be a positive integer, was %s\n", arg);
    84                                         goto usage;
    85                                 }
    86                                 break;
    87                         case 'p':
    88                                 nprocs = strtoul(arg, &end, 10);
    89                                 if(*end != '\0' || nprocs < 1) {
    90                                         fprintf(stderr, "Number of processors must be a positive integer, was %s\n", arg);
    91                                         goto usage;
    92                                 }
    93                                 break;
    94                         // Other cases
    95                         default: /* ? */
    96                                 fprintf( stderr, "Unkown option '%c'\n", opt);
    97                         usage:
    98                                 fprintf( stderr, "Usage: %s [options]\n", argv[0]);
    99                                 fprintf( stderr, "\n" );
    100                                 fprintf( stderr, "  -d, --duration=DURATION  Duration of the experiment, in seconds\n" );
    101                                 fprintf( stderr, "  -t, --nthreads=NTHREADS  Number of kernel threads\n" );
    102                                 fprintf( stderr, "  -q, --nqueues=NQUEUES    Number of queues per threads\n" );
    103                                 exit(1);
    104                 }
    105         }
    106         run:
     23        option_t opt[] = {
     24                BENCH_OPT
     25        };
     26        BENCH_OPT_PARSE("libfibre yield benchmark");
    10727
    10828        {
    10929                printf("Running %d threads on %d processors for %lf seconds\n", nthreads, nprocs, duration);
    11030
    111                 FibreInit();
    112                 barrier = new FredBarrier(nthreads + 1);
     31                FibreInit(1, nprocs);
     32                uint64_t start, end;
    11333                {
    114                         Context::CurrCluster().addWorkers(nprocs);
    115                         {
    116                                 counter_t counters[nthreads];
    117                                 Fibre threads[nthreads];
    118                                 for(int i = 0; i < nthreads; i++) {
    119                                         threads[i].run(fibre_main, &counters[i]);
    120                                 }
    121                                 printf("Starting\n");
    122                                 bool is_tty = isatty(STDOUT_FILENO);
    123                                 auto before = Clock::now();
    124                                 run = true;
     34                        threads_left = nthreads;
     35                        Fibre * threads[nthreads];
     36                        for(unsigned i = 0; i < nthreads; i++) {
     37                                threads[i] = new Fibre( reinterpret_cast<void (*)(void *)>(fibre_main), nullptr );
     38                        }
     39                        printf("Starting\n");
     40                        bool is_tty = isatty(STDOUT_FILENO);
     41                        start = timeHiRes();
    12542
    126                                 barrier->wait();
    127                                 for(;;) {
    128                                         usleep(500'000);
    129                                         auto now = Clock::now();
    130                                         duration_t durr = now - before;
    131                                         if( durr.count() > duration ) {
    132                                                 break;
    133                                         }
    134                                         if(is_tty) {
    135                                                 std::cout << "\r" << std::setprecision(4) << durr.count();
    136                                                 std::cout.flush();
    137                                         }
    138                                 }
     43                        for(unsigned i = 0; i < nthreads; i++ ) {
     44                                fibre_unpark( threads[i] );
     45                        }
     46                        wait<Fibre>(start, is_tty);
    13947
    140                                 auto after = Clock::now();
    141                                 duration_t durr = after - before;
    142                                 duration = durr.count();
    143                                 run = false;
    144                                 printf("\nDone\n");
    145                                 for(auto & thread : threads) {
    146                                         thread.join();
    147                                 }
    148 
    149                                 // for(const auto & counter : counters) {
    150                                 //      std::cout << counter.value << std::endl;
    151                                 // }
     48                        stop = true;
     49                        end = timeHiRes();
     50                        for(unsigned i = 0; i < nthreads; i++ ) {
     51                                fibre_join( threads[i], nullptr );
    15252                        }
    15353                }
    15454
    155                 auto dur_nano = duration_cast<std::nano>(duration);
    156                 auto dur_dms  = duration_cast<std::milli>(duration);
    157 
    158                 printf("Duration (ms)       : %'.2lf\n", dur_dms );
    159                 printf("Total yields        : %'15llu\n", global_counter );
    160                 printf("Yields per procs    : %'15llu\n", global_counter / nprocs );
    161                 printf("Yields per second   : %'18.2lf\n", ((double)global_counter) / duration );
    162                 printf("Yields/sec/procs    : %'18.2lf\n", (((double)global_counter) / nprocs) / duration );
    163                 printf("ns per yields       : %'18.2lf\n", dur_nano / global_counter );
    164                 printf("ns per yields/procs : %'18.2lf\n", dur_nano / (global_counter / nprocs) );
    165 
     55                printf("Duration (ms)        : %'ld\n", to_miliseconds(end - start));
     56                printf("Number of processors : %'d\n", nprocs);
     57                printf("Number of threads    : %'d\n", nthreads);
     58                printf("Total Operations(ops): %'15llu\n", global_counter);
     59                printf("Ops per second       : %'18.2lf\n", ((double)global_counter) / to_fseconds(end - start));
     60                printf("ns per ops           : %'18.2lf\n", ((double)(end - start)) / global_counter);
     61                printf("Ops per threads      : %'15llu\n", global_counter / nthreads);
     62                printf("Ops per procs        : %'15llu\n", global_counter / nprocs);
     63                printf("Ops/sec/procs        : %'18.2lf\n", (((double)global_counter) / nprocs) / to_fseconds(end - start));
     64                printf("ns per ops/procs     : %'18.2lf\n", ((double)(end - start)) / (global_counter / nprocs));
     65                fflush(stdout);
    16666        }
    16767}

  • benchmark/readyQ/yield.rs

    rdb89655 r9cf2b0f  
    9090        });
    9191
    92         println!("Duration (ms)       : {}", (duration.as_millis()).to_formatted_string(&Locale::en));
    93         println!("Number of processors: {}", (nprocs).to_formatted_string(&Locale::en));
    94         println!("Number of threads   : {}", (nthreads).to_formatted_string(&Locale::en));
    95         println!("Total yields        : {:>15}", (global_counter).to_formatted_string(&Locale::en));
    96         println!("Yields per second   : {:>15}", (((global_counter as f64) / duration.as_secs() as f64) as u64).to_formatted_string(&Locale::en));
    97         println!("ns per yields       : {:>15}", ((duration.as_nanos() as f64 / global_counter as f64) as u64).to_formatted_string(&Locale::en));
    98         println!("Yields per threads  : {:>15}", (global_counter / nthreads as u64).to_formatted_string(&Locale::en));
    99         println!("Yields per procs    : {:>15}", (global_counter / nprocs as u64).to_formatted_string(&Locale::en));
    100         println!("Yields/sec/procs    : {:>15}", ((((global_counter as f64) / nprocs as f64) / duration.as_secs() as f64) as u64).to_formatted_string(&Locale::en));
    101         println!("ns per yields/procs : {:>15}", ((duration.as_nanos() as f64 / (global_counter as f64 / nprocs as f64)) as u64).to_formatted_string(&Locale::en));
     92        println!("Duration (ms)        : {}", (duration.as_millis()).to_formatted_string(&Locale::en));
     93        println!("Number of processors : {}", (nprocs).to_formatted_string(&Locale::en));
     94        println!("Number of threads    : {}", (nthreads).to_formatted_string(&Locale::en));
     95        println!("Total Operations(ops): {:>15}", (global_counter).to_formatted_string(&Locale::en));
     96        println!("Ops per second       : {:>15}", (((global_counter as f64) / duration.as_secs() as f64) as u64).to_formatted_string(&Locale::en));
     97        println!("ns per ops           : {:>15}", ((duration.as_nanos() as f64 / global_counter as f64) as u64).to_formatted_string(&Locale::en));
     98        println!("Ops per threads      : {:>15}", (global_counter / nthreads as u64).to_formatted_string(&Locale::en));
     99        println!("Ops per procs        : {:>15}", (global_counter / nprocs as u64).to_formatted_string(&Locale::en));
     100        println!("Ops/sec/procs        : {:>15}", ((((global_counter as f64) / nprocs as f64) / duration.as_secs() as f64) as u64).to_formatted_string(&Locale::en));
     101        println!("ns per ops/procs    : {:>15}", ((duration.as_nanos() as f64 / (global_counter as f64 / nprocs as f64)) as u64).to_formatted_string(&Locale::en));
    102102}
Note: See TracChangeset for help on using the changeset viewer.