Changes in libcfa/src/concurrency/locks.hfa [ab1b971:454f478]

File:

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

libcfa/src/concurrency/locks.hfa

@@ -1 @@
-//
-// Cforall Version 1.0.0 Copyright (C) 2021 University of Waterloo
-//
-// The contents of this file are covered under the licence agreement in the
-// file "LICENCE" distributed with Cforall.
-//
-// locks.hfa -- PUBLIC
-// Runtime locks that used with the runtime thread system.
-//
-// Author           : Colby Alexander Parsons
-// Created On       : Thu Jan 21 19:46:50 2021
-// Last Modified By :
-// Last Modified On :
-// Update Count     :
-//
-
 #pragma once
 
 #include <stdbool.h>
 
-#include "bits/weakso_locks.hfa"
+#include "bits/locks.hfa"
+#include "bits/sequence.hfa"
+
+#include "invoke.h"
 
 #include "time_t.hfa"
 #include "time.hfa"
-
-//----------
-struct single_acquisition_lock {
-        inline blocking_lock;
-};
-
-static inline void  ?{}( single_acquisition_lock & this ) {((blocking_lock &)this){ false, false };}
-static inline void ^?{}( single_acquisition_lock & this ) {}
-static inline void   lock      ( single_acquisition_lock & this ) { lock   ( (blocking_lock &)this ); }
-static inline void   unlock    ( single_acquisition_lock & this ) { unlock ( (blocking_lock &)this ); }
-static inline void   on_wait   ( single_acquisition_lock & this ) { on_wait( (blocking_lock &)this ); }
-static inline void   on_notify ( single_acquisition_lock & this, struct $thread * t ) { on_notify( (blocking_lock &)this, t ); }
-static inline void   set_recursion_count( single_acquisition_lock & this, size_t recursion ) { set_recursion_count( (blocking_lock &)this, recursion ); }
-static inline size_t get_recursion_count( single_acquisition_lock & this ) { return get_recursion_count( (blocking_lock &)this ); }
-
-//----------
-struct owner_lock {
-        inline blocking_lock;
-};
-
-static inline void  ?{}( owner_lock & this ) {((blocking_lock &)this){ true, true };}
-static inline void ^?{}( owner_lock & this ) {}
-static inline void   lock     ( owner_lock & this ) { lock   ( (blocking_lock &)this ); }
-static inline void   unlock   ( owner_lock & this ) { unlock ( (blocking_lock &)this ); }
-static inline void   on_wait  ( owner_lock & this ) { on_wait( (blocking_lock &)this ); }
-static inline void   on_notify( owner_lock & this, struct $thread * t ) { on_notify( (blocking_lock &)this, t ); }
-static inline void   set_recursion_count( owner_lock & this, size_t recursion ) { set_recursion_count( (blocking_lock &)this, recursion ); }
-static inline size_t get_recursion_count( owner_lock & this ) { return get_recursion_count( (blocking_lock &)this ); }
 
 //-----------------------------------------------------------------------------
@@ -79 +38 @@
         info_thread(L) *& Next( info_thread(L) * this );
 }
+
+//-----------------------------------------------------------------------------
+// Blocking Locks
+struct blocking_lock {
+        // Spin lock used for mutual exclusion
+        __spinlock_t lock;
+
+        // List of blocked threads
+        Sequence( $thread ) blocked_threads;
+
+        // Count of current blocked threads
+        size_t wait_count;
+
+        // Flag if the lock allows multiple acquisition
+        bool multi_acquisition;
+
+        // Flag if lock can be released by non owner
+        bool strict_owner;
+
+        // Current thread owning the lock
+        struct $thread * owner;
+
+        // Number of recursion level
+        size_t recursion_count;
+};
+
+struct single_acquisition_lock {
+        inline blocking_lock;
+};
+
+struct owner_lock {
+        inline blocking_lock;
+};
+
+struct multiple_acquisition_lock {
+        inline blocking_lock;
+};
+
+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  ?{}( owner_lock & this );
+void ^?{}( owner_lock & this );
+
+void  ?{}( multiple_acquisition_lock & this );
+void ^?{}( multiple_acquisition_lock & this );
+
+void lock( blocking_lock & this );
+bool try_lock( blocking_lock & this );
+void unlock( 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 );
+size_t get_recursion_count( blocking_lock & this );
+
+void lock( single_acquisition_lock & this );
+void unlock( 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 );
+
+void lock( owner_lock & this );
+void unlock( 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 );
+
+void lock( multiple_acquisition_lock & this );
+void unlock( 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 );
 
 //-----------------------------------------------------------------------------