Changes in libcfa/src/concurrency/coroutine.hfa [5b11c25:212c2187]

File:

• libcfa/src/concurrency/coroutine.hfa (modified) (3 diffs)

libcfa/src/concurrency/coroutine.hfa

@@ -64 +64 @@
       forall(dtype T | is_coroutine(T))
       void CtxStart(T * this, void ( *invoke)(T *));
-
-        extern void _CtxCoroutine_Unwind(struct _Unwind_Exception * storage, struct coroutine_desc *) __attribute__ ((__noreturn__));
-
-        extern void CtxSwitch( struct __stack_context_t * from, struct __stack_context_t * to ) asm ("CtxSwitch");
-        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__));
 }
 
 // Private wrappers for context switch and stack creation
-// Wrapper for co
-static inline void CoroutineCtxSwitch(coroutine_desc* src, coroutine_desc* dst) {
-        // set state of current coroutine to inactive
-        src->state = src->state == Halted ? Halted : Inactive;
-
-        // set new coroutine that task is executing
-        TL_GET( this_thread )->curr_cor = dst;
-
-        // context switch to specified coroutine
-        verify( dst->context.SP );
-        CtxSwitch( &src->context, &dst->context );
-        // when CtxSwitch 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);
-        }
-}
-
-extern void __stack_prepare   ( __stack_info_t * this, size_t size /* ignored if storage already allocated */);
+extern void CoroutineCtxSwitch(coroutine_desc * src, coroutine_desc * dst);
+extern void create_stack( coStack_t * this, unsigned int storageSize );
 
 // Suspend implementation inlined for performance
@@ -128 +102 @@
         coroutine_desc * dst = get_coroutine(cor);
 
-        if( unlikely(dst->context.SP == NULL) ) {
-                __stack_prepare(&dst->stack, 65000);
+        if( unlikely(!dst->stack.base) ) {
+                create_stack(&dst->stack, dst->stack.size);
                 CtxStart(&cor, CtxInvokeCoroutine);
         }
@@ -172 +146 @@
 }
 
-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 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_return(void) {