Changeset 80d9e49

Timestamp:

Dec 7, 2016, 2:47:53 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:

550a3385

Parents:

a68caae

Message:

Coroutines no longer require virtual pointers or any code beyond the get_coroutine routine

Location:

src

Files:

• libcfa/concurrency/invoke.c (modified) (4 diffs)
• libcfa/concurrency/invoke.h (modified) (3 diffs)
• libcfa/concurrency/threads (modified) (1 diff)
• libcfa/concurrency/threads.c (modified) (6 diffs)
• tests/coroutine.c (modified) (2 diffs)

src/libcfa/concurrency/invoke.c

@@ -13 +13 @@
 // Called from the kernel when starting a coroutine or task so must switch back to user mode.
 
-void invokeCoroutine(covptr_t* vthis)
-{
-      LIB_DEBUG_PRINTF("Invoke : Received %p (v %p)\n", vthis, *vthis);
+extern void __suspend__F___1(void);
 
-      struct coroutine* cor = get_coroutine( vthis );
+void invokeCoroutine(
+      void (*main)(void *), 
+      struct coroutine *(*get_coroutine)(void *), 
+      void *this
+) {
+      LIB_DEBUG_PRINTF("Invoke : Received %p (main %p, get_c %p)\n", this, main, get_coroutine);
+
+      struct coroutine* cor = get_coroutine( this );
+
+      if(cor->state == Primed) {
+            __suspend__F___1();
+      }
 
       cor->state = Active;
 
-      (*vthis)->main( get_object(vthis) );
+      main( this );
 }
 
 
-void startCoroutine(covptr_t* vthis, void (*invoke)(covptr_t*)) {
-      LIB_DEBUG_PRINTF("StartCoroutine : Passing in %p (v %p) to %p\n", vthis, *vthis, invoke);
+void startCoroutine(
+      void (*main)(void *), 
+      struct coroutine *(*get_coroutine)(void *), 
+      void *this, 
+      void (*invoke)(void *)
+) {
+      LIB_DEBUG_PRINTF("StartCoroutine : Passing in %p (main %p, get_c %p) to %p\n", this, main, get_coroutine, invoke);
 
-      struct coroutine* this = get_coroutine( vthis );
-      struct coStack_t* stack = &this->stack;
+      struct coStack_t* stack = &get_coroutine( this )->stack;
 
 #if defined( __i386__ )
@@ -37 +50 @@
             void *rturn;                                      // where to go on return from uSwitch
             void *dummyReturn;                          // fake return compiler would have pushed on call to uInvoke
-            void *argument;                             // for 16-byte ABI, 16-byte alignment starts here
-            void *padding[3];                           // padding to force 16-byte alignment, as "base" is 16-byte aligned
+            void *argument[3];                          // for 16-byte ABI, 16-byte alignment starts here
+            void *padding;                              // padding to force 16-byte alignment, as "base" is 16-byte aligned
         };
 
@@ -45 +58 @@
 
         ((struct FakeStack *)(((struct machine_context_t *)stack->context)->SP))->dummyReturn = NULL;
-        ((struct FakeStack *)(((struct machine_context_t *)stack->context)->SP))->argument = vthis;     // argument to invoke
+        ((struct FakeStack *)(((struct machine_context_t *)stack->context)->SP))->argument[0] = this;     // argument to invoke
         ((struct FakeStack *)(((struct machine_context_t *)stack->context)->SP))->rturn = invoke;
 
@@ -61 +74 @@
       ((struct FakeStack *)(((struct machine_context_t *)stack->context)->SP))->dummyReturn = NULL;
       ((struct FakeStack *)(((struct machine_context_t *)stack->context)->SP))->rturn = coInvokeStub;
-      ((struct FakeStack *)(((struct machine_context_t *)stack->context)->SP))->fixedRegisters[0] = vthis;
+      ((struct FakeStack *)(((struct machine_context_t *)stack->context)->SP))->fixedRegisters[0] = this;
       ((struct FakeStack *)(((struct machine_context_t *)stack->context)->SP))->fixedRegisters[1] = invoke;
 #else

src/libcfa/concurrency/invoke.h

@@ -10 +10 @@
 #define _INVOKE_H_
 
-      #define OFFSET_OF(type, field) ((intptr_t)( &((type*)0)->field))
-      #define VPTR_OFFSET(type, vptr, field) (OFFSET_OF(type, field) - OFFSET_OF(type, vptr))
-
-      struct coVtable_t { 
-            void (*main)(void*);
-            intptr_t offset_coroutine;
-            intptr_t offset_object;
-      };
-
-      typedef struct coVtable_t* covptr_t;
-
-      static inline struct coroutine* get_coroutine(covptr_t* vthis) {
-            return (struct coroutine*) ( ((intptr_t)vthis) + ((intptr_t)(*vthis)->offset_coroutine) ); 
-      }
-
-      static inline void* get_object(covptr_t* vthis) {
-            return (void*) ( ((intptr_t)vthis) + ((intptr_t)(*vthis)->offset_object) ); 
-      }
-
-      struct coStack_t {
+     struct coStack_t {
             unsigned int size;          // size of stack
             void *storage;                      // pointer to stack
@@ -39 +20 @@
       };
 
-      enum coroutine_state { Start, Inactive, Active, Halt };
+      enum coroutine_state { Start, Inactive, Active, Halt, Primed };
 
       struct coroutine {
@@ -52 +33 @@
       };
 
-      void invokeCoroutine(covptr_t* this);
-      void startCoroutine(covptr_t* this, void (*invoke)(covptr_t*));
 #endif //_INVOKE_H_
 #else //! defined(__CFA_INVOKE_PRIVATE__)

src/libcfa/concurrency/threads

@@ -23 +23 @@
 
 void ?{}(coroutine* this);
-void ?{}(coroutine* this, covptr_t* object);
 
-trait coroutine_t(dtype T) {
+trait is_coroutine(dtype T) {
       void co_main(T* this);
-      covptr_t* vtable(T* this);
+      coroutine* get_coroutine(T* this);
 };
 
 void suspend(void);
 
-forall(dtype T | coroutine_t(T))
+forall(dtype T | is_coroutine(T))
 void resume(T* cor);
+
+forall(dtype T | is_coroutine(T))
+void prime(T* cor);
 
 #endif //__THREADS_H__

src/libcfa/concurrency/threads.c

@@ -34 +34 @@
 static size_t pageSize = 0;                             // architecture pagesize
 
-static coroutine main_coroutine;
+void ?{}(coStack_t* this, size_t size);
+void ?{}(coroutine* this, size_t size);
+
+static coroutine main_coroutine = { 1000 };
 static coroutine* current_coroutine = &main_coroutine;
 
@@ -43 +46 @@
 void ctxSwitchDirect(coroutine* src, coroutine* dst);
 void create_stack( coStack_t* this, unsigned int storageSize ); // used by all constructors
+
+extern "C" {
+      forall(dtype T | is_coroutine(T))
+      void invokeCoroutine(T* this);
+
+      forall(dtype T | is_coroutine(T))
+      void startCoroutine(T* this, void (*invoke)(T*));
+}
 
 void ?{}(coStack_t* this) {
@@ -52 +63 @@
         this->top               = NULL; // address of top of storage
         this->userStack = false;        
+}
+
+void ?{}(coStack_t* this, size_t size) {
+        this{};
+        this->size = size;
 
         create_stack(this, this->size);
@@ -66 +82 @@
 }
 
-void ?{}(coroutine* this, covptr_t* object)
+void ?{}(coroutine* this, size_t size)
 {
         this{};
-
-        startCoroutine(object, invokeCoroutine);
+        (&this->stack){size};
 }
 
@@ -88 +103 @@
 }
 
-forall(dtype T | coroutine_t(T))
+forall(dtype T | is_coroutine(T))
 void resume(T* cor) {
         coroutine* src = this_coroutine();              // optimization
-        coroutine* dst = get_coroutine(vtable(cor));
+        coroutine* dst = get_coroutine(cor);
+
+        if( ((intptr_t)dst->stack.base) == 0 ) {
+                create_stack(&dst->stack, dst->stack.size);
+                startCoroutine(cor, invokeCoroutine);
+        }
 
         if ( src != dst ) {                             // not resuming self ?
@@ -103 +123 @@
 }
 
+forall(dtype T | is_coroutine(T))
+void prime(T* cor) {
+        coroutine* this = get_coroutine(cor);
+        assert(this->state == Start);
+
+        this->state = Primed;
+        resume(cor);
+}
+
 void ctxSwitchDirect(coroutine* src, coroutine* dst) {
         // THREAD_GETMEM( This )->disableInterrupts();

src/tests/coroutine.c

@@ -4 +4 @@
 struct Fibonacci {
       int fn; // used for communication
-      covptr_t v;
       coroutine c;
-};
-
-void co_main(Fibonacci* this);
-covptr_t* vtable(Fibonacci* this);
-
-//GENERATED in proposal for virtuals
-void co_main_fib(void* this) {
-      co_main( (Fibonacci*) this );
-}
-
-//GENERATED in proposal for virtuals
-static coVtable_t FibonacciVtable = {
-      co_main_fib,
-      VPTR_OFFSET(Fibonacci, v, c),
-      VPTR_OFFSET(Fibonacci, v, fn)      
 };
 
 void ?{}(Fibonacci* this) {
       this->fn = 0;
-      this->v = &FibonacciVtable;  //GENERATED in proposal for virtuals
-      (&this->c) { &this->v };
+}
+
+coroutine* get_coroutine(Fibonacci* this) {
+      return &this->c;
 }
 
@@ -57 +43 @@
 }
 
-covptr_t* vtable(Fibonacci* this) {
-      return &this->v;
-}
-
 int main() {
       Fibonacci f1, f2;