Changeset 6b33e89 for libcfa/src/concurrency/coroutine.cfa

Timestamp:

Apr 25, 2025, 7:39:09 AM (8 months ago)

Author:

Peter A. Buhr <pabuhr@…>

Branches:

master

Children:

65bd3c2

Parents:

b195498

Message:

change backquote call to regular call

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 : Mon Sep 18 21:47:12 2023
-// Update Count     : 25
+// Last Modified On : Fri Apr 25 06:48:19 2025
+// Update Count     : 31
 //
 
@@ -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;
-        last = 0p;
+        this.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) {
+        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 ) {
                 coroutine$ * src = active_coroutine();
                 coroutine$ * dst = &this;
@@ -174 +173 @@
 // 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.
@@ -193 +192 @@
         #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 ) );
                 }
@@ -227 +226 @@
                 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 ) );
                 }
@@ -248 +247 @@
         void * storage;
         size_t size;
-        if ( !this->storage ) {
+        if ( ! this->storage ) {
                 userStack = false;
                 [storage, size] = __stack_alloc( create_size );
@@ -302 +301 @@
                 athrd->corctx_flag = false;
 
-                if(cor->state == Primed) {
+                if (cor->state == Primed) {
                         __cfactx_suspend();
                 }
@@ -317 +316 @@
 
 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 );
 }
 
@@ -328 +327 @@
 
 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 ){
+        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 ) ) {
                 ehm_cleanup ex_holder{ nl_ex->the_exception };
-        free( nl_ex );
-        __cfaehm_throw_resume( ex_holder.ex , defaultResumeAtHandler );
-        
-        nl_ex = pop_ehm_head( cor );
-    }
-    
-    return true;
+                free( nl_ex );
+                __cfaehm_throw_resume( ex_holder.ex , defaultResumeAtHandler );
+        }
+        
+        return true;
 }
 
@@ -354 +351 @@
 // 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; }
 }
 
@@ -371 +368 @@
 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 );
 }