Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • libcfa/src/concurrency/kernel.cfa

    r8fc652e0 r6a77224  
    108108static $thread * __next_thread_slow(cluster * this);
    109109static void __run_thread(processor * this, $thread * dst);
    110 static void __wake_one(cluster * cltr);
     110static void __wake_one(struct __processor_id_t * id, cluster * cltr);
    111111
    112112static void push  (__cluster_idles & idles, processor & proc);
    … …  
    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.
    … …  
    282282                if(unlikely(thrd_dst->preempted != __NO_PREEMPTION)) {
    283283                        // The thread was preempted, reschedule it and reset the flag
    284                         __schedule_thread( thrd_dst );
     284                        __schedule_thread( (__processor_id_t*)this, thrd_dst );
    285285                        break RUNNING;
    286286                }
    … …  
    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 );
    … …  
    358358// Scheduler routines
    359359// KERNEL ONLY
    360 void __schedule_thread( $thread * thrd ) {
    361         /* paranoid */ verify( ! __preemption_enabled() );
     360void __schedule_thread( struct __processor_id_t * id, $thread * thrd ) {
    362361        /* paranoid */ verify( thrd );
    363362        /* paranoid */ verify( thrd->state != Halted );
    364         /* paranoid */ verify( kernelTLS().this_proc_id );
     363        /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
    365364        /* paranoid */ #if defined( __CFA_WITH_VERIFY__ )
    366365        /* paranoid */  if( thrd->state == Blocked || thrd->state == Start ) assertf( thrd->preempted == __NO_PREEMPTION,
    … …  
    375374        if (thrd->preempted == __NO_PREEMPTION) thrd->state = Ready;
    376375
    377         ready_schedule_lock();
     376        ready_schedule_lock  ( id );
    378377                push( thrd->curr_cluster, thrd );
    379                 __wake_one(thrd->curr_cluster);
    380         ready_schedule_unlock();
    381 
    382         /* paranoid */ verify( ! __preemption_enabled() );
     378                __wake_one(id, thrd->curr_cluster);
     379        ready_schedule_unlock( id );
     380
     381        /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
    383382}
    384383
    385384// KERNEL ONLY
    386385static inline $thread * __next_thread(cluster * this) with( *this ) {
    387         /* paranoid */ verify( ! __preemption_enabled() );
    388         /* paranoid */ verify( kernelTLS().this_proc_id );
    389 
    390         ready_schedule_lock();
     386        /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
     387
     388        ready_schedule_lock  ( (__processor_id_t*)kernelTLS.this_processor );
    391389                $thread * thrd = pop( this );
    392         ready_schedule_unlock();
    393 
    394         /* paranoid */ verify( kernelTLS().this_proc_id );
    395         /* paranoid */ verify( ! __preemption_enabled() );
     390        ready_schedule_unlock( (__processor_id_t*)kernelTLS.this_processor );
     391
     392        /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
    396393        return thrd;
    397394}
    … …  
    399396// KERNEL ONLY
    400397static inline $thread * __next_thread_slow(cluster * this) with( *this ) {
    401         /* paranoid */ verify( ! __preemption_enabled() );
    402         /* paranoid */ verify( kernelTLS().this_proc_id );
    403 
    404         ready_schedule_lock();
     398        /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
     399
     400        ready_schedule_lock  ( (__processor_id_t*)kernelTLS.this_processor );
    405401                $thread * thrd = pop_slow( this );
    406         ready_schedule_unlock();
    407 
    408         /* paranoid */ verify( kernelTLS().this_proc_id );
    409         /* paranoid */ verify( ! __preemption_enabled() );
     402        ready_schedule_unlock( (__processor_id_t*)kernelTLS.this_processor );
     403
     404        /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
    410405        return thrd;
    411406}
    412407
    413 void unpark( $thread * thrd ) {
    414         if( !thrd ) return;
    415 
     408// KERNEL ONLY unpark with out disabling interrupts
     409void __unpark(  struct __processor_id_t * id, $thread * thrd ) {
    416410        int old_ticket = __atomic_fetch_add(&thrd->ticket, 1, __ATOMIC_SEQ_CST);
    417411        switch(old_ticket) {
    … …  
    423417                        /* paranoid */ verify( thrd->state == Blocked );
    424418
    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 
     419                        // Wake lost the race,
     420                        __schedule_thread( id, thrd );
    441421                        break;
    442422                default:
    … …  
    446426}
    447427
     428void unpark( $thread * thrd ) {
     429        if( !thrd ) return;
     430
     431        disable_interrupts();
     432        __unpark( (__processor_id_t*)kernelTLS.this_processor, thrd );
     433        enable_interrupts( __cfaabi_dbg_ctx );
     434}
     435
    448436void park( void ) {
    449         /* paranoid */ verify( __preemption_enabled() );
     437        /* paranoid */ verify( kernelTLS.preemption_state.enabled );
    450438        disable_interrupts();
    451         /* paranoid */ verify( ! __preemption_enabled() );
    452         /* paranoid */ verify( kernelTLS().this_thread->preempted == __NO_PREEMPTION );
     439        /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
     440        /* paranoid */ verify( kernelTLS.this_thread->preempted == __NO_PREEMPTION );
    453441
    454442        returnToKernel();
    455443
    456         /* paranoid */ verify( ! __preemption_enabled() );
     444        /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
    457445        enable_interrupts( __cfaabi_dbg_ctx );
    458         /* paranoid */ verify( __preemption_enabled() );
     446        /* paranoid */ verify( kernelTLS.preemption_state.enabled );
    459447
    460448}
    … …  
    465453        // Should never return
    466454        void __cfactx_thrd_leave() {
    467                 $thread * thrd = active_thread();
     455                $thread * thrd = TL_GET( this_thread );
    468456                $monitor * this = &thrd->self_mon;
    469457
    … …  
    474462
    475463                thrd->state = Halted;
    476                 if( TICKET_RUNNING != thrd->ticket ) { abort( "Thread terminated with pending unpark" ); }
     464
    477465                if( thrd != this->owner || this->recursion != 1) { abort( "Thread internal monitor has unbalanced recursion" ); }
    478466
    479467                // Leave the thread
    480                 /* paranoid */ verify( ! __preemption_enabled() );
     468                /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
    481469                returnToKernel();
    482470                abort();
    … …  
    488476// KERNEL ONLY
    489477bool force_yield( __Preemption_Reason reason ) {
    490         /* paranoid */ verify( __preemption_enabled() );
     478        /* paranoid */ verify( kernelTLS.preemption_state.enabled );
    491479        disable_interrupts();
    492         /* paranoid */ verify( ! __preemption_enabled() );
    493 
    494         $thread * thrd = kernelTLS().this_thread;
     480        /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
     481
     482        $thread * thrd = kernelTLS.this_thread;
    495483        /* paranoid */ verify(thrd->state == Active);
    496484
    … …  
    506494        }
    507495
    508         /* paranoid */ verify( ! __preemption_enabled() );
     496        /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
    509497        enable_interrupts_noPoll();
    510         /* paranoid */ verify( __preemption_enabled() );
     498        /* paranoid */ verify( kernelTLS.preemption_state.enabled );
    511499
    512500        return preempted;
    … …  
    517505//=============================================================================================
    518506// Wake a thread from the front if there are any
    519 static void __wake_one(cluster * this) {
    520         /* paranoid */ verify( ! __preemption_enabled() );
    521         /* paranoid */ verify( ready_schedule_islocked() );
     507static void __wake_one(struct __processor_id_t * id, cluster * this) {
     508        /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
     509        /* paranoid */ verify( ready_schedule_islocked( id ) );
    522510
    523511        // Check if there is a sleeping processor
    … …  
    537525        #endif
    538526
    539         /* paranoid */ verify( ready_schedule_islocked() );
    540         /* paranoid */ verify( ! __preemption_enabled() );
     527        /* paranoid */ verify( ready_schedule_islocked( id ) );
     528        /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
    541529
    542530        return;
    … …  
    548536
    549537        disable_interrupts();
    550                 /* paranoid */ verify( ! __preemption_enabled() );
     538                /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
    551539                post( this->idle );
    552540        enable_interrupts( __cfaabi_dbg_ctx );
    … …  
    554542
    555543static void push  (__cluster_idles & this, processor & proc) {
    556         /* paranoid */ verify( ! __preemption_enabled() );
     544        /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
    557545        lock( this );
    558546                this.idle++;
    … …  
    561549                insert_first(this.list, proc);
    562550        unlock( this );
    563         /* paranoid */ verify( ! __preemption_enabled() );
     551        /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
    564552}
    565553
    566554static void remove(__cluster_idles & this, processor & proc) {
    567         /* paranoid */ verify( ! __preemption_enabled() );
     555        /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
    568556        lock( this );
    569557                this.idle--;
    … …  
    572560                remove(proc);
    573561        unlock( this );
    574         /* paranoid */ verify( ! __preemption_enabled() );
     562        /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
    575563}
    576564
    … …  
    616604        }
    617605
    618         return __cfaabi_tls.this_thread;
     606        return kernelTLS.this_thread;
    619607}
    620608
    … …  
    641629
    642630int kernel_abort_lastframe( void ) __attribute__ ((__nothrow__)) {
    643         return get_coroutine(kernelTLS().this_thread) == get_coroutine(mainThread) ? 4 : 2;
     631        return get_coroutine(kernelTLS.this_thread) == get_coroutine(mainThread) ? 4 : 2;
    644632}
    645633
    … …  
    673661        if ( count < 0 ) {
    674662                // queue current task
    675                 append( waiting, active_thread() );
     663                append( waiting, kernelTLS.this_thread );
    676664
    677665                // atomically release spin lock and block
    … …  
    723711                void __cfaabi_dbg_record_lock(__spinlock_t & this, const char prev_name[]) {
    724712                        this.prev_name = prev_name;
    725                         this.prev_thrd = kernelTLS().this_thread;
     713                        this.prev_thrd = kernelTLS.this_thread;
    726714                }
    727715        }
    … …  
    740728                this.print_halts = true;
    741729        }
    742 
    743         void print_stats_now( cluster & this, int flags ) {
    744                 __print_stats( this.stats, this.print_stats, true, this.name, (void*)&this );
    745         }
    746730#endif
    747731// Local Variables: //
Note: See TracChangeset for help on using the changeset viewer.