Changeset 8fc652e0 for libcfa/src/concurrency/kernel/startup.cfa

Timestamp:

Nov 6, 2020, 11:22:57 AM (3 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.

File:

• libcfa/src/concurrency/kernel/startup.cfa (modified) (14 diffs)

libcfa/src/concurrency/kernel/startup.cfa

@@ -118 +118 @@
 //-----------------------------------------------------------------------------
 // Global state
-thread_local struct KernelThreadData kernelTLS __attribute__ ((tls_model ( "initial-exec" ))) @= {
+thread_local struct KernelThreadData __cfaabi_tls __attribute__ ((tls_model ( "initial-exec" ))) @= {
         NULL,                                                                                           // cannot use 0p
         NULL,
@@ -156 +156 @@
 // Kernel boot procedures
 static void __kernel_startup(void) {
-        verify( ! kernelTLS.preemption_state.enabled );
+        /* paranoid */ verify( ! __preemption_enabled() );
         __cfadbg_print_safe(runtime_core, "Kernel : Starting\n");
 
@@ -212 +212 @@
 
         //initialize the global state variables
-        kernelTLS.this_processor = mainProcessor;
-        kernelTLS.this_proc_id   = (__processor_id_t*)mainProcessor;
-        kernelTLS.this_thread    = mainThread;
+        __cfaabi_tls.this_processor = mainProcessor;
+        __cfaabi_tls.this_proc_id   = (__processor_id_t*)mainProcessor;
+        __cfaabi_tls.this_thread    = mainThread;
 
         #if !defined( __CFA_NO_STATISTICS__ )
-                kernelTLS.this_stats = (__stats_t *)& storage_mainProcStats;
-                __init_stats( kernelTLS.this_stats );
+                __cfaabi_tls.this_stats = (__stats_t *)& storage_mainProcStats;
+                __init_stats( __cfaabi_tls.this_stats );
         #endif
 
@@ -234 +234 @@
         // context. Hence, the main thread does not begin through __cfactx_invoke_thread, like all other threads. The trick here is that
         // mainThread is on the ready queue when this call is made.
-        __kernel_first_resume( kernelTLS.this_processor );
+        __kernel_first_resume( __cfaabi_tls.this_processor );
 
 
@@ -251 +251 @@
         __cfadbg_print_safe(runtime_core, "Kernel : Started\n--------------------------------------------------\n\n");
 
-        verify( ! kernelTLS.preemption_state.enabled );
+        /* paranoid */ verify( ! __preemption_enabled() );
         enable_interrupts( __cfaabi_dbg_ctx );
-        verify( TL_GET( preemption_state.enabled ) );
+        /* paranoid */ verify( __preemption_enabled() );
+
 }
 
@@ -262 +263 @@
         mainCluster->io.ctxs = 0p;
 
-        /* paranoid */ verify( TL_GET( preemption_state.enabled ) );
+        /* paranoid */ verify( __preemption_enabled() );
         disable_interrupts();
-        /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
+        /* paranoid */ verify( ! __preemption_enabled() );
 
         __cfadbg_print_safe(runtime_core, "\n--------------------------------------------------\nKernel : Shutting down\n");
@@ -272 +273 @@
         // which is currently here
         __atomic_store_n(&mainProcessor->do_terminate, true, __ATOMIC_RELEASE);
-        __kernel_last_resume( kernelTLS.this_processor );
+        __kernel_last_resume( __cfaabi_tls.this_processor );
         mainThread->self_cor.state = Halted;
 
@@ -321 +322 @@
                 __stats_t local_stats;
                 __init_stats( &local_stats );
-                kernelTLS.this_stats = &local_stats;
+                __cfaabi_tls.this_stats = &local_stats;
         #endif
 
         processor * proc = (processor *) arg;
-        kernelTLS.this_processor = proc;
-        kernelTLS.this_proc_id   = (__processor_id_t*)proc;
-        kernelTLS.this_thread    = 0p;
-        kernelTLS.preemption_state.[enabled, disable_count] = [false, 1];
+        __cfaabi_tls.this_processor = proc;
+        __cfaabi_tls.this_proc_id   = (__processor_id_t*)proc;
+        __cfaabi_tls.this_thread    = 0p;
+        __cfaabi_tls.preemption_state.[enabled, disable_count] = [false, 1];
         // SKULLDUGGERY: We want to create a context for the processor coroutine
         // which is needed for the 2-step context switch. However, there is no reason
@@ -340 +341 @@
 
         //Set global state
-        kernelTLS.this_thread = 0p;
+        __cfaabi_tls.this_thread = 0p;
 
         //We now have a proper context from which to schedule threads
@@ -370 +371 @@
         $coroutine * dst = get_coroutine(this->runner);
 
-        verify( ! kernelTLS.preemption_state.enabled );
-
-        kernelTLS.this_thread->curr_cor = dst;
+        /* paranoid */ verify( ! __preemption_enabled() );
+
+        __cfaabi_tls.this_thread->curr_cor = dst;
         __stack_prepare( &dst->stack, 65000 );
         __cfactx_start(main, dst, this->runner, __cfactx_invoke_coroutine);
 
-        verify( ! kernelTLS.preemption_state.enabled );
+        /* paranoid */ verify( ! __preemption_enabled() );
 
         dst->last = &src->self_cor;
@@ -394 +395 @@
         /* paranoid */ verify(src->state == Active);
 
-        verify( ! kernelTLS.preemption_state.enabled );
+        /* paranoid */ verify( ! __preemption_enabled() );
 }
 
@@ -402 +403 @@
         $coroutine * dst = get_coroutine(this->runner);
 
-        verify( ! kernelTLS.preemption_state.enabled );
-        verify( dst->starter == src );
-        verify( dst->context.SP );
+        /* paranoid */ verify( ! __preemption_enabled() );
+        /* paranoid */ verify( dst->starter == src );
+        /* paranoid */ verify( dst->context.SP );
 
         // SKULLDUGGERY in debug the processors check that the
@@ -546 +547 @@
 
                 P( terminated );
-                verify( kernelTLS.this_processor != &this);
+                /* paranoid */ verify( active_processor() != &this);
         }
 
@@ -696 +697 @@
 #if defined(__CFA_WITH_VERIFY__)
 static bool verify_fwd_bck_rng(void) {
-        kernelTLS.ready_rng.fwd_seed = 25214903917_l64u * (rdtscl() ^ (uintptr_t)&verify_fwd_bck_rng);
+        __cfaabi_tls.ready_rng.fwd_seed = 25214903917_l64u * (rdtscl() ^ (uintptr_t)&verify_fwd_bck_rng);
 
         unsigned values[10];