[ab1b971] | 1 | // |
---|
| 2 | // Cforall Version 1.0.0 Copyright (C) 2021 University of Waterloo |
---|
| 3 | // |
---|
| 4 | // The contents of this file are covered under the licence agreement in the |
---|
| 5 | // file "LICENCE" distributed with Cforall. |
---|
| 6 | // |
---|
| 7 | // locks.hfa -- PUBLIC |
---|
| 8 | // Runtime locks that used with the runtime thread system. |
---|
| 9 | // |
---|
| 10 | // Author : Colby Alexander Parsons |
---|
| 11 | // Created On : Thu Jan 21 19:46:50 2021 |
---|
| 12 | // Last Modified By : |
---|
| 13 | // Last Modified On : |
---|
| 14 | // Update Count : |
---|
| 15 | // |
---|
| 16 | |
---|
[f4e35326] | 17 | #pragma once |
---|
| 18 | |
---|
[848439f] | 19 | #include <stdbool.h> |
---|
| 20 | |
---|
[ab1b971] | 21 | #include "bits/weakso_locks.hfa" |
---|
[f4ec5e45] | 22 | #include "containers/queueLockFree.hfa" |
---|
| 23 | |
---|
| 24 | #include "thread.hfa" |
---|
[848439f] | 25 | |
---|
| 26 | #include "time_t.hfa" |
---|
| 27 | #include "time.hfa" |
---|
| 28 | |
---|
[f4ec5e45] | 29 | //----------------------------------------------------------------------------- |
---|
| 30 | // Semaphores |
---|
| 31 | |
---|
| 32 | // '0-nary' semaphore |
---|
| 33 | // Similar to a counting semaphore except the value of one is never reached |
---|
| 34 | // as a consequence, a V() that would bring the value to 1 *spins* until |
---|
| 35 | // a P consumes it |
---|
| 36 | struct Semaphore0nary { |
---|
| 37 | __spinlock_t lock; // needed to protect |
---|
| 38 | mpsc_queue($thread) queue; |
---|
| 39 | }; |
---|
| 40 | |
---|
| 41 | static inline bool P(Semaphore0nary & this, $thread * thrd) __attribute__((artificial)); |
---|
| 42 | static inline bool P(Semaphore0nary & this, $thread * thrd) { |
---|
| 43 | /* paranoid */ verify(!(thrd->seqable.next)); |
---|
| 44 | /* paranoid */ verify(!(thrd`next)); |
---|
| 45 | |
---|
| 46 | push(this.queue, thrd); |
---|
| 47 | return true; |
---|
| 48 | } |
---|
| 49 | |
---|
| 50 | static inline bool P(Semaphore0nary & this) __attribute__((artificial)); |
---|
| 51 | static inline bool P(Semaphore0nary & this) { |
---|
| 52 | $thread * thrd = active_thread(); |
---|
| 53 | P(this, thrd); |
---|
| 54 | park(); |
---|
| 55 | return true; |
---|
| 56 | } |
---|
| 57 | |
---|
| 58 | static inline $thread * V(Semaphore0nary & this, const bool doUnpark = true) __attribute__((artificial)); |
---|
| 59 | static inline $thread * V(Semaphore0nary & this, const bool doUnpark = true) { |
---|
| 60 | $thread * next; |
---|
| 61 | lock(this.lock __cfaabi_dbg_ctx2); |
---|
| 62 | for (;;) { |
---|
| 63 | next = pop(this.queue); |
---|
| 64 | if (next) break; |
---|
| 65 | Pause(); |
---|
| 66 | } |
---|
| 67 | unlock(this.lock); |
---|
| 68 | |
---|
| 69 | if (doUnpark) unpark(next); |
---|
| 70 | return next; |
---|
| 71 | } |
---|
| 72 | |
---|
| 73 | // Wrapper used on top of any sempahore to avoid potential locking |
---|
| 74 | struct BinaryBenaphore { |
---|
| 75 | volatile ssize_t counter; |
---|
| 76 | }; |
---|
| 77 | |
---|
| 78 | static inline { |
---|
| 79 | void ?{}(BinaryBenaphore & this) { this.counter = 0; } |
---|
| 80 | void ?{}(BinaryBenaphore & this, zero_t) { this.counter = 0; } |
---|
| 81 | void ?{}(BinaryBenaphore & this, one_t ) { this.counter = 1; } |
---|
| 82 | |
---|
| 83 | // returns true if no blocking needed |
---|
| 84 | bool P(BinaryBenaphore & this) { return __atomic_fetch_sub(&this.counter, 1, __ATOMIC_SEQ_CST) > 0; } |
---|
| 85 | bool tryP(BinaryBenaphore & this) { |
---|
| 86 | ssize_t c = this.counter; |
---|
| 87 | return (c >= 1) && __atomic_compare_exchange_n(&this.counter, &c, c-1, false, __ATOMIC_SEQ_CST, __ATOMIC_RELAXED); |
---|
| 88 | } |
---|
| 89 | |
---|
| 90 | // returns true if notify needed |
---|
| 91 | bool V(BinaryBenaphore & this) { |
---|
| 92 | ssize_t c = 0; |
---|
| 93 | for () { |
---|
| 94 | if (__atomic_compare_exchange_n(&this.counter, &c, c+1, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST)) { |
---|
| 95 | if (c == 0) return true; |
---|
| 96 | /* paranoid */ verify(c < 0); |
---|
| 97 | return false; |
---|
| 98 | } else { |
---|
| 99 | if (c == 1) return true; |
---|
| 100 | /* paranoid */ verify(c < 1); |
---|
| 101 | Pause(); |
---|
| 102 | } |
---|
| 103 | } |
---|
| 104 | } |
---|
| 105 | } |
---|
| 106 | |
---|
| 107 | // Binary Semaphore based on the BinaryBenaphore on top of the 0-nary Semaphore |
---|
| 108 | struct ThreadBenaphore { |
---|
| 109 | BinaryBenaphore ben; |
---|
| 110 | Semaphore0nary sem; |
---|
| 111 | }; |
---|
| 112 | |
---|
| 113 | static inline void ?{}(ThreadBenaphore & this) {} |
---|
| 114 | static inline void ?{}(ThreadBenaphore & this, zero_t) { (this.ben){ 0 }; } |
---|
| 115 | static inline void ?{}(ThreadBenaphore & this, one_t ) { (this.ben){ 1 }; } |
---|
| 116 | |
---|
| 117 | static inline bool P(ThreadBenaphore & this) { return /* P(this.ben) ? false : */ P(this.sem); } |
---|
| 118 | static inline bool P(ThreadBenaphore & this, $thread * t) { return /* P(this.ben) ? false : */ P(this.sem, t ); } |
---|
| 119 | static inline bool tryP(ThreadBenaphore & this) { return tryP(this.ben); } |
---|
| 120 | static inline bool P(ThreadBenaphore & this, bool wait) { return wait ? P(this) : tryP(this); } |
---|
| 121 | |
---|
| 122 | static inline $thread * V(ThreadBenaphore & this, const bool doUnpark = true) { |
---|
| 123 | // if (V(this.ben)) return 0p; |
---|
| 124 | return V(this.sem, doUnpark); |
---|
| 125 | } |
---|
| 126 | |
---|
| 127 | //----------------------------------------------------------------------------- |
---|
| 128 | // Semaphore |
---|
| 129 | struct semaphore { |
---|
| 130 | __spinlock_t lock; |
---|
| 131 | int count; |
---|
| 132 | __queue_t($thread) waiting; |
---|
| 133 | }; |
---|
| 134 | |
---|
| 135 | void ?{}(semaphore & this, int count = 1); |
---|
| 136 | void ^?{}(semaphore & this); |
---|
| 137 | bool P (semaphore & this); |
---|
| 138 | bool V (semaphore & this); |
---|
| 139 | bool V (semaphore & this, unsigned count); |
---|
| 140 | |
---|
[ab1b971] | 141 | //---------- |
---|
| 142 | struct single_acquisition_lock { |
---|
| 143 | inline blocking_lock; |
---|
| 144 | }; |
---|
| 145 | |
---|
| 146 | static inline void ?{}( single_acquisition_lock & this ) {((blocking_lock &)this){ false, false };} |
---|
| 147 | static inline void ^?{}( single_acquisition_lock & this ) {} |
---|
[f19497c] | 148 | static inline void lock ( single_acquisition_lock & this ) { lock ( (blocking_lock &)this ); } |
---|
[d27b6be] | 149 | static inline bool try_lock ( single_acquisition_lock & this ) { return try_lock( (blocking_lock &)this ); } |
---|
[f19497c] | 150 | static inline void unlock ( single_acquisition_lock & this ) { unlock ( (blocking_lock &)this ); } |
---|
| 151 | static inline void on_wait ( single_acquisition_lock & this ) { on_wait ( (blocking_lock &)this ); } |
---|
[ab1b971] | 152 | static inline void on_notify ( single_acquisition_lock & this, struct $thread * t ) { on_notify( (blocking_lock &)this, t ); } |
---|
| 153 | static inline void set_recursion_count( single_acquisition_lock & this, size_t recursion ) { set_recursion_count( (blocking_lock &)this, recursion ); } |
---|
| 154 | static inline size_t get_recursion_count( single_acquisition_lock & this ) { return get_recursion_count( (blocking_lock &)this ); } |
---|
| 155 | |
---|
| 156 | //---------- |
---|
| 157 | struct owner_lock { |
---|
| 158 | inline blocking_lock; |
---|
| 159 | }; |
---|
| 160 | |
---|
| 161 | static inline void ?{}( owner_lock & this ) {((blocking_lock &)this){ true, true };} |
---|
| 162 | static inline void ^?{}( owner_lock & this ) {} |
---|
[f19497c] | 163 | static inline void lock ( owner_lock & this ) { lock ( (blocking_lock &)this ); } |
---|
[d27b6be] | 164 | static inline bool try_lock ( owner_lock & this ) { return try_lock( (blocking_lock &)this ); } |
---|
[f19497c] | 165 | static inline void unlock ( owner_lock & this ) { unlock ( (blocking_lock &)this ); } |
---|
| 166 | static inline void on_wait ( owner_lock & this ) { on_wait ( (blocking_lock &)this ); } |
---|
[ab1b971] | 167 | static inline void on_notify( owner_lock & this, struct $thread * t ) { on_notify( (blocking_lock &)this, t ); } |
---|
| 168 | static inline void set_recursion_count( owner_lock & this, size_t recursion ) { set_recursion_count( (blocking_lock &)this, recursion ); } |
---|
| 169 | static inline size_t get_recursion_count( owner_lock & this ) { return get_recursion_count( (blocking_lock &)this ); } |
---|
| 170 | |
---|
[f4ec5e45] | 171 | struct fast_lock { |
---|
| 172 | $thread * volatile owner; |
---|
| 173 | ThreadBenaphore sem; |
---|
| 174 | }; |
---|
| 175 | |
---|
| 176 | static inline bool $try_lock(fast_lock & this, $thread * thrd) { |
---|
| 177 | $thread * exp = 0p; |
---|
| 178 | return __atomic_compare_exchange_n(&this.owner, &exp, thrd, false, __ATOMIC_SEQ_CST, __ATOMIC_RELAXED); |
---|
| 179 | } |
---|
| 180 | |
---|
| 181 | static inline void $lock(fast_lock & this, $thread * thrd) { |
---|
| 182 | /* paranoid */verify(thrd != this.owner); |
---|
| 183 | |
---|
| 184 | for (;;) { |
---|
| 185 | if ($try_lock(this, thrd)) return; |
---|
| 186 | P(this.sem, thrd); |
---|
| 187 | } |
---|
| 188 | } |
---|
| 189 | |
---|
| 190 | static inline void lock( fast_lock & this ) { |
---|
| 191 | $thread * thrd = active_thread(); |
---|
| 192 | /* paranoid */verify(thrd != this.owner); |
---|
| 193 | |
---|
| 194 | for (;;) { |
---|
| 195 | if ($try_lock(this, thrd)) return; |
---|
| 196 | P(this.sem); |
---|
| 197 | } |
---|
| 198 | } |
---|
| 199 | |
---|
| 200 | static inline void try_lock ( fast_lock & this ) { |
---|
| 201 | $thread * thrd = active_thread(); |
---|
| 202 | /* paranoid */ verify(thrd != this.owner); |
---|
| 203 | return $try_lock(this, thrd); |
---|
| 204 | } |
---|
| 205 | |
---|
| 206 | static inline void unlock( fast_lock & this ) { |
---|
| 207 | $thread * thrd = active_thread(); |
---|
| 208 | /* paranoid */ verify(thrd == this.owner); |
---|
| 209 | $thread * next = V(this.sem, false); // implicit fence |
---|
| 210 | // open 'owner' only after fence |
---|
| 211 | this.owner = 0p; |
---|
| 212 | |
---|
| 213 | // Unpark the next person (can be 0p, unpark handles it) |
---|
| 214 | unpark(next); |
---|
| 215 | } |
---|
| 216 | |
---|
| 217 | static inline void on_wait( fast_lock & this ) { |
---|
| 218 | unlock(this); |
---|
| 219 | #warning this is broken |
---|
| 220 | } |
---|
| 221 | |
---|
| 222 | static inline void on_notify( fast_lock & this, struct $thread * t ) { |
---|
| 223 | $lock(this, t); |
---|
| 224 | #warning this is broken |
---|
| 225 | } |
---|
| 226 | |
---|
| 227 | static inline void set_recursion_count( fast_lock & this, size_t recursion ) {} |
---|
| 228 | static inline size_t get_recursion_count( fast_lock & this ) { return 0; } |
---|
| 229 | |
---|
| 230 | struct mcs_node { |
---|
| 231 | mcs_node * volatile next; |
---|
| 232 | single_sem sem; |
---|
| 233 | }; |
---|
| 234 | |
---|
[8f5576d5] | 235 | static inline void ?{}(mcs_node & this) { this.next = 0p; } |
---|
[f4ec5e45] | 236 | |
---|
| 237 | static inline mcs_node * volatile & ?`next ( mcs_node * node ) { |
---|
| 238 | return node->next; |
---|
| 239 | } |
---|
| 240 | |
---|
| 241 | struct mcs_lock { |
---|
| 242 | mcs_queue(mcs_node) queue; |
---|
| 243 | }; |
---|
| 244 | |
---|
| 245 | static inline void lock(mcs_lock & l, mcs_node & n) { |
---|
| 246 | if(push(l.queue, &n)) |
---|
| 247 | wait(n.sem); |
---|
| 248 | } |
---|
| 249 | |
---|
| 250 | static inline void unlock(mcs_lock & l, mcs_node & n) { |
---|
| 251 | mcs_node * next = advance(l.queue, &n); |
---|
| 252 | if(next) post(next->sem); |
---|
| 253 | } |
---|
| 254 | |
---|
[ac5816d] | 255 | //----------------------------------------------------------------------------- |
---|
| 256 | // is_blocking_lock |
---|
[fd54fef] | 257 | trait is_blocking_lock(L & | sized(L)) { |
---|
[ac5816d] | 258 | // For synchronization locks to use when acquiring |
---|
| 259 | void on_notify( L &, struct $thread * ); |
---|
| 260 | |
---|
| 261 | // For synchronization locks to use when releasing |
---|
| 262 | void on_wait( L & ); |
---|
[848439f] | 263 | |
---|
[ac5816d] | 264 | // to get recursion count for cond lock to reset after waking |
---|
| 265 | size_t get_recursion_count( L & ); |
---|
| 266 | |
---|
| 267 | // to set recursion count after getting signalled; |
---|
| 268 | void set_recursion_count( L &, size_t recursion ); |
---|
| 269 | }; |
---|
[848439f] | 270 | |
---|
[ac5816d] | 271 | //----------------------------------------------------------------------------- |
---|
| 272 | // info_thread |
---|
[797a193] | 273 | // the info thread is a wrapper around a thread used |
---|
| 274 | // to store extra data for use in the condition variable |
---|
[fd54fef] | 275 | forall(L & | is_blocking_lock(L)) { |
---|
[ac5816d] | 276 | struct info_thread; |
---|
[c131a02] | 277 | |
---|
[797a193] | 278 | // for use by sequence |
---|
[c131a02] | 279 | info_thread(L) *& Back( info_thread(L) * this ); |
---|
| 280 | info_thread(L) *& Next( info_thread(L) * this ); |
---|
[848439f] | 281 | } |
---|
| 282 | |
---|
[ac5816d] | 283 | //----------------------------------------------------------------------------- |
---|
| 284 | // Synchronization Locks |
---|
[fd54fef] | 285 | forall(L & | is_blocking_lock(L)) { |
---|
[eeb5023] | 286 | struct condition_variable { |
---|
[848439f] | 287 | // Spin lock used for mutual exclusion |
---|
| 288 | __spinlock_t lock; |
---|
| 289 | |
---|
| 290 | // List of blocked threads |
---|
[cad1df1] | 291 | Sequence( info_thread(L) ) blocked_threads; |
---|
[848439f] | 292 | |
---|
| 293 | // Count of current blocked threads |
---|
| 294 | int count; |
---|
| 295 | }; |
---|
| 296 | |
---|
[ac5816d] | 297 | void ?{}( condition_variable(L) & this ); |
---|
[848439f] | 298 | void ^?{}( condition_variable(L) & this ); |
---|
| 299 | |
---|
[eeb5023] | 300 | bool notify_one( condition_variable(L) & this ); |
---|
| 301 | bool notify_all( condition_variable(L) & this ); |
---|
[848439f] | 302 | |
---|
[eeb5023] | 303 | uintptr_t front( condition_variable(L) & this ); |
---|
[848439f] | 304 | |
---|
[ac5816d] | 305 | bool empty ( condition_variable(L) & this ); |
---|
| 306 | int counter( condition_variable(L) & this ); |
---|
[848439f] | 307 | |
---|
[eeb5023] | 308 | void wait( condition_variable(L) & this ); |
---|
| 309 | void wait( condition_variable(L) & this, uintptr_t info ); |
---|
[dff1fd1] | 310 | bool wait( condition_variable(L) & this, Duration duration ); |
---|
| 311 | bool wait( condition_variable(L) & this, uintptr_t info, Duration duration ); |
---|
| 312 | bool wait( condition_variable(L) & this, Time time ); |
---|
| 313 | bool wait( condition_variable(L) & this, uintptr_t info, Time time ); |
---|
[848439f] | 314 | |
---|
[eeb5023] | 315 | void wait( condition_variable(L) & this, L & l ); |
---|
| 316 | void wait( condition_variable(L) & this, L & l, uintptr_t info ); |
---|
[dff1fd1] | 317 | bool wait( condition_variable(L) & this, L & l, Duration duration ); |
---|
| 318 | bool wait( condition_variable(L) & this, L & l, uintptr_t info, Duration duration ); |
---|
| 319 | bool wait( condition_variable(L) & this, L & l, Time time ); |
---|
| 320 | bool wait( condition_variable(L) & this, L & l, uintptr_t info, Time time ); |
---|
[f4ec5e45] | 321 | } |
---|