Ignore:
Timestamp:
Nov 5, 2020, 7:25:33 PM (13 months ago)
Author:
Fangren Yu <f37yu@…>
Branches:
arm-eh, jacob/cs343-translation, master, new-ast-unique-expr
Children:
16ba4a6, 3959595
Parents:
7d651a6 (diff), f4e35326 (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

File:
1 edited

Legend:

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

    r7d651a6 r3febb2d  
    1515                this.t = t;
    1616                this.lock = 0p;
     17                this.listed = false;
    1718        }
    1819
     
    2122                this.info = info;
    2223                this.lock = 0p;
     24                this.listed = false;
    2325        }
    2426
     
    7779        if ( owner == kernelTLS.this_thread && !multi_acquisition) {
    7880                fprintf(stderr, "A single acquisition lock holder attempted to reacquire the lock resulting in a deadlock."); // Possibly throw instead
    79                 exit(EXIT_FAILURE);
     81        exit(EXIT_FAILURE);
    8082        } else if ( owner != 0p && owner != kernelTLS.this_thread ) {
    8183                append( blocked_threads, kernelTLS.this_thread );
    8284                wait_count++;
    8385                unlock( lock );
    84                 park( __cfaabi_dbg_ctx );
     86                park( );
    8587        } else if ( owner == kernelTLS.this_thread && multi_acquisition ) {
    8688                recursion_count++;
     
    111113        lock( lock __cfaabi_dbg_ctx2 );
    112114        if ( owner == 0p ){ // no owner implies lock isn't held
    113                 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" ); 
    114116                return;
    115117        } else if ( strict_owner && owner != kernelTLS.this_thread ) {
    116                 fprintf( stderr, "A thread other than the owner attempted to release an owner lock" );
     118                fprintf( stderr, "A thread other than the owner attempted to release an owner lock" ); 
    117119                return;
    118120        }
     
    123125                recursion_count = ( thrd && multi_acquisition ? 1 : 0 );
    124126                wait_count--;
    125                 unpark( thrd __cfaabi_dbg_ctx2 );
     127                unpark( thrd );
    126128        }
    127129        unlock( lock );
     
    150152                owner = t;
    151153                if ( multi_acquisition ) recursion_count = 1;
    152                 unpark( t __cfaabi_dbg_ctx2 );
     154                #if !defined( __CFA_NO_STATISTICS__ )
     155                        kernelTLS.this_stats = t->curr_cluster->stats;
     156                #endif
     157                unpark( t );
    153158                unlock( lock );
    154159        }
     
    158163    lock( lock __cfaabi_dbg_ctx2 );
    159164        if ( owner == 0p ){ // no owner implies lock isn't held
    160                 fprintf( stderr, "A lock that is not held was passed to a synchronization lock" );
     165                fprintf( stderr, "A lock that is not held was passed to a synchronization lock" ); 
    161166        } else if ( strict_owner && owner != kernelTLS.this_thread ) {
    162                 fprintf( stderr, "A thread other than the owner of a lock passed it to a synchronization lock" );
     167                fprintf( stderr, "A thread other than the owner of a lock passed it to a synchronization lock" ); 
    163168        } else {
    164169                $thread * thrd = pop_head( blocked_threads );
     
    166171                recursion_count = ( thrd && multi_acquisition ? 1 : 0 );
    167172                wait_count--;
    168                 unpark( thrd __cfaabi_dbg_ctx2 );
     173                unpark( thrd );
    169174        }
    170175        unlock( lock );
     
    175180///////////////////////////////////////////////////////////////////
    176181
    177 // In an ideal world this may not be necessary
    178 // Is it possible for nominal inheritance to inherit traits??
    179 // If that occurs we would avoid all this extra code
     182// This is temporary until an inheritance bug is fixed
    180183
    181184void lock( mutex_lock & this ){
     
    228231
    229232///////////////////////////////////////////////////////////////////
    230 //// Synchronization Locks
     233//// condition variable
    231234///////////////////////////////////////////////////////////////////
    232235
    233236forall(dtype L | is_blocking_lock(L)) {
    234         void ?{}( synchronization_lock(L) & this, bool reacquire_after_signal ){
     237
     238        void timeout_handler ( alarm_node_wrap(L) & this ) with( this ) {
     239        // This condition_variable member is called from the kernel, and therefore, cannot block, but it can spin.
     240            lock( cond->lock __cfaabi_dbg_ctx2 );
     241            if ( (*i)->listed ) {                       // is thread on queue
     242                info_thread(L) * copy = *i;
     243                        remove( cond->blocked_threads, i );              //remove this thread O(1)
     244                        cond->wait_count--;
     245                        if( !copy->lock ) {
     246                                unlock( cond->lock );
     247                                #if !defined( __CFA_NO_STATISTICS__ )
     248                                        kernelTLS.this_stats = copy->t->curr_cluster->stats;
     249                                #endif
     250                                unpark( copy->t );
     251                } else {
     252                        add_(*copy->lock, copy->t);                     // call lock's add_
     253                }
     254            }
     255            unlock( cond->lock );
     256        }
     257
     258        void alarm_node_wrap_cast( alarm_node_t & a ) {
     259                timeout_handler( (alarm_node_wrap(L) &)a );
     260        }
     261
     262        void ?{}( condition_variable(L) & this ){
    235263                this.lock{};
    236264                this.blocked_threads{};
    237265                this.count = 0;
    238                 this.reacquire_after_signal = reacquire_after_signal;
    239         }
    240 
    241         void ^?{}( synchronization_lock(L) & this ){
    242                 // default
    243         }
    244 
    245         void ?{}( condition_variable(L) & this ){
    246                 ((synchronization_lock(L) &)this){ true };
    247266        }
    248267
     
    251270        }
    252271
    253         void ?{}( thread_queue(L) & this ){
    254                 ((synchronization_lock(L) &)this){ false };
    255         }
    256 
    257         void ^?{}( thread_queue(L) & this ){
     272        void ?{}( alarm_node_wrap(L) & this, $thread * thrd, Time alarm, Duration period, Alarm_Callback callback ) {
     273                this.alarm_node{ thrd, alarm, period, callback };
     274        }
     275
     276        void ^?{}( alarm_node_wrap(L) & this ) {
    258277                // default
    259278        }
    260279
    261         bool notify_one( synchronization_lock(L) & this ) with( this ) {
     280        bool notify_one( condition_variable(L) & this ) with( this ) {
    262281                lock( lock __cfaabi_dbg_ctx2 );
    263282                bool ret = !!blocked_threads;
    264283                info_thread(L) * popped = pop_head( blocked_threads );
     284                popped->listed = false;
    265285                if(popped != 0p) {
    266                         if( reacquire_after_signal ){
     286                        count--;
     287                        if (popped->lock) {
    267288                                add_(*popped->lock, popped->t);
    268289                        } else {
    269                                 unpark(
    270                                         popped->t __cfaabi_dbg_ctx2
    271                                 );
     290                                unpark(popped->t);
    272291                        }
    273292                }
     
    276295        }
    277296
    278         bool notify_all( synchronization_lock(L) & this ) with(this) {
     297        bool notify_all( condition_variable(L) & this ) with(this) {
    279298                lock( lock __cfaabi_dbg_ctx2 );
    280299                bool ret = blocked_threads ? true : false;
    281300                while( blocked_threads ) {
    282301                        info_thread(L) * popped = pop_head( blocked_threads );
     302                        popped->listed = false;
    283303                        if(popped != 0p){
    284                                 if( reacquire_after_signal ){
     304                                count--;
     305                                if (popped->lock) {
    285306                                        add_(*popped->lock, popped->t);
    286307                                } else {
    287                                         unpark(
    288                                                 popped->t __cfaabi_dbg_ctx2
    289                                         );
     308                                        unpark(popped->t);
    290309                                }
    291310                        }
     
    295314        }
    296315
    297         uintptr_t front( synchronization_lock(L) & this ) with(this) {
    298                 return (*peek(blocked_threads)).info;
    299         }
    300 
    301         bool empty( synchronization_lock(L) & this ) with(this) {
     316        uintptr_t front( condition_variable(L) & this ) with(this) {
     317                if(!blocked_threads) return NULL;
     318                return peek(blocked_threads)->info;
     319        }
     320
     321        bool empty( condition_variable(L) & this ) with(this) {
    302322                return blocked_threads ? false : true;
    303323        }
    304324
    305         int counter( synchronization_lock(L) & this ) with(this) {
     325        int counter( condition_variable(L) & this ) with(this) {
    306326                return count;
    307327        }
    308328
    309         void queue_info_thread( synchronization_lock(L) & this, info_thread(L) & i ) with(this) {
    310                 lock( lock __cfaabi_dbg_ctx2 );
    311                 append( blocked_threads, &i );
    312                 count++;
    313                 unlock( lock );
    314                 park( __cfaabi_dbg_ctx );
    315         }
    316 
    317 
    318         void wait( synchronization_lock(L) & this ) with(this) {
    319                 info_thread( L ) i = { kernelTLS.this_thread };
    320                 queue_info_thread( this, i );
    321         }
    322 
    323         void wait( synchronization_lock(L) & this, uintptr_t info ) with(this) {
    324                 info_thread( L ) i = { kernelTLS.this_thread, info };
    325                 queue_info_thread( this, i );
    326         }
    327         // I still need to implement the time delay wait routines
    328         bool wait( synchronization_lock(L) & this, Duration duration ) with(this) {
    329                 timeval tv = { time(0) };
    330                 Time t = { tv };
    331                 return wait( this, t + duration );
    332         }
    333 
    334         bool wait( synchronization_lock(L) & this, uintptr_t info, Duration duration ) with(this) {
    335                 // TODO: ADD INFO
    336                 return wait( this, duration );
    337         }
    338 
    339         bool wait( synchronization_lock(L) & this, Time time ) with(this) {
    340                 return false; //default
    341         }
    342 
    343         bool wait( synchronization_lock(L) & this, uintptr_t info, Time time ) with(this) {
    344                 // TODO: ADD INFO
    345                 return wait( this, time );
    346         }
    347 
    348         void queue_info_thread_unlock( synchronization_lock(L) & this, L & l, info_thread(L) & i ) with(this) {
     329        // helper for wait()'s' without a timeout
     330        void queue_info_thread( condition_variable(L) & this, info_thread(L) & i ) with(this) {
    349331                lock( lock __cfaabi_dbg_ctx2 );
    350332                append( this.blocked_threads, &i );
    351333                count++;
    352                 i.lock = &l;
    353                 size_t recursion_count = get_recursion_count(l);
    354                 remove_( l );
    355                 unlock( lock );
    356                 park( __cfaabi_dbg_ctx ); // blocks here
    357 
    358                 set_recursion_count(l, recursion_count); // resets recursion count here after waking
    359         }
    360 
    361         void wait( synchronization_lock(L) & this, L & l ) with(this) {
     334                i.listed = true;
     335                size_t recursion_count;
     336                if (i.lock) {
     337                        recursion_count = get_recursion_count(*i.lock);
     338                        remove_( *i.lock );
     339                }
     340               
     341                unlock( lock );
     342                park( ); // blocks here
     343
     344                if (i.lock) set_recursion_count(*i.lock, recursion_count); // resets recursion count here after waking
     345        }
     346
     347        // helper for wait()'s' with a timeout
     348        void queue_info_thread_timeout( condition_variable(L) & this, info_thread(L) & info, Time t ) with(this) {
     349                lock( lock __cfaabi_dbg_ctx2 );
     350
     351                info_thread(L) * queue_ptr = &info;
     352
     353                alarm_node_wrap(L) node_wrap = { info.t, t, 0`s, alarm_node_wrap_cast };
     354                node_wrap.cond = &this;
     355                node_wrap.i = &queue_ptr;
     356
     357                register_self( &node_wrap.alarm_node );
     358
     359                append( blocked_threads, queue_ptr );
     360                info.listed = true;
     361                count++;
     362
     363                size_t recursion_count;
     364                if (info.lock) {
     365                        recursion_count = get_recursion_count(*info.lock);
     366                        remove_( *info.lock );
     367                }
     368
     369                unlock( lock );
     370                park();
     371
     372                if (info.lock) set_recursion_count(*info.lock, recursion_count);
     373        }
     374
     375        void wait( condition_variable(L) & this ) with(this) {
     376                info_thread( L ) i = { kernelTLS.this_thread };
     377                queue_info_thread( this, i );
     378        }
     379
     380        void wait( condition_variable(L) & this, uintptr_t info ) with(this) {
     381                info_thread( L ) i = { kernelTLS.this_thread, info };
     382                queue_info_thread( this, i );
     383        }
     384       
     385        void wait( condition_variable(L) & this, Duration duration ) with(this) {
     386                info_thread( L ) i = { kernelTLS.this_thread };
     387                queue_info_thread_timeout(this, i, __kernel_get_time() + duration );
     388        }
     389
     390        void wait( condition_variable(L) & this, uintptr_t info, Duration duration ) with(this) {
     391                info_thread( L ) i = { kernelTLS.this_thread, info };
     392                queue_info_thread_timeout(this, i, __kernel_get_time() + duration );
     393        }
     394
     395        void wait( condition_variable(L) & this, Time time ) with(this) {
     396                info_thread( L ) i = { kernelTLS.this_thread };
     397                queue_info_thread_timeout(this, i, time);
     398        }
     399
     400        void wait( condition_variable(L) & this, uintptr_t info, Time time ) with(this) {
     401                info_thread( L ) i = { kernelTLS.this_thread, info };
     402                queue_info_thread_timeout(this, i, time);
     403        }
     404
     405        void wait( condition_variable(L) & this, L & l ) with(this) {
    362406                info_thread(L) i = { kernelTLS.this_thread };
    363                 queue_info_thread_unlock( this, l, i );
    364         }
    365 
    366         void wait( synchronization_lock(L) & this, L & l, uintptr_t info ) with(this) {
     407                i.lock = &l;
     408                queue_info_thread( this, i );
     409        }
     410
     411        void wait( condition_variable(L) & this, L & l, uintptr_t info ) with(this) {
    367412                info_thread(L) i = { kernelTLS.this_thread, info };
    368                 queue_info_thread_unlock( this, l, i );
    369         }
    370 
    371         bool wait( synchronization_lock(L) & this, L & l, Duration duration ) with(this) {
    372                 timeval tv = { time(0) };
    373                 Time t = { tv };
    374                 return wait( this, l, t + duration );
    375         }
    376 
    377         bool wait( synchronization_lock(L) & this, L & l, uintptr_t info, Duration duration ) with(this) {
    378                 // TODO: ADD INFO
    379                 return wait( this, l, duration );
    380         }
    381 
    382         bool wait( synchronization_lock(L) & this, L & l, Time time ) with(this) {
    383                 return false; //default
    384         }
    385 
    386         bool wait( synchronization_lock(L) & this, L & l, uintptr_t info, Time time ) with(this) {
    387                 // TODO: ADD INFO
    388                 return wait( this, l, time );
    389         }
    390 }
    391 
    392 ///////////////////////////////////////////////////////////////////
    393 //// condition lock alternative approach
    394 ///////////////////////////////////////////////////////////////////
    395 
    396 // the solution below is less efficient but does not require the lock to have a specific add/remove routine
    397 
    398 ///////////////////////////////////////////////////////////////////
    399 //// is_simple_lock
    400 ///////////////////////////////////////////////////////////////////
    401 
    402 forall(dtype L | is_simple_lock(L)) {
    403         void ?{}( condition_lock(L) & this ){
    404                 // default
    405         }
    406 
    407         void ^?{}( condition_lock(L) & this ){
    408                 // default
    409         }
    410 
    411         bool notify_one( condition_lock(L) & this ) with(this) {
    412                 return notify_one( c_var );
    413         }
    414 
    415         bool notify_all( condition_lock(L) & this ) with(this) {
    416                 return notify_all( c_var );
    417         }
    418 
    419         void wait( condition_lock(L) & this, L & l ) with(this) {
    420                 lock( m_lock );
    421                 size_t recursion = get_recursion_count( l );
    422                 unlock( l );
    423                 wait( c_var, m_lock );
    424                 lock( l );
    425                 set_recursion_count( l , recursion );
    426                 unlock( m_lock );
    427         }
    428 }
     413                i.lock = &l;
     414                queue_info_thread( this, i );
     415        }
     416       
     417        void wait( condition_variable(L) & this, L & l, Duration duration ) with(this) {
     418                info_thread(L) i = { kernelTLS.this_thread };
     419                i.lock = &l;
     420                queue_info_thread_timeout(this, i, __kernel_get_time() + duration );
     421        }
     422       
     423        void wait( condition_variable(L) & this, L & l, uintptr_t info, Duration duration ) with(this) {
     424                info_thread(L) i = { kernelTLS.this_thread, info };
     425                i.lock = &l;
     426                queue_info_thread_timeout(this, i, __kernel_get_time() + duration );
     427        }
     428       
     429        void wait( condition_variable(L) & this, L & l, Time time ) with(this) {
     430                info_thread(L) i = { kernelTLS.this_thread };
     431                i.lock = &l;
     432                queue_info_thread_timeout(this, i, time );
     433        }
     434       
     435        void wait( condition_variable(L) & this, L & l, uintptr_t info, Time time ) with(this) {
     436                info_thread(L) i = { kernelTLS.this_thread, info };
     437                i.lock = &l;
     438                queue_info_thread_timeout(this, i, time );
     439        }
     440}
Note: See TracChangeset for help on using the changeset viewer.