Changeset a2c2363 for tests/concurrency/actors
- Timestamp:
- Sep 18, 2023, 10:21:29 AM (10 months ago)
- Branches:
- master
- Children:
- e4c3819
- Parents:
- e3784a50 (diff), 7edf912 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the(diff)
links above to see all the changes relative to each parent. - Location:
- tests/concurrency/actors
- Files:
-
- 9 edited
Legend:
- Unmodified
- Added
- Removed
-
tests/concurrency/actors/dynamic.cfa
re3784a50 ra2c2363 9 9 struct derived_actor { inline actor; }; 10 10 struct derived_msg { 11 12 11 inline message; 12 int cnt; 13 13 }; 14 14 15 15 void ?{}( derived_msg & this, int cnt ) { 16 ((message &) this){ Delete };17 16 set_allocation( this, Delete ); 17 this.cnt = cnt; 18 18 } 19 19 void ?{}( derived_msg & this ) { ((derived_msg &)this){ 0 }; } 20 20 21 21 allocation receive( derived_actor & receiver, derived_msg & msg ) { 22 23 24 25 26 27 28 29 30 31 22 if ( msg.cnt >= Times ) { 23 sout | "Done"; 24 return Delete; 25 } 26 derived_msg * d_msg = alloc(); 27 (*d_msg){ msg.cnt + 1 }; 28 derived_actor * d_actor = alloc(); 29 (*d_actor){}; 30 *d_actor | *d_msg; 31 return Delete; 32 32 } 33 33 34 34 int main( int argc, char * argv[] ) { 35 35 switch ( argc ) { 36 36 case 2: 37 37 if ( strcmp( argv[1], "d" ) != 0 ) { // default ? 38 Times = ato i( argv[1] );39 if ( Times < 1 ) goto Usage;38 Times = ato( argv[1] ); 39 if ( Times < 1 ) fallthru default; 40 40 } // if 41 41 case 1: // use defaults 42 42 break; 43 43 default: 44 Usage: 45 sout | "Usage: " | argv[0] | " [ times (> 0) ]"; 46 exit( EXIT_FAILURE ); 44 exit | "Usage: " | argv[0] | " [ times (> 0) ]"; 47 45 } // switch 48 46 49 printf("starting\n");47 sout | "starting"; 50 48 51 52 49 executor e{ 0, 1, 1, false }; 50 start_actor_system( e ); 53 51 54 printf("started\n");52 sout | "started"; 55 53 56 57 58 59 60 54 derived_msg * d_msg = alloc(); 55 (*d_msg){}; 56 derived_actor * d_actor = alloc(); 57 (*d_actor){}; 58 *d_actor | *d_msg; 61 59 62 printf("stopping\n");60 sout | "stopping"; 63 61 64 62 stop_actor_system(); 65 63 66 printf("stopped\n"); 67 68 return 0; 64 sout | "stopped"; 69 65 } -
tests/concurrency/actors/executor.cfa
re3784a50 ra2c2363 10 10 static int ids = 0; 11 11 struct d_actor { 12 13 14 12 inline actor; 13 d_actor * gstart; 14 int id, rounds, recs, sends; 15 15 }; 16 16 void ?{}( d_actor & this ) with(this) { 17 18 19 20 21 17 id = ids++; 18 gstart = (&this + (id / Set * Set - id)); // remember group-start array-element 19 rounds = Set * Rounds; // send at least one message to each group member 20 recs = 0; 21 sends = 0; 22 22 } 23 23 … … 25 25 26 26 allocation receive( d_actor & this, d_msg & msg ) with( this ) { 27 28 29 30 31 32 33 34 35 27 if ( recs == rounds ) return Finished; 28 if ( recs % Batch == 0 ) { 29 for ( i; Batch ) { 30 gstart[sends % Set] | shared_msg; 31 sends += 1; 32 } 33 } 34 recs += 1; 35 return Nodelete; 36 36 } 37 37 38 38 int main( int argc, char * argv[] ) { 39 39 switch ( argc ) { 40 40 case 7: 41 41 if ( strcmp( argv[6], "d" ) != 0 ) { // default ? 42 BufSize = ato i( argv[6] );43 if ( BufSize < 0 ) goto Usage;42 BufSize = ato( argv[6] ); 43 if ( BufSize < 0 ) fallthru default; 44 44 } // if 45 45 case 6: 46 46 if ( strcmp( argv[5], "d" ) != 0 ) { // default ? 47 Batch = ato i( argv[5] );48 if ( Batch < 1 ) goto Usage;47 Batch = ato( argv[5] ); 48 if ( Batch < 1 ) fallthru default; 49 49 } // if 50 50 case 5: 51 51 if ( strcmp( argv[4], "d" ) != 0 ) { // default ? 52 Processors = ato i( argv[4] );53 if ( Processors < 1 ) goto Usage;52 Processors = ato( argv[4] ); 53 if ( Processors < 1 ) fallthru default; 54 54 } // if 55 55 case 4: 56 56 if ( strcmp( argv[3], "d" ) != 0 ) { // default ? 57 Rounds = ato i( argv[3] );58 if ( Rounds < 1 ) goto Usage;57 Rounds = ato( argv[3] ); 58 if ( Rounds < 1 ) fallthru default; 59 59 } // if 60 60 case 3: 61 61 if ( strcmp( argv[2], "d" ) != 0 ) { // default ? 62 Set = ato i( argv[2] );63 if ( Set < 1 ) goto Usage;62 Set = ato( argv[2] ); 63 if ( Set < 1 ) fallthru default; 64 64 } // if 65 65 case 2: 66 66 if ( strcmp( argv[1], "d" ) != 0 ) { // default ? 67 Actors = ato i( argv[1] );68 if ( Actors < 1 || Actors <= Set || Actors % Set != 0 ) goto Usage;67 Actors = ato( argv[1] ); 68 if ( Actors < 1 || Actors <= Set || Actors % Set != 0 ) fallthru default; 69 69 } // if 70 70 case 1: // use defaults 71 71 break; 72 72 default: 73 Usage: 74 sout | "Usage: " | argv[0] 75 | " [ actors (> 0 && > set && actors % set == 0 ) | 'd' (default " | Actors 73 exit | "Usage: " | argv[0] 74 | " [ actors (> 0 && > set && actors % set == 0 ) | 'd' (default " | Actors 76 75 | ") ] [ set (> 0) | 'd' (default " | Set 77 76 | ") ] [ rounds (> 0) | 'd' (default " | Rounds … … 80 79 | ") ] [ buffer size (>= 0) | 'd' (default " | BufSize 81 80 | ") ]" ; 82 exit( EXIT_FAILURE );83 81 } // switch 84 82 85 83 executor e{ Processors, Processors, Processors == 1 ? 1 : Processors * 512, true }; 86 84 87 printf("starting\n");85 sout | "starting"; 88 86 89 87 start_actor_system( e ); 90 88 91 printf("started\n");89 sout | "started"; 92 90 93 91 d_actor actors[ Actors ]; 94 92 95 93 for ( i; Actors ) { … … 97 95 } // for 98 96 99 printf("stopping\n");97 sout | "stopping"; 100 98 101 99 stop_actor_system(); 102 100 103 printf("stopped\n"); 104 105 return 0; 101 sout | "stopped"; 106 102 } -
tests/concurrency/actors/inherit.cfa
re3784a50 ra2c2363 18 18 19 19 allocation handle() { 20 20 return Finished; 21 21 } 22 22 … … 27 27 28 28 int main() { 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 29 sout | "Start"; 30 { 31 start_actor_system(); 32 D_msg * dm = alloc(); 33 (*dm){}; 34 D_msg2 * dm2 = alloc(); 35 (*dm2){}; 36 Server2 * s = alloc(); 37 (*s){}; 38 Server2 * s2 = alloc(); 39 (*s2){}; 40 *s | *dm; 41 *s2 | *dm2; 42 stop_actor_system(); 43 } 44 { 45 start_actor_system(); 46 Server s[2]; 47 D_msg * dm = alloc(); 48 (*dm){}; 49 D_msg2 * dm2 = alloc(); 50 (*dm2){}; 51 s[0] | *dm; 52 s[1] | *dm2; 53 stop_actor_system(); 54 } 55 sout | "Finished"; 56 56 } -
tests/concurrency/actors/inline.cfa
re3784a50 ra2c2363 3 3 4 4 struct d_actor { 5 5 inline actor; 6 6 }; 7 7 struct msg_wrapper { 8 9 8 int b; 9 inline message; 10 10 }; 11 11 void ^?{}( msg_wrapper & this ) { sout | "msg_wrapper dtor"; } 12 12 13 13 struct d_msg { 14 15 14 int m; 15 inline msg_wrapper; 16 16 }; 17 17 void ?{}( d_msg & this, int m, int b ) { this.m = m; this.b = b; set_allocation( this, Delete ); } … … 19 19 20 20 allocation receive( d_actor &, d_msg & msg ) { 21 22 23 21 sout | msg.m; 22 sout | msg.b; 23 return Finished; 24 24 } 25 25 26 26 struct d_msg2 { 27 28 27 int m; 28 inline msg_wrapper; 29 29 }; 30 30 void ^?{}( d_msg2 & this ) { sout | "d_msg2 dtor";} 31 31 32 32 allocation receive( d_actor &, d_msg2 & msg ) { 33 34 33 sout | msg.m; 34 return Finished; 35 35 } 36 36 37 37 int main() { 38 39 40 start_actor_system();// sets up executor41 42 43 44 45 stop_actor_system();// waits until actors finish46 47 48 start_actor_system();// sets up executor49 50 51 52 53 54 55 56 stop_actor_system();// waits until actors finish57 38 processor p; 39 { 40 start_actor_system(); // sets up executor 41 d_actor da; 42 d_msg * dm = alloc(); 43 (*dm){ 42, 2423 }; 44 da | *dm; 45 stop_actor_system(); // waits until actors finish 46 } 47 { 48 start_actor_system(); // sets up executor 49 d_actor da; 50 d_msg2 dm{ 29079 }; 51 set_allocation( dm, Nodelete ); 52 msg_wrapper * mw = &dm; 53 message * mg = &dm; 54 virtual_dtor * v = &dm; 55 da | dm; 56 stop_actor_system(); // waits until actors finish 57 } 58 58 } -
tests/concurrency/actors/matrix.cfa
re3784a50 ra2c2363 5 5 #include <stdio.h> 6 6 7 unsigned int xr = 500, xc = 500, yc = 500, Processors = 1; // default values 7 int xr = 500, xc = 500, yc = 500, Processors = 1; // default values, must be signed 8 8 9 9 struct derived_actor { inline actor; }; 10 10 11 11 struct derived_msg { 12 13 12 inline message; 13 int * Z; 14 14 int * X; 15 15 int ** Y; 16 16 }; 17 17 18 18 void ?{}( derived_msg & this ) {} 19 19 void ?{}( derived_msg & this, int * Z, int * X, int ** Y ) { 20 ((message &) this){ Nodelete };21 22 23 20 set_allocation( this, Nodelete ); 21 this.Z = Z; 22 this.X = X; 23 this.Y = Y; 24 24 } 25 25 26 26 allocation receive( derived_actor & receiver, derived_msg & msg ) { 27 28 29 30 31 32 33 27 for ( unsigned int i = 0; i < yc; i += 1 ) { // multiply X_row by Y_col and sum products 28 msg.Z[i] = 0; 29 for ( unsigned int j = 0; j < xc; j += 1 ) { 30 msg.Z[i] += msg.X[j] * msg.Y[j][i]; 31 } // for 32 } // for 33 return Finished; 34 34 } 35 35 36 36 int main( int argc, char * argv[] ) { 37 37 switch ( argc ) { 38 38 case 5: 39 39 if ( strcmp( argv[4], "d" ) != 0 ) { // default ? 40 Processors = ato i( argv[4] );41 if ( Processors < 1 ) goto Usage;40 Processors = ato( argv[4] ); 41 if ( Processors < 1 ) fallthru default; 42 42 } // if 43 43 case 4: 44 44 if ( strcmp( argv[3], "d" ) != 0 ) { // default ? 45 xr = ato i( argv[3] );46 if ( xr < 1 ) goto Usage;45 xr = ato( argv[3] ); 46 if ( xr < 1 ) fallthru default; 47 47 } // if 48 48 case 3: 49 49 if ( strcmp( argv[2], "d" ) != 0 ) { // default ? 50 xc = ato i( argv[2] );51 if ( xc < 1 ) goto Usage;50 xc = ato( argv[2] ); 51 if ( xc < 1 ) fallthru default; 52 52 } // if 53 53 case 2: 54 54 if ( strcmp( argv[1], "d" ) != 0 ) { // default ? 55 yc = ato i( argv[1] );56 if ( yc < 1 ) goto Usage;55 yc = ato( argv[1] ); 56 if ( yc < 1 ) fallthru default; 57 57 } // if 58 58 case 1: // use defaults 59 59 break; 60 60 default: 61 Usage: 62 sout | "Usage: " | argv[0] 61 exit | "Usage: " | argv[0] 63 62 | " [ yc (> 0) | 'd' (default " | yc 64 63 | ") ] [ xc (> 0) | 'd' (default " | xc … … 66 65 | ") ] [ processors (> 0) | 'd' (default " | Processors 67 66 | ") ]" ; 68 exit( EXIT_FAILURE );69 67 } // switch 70 68 71 69 unsigned int r, c; 72 70 int * Z[xr], * X[xr], * Y[xc]; 73 71 … … 88 86 } // for 89 87 90 88 executor e{ Processors, Processors, Processors == 1 ? 1 : Processors * 16, true }; 91 89 92 printf("starting\n");90 sout | "starting"; 93 91 94 92 start_actor_system( e ); 95 93 96 printf("started\n");94 sout | "started"; 97 95 98 96 derived_msg messages[xr]; 99 97 100 98 derived_actor actors[xr]; 101 99 102 100 for ( unsigned int r = 0; r < xr; r += 1 ) { … … 108 106 } // for 109 107 110 printf("stopping\n");108 sout | "stopping"; 111 109 112 110 stop_actor_system(); 113 111 114 printf("stopped\n");112 sout | "stopped"; 115 113 116 114 for ( r = 0; r < xr; r += 1 ) { // deallocate X and Z matrices 117 115 free( X[r] ); 118 116 free( Z[r] ); 119 117 } // for 120 118 for ( r = 0; r < xc; r += 1 ) { // deallocate Y matrix 121 119 free( Y[r] ); 122 120 } // for 123 124 return 0;125 121 } -
tests/concurrency/actors/pingpong.cfa
re3784a50 ra2c2363 10 10 11 11 struct p_msg { 12 13 12 inline message; 13 size_t count; 14 14 }; 15 static inline void ?{}( p_msg & this ) { ((message &)this){}; this.count = 0; } 15 //static inline void ?{}( p_msg & this ) { ((message &)this){}; this.count = 0; } 16 static inline void ?{}( p_msg & this ) { this.count = 0; } 16 17 17 18 ping * pi; … … 20 21 21 22 allocation receive( ping & receiver, p_msg & msg ) { 22 23 23 msg.count++; 24 if ( msg.count > times ) return Finished; 24 25 25 26 27 28 26 allocation retval = Nodelete; 27 if ( msg.count == times ) retval = Finished; 28 *po | msg; 29 return retval; 29 30 } 30 31 31 32 allocation receive( pong & receiver, p_msg & msg ) { 32 33 34 35 36 37 38 33 msg.count++; 34 if ( msg.count > times ) return Finished; 35 36 allocation retval = Nodelete; 37 if ( msg.count == times ) retval = Finished; 38 *pi | msg; 39 return retval; 39 40 } 40 41 … … 42 43 43 44 int main( int argc, char * argv[] ) { 44 printf("start\n");45 sout | "start"; 45 46 46 47 processor p[Processors - 1]; 47 48 48 start_actor_system( Processors ); // test passing number of processors 49 start_actor_system( Processors ); // test passing number of processors 50 ping pi_actor; 51 pong po_actor; 52 po = &po_actor; 53 pi = &pi_actor; 54 p_msg m; 55 pi_actor | m; 56 stop_actor_system(); 49 57 50 ping pi_actor; 51 pong po_actor; 52 po = &po_actor; 53 pi = &pi_actor; 54 p_msg m; 55 pi_actor | m; 56 stop_actor_system(); 57 58 printf("end\n"); 59 return 0; 58 sout | "end"; 60 59 } -
tests/concurrency/actors/poison.cfa
re3784a50 ra2c2363 11 11 12 12 int main() { 13 13 sout | "Start"; 14 14 15 16 17 18 19 20 21 22 23 15 sout | "Finished"; 16 { 17 start_actor_system(); 18 Server s[10]; 19 for ( i; 10 ) { 20 s[i] | finished_msg; 21 } 22 stop_actor_system(); 23 } 24 24 25 26 27 28 29 30 31 32 33 34 25 sout | "Delete"; 26 { 27 start_actor_system(); 28 for ( i; 10 ) { 29 Server * s = alloc(); 30 (*s){}; 31 (*s) | delete_msg; 32 } 33 stop_actor_system(); 34 } 35 35 36 37 38 39 40 41 42 43 44 45 46 36 sout | "Destroy"; 37 { 38 start_actor_system(); 39 Server s[10]; 40 for ( i; 10 ) 41 s[i] | destroy_msg; 42 stop_actor_system(); 43 for ( i; 10 ) 44 if (s[i].val != 777) 45 sout | "Error: dtor not called correctly."; 46 } 47 47 48 sout | "Done"; 49 return 0; 48 sout | "Done"; 50 49 } -
tests/concurrency/actors/static.cfa
re3784a50 ra2c2363 9 9 struct derived_actor { inline actor; }; 10 10 struct derived_msg { 11 12 11 inline message; 12 int cnt; 13 13 }; 14 14 15 15 void ?{}( derived_msg & this, int cnt ) { 16 ((message &) this){ Nodelete };17 16 set_allocation( this, Nodelete ); 17 this.cnt = cnt; 18 18 } 19 19 void ?{}( derived_msg & this ) { ((derived_msg &)this){ 0 }; } 20 20 21 21 allocation receive( derived_actor & receiver, derived_msg & msg ) { 22 23 24 25 26 27 28 22 if ( msg.cnt >= Times ) { 23 sout | "Done"; 24 return Finished; 25 } 26 msg.cnt++; 27 receiver | msg; 28 return Nodelete; 29 29 } 30 30 31 31 int main( int argc, char * argv[] ) { 32 32 switch ( argc ) { 33 33 case 2: 34 34 if ( strcmp( argv[1], "d" ) != 0 ) { // default ? 35 Times = ato i( argv[1] );36 if ( Times < 1 ) goto Usage;35 Times = ato( argv[1] ); 36 if ( Times < 1 ) fallthru default; 37 37 } // if 38 38 case 1: // use defaults 39 39 break; 40 40 default: 41 Usage: 42 sout | "Usage: " | argv[0] | " [ times (> 0) ]"; 43 exit( EXIT_FAILURE ); 41 exit | "Usage: " | argv[0] | " [ times (> 0) ]"; 44 42 } // switch 45 43 46 printf("starting\n");44 sout | "starting"; 47 45 48 49 46 executor e{ 0, 1, 1, false }; 47 start_actor_system( e ); 50 48 51 printf("started\n");49 sout | "started"; 52 50 53 51 derived_msg msg; 54 52 55 53 derived_actor actor; 56 54 57 55 actor | msg; 58 56 59 printf("stopping\n");57 sout | "stopping"; 60 58 61 59 stop_actor_system(); 62 60 63 printf("stopped\n"); 64 65 return 0; 61 sout | "stopped"; 66 62 } -
tests/concurrency/actors/types.cfa
re3784a50 ra2c2363 9 9 10 10 struct derived_actor { 11 12 11 inline actor; 12 int counter; 13 13 }; 14 14 static inline void ?{}( derived_actor & this ) { ((actor &)this){}; this.counter = 0; } 15 15 16 16 struct d_msg { 17 18 17 inline message; 18 int num; 19 19 }; 20 20 21 21 // this isn't a valid receive routine since int is not a message type 22 22 allocation receive( derived_actor & receiver, int i ) with( receiver ) { 23 24 25 26 23 mutex(sout) sout | i; 24 counter++; 25 if ( counter == 2 ) return Finished; 26 return Nodelete; 27 27 } 28 28 29 29 allocation receive( derived_actor & receiver, d_msg & msg ) { 30 30 return receive( receiver, msg.num ); 31 31 } 32 32 33 33 struct derived_actor2 { 34 35 34 struct nested { int i; }; // testing nested before inline 35 inline actor; 36 36 }; 37 37 38 38 allocation receive( derived_actor2 & receiver, d_msg & msg ) { 39 40 39 mutex(sout) sout | msg.num; 40 return Finished; 41 41 } 42 42 … … 44 44 struct derived_actor4 { inline derived_actor3; }; 45 45 struct d_msg2 { 46 47 46 inline message; 47 int num; 48 48 }; 49 49 50 50 allocation receive( derived_actor3 & receiver, d_msg & msg ) { 51 52 53 51 mutex(sout) sout | msg.num; 52 if ( msg.num == -1 ) return Nodelete; 53 return Finished; 54 54 } 55 55 56 56 allocation receive( derived_actor3 & receiver, d_msg2 & msg ) { 57 58 57 mutex(sout) sout | msg.num; 58 return Finished; 59 59 } 60 60 … … 62 62 63 63 int main( int argc, char * argv[] ) { 64 printf("start\n");64 sout | "start"; 65 65 66 66 processor p[Processors - 1]; 67 67 68 printf("basic test\n");69 70 71 72 73 74 75 68 sout | "basic test"; 69 start_actor_system( Processors ); // test passing number of processors 70 derived_actor a; 71 d_msg b, c; 72 b.num = 1; 73 c.num = 2; 74 a | b | c; 75 stop_actor_system(); 76 76 77 printf("same message and different actors test\n");78 79 80 81 82 83 84 77 sout | "same message and different actors test"; 78 start_actor_system(); // let system detect # of processors 79 derived_actor2 d_ac2_0, d_ac2_1; 80 d_msg d_ac2_msg; 81 d_ac2_msg.num = 3; 82 d_ac2_0 | d_ac2_msg; 83 d_ac2_1 | d_ac2_msg; 84 stop_actor_system(); 85 85 86 87 88 printf("same message and different actor types test\n");89 90 91 92 93 94 95 96 97 98 86 87 { 88 sout | "same message and different actor types test"; 89 executor e{ 0, Processors, Processors == 1 ? 1 : Processors * 4, false }; 90 start_actor_system( e ); // pass an explicit executor 91 derived_actor2 d_ac2_2; 92 derived_actor3 d_ac3_0; 93 d_msg d_ac23_msg; 94 d_ac23_msg.num = 4; 95 d_ac3_0 | d_ac23_msg; 96 d_ac2_2 | d_ac23_msg; 97 stop_actor_system(); 98 } // RAII to clean up executor 99 99 100 101 printf("different message types, one actor test\n");102 103 104 105 106 107 108 109 110 111 100 { 101 sout | "different message types, one actor test"; 102 executor e{ 1, Processors, Processors == 1 ? 1 : Processors * 4, true }; 103 start_actor_system( Processors ); 104 derived_actor3 a3; 105 d_msg b1; 106 d_msg2 c2; 107 b1.num = -1; 108 c2.num = 5; 109 a3 | b1 | c2; 110 stop_actor_system(); 111 } // RAII to clean up executor 112 112 113 114 printf("nested inheritance actor test\n");115 116 117 118 119 120 121 122 123 124 113 { 114 sout | "nested inheritance actor test"; 115 executor e{ 1, Processors, Processors == 1 ? 1 : Processors * 4, true }; 116 start_actor_system( Processors ); 117 derived_actor4 a4; 118 d_msg b1; 119 d_msg2 c2; 120 b1.num = -1; 121 c2.num = 5; 122 a4 | b1 | c2; 123 stop_actor_system(); 124 } // RAII to clean up executor 125 125 126 printf("end\n"); 127 return 0; 126 sout | "end"; 128 127 }
Note: See TracChangeset
for help on using the changeset viewer.