Changeset 1c01c58 for libcfa/src/concurrency

Timestamp:

Sep 9, 2020, 5:03:40 PM (4 years ago)

Author:

Andrew Beach <ajbeach@…>

Branches:

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

Children:

b9fa85b, c402739f

Parents:

2b7f6f0

Message:

Rather large commit to get coroutine cancellation working.

This includes what you would expect, like new code in exceptions and a new
test, but it also includes a bunch of other things.

New coroutine state, currently just marks that the stack was cancelled. New
helpers for checking code structure and generating vtables. Changes to the
coroutine interface so resume may throw exceptions on cancellation, plus the
exception type that is thrown. Changes to the coroutine keyword generation to
generate exception code for each type of coroutine.

Location:

libcfa/src/concurrency

Files:

• coroutine.cfa (modified) (2 diffs)
• coroutine.hfa (modified) (4 diffs)
• exception.cfa (modified) (1 diff)
• exception.hfa (modified) (2 diffs)
• invoke.h (modified) (1 diff)

libcfa/src/concurrency/coroutine.cfa

@@ -47 +47 @@
 
 //-----------------------------------------------------------------------------
+FORALL_DATA_INSTANCE(CoroutineCancelled,
+                (dtype coroutine_t | sized(coroutine_t)), (coroutine_t))
+
+struct __cfaehm_node {
+        struct _Unwind_Exception unwind_exception;
+        struct __cfaehm_node * next;
+        int handler_index;
+};
+
+forall(dtype T)
+void mark_exception(CoroutineCancelled(T) *) {}
+
+forall(dtype T | sized(T))
+void copy(CoroutineCancelled(T) * dst, CoroutineCancelled(T) * src) {
+        dst->the_coroutine = src->the_coroutine;
+        dst->the_exception = src->the_exception;
+}
+
+forall(dtype T)
+const char * msg(CoroutineCancelled(T) *) {
+        return "CoroutineCancelled(...)";
+}
+
+// This code should not be inlined. It is the error path on resume.
+forall(dtype T | is_coroutine(T))
+void __cfaehm_cancelled_coroutine( T & cor, $coroutine * desc ) {
+        verify( desc->cancellation );
+        desc->state = Cancelled;
+        exception_t * except = (exception_t *)(1 + (__cfaehm_node *)desc->cancellation);
+
+        CoroutineCancelled(T) except;
+        except.the_coroutine = &cor;
+        except.the_exception = except;
+        throwResume except;
+
+        except->virtual_table->free( except );
+        free( desc->cancellation );
+        desc->cancellation = 0p;
+}
+
+//-----------------------------------------------------------------------------
 // Global state variables
 
@@ -180 +221 @@
         this->storage->limit = storage;
         this->storage->base  = (void*)((intptr_t)storage + size);
+        this->storage->exception_context.top_resume = 0p;
+        this->storage->exception_context.current_exception = 0p;
         __attribute__((may_alias)) intptr_t * istorage = (intptr_t*)&this->storage;
         *istorage |= userStack ? 0x1 : 0x0;

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.
+// Should not have to be be sized (see trac #196).
+FORALL_DATA_EXCEPTION(CoroutineCancelled,
+                (dtype coroutine_t | sized(coroutine_t)), (coroutine_t)) (
+        coroutine_t * the_coroutine;
+        exception_t * the_exception;
+);
+
+forall(dtype T)
+void mark_exception(CoroutineCancelled(T) *);
+
+forall(dtype T | sized(T))
+void copy(CoroutineCancelled(T) * dst, CoroutineCancelled(T) * src);
+
+forall(dtype T)
+const char * msg(CoroutineCancelled(T) *);
 
 //-----------------------------------------------------------------------------
@@ -23 +42 @@
 // 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 | sized(T)
+                | is_resumption_exception(CoroutineCancelled(T))
+                | VTABLE_ASSERTION(CoroutineCancelled, (T))) {
+        void main(T & this);
+        $coroutine * get_coroutine(T & this);
 };
 
@@ -112 +133 @@
         }
 }
+
+forall(dtype T | is_coroutine(T))
+void __cfaehm_cancelled_coroutine( T & cor, $coroutine * desc );
 
 // Resume implementation inlined for performance
@@ -145 +169 @@
         // always done for performance testing
         $ctx_switch( src, dst );
+        if ( unlikely(dst->cancellation) ) {
+                __cfaehm_cancelled_coroutine( cor, dst );
+        }
 
         return cor;

libcfa/src/concurrency/exception.cfa

@@ -57 +57 @@
 
 STOP_AT_END_FUNCTION(coroutine_cancelstop,
-        // TODO: Instead pass information to the last resumer.
+        struct $coroutine * src = ($coroutine *)stop_param;
+        struct $coroutine * dst = src->last;
+
+        $ctx_switch( src, dst );
         abort();
 )

libcfa/src/concurrency/exception.hfa

@@ -18 +18 @@
 #include "bits/defs.hfa"
 #include "invoke.h"
-struct _Unwind_Exception;
-
-// It must also be usable as a C header file.
 
 #ifdef __cforall
 extern "C" {
+
+#define HIDE_EXPORTS
 #endif
+#include "unwind.h"
 
 struct exception_context_t * this_exception_context(void) OPTIONAL_THREAD;
@@ -32 +32 @@
 
 #ifdef __cforall
+#undef HIDE_EXPORTS
 }
 #endif

libcfa/src/concurrency/invoke.h

@@ -68 +68 @@
         };
 
-        enum __Coroutine_State { Halted, Start, Primed, Blocked, Ready, Active };
+        enum __Coroutine_State { Halted, Start, Primed, Blocked, Ready, Active, Cancelled };
 
         struct $coroutine {