Changeset 58fe85a for libcfa/src/concurrency/coroutine.hfa

Timestamp:

Jan 7, 2021, 3:27:00 PM (5 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

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

Children:

2b4daf2, 64aeca0

Parents:

3c64c668 (diff), eef8dfb (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge branch 'master' into park_unpark

File:

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

libcfa/src/concurrency/coroutine.hfa

@@ -18 +18 @@
 #include <assert.h>
 #include "invoke.h"
+#include "../exception.hfa"
+
+//-----------------------------------------------------------------------------
+// Exception thrown from resume when a coroutine stack is cancelled.
+FORALL_DATA_EXCEPTION(CoroutineCancelled, (dtype coroutine_t), (coroutine_t)) (
+        coroutine_t * the_coroutine;
+        exception_t * the_exception;
+);
+
+forall(dtype T)
+void copy(CoroutineCancelled(T) * dst, CoroutineCancelled(T) * src);
+
+forall(dtype T)
+const char * msg(CoroutineCancelled(T) *);
 
 //-----------------------------------------------------------------------------
@@ -23 +37 @@
 // Anything that implements this trait can be resumed.
 // Anything that is resumed is a coroutine.
-trait is_coroutine(dtype T) {
-      void main(T & this);
-      $coroutine * get_coroutine(T & this);
+trait is_coroutine(dtype T | IS_RESUMPTION_EXCEPTION(CoroutineCancelled, (T))) {
+        void main(T & this);
+        $coroutine * get_coroutine(T & this);
 };
 
@@ -46 +60 @@
 //-----------------------------------------------------------------------------
 // Public coroutine API
-static inline void suspend(void);
-
-forall(dtype T | is_coroutine(T))
-static inline T & resume(T & cor);
-
 forall(dtype T | is_coroutine(T))
 void prime(T & cor);
 
-static inline struct $coroutine * active_coroutine() { return TL_GET( this_thread )->curr_cor; }
+static inline struct $coroutine * active_coroutine() { return active_thread()->curr_cor; }
 
 //-----------------------------------------------------------------------------
@@ -75 +84 @@
 static inline void $ctx_switch( $coroutine * src, $coroutine * dst ) __attribute__((nonnull (1, 2))) {
         // set state of current coroutine to inactive
-        src->state = src->state == Halted ? Halted : Inactive;
+        src->state = src->state == Halted ? Halted : Blocked;
 
         // set new coroutine that task is executing
-        TL_GET( this_thread )->curr_cor = dst;
+        active_thread()->curr_cor = dst;
 
         // context switch to specified coroutine
@@ -93 +102 @@
 }
 
-extern void __stack_prepare   ( __stack_info_t * this, size_t size /* ignored if storage already allocated */);
+extern void __stack_prepare( __stack_info_t * this, size_t size /* ignored if storage already allocated */);
+extern void __stack_clean  ( __stack_info_t * this );
+
 
 // Suspend implementation inlined for performance
-static inline void suspend(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
-        $coroutine * src = TL_GET( this_thread )->curr_cor;
+extern "C" {
+        static inline void __cfactx_suspend(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
+                $coroutine * src = active_coroutine();
 
-        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 );
+                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 );
 
-        $ctx_switch( src, src->last );
+                $ctx_switch( src, src->last );
+        }
 }
+
+forall(dtype T | is_coroutine(T))
+void __cfaehm_cancelled_coroutine( T & cor, $coroutine * desc );
 
 // Resume implementation inlined for performance
@@ -124 +140 @@
         // will also migrate which means this value will
         // stay in syn with the TLS
-        $coroutine * src = TL_GET( this_thread )->curr_cor;
+        $coroutine * src = active_coroutine();
         $coroutine * dst = get_coroutine(cor);
 
         if( unlikely(dst->context.SP == 0p) ) {
-                TL_GET( this_thread )->curr_cor = dst;
                 __stack_prepare(&dst->stack, 65000);
                 __cfactx_start(main, dst, cor, __cfactx_invoke_coroutine);
-                TL_GET( this_thread )->curr_cor = src;
         }
 
@@ -148 +162 @@
         // always done for performance testing
         $ctx_switch( src, dst );
+        if ( unlikely(dst->cancellation) ) {
+                __cfaehm_cancelled_coroutine( cor, dst );
+        }
 
         return cor;
@@ -158 +175 @@
         // will also migrate which means this value will
         // stay in syn with the TLS
-        $coroutine * src = TL_GET( this_thread )->curr_cor;
+        $coroutine * src = active_coroutine();
 
         // not resuming self ?