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

Timestamp:

Jan 21, 2021, 8:47:31 PM (3 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

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

Children:

ea561c9

Parents:

7d01186d

Message:

blocking_lock & multiple_acquisition_lock can now be used without libcfa-thread.
Doing so will have all functions be no-ops for these locks.
If libcfa-thread is linked in, these locks will behave as proper user-level locking.

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/locks.hfa"
-#include "bits/sequence.hfa"
-
-#include "invoke.h"
+#include "bits/weakso_locks.hfa"
 
 #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 ); }
 
 //-----------------------------------------------------------------------------
@@ -38 +79 @@
         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 );
 
 //-----------------------------------------------------------------------------