Changeset 9d47c1f for libcfa

Timestamp:

Sep 6, 2023, 3:44:03 PM (16 months ago)

Author:

caparsons <caparson@…>

Branches:

master

Children:

cb0bcf1

Parents:

92d8cda

Message:

changes over all usages of uC++ collections to use dlist instead

Location:

libcfa/src/concurrency

Files:

• io.cfa (modified) (5 diffs)
• io/types.hfa (modified) (3 diffs)
• pthread.cfa (modified) (8 diffs)

libcfa/src/concurrency/io.cfa

@@ -594 +594 @@
                 lock( queue.lock __cfaabi_dbg_ctx2 );
                 {
-                        was_empty = empty(queue.queue);
+                        was_empty = queue.queue`isEmpty;
 
                         // Add our request to the list
-                        add( queue.queue, item );
+                        insert_last( queue.queue, item );
 
                         // Mark as pending
@@ -632 +632 @@
         // notify the arbiter that new allocations are available
         static void __ioarbiter_notify( io_arbiter$ & this, io_context$ * ctx ) {
-                /* paranoid */ verify( !empty(this.pending.queue) );
+                /* paranoid */ verify( !this.pending.queue`isEmpty );
                 /* 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( !empty(this.pending.queue) ) {
+                        while( !this.pending.queue`isEmpty ) {
                                 // get first pending allocs
                                 __u32 have = ctx->sq.free_ring.tail - ctx->sq.free_ring.head;
-                                __pending_alloc & pa = (__pending_alloc&)head( this.pending.queue );
+                                __pending_alloc & pa = (__pending_alloc&)(this.pending.queue`first);
 
                                 // check if we have enough to satisfy the request
@@ -651 +651 @@
 
                                 // if there are enough allocations it means we can drop the request
-                                drop( this.pending.queue );
+                                try_pop_front( this.pending.queue );
 
                                 /* paranoid */__attribute__((unused)) bool ret =
@@ -727 +727 @@
                         // pop each operation one at a time.
                         // There is no wait morphing because of the io sq ring
-                        while( !empty(ctx.ext_sq.queue) ) {
+                        while( !ctx.ext_sq.queue`isEmpty ) {
                                 // drop the element from the queue
-                                __external_io & ei = (__external_io&)drop( ctx.ext_sq.queue );
+                                __external_io & ei = (__external_io&)try_pop_front( ctx.ext_sq.queue );
 
                                 // submit it

libcfa/src/concurrency/io/types.hfa

@@ -24 +24 @@
 
 #include "bits/locks.hfa"
-#include "bits/queue.hfa"
 #include "iofwd.hfa"
 #include "kernel/fwd.hfa"
 
 #if defined(CFA_HAVE_LINUX_IO_URING_H)
-        #include "bits/sequence.hfa"
         #include "monitor.hfa"
 
@@ -120 +118 @@
         struct __outstanding_io {
                 // intrusive link fields
-                inline Colable;
+                inline dlink(__outstanding_io);
 
                 // primitive on which to block until the io is processed
                 oneshot waitctx;
         };
-        static inline __outstanding_io *& Next( __outstanding_io * n ) { return (__outstanding_io *)Next( (Colable *)n ); }
+    P9_EMBEDDED( __outstanding_io, dlink(__outstanding_io) )
 
         // queue of operations that are outstanding
@@ -134 +132 @@
 
                 // the actual queue
-                Queue(__outstanding_io) queue;
+                dlist(__outstanding_io) queue;
 
                 // volatile used to avoid the need for taking the lock if it's empty

libcfa/src/concurrency/pthread.cfa

@@ -20 +20 @@
 #include <errno.h>
 #include "locks.hfa"
-#include "bits/stack.hfa"
-#include "bits/sequence.hfa"
-
 
 #define check_nonnull(x) asm("": "+rm"(x)); if( x == 0p ) return EINVAL;
@@ -34 +31 @@
 
 struct pthread_values{
-        inline Seqable;
+        inline dlink(pthread_values);
         void * value;
         bool in_use;
 };
-
-static inline {
-        pthread_values *& Back( pthread_values * n ) {
-                return (pthread_values *)Back( (Seqable *)n );
-        }
-
-        pthread_values *& Next( pthread_values * n ) {
-                return (pthread_values *)Next( (Colable *)n );
-        }
-}
+P9_EMBEDDED( pthread_values, dlink(pthread_values) )
 
 struct pthread_keys {
         bool in_use;
         void (* destructor)( void * );
-        Sequence(pthread_values) threads;
+    dlist( pthread_values ) threads;
 };
 
@@ -78 +66 @@
 
 struct Pthread_kernel_threads{
-        inline Colable;
+        inline dlink(Pthread_kernel_threads);
         processor p;
 };
-
-Pthread_kernel_threads *& Next( Pthread_kernel_threads * n ) {
-        return (Pthread_kernel_threads *)Next( (Colable *)n );
-}
-
-static Stack(Pthread_kernel_threads) cfa_pthreads_kernel_threads;
+P9_EMBEDDED( Pthread_kernel_threads, dlink(Pthread_kernel_threads) )
+
+static dlist(Pthread_kernel_threads) cfa_pthreads_kernel_threads;
 static bool cfa_pthreads_kernel_threads_zero = false;   // set to zero ?
 static int cfa_pthreads_no_kernel_threads = 1;  // number of kernel threads
@@ -231 +216 @@
                                         key = &cfa_pthread_keys[i];
                                         value->in_use = false;
-                                        remove(key->threads, *value);
+                                        remove(*value);
+
                                         // if  a  key  value  has  a  non-NULL  destructor pointer,  and  the  thread  has  a  non-NULL  value associated with that key,
                                         // the value of the key is set to NULL, and then the function pointed to is called with the previously associated value as its sole argument.
@@ -551 +537 @@
 
                 // Remove key from all threads with a value.
-                pthread_values& p;
-                Sequence(pthread_values)& head = cfa_pthread_keys[key].threads;
-                for ( SeqIter(pthread_values) iter = { head }; iter | p; ) {
-                        remove(head, p);
-                        p.in_use = false;
-                }
+                
+                // Sequence(pthread_values)& head = cfa_pthread_keys[key].threads;
+                // for ( SeqIter(pthread_values) iter = { head }; iter | p; ) {
+                //      remove(head, p);
+                //      p.in_use = false;
+                // }
+        pthread_values * p = &try_pop_front( cfa_pthread_keys[key].threads );
+        for ( ; p; ) {            
+            p->in_use = false;
+            p = &try_pop_front( cfa_pthread_keys[key].threads );
+        }
                 unlock(key_lock);
                 return 0;
@@ -585 +576 @@
                 if ( ! entry.in_use ) {
                         entry.in_use = true;
-                        add(cfa_pthread_keys[key].threads, entry);
+                        insert_last(cfa_pthread_keys[key].threads, entry);
                 } // if
                 entry.value = (void *)value;
@@ -612 +603 @@
         //######################### Parallelism #########################
         void pthread_delete_kernel_threads_() __THROW { // see uMain::~uMain
-                Pthread_kernel_threads& p;
-                for ( StackIter(Pthread_kernel_threads) iter = {cfa_pthreads_kernel_threads}; iter | p; ) {
-                        delete(&p);
+                Pthread_kernel_threads * p = &try_pop_front(cfa_pthreads_kernel_threads);
+                for ( ; p; ) {
+            delete(p);
+                        p = &try_pop_front(cfa_pthreads_kernel_threads);
                 } // for
         } // pthread_delete_kernel_threads_
@@ -631 +623 @@
                 lock( concurrency_lock );
                 for ( ; new_level > cfa_pthreads_no_kernel_threads; cfa_pthreads_no_kernel_threads += 1 ) { // add processors ?
-                        push(cfa_pthreads_kernel_threads, *new() );
+                        insert_last(cfa_pthreads_kernel_threads, *new() );
                 } // for
                 for ( ; new_level < cfa_pthreads_no_kernel_threads; cfa_pthreads_no_kernel_threads -= 1 ) { // remove processors ?
-                        delete(&pop(cfa_pthreads_kernel_threads));
+                        delete(&try_pop_front(cfa_pthreads_kernel_threads));
                 } // for
                 unlock( concurrency_lock );