Changes in src/libcfa/concurrency/kernel.c [8def349:bd98b58]

File:

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

src/libcfa/concurrency/kernel.c

@@ -32 +32 @@
 #include "invoke.h"
 
-//-----------------------------------------------------------------------------
-// Kernel storage
+cluster * systemCluster;
+processor * systemProcessor;
+thread_h * mainThread;
+
+void kernel_startup(void)  __attribute__((constructor(101)));
+void kernel_shutdown(void) __attribute__((destructor(101)));
+
+void ?{}(processor * this, cluster * cltr) {
+        this->ctx = NULL;
+        this->cltr = cltr;
+        this->terminated = false;
+}
+
+void ^?{}(processor * this) {}
+
+void ?{}(cluster * this) {
+        ( &this->ready_queue ){};
+}
+
+void ^?{}(cluster * this) {}
+
+//-----------------------------------------------------------------------------
+// Global state
+
+/*thread_local*/ processor * this_processor;
+
+coroutine * this_coroutine(void) {
+        return this_processor->current_coroutine;
+}
+
+thread_h * this_thread(void) {
+        return this_processor->current_thread;
+}
+
+//-----------------------------------------------------------------------------
+// Processor coroutine
 struct processorCtx_t {
         processor * proc;
@@ -41 +75 @@
 DECL_COROUTINE(processorCtx_t)
 
+void ?{}(processorCtx_t * this, processor * proc) {
+        (&this->c){};
+        this->proc = proc;
+}
+
+void CtxInvokeProcessor(processor * proc) {
+        processorCtx_t proc_cor_storage = {proc};
+        resume( &proc_cor_storage );
+}
+
+//-----------------------------------------------------------------------------
+// Processor running routines
+void main(processorCtx_t * ctx);
+thread_h * nextThread(cluster * this);
+void runThread(processor * this, thread_h * dst);
+void spin(processor * this, unsigned int * spin_count);
+
+void main(processorCtx_t * ctx) {
+        processor * this = ctx->proc;
+        LIB_DEBUG_PRINTF("Kernel : core %p starting\n", this);
+
+        thread_h * readyThread = NULL;
+        for( unsigned int spin_count = 0; ! this->terminated; spin_count++ ) {
+                
+                readyThread = nextThread( this->cltr );
+
+                if(readyThread) {
+                        runThread(this, readyThread);
+                        spin_count = 0;
+                } else {
+                        spin(this, &spin_count);
+                }               
+        }
+
+        LIB_DEBUG_PRINTF("Kernel : core %p terminated\n", this);
+}
+
+void runThread(processor * this, thread_h * dst) {
+        coroutine * proc_ctx = get_coroutine(this->ctx);
+        coroutine * thrd_ctx = get_coroutine(dst);
+        thrd_ctx->last = proc_ctx;
+
+        // context switch to specified coroutine
+        // Which is now the current_coroutine
+        // LIB_DEBUG_PRINTF("Kernel : switching to ctx %p (from %p, current %p)\n", thrd_ctx, proc_ctx, current_coroutine);
+        this->current_thread = dst;
+        this->current_coroutine = thrd_ctx;
+        CtxSwitch( proc_ctx->stack.context, thrd_ctx->stack.context );
+        this->current_coroutine = proc_ctx;
+        // LIB_DEBUG_PRINTF("Kernel : returned from ctx %p (to %p, current %p)\n", thrd_ctx, proc_ctx, current_coroutine);
+
+        // when CtxSwitch returns we are back in the processor coroutine
+}
+
+void spin(processor * this, unsigned int * spin_count) {
+        (*spin_count)++;
+}
+
+//-----------------------------------------------------------------------------
+// Scheduler routines
+void thread_schedule( thread_h * thrd ) {
+        assertf( thrd->next == NULL, "Expected null got %p", thrd->next );
+        append( &systemProcessor->cltr->ready_queue, thrd );
+}
+
+thread_h * nextThread(cluster * this) {
+        return pop_head( &this->ready_queue );
+}
+
+//-----------------------------------------------------------------------------
+// Kernel storage
 #define KERNEL_STORAGE(T,X) static char X##_storage[sizeof(T)]
 
@@ -49 +154 @@
 KERNEL_STORAGE(machine_context_t, mainThread_context);
 
-cluster * systemCluster;
-processor * systemProcessor;
-thread_h * mainThread;
-
-void kernel_startup(void)  __attribute__((constructor(101)));
-void kernel_shutdown(void) __attribute__((destructor(101)));
-
-//-----------------------------------------------------------------------------
-// Global state
-
-thread_local processor * this_processor;
-
-processor * get_this_processor() {
-        return this_processor;
-}
-
-coroutine * this_coroutine(void) {
-        return this_processor->current_coroutine;
-}
-
-thread_h * this_thread(void) {
-        return this_processor->current_thread;
-}
-
 //-----------------------------------------------------------------------------
 // Main thread construction
-struct current_stack_info_t {
+struct mainThread_info_t {
         machine_context_t ctx;  
         unsigned int size;              // size of stack
@@ -85 +166 @@
 };
 
-void ?{}( current_stack_info_t * this ) {
+void ?{}( mainThread_info_t * this ) {
         CtxGet( &this->ctx );
         this->base = this->ctx.FP;
@@ -99 +180 @@
 }
 
-void ?{}( coStack_t * this, current_stack_info_t * info) {
+void ?{}( coStack_t * this, mainThread_info_t * info) {
         this->size = info->size;
         this->storage = info->storage;
@@ -109 +190 @@
 }
 
-void ?{}( coroutine * this, current_stack_info_t * info) {
+void ?{}( coroutine * this, mainThread_info_t * info) {
         (&this->stack){ info }; 
         this->name = "Main Thread";
@@ -117 +198 @@
 }
 
-void ?{}( thread_h * this, current_stack_info_t * info) {
+void ?{}( thread_h * this, mainThread_info_t * info) {
         (&this->c){ info };
-}
-
-//-----------------------------------------------------------------------------
-// Processor coroutine
-void ?{}(processorCtx_t * this, processor * proc) {
-        (&this->c){};
-        this->proc = proc;
-        proc->ctx = this;
-}
-
-void ?{}(processorCtx_t * this, processor * proc, current_stack_info_t * info) {
-        (&this->c){ info };
-        this->proc = proc;
-        proc->ctx = this;
-}
-
-void start(processor * this);
-
-void ?{}(processor * this) {
-        this{ systemCluster };
-}
-
-void ?{}(processor * this, cluster * cltr) {
-        this->cltr = cltr;
-        this->current_coroutine = NULL;
-        this->current_thread = NULL;
-        (&this->lock){};
-        this->terminated = false;
-
-        start( this );
-}
-
-void ?{}(processor * this, cluster * cltr, processorCtx_t * ctx) {
-        this->cltr = cltr;
-        this->current_coroutine = NULL;
-        this->current_thread = NULL;
-        (&this->lock){};
-        this->terminated = false;
-
-        this->ctx = ctx;
-        LIB_DEBUG_PRINTF("Kernel : constructing processor context %p\n", ctx);
-        ctx{ this };
-}
-
-void ^?{}(processor * this) {
-        if( ! this->terminated ) {
-                LIB_DEBUG_PRINTF("Kernel : core %p signaling termination\n", this);
-                this->terminated = true;
-                lock( &this->lock );
-        }
-}
-
-void ?{}(cluster * this) {
-        ( &this->ready_queue ){};
-        pthread_spin_init( &this->lock, PTHREAD_PROCESS_PRIVATE );
-}
-
-void ^?{}(cluster * this) {
-        pthread_spin_destroy( &this->lock );
-}
-
-//-----------------------------------------------------------------------------
-// Processor running routines
-void main(processorCtx_t * ctx);
-thread_h * nextThread(cluster * this);
-void runThread(processor * this, thread_h * dst);
-void spin(processor * this, unsigned int * spin_count);
-
-void main(processorCtx_t * ctx) {
-        processor * this = ctx->proc;
-        LIB_DEBUG_PRINTF("Kernel : core %p starting\n", this);
-
-        thread_h * readyThread = NULL;
-        for( unsigned int spin_count = 0; ! this->terminated; spin_count++ ) {
-                
-                readyThread = nextThread( this->cltr );
-
-                if(readyThread) {
-                        runThread(this, readyThread);
-                        spin_count = 0;
-                } else {
-                        spin(this, &spin_count);
-                }               
-        }
-
-        LIB_DEBUG_PRINTF("Kernel : core %p unlocking thread\n", this);
-        unlock( &this->lock );
-        LIB_DEBUG_PRINTF("Kernel : core %p terminated\n", this);
-}
-
-void runThread(processor * this, thread_h * dst) {
-        coroutine * proc_ctx = get_coroutine(this->ctx);
-        coroutine * thrd_ctx = get_coroutine(dst);
-        thrd_ctx->last = proc_ctx;
-
-        // context switch to specified coroutine
-        // Which is now the current_coroutine
-        // LIB_DEBUG_PRINTF("Kernel : switching to ctx %p (from %p, current %p)\n", thrd_ctx, proc_ctx, current_coroutine);
-        this->current_thread = dst;
-        this->current_coroutine = thrd_ctx;
-        CtxSwitch( proc_ctx->stack.context, thrd_ctx->stack.context );
-        this->current_coroutine = proc_ctx;
-        // LIB_DEBUG_PRINTF("Kernel : returned from ctx %p (to %p, current %p)\n", thrd_ctx, proc_ctx, current_coroutine);
-
-        // when CtxSwitch returns we are back in the processor coroutine
-}
-
-void spin(processor * this, unsigned int * spin_count) {
-        (*spin_count)++;
-}
-
-void * CtxInvokeProcessor(void * arg) {
-        processor * proc = (processor *) arg;
-        this_processor = proc;
-        // 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
-        // to waste the perfectly valid stack create by pthread. 
-        current_stack_info_t info;
-        machine_context_t ctx;
-        info.context = &ctx;
-        processorCtx_t proc_cor_storage = { proc, &info };
-
-        proc->current_coroutine = &proc->ctx->c;
-        proc->current_thread = NULL;
-
-        LIB_DEBUG_PRINTF("Kernel : core %p created (%p)\n", proc, proc->ctx);
-
-        // LIB_DEBUG_PRINTF("Kernel : core    base : %p \n", info.base );
-        // LIB_DEBUG_PRINTF("Kernel : core storage : %p \n", info.storage );
-        // LIB_DEBUG_PRINTF("Kernel : core    size : %x \n", info.size );
-        // LIB_DEBUG_PRINTF("Kernel : core   limit : %p \n", info.limit );
-        // LIB_DEBUG_PRINTF("Kernel : core context : %p \n", info.context );
-        // LIB_DEBUG_PRINTF("Kernel : core     top : %p \n", info.top );
-
-        //We now have a proper context from which to schedule threads
-
-        // SKULLDUGGERY: Since the coroutine doesn't have its own stack, we can't 
-        // resume it to start it like it normally would, it will just context switch 
-        // back to here. Instead directly call the main since we already are on the 
-        // appropriate stack.
-        proc_cor_storage.c.state = Active;
-      main( &proc_cor_storage );
-      proc_cor_storage.c.state = Halt;
-      proc_cor_storage.c.notHalted = false;
-
-        LIB_DEBUG_PRINTF("Kernel : core %p main ended (%p)\n", proc, proc->ctx);        
-
-        return NULL;
-}
-
-void start(processor * this) {
-        LIB_DEBUG_PRINTF("Kernel : Starting core %p\n", this);
-        
-        pthread_attr_t attributes;
-        pthread_attr_init( &attributes );
-
-        pthread_create( &this->kernel_thread, &attributes, CtxInvokeProcessor, (void*)this );
-
-        pthread_attr_destroy( &attributes );
-
-        LIB_DEBUG_PRINTF("Kernel : core %p started\n", this);   
-}
-
-//-----------------------------------------------------------------------------
-// Scheduler routines
-void thread_schedule( thread_h * thrd ) {
-        assertf( thrd->next == NULL, "Expected null got %p", thrd->next );
-        
-        pthread_spinlock_guard guard = { &systemProcessor->cltr->lock };
-        append( &systemProcessor->cltr->ready_queue, thrd );
-}
-
-thread_h * nextThread(cluster * this) {
-        pthread_spinlock_guard guard = { &this->lock };
-        return pop_head( &this->ready_queue );
 }
 
@@ -304 +210 @@
         LIB_DEBUG_PRINTF("Kernel : Starting\n");        
 
-        current_stack_info_t info;
-
-        // LIB_DEBUG_PRINTF("Kernel : core    base : %p \n", info.base );
-        // LIB_DEBUG_PRINTF("Kernel : core storage : %p \n", info.storage );
-        // LIB_DEBUG_PRINTF("Kernel : core    size : %x \n", info.size );
-        // LIB_DEBUG_PRINTF("Kernel : core   limit : %p \n", info.limit );
-        // LIB_DEBUG_PRINTF("Kernel : core context : %p \n", info.context );
-        // LIB_DEBUG_PRINTF("Kernel : core     top : %p \n", info.top );
+        mainThread_info_t ctx;
 
         // Start by initializing the main thread
         mainThread = (thread_h *)&mainThread_storage;
-        mainThread{ &info };
+        mainThread{ &ctx };
 
         // Initialize the system cluster
@@ -321 +220 @@
         systemCluster{};
 
-        // Initialize the system processor and the system processor ctx
+        // Initialize the system processor
+        systemProcessor = (processor *)&systemProcessor_storage;
+        systemProcessor{ systemCluster };
+
+        // Initialize the system processor ctx
         // (the coroutine that contains the processing control flow)
-        systemProcessor = (processor *)&systemProcessor_storage;
-        systemProcessor{ systemCluster, (processorCtx_t *)&systemProcessorCtx_storage };
+        systemProcessor->ctx = (processorCtx_t *)&systemProcessorCtx_storage;
+        systemProcessor->ctx{ systemProcessor };
 
         // Add the main thread to the ready queue 
@@ -383 +286 @@
 
 void lock( simple_lock * this ) {
-        {
-                pthread_spinlock_guard guard = { &systemCluster->lock };        //HUGE TEMP HACK which only works if we have a single cluster and is stupid
-                append( &this->blocked, this_thread() );
-        }
+        append( &this->blocked, this_thread() );
         suspend();
 }