Ignore:
Timestamp:
Jun 7, 2023, 1:34:08 PM (21 months ago)
Author:
caparson <caparson@…>
Branches:
master
Children:
fa5e1aa5
Parents:
ded6c2a6
Message:

refactored waituntil future benchmarks and updated runscript

Location:
doc/theses/colby_parsons_MMAth/benchmarks/waituntil
Files:
3 edited

Legend:

Unmodified
Added
Removed

  • TabularUnified doc/theses/colby_parsons_MMAth/benchmarks/waituntil/cfa/future.cfa

    rded6c2a6 rb5e3a80  
    77#include <string.h>
    88
    9 size_t Clients = 1, Time = 10;
     9// #define ANDOR
     10
     11size_t Processors = 2, Time = 10;
    1012
    1113size_t globalTotal = 0;
    1214future(size_t) A, B, C;
    13 volatile bool server_done_loop = false;
    14 volatile bool client_done_loop = false;
     15volatile bool done_loop = false;
    1516volatile bool client_done = false;
    1617volatile bool server_done = false;
    1718
    18 volatile size_t client_count = 0;
    19 volatile size_t client_loop_count = 0;
     19static inline void wait() {
     20    #ifdef OR
     21    waituntil( A ) { get( A ); }
     22    or waituntil( B ) { get( B ); }
     23    or waituntil( C ) { get( C ); }
     24    #endif
     25    #ifdef AND
     26    waituntil( A ) { get( A ); }
     27    and waituntil( B ) { get( B ); }
     28    #endif
     29    #ifdef AND3
     30    waituntil( A ) { get( A ); }
     31    and waituntil( B ) { get( B ); }
     32    and waituntil( C ) { get( C ); }
     33    #endif
     34    #ifdef ANDOR
     35    waituntil( A ) { get( A ); }
     36    and waituntil( B ) { get( B ); }
     37    or waituntil( C ) { get( C ); }
     38    #endif
     39    #ifdef ORAND
     40    (waituntil( A ) { get( A ); }
     41    or waituntil( B ) { get( B ); })
     42    and waituntil( C ) { get( C ); }
     43    #endif
     44    #ifdef BASIC
     45    get( A );
     46    #endif
     47}
     48
     49static inline fulfill( size_t i ) {
     50    #ifdef OR
     51    if ( i % 3 == 0 ) {
     52        fulfil(A, i);
     53    } else if ( i % 3 == 1 ) {
     54        fulfil(B, i);
     55    } else {
     56        fulfil(C, i);
     57    }
     58    #endif
     59    #ifdef AND
     60    if ( i % 2 == 0 ) {
     61        fulfil(A, i);
     62        fulfil(B, i);
     63    } else {
     64        fulfil(B, i);
     65        fulfil(A, i);
     66    }
     67    #endif
     68    #ifdef AND3
     69    if ( i % 6 == 0 ) {
     70        fulfil(A, i);
     71        fulfil(B, i);
     72        fulfil(C, i);
     73    } else if ( i % 6 == 1 ) {
     74        fulfil(A, i);
     75        fulfil(C, i);
     76        fulfil(B, i);
     77    } else if ( i % 6 == 2 ) {
     78        fulfil(B, i);
     79        fulfil(A, i);
     80        fulfil(C, i);
     81    } else if ( i % 6 == 3 ) {
     82        fulfil(B, i);
     83        fulfil(C, i);
     84        fulfil(A, i);
     85    } else if ( i % 6 == 4 ) {
     86        fulfil(C, i);
     87        fulfil(A, i);
     88        fulfil(B, i);
     89    } else if ( i % 6 == 5 ) {
     90        fulfil(C, i);
     91        fulfil(B, i);
     92        fulfil(A, i);
     93    }
     94    #endif
     95    #ifdef ANDOR
     96    if ( i % 4 == 0 ) {
     97        fulfil(A, i);
     98        fulfil(B, i);
     99    } else if ( i % 4 == 1 ) {
     100        fulfil(A, i);
     101        fulfil(C, i);
     102    } else if ( i % 4 == 2 ) {
     103        fulfil(B, i);
     104        fulfil(C, i);
     105    } else {
     106        fulfil(C, i);
     107    }
     108    #endif
     109    #ifdef ORAND
     110    if ( i % 4 == 0 ) {
     111        fulfil(A, i);
     112        fulfil(C, i);
     113    } else if ( i % 4 == 1 ) {
     114        fulfil(C, i);
     115        fulfil(A, i);
     116    } else if ( i % 4 == 2 ) {
     117        fulfil(B, i);
     118        fulfil(C, i);
     119    } else {
     120        fulfil(C, i);
     121        fulfil(B, i);
     122    }
     123    #endif
     124    #ifdef BASIC
     125    fulfil(A, i);
     126    #endif
     127}
     128
    20129thread Client {};
    21130void main( Client & this ) {
    22131    size_t i = 0;
    23     for(;; i++ ) {
    24         waituntil( A ) { get(A); }
    25         and waituntil( B ) { get(B); }
    26         or waituntil( C ) { get(C); }
    27 
    28         // needs to check after waituntil for termination synchronization
    29         if ( client_done ) break;
    30 
    31         // Barrier-like synch needed to reset futures safely
    32         if ( __atomic_add_fetch( &client_count, 1, __ATOMIC_SEQ_CST ) == Clients ) { // synchronize reset
    33             client_count = 0;
    34             reset( A );
    35             reset( B );
    36             reset( C );
    37             client_done_loop = true; // unblock clients
    38         }
    39         while( !client_done_loop ) {} // client barrier
    40         if ( __atomic_add_fetch( &client_loop_count, 1, __ATOMIC_SEQ_CST ) == Clients ) {
    41             client_done_loop = false; // reset barrier before clients can proceed past waituntil
    42             server_done_loop = true; // unblock server to restart iteration
    43             client_loop_count = 0;
    44         }
     132    for(; !client_done; i++ ) {
     133        wait();
     134        reset( A );
     135        reset( B );
     136        reset( C );
     137        done_loop = true;
    45138    }
    46139    __atomic_fetch_add( &globalTotal, i, __ATOMIC_SEQ_CST );
    … …  
    50143void main( Server & this ) {
    51144    for( size_t i = 0; !server_done; i++ ) {
    52         if ( i % 4 == 0 ) {
    53             fulfil(A, i);
    54             fulfil(B, i);
    55         } else if ( i % 4 == 1 ) {
    56             fulfil(A, i);
    57             fulfil(C, i);
    58         } else if ( i % 4 == 2 ) {
    59             fulfil(B, i);
    60             fulfil(C, i);
    61         } else {
    62             fulfil(C, i);
    63         }
    64         while( !server_done_loop && !server_done ) {} // server barrier
    65         server_done_loop = false; // reset server barrier
     145        fulfill( i );
     146        while( !done_loop ) {}
     147        done_loop = false;
    66148    }
    67149}
    … …  
    69151int main( int argc, char * argv[] ) {
    70152    switch ( argc ) {
    71           case 3:
    72                 if ( strcmp( argv[2], "d" ) != 0 ) {                    // default ?
    73                         Time = atoi( argv[2] );
    74                 } // if
    75153          case 2:
    76154                if ( strcmp( argv[1], "d" ) != 0 ) {                    // default ?
    77                         Clients = atoi( argv[1] );
    78                         if ( Clients < 1 ) goto Usage;
     155                        Time = atoi( argv[1] );
     156                        if ( Time < 0 ) goto Usage;
    79157                } // if
    80158          case 1:                                                                                       // use defaults
    … …  
    83161          Usage:
    84162                sout | "Usage: " | argv[0]
    85              | " [ clients (> 0) | 'd' (default " | Clients
    86                          | ") ] [ time (>= 0) | 'd' (default " | Time
     163             | "[ time (>= 0) | 'd' (default " | Time
    87164                         | ") ]" ;
    88165                exit( EXIT_FAILURE );
    89166        } // switch
    90     processor p[Clients];
     167    processor p[Processors - 1];
    91168
    92169    {
    93         Client c[Clients];
     170        Server s;
    94171        {
    95             Server s;
     172            Client c;
    96173
    97174            sleep(Time`s);
    98             server_done = true;
     175
     176            client_done = true;
    99177        }
    100         while( available(A) || available(B) || available(C) ) {}
    101         client_done = true;
    102         fulfil( C, 0 );
     178        server_done = true;
     179        done_loop = true;
    103180    }
    104181    printf("%zu\n", globalTotal);

  • TabularUnified doc/theses/colby_parsons_MMAth/benchmarks/waituntil/run

    rded6c2a6 rb5e3a80  
    8585}
    8686
    87 # numtimes=5
    88 numtimes=1
     87numtimes=3
     88# numtimes=1
    8989
    9090# num_threads='2 4 8 16 24 32'
    91 # side_chan_threads='6 12 18 24 30' # must be mults of 6
     91side_chan_threads='6 12 18 24 30' # must be mults of 6
    9292num_threads='2'
    93 side_chan_threads='6'
     93# side_chan_threads='6'
    9494
    9595chan_size='10'
    9696future_time='10'
     97future_flags=('-DOR' '-DAND3' '-DANDOR' '-DORAND')
     98future_names=('OR' 'AND' 'ANDOR' 'ORAND')
    9799
    98100# toggle benchmarks
    … …  
    103105spin=${false}
    104106contend=${false}
    105 sidechan=${false}
    106 # future=${false}
     107# sidechan=${false}
     108future=${false}
    107109
    108110runCFA=${true}
    … …  
    164166
    165167run_future() {
    166     for p in ${num_threads} ; do
    167         pre_args=$(( ${p} - 1 ))
    168         affinity ${p}
    169         preprint="${p}\t"
    170         repeat_command taskset -c ${taskset} ./a.${hostname} ${pre_args} ${post_args}
    171     done
     168    affinity 2
     169    preprint="2\t"
     170    repeat_command taskset -c ${taskset} ./a.${hostname} ${post_args}
    172171}
    173172
    … …  
    247246        ${cfa} ${cfa_flags} sidechan.cfa -o a.${hostname} > /dev/null 2>&1
    248247        run_side_chan
    249         rm a.${hostname}
     248        # rm a.${hostname}
    250249        cd - > /dev/null
    251250    fi # done CFA
    … …  
    262261
    263262if [ ${future} -eq ${true} ] ; then
    264     echo "future: "
    265263    post_args=${future_time}
    266     if [ ${runCFA} -eq ${true} ] ; then
    267         cd cfa # CFA RUN
    268         print_header 'CFA'
    269         ${cfa} ${cfa_flags} future.cfa -o a.${hostname} > /dev/null 2>&1
    270         run_future
    271         rm a.${hostname}
    272         cd - > /dev/null
    273     fi # done CFA
    274 
    275     if [ ${runUCPP} -eq ${true} ] ; then
    276         cd ucpp
    277         print_header 'uC++'
    278         ${UCPP} ${UCPPflags} future.cc -o a.${hostname} > /dev/null 2>&1
    279         run_future
    280         rm a.${hostname}
    281         cd - > /dev/null
    282     fi # done Go
    283 fi
    284 
     264    for i in ${!future_flags[@]}; do
     265        echo 'future '${future_names[$i]}':'
     266        if [ ${runCFA} -eq ${true} ] ; then
     267            cd cfa # CFA RUN
     268            print_header 'CFA'
     269            ${cfa} ${cfa_flags} ${future_flags[$i]} future.cfa -o a.${hostname} > /dev/null 2>&1
     270            run_future
     271            rm a.${hostname}
     272            cd - > /dev/null
     273        fi # done CFA
     274
     275        if [ ${runUCPP} -eq ${true} ] ; then
     276            cd ucpp
     277            print_header 'uC++'
     278            ${UCPP} ${UCPPflags} ${future_flags[$i]} future.cc -o a.${hostname} > /dev/null 2>&1
     279            run_future
     280            rm a.${hostname}
     281            cd - > /dev/null
     282        fi # done Go
     283    done
     284fi
     285

  • TabularUnified doc/theses/colby_parsons_MMAth/benchmarks/waituntil/ucpp/future.cc

    rded6c2a6 rb5e3a80  
    33#include <uFuture.h>
    44
    5 size_t Clients = 2, Time = 10;
     5// #define ANDOR
    66
     7size_t Processors = 2, Time = 10;
    78size_t globalTotal = 0;
    8 Future_ISM<size_t> A, B, C;
    9 volatile bool server_done_loop = false;
    10 volatile bool client_done_loop = false;
     9volatile bool done_loop = false;
    1110volatile bool client_done = false;
    1211volatile bool server_done = false;
    1312
    14 volatile size_t client_count = 0;
    15 volatile size_t client_loop_count = 0;
     13Future_ISM<size_t> A, B, C;
     14
     15static inline void wait() {
     16    #ifdef OR
     17    _Select( A ) { A(); }
     18    or _Select( B ) { B(); }
     19    or _Select( C ) { C(); }
     20    #endif
     21    #ifdef AND
     22    _Select( A ) { A(); }
     23    and _Select( B ) { B(); }
     24    #endif
     25    #ifdef AND3
     26    _Select( A ) { A(); }
     27    and _Select( B ) { B(); }
     28    and _Select( C ) { C(); }
     29    #endif
     30    #ifdef ANDOR
     31    _Select( A ) { A(); }
     32    and _Select( B ) { B(); }
     33    or _Select( C ) { C(); }
     34    #endif
     35    #ifdef ORAND
     36    (_Select( A ) { A(); }
     37    or _Select( B ) { B(); })
     38    and _Select( C ) { C(); }
     39    #endif
     40    #ifdef BASIC
     41    A();
     42    #endif
     43}
     44
     45static inline void fulfill( size_t i ) {
     46    #ifdef OR
     47    if ( i % 3 == 0 ) {
     48        A.delivery(i);
     49    } else if ( i % 3 == 1 ) {
     50        B.delivery(i);
     51    } else {
     52        C.delivery(i);
     53    }
     54    #endif
     55    #ifdef AND
     56    if ( i % 2 == 0 ) {
     57        A.delivery(i);
     58        B.delivery(i);
     59    } else {
     60        B.delivery(i);
     61        A.delivery(i);
     62    }
     63    #endif
     64    #ifdef AND3
     65    if ( i % 6 == 0 ) {
     66        A.delivery(i);
     67        B.delivery(i);
     68        C.delivery(i);
     69    } else if ( i % 6 == 1 ) {
     70        A.delivery(i);
     71        C.delivery(i);
     72        B.delivery(i);
     73    } else if ( i % 6 == 2 ) {
     74        B.delivery(i);
     75        A.delivery(i);
     76        C.delivery(i);
     77    } else if ( i % 6 == 3 ) {
     78        B.delivery(i);
     79        C.delivery(i);
     80        A.delivery(i);
     81    } else if ( i % 6 == 4 ) {
     82        C.delivery(i);
     83        A.delivery(i);
     84        B.delivery(i);
     85    } else if ( i % 6 == 5 ) {
     86        C.delivery(i);
     87        B.delivery(i);
     88        A.delivery(i);
     89    }
     90    #endif
     91    #ifdef ANDOR
     92    if ( i % 4 == 0 ) {
     93        A.delivery(i);
     94        B.delivery(i);
     95    } else if ( i % 4 == 1 ) {
     96        A.delivery(i);
     97        C.delivery(i);
     98    } else if ( i % 4 == 2 ) {
     99        B.delivery(i);
     100        C.delivery(i);
     101    } else {
     102        C.delivery(i);
     103    }
     104    #endif
     105    #ifdef ORAND
     106    if ( i % 4 == 0 ) {
     107        A.delivery(i);
     108        C.delivery(i);
     109    } else if ( i % 4 == 1 ) {
     110        C.delivery(i);
     111        A.delivery(i);
     112    } else if ( i % 4 == 2 ) {
     113        B.delivery(i);
     114        C.delivery(i);
     115    } else {
     116        C.delivery(i);
     117        B.delivery(i);
     118    }
     119    #endif
     120    #ifdef BASIC
     121    A.delivery(i);
     122    #endif
     123}
     124
    16125_Task Client {
    17126        void main() {
    18127                size_t i = 0;
    19         for(;; i++ ) {
    20             _Select( A ) { A(); }
    21             and _Select( B ) { B(); }
    22             or _Select( C ) { C(); }
    23 
    24             // needs to check after waituntil for termination synchronization
    25             if ( client_done ) break;
    26            
    27             // Barrier-like synch needed to reset futures safely
    28             if ( __atomic_add_fetch(&client_count, 1, __ATOMIC_SEQ_CST) == Clients ) {
    29                 client_count = 0;
    30                 A.reset();
    31                 B.reset();
    32                 C.reset();
    33                 client_done_loop = true;
    34             }
    35             while( !client_done_loop ) {} // client barrier
    36             if ( __atomic_add_fetch( &client_loop_count, 1, __ATOMIC_SEQ_CST ) == Clients ) {
    37                 client_done_loop = false; // reset barrier before clients can proceed past waituntil
    38                 server_done_loop = true; // unblock server to restart iteration
    39                 client_loop_count = 0;
    40             }
     128        for(; !client_done; i++ ) {
     129            wait();
     130            A.reset();
     131            B.reset();
     132            C.reset();
     133            done_loop = true;
    41134        }
    42135        __atomic_fetch_add( &globalTotal, i, __ATOMIC_SEQ_CST );
    … …  
    47140        void main() {
    48141                for( size_t i = 0; !server_done; i++ ) {
    49             if ( i % 4 == 0 ) {
    50                 A.delivery(i);
    51                 B.delivery(i);
    52             } else if ( i % 4 == 1 ) {
    53                 A.delivery(i);
    54                 C.delivery(i);
    55             } else if ( i % 4 == 2 ) {
    56                 B.delivery(i);
    57                 C.delivery(i);
    58             } else {
    59                 C.delivery(i);
    60             }
    61             while( !server_done_loop && !server_done ) {} // server barrier
    62             server_done_loop = false; // reset server barrier
     142            fulfill( i );
     143            while( !done_loop ) {}
     144            done_loop = false;
    63145        }
    64146        }
    … …  
    67149int main( int argc, char * argv[] ) {
    68150        switch ( argc ) {
    69           case 3:
    70                 if ( strcmp( argv[2], "d" ) != 0 ) {                    // default ?
    71                         Time = atoi( argv[2] );
    72                 } // if
    73151          case 2:
    74152                if ( strcmp( argv[1], "d" ) != 0 ) {                    // default ?
    75                         Clients = atoi( argv[1] );
    76                         if ( Clients < 1 ) goto Usage;
     153                        Time = atoi( argv[1] );
     154                        if ( Time < 0 ) goto Usage;
    77155                } // if
    78156          case 1:                                                                                       // use defaults
    … …  
    81159          Usage:
    82160                cerr << "Usage: " << argv[0]
    83              << " [ clients (> 0) | 'd' (default " << Clients
    84                          << ") ] [ time (>= 0) | 'd' (default " << Time
     161             << "[ time (>= 0) | 'd' (default " << Time
    85162                         << ") ]" ;
    86163                exit( EXIT_FAILURE );
    87164        } // switch
    88     uProcessor p[Clients];
     165    uProcessor p[Processors - 1];
    89166
    90167    {
    91         Client c[Clients];
     168        Server s;
    92169        {
    93             Server s;
     170            Client c;
    94171
    95172            uBaseTask::sleep( uDuration( Time ) );
    96173
    97             server_done = true;
     174            client_done = true;
    98175        }
    99         while( A.available() || B.available() || C.available() ) {}
    100         client_done = true;
    101         C.delivery(1); // can't deliver 0 since it causes ambiguity
     176        server_done = true;
     177        done_loop = true;
    102178    }
    103179    cout << globalTotal << endl;
Note: See TracChangeset for help on using the changeset viewer.