Changeset adc73a5

Timestamp:

Jun 20, 2023, 2:20:56 PM (20 months ago)

Author:

caparson <caparson@…>

Branches:

master

Children:

48ec19a

Parents:

b7b3e41 (diff), d10e391 (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.

Message:

Merge branch 'master' of plg.uwaterloo.ca:software/cfa/cfa-cc

Files:

• libcfa/src/concurrency/actor.hfa (modified) (3 diffs)
• libcfa/src/concurrency/locks.hfa (modified) (1 diff)
• src/Concurrency/Actors.cpp (modified) (6 diffs)
• tests/Makefile.am (modified) (1 diff)
• tests/array-container/.expect/dimexpr-match-c-ERRS.arm64.txt (added)
• tests/array-container/.expect/dimexpr-match-c-ERRS.x64.txt (added)
• tests/array-container/.expect/dimexpr-match-c-ERRS.x86.txt (added)
• tests/array-container/.expect/dimexpr-match-c.txt (added)
• tests/array-container/.expect/dimexpr-match-cfa-ERRS.arm64.txt (added)
• tests/array-container/.expect/dimexpr-match-cfa-ERRS.x64.txt (added)
• tests/array-container/.expect/dimexpr-match-cfa-ERRS.x86.txt (added)
• tests/array-container/.expect/dimexpr-match-cfa.txt (added)
• tests/array-container/dimexpr-match-c.cfa (added)
• tests/array-container/dimexpr-match-cfa.cfa (added)
• tests/array-container/dimexpr-match-detail.sh (added)
• tests/array-container/dimexpr-match.hfa (added)
• tests/test.py (modified) (1 diff)

libcfa/src/concurrency/actor.hfa

@@ -46 +46 @@
 enum allocation { Nodelete, Delete, Destroy, Finished }; // allocation status
 
-typedef allocation (*__receive_fn)(actor &, message &);
+typedef allocation (*__receive_fn)(actor &, message &, actor **, message **);
 struct request {
-    actor * base_receiver;
     actor * receiver;
-    message * base_msg;
     message * msg;
     __receive_fn fn;
@@ -59 +57 @@
 };
 static inline void ?{}( request & this ) {}
-static inline void ?{}( request & this, actor * base_receiver, actor * receiver, message * base_msg, message * msg, __receive_fn fn ) {
-    this.base_receiver = base_receiver;
+static inline void ?{}( request & this, actor * receiver, message * msg, __receive_fn fn ) {
     this.receiver = receiver;
-    this.base_msg = base_msg;
     this.msg = msg;
     this.fn = fn;
@@ -460 +456 @@
 static inline void deliver_request( request & this ) {
     DEBUG_ABORT( this.receiver->ticket == (unsigned long int)MAX, "Attempted to send message to deleted/dead actor\n" );
-    this.base_receiver->allocation_ = this.fn( *this.receiver, *this.msg );
-    check_message( *this.base_msg );
-    check_actor( *this.base_receiver );
+    actor * base_actor;
+    message * base_msg;
+    allocation temp = this.fn( *this.receiver, *this.msg, &base_actor, &base_msg );
+    base_actor->allocation_ = temp;
+    check_message( *base_msg );
+    check_actor( *base_actor );
 }
 

libcfa/src/concurrency/locks.hfa

@@ -35 +35 @@
 #include <linux/futex.h>      /* Definition of FUTEX_* constants */
 #include <sys/syscall.h>      /* Definition of SYS_* constants */
-#include <unistd.h>
+#include <unistd.h>           /* Definition of syscall routine */
 
 typedef void (*__cfa_pre_park)( void * );

src/Concurrency/Actors.cpp

@@ -223 +223 @@
         if ( actorIter != actorStructDecls.end() && messageIter != messageStructDecls.end() ) {
             //////////////////////////////////////////////////////////////////////
+            // The following generates this wrapper for all receive(derived_actor &, derived_msg &) functions
+            /* base_actor and base_msg are output params
+            static inline allocation __CFA_receive_wrap( derived_actor & receiver, derived_msg & msg, actor ** base_actor, message ** base_msg ) {
+                base_actor = &receiver;
+                base_msg = &msg;
+                return receive( receiver, msg );
+            }
+            */
+            CompoundStmt * wrapBody = new CompoundStmt( decl->location );
+
+            // generates: base_actor = &receiver;
+            wrapBody->push_back( new ExprStmt( decl->location,
+                UntypedExpr::createAssign( decl->location, 
+                    UntypedExpr::createDeref( decl->location, new NameExpr( decl->location, "base_actor" ) ),
+                    new AddressExpr( decl->location, new NameExpr( decl->location, "receiver" ) )
+                )
+            ));
+
+            // generates: base_msg = &msg;
+            wrapBody->push_back( new ExprStmt( decl->location,
+                UntypedExpr::createAssign( decl->location, 
+                    UntypedExpr::createDeref( decl->location, new NameExpr( decl->location, "base_msg" ) ),
+                    new AddressExpr( decl->location, new NameExpr( decl->location, "msg" ) )
+                )
+            ));
+
+            // generates: return receive( receiver, msg );
+            wrapBody->push_back( new ReturnStmt( decl->location,
+                new UntypedExpr ( decl->location,
+                    new NameExpr( decl->location, "receive" ),
+                    {
+                        new NameExpr( decl->location, "receiver" ),
+                        new NameExpr( decl->location, "msg" )
+                    }
+                )
+            ));
+
+            // create receive wrapper to extract base message and actor pointer
+            // put it all together into the complete function decl from above
+            FunctionDecl * receiveWrapper = new FunctionDecl(
+                decl->location,
+                "__CFA_receive_wrap",
+                {},                     // forall
+                {
+                    new ObjectDecl(
+                        decl->location,
+                        "receiver",
+                        ast::deepCopy( derivedActorRef )
+                    ),
+                    new ObjectDecl(
+                        decl->location,
+                        "msg",
+                        ast::deepCopy( derivedMsgRef )
+                    ),
+                    new ObjectDecl(
+                        decl->location,
+                        "base_actor",
+                        new PointerType( new PointerType( new StructInstType( *actorDecl ) ) )
+                    ),
+                    new ObjectDecl(
+                        decl->location,
+                        "base_msg",
+                        new PointerType( new PointerType( new StructInstType( *msgDecl ) ) )
+                    )
+                },                      // params
+                { 
+                    new ObjectDecl(
+                        decl->location,
+                        "__CFA_receive_wrap_ret",
+                        new EnumInstType( *allocationDecl )
+                    )
+                },
+                wrapBody,               // body
+                { Storage::Static },    // storage
+                Linkage::Cforall,       // linkage
+                {},                     // attributes
+                { Function::Inline }
+            );
+
+            declsToAddAfter.push_back( receiveWrapper );
+
+            //////////////////////////////////////////////////////////////////////
             // The following generates this send message operator routine for all receive(derived_actor &, derived_msg &) functions
             /*
@@ -246 +328 @@
             ));
             
-            // Function type is: allocation (*)( derived_actor &, derived_msg & )
+            // Function type is: allocation (*)( derived_actor &, derived_msg &, actor **, message ** )
             FunctionType * derivedReceive = new FunctionType();
             derivedReceive->params.push_back( ast::deepCopy( derivedActorRef ) );
             derivedReceive->params.push_back( ast::deepCopy( derivedMsgRef ) );
+            derivedReceive->params.push_back( new PointerType( new PointerType( new StructInstType( *actorDecl ) ) ) );
+            derivedReceive->params.push_back( new PointerType( new PointerType( new StructInstType( *msgDecl ) ) ) );
             derivedReceive->returns.push_back( new EnumInstType( *allocationDecl ) );
 
-            // Generates: allocation (*my_work_fn)( derived_actor &, derived_msg & ) = receive;
+            // Generates: allocation (*my_work_fn)( derived_actor &, derived_msg &, actor **, message ** ) = receive;
             sendBody->push_back( new DeclStmt(
                 decl->location,
@@ -259 +343 @@
                     "my_work_fn",
                     new PointerType( derivedReceive ),
-                    new SingleInit( decl->location, new NameExpr( decl->location, "receive" ) )
+                    new SingleInit( decl->location, new NameExpr( decl->location, "__CFA_receive_wrap" ) )
                 )
             ));
@@ -267 +351 @@
             genericReceive->params.push_back( new ReferenceType( new StructInstType( *actorDecl ) ) );
             genericReceive->params.push_back( new ReferenceType( new StructInstType( *msgDecl ) ) );
+            genericReceive->params.push_back( new PointerType( new PointerType( new StructInstType( *actorDecl ) ) ) );
+            genericReceive->params.push_back( new PointerType( new PointerType( new StructInstType( *msgDecl ) ) ) );
             genericReceive->returns.push_back( new EnumInstType( *allocationDecl ) );
 
@@ -285 +371 @@
             ));
 
-            // Generates: new_req{ &receiver, (actor *)&receiver, &msg, (message *)&msg, fn };
+            // Generates: new_req{ (actor *)&receiver, (message *)&msg, fn };
             sendBody->push_back( new ExprStmt(
                 decl->location,
@@ -293 +379 @@
                                         {
                                                 new NameExpr( decl->location, "new_req" ),
-                        new AddressExpr( new NameExpr( decl->location, "receiver" ) ),
                         new CastExpr( decl->location, new AddressExpr( new NameExpr( decl->location, "receiver" ) ), new PointerType( new StructInstType( *actorDecl ) ), ExplicitCast ),
-                        new AddressExpr( new NameExpr( decl->location, "msg" ) ),
                         new CastExpr( decl->location, new AddressExpr( new NameExpr( decl->location, "msg" ) ), new PointerType( new StructInstType( *msgDecl ) ), ExplicitCast ),
                         new NameExpr( decl->location, "fn" )

tests/Makefile.am

@@ -225 +225 @@
         -cp ${test} ${abspath ${@}}
 
+array-container/dimexpr-match-c-ERRS : array-container/dimexpr-match-c.cfa
+        ${CFACOMPILE_SYNTAX} -DERRS
+        -cp ${test} ${abspath ${@}}
+
+array-container/dimexpr-match-cfa-ERRS : array-container/dimexpr-match-cfa.cfa
+        ${CFACOMPILE_SYNTAX} -DERRS
+        -cp ${test} ${abspath ${@}}
+
 alloc-ERROR : alloc.cfa ${CFACCBIN}
         ${CFACOMPILE_SYNTAX} -DERR1

tests/test.py

@@ -115 +115 @@
         parser.add_argument('--continue', help='When multiple specifications are passed (debug/install/arch), sets whether or not to continue if the last specification failed', type=yes_no, default='yes', dest='continue_')
         parser.add_argument('--invariant', help='Tell the compiler to check invariants.', action='store_true')
-        parser.add_argument('--no-invariant', help='Tell the compiler not to check invariant.', action='store_false')
+        parser.add_argument('--no-invariant', help='Tell the compiler not to check invariants.', action='store_false')
         parser.add_argument('--timeout', help='Maximum duration in seconds after a single test is considered to have timed out', type=int, default=180)
         parser.add_argument('--global-timeout', help='Maximum cumulative duration in seconds after the ALL tests are considered to have timed out', type=int, default=7200)