Changeset 81ab5eb for libcfa/src/concurrency/channel.hfa

Timestamp:

Mar 29, 2026, 9:52:51 PM (5 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

File:

• libcfa/src/concurrency/channel.hfa (modified) (15 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 );