Changes in libcfa/src/concurrency/pthread.cfa [555af62:9d47c1f]

File:

• libcfa/src/concurrency/pthread.cfa (modified) (8 diffs)

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 );