Index: doc/theses/colby_parsons_MMAth/benchmarks/actors/cfa/balance.cfa =================================================================== --- doc/theses/colby_parsons_MMAth/benchmarks/actors/cfa/balance.cfa (revision cec2551f696bdb182deb718cf71e465327e0e4ca) +++ doc/theses/colby_parsons_MMAth/benchmarks/actors/cfa/balance.cfa (revision cec2551f696bdb182deb718cf71e465327e0e4ca) @@ -0,0 +1,185 @@ +#include +#include +#include +#include +#include +#include "bench.hfa" + +// int Actors = 40000, Set = 100, Rounds = 100, Processors = 1, Batch = 1, BufSize = 10; // default values +int ActorsPerQueue = 32, Set = 32, Rounds = 100, Processors = 1, Batch = 100, BufSize = 10; // other defaults for test to run in reasonable time + +struct filler { + inline actor; +}; +void ?{}( filler & this ) with(this) { ((actor &)this){}; } + +static int ids = 0; +struct d_actor { + inline actor; + int gstart, id, rounds, recs, sends; +}; +void ?{}( d_actor & this, int idx ) with(this) { + ((actor &)this){}; + id = idx; + gstart = id / Set * Set; // remember group-start index + rounds = Set * Rounds; // send at least one message to each group member + recs = 0; + sends = 0; +} +struct d_msg { inline message; } shared_msg; +struct start_msg { inline message; } start_send; + +d_actor ** actor_arr; +Allocation receive( d_actor & this, start_msg & msg ) with( this ) { + for ( i; Set ) { + *actor_arr[i + gstart] << shared_msg; + } + return Nodelete; +} + +Allocation receive( d_actor & this, d_msg & msg ) with( this ) { + if ( recs == rounds ) return Delete; + if ( recs % Batch == 0 ) { + for ( i; Batch ) { + *actor_arr[gstart + sends % Set] << shared_msg; + sends += 1; + } + } + recs += 1; + return Nodelete; +} + +Allocation receive( filler & this, d_msg & msg ) { return Delete; } + +int main( int argc, char * argv[] ) { + switch ( argc ) { + case 7: + if ( strcmp( argv[6], "d" ) != 0 ) { // default ? + BufSize = atoi( argv[6] ); + if ( BufSize < 0 ) goto Usage; + } // if + case 6: + if ( strcmp( argv[5], "d" ) != 0 ) { // default ? + Batch = atoi( argv[5] ); + if ( Batch < 1 ) goto Usage; + } // if + case 5: + if ( strcmp( argv[4], "d" ) != 0 ) { // default ? + Processors = atoi( argv[4] ); + if ( Processors < 1 ) goto Usage; + } // if + case 4: + if ( strcmp( argv[3], "d" ) != 0 ) { // default ? + Rounds = atoi( argv[3] ); + if ( Rounds < 1 ) goto Usage; + } // if + case 3: + if ( strcmp( argv[2], "d" ) != 0 ) { // default ? + Set = atoi( argv[2] ); + if ( Set < 1 ) goto Usage; + } // if + case 2: + if ( strcmp( argv[1], "d" ) != 0 ) { // default ? + ActorsPerQueue = atoi( argv[1] ); + if ( ActorsPerQueue < 1 ) goto Usage; + } // if + case 1: // use defaults + break; + default: + Usage: + sout | "Usage: " | argv[0] + | " [ ActorsPerQueue (> 0) | 'd' (default " | ActorsPerQueue + | ") ] [ set (> 0) | 'd' (default " | Set + | ") ] [ rounds (> 0) | 'd' (default " | Rounds + | ") ] [ processors (> 0) | 'd' (default " | Processors + | ") ] [ batch (> 0) | 'd' (default " | Batch + | ") ] [ buffer size (>= 0) | 'd' (default " | BufSize + | ") ]" ; + exit( EXIT_FAILURE ); + } // switch + + //C_TODO: make this an arg + unsigned int qpw = 512; // queues per worker + + executor e{ Processors, Processors, Processors == 1 ? 1 : Processors * qpw, true }; + + // printf("starting\n"); + + start_actor_system( e ); + + // printf("started\n"); + + #ifndef MULTI + int Actors = ActorsPerQueue * qpw; + int FillActors = ActorsPerQueue * qpw * (Processors - 1); + #else + int extra = Processors % 2; + int ActorProcs = (Processors / 2 + extra); + int Actors = ActorsPerQueue * qpw * ActorProcs; + int FillActors = ActorsPerQueue * qpw * (Processors/2); + #endif + int fill_offset = (Processors - 1) * qpw; + + int AllocFill = FillActors; + if ( FillActors == 0 ) AllocFill = 1; + + d_actor ** actors; // array needs to be on the heap since it can be very large + actors = aalloc( Actors ); + + actor_arr = actors; + + filler ** filler_actors; // array needs to be on the heap since it can be very large + filler_actors = aalloc( AllocFill ); + + int actor_count = 0; + int fill_count = 0; + + int idx; + for ( i; ActorsPerQueue ) { + for ( j; Processors ) { + for ( k; qpw ) { + #ifndef MULTI + if ( j == 0 ) + #else + if ( j % 2 == 0 ) + #endif + { + #ifndef MULTI + idx = k * ActorsPerQueue + i; + #else + idx = (j / 2) * qpw * ActorsPerQueue + k * ActorsPerQueue + i; // set all on one queue + #endif + (*(actors[ idx ] = alloc())){ idx }; + } else { + (*(filler_actors[ fill_count ] = alloc())){}; + fill_count++; + } + } + } + } + + uint64_t start_time = bench_time(); + + #ifndef MULTI + for ( i; qpw ) + *actors[i * ActorsPerQueue] << start_send; + #else + for ( i; qpw * ActorProcs ) { + *actors[i * ActorsPerQueue] << start_send; + } + #endif + + for ( i; FillActors ) + *filler_actors[i] << shared_msg; + + stop_actor_system(); + + uint64_t end_time = bench_time(); + + printf("%.2f\n", ((double)(end_time - start_time))*((double)1e-9) ); + + adelete( filler_actors ); + adelete( actors ); + + return 0; +} Index: doc/theses/colby_parsons_MMAth/benchmarks/actors/cfa/dynamic.cfa =================================================================== --- doc/theses/colby_parsons_MMAth/benchmarks/actors/cfa/dynamic.cfa (revision cec2551f696bdb182deb718cf71e465327e0e4ca) +++ doc/theses/colby_parsons_MMAth/benchmarks/actors/cfa/dynamic.cfa (revision cec2551f696bdb182deb718cf71e465327e0e4ca) @@ -0,0 +1,83 @@ +#include +#include +#include +#include +#include +#include "bench.hfa" + +int Times = 1000000; // default values + +struct derived_actor { + inline actor; +}; + +struct derived_msg { + inline message; + int cnt; +}; + +static inline void ?{}( derived_msg & this, int cnt ) { + ((message &) this){ Delete }; + this.cnt = cnt; +} +static inline void ?{}( derived_msg & this ) { this{ 0 }; } + +uint64_t start_time; +Allocation receive( derived_actor & receiver, derived_msg & msg ) { + if ( msg.cnt >= Times ) { + printf("%.2f\n", ((double)(bench_time() - start_time)) / ((double)Times) ); // ns + return Delete; + } + derived_msg * d_msg = malloc(); + (*d_msg){ msg.cnt + 1 }; + derived_actor * d_actor = malloc(); + (*d_actor){}; + *d_actor << *d_msg; + return Delete; +} + +int main( int argc, char * argv[] ) { + switch ( argc ) { + case 2: + if ( strcmp( argv[1], "d" ) != 0 ) { // default ? + Times = atoi( argv[1] ); + if ( Times < 1 ) goto Usage; + } // if + case 1: // use defaults + break; + default: + Usage: + sout | "Usage: " | argv[0] | " [ times (> 0) ]"; + exit( EXIT_FAILURE ); + } // switch + + // printf("starting\n"); + + executor e{ 0, 1, 1, false, 1 }; + + start_actor_system( e ); + + start_time = bench_time(); + + // printf("started\n"); + + derived_msg * d_msg = malloc(); + (*d_msg){}; + derived_actor * d_actor = malloc(); + (*d_actor){}; + *d_actor << *d_msg; + + // printf("stopping\n"); + + stop_actor_system(); + + // uint64_t end_time = bench_time(); + + // printf("%.2f\n", ((double)(end_time - start_time))*((double)1e-9) ); // s + + // printf("%.2f\n", ((double)(end_time - start_time)) / ((double)Times) ); // ns + + // printf("stopped\n"); + + return 0; +} Index: doc/theses/colby_parsons_MMAth/benchmarks/actors/cfa/executor.cfa =================================================================== --- doc/theses/colby_parsons_MMAth/benchmarks/actors/cfa/executor.cfa (revision cec2551f696bdb182deb718cf71e465327e0e4ca) +++ doc/theses/colby_parsons_MMAth/benchmarks/actors/cfa/executor.cfa (revision cec2551f696bdb182deb718cf71e465327e0e4ca) @@ -0,0 +1,113 @@ +#include +#include +#include +#include +#include +#include "bench.hfa" + +// int Actors = 40000, Set = 100, Rounds = 100, Processors = 1, Batch = 1, BufSize = 10; // default values +int Actors = 1000, Set = 20, Rounds = 10, Processors = 1, Batch = 1, BufSize = 10; // other defaults for test to run in reasonable time + +static int ids = 0; +struct d_actor { + inline actor; + d_actor * gstart; + int id, rounds, recs, sends; +}; +void ?{}( d_actor & this ) with(this) { + ((actor &)this){}; + id = ids++; + gstart = (&this + (id / Set * Set - id)); // remember group-start array-element + rounds = Set * Rounds; // send at least one message to each group member + recs = 0; + sends = 0; +} +struct d_msg { inline message; } shared_msg; + +Allocation receive( d_actor & this, d_msg & msg ) with( this ) { + if ( recs == rounds ) return Finished; + if ( recs % Batch == 0 ) { + for ( i; Batch ) { + gstart[sends % Set] << shared_msg; + sends += 1; + } + } + recs += 1; + return Nodelete; +} + +int main( int argc, char * argv[] ) { + switch ( argc ) { + case 7: + if ( strcmp( argv[6], "d" ) != 0 ) { // default ? + BufSize = atoi( argv[6] ); + if ( BufSize < 0 ) goto Usage; + } // if + case 6: + if ( strcmp( argv[5], "d" ) != 0 ) { // default ? + Batch = atoi( argv[5] ); + if ( Batch < 1 ) goto Usage; + } // if + case 5: + if ( strcmp( argv[4], "d" ) != 0 ) { // default ? + Processors = atoi( argv[4] ); + if ( Processors < 1 ) goto Usage; + } // if + case 4: + if ( strcmp( argv[3], "d" ) != 0 ) { // default ? + Rounds = atoi( argv[3] ); + if ( Rounds < 1 ) goto Usage; + } // if + case 3: + if ( strcmp( argv[2], "d" ) != 0 ) { // default ? + Set = atoi( argv[2] ); + if ( Set < 1 ) goto Usage; + } // if + case 2: + if ( strcmp( argv[1], "d" ) != 0 ) { // default ? + Actors = atoi( argv[1] ); + if ( Actors < 1 || Actors <= Set || Actors % Set != 0 ) goto Usage; + } // if + case 1: // use defaults + break; + default: + Usage: + sout | "Usage: " | argv[0] + | " [ actors (> 0 && > set && actors % set == 0 ) | 'd' (default " | Actors + | ") ] [ set (> 0) | 'd' (default " | Set + | ") ] [ rounds (> 0) | 'd' (default " | Rounds + | ") ] [ processors (> 0) | 'd' (default " | Processors + | ") ] [ batch (> 0) | 'd' (default " | Batch + | ") ] [ buffer size (>= 0) | 'd' (default " | BufSize + | ") ]" ; + exit( EXIT_FAILURE ); + } // switch + + + executor e{ Processors, Processors, Processors == 1 ? 1 : Processors * 512, true, BufSize }; + + // printf("starting\n"); + uint64_t start_time = bench_time(); + + start_actor_system( e ); + + // printf("started\n"); + + d_actor actors[ Actors ]; + + for ( i; Actors ) { + actors[i] << shared_msg; + } // for + + // printf("stopping\n"); + + stop_actor_system(); + + uint64_t end_time = bench_time(); + + printf("%.2f\n", ((double)(end_time - start_time))*((double)1e-9) ); + + // printf("stopped\n"); + + return 0; +} Index: doc/theses/colby_parsons_MMAth/benchmarks/actors/cfa/matrix.cfa =================================================================== --- doc/theses/colby_parsons_MMAth/benchmarks/actors/cfa/matrix.cfa (revision cec2551f696bdb182deb718cf71e465327e0e4ca) +++ doc/theses/colby_parsons_MMAth/benchmarks/actors/cfa/matrix.cfa (revision cec2551f696bdb182deb718cf71e465327e0e4ca) @@ -0,0 +1,131 @@ +#include +#include +#include +#include +#include +#include "bench.hfa" + +unsigned int xr = 500, xc = 500, yc = 500, Processors = 1; // default values + +struct derived_actor { inline actor; }; +struct derived_msg { + inline message; + int * Z; + int * X; + int ** Y; +}; + +void ?{}( derived_msg & this ) {} +void ?{}( derived_msg & this, int * Z, int * X, int ** Y ) { + ((message &) this){ Nodelete }; + this.Z = Z; + this.X = X; + this.Y = Y; +} + +Allocation receive( derived_actor & receiver, derived_msg & msg ) { + for ( unsigned int i = 0; i < yc; i += 1 ) { // multiply X_row by Y_col and sum products + msg.Z[i] = 0; + for ( unsigned int j = 0; j < xc; j += 1 ) { + msg.Z[i] += msg.X[j] * msg.Y[j][i]; + } // for + } // for + return Finished; +} + +int main( int argc, char * argv[] ) { + switch ( argc ) { + case 5: + if ( strcmp( argv[4], "d" ) != 0 ) { // default ? + Processors = atoi( argv[4] ); + if ( Processors < 1 ) goto Usage; + } // if + case 4: + if ( strcmp( argv[3], "d" ) != 0 ) { // default ? + xr = atoi( argv[3] ); + if ( xr < 1 ) goto Usage; + } // if + case 3: + if ( strcmp( argv[2], "d" ) != 0 ) { // default ? + xc = atoi( argv[2] ); + if ( xc < 1 ) goto Usage; + } // if + case 2: + if ( strcmp( argv[1], "d" ) != 0 ) { // default ? + yc = atoi( argv[1] ); + if ( yc < 1 ) goto Usage; + } // if + case 1: // use defaults + break; + default: + Usage: + sout | "Usage: " | argv[0] + | " [ yc (> 0) | 'd' (default " | yc + | ") ] [ xc (> 0) | 'd' (default " | xc + | ") ] [ xr (> 0) | 'd' (default " | xr + | ") ] [ processors (> 0) | 'd' (default " | Processors + | ") ]" ; + exit( EXIT_FAILURE ); + } // switch + + unsigned int r, c; + int * Z[xr], * X[xr], * Y[xc]; + + for ( r = 0; r < xr; r += 1 ) { // create/initialize X matrix + X[r] = aalloc( xc ); + for ( c = 0; c < xc; c += 1 ) { + X[r][c] = r * c % 37; // for timing + } // for + } // for + for ( r = 0; r < xc; r += 1 ) { // create/initialize Y matrix + Y[r] = aalloc( yc ); + for ( c = 0; c < yc; c += 1 ) { + Y[r][c] = r * c % 37; // for timing + } // for + } // for + for ( r = 0; r < xr; r += 1 ) { // create Z matrix + Z[r] = aalloc( yc ); + } // for + + executor e{ Processors, Processors, Processors == 1 ? 1 : Processors * 32, true }; + + // printf("starting\n"); + + uint64_t start_time = bench_time(); + + start_actor_system( e ); + + // printf("started\n"); + + derived_msg messages[xr]; + + derived_actor actors[xr]; + + for ( unsigned int r = 0; r < xr; r += 1 ) { + messages[r]{ Z[r], X[r], Y }; + } // for + + for ( unsigned int r = 0; r < xr; r += 1 ) { + actors[r] << messages[r]; + } // for + + // printf("stopping\n"); + + stop_actor_system(); + + uint64_t end_time = bench_time(); + + printf("%.2f\n", ((double)(end_time - start_time))*((double)1e-9) ); + + // printf("stopped\n"); + + for ( r = 0; r < xr; r += 1 ) { // deallocate X and Z matrices + free( X[r] ); + free( Z[r] ); + } // for + for ( r = 0; r < xc; r += 1 ) { // deallocate Y matrix + free( Y[r] ); + } // for + + return 0; +} Index: doc/theses/colby_parsons_MMAth/benchmarks/actors/cfa/repeat.cfa =================================================================== --- doc/theses/colby_parsons_MMAth/benchmarks/actors/cfa/repeat.cfa (revision cec2551f696bdb182deb718cf71e465327e0e4ca) +++ doc/theses/colby_parsons_MMAth/benchmarks/actors/cfa/repeat.cfa (revision cec2551f696bdb182deb718cf71e465327e0e4ca) @@ -0,0 +1,135 @@ +#include +#include +#include +#include +#include +#include "bench.hfa" + +size_t Messages = 100000, Processors = 4, QScale = 256, Times = 100; + +struct Server { inline actor; }; +struct IntMsg { + inline message; + int val; +}; +struct CharMsg { + inline message; + char val; +}; +struct StateMsg { inline message; } stateMsg; + +struct Client { + inline actor; + Server * servers; + IntMsg * intmsg; + CharMsg * charmsg; + size_t results, times; +}; +void ?{}( Client & this ) with(this) { + ((actor &)this){}; + results = 0; + times = 0; + servers = aalloc( Messages ); + intmsg = aalloc( Messages ); + charmsg = aalloc( Messages ); + for ( i; Messages ) { + servers[i]{}; + intmsg[i]{}; + charmsg[i]{}; + } +} +void ^?{}( Client & this ) with(this) { + adelete( servers ); + adelete( intmsg ); + adelete( charmsg ); +} + +Client * cl; +Allocation receive( Server & this, IntMsg & msg ) { msg.val = 7; *cl << msg; return Nodelete; } +Allocation receive( Server & this, CharMsg & msg ) { msg.val = 'x'; *cl << msg; return Nodelete; } +Allocation receive( Server & this, StateMsg & msg ) { return Finished; } + +void terminateServers( Client & this ) with(this) { + for ( i; Messages ) { + servers[i] << stateMsg; + } // for +} + +Allocation reset( Client & this ) with(this) { + times += 1; + if ( times == Times ) { terminateServers( this ); return Finished; } + results = 0; + this << stateMsg; + return Nodelete; +} + +Allocation process( Client & this ) with(this) { + this.results++; + if ( results == 2 * Messages ) { return reset( this ); } + return Nodelete; +} + +Allocation receive( Client & this, IntMsg & msg ) { return process( this ); } +Allocation receive( Client & this, CharMsg & msg ) { return process( this ); } +Allocation receive( Client & this, StateMsg & msg ) with(this) { + for ( i; Messages ) { + servers[i] << intmsg[i]; + servers[i] << charmsg[i]; + } + return Nodelete; +} + +int main( int argc, char * argv[] ) { + switch ( argc ) { + case 5: + if ( strcmp( argv[4], "d" ) != 0 ) { // default ? + QScale = atoi( argv[4] ); + if ( QScale < 1 ) goto Usage; + } // if + case 4: + if ( strcmp( argv[3], "d" ) != 0 ) { // default ? + Times = atoi( argv[3] ); + if ( Times < 1 ) goto Usage; + } // if + case 3: + if ( strcmp( argv[2], "d" ) != 0 ) { // default ? + Processors = atoi( argv[2] ); + if ( Processors < 1 ) goto Usage; + } // if + case 2: + if ( strcmp( argv[1], "d" ) != 0 ) { // default ? + Messages = atoi( argv[1] ); + if ( Messages < 1 ) goto Usage; + } // if + case 1: // use defaults + break; + default: + Usage: + sout | "Usage: " | argv[0] + | ") ] [ messages (> 0) | 'd' (default " | Messages + | ") ] [ processors (> 0) | 'd' (default " | Processors + | ") ] [ Times (> 0) | 'd' (default " | Times + | ") ] [ qscale (> 0) | 'd' (default " | QScale + | ") ]" ; + exit( EXIT_FAILURE ); + } // switch + + + executor e{ Processors, Processors, Processors == 1 ? 1 : Processors * QScale, true, 1 }; + + uint64_t start_time = bench_time(); + + start_actor_system( e ); + + Client client; + cl = &client; + client << stateMsg; + + stop_actor_system(); + + uint64_t end_time = bench_time(); + + printf("%.2f\n", ((double)(end_time - start_time))*((double)1e-9) ); + + return 0; +} Index: doc/theses/colby_parsons_MMAth/benchmarks/actors/cfa/static.cfa =================================================================== --- doc/theses/colby_parsons_MMAth/benchmarks/actors/cfa/static.cfa (revision cec2551f696bdb182deb718cf71e465327e0e4ca) +++ doc/theses/colby_parsons_MMAth/benchmarks/actors/cfa/static.cfa (revision cec2551f696bdb182deb718cf71e465327e0e4ca) @@ -0,0 +1,77 @@ +#include +#include +#include +#include +#include +#include "bench.hfa" + +int Times = 1000000; // default values + +struct derived_actor { + inline actor; +}; + +struct derived_msg { + inline message; + int cnt; +}; + +static inline void ?{}( derived_msg & this, int cnt ) { + this.cnt = cnt; +} +static inline void ?{}( derived_msg & this ) { this{ 0 }; } + +uint64_t start_time; +Allocation receive( derived_actor & receiver, derived_msg & msg ) { + if ( msg.cnt >= Times ) { + printf("%.2f\n", ((double)(bench_time() - start_time)) / ((double)Times) ); // ns + return Finished; + } + msg.cnt++; + receiver << msg; + return Nodelete; +} + +int main( int argc, char * argv[] ) { + switch ( argc ) { + case 2: + if ( strcmp( argv[1], "d" ) != 0 ) { // default ? + Times = atoi( argv[1] ); + if ( Times < 1 ) goto Usage; + } // if + case 1: // use defaults + break; + default: + Usage: + sout | "Usage: " | argv[0] | " [ times (> 0) ]"; + exit( EXIT_FAILURE ); + } // switch + + // printf("starting\n"); + + executor e{ 0, 1, 1, false, 1 }; + + start_actor_system( e ); + + start_time = bench_time(); + + // printf("started\n"); + + derived_msg msg; + + derived_actor actor; + + actor << msg; + + // printf("stopping\n"); + + stop_actor_system(); + + // uint64_t end_time = bench_time(); + + // printf("%.2f\n", ((double)(end_time - start_time))*((double)1e-9) ); // s + + // printf("stopped\n"); + + return 0; +}