Changeset 8118303 for src/libcfa

Timestamp:

Jan 17, 2017, 5:13:47 PM (8 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:

c49bf54

Parents:

7350ff97

Message:

First prototype of cfa threads running (1 thread on 1 processor)

Location:

src/libcfa/concurrency

Files:

• coroutines (modified) (6 diffs)
• coroutines.c (modified) (1 diff)
• invoke.c (modified) (3 diffs)
• invoke.h (modified) (1 diff)
• kernel (modified) (1 diff)
• kernel.c (modified) (1 diff)
• threads (modified) (1 diff)
• threads.c (modified) (2 diffs)

src/libcfa/concurrency/coroutines

@@ -1 @@
-//                              -*- Mode: CFA -*-
+//                              - *- Mode: CFA - *-
 //
 // Cforall Version 1.0.0 Copyright (C) 2016 University of Waterloo
@@ -18 +18 @@
 #define COROUTINES_H
 
-#include "assert"       //
+#include "assert"
 #include "invoke.h"
 
@@ -26 +26 @@
 // Anything that is resumed is a coroutine.
 trait is_coroutine(dtype T) {
-      void co_main(T* this);
-      coroutine* get_coroutine(T* this);
+      void co_main(T * this);
+      coroutine * get_coroutine(T * this);
 };
 
 //-----------------------------------------------------------------------------
 // Ctors and dtors
-void ?{}(coStack_t* this);
-void ?{}(coroutine* this);
-void ^?{}(coStack_t* this);
-void ^?{}(coroutine* this);
+void ?{}(coStack_t * this);
+void ?{}(coroutine * this);
+void ^?{}(coStack_t * this);
+void ^?{}(coroutine * this);
 
 //-----------------------------------------------------------------------------
@@ -42 +42 @@
 
 forall(dtype T | is_coroutine(T))
-static inline void resume(T* cor);
+static inline void resume(T * cor);
 
 forall(dtype T | is_coroutine(T))
-void prime(T* cor);
+void prime(T * cor);
 
 //-----------------------------------------------------------------------------
@@ -53 +53 @@
 extern "C" {
       forall(dtype T | is_coroutine(T))
-      void CtxInvokeCoroutine(T* this);
+      void CtxInvokeCoroutine(T * this);
 
       forall(dtype T | is_coroutine(T))
-      void CtxStart(T* this, void (*invoke)(T*));
+      void CtxStart(T * this, void ( *invoke)(T *));
 }
 
 // Get current coroutine
-extern coroutine* current_coroutine; //PRIVATE, never use directly
-static inline coroutine* this_coroutine(void) {
+extern coroutine * current_coroutine; //PRIVATE, never use directly
+static inline coroutine * this_coroutine(void) {
         return current_coroutine;
 }
 
 // Private wrappers for context switch and stack creation
-extern void corCxtSw(coroutine* src, coroutine* dst);
-extern void create_stack( coStack_t* this, unsigned int storageSize );
+extern void corCxtSw(coroutine * src, coroutine * dst);
+extern void create_stack( coStack_t * this, unsigned int storageSize );
 
 // Suspend implementation inlined for performance
 static inline void suspend() {
-      coroutine* src = this_coroutine();                // optimization
+      coroutine * src = this_coroutine();               // optimization
 
         assertf( src->last != 0,
@@ -87 +87 @@
 // Resume implementation inlined for performance
 forall(dtype T | is_coroutine(T))
-static inline void resume(T* cor) {
-        coroutine* src = this_coroutine();              // optimization
-        coroutine* dst = get_coroutine(cor);
+static inline void resume(T * cor) {
+        coroutine * src = this_coroutine();             // optimization
+        coroutine * dst = get_coroutine(cor);
 
       if( unlikely(!dst->stack.base) ) {

src/libcfa/concurrency/coroutines.c

@@ -111 +111 @@
 // is not inline (We can't inline Cforall in C)
 void suspend_no_inline(void) {
+        LIB_DEBUG_PRINTF("Suspending back : to %p from %p\n", this_coroutine(), this_coroutine() ? this_coroutine()->last : (void*)-1);
+
         suspend();
 }

src/libcfa/concurrency/invoke.c

@@ -20 +20 @@
       void *this
 ) {
-      LIB_DEBUG_PRINTF("Invoke : Received %p (main %p, get_c %p)\n", this, main, get_coroutine);
+      LIB_DEBUG_PRINTF("Invoke Coroutine : Received %p (main %p, get_c %p)\n", this, main, get_coroutine);
 
       struct coroutine* cor = get_coroutine( this );
@@ -31 +31 @@
 
       main( this );
+
+      //Final suspend, should never return
+      __suspend_no_inline__F___1();
+      assertf(false, "Resumed dead coroutine");
+}
+
+void CtxInvokeThread(
+      void (*main)(void *), 
+      struct thread_h *(*get_thread)(void *), 
+      void *this
+) {
+      LIB_DEBUG_PRINTF("Invoke Thread : Received %p (main %p, get_t %p)\n", this, main, get_thread);
+
+      __suspend_no_inline__F___1();
+
+      struct coroutine* cor = &get_thread( this )->c;
+      cor->state = Active;
+
+      LIB_DEBUG_PRINTF("Invoke Thread : invoking main %p (args %p)\n", main, this);
+      main( this );
+
+      //Final suspend, should never return
+      __suspend_no_inline__F___1();
+      assertf(false, "Resumed dead thread");
 }
 
@@ -40 +64 @@
       void (*invoke)(void *)
 ) {
-      LIB_DEBUG_PRINTF("StartCoroutine : Passing in %p (main %p, get_c %p) to %p\n", this, main, get_coroutine, invoke);
+      LIB_DEBUG_PRINTF("StartCoroutine : Passing in %p (main %p) to invoke (%p) from start (%p)\n", this, main, invoke, CtxStart);
 
       struct coStack_t* stack = &get_coroutine( this )->stack;

src/libcfa/concurrency/invoke.h

@@ -35 +35 @@
       };
 
+      struct thread_h {
+            struct coroutine c;
+      };
+
 #endif //_INVOKE_H_
 #else //! defined(__CFA_INVOKE_PRIVATE__)

src/libcfa/concurrency/kernel

@@ +1 @@
+//                              -*- Mode: CFA -*-
+//
+// Cforall Version 1.0.0 Copyright (C) 2016 University of Waterloo
+//
+// The contents of this file are covered under the licence agreement in the
+// file "LICENCE" distributed with Cforall.
+//
+// threads --
+//
+// Author           : Thierry Delisle
+// Created On       : Tue Jan 17 12:27:26 2016
+// Last Modified By : Thierry Delisle
+// Last Modified On : --
+// Update Count     : 0
+//
+
+#ifndef KERNEL_H
+#define KERNEL_H
+
+extern struct thread_h * the_thread;
+
+void kernel_run( void );
+
+#endif //KERNEL_H
+
+// Local Variables: //
+// mode: c //
+// tab-width: 4 //
+// End: //

src/libcfa/concurrency/kernel.c

@@ +1 @@
+//                              -*- Mode: CFA -*-
+//
+// Cforall Version 1.0.0 Copyright (C) 2016 University of Waterloo
+//
+// The contents of this file are covered under the licence agreement in the
+// file "LICENCE" distributed with Cforall.
+//
+// kernel.c --
+//
+// Author           : Thierry Delisle
+// Created On       : Tue Jan 17 12:27:26 2016
+// Last Modified By : Thierry Delisle
+// Last Modified On : --
+// Update Count     : 0
+//
+
+//Header
+#include "kernel"
+
+//C Includes
+#include <stdbool.h>
+
+//CFA Includes
+#include "libhdr.h"
+#include "threads"
+
+//Private includes
+#define __CFA_INVOKE_PRIVATE__
+#include "invoke.h"
+
+thread_h * the_thread = 0;
+
+void kernel_run( void ) {
+        
+        bool done = true;
+        coroutine* processor_cor = this_coroutine();
+        LIB_DEBUG_PRINTF("Kernel : processor cor is %p\n", processor_cor);
+
+        do {
+                thread_h * dst = the_thread;
+
+                LIB_DEBUG_PRINTF("Kernel : picked thread %p\n", dst);
+
+                // set new coroutine that task is executing
+                current_coroutine = &dst->c;
+
+                // context switch to specified coroutine
+                LIB_DEBUG_PRINTF("Kernel : switching to ctx %p (from %p)\n", current_coroutine, processor_cor);
+                CtxSwitch( processor_cor->stack.context, current_coroutine->stack.context );
+                // when CtxSwitch returns we are back in the processor coroutine
+        } while( ! done );
+}
+
+// Local Variables: //
+// mode: c //
+// tab-width: 4 //
+// End: //

src/libcfa/concurrency/threads

@@ -18 +18 @@
 #define THREADS_H
 
+#include "assert"
+#include "invoke.h"
 
+#include "coroutines"
+
+//-----------------------------------------------------------------------------
+// Coroutine trait
+// Anything that implements this trait can be resumed.
+// Anything that is resumed is a coroutine.
+trait is_thread(dtype T /*| sized(T)*/) {
+      void co_main(T* this);
+      thread_h* get_thread(T* this);
+        /*void ?{}(T*);
+        void ^?{}(T*);*/
+};
+
+forall(otype T | is_thread(T) )
+static inline coroutine* get_coroutine(T* this) {
+        return &get_thread(this)->c;
+}
+
+//-----------------------------------------------------------------------------
+// Ctors and dtors
+void ?{}(thread_h* this);
+void ^?{}(thread_h* this);
+
+//-----------------------------------------------------------------------------
+// thread runner
+// Structure that actually start and stop threads
+forall(otype T | is_thread(T) )
+struct thread {
+        T handle;
+};
+
+forall(otype T | is_thread(T) )
+void ?{}( thread(T)* this );
+
+forall(otype T, ttype P | is_thread(T) | { void ?{}(T*, P); } )
+void ?{}( thread(T)* this, P params );
+
+forall(otype T | is_thread(T) )
+void ^?{}( thread(T)* this );
+
+//-----------------------------------------------------------------------------
+// PRIVATE exposed because of inline
 
 #endif //THREADS_H

src/libcfa/concurrency/threads.c

@@ -6 +6 @@
 // file "LICENCE" distributed with Cforall.
 //
-// threads --
+// threads.c --
 //
 // Author           : Thierry Delisle
@@ -15 +15 @@
 //
 
+#include "threads"
 
+#include "kernel"
+#include "libhdr.h"
+
+#define __CFA_INVOKE_PRIVATE__
+#include "invoke.h"
+
+#include <stdlib>
+
+//-----------------------------------------------------------------------------
+// Forward declarations
+forall(otype T | is_thread(T) )
+void start( thread(T)* this );
+
+forall(otype T | is_thread(T) )
+void stop( thread(T)* this );
+
+//-----------------------------------------------------------------------------
+// Thread ctors and dtors
+
+void ?{}(thread_h* this) {
+        (&this->c){};
+}
+
+void ^?{}(thread_h* this) {
+        ^(&this->c){};
+}
+
+forall(otype T | is_thread(T) )
+void ?{}( thread(T)* this ) {
+        printf("thread() ctor\n");
+        (&this->handle){};
+        start(this);
+}
+
+forall(otype T, ttype P | is_thread(T) | { void ?{}(T*, P); } )
+void ?{}( thread(T)* this, P params ) {
+        (&this->handle){ params };
+        start(this);
+}
+
+forall(otype T | is_thread(T) )
+void ^?{}( thread(T)* this ) {
+        stop(this);
+        ^(&this->handle){};
+}
+
+//-----------------------------------------------------------------------------
+// Starting and stopping threads
+extern "C" {
+      forall(dtype T | is_thread(T))
+      void CtxInvokeThread(T * this);
+}
+
+forall(otype T | is_thread(T))
+void start( thread(T)* this ) {
+        T* handle  = &this->handle;
+        coroutine* thrd_c = get_coroutine(handle);
+        thread_h*  thrd_h = get_thread   (handle);
+        thrd_c->last = this_coroutine();
+        current_coroutine = thrd_c;
+
+        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);
+        CtxStart(handle, CtxInvokeThread);
+        CtxSwitch( thrd_c->last->stack.context, thrd_c->stack.context );
+
+        the_thread = thrd_h;
+}
+
+forall(otype T | is_thread(T) )
+void stop( thread(T)* this ) {
+
+}
 
 // Local Variables: //