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

File:

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

src/libcfa/concurrency/kernel.c

@@ -32 +32 @@
 #include "invoke.h"
 
-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
+//-----------------------------------------------------------------------------
+// Kernel storage
 struct processorCtx_t {
         processor * proc;
@@ -75 +41 @@
 DECL_COROUTINE(processorCtx_t)
 
+#define KERNEL_STORAGE(T,X) static char X##_storage[sizeof(T)]
+
+KERNEL_STORAGE(processorCtx_t, systemProcessorCtx);
+KERNEL_STORAGE(cluster, systemCluster);
+KERNEL_STORAGE(processor, systemProcessor);
+KERNEL_STORAGE(thread_h, mainThread);
+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 {
+        machine_context_t ctx;  
+        unsigned int size;              // size of stack
+        void *base;                             // base of stack
+        void *storage;                  // pointer to stack
+        void *limit;                    // stack grows towards stack limit
+        void *context;                  // address of cfa_context_t
+        void *top;                              // address of top of storage
+};
+
+void ?{}( current_stack_info_t * this ) {
+        CtxGet( &this->ctx );
+        this->base = this->ctx.FP;
+        this->storage = this->ctx.SP;
+
+        rlimit r;
+        int ret = getrlimit( RLIMIT_STACK, &r);
+        this->size = r.rlim_cur;
+
+        this->limit = (void *)(((intptr_t)this->base) - this->size);
+        this->context = &mainThread_context_storage;
+        this->top = this->base;
+}
+
+void ?{}( coStack_t * this, current_stack_info_t * info) {
+        this->size = info->size;
+        this->storage = info->storage;
+        this->limit = info->limit;
+        this->base = info->base;
+        this->context = info->context;
+        this->top = info->top;
+        this->userStack = true;
+}
+
+void ?{}( coroutine * this, current_stack_info_t * info) {
+        (&this->stack){ info }; 
+        this->name = "Main Thread";
+        this->errno_ = 0;
+        this->state = Inactive;
+        this->notHalted = true;
+}
+
+void ?{}( thread_h * this, current_stack_info_t * info) {
+        (&this->c){ info };
+}
+
+//-----------------------------------------------------------------------------
+// Processor coroutine
 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 );
+        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 );
 }
 
@@ -109 +204 @@
         }
 
+        LIB_DEBUG_PRINTF("Kernel : core %p unlocking thread\n", this);
+        unlock( &this->lock );
         LIB_DEBUG_PRINTF("Kernel : core %p terminated\n", this);
 }
@@ -133 +230 @@
 }
 
+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 );
-}
-
-//-----------------------------------------------------------------------------
-// Kernel storage
-#define KERNEL_STORAGE(T,X) static char X##_storage[sizeof(T)]
-
-KERNEL_STORAGE(processorCtx_t, systemProcessorCtx);
-KERNEL_STORAGE(cluster, systemCluster);
-KERNEL_STORAGE(processor, systemProcessor);
-KERNEL_STORAGE(thread_h, mainThread);
-KERNEL_STORAGE(machine_context_t, mainThread_context);
-
-//-----------------------------------------------------------------------------
-// Main thread construction
-struct mainThread_info_t {
-        machine_context_t ctx;  
-        unsigned int size;              // size of stack
-        void *base;                             // base of stack
-        void *storage;                  // pointer to stack
-        void *limit;                    // stack grows towards stack limit
-        void *context;                  // address of cfa_context_t
-        void *top;                              // address of top of storage
-};
-
-void ?{}( mainThread_info_t * this ) {
-        CtxGet( &this->ctx );
-        this->base = this->ctx.FP;
-        this->storage = this->ctx.SP;
-
-        rlimit r;
-        int ret = getrlimit( RLIMIT_STACK, &r);
-        this->size = r.rlim_cur;
-
-        this->limit = (void *)(((intptr_t)this->base) - this->size);
-        this->context = &mainThread_context_storage;
-        this->top = this->base;
-}
-
-void ?{}( coStack_t * this, mainThread_info_t * info) {
-        this->size = info->size;
-        this->storage = info->storage;
-        this->limit = info->limit;
-        this->base = info->base;
-        this->context = info->context;
-        this->top = info->top;
-        this->userStack = true;
-}
-
-void ?{}( coroutine * this, mainThread_info_t * info) {
-        (&this->stack){ info }; 
-        this->name = "Main Thread";
-        this->errno_ = 0;
-        this->state = Inactive;
-        this->notHalted = true;
-}
-
-void ?{}( thread_h * this, mainThread_info_t * info) {
-        (&this->c){ info };
 }
 
@@ -210 +304 @@
         LIB_DEBUG_PRINTF("Kernel : Starting\n");        
 
-        mainThread_info_t ctx;
+        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 );
 
         // Start by initializing the main thread
         mainThread = (thread_h *)&mainThread_storage;
-        mainThread{ &ctx };
+        mainThread{ &info };
 
         // Initialize the system cluster
@@ -220 +321 @@
         systemCluster{};
 
-        // Initialize the system processor
+        // Initialize the system processor and the system processor ctx
+        // (the coroutine that contains the processing control flow)
         systemProcessor = (processor *)&systemProcessor_storage;
-        systemProcessor{ systemCluster };
-
-        // Initialize the system processor ctx
-        // (the coroutine that contains the processing control flow)
-        systemProcessor->ctx = (processorCtx_t *)&systemProcessorCtx_storage;
-        systemProcessor->ctx{ systemProcessor };
+        systemProcessor{ systemCluster, (processorCtx_t *)&systemProcessorCtx_storage };
 
         // Add the main thread to the ready queue 
@@ -286 +383 @@
 
 void lock( simple_lock * this ) {
-        append( &this->blocked, this_thread() );
+        {
+                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() );
+        }
         suspend();
 }