Changes in / [eaeca5f:cfbab07]


Ignore:
Files:
4 deleted
12 edited

Legend:

Unmodified
Added
Removed

  • libcfa/src/Makefile.am

    reaeca5f rcfbab07  
    5959        containers/array.hfa \
    6060        concurrency/iofwd.hfa \
    61         concurrency/mutex_stmt.hfa \
    6261        containers/list.hfa \
    6362        containers/queueLockFree.hfa \

  • libcfa/src/concurrency/monitor.cfa

    reaeca5f rcfbab07  
    990990}
    991991
    992 //-----------------------------------------------------------------------------
    993 // Enter routine for mutex stmt
    994 // Can't be accepted since a mutex stmt is effectively an anonymous routine
    995 // Thus we do not need a monitor group
    996 void lock( monitor$ * this ) {
    997         thread$ * thrd = active_thread();
    998 
    999         // Lock the monitor spinlock
    1000         lock( this->lock __cfaabi_dbg_ctx2 );
    1001 
    1002         __cfaabi_dbg_print_safe( "Kernel : %10p Entering mon %p (%p)\n", thrd, this, this->owner);
    1003 
    1004         if( unlikely(0 != (0x1 & (uintptr_t)this->owner)) ) {
    1005                 abort( "Attempt by thread \"%.256s\" (%p) to access joined monitor %p.", thrd->self_cor.name, thrd, this );
    1006         }
    1007         else if( !this->owner ) {
    1008                 // No one has the monitor, just take it
    1009                 __set_owner( this, thrd );
    1010 
    1011                 __cfaabi_dbg_print_safe( "Kernel :  mon is free \n" );
    1012         }
    1013         else if( this->owner == thrd) {
    1014                 // We already have the monitor, just note how many times we took it
    1015                 this->recursion += 1;
    1016 
    1017                 __cfaabi_dbg_print_safe( "Kernel :  mon already owned \n" );
    1018         }
    1019         else {
    1020                 __cfaabi_dbg_print_safe( "Kernel :  blocking \n" );
    1021 
    1022                 // Some one else has the monitor, wait in line for it
    1023                 /* paranoid */ verify( thrd->link.next == 0p );
    1024                 append( this->entry_queue, thrd );
    1025                 /* paranoid */ verify( thrd->link.next == 1p );
    1026 
    1027                 unlock( this->lock );
    1028                 park();
    1029 
    1030                 __cfaabi_dbg_print_safe( "Kernel : %10p Entered  mon %p\n", thrd, this);
    1031 
    1032                 /* paranoid */ verifyf( active_thread() == this->owner, "Expected owner to be %p, got %p (r: %i, m: %p)", active_thread(), this->owner, this->recursion, this );
    1033                 return;
    1034         }
    1035 
    1036         __cfaabi_dbg_print_safe( "Kernel : %10p Entered  mon %p\n", thrd, this);
    1037 
    1038         /* paranoid */ verifyf( active_thread() == this->owner, "Expected owner to be %p, got %p (r: %i, m: %p)", active_thread(), this->owner, this->recursion, this );
    1039         /* paranoid */ verify( this->lock.lock );
    1040 
    1041         // Release the lock and leave
    1042         unlock( this->lock );
    1043         return;
    1044 }
    1045 
    1046 // Leave routine for mutex stmt
    1047 // Is just a wrapper around __leave for the is_lock trait to see
    1048 void unlock( monitor$ * this ) { __leave( this ); }
    1049 
    1050992// Local Variables: //
    1051993// mode: c //

  • libcfa/src/concurrency/monitor.hfa

    reaeca5f rcfbab07  
    149149void __waitfor_internal( const __waitfor_mask_t & mask, int duration );
    150150
    151 // lock and unlock routines for mutex statements to use
    152 void lock( monitor$ * this );
    153 void unlock( monitor$ * this );
    154 
    155151// Local Variables: //
    156152// mode: c //

  • src/Concurrency/Keywords.cc

    reaeca5f rcfbab07  
    9393                ObjectDecl * addField( StructDecl * );
    9494                void addRoutines( ObjectDecl *, FunctionDecl * );
    95                 void addLockUnlockRoutines( StructDecl * );
    9695
    9796                virtual bool is_target( StructDecl * decl ) = 0;
    … …  
    323322                StructDecl* dtor_guard_decl = nullptr;
    324323                StructDecl* thread_guard_decl = nullptr;
    325                 StructDecl* lock_guard_decl = nullptr;
    326324
    327325                static std::unique_ptr< Type > generic_func;
    … …  
    465463        }
    466464
     465
    467466        void ConcurrentSueKeyword::handle( StructDecl * decl ) {
    468467                if( ! decl->body ) return;
    … …  
    480479                FunctionDecl * func = forwardDeclare( decl );
    481480                ObjectDecl * field = addField( decl );
    482 
    483                 // add get_.* routine
    484481                addRoutines( field, func );
    485                 // add lock/unlock routines to monitors for use by mutex stmt
    486                 addLockUnlockRoutines( decl );
    487482        }
    488483
    … …  
    617612        }
    618613
    619         // This function adds the get_.* routine body for coroutines, monitors etc
    620         //              after their corresponding struct has been made
    621614        void ConcurrentSueKeyword::addRoutines( ObjectDecl * field, FunctionDecl * func ) {
    622615                CompoundStmt * statement = new CompoundStmt();
    … …  
    641634
    642635                declsToAddAfter.push_back( get_decl );
    643         }
    644 
    645         // Generates lock/unlock routines for monitors to be used by mutex stmts
    646         void ConcurrentSueKeyword::addLockUnlockRoutines( StructDecl * decl ) {
    647                 // this routine will be called for all ConcurrentSueKeyword children so only continue if we are a monitor
    648                 if ( !decl->is_monitor() ) return;
    649 
    650                 FunctionType * lock_fn_type = new FunctionType( noQualifiers, false );
    651                 FunctionType * unlock_fn_type = new FunctionType( noQualifiers, false );
    652 
    653                 // create this ptr parameter for both routines
    654                 ObjectDecl * this_decl = new ObjectDecl(
    655                         "this",
    656                         noStorageClasses,
    657                         LinkageSpec::Cforall,
    658                         nullptr,
    659                         new ReferenceType(
    660                                 noQualifiers,
    661                                 new StructInstType(
    662                                         noQualifiers,
    663                                         decl
    664                                 )
    665                         ),
    666                         nullptr
    667                 );
    668 
    669                 lock_fn_type->get_parameters().push_back( this_decl->clone() );
    670                 unlock_fn_type->get_parameters().push_back( this_decl->clone() );
    671                 fixupGenerics(lock_fn_type, decl);
    672                 fixupGenerics(unlock_fn_type, decl);
    673 
    674                 delete this_decl;
    675 
    676 
    677                 //////////////////////////////////////////////////////////////////////
    678                 // The following generates this lock routine for all monitors
    679                 /*
    680                         void lock (monitor_t & this) {
    681                                 lock(get_monitor(this));
    682                         }       
    683                 */
    684                 FunctionDecl * lock_decl = new FunctionDecl(
    685                         "lock",
    686                         Type::Static,
    687                         LinkageSpec::Cforall,
    688                         lock_fn_type,
    689                         nullptr,
    690                         { },
    691                         Type::Inline
    692                 );
    693 
    694                 UntypedExpr * get_monitor_lock =  new UntypedExpr (
    695                         new NameExpr( "get_monitor" ),
    696                         { new VariableExpr( lock_fn_type->get_parameters().front() ) }
    697                 );
    698 
    699                 CompoundStmt * lock_statement = new CompoundStmt();
    700                 lock_statement->push_back(
    701                         new ExprStmt(
    702                                 new UntypedExpr (
    703                                         new NameExpr( "lock" ),
    704                                         {
    705                                                 get_monitor_lock
    706                                         }
    707                                 )
    708                         )
    709                 );
    710                 lock_decl->set_statements( lock_statement );
    711 
    712                 //////////////////////////////////////////////////////////////////
    713                 // The following generates this routine for all monitors
    714                 /*
    715                         void unlock (monitor_t & this) {
    716                                 unlock(get_monitor(this));
    717                         }       
    718                 */
    719                 FunctionDecl * unlock_decl = new FunctionDecl(
    720                         "unlock",
    721                         Type::Static,
    722                         LinkageSpec::Cforall,
    723                         unlock_fn_type,
    724                         nullptr,
    725                         { },
    726                         Type::Inline
    727                 );
    728 
    729                 CompoundStmt * unlock_statement = new CompoundStmt();
    730 
    731                 UntypedExpr * get_monitor_unlock =  new UntypedExpr (
    732                         new NameExpr( "get_monitor" ),
    733                         { new VariableExpr( unlock_fn_type->get_parameters().front() ) }
    734                 );
    735 
    736                 unlock_statement->push_back(
    737                         new ExprStmt(
    738                                 new UntypedExpr(
    739                                         new NameExpr( "unlock" ),
    740                                         {
    741                                                 get_monitor_unlock
    742                                         }
    743                                 )
    744                         )
    745                 );
    746                 unlock_decl->set_statements( unlock_statement );
    747                
    748                 // pushes routines to declsToAddAfter to add at a later time
    749                 declsToAddAfter.push_back( lock_decl );
    750                 declsToAddAfter.push_back( unlock_decl );
    751636        }
    752637
    … …  
    1052937                        assert( !thread_guard_decl );
    1053938                        thread_guard_decl = decl;
    1054                 }
    1055                 else if ( decl->name == "__mutex_stmt_lock_guard" && decl->body ) {
    1056                         assert( !lock_guard_decl );
    1057                         lock_guard_decl = decl;
    1058939                }
    1059940        }
    … …  
    12001081                                new PointerType(
    12011082                                        noQualifiers,
    1202                                         new TypeofType( noQualifiers, args.front()->clone() )
     1083                                        new StructInstType(
     1084                                                noQualifiers,
     1085                                                monitor_decl
     1086                                        )
    12031087                                ),
    12041088                                new ConstantExpr( Constant::from_ulong( args.size() ) ),
    … …  
    12091093                                map_range < std::list<Initializer*> > ( args, [](Expression * var ){
    12101094                                        return new SingleInit( new UntypedExpr(
    1211                                                 new NameExpr( "__get_pointer" ),
     1095                                                new NameExpr( "get_monitor" ),
    12121096                                                { var }
    12131097                                        ) );
    … …  
    12151099                        )
    12161100                );
    1217 
    1218                 StructInstType * lock_guard_struct = new StructInstType( noQualifiers, lock_guard_decl );
    1219                 TypeExpr * lock_type_expr = new TypeExpr( new TypeofType( noQualifiers, args.front()->clone() ) );
    1220 
    1221                 lock_guard_struct->parameters.push_back( lock_type_expr ) ;
    12221101
    12231102                // in reverse order :
    … …  
    12291108                                LinkageSpec::Cforall,
    12301109                                nullptr,
    1231                                 lock_guard_struct,
     1110                                new StructInstType(
     1111                                        noQualifiers,
     1112                                        guard_decl
     1113                                ),
    12321114                                new ListInit(
    12331115                                        {

  • src/MakeLibCfa.h

    reaeca5f rcfbab07  
    1919
    2020class Declaration;
    21 namespace ast {
    22         struct TranslationUnit;
    23 }
    2421
    2522namespace LibCfa {
    2623        void makeLibCfa( std::list< Declaration* > &prelude );
    27         void makeLibCfa( ast::TranslationUnit & translationUnit );
    2824} // namespace LibCfa
    2925

  • src/Makefile.am

    reaeca5f rcfbab07  
    2323      CompilationState.h \
    2424      MakeLibCfa.cc \
    25           MakeLibCfaNew.cpp \
    2625        MakeLibCfa.h
    2726

  • src/Tuples/Tuples.h

    reaeca5f rcfbab07  
    99// Author           : Rodolfo G. Esteves
    1010// Created On       : Mon May 18 07:44:20 2015
    11 // Last Modified By : Henry Xue
    12 // Last Modified On : Mon Aug 23 15:36:09 2021
    13 // Update Count     : 19
     11// Last Modified By : Andrew Beach
     12// Last Modified On : Tue Jun 18 09:36:00 2019
     13// Update Count     : 18
    1414//
    1515
    … …  
    3939        /// expands z.[a, b.[x, y], c] into [z.a, z.b.x, z.b.y, z.c], inserting UniqueExprs as appropriate
    4040        void expandMemberTuples( std::list< Declaration * > & translationUnit );
    41         void expandMemberTuples( ast::TranslationUnit & translationUnit );
    4241
    4342        /// replaces tuple-related elements, such as TupleType, TupleExpr, TupleAssignExpr, etc.

  • src/Tuples/module.mk

    reaeca5f rcfbab07  
    1010## Author           : Richard C. Bilson
    1111## Created On       : Mon Jun  1 17:49:17 2015
    12 ## Last Modified By : Henry Xue
    13 ## Last Modified On : Mon Aug 23 15:36:09 2021
    14 ## Update Count     : 2
     12## Last Modified By : Peter A. Buhr
     13## Last Modified On : Mon Jun  1 17:54:33 2015
     14## Update Count     : 1
    1515###############################################################################
    1616
    … …  
    2020        Tuples/TupleAssignment.cc \
    2121        Tuples/TupleExpansion.cc \
    22         Tuples/TupleExpansionNew.cpp \
    2322        Tuples/Tuples.cc \
    2423        Tuples/Tuples.h

  • src/main.cc

    reaeca5f rcfbab07  
    1010// Created On       : Fri May 15 23:12:02 2015
    1111// Last Modified By : Henry Xue
    12 // Last Modified On : Mon Aug 23 15:42:08 2021
    13 // Update Count     : 650
     12// Last Modified On : Tue Jul 20 04:27:35 2021
     13// Update Count     : 658
    1414//
    1515
    … …  
    335335                PASS( "Fix Names", CodeGen::fixNames( translationUnit ) );
    336336                PASS( "Gen Init", InitTweak::genInit( translationUnit ) );
    337 
     337                PASS( "Expand Member Tuples" , Tuples::expandMemberTuples( translationUnit ) );
    338338                if ( libcfap ) {
    339339                        // generate the bodies of cfa library functions
    … …  
    365365                        }
    366366                        auto transUnit = convert( move( translationUnit ) );
    367 
    368                         PASS( "Expand Member Tuples" , Tuples::expandMemberTuples( transUnit ) );
    369                        
    370367                        PASS( "Resolve", ResolvExpr::resolve( transUnit ) );
    371368                        if ( exprp ) {
    … …  
    379376                        translationUnit = convert( move( transUnit ) );
    380377                } else {
    381                         PASS( "Expand Member Tuples" , Tuples::expandMemberTuples( translationUnit ) );
    382 
    383378                        PASS( "Resolve", ResolvExpr::resolve( translationUnit ) );
    384379                        if ( exprp ) {

  • tests/Makefile.am

    reaeca5f rcfbab07  
    8282        concurrent/clib_tls.c \
    8383        exceptions/with-threads.hfa \
    84         exceptions/except-io.hfa
     84        exceptions/except-io.hfa \
     85        unified_locking/mutex_test.hfa
    8586
    8687dist-hook:

  • tests/concurrent/mutexstmt/locks.cfa

    reaeca5f rcfbab07  
    1 #include <mutex_stmt.hfa>
     1#include <mutex_stmt_locks.hfa>
    22#include <locks.hfa>
    33
    … …  
    1313        for (unsigned int i = 0; i < num_times; i++) {
    1414                mutex ( m1 ) count++;
    15                 mutex ( m1 ) { 
     15                mutex ( m1 ) {
    1616                        assert(!insideFlag);
    1717                        insideFlag = true;
    … …  
    6565        printf("Start Test: single lock mutual exclusion\n");
    6666        {
    67                 T_Mutex t[1];
     67                T_Mutex t[10];
    6868        }
    6969        printf("End Test: single lock mutual exclusion\n");

  • tests/concurrent/mutexstmt/monitors.cfa

    reaeca5f rcfbab07  
    11#include <monitor.hfa>
    2 #include <mutex_stmt.hfa>
    32#include <stdio.h>
    43#include <stdlib.hfa>
    … …  
    1413bool insideFlag = false;
    1514int count = 0;
    16 bool startFlag = false;
    1715
    1816void main( T_Mutex & this ) {
Note: See TracChangeset for help on using the changeset viewer.