Changeset 2fe64ba for libcfa/src/concurrency

Timestamp:

Jul 6, 2023, 4:51:42 PM (20 months ago)

Author:

caparsons <caparson@…>

Branches:

master

Children:

bef2245

Parents:

b4d2b3b

Message:

added support for non-local exceptions

Location:

libcfa/src/concurrency

Files:

• coroutine.cfa (modified) (2 diffs)
• coroutine.hfa (modified) (2 diffs)
• invoke.h (modified) (2 diffs)

libcfa/src/concurrency/coroutine.cfa

@@ -121 +121 @@
         last = 0p;
         cancellation = 0p;
+    ehm_state.ehm_buffer{};
+    ehm_state.buffer_lock{};
+    ehm_state.ehm_enabled = false;
 }
 
@@ -283 +286 @@
 }
 
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+// non local ehm routines
+
+// helper for popping from coroutine's ehm buffer
+inline nonlocal_exception * pop_ehm_head( coroutine$ * this ) {
+    lock( this->ehm_state.buffer_lock __cfaabi_dbg_ctx2 );
+    nonlocal_exception * nl_ex = pop_head( this->ehm_state.ehm_buffer );
+    unlock( this->ehm_state.buffer_lock );
+    return nl_ex;
+}
+
+// user facing ehm operations
+forall(T & | is_coroutine(T)) {
+    // enable/disable non-local exceptions
+    void enable_ehm( T & cor ) libcfa_public { get_coroutine( cor )->ehm_state.ehm_enabled = true; }
+    void disable_ehm( T & cor ) libcfa_public { get_coroutine( cor )->ehm_state.ehm_enabled = false; }
+
+    // poll for non-local exceptions
+    bool poll( T & cor ) libcfa_public {
+        coroutine$ * base_cor = get_coroutine( cor );
+        nonlocal_exception * nl_ex = pop_ehm_head( base_cor );
+
+        // if no exceptions return false
+        if ( nl_ex == 0p ) return false;
+        
+        // otherwise loop and throwResume all pending exceptions
+        while ( nl_ex != 0p ){
+            exception_t * ex = nl_ex->the_exception;
+            free( nl_ex );
+            throwResume *ex;
+            nl_ex = pop_ehm_head( base_cor );
+        }
+        
+        return true;
+    }
+
+    // poll iff nonlocal ehm is enabled
+    bool checked_poll( T & cor ) libcfa_public { return get_coroutine( cor )->ehm_state.ehm_enabled ? poll( cor ) : false; }
+}
+
+// resume non local exception at receiver (i.e. enqueue in ehm buffer)
+forall(exceptT &, T & | ehm_resume_at( exceptT, T ))
+void resumeAt( T & receiver, exceptT & ex )  libcfa_public {
+    coroutine$ * cor = get_coroutine( receiver );
+    nonlocal_exception * nl_ex = alloc();
+    (*nl_ex){ (exception_t *)&ex };
+    lock( cor->ehm_state.buffer_lock __cfaabi_dbg_ctx2 );
+    append( cor->ehm_state.ehm_buffer, nl_ex ); 
+    unlock( cor->ehm_state.buffer_lock );
+}
+
 // Local Variables: //
 // mode: c //

libcfa/src/concurrency/coroutine.hfa

@@ -19 +19 @@
 #include "invoke.h"
 #include "../exception.hfa"
+
+//-----------------------------------------------------------------------------
+// Type used to store and queue nonlocal exceptions on coroutines
+struct nonlocal_exception {
+    exception_t * the_exception;
+    nonlocal_exception * next;
+};
+static inline void ?{} ( nonlocal_exception & this, exception_t * ex ) with(this) {
+    the_exception = ex;
+    next = 0p;
+}
+
+static inline nonlocal_exception *& get_next( nonlocal_exception & this ) __attribute__((const)) {
+    return this.next;
+}
 
 //-----------------------------------------------------------------------------
@@ -203 +218 @@
 }
 
+// non local ehm routines
+forall(T & | is_coroutine(T)) {
+    void enable_ehm( T & cor );
+    void disable_ehm( T & cor );
+    bool poll( T & cor );
+    bool checked_poll( T & cor );
+}
+
+// trait for exceptions able to be resumed at another coroutine
+forall(exceptT &, T & | is_coroutine(T))
+trait ehm_resume_at { void $throwResume(exceptT &); };
+
+forall(exceptT &, T & | ehm_resume_at( exceptT, T ))
+void resumeAt( T & receiver, exceptT & ex );
+
 // Local Variables: //
 // mode: c //

libcfa/src/concurrency/invoke.h

@@ -74 +74 @@
         };
 
+    struct nonlocal_ehm {
+        // list of pending nonlocal exceptions
+        __queue_t(struct nonlocal_exception) ehm_buffer;
+
+        // lock to protect the buffer
+        struct __spinlock_t buffer_lock;
+
+        // enable/disabled flag
+        bool ehm_enabled;
+    };
+
         enum __Coroutine_State { Halted, Start, Primed, Blocked, Ready, Active, Cancelled, Halting };
 
@@ -98 +109 @@
                 struct _Unwind_Exception * cancellation;
 
+        // Non-local exception handling information
+        struct nonlocal_ehm ehm_state;
         };
         // Wrapper for gdb