Changeset 8a1d95af

Timestamp:

Aug 14, 2021, 8:48:49 AM (3 years ago)

Author:

Peter A. Buhr <pabuhr@…>

Branches:

ADT, ast-experimental, enum, forall-pointer-decay, jacob/cs343-translation, master, pthread-emulation, qualifiedEnum

Children:

f79ee0d

Parents:

c99a0d1 (diff), 6d63c14 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge branch 'master' of plg.uwaterloo.ca:software/cfa/cfa-cc

Files:

• libcfa/src/concurrency/monitor.cfa (modified) (1 diff)
• libcfa/src/concurrency/monitor.hfa (modified) (1 diff)
• src/AST/Convert.cpp (modified) (2 diffs)
• src/AST/Fwd.hpp (modified) (1 diff)
• src/AST/Node.cpp (modified) (1 diff)
• src/AST/Pass.hpp (modified) (1 diff)
• src/AST/Pass.impl.hpp (modified) (1 diff)
• src/AST/Print.cpp (modified) (1 diff)
• src/AST/Stmt.hpp (modified) (1 diff)
• src/AST/Visitor.hpp (modified) (1 diff)
• src/CodeGen/CodeGenerator.cc (modified) (1 diff)
• src/CodeGen/CodeGenerator.h (modified) (1 diff)
• src/Common/CodeLocationTools.cpp (modified) (1 diff)
• src/Common/PassVisitor.h (modified) (2 diffs)
• src/Common/PassVisitor.impl.h (modified) (1 diff)
• src/Concurrency/Keywords.cc (modified) (5 diffs)
• src/Parser/ParseNode.h (modified) (1 diff)
• src/Parser/StatementNode.cc (modified) (1 diff)
• src/Parser/parser.yy (modified) (1 diff)
• src/SynTree/Mutator.h (modified) (1 diff)
• src/SynTree/Statement.cc (modified) (1 diff)
• src/SynTree/Statement.h (modified) (1 diff)
• src/SynTree/SynTree.h (modified) (1 diff)
• src/SynTree/Visitor.h (modified) (1 diff)
• tests/concurrent/mutexstmt/.expect/monitors.txt (added)
• tests/concurrent/mutexstmt/locks.cfa (added)
• tests/concurrent/mutexstmt/monitors.cfa (added)
• tests/unified_locking/.expect/lin_backoff.txt (added)

libcfa/src/concurrency/monitor.cfa

@@ -367 +367 @@
 
         // __cfaabi_dbg_print_safe( "MGUARD : entered\n" );
+}
+
+void ?{}( monitor_guard_t & this, monitor$ * m [], __lock_size_t count ) {
+        this{ m, count, 0p };
 }
 

libcfa/src/concurrency/monitor.hfa

@@ -48 +48 @@
 
 void ?{}( monitor_guard_t & this, monitor$ ** m, __lock_size_t count, void (*func)() );
+void ?{}( monitor_guard_t & this, monitor$ ** m, __lock_size_t count );
 void ^?{}( monitor_guard_t & this );
 

src/AST/Convert.cpp

@@ -606 +606 @@
         }
 
+        const ast::Stmt * visit( const ast::MutexStmt * node ) override final {
+                if ( inCache( node ) ) return nullptr;
+                 auto stmt = new MutexStmt(
+                        get<Statement>().accept1( node->stmt ),
+                        get<Expression>().acceptL( node->mutexObjs )
+                );
+                return stmtPostamble( stmt, node );
+        }
+
         TypeSubstitution * convertTypeSubstitution(const ast::TypeSubstitution * src) {
 
@@ -2124 +2133 @@
         }
 
+        virtual void visit( const MutexStmt * old ) override final {
+                if ( inCache( old ) ) return;
+                this->node = new ast::MutexStmt(
+                        old->location,
+                        GET_ACCEPT_1(stmt, Stmt),
+                        GET_ACCEPT_V(mutexObjs, Expr)
+                );
+                cache.emplace( old, this->node );
+        }
+
         // TypeSubstitution shouldn't exist yet in old.
         ast::TypeSubstitution * convertTypeSubstitution(const TypeSubstitution * old) {

src/AST/Fwd.hpp

@@ -60 +60 @@
 class NullStmt;
 class ImplicitCtorDtorStmt;
+class MutexStmt;
 
 class Expr;

src/AST/Node.cpp

@@ -176 +176 @@
 template class ast::ptr_base< ast::ImplicitCtorDtorStmt, ast::Node::ref_type::weak >;
 template class ast::ptr_base< ast::ImplicitCtorDtorStmt, ast::Node::ref_type::strong >;
+template class ast::ptr_base< ast::MutexStmt, ast::Node::ref_type::weak >;
+template class ast::ptr_base< ast::MutexStmt, ast::Node::ref_type::strong >;
 template class ast::ptr_base< ast::Expr, ast::Node::ref_type::weak >;
 template class ast::ptr_base< ast::Expr, ast::Node::ref_type::strong >;

src/AST/Pass.hpp

@@ -162 +162 @@
         const ast::Stmt *             visit( const ast::DeclStmt             * ) override final;
         const ast::Stmt *             visit( const ast::ImplicitCtorDtorStmt * ) override final;
+        const ast::Stmt *             visit( const ast::MutexStmt            * ) override final;
         const ast::Expr *             visit( const ast::ApplicationExpr      * ) override final;
         const ast::Expr *             visit( const ast::UntypedExpr          * ) override final;

src/AST/Pass.impl.hpp

@@ -1039 +1039 @@
 
 //--------------------------------------------------------------------------
+// MutexStmt
+template< typename core_t >
+const ast::Stmt * ast::Pass< core_t >::visit( const ast::MutexStmt * node ) {
+        VISIT_START( node );
+
+        VISIT({
+                // mutex statements introduce a level of scope (for the initialization)
+                guard_symtab guard { *this };
+                maybe_accept( node, &MutexStmt::stmt );
+                maybe_accept( node, &MutexStmt::mutexObjs );
+        })
+
+        VISIT_END( Stmt, node );
+}
+
+//--------------------------------------------------------------------------
 // ApplicationExpr
 template< typename core_t >

src/AST/Print.cpp

@@ -794 +794 @@
                 ++indent;
                 safe_print( node->callStmt );
+                --indent;
+                os << endl;
+
+                return node;
+        }
+
+        virtual const ast::Stmt * visit( const ast::MutexStmt * node ) override final {
+                os << "Mutex Statement" << endl;
+                os << indent << "... with Mutex Parameters: ";
+                ++indent;
+                printAll( node->mutexObjs );
+                --indent;
+                os << indent << "... with Statement: ";
+                ++indent;
+                safe_print( node->stmt );
                 --indent;
                 os << endl;

src/AST/Stmt.hpp

@@ -426 +426 @@
 };
 
+/// Mutex Statement
+class MutexStmt final : public Stmt {
+public:
+        ptr<Stmt> stmt;
+        std::vector<ptr<Expr>> mutexObjs;
+
+        MutexStmt( const CodeLocation & loc, const Stmt * stmt, 
+                std::vector<ptr<Expr>> && mutexes, std::vector<Label> && labels = {} )
+        : Stmt(loc, std::move(labels)), stmt(stmt), mutexObjs(std::move(mutexes)) {}
+
+        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
+private:
+        MutexStmt * clone() const override { return new MutexStmt{ *this }; }
+        MUTATE_FRIEND
+};
+
 }
 

src/AST/Visitor.hpp

@@ -54 +54 @@
     virtual const ast::Stmt *             visit( const ast::DeclStmt             * ) = 0;
     virtual const ast::Stmt *             visit( const ast::ImplicitCtorDtorStmt * ) = 0;
+    virtual const ast::Stmt *             visit( const ast::MutexStmt            * ) = 0;
     virtual const ast::Expr *             visit( const ast::ApplicationExpr      * ) = 0;
     virtual const ast::Expr *             visit( const ast::UntypedExpr          * ) = 0;

src/CodeGen/CodeGenerator.cc

@@ -1187 +1187 @@
         }
 
+        void CodeGenerator::postvisit( MutexStmt * stmt ) {
+                assertf( ! options.genC, "ImplicitCtorDtorStmts should not reach code generation." );
+                stmt->stmt->accept( *visitor );
+        }
+
         void CodeGenerator::handleStorageClass( DeclarationWithType * decl ) {
                 if ( decl->get_storageClasses().any() ) {

src/CodeGen/CodeGenerator.h

@@ -121 +121 @@
                 void postvisit( DeclStmt * );
                 void postvisit( ImplicitCtorDtorStmt * );
+                void postvisit( MutexStmt * stmt );
 
                 void genAttributes( std::list< Attribute * > & attributes );

src/Common/CodeLocationTools.cpp

@@ -125 +125 @@
     macro(DeclStmt, Stmt) \
     macro(ImplicitCtorDtorStmt, Stmt) \
+    macro(MutexStmt, Stmt) \
     macro(ApplicationExpr, Expr) \
     macro(UntypedExpr, Expr) \

src/Common/PassVisitor.h

@@ -124 +124 @@
         virtual void visit( ImplicitCtorDtorStmt * impCtorDtorStmt ) override final;
         virtual void visit( const ImplicitCtorDtorStmt * impCtorDtorStmt ) override final;
+        virtual void visit( MutexStmt * mutexStmt ) override final;
+        virtual void visit( const MutexStmt * mutexStmt ) override final;
 
         virtual void visit( ApplicationExpr * applicationExpr ) override final;
@@ -291 +293 @@
         virtual Statement * mutate( DeclStmt * declStmt ) override final;
         virtual Statement * mutate( ImplicitCtorDtorStmt * impCtorDtorStmt ) override final;
+        virtual Statement * mutate( MutexStmt * mutexStmt ) override final;
 
         virtual Expression * mutate( ApplicationExpr * applicationExpr ) override final;

src/Common/PassVisitor.impl.h

@@ -1781 +1781 @@
 
 //--------------------------------------------------------------------------
+// MutexStmt
+template< typename pass_type >
+void PassVisitor< pass_type >::visit( MutexStmt * node ) {
+        VISIT_START( node );
+        // mutex statements introduce a level of scope (for the initialization)
+        maybeAccept_impl( node->mutexObjs, *this );
+        {
+                auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
+                node->stmt = visitStatement( node->stmt );
+        }
+        VISIT_END( node );
+}
+
+template< typename pass_type >
+void PassVisitor< pass_type >::visit( const MutexStmt * node ) {
+        VISIT_START( node );
+        maybeAccept_impl( node->mutexObjs, *this );
+        {
+                auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
+                visitStatement( node->stmt );
+        }
+        VISIT_END( node );
+}
+
+template< typename pass_type >
+Statement * PassVisitor< pass_type >::mutate( MutexStmt * node ) {
+        MUTATE_START( node );
+        maybeMutate_impl( node->mutexObjs, *this );
+        {
+                auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
+                node->stmt = mutateStatement( node->stmt );
+        }
+        MUTATE_END( Statement, node );
+}
+
+//--------------------------------------------------------------------------
 // ApplicationExpr
 template< typename pass_type >

src/Concurrency/Keywords.cc

@@ -302 +302 @@
                 void postvisit( FunctionDecl * decl );
                 void postvisit(   StructDecl * decl );
+                Statement * postmutate( MutexStmt * stmt );
 
                 std::list<DeclarationWithType*> findMutexArgs( FunctionDecl*, bool & first );
@@ -307 +308 @@
                 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 +314 @@
                         PassVisitor< MutexKeyword > impl;
                         acceptAll( translationUnit, impl );
+                        mutateAll( translationUnit, impl );
                 }
 
@@ -935 +938 @@
                         thread_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 +1069 @@
                         ))
                 );
+        }
+
+        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 StructInstType(
+                                                noQualifiers,
+                                                monitor_decl
+                                        )
+                                ),
+                                new ConstantExpr( Constant::from_ulong( args.size() ) ),
+                                false,
+                                false
+                        ),
+                        new ListInit(
+                                map_range < std::list<Initializer*> > ( args, [](Expression * var ){
+                                        return new SingleInit( new UntypedExpr(
+                                                new NameExpr( "get_monitor" ),
+                                                { var }
+                                        ) );
+                                })
+                        )
+                );
+
+                // in reverse order :
+                // monitor_guard_t __guard = { __monitors, # };
+                body->push_front(
+                        new DeclStmt( new ObjectDecl(
+                                "__guard",
+                                noStorageClasses,
+                                LinkageSpec::Cforall,
+                                nullptr,
+                                new StructInstType(
+                                        noQualifiers,
+                                        guard_decl
+                                ),
+                                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) );
         }
 

src/Parser/ParseNode.h

@@ -437 +437 @@
 WaitForStmt * build_waitfor_timeout( ExpressionNode * timeout, StatementNode * stmt, ExpressionNode * when, StatementNode * else_stmt, ExpressionNode * else_when );
 Statement * build_with( ExpressionNode * exprs, StatementNode * stmt );
+Statement * build_mutex( ExpressionNode * exprs, StatementNode * stmt );
 
 //##############################################################################

src/Parser/StatementNode.cc

@@ -374 +374 @@
 } // build_directive
 
+Statement * build_mutex( ExpressionNode * exprs, StatementNode * stmt ) {
+        std::list< Expression * > expList;
+        buildMoveList( exprs, expList );
+        Statement * body = maybeMoveBuild<Statement>( stmt );
+        return new MutexStmt( body, expList );
+} // build_mutex
+
 // Local Variables: //
 // tab-width: 4 //

src/Parser/parser.yy

@@ -1347 +1347 @@
 mutex_statement:
         MUTEX '(' argument_expression_list_opt ')' statement
-                { SemanticError( yylloc, "Mutex statement is currently unimplemented." ); $$ = nullptr; }
+                { $$ = new StatementNode( build_mutex( $3, $5 ) ); }
         ;
 

src/SynTree/Mutator.h

@@ -58 +58 @@
         virtual Statement * mutate( DeclStmt * declStmt ) = 0;
         virtual Statement * mutate( ImplicitCtorDtorStmt * impCtorDtorStmt ) = 0;
+        virtual Statement * mutate( MutexStmt * mutexStmt ) = 0;
 
         virtual Expression * mutate( ApplicationExpr * applicationExpr ) = 0;

src/SynTree/Statement.cc

@@ -565 +565 @@
 }
 
+MutexStmt::MutexStmt( Statement * stmt, std::list<Expression *> mutexObjs ) 
+        : Statement(), stmt( stmt ), mutexObjs( mutexObjs ) { }
+
+MutexStmt::MutexStmt( const MutexStmt & other ) : Statement( other ), stmt( maybeClone( other.stmt ) ) {
+        cloneAll( other.mutexObjs, mutexObjs );
+}
+
+MutexStmt::~MutexStmt() {
+        deleteAll( mutexObjs );
+        delete stmt;
+}
+
+void MutexStmt::print( std::ostream & os, Indenter indent ) const {
+        os << "Mutex Statement" << endl;
+        os << indent << "... with Expressions: " << endl;
+        for (auto * obj : mutexObjs) {
+                os << indent+1;
+                obj->print( os, indent+1);
+                os << endl;
+        }
+        os << indent << "... with Statement: " << endl << indent+1;
+        stmt->print( os, indent+1 );
+}
+
 // Local Variables: //
 // tab-width: 4 //

src/SynTree/Statement.h

@@ -535 +535 @@
 };
 
+class MutexStmt : public Statement {
+  public:
+        Statement * stmt;
+        std::list<Expression *> mutexObjs; // list of mutex objects to acquire
+
+        MutexStmt( Statement * stmt, std::list<Expression *> mutexObjs );
+        MutexStmt( const MutexStmt & other );
+        virtual ~MutexStmt();
+
+        virtual MutexStmt * clone() const override { return new MutexStmt( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
+        virtual Statement * acceptMutator( Mutator & m )  override { return m.mutate( this ); }
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
+};
+
 // Local Variables: //
 // tab-width: 4 //

src/SynTree/SynTree.h

@@ -62 +62 @@
 class NullStmt;
 class ImplicitCtorDtorStmt;
+class MutexStmt;
 
 class Expression;

src/SynTree/Visitor.h

@@ -92 +92 @@
         virtual void visit( ImplicitCtorDtorStmt * node ) { visit( const_cast<const ImplicitCtorDtorStmt *>(node) ); }
         virtual void visit( const ImplicitCtorDtorStmt * impCtorDtorStmt ) = 0;
+        virtual void visit( MutexStmt * node ) { visit( const_cast<const MutexStmt *>(node) ); }
+        virtual void visit( const MutexStmt * mutexStmt ) = 0;
 
         virtual void visit( ApplicationExpr * node ) { visit( const_cast<const ApplicationExpr *>(node) ); }