source: libcfa/src/concurrency/locks.hfa @ dafbde8

arm-ehjacob/cs343-translationnew-ast-unique-expr
Last change on this file since dafbde8 was fd54fef, checked in by Michael Brooks <mlbrooks@…>, 11 months ago

Converting the project to use the new syntax for otype, dtype and ttytpe.

Changed prelude (gen), libcfa and test suite to use it. Added a simple deprecation rule of the old syntax to the parser; we might wish to support both syntaxes "officially," like with an extra CLI switch, but this measure should serve as a simple reminder for our team to try the new syntax.

  • Property mode set to 100644
File size: 4.9 KB
Line 
1#pragma once
2
3#include <stdbool.h>
4
5#include "bits/locks.hfa"
6#include "bits/sequence.hfa"
7
8#include "invoke.h"
9
10#include "time_t.hfa"
11#include "time.hfa"
12
13//-----------------------------------------------------------------------------
14// is_blocking_lock
15trait is_blocking_lock(L & | sized(L)) {
16        // For synchronization locks to use when acquiring
17        void on_notify( L &, struct $thread * );
18
19        // For synchronization locks to use when releasing
20        void on_wait( L & );
21
22        // to get recursion count for cond lock to reset after waking
23        size_t get_recursion_count( L & );
24
25        // to set recursion count after getting signalled;
26        void set_recursion_count( L &, size_t recursion );
27};
28
29//-----------------------------------------------------------------------------
30// info_thread
31// the info thread is a wrapper around a thread used
32// to store extra data for use in the condition variable
33forall(L & | is_blocking_lock(L)) {
34        struct info_thread;
35
36        // for use by sequence
37        info_thread(L) *& Back( info_thread(L) * this );
38        info_thread(L) *& Next( info_thread(L) * this );
39}
40
41//-----------------------------------------------------------------------------
42// Blocking Locks
43struct blocking_lock {
44        // Spin lock used for mutual exclusion
45        __spinlock_t lock;
46
47        // List of blocked threads
48        Sequence( $thread ) blocked_threads;
49
50        // Count of current blocked threads
51        size_t wait_count;
52
53        // Flag if the lock allows multiple acquisition
54        bool multi_acquisition;
55
56        // Flag if lock can be released by non owner
57        bool strict_owner;
58
59        // Current thread owning the lock
60        struct $thread * owner;
61
62        // Number of recursion level
63        size_t recursion_count;
64};
65
66struct single_acquisition_lock {
67        inline blocking_lock;
68};
69
70struct owner_lock {
71        inline blocking_lock;
72};
73
74struct multiple_acquisition_lock {
75        inline blocking_lock;
76};
77
78void  ?{}( blocking_lock & this, bool multi_acquisition, bool strict_owner );
79void ^?{}( blocking_lock & this );
80
81void  ?{}( single_acquisition_lock & this );
82void ^?{}( single_acquisition_lock & this );
83
84void  ?{}( owner_lock & this );
85void ^?{}( owner_lock & this );
86
87void  ?{}( multiple_acquisition_lock & this );
88void ^?{}( multiple_acquisition_lock & this );
89
90void lock( blocking_lock & this );
91bool try_lock( blocking_lock & this );
92void unlock( blocking_lock & this );
93void on_notify( blocking_lock & this, struct $thread * t );
94void on_wait( blocking_lock & this );
95size_t wait_count( blocking_lock & this );
96void set_recursion_count( blocking_lock & this, size_t recursion );
97size_t get_recursion_count( blocking_lock & this );
98
99void lock( single_acquisition_lock & this );
100void unlock( single_acquisition_lock & this );
101void on_notify( single_acquisition_lock & this, struct $thread * t );
102void on_wait( single_acquisition_lock & this );
103void set_recursion_count( single_acquisition_lock & this, size_t recursion );
104size_t get_recursion_count( single_acquisition_lock & this );
105
106void lock( owner_lock & this );
107void unlock( owner_lock & this );
108void on_notify( owner_lock & this, struct $thread * t );
109void on_wait( owner_lock & this );
110void set_recursion_count( owner_lock & this, size_t recursion );
111size_t get_recursion_count( owner_lock & this );
112
113void lock( multiple_acquisition_lock & this );
114void unlock( multiple_acquisition_lock & this );
115void on_notify( multiple_acquisition_lock & this, struct $thread * t );
116void on_wait( multiple_acquisition_lock & this );
117void set_recursion_count( multiple_acquisition_lock & this, size_t recursion );
118size_t get_recursion_count( multiple_acquisition_lock & this );
119
120//-----------------------------------------------------------------------------
121// Synchronization Locks
122forall(L & | is_blocking_lock(L)) {
123        struct condition_variable {
124                // Spin lock used for mutual exclusion
125                __spinlock_t lock;
126
127                // List of blocked threads
128                Sequence( info_thread(L) ) blocked_threads;
129
130                // Count of current blocked threads
131                int count;
132        };
133
134        void  ?{}( condition_variable(L) & this );
135        void ^?{}( condition_variable(L) & this );
136
137        bool notify_one( condition_variable(L) & this );
138        bool notify_all( condition_variable(L) & this );
139
140        uintptr_t front( condition_variable(L) & this );
141
142        bool empty  ( condition_variable(L) & this );
143        int  counter( condition_variable(L) & this );
144
145        void wait( condition_variable(L) & this );
146        void wait( condition_variable(L) & this, uintptr_t info );
147        bool wait( condition_variable(L) & this, Duration duration );
148        bool wait( condition_variable(L) & this, uintptr_t info, Duration duration );
149        bool wait( condition_variable(L) & this, Time time );
150        bool wait( condition_variable(L) & this, uintptr_t info, Time time );
151
152        void wait( condition_variable(L) & this, L & l );
153        void wait( condition_variable(L) & this, L & l, uintptr_t info );
154        bool wait( condition_variable(L) & this, L & l, Duration duration );
155        bool wait( condition_variable(L) & this, L & l, uintptr_t info, Duration duration );
156        bool wait( condition_variable(L) & this, L & l, Time time );
157        bool wait( condition_variable(L) & this, L & l, uintptr_t info, Time time );
158}
Note: See TracBrowser for help on using the repository browser.