source: src/Concurrency/Actors.cpp@ 2125443a

ADT ast-experimental
Last change on this file since 2125443a was ccf1d99, checked in by caparsons <caparson@…>, 3 years ago

intermediate push so I can move to nasus to performance test some stuff
  • Property mode set to 100644
File size: 21.2 KB
Line 
1//
2// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
3//
4// The contents of this file are covered under the licence agreement in the
5// file "LICENCE" distributed with Cforall.
6//
7// Actors.cpp -- generate code needed by the actor system
8//
9// Author : Colby Parsons
10// Created On : Thurs Jan 19 15:34:00 2023
11// Last Modified By : Colby Parsons
12// Last Modified On : Thurs Jan 19 15:34:00 2023
13// Update Count : 0
14//
15
16#include "AST/Print.hpp"
17#include "AST/Decl.hpp"
18#include "AST/Pass.hpp"
19#include "AST/Type.hpp"
20#include "AST/Stmt.hpp"
21#include "AST/TranslationUnit.hpp"
22#include "AST/Expr.hpp"
23#include <algorithm>
24using namespace ast;
25using namespace std;
26
27namespace Concurrency {
28
29struct CollectactorStructDecls : public ast::WithGuards {
30 unordered_set<const StructDecl *> & actorStructDecls;
31 unordered_set<const StructDecl *> & messageStructDecls;
32 const StructDecl ** requestDecl;
33 const EnumDecl ** allocationDecl;
34 const StructDecl ** actorDecl;
35 const StructDecl ** msgDecl;
36 StructDecl * parentDecl;
37 bool insideStruct = false;
38 bool namedDecl = false;
39
40 // finds and sets a ptr to the Allocation enum, which is needed in the next pass
41 void previsit( const EnumDecl * decl ) {
42 if( decl->name == "Allocation" ) *allocationDecl = decl;
43 }
44
45 // finds and sets a ptr to the actor, message, and request structs, which are needed in the next pass
46 void previsit( const StructDecl * decl ) {
47 GuardValue(insideStruct);
48 insideStruct = true;
49 parentDecl = mutate( decl );
50 if( decl->name == "actor" ) *actorDecl = decl;
51 if( decl->name == "message" ) *msgDecl = decl;
52 if( decl->name == "request" ) *requestDecl = decl;
53 }
54
55 // this catches structs of the form:
56 // struct dummy_actor { actor a; };
57 // since they should be:
58 // struct dummy_actor { inline actor; };
59 void previsit ( const ObjectDecl * decl ) {
60 if ( insideStruct && ! decl->name.empty() ) {
61 GuardValue(namedDecl);
62 namedDecl = true;
63 }
64 }
65
66 // this collects the valid actor and message struct decl pts
67 void postvisit( const StructInstType * node ) {
68 if ( ! *actorDecl || ! *msgDecl ) return;
69 if ( insideStruct && !namedDecl ) {
70 if ( node->aggr() == *actorDecl ) {
71 actorStructDecls.insert( parentDecl );
72 } else if ( node->aggr() == *msgDecl ) {
73 messageStructDecls.insert( parentDecl );
74 }
75 }
76 }
77
78 public:
79 CollectactorStructDecls( unordered_set<const StructDecl *> & actorStructDecls, unordered_set<const StructDecl *> & messageStructDecls,
80 const StructDecl ** requestDecl, const EnumDecl ** allocationDecl, const StructDecl ** actorDecl, const StructDecl ** msgDecl )
81 : actorStructDecls( actorStructDecls ), messageStructDecls( messageStructDecls ), requestDecl( requestDecl ),
82 allocationDecl( allocationDecl ), actorDecl(actorDecl), msgDecl(msgDecl) {}
83};
84
85// keeps track of all fwdDecls of message routines so that we can hoist them to right after the appropriate decls
86class FwdDeclTable {
87
88 // tracks which decls we have seen so that we can hoist the FunctionDecl to the highest point possible
89 struct FwdDeclData {
90 const StructDecl * actorDecl;
91 const StructDecl * msgDecl;
92 FunctionDecl * fwdDecl;
93 bool actorFound;
94 bool msgFound;
95
96 bool readyToInsert() { return actorFound && msgFound; }
97 bool foundActor() { actorFound = true; return readyToInsert(); }
98 bool foundMsg() { msgFound = true; return readyToInsert(); }
99
100 FwdDeclData( const StructDecl * actorDecl, const StructDecl * msgDecl, FunctionDecl * fwdDecl ) :
101 actorDecl(actorDecl), msgDecl(msgDecl), fwdDecl(fwdDecl), actorFound(false), msgFound(false) {}
102 };
103
104 // map indexed by actor struct ptr
105 // value is map of all FwdDeclData that contains said actor struct ptr
106 // inner map is indexed by the message struct ptr of FwdDeclData
107 unordered_map<const StructDecl *, unordered_map<const StructDecl *, FwdDeclData *>> actorMap;
108
109 // this map is the same except the outer map is indexed by message ptr and the inner is indexed by actor ptr
110 unordered_map<const StructDecl *, unordered_map<const StructDecl *, FwdDeclData *>> msgMap;
111
112 void insert( const StructDecl * decl, const StructDecl * otherDecl, unordered_map<const StructDecl *, unordered_map<const StructDecl *, FwdDeclData *>> & map, FwdDeclData * data ) {
113 auto iter = map.find( decl );
114 if ( iter != map.end() ) { // if decl exists in map append data to existing inner map
115 iter->second.emplace( make_pair( otherDecl, data ) );
116 } else { // else create inner map for key
117 map.emplace( make_pair( decl, unordered_map<const StructDecl *, FwdDeclData *>( { make_pair( otherDecl, data ) } ) ) );
118 }
119 }
120
121 public:
122 // insert decl into table so that we can fwd declare it later (average cost: O(1))
123 void insertDecl( const StructDecl * actorDecl, const StructDecl * msgDecl, FunctionDecl * fwdDecl ) {
124 FwdDeclData * declToInsert = new FwdDeclData( actorDecl, msgDecl, fwdDecl );
125 insert( actorDecl, msgDecl, actorMap, declToInsert );
126 insert( msgDecl, actorDecl, msgMap, declToInsert );
127 }
128
129 // returns list of decls to insert after current struct decl
130 // Over the entire pass the runtime of this routine is O(r) where r is the # of receive routines
131 list<FunctionDecl *> updateDecl( const StructDecl * decl, bool isMsg ) {
132 unordered_map<const StructDecl *, unordered_map<const StructDecl *, FwdDeclData *>> & map = isMsg ? msgMap : actorMap;
133 unordered_map<const StructDecl *, unordered_map<const StructDecl *, FwdDeclData *>> & otherMap = isMsg ? actorMap : msgMap;
134 auto iter = map.find( decl );
135 list<FunctionDecl *> toInsertAfter; // this is populated with decls that are ready to insert
136 if ( iter == map.end() ) return toInsertAfter;
137
138 // iterate over inner map
139 unordered_map<const StructDecl *, FwdDeclData *> & currInnerMap = iter->second;
140 for ( auto innerIter = currInnerMap.begin(); innerIter != currInnerMap.end(); ) {
141 FwdDeclData * currentDatum = innerIter->second;
142 bool readyToInsert = isMsg ? currentDatum->foundMsg() : currentDatum->foundActor();
143 if ( ! readyToInsert ) { ++innerIter; continue; }
144
145 // readyToInsert is true so we are good to insert the forward decl of the message fn
146 toInsertAfter.push_back( currentDatum->fwdDecl );
147
148 // need to remove from other map before deleting
149 // find inner map in other map ( other map is actor map if original is msg map and vice versa )
150 const StructDecl * otherDecl = isMsg ? currentDatum->actorDecl : currentDatum->msgDecl;
151 auto otherMapIter = otherMap.find( otherDecl );
152
153 unordered_map<const StructDecl *, FwdDeclData *> & otherInnerMap = otherMapIter->second;
154
155 // find the FwdDeclData we need to remove in the other inner map
156 auto otherInnerIter = otherInnerMap.find( decl );
157
158 // remove references to deleted FwdDeclData from current inner map
159 innerIter = currInnerMap.erase( innerIter ); // this does the increment so no explicit inc needed
160
161 // remove references to deleted FwdDeclData from other inner map
162 otherInnerMap.erase( otherInnerIter );
163
164 // if other inner map is now empty, remove key from other outer map
165 if ( otherInnerMap.empty() )
166 otherMap.erase( otherDecl );
167
168 // now we are safe to delete the FwdDeclData since we are done with it
169 // and we have removed all references to it from our data structures
170 delete currentDatum;
171 }
172
173 // if current inner map is now empty, remove key from outer map.
174 // Have to do this after iterating for safety
175 if ( currInnerMap.empty() )
176 map.erase( decl );
177
178 return toInsertAfter;
179 }
180};
181
182#define __ALLOC 0 // C_TODO: complete swap to no-alloc version
183
184struct GenReceiveDecls : public ast::WithDeclsToAdd<> {
185 unordered_set<const StructDecl *> & actorStructDecls;
186 unordered_set<const StructDecl *> & messageStructDecls;
187 const StructDecl ** requestDecl;
188 const EnumDecl ** allocationDecl;
189 const StructDecl ** actorDecl;
190 const StructDecl ** msgDecl;
191 FwdDeclTable & forwardDecls;
192
193 void postvisit( const FunctionDecl * decl ) {
194 // return if not of the form receive( param1, param2 ) or if it is a forward decl
195 if ( decl->name != "receive" || decl->params.size() != 2 || !decl->stmts ) return;
196
197 // the params should be references
198 const ReferenceType * derivedActorRef = dynamic_cast<const ReferenceType *>(decl->params.at(0)->get_type());
199 const ReferenceType * derivedMsgRef = dynamic_cast<const ReferenceType *>(decl->params.at(1)->get_type());
200 if ( !derivedActorRef || !derivedMsgRef ) return;
201
202 // the references should be to struct instances
203 const StructInstType * arg1InstType = dynamic_cast<const StructInstType *>(derivedActorRef->base.get());
204 const StructInstType * arg2InstType = dynamic_cast<const StructInstType *>(derivedMsgRef->base.get());
205 if ( !arg1InstType || !arg2InstType ) return;
206
207 // If the struct instances are derived actor and message types then generate the message send routine
208 auto actorIter = actorStructDecls.find( arg1InstType->aggr() );
209 auto messageIter = messageStructDecls.find( arg2InstType->aggr() );
210 if ( actorIter != actorStructDecls.end() && messageIter != messageStructDecls.end() ) {
211
212 // check that we have found all the decls we need from <actor.hfa>
213 if ( !*allocationDecl || !*requestDecl )
214 SemanticError( decl->location, "using actors requires a header, add #include <actor.hfa>\n" );
215
216 //////////////////////////////////////////////////////////////////////
217 // The following generates this send message operator routine for all receive(derived_actor &, derived_msg &) functions
218 /*
219 static inline derived_actor & ?|?( derived_actor & receiver, derived_msg & msg ) {
220 request * new_req = alloc();
221 Allocation (*my_work_fn)( derived_actor &, derived_msg & ) = receive;
222 __receive_fn fn = (__receive_fn)my_work_fn;
223 (*new_req){ &receiver, &msg, fn };
224 send( receiver, *new_req );
225 return receiver;
226 }
227 */ // C_TODO: update this with new no alloc version
228 CompoundStmt * sendBody = new CompoundStmt( decl->location );
229
230 #if __ALLOC
231 // Generates: request * new_req = alloc();
232 sendBody->push_back( new DeclStmt(
233 decl->location,
234 new ObjectDecl(
235 decl->location,
236 "new_req",
237 new PointerType( new StructInstType( *requestDecl ) ),
238 new SingleInit( decl->location, new UntypedExpr( decl->location, new NameExpr( decl->location, "alloc" ), {} ) )
239 )
240 ));
241 #else
242 // Generates: request new_req;
243 sendBody->push_back( new DeclStmt(
244 decl->location,
245 new ObjectDecl(
246 decl->location,
247 "new_req",
248 new StructInstType( *requestDecl )
249 )
250 ));
251 #endif
252
253 // Function type is: Allocation (*)( derived_actor &, derived_msg & )
254 FunctionType * derivedReceive = new FunctionType();
255 derivedReceive->params.push_back( ast::deepCopy( derivedActorRef ) );
256 derivedReceive->params.push_back( ast::deepCopy( derivedMsgRef ) );
257 derivedReceive->returns.push_back( new EnumInstType( *allocationDecl ) );
258
259 // Generates: Allocation (*my_work_fn)( derived_actor &, derived_msg & ) = receive;
260 sendBody->push_back( new DeclStmt(
261 decl->location,
262 new ObjectDecl(
263 decl->location,
264 "my_work_fn",
265 new PointerType( derivedReceive ),
266 new SingleInit( decl->location, new NameExpr( decl->location, "receive" ) )
267 )
268 ));
269
270 // Function type is: Allocation (*)( actor &, messsage & )
271 FunctionType * genericReceive = new FunctionType();
272 genericReceive->params.push_back( new ReferenceType( new StructInstType( *actorDecl ) ) );
273 genericReceive->params.push_back( new ReferenceType( new StructInstType( *msgDecl ) ) );
274 genericReceive->returns.push_back( new EnumInstType( *allocationDecl ) );
275
276 // Generates: Allocation (*fn)( actor &, messsage & ) = (Allocation (*)( actor &, messsage & ))my_work_fn;
277 // More readable synonymous code:
278 // typedef Allocation (*__receive_fn)(actor &, message &);
279 // __receive_fn fn = (__receive_fn)my_work_fn;
280 sendBody->push_back( new DeclStmt(
281 decl->location,
282 new ObjectDecl(
283 decl->location,
284 "fn",
285 new PointerType( genericReceive ),
286 new SingleInit( decl->location,
287 new CastExpr( decl->location, new NameExpr( decl->location, "my_work_fn" ), new PointerType( genericReceive ), ExplicitCast )
288 )
289 )
290 ));
291
292 #if __ALLOC
293 // Generates: (*new_req){ &receiver, &msg, fn };
294 sendBody->push_back( new ExprStmt(
295 decl->location,
296 new UntypedExpr (
297 decl->location,
298 new NameExpr( decl->location, "?{}" ),
299 {
300 new UntypedExpr( decl->location, new NameExpr( decl->location, "*?" ), { new NameExpr( decl->location, "new_req" ) } ),
301 new AddressExpr( new NameExpr( decl->location, "receiver" ) ),
302 new AddressExpr( new NameExpr( decl->location, "msg" ) ),
303 new NameExpr( decl->location, "fn" )
304 }
305 )
306 ));
307
308 // Generates: send( receiver, *new_req );
309 sendBody->push_back( new ExprStmt(
310 decl->location,
311 new UntypedExpr (
312 decl->location,
313 new NameExpr( decl->location, "send" ),
314 {
315 {
316 new NameExpr( decl->location, "receiver" ),
317 new UntypedExpr( decl->location, new NameExpr( decl->location, "*?" ), { new NameExpr( decl->location, "new_req" ) } )
318 }
319 }
320 )
321 ));
322 #else
323 // Generates: new_req{ &receiver, &msg, fn };
324 sendBody->push_back( new ExprStmt(
325 decl->location,
326 new UntypedExpr (
327 decl->location,
328 new NameExpr( decl->location, "?{}" ),
329 {
330 new NameExpr( decl->location, "new_req" ),
331 new AddressExpr( new NameExpr( decl->location, "receiver" ) ),
332 new AddressExpr( new NameExpr( decl->location, "msg" ) ),
333 new NameExpr( decl->location, "fn" )
334 }
335 )
336 ));
337
338 // Generates: send( receiver, new_req );
339 sendBody->push_back( new ExprStmt(
340 decl->location,
341 new UntypedExpr (
342 decl->location,
343 new NameExpr( decl->location, "send" ),
344 {
345 {
346 new NameExpr( decl->location, "receiver" ),
347 new NameExpr( decl->location, "new_req" )
348 }
349 }
350 )
351 ));
352 #endif
353
354 // Generates: return receiver;
355 sendBody->push_back( new ReturnStmt( decl->location, new NameExpr( decl->location, "receiver" ) ) );
356
357 // put it all together into the complete function decl from above
358 FunctionDecl * sendOperatorFunction = new FunctionDecl(
359 decl->location,
360 "?|?",
361 {}, // forall
362 {
363 new ObjectDecl(
364 decl->location,
365 "receiver",
366 ast::deepCopy( derivedActorRef )
367 ),
368 new ObjectDecl(
369 decl->location,
370 "msg",
371 ast::deepCopy( derivedMsgRef )
372 )
373 }, // params
374 {
375 new ObjectDecl(
376 decl->location,
377 "receiver_ret",
378 ast::deepCopy( derivedActorRef )
379 )
380 },
381 nullptr, // body
382 { Storage::Static }, // storage
383 Linkage::Cforall, // linkage
384 {}, // attributes
385 { Function::Inline }
386 );
387
388 // forward decls to resolve use before decl problem for '|' routines
389 forwardDecls.insertDecl( *actorIter, *messageIter , ast::deepCopy( sendOperatorFunction ) );
390 // forwardDecls.push_back( ast::deepCopy( sendOperatorFunction ) );
391
392 sendOperatorFunction->stmts = sendBody;
393 declsToAddAfter.push_back( sendOperatorFunction );
394 }
395 }
396
397 public:
398 GenReceiveDecls( unordered_set<const StructDecl *> & actorStructDecls, unordered_set<const StructDecl *> & messageStructDecls,
399 const StructDecl ** requestDecl, const EnumDecl ** allocationDecl, const StructDecl ** actorDecl, const StructDecl ** msgDecl,
400 FwdDeclTable & forwardDecls ) : actorStructDecls(actorStructDecls), messageStructDecls(messageStructDecls),
401 requestDecl(requestDecl), allocationDecl(allocationDecl), actorDecl(actorDecl), msgDecl(msgDecl), forwardDecls(forwardDecls) {}
402};
403
404struct GenFwdDecls : public ast::WithDeclsToAdd<> {
405 unordered_set<const StructDecl *> & actorStructDecls;
406 unordered_set<const StructDecl *> & messageStructDecls;
407 FwdDeclTable & forwardDecls;
408
409 void postvisit( const StructDecl * decl ) {
410 list<FunctionDecl *> toAddAfter;
411 auto actorIter = actorStructDecls.find( decl );
412 if ( actorIter != actorStructDecls.end() ) { // this is a derived actor decl
413 // get list of fwd decls that we can now insert
414 toAddAfter = forwardDecls.updateDecl( decl, false );
415
416 // get rid of decl from actorStructDecls since we no longer need it
417 actorStructDecls.erase( actorIter );
418 } else {
419 auto messageIter = messageStructDecls.find( decl );
420 if ( messageIter == messageStructDecls.end() ) return;
421
422 toAddAfter = forwardDecls.updateDecl( decl, true );
423
424 // get rid of decl from messageStructDecls since we no longer need it
425 messageStructDecls.erase( messageIter );
426 }
427
428 // add the fwd decls to declsToAddAfter
429 for ( FunctionDecl * func : toAddAfter ) {
430 declsToAddAfter.push_back( func );
431 }
432 }
433
434 public:
435 GenFwdDecls( unordered_set<const StructDecl *> & actorStructDecls, unordered_set<const StructDecl *> & messageStructDecls,
436 FwdDeclTable & forwardDecls ) : actorStructDecls(actorStructDecls), messageStructDecls(messageStructDecls),
437 forwardDecls(forwardDecls) {}
438};
439
440void implementActors( TranslationUnit & translationUnit ) {
441 // unordered_maps to collect all derived actor and message types
442 unordered_set<const StructDecl *> actorStructDecls;
443 unordered_set<const StructDecl *> messageStructDecls;
444 FwdDeclTable forwardDecls;
445
446 // for storing through the passes
447 // these are populated with various important struct decls
448 const StructDecl * requestDeclPtr = nullptr;
449 const EnumDecl * allocationDeclPtr = nullptr;
450 const StructDecl * actorDeclPtr = nullptr;
451 const StructDecl * msgDeclPtr = nullptr;
452
453 // double pointer to modify local ptrs above
454 const StructDecl ** requestDecl = &requestDeclPtr;
455 const EnumDecl ** allocationDecl = &allocationDeclPtr;
456 const StructDecl ** actorDecl = &actorDeclPtr;
457 const StructDecl ** msgDecl = &msgDeclPtr;
458
459 // first pass collects ptrs to Allocation enum, request type, and generic receive fn typedef
460 // also populates maps of all derived actors and messages
461 Pass<CollectactorStructDecls>::run( translationUnit, actorStructDecls, messageStructDecls, requestDecl,
462 allocationDecl, actorDecl, msgDecl );
463
464 // second pass locates all receive() routines that overload the generic receive fn
465 // it then generates the appropriate operator '|' send routines for the receive routines
466 Pass<GenReceiveDecls>::run( translationUnit, actorStructDecls, messageStructDecls, requestDecl,
467 allocationDecl, actorDecl, msgDecl, forwardDecls );
468
469 // The third pass forward declares operator '|' send routines
470 Pass<GenFwdDecls>::run( translationUnit, actorStructDecls, messageStructDecls, forwardDecls );
471}
472
473
474} // namespace Concurrency
475
476// Local Variables: //
477// tab-width: 4 //
478// mode: c++ //
479// compile-command: "make install" //
480// End: //
481
Note: See TracBrowser for help on using the repository browser.