Ignore:
Timestamp:
Nov 11, 2020, 2:39:48 PM (12 months ago)
Author:
Colby Alexander Parsons <caparsons@…>
Branches:
arm-eh, jacob/cs343-translation, master, new-ast-unique-expr
Children:
2125567
Parents:
836c992
Message:

fixed some bugs

File:
1 edited

Legend:

Unmodified
Added
Removed
  • libcfa/src/concurrency/locks.cfa

    r836c992 r6a8882c  
    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// }
Note: See TracChangeset for help on using the changeset viewer.