Changeset 9791ab5


Ignore:
Timestamp:
Jun 24, 2020, 4:57:42 PM (15 months ago)
Author:
Thierry Delisle <tdelisle@…>
Branches:
arm-eh, jacob/cs343-translation, master, new-ast, new-ast-unique-expr
Children:
8b58bae
Parents:
564148f
Message:

Harmonized readv and yield benchmark

Location:
benchmark
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • benchmark/benchcltr.hfa

    r564148f r9791ab5  
    1010};
    1111
    12 void ?{}( BenchCluster & this ) {
    13       (this.self){ "Benchmark Cluster" };
     12void ?{}( BenchCluster & this, int flags ) {
     13      (this.self){ "Benchmark Cluster", flags };
    1414
    1515      assert( the_benchmark_cluster == 0p );
     
    2626}
    2727
    28 
     28void wait(double duration, Time & start, Time & end, bool is_tty) {
     29      for() {
     30            sleep(500`ms);
     31            end = getTime();
     32            if( (end - start) >= duration`s ) {
     33                  break;
     34            }
     35            if(is_tty) {
     36                  printf("\r%.4lf", (double)(end - start)`s);
     37                  fflush(stdout);
     38            }
     39      }
     40}
  • benchmark/io/readv.cfa

    r564148f r9791ab5  
    1717#include <time.hfa>
    1818
     19#include "../benchcltr.hfa"
     20
    1921extern bool traceHeapOn();
    2022extern ssize_t cfa_preadv2(int fd, const struct iovec *iov, int iovcnt, off_t offset, int flags);
     
    2628unsigned long int buflen = 50;
    2729
    28 cluster * the_cluster;
    29 
    30 thread Reader {};
     30thread __attribute__((aligned(128))) Reader {};
    3131void ?{}( Reader & this ) {
    32         ((thread&)this){ "Reader Thread", *the_cluster };
    33 }
    34 
    35 struct my_processor {
    36         processor p;
    37 };
    38 
    39 void ?{}( my_processor & this ) {
    40         (this.p){ "I/O Processor", *the_cluster };
     32        ((thread&)this){ "Reader Thread", *the_benchmark_cluster };
    4133}
    4234
    4335void main( Reader & ) {
    44         while(!__atomic_load_n(&run, __ATOMIC_RELAXED)) yield();
     36        park( __cfaabi_dbg_ctx );
     37        /* paranoid */ assert( true == __atomic_load_n(&run, __ATOMIC_RELAXED) );
    4538
    4639        char data[buflen];
     
    153146        {
    154147                Time start, end;
    155                 cluster cl = { "IO Cluster", flags };
    156                 the_cluster = &cl;
     148                BenchCluster cl = { flags };
    157149                #if !defined(__CFA_NO_STATISTICS__)
    158                         print_stats_at_exit( cl );
     150                        print_stats_at_exit( cl.self );
    159151                #endif
    160152                {
    161                         my_processor procs[nprocs];
     153                        BenchProc procs[nprocs];
    162154                        {
    163155                                Reader threads[nthreads];
    164156
    165157                                printf("Starting\n");
     158                                bool is_tty = isatty(STDOUT_FILENO);
    166159                                start = getTime();
    167160                                run = true;
    168                                 do {
    169                                         sleep(500`ms);
    170                                         end = getTime();
    171                                 } while( (end - start) < duration`s );
     161
     162                                for(i; nthreads) {
     163                                        unpark( threads[i] __cfaabi_dbg_ctx2 );
     164                                }
     165                                wait(duration, start, end, is_tty);
     166
    172167                                run = false;
    173168                                end = getTime();
    174                                 printf("Done\n");
     169                                printf("\nDone\n");
    175170                        }
    176171                }
  • benchmark/readyQ/yield.cfa

    r564148f r9791ab5  
    105105
    106106                Time start, end;
    107                 BenchCluster cl;
     107                BenchCluster cl = { 0 };
    108108                #if !defined(__CFA_NO_STATISTICS__)
    109109                        print_stats_at_exit( cl.self );
     
    113113                        {
    114114                                Yielder threads[nthreads];
     115                                printf("Starting\n");
     116
    115117                                bool is_tty = isatty(STDOUT_FILENO);
    116                                 printf("Starting\n");
    117118                                start = getTime();
    118119                                run = true;
     
    121122                                        unpark( threads[i] __cfaabi_dbg_ctx2 );
    122123                                }
    123                                 for() {
    124                                         sleep(500`ms);
    125                                         end = getTime();
    126                                         if( (end - start) >= duration`s ) {
    127                                                 break;
    128                                         }
    129                                         if(is_tty) {
    130                                                 printf("\r%.4lf", (double)(end - start)`s);
    131                                                 fflush(stdout);
    132                                         }
    133                                 }
     124                                wait(duration, start, end, is_tty);
    134125
    135126                                run = false;
    136127                                end = getTime();
    137                                 printf("Done\n");
     128                                printf("\nDone\n");
    138129                        }
    139130                }
Note: See TracChangeset for help on using the changeset viewer.