Changes in src/libcfa/concurrency/kernel.c [6b0b624:f2b12406]

File:

• src/libcfa/concurrency/kernel.c (modified) (17 diffs)

src/libcfa/concurrency/kernel.c

@@ +1 @@
+//                              -*- Mode: CFA -*-
 //
 // Cforall Version 1.0.0 Copyright (C) 2016 University of Waterloo
@@ -9 +10 @@
 // Author           : Thierry Delisle
 // Created On       : Tue Jan 17 12:27:26 2017
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Jul 21 22:33:18 2017
-// Update Count     : 2
+// Last Modified By : Thierry Delisle
+// Last Modified On : --
+// Update Count     : 0
 //
 
@@ -41 +42 @@
 //-----------------------------------------------------------------------------
 // Kernel storage
-KERNEL_STORAGE(cluster,           mainCluster);
-KERNEL_STORAGE(processor,         mainProcessor);
-KERNEL_STORAGE(processorCtx_t,    mainProcessorCtx);
-KERNEL_STORAGE(thread_desc,       mainThread);
+#define KERNEL_STORAGE(T,X) static char X##Storage[sizeof(T)]
+
+KERNEL_STORAGE(processorCtx_t, systemProcessorCtx);
+KERNEL_STORAGE(cluster, systemCluster);
+KERNEL_STORAGE(system_proc_t, systemProcessor);
+KERNEL_STORAGE(thread_desc, mainThread);
 KERNEL_STORAGE(machine_context_t, mainThreadCtx);
 
-cluster *     mainCluster;
-processor *   mainProcessor;
+cluster * systemCluster;
+system_proc_t * systemProcessor;
 thread_desc * mainThread;
 
@@ -54 +57 @@
 // Global state
 
-thread_local coroutine_desc * volatile this_coroutine;
-thread_local thread_desc *    volatile this_thread;
-thread_local processor *      volatile this_processor;
-
-volatile thread_local bool preemption_in_progress = 0;
+volatile thread_local processor * this_processor;
+volatile thread_local coroutine_desc * this_coroutine;
+volatile thread_local thread_desc * this_thread;
 volatile thread_local unsigned short disable_preempt_count = 1;
 
@@ -83 +84 @@
 
         this->limit = (void *)(((intptr_t)this->base) - this->size);
-        this->context = &storage_mainThreadCtx;
+        this->context = &mainThreadCtxStorage;
         this->top = this->base;
 }
@@ -123 +124 @@
 
 void ?{}(processor * this) {
-        this{ mainCluster };
+        this{ systemCluster };
 }
 
@@ -129 +130 @@
         this->cltr = cltr;
         (&this->terminated){ 0 };
-        this->do_terminate = false;
+        this->is_terminated = false;
         this->preemption_alarm = NULL;
+        this->preemption = default_preemption();
         this->pending_preemption = false;
 
@@ -139 +141 @@
         this->cltr = cltr;
         (&this->terminated){ 0 };
-        this->do_terminate = false;
+        this->is_terminated = false;
         this->preemption_alarm = NULL;
+        this->preemption = default_preemption();
         this->pending_preemption = false;
         this->kernel_thread = pthread_self();
 
         this->runner = runner;
-        LIB_DEBUG_PRINT_SAFE("Kernel : constructing main processor context %p\n", runner);
+        LIB_DEBUG_PRINT_SAFE("Kernel : constructing system processor context %p\n", runner);
         runner{ this };
 }
 
+LIB_DEBUG_DO( bool validate( alarm_list_t * this ); )
+
+void ?{}(system_proc_t * this, cluster * cltr, processorCtx_t * runner) {
+        (&this->alarms){};
+        (&this->alarm_lock){};
+        this->pending_alarm = false;
+
+        (&this->proc){ cltr, runner };
+
+        verify( validate( &this->alarms ) );
+}
+
 void ^?{}(processor * this) {
-        if( ! this->do_terminate ) {
+        if( ! this->is_terminated ) {
                 LIB_DEBUG_PRINT_SAFE("Kernel : core %p signaling termination\n", this);
-                this->do_terminate = true;
+                this->is_terminated = true;
                 P( &this->terminated );
                 pthread_join( this->kernel_thread, NULL );
@@ -160 +175 @@
 void ?{}(cluster * this) {
         ( &this->ready_queue ){};
-        ( &this->ready_queue_lock ){};
-
-        this->preemption = default_preemption();
+        ( &this->lock ){};
 }
 
@@ -185 +198 @@
 
                 thread_desc * readyThread = NULL;
-                for( unsigned int spin_count = 0; ! this->do_terminate; spin_count++ )
+                for( unsigned int spin_count = 0; ! this->is_terminated; spin_count++ )
                 {
                         readyThread = nextThread( this->cltr );
@@ -329 +342 @@
         verifyf( thrd->next == NULL, "Expected null got %p", thrd->next );
 
-        lock(   &this_processor->cltr->ready_queue_lock DEBUG_CTX2 );
-        append( &this_processor->cltr->ready_queue, thrd );
-        unlock( &this_processor->cltr->ready_queue_lock );
+        lock( &systemProcessor->proc.cltr->lock DEBUG_CTX2 );
+        append( &systemProcessor->proc.cltr->ready_queue, thrd );
+        unlock( &systemProcessor->proc.cltr->lock );
 
         verify( disable_preempt_count > 0 );
@@ -338 +351 @@
 thread_desc * nextThread(cluster * this) {
         verify( disable_preempt_count > 0 );
-        lock( &this->ready_queue_lock DEBUG_CTX2 );
+        lock( &this->lock DEBUG_CTX2 );
         thread_desc * head = pop_head( &this->ready_queue );
-        unlock( &this->ready_queue_lock );
+        unlock( &this->lock );
         verify( disable_preempt_count > 0 );
         return head;
@@ -438 +451 @@
         // Start by initializing the main thread
         // SKULLDUGGERY: the mainThread steals the process main thread
-        // which will then be scheduled by the mainProcessor normally
-        mainThread = (thread_desc *)&storage_mainThread;
+        // which will then be scheduled by the systemProcessor normally
+        mainThread = (thread_desc *)&mainThreadStorage;
         current_stack_info_t info;
         mainThread{ &info };
@@ -445 +458 @@
         LIB_DEBUG_PRINT_SAFE("Kernel : Main thread ready\n");
 
-        // Initialize the main cluster
-        mainCluster = (cluster *)&storage_mainCluster;
-        mainCluster{};
-
-        LIB_DEBUG_PRINT_SAFE("Kernel : main cluster ready\n");
-
-        // Initialize the main processor and the main processor ctx
+        // Initialize the system cluster
+        systemCluster = (cluster *)&systemClusterStorage;
+        systemCluster{};
+
+        LIB_DEBUG_PRINT_SAFE("Kernel : System cluster ready\n");
+
+        // Initialize the system processor and the system processor ctx
         // (the coroutine that contains the processing control flow)
-        mainProcessor = (processor *)&storage_mainProcessor;
-        mainProcessor{ mainCluster, (processorCtx_t *)&storage_mainProcessorCtx };
+        systemProcessor = (system_proc_t *)&systemProcessorStorage;
+        systemProcessor{ systemCluster, (processorCtx_t *)&systemProcessorCtxStorage };
+
+        // Add the main thread to the ready queue
+        // once resume is called on systemProcessor->runner the mainThread needs to be scheduled like any normal thread
+        ScheduleThread(mainThread);
 
         //initialize the global state variables
-        this_processor = mainProcessor;
+        this_processor = &systemProcessor->proc;
         this_thread = mainThread;
         this_coroutine = &mainThread->cor;
+        disable_preempt_count = 1;
 
         // Enable preemption
         kernel_start_preemption();
 
-        // 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
-        ScheduleThread(mainThread);
-
-        // SKULLDUGGERY: Force a context switch to the main processor to set the main thread's context to the current UNIX
+        // SKULLDUGGERY: Force a context switch to the system processor to set the main thread's context to the current UNIX
         // context. Hence, the main thread does not begin through CtxInvokeThread, like all other threads. The trick here is that
         // mainThread is on the ready queue when this call is made.
-        resume( mainProcessor->runner );
+        resume( systemProcessor->proc.runner );
 
 
@@ -486 +500 @@
         disable_interrupts();
 
-        // SKULLDUGGERY: Notify the mainProcessor it needs to terminates.
+        // SKULLDUGGERY: Notify the systemProcessor it needs to terminates.
         // When its coroutine terminates, it return control to the mainThread
         // which is currently here
-        mainProcessor->do_terminate = true;
+        systemProcessor->proc.is_terminated = true;
         suspend();
 
@@ -497 +511 @@
         kernel_stop_preemption();
 
-        // Destroy the main processor and its context in reverse order of construction
+        // Destroy the system processor and its context in reverse order of construction
         // These were manually constructed so we need manually destroy them
-        ^(mainProcessor->runner){};
-        ^(mainProcessor){};
+        ^(systemProcessor->proc.runner){};
+        ^(systemProcessor){};
 
         // Final step, destroy the main thread since it is no longer needed
@@ -684 +698 @@
         return top;
 }
-
 // Local Variables: //
 // mode: c //