Changeset 0c92c9f for src/libcfa/concurrency/kernel.c

Timestamp:

Jan 27, 2017, 4:28:05 PM (7 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, deferred_resn, demangler, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, with_gc

Children:

8804701

Parents:

0157ca7

Message:

Cleaned-up threading code and added temporary test for threads (single core)

File:

• src/libcfa/concurrency/kernel.c (modified) (7 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"
@@ -52 +56 @@
 processor * systemProcessor;
 thread * mainThread;
-
-void kernel_startup(void)  __attribute__((constructor(101)));
-void kernel_shutdown(void) __attribute__((destructor(101)));
 
 //-----------------------------------------------------------------------------
@@ -184 +185 @@
 void main(processorCtx_t * ctx);
 thread * nextThread(cluster * this);
-void runThread(processor * this, thread * dst);
+void scheduleInternal(processor * this, thread * dst);
 void spin(processor * this, unsigned int * spin_count);
 
@@ -197 +198 @@
 
                 if(readyThread) {
-                        runThread(this, readyThread);
+                        scheduleInternal(this, readyThread);
                         spin_count = 0;
                 } else {
@@ -209 +210 @@
 }
 
-void runThread(processor * this, thread * dst) {
+//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
+
         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
-}
-
+      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
 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;
@@ -241 +262 @@
         processorCtx_t proc_cor_storage = { proc, &info };
 
+        //Set global state
         proc->current_coroutine = &proc->ctx->c;
         proc->current_thread = NULL;
 
+        //We now have a proper context from which to schedule threads
         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 
@@ -264 +278 @@
       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);