Changeset ed1a7ab8 for src/Concurrency/Waituntil.cpp

Timestamp:

Jul 3, 2023, 1:09:53 PM (12 months ago)

Author:

caparsons <caparson@…>

Branches:

master

Children:

a2f1ea8d

Parents:

bdf4cd9

Message:

fixed two bugs with breaks in waituntils, required reordering of waituntil pass to set correct labels for breaks

File:

• src/Concurrency/Waituntil.cpp (modified) (11 diffs)

src/Concurrency/Waituntil.cpp

@@ -142 +142 @@
     UniqueName namer_target = "__clause_target_"s;
     UniqueName namer_when = "__when_cond_"s;
+    UniqueName namer_label = "__waituntil_label_"s;
 
     string idxName = "__CFA_clause_idx_";
@@ -173 +174 @@
     void addPredicates( const WaitUntilStmt * stmt, string & satName, string & runName );
     void setUpClause( const WhenClause * clause, ClauseData * data, string & pCountName, CompoundStmt * body );
-    ForStmt * genStatusCheckFor( const WaitUntilStmt * stmt, vector<ClauseData *> & clauseData, string & predName );
+    CompoundStmt * genStatusCheckFor( const WaitUntilStmt * stmt, vector<ClauseData *> & clauseData, string & predName );
     Expr * genSelectTraitCall( const WhenClause * clause, const ClauseData * data, string fnName );
     CompoundStmt * genStmtBlock( const WhenClause * clause, const ClauseData * data );
@@ -653 +654 @@
     }
 }*/
-ForStmt * GenerateWaitUntilCore::genStatusCheckFor( const WaitUntilStmt * stmt, vector<ClauseData *> & clauseData, string & predName ) {
+CompoundStmt * GenerateWaitUntilCore::genStatusCheckFor( const WaitUntilStmt * stmt, vector<ClauseData *> & clauseData, string & predName ) {
     CompoundStmt * ifBody = new CompoundStmt( stmt->location );
     const CodeLocation & loc = stmt->location;
+
+    string switchLabel = namer_label.newName();
 
     /* generates:
@@ -707 +710 @@
                                 )
                             ),
-                            new BranchStmt( cLoc, BranchStmt::Kind::Break, Label( cLoc ) )
+                            new BranchStmt( cLoc, BranchStmt::Kind::Break, Label( cLoc, switchLabel ) )
                         }
                     )
@@ -719 +722 @@
         new SwitchStmt( loc,
             new NameExpr( loc, idxName ),
-            std::move( switchCases )
+            std::move( switchCases ),
+            { Label( loc, switchLabel ) }
         )
     );
@@ -744 +748 @@
     );
 
-    return new ForStmt( loc,
+    string forLabel = namer_label.newName();
+
+    // we hoist init here so that this pass can happen after hoistdecls pass
+    return new CompoundStmt( loc,
         {
             new DeclStmt( loc,
@@ -752 +759 @@
                     new SingleInit( loc, ConstantExpr::from_int( loc, 0 ) )
                 )
-            )
-        },  // inits
-        new UntypedExpr ( loc,
-            new NameExpr( loc, "?<?" ),
-            {
-                new NameExpr( loc, idxName ),
-                ConstantExpr::from_int( loc, stmt->clauses.size() )
-            }
-        ),  // cond
-        new UntypedExpr ( loc,
-            new NameExpr( loc, "?++" ),
-            { new NameExpr( loc, idxName ) }
-        ),  // inc
-        new CompoundStmt( loc,
-            {
-                new IfStmt( loc,
-                    new UntypedExpr ( loc,
-                        new NameExpr( loc, predName ),
-                        { new NameExpr( loc, clauseData.at(0)->statusName ) }
-                    ),
-                    new BranchStmt( loc, BranchStmt::Kind::Break, Label( loc ) )
-                ),
-                ifSwitch
-            }
-        )   // body
+            ),
+            new ForStmt( loc,
+                {},  // inits
+                new UntypedExpr ( loc,
+                    new NameExpr( loc, "?<?" ),
+                    {
+                        new NameExpr( loc, idxName ),
+                        ConstantExpr::from_int( loc, stmt->clauses.size() )
+                    }
+                ),  // cond
+                new UntypedExpr ( loc,
+                    new NameExpr( loc, "?++" ),
+                    { new NameExpr( loc, idxName ) }
+                ),  // inc
+                new CompoundStmt( loc,
+                    {
+                        new IfStmt( loc,
+                            new UntypedExpr ( loc,
+                                new NameExpr( loc, predName ),
+                                { new NameExpr( loc, clauseData.at(0)->statusName ) }
+                            ),
+                            new BranchStmt( loc, BranchStmt::Kind::Break, Label( loc, forLabel ) )
+                        ),
+                        ifSwitch
+                    }
+                ),   // body
+                { Label( loc, forLabel ) }
+            )
+        }
     );
 }
@@ -870 +881 @@
                         new BasicType( BasicType::Kind::Bool ),
                         new SingleInit( cLoc, ast::deepCopy( stmt->clauses.at(i)->when_cond ) )
+                    )
+                )
+            );
+        else // we reuse the when_cond bools later during unregister so init to false if initially unused
+            body->push_back(
+                new DeclStmt( cLoc,
+                    new ObjectDecl( cLoc,
+                        currClause->whenName,
+                        new BasicType( BasicType::Kind::Bool ),
+                        new SingleInit( cLoc, ConstantExpr::from_bool( cLoc, false ) )
                     )
                 )
@@ -1277 +1298 @@
     }
 
+    // Collection of unregister calls on resources to be put in finally clause
+    // for each clause: 
+    // when_cond_i = (!__CFA_has_clause_run( clause_statuses[i] )) && unregister_select( ... , clausei );
+    // OR if when( ... ) defined on resource
+    // if ( when_cond_i ) 
+    //   when_cond_i =  (!__CFA_has_clause_run( clause_statuses[i] )) && unregister_select( ... , clausei );
     CompoundStmt * unregisters = new CompoundStmt( loc );
-    // generates for each clause: 
-    // if ( !has_run( clause_statuses[i] ) ) 
-    // OR if when_cond defined
-    // if ( when_cond_i && !has_run( clause_statuses[i] ) )
-    // body of if is:
-    // { if (unregister_select(A, clause1) && on_selected(A, clause1)) clause1->stmt; } // this conditionally runs the block unregister_select returns true (needed by some primitives)
-    Expr * ifCond;
-    UntypedExpr * statusExpr; // !clause_statuses[i]
+
+    // Collection of optional statement executions following finally clause
+    // for each clause:
+    // if ( when_cond_i ) clausei->stmt;
+    // when_cond_i is repurposed in the finally to store if any statements need to be run after unregisters
+    // the statements need to be run outside a finally clause since they may contain non-local transfers
+    CompoundStmt * unregisterStmts = new CompoundStmt( loc );
+
+    UntypedExpr * statusExpr; // !__CFA_has_clause_run( clause_statuses[i] )
+    ExprStmt * assignStmt; // when_cond_i = (!__CFA_has_clause_run( clause_statuses[i] )) && unregister_select( ... , clausei );
     for ( int i = 0; i < numClauses; i++ ) {
         const CodeLocation & cLoc = stmt->clauses.at(i)->location;
 
+        // Generates: !__CFA_has_clause_run( clause_statuses[i] )
         statusExpr = new UntypedExpr ( cLoc,
             new NameExpr( cLoc, "!?" ),
@@ -1300 +1330 @@
             }
         );
-
-        if ( stmt->clauses.at(i)->when_cond ) {
-            // generates: if( when_cond_i && !has_run(clause_statuses[i]) )
-            ifCond = new LogicalExpr( cLoc,
-                new CastExpr( cLoc,
-                    new NameExpr( cLoc, clauseData.at(i)->whenName ), 
-                    new BasicType( BasicType::Kind::Bool ), GeneratedFlag::ExplicitCast 
-                ),
-                new CastExpr( cLoc,
-                    statusExpr,
-                    new BasicType( BasicType::Kind::Bool ), GeneratedFlag::ExplicitCast 
-                ),
-                LogicalFlag::AndExpr
+        
+        // Generates:
+        // when_cond_i = (!__CFA_has_clause_run( clause_statuses[i] )) && unregister_select( ... , clausei );
+        assignStmt = new ExprStmt( cLoc, 
+            UntypedExpr::createAssign( cLoc,
+                new NameExpr( cLoc, clauseData.at(i)->whenName ),
+                new LogicalExpr( cLoc,
+                    new CastExpr( cLoc,
+                        statusExpr, 
+                        new BasicType( BasicType::Kind::Bool ), GeneratedFlag::ExplicitCast 
+                    ),
+                    new CastExpr( cLoc,
+                        genSelectTraitCall( stmt->clauses.at(i), clauseData.at(i), "unregister_select" ),
+                        new BasicType( BasicType::Kind::Bool ), GeneratedFlag::ExplicitCast 
+                    ),
+                    LogicalFlag::AndExpr
+                )
+            )
+        );
+
+        if ( stmt->clauses.at(i)->when_cond ) // if ( when_cond_i ) assignStmt
+            unregisters->push_back( 
+                new IfStmt( cLoc,
+                    new NameExpr( cLoc, clauseData.at(i)->whenName ),
+                    new CompoundStmt( cLoc, { assignStmt } )
+                )
             );
-        } else // generates: if( !clause_statuses[i] )
-            ifCond = statusExpr;
-        
-        unregisters->push_back( 
+        else
+            unregisters->push_back( assignStmt );
+
+        unregisterStmts->push_back(
             new IfStmt( cLoc,
-                ifCond,
-                new CompoundStmt( cLoc,
-                    {
-                        new IfStmt( cLoc,
-                            genSelectTraitCall( stmt->clauses.at(i), clauseData.at(i), "unregister_select" ),
-                            // ast::deepCopy( stmt->clauses.at(i)->stmt )
-                            genStmtBlock( stmt->clauses.at(i), clauseData.at(i) )
-                        )
-                    }
-                )
-                
+                new NameExpr( cLoc, clauseData.at(i)->whenName ),
+                genStmtBlock( stmt->clauses.at(i), clauseData.at(i) )
             )
         );
@@ -1342 +1376 @@
         )
     );
+
+    body->push_back( unregisterStmts );
+    
 
     for ( ClauseData * datum : clauseData )