Changes in libcfa/src/concurrency/coroutine.cfa [6b33e89:5251c6b]

File:

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

libcfa/src/concurrency/coroutine.cfa

@@ -10 +10 @@
 // Created On       : Mon Nov 28 12:27:26 2016
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Apr 25 06:48:19 2025
-// Update Count     : 31
+// Last Modified On : Mon Sep 18 21:47:12 2023
+// Update Count     : 25
 //
 
@@ -82 +82 @@
 // helper for popping from coroutine's ehm buffer
 static 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;
+    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;
 }
 
@@ -97 +97 @@
 
 void __stack_prepare( __stack_info_t * this, size_t create_size );
-static void __stack_clean( __stack_info_t * this );
+static void __stack_clean  ( __stack_info_t * this );
 
 //-----------------------------------------------------------------------------
@@ -105 +105 @@
 
         // Did we get a piece of storage ?
-        if ( this.storage || storageSize != 0 ) {
+        if (this.storage || storageSize != 0) {
                 // We either got a piece of storage or the user asked for a specific size
                 // Immediately create the stack
@@ -128 +128 @@
         state = Start;
         starter = 0p;
-        this.last = 0p;
+        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 
-        for ( ; nl_ex != 0p; nl_ex = pop_ehm_head( &this ) ) {
-                unhandled_ex++;
-                free( nl_ex->the_exception );
-                free( nl_ex );
-        }
-
-        #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 ) {
+    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();
                 coroutine$ * dst = &this;
@@ -173 +174 @@
 // Part of the Public API
 // Not inline since only ever called once per coroutine
-forall( T & | is_coroutine(T) | { EHM_DEFAULT_VTABLE(CoroutineCancelled(T)); } )
-void prime( T & cor ) libcfa_public {
-        coroutine$ * this = get_coroutine(cor);
-        assert( this->state == Start );
+forall(T & | is_coroutine(T) | { EHM_DEFAULT_VTABLE(CoroutineCancelled(T)); })
+void prime(T& cor) libcfa_public {
+        coroutine$* this = get_coroutine(cor);
+        assert(this->state == Start);
 
         this->state = Primed;
-        resume( cor );
+        resume(cor);
 }
 
 static [void *, size_t] __stack_alloc( size_t storageSize ) {
         const size_t stack_data_size = libCeiling( sizeof(__stack_t), 16 ); // minimum alignment
-        assert( __page_size != 0l );
+        assert(__page_size != 0l);
         size_t size = libCeiling( storageSize, 16 ) + stack_data_size;
-        size = ceiling( size, __page_size );
+        size = ceiling(size, __page_size);
 
         // If we are running debug, we also need to allocate a guardpage to catch stack overflows.
@@ -192 +193 @@
         #if CFA_COROUTINE_USE_MMAP
                 storage = mmap(0p, size + __page_size, PROT_EXEC | PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, 0, 0);
-                if (storage == ((void*)-1)) {
+                if(storage == ((void*)-1)) {
                         abort( "coroutine stack creation : internal error, mmap failure, error(%d) %s.", errno, strerror( errno ) );
                 }
@@ -226 +227 @@
                 size_t size = ((intptr_t)this->storage->base) - ((intptr_t)this->storage->limit) + sizeof(__stack_t);
                 storage = (void *)(((intptr_t)storage) - __page_size);
-                if (munmap(storage, size + __page_size) == -1) {
+                if(munmap(storage, size + __page_size) == -1) {
                         abort( "coroutine stack destruction : internal error, munmap failure, error(%d) %s.", errno, strerror( errno ) );
                 }
@@ -247 +248 @@
         void * storage;
         size_t size;
-        if ( ! this->storage ) {
+        if ( !this->storage ) {
                 userStack = false;
                 [storage, size] = __stack_alloc( create_size );
@@ -301 +302 @@
                 athrd->corctx_flag = false;
 
-                if (cor->state == Primed) {
+                if(cor->state == Primed) {
                         __cfactx_suspend();
                 }
@@ -316 +317 @@
 
 void defaultResumeAtHandler( exception_t * except ) {
-        __cfaehm_allocate_exception( except );
-        __cfaehm_begin_unwind( (void(*)(exception_t *))defaultTerminationHandler );
+    __cfaehm_allocate_exception( except );
+    __cfaehm_begin_unwind( (void(*)(exception_t *))defaultTerminationHandler );
 }
 
@@ -327 +328 @@
 
 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
-        for ( ; nl_ex != 0p; nl_ex = pop_ehm_head( cor ) ) {
+    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 ){
                 ehm_cleanup ex_holder{ nl_ex->the_exception };
-                free( nl_ex );
-                __cfaehm_throw_resume( ex_holder.ex , defaultResumeAtHandler );
-        }
-        
-        return true;
+        free( nl_ex );
+        __cfaehm_throw_resume( ex_holder.ex , defaultResumeAtHandler );
+        
+        nl_ex = pop_ehm_head( cor );
+    }
+    
+    return true;
 }
 
@@ -351 +354 @@
 // 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; }
-        coroutine$ * first_resumer( T & cor ) libcfa_public { return get_coroutine( cor )->starter; }
+    // 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; }
+    coroutine$ * first_resumer( T & cor ) libcfa_public { return get_coroutine( cor )->starter; }
 }
 
@@ -368 +371 @@
 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 );
+    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 );
+    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 );
 }