Changeset 82f4063 for libcfa/src

Timestamp:

May 26, 2021, 10:38:19 AM (3 years ago)

Author:

caparsons <caparson@…>

Branches:

ADT, ast-experimental, enum, forall-pointer-decay, jacob/cs343-translation, master, new-ast-unique-expr, pthread-emulation, qualifiedEnum

Children:

bae0d35

Parents:

c65b930

Message:

switched unified locking to use dlist

Location:

libcfa/src

Files:

• bits/defs.hfa (modified) (1 diff)
• bits/weakso_locks.hfa (modified) (2 diffs)
• concurrency/invoke.h (modified) (4 diffs)
• concurrency/locks.cfa (modified) (11 diffs)
• concurrency/locks.hfa (modified) (4 diffs)

libcfa/src/bits/defs.hfa

@@ -31 +31 @@
 #ifdef __cforall
 #define __cfa_anonymous_object(x) inline struct x
+#define __cfa_dlink(x) inline dlink(x)
 #else
 #define __cfa_anonymous_object(x) struct x __cfa_anonymous_object
+#define __cfa_dlink(x) struct { struct x * next; struct x * back; } __dlink_substitute
 #endif
 

libcfa/src/bits/weakso_locks.hfa

@@ -21 +21 @@
 #include "bits/sequence.hfa"
 #include "bits/containers.hfa"
+#include "containers/list.hfa"
 
 struct $thread;
@@ -31 +32 @@
 
         // List of blocked threads
-        Sequence( $thread ) blocked_threads;
+        dlist( $thread ) blocked_threads;
 
         // Count of current blocked threads

libcfa/src/concurrency/invoke.h

@@ -20 +20 @@
 
 #ifdef __cforall
+#include "containers/list.hfa"
 extern "C" {
 #endif
@@ -196 +197 @@
                 } seqable;
 
+                // used to put threads on dlist data structure
+                __cfa_dlink($thread);
+
                 struct {
                         struct $thread * next;
@@ -207 +211 @@
                 #endif
         };
+        #ifdef __cforall
+                P9_EMBEDDED( $thread, dlink($thread) )
+        #endif
         // Wrapper for gdb
         struct cfathread_thread_t { struct $thread debug; };
@@ -236 +243 @@
 
                 static inline $thread *& Next( $thread * this ) __attribute__((const)) {
-                        return this->seqable.next;
+                                return this->seqable.next;
                 }
 

libcfa/src/concurrency/locks.cfa

@@ -27 +27 @@
 forall(L & | is_blocking_lock(L)) {
         struct info_thread {
-                // used to put info_thread on a dl queue (aka sequence)
-                inline Seqable;
+                // used to put info_thread on a dl queue
+                inline dlink(info_thread(L));
 
                 // waiting thread
@@ -42 +42 @@
                 bool signalled;
         };
+        P9_EMBEDDED( info_thread(L), dlink(info_thread(L)) )
 
         void ?{}( info_thread(L) & this, $thread * t, uintptr_t info, L * l ) {
-                ((Seqable &) this){};
                 this.t = t;
                 this.info = info;
@@ -51 +51 @@
 
         void ^?{}( info_thread(L) & this ) {}
-
-        info_thread(L) *& Back( info_thread(L) * this ) {
-                return (info_thread(L) *)Back( (Seqable *)this );
-        }
-
-        info_thread(L) *& Next( info_thread(L) * this ) {
-                return (info_thread(L) *)Next( (Colable *)this );
-        }
 }
 
@@ -85 +77 @@
         // lock is held by some other thread
         if ( owner != 0p && owner != thrd ) {
-                addTail( blocked_threads, *thrd );
+                insert_last( blocked_threads, *thrd );
                 wait_count++;
                 unlock( lock );
@@ -124 +116 @@
 
 void pop_and_set_new_owner( blocking_lock & this ) with( this ) {
-        $thread * t = &dropHead( blocked_threads );
+        $thread * t = &try_pop_front( blocked_threads );
         owner = t;
         recursion_count = ( t ? 1 : 0 );
@@ -153 +145 @@
         // lock held
         if ( owner != 0p ) {
-                addTail( blocked_threads, *t );
+                insert_last( blocked_threads, *t );
                 wait_count++;
                 unlock( lock );
@@ -206 +198 @@
                 //      may still be called after a thread has been removed from the queue but
                 //      before the alarm is unregistered
-                if ( listed(info_thd) ) {       // is thread on queue
+                if ( (*info_thd)`isListed ) {   // is thread on queue
                         info_thd->signalled = false;
                         // remove this thread O(1)
-                        remove( cond->blocked_threads, *info_thd );
+                        remove( *info_thd );
                         cond->count--;
                         if( info_thd->lock ) {
@@ -254 +246 @@
         bool notify_one( condition_variable(L) & this ) with( this ) {
                 lock( lock __cfaabi_dbg_ctx2 );
-                bool ret = !empty(blocked_threads);
-                process_popped(this, dropHead( blocked_threads ));
+                bool ret = ! blocked_threads`isEmpty;
+                process_popped(this, try_pop_front( blocked_threads ));
                 unlock( lock );
                 return ret;
@@ -262 +254 @@
         bool notify_all( condition_variable(L) & this ) with(this) {
                 lock( lock __cfaabi_dbg_ctx2 );
-                bool ret = !empty(blocked_threads);
-                while( !empty(blocked_threads) ) {
-                        process_popped(this, dropHead( blocked_threads ));
+                bool ret = ! blocked_threads`isEmpty;
+                while( ! blocked_threads`isEmpty ) {
+                        process_popped(this, try_pop_front( blocked_threads ));
                 }
                 unlock( lock );
@@ -271 +263 @@
 
         uintptr_t front( condition_variable(L) & this ) with(this) {
-                return empty(blocked_threads) ? NULL : head(blocked_threads).info;
+                return blocked_threads`isEmpty ? NULL : blocked_threads`first.info;
         }
 
         bool empty( condition_variable(L) & this ) with(this) {
                 lock( lock __cfaabi_dbg_ctx2 );
-                bool ret = empty(blocked_threads);
+                bool ret = blocked_threads`isEmpty;
                 unlock( lock );
                 return ret;
@@ -285 +277 @@
         size_t queue_and_get_recursion( condition_variable(L) & this, info_thread(L) * i ) with(this) {
                 // add info_thread to waiting queue
-                addTail( blocked_threads, *i );
+                insert_last( blocked_threads, *i );
                 count++;
                 size_t recursion_count = 0;

libcfa/src/concurrency/locks.hfa

@@ -21 +21 @@
 #include "bits/weakso_locks.hfa"
 #include "containers/queueLockFree.hfa"
+#include "containers/list.hfa"
 
 #include "thread.hfa"
@@ -40 +41 @@
 
 static inline bool P(Semaphore0nary & this, $thread * thrd) {
-        /* paranoid */ verify(!(thrd->seqable.next));
-        /* paranoid */ verify(!(thrd`next));
+        /* paranoid */ verify(!thrd`next);
+        /* paranoid */ verify(!(&(*thrd)`next));
 
         push(this.queue, thrd);
@@ -250 +251 @@
 
 //-----------------------------------------------------------------------------
-// info_thread
-// the info thread is a wrapper around a thread used
-// to store extra data for use in the condition variable
+// // info_thread
+// // the info thread is a wrapper around a thread used
+// // to store extra data for use in the condition variable
 forall(L & | is_blocking_lock(L)) {
         struct info_thread;
 
-        // for use by sequence
-        info_thread(L) *& Back( info_thread(L) * this );
-        info_thread(L) *& Next( info_thread(L) * this );
+        // // for use by sequence
+        // info_thread(L) *& Back( info_thread(L) * this );
+        // info_thread(L) *& Next( info_thread(L) * this );
 }
 
@@ -269 +270 @@
 
                 // List of blocked threads
-                Sequence( info_thread(L) ) blocked_threads;
+                dlist( info_thread(L) ) blocked_threads;
 
                 // Count of current blocked threads
                 int count;
         };
+        
 
         void  ?{}( condition_variable(L) & this );