Changes in libcfa/src/concurrency/locks.hfa [ac5816d:797a193]

File:

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

libcfa/src/concurrency/locks.hfa

@@ -3 +3 @@
 #include <stdbool.h>
 
+#include "bits/algorithm.hfa"
 #include "bits/locks.hfa"
 #include "bits/sequence.hfa"
@@ -10 +11 @@
 #include "time_t.hfa"
 #include "time.hfa"
+#include <sys/time.h>
+#include "alarm.hfa"
 
-//-----------------------------------------------------------------------------
-// is_blocking_lock
+///////////////////////////////////////////////////////////////////
+//// is_blocking_lock
+///////////////////////////////////////////////////////////////////
+
 trait is_blocking_lock(dtype L | sized(L)) {
-        // For synchronization locks to use when acquiring
-        void on_notify( L &, struct $thread * );
-
-        // For synchronization locks to use when releasing
-        void on_wait( L & );
-
-        // to get recursion count for cond lock to reset after waking
-        size_t get_recursion_count( L & );
-
-        // to set recursion count after getting signalled;
-        void set_recursion_count( L &, size_t recursion );
+        void on_notify( L &, struct $thread * );                        // For synchronization locks to use when acquiring
+        void on_wait( 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;
 };
 
-//-----------------------------------------------------------------------------
-// info_thread
+///////////////////////////////////////////////////////////////////
+//// info_thread
+///////////////////////////////////////////////////////////////////
+
 // the info thread is a wrapper around a thread used
 // to store extra data for use in the condition variable
 forall(dtype L | is_blocking_lock(L)) {
-        struct info_thread;
+        struct info_thread {
+                inline Seqable;                                 // used to put info_thread on a dl queue (aka sequence)
+                struct $thread * t;                             // waiting thread
+                uintptr_t info;                                 // shadow field
+                L * lock;                                               // lock that is passed to wait() (if one is passed)
+                bool signalled;                                 // true when signalled and false when timeout wakes thread
+        };
+
+
+        void ?{}( info_thread(L) & this, $thread * t );
+        void ?{}( info_thread(L) & this, $thread * t, uintptr_t info );
+        void ^?{}( info_thread(L) & this );
 
         // for use by sequence
@@ -39 +50 @@
 }
 
-//-----------------------------------------------------------------------------
-// Blocking Locks
+///////////////////////////////////////////////////////////////////
+//// Blocking Locks
+///////////////////////////////////////////////////////////////////
+
 struct blocking_lock {
         // Spin lock used for mutual exclusion
@@ -76 +89 @@
 };
 
-void  ?{}( blocking_lock & this, bool multi_acquisition, bool strict_owner );
+void ?{}( blocking_lock & this, bool multi_acquisition, bool strict_owner );
 void ^?{}( blocking_lock & this );
 
-void  ?{}( single_acquisition_lock & this );
+void ?{}( single_acquisition_lock & this );
 void ^?{}( single_acquisition_lock & this );
 
-void  ?{}( owner_lock & this );
+void ?{}( owner_lock & this );
 void ^?{}( owner_lock & this );
 
-void  ?{}( multiple_acquisition_lock & this );
+void ?{}( multiple_acquisition_lock & this );
 void ^?{}( multiple_acquisition_lock & this );
 
@@ -118 +131 @@
 size_t get_recursion_count( multiple_acquisition_lock & this );
 
-//-----------------------------------------------------------------------------
-// Synchronization Locks
+///////////////////////////////////////////////////////////////////
+//// Synchronization Locks
+///////////////////////////////////////////////////////////////////
 forall(dtype L | is_blocking_lock(L)) {
         struct condition_variable {
@@ -132 +146 @@
         };
 
-        void  ?{}( condition_variable(L) & this );
+        void ?{}( condition_variable(L) & this );
         void ^?{}( condition_variable(L) & this );
+
+        struct alarm_node_wrap {
+                alarm_node_t alarm_node;
+
+                condition_variable(L) * cond;
+
+                info_thread(L) * i;
+        };
+
+        void ?{}( alarm_node_wrap(L) & this, Time alarm, Duration period, Alarm_Callback callback );
+        void ^?{}( alarm_node_wrap(L) & this );
+
+        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 );
@@ -140 +169 @@
         uintptr_t front( condition_variable(L) & this );
 
-        bool empty  ( condition_variable(L) & this );
-        int  counter( condition_variable(L) & this );
+        bool empty( condition_variable(L) & this );
+        int counter( condition_variable(L) & this );
 
         void wait( condition_variable(L) & this );