Changeset 2a301ff for libcfa/src/concurrency/coroutine.cfa

Timestamp:

Aug 31, 2023, 11:31:15 PM (2 years ago)

Author:

JiadaL <j82liang@…>

Branches:

master

Children:

950c58e

Parents:

92355883 (diff), 686912c (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:

Resolve conflict

File:

• libcfa/src/concurrency/coroutine.cfa (modified) (4 diffs)

libcfa/src/concurrency/coroutine.cfa

@@ -28 +28 @@
 #include "kernel/private.hfa"
 #include "exception.hfa"
+#include "exception.h"
 #include "math.hfa"
 
@@ -77 +78 @@
         free( desc->cancellation );
         desc->cancellation = 0p;
+}
+
+// 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;
 }
 
@@ -121 +130 @@
         last = 0p;
         cancellation = 0p;
+    ehm_state.ehm_buffer{};
+    ehm_state.buffer_lock{};
+    ehm_state.ehm_enabled = false;
 }
 
 void ^?{}(coroutine$& this) libcfa_public {
+    // handle any leftover pending non-local exceptions
+    nonlocal_exception * nl_ex = pop_ehm_head( &this );
+    unsigned unhandled_ex = 0;
+    
+    // if any leftover exceptions handle 
+    while ( nl_ex != 0p ){
+        unhandled_ex++;
+        free( nl_ex->the_exception );
+        free( nl_ex );
+        nl_ex = pop_ehm_head( &this );
+    }
+
+    #ifdef __CFA_DEBUG__
+    if ( unhandled_ex > 0 )
+        printf( "Warning: Coroutine %p exited with %u pending nonlocal exceptions.\n", &this, unhandled_ex );
+    #endif
+
         if(this.state != Halted && this.state != Start && this.state != Primed) {
                 coroutine$ * src = active_coroutine();
@@ -283 +312 @@
 }
 
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+// non local ehm routines
+
+void defaultResumeAtHandler( exception_t * except ) {
+    __cfaehm_allocate_exception( except );
+    free( except );
+    __cfaehm_begin_unwind( (void(*)(exception_t *))defaultTerminationHandler );
+}
+
+bool poll( coroutine$ * cor ) libcfa_public {
+    nonlocal_exception * nl_ex = pop_ehm_head( 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 );
+        __cfaehm_throw_resume( ex, defaultResumeAtHandler );
+        
+        // only reached if resumption handled. other dealloc handled in defaultResumeAtHandler
+        free( ex );
+        nl_ex = pop_ehm_head( cor );
+    }
+    
+    return true;
+}
+
+bool poll() libcfa_public { return poll( active_coroutine() ); }
+coroutine$ * resumer() libcfa_public { return active_coroutine()->last; }
+
+// 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 { return poll( get_coroutine( cor ) ); }
+
+    // poll iff nonlocal ehm is enabled
+    bool checked_poll( T & cor ) libcfa_public { return get_coroutine( cor )->ehm_state.ehm_enabled ? poll( cor ) : false; }
+
+    coroutine$ * resumer( T & cor ) libcfa_public { return get_coroutine( cor )->last; }
+}
+
+// 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();
+    exceptT * ex_copy = alloc();
+    memcpy( ex_copy, &ex, sizeof(exceptT) );
+    (*nl_ex){ (exception_t *)ex_copy };
+    lock( cor->ehm_state.buffer_lock __cfaabi_dbg_ctx2 );
+    append( cor->ehm_state.ehm_buffer, nl_ex ); 
+    unlock( cor->ehm_state.buffer_lock );
+}
+
+forall(exceptT * | { void $throwResume(exceptT &); })
+void resumeAt( coroutine$ * receiver, exceptT & ex ) libcfa_public {
+    nonlocal_exception * nl_ex = alloc();
+    exceptT * ex_copy = alloc();
+    memcpy( ex_copy, &ex, sizeof(exceptT) );
+    (*nl_ex){ (exception_t *)ex_copy };
+    lock( receiver->ehm_state.buffer_lock __cfaabi_dbg_ctx2 );
+    append( receiver->ehm_state.ehm_buffer, nl_ex ); 
+    unlock( receiver->ehm_state.buffer_lock );
+}
+
 // Local Variables: //
 // mode: c //