Changeset 2a301ff for src/Concurrency/Waituntil.cpp

Timestamp:

Aug 31, 2023, 11:31:15 PM (2 years ago)

Author:

JiadaL <j82liang@…>

Branches:

master

Children:

950c58e

Parents:

92355883 (diff), 686912c (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:

Resolve conflict

File:

• src/Concurrency/Waituntil.cpp (modified) (14 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 );
     Stmt * genElseClauseBranch( const WaitUntilStmt * stmt, string & runName, string & arrName, vector<ClauseData *> & clauseData );
-    Stmt * genNoElseClauseBranch( const WaitUntilStmt * stmt, string & satName, string & runName, string & arrName, string & pCountName, vector<ClauseData *> & clauseData );
+    Stmt * genNoElseClauseBranch( const WaitUntilStmt * stmt, string & runName, string & arrName, string & pCountName, vector<ClauseData *> & clauseData );
     void genClauseInits( const WaitUntilStmt * stmt, vector<ClauseData *> & clauseData, CompoundStmt * body, string & statusName, string & elseWhenName );
     Stmt * recursiveOrIfGen( const WaitUntilStmt * stmt, vector<ClauseData *> & data, vector<ClauseData*>::size_type idx, string & elseWhenName );
@@ -626 +627 @@
     return new CompoundStmt( cLoc,
         {
-            new ExprStmt( cLoc,
-                genSelectTraitCall( clause, data, "on_selected" )
-            ),
-            ast::deepCopy( clause->stmt )
+            new IfStmt( cLoc,
+                genSelectTraitCall( clause, data, "on_selected" ),
+                ast::deepCopy( clause->stmt )
+            )
         }
     );
@@ -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 ) }
+            )
+        }
     );
 }
@@ -809 +820 @@
 }
 
-Stmt * GenerateWaitUntilCore::genNoElseClauseBranch( const WaitUntilStmt * stmt, string & satName, string & runName, string & arrName, string & pCountName, vector<ClauseData *> & clauseData ) {
+Stmt * GenerateWaitUntilCore::genNoElseClauseBranch( const WaitUntilStmt * stmt, string & runName, string & arrName, string & pCountName, vector<ClauseData *> & clauseData ) {
     CompoundStmt * whileBody = new CompoundStmt( stmt->location );
     const CodeLocation & loc = stmt->location;
@@ -823 +834 @@
     );
 
-    whileBody->push_back( genStatusCheckFor( stmt, clauseData, satName ) );
+    whileBody->push_back( genStatusCheckFor( stmt, clauseData, runName ) );
 
     return new CompoundStmt( loc,
         {
             new WhileDoStmt( loc,
-                genNotSatExpr( stmt, satName, arrName ),
+                genNotSatExpr( stmt, runName, arrName ),
                 whileBody,  // body
                 {}          // no inits
-            ),
-            genStatusCheckFor( stmt, clauseData, runName )
+            )
         }
     );
@@ -856 +866 @@
                 new ObjectDecl( cLoc,
                     currClause->targetName,
-                    new ReferenceType( new TypeofType( ast::deepCopy( stmt->clauses.at(i)->target ) ) ),
+                    new ReferenceType( 
+                        new TypeofType( new UntypedExpr( cLoc,
+                            new NameExpr( cLoc, "__CFA_select_get_type" ),
+                            { ast::deepCopy( stmt->clauses.at(i)->target ) }
+                        ))
+                    ),
                     new SingleInit( cLoc, ast::deepCopy( stmt->clauses.at(i)->target ) )
                 )
@@ -1268 +1283 @@
                 new NameExpr( stmt->else_cond->location, elseWhenName ),
                 genElseClauseBranch( stmt, runName, statusArrName, clauseData ),
-                genNoElseClauseBranch( stmt, satName, runName, statusArrName, pCountName, clauseData )
+                genNoElseClauseBranch( stmt, runName, statusArrName, pCountName, clauseData )
             )
         );
     } else if ( !stmt->else_stmt ) { // normal gen
-        tryBody->push_back( genNoElseClauseBranch( stmt, satName, runName, statusArrName, pCountName, clauseData ) );
+        tryBody->push_back( genNoElseClauseBranch( stmt, runName, statusArrName, pCountName, clauseData ) );
     } else { // generate just else
         tryBody->push_back( genElseClauseBranch( stmt, runName, statusArrName, clauseData ) );
     }
 
+    // Collection of unregister calls on resources to be put in finally clause
+    // for each clause: 
+    // if ( !__CFA_has_clause_run( clause_statuses[i] )) && unregister_select( ... , clausei ) ) { ... clausei stmt ... }
+    // OR if when( ... ) defined on resource
+    // if ( when_cond_i && (!__CFA_has_clause_run( clause_statuses[i] )) && unregister_select( ... , clausei ) ) { ... clausei stmt ... }
     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]
+
+    Expr * statusExpr; // !__CFA_has_clause_run( clause_statuses[i] )
     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 +1315 @@
             }
         );
-
-        if ( stmt->clauses.at(i)->when_cond ) {
-            // generates: if( when_cond_i && !has_run(clause_statuses[i]) )
-            ifCond = new LogicalExpr( cLoc,
+        
+        // Generates:
+        // (!__CFA_has_clause_run( clause_statuses[i] )) && unregister_select( ... , clausei );
+        statusExpr = 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 when cond defined generates:
+        // when_cond_i && (!__CFA_has_clause_run( clause_statuses[i] )) && unregister_select( ... , clausei );
+        if ( stmt->clauses.at(i)->when_cond )
+            statusExpr = new LogicalExpr( cLoc,
                 new CastExpr( cLoc,
                     new NameExpr( cLoc, clauseData.at(i)->whenName ), 
@@ -1314 +1344 @@
                 LogicalFlag::AndExpr
             );
-        } else // generates: if( !clause_statuses[i] )
-            ifCond = statusExpr;
-        
+
+        // generates:
+        // if ( statusExpr ) { ... clausei stmt ... }
         unregisters->push_back( 
             new IfStmt( cLoc,
-                ifCond,
+                statusExpr,
                 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) )
+                            genSelectTraitCall( stmt->clauses.at(i), clauseData.at(i), "on_selected" ),
+                            ast::deepCopy( stmt->clauses.at(i)->stmt )
                         )
                     }
                 )
-                
-            )
-        );
+            )
+        );
+
+        // // generates:
+        // // if ( statusExpr ) { ... clausei stmt ... }
+        // unregisters->push_back( 
+        //     new IfStmt( cLoc,
+        //         statusExpr,
+        //         genStmtBlock( stmt->clauses.at(i), clauseData.at(i) )
+        //     )
+        // );
     }