Index: src/tests/boundedBuffer.c =================================================================== --- src/tests/boundedBuffer.c (revision c2b9f212d8881b8a864b548bc1b467e8c22aba72) +++ (revision ) @@ -1,119 +1,0 @@ -// -// The contents of this file are covered under the licence agreement in the -// file "LICENCE" distributed with Cforall. -// -// boundedBuffer.c -- -// -// Author : Peter A. Buhr -// Created On : Mon Oct 30 12:45:13 2017 -// Last Modified By : Peter A. Buhr -// Last Modified On : Mon Oct 30 23:02:46 2017 -// Update Count : 9 -// - -#include -#include // random -#include -#include -#include // getpid - -monitor Buffer { - condition full, empty; - int front, back, count; - int elements[20]; -}; - -void ?{}( Buffer & buffer ) { - buffer.front = buffer.back = buffer.count = 0; -} - -int query( Buffer & buffer ) { return buffer.count; } - -void insert( Buffer & mutex buffer, int elem ) { - if ( buffer.count == 20 ) wait( buffer.empty ); - buffer.elements[buffer.back] = elem; - buffer.back = ( buffer.back + 1 ) % 20; - buffer.count += 1; - signal( buffer.full ); -} -int remove( Buffer & mutex buffer ) { - if ( buffer.count == 0 ) wait( buffer.full ); - int elem = buffer.elements[buffer.front]; - buffer.front = ( buffer.front + 1 ) % 20; - buffer.count -= 1; - signal( buffer.empty ); - return elem; -} - -thread Producer { - Buffer & buffer; - unsigned int N; -}; -void main( Producer & prod ) { - for ( int i = 1; i <= prod.N; i += 1 ) { - yield( random( 5 ) ); - insert( prod.buffer, 1 ); - } // for - insert( prod.buffer, -1 ); -} -void ?{}( Producer & prod, Buffer * buffer, unsigned int N ) { - &prod.buffer = buffer; - prod.N = N; - } - -thread Consumer { - Buffer & buffer; - int & sum; // summation of producer values -}; -void main( Consumer & cons ) { - cons.sum = 0; - for ( ;; ) { - yield( random( 5 ) ); - int item = remove( cons.buffer ); - if ( item == -1 ) break; // sentinel ? - cons.sum += item; - } // for -} -void ?{}( Consumer & cons, Buffer * buffer, int * sum ) { - &cons.buffer = buffer; - &cons.sum = sum; -} - -int main() { - Buffer buffer; - enum { Prods = 5, Cons = 5 }; - Producer * prods[Prods]; - Consumer * cons[Cons]; - const int Sentinel = -1; - int sums[Cons]; - int i; - processor p; - - //random_seed( getpid() ); - random_seed( 1003 ); - - for ( i = 0; i < Cons; i += 1 ) { // create consumers - cons[i] = new( &buffer, &sums[i] ); - } // for - for ( i = 0; i < Prods; i += 1 ) { // create producers - prods[i] = new( &buffer, 100000u ); - } // for - - for ( i = 0; i < Prods; i += 1 ) { // wait for producers to finish - delete( prods[i] ); - } // for - for ( i = 0; i < Cons; i += 1 ) { // generate sentinal values to stop consumers - insert( buffer, Sentinel ); - } // for - int sum = 0; - for ( i = 0; i < Cons; i += 1 ) { // wait for consumers to finish - delete( cons[i] ); - sum += sums[i]; - } // for - sout | "total:" | sum | endl; -} - -// Local Variables: // -// tab-width: 4 // -// compile-command: "cfa boundedBuffer.c" // -// End: // Index: src/tests/concurrent/boundedBuffer.c =================================================================== --- src/tests/concurrent/boundedBuffer.c (revision 557435e22bc33d5b46d38478863149e4bb72817e) +++ src/tests/concurrent/boundedBuffer.c (revision 557435e22bc33d5b46d38478863149e4bb72817e) @@ -0,0 +1,119 @@ +// +// The contents of this file are covered under the licence agreement in the +// file "LICENCE" distributed with Cforall. +// +// boundedBuffer.c -- +// +// Author : Peter A. Buhr +// Created On : Mon Oct 30 12:45:13 2017 +// Last Modified By : Peter A. Buhr +// Last Modified On : Mon Oct 30 23:02:46 2017 +// Update Count : 9 +// + +#include +#include // random +#include +#include +#include // getpid + +monitor Buffer { + condition full, empty; + int front, back, count; + int elements[20]; +}; + +void ?{}( Buffer & buffer ) { + buffer.front = buffer.back = buffer.count = 0; +} + +int query( Buffer & buffer ) { return buffer.count; } + +void insert( Buffer & mutex buffer, int elem ) { + if ( buffer.count == 20 ) wait( buffer.empty ); + buffer.elements[buffer.back] = elem; + buffer.back = ( buffer.back + 1 ) % 20; + buffer.count += 1; + signal( buffer.full ); +} +int remove( Buffer & mutex buffer ) { + if ( buffer.count == 0 ) wait( buffer.full ); + int elem = buffer.elements[buffer.front]; + buffer.front = ( buffer.front + 1 ) % 20; + buffer.count -= 1; + signal( buffer.empty ); + return elem; +} + +thread Producer { + Buffer & buffer; + unsigned int N; +}; +void main( Producer & prod ) { + for ( int i = 1; i <= prod.N; i += 1 ) { + yield( random( 5 ) ); + insert( prod.buffer, 1 ); + } // for + insert( prod.buffer, -1 ); +} +void ?{}( Producer & prod, Buffer * buffer, unsigned int N ) { + &prod.buffer = buffer; + prod.N = N; + } + +thread Consumer { + Buffer & buffer; + int & sum; // summation of producer values +}; +void main( Consumer & cons ) { + cons.sum = 0; + for ( ;; ) { + yield( random( 5 ) ); + int item = remove( cons.buffer ); + if ( item == -1 ) break; // sentinel ? + cons.sum += item; + } // for +} +void ?{}( Consumer & cons, Buffer * buffer, int * sum ) { + &cons.buffer = buffer; + &cons.sum = sum; +} + +int main() { + Buffer buffer; + enum { Prods = 5, Cons = 5 }; + Producer * prods[Prods]; + Consumer * cons[Cons]; + const int Sentinel = -1; + int sums[Cons]; + int i; + processor p; + + //random_seed( getpid() ); + random_seed( 1003 ); + + for ( i = 0; i < Cons; i += 1 ) { // create consumers + cons[i] = new( &buffer, &sums[i] ); + } // for + for ( i = 0; i < Prods; i += 1 ) { // create producers + prods[i] = new( &buffer, 100000u ); + } // for + + for ( i = 0; i < Prods; i += 1 ) { // wait for producers to finish + delete( prods[i] ); + } // for + for ( i = 0; i < Cons; i += 1 ) { // generate sentinal values to stop consumers + insert( buffer, Sentinel ); + } // for + int sum = 0; + for ( i = 0; i < Cons; i += 1 ) { // wait for consumers to finish + delete( cons[i] ); + sum += sums[i]; + } // for + sout | "total:" | sum | endl; +} + +// Local Variables: // +// tab-width: 4 // +// compile-command: "cfa boundedBuffer.c" // +// End: // Index: src/tests/concurrent/datingService.c =================================================================== --- src/tests/concurrent/datingService.c (revision 557435e22bc33d5b46d38478863149e4bb72817e) +++ src/tests/concurrent/datingService.c (revision 557435e22bc33d5b46d38478863149e4bb72817e) @@ -0,0 +1,114 @@ +// -*- Mode: C -*- +// +// The contents of this file are covered under the licence agreement in the +// file "LICENCE" distributed with Cforall. +// +// datingService.c -- +// +// Author : Peter A. Buhr +// Created On : Mon Oct 30 12:56:20 2017 +// Last Modified By : Peter A. Buhr +// Last Modified On : Mon Oct 30 23:02:11 2017 +// Update Count : 15 +// + +#include // random +#include +#include +#include +#include // getpid + +enum { NoOfPairs = 20 }; + +monitor DatingService { + condition Girls[NoOfPairs], Boys[NoOfPairs]; + unsigned int GirlPhoneNo, BoyPhoneNo; +}; // DatingService + +unsigned int girl( DatingService & mutex ds, unsigned int PhoneNo, unsigned int ccode ) { + if ( is_empty( ds.Boys[ccode] ) ) { + wait( ds.Girls[ccode] ); + ds.GirlPhoneNo = PhoneNo; + } else { + ds.GirlPhoneNo = PhoneNo; + signal_block( ds.Boys[ccode] ); + } // if + return ds.BoyPhoneNo; +} // DatingService girl + +unsigned int boy( DatingService & mutex ds, unsigned int PhoneNo, unsigned int ccode ) { + if ( is_empty( ds.Girls[ccode] ) ) { + wait( ds.Boys[ccode] ); + ds.BoyPhoneNo = PhoneNo; + } else { + ds.BoyPhoneNo = PhoneNo; + signal_block( ds.Girls[ccode] ); + } // if + return ds.GirlPhoneNo; +} // DatingService boy + +unsigned int girlck[NoOfPairs]; +unsigned int boyck[NoOfPairs]; + +thread Girl { + DatingService & TheExchange; + unsigned int id, ccode; +}; // Girl + +void main( Girl & g ) { + yield( random( 100 ) ); // don't all start at the same time + unsigned int partner = girl( g.TheExchange, g.id, g.ccode ); + //sout | "Girl:" | g.id | "is dating Boy at" | partner | "with ccode" | g.ccode | endl; + girlck[g.id] = partner; +} // Girl main + +void ?{}( Girl & g, DatingService * TheExchange, unsigned int id, unsigned int ccode ) { + &g.TheExchange = TheExchange; + g.id = id; + g.ccode = ccode; +} // Girl ?{} + +thread Boy { + DatingService &TheExchange; + unsigned int id, ccode; +}; // Boy + +void main( Boy & b ) { + yield( random( 100 ) ); // don't all start at the same time + unsigned int partner = boy( b.TheExchange, b.id, b.ccode ); + //sout | " Boy:" | b.id | "is dating Girl" | partner | "with ccode" | b.ccode | endl; + boyck[b.id] = partner; +} // Boy main + +void ?{}( Boy & b, DatingService * TheExchange, unsigned int id, unsigned int ccode ) { + &b.TheExchange = TheExchange; + b.id = id; + b.ccode = ccode; +} // Boy ?{} + +int main() { + DatingService TheExchange; + Girl *girls[NoOfPairs]; + Boy *boys[NoOfPairs]; + + random_seed( getpid() ); + + for ( unsigned int i = 0; i < NoOfPairs; i += 1 ) { + girls[i] = new( &TheExchange, i, i ); + boys[i] = new( &TheExchange, i, NoOfPairs - ( i + 1 ) ); + } // for + + for ( unsigned int i = 0; i < NoOfPairs; i += 1 ) { + delete( boys[i] ); + delete( girls[i] ); + } // for + + for ( unsigned int i = 0; i < NoOfPairs; i += 1 ) { + if ( girlck[ boyck[i] ] != boyck[ girlck[i] ] ) abort(); + } // for +} // main + +// Local Variables: // +// tab-width: 4 // +// compile-command: "cfa datingService.c" // +// End: // Index: src/tests/concurrent/matrixSum.c =================================================================== --- src/tests/concurrent/matrixSum.c (revision 557435e22bc33d5b46d38478863149e4bb72817e) +++ src/tests/concurrent/matrixSum.c (revision 557435e22bc33d5b46d38478863149e4bb72817e) @@ -0,0 +1,63 @@ +// -*- Mode: C -*- +// +// Cforall Version 1.0.0 Copyright (C) 2017 University of Waterloo +// +// The contents of this file are covered under the licence agreement in the +// file "LICENCE" distributed with Cforall. +// +// matrixSum.c -- +// +// Author : Peter A. Buhr +// Created On : Mon Oct 9 08:29:28 2017 +// Last Modified By : Peter A. Buhr +// Last Modified On : Sun Oct 29 21:08:48 2017 +// Update Count : 2 +// + +#include +#include +#include + +thread Adder { + int * row, cols, * subtotal; // communication +}; + +void ?{}( Adder & adder, int row[], int cols, int & subtotal ) { + adder.row = row; + adder.cols = cols; + adder.subtotal = &subtotal; +} + +void main( Adder & adder ) { + *adder.subtotal = 0; + for ( int c = 0; c < adder.cols; c += 1 ) { + *adder.subtotal += adder.row[c]; + } // for +} + +int main() { + const int rows = 10, cols = 1000; + int matrix[rows][cols], subtotals[rows], total = 0; + processor p; // extra kernel thread + + for ( int r = 0; r < rows; r += 1 ) { + for ( int c = 0; c < cols; c += 1 ) { + matrix[r][c] = 1; + } // for + } // for + Adder * adders[rows]; + for ( int r = 0; r < rows; r += 1 ) { // start threads to sum rows + adders[r] = &(*malloc()){ matrix[r], cols, subtotals[r] }; +// adders[r] = new( matrix[r], cols, &subtotals[r] ); + } // for + for ( int r = 0; r < rows; r += 1 ) { // wait for threads to finish + delete( adders[r] ); + total += subtotals[r]; // total subtotals + } // for + sout | total | endl; +} + +// Local Variables: // +// tab-width: 4 // +// compile-command: "cfa matrixSum.c" // +// End: // Index: src/tests/concurrent/monitor.c =================================================================== --- src/tests/concurrent/monitor.c (revision 557435e22bc33d5b46d38478863149e4bb72817e) +++ src/tests/concurrent/monitor.c (revision 557435e22bc33d5b46d38478863149e4bb72817e) @@ -0,0 +1,43 @@ +#include +#include +#include +#include + +monitor global_t { + int value; +}; + +void ?{}(global_t & this) { + this.value = 0; +} + +static global_t global; + +void increment3( global_t & mutex this ) { + this.value += 1; +} + +void increment2( global_t & mutex this ) { + increment3( this ); +} + +void increment( global_t & mutex this ) { + increment2( this ); +} + +thread MyThread {}; + +void main( MyThread & this ) { + for(int i = 0; i < 1_000_000; i++) { + increment( global ); + } +} + +int main(int argc, char* argv[]) { + assert( global.__mon.entry_queue.tail != NULL ); + processor p; + { + MyThread f[4]; + } + sout | global.value | endl; +} Index: src/tests/concurrent/multi-monitor.c =================================================================== --- src/tests/concurrent/multi-monitor.c (revision 557435e22bc33d5b46d38478863149e4bb72817e) +++ src/tests/concurrent/multi-monitor.c (revision 557435e22bc33d5b46d38478863149e4bb72817e) @@ -0,0 +1,55 @@ +#include +#include +#include +#include + +static int global12, global23, global13; + +monitor monitor_t {}; + +static monitor_t m1, m2, m3; + +void increment( monitor_t & mutex p1, monitor_t & mutex p2, int & value ) { + value += 1; +} + +thread MyThread { + int target; +}; + +void ?{}( MyThread & this, int target ) { + this.target = target; +} + +void ^?{}( MyThread & mutex this ) {} + +void main( MyThread & this ) { + for(int i = 0; i < 1000000; i++) { + choose(this.target) { + case 0: increment( m1, m2, global12 ); + case 1: increment( m2, m3, global23 ); + case 2: increment( m1, m3, global13 ); + } + } +} + +forall(dtype T | sized(T) | { void ^?{}(T & mutex); }) +void delete_mutex(T * x) { + ^(*x){}; + free(x); +} + +int main(int argc, char* argv[]) { + processor p; + { + MyThread * f[6]; + for(int i = 0; i < 6; i++) { + f[i] = new(i % 3); + } + + for(int i = 0; i < 6; i++) { + delete_mutex( f[i] ); + } + } + sout | global12 | global23 | global13 | endl; +} Index: src/tests/concurrent/preempt.c =================================================================== --- src/tests/concurrent/preempt.c (revision 557435e22bc33d5b46d38478863149e4bb72817e) +++ src/tests/concurrent/preempt.c (revision 557435e22bc33d5b46d38478863149e4bb72817e) @@ -0,0 +1,42 @@ +#include +#include + +#ifndef PREEMPTION_RATE +#define PREEMPTION_RATE 10_000ul +#endif + +unsigned int default_preemption() { + return PREEMPTION_RATE; +} + +static volatile int counter = 0; + +thread worker_t { + int value; +}; + +void ?{}( worker_t & this, int value ) { + this.value = value; +} + +void main(worker_t & this) { + while(counter < 1000) { + if( (counter % 7) == this.value ) { + int next = __atomic_add_fetch_4(&counter, 1, __ATOMIC_SEQ_CST); + if( (next % 100) == 0 ) printf("%d\n", next); + } + } +} + +int main(int argc, char* argv[]) { + processor p; + { + worker_t w0 = 0; + worker_t w1 = 1; + worker_t w2 = 2; + worker_t w3 = 3; + worker_t w4 = 4; + worker_t w5 = 5; + worker_t w6 = 6; + } +} Index: src/tests/concurrent/sched-ext-barge.c =================================================================== --- src/tests/concurrent/sched-ext-barge.c (revision 557435e22bc33d5b46d38478863149e4bb72817e) +++ src/tests/concurrent/sched-ext-barge.c (revision 557435e22bc33d5b46d38478863149e4bb72817e) @@ -0,0 +1,92 @@ +//--------------------------------------------------------- +// Barging test +// Ensures that no barging can occur between : +// - the frontend of the waitfor and the waited call +// - the waited call and the backend of the waitfor +//--------------------------------------------------------- + +#include +#include +#include +#include +#include + +#include + +static const unsigned long N = 5_000ul; + +enum state_t { WAITFOR, CALL, BARGE }; + +monitor global_t { + bool done; + bool started; + state_t state; +}; + +void ?{} ( global_t & this ) { + this.done = false; + this.started = false; + this.state = BARGE; +} + +void ^?{} ( global_t & mutex this ) {} + +global_t global; + +bool barge( global_t & mutex this ) { + this.state = BARGE; + return !this.done; +} + +thread barger_t {}; +void main( barger_t & this ) { + yield(); + while( barge( global ) ) { yield(random( 10 )); } +} + +bool do_call( global_t & mutex this ) { + yield(random( 10 )); + if( this.state != WAITFOR && !this.done && this.started ) { + serr | "Barging before caller detected" | endl; + } + + this.state = CALL; + return !this.done; +} + +thread caller_t {}; +void main( caller_t & this ) { + while( do_call(global) ) { yield(random( 10 )); } +} + +void do_wait( global_t & mutex this ) { + this.started = true; + for( int i = 0; i < N; i++) { + yield(random( 10 )); + this.state = WAITFOR; + waitfor(do_call, this) { + sout | i | endl; + } + + if( this.state != CALL ) { + serr | "Barging after caller detected" | endl; + } + } + + this.done = true; +} + +thread waiter_t{}; +void main( waiter_t & this ) { + do_wait(global); +} + +int main() { + sout | "Starting" | endl; + { + barger_t bargers[17]; + caller_t callers[7]; + waiter_t waiters; + } + sout | "Stopping" | endl; +} Index: src/tests/concurrent/sched-ext-dtor.c =================================================================== --- src/tests/concurrent/sched-ext-dtor.c (revision 557435e22bc33d5b46d38478863149e4bb72817e) +++ src/tests/concurrent/sched-ext-dtor.c (revision 557435e22bc33d5b46d38478863149e4bb72817e) @@ -0,0 +1,63 @@ +//--------------------------------------------------------- +// Barging test +// Ensures the statement order is reverse when using waitfor ^?{} +//--------------------------------------------------------- + +#include +#include +#include +#include +#include + +#include + +static const unsigned long N = 5_000ul; + +enum state_t { + CTOR, + MAIN, + AFTER, + END, + DTOR +}; + +thread dummy_t { + state_t state; +}; + +static inline void set_state( dummy_t & this, state_t state) { + switch(state) { + case CTOR : break; + case MAIN : if( this.state != CTOR ) { serr | "ERROR Expected state to be CTOR" | endl; abort(); } this.state = state; break; + case AFTER : if( this.state != MAIN ) { serr | "ERROR Expected state to be MAIN" | endl; abort(); } this.state = state; break; + case END : if( this.state != AFTER ) { serr | "ERROR Expected state to be AFTER" | endl; abort(); } this.state = state; break; + case DTOR : if( this.state != END ) { serr | "ERROR Expected state to be END" | endl; abort(); } this.state = state; break; + } +} + +void ^?{}( dummy_t & mutex this ) { + set_state( this, DTOR ); +} + +void ?{}( dummy_t & this ) { + this.state = CTOR; +} + +void main( dummy_t & this ) { + yield(random( 10 )); + set_state( this, MAIN ); + waitfor( ^?{}, this ) { + set_state( this, AFTER ); + } + set_state( this, END ); +} + +int main() { + sout | "Starting" | endl; + processor p; + for( int i = 0; i < N; i++ ){ + dummy_t dummy[4]; + yield( random( 100 ) ); + } + sout | "Stopping" | endl; +} Index: src/tests/concurrent/sched-ext-else.c =================================================================== --- src/tests/concurrent/sched-ext-else.c (revision 557435e22bc33d5b46d38478863149e4bb72817e) +++ src/tests/concurrent/sched-ext-else.c (revision 557435e22bc33d5b46d38478863149e4bb72817e) @@ -0,0 +1,48 @@ +#include +#include + +#include + +monitor M {}; + +void notcalled( M & mutex m ) { + abort(); +} + +void test( M & mutex m ) { + int i = 0; + sout | "Starting" | endl; + + when( false ) waitfor( notcalled, m ); + + sout | "Step" | i++ | endl; + + waitfor( notcalled, m ); or else { + sout | "else called" | endl; + } + + sout | "Step" | i++ | endl; + + when( true ) waitfor( notcalled, m ); or when( true ) else { + sout | "else called" | endl; + } + + sout | "Step" | i++ | endl; + + when( false ) waitfor( notcalled, m ); or when( true ) else { + sout | "else called" | endl; + } + + sout | "Step" | i++ | endl; + + when( false ) waitfor( notcalled, m ); or when( false ) else { + sout | "else called" | endl; + } + + sout | "Done" | endl; +} + +int main() { + M m; + test(m); +} Index: src/tests/concurrent/sched-ext-parse.c =================================================================== --- src/tests/concurrent/sched-ext-parse.c (revision 557435e22bc33d5b46d38478863149e4bb72817e) +++ src/tests/concurrent/sched-ext-parse.c (revision 557435e22bc33d5b46d38478863149e4bb72817e) @@ -0,0 +1,104 @@ +//---------------------------------------------------------------------------------------- +//---------------------------------------------------------------------------------------- +// +// DEPRECATED TEST +// DIFFERS BETWEEN DEBUG AND RELEASE +// +//---------------------------------------------------------------------------------------- +//---------------------------------------------------------------------------------------- + +#include + +monitor M {}; + +M a; + +void f1( M & mutex a ); +void f2( M & mutex a ); +void f2( M & mutex a, M & mutex b ); +void f3( M & mutex a ); +void f3( M & mutex a, M & mutex b ); +void f3( M & mutex a, M & mutex b, M & mutex c ); + +void foo() { + + //--------------------------------------- + waitfor( f1, a ) { + 1; + } + + //--------------------------------------- + waitfor( f1, a ) { + 2; + } + waitfor( f2, a ) { + 3; + } + + //--------------------------------------- + when( 1 < 3 ) waitfor( f2, a, a ) { + 4; + } + or timeout( 100 ) { + 5; + } + + //--------------------------------------- + when( 2 < 3 ) waitfor( f3, a ) { + 5; + } + or else { + 6; + } + + //--------------------------------------- + when( 3 < 3 ) waitfor( f3, a, a ) { + 7; + } + or when( 4 < 3 ) timeout( 101 ) { + 8; + } + or when( 5 < 3 ) else { + 9; + } + + //--------------------------------------- + when( 6 < 3 ) waitfor( f3, a, a, a ) { + 10; + } + or when( 7 < 3 ) waitfor( f1, a ) { + 11; + } + or else { + 12; + } + + //--------------------------------------- + when( 8 < 3 ) waitfor( f3, a, a ) { + 13; + } + or waitfor( f1, a ) { + 14; + } + or when( 9 < 3 ) timeout( 102 ) { + 15; + } + + //--------------------------------------- + when( 10 < 3 ) waitfor( f1, a ) { + 16; + } + or waitfor( f2, a, a ) { + 17; + } + or timeout( 103 ) { + 18; + } + or when( 11 < 3 ) else { + 19; + } +} + +int main() { + +} Index: src/tests/concurrent/sched-ext-recurse.c =================================================================== --- src/tests/concurrent/sched-ext-recurse.c (revision 557435e22bc33d5b46d38478863149e4bb72817e) +++ src/tests/concurrent/sched-ext-recurse.c (revision 557435e22bc33d5b46d38478863149e4bb72817e) @@ -0,0 +1,145 @@ +//---------------------------------------------------------------- +// Recursion test +// Ensures that proper ordering occurs between the nested waitfors +//----------------------------------------------------------------- + +#include +#include +#include +#include +#include + +#include +#include + +static const unsigned long N = 5_000ul; + +static inline void rand_yield() { yield(random( 10 )); } + +enum state_t { FIRST, SECOND, THIRD, LAST, STOP }; +void shuffle(enum state_t * array) +{ + int i; + for (i = 0; i < 4; i++) + { + int j = random( 4 ); + enum state_t t = array[j]; + array[j] = array[i]; + array[i] = t; + } +} + + +monitor global_t { + int counter; + volatile bool ready; + state_t actions[4]; +}; + +void ?{} ( global_t & this ) { + this.counter = 0; + this.ready = false; + this.actions[0] = FIRST; + this.actions[1] = SECOND; + this.actions[2] = THIRD; + this.actions[3] = LAST; + shuffle( this.actions ); +} + +void ^?{} ( global_t & mutex this ) {} + +global_t global; + +state_t call4( global_t & mutex this, int idx ) { + sout | "Last"; + + rand_yield(); + this.counter++; + this.ready = false; + shuffle( this.actions ); + + return this.counter < N ? (state_t)this.actions[idx] : (state_t)STOP; +} + +state_t call3( global_t & mutex this, int idx ) { + sout | "3rd"; + + rand_yield(); + waitfor( call4, this ); + rand_yield(); + + sout | "3rd"; + + return this.counter < N ? (state_t)this.actions[idx] : (state_t)STOP; +} + +state_t call2( global_t & mutex this, int idx ) { + sout | "2nd"; + + rand_yield(); + waitfor( call3, this ); + rand_yield(); + + sout | "2nd"; + + return this.counter < N ? (state_t)this.actions[idx] : (state_t)STOP; +} + +state_t call1( global_t & mutex this, int idx ) { + this.ready = true; + + sout | this.counter | "1st"; + + rand_yield(); + waitfor( call2, this ); + rand_yield(); + + sout | "1st" | endl; + + return this.counter < N ? (state_t)this.actions[idx] : (state_t)STOP; +} + +thread waiter_t{ + int idx; + state_t state; +}; + +void ^?{} ( waiter_t & mutex this ) {} +void ?{} ( waiter_t & this ) {} + +void ?{}( waiter_t & this, int idx, state_t state ) { + this.idx = idx; + this.state = state; +} + + +void main( waiter_t & this ) { + while( this.state != STOP ) { + rand_yield(); + + switch( this.state ) { + case FIRST : this.state = call1( global, this.idx ); break; + case SECOND : while( !global.ready ) { yield(); } this.state = call2( global, this.idx ); break; + case THIRD : while( !global.ready ) { yield(); } this.state = call3( global, this.idx ); break; + case LAST : while( !global.ready ) { yield(); } this.state = call4( global, this.idx ); break; + case STOP : serr | "This should not happen" | endl; + } + } +} + +static waiter_t * volatile the_threads; + +int main() { + random_seed( time(NULL) ); + sout | "Starting" | endl; + { + waiter_t waiters[4] = { + { 0, FIRST }, + { 1, SECOND }, + { 2, THIRD }, + { 3, LAST } + }; + the_threads = waiters; + } + sout | "Stopping" | endl; +} Index: src/tests/concurrent/sched-ext-statment.c =================================================================== --- src/tests/concurrent/sched-ext-statment.c (revision 557435e22bc33d5b46d38478863149e4bb72817e) +++ src/tests/concurrent/sched-ext-statment.c (revision 557435e22bc33d5b46d38478863149e4bb72817e) @@ -0,0 +1,136 @@ +#include +#include +#include +#include + +#include + +monitor M { + int index; + int last_val; + int calls[7]; +}; + +volatile bool start = false; + +void ?{}( M & this ) { + this.index = 0; + this.last_val = 0; + for( int i = 0; i < 7; i++ ) { + this.calls[i] = 100; //10_000; + } +} + +void ^?{} ( M & mutex this ) {} + +int get_index( M & mutex this ) { + this.index += 1; + return this.index; +} + +bool call1( M & mutex this ) { + this.last_val = 1; + this.calls[0] -= 1; + return this.calls[0] > 0; +} + +bool call2( M & mutex this ) { + this.last_val = 2; + this.calls[1] -= 1; + return this.calls[1] > 0; +} + +bool call3( M & mutex this ) { + this.last_val = 3; + this.calls[2] -= 1; + return this.calls[2] > 0; +} + +bool call4( M & mutex this ) { + this.last_val = 4; + this.calls[3] -= 1; + return this.calls[3] > 0; +} + +bool call5( M & mutex this ) { + this.last_val = 5; + this.calls[4] -= 1; + return this.calls[4] > 0; +} + +bool call6( M & mutex this ) { + this.last_val = 6; + this.calls[5] -= 1; + return this.calls[5] > 0; +} + +bool call7( M & mutex this ) { + this.last_val = 7; + this.calls[6] -= 1; + return this.calls[6] > 0; +} + +M m; +thread caller{}; + +bool call( int index ) { + switch( index ) { + case 1: return call1( m ); + case 2: return call2( m ); + case 3: return call3( m ); + case 4: return call4( m ); + case 5: return call5( m ); + case 6: return call6( m ); + case 7: return call7( m ); + default : + serr | "Incorrect index" | index | endl; + abort(); + } +} + +void main( caller & this ) { + int index = get_index( m ); + while( !start ) yield(); + while( call( index ) ); +} + +void do_wait( M & mutex this ) { + bool done = false; + + start = true; + + while( !done ) { + waitfor( get_index, this ); + or waitfor( call1, this ) { sout | "Statement" | endl; if( this.last_val != 1 ) { serr | "Incorrect index: expected" | 1 | "got" | this.last_val | endl; } } + or waitfor( call2, this ) { sout | "Statement" | endl; if( this.last_val != 2 ) { serr | "Incorrect index: expected" | 2 | "got" | this.last_val | endl; } } + or waitfor( call3, this ) { sout | "Statement" | endl; if( this.last_val != 3 ) { serr | "Incorrect index: expected" | 3 | "got" | this.last_val | endl; } } + or waitfor( call4, this ) { sout | "Statement" | endl; if( this.last_val != 4 ) { serr | "Incorrect index: expected" | 4 | "got" | this.last_val | endl; } } + or waitfor( call5, this ) { sout | "Statement" | endl; if( this.last_val != 5 ) { serr | "Incorrect index: expected" | 5 | "got" | this.last_val | endl; } } + or waitfor( call6, this ) { sout | "Statement" | endl; if( this.last_val != 6 ) { serr | "Incorrect index: expected" | 6 | "got" | this.last_val | endl; } } + or waitfor( call7, this ) { sout | "Statement" | endl; if( this.last_val != 7 ) { serr | "Incorrect index: expected" | 7 | "got" | this.last_val | endl; } } + + done = true; + for( int i = 0; i < 7; i++ ) { + if( this.calls[i] > 0 ) { + done = false; + break; + } + } + } +} + +thread waiter{}; + +void main( waiter & this ) { + do_wait( m ); +} + +int main() { + processor p[2]; + sout | "Starting" | endl; + { + caller c[7]; + waiter w; + } + sout | "Stopping" | endl; +} Index: src/tests/concurrent/sched-ext-when.c =================================================================== --- src/tests/concurrent/sched-ext-when.c (revision 557435e22bc33d5b46d38478863149e4bb72817e) +++ src/tests/concurrent/sched-ext-when.c (revision 557435e22bc33d5b46d38478863149e4bb72817e) @@ -0,0 +1,87 @@ +//---------------------------------------------------------------- +// When test +// Ensures that when clauses on waitfor are respected +//----------------------------------------------------------------- + +#include +#include +#include +#include +#include + +#include +#include + +static const unsigned long N = 4_998ul; + +static inline void rand_yield() { yield(random( 10 )); } + +monitor global_t { + int last_call; + bool done; +}; + +void ?{} ( global_t & this ) { + this.last_call = 6; + this.done = false; +} + +void ^?{} ( global_t & mutex this ) {} + +global_t global; + +bool call1( global_t & mutex this ) { this.last_call = 1; return this.done; } +bool call2( global_t & mutex this ) { this.last_call = 2; return this.done; } +bool call3( global_t & mutex this ) { this.last_call = 3; return this.done; } +bool call4( global_t & mutex this ) { this.last_call = 4; return this.done; } +bool call5( global_t & mutex this ) { this.last_call = 5; return this.done; } +bool call6( global_t & mutex this ) { this.last_call = 6; return this.done; } + +thread caller_t{}; +void main( caller_t & this ) { + while( true ) { + rand_yield(); + if( call1( global ) ) return; + rand_yield(); + if( call2( global ) ) return; + rand_yield(); + if( call3( global ) ) return; + rand_yield(); + if( call4( global ) ) return; + rand_yield(); + if( call5( global ) ) return; + rand_yield(); + if( call6( global ) ) return; + } +} + +void arbiter( global_t & mutex this ) { + for( int i = 0; i < N; i++ ) { + when( this.last_call == 6 ) waitfor( call1, this ) { if( this.last_call != 1) { serr | "Expected last_call to be 1 got" | this.last_call | endl; } } + or when( this.last_call == 1 ) waitfor( call2, this ) { if( this.last_call != 2) { serr | "Expected last_call to be 2 got" | this.last_call | endl; } } + or when( this.last_call == 2 ) waitfor( call3, this ) { if( this.last_call != 3) { serr | "Expected last_call to be 3 got" | this.last_call | endl; } } + or when( this.last_call == 3 ) waitfor( call4, this ) { if( this.last_call != 4) { serr | "Expected last_call to be 4 got" | this.last_call | endl; } } + or when( this.last_call == 4 ) waitfor( call5, this ) { if( this.last_call != 5) { serr | "Expected last_call to be 5 got" | this.last_call | endl; } } + or when( this.last_call == 5 ) waitfor( call6, this ) { if( this.last_call != 6) { serr | "Expected last_call to be 6 got" | this.last_call | endl; } } + + sout | this.last_call | endl; + } + + this.done = true; +} + +thread arbiter_t{}; +void main( arbiter_t & this ) { + arbiter( global ); +} + +int main() { + random_seed( time(NULL) ); + sout | "Starting" | endl; + { + arbiter_t arbiter; + caller_t callers[7]; + + } + sout | "Stopping" | endl; +} Index: src/tests/concurrent/sched-ext.c =================================================================== --- src/tests/concurrent/sched-ext.c (revision 557435e22bc33d5b46d38478863149e4bb72817e) +++ src/tests/concurrent/sched-ext.c (revision 557435e22bc33d5b46d38478863149e4bb72817e) @@ -0,0 +1,85 @@ +#include +#include +#include +#include +#include + +#include + +static const unsigned long N = 500ul; + +#ifndef PREEMPTION_RATE +#define PREEMPTION_RATE 10_000ul +#endif + +unsigned int default_preemption() { + return PREEMPTION_RATE; +} + +monitor global_t {}; + +global_t globalA; + +thread Acceptor {}; +thread Acceptee {}; + +volatile bool done; + +//---------------------------------------------------------------------------------------------------- +// Acceptor +void do_notify( global_t * mutex a ); + +void do_wait( global_t * mutex a ) { + sout | "Waiting to accept" | endl; + yield( random( 10 ) ); + + sout | "Accepting" | endl; + + __acceptable_t acceptable; + acceptable.func = (fptr_t)do_notify; + acceptable.count = 1; + acceptable.monitors = &a; + + __waitfor_internal( 1, &acceptable ); + + sout | "Accepted" | endl; + yield( random( 10 ) ); +} + +void main( Acceptor* this ) { + for( int i = 0; i < N; i++ ) { + do_wait( &globalA ); + sout | i | endl; + } + + done = true; +} + +//---------------------------------------------------------------------------------------------------- +// Acceptee +void do_notify( global_t * mutex a ) { + +} + +void main( Acceptee* this ) { + while( !done ) { + yield( random( 10 ) ); + do_notify( &globalA ); + yield( random( 10 ) ); + } +} + +//---------------------------------------------------------------------------------------------------- +// Main +int main(int argc, char* argv[]) { + done = false; + random_seed( time( NULL ) ); + printf("%p\n", &globalA); + sout | "Starting" | endl; + { + Acceptor r; + Acceptee e[13]; + + } + sout | "Done" | endl; +} Index: src/tests/concurrent/sched-int-barge.c =================================================================== --- src/tests/concurrent/sched-int-barge.c (revision 557435e22bc33d5b46d38478863149e4bb72817e) +++ src/tests/concurrent/sched-int-barge.c (revision 557435e22bc33d5b46d38478863149e4bb72817e) @@ -0,0 +1,117 @@ +//---------------------------------------------------------------------------------------- +//---------------------------------------------------------------------------------------- +// +// DEPRECATED TEST +// +//---------------------------------------------------------------------------------------- +//---------------------------------------------------------------------------------------- + +#include +#include +#include +#include +#include + +static const unsigned long N = 50_000ul; + +#ifndef PREEMPTION_RATE +#define PREEMPTION_RATE 10_000ul +#endif + +unsigned int default_preemption() { + return 0; +} +enum state_t { WAIT, SIGNAL, BARGE }; + +monitor global_t {}; + +monitor global_data_t { + volatile bool done; + int counter; + state_t state; + + unsigned short do_signal; + unsigned short do_wait2; + unsigned short do_wait1; +}; + +void ?{} ( global_data_t & this ) { + this.done = false; + this.counter = 0; + this.state = BARGE; + + this.do_signal = 6; + this.do_wait1 = 1; + this.do_wait2 = 3; +} + +void ^?{} ( global_data_t & this ) {} + +global_t globalA; +global_t globalB; +global_data_t globalC; + +condition cond; + +thread Threads {}; + +bool logicC( global_t & mutex a, global_t & mutex b, global_data_t & mutex c ) { + c.counter++; + + if( (c.counter % 1000) == 0 ) sout | c.counter | endl; + + int action = c.counter % 10; + + if( action == 0 ) { + c.do_signal = max( random( 10 ), 1); + c.do_wait1 = random( c.do_signal ); + c.do_wait2 = random( c.do_signal ); + + if(c.do_wait1 == c.do_wait2) sout | "Same" | endl; + } + + if( action == c.do_wait1 || action == c.do_wait2 ) { + c.state = WAIT; + wait( cond ); + + if(c.state != SIGNAL) { + sout | "ERROR Barging detected" | c.counter | endl; + abort(); + } + } + else if( action == c.do_signal ) { + c.state = SIGNAL; + + signal( cond ); + signal( cond ); + } + else { + c.state = BARGE; + } + + if( c.counter >= N ) c.done = true; + return !c.done; +} + +bool logicB( global_t & mutex a, global_t & mutex b ) { + return logicC(a, b, globalC); +} + +bool logicA( global_t & mutex a ) { + return logicB(a, globalB); +} + +void main( Threads & this ) { + while( logicA(globalA) ) { yield(); }; +} + +static thread_desc * volatile the_threads; + +int main(int argc, char* argv[]) { + random_seed(0); + processor p; + { + Threads t[17]; + the_threads = (thread_desc*)t; + } +} Index: src/tests/concurrent/sched-int-block.c =================================================================== --- src/tests/concurrent/sched-int-block.c (revision 557435e22bc33d5b46d38478863149e4bb72817e) +++ src/tests/concurrent/sched-int-block.c (revision 557435e22bc33d5b46d38478863149e4bb72817e) @@ -0,0 +1,133 @@ +//--------------------------------------------------------- +// Barging test +// Ensures that no barging can occur between : +// - the frontend of the signal_block and the signaled thread +// - the signaled threadand the backend of the signal_block +//--------------------------------------------------------- + + +#include +#include +#include +#include +#include + +#include + +static const unsigned long N = 5_000ul; + +#ifndef PREEMPTION_RATE +#define PREEMPTION_RATE 10_000ul +#endif + +unsigned int default_preemption() { + return PREEMPTION_RATE; +} + +enum state_t { WAITED, SIGNAL, BARGE }; + +monitor global_data_t { + thread_desc * last_thread; + thread_desc * last_signaller; +}; + +void ?{} ( global_data_t & this ) { + this.last_thread = NULL; + this.last_signaller = NULL; +} + +void ^?{} ( global_data_t & this ) {} + +global_data_t globalA, globalB; + +condition cond; + +volatile bool done; + +//------------------------------------------------------------------------------ +void wait_op( global_data_t & mutex a, global_data_t & mutex b, unsigned i ) { + wait( cond, (uintptr_t)this_thread ); + + yield( random( 10 ) ); + + if(a.last_thread != a.last_signaller || b.last_thread != b.last_signaller ) { + sout | "ERROR Barging detected, expected" | a.last_signaller | b.last_signaller | "got" | a.last_thread | b.last_thread | endl; + abort(); + } + + a.last_thread = b.last_thread = this_thread; + + yield( random( 10 ) ); +} + +thread Waiter {}; +void main( Waiter & this ) { + for( int i = 0; i < N; i++ ) { + wait_op( globalA, globalB, i ); + } +} + +//------------------------------------------------------------------------------ +void signal_op( global_data_t & mutex a, global_data_t & mutex b ) { + yield( random( 10 ) ); + + [a.last_thread, b.last_thread, a.last_signaller, b.last_signaller] = this_thread; + + if( !is_empty( cond ) ) { + + thread_desc * next = front( cond ); + + if( ! signal_block( cond ) ) { + sout | "ERROR expected to be able to signal" | endl; + abort(); + } + + yield( random( 10 ) ); + + if(a.last_thread != next || b.last_thread != next) { + sout | "ERROR Barging detected, expected" | next | "got" | a.last_thread | b.last_thread | endl; + abort(); + } + } + +} + +thread Signaller {}; +void main( Signaller & this ) { + while( !done ) { + signal_op( globalA, globalB ); + } +} + +//------------------------------------------------------------------------------ +void barge_op( global_data_t & mutex a ) { + a.last_thread = this_thread; +} + +thread Barger {}; +void main( Barger & this ) { + for( unsigned i = 0; !done; i++ ) { + //Choose some monitor to barge into with some irregular pattern + bool choose_a = (i % 13) > (i % 17); + if ( choose_a ) barge_op( globalA ); + else barge_op( globalB ); + } +} + +//------------------------------------------------------------------------------ + +int main(int argc, char* argv[]) { + random_seed( time( NULL ) ); + done = false; + processor p; + { + Signaller s[4]; + Barger b[13]; + sout | "Starting waiters" | endl; + { + Waiter w[3]; + } + sout | "Waiters done" | endl; + done = true; + } +} Index: src/tests/concurrent/sched-int-disjoint.c =================================================================== --- src/tests/concurrent/sched-int-disjoint.c (revision 557435e22bc33d5b46d38478863149e4bb72817e) +++ src/tests/concurrent/sched-int-disjoint.c (revision 557435e22bc33d5b46d38478863149e4bb72817e) @@ -0,0 +1,123 @@ +#include +#include +#include +#include + +#include + +static const unsigned long N = 10_000ul; + +#ifndef PREEMPTION_RATE +#define PREEMPTION_RATE 10_000ul +#endif + +unsigned int default_preemption() { + return PREEMPTION_RATE; +} + +enum state_t { WAIT, SIGNAL, BARGE }; + +monitor global_t {}; +global_t mut; + +monitor global_data_t; +void ?{}( global_data_t & this ); +void ^?{} ( global_data_t & this ); + +monitor global_data_t { + int counter; + state_t state; +} data; + +condition cond; + +volatile bool all_done; + +void ?{}( global_data_t & this ) { + this.counter == 0; + this.state = BARGE; +} + +void ^?{} ( global_data_t & this ) {} + +//------------------------------------------------------------------------------ +// Barging logic +void barge( global_data_t & mutex d ) { + d.state = BARGE; +} + +thread Barger {}; + +void main( Barger & this ) { + while( !all_done ) { + barge( data ); + yield(); + } +} + +//------------------------------------------------------------------------------ +// Waiting logic +bool wait( global_t & mutex m, global_data_t & mutex d ) { + wait( cond ); + if( d.state != SIGNAL ) { + sout | "ERROR barging!" | endl; + } + + d.counter++; + + if( (d.counter % 1000) == 0 ) sout | d.counter | endl; + + return d.counter < N; +} + +thread Waiter {}; + +void main( Waiter & this ) { + while( wait( mut, data ) ) { yield(); } +} + + +//------------------------------------------------------------------------------ +// Signalling logic +void signal( condition & cond, global_t & mutex a, global_data_t & mutex b ) { + b.state = SIGNAL; + signal( cond ); +} + +void logic( global_t & mutex a ) { + signal( cond, a, data ); + + yield( random( 10 ) ); + + //This is technically a mutual exclusion violation but the mutex monitor protects us + bool running = data.counter < N && data.counter > 0; + if( data.state != SIGNAL && running ) { + sout | "ERROR Eager signal" | data.state | endl; + } +} + +thread Signaller {}; + +void main( Signaller & this ) { + while( !all_done ) { + logic( mut ); + yield(); + } +} + +//------------------------------------------------------------------------------ +// Main loop +int main(int argc, char* argv[]) { + random_seed( time( NULL ) ); + all_done = false; + processor p; + { + Signaller s; + Barger b[17]; + { + Waiter w[4]; + } + sout | "All waiter done" | endl; + all_done = true; + } +} Index: src/tests/concurrent/sched-int-wait.c =================================================================== --- src/tests/concurrent/sched-int-wait.c (revision 557435e22bc33d5b46d38478863149e4bb72817e) +++ src/tests/concurrent/sched-int-wait.c (revision 557435e22bc33d5b46d38478863149e4bb72817e) @@ -0,0 +1,143 @@ +//--------------------------------------------------------- +// Multi wait test +// Ensures that no deadlock from waiting/signalling conditions +//--------------------------------------------------------- + + +#include +#include +#include +#include +#include + +#include + +static const unsigned long N = 2_500ul; + +#ifndef PREEMPTION_RATE +#define PREEMPTION_RATE 10_000ul +#endif + +unsigned int default_preemption() { + return PREEMPTION_RATE; +} + +monitor global_t {}; + +global_t globalA; +global_t globalB; +global_t globalC; + +condition condAB, condAC, condBC, condABC; + +thread Signaler {}; +thread WaiterAB {}; +thread WaiterAC {}; +thread WaiterBC {}; +thread WaiterABC{}; + +volatile int waiter_left; + +//---------------------------------------------------------------------------------------------------- +// Tools +void signal( condition & cond, global_t & mutex a, global_t & mutex b ) { + signal( cond ); +} + +void signal( condition & cond, global_t & mutex a, global_t & mutex b, global_t & mutex c ) { + signal( cond ); +} + +void wait( condition & cond, global_t & mutex a, global_t & mutex b ) { + wait( cond ); +} + +void wait( condition & cond, global_t & mutex a, global_t & mutex b, global_t & mutex c ) { + wait( cond ); +} + +//---------------------------------------------------------------------------------------------------- +// Signaler +void main( Signaler & this ) { + + while( waiter_left != 0 ) { + unsigned action = random( 4 ); + switch( action ) { + case 0: + signal( condABC, globalA, globalB, globalC ); + break; + case 1: + signal( condAB , globalA, globalB ); + break; + case 2: + signal( condBC , globalB, globalC ); + break; + case 3: + signal( condAC , globalA, globalC ); + break; + default: + sout | "Something went wrong" | endl; + abort(); + } + yield(); + } +} + +//---------------------------------------------------------------------------------------------------- +// Waiter ABC +void main( WaiterABC & this ) { + for( int i = 0; i < N; i++ ) { + wait( condABC, globalA, globalB, globalC ); + } + + __sync_fetch_and_sub_4( &waiter_left, 1); +} + +//---------------------------------------------------------------------------------------------------- +// Waiter AB +void main( WaiterAB & this ) { + for( int i = 0; i < N; i++ ) { + wait( condAB , globalA, globalB ); + } + + __sync_fetch_and_sub_4( &waiter_left, 1); +} + +//---------------------------------------------------------------------------------------------------- +// Waiter AC +void main( WaiterAC & this ) { + for( int i = 0; i < N; i++ ) { + wait( condAC , globalA, globalC ); + } + + __sync_fetch_and_sub_4( &waiter_left, 1); +} + +//---------------------------------------------------------------------------------------------------- +// Waiter BC +void main( WaiterBC & this ) { + for( int i = 0; i < N; i++ ) { + wait( condBC , globalB, globalC ); + } + + __sync_fetch_and_sub_4( &waiter_left, 1); +} + +//---------------------------------------------------------------------------------------------------- +// Main +int main(int argc, char* argv[]) { + random_seed( time( NULL ) ); + waiter_left = 4; + processor p[2]; + sout | "Starting" | endl; + { + Signaler e; + { + WaiterABC a; + WaiterAB b; + WaiterBC c; + WaiterAC d; + } + } + sout | "Done" | endl; +} Index: src/tests/concurrent/thread.c =================================================================== --- src/tests/concurrent/thread.c (revision 557435e22bc33d5b46d38478863149e4bb72817e) +++ src/tests/concurrent/thread.c (revision 557435e22bc33d5b46d38478863149e4bb72817e) @@ -0,0 +1,40 @@ +#include +#include +#include +#include + +thread First { semaphore* lock; }; +thread Second { semaphore* lock; }; + +void ?{}( First & this, semaphore & lock ) { this.lock = &lock; } +void ?{}( Second & this, semaphore & lock ) { this.lock = &lock; } + +void main(First& this) { + for(int i = 0; i < 10; i++) { + sout | "First : Suspend No." | i + 1 | endl; + yield(); + } + V(*this.lock); +} + +void main(Second& this) { + P(*this.lock); + for(int i = 0; i < 10; i++) { + sout | "Second : Suspend No." | i + 1 | endl; + yield(); + } +} + + +int main(int argc, char* argv[]) { + semaphore lock = { 0 }; + sout | "User main begin" | endl; + { + processor p; + { + First f = { lock }; + Second s = { lock }; + } + } + sout | "User main end" | endl; +} Index: src/tests/concurrent/waitfor.c =================================================================== --- src/tests/concurrent/waitfor.c (revision 557435e22bc33d5b46d38478863149e4bb72817e) +++ src/tests/concurrent/waitfor.c (revision 557435e22bc33d5b46d38478863149e4bb72817e) @@ -0,0 +1,249 @@ +// +// Cforall Version 1.0.0 Copyright (C) 2017 University of Waterloo +// +// The contents of this file are covered under the licence agreement in the +// file "LICENCE" distributed with Cforall. +// +// waitfor.c -- +// +// Author : Peter A. Buhr +// Created On : Wed Aug 30 17:53:29 2017 +// Last Modified By : Peter A. Buhr +// Last Modified On : Wed Aug 30 17:55:17 2017 +// Update Count : 2 +// + +#include + +int fred() { + int x, z; + + // test waitfor and when + + waitfor( x ); + + waitfor( x ) { + } + + waitfor( x, z ) { + } + + when( true ) waitfor( x ); + + when( true ) waitfor( x ) { + } + + waitfor( x ); + or waitfor( y ); + + waitfor( x, z ); + or waitfor( y ); + + when( true ) waitfor( x ); + or when( true ) waitfor( y ); + + when( true ) waitfor( x, z ); + or when( true ) waitfor( y ); + + waitfor( x ) { + } or waitfor( y ) { + } + + waitfor( x, z ) { + } or waitfor( y ) { + } + + when( true ) waitfor( x ) { + } or when( true ) waitfor( y ) { + } + + waitfor( x ); + or waitfor( y ) { + } + + when( true ) waitfor( x ); + or when( true ) waitfor( y ) { + } + + waitfor( x ) { + } or waitfor( y ); + + when( true ) waitfor( x ) { + } or when( true ) waitfor( y ); + + // test when, waitfor and else + + waitfor( x ); + or else; + + when( true ) waitfor( x ); + or else; + + when( true ) waitfor( x, z ); + or else; + + waitfor( x ) { + } or else { + } + + when( true ) waitfor( x ) { + } or else { + } + + waitfor( x ); + or else { + } + + when( true ) waitfor( x ); + or else { + } + + when( true ) waitfor( x, z ); + or else { + } + + waitfor( x ) { + } or else; + + when( true ) waitfor( x ) { + } or else; + + waitfor( x ); + or when( true ) else; + + when( true ) waitfor( x ); + or when( true ) else; + + when( true ) waitfor( x, z ); + or when( true ) else; + + waitfor( x ) { + } or when( true ) else { + } + + when( true ) waitfor( x ) { + } or when( true ) else { + } + + waitfor( x ); + or when( true ) else { + } + + when( true ) waitfor( x ); + or when( true ) else { + } + + when( true ) waitfor( x, z ); + or when( true ) else { + } + + waitfor( x ) { + } or when( true ) else; + + when( true ) waitfor( x ) { + } or when( true ) else; + + // test when, waitfor and timeout + + waitfor( x ); + or timeout( 3 ); + + waitfor( x, z ); + or timeout( 3 ); + + when( true ) waitfor( x ); + or timeout( 3 ); + + waitfor( x ) { + } or timeout( 3 ) { + } + + when( true ) waitfor( x ) { + } or timeout( 3 ) { + } + + when( true ) waitfor( x, z ) { + } or timeout( 3 ) { + } + + when( true ) waitfor( x ) { + } or when ( true ) timeout( 3 ) { + } + + when( true ) waitfor( x, z ) { + } or when ( true ) timeout( 3 ) { + } + + waitfor( x ); + or timeout( 3 ) { + } + + when( true ) waitfor( x ); + or timeout( 3 ) { + } + + when( true ) waitfor( x ); + or when( true ) timeout( 3 ) { + } + + waitfor( x ) { + } or timeout( 3 ); + + when( true ) waitfor( x ) { + } or timeout( 3 ); + + when( true ) waitfor( x ) { + } or when( true ) timeout( 3 ); + + // test when, waitfor, timeout and else + + waitfor( x ) { + } or timeout( 3 ) { + } or when( true ) else {} + + when( true ) waitfor( x ) { + } or timeout( 3 ) { + } or when( true ) else {} + + waitfor( x ) { + } or timeout( 3 ) { + } or when( true ) else {} + + waitfor( x ) { + } or when( true ) timeout( 3 ) { + } or when( true ) else {} + + when( true ) waitfor( x ) { + } or timeout( 3 ) { + } or when( true ) else {} + + waitfor( x ) { + } or when( true ) timeout( 3 ) { + } or when( true ) else {} + + when( true ) waitfor( x ) { + } or when( true ) timeout( 3 ) { + } or when( true ) else {} + + // test quasi-keywords "or" and "timeout" + + int or, timeout; + waitfor( timeout, 7 ) 3; + waitfor( timeout, 7 ) 3; or waitfor( timeout, 7 ) 3; + when( or ) waitfor( or, ) { 4; } or timeout( 1 ) 3; + when( 3 ) waitfor( or, 2 ) 4; or else 4; + when( 3 ) waitfor( or, 3 ) 4; or when( or ) timeout( or ) 4; or when( or ) else timeout; + when( 3 ) waitfor( or, or ) 3; or when( or ) waitfor( or, timeout ) 4; or else 4; + when( 3 ) waitfor( or, or ) 3; or waitfor( or, 9 ) 4; or when( or ) timeout( timeout ) 4; + when( 3 ) waitfor( or, 3 ) 3; or waitfor( or, 7 ) or; or timeout( 1 ) or; or when( 3 ) else or; + + // test else selection + + if ( or > timeout ) waitfor( or ) 3; + else waitfor( timeout ) 4; +} + +// Local Variables: // +// tab-width: 4 // +// compile-command: "cfa waitfor.c" // +// End: // Index: src/tests/coroutine.c =================================================================== --- src/tests/coroutine.c (revision c2b9f212d8881b8a864b548bc1b467e8c22aba72) +++ (revision ) @@ -1,59 +1,0 @@ -// -// Cforall Version 1.0.0 Copyright (C) 2017 University of Waterloo -// -// The contents of this file are covered under the licence agreement in the -// file "LICENCE" distributed with Cforall. -// -// fibonacci.c -- -// -// Author : Thierry Delisle -// Created On : Thu Jun 8 07:29:37 2017 -// Last Modified By : Peter A. Buhr -// Last Modified On : Sun Sep 17 21:38:15 2017 -// Update Count : 7 -// - -#include -#include - -coroutine Fibonacci { - int fn; // used for communication -}; - -void ?{}( Fibonacci & this ) { - this.fn = 0; -} - -void main( Fibonacci & this ) { - int fn1, fn2; // retained between resumes - this.fn = 0; // case 0 - fn1 = this.fn; - suspend(); // restart last resume - - this.fn = 1; // case 1 - fn2 = fn1; fn1 = this.fn; - suspend(); // restart last resume - - for ( ;; ) { // general case - this.fn = fn1 + fn2; - fn2 = fn1; fn1 = this.fn; - suspend(); // restart last resume - } // for -} - -int next( Fibonacci & this ) { - resume( this ); // restart last suspend - return this.fn; -} - -int main() { - Fibonacci f1, f2; - for ( int i = 1; i <= 10; i += 1 ) { - sout | next( f1 ) | next( f2 ) | endl; - } // for -} - -// Local Variables: // -// tab-width: 4 // -// compile-command: "cfa fibonacci.c" // -// End: // Index: src/tests/coroutine/coroutine.c =================================================================== --- src/tests/coroutine/coroutine.c (revision 557435e22bc33d5b46d38478863149e4bb72817e) +++ src/tests/coroutine/coroutine.c (revision 557435e22bc33d5b46d38478863149e4bb72817e) @@ -0,0 +1,59 @@ +// +// Cforall Version 1.0.0 Copyright (C) 2017 University of Waterloo +// +// The contents of this file are covered under the licence agreement in the +// file "LICENCE" distributed with Cforall. +// +// fibonacci.c -- +// +// Author : Thierry Delisle +// Created On : Thu Jun 8 07:29:37 2017 +// Last Modified By : Peter A. Buhr +// Last Modified On : Sun Sep 17 21:38:15 2017 +// Update Count : 7 +// + +#include +#include + +coroutine Fibonacci { + int fn; // used for communication +}; + +void ?{}( Fibonacci & this ) { + this.fn = 0; +} + +void main( Fibonacci & this ) { + int fn1, fn2; // retained between resumes + this.fn = 0; // case 0 + fn1 = this.fn; + suspend(); // restart last resume + + this.fn = 1; // case 1 + fn2 = fn1; fn1 = this.fn; + suspend(); // restart last resume + + for ( ;; ) { // general case + this.fn = fn1 + fn2; + fn2 = fn1; fn1 = this.fn; + suspend(); // restart last resume + } // for +} + +int next( Fibonacci & this ) { + resume( this ); // restart last suspend + return this.fn; +} + +int main() { + Fibonacci f1, f2; + for ( int i = 1; i <= 10; i += 1 ) { + sout | next( f1 ) | next( f2 ) | endl; + } // for +} + +// Local Variables: // +// tab-width: 4 // +// compile-command: "cfa fibonacci.c" // +// End: // Index: src/tests/coroutine/fmtLines.c =================================================================== --- src/tests/coroutine/fmtLines.c (revision 557435e22bc33d5b46d38478863149e4bb72817e) +++ src/tests/coroutine/fmtLines.c (revision 557435e22bc33d5b46d38478863149e4bb72817e) @@ -0,0 +1,67 @@ +// +// Cforall Version 1.0.0 Copyright (C) 2017 University of Waterloo +// +// The contents of this file are covered under the licence agreement in the +// file "LICENCE" distributed with Cforall. +// +// fmtLines.cc -- +// +// Author : Peter A. Buhr +// Created On : Sun Sep 17 21:56:15 2017 +// Last Modified By : Peter A. Buhr +// Last Modified On : Sun Oct 1 11:57:19 2017 +// Update Count : 34 +// + +#include +#include + +coroutine Format { + char ch; // used for communication + int g, b; // global because used in destructor +}; + +void ?{}( Format & fmt ) { + resume( fmt ); // prime (start) coroutine +} + +void ^?{}( Format & fmt ) { + if ( fmt.g != 0 || fmt.b != 0 ) sout | endl; +} + +void main( Format & fmt ) { + for ( ;; ) { // for as many characters + for ( fmt.g = 0; fmt.g < 5; fmt.g += 1 ) { // groups of 5 blocks + for ( fmt.b = 0; fmt.b < 4; fmt.b += 1 ) { // blocks of 4 characters + for ( ;; ) { // for newline characters + suspend(); + if ( fmt.ch != '\n' ) break; // ignore newline + } // for + sout | fmt.ch; // print character + } // for + sout | " "; // print block separator + } // for + sout | endl; // print group separator + } // for +} // main + +void prt( Format & fmt, char ch ) { + fmt.ch = ch; + resume( fmt ); +} // prt + +int main() { + Format fmt; // format characters into blocks of 4 and groups of 5 blocks per line + char ch; + + Eof: for ( ;; ) { // read until end of file + sin | ch; // read one character + if ( eof( sin ) ) break Eof; // eof ? + prt( fmt, ch ); // push character for formatting + } // for +} // main + +// Local Variables: // +// tab-width: 4 // +// compile-command: "cfa fmtLines.c" // +// End: // Index: src/tests/coroutine/pingpong.c =================================================================== --- src/tests/coroutine/pingpong.c (revision 557435e22bc33d5b46d38478863149e4bb72817e) +++ src/tests/coroutine/pingpong.c (revision 557435e22bc33d5b46d38478863149e4bb72817e) @@ -0,0 +1,55 @@ +// +// Cforall Version 1.0.0 Copyright (C) 2017 University of Waterloo +// +// The contents of this file are covered under the licence agreement in the +// file "LICENCE" distributed with Cforall. +// +// pingpong.c -- +// +// Author : Peter A. Buhr +// Created On : Wed Sep 20 11:55:23 2017 +// Last Modified By : Peter A. Buhr +// Last Modified On : Wed Sep 20 13:41:39 2017 +// Update Count : 26 +// + +#include +#include + +coroutine PingPong { + const char * name; + /* const */ unsigned int N; + PingPong * part; +}; + +void ?{}( PingPong & this, const char * name, unsigned int N, PingPong & part ) { + this.name = name; + this.N = N; + this.part = ∂ +} +void ?{}( PingPong & this, const char * name, unsigned int N ) { + this{ name, N, *(PingPong *)0 }; +} +void cycle( PingPong & pingpong ) { + resume( pingpong ); +} +void partner( PingPong & this, PingPong & part ) { + this.part = ∂ + resume( this ); +} +void main( PingPong & pingpong ) { // ping's starter ::main, pong's starter ping + for ( unsigned int i = 0; i < pingpong.N; i += 1 ) { + sout | pingpong.name | endl; + cycle( *pingpong.part ); + } // for +} +int main() { + enum { N = 20 }; + PingPong ping = { "ping", N }, pong = { "pong", N, ping }; + partner( ping, pong ); +} + +// Local Variables: // +// tab-width: 4 // +// compile-command: "cfa pingpong.c" // +// End: // Index: src/tests/coroutine/prodcons.c =================================================================== --- src/tests/coroutine/prodcons.c (revision 557435e22bc33d5b46d38478863149e4bb72817e) +++ src/tests/coroutine/prodcons.c (revision 557435e22bc33d5b46d38478863149e4bb72817e) @@ -0,0 +1,100 @@ +// +// Cforall Version 1.0.0 Copyright (C) 2017 University of Waterloo +// +// The contents of this file are covered under the licence agreement in the +// file "LICENCE" distributed with Cforall. +// +// prodcons.c -- +// +// Author : Peter A. Buhr +// Created On : Mon Sep 18 12:23:39 2017 +// Last Modified By : Peter A. Buhr +// Last Modified On : Mon Oct 30 23:06:05 2017 +// Update Count : 42 +// + +#include +#include +#include // random +#include // getpid + +coroutine Cons; // forward +int delivery( Cons & cons, int p1, int p2 ); +void stop( Cons & cons ); + +coroutine Prod { + Cons *c; + int N, money, receipt; +}; +void main( Prod & prod ) { // starter ::main + // 1st resume starts here + for ( int i = 0; i < prod.N; i += 1 ) { + int p1 = random( 100 ); + int p2 = random( 100 ); + sout | p1 | " " | p2 | endl; + int status = delivery( *prod.c, p1, p2 ); + sout | " $" | prod.money | endl; + sout | status | endl; + prod.receipt += 1; + } + stop( *prod.c ); + sout | "prod stops" | endl; +} +int payment( Prod & prod, int money ) { + prod.money = money; + resume( prod ); // main 1st time, then + return prod.receipt; // prod in delivery +} +void start( Prod & prod, int N, Cons &c ) { + prod.N = N; + prod.c = &c; + prod.receipt = 0; + resume( prod ); // activate main +} + +coroutine Cons { + Prod * p; + int p1, p2, status; + bool done; +}; +void ?{}( Cons & cons, Prod & p ) { + cons.p = &p; + cons.status = 0; + cons.done = false; +} +void ^?{}( Cons & cons ) {} +void main( Cons & cons ) { // starter prod + // 1st resume starts here + int money = 1, receipt; + for ( ; ! cons.done; ) { + sout | cons.p1 | " " | cons.p2 | endl; + sout | " $" | money | endl; + cons.status += 1; + receipt = payment( *cons.p, money ); + sout | " #" | receipt | endl; + money += 1; + } + sout | "cons stops" | endl; +} +int delivery( Cons & cons, int p1, int p2 ) { + cons.p1 = p1; + cons.p2 = p2; + resume( cons ); // main 1st time, then + return cons.status; // cons in payment +} +void stop( Cons & cons ) { + cons.done = true; + resume( cons ); // activate payment +} +int main() { + Prod prod; + Cons cons = { prod }; + random_seed( /* getpid() */ 103 ); // fixed seed for testing + start( prod, 5, cons ); + sout | "main stops" | endl; +} + +// Local Variables: // +// tab-width: 4 // +// compile-command: "cfa prodcons.c" // +// End: // Index: src/tests/datingService.c =================================================================== --- src/tests/datingService.c (revision c2b9f212d8881b8a864b548bc1b467e8c22aba72) +++ (revision ) @@ -1,114 +1,0 @@ -// -*- Mode: C -*- -// -// The contents of this file are covered under the licence agreement in the -// file "LICENCE" distributed with Cforall. -// -// datingService.c -- -// -// Author : Peter A. Buhr -// Created On : Mon Oct 30 12:56:20 2017 -// Last Modified By : Peter A. Buhr -// Last Modified On : Mon Oct 30 23:02:11 2017 -// Update Count : 15 -// - -#include // random -#include -#include -#include -#include // getpid - -enum { NoOfPairs = 20 }; - -monitor DatingService { - condition Girls[NoOfPairs], Boys[NoOfPairs]; - unsigned int GirlPhoneNo, BoyPhoneNo; -}; // DatingService - -unsigned int girl( DatingService & mutex ds, unsigned int PhoneNo, unsigned int ccode ) { - if ( is_empty( ds.Boys[ccode] ) ) { - wait( ds.Girls[ccode] ); - ds.GirlPhoneNo = PhoneNo; - } else { - ds.GirlPhoneNo = PhoneNo; - signal_block( ds.Boys[ccode] ); - } // if - return ds.BoyPhoneNo; -} // DatingService girl - -unsigned int boy( DatingService & mutex ds, unsigned int PhoneNo, unsigned int ccode ) { - if ( is_empty( ds.Girls[ccode] ) ) { - wait( ds.Boys[ccode] ); - ds.BoyPhoneNo = PhoneNo; - } else { - ds.BoyPhoneNo = PhoneNo; - signal_block( ds.Girls[ccode] ); - } // if - return ds.GirlPhoneNo; -} // DatingService boy - -unsigned int girlck[NoOfPairs]; -unsigned int boyck[NoOfPairs]; - -thread Girl { - DatingService & TheExchange; - unsigned int id, ccode; -}; // Girl - -void main( Girl & g ) { - yield( random( 100 ) ); // don't all start at the same time - unsigned int partner = girl( g.TheExchange, g.id, g.ccode ); - //sout | "Girl:" | g.id | "is dating Boy at" | partner | "with ccode" | g.ccode | endl; - girlck[g.id] = partner; -} // Girl main - -void ?{}( Girl & g, DatingService * TheExchange, unsigned int id, unsigned int ccode ) { - &g.TheExchange = TheExchange; - g.id = id; - g.ccode = ccode; -} // Girl ?{} - -thread Boy { - DatingService &TheExchange; - unsigned int id, ccode; -}; // Boy - -void main( Boy & b ) { - yield( random( 100 ) ); // don't all start at the same time - unsigned int partner = boy( b.TheExchange, b.id, b.ccode ); - //sout | " Boy:" | b.id | "is dating Girl" | partner | "with ccode" | b.ccode | endl; - boyck[b.id] = partner; -} // Boy main - -void ?{}( Boy & b, DatingService * TheExchange, unsigned int id, unsigned int ccode ) { - &b.TheExchange = TheExchange; - b.id = id; - b.ccode = ccode; -} // Boy ?{} - -int main() { - DatingService TheExchange; - Girl *girls[NoOfPairs]; - Boy *boys[NoOfPairs]; - - random_seed( getpid() ); - - for ( unsigned int i = 0; i < NoOfPairs; i += 1 ) { - girls[i] = new( &TheExchange, i, i ); - boys[i] = new( &TheExchange, i, NoOfPairs - ( i + 1 ) ); - } // for - - for ( unsigned int i = 0; i < NoOfPairs; i += 1 ) { - delete( boys[i] ); - delete( girls[i] ); - } // for - - for ( unsigned int i = 0; i < NoOfPairs; i += 1 ) { - if ( girlck[ boyck[i] ] != boyck[ girlck[i] ] ) abort(); - } // for -} // main - -// Local Variables: // -// tab-width: 4 // -// compile-command: "cfa datingService.c" // -// End: // Index: src/tests/fmtLines.c =================================================================== --- src/tests/fmtLines.c (revision c2b9f212d8881b8a864b548bc1b467e8c22aba72) +++ (revision ) @@ -1,67 +1,0 @@ -// -// Cforall Version 1.0.0 Copyright (C) 2017 University of Waterloo -// -// The contents of this file are covered under the licence agreement in the -// file "LICENCE" distributed with Cforall. -// -// fmtLines.cc -- -// -// Author : Peter A. Buhr -// Created On : Sun Sep 17 21:56:15 2017 -// Last Modified By : Peter A. Buhr -// Last Modified On : Sun Oct 1 11:57:19 2017 -// Update Count : 34 -// - -#include -#include - -coroutine Format { - char ch; // used for communication - int g, b; // global because used in destructor -}; - -void ?{}( Format & fmt ) { - resume( fmt ); // prime (start) coroutine -} - -void ^?{}( Format & fmt ) { - if ( fmt.g != 0 || fmt.b != 0 ) sout | endl; -} - -void main( Format & fmt ) { - for ( ;; ) { // for as many characters - for ( fmt.g = 0; fmt.g < 5; fmt.g += 1 ) { // groups of 5 blocks - for ( fmt.b = 0; fmt.b < 4; fmt.b += 1 ) { // blocks of 4 characters - for ( ;; ) { // for newline characters - suspend(); - if ( fmt.ch != '\n' ) break; // ignore newline - } // for - sout | fmt.ch; // print character - } // for - sout | " "; // print block separator - } // for - sout | endl; // print group separator - } // for -} // main - -void prt( Format & fmt, char ch ) { - fmt.ch = ch; - resume( fmt ); -} // prt - -int main() { - Format fmt; // format characters into blocks of 4 and groups of 5 blocks per line - char ch; - - Eof: for ( ;; ) { // read until end of file - sin | ch; // read one character - if ( eof( sin ) ) break Eof; // eof ? - prt( fmt, ch ); // push character for formatting - } // for -} // main - -// Local Variables: // -// tab-width: 4 // -// compile-command: "cfa fmtLines.c" // -// End: // Index: src/tests/matrixSum.c =================================================================== --- src/tests/matrixSum.c (revision c2b9f212d8881b8a864b548bc1b467e8c22aba72) +++ (revision ) @@ -1,63 +1,0 @@ -// -*- Mode: C -*- -// -// Cforall Version 1.0.0 Copyright (C) 2017 University of Waterloo -// -// The contents of this file are covered under the licence agreement in the -// file "LICENCE" distributed with Cforall. -// -// matrixSum.c -- -// -// Author : Peter A. Buhr -// Created On : Mon Oct 9 08:29:28 2017 -// Last Modified By : Peter A. Buhr -// Last Modified On : Sun Oct 29 21:08:48 2017 -// Update Count : 2 -// - -#include -#include -#include - -thread Adder { - int * row, cols, * subtotal; // communication -}; - -void ?{}( Adder & adder, int row[], int cols, int & subtotal ) { - adder.row = row; - adder.cols = cols; - adder.subtotal = &subtotal; -} - -void main( Adder & adder ) { - *adder.subtotal = 0; - for ( int c = 0; c < adder.cols; c += 1 ) { - *adder.subtotal += adder.row[c]; - } // for -} - -int main() { - const int rows = 10, cols = 1000; - int matrix[rows][cols], subtotals[rows], total = 0; - processor p; // extra kernel thread - - for ( int r = 0; r < rows; r += 1 ) { - for ( int c = 0; c < cols; c += 1 ) { - matrix[r][c] = 1; - } // for - } // for - Adder * adders[rows]; - for ( int r = 0; r < rows; r += 1 ) { // start threads to sum rows - adders[r] = &(*malloc()){ matrix[r], cols, subtotals[r] }; -// adders[r] = new( matrix[r], cols, &subtotals[r] ); - } // for - for ( int r = 0; r < rows; r += 1 ) { // wait for threads to finish - delete( adders[r] ); - total += subtotals[r]; // total subtotals - } // for - sout | total | endl; -} - -// Local Variables: // -// tab-width: 4 // -// compile-command: "cfa matrixSum.c" // -// End: // Index: src/tests/monitor.c =================================================================== --- src/tests/monitor.c (revision c2b9f212d8881b8a864b548bc1b467e8c22aba72) +++ (revision ) @@ -1,43 +1,0 @@ -#include -#include -#include -#include - -monitor global_t { - int value; -}; - -void ?{}(global_t & this) { - this.value = 0; -} - -static global_t global; - -void increment3( global_t & mutex this ) { - this.value += 1; -} - -void increment2( global_t & mutex this ) { - increment3( this ); -} - -void increment( global_t & mutex this ) { - increment2( this ); -} - -thread MyThread {}; - -void main( MyThread & this ) { - for(int i = 0; i < 1_000_000; i++) { - increment( global ); - } -} - -int main(int argc, char* argv[]) { - assert( global.__mon.entry_queue.tail != NULL ); - processor p; - { - MyThread f[4]; - } - sout | global.value | endl; -} Index: src/tests/multi-monitor.c =================================================================== --- src/tests/multi-monitor.c (revision c2b9f212d8881b8a864b548bc1b467e8c22aba72) +++ (revision ) @@ -1,55 +1,0 @@ -#include -#include -#include -#include - -static int global12, global23, global13; - -monitor monitor_t {}; - -static monitor_t m1, m2, m3; - -void increment( monitor_t & mutex p1, monitor_t & mutex p2, int & value ) { - value += 1; -} - -thread MyThread { - int target; -}; - -void ?{}( MyThread & this, int target ) { - this.target = target; -} - -void ^?{}( MyThread & mutex this ) {} - -void main( MyThread & this ) { - for(int i = 0; i < 1000000; i++) { - choose(this.target) { - case 0: increment( m1, m2, global12 ); - case 1: increment( m2, m3, global23 ); - case 2: increment( m1, m3, global13 ); - } - } -} - -forall(dtype T | sized(T) | { void ^?{}(T & mutex); }) -void delete_mutex(T * x) { - ^(*x){}; - free(x); -} - -int main(int argc, char* argv[]) { - processor p; - { - MyThread * f[6]; - for(int i = 0; i < 6; i++) { - f[i] = new(i % 3); - } - - for(int i = 0; i < 6; i++) { - delete_mutex( f[i] ); - } - } - sout | global12 | global23 | global13 | endl; -} Index: src/tests/pingpong.c =================================================================== --- src/tests/pingpong.c (revision c2b9f212d8881b8a864b548bc1b467e8c22aba72) +++ (revision ) @@ -1,55 +1,0 @@ -// -// Cforall Version 1.0.0 Copyright (C) 2017 University of Waterloo -// -// The contents of this file are covered under the licence agreement in the -// file "LICENCE" distributed with Cforall. -// -// pingpong.c -- -// -// Author : Peter A. Buhr -// Created On : Wed Sep 20 11:55:23 2017 -// Last Modified By : Peter A. Buhr -// Last Modified On : Wed Sep 20 13:41:39 2017 -// Update Count : 26 -// - -#include -#include - -coroutine PingPong { - const char * name; - /* const */ unsigned int N; - PingPong * part; -}; - -void ?{}( PingPong & this, const char * name, unsigned int N, PingPong & part ) { - this.name = name; - this.N = N; - this.part = ∂ -} -void ?{}( PingPong & this, const char * name, unsigned int N ) { - this{ name, N, *(PingPong *)0 }; -} -void cycle( PingPong & pingpong ) { - resume( pingpong ); -} -void partner( PingPong & this, PingPong & part ) { - this.part = ∂ - resume( this ); -} -void main( PingPong & pingpong ) { // ping's starter ::main, pong's starter ping - for ( unsigned int i = 0; i < pingpong.N; i += 1 ) { - sout | pingpong.name | endl; - cycle( *pingpong.part ); - } // for -} -int main() { - enum { N = 20 }; - PingPong ping = { "ping", N }, pong = { "pong", N, ping }; - partner( ping, pong ); -} - -// Local Variables: // -// tab-width: 4 // -// compile-command: "cfa pingpong.c" // -// End: // Index: src/tests/preempt.c =================================================================== --- src/tests/preempt.c (revision c2b9f212d8881b8a864b548bc1b467e8c22aba72) +++ (revision ) @@ -1,42 +1,0 @@ -#include -#include - -#ifndef PREEMPTION_RATE -#define PREEMPTION_RATE 10_000ul -#endif - -unsigned int default_preemption() { - return PREEMPTION_RATE; -} - -static volatile int counter = 0; - -thread worker_t { - int value; -}; - -void ?{}( worker_t & this, int value ) { - this.value = value; -} - -void main(worker_t & this) { - while(counter < 1000) { - if( (counter % 7) == this.value ) { - int next = __atomic_add_fetch_4(&counter, 1, __ATOMIC_SEQ_CST); - if( (next % 100) == 0 ) printf("%d\n", next); - } - } -} - -int main(int argc, char* argv[]) { - processor p; - { - worker_t w0 = 0; - worker_t w1 = 1; - worker_t w2 = 2; - worker_t w3 = 3; - worker_t w4 = 4; - worker_t w5 = 5; - worker_t w6 = 6; - } -} Index: src/tests/prodcons.c =================================================================== --- src/tests/prodcons.c (revision c2b9f212d8881b8a864b548bc1b467e8c22aba72) +++ (revision ) @@ -1,100 +1,0 @@ -// -// Cforall Version 1.0.0 Copyright (C) 2017 University of Waterloo -// -// The contents of this file are covered under the licence agreement in the -// file "LICENCE" distributed with Cforall. -// -// prodcons.c -- -// -// Author : Peter A. Buhr -// Created On : Mon Sep 18 12:23:39 2017 -// Last Modified By : Peter A. Buhr -// Last Modified On : Mon Oct 30 23:06:05 2017 -// Update Count : 42 -// - -#include -#include -#include // random -#include // getpid - -coroutine Cons; // forward -int delivery( Cons & cons, int p1, int p2 ); -void stop( Cons & cons ); - -coroutine Prod { - Cons *c; - int N, money, receipt; -}; -void main( Prod & prod ) { // starter ::main - // 1st resume starts here - for ( int i = 0; i < prod.N; i += 1 ) { - int p1 = random( 100 ); - int p2 = random( 100 ); - sout | p1 | " " | p2 | endl; - int status = delivery( *prod.c, p1, p2 ); - sout | " $" | prod.money | endl; - sout | status | endl; - prod.receipt += 1; - } - stop( *prod.c ); - sout | "prod stops" | endl; -} -int payment( Prod & prod, int money ) { - prod.money = money; - resume( prod ); // main 1st time, then - return prod.receipt; // prod in delivery -} -void start( Prod & prod, int N, Cons &c ) { - prod.N = N; - prod.c = &c; - prod.receipt = 0; - resume( prod ); // activate main -} - -coroutine Cons { - Prod * p; - int p1, p2, status; - bool done; -}; -void ?{}( Cons & cons, Prod & p ) { - cons.p = &p; - cons.status = 0; - cons.done = false; -} -void ^?{}( Cons & cons ) {} -void main( Cons & cons ) { // starter prod - // 1st resume starts here - int money = 1, receipt; - for ( ; ! cons.done; ) { - sout | cons.p1 | " " | cons.p2 | endl; - sout | " $" | money | endl; - cons.status += 1; - receipt = payment( *cons.p, money ); - sout | " #" | receipt | endl; - money += 1; - } - sout | "cons stops" | endl; -} -int delivery( Cons & cons, int p1, int p2 ) { - cons.p1 = p1; - cons.p2 = p2; - resume( cons ); // main 1st time, then - return cons.status; // cons in payment -} -void stop( Cons & cons ) { - cons.done = true; - resume( cons ); // activate payment -} -int main() { - Prod prod; - Cons cons = { prod }; - random_seed( /* getpid() */ 103 ); // fixed seed for testing - start( prod, 5, cons ); - sout | "main stops" | endl; -} - -// Local Variables: // -// tab-width: 4 // -// compile-command: "cfa prodcons.c" // -// End: // Index: src/tests/sched-ext-barge.c =================================================================== --- src/tests/sched-ext-barge.c (revision c2b9f212d8881b8a864b548bc1b467e8c22aba72) +++ (revision ) @@ -1,92 +1,0 @@ -//--------------------------------------------------------- -// Barging test -// Ensures that no barging can occur between : -// - the frontend of the waitfor and the waited call -// - the waited call and the backend of the waitfor -//--------------------------------------------------------- - -#include -#include -#include -#include -#include - -#include - -static const unsigned long N = 5_000ul; - -enum state_t { WAITFOR, CALL, BARGE }; - -monitor global_t { - bool done; - bool started; - state_t state; -}; - -void ?{} ( global_t & this ) { - this.done = false; - this.started = false; - this.state = BARGE; -} - -void ^?{} ( global_t & mutex this ) {} - -global_t global; - -bool barge( global_t & mutex this ) { - this.state = BARGE; - return !this.done; -} - -thread barger_t {}; -void main( barger_t & this ) { - yield(); - while( barge( global ) ) { yield(random( 10 )); } -} - -bool do_call( global_t & mutex this ) { - yield(random( 10 )); - if( this.state != WAITFOR && !this.done && this.started ) { - serr | "Barging before caller detected" | endl; - } - - this.state = CALL; - return !this.done; -} - -thread caller_t {}; -void main( caller_t & this ) { - while( do_call(global) ) { yield(random( 10 )); } -} - -void do_wait( global_t & mutex this ) { - this.started = true; - for( int i = 0; i < N; i++) { - yield(random( 10 )); - this.state = WAITFOR; - waitfor(do_call, this) { - sout | i | endl; - } - - if( this.state != CALL ) { - serr | "Barging after caller detected" | endl; - } - } - - this.done = true; -} - -thread waiter_t{}; -void main( waiter_t & this ) { - do_wait(global); -} - -int main() { - sout | "Starting" | endl; - { - barger_t bargers[17]; - caller_t callers[7]; - waiter_t waiters; - } - sout | "Stopping" | endl; -} Index: src/tests/sched-ext-dtor.c =================================================================== --- src/tests/sched-ext-dtor.c (revision c2b9f212d8881b8a864b548bc1b467e8c22aba72) +++ (revision ) @@ -1,63 +1,0 @@ -//--------------------------------------------------------- -// Barging test -// Ensures the statement order is reverse when using waitfor ^?{} -//--------------------------------------------------------- - -#include -#include -#include -#include -#include - -#include - -static const unsigned long N = 5_000ul; - -enum state_t { - CTOR, - MAIN, - AFTER, - END, - DTOR -}; - -thread dummy_t { - state_t state; -}; - -static inline void set_state( dummy_t & this, state_t state) { - switch(state) { - case CTOR : break; - case MAIN : if( this.state != CTOR ) { serr | "ERROR Expected state to be CTOR" | endl; abort(); } this.state = state; break; - case AFTER : if( this.state != MAIN ) { serr | "ERROR Expected state to be MAIN" | endl; abort(); } this.state = state; break; - case END : if( this.state != AFTER ) { serr | "ERROR Expected state to be AFTER" | endl; abort(); } this.state = state; break; - case DTOR : if( this.state != END ) { serr | "ERROR Expected state to be END" | endl; abort(); } this.state = state; break; - } -} - -void ^?{}( dummy_t & mutex this ) { - set_state( this, DTOR ); -} - -void ?{}( dummy_t & this ) { - this.state = CTOR; -} - -void main( dummy_t & this ) { - yield(random( 10 )); - set_state( this, MAIN ); - waitfor( ^?{}, this ) { - set_state( this, AFTER ); - } - set_state( this, END ); -} - -int main() { - sout | "Starting" | endl; - processor p; - for( int i = 0; i < N; i++ ){ - dummy_t dummy[4]; - yield( random( 100 ) ); - } - sout | "Stopping" | endl; -} Index: src/tests/sched-ext-else.c =================================================================== --- src/tests/sched-ext-else.c (revision c2b9f212d8881b8a864b548bc1b467e8c22aba72) +++ (revision ) @@ -1,48 +1,0 @@ -#include -#include - -#include - -monitor M {}; - -void notcalled( M & mutex m ) { - abort(); -} - -void test( M & mutex m ) { - int i = 0; - sout | "Starting" | endl; - - when( false ) waitfor( notcalled, m ); - - sout | "Step" | i++ | endl; - - waitfor( notcalled, m ); or else { - sout | "else called" | endl; - } - - sout | "Step" | i++ | endl; - - when( true ) waitfor( notcalled, m ); or when( true ) else { - sout | "else called" | endl; - } - - sout | "Step" | i++ | endl; - - when( false ) waitfor( notcalled, m ); or when( true ) else { - sout | "else called" | endl; - } - - sout | "Step" | i++ | endl; - - when( false ) waitfor( notcalled, m ); or when( false ) else { - sout | "else called" | endl; - } - - sout | "Done" | endl; -} - -int main() { - M m; - test(m); -} Index: src/tests/sched-ext-parse.c =================================================================== --- src/tests/sched-ext-parse.c (revision c2b9f212d8881b8a864b548bc1b467e8c22aba72) +++ (revision ) @@ -1,104 +1,0 @@ -//---------------------------------------------------------------------------------------- -//---------------------------------------------------------------------------------------- -// -// DEPRECATED TEST -// DIFFERS BETWEEN DEBUG AND RELEASE -// -//---------------------------------------------------------------------------------------- -//---------------------------------------------------------------------------------------- - -#include - -monitor M {}; - -M a; - -void f1( M & mutex a ); -void f2( M & mutex a ); -void f2( M & mutex a, M & mutex b ); -void f3( M & mutex a ); -void f3( M & mutex a, M & mutex b ); -void f3( M & mutex a, M & mutex b, M & mutex c ); - -void foo() { - - //--------------------------------------- - waitfor( f1, a ) { - 1; - } - - //--------------------------------------- - waitfor( f1, a ) { - 2; - } - waitfor( f2, a ) { - 3; - } - - //--------------------------------------- - when( 1 < 3 ) waitfor( f2, a, a ) { - 4; - } - or timeout( 100 ) { - 5; - } - - //--------------------------------------- - when( 2 < 3 ) waitfor( f3, a ) { - 5; - } - or else { - 6; - } - - //--------------------------------------- - when( 3 < 3 ) waitfor( f3, a, a ) { - 7; - } - or when( 4 < 3 ) timeout( 101 ) { - 8; - } - or when( 5 < 3 ) else { - 9; - } - - //--------------------------------------- - when( 6 < 3 ) waitfor( f3, a, a, a ) { - 10; - } - or when( 7 < 3 ) waitfor( f1, a ) { - 11; - } - or else { - 12; - } - - //--------------------------------------- - when( 8 < 3 ) waitfor( f3, a, a ) { - 13; - } - or waitfor( f1, a ) { - 14; - } - or when( 9 < 3 ) timeout( 102 ) { - 15; - } - - //--------------------------------------- - when( 10 < 3 ) waitfor( f1, a ) { - 16; - } - or waitfor( f2, a, a ) { - 17; - } - or timeout( 103 ) { - 18; - } - or when( 11 < 3 ) else { - 19; - } -} - -int main() { - -} Index: src/tests/sched-ext-recurse.c =================================================================== --- src/tests/sched-ext-recurse.c (revision c2b9f212d8881b8a864b548bc1b467e8c22aba72) +++ (revision ) @@ -1,145 +1,0 @@ -//---------------------------------------------------------------- -// Recursion test -// Ensures that proper ordering occurs between the nested waitfors -//----------------------------------------------------------------- - -#include -#include -#include -#include -#include - -#include -#include - -static const unsigned long N = 5_000ul; - -static inline void rand_yield() { yield(random( 10 )); } - -enum state_t { FIRST, SECOND, THIRD, LAST, STOP }; -void shuffle(enum state_t * array) -{ - int i; - for (i = 0; i < 4; i++) - { - int j = random( 4 ); - enum state_t t = array[j]; - array[j] = array[i]; - array[i] = t; - } -} - - -monitor global_t { - int counter; - volatile bool ready; - state_t actions[4]; -}; - -void ?{} ( global_t & this ) { - this.counter = 0; - this.ready = false; - this.actions[0] = FIRST; - this.actions[1] = SECOND; - this.actions[2] = THIRD; - this.actions[3] = LAST; - shuffle( this.actions ); -} - -void ^?{} ( global_t & mutex this ) {} - -global_t global; - -state_t call4( global_t & mutex this, int idx ) { - sout | "Last"; - - rand_yield(); - this.counter++; - this.ready = false; - shuffle( this.actions ); - - return this.counter < N ? (state_t)this.actions[idx] : (state_t)STOP; -} - -state_t call3( global_t & mutex this, int idx ) { - sout | "3rd"; - - rand_yield(); - waitfor( call4, this ); - rand_yield(); - - sout | "3rd"; - - return this.counter < N ? (state_t)this.actions[idx] : (state_t)STOP; -} - -state_t call2( global_t & mutex this, int idx ) { - sout | "2nd"; - - rand_yield(); - waitfor( call3, this ); - rand_yield(); - - sout | "2nd"; - - return this.counter < N ? (state_t)this.actions[idx] : (state_t)STOP; -} - -state_t call1( global_t & mutex this, int idx ) { - this.ready = true; - - sout | this.counter | "1st"; - - rand_yield(); - waitfor( call2, this ); - rand_yield(); - - sout | "1st" | endl; - - return this.counter < N ? (state_t)this.actions[idx] : (state_t)STOP; -} - -thread waiter_t{ - int idx; - state_t state; -}; - -void ^?{} ( waiter_t & mutex this ) {} -void ?{} ( waiter_t & this ) {} - -void ?{}( waiter_t & this, int idx, state_t state ) { - this.idx = idx; - this.state = state; -} - - -void main( waiter_t & this ) { - while( this.state != STOP ) { - rand_yield(); - - switch( this.state ) { - case FIRST : this.state = call1( global, this.idx ); break; - case SECOND : while( !global.ready ) { yield(); } this.state = call2( global, this.idx ); break; - case THIRD : while( !global.ready ) { yield(); } this.state = call3( global, this.idx ); break; - case LAST : while( !global.ready ) { yield(); } this.state = call4( global, this.idx ); break; - case STOP : serr | "This should not happen" | endl; - } - } -} - -static waiter_t * volatile the_threads; - -int main() { - random_seed( time(NULL) ); - sout | "Starting" | endl; - { - waiter_t waiters[4] = { - { 0, FIRST }, - { 1, SECOND }, - { 2, THIRD }, - { 3, LAST } - }; - the_threads = waiters; - } - sout | "Stopping" | endl; -} Index: src/tests/sched-ext-statment.c =================================================================== --- src/tests/sched-ext-statment.c (revision c2b9f212d8881b8a864b548bc1b467e8c22aba72) +++ (revision ) @@ -1,136 +1,0 @@ -#include -#include -#include -#include - -#include - -monitor M { - int index; - int last_val; - int calls[7]; -}; - -volatile bool start = false; - -void ?{}( M & this ) { - this.index = 0; - this.last_val = 0; - for( int i = 0; i < 7; i++ ) { - this.calls[i] = 100; //10_000; - } -} - -void ^?{} ( M & mutex this ) {} - -int get_index( M & mutex this ) { - this.index += 1; - return this.index; -} - -bool call1( M & mutex this ) { - this.last_val = 1; - this.calls[0] -= 1; - return this.calls[0] > 0; -} - -bool call2( M & mutex this ) { - this.last_val = 2; - this.calls[1] -= 1; - return this.calls[1] > 0; -} - -bool call3( M & mutex this ) { - this.last_val = 3; - this.calls[2] -= 1; - return this.calls[2] > 0; -} - -bool call4( M & mutex this ) { - this.last_val = 4; - this.calls[3] -= 1; - return this.calls[3] > 0; -} - -bool call5( M & mutex this ) { - this.last_val = 5; - this.calls[4] -= 1; - return this.calls[4] > 0; -} - -bool call6( M & mutex this ) { - this.last_val = 6; - this.calls[5] -= 1; - return this.calls[5] > 0; -} - -bool call7( M & mutex this ) { - this.last_val = 7; - this.calls[6] -= 1; - return this.calls[6] > 0; -} - -M m; -thread caller{}; - -bool call( int index ) { - switch( index ) { - case 1: return call1( m ); - case 2: return call2( m ); - case 3: return call3( m ); - case 4: return call4( m ); - case 5: return call5( m ); - case 6: return call6( m ); - case 7: return call7( m ); - default : - serr | "Incorrect index" | index | endl; - abort(); - } -} - -void main( caller & this ) { - int index = get_index( m ); - while( !start ) yield(); - while( call( index ) ); -} - -void do_wait( M & mutex this ) { - bool done = false; - - start = true; - - while( !done ) { - waitfor( get_index, this ); - or waitfor( call1, this ) { sout | "Statement" | endl; if( this.last_val != 1 ) { serr | "Incorrect index: expected" | 1 | "got" | this.last_val | endl; } } - or waitfor( call2, this ) { sout | "Statement" | endl; if( this.last_val != 2 ) { serr | "Incorrect index: expected" | 2 | "got" | this.last_val | endl; } } - or waitfor( call3, this ) { sout | "Statement" | endl; if( this.last_val != 3 ) { serr | "Incorrect index: expected" | 3 | "got" | this.last_val | endl; } } - or waitfor( call4, this ) { sout | "Statement" | endl; if( this.last_val != 4 ) { serr | "Incorrect index: expected" | 4 | "got" | this.last_val | endl; } } - or waitfor( call5, this ) { sout | "Statement" | endl; if( this.last_val != 5 ) { serr | "Incorrect index: expected" | 5 | "got" | this.last_val | endl; } } - or waitfor( call6, this ) { sout | "Statement" | endl; if( this.last_val != 6 ) { serr | "Incorrect index: expected" | 6 | "got" | this.last_val | endl; } } - or waitfor( call7, this ) { sout | "Statement" | endl; if( this.last_val != 7 ) { serr | "Incorrect index: expected" | 7 | "got" | this.last_val | endl; } } - - done = true; - for( int i = 0; i < 7; i++ ) { - if( this.calls[i] > 0 ) { - done = false; - break; - } - } - } -} - -thread waiter{}; - -void main( waiter & this ) { - do_wait( m ); -} - -int main() { - processor p[2]; - sout | "Starting" | endl; - { - caller c[7]; - waiter w; - } - sout | "Stopping" | endl; -} Index: src/tests/sched-ext-when.c =================================================================== --- src/tests/sched-ext-when.c (revision c2b9f212d8881b8a864b548bc1b467e8c22aba72) +++ (revision ) @@ -1,87 +1,0 @@ -//---------------------------------------------------------------- -// When test -// Ensures that when clauses on waitfor are respected -//----------------------------------------------------------------- - -#include -#include -#include -#include -#include - -#include -#include - -static const unsigned long N = 4_998ul; - -static inline void rand_yield() { yield(random( 10 )); } - -monitor global_t { - int last_call; - bool done; -}; - -void ?{} ( global_t & this ) { - this.last_call = 6; - this.done = false; -} - -void ^?{} ( global_t & mutex this ) {} - -global_t global; - -bool call1( global_t & mutex this ) { this.last_call = 1; return this.done; } -bool call2( global_t & mutex this ) { this.last_call = 2; return this.done; } -bool call3( global_t & mutex this ) { this.last_call = 3; return this.done; } -bool call4( global_t & mutex this ) { this.last_call = 4; return this.done; } -bool call5( global_t & mutex this ) { this.last_call = 5; return this.done; } -bool call6( global_t & mutex this ) { this.last_call = 6; return this.done; } - -thread caller_t{}; -void main( caller_t & this ) { - while( true ) { - rand_yield(); - if( call1( global ) ) return; - rand_yield(); - if( call2( global ) ) return; - rand_yield(); - if( call3( global ) ) return; - rand_yield(); - if( call4( global ) ) return; - rand_yield(); - if( call5( global ) ) return; - rand_yield(); - if( call6( global ) ) return; - } -} - -void arbiter( global_t & mutex this ) { - for( int i = 0; i < N; i++ ) { - when( this.last_call == 6 ) waitfor( call1, this ) { if( this.last_call != 1) { serr | "Expected last_call to be 1 got" | this.last_call | endl; } } - or when( this.last_call == 1 ) waitfor( call2, this ) { if( this.last_call != 2) { serr | "Expected last_call to be 2 got" | this.last_call | endl; } } - or when( this.last_call == 2 ) waitfor( call3, this ) { if( this.last_call != 3) { serr | "Expected last_call to be 3 got" | this.last_call | endl; } } - or when( this.last_call == 3 ) waitfor( call4, this ) { if( this.last_call != 4) { serr | "Expected last_call to be 4 got" | this.last_call | endl; } } - or when( this.last_call == 4 ) waitfor( call5, this ) { if( this.last_call != 5) { serr | "Expected last_call to be 5 got" | this.last_call | endl; } } - or when( this.last_call == 5 ) waitfor( call6, this ) { if( this.last_call != 6) { serr | "Expected last_call to be 6 got" | this.last_call | endl; } } - - sout | this.last_call | endl; - } - - this.done = true; -} - -thread arbiter_t{}; -void main( arbiter_t & this ) { - arbiter( global ); -} - -int main() { - random_seed( time(NULL) ); - sout | "Starting" | endl; - { - arbiter_t arbiter; - caller_t callers[7]; - - } - sout | "Stopping" | endl; -} Index: src/tests/sched-ext.c =================================================================== --- src/tests/sched-ext.c (revision c2b9f212d8881b8a864b548bc1b467e8c22aba72) +++ (revision ) @@ -1,85 +1,0 @@ -#include -#include -#include -#include -#include - -#include - -static const unsigned long N = 500ul; - -#ifndef PREEMPTION_RATE -#define PREEMPTION_RATE 10_000ul -#endif - -unsigned int default_preemption() { - return PREEMPTION_RATE; -} - -monitor global_t {}; - -global_t globalA; - -thread Acceptor {}; -thread Acceptee {}; - -volatile bool done; - -//---------------------------------------------------------------------------------------------------- -// Acceptor -void do_notify( global_t * mutex a ); - -void do_wait( global_t * mutex a ) { - sout | "Waiting to accept" | endl; - yield( random( 10 ) ); - - sout | "Accepting" | endl; - - __acceptable_t acceptable; - acceptable.func = (fptr_t)do_notify; - acceptable.count = 1; - acceptable.monitors = &a; - - __waitfor_internal( 1, &acceptable ); - - sout | "Accepted" | endl; - yield( random( 10 ) ); -} - -void main( Acceptor* this ) { - for( int i = 0; i < N; i++ ) { - do_wait( &globalA ); - sout | i | endl; - } - - done = true; -} - -//---------------------------------------------------------------------------------------------------- -// Acceptee -void do_notify( global_t * mutex a ) { - -} - -void main( Acceptee* this ) { - while( !done ) { - yield( random( 10 ) ); - do_notify( &globalA ); - yield( random( 10 ) ); - } -} - -//---------------------------------------------------------------------------------------------------- -// Main -int main(int argc, char* argv[]) { - done = false; - random_seed( time( NULL ) ); - printf("%p\n", &globalA); - sout | "Starting" | endl; - { - Acceptor r; - Acceptee e[13]; - - } - sout | "Done" | endl; -} Index: src/tests/sched-int-barge.c =================================================================== --- src/tests/sched-int-barge.c (revision c2b9f212d8881b8a864b548bc1b467e8c22aba72) +++ (revision ) @@ -1,117 +1,0 @@ -//---------------------------------------------------------------------------------------- -//---------------------------------------------------------------------------------------- -// -// DEPRECATED TEST -// -//---------------------------------------------------------------------------------------- -//---------------------------------------------------------------------------------------- - -#include -#include -#include -#include -#include - -static const unsigned long N = 50_000ul; - -#ifndef PREEMPTION_RATE -#define PREEMPTION_RATE 10_000ul -#endif - -unsigned int default_preemption() { - return 0; -} -enum state_t { WAIT, SIGNAL, BARGE }; - -monitor global_t {}; - -monitor global_data_t { - volatile bool done; - int counter; - state_t state; - - unsigned short do_signal; - unsigned short do_wait2; - unsigned short do_wait1; -}; - -void ?{} ( global_data_t & this ) { - this.done = false; - this.counter = 0; - this.state = BARGE; - - this.do_signal = 6; - this.do_wait1 = 1; - this.do_wait2 = 3; -} - -void ^?{} ( global_data_t & this ) {} - -global_t globalA; -global_t globalB; -global_data_t globalC; - -condition cond; - -thread Threads {}; - -bool logicC( global_t & mutex a, global_t & mutex b, global_data_t & mutex c ) { - c.counter++; - - if( (c.counter % 1000) == 0 ) sout | c.counter | endl; - - int action = c.counter % 10; - - if( action == 0 ) { - c.do_signal = max( random( 10 ), 1); - c.do_wait1 = random( c.do_signal ); - c.do_wait2 = random( c.do_signal ); - - if(c.do_wait1 == c.do_wait2) sout | "Same" | endl; - } - - if( action == c.do_wait1 || action == c.do_wait2 ) { - c.state = WAIT; - wait( cond ); - - if(c.state != SIGNAL) { - sout | "ERROR Barging detected" | c.counter | endl; - abort(); - } - } - else if( action == c.do_signal ) { - c.state = SIGNAL; - - signal( cond ); - signal( cond ); - } - else { - c.state = BARGE; - } - - if( c.counter >= N ) c.done = true; - return !c.done; -} - -bool logicB( global_t & mutex a, global_t & mutex b ) { - return logicC(a, b, globalC); -} - -bool logicA( global_t & mutex a ) { - return logicB(a, globalB); -} - -void main( Threads & this ) { - while( logicA(globalA) ) { yield(); }; -} - -static thread_desc * volatile the_threads; - -int main(int argc, char* argv[]) { - random_seed(0); - processor p; - { - Threads t[17]; - the_threads = (thread_desc*)t; - } -} Index: src/tests/sched-int-block.c =================================================================== --- src/tests/sched-int-block.c (revision c2b9f212d8881b8a864b548bc1b467e8c22aba72) +++ (revision ) @@ -1,133 +1,0 @@ -//--------------------------------------------------------- -// Barging test -// Ensures that no barging can occur between : -// - the frontend of the signal_block and the signaled thread -// - the signaled threadand the backend of the signal_block -//--------------------------------------------------------- - - -#include -#include -#include -#include -#include - -#include - -static const unsigned long N = 5_000ul; - -#ifndef PREEMPTION_RATE -#define PREEMPTION_RATE 10_000ul -#endif - -unsigned int default_preemption() { - return PREEMPTION_RATE; -} - -enum state_t { WAITED, SIGNAL, BARGE }; - -monitor global_data_t { - thread_desc * last_thread; - thread_desc * last_signaller; -}; - -void ?{} ( global_data_t & this ) { - this.last_thread = NULL; - this.last_signaller = NULL; -} - -void ^?{} ( global_data_t & this ) {} - -global_data_t globalA, globalB; - -condition cond; - -volatile bool done; - -//------------------------------------------------------------------------------ -void wait_op( global_data_t & mutex a, global_data_t & mutex b, unsigned i ) { - wait( cond, (uintptr_t)this_thread ); - - yield( random( 10 ) ); - - if(a.last_thread != a.last_signaller || b.last_thread != b.last_signaller ) { - sout | "ERROR Barging detected, expected" | a.last_signaller | b.last_signaller | "got" | a.last_thread | b.last_thread | endl; - abort(); - } - - a.last_thread = b.last_thread = this_thread; - - yield( random( 10 ) ); -} - -thread Waiter {}; -void main( Waiter & this ) { - for( int i = 0; i < N; i++ ) { - wait_op( globalA, globalB, i ); - } -} - -//------------------------------------------------------------------------------ -void signal_op( global_data_t & mutex a, global_data_t & mutex b ) { - yield( random( 10 ) ); - - [a.last_thread, b.last_thread, a.last_signaller, b.last_signaller] = this_thread; - - if( !is_empty( cond ) ) { - - thread_desc * next = front( cond ); - - if( ! signal_block( cond ) ) { - sout | "ERROR expected to be able to signal" | endl; - abort(); - } - - yield( random( 10 ) ); - - if(a.last_thread != next || b.last_thread != next) { - sout | "ERROR Barging detected, expected" | next | "got" | a.last_thread | b.last_thread | endl; - abort(); - } - } - -} - -thread Signaller {}; -void main( Signaller & this ) { - while( !done ) { - signal_op( globalA, globalB ); - } -} - -//------------------------------------------------------------------------------ -void barge_op( global_data_t & mutex a ) { - a.last_thread = this_thread; -} - -thread Barger {}; -void main( Barger & this ) { - for( unsigned i = 0; !done; i++ ) { - //Choose some monitor to barge into with some irregular pattern - bool choose_a = (i % 13) > (i % 17); - if ( choose_a ) barge_op( globalA ); - else barge_op( globalB ); - } -} - -//------------------------------------------------------------------------------ - -int main(int argc, char* argv[]) { - random_seed( time( NULL ) ); - done = false; - processor p; - { - Signaller s[4]; - Barger b[13]; - sout | "Starting waiters" | endl; - { - Waiter w[3]; - } - sout | "Waiters done" | endl; - done = true; - } -} Index: src/tests/sched-int-disjoint.c =================================================================== --- src/tests/sched-int-disjoint.c (revision c2b9f212d8881b8a864b548bc1b467e8c22aba72) +++ (revision ) @@ -1,123 +1,0 @@ -#include -#include -#include -#include - -#include - -static const unsigned long N = 10_000ul; - -#ifndef PREEMPTION_RATE -#define PREEMPTION_RATE 10_000ul -#endif - -unsigned int default_preemption() { - return PREEMPTION_RATE; -} - -enum state_t { WAIT, SIGNAL, BARGE }; - -monitor global_t {}; -global_t mut; - -monitor global_data_t; -void ?{}( global_data_t & this ); -void ^?{} ( global_data_t & this ); - -monitor global_data_t { - int counter; - state_t state; -} data; - -condition cond; - -volatile bool all_done; - -void ?{}( global_data_t & this ) { - this.counter == 0; - this.state = BARGE; -} - -void ^?{} ( global_data_t & this ) {} - -//------------------------------------------------------------------------------ -// Barging logic -void barge( global_data_t & mutex d ) { - d.state = BARGE; -} - -thread Barger {}; - -void main( Barger & this ) { - while( !all_done ) { - barge( data ); - yield(); - } -} - -//------------------------------------------------------------------------------ -// Waiting logic -bool wait( global_t & mutex m, global_data_t & mutex d ) { - wait( cond ); - if( d.state != SIGNAL ) { - sout | "ERROR barging!" | endl; - } - - d.counter++; - - if( (d.counter % 1000) == 0 ) sout | d.counter | endl; - - return d.counter < N; -} - -thread Waiter {}; - -void main( Waiter & this ) { - while( wait( mut, data ) ) { yield(); } -} - - -//------------------------------------------------------------------------------ -// Signalling logic -void signal( condition & cond, global_t & mutex a, global_data_t & mutex b ) { - b.state = SIGNAL; - signal( cond ); -} - -void logic( global_t & mutex a ) { - signal( cond, a, data ); - - yield( random( 10 ) ); - - //This is technically a mutual exclusion violation but the mutex monitor protects us - bool running = data.counter < N && data.counter > 0; - if( data.state != SIGNAL && running ) { - sout | "ERROR Eager signal" | data.state | endl; - } -} - -thread Signaller {}; - -void main( Signaller & this ) { - while( !all_done ) { - logic( mut ); - yield(); - } -} - -//------------------------------------------------------------------------------ -// Main loop -int main(int argc, char* argv[]) { - random_seed( time( NULL ) ); - all_done = false; - processor p; - { - Signaller s; - Barger b[17]; - { - Waiter w[4]; - } - sout | "All waiter done" | endl; - all_done = true; - } -} Index: src/tests/sched-int-wait.c =================================================================== --- src/tests/sched-int-wait.c (revision c2b9f212d8881b8a864b548bc1b467e8c22aba72) +++ (revision ) @@ -1,143 +1,0 @@ -//--------------------------------------------------------- -// Multi wait test -// Ensures that no deadlock from waiting/signalling conditions -//--------------------------------------------------------- - - -#include -#include -#include -#include -#include - -#include - -static const unsigned long N = 2_500ul; - -#ifndef PREEMPTION_RATE -#define PREEMPTION_RATE 10_000ul -#endif - -unsigned int default_preemption() { - return PREEMPTION_RATE; -} - -monitor global_t {}; - -global_t globalA; -global_t globalB; -global_t globalC; - -condition condAB, condAC, condBC, condABC; - -thread Signaler {}; -thread WaiterAB {}; -thread WaiterAC {}; -thread WaiterBC {}; -thread WaiterABC{}; - -volatile int waiter_left; - -//---------------------------------------------------------------------------------------------------- -// Tools -void signal( condition & cond, global_t & mutex a, global_t & mutex b ) { - signal( cond ); -} - -void signal( condition & cond, global_t & mutex a, global_t & mutex b, global_t & mutex c ) { - signal( cond ); -} - -void wait( condition & cond, global_t & mutex a, global_t & mutex b ) { - wait( cond ); -} - -void wait( condition & cond, global_t & mutex a, global_t & mutex b, global_t & mutex c ) { - wait( cond ); -} - -//---------------------------------------------------------------------------------------------------- -// Signaler -void main( Signaler & this ) { - - while( waiter_left != 0 ) { - unsigned action = random( 4 ); - switch( action ) { - case 0: - signal( condABC, globalA, globalB, globalC ); - break; - case 1: - signal( condAB , globalA, globalB ); - break; - case 2: - signal( condBC , globalB, globalC ); - break; - case 3: - signal( condAC , globalA, globalC ); - break; - default: - sout | "Something went wrong" | endl; - abort(); - } - yield(); - } -} - -//---------------------------------------------------------------------------------------------------- -// Waiter ABC -void main( WaiterABC & this ) { - for( int i = 0; i < N; i++ ) { - wait( condABC, globalA, globalB, globalC ); - } - - __sync_fetch_and_sub_4( &waiter_left, 1); -} - -//---------------------------------------------------------------------------------------------------- -// Waiter AB -void main( WaiterAB & this ) { - for( int i = 0; i < N; i++ ) { - wait( condAB , globalA, globalB ); - } - - __sync_fetch_and_sub_4( &waiter_left, 1); -} - -//---------------------------------------------------------------------------------------------------- -// Waiter AC -void main( WaiterAC & this ) { - for( int i = 0; i < N; i++ ) { - wait( condAC , globalA, globalC ); - } - - __sync_fetch_and_sub_4( &waiter_left, 1); -} - -//---------------------------------------------------------------------------------------------------- -// Waiter BC -void main( WaiterBC & this ) { - for( int i = 0; i < N; i++ ) { - wait( condBC , globalB, globalC ); - } - - __sync_fetch_and_sub_4( &waiter_left, 1); -} - -//---------------------------------------------------------------------------------------------------- -// Main -int main(int argc, char* argv[]) { - random_seed( time( NULL ) ); - waiter_left = 4; - processor p[2]; - sout | "Starting" | endl; - { - Signaler e; - { - WaiterABC a; - WaiterAB b; - WaiterBC c; - WaiterAC d; - } - } - sout | "Done" | endl; -} Index: src/tests/thread.c =================================================================== --- src/tests/thread.c (revision c2b9f212d8881b8a864b548bc1b467e8c22aba72) +++ (revision ) @@ -1,40 +1,0 @@ -#include -#include -#include -#include - -thread First { semaphore* lock; }; -thread Second { semaphore* lock; }; - -void ?{}( First & this, semaphore & lock ) { this.lock = &lock; } -void ?{}( Second & this, semaphore & lock ) { this.lock = &lock; } - -void main(First& this) { - for(int i = 0; i < 10; i++) { - sout | "First : Suspend No." | i + 1 | endl; - yield(); - } - V(*this.lock); -} - -void main(Second& this) { - P(*this.lock); - for(int i = 0; i < 10; i++) { - sout | "Second : Suspend No." | i + 1 | endl; - yield(); - } -} - - -int main(int argc, char* argv[]) { - semaphore lock = { 0 }; - sout | "User main begin" | endl; - { - processor p; - { - First f = { lock }; - Second s = { lock }; - } - } - sout | "User main end" | endl; -} Index: src/tests/waitfor.c =================================================================== --- src/tests/waitfor.c (revision c2b9f212d8881b8a864b548bc1b467e8c22aba72) +++ (revision ) @@ -1,249 +1,0 @@ -// -// Cforall Version 1.0.0 Copyright (C) 2017 University of Waterloo -// -// The contents of this file are covered under the licence agreement in the -// file "LICENCE" distributed with Cforall. -// -// waitfor.c -- -// -// Author : Peter A. Buhr -// Created On : Wed Aug 30 17:53:29 2017 -// Last Modified By : Peter A. Buhr -// Last Modified On : Wed Aug 30 17:55:17 2017 -// Update Count : 2 -// - -#include - -int fred() { - int x, z; - - // test waitfor and when - - waitfor( x ); - - waitfor( x ) { - } - - waitfor( x, z ) { - } - - when( true ) waitfor( x ); - - when( true ) waitfor( x ) { - } - - waitfor( x ); - or waitfor( y ); - - waitfor( x, z ); - or waitfor( y ); - - when( true ) waitfor( x ); - or when( true ) waitfor( y ); - - when( true ) waitfor( x, z ); - or when( true ) waitfor( y ); - - waitfor( x ) { - } or waitfor( y ) { - } - - waitfor( x, z ) { - } or waitfor( y ) { - } - - when( true ) waitfor( x ) { - } or when( true ) waitfor( y ) { - } - - waitfor( x ); - or waitfor( y ) { - } - - when( true ) waitfor( x ); - or when( true ) waitfor( y ) { - } - - waitfor( x ) { - } or waitfor( y ); - - when( true ) waitfor( x ) { - } or when( true ) waitfor( y ); - - // test when, waitfor and else - - waitfor( x ); - or else; - - when( true ) waitfor( x ); - or else; - - when( true ) waitfor( x, z ); - or else; - - waitfor( x ) { - } or else { - } - - when( true ) waitfor( x ) { - } or else { - } - - waitfor( x ); - or else { - } - - when( true ) waitfor( x ); - or else { - } - - when( true ) waitfor( x, z ); - or else { - } - - waitfor( x ) { - } or else; - - when( true ) waitfor( x ) { - } or else; - - waitfor( x ); - or when( true ) else; - - when( true ) waitfor( x ); - or when( true ) else; - - when( true ) waitfor( x, z ); - or when( true ) else; - - waitfor( x ) { - } or when( true ) else { - } - - when( true ) waitfor( x ) { - } or when( true ) else { - } - - waitfor( x ); - or when( true ) else { - } - - when( true ) waitfor( x ); - or when( true ) else { - } - - when( true ) waitfor( x, z ); - or when( true ) else { - } - - waitfor( x ) { - } or when( true ) else; - - when( true ) waitfor( x ) { - } or when( true ) else; - - // test when, waitfor and timeout - - waitfor( x ); - or timeout( 3 ); - - waitfor( x, z ); - or timeout( 3 ); - - when( true ) waitfor( x ); - or timeout( 3 ); - - waitfor( x ) { - } or timeout( 3 ) { - } - - when( true ) waitfor( x ) { - } or timeout( 3 ) { - } - - when( true ) waitfor( x, z ) { - } or timeout( 3 ) { - } - - when( true ) waitfor( x ) { - } or when ( true ) timeout( 3 ) { - } - - when( true ) waitfor( x, z ) { - } or when ( true ) timeout( 3 ) { - } - - waitfor( x ); - or timeout( 3 ) { - } - - when( true ) waitfor( x ); - or timeout( 3 ) { - } - - when( true ) waitfor( x ); - or when( true ) timeout( 3 ) { - } - - waitfor( x ) { - } or timeout( 3 ); - - when( true ) waitfor( x ) { - } or timeout( 3 ); - - when( true ) waitfor( x ) { - } or when( true ) timeout( 3 ); - - // test when, waitfor, timeout and else - - waitfor( x ) { - } or timeout( 3 ) { - } or when( true ) else {} - - when( true ) waitfor( x ) { - } or timeout( 3 ) { - } or when( true ) else {} - - waitfor( x ) { - } or timeout( 3 ) { - } or when( true ) else {} - - waitfor( x ) { - } or when( true ) timeout( 3 ) { - } or when( true ) else {} - - when( true ) waitfor( x ) { - } or timeout( 3 ) { - } or when( true ) else {} - - waitfor( x ) { - } or when( true ) timeout( 3 ) { - } or when( true ) else {} - - when( true ) waitfor( x ) { - } or when( true ) timeout( 3 ) { - } or when( true ) else {} - - // test quasi-keywords "or" and "timeout" - - int or, timeout; - waitfor( timeout, 7 ) 3; - waitfor( timeout, 7 ) 3; or waitfor( timeout, 7 ) 3; - when( or ) waitfor( or, ) { 4; } or timeout( 1 ) 3; - when( 3 ) waitfor( or, 2 ) 4; or else 4; - when( 3 ) waitfor( or, 3 ) 4; or when( or ) timeout( or ) 4; or when( or ) else timeout; - when( 3 ) waitfor( or, or ) 3; or when( or ) waitfor( or, timeout ) 4; or else 4; - when( 3 ) waitfor( or, or ) 3; or waitfor( or, 9 ) 4; or when( or ) timeout( timeout ) 4; - when( 3 ) waitfor( or, 3 ) 3; or waitfor( or, 7 ) or; or timeout( 1 ) or; or when( 3 ) else or; - - // test else selection - - if ( or > timeout ) waitfor( or ) 3; - else waitfor( timeout ) 4; -} - -// Local Variables: // -// tab-width: 4 // -// compile-command: "cfa waitfor.c" // -// End: //