Changeset 81ab5eb for libcfa/src/concurrency

Timestamp:

Mar 29, 2026, 9:52:51 PM (9 days ago)

Author:

Peter A. Buhr <pabuhr@…>

Branches:

master

Children:

e6e250d

Parents:

00675ed4

Message:

2nd attempt at harmonizing isOp functions, e.g., isEmpty, to C/C++ form empty

Location:

libcfa/src/concurrency

Files:

• channel.hfa (modified) (15 diffs)
• cofor.hfa (modified) (1 diff)
• future.hfa (modified) (3 diffs)
• io.cfa (modified) (4 diffs)
• kernel.cfa (modified) (2 diffs)
• select.hfa (modified) (2 diffs)

libcfa/src/concurrency/channel.hfa

@@ -117 +117 @@
                 printf("Channel %p Producer Blocks: %lu,\tProducer Ops: %lu,\t%.2f%% of Producer ops blocked\n", &c, c_blocks, c_ops, ((double)c_blocks)/c_ops * 100);
             #endif
-                verifyf( __handle_waituntil_OR( cons ) || __handle_waituntil_OR( prods ) || isEmpty( cons ) && isEmpty( prods ), 
+                verifyf( __handle_waituntil_OR( cons ) || __handle_waituntil_OR( prods ) || empty( cons ) && empty( prods ), 
                                  "Attempted to delete channel with waiting threads (Deadlock).\n" );
                 if ( size != 0 ) delete( buffer );
@@ -123 +123 @@
         size_t get_count( channel(T) & chan ) with(chan) { return __atomic_load_n( &count, __ATOMIC_RELAXED ); }
         size_t get_size( channel(T) & chan ) with(chan) { return __atomic_load_n( &size, __ATOMIC_RELAXED ); }
-        bool has_waiters( channel(T) & chan ) with(chan) { return ! isEmpty( cons ) || ! isEmpty( prods ); }
-        bool has_waiting_consumers( channel(T) & chan ) with(chan) { return ! isEmpty( cons ); }
-        bool has_waiting_producers( channel(T) & chan ) with(chan) { return ! isEmpty( prods ); }
+        bool has_waiters( channel(T) & chan ) with(chan) { return ! empty( cons ) || ! empty( prods ); }
+        bool has_waiting_consumers( channel(T) & chan ) with(chan) { return ! empty( cons ); }
+        bool has_waiting_producers( channel(T) & chan ) with(chan) { return ! empty( prods ); }
 
         // closes the channel and notifies all blocked threads
@@ -164 +164 @@
         void flush( channel(T) & chan, T elem ) with(chan) {
                 lock( mutex_lock );
-                while ( count == 0 && ! isEmpty( cons ) ) {
+                while ( count == 0 && ! empty( cons ) ) {
                         __cons_handoff( chan, elem );
                 }
@@ -186 +186 @@
 
           ConsEmpty:
-                if ( ! isEmpty( cons ) ) {
+                if ( ! empty( cons ) ) {
                         if ( ! __handle_waituntil_OR( cons ) ) break ConsEmpty;
                         __cons_handoff( chan, elem );
@@ -233 +233 @@
                 // buffer count must be zero if cons are blocked (also handles zero-size case)
           ConsEmpty:
-                if ( ! isEmpty( cons ) ) {
+                if ( ! empty( cons ) ) {
                         if ( ! __handle_waituntil_OR( cons ) ) break ConsEmpty;
                         __cons_handoff( chan, elem );
@@ -261 +261 @@
                 count -= 1;
                 front = (front + 1) % size;
-                if (count == size - 1 && ! isEmpty( prods ) ) {
+                if (count == size - 1 && ! empty( prods ) ) {
                         if ( ! __handle_waituntil_OR( prods ) ) return;
                         __buf_insert( chan, *(T *)first( prods ).extra );  // do waiting producer work
@@ -276 +276 @@
 
           ZeroSize:
-                if ( size == 0 && ! isEmpty( prods ) ) {
+                if ( size == 0 && ! empty( prods ) ) {
                         if ( ! __handle_waituntil_OR( prods ) ) break ZeroSize;
                         __prods_handoff( chan, retval );
@@ -332 +332 @@
                 // have to check for the zero size channel case
           ZeroSize:
-                if ( size == 0 && ! isEmpty( prods ) ) {
+                if ( size == 0 && ! empty( prods ) ) {
                         if ( ! __handle_waituntil_OR( prods ) ) break ZeroSize;
                         __prods_handoff( chan, retval );
@@ -384 +384 @@
         // special case of __handle_waituntil_OR, that does some work to avoid starvation/deadlock case
         bool __handle_pending( dlist( select_node ) & queue, select_node & mine ) {
-            while ( ! isEmpty( queue ) ) {
+            while ( ! empty( queue ) ) {
                 // if node not a special OR case or if we win the special OR case race break
                 if ( ! first( queue ).clause_status || first( queue ).park_counter || __pending_set_other( first( queue ), mine, ((unsigned long int)(&(first( queue )))) ) )
@@ -421 +421 @@
             if ( ! node.park_counter ) {
                 // are we special case OR and front of cons is also special case OR
-                if ( ! unlikely(closed) && ! isEmpty( prods ) && first( prods ).clause_status && ! first( prods ).park_counter ) {
+                if ( ! unlikely(closed) && ! empty( prods ) && first( prods ).clause_status && ! first( prods ).park_counter ) {
                     if ( ! __make_select_node_pending( node ) ) {
                         unlock( mutex_lock );
@@ -437 +437 @@
                 }
                 // check if we can complete operation. If so race to establish winner in special OR case
-                if ( count != 0 || ! isEmpty( prods ) || unlikely(closed) ) {
+                if ( count != 0 || ! empty( prods ) || unlikely(closed) ) {
                     if ( ! __make_select_node_available( node ) ) { // we didn't win the race so give up on registering
                         unlock( mutex_lock );
@@ -453 +453 @@
             // have to check for the zero size channel case
             ZeroSize:
-                if ( size == 0 && ! isEmpty( prods ) ) {
+                if ( size == 0 && ! empty( prods ) ) {
                         if ( ! __handle_waituntil_OR( prods ) ) break ZeroSize;
                         __prods_handoff( *chan, *ret );
@@ -522 +522 @@
             if ( ! node.park_counter ) {
                 // are we special case OR and front of cons is also special case OR
-                if ( ! unlikely(closed) && ! isEmpty( cons ) && first( cons ).clause_status && ! first( cons ).park_counter ) {
+                if ( ! unlikely(closed) && ! empty( cons ) && first( cons ).clause_status && ! first( cons ).park_counter ) {
                     if ( ! __make_select_node_pending( node ) ) {
                         unlock( mutex_lock );
@@ -537 +537 @@
                         }
                         // check if we can complete operation. If so race to establish winner in special OR case
-                        if ( count != size || ! isEmpty( cons ) || unlikely(closed) ) {
+                        if ( count != size || ! empty( cons ) || unlikely(closed) ) {
                                 if ( ! __make_select_node_available( node ) ) { // we didn't win the race so give up on registering
                                         unlock( mutex_lock );
@@ -554 +554 @@
                 // handle blocked consumer case via handoff (buffer is implicitly empty)
     ConsEmpty:
-                if ( ! isEmpty( cons ) ) {
+                if ( ! empty( cons ) ) {
                         if ( ! __handle_waituntil_OR( cons ) ) break ConsEmpty;
                         __cons_handoff( *chan, elem );

libcfa/src/concurrency/cofor.hfa

@@ -33 +33 @@
 
 void main( cofor_runner & this ) with(this) {
-    while ( ! done || ! isEmpty( items ) ) {
+    while ( ! done || ! empty( items ) ) {
                 lock( mutex_lock );
         runner_node * node = &remove_first( items );

libcfa/src/concurrency/future.hfa

@@ -10 +10 @@
 // Created On       : Wed Jan 06 17:33:18 2021
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Mon Nov 24 16:08:52 2025
-// Update Count     : 222
+// Last Modified On : Sun Mar 29 21:13:04 2026
+// Update Count     : 223
 //
 
@@ -173 +173 @@
 
                 bool fulfil$( future(T) & fut ) with( fut ) {   // helper
-                        bool ret_val = ! isEmpty( waiters );
+                        bool ret_val = ! empty( waiters );
                         state = FUTURE_FULFILLED$;
-                        while ( ! isEmpty( waiters ) ) {
+                        while ( ! empty( waiters ) ) {
                                 if ( !__handle_waituntil_OR( waiters ) ) // handle special waituntil OR case
                                         break; // if handle_OR returns false then waiters is empty so break
@@ -211 +211 @@
                 void reset( future(T) & fut ) with( fut ) {             // mark future as empty (for reuse)
                         lock( lock );
-                  if ( ! isEmpty( waiters ) ) abort( "Attempting to reset a future with blocked waiters" );
+                  if ( ! empty( waiters ) ) abort( "Attempting to reset a future with blocked waiters" );
                         state = FUTURE_EMPTY$;
                         free( except );

libcfa/src/concurrency/io.cfa

@@ -594 +594 @@
                 lock( queue.lock __cfaabi_dbg_ctx2 );
                 {
-                        was_empty = isEmpty( queue.queue );
+                        was_empty = empty( queue.queue );
 
                         // Add our request to the list
@@ -632 +632 @@
         // notify the arbiter that new allocations are available
         static void __ioarbiter_notify( io_arbiter$ & this, io_context$ * ctx ) {
-                /* paranoid */ verify( ! isEmpty( this.pending.queue ) );
+                /* paranoid */ verify( ! empty( this.pending.queue ) );
                 /* paranoid */ verify( __preemption_enabled() );
 
@@ -642 +642 @@
                         // as long as there are pending allocations try to satisfy them
                         // for simplicity do it in FIFO order
-                        while( ! isEmpty( this.pending.queue ) ) {
+                        while( ! empty( this.pending.queue ) ) {
                                 // get first pending allocs
                                 __u32 have = ctx->sq.free_ring.tail - ctx->sq.free_ring.head;
@@ -727 +727 @@
                         // pop each operation one at a time.
                         // There is no wait morphing because of the io sq ring
-                        while( ! isEmpty( ctx.ext_sq.queue ) ) {
+                        while( ! empty( ctx.ext_sq.queue ) ) {
                                 // drop the element from the queue
                                 __external_io & ei = (__external_io&)remove_first( ctx.ext_sq.queue );

libcfa/src/concurrency/kernel.cfa

@@ -10 +10 @@
 // Created On       : Tue Jan 17 12:27:26 2017
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Apr 25 07:02:42 2025
-// Update Count     : 82
+// Last Modified On : Sun Mar 29 21:20:54 2026
+// Update Count     : 83
 //
 
@@ -785 +785 @@
                         // update the pointer to the head wait context
                         struct __fd_waitctx * wctx = 0;
-                        if ( ! isEmpty( this.idles )) wctx = &first( this. idles ).idle_wctx;
+                        if ( ! empty( this.idles )) wctx = &first( this. idles ).idle_wctx;
                         __atomic_store_n(&this.fdw, wctx, __ATOMIC_SEQ_CST);
                 }

libcfa/src/concurrency/select.hfa

@@ -11 +11 @@
 // Created On       : Thu Jan 21 19:46:50 2023
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sun Nov 23 22:38:36 2025
-// Update Count     : 8
+// Last Modified On : Sun Mar 29 21:12:52 2026
+// Update Count     : 9
 //
 
@@ -169 +169 @@
 // Returns true if execution can continue normally and false if the queue has now been drained
 static inline bool __handle_waituntil_OR( dlist( select_node ) & queue ) {
-        if ( isEmpty( queue ) ) return false;
+        if ( empty( queue ) ) return false;
         if ( first( queue ).clause_status && ! first( queue ).park_counter ) {
-                while ( ! isEmpty( queue ) ) {
+                while ( ! empty( queue ) ) {
                         // if node not a special OR case or if we win the special OR case race break
                         if ( ! first( queue ).clause_status || first( queue ).park_counter || __make_select_node_available( first( queue ) ) )