Changes in / [212c421e:f22b7aef]

Location:

src

Files:

• Concurrency/Keywords.cc (modified) (7 diffs)
• Parser/ParseNode.h (modified) (1 diff)
• Parser/StatementNode.cc (modified) (2 diffs)
• Parser/parser.yy (modified) (5 diffs)
• SynTree/Mutator.cc (modified) (61 diffs)
• SynTree/Mutator.h (modified) (1 diff)
• SynTree/Statement.cc (modified) (1 diff)
• SynTree/Statement.h (modified) (2 diffs)
• SynTree/SynTree.h (modified) (1 diff)
• SynTree/Visitor.cc (modified) (1 diff)
• SynTree/Visitor.h (modified) (1 diff)
• libcfa/concurrency/invoke.h (modified) (3 diffs)
• libcfa/concurrency/kernel.c (modified) (4 diffs)
• libcfa/concurrency/monitor (modified) (4 diffs)
• libcfa/concurrency/monitor.c (modified) (19 diffs)
• libcfa/concurrency/preemption.c (modified) (2 diffs)
• tests/preempt_longrun/stack.c (modified) (1 diff)
• tests/sched-ext.c (deleted)
• tests/sched-int-disjoint.c (modified) (2 diffs)
• tests/sched-int-wait.c (modified) (2 diffs)

src/Concurrency/Keywords.cc

@@ -201 +201 @@
                 std::list<DeclarationWithType*> findMutexArgs( FunctionDecl* );
                 void validate( DeclarationWithType * );
-                void addStatments( FunctionDecl* func, CompoundStmt *, const std::list<DeclarationWithType * > &);
+                void addStatments( CompoundStmt *, const std::list<DeclarationWithType * > &);
 
                 static void implement( std::list< Declaration * > & translationUnit ) {
@@ -211 +211 @@
                 StructDecl* monitor_decl = nullptr;
                 StructDecl* guard_decl = nullptr;
-
-                static std::unique_ptr< Type > generic_func;
         };
-
-        std::unique_ptr< Type > MutexKeyword::generic_func = std::unique_ptr< Type >(
-                new FunctionType(
-                        noQualifiers,
-                        true
-                )
-        );
 
         //-----------------------------------------------------------------------------
@@ -404 +395 @@
         // Mutex keyword implementation
         //=============================================================================================
-
         void MutexKeyword::visit(FunctionDecl* decl) {
                 Visitor::visit(decl);
@@ -421 +411 @@
                 if( !guard_decl ) throw SemanticError( "mutex keyword requires monitors to be in scope, add #include <monitor>", decl );
 
-                addStatments( decl, body, mutexArgs );
+                addStatments( body, mutexArgs );
         }
 
@@ -468 +458 @@
         }
 
-        void MutexKeyword::addStatments( FunctionDecl* func, CompoundStmt * body, const std::list<DeclarationWithType * > & args ) {
+        void MutexKeyword::addStatments( CompoundStmt * body, const std::list<DeclarationWithType * > & args ) {
                 ObjectDecl * monitors = new ObjectDecl(
                         "__monitors",
@@ -499 +489 @@
                 );
 
-                assert(generic_func);
-
                 //in reverse order :
-                // monitor_guard_t __guard = { __monitors, #, func };
+                // monitor_guard_t __guard = { __monitors, # };
                 body->push_front(
                         new DeclStmt( noLabels, new ObjectDecl(
@@ -516 +504 @@
                                         {
                                                 new SingleInit( new VariableExpr( monitors ) ),
-                                                new SingleInit( new ConstantExpr( Constant::from_ulong( args.size() ) ) ),
-                                                new SingleInit( new CastExpr( new VariableExpr( func ), generic_func->clone() ) )
+                                                new SingleInit( new ConstantExpr( Constant::from_ulong( args.size() ) ) )
                                         },
                                         noDesignators,

src/Parser/ParseNode.h

@@ -414 +414 @@
 Statement * build_compound( StatementNode * first );
 Statement * build_asmstmt( bool voltile, ConstantExpr * instruction, ExpressionNode * output = nullptr, ExpressionNode * input = nullptr, ExpressionNode * clobber = nullptr, LabelNode * gotolabels = nullptr );
-WaitForStmt * build_waitfor( ExpressionNode * target, StatementNode * stmt, ExpressionNode * when );
-WaitForStmt * build_waitfor( ExpressionNode * target, StatementNode * stmt, ExpressionNode * when, WaitForStmt * existing );
-WaitForStmt * build_waitfor_timeout( ExpressionNode * timeout, StatementNode * stmt, ExpressionNode * when );
-WaitForStmt * build_waitfor_timeout( ExpressionNode * timeout, StatementNode * stmt, ExpressionNode * when, StatementNode * else_stmt, ExpressionNode * else_when );
 
 //##############################################################################

src/Parser/StatementNode.cc

@@ -93 +93 @@
                 elseb = branches.front();
         } // if
-
+        
         std::list< Statement * > init;
         if ( ctl->init != 0 ) {
@@ -207 +207 @@
 }
 
-WaitForStmt * build_waitfor( ExpressionNode * targetExpr, StatementNode * stmt, ExpressionNode * when ) {
-        auto node = new WaitForStmt();
-
-        WaitForStmt::Target target;
-        target.function = maybeBuild<Expression>( targetExpr );
-        buildMoveList< Expression >( targetExpr, target.arguments );
-        delete targetExpr;
-
-        node->clauses.push_back( WaitForStmt::Clause{
-                target,
-                maybeMoveBuild<Statement >( stmt ),
-                maybeMoveBuild<Expression>( when )
-        });
-
-        return node;
-}
-
-WaitForStmt * build_waitfor( ExpressionNode * targetExpr, StatementNode * stmt, ExpressionNode * when, WaitForStmt * node ) {
-        WaitForStmt::Target target;
-
-        target.function = maybeBuild<Expression>( targetExpr );
-        buildMoveList< Expression >( targetExpr, target.arguments );
-        delete targetExpr;
-
-        node->clauses.push_back( WaitForStmt::Clause{
-                std::move( target ),
-                maybeMoveBuild<Statement >( stmt ),
-                maybeMoveBuild<Expression>( when )
-        });
-
-        return node;
-}
-
-WaitForStmt * build_waitfor_timeout( ExpressionNode * timeout, StatementNode * stmt, ExpressionNode * when ) {
-        auto node = new WaitForStmt();
-
-        if( timeout ) {
-                node->timeout.time      = maybeMoveBuild<Expression>( timeout );
-                node->timeout.statement = maybeMoveBuild<Statement >( stmt    );
-                node->timeout.condition = maybeMoveBuild<Expression>( when    );
-        }
-        else {
-                node->orelse.statement  = maybeMoveBuild<Statement >( stmt    );
-                node->orelse.condition  = maybeMoveBuild<Expression>( when    );
-        }
-
-        return node;
-}
-
-WaitForStmt * build_waitfor_timeout( ExpressionNode * timeout, StatementNode * stmt, ExpressionNode * when,  StatementNode * else_stmt, ExpressionNode * else_when ) {
-        auto node = new WaitForStmt();
-
-        node->timeout.time      = maybeMoveBuild<Expression>( timeout );
-        node->timeout.statement = maybeMoveBuild<Statement >( stmt    );
-        node->timeout.condition = maybeMoveBuild<Expression>( when    );
-
-        node->orelse.statement = maybeMoveBuild<Statement >( else_stmt );
-        node->orelse.condition = maybeMoveBuild<Expression>( else_when );
-
-        return node;
-}
-
-// WaitForStmt::Target build_waitfor( const std::string * name, ExpressionNode * arguments ) {
-//       return WaitForStmt::Clause{
-
-//       };
-// }
-
 Statement *build_compound( StatementNode *first ) {
         CompoundStmt *cs = new CompoundStmt( noLabels );

src/Parser/parser.yy

@@ -97 +97 @@
         DeclarationNode::TypeClass tclass;
         StatementNode * sn;
-        WaitForStmt * wfs;
         ConstantExpr * constant;
         IfCtl * ifctl;
@@ -188 +187 @@
 %type<flag> asm_volatile_opt
 %type<en> handler_predicate_opt
-%type<en> when_clause_opt timeout
 
 // statements
@@ -194 +192 @@
 %type<sn> iteration_statement                   jump_statement
 %type<sn> with_statement                                exception_statement                     asm_statement
-%type<sn> waitfor_statement
+%type<sn> when_clause_opt                               waitfor_statement                       waitfor_clause                          waitfor                         timeout
 %type<sn> fall_through_opt                              fall_through
 %type<sn> statement                                             statement_list
@@ -204 +202 @@
 %type<sn> handler_clause                                finally_clause
 %type<catch_kind> handler_key
-%type<wfs> waitfor_clause
-%type<en> waitfor
 
 // declarations
@@ -983 +979 @@
 when_clause_opt:
         // empty
-                { $$ = nullptr; }
+                { $$ = nullptr; }                                                               // FIX ME
         | WHEN '(' comma_expression ')'
-                { $$ = $3; }
+                { $$ = nullptr; }                                                               // FIX ME
         ;
 
 waitfor:
         WAITFOR '(' identifier ')'
-                {
-                        $$ = new ExpressionNode( new NameExpr( *$3 ) );
-                        delete $3;
-                }
+                { $$ = nullptr; }                                                               // FIX ME
         | WAITFOR '(' identifier ',' argument_expression_list ')'
-                {
-                        $$ = new ExpressionNode( new NameExpr( *$3 ) );
-                        $$->set_last( $5 );
-                        delete $3;
-                }
+                { $$ = nullptr; }                                                               // FIX ME
         ;
 
 timeout:
         TIMEOUT '(' comma_expression ')'
-                { $$ = $3; }
+                { $$ = nullptr; }                                                               // FIX ME
         ;
 
 waitfor_clause:
         when_clause_opt waitfor statement %prec THEN
-                { $$ = build_waitfor( $2, $3, $1 ); }
+                { $$ = nullptr; }                                                               // FIX ME
         | when_clause_opt waitfor statement WOR waitfor_clause
-                { $$ = build_waitfor( $2, $3, $1, $5 ); }
+                { $$ = nullptr; }                                                               // FIX ME
         | when_clause_opt timeout statement %prec THEN
-                { $$ = build_waitfor_timeout( $2, $3, $1 ); }
+                { $$ = nullptr; }                                                               // FIX ME
         | when_clause_opt ELSE statement
-                { $$ = build_waitfor_timeout( nullptr, $3, $1 ); }
+                { $$ = nullptr; }                                                               // FIX ME
         | when_clause_opt timeout statement WOR when_clause_opt ELSE statement
-                { $$ = build_waitfor_timeout( $2, $3, $1, $7, $5 ); }
+                { $$ = nullptr; }                                                               // FIX ME
         ;
 
 waitfor_statement:
         when_clause_opt waitfor statement %prec THEN
-                { $$ = new StatementNode( build_waitfor( $2, $3, $1 ) ); }
+                { $$ = nullptr; }                                                               // FIX ME
         | when_clause_opt waitfor statement WOR waitfor_clause
-                { $$ = new StatementNode( build_waitfor( $2, $3, $1, $5 ) ); }
+                { $$ = nullptr; }                                                               // FIX ME
         ;
 

src/SynTree/Mutator.cc

@@ -32 +32 @@
 Mutator::~Mutator() {}
 
-DeclarationWithType * Mutator::mutate( ObjectDecl *objectDecl ) {
+DeclarationWithType *Mutator::mutate( ObjectDecl *objectDecl ) {
         objectDecl->set_type( maybeMutate( objectDecl->get_type(), *this ) );
         objectDecl->set_init( maybeMutate( objectDecl->get_init(), *this ) );
@@ -39 +39 @@
 }
 
-DeclarationWithType * Mutator::mutate( FunctionDecl *functionDecl ) {
+DeclarationWithType *Mutator::mutate( FunctionDecl *functionDecl ) {
         functionDecl->set_functionType( maybeMutate( functionDecl->get_functionType(), *this ) );
         functionDecl->set_statements( maybeMutate( functionDecl->get_statements(), *this ) );
@@ -45 +45 @@
 }
 
-Declaration * Mutator::handleAggregateDecl( AggregateDecl *aggregateDecl ) {
+Declaration *Mutator::handleAggregateDecl( AggregateDecl *aggregateDecl ) {
         mutateAll( aggregateDecl->get_parameters(), *this );
         mutateAll( aggregateDecl->get_members(), *this );
@@ -51 +51 @@
 }
 
-Declaration * Mutator::mutate( StructDecl *aggregateDecl ) {
+Declaration *Mutator::mutate( StructDecl *aggregateDecl ) {
         handleAggregateDecl( aggregateDecl );
         return aggregateDecl;
 }
 
-Declaration * Mutator::mutate( UnionDecl *aggregateDecl ) {
+Declaration *Mutator::mutate( UnionDecl *aggregateDecl ) {
         handleAggregateDecl( aggregateDecl );
         return aggregateDecl;
 }
 
-Declaration * Mutator::mutate( EnumDecl *aggregateDecl ) {
+Declaration *Mutator::mutate( EnumDecl *aggregateDecl ) {
         handleAggregateDecl( aggregateDecl );
         return aggregateDecl;
 }
 
-Declaration * Mutator::mutate( TraitDecl *aggregateDecl ) {
+Declaration *Mutator::mutate( TraitDecl *aggregateDecl ) {
         handleAggregateDecl( aggregateDecl );
         return aggregateDecl;
 }
 
-Declaration * Mutator::handleNamedTypeDecl( NamedTypeDecl *typeDecl ) {
+Declaration *Mutator::handleNamedTypeDecl( NamedTypeDecl *typeDecl ) {
         mutateAll( typeDecl->get_parameters(), *this );
         mutateAll( typeDecl->get_assertions(), *this );
@@ -78 +78 @@
 }
 
-TypeDecl * Mutator::mutate( TypeDecl *typeDecl ) {
+TypeDecl *Mutator::mutate( TypeDecl *typeDecl ) {
         handleNamedTypeDecl( typeDecl );
         typeDecl->set_init( maybeMutate( typeDecl->get_init(), *this ) );
@@ -84 +84 @@
 }
 
-Declaration * Mutator::mutate( TypedefDecl *typeDecl ) {
+Declaration *Mutator::mutate( TypedefDecl *typeDecl ) {
         handleNamedTypeDecl( typeDecl );
         return typeDecl;
 }
 
-AsmDecl * Mutator::mutate( AsmDecl *asmDecl ) {
+AsmDecl *Mutator::mutate( AsmDecl *asmDecl ) {
         asmDecl->set_stmt( maybeMutate( asmDecl->get_stmt(), *this ) );
         return asmDecl;
@@ -95 +95 @@
 
 
-CompoundStmt * Mutator::mutate( CompoundStmt *compoundStmt ) {
+CompoundStmt *Mutator::mutate( CompoundStmt *compoundStmt ) {
         mutateAll( compoundStmt->get_kids(), *this );
         return compoundStmt;
 }
 
-Statement * Mutator::mutate( ExprStmt *exprStmt ) {
+Statement *Mutator::mutate( ExprStmt *exprStmt ) {
         exprStmt->set_expr( maybeMutate( exprStmt->get_expr(), *this ) );
         return exprStmt;
 }
 
-Statement * Mutator::mutate( AsmStmt *asmStmt ) {
+Statement *Mutator::mutate( AsmStmt *asmStmt ) {
         asmStmt->set_instruction( maybeMutate( asmStmt->get_instruction(), *this ) );
         mutateAll( asmStmt->get_output(), *this );
@@ -113 +113 @@
 }
 
-Statement * Mutator::mutate( IfStmt *ifStmt ) {
+Statement *Mutator::mutate( IfStmt *ifStmt ) {
         mutateAll( ifStmt->get_initialization(), *this );
         ifStmt->set_condition( maybeMutate( ifStmt->get_condition(), *this ) );
@@ -121 +121 @@
 }
 
-Statement * Mutator::mutate( WhileStmt *whileStmt ) {
+Statement *Mutator::mutate( WhileStmt *whileStmt ) {
         whileStmt->set_condition( maybeMutate( whileStmt->get_condition(), *this ) );
         whileStmt->set_body( maybeMutate( whileStmt->get_body(), *this ) );
@@ -127 +127 @@
 }
 
-Statement * Mutator::mutate( ForStmt *forStmt ) {
+Statement *Mutator::mutate( ForStmt *forStmt ) {
         mutateAll( forStmt->get_initialization(), *this );
         forStmt->set_condition( maybeMutate( forStmt->get_condition(), *this ) );
@@ -135 +135 @@
 }
 
-Statement * Mutator::mutate( SwitchStmt *switchStmt ) {
+Statement *Mutator::mutate( SwitchStmt *switchStmt ) {
         switchStmt->set_condition( maybeMutate( switchStmt->get_condition(), *this ) );
         mutateAll( switchStmt->get_statements(), *this );
@@ -141 +141 @@
 }
 
-Statement * Mutator::mutate( CaseStmt *caseStmt ) {
+Statement *Mutator::mutate( CaseStmt *caseStmt ) {
         caseStmt->set_condition( maybeMutate( caseStmt->get_condition(), *this ) );
         mutateAll (caseStmt->get_statements(), *this );
@@ -148 +148 @@
 }
 
-Statement * Mutator::mutate( BranchStmt *branchStmt ) {
+Statement *Mutator::mutate( BranchStmt *branchStmt ) {
         return branchStmt;
 }
 
-Statement * Mutator::mutate( ReturnStmt *returnStmt ) {
+Statement *Mutator::mutate( ReturnStmt *returnStmt ) {
         returnStmt->set_expr( maybeMutate( returnStmt->get_expr(), *this ) );
         return returnStmt;
 }
 
-Statement * Mutator::mutate( ThrowStmt *throwStmt ) {
+Statement *Mutator::mutate( ThrowStmt *throwStmt ) {
         throwStmt->set_expr( maybeMutate( throwStmt->get_expr(), *this ) );
         throwStmt->set_target( maybeMutate( throwStmt->get_target(), *this ) );
@@ -163 +163 @@
 }
 
-Statement * Mutator::mutate( TryStmt *tryStmt ) {
+Statement *Mutator::mutate( TryStmt *tryStmt ) {
         tryStmt->set_block( maybeMutate( tryStmt->get_block(), *this ) );
         mutateAll( tryStmt->get_catchers(), *this );
@@ -170 +170 @@
 }
 
-Statement * Mutator::mutate( CatchStmt *catchStmt ) {
+Statement *Mutator::mutate( CatchStmt *catchStmt ) {
         catchStmt->set_decl( maybeMutate( catchStmt->get_decl(), *this ) );
         catchStmt->set_cond( maybeMutate( catchStmt->get_cond(), *this ) );
@@ -177 +177 @@
 }
 
-Statement * Mutator::mutate( FinallyStmt *finalStmt ) {
+Statement *Mutator::mutate( FinallyStmt *finalStmt ) {
         finalStmt->set_block( maybeMutate( finalStmt->get_block(), *this ) );
         return finalStmt;
 }
 
-Statement * Mutator::mutate( WaitForStmt *waitforStmt ) {
-        for( auto & clause : waitforStmt->clauses ) {
-                clause.target.function = maybeMutate( clause.target.function, *this );
-                mutateAll( clause.target.arguments, *this );
-
-                clause.statement = maybeMutate( clause.statement, *this );
-                clause.condition = maybeMutate( clause.condition, *this );
-        }
-
-        waitforStmt->timeout.time      = maybeMutate( waitforStmt->timeout.time, *this );
-        waitforStmt->timeout.statement = maybeMutate( waitforStmt->timeout.statement, *this );
-        waitforStmt->timeout.condition = maybeMutate( waitforStmt->timeout.condition, *this );
-        waitforStmt->orelse.statement  = maybeMutate( waitforStmt->orelse.statement, *this );
-        waitforStmt->orelse.condition  = maybeMutate( waitforStmt->orelse.condition, *this );
-
-        return waitforStmt;
-}
-
-NullStmt * Mutator::mutate( NullStmt *nullStmt ) {
+NullStmt *Mutator::mutate( NullStmt *nullStmt ) {
         return nullStmt;
 }
 
-Statement * Mutator::mutate( DeclStmt *declStmt ) {
+Statement *Mutator::mutate( DeclStmt *declStmt ) {
         declStmt->set_decl( maybeMutate( declStmt->get_decl(), *this ) );
         return declStmt;
 }
 
-Statement * Mutator::mutate( ImplicitCtorDtorStmt *impCtorDtorStmt ) {
+Statement *Mutator::mutate( ImplicitCtorDtorStmt *impCtorDtorStmt ) {
         impCtorDtorStmt->set_callStmt( maybeMutate( impCtorDtorStmt->get_callStmt(), *this ) );
         return impCtorDtorStmt;
@@ -215 +197 @@
 
 
-Expression * Mutator::mutate( ApplicationExpr *applicationExpr ) {
+Expression *Mutator::mutate( ApplicationExpr *applicationExpr ) {
         applicationExpr->set_env( maybeMutate( applicationExpr->get_env(), *this ) );
         applicationExpr->set_result( maybeMutate( applicationExpr->get_result(), *this ) );
@@ -223 +205 @@
 }
 
-Expression * Mutator::mutate( UntypedExpr *untypedExpr ) {
+Expression *Mutator::mutate( UntypedExpr *untypedExpr ) {
         untypedExpr->set_env( maybeMutate( untypedExpr->get_env(), *this ) );
         untypedExpr->set_result( maybeMutate( untypedExpr->get_result(), *this ) );
@@ -230 +212 @@
 }
 
-Expression * Mutator::mutate( NameExpr *nameExpr ) {
+Expression *Mutator::mutate( NameExpr *nameExpr ) {
         nameExpr->set_env( maybeMutate( nameExpr->get_env(), *this ) );
         nameExpr->set_result( maybeMutate( nameExpr->get_result(), *this ) );
@@ -236 +218 @@
 }
 
-Expression * Mutator::mutate( AddressExpr *addressExpr ) {
+Expression *Mutator::mutate( AddressExpr *addressExpr ) {
         addressExpr->set_env( maybeMutate( addressExpr->get_env(), *this ) );
         addressExpr->set_result( maybeMutate( addressExpr->get_result(), *this ) );
@@ -243 +225 @@
 }
 
-Expression * Mutator::mutate( LabelAddressExpr *labelAddressExpr ) {
+Expression *Mutator::mutate( LabelAddressExpr *labelAddressExpr ) {
         labelAddressExpr->set_env( maybeMutate( labelAddressExpr->get_env(), *this ) );
         labelAddressExpr->set_result( maybeMutate( labelAddressExpr->get_result(), *this ) );
@@ -250 +232 @@
 }
 
-Expression * Mutator::mutate( CastExpr *castExpr ) {
+Expression *Mutator::mutate( CastExpr *castExpr ) {
         castExpr->set_env( maybeMutate( castExpr->get_env(), *this ) );
         castExpr->set_result( maybeMutate( castExpr->get_result(), *this ) );
@@ -257 +239 @@
 }
 
-Expression * Mutator::mutate( VirtualCastExpr *castExpr ) {
+Expression *Mutator::mutate( VirtualCastExpr *castExpr ) {
         castExpr->set_env( maybeMutate( castExpr->get_env(), *this ) );
         castExpr->set_result( maybeMutate( castExpr->get_result(), *this ) );
@@ -264 +246 @@
 }
 
-Expression * Mutator::mutate( UntypedMemberExpr *memberExpr ) {
+Expression *Mutator::mutate( UntypedMemberExpr *memberExpr ) {
         memberExpr->set_env( maybeMutate( memberExpr->get_env(), *this ) );
         memberExpr->set_result( maybeMutate( memberExpr->get_result(), *this ) );
@@ -272 +254 @@
 }
 
-Expression * Mutator::mutate( MemberExpr *memberExpr ) {
+Expression *Mutator::mutate( MemberExpr *memberExpr ) {
         memberExpr->set_env( maybeMutate( memberExpr->get_env(), *this ) );
         memberExpr->set_result( maybeMutate( memberExpr->get_result(), *this ) );
@@ -279 +261 @@
 }
 
-Expression * Mutator::mutate( VariableExpr *variableExpr ) {
+Expression *Mutator::mutate( VariableExpr *variableExpr ) {
         variableExpr->set_env( maybeMutate( variableExpr->get_env(), *this ) );
         variableExpr->set_result( maybeMutate( variableExpr->get_result(), *this ) );
@@ -285 +267 @@
 }
 
-Expression * Mutator::mutate( ConstantExpr *constantExpr ) {
+Expression *Mutator::mutate( ConstantExpr *constantExpr ) {
         constantExpr->set_env( maybeMutate( constantExpr->get_env(), *this ) );
         constantExpr->set_result( maybeMutate( constantExpr->get_result(), *this ) );
@@ -292 +274 @@
 }
 
-Expression * Mutator::mutate( SizeofExpr *sizeofExpr ) {
+Expression *Mutator::mutate( SizeofExpr *sizeofExpr ) {
         sizeofExpr->set_env( maybeMutate( sizeofExpr->get_env(), *this ) );
         sizeofExpr->set_result( maybeMutate( sizeofExpr->get_result(), *this ) );
@@ -303 +285 @@
 }
 
-Expression * Mutator::mutate( AlignofExpr *alignofExpr ) {
+Expression *Mutator::mutate( AlignofExpr *alignofExpr ) {
         alignofExpr->set_env( maybeMutate( alignofExpr->get_env(), *this ) );
         alignofExpr->set_result( maybeMutate( alignofExpr->get_result(), *this ) );
@@ -314 +296 @@
 }
 
-Expression * Mutator::mutate( UntypedOffsetofExpr *offsetofExpr ) {
+Expression *Mutator::mutate( UntypedOffsetofExpr *offsetofExpr ) {
         offsetofExpr->set_env( maybeMutate( offsetofExpr->get_env(), *this ) );
         offsetofExpr->set_result( maybeMutate( offsetofExpr->get_result(), *this ) );
@@ -321 +303 @@
 }
 
-Expression * Mutator::mutate( OffsetofExpr *offsetofExpr ) {
+Expression *Mutator::mutate( OffsetofExpr *offsetofExpr ) {
         offsetofExpr->set_env( maybeMutate( offsetofExpr->get_env(), *this ) );
         offsetofExpr->set_result( maybeMutate( offsetofExpr->get_result(), *this ) );
@@ -329 +311 @@
 }
 
-Expression * Mutator::mutate( OffsetPackExpr *offsetPackExpr ) {
+Expression *Mutator::mutate( OffsetPackExpr *offsetPackExpr ) {
         offsetPackExpr->set_env( maybeMutate( offsetPackExpr->get_env(), *this ) );
         offsetPackExpr->set_result( maybeMutate( offsetPackExpr->get_result(), *this ) );
@@ -336 +318 @@
 }
 
-Expression * Mutator::mutate( AttrExpr *attrExpr ) {
+Expression *Mutator::mutate( AttrExpr *attrExpr ) {
         attrExpr->set_env( maybeMutate( attrExpr->get_env(), *this ) );
         attrExpr->set_result( maybeMutate( attrExpr->get_result(), *this ) );
@@ -347 +329 @@
 }
 
-Expression * Mutator::mutate( LogicalExpr *logicalExpr ) {
+Expression *Mutator::mutate( LogicalExpr *logicalExpr ) {
         logicalExpr->set_env( maybeMutate( logicalExpr->get_env(), *this ) );
         logicalExpr->set_result( maybeMutate( logicalExpr->get_result(), *this ) );
@@ -355 +337 @@
 }
 
-Expression * Mutator::mutate( ConditionalExpr *conditionalExpr ) {
+Expression *Mutator::mutate( ConditionalExpr *conditionalExpr ) {
         conditionalExpr->set_env( maybeMutate( conditionalExpr->get_env(), *this ) );
         conditionalExpr->set_result( maybeMutate( conditionalExpr->get_result(), *this ) );
@@ -364 +346 @@
 }
 
-Expression * Mutator::mutate( CommaExpr *commaExpr ) {
+Expression *Mutator::mutate( CommaExpr *commaExpr ) {
         commaExpr->set_env( maybeMutate( commaExpr->get_env(), *this ) );
         commaExpr->set_result( maybeMutate( commaExpr->get_result(), *this ) );
@@ -372 +354 @@
 }
 
-Expression * Mutator::mutate( TypeExpr *typeExpr ) {
+Expression *Mutator::mutate( TypeExpr *typeExpr ) {
         typeExpr->set_env( maybeMutate( typeExpr->get_env(), *this ) );
         typeExpr->set_result( maybeMutate( typeExpr->get_result(), *this ) );
@@ -379 +361 @@
 }
 
-Expression * Mutator::mutate( AsmExpr *asmExpr ) {
+Expression *Mutator::mutate( AsmExpr *asmExpr ) {
         asmExpr->set_env( maybeMutate( asmExpr->get_env(), *this ) );
         asmExpr->set_inout( maybeMutate( asmExpr->get_inout(), *this ) );
@@ -404 +386 @@
 }
 
-Expression * Mutator::mutate( CompoundLiteralExpr *compLitExpr ) {
+Expression *Mutator::mutate( CompoundLiteralExpr *compLitExpr ) {
         compLitExpr->set_env( maybeMutate( compLitExpr->get_env(), *this ) );
         compLitExpr->set_result( maybeMutate( compLitExpr->get_result(), *this ) );
@@ -411 +393 @@
 }
 
-Expression * Mutator::mutate( RangeExpr *rangeExpr ) {
+Expression *Mutator::mutate( RangeExpr *rangeExpr ) {
         rangeExpr->set_env( maybeMutate( rangeExpr->get_env(), *this ) );
         rangeExpr->set_low( maybeMutate( rangeExpr->get_low(), *this ) );
@@ -418 +400 @@
 }
 
-Expression * Mutator::mutate( UntypedTupleExpr *tupleExpr ) {
+Expression *Mutator::mutate( UntypedTupleExpr *tupleExpr ) {
         tupleExpr->set_env( maybeMutate( tupleExpr->get_env(), *this ) );
         tupleExpr->set_result( maybeMutate( tupleExpr->get_result(), *this ) );
@@ -425 +407 @@
 }
 
-Expression * Mutator::mutate( TupleExpr *tupleExpr ) {
+Expression *Mutator::mutate( TupleExpr *tupleExpr ) {
         tupleExpr->set_env( maybeMutate( tupleExpr->get_env(), *this ) );
         tupleExpr->set_result( maybeMutate( tupleExpr->get_result(), *this ) );
@@ -432 +414 @@
 }
 
-Expression * Mutator::mutate( TupleIndexExpr *tupleExpr ) {
+Expression *Mutator::mutate( TupleIndexExpr *tupleExpr ) {
         tupleExpr->set_env( maybeMutate( tupleExpr->get_env(), *this ) );
         tupleExpr->set_result( maybeMutate( tupleExpr->get_result(), *this ) );
@@ -439 +421 @@
 }
 
-Expression * Mutator::mutate( TupleAssignExpr *assignExpr ) {
+Expression *Mutator::mutate( TupleAssignExpr *assignExpr ) {
         assignExpr->set_env( maybeMutate( assignExpr->get_env(), *this ) );
         assignExpr->set_result( maybeMutate( assignExpr->get_result(), *this ) );
@@ -446 +428 @@
 }
 
-Expression * Mutator::mutate( StmtExpr *stmtExpr ) {
+Expression *Mutator::mutate( StmtExpr *stmtExpr ) {
         stmtExpr->set_env( maybeMutate( stmtExpr->get_env(), *this ) );
         stmtExpr->set_result( maybeMutate( stmtExpr->get_result(), *this ) );
@@ -455 +437 @@
 }
 
-Expression * Mutator::mutate( UniqueExpr *uniqueExpr ) {
+Expression *Mutator::mutate( UniqueExpr *uniqueExpr ) {
         uniqueExpr->set_env( maybeMutate( uniqueExpr->get_env(), *this ) );
         uniqueExpr->set_result( maybeMutate( uniqueExpr->get_result(), *this ) );
@@ -462 +444 @@
 }
 
-Expression * Mutator::mutate( UntypedInitExpr * initExpr ) {
+Expression *Mutator::mutate( UntypedInitExpr * initExpr ) {
         initExpr->set_env( maybeMutate( initExpr->get_env(), *this ) );
         initExpr->set_result( maybeMutate( initExpr->get_result(), *this ) );
@@ -470 +452 @@
 }
 
-Expression * Mutator::mutate( InitExpr * initExpr ) {
+Expression *Mutator::mutate( InitExpr * initExpr ) {
         initExpr->set_env( maybeMutate( initExpr->get_env(), *this ) );
         initExpr->set_result( maybeMutate( initExpr->get_result(), *this ) );
@@ -479 +461 @@
 
 
-Type * Mutator::mutate( VoidType *voidType ) {
+Type *Mutator::mutate( VoidType *voidType ) {
         mutateAll( voidType->get_forall(), *this );
         return voidType;
 }
 
-Type * Mutator::mutate( BasicType *basicType ) {
+Type *Mutator::mutate( BasicType *basicType ) {
         mutateAll( basicType->get_forall(), *this );
         return basicType;
 }
 
-Type * Mutator::mutate( PointerType *pointerType ) {
+Type *Mutator::mutate( PointerType *pointerType ) {
         mutateAll( pointerType->get_forall(), *this );
         pointerType->set_base( maybeMutate( pointerType->get_base(), *this ) );
@@ -495 +477 @@
 }
 
-Type * Mutator::mutate( ArrayType *arrayType ) {
+Type *Mutator::mutate( ArrayType *arrayType ) {
         mutateAll( arrayType->get_forall(), *this );
         arrayType->set_dimension( maybeMutate( arrayType->get_dimension(), *this ) );
@@ -502 +484 @@
 }
 
-Type * Mutator::mutate( ReferenceType * refType ) {
+Type *Mutator::mutate( ReferenceType *refType ) {
         mutateAll( refType->get_forall(), *this );
         refType->set_base( maybeMutate( refType->get_base(), *this ) );
@@ -508 +490 @@
 }
 
-Type * Mutator::mutate( FunctionType * functionType ) {
+Type *Mutator::mutate( FunctionType *functionType ) {
         mutateAll( functionType->get_forall(), *this );
         mutateAll( functionType->get_returnVals(), *this );
@@ -515 +497 @@
 }
 
-Type * Mutator::handleReferenceToType( ReferenceToType *aggregateUseType ) {
+Type *Mutator::handleReferenceToType( ReferenceToType *aggregateUseType ) {
         mutateAll( aggregateUseType->get_forall(), *this );
         mutateAll( aggregateUseType->get_parameters(), *this );
@@ -521 +503 @@
 }
 
-Type * Mutator::mutate( StructInstType *aggregateUseType ) {
+Type *Mutator::mutate( StructInstType *aggregateUseType ) {
         handleReferenceToType( aggregateUseType );
         return aggregateUseType;
 }
 
-Type * Mutator::mutate( UnionInstType *aggregateUseType ) {
+Type *Mutator::mutate( UnionInstType *aggregateUseType ) {
         handleReferenceToType( aggregateUseType );
         return aggregateUseType;
 }
 
-Type * Mutator::mutate( EnumInstType *aggregateUseType ) {
+Type *Mutator::mutate( EnumInstType *aggregateUseType ) {
         handleReferenceToType( aggregateUseType );
         return aggregateUseType;
 }
 
-Type * Mutator::mutate( TraitInstType *aggregateUseType ) {
+Type *Mutator::mutate( TraitInstType *aggregateUseType ) {
         handleReferenceToType( aggregateUseType );
         mutateAll( aggregateUseType->get_members(), *this );
@@ -542 +524 @@
 }
 
-Type * Mutator::mutate( TypeInstType *aggregateUseType ) {
+Type *Mutator::mutate( TypeInstType *aggregateUseType ) {
         handleReferenceToType( aggregateUseType );
         return aggregateUseType;
 }
 
-Type * Mutator::mutate( TupleType *tupleType ) {
+Type *Mutator::mutate( TupleType *tupleType ) {
         mutateAll( tupleType->get_forall(), *this );
         mutateAll( tupleType->get_types(), *this );
@@ -554 +536 @@
 }
 
-Type * Mutator::mutate( TypeofType *typeofType ) {
+Type *Mutator::mutate( TypeofType *typeofType ) {
         assert( typeofType->get_expr() );
         typeofType->set_expr( typeofType->get_expr()->acceptMutator( *this ) );
@@ -560 +542 @@
 }
 
-Type * Mutator::mutate( AttrType *attrType ) {
+Type *Mutator::mutate( AttrType *attrType ) {
         if ( attrType->get_isType() ) {
                 assert( attrType->get_type() );
@@ -571 +553 @@
 }
 
-Type * Mutator::mutate( VarArgsType *varArgsType ) {
+Type *Mutator::mutate( VarArgsType *varArgsType ) {
         mutateAll( varArgsType->get_forall(), *this );
         return varArgsType;
 }
 
-Type * Mutator::mutate( ZeroType *zeroType ) {
+Type *Mutator::mutate( ZeroType *zeroType ) {
         mutateAll( zeroType->get_forall(), *this );
         return zeroType;
 }
 
-Type * Mutator::mutate( OneType *oneType ) {
+Type *Mutator::mutate( OneType *oneType ) {
         mutateAll( oneType->get_forall(), *this );
         return oneType;
@@ -587 +569 @@
 
 
-Designation * Mutator::mutate( Designation * designation ) {
+Designation *Mutator::mutate( Designation * designation ) {
         mutateAll( designation->get_designators(), *this );
         return designation;
 }
 
-Initializer * Mutator::mutate( SingleInit *singleInit ) {
+Initializer *Mutator::mutate( SingleInit *singleInit ) {
         singleInit->set_value( singleInit->get_value()->acceptMutator( *this ) );
         return singleInit;
 }
 
-Initializer * Mutator::mutate( ListInit *listInit ) {
+Initializer *Mutator::mutate( ListInit *listInit ) {
         mutateAll( listInit->get_designations(), *this );
         mutateAll( listInit->get_initializers(), *this );
@@ -603 +585 @@
 }
 
-Initializer * Mutator::mutate( ConstructorInit *ctorInit ) {
+Initializer *Mutator::mutate( ConstructorInit *ctorInit ) {
         ctorInit->set_ctor( maybeMutate( ctorInit->get_ctor(), *this ) );
         ctorInit->set_dtor( maybeMutate( ctorInit->get_dtor(), *this ) );
@@ -611 +593 @@
 
 
-Subrange * Mutator::mutate( Subrange *subrange ) {
+Subrange *Mutator::mutate( Subrange *subrange ) {
         return subrange;
 }
 
 
-Constant * Mutator::mutate( Constant *constant ) {
+Constant *Mutator::mutate( Constant *constant ) {
         return constant;
 }

src/SynTree/Mutator.h

@@ -49 +49 @@
         virtual Statement* mutate( CatchStmt *catchStmt );
         virtual Statement* mutate( FinallyStmt *catchStmt );
-        virtual Statement* mutate( WaitForStmt *waitforStmt );
         virtual NullStmt* mutate( NullStmt *nullStmt );
         virtual Statement* mutate( DeclStmt *declStmt );

src/SynTree/Statement.cc

@@ -419 +419 @@
 }
 
-WaitForStmt::WaitForStmt( std::list<Label> labels ) : Statement( labels ) {
-        timeout.time      = nullptr;
-        timeout.statement = nullptr;
-        timeout.condition = nullptr;
-        orelse .statement = nullptr;
-        orelse .condition = nullptr;
-}
-
-WaitForStmt::WaitForStmt( const WaitForStmt & other ) : Statement( other ) {
-        clauses.reserve( other.clauses.size() );
-        for( auto & ocl : other.clauses ) {
-                clauses.emplace_back();
-                clauses.back().target.function = ocl.target.function->clone();
-                cloneAll( ocl.target.arguments, clauses.back().target.arguments );
-                clauses.back().statement = ocl.statement->clone();
-                clauses.back().condition = ocl.condition->clone();
-        }
-
-        timeout.time      = other.timeout.time     ->clone();
-        timeout.statement = other.timeout.statement->clone();
-        timeout.condition = other.timeout.condition->clone();
-        orelse .statement = other.orelse .statement->clone();
-        orelse .condition = other.orelse .condition->clone();
-}
-
-WaitForStmt::~WaitForStmt() {
-        for( auto & clause : clauses ) {
-                delete clause.target.function;
-                deleteAll( clause.target.arguments );
-                delete clause.statement;
-                delete clause.condition;
-        }
-
-        delete timeout.time;
-        delete timeout.statement;
-        delete timeout.condition;
-
-        delete orelse.statement;
-        delete orelse.condition;
-}
-
-void WaitForStmt::print( std::ostream &os, int indent ) const {
-        os << "Waitfor Statement" << endl;
-        os << string( indent + 2, ' ' ) << "with block:" << endl;
-        os << string( indent + 4, ' ' );
-        // block->print( os, indent + 4 );
-}
-
 NullStmt::NullStmt( std::list<Label> labels ) : CompoundStmt( labels ) {}
 NullStmt::NullStmt() : CompoundStmt( std::list<Label>() ) {}

src/SynTree/Statement.h

@@ -19 +19 @@
 #include <list>                    // for list
 #include <memory>                  // for allocator
-#include <vector>                        // for vector
 
 #include "BaseSyntaxNode.h"        // for BaseSyntaxNode
@@ -393 +392 @@
 };
 
-class WaitForStmt : public Statement {
-  public:
-
-        struct Target {
-                Expression * function;
-                std::list<Expression * > arguments;
-        };
-
-        struct Clause {
-                Target       target;
-                Statement  * statement;
-                Expression * condition;
-        };
-
-        WaitForStmt( std::list<Label> labels = noLabels );
-        WaitForStmt( const WaitForStmt & );
-        virtual ~WaitForStmt();
-
-        std::vector<Clause> clauses;
-
-        struct {
-                Expression * time;
-                Statement  * statement;
-                Expression * condition;
-        } timeout;
-
-        struct {
-                Statement  * statement;
-                Expression * condition;
-        } orelse;
-
-        virtual WaitForStmt *clone() const { return new WaitForStmt( *this ); }
-        virtual void accept( Visitor &v ) { v.visit( this ); }
-        virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
-        virtual void print( std::ostream &os, int indent = 0 ) const;
-
-};
-
 
 // represents a declaration that occurs as part of a compound statement

src/SynTree/SynTree.h

@@ -54 +54 @@
 class CatchStmt;
 class FinallyStmt;
-class WaitForStmt;
 class NullStmt;
 class DeclStmt;

src/SynTree/Visitor.cc

@@ -155 +155 @@
 }
 
-void Visitor::visit( WaitForStmt *waitforStmt ) {
-        for( auto & clause : waitforStmt->clauses ) {
-                maybeAccept( clause.target.function, *this );
-                acceptAll( clause.target.arguments, *this );
-
-                maybeAccept( clause.statement, *this );
-                maybeAccept( clause.condition, *this );
-        }
-
-        maybeAccept( waitforStmt->timeout.time, *this );
-        maybeAccept( waitforStmt->timeout.statement, *this );
-        maybeAccept( waitforStmt->timeout.condition, *this );
-        maybeAccept( waitforStmt->orelse.statement, *this );
-        maybeAccept( waitforStmt->orelse.condition, *this );
-}
-
 void Visitor::visit( __attribute__((unused)) NullStmt *nullStmt ) {
 }

src/SynTree/Visitor.h

@@ -51 +51 @@
         virtual void visit( CatchStmt *catchStmt );
         virtual void visit( FinallyStmt *finallyStmt );
-        virtual void visit( WaitForStmt *waitforStmt );
         virtual void visit( NullStmt *nullStmt );
         virtual void visit( DeclStmt *declStmt );

src/libcfa/concurrency/invoke.h

@@ -28 +28 @@
       #define thread_local _Thread_local
 
-      typedef void (*fptr_t)();
-
       struct spinlock {
             volatile int lock;
@@ -52 +50 @@
             void append( struct __thread_queue_t *, struct thread_desc * );
             struct thread_desc * pop_head( struct __thread_queue_t * );
-            struct thread_desc * remove( struct __thread_queue_t *, struct thread_desc ** );
 
             void ?{}( struct __condition_stack_t & );
@@ -90 +87 @@
             struct __condition_stack_t signal_stack;  // stack of conditions to run next once we exit the monitor
             unsigned int recursion;                   // monitor routines can be called recursively, we need to keep track of that
-
-            struct __acceptable_t * acceptables;      // list of acceptable functions, null if any
-            unsigned short acceptable_count;          // number of acceptable functions
-            short accepted_index;                     // the index of the accepted function, -1 if none
-       };
+      };
 
       struct thread_desc {
-            // Core threading fields
             struct coroutine_desc cor;                // coroutine body used to store context
             struct monitor_desc mon;                  // monitor body used for mutual exclusion
-
-            // Link lists fields
             struct thread_desc * next;                // instrusive link field for threads
-
-            // Current status related to monitors
             struct monitor_desc ** current_monitors;  // currently held monitors
             unsigned short current_monitor_count;     // number of currently held monitors
-            fptr_t current_monitor_func;              // last function that acquired monitors
-     };
+      };
 
 #endif //_INVOKE_H_

src/libcfa/concurrency/kernel.c

@@ -322 +322 @@
 void ScheduleThread( thread_desc * thrd ) {
         // if( !thrd ) return;
-        verify( thrd );
-        verify( thrd->cor.state != Halted );
+        assert( thrd );
+        assert( thrd->cor.state != Halted );
 
         verify( disable_preempt_count > 0 );
@@ -366 +366 @@
 
 void BlockInternal( thread_desc * thrd ) {
-        assert(thrd);
         disable_interrupts();
         assert( thrd->cor.state != Halted );
@@ -380 +379 @@
 
 void BlockInternal( spinlock * lock, thread_desc * thrd ) {
-        assert(thrd);
         disable_interrupts();
         this_processor->finish.action_code = Release_Schedule;
@@ -668 +666 @@
 }
 
-thread_desc * remove( __thread_queue_t * this, thread_desc ** it ) {
-        thread_desc * thrd = *it;
-        verify( thrd );
-
-        (*it) = thrd->next;
-
-        if( this->tail == &thrd->next ) {
-                this->tail = it;
-        }
-
-        thrd->next = NULL;
-
-        verify( (this->head == NULL) == (&this->head == this->tail) );
-        verify( *this->tail == NULL );
-        return thrd;
-}
-
 void ?{}( __condition_stack_t & this ) {
         this.top = NULL;

src/libcfa/concurrency/monitor

@@ -23 +23 @@
 
 static inline void ?{}(monitor_desc & this) {
-        (this.lock){};
         this.owner = NULL;
-        (this.entry_queue){};
-        (this.signal_stack){};
         this.recursion = 0;
-        this.acceptables = NULL;
-        this.acceptable_count = 0;
-        this.accepted_index = -1;
 }
 
@@ -38 +32 @@
         monitor_desc ** prev_mntrs;
         unsigned short  prev_count;
-        fptr_t          prev_func;
 };
 
@@ -45 +38 @@
 }
 
-void ?{}( monitor_guard_t & this, monitor_desc ** m, int count, void (*func)() );
+void ?{}( monitor_guard_t & this, monitor_desc ** m, int count );
 void ^?{}( monitor_guard_t & this );
 
@@ -96 +89 @@
 uintptr_t front( condition * this );
 
-//-----------------------------------------------------------------------------
-// External scheduling
-
 struct __acceptable_t {
-        fptr_t func;
+        void (*func)(void);
         unsigned short count;
-        monitor_desc ** monitors;
+        monitor_desc * monitors[1];
 };
 
-int __accept_internal( unsigned short count, __acceptable_t * acceptables );
+void __accept_internal( unsigned short count, __acceptable_t * acceptables, void (*func)(void) );
 
 // Local Variables: //

src/libcfa/concurrency/monitor.c

@@ -25 +25 @@
 static inline void set_owner( monitor_desc * this, thread_desc * owner );
 static inline thread_desc * next_thread( monitor_desc * this );
-static inline int is_accepted( thread_desc * owner, monitor_desc * this, monitor_desc ** group, int group_cnt, void (*func)() );
 
 static inline void lock_all( spinlock ** locks, unsigned short count );
@@ -35 +34 @@
 static inline void restore_recursion( monitor_desc ** ctx, unsigned int * /*in */ recursions, unsigned short count );
 
-static inline void init     ( int count, monitor_desc ** monitors, __condition_node_t * waiter, __condition_criterion_t * criteria );
-static inline void init_push( int count, monitor_desc ** monitors, __condition_node_t * waiter, __condition_criterion_t * criteria );
-
 static inline thread_desc * check_condition( __condition_criterion_t * );
 static inline void brand_condition( condition * );
 static inline unsigned short insert_unique( thread_desc ** thrds, unsigned short end, thread_desc * val );
 
-static inline thread_desc * search_entry_queue( __acceptable_t * acceptables, int acc_count, monitor_desc ** monitors, int count );
-
-//-----------------------------------------------------------------------------
-// Useful defines
-#define wait_ctx(thrd, user_info)                               /* Create the necessary information to use the signaller stack       */ \
-        __condition_node_t waiter = { thrd, count, user_info };   /* Create the node specific to this wait operation                   */ \
-        __condition_criterion_t criteria[count];                  /* Create the creteria this wait operation needs to wake up          */ \
-        init( count, monitors, &waiter, criteria );               /* Link everything together                                          */ \
-
-#define wait_ctx_primed(thrd, user_info)                        /* Create the necessary information to use the signaller stack       */ \
-        __condition_node_t waiter = { thrd, count, user_info };   /* Create the node specific to this wait operation                   */ \
-        __condition_criterion_t criteria[count];                  /* Create the creteria this wait operation needs to wake up          */ \
-        init_push( count, monitors, &waiter, criteria );          /* Link everything together and push it to the AS-Stack              */ \
-
-#define monitor_ctx( mons, cnt )              /* Define that create the necessary struct for internal/external scheduling operations */ \
-        monitor_desc ** monitors = mons;        /* Save the targeted monitors                                                          */ \
-        unsigned short count = cnt;             /* Save the count to a local variable                                                  */ \
-        unsigned int recursions[ count ];       /* Save the current recursion levels to restore them later                             */ \
-        spinlock *   locks     [ count ];       /* We need to pass-in an array of locks to BlockInternal                               */ \
-
 //-----------------------------------------------------------------------------
 // Enter/Leave routines
@@ -67 +43 @@
 
 extern "C" {
-        // Enter single monitor
-        static void __enter_monitor_desc( monitor_desc * this, monitor_desc ** group, int group_cnt, void (*func)() ) {
-                // Lock the monitor spinlock, lock_yield to reduce contention
+        void __enter_monitor_desc( monitor_desc * this ) {
                 lock_yield( &this->lock DEBUG_CTX2 );
                 thread_desc * thrd = this_thread;
 
-                LIB_DEBUG_PRINT_SAFE("Kernel : %10p Entering mon %p (%p)\n", thrd, this, this->owner);
-
-                this->accepted_index = -1;
+                // LIB_DEBUG_PRINT_SAFE("%p Entering %p (o: %p, r: %i)\n", thrd, this, this->owner, this->recursion);
+
                 if( !this->owner ) {
-                        // No one has the monitor, just take it
+                        //No one has the monitor, just take it
                         set_owner( this, thrd );
-
-                        LIB_DEBUG_PRINT_SAFE("Kernel :  mon is free \n");
                 }
                 else if( this->owner == thrd) {
-                        // We already have the monitor, just not how many times we took it
+                        //We already have the monitor, just not how many times we took it
                         verify( this->recursion > 0 );
                         this->recursion += 1;
-
-                        LIB_DEBUG_PRINT_SAFE("Kernel :  mon already owned \n");
-                }
-                else if( (this->accepted_index = is_accepted( thrd, this, group, group_cnt, func)) >= 0 ) {
-                        // Some one was waiting for us, enter
-                        set_owner( this, thrd );
-
-                        LIB_DEBUG_PRINT_SAFE("Kernel :  mon accepts \n");
                 }
                 else {
-                        LIB_DEBUG_PRINT_SAFE("Kernel :  blocking \n");
-
-                        // Some one else has the monitor, wait in line for it
+                        //Some one else has the monitor, wait in line for it
                         append( &this->entry_queue, thrd );
+                        // LIB_DEBUG_PRINT_SAFE("%p Blocking on entry\n", thrd);
                         BlockInternal( &this->lock );
 
-                        LIB_DEBUG_PRINT_SAFE("Kernel : %10p Entered  mon %p\n", thrd, this);
-
-                        // BlockInternal will unlock spinlock, no need to unlock ourselves
+                        //BlockInternal will unlock spinlock, no need to unlock ourselves
                         return;
                 }
 
-                LIB_DEBUG_PRINT_SAFE("Kernel : %10p Entered  mon %p\n", thrd, this);
-
-                // Release the lock and leave
                 unlock( &this->lock );
                 return;
         }
 
-        // Leave single monitor
+        // leave pseudo code :
+        //      TODO
         void __leave_monitor_desc( monitor_desc * this ) {
-                // Lock the monitor spinlock, lock_yield to reduce contention
                 lock_yield( &this->lock DEBUG_CTX2 );
 
+                // LIB_DEBUG_PRINT_SAFE("%p Leaving %p (o: %p, r: %i). ", this_thread, this, this->owner, this->recursion);
                 verifyf( this_thread == this->owner, "Expected owner to be %p, got %p (r: %i)", this_thread, this->owner, this->recursion );
 
-                // Leaving a recursion level, decrement the counter
+                //Leaving a recursion level, decrement the counter
                 this->recursion -= 1;
 
-                // If we haven't left the last level of recursion
-                // it means we don't need to do anything
+                //If we haven't left the last level of recursion
+                //it means we don't need to do anything
                 if( this->recursion != 0) {
                         unlock( &this->lock );
@@ -132 +90 @@
                 }
 
-                // Get the next thread, will be null on low contention monitor
                 thread_desc * new_owner = next_thread( this );
 
-                // We can now let other threads in safely
+                //We can now let other threads in safely
                 unlock( &this->lock );
+
+                // LIB_DEBUG_PRINT_SAFE("Next owner is %p\n", new_owner);
 
                 //We need to wake-up the thread
@@ -142 +101 @@
         }
 
-        // Leave the thread monitor
-        // last routine called by a thread.
-        // Should never return
         void __leave_thread_monitor( thread_desc * thrd ) {
                 monitor_desc * this = &thrd->mon;
-
-                // Lock the monitor now
                 lock_yield( &this->lock DEBUG_CTX2 );
 
@@ -157 +111 @@
                 verifyf( thrd == this->owner, "Expected owner to be %p, got %p (r: %i)", thrd, this->owner, this->recursion );
 
-                // Leaving a recursion level, decrement the counter
+                //Leaving a recursion level, decrement the counter
                 this->recursion -= 1;
 
-                // If we haven't left the last level of recursion
-                // it must mean there is an error
-                if( this->recursion != 0) { abortf("Thread internal monitor has unbalanced recursion"); }
-
-                // Fetch the next thread, can be null
+                //If we haven't left the last level of recursion
+                //it means we don't need to do anything
+                if( this->recursion != 0) {
+                        unlock( &this->lock );
+                        return;
+                }
+
                 thread_desc * new_owner = next_thread( this );
 
-                // Leave the thread, this will unlock the spinlock
-                // Use leave thread instead of BlockInternal which is
-                // specialized for this case and supports null new_owner
                 LeaveThread( &this->lock, new_owner );
-
-                // Control flow should never reach here!
-        }
-}
-
-// Enter multiple monitor
-// relies on the monitor array being sorted
-static inline void enter(monitor_desc ** monitors, int count, void (*func)() ) {
+        }
+}
+
+static inline void enter(monitor_desc ** monitors, int count) {
         for(int i = 0; i < count; i++) {
-                __enter_monitor_desc( monitors[i], monitors, count, func );
-        }
-}
-
-// Leave multiple monitor
-// relies on the monitor array being sorted
+                __enter_monitor_desc( monitors[i] );
+        }
+}
+
 static inline void leave(monitor_desc ** monitors, int count) {
         for(int i = count - 1; i >= 0; i--) {
@@ -192 +139 @@
 }
 
-// Ctor for monitor guard
-// Sorts monitors before entering
-void ?{}( monitor_guard_t & this, monitor_desc ** m, int count, void (*func)() ) {
-        // Store current array
+void ?{}( monitor_guard_t & this, monitor_desc ** m, int count ) {
         this.m = m;
         this.count = count;
-
-        // Sort monitors based on address -> TODO use a sort specialized for small numbers
         qsort(this.m, count);
-
-        // Save previous thread context
+        enter( this.m, this.count );
+
         this.prev_mntrs = this_thread->current_monitors;
         this.prev_count = this_thread->current_monitor_count;
-        this.prev_func  = this_thread->current_monitor_func;
-
-        // Update thread context (needed for conditions)
+
         this_thread->current_monitors      = m;
         this_thread->current_monitor_count = count;
-        this_thread->current_monitor_func  = func;
-
-        // Enter the monitors in order
-        enter( this.m, this.count, func );
-}
-
-
-// Dtor for monitor guard
+}
+
 void ^?{}( monitor_guard_t & this ) {
-        // Leave the monitors in order
         leave( this.m, this.count );
 
-        // Restore thread context
         this_thread->current_monitors      = this.prev_mntrs;
         this_thread->current_monitor_count = this.prev_count;
-        this_thread->current_monitor_func  = this.prev_func;
-}
-
-//-----------------------------------------------------------------------------
-// Internal scheduling types
+}
+
 void ?{}(__condition_node_t & this, thread_desc * waiting_thread, unsigned short count, uintptr_t user_info ) {
         this.waiting_thread = waiting_thread;
@@ -254 +183 @@
 // Internal scheduling
 void wait( condition * this, uintptr_t user_info = 0 ) {
+        // LIB_DEBUG_PRINT_SAFE("Waiting\n");
+
         brand_condition( this );
 
-        // Check that everything is as expected
+        //Check that everything is as expected
         assertf( this->monitors != NULL, "Waiting with no monitors (%p)", this->monitors );
         verifyf( this->monitor_count != 0, "Waiting with 0 monitors (%i)", this->monitor_count );
         verifyf( this->monitor_count < 32u, "Excessive monitor count (%i)", this->monitor_count );
 
-        // Create storage for monitor context
-        monitor_ctx( this->monitors, this->monitor_count );
-
-        // Create the node specific to this wait operation
-        wait_ctx( this_thread, user_info );
-
-        // Append the current wait operation to the ones already queued on the condition
-        // We don't need locks for that since conditions must always be waited on inside monitor mutual exclusion
+        unsigned short count = this->monitor_count;
+        unsigned int recursions[ count ];               //Save the current recursion levels to restore them later
+        spinlock *   locks     [ count ];               //We need to pass-in an array of locks to BlockInternal
+
+        // LIB_DEBUG_PRINT_SAFE("count %i\n", count);
+
+        __condition_node_t waiter = { (thread_desc*)this_thread, count, user_info };
+
+        __condition_criterion_t criteria[count];
+        for(int i = 0; i < count; i++) {
+                (criteria[i]){ this->monitors[i], &waiter };
+                // LIB_DEBUG_PRINT_SAFE( "Criterion %p\n", &criteria[i] );
+        }
+
+        waiter.criteria = criteria;
         append( &this->blocked, &waiter );
 
-        // Lock all monitors (aggregates the lock them as well)
-        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
+        lock_all( this->monitors, locks, count );
+        save_recursion( this->monitors, recursions, count );
+        //DON'T unlock, ask the kernel to do it
+
+        //Find the next thread(s) to run
         unsigned short thread_count = 0;
         thread_desc * threads[ count ];
@@ -286 +220 @@
         }
 
-        // Remove any duplicate threads
         for( int i = 0; i < count; i++) {
-                thread_desc * new_owner = next_thread( monitors[i] );
+                thread_desc * new_owner = next_thread( this->monitors[i] );
                 thread_count = insert_unique( threads, thread_count, new_owner );
         }
+
+        // LIB_DEBUG_PRINT_SAFE("Will unblock: ");
+        for(int i = 0; i < thread_count; i++) {
+                // LIB_DEBUG_PRINT_SAFE("%p ", threads[i]);
+        }
+        // LIB_DEBUG_PRINT_SAFE("\n");
 
         // Everything is ready to go to sleep
@@ -296 +235 @@
 
 
-        // WE WOKE UP
-
-
-        // We are back, restore the owners and recursions
+        //WE WOKE UP
+
+
+        //We are back, restore the owners and recursions
         lock_all( locks, count );
-        restore_recursion( monitors, recursions, count );
+        restore_recursion( this->monitors, recursions, count );
         unlock_all( locks, count );
 }
 
 bool signal( condition * this ) {
-        if( is_empty( this ) ) { return false; }
+        if( is_empty( this ) ) {
+                // LIB_DEBUG_PRINT_SAFE("Nothing to signal\n");
+                return false;
+        }
 
         //Check that everything is as expected
         verify( this->monitors );
         verify( this->monitor_count != 0 );
+
+        unsigned short count = this->monitor_count;
 
         //Some more checking in debug
@@ -317 +261 @@
                 if ( this->monitor_count != this_thrd->current_monitor_count ) {
                         abortf( "Signal on condition %p made with different number of monitor(s), expected %i got %i", this, this->monitor_count, this_thrd->current_monitor_count );
-                }
+                } // if
 
                 for(int i = 0; i < this->monitor_count; i++) {
                         if ( this->monitors[i] != this_thrd->current_monitors[i] ) {
                                 abortf( "Signal on condition %p made with different monitor, expected %p got %i", this, this->monitors[i], this_thrd->current_monitors[i] );
-                        }
+                        } // if
                 }
         );
 
-        unsigned short count = this->monitor_count;
-
-        // Lock all monitors
+        //Lock all the monitors
         lock_all( this->monitors, NULL, count );
+        // LIB_DEBUG_PRINT_SAFE("Signalling");
 
         //Pop the head of the waiting queue
@@ -337 +280 @@
         for(int i = 0; i < count; i++) {
                 __condition_criterion_t * crit = &node->criteria[i];
+                // LIB_DEBUG_PRINT_SAFE(" %p", crit->target);
                 assert( !crit->ready );
                 push( &crit->target->signal_stack, crit );
         }
 
+        // LIB_DEBUG_PRINT_SAFE("\n");
+
         //Release
         unlock_all( this->monitors, count );
@@ -348 +294 @@
 
 bool signal_block( condition * this ) {
-        if( !this->blocked.head ) { return false; }
+        if( !this->blocked.head ) {
+                LIB_DEBUG_PRINT_SAFE("Nothing to signal\n");
+                return false;
+        }
 
         //Check that everything is as expected
@@ -354 +303 @@
         verifyf( this->monitor_count != 0, "Waiting with 0 monitors (%i)", this->monitor_count );
 
-        // Create storage for monitor context
-        monitor_ctx( this->monitors, this->monitor_count );
-
-        // Lock all monitors (aggregates the locks them as well)
-        lock_all( monitors, locks, count );
-
-        // Create the node specific to this wait operation
-        wait_ctx_primed( this_thread, 0 )
+        unsigned short count = this->monitor_count;
+        unsigned int recursions[ count ];               //Save the current recursion levels to restore them later
+        spinlock *   locks     [ count ];               //We need to pass-in an array of locks to BlockInternal
+
+        lock_all( this->monitors, locks, count );
+
+        //create creteria
+        __condition_node_t waiter = { (thread_desc*)this_thread, count, 0 };
+
+        __condition_criterion_t criteria[count];
+        for(int i = 0; i < count; i++) {
+                (criteria[i]){ this->monitors[i], &waiter };
+                // LIB_DEBUG_PRINT_SAFE( "Criterion %p\n", &criteria[i] );
+                push( &criteria[i].target->signal_stack, &criteria[i] );
+        }
+
+        waiter.criteria = criteria;
 
         //save contexts
-        save_recursion( monitors, recursions, count );
+        save_recursion( this->monitors, recursions, count );
 
         //Find the thread to run
         thread_desc * signallee = pop_head( &this->blocked )->waiting_thread;
         for(int i = 0; i < count; i++) {
-                set_owner( monitors[i], signallee );
-        }
+                set_owner( this->monitors[i], signallee );
+        }
+
+        LIB_DEBUG_PRINT_SAFE( "Waiting on signal block\n" );
 
         //Everything is ready to go to sleep
@@ -376 +336 @@
 
 
-        // WE WOKE UP
-
+
+
+        LIB_DEBUG_PRINT_SAFE( "Back from signal block\n" );
 
         //We are back, restore the owners and recursions
         lock_all( locks, count );
-        restore_recursion( monitors, recursions, count );
+        restore_recursion( this->monitors, recursions, count );
         unlock_all( locks, count );
 
@@ -387 +348 @@
 }
 
-// Access the user_info of the thread waiting at the front of the queue
 uintptr_t front( condition * this ) {
         verifyf( !is_empty(this),
@@ -398 +358 @@
 //-----------------------------------------------------------------------------
 // Internal scheduling
-int __accept_internal( unsigned short acc_count, __acceptable_t * acceptables ) {
-        thread_desc * thrd = this_thread;
-
-        // Create storage for monitor context
-        monitor_ctx( acceptables->monitors, acceptables->count );
-
-        // Lock all monitors (aggregates the lock them as well)
-        lock_all( monitors, locks, count );
-
-        // Create the node specific to this wait operation
-        wait_ctx_primed( thrd, 0 );
-
-        // Check if the entry queue
-        thread_desc * next = search_entry_queue( acceptables, acc_count, monitors, count );
-
-        LIB_DEBUG_PRINT_SAFE("Owner(s) :");
-        for(int i = 0; i < count; i++) {
-                LIB_DEBUG_PRINT_SAFE(" %p", monitors[i]->owner );
-        }
-        LIB_DEBUG_PRINT_SAFE("\n");
-
-        LIB_DEBUG_PRINT_SAFE("Passing mon to %p\n", next);
-
-        if( !next ) {
-                // Update acceptables on the current monitors
-                for(int i = 0; i < count; i++) {
-                        monitors[i]->acceptables = acceptables;
-                        monitors[i]->acceptable_count = acc_count;
-                }
-        }
-        else {
-                for(int i = 0; i < count; i++) {
-                        set_owner( monitors[i], next );
-                }
-        }
-
-
-        save_recursion( monitors, recursions, count );
-
-
-        // Everything is ready to go to sleep
-        BlockInternal( locks, count, &next, next ? 1 : 0 );
-
-
-        //WE WOKE UP
-
-
-        //We are back, restore the owners and recursions
-        lock_all( locks, count );
-        restore_recursion( monitors, recursions, count );
-        int acc_idx = monitors[0]->accepted_index;
-        unlock_all( locks, count );
-
-        return acc_idx;
+void __accept_internal( unsigned short count, __acceptable_t * acceptables, void (*func)(void) ) {
+        // thread_desc * this = this_thread;
+
+        // unsigned short count = this->current_monitor_count;
+        // unsigned int recursions[ count ];            //Save the current recursion levels to restore them later
+        // spinlock *   locks     [ count ];            //We need to pass-in an array of locks to BlockInternal
+
+        // lock_all( this->current_monitors, locks, count );
+
+
+
+
+
+        // // // Everything is ready to go to sleep
+        // // BlockInternal( locks, count, threads, thread_count );
+
+
+        // //WE WOKE UP
+
+
+        // //We are back, restore the owners and recursions
+        // lock_all( locks, count );
+        // restore_recursion( this->monitors, recursions, count );
+        // unlock_all( locks, count );
 }
 
@@ -485 +415 @@
 }
 
-static inline int is_accepted( thread_desc * owner, monitor_desc * this, monitor_desc ** group, int group_cnt, void (*func)() ) {
-        __acceptable_t* accs = this->acceptables; // Optim
-        int acc_cnt = this->acceptable_count;
-
-        // Check if there are any acceptable functions
-        if( !accs ) return -1;
-
-        // If this isn't the first monitor to test this, there is no reason to repeat the test.
-        if( this != group[0] ) return group[0]->accepted_index;
-
-        // For all acceptable functions check if this is the current function.
-        OUT_LOOP:
-        for( int i = 0; i < acc_cnt; i++ ) {
-                __acceptable_t * acc = &accs[i];
-
-                // if function matches, check the monitors
-                if( acc->func == func ) {
-
-                        // If the group count is different then it can't be a match
-                        if( acc->count != group_cnt ) return -1;
-
-                        // Check that all the monitors match
-                        for( int j = 0; j < group_cnt; j++ ) {
-                                // If not a match, check next function
-                                if( acc->monitors[j] != group[j] ) continue OUT_LOOP;
-                        }
-
-                        // It's a complete match, accept the call
-                        return i;
-                }
-        }
-
-        // No function matched
-        return -1;
-}
-
-static inline void init( int count, monitor_desc ** monitors, __condition_node_t * waiter, __condition_criterion_t * criteria ) {
-        for(int i = 0; i < count; i++) {
-                (criteria[i]){ monitors[i], waiter };
-        }
-
-        waiter->criteria = criteria;
-}
-
-static inline void init_push( int count, monitor_desc ** monitors, __condition_node_t * waiter, __condition_criterion_t * criteria ) {
-        for(int i = 0; i < count; i++) {
-                (criteria[i]){ monitors[i], waiter };
-                push( &criteria[i].target->signal_stack, &criteria[i] );
-        }
-
-        waiter->criteria = criteria;
-}
-
 static inline void lock_all( spinlock ** locks, unsigned short count ) {
         for( int i = 0; i < count; i++ ) {
@@ -628 +505 @@
 }
 
-
-static inline bool match( __acceptable_t * acc, thread_desc * thrd ) {
-        verify( thrd );
-        verify( acc );
-        if( acc->func != thrd->current_monitor_func ) return false;
-
-        return true;
-}
-
-static inline thread_desc * search_entry_queue( __acceptable_t * acceptables, int acc_count, monitor_desc ** monitors, int count ) {
-
-        __thread_queue_t * entry_queue = &monitors[0]->entry_queue;
-
-        // For each thread in the entry-queue
-        for(    thread_desc ** thrd_it = &entry_queue->head;
-                *thrd_it;
-                thrd_it = &(*thrd_it)->next)
-        {
-                // For each acceptable check if it matches
-                __acceptable_t * acc_end = acceptables + acc_count;
-                for( __acceptable_t * acc_it = acceptables; acc_it != acc_end; acc_it++ ) {
-                        // Check if we have a match
-                        if( match( acc_it, *thrd_it ) ) {
-
-                                // If we have a match return it
-                                // after removeing it from the entry queue
-                                return remove( entry_queue, thrd_it );
-                        }
-                }
-        }
-
-        return NULL;
-}
 void ?{}( __condition_blocked_queue_t & this ) {
         this.head = NULL;

src/libcfa/concurrency/preemption.c

@@ -332 +332 @@
                 assertf(sig == SIGALRM, "Kernel Internal Error, sigwait: Unexpected signal %d (%d : %d)\n", sig, info.si_code, info.si_value.sival_int);
 
-                // LIB_DEBUG_PRINT_SAFE("Kernel : Caught alarm from %d with %d\n", info.si_code, info.si_value.sival_int );
+                LIB_DEBUG_PRINT_SAFE("Kernel : Caught alarm from %d with %d\n", info.si_code, info.si_value.sival_int );
                 // Switch on the code (a.k.a. the sender) to
                 switch( info.si_code )
@@ -340 +340 @@
                 case SI_TIMER:
                 case SI_KERNEL:
-                        // LIB_DEBUG_PRINT_SAFE("Kernel : Preemption thread tick\n");
+                        LIB_DEBUG_PRINT_SAFE("Kernel : Preemption thread tick\n");
                         lock( &event_kernel->lock DEBUG_CTX2 );
                         tick_preemption();

src/tests/preempt_longrun/stack.c

@@ -15 +15 @@
 
 void main(worker_t * this) {
-        volatile long long p = 5_021_609ul;
-        volatile long long a = 326_417ul;
-        volatile long long n = 1l;
-        for (volatile long long i = 0; i < p; i++) {
+        volatile long p = 5_021_609ul;
+        volatile long a = 326_417ul;
+        volatile long n = 1l;
+        for (volatile long i = 0; i < p; i++) {
                 n *= a;
                 n %= p;

src/tests/sched-int-disjoint.c

@@ -3 +3 @@
 #include <monitor>
 #include <thread>
-
-#include <time.h>
 
 static const unsigned long N = 10_000ul;
@@ -109 +107 @@
 // Main loop
 int main(int argc, char* argv[]) {
-        rand48seed( time( NULL ) );
         all_done = false;
         processor p;

src/tests/sched-int-wait.c

@@ -5 +5 @@
 #include <thread>
 
-#include <time.h>
-
-static const unsigned long N = 2_500ul;
+static const unsigned long N = 10_000ul;
 
 #ifndef PREEMPTION_RATE
@@ -121 +119 @@
 // Main
 int main(int argc, char* argv[]) {
-        rand48seed( time( NULL ) );
         waiter_left = 4;
         processor p[2];