Changeset e50d9cb8 for libcfa/src

Timestamp:

Nov 1, 2022, 10:06:40 PM (3 years ago)

Author:

Peter A. Buhr <pabuhr@…>

Branches:

ADT, ast-experimental, master

Children:

7cf8006

Parents:

0bdfcc3 (diff), 03c56f6 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge branch 'master' of plg.uwaterloo.ca:software/cfa/cfa-cc

Location:

libcfa/src

Files:

• Makefile.am (modified) (1 diff)
• bits/defs.hfa (modified) (1 diff)
• concurrency/invoke.h (modified) (3 diffs)
• concurrency/kernel.hfa (modified) (1 diff)
• concurrency/kernel/startup.cfa (modified) (4 diffs)
• concurrency/once.hfa (added)
• concurrency/thread.cfa (modified) (1 diff)
• containers/lockfree.hfa (modified) (5 diffs)

libcfa/src/Makefile.am

@@ -111 +111 @@
         concurrency/invoke.h \
         concurrency/future.hfa \
+        concurrency/once.hfa \
         concurrency/kernel/fwd.hfa \
         concurrency/mutex_stmt.hfa

libcfa/src/bits/defs.hfa

@@ -31 +31 @@
 #define __cfa_anonymous_object(x) inline struct x
 #define __cfa_dlink1(x) dlink(x)
+#define __cfa_dlink2(x, name) inline struct name { inline dlink(x); }
 #else
 #define __cfa_anonymous_object(x) struct x __cfa_anonymous_object
 #define __cfa_dlink1(x) struct { struct x * next; struct x * back; }
+#define __cfa_dlink2(x, name) struct { struct x * next; struct x * back; } __dlink ## name
 #endif
 

libcfa/src/concurrency/invoke.h

@@ -195 +195 @@
                 struct __monitor_group_t monitors;
 
-                // used to put threads on dlist data structure
+                // intrusive link fields, used for locks, monitors and any user defined data structure
+                // default link fields for dlist
                 __cfa_dlink1(thread$) user_link;
 
-                struct {
-                        struct thread$ * next;
-                        struct thread$ * prev;
-                } node;
+                // secondary intrusive link fields, used for global cluster list
+                // default link fields for dlist
+                __cfa_dlink2(thread$, cltr_link);
 
                 // used to store state between clh lock/unlock
@@ -230 +230 @@
         #ifdef __cforall
         extern "Cforall" {
+                static inline thread$ * volatile & ?`next ( thread$ * this ) {
+                        return this->user_link.next;
+                }
 
                 static inline thread$ *& get_next( thread$ & this ) __attribute__((const)) {
                         return this.user_link.next;
-                }
-
-                static inline [thread$ *&, thread$ *& ] __get( thread$ & this ) __attribute__((const)) {
-                        return this.node.[next, prev];
                 }
 
@@ -244 +243 @@
                         return result;
                 }
+
+                P9_EMBEDDED(thread$, thread$.cltr_link)
+                P9_EMBEDDED(thread$.cltr_link, dlink(thread$))
 
                 static inline void ?{}(__monitor_group_t & this) {

libcfa/src/concurrency/kernel.hfa

@@ -256 +256 @@
         // List of threads
         __spinlock_t thread_list_lock;
-        __dllist_t(struct thread$) threads;
+        dlist(struct thread$, thread$.cltr_link) threads;
         unsigned int nthreads;
 

libcfa/src/concurrency/kernel/startup.cfa

@@ -535 +535 @@
         #endif
 
-        node.next = 0p;
-        node.prev = 0p;
         doregister(curr_cluster, this);
 
@@ -659 +657 @@
         #endif
 
-        threads{ __get };
+        threads{};
 
         io.arbiter = create();
@@ -739 +737 @@
         lock      (cltr->thread_list_lock __cfaabi_dbg_ctx2);
         cltr->nthreads += 1;
-        push_front(cltr->threads, thrd);
+        insert_first(cltr->threads, thrd);
         unlock    (cltr->thread_list_lock);
 }
@@ -745 +743 @@
 void unregister( cluster * cltr, thread$ & thrd ) {
         lock  (cltr->thread_list_lock __cfaabi_dbg_ctx2);
-        remove(cltr->threads, thrd );
-        cltr->nthreads -= 1;
+        {
+                tytagref( dlink(thread$), dlink(thread$) ) ?`inner( thread$ & this ) = void;
+                with( DLINK_VIA( thread$, thread$.cltr_link ) )
+                        remove( thrd );
+                cltr->nthreads -= 1;
+        }
         unlock(cltr->thread_list_lock);
 }

libcfa/src/concurrency/thread.cfa

@@ -54 +54 @@
         #endif
 
-        node.next = 0p;
-        node.prev = 0p;
-
         clh_node = malloc( );
         *clh_node = false;

libcfa/src/containers/lockfree.hfa

@@ -142 +142 @@
 
         static inline void ?{}(poison_list(T) & this) { this.head = 0p; }
+        static inline bool is_poisoned( const poison_list(T) & this ) { return 1p == this.head; }
 
         static inline forall(| { T * volatile & ?`next ( T * ); })
@@ -147 +148 @@
                 // Adds an element to the list
                 // Multi-Thread Safe, Lock-Free
-                T * push(poison_list(T) & this, T * elem) __attribute__((artificial));
-                T * push(poison_list(T) & this, T * elem) {
+                bool push(poison_list(T) & this, T * elem) __attribute__((artificial));
+                bool push(poison_list(T) & this, T * elem) {
                         /* paranoid */ verify(0p == (elem`next));
                         __atomic_store_n( &elem`next, (T*)1p, __ATOMIC_RELAXED );
@@ -156 +157 @@
                         for() {
                                 // check if it's poisoned
-                                if(expected == 1p) return 0p;
+                                if(expected == 1p) return false;
 
                                 // try to CAS the elem in
@@ -162 +163 @@
                                         // We managed to exchange in, we are done
 
-                                        // We should never succeed the CAS if it's poisonned.
-                                        /* paranoid */ verify( expected != 1p );
+                                        // We should never succeed the CAS if it's poisonned and the elem should be 1p.
+                                        /* paranoid */ verify( expected  != 1p );
+                                        /* paranoid */ verify( elem`next == 1p );
 
                                         // If we aren't the first, we need to tell the person before us
                                         // No need to
                                         elem`next = expected;
-                                        return expected;
+                                        return true;
                                 }
                         }
@@ -190 +192 @@
                 T * poison(poison_list(T) & this) {
                         T * ret = __atomic_exchange_n( &this.head, (T*)1p, __ATOMIC_SEQ_CST );
-                        /* paranoid */ verify( ret != (T*)1p );
+                        /* paranoid */ verifyf( ret != (T*)1p, "Poison list %p poisoned more than once!", &this );
                         return ret;
                 }