Changes in / [b1e21da:0e0f25d5]


Ignore:
Files:
16 edited

Legend:

Unmodified
Added
Removed

  • doc/theses/colby_parsons_MMAth/benchmarks/actors/cfa/balance.cfa

    rb1e21da r0e0f25d5  
    3333allocation receive( d_actor & this, start_msg & msg ) with( this ) {
    3434    for ( i; Set ) {
    35         *actor_arr[i + gstart] << shared_msg;
     35        *actor_arr[i + gstart] | shared_msg;
    3636    }
    3737    return Nodelete;
    … …  
    4242    if ( recs % Batch == 0 ) {
    4343        for ( i; Batch ) {
    44             *actor_arr[gstart + sends % Set] << shared_msg;
     44            *actor_arr[gstart + sends % Set] | shared_msg;
    4545            sends += 1;
    4646        }
    … …  
    163163    #ifndef MULTI
    164164        for ( i; qpw )
    165                 *actors[i * ActorsPerQueue] << start_send;
     165                *actors[i * ActorsPerQueue] | start_send;
    166166    #else
    167167    for ( i; qpw * ActorProcs ) {
    168                 *actors[i * ActorsPerQueue] << start_send;
     168                *actors[i * ActorsPerQueue] | start_send;
    169169    }
    170170    #endif
    171171   
    172172    for ( i; FillActors )
    173         *filler_actors[i] << shared_msg;
     173        *filler_actors[i] | shared_msg;
    174174
    175175    stop_actor_system();

  • doc/theses/colby_parsons_MMAth/benchmarks/actors/cfa/dynamic.cfa

    rb1e21da r0e0f25d5  
    3333    derived_actor * d_actor = malloc();
    3434    (*d_actor){};
    35     *d_actor << *d_msg;
     35    *d_actor | *d_msg;
    3636    return Delete;
    3737}
    … …  
    6262    derived_actor * d_actor = malloc();
    6363    (*d_actor){};
    64     *d_actor << *d_msg;
     64    *d_actor | *d_msg;
    6565
    6666

  • doc/theses/colby_parsons_MMAth/benchmarks/actors/cfa/executor.cfa

    rb1e21da r0e0f25d5  
    2929    if ( recs % Batch == 0 ) {
    3030        for ( i; Batch ) {
    31             gstart[sends % Set] << shared_msg;
     31            gstart[sends % Set] | shared_msg;
    3232            sends += 1;
    3333        }
    … …  
    9494
    9595        for ( i; Actors ) {
    96                 actors[i] << shared_msg;
     96                actors[i] | shared_msg;
    9797        } // for
    9898

  • doc/theses/colby_parsons_MMAth/benchmarks/actors/cfa/matrix.cfa

    rb1e21da r0e0f25d5  
    103103
    104104        for ( unsigned int r = 0; r < xr; r += 1 ) {
    105                 actors[r] << messages[r];
     105                actors[r] | messages[r];
    106106        } // for
    107107

  • doc/theses/colby_parsons_MMAth/benchmarks/actors/cfa/repeat.cfa

    rb1e21da r0e0f25d5  
    4646
    4747Client * cl;
    48 allocation receive( Server & this, IntMsg & msg ) { msg.val = 7; *cl << msg; return Nodelete; }
    49 allocation receive( Server & this, CharMsg & msg ) { msg.val = 'x'; *cl << msg; return Nodelete; }
     48allocation receive( Server & this, IntMsg & msg ) { msg.val = 7; *cl | msg; return Nodelete; }
     49allocation receive( Server & this, CharMsg & msg ) { msg.val = 'x'; *cl | msg; return Nodelete; }
    5050allocation receive( Server & this, StateMsg & msg ) { return Finished; }
    5151
    5252void terminateServers( Client & this ) with(this) {
    5353    for ( i; Messages ) {
    54         servers[i] << stateMsg;
     54        servers[i] | stateMsg;
    5555    } // for
    5656}
    … …  
    6060    if ( times == Times ) { terminateServers( this ); return Finished; }
    6161    results = 0;
    62     this << stateMsg;
     62    this | stateMsg;
    6363    return Nodelete;
    6464}
    … …  
    7474allocation receive( Client & this, StateMsg & msg ) with(this) {
    7575    for ( i; Messages ) {
    76         servers[i] << intmsg[i];
    77         servers[i] << charmsg[i];
     76        servers[i] | intmsg[i];
     77        servers[i] | charmsg[i];
    7878    }
    7979    return Nodelete;
    … …  
    124124    Client client;
    125125    cl = &client;
    126     client << stateMsg;
     126    client | stateMsg;
    127127
    128128    stop_actor_system();

  • doc/theses/colby_parsons_MMAth/benchmarks/actors/cfa/static.cfa

    rb1e21da r0e0f25d5  
    2929    }
    3030    msg.cnt++;
    31     receiver << msg;
     31    receiver | msg;
    3232    return Nodelete;
    3333}
    … …  
    5858    derived_actor actor;
    5959
    60     actor << msg;
     60    actor | msg;
    6161
    6262    stop_actor_system();

  • src/Concurrency/Actors.cpp

    rb1e21da r0e0f25d5  
    323323            FunctionDecl * sendOperatorFunction = new FunctionDecl(
    324324                decl->location,
    325                 "?<<?",
     325                "?|?",
    326326                {},                     // forall
    327327                {

  • tests/concurrency/actors/dynamic.cfa

    rb1e21da r0e0f25d5  
    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

    rb1e21da r0e0f25d5  
    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

    rb1e21da r0e0f25d5  
    3838        Server2 * s2 = alloc();
    3939        (*s2){};
    40         *s << *dm;
    41         *s2 << *dm2;
     40        *s | *dm;
     41        *s2 | *dm2;
    4242        stop_actor_system();
    4343    }
    … …  
    4949        D_msg2 * dm2 = alloc();
    5050        (*dm2){};
    51         s[0] << *dm;
    52         s[1] << *dm2;
     51        s[0] | *dm;
     52        s[1] | *dm2;
    5353        stop_actor_system();
    5454    }

  • tests/concurrency/actors/inline.cfa

    rb1e21da r0e0f25d5  
    4141        d_msg * dm = alloc();
    4242        (*dm){ 42, 2423 };
    43         da << *dm;
     43        da | *dm;
    4444        stop_actor_system();                                // waits until actors finish
    4545    }
    … …  
    5252        message * mg = &dm;
    5353        virtual_dtor * v = &dm;
    54         da << dm;
     54        da | dm;
    5555        stop_actor_system();                                // waits until actors finish
    5656    }

  • tests/concurrency/actors/matrix.cfa

    rb1e21da r0e0f25d5  
    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

    rb1e21da r0e0f25d5  
    2525    allocation retval = Nodelete;
    2626    if ( msg.count == times ) retval = Finished;
    27     *po << msg;
     27    *po | msg;
    2828    return retval;
    2929}
    … …  
    3535    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

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

  • tests/concurrency/actors/static.cfa

    rb1e21da r0e0f25d5  
    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

    rb1e21da r0e0f25d5  
    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
Note: See TracChangeset for help on using the changeset viewer.