Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • libcfa/src/concurrency/kernel.cfa

    r8fc652e0 r58688bf  
    122122        // Because of a bug, we couldn't initialized the seed on construction
    123123        // Do it here
    124         __cfaabi_tls.rand_seed ^= rdtscl();
    125         __cfaabi_tls.ready_rng.fwd_seed = 25214903917_l64u * (rdtscl() ^ (uintptr_t)&runner);
     124        kernelTLS.rand_seed ^= rdtscl();
     125        kernelTLS.ready_rng.fwd_seed = 25214903917_l64u * (rdtscl() ^ (uintptr_t)&runner);
    126126        __tls_rand_advance_bck();
    127127
    … …  
    217217                // and it make sense for it to be set in all other cases except here
    218218                // fake it
    219                 __cfaabi_tls.this_thread = mainThread;
     219                kernelTLS.this_thread = mainThread;
    220220        }
    221221
    … …  
    230230// from the processor coroutine to the target thread
    231231static void __run_thread(processor * this, $thread * thrd_dst) {
    232         /* paranoid */ verify( ! __preemption_enabled() );
     232        /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
    233233        /* paranoid */ verifyf( thrd_dst->state == Ready || thrd_dst->preempted != __NO_PREEMPTION, "state : %d, preempted %d\n", thrd_dst->state, thrd_dst->preempted);
    234234        /* paranoid */ verifyf( thrd_dst->link.next == 0p, "Expected null got %p", thrd_dst->link.next );
    … …  
    247247
    248248                // Update global state
    249                 kernelTLS().this_thread = thrd_dst;
    250 
    251                 /* paranoid */ verify( ! __preemption_enabled() );
    252                 /* paranoid */ verify( kernelTLS().this_thread == thrd_dst );
     249                kernelTLS.this_thread = thrd_dst;
     250
     251                /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
     252                /* paranoid */ verify( kernelTLS.this_thread == thrd_dst );
    253253                /* paranoid */ verify( thrd_dst->context.SP );
    254254                /* paranoid */ verify( thrd_dst->state != Halted );
    … …  
    267267                /* paranoid */ verifyf( ((uintptr_t)thrd_dst->context.SP) < ((uintptr_t)__get_stack(thrd_dst->curr_cor)->base ), "ERROR : Destination $thread %p has been corrupted.\n StackPointer too small.\n", thrd_dst );
    268268                /* paranoid */ verify( thrd_dst->context.SP );
    269                 /* paranoid */ verify( kernelTLS().this_thread == thrd_dst );
    270                 /* paranoid */ verify( ! __preemption_enabled() );
     269                /* paranoid */ verify( kernelTLS.this_thread == thrd_dst );
     270                /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
    271271
    272272                // Reset global state
    273                 kernelTLS().this_thread = 0p;
     273                kernelTLS.this_thread = 0p;
    274274
    275275                // We just finished running a thread, there are a few things that could have happened.
    … …  
    315315        proc_cor->state = Active;
    316316
    317         /* paranoid */ verify( ! __preemption_enabled() );
     317        /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
    318318}
    319319
    320320// KERNEL_ONLY
    321321void returnToKernel() {
    322         /* paranoid */ verify( ! __preemption_enabled() );
    323         $coroutine * proc_cor = get_coroutine(kernelTLS().this_processor->runner);
    324         $thread * thrd_src = kernelTLS().this_thread;
     322        /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
     323        $coroutine * proc_cor = get_coroutine(kernelTLS.this_processor->runner);
     324        $thread * thrd_src = kernelTLS.this_thread;
    325325
    326326        #if !defined(__CFA_NO_STATISTICS__)
    327                 struct processor * last_proc = kernelTLS().this_processor;
     327                struct processor * last_proc = kernelTLS.this_processor;
    328328        #endif
    329329
    … …  
    345345
    346346        #if !defined(__CFA_NO_STATISTICS__)
    347                 if(last_proc != kernelTLS().this_processor) {
     347                if(last_proc != kernelTLS.this_processor) {
    348348                        __tls_stats()->ready.threads.migration++;
    349349                }
    350350        #endif
    351351
    352         /* paranoid */ verify( ! __preemption_enabled() );
     352        /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
    353353        /* paranoid */ verifyf( ((uintptr_t)thrd_src->context.SP) < ((uintptr_t)__get_stack(thrd_src->curr_cor)->base ), "ERROR : Returning $thread %p has been corrupted.\n StackPointer too small.\n", thrd_src );
    354354        /* paranoid */ verifyf( ((uintptr_t)thrd_src->context.SP) > ((uintptr_t)__get_stack(thrd_src->curr_cor)->limit), "ERROR : Returning $thread %p has been corrupted.\n StackPointer too large.\n", thrd_src );
    … …  
    359359// KERNEL ONLY
    360360void __schedule_thread( $thread * thrd ) {
    361         /* paranoid */ verify( ! __preemption_enabled() );
    362361        /* paranoid */ verify( thrd );
    363362        /* paranoid */ verify( thrd->state != Halted );
    364         /* paranoid */ verify( kernelTLS().this_proc_id );
     363        /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
     364        /* paranoid */ verify( kernelTLS.this_proc_id );
    365365        /* paranoid */ #if defined( __CFA_WITH_VERIFY__ )
    366366        /* paranoid */  if( thrd->state == Blocked || thrd->state == Start ) assertf( thrd->preempted == __NO_PREEMPTION,
    … …  
    380380        ready_schedule_unlock();
    381381
    382         /* paranoid */ verify( ! __preemption_enabled() );
     382        /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
    383383}
    384384
    385385// KERNEL ONLY
    386386static inline $thread * __next_thread(cluster * this) with( *this ) {
    387         /* paranoid */ verify( ! __preemption_enabled() );
    388         /* paranoid */ verify( kernelTLS().this_proc_id );
     387        /* paranoid */ verify( kernelTLS.this_proc_id );
     388        /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
    389389
    390390        ready_schedule_lock();
    … …  
    392392        ready_schedule_unlock();
    393393
    394         /* paranoid */ verify( kernelTLS().this_proc_id );
    395         /* paranoid */ verify( ! __preemption_enabled() );
     394        /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
     395        /* paranoid */ verify( kernelTLS.this_proc_id );
    396396        return thrd;
    397397}
    … …  
    399399// KERNEL ONLY
    400400static inline $thread * __next_thread_slow(cluster * this) with( *this ) {
    401         /* paranoid */ verify( ! __preemption_enabled() );
    402         /* paranoid */ verify( kernelTLS().this_proc_id );
     401        /* paranoid */ verify( kernelTLS.this_proc_id );
     402        /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
    403403
    404404        ready_schedule_lock();
    … …  
    406406        ready_schedule_unlock();
    407407
    408         /* paranoid */ verify( kernelTLS().this_proc_id );
    409         /* paranoid */ verify( ! __preemption_enabled() );
     408        /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
     409        /* paranoid */ verify( kernelTLS.this_proc_id );
    410410        return thrd;
    411411}
    … …  
    414414        if( !thrd ) return;
    415415
     416        /* paranoid */ verify( kernelTLS.this_proc_id );
     417        bool full = kernelTLS.this_proc_id->full_proc;
     418        if(full) disable_interrupts();
     419
     420        /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
    416421        int old_ticket = __atomic_fetch_add(&thrd->ticket, 1, __ATOMIC_SEQ_CST);
    417422        switch(old_ticket) {
    … …  
    423428                        /* paranoid */ verify( thrd->state == Blocked );
    424429
    425                         {
    426                                 /* paranoid */ verify( publicTLS_get(this_proc_id) );
    427                                 bool full = publicTLS_get(this_proc_id)->full_proc;
    428                                 if(full) disable_interrupts();
    429 
    430                                 /* paranoid */ verify( ! __preemption_enabled() );
    431 
    432                                 // Wake lost the race,
    433                                 __schedule_thread( thrd );
    434 
    435                                 /* paranoid */ verify( ! __preemption_enabled() );
    436 
    437                                 if(full) enable_interrupts( __cfaabi_dbg_ctx );
    438                                 /* paranoid */ verify( publicTLS_get(this_proc_id) );
    439                         }
    440 
     430                        // Wake lost the race,
     431                        __schedule_thread( thrd );
    441432                        break;
    442433                default:
    … …  
    444435                        abort("Thread %p (%s) has mismatch park/unpark\n", thrd, thrd->self_cor.name);
    445436        }
     437        /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
     438
     439        if(full) enable_interrupts( __cfaabi_dbg_ctx );
     440        /* paranoid */ verify( kernelTLS.this_proc_id );
    446441}
    447442
    448443void park( void ) {
    449         /* paranoid */ verify( __preemption_enabled() );
     444        /* paranoid */ verify( kernelTLS.preemption_state.enabled );
    450445        disable_interrupts();
    451         /* paranoid */ verify( ! __preemption_enabled() );
    452         /* paranoid */ verify( kernelTLS().this_thread->preempted == __NO_PREEMPTION );
     446        /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
     447        /* paranoid */ verify( kernelTLS.this_thread->preempted == __NO_PREEMPTION );
    453448
    454449        returnToKernel();
    455450
    456         /* paranoid */ verify( ! __preemption_enabled() );
     451        /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
    457452        enable_interrupts( __cfaabi_dbg_ctx );
    458         /* paranoid */ verify( __preemption_enabled() );
     453        /* paranoid */ verify( kernelTLS.preemption_state.enabled );
    459454
    460455}
    … …  
    465460        // Should never return
    466461        void __cfactx_thrd_leave() {
    467                 $thread * thrd = active_thread();
     462                $thread * thrd = TL_GET( this_thread );
    468463                $monitor * this = &thrd->self_mon;
    469464
    … …  
    478473
    479474                // Leave the thread
    480                 /* paranoid */ verify( ! __preemption_enabled() );
     475                /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
    481476                returnToKernel();
    482477                abort();
    … …  
    488483// KERNEL ONLY
    489484bool force_yield( __Preemption_Reason reason ) {
    490         /* paranoid */ verify( __preemption_enabled() );
     485        /* paranoid */ verify( kernelTLS.preemption_state.enabled );
    491486        disable_interrupts();
    492         /* paranoid */ verify( ! __preemption_enabled() );
    493 
    494         $thread * thrd = kernelTLS().this_thread;
     487        /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
     488
     489        $thread * thrd = kernelTLS.this_thread;
    495490        /* paranoid */ verify(thrd->state == Active);
    496491
    … …  
    506501        }
    507502
    508         /* paranoid */ verify( ! __preemption_enabled() );
     503        /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
    509504        enable_interrupts_noPoll();
    510         /* paranoid */ verify( __preemption_enabled() );
     505        /* paranoid */ verify( kernelTLS.preemption_state.enabled );
    511506
    512507        return preempted;
    … …  
    518513// Wake a thread from the front if there are any
    519514static void __wake_one(cluster * this) {
    520         /* paranoid */ verify( ! __preemption_enabled() );
     515        /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
    521516        /* paranoid */ verify( ready_schedule_islocked() );
    522517
    … …  
    538533
    539534        /* paranoid */ verify( ready_schedule_islocked() );
    540         /* paranoid */ verify( ! __preemption_enabled() );
     535        /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
    541536
    542537        return;
    … …  
    548543
    549544        disable_interrupts();
    550                 /* paranoid */ verify( ! __preemption_enabled() );
     545                /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
    551546                post( this->idle );
    552547        enable_interrupts( __cfaabi_dbg_ctx );
    … …  
    554549
    555550static void push  (__cluster_idles & this, processor & proc) {
    556         /* paranoid */ verify( ! __preemption_enabled() );
     551        /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
    557552        lock( this );
    558553                this.idle++;
    … …  
    561556                insert_first(this.list, proc);
    562557        unlock( this );
    563         /* paranoid */ verify( ! __preemption_enabled() );
     558        /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
    564559}
    565560
    566561static void remove(__cluster_idles & this, processor & proc) {
    567         /* paranoid */ verify( ! __preemption_enabled() );
     562        /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
    568563        lock( this );
    569564                this.idle--;
    … …  
    572567                remove(proc);
    573568        unlock( this );
    574         /* paranoid */ verify( ! __preemption_enabled() );
     569        /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
    575570}
    576571
    … …  
    616611        }
    617612
    618         return __cfaabi_tls.this_thread;
     613        return kernelTLS.this_thread;
    619614}
    620615
    … …  
    641636
    642637int kernel_abort_lastframe( void ) __attribute__ ((__nothrow__)) {
    643         return get_coroutine(kernelTLS().this_thread) == get_coroutine(mainThread) ? 4 : 2;
     638        return get_coroutine(kernelTLS.this_thread) == get_coroutine(mainThread) ? 4 : 2;
    644639}
    645640
    … …  
    673668        if ( count < 0 ) {
    674669                // queue current task
    675                 append( waiting, active_thread() );
     670                append( waiting, kernelTLS.this_thread );
    676671
    677672                // atomically release spin lock and block
    … …  
    723718                void __cfaabi_dbg_record_lock(__spinlock_t & this, const char prev_name[]) {
    724719                        this.prev_name = prev_name;
    725                         this.prev_thrd = kernelTLS().this_thread;
     720                        this.prev_thrd = kernelTLS.this_thread;
    726721                }
    727722        }
Note: See TracChangeset for help on using the changeset viewer.