Changes in / [caa649b:1feb535f]

Location:

src/libcfa/concurrency

Files:

• kernel (modified) (1 diff)
• kernel.c (modified) (13 diffs)
• kernel_private.h (modified) (1 diff)

src/libcfa/concurrency/kernel

@@ -79 +79 @@
 
 // Processor
-coroutine processorCtx_t {
-        struct processor * proc;
-};
-
 // Wrapper around kernel threads
 struct processor {
         // Main state
         // Coroutine ctx who does keeps the state of the processor
-        struct processorCtx_t runner;
+        struct processorCtx_t * runner;
 
         // Cluster from which to get threads

src/libcfa/concurrency/kernel.c

@@ -124 +124 @@
 //-----------------------------------------------------------------------------
 // Processor coroutine
-void ?{}(processorCtx_t & this) {}
 
 // Construct the processor context of the main processor
@@ -131 +130 @@
         this.__cor.starter = NULL;
         this.proc = proc;
+        proc->runner = &this;
 }
 
@@ -137 +137 @@
         (this.__cor){ info };
         this.proc = proc;
+        proc->runner = &this;
 }
 
@@ -149 +150 @@
         preemption_alarm = NULL;
         pending_preemption = false;
-        runner.proc = &this;
 
         start( &this );
@@ -161 +161 @@
         pending_preemption = false;
         kernel_thread = pthread_self();
-        runner.proc = &this;
-
+
+        this.runner = &runner;
         __cfaabi_dbg_print_safe("Kernel : constructing main processor context %p\n", &runner);
         runner{ &this };
@@ -196 +196 @@
 void main(processorCtx_t & runner) {
         processor * this = runner.proc;
-        verify(this);
 
         __cfaabi_dbg_print_safe("Kernel : core %p starting\n", this);
@@ -242 +241 @@
 void runThread(processor * this, thread_desc * dst) {
         assert(dst->curr_cor);
-        coroutine_desc * proc_cor = get_coroutine(this->runner);
+        coroutine_desc * proc_cor = get_coroutine(*this->runner);
         coroutine_desc * thrd_cor = dst->curr_cor;
 
@@ -257 +256 @@
 
 void returnToKernel() {
-        coroutine_desc * proc_cor = get_coroutine(this_processor->runner);
+        coroutine_desc * proc_cor = get_coroutine(*this_processor->runner);
         coroutine_desc * thrd_cor = this_thread->curr_cor = this_coroutine;
         ThreadCtxSwitch(thrd_cor, proc_cor);
@@ -318 +317 @@
         machine_context_t ctx;
         info.context = &ctx;
-        (proc->runner){ proc, &info };
-
-        __cfaabi_dbg_print_safe("Coroutine : created stack %p\n", get_coroutine(proc->runner)->stack.base);
+        processorCtx_t proc_cor_storage = { proc, &info };
+
+        __cfaabi_dbg_print_safe("Coroutine : created stack %p\n", proc_cor_storage.__cor.stack.base);
 
         //Set global state
-        this_coroutine = get_coroutine(proc->runner);
+        this_coroutine = &proc->runner->__cor;
         this_thread = NULL;
 
         //We now have a proper context from which to schedule threads
-        __cfaabi_dbg_print_safe("Kernel : core %p created (%p, %p)\n", proc, &proc->runner, &ctx);
+        __cfaabi_dbg_print_safe("Kernel : core %p created (%p, %p)\n", proc, proc->runner, &ctx);
 
         // SKULLDUGGERY: Since the coroutine doesn't have its own stack, we can't
@@ -333 +332 @@
         // back to here. Instead directly call the main since we already are on the
         // appropriate stack.
-        get_coroutine(proc->runner)->state = Active;
-        main( proc->runner );
-        get_coroutine(proc->runner)->state = Halted;
+        proc_cor_storage.__cor.state = Active;
+        main( proc_cor_storage );
+        proc_cor_storage.__cor.state = Halted;
 
         // Main routine of the core returned, the core is now fully terminated
-        __cfaabi_dbg_print_safe("Kernel : core %p main ended (%p)\n", proc, &proc->runner);
+        __cfaabi_dbg_print_safe("Kernel : core %p main ended (%p)\n", proc, proc->runner);
 
         return NULL;
@@ -353 +352 @@
 void kernel_first_resume(processor * this) {
         coroutine_desc * src = this_coroutine;
-        coroutine_desc * dst = get_coroutine(this->runner);
+        coroutine_desc * dst = get_coroutine(*this->runner);
 
         verify( !preemption_state.enabled );
 
         create_stack(&dst->stack, dst->stack.size);
-        CtxStart(&this->runner, CtxInvokeCoroutine);
+        CtxStart(this->runner, CtxInvokeCoroutine);
 
         verify( !preemption_state.enabled );
@@ -412 +411 @@
         verify( !preemption_state.enabled );
         lock( ready_queue_lock __cfaabi_dbg_ctx2 );
+        //TEMP hack to find a bug
+        if(this_processor != mainProcessor) {
+                if(ready_queue.head == mainThread) {
+                        unlock( ready_queue_lock );
+                        return NULL;
+                }
+        }
+
         thread_desc * head = pop_head( ready_queue );
         unlock( ready_queue_lock );
@@ -577 +584 @@
         // Destroy the main processor and its context in reverse order of construction
         // These were manually constructed so we need manually destroy them
-        ^(mainProcessor->runner){};
+        ^(*mainProcessor->runner){};
         ^(mainProcessor){};
 

src/libcfa/concurrency/kernel_private.h

@@ -52 +52 @@
 //-----------------------------------------------------------------------------
 // Processor
+coroutine processorCtx_t {
+        processor * proc;
+};
+
 void main(processorCtx_t *);
 void start(processor * this);