Changeset cb85603


Ignore:
Timestamp:
Jun 25, 2020, 2:57:39 PM (18 months ago)
Author:
Thierry Delisle <tdelisle@…>
Branches:
arm-eh, jacob/cs343-translation, master, new-ast, new-ast-unique-expr
Children:
ec21f13
Parents:
566fde0
Message:

Moved common code of benchmarks to benchcltr.hfa

Location:
benchmark
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • benchmark/benchcltr.hfa

    r566fde0 rcb85603  
    44#include <kernel.hfa>
    55#include <thread.hfa>
     6#include <stats.hfa>
    67
     8#define BENCH_OPT_SHORT "d:p:t:SP"
     9#define BENCH_OPT_LONG \
     10        {"duration",     required_argument, 0, 'd'}, \
     11        {"nthreads",     required_argument, 0, 't'}, \
     12        {"nprocs",       required_argument, 0, 'p'}, \
     13        {"nostats",      no_argument      , 0, 'S'}, \
     14        {"procstat",     no_argument      , 0, 'P'},
     15
     16#define BENCH_DECL \
     17        double duration = 5; \
     18        int nprocs = 1; \
     19        int nthreads = 1;
     20
     21#define BENCH_OPT_CASE \
     22        case 'd': \
     23                duration = strtod(arg, &end); \
     24                if(*end != '\0') { \
     25                        fprintf(stderr, "Duration must be a valid double, was %s\n", arg); \
     26                        goto usage; \
     27                } \
     28                break; \
     29        case 't': \
     30                nthreads = strtoul(arg, &end, 10); \
     31                if(*end != '\0' || nthreads < 1) { \
     32                        fprintf(stderr, "Number of threads must be a positive integer, was %s\n", arg); \
     33                        goto usage; \
     34                } \
     35                break; \
     36        case 'p': \
     37                nprocs = strtoul(arg, &end, 10); \
     38                if(*end != '\0' || nprocs < 1) { \
     39                        fprintf(stderr, "Number of processors must be a positive integer, was %s\n", arg); \
     40                        goto usage; \
     41                } \
     42                break; \
     43        case 'S': \
     44                silent = true; \
     45                break; \
     46        case 'P': \
     47                procstats = true; \
     48                break;
     49
     50bool silent = false;
     51bool procstats = false;
    752struct cluster * the_benchmark_cluster = 0p;
    853struct BenchCluster {
    9       cluster self;
     54        cluster self;
    1055};
    1156
    12 void ?{}( BenchCluster & this, int flags ) {
    13       (this.self){ "Benchmark Cluster", flags };
     57void ?{}( BenchCluster & this, int flags, int stats ) {
     58        (this.self){ "Benchmark Cluster", flags };
    1459
    15       assert( the_benchmark_cluster == 0p );
    16       the_benchmark_cluster = &this.self;
     60        assert( the_benchmark_cluster == 0p );
     61        the_benchmark_cluster = &this.self;
     62
     63        #if !defined(__CFA_NO_STATISTICS__)
     64                if( !silent ) {
     65                        print_stats_at_exit( this.self, stats );
     66                }
     67        #endif
    1768}
    1869
     
    2273
    2374void ?{}( BenchProc & this ) {
    24       assert( the_benchmark_cluster != 0p );
     75        assert( the_benchmark_cluster != 0p );
    2576        (this.self){ "Benchmark Processor", *the_benchmark_cluster };
     77
     78        #if !defined(__CFA_NO_STATISTICS__)
     79                if( procstats ) {
     80                        print_stats_at_exit( this.self, the_benchmark_cluster->print_stats );
     81                }
     82        #endif
    2683}
    2784
    2885void wait(double duration, Time & start, Time & end, bool is_tty) {
    29       for() {
    30             sleep(100`ms);
    31             end = getTimeNsec();
    32             Duration delta = end - start;
    33             if(is_tty) {
    34                   printf("\r%.1f", delta`ds);
    35                   fflush(stdout);
    36             }
    37             if( delta >= duration`s ) {
    38                   break;
    39             }
    40       }
     86        for() {
     87                sleep(100`ms);
     88                end = getTimeNsec();
     89                Duration delta = end - start;
     90                if(is_tty) {
     91                        printf("\r%.1f", delta`ds);
     92                        fflush(stdout);
     93                }
     94                if( delta >= duration`s ) {
     95                        break;
     96                }
     97        }
    4198}
     99
     100void bench_usage( char * argv [] ) {
     101        fprintf( stderr, "Usage: %s : [options]\n", argv[0] );
     102        fprintf( stderr, "\n" );
     103        fprintf( stderr, "  -d, --duration=DURATION  Duration of the experiment, in seconds\n" );
     104        fprintf( stderr, "  -t, --nthreads=NTHREADS  Number of user threads\n" );
     105        fprintf( stderr, "  -p, --nprocs=NPROCS      Number of kernel threads\n" );
     106        fprintf( stderr, "  -S, --nostats            Don't print cluster stats\n" );
     107        fprintf( stderr, "  -P, --procstat           Print processor stats" );
     108}
  • benchmark/io/readv.cfa

    r566fde0 rcb85603  
    5050
    5151int main(int argc, char * argv[]) {
    52         double duration   = 5.0;
    53         unsigned long int nthreads = 2;
    54         unsigned long int nprocs   = 1;
    55         bool silent = false;
    56         bool procstats = false;
     52        BENCH_DECL
    5753        unsigned flags = 0;
    5854        unsigned sublen = 16;
     
    6157        for(;;) {
    6258                static struct option options[] = {
    63                         {"duration",     required_argument, 0, 'd'},
    64                         {"nthreads",     required_argument, 0, 't'},
    65                         {"nprocs",       required_argument, 0, 'p'},
    66                         {"nostats",      no_argument      , 0, 'S'},
    67                         {"procstat",     no_argument      , 0, 'P'},
     59                        BENCH_OPT_LONG
    6860                        {"bufsize",      required_argument, 0, 'b'},
    6961                        {"userthread",   no_argument      , 0, 'u'},
     
    7466
    7567                int idx = 0;
    76                 int opt = getopt_long(argc, argv, "d:t:p:SPb:usl:", options, &idx);
     68                int opt = getopt_long(argc, argv, BENCH_OPT_SHORT "b:usl:", options, &idx);
    7769
    7870                const char * arg = optarg ? optarg : "";
     
    8274                        case -1:
    8375                                break arg_loop;
    84                         // Numeric Arguments
    85                         case 'd':
    86                                 duration = strtod(arg, &end);
    87                                 if(*end != '\0') {
    88                                         fprintf(stderr, "Duration must be a valid double, was %s\n", arg);
    89                                         goto usage;
    90                                 }
    91                                 break;
    92                         case 't':
    93                                 nthreads = strtoul(arg, &end, 10);
    94                                 if(*end != '\0' || nthreads < 1) {
    95                                         fprintf(stderr, "Number of threads must be a positive integer, was %s\n", arg);
    96                                         goto usage;
    97                                 }
    98                                 break;
    99                         case 'p':
    100                                 nprocs = strtoul(arg, &end, 10);
    101                                 if(*end != '\0' || nprocs < 1) {
    102                                         fprintf(stderr, "Number of processors must be a positive integer, was %s\n", arg);
    103                                         goto usage;
    104                                 }
    105                                 break;
    106                         case 'S':
    107                                 silent = true;
    108                                 break;
    109                         case 'P':
    110                                 procstats = true;
    111                                 break;
     76                        BENCH_OPT_CASE
    11277                        case 'b':
    11378                                buflen = strtoul(arg, &end, 10);
     
    13196                                flags |= (sublen << CFA_CLUSTER_IO_BUFFLEN_OFFSET);
    13297                                break;
    133                         // Other cases
    13498                        default: /* ? */
    13599                                fprintf(stderr, "%d\n", opt);
    136100                        usage:
    137                                 fprintf( stderr, "Usage: %s : [options]\n", argv[0] );
    138                                 fprintf( stderr, "\n" );
    139                                 fprintf( stderr, "  -d, --duration=DURATION  Duration of the experiment, in seconds\n" );
    140                                 fprintf( stderr, "  -t, --nthreads=NTHREADS  Number of user threads\n" );
    141                                 fprintf( stderr, "  -p, --nprocs=NPROCS      Number of kernel threads\n" );
    142                                 fprintf( stderr, "  -S, --nostats            Don't print cluster stats\n" );
    143                                 fprintf( stderr, "  -P, --procstat           Print processor stats" );
     101                                bench_usage( argv );
    144102                                fprintf( stderr, "  -b, --buflen=SIZE        Number of bytes to read per request\n" );
    145103                                fprintf( stderr, "  -u, --userthread         If set, cluster uses user-thread to poll I/O\n" );
     
    155113        }
    156114
    157         printf("Running %lu threads, reading %lu bytes each, over %lu processors for %lf seconds\n", nthreads, buflen, nprocs, duration);
     115        printf("Running %d threads, reading %lu bytes each, over %d processors for %f seconds\n", nthreads, buflen, nprocs, duration);
    158116
    159117        {
    160118                Time start, end;
    161                 BenchCluster cl = { flags };
    162                 #if !defined(__CFA_NO_STATISTICS__)
    163                         if( !silent ) {
    164                                 print_stats_at_exit( cl.self, CFA_STATS_READY_Q | CFA_STATS_IO );
    165                         }
    166                 #endif
     119                BenchCluster cl = { flags, CFA_STATS_READY_Q | CFA_STATS_IO };
    167120                {
    168121                        BenchProc procs[nprocs];
    169                         #if !defined(__CFA_NO_STATISTICS__)
    170                                 if( procstats ) {
    171                                         for(i; nprocs) {
    172                                                 print_stats_at_exit( procs[i].self, CFA_STATS_READY_Q | CFA_STATS_IO );
    173                                         }
    174                                 }
    175                         #endif
    176122                        {
    177123                                Reader threads[nthreads];
  • benchmark/readyQ/yield.cfa

    r566fde0 rcb85603  
    4343
    4444int main(int argc, char * argv[]) {
    45         double duration = 5;
    46         int nprocs = 1;
    47         int nthreads = 1;
    48         bool silent = false;
    49         bool procstats = false;
     45        BENCH_DECL
    5046
    5147        for(;;) {
    5248                static struct option options[] = {
    53                         {"duration",  required_argument, 0, 'd'},
    54                         {"nprocs",    required_argument, 0, 'p'},
    55                         {"nthreads",  required_argument, 0, 't'},
    56                         {"nostats",   no_argument      , 0, 'S'},
    57                         {"procstat",  no_argument      , 0, 'P'},
     49                        BENCH_OPT_LONG
    5850                        {0, 0, 0, 0}
    5951                };
    6052
    6153                int idx = 0;
    62                 int opt = getopt_long(argc, argv, "d:p:t:SP", options, &idx);
     54                int opt = getopt_long(argc, argv, BENCH_OPT_SHORT, options, &idx);
    6355
    64                 char * arg = optarg ? optarg : "";
    65                 size_t len = 0;
     56                const char * arg = optarg ? optarg : "";
    6657                char * end;
    6758                switch(opt) {
    6859                        case -1:
    6960                                goto run;
    70                         // Numeric Arguments
    71                         case 'd':
    72                                 duration = strtod(arg, &end);
    73                                 if(*end != '\0') {
    74                                         fprintf(stderr, "Duration must be a valid double, was %s\n", arg);
    75                                         goto usage;
    76                                 }
    77                                 break;
    78                         case 't':
    79                                 nthreads = strtoul(arg, &end, 10);
    80                                 if(*end != '\0' || nthreads < 1) {
    81                                         fprintf(stderr, "Number of threads must be a positive integer, was %s\n", arg);
    82                                         goto usage;
    83                                 }
    84                                 break;
    85                         case 'p':
    86                                 nprocs = strtoul(arg, &end, 10);
    87                                 if(*end != '\0' || nprocs < 1) {
    88                                         fprintf(stderr, "Number of processors must be a positive integer, was %s\n", arg);
    89                                         goto usage;
    90                                 }
    91                                 break;
    92                         case 'S':
    93                                 silent = true;
    94                                 break;
    95                         case 'P':
    96                                 procstats = true;
    97                                 break;
    98                         // Other cases
     61                        BENCH_OPT_CASE
    9962                        default: /* ? */
    10063                                fprintf( stderr, "Unkown option '%c'\n", opt);
    10164                        usage:
    102                                 fprintf( stderr, "Usage: %s [options]\n", argv[0]);
    103                                 fprintf( stderr, "\n" );
    104                                 fprintf( stderr, "  -d, --duration=DURATION  Duration of the experiment, in seconds\n" );
    105                                 fprintf( stderr, "  -t, --nthreads=NTHREADS  Number of kernel threads\n" );
    106                                 fprintf( stderr, "  -q, --nqueues=NQUEUES    Number of queues per threads\n" );
    107                                 fprintf( stderr, "  -S, --nostats            Don't print cluster stats\n" );
    108                                 fprintf( stderr, "  -P, --procstat           Print processor stats" );
     65                                bench_usage( argv );
    10966                                exit(1);
    11067                }
     
    11370
    11471        {
    115                 printf("Running %d threads on %d processors for %lf seconds\n", nthreads, nprocs, duration);
     72                printf("Running %d threads on %d processors for %f seconds\n", nthreads, nprocs, duration);
    11673
    11774                Time start, end;
    118                 BenchCluster cl = { 0 };
    119                 #if !defined(__CFA_NO_STATISTICS__)
    120                         if( !silent ) {
    121                                 print_stats_at_exit( cl.self, CFA_STATS_READY_Q );
    122                         }
    123                 #endif
     75                BenchCluster cl = { 0, CFA_STATS_READY_Q };
    12476                {
    12577                        BenchProc procs[nprocs];
    126                         #if !defined(__CFA_NO_STATISTICS__)
    127                                 if( procstats ) {
    128                                         for(i; nprocs) {
    129                                                 print_stats_at_exit( procs[i].self, CFA_STATS_READY_Q );
    130                                         }
    131                                 }
    132                         #endif
    13378                        {
    13479                                Yielder threads[nthreads];
Note: See TracChangeset for help on using the changeset viewer.