Changes in src/Concurrency/Keywords.cc [e84ab3d:bbe3719]

File:

• src/Concurrency/Keywords.cc (modified) (11 diffs)

src/Concurrency/Keywords.cc

@@ -93 +93 @@
                 ObjectDecl * addField( StructDecl * );
                 void addRoutines( ObjectDecl *, FunctionDecl * );
+                void addLockUnlockRoutines( StructDecl * );
 
                 virtual bool is_target( StructDecl * decl ) = 0;
@@ -302 +303 @@
                 void postvisit( FunctionDecl * decl );
                 void postvisit(   StructDecl * decl );
+                Statement * postmutate( MutexStmt * stmt );
 
                 std::list<DeclarationWithType*> findMutexArgs( FunctionDecl*, bool & first );
@@ -307 +309 @@
                 void addDtorStatements( FunctionDecl* func, CompoundStmt *, const std::list<DeclarationWithType * > &);
                 void addStatements( FunctionDecl* func, CompoundStmt *, const std::list<DeclarationWithType * > &);
+                void addStatements( CompoundStmt * body, const std::list<Expression * > & args );
                 void addThreadDtorStatements( FunctionDecl* func, CompoundStmt * body, const std::list<DeclarationWithType * > & args );
 
@@ -312 +315 @@
                         PassVisitor< MutexKeyword > impl;
                         acceptAll( translationUnit, impl );
+                        mutateAll( translationUnit, impl );
                 }
 
@@ -319 +323 @@
                 StructDecl* dtor_guard_decl = nullptr;
                 StructDecl* thread_guard_decl = nullptr;
+                StructDecl* lock_guard_decl = nullptr;
 
                 static std::unique_ptr< Type > generic_func;
@@ -460 +465 @@
         }
 
-
         void ConcurrentSueKeyword::handle( StructDecl * decl ) {
                 if( ! decl->body ) return;
@@ -476 +480 @@
                 FunctionDecl * func = forwardDeclare( decl );
                 ObjectDecl * field = addField( decl );
+
+                // add get_.* routine
                 addRoutines( field, func );
+                // add lock/unlock routines to monitors for use by mutex stmt
+                addLockUnlockRoutines( decl );
         }
 
@@ -609 +617 @@
         }
 
+        // This function adds the get_.* routine body for coroutines, monitors etc
+        //              after their corresponding struct has been made
         void ConcurrentSueKeyword::addRoutines( ObjectDecl * field, FunctionDecl * func ) {
                 CompoundStmt * statement = new CompoundStmt();
@@ -631 +641 @@
 
                 declsToAddAfter.push_back( get_decl );
+        }
+
+        // Generates lock/unlock routines for monitors to be used by mutex stmts
+        void ConcurrentSueKeyword::addLockUnlockRoutines( StructDecl * decl ) {
+                // this routine will be called for all ConcurrentSueKeyword children so only continue if we are a monitor
+                if ( !decl->is_monitor() ) return;
+
+                FunctionType * lock_fn_type = new FunctionType( noQualifiers, false );
+                FunctionType * unlock_fn_type = new FunctionType( noQualifiers, false );
+
+                // create this ptr parameter for both routines
+                ObjectDecl * this_decl = new ObjectDecl(
+                        "this",
+                        noStorageClasses,
+                        LinkageSpec::Cforall,
+                        nullptr,
+                        new ReferenceType(
+                                noQualifiers,
+                                new StructInstType(
+                                        noQualifiers,
+                                        decl
+                                )
+                        ),
+                        nullptr
+                );
+
+                lock_fn_type->get_parameters().push_back( this_decl->clone() );
+                unlock_fn_type->get_parameters().push_back( this_decl->clone() );
+                fixupGenerics(lock_fn_type, decl);
+                fixupGenerics(unlock_fn_type, decl);
+
+                delete this_decl;
+
+
+                //////////////////////////////////////////////////////////////////////
+                // The following generates this lock routine for all monitors
+                /*
+                        void lock (monitor_t & this) {
+                                lock(get_monitor(this));
+                        }       
+                */
+                FunctionDecl * lock_decl = new FunctionDecl(
+                        "lock",
+                        Type::Static,
+                        LinkageSpec::Cforall,
+                        lock_fn_type,
+                        nullptr,
+                        { },
+                        Type::Inline
+                );
+
+                UntypedExpr * get_monitor_lock =  new UntypedExpr (
+                        new NameExpr( "get_monitor" ),
+                        { new VariableExpr( lock_fn_type->get_parameters().front() ) }
+                );
+
+                CompoundStmt * lock_statement = new CompoundStmt();
+                lock_statement->push_back(
+                        new ExprStmt( 
+                                new UntypedExpr (
+                                        new NameExpr( "lock" ),
+                                        {
+                                                get_monitor_lock
+                                        }
+                                )
+                        )
+                );
+                lock_decl->set_statements( lock_statement );
+
+                //////////////////////////////////////////////////////////////////
+                // The following generates this routine for all monitors
+                /*
+                        void unlock (monitor_t & this) {
+                                unlock(get_monitor(this));
+                        }       
+                */
+                FunctionDecl * unlock_decl = new FunctionDecl(
+                        "unlock",
+                        Type::Static,
+                        LinkageSpec::Cforall,
+                        unlock_fn_type,
+                        nullptr,
+                        { },
+                        Type::Inline
+                );
+
+                CompoundStmt * unlock_statement = new CompoundStmt();
+
+                UntypedExpr * get_monitor_unlock =  new UntypedExpr (
+                        new NameExpr( "get_monitor" ),
+                        { new VariableExpr( unlock_fn_type->get_parameters().front() ) }
+                );
+
+                unlock_statement->push_back(
+                        new ExprStmt( 
+                                new UntypedExpr(
+                                        new NameExpr( "unlock" ),
+                                        {
+                                                get_monitor_unlock
+                                        }
+                                )
+                        )
+                );
+                unlock_decl->set_statements( unlock_statement );
+                
+                // pushes routines to declsToAddAfter to add at a later time
+                declsToAddAfter.push_back( lock_decl );
+                declsToAddAfter.push_back( unlock_decl );
         }
 
@@ -934 +1052 @@
                         assert( !thread_guard_decl );
                         thread_guard_decl = decl;
-                }
+                } 
+                else if ( decl->name == "__mutex_stmt_lock_guard" && decl->body ) {
+                        assert( !lock_guard_decl );
+                        lock_guard_decl = decl;
+                }
+        }
+
+        Statement * MutexKeyword::postmutate( MutexStmt * stmt ) {
+                std::list<Statement *> stmtsForCtor;
+                stmtsForCtor.push_back(stmt->stmt);
+                CompoundStmt * body = new CompoundStmt( stmtsForCtor );
+                addStatements( body, stmt->mutexObjs);
+                return body;
         }
 
@@ -1058 +1188 @@
                         ))
                 );
+        }
+
+        void MutexKeyword::addStatements( CompoundStmt * body, const std::list<Expression * > & args ) {
+                ObjectDecl * monitors = new ObjectDecl(
+                        "__monitors",
+                        noStorageClasses,
+                        LinkageSpec::Cforall,
+                        nullptr,
+                        new ArrayType(
+                                noQualifiers,
+                                new PointerType(
+                                        noQualifiers,
+                                        new TypeofType( noQualifiers, args.front()->clone() )
+                                ),
+                                new ConstantExpr( Constant::from_ulong( args.size() ) ),
+                                false,
+                                false
+                        ),
+                        new ListInit(
+                                map_range < std::list<Initializer*> > ( args, [](Expression * var ){
+                                        return new SingleInit( new AddressExpr( var ) );
+                                })
+                        )
+                );
+
+                StructInstType * lock_guard_struct = new StructInstType( noQualifiers, lock_guard_decl );
+                TypeExpr * lock_type_expr = new TypeExpr( new TypeofType( noQualifiers, args.front()->clone() ) );
+
+                lock_guard_struct->parameters.push_back( lock_type_expr ) ;
+
+                // in reverse order :
+                // monitor_guard_t __guard = { __monitors, # };
+                body->push_front(
+                        new DeclStmt( new ObjectDecl(
+                                "__guard",
+                                noStorageClasses,
+                                LinkageSpec::Cforall,
+                                nullptr,
+                                lock_guard_struct,
+                                new ListInit(
+                                        {
+                                                new SingleInit( new VariableExpr( monitors ) ),
+                                                new SingleInit( new ConstantExpr( Constant::from_ulong( args.size() ) ) )
+                                        },
+                                        noDesignators,
+                                        true
+                                )
+                        ))
+                );
+
+                //monitor$ * __monitors[] = { get_monitor(a), get_monitor(b) };
+                body->push_front( new DeclStmt( monitors) );
         }