Changeset aaa4f93

Timestamp:

Sep 21, 2017, 11:33:23 AM (7 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, deferred_resn, demangler, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, with_gc

Children:

7453a68

Parents:

a2dbad10

Message:

Updated accepted index to live in the waitfor caller stack.
Waitfor no longer blocks if all when clauses are false.
Waitfor now properly zeroes out acceptables before use.

Location:

src

Files:

• Concurrency/Waitfor.cc (modified) (13 diffs)
• libcfa/concurrency/monitor (modified) (1 diff)
• libcfa/concurrency/monitor.c (modified) (5 diffs)

src/Concurrency/Waitfor.cc

@@ -126 +126 @@
 
                 ObjectDecl * declare( unsigned long count, CompoundStmt * stmt );
+                ObjectDecl * declareFlag( CompoundStmt * stmt );
+                Statement  * makeSetter( ObjectDecl * flag );
                 ObjectDecl * declMon( WaitForStmt::Clause & clause, CompoundStmt * stmt );
-                void         init( ObjectDecl * acceptables, int index, WaitForStmt::Clause & clause, CompoundStmt * stmt );
-                Expression * init_timeout( Expression *& time, Expression *& time_cond, bool has_else, Expression *& else_cond, CompoundStmt * stmt );
+                void         init( ObjectDecl * acceptables, int index, WaitForStmt::Clause & clause, Statement * settter, CompoundStmt * stmt );
+                Expression * init_timeout( Expression *& time, Expression *& time_cond, bool has_else, Expression *& else_cond, Statement * settter, CompoundStmt * stmt );
                 Expression * call(size_t count, ObjectDecl * acceptables, Expression * timeout, CompoundStmt * stmt);
                 void         choose( WaitForStmt * waitfor, Expression  * result, CompoundStmt * stmt );
@@ -140 +142 @@
           private:
                 FunctionDecl        * decl_waitfor    = nullptr;
+                StructDecl          * decl_mask       = nullptr;
                 StructDecl          * decl_acceptable = nullptr;
                 StructDecl          * decl_monitor    = nullptr;
@@ -145 +148 @@
                 static std::unique_ptr< Type > generic_func;
 
+                UniqueName namer_acc = "__acceptables_"s;
+                UniqueName namer_idx = "__index_"s;
+                UniqueName namer_flg = "__do_run_"s;
+                UniqueName namer_msk = "__mask_"s;
                 UniqueName namer_mon = "__monitors_"s;
-                UniqueName namer_acc = "__acceptables_"s;
                 UniqueName namer_tim = "__timeout_"s;
-                UniqueName namer_ret = "__return_"s;
         };
 
@@ -239 +244 @@
                         decl_acceptable = decl;
                 }
+                else if( decl->name == "__waitfor_mask_t" ) {
+                        assert( !decl_mask );
+                        decl_mask = decl;
+                }
                 else if( decl->name == "monitor_desc" ) {
                         assert( !decl_monitor );
@@ -246 +255 @@
 
         Statement * GenerateWaitForPass::postmutate( WaitForStmt * waitfor ) {
-                if( !decl_monitor || !decl_acceptable ) throw SemanticError( "waitfor keyword requires monitors to be in scope, add #include <monitor>", waitfor );
+                if( !decl_monitor || !decl_acceptable || !decl_mask ) throw SemanticError( "waitfor keyword requires monitors to be in scope, add #include <monitor>", waitfor );
 
                 CompoundStmt * stmt = new CompoundStmt( noLabels );
 
                 ObjectDecl * acceptables = declare( waitfor->clauses.size(), stmt );
+                ObjectDecl * flag        = declareFlag( stmt );
+                Statement  * setter      = makeSetter( flag );
 
                 int index = 0;
                 for( auto & clause : waitfor->clauses ) {
-                        init( acceptables, index, clause, stmt );
+                        init( acceptables, index, clause, setter, stmt );
 
                         index++;
@@ -264 +275 @@
                         waitfor->orelse .statement,
                         waitfor->orelse .condition,
+                        setter,
                         stmt
                 );
 
-                Expression * result = call( waitfor->clauses.size(), acceptables, timeout, stmt );
-
-                choose( waitfor, result, stmt );
+                CompoundStmt * compound = new CompoundStmt( noLabels );
+                stmt->push_back( new IfStmt(
+                        noLabels,
+                        safeCond( new VariableExpr( flag ) ),
+                        compound,
+                        nullptr
+                ));
+
+                Expression * result = call( waitfor->clauses.size(), acceptables, timeout, compound );
+
+                choose( waitfor, result, compound );
 
                 return stmt;
@@ -293 +313 @@
                 stmt->push_back( new DeclStmt( noLabels, acceptables) );
 
+                UntypedExpr * set = new UntypedExpr(
+                        new NameExpr( "__builtin_memset" ),
+                        {
+                                new VariableExpr( acceptables ),
+                                new ConstantExpr( Constant::from_int( 0 ) ),
+                                new SizeofExpr( new VariableExpr( acceptables ) )
+                        }
+                );
+
+                Expression * resolved_set = ResolvExpr::findVoidExpression( set, indexer );
+                delete set;
+
+                stmt->push_back( new ExprStmt( noLabels, resolved_set ) );
+
                 return acceptables;
+        }
+
+        ObjectDecl * GenerateWaitForPass::declareFlag( CompoundStmt * stmt ) {
+                ObjectDecl * flag = ObjectDecl::newObject(
+                        namer_flg.newName(),
+                        new BasicType(
+                                noQualifiers,
+                                BasicType::Bool
+                        ),
+                        new SingleInit( new ConstantExpr( Constant::from_ulong( 0 ) ) )
+                );
+
+                stmt->push_back( new DeclStmt( noLabels, flag) );
+
+                return flag;
+        }
+
+        Statement * GenerateWaitForPass::makeSetter( ObjectDecl * flag ) {
+                Expression * untyped = new UntypedExpr(
+                        new NameExpr( "?=?" ),
+                        {
+                                new VariableExpr( flag ),
+                                new ConstantExpr( Constant::from_ulong( 1 ) )
+                        }
+                );
+
+                Expression * expr = ResolvExpr::findVoidExpression( untyped, indexer );
+                delete untyped;
+
+                return new ExprStmt( noLabels, expr );
         }
 
@@ -341 +405 @@
         }
 
-        void GenerateWaitForPass::init( ObjectDecl * acceptables, int index, WaitForStmt::Clause & clause, CompoundStmt * stmt ) {
+        void GenerateWaitForPass::init( ObjectDecl * acceptables, int index, WaitForStmt::Clause & clause, Statement * setter, CompoundStmt * stmt ) {
 
                 ObjectDecl * monitors = declMon( clause, stmt );
 
                 Type * fptr_t = new PointerType( noQualifiers, new FunctionType( noQualifiers, true ) );
-
-                CompoundStmt * compound = new CompoundStmt( noLabels );
-                compound->push_back( makeAccStatement( acceptables, index, "is_dtor" , detectIsDtor( clause.target.function )                                    , indexer ) );
-                compound->push_back( makeAccStatement( acceptables, index, "func"    , new CastExpr( clause.target.function, fptr_t )                            , indexer ) );
-                compound->push_back( makeAccStatement( acceptables, index, "monitors", new VariableExpr( monitors )                                              , indexer ) );
-                compound->push_back( makeAccStatement( acceptables, index, "count"   , new ConstantExpr( Constant::from_ulong( clause.target.arguments.size() ) ), indexer ) );
 
                 stmt->push_back( new IfStmt(
                         noLabels,
                         safeCond( clause.condition ),
-                        compound,
+                        new CompoundStmt({
+                                makeAccStatement( acceptables, index, "is_dtor", detectIsDtor( clause.target.function )                                    , indexer ),
+                                makeAccStatement( acceptables, index, "func"   , new CastExpr( clause.target.function, fptr_t )                            , indexer ),
+                                makeAccStatement( acceptables, index, "list"   , new VariableExpr( monitors )                                              , indexer ),
+                                makeAccStatement( acceptables, index, "size"   , new ConstantExpr( Constant::from_ulong( clause.target.arguments.size() ) ), indexer ),
+                                setter->clone()
+                        }),
                         nullptr
                 ));
@@ -370 +434 @@
                 bool has_else,
                 Expression *& else_cond,
+                Statement * setter,
                 CompoundStmt * stmt
         ) {
@@ -389 +454 @@
                                 noLabels,
                                 safeCond( time_cond ),
-                                new ExprStmt(
-                                        noLabels,
-                                        makeOpAssign(
-                                                new VariableExpr( timeout ),
-                                                time
-                                        )
-                                ),
+                                new CompoundStmt({
+                                        new ExprStmt(
+                                                noLabels,
+                                                makeOpAssign(
+                                                        new VariableExpr( timeout ),
+                                                        time
+                                                )
+                                        ),
+                                        setter->clone()
+                                }),
                                 nullptr
                         ));
@@ -406 +474 @@
                                 noLabels,
                                 safeCond( else_cond ),
-                                new ExprStmt(
-                                        noLabels,
-                                        makeOpAssign(
-                                                new VariableExpr( timeout ),
-                                                new ConstantExpr( Constant::from_ulong( 0 ) )
-                                        )
-                                ),
+                                new CompoundStmt({
+                                        new ExprStmt(
+                                                noLabels,
+                                                makeOpAssign(
+                                                        new VariableExpr( timeout ),
+                                                        new ConstantExpr( Constant::from_ulong( 0 ) )
+                                                )
+                                        ),
+                                        setter->clone()
+                                }),
                                 nullptr
                         ));
@@ -418 +489 @@
                         else_cond = nullptr;
                 }
+
+                delete setter;
 
                 return new VariableExpr( timeout );
@@ -428 +501 @@
                 CompoundStmt * stmt
         ) {
-                ObjectDecl * decl = ObjectDecl::newObject(
-                        namer_ret.newName(),
+                ObjectDecl * index = ObjectDecl::newObject(
+                        namer_idx.newName(),
                         new BasicType(
                                 noQualifiers,
-                                BasicType::LongLongUnsignedInt
+                                BasicType::ShortSignedInt
                         ),
                         new SingleInit(
-                                new UntypedExpr(
-                                        VariableExpr::functionPointer( decl_waitfor ),
-                                        {
-                                                new ConstantExpr( Constant::from_ulong( count ) ),
-                                                new VariableExpr( acceptables ),
-                                                timeout
-                                        }
-                                )
+                                new ConstantExpr( Constant::from_int( -1 ) )
                         )
                 );
 
-                stmt->push_back( new DeclStmt( noLabels, decl ) );
-
-                return new VariableExpr( decl );
+                stmt->push_back( new DeclStmt( noLabels, index ) );
+
+                ObjectDecl * mask = ObjectDecl::newObject(
+                        namer_msk.newName(),
+                        new StructInstType(
+                                noQualifiers,
+                                decl_mask
+                        ),
+                        new ListInit({
+                                new SingleInit( new AddressExpr( new VariableExpr( index ) ) ),
+                                new SingleInit( new VariableExpr( acceptables ) ),
+                                new SingleInit( new ConstantExpr( Constant::from_ulong( count ) ) )
+                        })
+                );
+
+                stmt->push_back( new DeclStmt( noLabels, mask ) );
+
+                stmt->push_back( new ExprStmt(
+                        noLabels,
+                        new ApplicationExpr(
+                                VariableExpr::functionPointer( decl_waitfor ),
+                                {
+                                        new CastExpr(
+                                                new VariableExpr( mask ),
+                                                new ReferenceType(
+                                                        noQualifiers,
+                                                        new StructInstType(
+                                                                noQualifiers,
+                                                                decl_mask
+                                                        )
+                                                )
+                                        ),
+                                        timeout
+                                }
+                        )
+                ));
+
+                return new VariableExpr( index );
         }
 

src/libcfa/concurrency/monitor

@@ -105 +105 @@
 
 struct __acceptable_t {
-        __monitor_group_t monitors;
+        __monitor_group_t;
         bool is_dtor;
 };

src/libcfa/concurrency/monitor.c

@@ -280 +280 @@
         lock_all( monitors, locks, count );
 
-        // DON'T unlock, ask the kernel to do it
-
-        // Save monitor state
-        save_recursion( monitors, recursions, count );
-
         // Find the next thread(s) to run
         unsigned short thread_count = 0;
@@ -297 +292 @@
                 thread_count = insert_unique( threads, thread_count, new_owner );
         }
+
+        // Save monitor state
+        save_recursion( monitors, recursions, count );
 
         // Everything is ready to go to sleep
@@ -634 +632 @@
         // For all acceptable functions check if this is the current function.
         for( short i = 0; i < count; i++, it++ ) {
-                if( it->monitors == group ) {
+                if( *it == group ) {
                         *this->mask.accepted = i;
                         return true;
@@ -658 +656 @@
                 for( __acceptable_t * it = mask.clauses; it != end; it++, i++ ) {
                         // Check if we have a match
-                        if( it->monitors == (*thrd_it)->monitors ) {
+                        if( *it == (*thrd_it)->monitors ) {
 
                                 // If we have a match return it
@@ -673 +671 @@
         short max = 0;
         for( int i = 0; i < mask.size; i++ ) {
-                max += mask.clauses[i].monitors.size;
+                max += mask.clauses[i].size;
         }
         return max;