Changeset ecfd758 for libcfa/src/concurrency

Timestamp:

Apr 9, 2021, 2:11:43 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:

b91bfde

Parents:

e07b589

Message:

Major exception update, seperating type-ids from virtual tables. The major interface changes are done. There is a regression of ?Cancelled(T) to Some?Cancelled. There is some bits of code for the new verion of the ?Cancelled(T) interface already there. Not connected yet but I just reached the limit of what I wanted to do in one commit and then spent over a day cleaning up, so it will replace Some?Cancelled in a future commit.

Location:

libcfa/src/concurrency

Files:

• coroutine.cfa (modified) (2 diffs)
• coroutine.hfa (modified) (2 diffs)
• thread.cfa (modified) (4 diffs)
• thread.hfa (modified) (3 diffs)

libcfa/src/concurrency/coroutine.cfa

@@ -46 +46 @@
 
 //-----------------------------------------------------------------------------
-FORALL_DATA_INSTANCE(CoroutineCancelled, (coroutine_t &), (coroutine_t))
-
-forall(T &)
-void mark_exception(CoroutineCancelled(T) *) {}
+EHM_VIRTUAL_TABLE(SomeCoroutineCancelled, std_coroutine_cancelled);
 
 forall(T &)
@@ -71 +68 @@
 
         // TODO: Remove explitate vtable set once trac#186 is fixed.
-        CoroutineCancelled(T) except;
-        except.virtual_table = &get_exception_vtable(&except);
+        SomeCoroutineCancelled except;
+        except.virtual_table = &std_coroutine_cancelled;
         except.the_coroutine = &cor;
         except.the_exception = except;
-        throwResume except;
+        // Why does this need a cast?
+        throwResume (SomeCoroutineCancelled &)except;
 
         except->virtual_table->free( except );

libcfa/src/concurrency/coroutine.hfa

@@ -22 +22 @@
 //-----------------------------------------------------------------------------
 // Exception thrown from resume when a coroutine stack is cancelled.
-FORALL_DATA_EXCEPTION(CoroutineCancelled, (coroutine_t &), (coroutine_t)) (
+EHM_EXCEPTION(SomeCoroutineCancelled)(
+        void * the_coroutine;
+        exception_t * the_exception;
+);
+
+EHM_EXTERN_VTABLE(SomeCoroutineCancelled, std_coroutine_cancelled);
+
+EHM_FORALL_EXCEPTION(CoroutineCancelled, (coroutine_t &), (coroutine_t)) (
         coroutine_t * the_coroutine;
         exception_t * the_exception;
@@ -37 +44 @@
 // Anything that implements this trait can be resumed.
 // Anything that is resumed is a coroutine.
-trait is_coroutine(T & | IS_RESUMPTION_EXCEPTION(CoroutineCancelled, (T))) {
+trait is_coroutine(T & | IS_RESUMPTION_EXCEPTION(SomeCoroutineCancelled)) {
         void main(T & this);
         $coroutine * get_coroutine(T & this);

libcfa/src/concurrency/thread.cfa

@@ -62 +62 @@
 }
 
-FORALL_DATA_INSTANCE(ThreadCancelled, (thread_t &), (thread_t))
+EHM_VIRTUAL_TABLE(SomeThreadCancelled, std_thread_cancelled);
 
 forall(T &)
@@ -73 +73 @@
 forall(T &)
 const char * msg(ThreadCancelled(T) *) {
-        return "ThreadCancelled";
+        return "ThreadCancelled(...)";
 }
 
 forall(T &)
 static void default_thread_cancel_handler(ThreadCancelled(T) & ) {
+        // Improve this error message, can I do formatting?
         abort( "Unhandled thread cancellation.\n" );
 }
 
-forall(T & | is_thread(T) | IS_EXCEPTION(ThreadCancelled, (T)))
+static void default_thread_cancel_handler(SomeThreadCancelled & ) {
+        // Improve this error message, can I do formatting?
+        abort( "Unhandled thread cancellation.\n" );
+}
+
+forall(T & | is_thread(T) | IS_EXCEPTION(SomeThreadCancelled))
 void ?{}( thread_dtor_guard_t & this,
-                T & thrd, void(*cancelHandler)(ThreadCancelled(T) &)) {
-        $monitor * m = get_monitor(thrd);
+                T & thrd, void(*cancelHandler)(SomeThreadCancelled &)) {
+        $monitor * m = get_monitor(thrd);
         $thread * desc = get_thread(thrd);
 
         // Setup the monitor guard
         void (*dtor)(T& mutex this) = ^?{};
-        bool join = cancelHandler != (void(*)(ThreadCancelled(T)&))0;
+        bool join = cancelHandler != (void(*)(SomeThreadCancelled&))0;
         (this.mg){&m, (void(*)())dtor, join};
 
@@ -103 +109 @@
         }
         desc->state = Cancelled;
-        void(*defaultResumptionHandler)(ThreadCancelled(T) &) = 
+        void(*defaultResumptionHandler)(SomeThreadCancelled &) =
                 join ? cancelHandler : default_thread_cancel_handler;
 
-        ThreadCancelled(T) except;
         // TODO: Remove explitate vtable set once trac#186 is fixed.
-        except.virtual_table = &get_exception_vtable(&except);
+        SomeThreadCancelled except;
+        except.virtual_table = &std_thread_cancelled;
         except.the_thread = &thrd;
         except.the_exception = __cfaehm_cancellation_exception( cancellation );
-        throwResume except;
+        // Why is this cast required?
+        throwResume (SomeThreadCancelled &)except;
 
         except.the_exception->virtual_table->free( except.the_exception );
@@ -158 +165 @@
 
 //-----------------------------------------------------------------------------
-forall(T & | is_thread(T) | IS_RESUMPTION_EXCEPTION(ThreadCancelled, (T)))
+forall(T & | is_thread(T) | IS_RESUMPTION_EXCEPTION(SomeThreadCancelled))
 T & join( T & this ) {
         thread_dtor_guard_t guard = { this, defaultResumptionHandler };

libcfa/src/concurrency/thread.hfa

@@ -32 +32 @@
 };
 
-FORALL_DATA_EXCEPTION(ThreadCancelled, (thread_t &), (thread_t)) (
+EHM_EXCEPTION(SomeThreadCancelled) (
+        void * the_thread;
+        exception_t * the_exception;
+);
+
+EHM_EXTERN_VTABLE(SomeThreadCancelled, std_thread_cancelled);
+
+EHM_FORALL_EXCEPTION(ThreadCancelled, (thread_t &), (thread_t)) (
         thread_t * the_thread;
         exception_t * the_exception;
@@ -79 +86 @@
 };
 
-forall( T & | is_thread(T) | IS_EXCEPTION(ThreadCancelled, (T)) )
-void ?{}( thread_dtor_guard_t & this, T & thrd, void(*)(ThreadCancelled(T) &) );
+forall( T & | is_thread(T) | IS_EXCEPTION(SomeThreadCancelled) )
+void ?{}( thread_dtor_guard_t & this, T & thrd, void(*)(SomeThreadCancelled &) );
 void ^?{}( thread_dtor_guard_t & this );
 
@@ -125 +132 @@
 //----------
 // join
-forall( T & | is_thread(T) | IS_RESUMPTION_EXCEPTION(ThreadCancelled, (T)) )
+forall( T & | is_thread(T) | IS_RESUMPTION_EXCEPTION(SomeThreadCancelled) )
 T & join( T & this );