Changeset 797a193 for libcfa/src/concurrency/locks.hfa

Timestamp:

Dec 22, 2020, 12:50:46 PM (2 years ago)

Author:

caparsons <caparson@…>

Branches:

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

Children:

26a249c, 302ef2a

Parents:

fe97de26

Message:

cleaned up locks code and added comments

File:

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

libcfa/src/concurrency/locks.hfa

@@ -6 +6 @@
 #include "bits/locks.hfa"
 #include "bits/sequence.hfa"
-#include "bits/containers.hfa"
 
 #include "invoke.h"
@@ -20 +19 @@
 
 trait is_blocking_lock(dtype L | sized(L)) {
-        void add_( L &, struct $thread * );             // For synchronization locks to use when acquiring
-        void remove_( 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;
+        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;
 };
 
@@ -30 +29 @@
 ///////////////////////////////////////////////////////////////////
 
+// 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 {
-                inline Seqable;
-                struct $thread * t;
-                uintptr_t info;
-                L * lock;
+                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
         };
@@ -44 +45 @@
         void ^?{}( info_thread(L) & this );
 
+        // for use by sequence
         info_thread(L) *& Back( info_thread(L) * this );
         info_thread(L) *& Next( info_thread(L) * this );
@@ -102 +104 @@
 bool try_lock( blocking_lock & this );
 void unlock( blocking_lock & this );
-void add_( blocking_lock & this, struct $thread * t );
-void remove_( blocking_lock & this );
+void on_notify( blocking_lock & this, struct $thread * t );
+void on_wait( blocking_lock & this );
 size_t wait_count( blocking_lock & this );
 void set_recursion_count( blocking_lock & this, size_t recursion );
@@ -110 +112 @@
 void lock( single_acquisition_lock & this );
 void unlock( single_acquisition_lock & this );
-void add_( single_acquisition_lock & this, struct $thread * t );
-void remove_( single_acquisition_lock & this );
+void on_notify( single_acquisition_lock & this, struct $thread * t );
+void on_wait( single_acquisition_lock & this );
 void set_recursion_count( single_acquisition_lock & this, size_t recursion );
 size_t get_recursion_count( single_acquisition_lock & this );
@@ -117 +119 @@
 void lock( owner_lock & this );
 void unlock( owner_lock & this );
-void add_( owner_lock & this, struct $thread * t );
-void remove_( owner_lock & this );
+void on_notify( owner_lock & this, struct $thread * t );
+void on_wait( owner_lock & this );
 void set_recursion_count( owner_lock & this, size_t recursion );
 size_t get_recursion_count( owner_lock & this );
@@ -124 +126 @@
 void lock( multiple_acquisition_lock & this );
 void unlock( multiple_acquisition_lock & this );
-void add_( multiple_acquisition_lock & this, struct $thread * t );
-void remove_( multiple_acquisition_lock & this );
+void on_notify( multiple_acquisition_lock & this, struct $thread * t );
+void on_wait( multiple_acquisition_lock & this );
 void set_recursion_count( multiple_acquisition_lock & this, size_t recursion );
 size_t get_recursion_count( multiple_acquisition_lock & this );
@@ -136 +138 @@
                 // Spin lock used for mutual exclusion
                 __spinlock_t lock;
-
-                info_thread(L) * last_thread;
 
                 // List of blocked threads