Ignore:
Timestamp:
Nov 6, 2020, 11:22:57 AM (5 years ago)
Author:
Thierry Delisle <tdelisle@…>
Branches:
ADT, arm-eh, ast-experimental, enum, forall-pointer-decay, jacob/cs343-translation, master, new-ast-unique-expr, pthread-emulation, qualifiedEnum
Children:
54dcab1
Parents:
be5e34b
Message:

Change usage of TLS to more strongly segregate in kernel and out of kernel usage.

Location:
libcfa/src/concurrency/kernel
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • libcfa/src/concurrency/kernel/fwd.hfa

    rbe5e34b r8fc652e0  
    5555                                uint64_t bck_seed;
    5656                        } ready_rng;
    57                 } kernelTLS __attribute__ ((tls_model ( "initial-exec" )));
     57                } __cfaabi_tls __attribute__ ((tls_model ( "initial-exec" )));
    5858
     59                extern bool __preemption_enabled();
    5960
     61                static inline KernelThreadData & kernelTLS( void ) {
     62                        /* paranoid */ verify( ! __preemption_enabled() );
     63                        return __cfaabi_tls;
     64                }
     65
     66                extern uintptr_t __cfatls_get( unsigned long int member );
     67                // #define publicTLS_get( member ) ((typeof(__cfaabi_tls.member))__cfatls_get( __builtin_offsetof(KernelThreadData, member) ))
     68                #define publicTLS_get( member ) (__cfaabi_tls.member)
     69                // extern forall(otype T) T __cfatls_get( T * member, T value );
     70                // #define publicTLS_set( member, value ) __cfatls_set( (typeof(member)*)__builtin_offsetof(KernelThreadData, member), value );
    6071
    6172                static inline uint64_t __tls_rand() {
    6273                        #if defined(__SIZEOF_INT128__)
    63                                 return __lehmer64( kernelTLS.rand_seed );
     74                                return __lehmer64( kernelTLS().rand_seed );
    6475                        #else
    65                                 return __xorshift64( kernelTLS.rand_seed );
     76                                return __xorshift64( kernelTLS().rand_seed );
    6677                        #endif
    6778                }
    … …  
    7586                static inline unsigned __tls_rand_fwd() {
    7687
    77                         kernelTLS.ready_rng.fwd_seed = (A * kernelTLS.ready_rng.fwd_seed + C) & (M - 1);
    78                         return kernelTLS.ready_rng.fwd_seed >> D;
     88                        kernelTLS().ready_rng.fwd_seed = (A * kernelTLS().ready_rng.fwd_seed + C) & (M - 1);
     89                        return kernelTLS().ready_rng.fwd_seed >> D;
    7990                }
    8091
    8192                static inline unsigned __tls_rand_bck() {
    82                         unsigned int r = kernelTLS.ready_rng.bck_seed >> D;
    83                         kernelTLS.ready_rng.bck_seed = AI * (kernelTLS.ready_rng.bck_seed - C) & (M - 1);
     93                        unsigned int r = kernelTLS().ready_rng.bck_seed >> D;
     94                        kernelTLS().ready_rng.bck_seed = AI * (kernelTLS().ready_rng.bck_seed - C) & (M - 1);
    8495                        return r;
    8596                }
    … …  
    92103
    93104                static inline void __tls_rand_advance_bck(void) {
    94                         kernelTLS.ready_rng.bck_seed = kernelTLS.ready_rng.fwd_seed;
     105                        kernelTLS().ready_rng.bck_seed = kernelTLS().ready_rng.fwd_seed;
    95106                }
    96107        }
    97108
    98         #if 0 // def __ARM_ARCH
    99                 // function prototypes are only really used by these macros on ARM
    100                 void disable_global_interrupts();
    101                 void enable_global_interrupts();
    102109
    103                 #define TL_GET( member ) ( { __typeof__( kernelTLS.member ) target; \
    104                         disable_global_interrupts(); \
    105                         target = kernelTLS.member; \
    106                         enable_global_interrupts(); \
    107                         target; } )
    108                 #define TL_SET( member, value ) disable_global_interrupts(); \
    109                         kernelTLS.member = value; \
    110                         enable_global_interrupts();
    111         #else
    112                 #define TL_GET( member ) kernelTLS.member
    113                 #define TL_SET( member, value ) kernelTLS.member = value;
    114         #endif
    115110
    116111        extern void disable_interrupts();
    … …  
    121116                extern void park( void );
    122117                extern void unpark( struct $thread * this );
    123                 static inline struct $thread * active_thread () { return TL_GET( this_thread ); }
     118                static inline struct $thread * active_thread () {
     119                        struct $thread * t = publicTLS_get( this_thread );
     120                        /* paranoid */ verify( t );
     121                        return t;
     122                }
    124123
    125124                extern bool force_yield( enum __Preemption_Reason );
    … …  
    140139                #if !defined(__CFA_NO_STATISTICS__)
    141140                        static inline struct __stats_t * __tls_stats() {
    142                                 /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
    143                                 /* paranoid */ verify( kernelTLS.this_stats );
    144                                 return kernelTLS.this_stats;
     141                                /* paranoid */ verify( ! __preemption_enabled() );
     142                                /* paranoid */ verify( kernelTLS().this_stats );
     143                                return kernelTLS().this_stats;
    145144                        }
    146145

  • libcfa/src/concurrency/kernel/startup.cfa

    rbe5e34b r8fc652e0  
    118118//-----------------------------------------------------------------------------
    119119// Global state
    120 thread_local struct KernelThreadData kernelTLS __attribute__ ((tls_model ( "initial-exec" ))) @= {
     120thread_local struct KernelThreadData __cfaabi_tls __attribute__ ((tls_model ( "initial-exec" ))) @= {
    121121        NULL,                                                                                           // cannot use 0p
    122122        NULL,
    … …  
    156156// Kernel boot procedures
    157157static void __kernel_startup(void) {
    158         verify( ! kernelTLS.preemption_state.enabled );
     158        /* paranoid */ verify( ! __preemption_enabled() );
    159159        __cfadbg_print_safe(runtime_core, "Kernel : Starting\n");
    160160
    … …  
    212212
    213213        //initialize the global state variables
    214         kernelTLS.this_processor = mainProcessor;
    215         kernelTLS.this_proc_id   = (__processor_id_t*)mainProcessor;
    216         kernelTLS.this_thread    = mainThread;
     214        __cfaabi_tls.this_processor = mainProcessor;
     215        __cfaabi_tls.this_proc_id   = (__processor_id_t*)mainProcessor;
     216        __cfaabi_tls.this_thread    = mainThread;
    217217
    218218        #if !defined( __CFA_NO_STATISTICS__ )
    219                 kernelTLS.this_stats = (__stats_t *)& storage_mainProcStats;
    220                 __init_stats( kernelTLS.this_stats );
     219                __cfaabi_tls.this_stats = (__stats_t *)& storage_mainProcStats;
     220                __init_stats( __cfaabi_tls.this_stats );
    221221        #endif
    222222
    … …  
    234234        // context. Hence, the main thread does not begin through __cfactx_invoke_thread, like all other threads. The trick here is that
    235235        // mainThread is on the ready queue when this call is made.
    236         __kernel_first_resume( kernelTLS.this_processor );
     236        __kernel_first_resume( __cfaabi_tls.this_processor );
    237237
    238238
    … …  
    251251        __cfadbg_print_safe(runtime_core, "Kernel : Started\n--------------------------------------------------\n\n");
    252252
    253         verify( ! kernelTLS.preemption_state.enabled );
     253        /* paranoid */ verify( ! __preemption_enabled() );
    254254        enable_interrupts( __cfaabi_dbg_ctx );
    255         verify( TL_GET( preemption_state.enabled ) );
     255        /* paranoid */ verify( __preemption_enabled() );
     256
    256257}
    257258
    … …  
    262263        mainCluster->io.ctxs = 0p;
    263264
    264         /* paranoid */ verify( TL_GET( preemption_state.enabled ) );
     265        /* paranoid */ verify( __preemption_enabled() );
    265266        disable_interrupts();
    266         /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
     267        /* paranoid */ verify( ! __preemption_enabled() );
    267268
    268269        __cfadbg_print_safe(runtime_core, "\n--------------------------------------------------\nKernel : Shutting down\n");
    … …  
    272273        // which is currently here
    273274        __atomic_store_n(&mainProcessor->do_terminate, true, __ATOMIC_RELEASE);
    274         __kernel_last_resume( kernelTLS.this_processor );
     275        __kernel_last_resume( __cfaabi_tls.this_processor );
    275276        mainThread->self_cor.state = Halted;
    276277
    … …  
    321322                __stats_t local_stats;
    322323                __init_stats( &local_stats );
    323                 kernelTLS.this_stats = &local_stats;
     324                __cfaabi_tls.this_stats = &local_stats;
    324325        #endif
    325326
    326327        processor * proc = (processor *) arg;
    327         kernelTLS.this_processor = proc;
    328         kernelTLS.this_proc_id   = (__processor_id_t*)proc;
    329         kernelTLS.this_thread    = 0p;
    330         kernelTLS.preemption_state.[enabled, disable_count] = [false, 1];
     328        __cfaabi_tls.this_processor = proc;
     329        __cfaabi_tls.this_proc_id   = (__processor_id_t*)proc;
     330        __cfaabi_tls.this_thread    = 0p;
     331        __cfaabi_tls.preemption_state.[enabled, disable_count] = [false, 1];
    331332        // SKULLDUGGERY: We want to create a context for the processor coroutine
    332333        // which is needed for the 2-step context switch. However, there is no reason
    … …  
    340341
    341342        //Set global state
    342         kernelTLS.this_thread = 0p;
     343        __cfaabi_tls.this_thread = 0p;
    343344
    344345        //We now have a proper context from which to schedule threads
    … …  
    370371        $coroutine * dst = get_coroutine(this->runner);
    371372
    372         verify( ! kernelTLS.preemption_state.enabled );
    373 
    374         kernelTLS.this_thread->curr_cor = dst;
     373        /* paranoid */ verify( ! __preemption_enabled() );
     374
     375        __cfaabi_tls.this_thread->curr_cor = dst;
    375376        __stack_prepare( &dst->stack, 65000 );
    376377        __cfactx_start(main, dst, this->runner, __cfactx_invoke_coroutine);
    377378
    378         verify( ! kernelTLS.preemption_state.enabled );
     379        /* paranoid */ verify( ! __preemption_enabled() );
    379380
    380381        dst->last = &src->self_cor;
    … …  
    394395        /* paranoid */ verify(src->state == Active);
    395396
    396         verify( ! kernelTLS.preemption_state.enabled );
     397        /* paranoid */ verify( ! __preemption_enabled() );
    397398}
    398399
    … …  
    402403        $coroutine * dst = get_coroutine(this->runner);
    403404
    404         verify( ! kernelTLS.preemption_state.enabled );
    405         verify( dst->starter == src );
    406         verify( dst->context.SP );
     405        /* paranoid */ verify( ! __preemption_enabled() );
     406        /* paranoid */ verify( dst->starter == src );
     407        /* paranoid */ verify( dst->context.SP );
    407408
    408409        // SKULLDUGGERY in debug the processors check that the
    … …  
    546547
    547548                P( terminated );
    548                 verify( kernelTLS.this_processor != &this);
     549                /* paranoid */ verify( active_processor() != &this);
    549550        }
    550551
    … …  
    696697#if defined(__CFA_WITH_VERIFY__)
    697698static bool verify_fwd_bck_rng(void) {
    698         kernelTLS.ready_rng.fwd_seed = 25214903917_l64u * (rdtscl() ^ (uintptr_t)&verify_fwd_bck_rng);
     699        __cfaabi_tls.ready_rng.fwd_seed = 25214903917_l64u * (rdtscl() ^ (uintptr_t)&verify_fwd_bck_rng);
    699700
    700701        unsigned values[10];
Note: See TracChangeset for help on using the changeset viewer.