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

Timestamp:

Nov 5, 2020, 3:32:05 PM (4 years ago)

Author:

Colby Alexander Parsons <caparsons@…>

Branches:

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

Children:

c5bbb9b

Parents:

c28ea4e

Message:

added full timeout functionality to unified condition variables

File:

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

libcfa/src/concurrency/locks.hfa

@@ -10 +10 @@
 #include "time.hfa"
 #include <sys/time.h>
+#include "alarm.hfa"
 
 ///////////////////////////////////////////////////////////////////
@@ -32 +33 @@
                 info_thread(L) * next;
                 L * lock;
+                bool listed;                                    // true if info_thread is on queue, false otherwise;
         };
 
@@ -119 +121 @@
 ///////////////////////////////////////////////////////////////////
 forall(dtype L | is_blocking_lock(L)) {
-        struct synchronization_lock {
+        struct condition_variable {
                 // Spin lock used for mutual exclusion
                 __spinlock_t lock;
@@ -128 +130 @@
                 // Count of current blocked threads
                 int count;
-
-                // If true threads will reacquire the lock they block on upon waking
-                bool reacquire_after_signal;
         };
-
-        struct condition_variable {
-                inline synchronization_lock(L);
-        };
-
-        struct thread_queue {
-                inline synchronization_lock(L);
-        };
-
-
-        void ?{}( synchronization_lock(L) & this, bool multi_acquisition, bool strict_owner );
-        void ^?{}( synchronization_lock(L) & this );
 
         void ?{}( condition_variable(L) & this );
         void ^?{}( condition_variable(L) & this );
 
-        void ?{}( thread_queue(L) & this );
-        void ^?{}( thread_queue(L) & this );
+        struct alarm_node_wrap {
+                alarm_node_t alarm_node;
 
-        bool notify_one( synchronization_lock(L) & this );
-        bool notify_all( synchronization_lock(L) & this );
+                condition_variable(L) * cond;
 
-        uintptr_t front( synchronization_lock(L) & this );
-
-        bool empty( synchronization_lock(L) & this );
-        int counter( synchronization_lock(L) & this );
-
-        // wait functions that are not passed a mutex lock
-        void wait( synchronization_lock(L) & this );
-        void wait( synchronization_lock(L) & this, uintptr_t info );
-        bool wait( synchronization_lock(L) & this, Duration duration );
-        bool wait( synchronization_lock(L) & this, uintptr_t info, Duration duration );
-        bool wait( synchronization_lock(L) & this, Time time );
-        bool wait( synchronization_lock(L) & this, uintptr_t info, Time time );
-
-        // wait functions that are passed a lock
-        bool notify_one( synchronization_lock(L) & this, L & l );
-        bool notify_all( synchronization_lock(L) & this, L & l );
-
-        void wait( synchronization_lock(L) & this, L & l );
-        void wait( synchronization_lock(L) & this, L & l, uintptr_t info );
-        bool wait( synchronization_lock(L) & this, L & l, Duration duration );
-        bool wait( synchronization_lock(L) & this, L & l, uintptr_t info, Duration duration );
-        bool wait( synchronization_lock(L) & this, L & l, Time time );
-        bool wait( synchronization_lock(L) & this, L & l, uintptr_t info, Time time );
-}
-
-///////////////////////////////////////////////////////////////////
-//// condition lock alternative approach
-///////////////////////////////////////////////////////////////////
-
-
-///////////////////////////////////////////////////////////////////
-//// is_simple_lock
-///////////////////////////////////////////////////////////////////
-
-trait is_simple_lock(dtype L | sized(L)) {
-        void lock( L & );               // For synchronization locks to use when acquiring
-        void unlock( L & );    // For synchronization locks to use when releasing
-        size_t get_recursion_count( L & ); // to get recursion count for cond lock to reset after waking
-        void set_recursion_count( L &, size_t recursion ); // to set recursion count after getting signalled;
-};
-
-forall(dtype L | is_simple_lock(L)) {
-        struct condition_lock {
-                // Spin lock used for mutual exclusion
-                mutex_lock m_lock;
-
-                condition_variable( mutex_lock ) c_var;
+                info_thread(L) ** i;
         };
 
-        void ?{}( condition_lock(L) & this );
-        void ^?{}( condition_lock(L) & this );
+        void ?{}( alarm_node_wrap(L) & this, $thread * thrd, Time alarm, Duration period, Alarm_Callback callback );
+        void ^?{}( alarm_node_wrap(L) & this );
 
-        bool notify_one( condition_lock(L) & this );
-        bool notify_all( condition_lock(L) & this );
-        void wait( condition_lock(L) & this, L & l );
+        void alarm_node_callback( alarm_node_wrap(L) & this );
+
+        void alarm_node_wrap_cast( alarm_node_t & a );
+
+        bool notify_one( condition_variable(L) & this );
+        bool notify_all( condition_variable(L) & this );
+
+        uintptr_t front( condition_variable(L) & this );
+
+        bool empty( condition_variable(L) & this );
+        int counter( condition_variable(L) & this );
+
+        // TODO: look into changing timout routines to return bool showing if signalled or woken by kernel
+        void wait( condition_variable(L) & this );
+        void wait( condition_variable(L) & this, uintptr_t info );
+        void wait( condition_variable(L) & this, Duration duration );
+        void wait( condition_variable(L) & this, uintptr_t info, Duration duration );
+        void wait( condition_variable(L) & this, Time time );
+        void wait( condition_variable(L) & this, uintptr_t info, Time time );
+
+        void wait( condition_variable(L) & this, L & l );
+        void wait( condition_variable(L) & this, L & l, uintptr_t info );
+        void wait( condition_variable(L) & this, L & l, Duration duration );
+        void wait( condition_variable(L) & this, L & l, uintptr_t info, Duration duration );
+        void wait( condition_variable(L) & this, L & l, Time time );
+        void wait( condition_variable(L) & this, L & l, uintptr_t info, Time time );
 }