Changeset 5b11c25

Timestamp:

Apr 30, 2019, 2:53:41 PM (5 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

ADT, arm-eh, ast-experimental, cleanup-dtors, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, pthread-emulation, qualifiedEnum

Children:

8278abf

Parents:

673cd63

Message:

Added new suspen_then function which runs a callback in the middle of susending

Files:

• benchmark/ctxswitch/cfa_cor_then.cfa (added)
• libcfa/src/concurrency/CtxSwitch-x86_64.S (modified) (2 diffs)
• libcfa/src/concurrency/coroutine.hfa (modified) (2 diffs)
• libcfa/src/concurrency/invoke.h (modified) (1 diff)
• tests/concurrent/.expect/coroutineThen.txt (added)
• tests/concurrent/coroutineThen.cfa (added)
• tests/coroutine/.expect/suspend_then.txt (added)
• tests/coroutine/suspend_then.cfa (added)

libcfa/src/concurrency/CtxSwitch-x86_64.S

@@ -40 +40 @@
 #define FP_OFFSET       ( 1 * PTR_BYTE )
 
+//-----------------------------------------------------------------------------
+// Regular context switch routine which enables switching from one context to anouther
         .text
         .align 2
@@ -77 +79 @@
         .size  CtxSwitch, .-CtxSwitch
 
-.text
+//-----------------------------------------------------------------------------
+// Part of a 2 part context switch routine, use with CtxRet, stores the current context and then makes a function call
+        .text
         .align 2
-.globl  CtxInvokeStub
+        .globl CtxStore
+        .type  CtxStore, @function
+CtxStore:
+
+        // Save volatile registers on the stack.
+
+        pushq %r15
+        pushq %r14
+        pushq %r13
+        pushq %r12
+        pushq %rbx
+
+        // Save old context in the "from" area.
+
+        movq %rsp,SP_OFFSET(%rdi)
+        movq %rbp,FP_OFFSET(%rdi)
+
+        // Don't load a new context, directly jump to the desired function
+
+        jmp *%rsi
+        .size  CtxStore, .-CtxStore
+
+//-----------------------------------------------------------------------------
+// Part of a 2 part context switch routine, use with CtxStore, context switches to the desired target without saving the current context
+        .text
+        .align 2
+        .globl CtxRet
+        .type  CtxRet, @function
+CtxRet:
+        // Load new context from the "to" area.
+
+        movq SP_OFFSET(%rdi),%rsp
+        movq FP_OFFSET(%rdi),%rbp
+
+        // Load volatile registers from the stack.
+
+        popq %rbx
+        popq %r12
+        popq %r13
+        popq %r14
+        popq %r15
+
+        // Return to thread.
+
+        ret
+        .size  CtxRet, .-CtxRet
+
+
+//-----------------------------------------------------------------------------
+// Stub used to create new stacks which are ready to be context switched to
+        .text
+        .align 2
+        .globl CtxInvokeStub
+        .type    CtxInvokeStub, @function
 CtxInvokeStub:
         movq %rbx, %rdi
         jmp *%r12
+        .size  CtxInvokeStub, .-CtxInvokeStub
 
 // Local Variables: //

libcfa/src/concurrency/coroutine.hfa

@@ -68 +68 @@
 
         extern void CtxSwitch( struct __stack_context_t * from, struct __stack_context_t * to ) asm ("CtxSwitch");
-        // void CtxStore ( void * this ) asm ("CtxStore");
-        // void CtxRet   ( void * dst  ) asm ("CtxRet");
+        extern void CtxStore ( struct __stack_context_t * from, __attribute__((noreturn)) void (*__callback)(void) ) asm ("CtxStore");
+        extern void CtxRet   ( struct __stack_context_t * to ) asm ("CtxRet") __attribute__ ((__noreturn__));
 }
 
@@ -172 +172 @@
 }
 
-
-
-// static inline bool suspend_checkpoint(void) {
-//      // optimization : read TLS once and reuse it
-//      // Safety note: this is preemption safe since if
-//      // preemption occurs after this line, the pointer
-//      // will also migrate which means this value will
-//      // stay in syn with the TLS
-//      // set state of current coroutine to inactive
-//       this->state = Checkpoint;
-
-//       // context switch to specified coroutine
-//       assert( src->stack.context );
-
-//       CtxStore(src->stack.context);
-
-//      bool ret = this->state == Checkpoint;
-
-//       // set state of new coroutine to active
-//       src->state = Active;
-
-//       enable_interrupts( __cfaabi_dbg_ctx );
-//       // Safety note : This could cause some false positives due to preemption
-//       verify( TL_GET( preemption_state.enabled ) || TL_GET( this_processor )->do_terminate );
-
-//       if( unlikely(src->cancellation != NULL) ) {
-//             _CtxCoroutine_Unwind(src->cancellation);
-//       }
-
-//      return ret;
-// }
+static inline void suspend_then(fptr_t call) {
+        // optimization : read TLS once and reuse it
+        // Safety note: this is preemption safe since if
+        // preemption occurs after this line, the pointer
+        // will also migrate which means this value will
+        // stay in syn with the TLS
+        coroutine_desc * src = TL_GET( this_thread )->curr_cor;
+
+        assertf( src->last != 0,
+                "Attempt to suspend coroutine \"%.256s\" (%p) that has never been resumed.\n"
+                "Possible cause is a suspend executed in a member called by a coroutine user rather than by the coroutine main.",
+                src->name, src );
+        assertf( src->last->state != Halted,
+                "Attempt by coroutine \"%.256s\" (%p) to suspend back to terminated coroutine \"%.256s\" (%p).\n"
+                "Possible cause is terminated coroutine's main routine has already returned.",
+                src->name, src, src->last->name, src->last );
+
+        src->state = PreInactive;
+
+      // context switch to specified coroutine
+      assert( src->context.SP );
+
+        __attribute__((noreturn)) void __suspend_callback(void) {
+                call();
+
+                // set state of current coroutine to inactive
+                src->state = src->state == Halted ? Halted : Inactive;
+
+                TL_GET( this_thread )->curr_cor = src->last;
+
+                // context switch to specified coroutine
+                assert( src->last->context.SP );
+                CtxRet( &src->last->context );
+
+                abort();
+        }
+      CtxStore( &src->context, __suspend_callback );
+        // when CtxStore returns we are back in the src coroutine
+
+        // set state of new coroutine to active
+        src->state = Active;
+
+        if( unlikely(src->cancellation != NULL) ) {
+                _CtxCoroutine_Unwind(src->cancellation, src);
+        }
+
+        return;
+}
 
 // static inline void suspend_return(void) {

libcfa/src/concurrency/invoke.h

@@ -93 +93 @@
         };
 
-        enum coroutine_state { Halted, Start, Inactive, Active, Primed };
+        enum coroutine_state { Halted, Start, Inactive, Active, Primed, PreInactive };
 
         struct coroutine_desc {