Changes in / [b7b3e41:33d4bc8]


Ignore:
Location:
doc/theses/colby_parsons_MMAth/benchmarks/waituntil
Files:
4 edited

Legend:

Unmodified
Added
Removed

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

    rb7b3e41 r33d4bc8  
    77#include <string.h>
    88
    9 // #define ANDOR
    10 
    11 size_t Processors = 2, Time = 10;
     9size_t Clients = 1, Time = 10;
    1210
    1311size_t globalTotal = 0;
    1412future(size_t) A, B, C;
    15 volatile bool done_loop = false;
     13volatile bool server_done_loop = false;
     14volatile bool client_done_loop = false;
    1615volatile bool client_done = false;
    1716volatile bool server_done = false;
    1817
    19 static 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 
    49 static 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 
     18volatile size_t client_count = 0;
     19volatile size_t client_loop_count = 0;
    12920thread Client {};
    13021void main( Client & this ) {
    13122    size_t i = 0;
    132     for(; !client_done; i++ ) {
    133         wait();
    134         reset( A );
    135         reset( B );
    136         reset( C );
    137         done_loop = true;
     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        }
    13845    }
    13946    __atomic_fetch_add( &globalTotal, i, __ATOMIC_SEQ_CST );
    … …  
    14350void main( Server & this ) {
    14451    for( size_t i = 0; !server_done; i++ ) {
    145         fulfill( i );
    146         while( !done_loop ) {}
    147         done_loop = false;
     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
    14866    }
    14967}
    … …  
    15169int main( int argc, char * argv[] ) {
    15270    switch ( argc ) {
     71          case 3:
     72                if ( strcmp( argv[2], "d" ) != 0 ) {                    // default ?
     73                        Time = atoi( argv[2] );
     74                } // if
    15375          case 2:
    15476                if ( strcmp( argv[1], "d" ) != 0 ) {                    // default ?
    155                         Time = atoi( argv[1] );
    156                         if ( Time < 0 ) goto Usage;
     77                        Clients = atoi( argv[1] );
     78                        if ( Clients < 1 ) goto Usage;
    15779                } // if
    15880          case 1:                                                                                       // use defaults
    … …  
    16183          Usage:
    16284                sout | "Usage: " | argv[0]
    163              | "[ time (>= 0) | 'd' (default " | Time
     85             | " [ clients (> 0) | 'd' (default " | Clients
     86                         | ") ] [ time (>= 0) | 'd' (default " | Time
    16487                         | ") ]" ;
    16588                exit( EXIT_FAILURE );
    16689        } // switch
    167     processor p[Processors - 1];
     90    processor p[Clients];
    16891
    16992    {
    170         Server s;
     93        Client c[Clients];
    17194        {
    172             Client c;
     95            Server s;
    17396
    17497            sleep(Time`s);
    175 
    176             client_done = true;
     98            server_done = true;
    17799        }
    178         server_done = true;
    179         done_loop = true;
     100        while( available(A) || available(B) || available(C) ) {}
     101        client_done = true;
     102        fulfil( C, 0 );
    180103    }
    181104    printf("%zu\n", globalTotal);

  • doc/theses/colby_parsons_MMAth/benchmarks/waituntil/cfa/sidechan.cfa

    rb7b3e41 r33d4bc8  
    3737thread Consumer {};
    3838void main( Consumer & this ) {
    39     const int idx = __atomic_fetch_add( &cons_counter, 1, __ATOMIC_SEQ_CST ) % Channels;
     39    int idx = __atomic_fetch_add( &cons_counter, 1, __ATOMIC_SEQ_CST ) % Channels;
    4040    size_t val, i = 0;
    4141    try {
    … …  
    4949thread Producer {};
    5050void main( Producer & this ) {
    51     const int idx = __atomic_fetch_add( &prod_counter, 1, __ATOMIC_SEQ_CST ) % Channels;
     51    int idx = __atomic_fetch_add( &prod_counter, 1, __ATOMIC_SEQ_CST ) % Channels;
    5252    try {
    5353        for( size_t i = 0;; i++ ) {

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

    rb7b3e41 r33d4bc8  
    8585}
    8686
    87 numtimes=3
    88 # numtimes=1
     87# numtimes=5
     88numtimes=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
     91# side_chan_threads='6 12 18 24 30' # must be mults of 6
    9292num_threads='2'
    93 # side_chan_threads='6'
     93side_chan_threads='6'
    9494
    9595chan_size='10'
    9696future_time='10'
    97 future_flags=('-DOR' '-DAND3' '-DANDOR' '-DORAND')
    98 future_names=('OR' 'AND' 'ANDOR' 'ORAND')
    9997
    10098# toggle benchmarks
    … …  
    105103spin=${false}
    106104contend=${false}
    107 # sidechan=${false}
    108 future=${false}
     105sidechan=${false}
     106# future=${false}
    109107
    110108runCFA=${true}
    … …  
    166164
    167165run_future() {
    168     affinity 2
    169     preprint="2\t"
    170     repeat_command taskset -c ${taskset} ./a.${hostname} ${post_args}
     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
    171172}
    172173
    … …  
    246247        ${cfa} ${cfa_flags} sidechan.cfa -o a.${hostname} > /dev/null 2>&1
    247248        run_side_chan
    248         # rm a.${hostname}
     249        rm a.${hostname}
    249250        cd - > /dev/null
    250251    fi # done CFA
    … …  
    261262
    262263if [ ${future} -eq ${true} ] ; then
     264    echo "future: "
    263265    post_args=${future_time}
    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
    284 fi
    285 
     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
     283fi
     284

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

    rb7b3e41 r33d4bc8  
    33#include <uFuture.h>
    44
    5 // #define ANDOR
     5size_t Clients = 2, Time = 10;
    66
    7 size_t Processors = 2, Time = 10;
    87size_t globalTotal = 0;
    9 volatile bool done_loop = false;
     8Future_ISM<size_t> A, B, C;
     9volatile bool server_done_loop = false;
     10volatile bool client_done_loop = false;
    1011volatile bool client_done = false;
    1112volatile bool server_done = false;
    1213
    13 Future_ISM<size_t> A, B, C;
    14 
    15 static 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 
    45 static 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 
     14volatile size_t client_count = 0;
     15volatile size_t client_loop_count = 0;
    12516_Task Client {
    12617        void main() {
    12718                size_t i = 0;
    128         for(; !client_done; i++ ) {
    129             wait();
    130             A.reset();
    131             B.reset();
    132             C.reset();
    133             done_loop = true;
     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            }
    13441        }
    13542        __atomic_fetch_add( &globalTotal, i, __ATOMIC_SEQ_CST );
    … …  
    14047        void main() {
    14148                for( size_t i = 0; !server_done; i++ ) {
    142             fulfill( i );
    143             while( !done_loop ) {}
    144             done_loop = false;
     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
    14563        }
    14664        }
    … …  
    14967int main( int argc, char * argv[] ) {
    15068        switch ( argc ) {
     69          case 3:
     70                if ( strcmp( argv[2], "d" ) != 0 ) {                    // default ?
     71                        Time = atoi( argv[2] );
     72                } // if
    15173          case 2:
    15274                if ( strcmp( argv[1], "d" ) != 0 ) {                    // default ?
    153                         Time = atoi( argv[1] );
    154                         if ( Time < 0 ) goto Usage;
     75                        Clients = atoi( argv[1] );
     76                        if ( Clients < 1 ) goto Usage;
    15577                } // if
    15678          case 1:                                                                                       // use defaults
    … …  
    15981          Usage:
    16082                cerr << "Usage: " << argv[0]
    161              << "[ time (>= 0) | 'd' (default " << Time
     83             << " [ clients (> 0) | 'd' (default " << Clients
     84                         << ") ] [ time (>= 0) | 'd' (default " << Time
    16285                         << ") ]" ;
    16386                exit( EXIT_FAILURE );
    16487        } // switch
    165     uProcessor p[Processors - 1];
     88    uProcessor p[Clients];
    16689
    16790    {
    168         Server s;
     91        Client c[Clients];
    16992        {
    170             Client c;
     93            Server s;
    17194
    17295            uBaseTask::sleep( uDuration( Time ) );
    17396
    174             client_done = true;
     97            server_done = true;
    17598        }
    176         server_done = true;
    177         done_loop = true;
     99        while( A.available() || B.available() || C.available() ) {}
     100        client_done = true;
     101        C.delivery(1); // can't deliver 0 since it causes ambiguity
    178102    }
    179103    cout << globalTotal << endl;
Note: See TracChangeset for help on using the changeset viewer.