Changeset 10e90cb for src/libcfa/concurrency/kernel.c

Timestamp:

Jun 6, 2017, 2:50:57 PM (7 years ago)

Author:

Rob Schluntz <rschlunt@…>

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:

c6d2e93

Parents:

8ca3a72 (diff), c5ac6d5 (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:/u/cforall/software/cfa/cfa-cc

File:

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

src/libcfa/concurrency/kernel.c

@@ -36 +36 @@
 //CFA Includes
 #include "libhdr.h"
+#include "preemption.h"
 
 //Private includes
@@ -47 +48 @@
 KERNEL_STORAGE(processorCtx_t, systemProcessorCtx);
 KERNEL_STORAGE(cluster, systemCluster);
-KERNEL_STORAGE(processor, systemProcessor);
+KERNEL_STORAGE(system_proc_t, systemProcessor);
 KERNEL_STORAGE(thread_desc, mainThread);
 KERNEL_STORAGE(machine_context_t, mainThread_context);
 
 cluster * systemCluster;
-processor * systemProcessor;
+system_proc_t * systemProcessor;
 thread_desc * mainThread;
 
@@ -118 +119 @@
 // Processor coroutine
 void ?{}(processorCtx_t * this, processor * proc) {
-        (&this->__cor){};
+        (&this->__cor){ "Processor" };
         this->proc = proc;
         proc->runner = this;
@@ -139 +140 @@
         (&this->terminated){};
         this->is_terminated = false;
+        this->preemption_alarm = NULL;
+        this->preemption = default_preemption();
+        this->disable_preempt_count = 1;                //Start with interrupts disabled
+        this->pending_preemption = false;
 
         start( this );
@@ -149 +154 @@
         (&this->terminated){};
         this->is_terminated = false;
+        this->disable_preempt_count = 0;
+        this->pending_preemption = false;
 
         this->runner = runner;
         LIB_DEBUG_PRINT_SAFE("Kernel : constructing processor context %p\n", runner);
         runner{ this };
+}
+
+void ?{}(system_proc_t * this, cluster * cltr, processorCtx_t * runner) {
+        (&this->alarms){};
+        (&this->alarm_lock){};
+        this->pending_alarm = false;
+
+        (&this->proc){ cltr, runner };
 }
 
@@ -178 +193 @@
 void main(processorCtx_t * runner) {
         processor * this = runner->proc;
+
         LIB_DEBUG_PRINT_SAFE("Kernel : core %p starting\n", this);
 
-        thread_desc * readyThread = NULL;
-        for( unsigned int spin_count = 0; ! this->is_terminated; spin_count++ ) 
         {
-                readyThread = nextThread( this->cltr );
-
-                if(readyThread) 
+                // Setup preemption data
+                preemption_scope scope = { this };
+
+                LIB_DEBUG_PRINT_SAFE("Kernel : core %p started\n", this);
+
+                thread_desc * readyThread = NULL;
+                for( unsigned int spin_count = 0; ! this->is_terminated; spin_count++ ) 
                 {
-                        runThread(this, readyThread);
-
-                        //Some actions need to be taken from the kernel
-                        finishRunning(this);
-
-                        spin_count = 0;
-                } 
-                else 
-                {
-                        spin(this, &spin_count);
-                }               
-        }
-
-        LIB_DEBUG_PRINT_SAFE("Kernel : core %p unlocking thread\n", this);
+                        readyThread = nextThread( this->cltr );
+
+                        if(readyThread)
+                        {
+                                runThread(this, readyThread);
+
+                                //Some actions need to be taken from the kernel
+                                finishRunning(this);
+
+                                spin_count = 0;
+                        }
+                        else
+                        {
+                                spin(this, &spin_count);
+                        }
+                }
+
+                LIB_DEBUG_PRINT_SAFE("Kernel : core %p stopping\n", this);
+        }
+
         signal( &this->terminated );
         LIB_DEBUG_PRINT_SAFE("Kernel : core %p terminated\n", this);
@@ -299 +323 @@
         LIB_DEBUG_PRINT_SAFE("Kernel : Starting core %p\n", this);
         
-        // pthread_attr_t attributes;
-        // pthread_attr_init( &attributes );
-
         pthread_create( &this->kernel_thread, NULL, CtxInvokeProcessor, (void*)this );
-
-        // pthread_attr_destroy( &attributes );
 
         LIB_DEBUG_PRINT_SAFE("Kernel : core %p started\n", this);       
@@ -316 +335 @@
         assertf( thrd->next == NULL, "Expected null got %p", thrd->next );
         
-        lock( &systemProcessor->cltr->lock );
-        append( &systemProcessor->cltr->ready_queue, thrd );
-        unlock( &systemProcessor->cltr->lock );
+        lock( &systemProcessor->proc.cltr->lock );
+        append( &systemProcessor->proc.cltr->ready_queue, thrd );
+        unlock( &systemProcessor->proc.cltr->lock );
 }
 
@@ -367 +386 @@
 }
 
+//=============================================================================================
+// Kernel Setup logic
+//=============================================================================================
 //-----------------------------------------------------------------------------
 // Kernel boot procedures
@@ -379 +401 @@
         mainThread{ &info };
 
+        LIB_DEBUG_PRINT_SAFE("Kernel : Main thread ready\n");
+
+        // Enable preemption
+        kernel_start_preemption();
+
         // Initialize the system cluster
         systemCluster = (cluster *)&systemCluster_storage;
         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)
-        systemProcessor = (processor *)&systemProcessor_storage;
+        systemProcessor = (system_proc_t *)&systemProcessor_storage;
         systemProcessor{ systemCluster, (processorCtx_t *)&systemProcessorCtx_storage };
 
         // Add the main thread to the ready queue 
-        // once resume is called on systemProcessor->ctx the mainThread needs to be scheduled like any normal thread
+        // 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 = systemProcessor;
+        this_processor = &systemProcessor->proc;
         this_processor->current_thread = mainThread;
         this_processor->current_coroutine = &mainThread->cor;
@@ -400 +429 @@
         // 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->runner);
+        resume( systemProcessor->proc.runner );
 
 
@@ -414 +443 @@
         // When its coroutine terminates, it return control to the mainThread
         // which is currently here
-        systemProcessor->is_terminated = true;
+        systemProcessor->proc.is_terminated = true;
         suspend();
 
@@ -421 +450 @@
         // Destroy the system processor and its context in reverse order of construction
         // These were manually constructed so we need manually destroy them
-        ^(systemProcessor->runner){};
+        ^(systemProcessor->proc.runner){};
         ^(systemProcessor){};
 
@@ -484 +513 @@
 }
 
+//=============================================================================================
+// Kernel Utilities
+//=============================================================================================
 //-----------------------------------------------------------------------------
 // Locks
@@ -491 +523 @@
 void ^?{}( spinlock * this ) {
 
+}
+
+bool try_lock( spinlock * this ) {
+        return this->lock == 0 && __sync_lock_test_and_set_4( &this->lock, 1 ) == 0;
 }