Changeset ae06e0b for libcfa/src/concurrency/locks.hfa

Timestamp:

Jun 8, 2022, 4:23:08 PM (23 months ago)

Author:

caparsons <caparson@…>

Branches:

ADT, ast-experimental, master, pthread-emulation, qualifiedEnum

Children:

55422cf

Parents:

ced5e2a

Message:

added pthread_cond_var

File:

• libcfa/src/concurrency/locks.hfa (modified) (4 diffs)

libcfa/src/concurrency/locks.hfa

@@ -366 +366 @@
 static inline void ?=?( simple_owner_lock & this, simple_owner_lock this2 ) = void;
 
+static inline void lock(simple_owner_lock & this) with(this) {
+        if (owner == active_thread()) {
+                recursion_count++;
+                return;
+        }
+        lock( lock __cfaabi_dbg_ctx2 );
+
+        if (owner != 0p) {
+                insert_last( blocked_threads, *active_thread() );
+                unlock( lock );
+                park( );
+                return;
+        }
+        owner = active_thread();
+        recursion_count = 1;
+        unlock( lock );
+}
+
+// TODO: fix duplicate def issue and bring this back
+// void pop_and_set_new_owner( simple_owner_lock & this ) with( this ) {
+        // thread$ * t = &try_pop_front( blocked_threads );
+        // owner = t;
+        // recursion_count = ( t ? 1 : 0 );
+        // unpark( t );
+// }
+
+static inline void unlock(simple_owner_lock & this) with(this) {
+        lock( lock __cfaabi_dbg_ctx2 );
+        /* paranoid */ verifyf( owner != 0p, "Attempt to release lock %p that isn't held", &this );
+        /* paranoid */ verifyf( owner == active_thread(), "Thread %p other than the owner %p attempted to release owner lock %p", owner, active_thread(), &this );
+        // if recursion count is zero release lock and set new owner if one is waiting
+        recursion_count--;
+        if ( recursion_count == 0 ) {
+                // pop_and_set_new_owner( this );
+                thread$ * t = &try_pop_front( blocked_threads );
+                owner = t;
+                recursion_count = ( t ? 1 : 0 );
+                unpark( t );
+        }
+        unlock( lock );
+}
+
+static inline void on_notify(simple_owner_lock & this, struct thread$ * t ) with(this) {
+        lock( lock __cfaabi_dbg_ctx2 );
+        // lock held
+        if ( owner != 0p ) {
+                insert_last( blocked_threads, *t );
+                unlock( lock );
+        }
+        // lock not held
+        else {
+                owner = t;
+                recursion_count = 1;
+                unpark( t );
+                unlock( lock );
+        }
+}
+
+static inline size_t on_wait(simple_owner_lock & this) with(this) { 
+        lock( lock __cfaabi_dbg_ctx2 );
+        /* paranoid */ verifyf( owner != 0p, "Attempt to release lock %p that isn't held", &this );
+        /* paranoid */ verifyf( owner == active_thread(), "Thread %p other than the owner %p attempted to release owner lock %p", owner, active_thread(), &this );
+
+        size_t ret = recursion_count;
+
+        // pop_and_set_new_owner( this );
+
+        thread$ * t = &try_pop_front( blocked_threads );
+        owner = t;
+        recursion_count = ( t ? 1 : 0 );
+        unpark( t );
+
+        unlock( lock );
+        return ret;
+}
+
+static inline void on_wakeup(simple_owner_lock & this, size_t recursion ) with(this) { recursion_count = recursion; }
+
 //-----------------------------------------------------------------------------
 // Spin Queue Lock
@@ -606 +684 @@
         // - signalling without holding branded lock is UNSAFE!
         // - only allows usage of one lock, cond var is branded after usage
+
         struct fast_cond_var {
                 // List of blocked threads
                 dlist( info_thread(L) ) blocked_threads;
-
                 #ifdef __CFA_DEBUG__
                 L * lock_used;
@@ -615 +693 @@
         };
 
-
         void  ?{}( fast_cond_var(L) & this );
         void ^?{}( fast_cond_var(L) & this );
@@ -623 +700 @@
 
         uintptr_t front( fast_cond_var(L) & this );
-
         bool empty  ( fast_cond_var(L) & this );
 
         void wait( fast_cond_var(L) & this, L & l );
         void wait( fast_cond_var(L) & this, L & l, uintptr_t info );
-}
+
+
+        //-----------------------------------------------------------------------------
+        // pthread_cond_var
+        //
+        // - cond var with minimal footprint
+        // - supports operations needed for phthread cond
+
+        struct pthread_cond_var {
+                dlist( info_thread(L) ) blocked_threads;
+                __spinlock_t lock;
+        };
+
+        void  ?{}( pthread_cond_var(L) & this );
+        void ^?{}( pthread_cond_var(L) & this );
+
+        bool notify_one( pthread_cond_var(L) & this );
+        bool notify_all( pthread_cond_var(L) & this );
+
+        uintptr_t front( pthread_cond_var(L) & this );
+        bool empty ( pthread_cond_var(L) & this );
+
+        void wait( pthread_cond_var(L) & this, L & l );
+        void wait( pthread_cond_var(L) & this, L & l, uintptr_t info );
+        bool wait( pthread_cond_var(L) & this, L & l, timespec t );
+        bool wait( pthread_cond_var(L) & this, L & l, uintptr_t info, timespec t );
+}