Changes in src/Concurrency/Actors.cpp [3830c84:ccf1d99]

File:

• src/Concurrency/Actors.cpp (modified) (16 diffs)

src/Concurrency/Actors.cpp

@@ -45 +45 @@
     // finds and sets a ptr to the actor, message, and request structs, which are needed in the next pass
     void previsit( const StructDecl * decl ) {
-        if ( !decl->body ) return;
-        if ( decl->name == "actor" ) {
-            actorStructDecls.insert( decl ); // skip inserting fwd decl
-            *actorDecl = decl;
-        } else if( decl->name == "message" ) {
-            messageStructDecls.insert( decl ); // skip inserting fwd decl
-            *msgDecl = decl;
-        } else if( decl->name == "request" ) *requestDecl = decl;
-        else {
-            GuardValue(insideStruct);
-            insideStruct = true;
-            parentDecl = mutate( decl );
-        }
+        GuardValue(insideStruct);
+        insideStruct = true;
+        parentDecl = mutate( decl );
+        if( decl->name == "actor" ) *actorDecl = decl;
+        if( decl->name == "message" ) *msgDecl = decl;
+        if( decl->name == "request" ) *requestDecl = decl;
         }
 
@@ -71 +64 @@
     }
 
-    // this collects the derived actor and message struct decl ptrs
+    // this collects the valid actor and message struct decl pts
     void postvisit( const StructInstType * node ) {
         if ( ! *actorDecl || ! *msgDecl ) return;
         if ( insideStruct && !namedDecl ) {
-            auto actorIter = actorStructDecls.find( node->aggr() );    
-            if ( actorIter != actorStructDecls.end() ) {
+            if ( node->aggr() == *actorDecl ) {
                 actorStructDecls.insert( parentDecl );
-                return;
-            }
-            auto messageIter = messageStructDecls.find( node->aggr() );
-            if ( messageIter != messageStructDecls.end() ) {
+            } else if ( node->aggr() == *msgDecl ) {
                 messageStructDecls.insert( parentDecl );
             }
@@ -191 +180 @@
 };
 
-// generates the definitions of send operators for actors
-// collects data needed for next pass that does the circular defn resolution 
-//     for message send operators (via table above)
-struct GenFuncsCreateTables : public ast::WithDeclsToAdd<> {
+#define __ALLOC 0 // C_TODO: complete swap to no-alloc version
+
+struct GenReceiveDecls : public ast::WithDeclsToAdd<> {
     unordered_set<const StructDecl *> & actorStructDecls;
     unordered_set<const StructDecl *>  & messageStructDecls;
@@ -203 +191 @@
     FwdDeclTable & forwardDecls;
 
-    // generates the operator for actor message sends
         void postvisit( const FunctionDecl * decl ) {
         // return if not of the form receive( param1, param2 ) or if it is a forward decl
@@ -222 +209 @@
         auto messageIter = messageStructDecls.find( arg2InstType->aggr() );
         if ( actorIter != actorStructDecls.end() && messageIter != messageStructDecls.end() ) {
+
+            // check that we have found all the decls we need from <actor.hfa>
+            if ( !*allocationDecl || !*requestDecl ) 
+                SemanticError( decl->location, "using actors requires a header, add #include <actor.hfa>\n" );
+
             //////////////////////////////////////////////////////////////////////
             // The following generates this send message operator routine for all receive(derived_actor &, derived_msg &) functions
             /*
                 static inline derived_actor & ?|?( derived_actor & receiver, derived_msg & msg ) {
-                    request new_req;
+                    request * new_req = alloc();
                     Allocation (*my_work_fn)( derived_actor &, derived_msg & ) = receive;
                     __receive_fn fn = (__receive_fn)my_work_fn;
-                    new_req{ &receiver, &msg, fn };
-                    send( receiver, new_req );
+                    (*new_req){ &receiver, &msg, fn };
+                    send( receiver, *new_req );
                     return receiver;
                 }
-            */ 
+            */ // C_TODO: update this with new no alloc version
             CompoundStmt * sendBody = new CompoundStmt( decl->location );
 
+            #if __ALLOC
+            // Generates: request * new_req = alloc();
+            sendBody->push_back( new DeclStmt(
+                decl->location,
+                new ObjectDecl(
+                    decl->location,
+                    "new_req",
+                    new PointerType( new StructInstType( *requestDecl ) ),
+                    new SingleInit( decl->location, new UntypedExpr( decl->location, new NameExpr( decl->location, "alloc" ), {} ) )
+                )
+            ));
+            #else
             // Generates: request new_req;
             sendBody->push_back( new DeclStmt(
@@ -245 +249 @@
                 )
             ));
+            #endif
             
             // Function type is: Allocation (*)( derived_actor &, derived_msg & )
@@ -263 +268 @@
             ));
 
-            // Function type is: Allocation (*)( actor &, message & )
+            // Function type is: Allocation (*)( actor &, messsage & )
             FunctionType * genericReceive = new FunctionType();
             genericReceive->params.push_back( new ReferenceType( new StructInstType( *actorDecl ) ) );
@@ -269 +274 @@
             genericReceive->returns.push_back( new EnumInstType( *allocationDecl ) );
 
-            // Generates: Allocation (*fn)( actor &, message & ) = (Allocation (*)( actor &, message & ))my_work_fn;
+            // Generates: Allocation (*fn)( actor &, messsage & ) = (Allocation (*)( actor &, messsage & ))my_work_fn;
             // More readable synonymous code: 
             //     typedef Allocation (*__receive_fn)(actor &, message &);
@@ -285 +290 @@
             ));
 
+            #if __ALLOC
+            // Generates: (*new_req){ &receiver, &msg, fn };
+            sendBody->push_back( new ExprStmt(
+                decl->location,
+                                new UntypedExpr (
+                    decl->location, 
+                                        new NameExpr( decl->location, "?{}" ),
+                                        {
+                                                new UntypedExpr( decl->location, new NameExpr( decl->location, "*?" ), {  new NameExpr( decl->location, "new_req" ) } ),
+                        new AddressExpr( new NameExpr( decl->location, "receiver" ) ),
+                        new AddressExpr( new NameExpr( decl->location, "msg" ) ),
+                        new NameExpr( decl->location, "fn" )
+                                        }
+                                )
+                        ));
+
+            // Generates: send( receiver, *new_req );
+            sendBody->push_back( new ExprStmt(
+                decl->location,
+                                new UntypedExpr (
+                    decl->location,
+                                        new NameExpr( decl->location, "send" ),
+                                        {
+                                                {
+                            new NameExpr( decl->location, "receiver" ),
+                            new UntypedExpr( decl->location, new NameExpr( decl->location, "*?" ), {  new NameExpr( decl->location, "new_req" ) } )
+                        }
+                                        }
+                                )
+                        ));
+            #else
             // Generates: new_req{ &receiver, &msg, fn };
             sendBody->push_back( new ExprStmt(
@@ -314 +350 @@
                                 )
                         ));
+            #endif
             
             // Generates: return receiver;
@@ -321 +358 @@
             FunctionDecl * sendOperatorFunction = new FunctionDecl(
                 decl->location,
-                "?<<?",
+                "?|?",
                 {},                     // forall
                 {
@@ -351 +388 @@
             // forward decls to resolve use before decl problem for '|' routines
             forwardDecls.insertDecl( *actorIter, *messageIter , ast::deepCopy( sendOperatorFunction ) );
+            // forwardDecls.push_back( ast::deepCopy( sendOperatorFunction ) );
 
             sendOperatorFunction->stmts = sendBody;
@@ -358 +396 @@
 
   public:
-    GenFuncsCreateTables( unordered_set<const StructDecl *> & actorStructDecls, unordered_set<const StructDecl *> & messageStructDecls,
+    GenReceiveDecls( unordered_set<const StructDecl *> & actorStructDecls, unordered_set<const StructDecl *> & messageStructDecls,
         const StructDecl ** requestDecl, const EnumDecl ** allocationDecl, const StructDecl ** actorDecl, const StructDecl ** msgDecl, 
         FwdDeclTable & forwardDecls ) : actorStructDecls(actorStructDecls), messageStructDecls(messageStructDecls), 
@@ -364 +402 @@
 };
 
-
-// separate pass is needed since this pass resolves circular defn issues
-// generates the forward declarations of the send operator for actor routines
-struct FwdDeclOperator : public ast::WithDeclsToAdd<> {
+struct GenFwdDecls : public ast::WithDeclsToAdd<> {
     unordered_set<const StructDecl *> & actorStructDecls;
     unordered_set<const StructDecl *>  & messageStructDecls;
     FwdDeclTable & forwardDecls;
 
-    // handles forward declaring the message operator
     void postvisit( const StructDecl * decl ) {
         list<FunctionDecl *> toAddAfter;
@@ -399 +433 @@
 
   public:
-    FwdDeclOperator( unordered_set<const StructDecl *> & actorStructDecls, unordered_set<const StructDecl *> & messageStructDecls, 
-        FwdDeclTable & forwardDecls ) : actorStructDecls(actorStructDecls), messageStructDecls(messageStructDecls), forwardDecls(forwardDecls) {}
+    GenFwdDecls( unordered_set<const StructDecl *> & actorStructDecls, unordered_set<const StructDecl *> & messageStructDecls, 
+        FwdDeclTable & forwardDecls ) : actorStructDecls(actorStructDecls), messageStructDecls(messageStructDecls),
+        forwardDecls(forwardDecls) {}
 };
 
@@ -426 +461 @@
     Pass<CollectactorStructDecls>::run( translationUnit, actorStructDecls, messageStructDecls, requestDecl, 
         allocationDecl, actorDecl, msgDecl );
-
-    // check that we have found all the decls we need from <actor.hfa>, if not no need to run the rest of this pass
-    if ( !allocationDeclPtr || !requestDeclPtr || !actorDeclPtr || !msgDeclPtr ) 
-        return;
-
+        
     // second pass locates all receive() routines that overload the generic receive fn
     // it then generates the appropriate operator '|' send routines for the receive routines
-    Pass<GenFuncsCreateTables>::run( translationUnit, actorStructDecls, messageStructDecls, requestDecl, 
+    Pass<GenReceiveDecls>::run( translationUnit, actorStructDecls, messageStructDecls, requestDecl, 
         allocationDecl, actorDecl, msgDecl, forwardDecls );
 
     // The third pass forward declares operator '|' send routines
-    Pass<FwdDeclOperator>::run( translationUnit, actorStructDecls, messageStructDecls, forwardDecls );
+    Pass<GenFwdDecls>::run( translationUnit, actorStructDecls, messageStructDecls, forwardDecls );
 }