Changes in libcfa/src/concurrency/kernel/startup.cfa [8fc652e0:6a77224]

File:

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

libcfa/src/concurrency/kernel/startup.cfa

@@ -118 +118 @@
 //-----------------------------------------------------------------------------
 // Global state
-thread_local struct KernelThreadData __cfaabi_tls __attribute__ ((tls_model ( "initial-exec" ))) @= {
+thread_local struct KernelThreadData kernelTLS __attribute__ ((tls_model ( "initial-exec" ))) @= {
         NULL,                                                                                           // cannot use 0p
-        NULL,
         NULL,
         NULL,
@@ -156 +155 @@
 // Kernel boot procedures
 static void __kernel_startup(void) {
-        /* paranoid */ verify( ! __preemption_enabled() );
+        verify( ! kernelTLS.preemption_state.enabled );
         __cfadbg_print_safe(runtime_core, "Kernel : Starting\n");
 
@@ -212 +211 @@
 
         //initialize the global state variables
-        __cfaabi_tls.this_processor = mainProcessor;
-        __cfaabi_tls.this_proc_id   = (__processor_id_t*)mainProcessor;
-        __cfaabi_tls.this_thread    = mainThread;
+        kernelTLS.this_processor = mainProcessor;
+        kernelTLS.this_thread    = mainThread;
 
         #if !defined( __CFA_NO_STATISTICS__ )
-                __cfaabi_tls.this_stats = (__stats_t *)& storage_mainProcStats;
-                __init_stats( __cfaabi_tls.this_stats );
+                kernelTLS.this_stats = (__stats_t *)& storage_mainProcStats;
+                __init_stats( kernelTLS.this_stats );
         #endif
 
@@ -229 +227 @@
         // Add the main thread to the ready queue
         // once resume is called on mainProcessor->runner the mainThread needs to be scheduled like any normal thread
-        __schedule_thread(mainThread);
+        __schedule_thread((__processor_id_t *)mainProcessor, mainThread);
 
         // SKULLDUGGERY: Force a context switch to the main processor to set the main thread's context to the current UNIX
         // 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( __cfaabi_tls.this_processor );
+        __kernel_first_resume( kernelTLS.this_processor );
 
 
@@ -251 +249 @@
         __cfadbg_print_safe(runtime_core, "Kernel : Started\n--------------------------------------------------\n\n");
 
-        /* paranoid */ verify( ! __preemption_enabled() );
+        verify( ! kernelTLS.preemption_state.enabled );
         enable_interrupts( __cfaabi_dbg_ctx );
-        /* paranoid */ verify( __preemption_enabled() );
-
+        verify( TL_GET( preemption_state.enabled ) );
 }
 
@@ -263 +260 @@
         mainCluster->io.ctxs = 0p;
 
-        /* paranoid */ verify( __preemption_enabled() );
+        /* paranoid */ verify( TL_GET( preemption_state.enabled ) );
         disable_interrupts();
-        /* paranoid */ verify( ! __preemption_enabled() );
+        /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
 
         __cfadbg_print_safe(runtime_core, "\n--------------------------------------------------\nKernel : Shutting down\n");
@@ -273 +270 @@
         // which is currently here
         __atomic_store_n(&mainProcessor->do_terminate, true, __ATOMIC_RELEASE);
-        __kernel_last_resume( __cfaabi_tls.this_processor );
+        __kernel_last_resume( kernelTLS.this_processor );
         mainThread->self_cor.state = Halted;
 
@@ -322 +319 @@
                 __stats_t local_stats;
                 __init_stats( &local_stats );
-                __cfaabi_tls.this_stats = &local_stats;
+                kernelTLS.this_stats = &local_stats;
         #endif
 
         processor * proc = (processor *) arg;
-        __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];
+        kernelTLS.this_processor = proc;
+        kernelTLS.this_thread    = 0p;
+        kernelTLS.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
@@ -341 +337 @@
 
         //Set global state
-        __cfaabi_tls.this_thread = 0p;
+        kernelTLS.this_thread = 0p;
 
         //We now have a proper context from which to schedule threads
@@ -371 +367 @@
         $coroutine * dst = get_coroutine(this->runner);
 
-        /* paranoid */ verify( ! __preemption_enabled() );
-
-        __cfaabi_tls.this_thread->curr_cor = dst;
+        verify( ! kernelTLS.preemption_state.enabled );
+
+        kernelTLS.this_thread->curr_cor = dst;
         __stack_prepare( &dst->stack, 65000 );
         __cfactx_start(main, dst, this->runner, __cfactx_invoke_coroutine);
 
-        /* paranoid */ verify( ! __preemption_enabled() );
+        verify( ! kernelTLS.preemption_state.enabled );
 
         dst->last = &src->self_cor;
@@ -395 +391 @@
         /* paranoid */ verify(src->state == Active);
 
-        /* paranoid */ verify( ! __preemption_enabled() );
+        verify( ! kernelTLS.preemption_state.enabled );
 }
 
@@ -403 +399 @@
         $coroutine * dst = get_coroutine(this->runner);
 
-        /* paranoid */ verify( ! __preemption_enabled() );
-        /* paranoid */ verify( dst->starter == src );
-        /* paranoid */ verify( dst->context.SP );
+        verify( ! kernelTLS.preemption_state.enabled );
+        verify( dst->starter == src );
+        verify( dst->context.SP );
 
         // SKULLDUGGERY in debug the processors check that the
@@ -547 +543 @@
 
                 P( terminated );
-                /* paranoid */ verify( active_processor() != &this);
+                verify( kernelTLS.this_processor != &this);
         }
 
@@ -697 +693 @@
 #if defined(__CFA_WITH_VERIFY__)
 static bool verify_fwd_bck_rng(void) {
-        __cfaabi_tls.ready_rng.fwd_seed = 25214903917_l64u * (rdtscl() ^ (uintptr_t)&verify_fwd_bck_rng);
+        kernelTLS.ready_rng.fwd_seed = 25214903917_l64u * (rdtscl() ^ (uintptr_t)&verify_fwd_bck_rng);
 
         unsigned values[10];