Changes in src/libcfa/concurrency/kernel.c [77e6fcb:e15df4c]

File:

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

src/libcfa/concurrency/kernel.c

@@ -15 +15 @@
 //
 
-//Start and stop routine for the kernel, declared first to make sure they run first
-void kernel_startup(void)  __attribute__((constructor(101)));
-void kernel_shutdown(void) __attribute__((destructor(101)));
-
 //Header
 #include "kernel"
@@ -43 +39 @@
 };
 
-DECL_COROUTINE(processorCtx_t);
+DECL_COROUTINE(processorCtx_t)
 
 #define KERNEL_STORAGE(T,X) static char X##_storage[sizeof(T)]
@@ -56 +52 @@
 processor * systemProcessor;
 thread * mainThread;
+
+void kernel_startup(void)  __attribute__((constructor(101)));
+void kernel_shutdown(void) __attribute__((destructor(101)));
 
 //-----------------------------------------------------------------------------
@@ -185 +184 @@
 void main(processorCtx_t * ctx);
 thread * nextThread(cluster * this);
-void scheduleInternal(processor * this, thread * dst);
+void runThread(processor * this, thread * dst);
 void spin(processor * this, unsigned int * spin_count);
 
@@ -198 +197 @@
 
                 if(readyThread) {
-                        scheduleInternal(this, readyThread);
+                        runThread(this, readyThread);
                         spin_count = 0;
                 } else {
@@ -210 +209 @@
 }
 
-//Declarations for scheduleInternal
-extern void ThreadCtxSwitch(coroutine * src, coroutine * dst);
-
-// scheduleInternal runs a thread by context switching 
-// from the processor coroutine to the target thread 
-void scheduleInternal(processor * this, thread * dst) {
-        // coroutine * proc_ctx = get_coroutine(this->ctx);
-        // coroutine * thrd_ctx = get_coroutine(dst);
-
-        // //Update global state
-        // this->current_thread = dst;
-
-        // // Context Switch to the thread
-        // ThreadCtxSwitch(proc_ctx, thrd_ctx);
-        // // when ThreadCtxSwitch returns we are back in the processor coroutine
-
+void runThread(processor * this, thread * 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, this->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, this->current_coroutine);
- 
-      // when CtxSwitch returns we are back in the processor coroutine
-}
-
-// Handles spinning logic
-// TODO : find some strategy to put cores to sleep after some time
+        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)++;
 }
 
-// Context invoker for processors
-// This is the entry point for processors (kernel threads)
-// It effectively constructs a coroutine by stealing the pthread stack
 void * CtxInvokeProcessor(void * arg) {
         processor * proc = (processor *) arg;
@@ -262 +241 @@
         processorCtx_t proc_cor_storage = { proc, &info };
 
-        //Set global state
         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
-        LIB_DEBUG_PRINTF("Kernel : core %p created (%p)\n", proc, proc->ctx);
 
         // SKULLDUGGERY: Since the coroutine doesn't have its own stack, we can't 
@@ -278 +264 @@
       proc_cor_storage.c.notHalted = false;
 
-        // Main routine of the core returned, the core is now fully terminated
         LIB_DEBUG_PRINTF("Kernel : core %p main ended (%p)\n", proc, proc->ctx);