Changeset 957453d for src/libcfa/concurrency/kernel.c

Timestamp:

Jul 20, 2017, 2:05:44 PM (7 years ago)

Author:

Andrew Beach <ajbeach@…>

Branches:

ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, deferred_resn, demangler, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, with_gc

Children:

c72f9fd

Parents:

d49bfa8 (diff), 8b28a52 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge branch 'master' of plg.uwaterloo.ca:software/cfa/cfa-cc

File:

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

src/libcfa/concurrency/kernel.c

@@ -42 +42 @@
 //-----------------------------------------------------------------------------
 // Kernel storage
-#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(cluster,           mainCluster);
+KERNEL_STORAGE(processor,         mainProcessor);
+KERNEL_STORAGE(processorCtx_t,    mainProcessorCtx);
+KERNEL_STORAGE(thread_desc,       mainThread);
 KERNEL_STORAGE(machine_context_t, mainThreadCtx);
 
-cluster * systemCluster;
-system_proc_t * systemProcessor;
+cluster *     mainCluster;
+processor *   mainProcessor;
 thread_desc * mainThread;
 
@@ -57 +55 @@
 // Global state
 
-volatile thread_local processor * this_processor;
-volatile thread_local coroutine_desc * this_coroutine;
-volatile thread_local thread_desc * this_thread;
+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 unsigned short disable_preempt_count = 1;
@@ -85 +84 @@
 
         this->limit = (void *)(((intptr_t)this->base) - this->size);
-        this->context = &mainThreadCtxStorage;
+        this->context = &storage_mainThreadCtx;
         this->top = this->base;
 }
@@ -125 +124 @@
 
 void ?{}(processor * this) {
-        this{ systemCluster };
+        this{ mainCluster };
 }
 
@@ -131 +130 @@
         this->cltr = cltr;
         (&this->terminated){ 0 };
-        this->is_terminated = false;
+        this->do_terminate = false;
         this->preemption_alarm = NULL;
-        this->preemption = default_preemption();
         this->pending_preemption = false;
 
@@ -142 +140 @@
         this->cltr = cltr;
         (&this->terminated){ 0 };
-        this->is_terminated = false;
+        this->do_terminate = 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 system processor context %p\n", runner);
+        LIB_DEBUG_PRINT_SAFE("Kernel : constructing main 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->is_terminated ) {
+        if( ! this->do_terminate ) {
                 LIB_DEBUG_PRINT_SAFE("Kernel : core %p signaling termination\n", this);
-                this->is_terminated = true;
+                this->do_terminate = true;
                 P( &this->terminated );
                 pthread_join( this->kernel_thread, NULL );
@@ -176 +161 @@
 void ?{}(cluster * this) {
         ( &this->ready_queue ){};
-        ( &this->lock ){};
+        ( &this->ready_queue_lock ){};
+
+        this->preemption = default_preemption();
 }
 
@@ -199 +186 @@
 
                 thread_desc * readyThread = NULL;
-                for( unsigned int spin_count = 0; ! this->is_terminated; spin_count++ )
+                for( unsigned int spin_count = 0; ! this->do_terminate; spin_count++ )
                 {
                         readyThread = nextThread( this->cltr );
@@ -343 +330 @@
         verifyf( thrd->next == NULL, "Expected null got %p", thrd->next );
 
-        lock( &systemProcessor->proc.cltr->lock DEBUG_CTX2 );
-        append( &systemProcessor->proc.cltr->ready_queue, thrd );
-        unlock( &systemProcessor->proc.cltr->lock );
+        lock(   &this_processor->cltr->ready_queue_lock DEBUG_CTX2 );
+        append( &this_processor->cltr->ready_queue, thrd );
+        unlock( &this_processor->cltr->ready_queue_lock );
 
         verify( disable_preempt_count > 0 );
@@ -352 +339 @@
 thread_desc * nextThread(cluster * this) {
         verify( disable_preempt_count > 0 );
-        lock( &this->lock DEBUG_CTX2 );
+        lock( &this->ready_queue_lock DEBUG_CTX2 );
         thread_desc * head = pop_head( &this->ready_queue );
-        unlock( &this->lock );
+        unlock( &this->ready_queue_lock );
         verify( disable_preempt_count > 0 );
         return head;
@@ -452 +439 @@
         // Start by initializing the main thread
         // SKULLDUGGERY: the mainThread steals the process main thread
-        // which will then be scheduled by the systemProcessor normally
-        mainThread = (thread_desc *)&mainThreadStorage;
+        // which will then be scheduled by the mainProcessor normally
+        mainThread = (thread_desc *)&storage_mainThread;
         current_stack_info_t info;
         mainThread{ &info };
@@ -459 +446 @@
         LIB_DEBUG_PRINT_SAFE("Kernel : Main thread ready\n");
 
-        // 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
+        // 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
         // (the coroutine that contains the processing control flow)
-        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);
+        mainProcessor = (processor *)&storage_mainProcessor;
+        mainProcessor{ mainCluster, (processorCtx_t *)&storage_mainProcessorCtx };
 
         //initialize the global state variables
-        this_processor = &systemProcessor->proc;
+        this_processor = mainProcessor;
         this_thread = mainThread;
         this_coroutine = &mainThread->cor;
-        disable_preempt_count = 1;
 
         // Enable preemption
         kernel_start_preemption();
 
-        // SKULLDUGGERY: Force a context switch to the system processor to set the main thread's context to the current UNIX
+        // 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
         // 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( systemProcessor->proc.runner );
+        resume( mainProcessor->runner );
 
 
@@ -501 +487 @@
         disable_interrupts();
 
-        // SKULLDUGGERY: Notify the systemProcessor it needs to terminates.
+        // SKULLDUGGERY: Notify the mainProcessor it needs to terminates.
         // When its coroutine terminates, it return control to the mainThread
         // which is currently here
-        systemProcessor->proc.is_terminated = true;
+        mainProcessor->do_terminate = true;
         suspend();
 
@@ -512 +498 @@
         kernel_stop_preemption();
 
-        // Destroy the system processor and its context in reverse order of construction
+        // Destroy the main processor and its context in reverse order of construction
         // These were manually constructed so we need manually destroy them
-        ^(systemProcessor->proc.runner){};
-        ^(systemProcessor){};
+        ^(mainProcessor->runner){};
+        ^(mainProcessor){};
 
         // Final step, destroy the main thread since it is no longer needed