Changeset 8d61d620


Ignore:
Timestamp:
Jun 21, 2019, 3:42:05 PM (2 years ago)
Author:
Aaron Moss <a3moss@…>
Branches:
arm-eh, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr
Children:
18e683b, f2f22e3
Parents:
c1ed2ee (diff), 49dee5e (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/concurrent/examples
Files:
1 added
6 edited

Legend:

Unmodified
Added
Removed
  • tests/concurrent/examples/boundedBufferEXT.cfa

    rc1ed2ee r8d61d620  
    1010// Created On       : Wed Apr 18 22:52:12 2018
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Fri Mar 22 13:41:33 2019
    13 // Update Count     : 12
     12// Last Modified On : Fri Jun 21 08:19:20 2019
     13// Update Count     : 14
    1414//
    1515
     
    5252}
    5353
    54 const int Sentinel = -1;
     54enum { Sentinel = -1 };
    5555
    5656thread Producer {
     
    5959};
    6060void main( Producer & prod ) with( prod ) {
    61         for ( int i = 1; i <= N; i += 1 ) {
     61        for ( i; 1 ~= N ) {
    6262                yield( random( 5 ) );
    6363                insert( buffer, 1 );
     
    9999        srandom( 1003 );
    100100
    101         for ( i = 0; i < Cons; i += 1 ) {                                       // create consumers
     101        for ( i; Cons ) {                                                                       // create consumers
    102102                cons[i] = new( &buffer, sums[i] );
    103103        } // for
    104         for ( i = 0; i < Prods; i += 1 ) {                                      // create producers
     104        for ( i; Prods ) {                                                                      // create producers
    105105                prods[i] = new( &buffer, 100000 );
    106106        } // for
    107107
    108         for ( i = 0; i < Prods; i += 1 ) {                                      // wait for producers to finish
     108        for ( i; Prods ) {                                                                      // wait for producers to finish
    109109                delete( prods[i] );
    110110        } // for
    111         for ( i = 0; i < Cons; i += 1 ) {                                       // generate sentinal values to stop consumers
     111        for ( i; Cons ) {                                                                       // generate sentinal values to stop consumers
    112112                insert( buffer, Sentinel );
    113113        } // for
    114114        int sum = 0;
    115         for ( i = 0; i < Cons; i += 1 ) {                                       // wait for consumers to finish
     115        for ( i; Cons ) {                                                                       // wait for consumers to finish
    116116                delete( cons[i] );
    117117                sum += sums[i];
  • tests/concurrent/examples/boundedBufferINT.cfa

    rc1ed2ee r8d61d620  
    1010// Created On       : Mon Oct 30 12:45:13 2017
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Fri Mar 22 13:41:52 2019
    13 // Update Count     : 88
     12// Last Modified On : Fri Jun 21 08:20:46 2019
     13// Update Count     : 90
    1414//
    1515
     
    5353}
    5454
    55 const int Sentinel = -1;
     55enum { Sentinel = -1 };
    5656
    5757thread Producer {
     
    6060};
    6161void main( Producer & prod ) with( prod ) {
    62         for ( int i = 1; i <= N; i += 1 ) {
     62        for ( i; 1 ~= N ) {
    6363                yield( random( 5 ) );
    6464                insert( buffer, 1 );
     
    100100        srandom( 1003 );
    101101
    102         for ( i = 0; i < Cons; i += 1 ) {                                       // create consumers
     102        for ( i; Cons ) {                                                                       // create consumers
    103103                cons[i] = new( &buffer, sums[i] );
    104104        } // for
    105         for ( i = 0; i < Prods; i += 1 ) {                                      // create producers
     105        for ( i; Prods ) {                                                                      // create producers
    106106                prods[i] = new( &buffer, 100000 );
    107107        } // for
    108108
    109         for ( i = 0; i < Prods; i += 1 ) {                                      // wait for producers to finish
     109        for ( i; Prods ) {                                                                      // wait for producers to finish
    110110                delete( prods[i] );
    111111        } // for
    112         for ( i = 0; i < Cons; i += 1 ) {                                       // generate sentinal values to stop consumers
     112        for ( i; Cons ) {                                                                       // generate sentinal values to stop consumers
    113113                insert( buffer, Sentinel );
    114114        } // for
    115115        int sum = 0;
    116         for ( i = 0; i < Cons; i += 1 ) {                                       // wait for consumers to finish
     116        for ( i; Cons ) {                                                                       // wait for consumers to finish
    117117                delete( cons[i] );
    118118                sum += sums[i];
  • tests/concurrent/examples/datingService.cfa

    rc1ed2ee r8d61d620  
    1010// Created On       : Mon Oct 30 12:56:20 2017
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Fri Mar 22 13:41:39 2019
    13 // Update Count     : 31
     12// Last Modified On : Fri Jun 21 11:32:34 2019
     13// Update Count     : 38
    1414//
    1515
     
    9595        srandom( /*getpid()*/ 103 );
    9696
    97         for ( unsigned int i = 0; i < CompCodes; i += 1 ) {
    98                 girls[i] = new( &TheExchange, i, i );
     97        for ( i; (unsigned int)CompCodes ) {
     98                girls[i] = new( &TheExchange, i, i );                   // TheExchange constructor needs unsigned int
    9999                boys[i]  = new( &TheExchange, i, CompCodes - ( i + 1 ) );
    100100        } // for
    101101
    102         for ( unsigned int i = 0; i < CompCodes; i += 1 ) {
     102        for ( i; CompCodes ) {
    103103                delete( boys[i] );
    104104                delete( girls[i] );
    105105        } // for
    106106
    107         for ( unsigned int i = 0; i < CompCodes; i += 1 ) {
     107        for ( i; CompCodes ) {
    108108                if ( girlck[ boyck[i] ] != boyck[ girlck[i] ] ) abort();
    109109        } // for
  • tests/concurrent/examples/gortn.cfa

    rc1ed2ee r8d61d620  
    1010// Created On       : Wed Feb 20 08:02:37 2019
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Wed Feb 20 08:35:55 2019
    13 // Update Count     : 3
     12// Last Modified On : Fri Jun 21 08:25:03 2019
     13// Update Count     : 4
    1414//
    1515
     
    1818
    1919struct Msg { int i, j; };
    20 thread Gortn { int i;  float f;  Msg m; };
    21 void ^?{}( Gortn & mutex ) {}
    22 void mem1( Gortn & mutex gortn, int i ) { gortn.i = i; }
    23 void mem2( Gortn & mutex gortn, float f ) { gortn.f = f; }
    24 void mem3( Gortn & mutex gortn, Msg m ) { gortn.m = m; }
     20thread GoRtn { int i;  float f;  Msg m; };
     21void ^?{}( GoRtn & mutex ) {}
     22void mem1( GoRtn & mutex gortn, int i ) { gortn.i = i; }
     23void mem2( GoRtn & mutex gortn, float f ) { gortn.f = f; }
     24void mem3( GoRtn & mutex gortn, Msg m ) { gortn.m = m; }
    2525
    26 void main( Gortn & gortn ) with( gortn ) {
    27         for ( ;; ) {
     26void main( GoRtn & gortn ) with( gortn ) {
     27        for () {
    2828                waitfor( mem1, gortn ) sout | i;
    2929                or waitfor( mem2, gortn ) sout | f;
     
    3333}
    3434int main() {
    35         Gortn gortn;                                                                            // start thread
     35        GoRtn gortn;                                                                            // start thread
    3636        mem1( gortn, 0 );
    3737        mem2( gortn, 2.5 );
  • tests/concurrent/examples/quickSort.cfa

    rc1ed2ee r8d61d620  
    1111// Created On       : Wed Dec  6 12:15:52 2017
    1212// Last Modified By : Peter A. Buhr
    13 // Last Modified On : Fri Mar 22 13:42:01 2019
    14 // Update Count     : 170
     13// Last Modified On : Fri Jun 21 08:27:45 2019
     14// Update Count     : 172
    1515//
    1616
     
    138138                  if ( eof( unsortedfile ) ) break;
    139139                        int * values = alloc( size );                           // values to be sorted, too large to put on stack
    140                         for ( int counter = 0; counter < size; counter += 1 ) { // read unsorted numbers
     140                        for ( counter; size ) {                                         // read unsorted numbers
    141141                                unsortedfile | values[counter];
    142142                                if ( counter != 0 && counter % ValuesPerLine == 0 ) sortedfile | nl | "  ";
     
    148148                                Quicksort QS = { values, size - 1, 0 }; // sort values
    149149                        } // wait until sort tasks terminate
    150                         for ( int counter = 0; counter < size; counter += 1 ) { // print sorted list
     150                        for ( counter; size ) {                                         // print sorted list
    151151                                if ( counter != 0 && counter % ValuesPerLine == 0 ) sortedfile | nl | "  ";
    152152                                sortedfile | values[counter];
     
    163163
    164164                int * values = alloc( size );                           // values to be sorted, too large to put on stack
    165                 for ( int counter = 0; counter < size; counter += 1 ) { // generate unsorted numbers
     165                for ( counter; size ) {                                         // generate unsorted numbers
    166166                        values[counter] = size - counter;                       // descending values
    167167                } // for
     
    170170                } // wait until sort tasks terminate
    171171
    172                 // for ( int counter = 0; counter < size - 1; counter += 1 ) { // check sorting
     172                // for ( counter; size - 1 ) {                          // check sorting
    173173                //      if ( values[counter] > values[counter + 1] ) abort();
    174174                // } // for
  • tests/concurrent/examples/quickSort.generic.cfa

    rc1ed2ee r8d61d620  
    1111// Created On       : Wed Dec  6 12:15:52 2017
    1212// Last Modified By : Peter A. Buhr
    13 // Last Modified On : Fri Mar 15 14:52:41 2019
    14 // Update Count     : 147
     13// Last Modified On : Fri Jun 21 08:28:20 2019
     14// Update Count     : 149
    1515//
    1616
     
    141141                  if ( eof( unsortedfile ) ) break;
    142142                        ELEMTYPE * values = alloc( size );                      // values to be sorted, too large to put on stack
    143                         for ( int counter = 0; counter < size; counter += 1 ) { // read unsorted numbers
     143                        for ( counter; size ) {                                         // read unsorted numbers
    144144                                unsortedfile | values[counter];
    145145                                if ( counter != 0 && counter % ValuesPerLine == 0 ) sortedfile | nl | "  ";
     
    151151                                Quicksort(ELEMTYPE) QS = { values, size - 1, 0 }; // sort values
    152152                        } // wait until sort tasks terminate
    153                         for ( int counter = 0; counter < size; counter += 1 ) { // print sorted list
     153                        for ( counter; size ) {                                         // print sorted list
    154154                                if ( counter != 0 && counter % ValuesPerLine == 0 ) sortedfile | nl | "  ";
    155155                                sortedfile | values[counter];
     
    166166
    167167                ELEMTYPE * values = alloc( size );                              // values to be sorted, too large to put on stack
    168                 for ( int counter = 0; counter < size; counter += 1 ) { // generate unsorted numbers
     168                for ( counter; size ) {                                                 // generate unsorted numbers
    169169                        values[counter] = size - counter;                       // descending values
    170170                } // for
     
    173173                } // wait until sort tasks terminate
    174174
    175                 // for ( int counter = 0; counter < size - 1; counter += 1 ) { // check sorting
     175                // for ( counter; size - 1 ) {                                  // check sorting
    176176                //      if ( values[counter] > values[counter + 1] ) abort();
    177177                // } // for
Note: See TracChangeset for help on using the changeset viewer.