Changeset 7edf912 for tests/concurrency/actors
- Timestamp:
- Sep 17, 2023, 10:17:50 PM (10 months ago)
- Branches:
- master
- Children:
- a2c2363
- Parents:
- 50be8af
- Location:
- tests/concurrency/actors
- Files:
-
- 9 edited
Legend:
- Unmodified
- Added
- Removed
-
tests/concurrency/actors/dynamic.cfa
r50be8af r7edf912 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 ? … … 45 45 } // switch 46 46 47 47 sout | "starting"; 48 48 49 50 49 executor e{ 0, 1, 1, false }; 50 start_actor_system( e ); 51 51 52 52 sout | "started"; 53 53 54 55 56 57 58 54 derived_msg * d_msg = alloc(); 55 (*d_msg){}; 56 derived_actor * d_actor = alloc(); 57 (*d_actor){}; 58 *d_actor | *d_msg; 59 59 60 60 sout | "stopping"; 61 61 62 62 stop_actor_system(); 63 63 64 sout | "stopped"; 65 66 return 0; 64 sout | "stopped"; 67 65 } -
tests/concurrency/actors/executor.cfa
r50be8af r7edf912 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 ? … … 72 72 default: 73 73 exit | "Usage: " | argv[0] 74 74 | " [ actors (> 0 && > set && actors % set == 0 ) | 'd' (default " | Actors 75 75 | ") ] [ set (> 0) | 'd' (default " | Set 76 76 | ") ] [ rounds (> 0) | 'd' (default " | Rounds … … 81 81 } // switch 82 82 83 83 executor e{ Processors, Processors, Processors == 1 ? 1 : Processors * 512, true }; 84 84 85 85 sout | "starting"; 86 86 87 87 start_actor_system( e ); 88 88 89 89 sout | "started"; 90 90 91 91 d_actor actors[ Actors ]; 92 92 93 93 for ( i; Actors ) { … … 95 95 } // for 96 96 97 97 sout | "stopping"; 98 98 99 99 stop_actor_system(); 100 100 101 sout | "stopped"; 102 103 return 0; 101 sout | "stopped"; 104 102 } -
tests/concurrency/actors/inherit.cfa
r50be8af r7edf912 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
r50be8af r7edf912 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
r50be8af r7edf912 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 ? … … 67 67 } // switch 68 68 69 69 unsigned int r, c; 70 70 int * Z[xr], * X[xr], * Y[xc]; 71 71 … … 86 86 } // for 87 87 88 88 executor e{ Processors, Processors, Processors == 1 ? 1 : Processors * 16, true }; 89 89 90 90 sout | "starting"; 91 91 92 92 start_actor_system( e ); 93 93 94 94 sout | "started"; 95 95 96 96 derived_msg messages[xr]; 97 97 98 98 derived_actor actors[xr]; 99 99 100 100 for ( unsigned int r = 0; r < xr; r += 1 ) { … … 106 106 } // for 107 107 108 108 sout | "stopping"; 109 109 110 110 stop_actor_system(); 111 111 112 112 sout | "stopped"; 113 113 114 114 for ( r = 0; r < xr; r += 1 ) { // deallocate X and Z matrices 115 115 free( X[r] ); 116 116 free( Z[r] ); 117 117 } // for 118 118 for ( r = 0; r < xc; r += 1 ) { // deallocate Y matrix 119 119 free( Y[r] ); 120 120 } // for 121 121 } -
tests/concurrency/actors/pingpong.cfa
r50be8af r7edf912 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 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 sout | "end"; 58 sout | "end"; 59 59 } -
tests/concurrency/actors/poison.cfa
r50be8af r7edf912 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
r50be8af r7edf912 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 ? … … 42 42 } // switch 43 43 44 44 sout | "starting"; 45 45 46 47 46 executor e{ 0, 1, 1, false }; 47 start_actor_system( e ); 48 48 49 49 sout | "started"; 50 50 51 51 derived_msg msg; 52 52 53 53 derived_actor actor; 54 54 55 55 actor | msg; 56 56 57 57 sout | "stopping"; 58 58 59 59 stop_actor_system(); 60 60 61 sout | "stopped"; 62 63 return 0; 61 sout | "stopped"; 64 62 } -
tests/concurrency/actors/types.cfa
r50be8af r7edf912 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 64 sout | "start"; 65 65 66 66 processor p[Processors - 1]; 67 67 68 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 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 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 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 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 126 sout | "end"; 127 127 }
Note: See TracChangeset
for help on using the changeset viewer.