Changeset 52fad0c

Timestamp:

Aug 27, 2021, 3:52:13 PM (3 years ago)

Author:

Henry Xue <y58xue@…>

Branches:

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

Children:

1d402be

Parents:

6c2dc00 (diff), 702839bb (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)
• libcfa/src/concurrency/mutex_stmt.hfa (added)
• src/Concurrency/Keywords.cc (modified) (11 diffs)
• tests/Makefile.am (modified) (1 diff)
• tests/concurrent/mutexstmt/.expect/locks.txt (added)
• tests/concurrent/mutexstmt/locks.cfa (modified) (3 diffs)
• tests/concurrent/mutexstmt/monitors.cfa (modified) (2 diffs)

libcfa/src/concurrency/monitor.cfa

@@ -990 +990 @@
 }
 
+//-----------------------------------------------------------------------------
+// Enter routine for mutex stmt
+// Can't be accepted since a mutex stmt is effectively an anonymous routine
+// Thus we do not need a monitor group
+void lock( monitor$ * this ) {
+        thread$ * thrd = active_thread();
+
+        // Lock the monitor spinlock
+        lock( this->lock __cfaabi_dbg_ctx2 );
+
+        __cfaabi_dbg_print_safe( "Kernel : %10p Entering mon %p (%p)\n", thrd, this, this->owner);
+
+        if( unlikely(0 != (0x1 & (uintptr_t)this->owner)) ) {
+                abort( "Attempt by thread \"%.256s\" (%p) to access joined monitor %p.", thrd->self_cor.name, thrd, this );
+        }
+        else if( !this->owner ) {
+                // No one has the monitor, just take it
+                __set_owner( this, thrd );
+
+                __cfaabi_dbg_print_safe( "Kernel :  mon is free \n" );
+        }
+        else if( this->owner == thrd) {
+                // We already have the monitor, just note how many times we took it
+                this->recursion += 1;
+
+                __cfaabi_dbg_print_safe( "Kernel :  mon already owned \n" );
+        }
+        else {
+                __cfaabi_dbg_print_safe( "Kernel :  blocking \n" );
+
+                // Some one else has the monitor, wait in line for it
+                /* paranoid */ verify( thrd->link.next == 0p );
+                append( this->entry_queue, thrd );
+                /* paranoid */ verify( thrd->link.next == 1p );
+
+                unlock( this->lock );
+                park();
+
+                __cfaabi_dbg_print_safe( "Kernel : %10p Entered  mon %p\n", thrd, this);
+
+                /* paranoid */ verifyf( active_thread() == this->owner, "Expected owner to be %p, got %p (r: %i, m: %p)", active_thread(), this->owner, this->recursion, this );
+                return;
+        }
+
+        __cfaabi_dbg_print_safe( "Kernel : %10p Entered  mon %p\n", thrd, this);
+
+        /* paranoid */ verifyf( active_thread() == this->owner, "Expected owner to be %p, got %p (r: %i, m: %p)", active_thread(), this->owner, this->recursion, this );
+        /* paranoid */ verify( this->lock.lock );
+
+        // Release the lock and leave
+        unlock( this->lock );
+        return;
+}
+
+// Leave routine for mutex stmt
+// Is just a wrapper around __leave for the is_lock trait to see
+void unlock( monitor$ * this ) { __leave( this ); }
+
 // Local Variables: //
 // mode: c //

libcfa/src/concurrency/monitor.hfa

@@ -149 +149 @@
 void __waitfor_internal( const __waitfor_mask_t & mask, int duration );
 
+// lock and unlock routines for mutex statements to use
+void lock( monitor$ * this );
+void unlock( monitor$ * this );
+
 // Local Variables: //
 // mode: c //

src/Concurrency/Keywords.cc

@@ -93 +93 @@
                 ObjectDecl * addField( StructDecl * );
                 void addRoutines( ObjectDecl *, FunctionDecl * );
+                void addLockUnlockRoutines( StructDecl * );
 
                 virtual bool is_target( StructDecl * decl ) = 0;
@@ -322 +323 @@
                 StructDecl* dtor_guard_decl = nullptr;
                 StructDecl* thread_guard_decl = nullptr;
+                StructDecl* lock_guard_decl = nullptr;
 
                 static std::unique_ptr< Type > generic_func;
@@ -463 +465 @@
         }
 
-
         void ConcurrentSueKeyword::handle( StructDecl * decl ) {
                 if( ! decl->body ) return;
@@ -479 +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 );
         }
 
@@ -612 +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();
@@ -634 +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() );
+
+                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
+                );
+                fixupGenerics(lock_fn_type, decl);
+
+                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
+                );
+                fixupGenerics(unlock_fn_type, decl);
+
+                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 );
         }
 
@@ -937 +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;
                 }
         }
@@ -1081 +1200 @@
                                 new PointerType(
                                         noQualifiers,
-                                        new StructInstType(
-                                                noQualifiers,
-                                                monitor_decl
-                                        )
+                                        new TypeofType( noQualifiers, args.front()->clone() )
                                 ),
                                 new ConstantExpr( Constant::from_ulong( args.size() ) ),
@@ -1093 +1209 @@
                                 map_range < std::list<Initializer*> > ( args, [](Expression * var ){
                                         return new SingleInit( new UntypedExpr(
-                                                new NameExpr( "get_monitor" ),
+                                                new NameExpr( "__get_pointer" ),
                                                 { var }
                                         ) );
@@ -1099 +1215 @@
                         )
                 );
+
+                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 :
@@ -1108 +1229 @@
                                 LinkageSpec::Cforall,
                                 nullptr,
-                                new StructInstType(
-                                        noQualifiers,
-                                        guard_decl
-                                ),
+                                lock_guard_struct,
                                 new ListInit(
                                         {

tests/Makefile.am

@@ -82 +82 @@
         concurrent/clib_tls.c \
         exceptions/with-threads.hfa \
-        exceptions/except-io.hfa \
-        unified_locking/mutex_test.hfa
+        exceptions/except-io.hfa
 
 dist-hook:

tests/concurrent/mutexstmt/locks.cfa

@@ -1 @@
-#include <mutex_stmt_locks.hfa>
+#include <mutex_stmt.hfa>
 #include <locks.hfa>
 
@@ -13 +13 @@
         for (unsigned int i = 0; i < num_times; i++) {
                 mutex ( m1 ) count++;
-                mutex ( m1 ) {
+                mutex ( m1 ) { 
                         assert(!insideFlag);
                         insideFlag = true;
@@ -65 +65 @@
         printf("Start Test: single lock mutual exclusion\n");
         {
-                T_Mutex t[10];
+                T_Mutex t[1];
         }
         printf("End Test: single lock mutual exclusion\n");

tests/concurrent/mutexstmt/monitors.cfa

@@ -1 +1 @@
 #include <monitor.hfa>
+#include <mutex_stmt.hfa>
 #include <stdio.h>
 #include <stdlib.hfa>
@@ -13 +14 @@
 bool insideFlag = false;
 int count = 0;
+bool startFlag = false;
 
 void main( T_Mutex & this ) {