Changeset b7b3e41 for tests/concurrency


Ignore:
Timestamp:
Jun 19, 2023, 1:57:11 PM (2 years ago)
Author:
caparson <caparson@…>
Branches:
master
Children:
adc73a5
Parents:
fa5e1aa5 (diff), 33d4bc8 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Merge branch 'master' of plg.uwaterloo.ca:software/cfa/cfa-cc

Location:
tests/concurrency
Files:
2 added
11 edited

Legend:

Unmodified
Added
Removed

  • tests/concurrency/actors/.expect/inherit.txt

    rfa5e1aa5 rb7b3e41  
    44A
    55A
     6A
     7A
    68Finished

  • tests/concurrency/actors/dynamic.cfa

    rfa5e1aa5 rb7b3e41  
    1919void ?{}( derived_msg & this ) { ((derived_msg &)this){ 0 }; }
    2020
    21 Allocation receive( derived_actor & receiver, derived_msg & msg ) {
     21allocation receive( derived_actor & receiver, derived_msg & msg ) {
    2222    if ( msg.cnt >= Times ) {
    2323        sout | "Done";
    … …  
    2828    derived_actor * d_actor = alloc();
    2929    (*d_actor){};
    30     *d_actor << *d_msg;
     30    *d_actor | *d_msg;
    3131    return Delete;
    3232}
    … …  
    5858    derived_actor * d_actor = alloc();
    5959    (*d_actor){};
    60     *d_actor << *d_msg;
     60    *d_actor | *d_msg;
    6161
    6262    printf("stopping\n");

  • tests/concurrency/actors/executor.cfa

    rfa5e1aa5 rb7b3e41  
    2424struct d_msg { inline message; } shared_msg;
    2525
    26 Allocation receive( d_actor & this, d_msg & msg ) with( this ) {
     26allocation receive( d_actor & this, d_msg & msg ) with( this ) {
    2727    if ( recs == rounds ) return Finished;
    2828    if ( recs % Batch == 0 ) {
    2929        for ( i; Batch ) {
    30             gstart[sends % Set] << shared_msg;
     30            gstart[sends % Set] | shared_msg;
    3131            sends += 1;
    3232        }
    … …  
    9494
    9595        for ( i; Actors ) {
    96                 actors[i] << shared_msg;
     96                actors[i] | shared_msg;
    9797        } // for
    9898

  • tests/concurrency/actors/inherit.cfa

    rfa5e1aa5 rb7b3e41  
    77
    88struct Server { inline actor; };
     9
    910struct Server2 { inline Server; int b; };
     11void ^?{}( Server2 & this ) { mutex(sout) sout | 'A'; }
     12
    1013struct D_msg { int a; inline message; };
    11 struct D_msg2 { inline D_msg; };
    12 
    13 void ^?{}( Server2 & this ) { mutex(sout) sout | 'A'; }
    1414void ?{}( D_msg & this ) { set_allocation( this, Delete ); }
    1515void ^?{}( D_msg & this ) { mutex(sout) sout | 'A'; }
    1616
    17 Allocation handle() {
     17struct D_msg2 { inline D_msg; };
     18
     19allocation handle() {
    1820    return Finished;
    1921}
    2022
    21 Allocation receive( Server & receiver, D_msg & msg ) { return handle(); }
    22 Allocation receive( Server & receiver, D_msg2 & msg ) { return handle(); }
    23 Allocation receive( Server2 & receiver, D_msg & msg ) { return Delete; }
    24 Allocation receive( Server2 & receiver, D_msg2 & msg ) { return Delete; }
     23allocation receive( Server & receiver, D_msg & msg ) { return handle(); }
     24allocation receive( Server & receiver, D_msg2 & msg ) { return handle(); }
     25allocation receive( Server2 & receiver, D_msg & msg ) { return Delete; }
     26allocation receive( Server2 & receiver, D_msg2 & msg ) { return Delete; }
    2527
    2628int main() {
    … …  
    3032        D_msg * dm = alloc();
    3133        (*dm){};
    32         D_msg2 dm2;
     34        D_msg2 * dm2 = alloc();
     35        (*dm2){};
    3336        Server2 * s = alloc();
    3437        (*s){};
    3538        Server2 * s2 = alloc();
    3639        (*s2){};
    37         *s << *dm;
    38         *s2 << dm2;
     40        *s | *dm;
     41        *s2 | *dm2;
    3942        stop_actor_system();
    4043    }
    … …  
    4447        D_msg * dm = alloc();
    4548        (*dm){};
    46         D_msg2 dm2;
    47         s[0] << *dm;
    48         s[1] << dm2;
     49        D_msg2 * dm2 = alloc();
     50        (*dm2){};
     51        s[0] | *dm;
     52        s[1] | *dm2;
    4953        stop_actor_system();
    5054    }

  • tests/concurrency/actors/matrix.cfa

    rfa5e1aa5 rb7b3e41  
    2424}
    2525
    26 Allocation receive( derived_actor & receiver, derived_msg & msg ) {
     26allocation receive( derived_actor & receiver, derived_msg & msg ) {
    2727    for ( unsigned int i = 0; i < yc; i += 1 ) { // multiply X_row by Y_col and sum products
    2828        msg.Z[i] = 0;
    … …  
    105105
    106106        for ( unsigned int r = 0; r < xr; r += 1 ) {
    107                 actors[r] << messages[r];
     107                actors[r] | messages[r];
    108108        } // for
    109109

  • tests/concurrency/actors/pingpong.cfa

    rfa5e1aa5 rb7b3e41  
    1919size_t times = 100000;
    2020
    21 Allocation receive( ping & receiver, p_msg & msg ) {
     21allocation receive( ping & receiver, p_msg & msg ) {
    2222    msg.count++;
    2323    if ( msg.count > times ) return Finished;
    2424
    25     Allocation retval = Nodelete;
     25    allocation retval = Nodelete;
    2626    if ( msg.count == times ) retval = Finished;
    27     *po << msg;
     27    *po | msg;
    2828    return retval;
    2929}
    3030
    31 Allocation receive( pong & receiver, p_msg & msg ) {
     31allocation receive( pong & receiver, p_msg & msg ) {
    3232    msg.count++;
    3333    if ( msg.count > times ) return Finished;
    3434   
    35     Allocation retval = Nodelete;
     35    allocation retval = Nodelete;
    3636    if ( msg.count == times ) retval = Finished;
    37     *pi << msg;
     37    *pi | msg;
    3838    return retval;
    3939}
    … …  
    5353    pi = &pi_actor;
    5454    p_msg m;
    55     pi_actor << m;
     55    pi_actor | m;
    5656    stop_actor_system();
    5757

  • tests/concurrency/actors/poison.cfa

    rfa5e1aa5 rb7b3e41  
    1818        Server s[10];
    1919        for ( i; 10 ) {
    20             s[i] << FinishedMsg;
     20            s[i] | finished_msg;
    2121        }
    2222        stop_actor_system();
    … …  
    2929            Server * s = alloc();
    3030            (*s){};
    31             (*s) << DeleteMsg;
     31            (*s) | delete_msg;
    3232        }
    3333        stop_actor_system();
    … …  
    3939        Server s[10];
    4040        for ( i; 10 )
    41             s[i] << DestroyMsg;
     41            s[i] | destroy_msg;
    4242        stop_actor_system();
    4343        for ( i; 10 )

  • tests/concurrency/actors/static.cfa

    rfa5e1aa5 rb7b3e41  
    1919void ?{}( derived_msg & this ) { ((derived_msg &)this){ 0 }; }
    2020
    21 Allocation receive( derived_actor & receiver, derived_msg & msg ) {
     21allocation receive( derived_actor & receiver, derived_msg & msg ) {
    2222    if ( msg.cnt >= Times ) {
    2323        sout | "Done";
    … …  
    2525    }
    2626    msg.cnt++;
    27     receiver << msg;
     27    receiver | msg;
    2828    return Nodelete;
    2929}
    … …  
    5555    derived_actor actor;
    5656
    57     actor << msg;
     57    actor | msg;
    5858
    5959    printf("stopping\n");

  • tests/concurrency/actors/types.cfa

    rfa5e1aa5 rb7b3e41  
    2020
    2121// this isn't a valid receive routine since int is not a message type
    22 Allocation receive( derived_actor & receiver, int i ) with( receiver ) {
     22allocation receive( derived_actor & receiver, int i ) with( receiver ) {
    2323    mutex(sout) sout | i;
    2424    counter++;
    … …  
    2727}
    2828
    29 Allocation receive( derived_actor & receiver, d_msg & msg ) {
     29allocation receive( derived_actor & receiver, d_msg & msg ) {
    3030    return receive( receiver, msg.num );
    3131}
    … …  
    3636};
    3737
    38 Allocation receive( derived_actor2 & receiver, d_msg & msg ) {
     38allocation receive( derived_actor2 & receiver, d_msg & msg ) {
    3939    mutex(sout) sout | msg.num;
    4040    return Finished;
    … …  
    4848};
    4949
    50 Allocation receive( derived_actor3 & receiver, d_msg & msg ) {
     50allocation receive( derived_actor3 & receiver, d_msg & msg ) {
    5151    mutex(sout) sout | msg.num;
    5252    if ( msg.num == -1 ) return Nodelete;
    … …  
    5454}
    5555
    56 Allocation receive( derived_actor3 & receiver, d_msg2 & msg ) {
     56allocation receive( derived_actor3 & receiver, d_msg2 & msg ) {
    5757    mutex(sout) sout | msg.num;
    5858    return Finished;
    … …  
    7272    b.num = 1;
    7373    c.num = 2;
    74     a << b << c;
     74    a | b | c;
    7575    stop_actor_system();
    7676
    … …  
    8080    d_msg d_ac2_msg;
    8181    d_ac2_msg.num = 3;
    82     d_ac2_0 << d_ac2_msg;
    83     d_ac2_1 << d_ac2_msg;
     82    d_ac2_0 | d_ac2_msg;
     83    d_ac2_1 | d_ac2_msg;
    8484    stop_actor_system();
    8585
    … …  
    9393        d_msg d_ac23_msg;
    9494        d_ac23_msg.num = 4;
    95         d_ac3_0 << d_ac23_msg;
    96         d_ac2_2 << d_ac23_msg;
     95        d_ac3_0 | d_ac23_msg;
     96        d_ac2_2 | d_ac23_msg;
    9797        stop_actor_system();
    9898    } // RAII to clean up executor
    … …  
    107107        b1.num = -1;
    108108        c2.num = 5;
    109         a3 << b1 << c2;
     109        a3 | b1 | c2;
    110110        stop_actor_system();
    111111    } // RAII to clean up executor
    … …  
    120120        b1.num = -1;
    121121        c2.num = 5;
    122         a4 << b1 << c2;
     122        a4 | b1 | c2;
    123123        stop_actor_system();
    124124    } // RAII to clean up executor

  • tests/concurrency/lockfree_stack.cfa

    rfa5e1aa5 rb7b3e41  
    1010// Created On       : Thu May 25 15:36:50 2023
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Tue May 30 19:02:32 2023
    13 // Update Count     : 18
     12// Last Modified On : Fri Jun  9 14:01:07 2023
     13// Update Count     : 68
    1414//
    1515
    … …  
    2929        int64_t atom;
    3030        #endif // __SIZEOF_INT128__
    31 } __attribute__(( aligned( 16 ) ));
     31};
    3232
    3333struct Node {
    … …  
    4242        n.next = stack;                                                                         // atomic assignment unnecessary
    4343        for () {                                                                                        // busy wait
    44                 if ( CASV( stack.atom, n.next.atom, ((Link){ &n, n.next.count + 1 }.atom) ) ) break; // attempt to update top node
     44                Link temp{ &n, n.next.count + 1 };
     45                if ( CASV( s.stack.atom, n.next.atom, temp.atom ) ) break; // attempt to update top node
    4546        }
    4647}
    … …  
    5051        for () {                                                                                        // busy wait
    5152                if ( t.top == NULL ) return NULL;                               // empty stack ?
    52                 if ( CASV( stack.atom, t.atom, ((Link){ t.top->next.top, t.count }.atom) ) ) return t.top; // attempt to update top node
     53                Link temp{ t.top->next.top, t.count };
     54                if ( CASV( stack.atom, t.atom, temp.atom ) ) return t.top; // attempt to update top node
    5355        }
    5456}
    … …  
    5759Stack stack;                                                                                    // global stack
    5860
    59 enum { Times =
    60         #if defined( __ARM_ARCH )                                                       // ARM CASV is very slow
    61         10_000
    62         #else
    63         1_000_000
    64         #endif // __arm_64__
    65 };
     61enum { Times = 2_000_000 };
    6662
    6763thread Worker {};
    … …  
    8278
    8379        for ( i; N ) {                                                                          // push N values on stack
    84                 // storage must be 16-bytes aligned for cmpxchg16b
    85                 push( stack, *(Node *)memalign( 16, sizeof( Node ) ) );
     80                push( stack, *(Node *)new() );                                  // must be 16-byte aligned
    8681        }
    8782        {

  • tests/concurrency/waituntil/locks.cfa

    rfa5e1aa5 rb7b3e41  
    22#include <thread.hfa>
    33#include <locks.hfa>
     4#include <fstream.hfa>
    45#include <mutex_stmt.hfa>
    56
Note: See TracChangeset for help on using the changeset viewer.