Changeset 0d4456b


Ignore:
Timestamp:
Nov 12, 2020, 11:28:00 AM (3 years ago)
Author:
Peter A. Buhr <pabuhr@…>
Branches:
ADT, arm-eh, ast-experimental, enum, forall-pointer-decay, jacob/cs343-translation, master, new-ast-unique-expr, pthread-emulation, qualifiedEnum
Children:
0b996a1
Parents:
6403ae5 (diff), 23954b6 (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:
1 added
4 edited

Legend:

Unmodified
Added
Removed

  • libcfa/src/Makefile.am

    r6403ae5 r0d4456b  
    9696        concurrency/exception.hfa \
    9797        concurrency/kernel.hfa \
     98        concurrency/locks.hfa \
    9899        concurrency/monitor.hfa \
    99100        concurrency/mutex.hfa \

  • libcfa/src/concurrency/locks.cfa

    r6403ae5 r0d4456b  
    5151}
    5252
    53 void ?{}( mutex_lock & this ) {
     53void ?{}( single_acquisition_lock & this ) {
    5454        ((blocking_lock &)this){ false, false };
    5555}
    5656
    57 void ^?{}( mutex_lock & this ) {
     57void ^?{}( single_acquisition_lock & this ) {
    5858        // default
    5959}
    … …  
    6767}
    6868
    69 void ?{}( recursive_mutex_lock & this ) {
     69void ?{}( multiple_acquisition_lock & this ) {
    7070        ((blocking_lock &)this){ true, false };
    7171}
    7272
    73 void ^?{}( recursive_mutex_lock & this ) {
     73void ^?{}( multiple_acquisition_lock & this ) {
    7474        // default
    7575}
    7676
    7777void lock( blocking_lock & this ) with( this ) {
    78         $thread * thrd = active_thread();
    7978        lock( lock __cfaabi_dbg_ctx2 );
    80         if ( owner == thrd && !multi_acquisition) {
     79        if ( owner == active_thread() && !multi_acquisition) {
    8180                fprintf(stderr, "A single acquisition lock holder attempted to reacquire the lock resulting in a deadlock."); // Possibly throw instead
    8281        exit(EXIT_FAILURE);
    83         } else if ( owner != 0p && owner != thrd ) {
    84                 append( blocked_threads, thrd );
     82        } else if ( owner != 0p && owner != active_thread() ) {
     83                append( blocked_threads, active_thread() );
    8584                wait_count++;
    8685                unlock( lock );
    8786                park( );
    88         } else if ( owner == thrd && multi_acquisition ) {
     87        } else if ( owner == active_thread() && multi_acquisition ) {
    8988                recursion_count++;
    9089                unlock( lock );
    9190        } else {
    92                 owner = thrd;
     91                owner = active_thread();
    9392                recursion_count = 1;
    9493                unlock( lock );
    … …  
    9796
    9897bool try_lock( blocking_lock & this ) with( this ) {
    99         $thread * thrd = active_thread();
    10098        bool ret = false;
    10199        lock( lock __cfaabi_dbg_ctx2 );
    102100        if ( owner == 0p ) {
    103                 owner = thrd;
    104                 if ( multi_acquisition ) recursion_count = 1;
     101                owner = active_thread();
     102                recursion_count = 1;
    105103                ret = true;
    106         } else if ( owner == thrd && multi_acquisition ) {
     104        } else if ( owner == active_thread() && multi_acquisition ) {
    107105                recursion_count++;
    108106                ret = true;
    … …  
    115113        lock( lock __cfaabi_dbg_ctx2 );
    116114        if ( owner == 0p ){ // no owner implies lock isn't held
    117                 fprintf( stderr, "There was an attempt to release a lock that isn't held" );
     115                fprintf( stderr, "There was an attempt to release a lock that isn't held" ); 
    118116                return;
    119         } else if ( strict_owner && active_thread() ) {
    120                 fprintf( stderr, "A thread other than the owner attempted to release an owner lock" );
     117        } else if ( strict_owner && owner != active_thread() ) {
     118                fprintf( stderr, "A thread other than the owner attempted to release an owner lock" ); 
    121119                return;
    122120        }
    … …  
    125123                $thread * thrd = pop_head( blocked_threads );
    126124                owner = thrd;
    127                 recursion_count = ( thrd && multi_acquisition ? 1 : 0 );
     125                recursion_count = ( thrd ? 1 : 0 );
    128126                wait_count--;
    129127                unpark( thrd );
    … …  
    153151        } else {
    154152                owner = t;
    155                 if ( multi_acquisition ) recursion_count = 1;
     153                recursion_count = 1;
    156154                #if !defined( __CFA_NO_STATISTICS__ )
    157                         kernelTLS.this_stats = t->curr_cluster->stats;
     155                        //kernelTLS.this_stats = t->curr_cluster->stats;
    158156                #endif
    159157                unpark( t );
    … …  
    165163    lock( lock __cfaabi_dbg_ctx2 );
    166164        if ( owner == 0p ){ // no owner implies lock isn't held
    167                 fprintf( stderr, "A lock that is not held was passed to a synchronization lock" );
    168         } else if ( strict_owner && active_thread() ) {
    169                 fprintf( stderr, "A thread other than the owner of a lock passed it to a synchronization lock" );
     165                fprintf( stderr, "A lock that is not held was passed to a synchronization lock" ); 
     166        } else if ( strict_owner && owner != active_thread() ) {
     167                fprintf( stderr, "A thread other than the owner of a lock passed it to a synchronization lock" ); 
    170168        } else {
    171169                $thread * thrd = pop_head( blocked_threads );
    172170                owner = thrd;
    173                 recursion_count = ( thrd && multi_acquisition ? 1 : 0 );
     171                recursion_count = ( thrd ? 1 : 0 );
    174172                wait_count--;
    175173                unpark( thrd );
    … …  
    184182// This is temporary until an inheritance bug is fixed
    185183
    186 void lock( mutex_lock & this ){
     184void lock( single_acquisition_lock & this ){
    187185        lock( (blocking_lock &)this );
    188186}
    189187
    190 void unlock( mutex_lock & this ){
     188void unlock( single_acquisition_lock & this ){
    191189        unlock( (blocking_lock &)this );
    192190}
    193191
    194 void add_( mutex_lock & this, struct $thread * t ){
     192void add_( single_acquisition_lock & this, struct $thread * t ){
    195193        add_( (blocking_lock &)this, t );
    196194}
    197195
    198 void remove_( mutex_lock & this ){
     196void remove_( single_acquisition_lock & this ){
    199197        remove_( (blocking_lock &)this );
    200198}
    201199
    202 void set_recursion_count( mutex_lock & this, size_t recursion ){
     200void set_recursion_count( single_acquisition_lock & this, size_t recursion ){
    203201        set_recursion_count( (blocking_lock &)this, recursion );
    204202}
    205203
    206 size_t get_recursion_count( mutex_lock & this ){
    207         get_recursion_count( (blocking_lock &)this );
    208 }
    209 
    210 void lock( recursive_mutex_lock & this ){
     204size_t get_recursion_count( single_acquisition_lock & this ){
     205        return get_recursion_count( (blocking_lock &)this );
     206}
     207
     208void lock( owner_lock & this ){
    211209        lock( (blocking_lock &)this );
    212210}
    213211
    214 void unlock( recursive_mutex_lock & this ){
     212void unlock( owner_lock & this ){
    215213        unlock( (blocking_lock &)this );
    216214}
    217215
    218 void add_( recursive_mutex_lock & this, struct $thread * t ){
     216void add_( owner_lock & this, struct $thread * t ){
    219217        add_( (blocking_lock &)this, t );
    220218}
    221219
    222 void remove_( recursive_mutex_lock & this ){
     220void remove_( owner_lock & this ){
    223221        remove_( (blocking_lock &)this );
    224222}
    225223
    226 void set_recursion_count( recursive_mutex_lock & this, size_t recursion ){
     224void set_recursion_count( owner_lock & this, size_t recursion ){
    227225        set_recursion_count( (blocking_lock &)this, recursion );
    228226}
    229227
    230 size_t get_recursion_count( recursive_mutex_lock & this ){
    231         get_recursion_count( (blocking_lock &)this );
     228size_t get_recursion_count( owner_lock & this ){
     229        return get_recursion_count( (blocking_lock &)this );
     230}
     231
     232void lock( multiple_acquisition_lock & this ){
     233        lock( (blocking_lock &)this );
     234}
     235
     236void unlock( multiple_acquisition_lock & this ){
     237        unlock( (blocking_lock &)this );
     238}
     239
     240void add_( multiple_acquisition_lock & this, struct $thread * t ){
     241        add_( (blocking_lock &)this, t );
     242}
     243
     244void remove_( multiple_acquisition_lock & this ){
     245        remove_( (blocking_lock &)this );
     246}
     247
     248void set_recursion_count( multiple_acquisition_lock & this, size_t recursion ){
     249        set_recursion_count( (blocking_lock &)this, recursion );
     250}
     251
     252size_t get_recursion_count( multiple_acquisition_lock & this ){
     253        return get_recursion_count( (blocking_lock &)this );
    232254}
    233255
    … …  
    244266                info_thread(L) * copy = *i;
    245267                        remove( cond->blocked_threads, i );              //remove this thread O(1)
    246                         cond->wait_count--;
     268                        cond->count--;
    247269                        if( !copy->lock ) {
    248                                 unlock( cond->lock );
    249270                                #if !defined( __CFA_NO_STATISTICS__ )
    250                                         #warning unprotected access to tls TODO discuss this
    251                                         kernelTLS.this_stats = copy->t->curr_cluster->stats;
     271                                        //kernelTLS.this_stats = copy->t->curr_cluster->stats;
    252272                                #endif
    253273                                unpark( copy->t );
    … …  
    285305                bool ret = !!blocked_threads;
    286306                info_thread(L) * popped = pop_head( blocked_threads );
    287                 popped->listed = false;
    288307                if(popped != 0p) {
     308                        popped->listed = false;
    289309                        count--;
    290310                        if (popped->lock) {
    … …  
    303323                while( blocked_threads ) {
    304324                        info_thread(L) * popped = pop_head( blocked_threads );
    305                         popped->listed = false;
    306325                        if(popped != 0p){
     326                                popped->listed = false;
    307327                                count--;
    308328                                if (popped->lock) {
    … …  
    341361                        remove_( *i.lock );
    342362                }
    343 
     363               
    344364                unlock( lock );
    345365                park( ); // blocks here
    … …  
    385405                queue_info_thread( this, i );
    386406        }
    387 
     407       
    388408        void wait( condition_variable(L) & this, Duration duration ) with(this) {
    389409                info_thread( L ) i = { active_thread() };
    … …  
    391411        }
    392412
    393         void wait( condition_variable(L) & this, uintptr_t info, Duration duration ) with(this) {
     413        void wait( condition_variable(L) & this, uintptr_t info, Duration duration ) with(this) { 
    394414                info_thread( L ) i = { active_thread(), info };
    395415                queue_info_thread_timeout(this, i, __kernel_get_time() + duration );
    … …  
    417437                queue_info_thread( this, i );
    418438        }
    419 
     439       
    420440        void wait( condition_variable(L) & this, L & l, Duration duration ) with(this) {
    421441                info_thread(L) i = { active_thread() };
    … …  
    423443                queue_info_thread_timeout(this, i, __kernel_get_time() + duration );
    424444        }
    425 
     445       
    426446        void wait( condition_variable(L) & this, L & l, uintptr_t info, Duration duration ) with(this) {
    427447                info_thread(L) i = { active_thread(), info };
    … …  
    429449                queue_info_thread_timeout(this, i, __kernel_get_time() + duration );
    430450        }
    431 
     451       
    432452        void wait( condition_variable(L) & this, L & l, Time time ) with(this) {
    433453                info_thread(L) i = { active_thread() };
    … …  
    435455                queue_info_thread_timeout(this, i, time );
    436456        }
    437 
     457       
    438458        void wait( condition_variable(L) & this, L & l, uintptr_t info, Time time ) with(this) {
    439459                info_thread(L) i = { active_thread(), info };
    … …  
    442462        }
    443463}
     464
     465// thread T1 {};
     466// thread T2 {};
     467
     468// multiple_acquisition_lock m;
     469// condition_variable( multiple_acquisition_lock ) c;
     470
     471// void main( T1 & this ) {
     472//      printf("T1 start\n");
     473//      lock(m);
     474//      printf("%d\n", counter(c));
     475//      if(empty(c)) {
     476//              printf("T1 wait\n");
     477//              wait(c,m,12);
     478//      }else{
     479//              printf("%d\n", front(c));
     480//              notify_one(c);
     481//      }
     482//      unlock(m);
     483//      printf("curr thd in main %p \n", active_thread());
     484//      printf("T1 waits for 2s\n");
     485//      lock(m);
     486//      wait( c, m, 2`s );
     487//      unlock(m);
     488//      printf("T1 wakes\n");
     489//      printf("T1 done\n");
     490// }
     491
     492// void main( T2 & this ) {
     493//      printf("T2 start\n");
     494//      lock(m);
     495//      printf("%d\n", counter(c));
     496//      if(empty(c)) {
     497//              printf("T2 wait\n");
     498//              wait(c,m,12);
     499//      }else{
     500//              printf("%d\n", front(c));
     501//              notify_one(c);
     502//      }
     503//      unlock(m);
     504//      printf("T2 done\n");
     505// }
     506
     507// int main() {
     508//      printf("start\n");
     509//      processor p[2];
     510//      {
     511//              T1 t1;
     512//              T2 t2;
     513//      }
     514//      printf("done\n");
     515// }

  • libcfa/src/concurrency/locks.hfa

    r6403ae5 r0d4456b  
    4949//// Blocking Locks
    5050///////////////////////////////////////////////////////////////////
     51
    5152struct blocking_lock {
    5253        // Spin lock used for mutual exclusion
    … …  
    7273};
    7374
    74 struct mutex_lock {
     75struct single_acquisition_lock {
    7576        inline blocking_lock;
    7677};
    … …  
    8081};
    8182
    82 struct recursive_mutex_lock {
     83struct multiple_acquisition_lock {
    8384        inline blocking_lock;
    8485};
    … …  
    8788void ^?{}( blocking_lock & this );
    8889
    89 void ?{}( mutex_lock & this );
    90 void ^?{}( mutex_lock & this );
     90void ?{}( single_acquisition_lock & this );
     91void ^?{}( single_acquisition_lock & this );
    9192
    9293void ?{}( owner_lock & this );
    9394void ^?{}( owner_lock & this );
    9495
    95 void ?{}( recursive_mutex_lock & this );
    96 void ^?{}( recursive_mutex_lock & this );
     96void ?{}( multiple_acquisition_lock & this );
     97void ^?{}( multiple_acquisition_lock & this );
    9798
    9899void lock( blocking_lock & this );
    … …  
    105106size_t get_recursion_count( blocking_lock & this );
    106107
    107 void lock( mutex_lock & this );
    108 void unlock( mutex_lock & this );
    109 void add_( mutex_lock & this, struct $thread * t );
    110 void remove_( mutex_lock & this );
    111 void set_recursion_count( mutex_lock & this, size_t recursion );
    112 size_t get_recursion_count( mutex_lock & this );
     108void lock( single_acquisition_lock & this );
     109void unlock( single_acquisition_lock & this );
     110void add_( single_acquisition_lock & this, struct $thread * t );
     111void remove_( single_acquisition_lock & this );
     112void set_recursion_count( single_acquisition_lock & this, size_t recursion );
     113size_t get_recursion_count( single_acquisition_lock & this );
    113114
    114 void lock( recursive_mutex_lock & this );
    115 void unlock( recursive_mutex_lock & this );
    116 void add_( recursive_mutex_lock & this, struct $thread * t );
    117 void remove_( recursive_mutex_lock & this );
    118 void set_recursion_count( recursive_mutex_lock & this, size_t recursion );
    119 size_t get_recursion_count( recursive_mutex_lock & this );
     115void lock( owner_lock & this );
     116void unlock( owner_lock & this );
     117void add_( owner_lock & this, struct $thread * t );
     118void remove_( owner_lock & this );
     119void set_recursion_count( owner_lock & this, size_t recursion );
     120size_t get_recursion_count( owner_lock & this );
     121
     122void lock( multiple_acquisition_lock & this );
     123void unlock( multiple_acquisition_lock & this );
     124void add_( multiple_acquisition_lock & this, struct $thread * t );
     125void remove_( multiple_acquisition_lock & this );
     126void set_recursion_count( multiple_acquisition_lock & this, size_t recursion );
     127size_t get_recursion_count( multiple_acquisition_lock & this );
    120128
    121129///////////////////////////////////////////////////////////////////

  • src/AST/Convert.cpp

    r6403ae5 r0d4456b  
    99// Author           : Thierry Delisle
    1010// Created On       : Thu May 09 15::37::05 2019
    11 // Last Modified By : Peter A. Buhr
    12 // Last Modified On : Wed Dec 11 21:39:32 2019
    13 // Update Count     : 33
     11// Last Modified By : Andrew Beach
     12// Last Modified On : Thr Nov 12 10:07:00 2020
     13// Update Count     : 34
    1414//
    1515
    … …  
    187187                auto init = get<Initializer>().accept1( node->init );
    188188                decl->init = init;
    189                
     189
    190190                this->node = decl;
    191191                return nullptr;
    … …  
    28122812        }
    28132813        deleteAll(translationUnit);
     2814
     2815        // Load the local static varables into the global store.
     2816        unit.global.sizeType = ast::sizeType;
     2817        unit.global.dereference = ast::dereferenceOperator;
     2818        unit.global.dtorStruct = ast::dtorStruct;
     2819        unit.global.dtorDestroy = ast::dtorStructDestroy;
     2820
    28142821        return unit;
    28152822}
Note: See TracChangeset for help on using the changeset viewer.