Changes in src/libcfa/concurrency/kernel.c [c81ebf9:0c78741]

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
@@ -48 +47 @@
 KERNEL_STORAGE(processorCtx_t, systemProcessorCtx);
 KERNEL_STORAGE(cluster, systemCluster);
-KERNEL_STORAGE(system_proc_t, systemProcessor);
+KERNEL_STORAGE(processor, systemProcessor);
 KERNEL_STORAGE(thread_desc, mainThread);
 KERNEL_STORAGE(machine_context_t, mainThread_context);
 
 cluster * systemCluster;
-system_proc_t * systemProcessor;
+processor * systemProcessor;
 thread_desc * mainThread;
 
@@ -119 +118 @@
 // Processor coroutine
 void ?{}(processorCtx_t * this, processor * proc) {
-        (&this->__cor){ "Processor" };
+        (&this->__cor){};
         this->proc = proc;
         proc->runner = this;
@@ -140 +139 @@
         (&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 );
@@ -154 +149 @@
         (&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 };
 }
 
@@ -193 +178 @@
 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++ ) 
         {
-                // 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++ ) 
+                readyThread = nextThread( this->cltr );
+
+                if(readyThread) 
                 {
-                        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);
-        }
-
+                        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);
         signal( &this->terminated );
         LIB_DEBUG_PRINT_SAFE("Kernel : core %p terminated\n", this);
@@ -323 +299 @@
         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);       
@@ -335 +316 @@
         assertf( thrd->next == NULL, "Expected null got %p", thrd->next );
         
-        lock( &systemProcessor->proc.cltr->lock );
-        append( &systemProcessor->proc.cltr->ready_queue, thrd );
-        unlock( &systemProcessor->proc.cltr->lock );
+        lock( &systemProcessor->cltr->lock );
+        append( &systemProcessor->cltr->ready_queue, thrd );
+        unlock( &systemProcessor->cltr->lock );
 }
 
@@ -386 +367 @@
 }
 
-//=============================================================================================
-// Kernel Setup logic
-//=============================================================================================
 //-----------------------------------------------------------------------------
 // Kernel boot procedures
@@ -401 +379 @@
         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 = (system_proc_t *)&systemProcessor_storage;
+        systemProcessor = (processor *)&systemProcessor_storage;
         systemProcessor{ systemCluster, (processorCtx_t *)&systemProcessorCtx_storage };
 
         // 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
+        // once resume is called on systemProcessor->ctx the mainThread needs to be scheduled like any normal thread
         ScheduleThread(mainThread);
 
         //initialize the global state variables
-        this_processor = &systemProcessor->proc;
+        this_processor = systemProcessor;
         this_processor->current_thread = mainThread;
         this_processor->current_coroutine = &mainThread->cor;
@@ -429 +400 @@
         // 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(systemProcessor->runner);
 
 
@@ -443 +414 @@
         // When its coroutine terminates, it return control to the mainThread
         // which is currently here
-        systemProcessor->proc.is_terminated = true;
+        systemProcessor->is_terminated = true;
         suspend();
 
@@ -450 +421 @@
         // Destroy the system processor and its context in reverse order of construction
         // These were manually constructed so we need manually destroy them
-        ^(systemProcessor->proc.runner){};
+        ^(systemProcessor->runner){};
         ^(systemProcessor){};
 
@@ -513 +484 @@
 }
 
-//=============================================================================================
-// Kernel Utilities
-//=============================================================================================
 //-----------------------------------------------------------------------------
 // Locks
@@ -523 +491 @@
 void ^?{}( spinlock * this ) {
 
-}
-
-bool try_lock( spinlock * this ) {
-        return this->lock == 0 && __sync_lock_test_and_set_4( &this->lock, 1 ) == 0;
 }