Changes in / [8804701:0a86a30]

Location:

src

Files:

• examples/thread.c (added)
• libcfa/concurrency/coroutines (modified) (3 diffs)
• libcfa/concurrency/coroutines.c (modified) (2 diffs)
• libcfa/concurrency/invoke.c (modified) (5 diffs)
• libcfa/concurrency/kernel.c (modified) (7 diffs)
• libcfa/concurrency/threads (modified) (1 diff)
• libcfa/concurrency/threads.c (modified) (5 diffs)
• tests/.expect/thread.txt (deleted)
• tests/thread.c (deleted)

src/libcfa/concurrency/coroutines

@@ -65 +65 @@
 
 // Private wrappers for context switch and stack creation
-extern void CoroutineCtxSwitch(coroutine * src, coroutine * dst);
+extern void corCxtSw(coroutine * src, coroutine * dst);
 extern void create_stack( coStack_t * this, unsigned int storageSize );
 
@@ -81 +81 @@
                 src->name, src, src->last->name, src->last );
 
-        CoroutineCtxSwitch( src, src->last );
+        corCxtSw( src, src->last );
 }
 
@@ -107 +107 @@
 
       // always done for performance testing
-        CoroutineCtxSwitch( src, dst );
+        corCxtSw( src, dst );
 }
 

src/libcfa/concurrency/coroutines.c

@@ -98 +98 @@
 }
 
-// Wrapper for co
-void CoroutineCtxSwitch(coroutine* src, coroutine* dst) {
+// We need to call suspend from invoke.c, so we expose this wrapper that
+// is not inline (We can't inline Cforall in C)
+void suspend_no_inline(void) {
+        suspend();
+}
+
+void corCxtSw(coroutine* src, coroutine* dst) {
         // THREAD_GETMEM( This )->disableInterrupts();
 
@@ -162 +167 @@
 }
 
-// We need to call suspend from invoke.c, so we expose this wrapper that
-// is not inline (We can't inline Cforall in C)
-extern "C" {
-        void __suspend_internal(void) {
-                suspend();
-        }
-}
-
 // Local Variables: //
 // mode: c //

src/libcfa/concurrency/invoke.c

@@ -28 +28 @@
 // Called from the kernel when starting a coroutine or task so must switch back to user mode.
 
-extern void __suspend_internal(void);
-extern void __thread_signal_termination(struct thread*);
+extern void __suspend_no_inline__F___1(void);
+extern void __signal_termination__F_P7sthread__1(struct thread*);
 
 void CtxInvokeCoroutine(
@@ -41 +41 @@
 
       if(cor->state == Primed) {
-            __suspend_internal();
+            __suspend_no_inline__F___1();
       }
 
@@ -52 +52 @@
 
       //Final suspend, should never return
-      __suspend_internal();
-      abortf("Resumed dead coroutine");
+      __suspend_no_inline__F___1();
+      assertf(false, "Resumed dead coroutine");
 }
 
@@ -61 +61 @@
       void *this
 ) {
-      __suspend_internal();
+      // LIB_DEBUG_PRINTF("Invoke Thread : Received %p (main %p, get_t %p)\n", this, main, get_thread);
+
+      __suspend_no_inline__F___1();
 
       struct thread* thrd = get_thread( this );
@@ -70 +72 @@
       main( this );
 
-      __thread_signal_termination(thrd);
+      __signal_termination__F_P7sthread__1(thrd);
 
       //Final suspend, should never return
-      __suspend_internal();
-      abortf("Resumed dead thread");
+      __suspend_no_inline__F___1();
+      assertf(false, "Resumed dead thread");
 }
 

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"
@@ -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);        
 

src/libcfa/concurrency/threads

@@ -27 +27 @@
 // Anything that implements this trait can be resumed.
 // Anything that is resumed is a coroutine.
-trait is_thread(dtype T) {
+trait is_thread(dtype T | sized(T)) {
       void main(T* this);
       thread* get_thread(T* this);
 };
 
-#define DECL_THREAD(X) thread* get_thread(X* this) { return &this->t; } void main(X* this);
+#define DECL_THREAD(X) static inline thread* get_thread(X* this) { return &this->t; } void main(X* this);
 
-forall( dtype T | is_thread(T) )
+forall( dtype T | sized(T) | is_thread(T) )
 static inline coroutine* get_coroutine(T* this) {
         return &get_thread(this)->c;

src/libcfa/concurrency/threads.c

@@ -31 +31 @@
 //-----------------------------------------------------------------------------
 // Forward declarations
-forall( dtype T | is_thread(T) )
+forall( dtype T | sized(T) | is_thread(T) )
 void start( T* this );
 
-forall( dtype T | is_thread(T) )
+forall( dtype T | sized(T) | is_thread(T) )
 void stop( T* this );
 
@@ -78 +78 @@
 extern void thread_schedule( thread * );
 
-forall( dtype T | is_thread(T) )
+forall( dtype T | sized(T) | is_thread(T) )
 void start( T* this ) {
         coroutine* thrd_c = get_coroutine(this);
@@ -85 +85 @@
         get_this_processor()->current_coroutine = thrd_c;
 
-        LIB_DEBUG_PRINTF("Thread start : %p (t %p, c %p)\n", this, thrd_c, thrd_h);
+        // LIB_DEBUG_PRINTF("Thread start : %p (t %p, c %p)\n", handle, thrd_c, thrd_h);
 
         create_stack(&thrd_c->stack, thrd_c->stack.size);
@@ -91 +91 @@
         CtxSwitch( thrd_c->last->stack.context, thrd_c->stack.context );
 
-        LIB_DEBUG_PRINTF("Thread started : %p (t %p, c %p)\n", this, thrd_c, thrd_h);
-
         thread_schedule(thrd_h);
 }
 
-forall( dtype T | is_thread(T) )
+forall( dtype T | sized(T) | is_thread(T) )
 void stop( T* this ) {
         thread*  thrd = get_thread(this);
@@ -104 +102 @@
 }
 
+void signal_termination( thread * this ) {
+        this->c.state = Halt;
+      this->c.notHalted = false;
+        unlock( &this->lock );
+}
+
 void yield( void ) {
         thread_schedule( this_thread() );
         suspend();
-}
-
-void ThreadCtxSwitch(coroutine* src, coroutine* dst) {
-        dst->last = src;
-
-        // set state of current coroutine to inactive
-        src->state = Inactive;
-
-        // set new coroutine that task is executing
-        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
-
-        // set state of new coroutine to active
-        src->state = Active;
-}
-
-// C Helper to signal the termination of a thread
-// Used in invoke.c
-extern "C" {
-        void __thread_signal_termination( thread * this ) {
-                this->c.state = Halt;
-                this->c.notHalted = false;
-                unlock( &this->lock );
-        }
 }