Changeset 75f3522

Timestamp:

Feb 13, 2017, 2:39:26 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:

db6f06a

Parents:

fb7dca0

Message:

Moved several declarations to a new private header and made some clean-up

Location:

src/libcfa/concurrency

Files:

• kernel (modified) (2 diffs)
• kernel.c (modified) (11 diffs)
• kernel_private.h (added)
• threads.c (modified) (4 diffs)

src/libcfa/concurrency/kernel

@@ -9 +9 @@
 //
 // Author           : Thierry Delisle
-// Created On       : Tue Jan 17 12:27:26 2016
+// Created On       : Tue Jan 17 12:27:26 2017
 // Last Modified By : Thierry Delisle
 // Last Modified On : --
@@ -58 +58 @@
 void ^?{}(processor * this);
 
-
 //-----------------------------------------------------------------------------
 // Locks

src/libcfa/concurrency/kernel.c

@@ -9 +9 @@
 //
 // Author           : Thierry Delisle
-// Created On       : Tue Jan 17 12:27:26 2016
+// Created On       : Tue Jan 17 12:27:26 2017
 // Last Modified By : Thierry Delisle
 // Last Modified On : --
@@ -20 +20 @@
 
 //Header
-#include "kernel"
+#include "kernel_private.h"
 
 //C Includes
@@ -31 +31 @@
 //CFA Includes
 #include "libhdr.h"
-#include "threads"
 
 //Private includes
@@ -51 +50 @@
 //-----------------------------------------------------------------------------
 // Kernel storage
-struct processorCtx_t {
-        processor * proc;
-        coroutine c;
-};
-
-DECL_COROUTINE(processorCtx_t);
-
 #define KERNEL_STORAGE(T,X) static char X##_storage[sizeof(T)]
 
@@ -194 +186 @@
 }
 
-//-----------------------------------------------------------------------------
-// Processor running routines
-void main(processorCtx_t *);
-thread * nextThread(cluster * this);
-void scheduleInternal(processor * this, thread * dst);
-void spin(processor * this, unsigned int * spin_count);
-void thread_schedule( thread * thrd );
-
+//=============================================================================================
+// Kernel Scheduling logic
+//=============================================================================================
 //Main of the processor contexts
 void main(processorCtx_t * runner) {
@@ -212 +199 @@
 
         thread * readyThread = NULL;
-        for( unsigned int spin_count = 0; ! this->terminated; spin_count++ ) {
-                
+        for( unsigned int spin_count = 0; ! this->terminated; spin_count++ ) 
+        {
                 readyThread = nextThread( this->cltr );
 
-                if(readyThread) {
-                        scheduleInternal(this, readyThread);
+                if(readyThread) 
+                {
+                        runThread(this, readyThread);
+
+                        //Some actions need to be taken from the kernel
+                        finishRunning(this, readyThread);
+
                         spin_count = 0;
-                } else {
+                } 
+                else 
+                {
                         spin(this, &spin_count);
                 }               
@@ -229 +223 @@
 }
 
-//Declarations for scheduleInternal
-extern void ThreadCtxSwitch(coroutine * src, coroutine * dst);
-
-// scheduleInternal runs a thread by context switching 
+// runThread runs a thread by context switching 
 // from the processor coroutine to the target thread 
-void scheduleInternal(processor * this, thread * dst) {
+void runThread(processor * this, thread * dst) {
+        coroutine * proc_cor = get_coroutine(this->runner);
+        coroutine * thrd_cor = get_coroutine(dst);
+        
+        //Reset the terminating actions here
         this->thread_action = NoAction;
 
-        // 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->runner);
-        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
+        //Update global state
+        this->current_thread = dst;
+
+        // Context Switch to the thread
+        ThreadCtxSwitch(proc_cor, thrd_cor);
+        // when ThreadCtxSwitch returns we are back in the processor coroutine
+}
+
+// Once a thread has finished running, some of 
+// its final actions must be executed from the kernel
+void finishRunning(processor * this, thread * thrd) {
         if(this->thread_action == Reschedule) {
-                thread_schedule( dst );
+                ScheduleThread( thrd );
         }
 }
@@ -325 +307 @@
 //-----------------------------------------------------------------------------
 // Scheduler routines
-void thread_schedule( thread * thrd ) {
+void ScheduleThread( thread * thrd ) {
         assertf( thrd->next == NULL, "Expected null got %p", thrd->next );
         
@@ -331 +313 @@
         append( &systemProcessor->cltr->ready_queue, thrd );
         spin_unlock( &lock );
+}
+
+void ScheduleInternal() {
+        get_this_processor()->thread_action = Reschedule;
+        suspend();
 }
 
@@ -363 +350 @@
         // Add the main thread to the ready queue 
         // once resume is called on systemProcessor->ctx the mainThread needs to be scheduled like any normal thread
-        thread_schedule(mainThread);
+        ScheduleThread(mainThread);
 
         //initialize the global state variables
@@ -426 +413 @@
         thread * it;
         while( it = pop_head( &this->blocked) ) {
-                thread_schedule( it );
+                ScheduleThread( it );
         }
 }

src/libcfa/concurrency/threads.c

@@ -17 +17 @@
 #include "threads"
 
-#include "kernel"
+#include "kernel_private.h"
 #include "libhdr.h"
 
@@ -72 +72 @@
 //-----------------------------------------------------------------------------
 // Starting and stopping threads
-extern "C" {
-      forall(dtype T | is_thread(T))
-      void CtxInvokeThread(T * this);
-}
-
-extern void thread_schedule( thread * );
-
 forall( dtype T | is_thread(T) )
 void start( T* this ) {
@@ -92 +85 @@
         CtxSwitch( thrd_c->last->stack.context, thrd_c->stack.context );
 
-        fenv_t envp;
-        fegetenv( &envp );
-        LIB_DEBUG_PRINTF("Thread : mxcsr %x\n", envp.__mxcsr);
-        LIB_DEBUG_PRINTF("Thread started : %p (t %p, c %p)\n", this, thrd_c, thrd_h);
-
-        thread_schedule(thrd_h);
+        ScheduleThread(thrd_h);
 }
 
@@ -109 +97 @@
 
 void yield( void ) {
-        get_this_processor()->thread_action = Reschedule;
-        suspend();
+        ScheduleInternal();
 }
 
 void ThreadCtxSwitch(coroutine* src, coroutine* dst) {
+        // set state of current coroutine to inactive
+        src->state = Inactive;
+        dst->state = Active;
+
+        //update the last resumer
         dst->last = src;
 
-        // set state of current coroutine to inactive
-        src->state = Inactive;
-
-        // set new coroutine that task is executing
+        // set new coroutine that the processor is executing
+        // and context switch to it
         get_this_processor()->current_coroutine = dst;  
-
-        // context switch to specified coroutine
         CtxSwitch( src->stack.context, dst->stack.context );
-        // when CtxSwitch returns we are back in the src coroutine
+        get_this_processor()->current_coroutine = src;  
 
         // set state of new coroutine to active
+        dst->state = Inactive;
         src->state = Active;
 }