LLVM OpenMP* Runtime Library
kmp_lock.h
1 /*
2  * kmp_lock.h -- lock header file
3  */
4 
5 //===----------------------------------------------------------------------===//
6 //
7 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
8 // See https://llvm.org/LICENSE.txt for license information.
9 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
10 //
11 //===----------------------------------------------------------------------===//
12 
13 #ifndef KMP_LOCK_H
14 #define KMP_LOCK_H
15 
16 #include <limits.h> // CHAR_BIT
17 #include <stddef.h> // offsetof
18 
19 #include "kmp_debug.h"
20 #include "kmp_os.h"
21 
22 #ifdef __cplusplus
23 #include <atomic>
24 
25 extern "C" {
26 #endif // __cplusplus
27 
28 // ----------------------------------------------------------------------------
29 // Have to copy these definitions from kmp.h because kmp.h cannot be included
30 // due to circular dependencies. Will undef these at end of file.
31 
32 #define KMP_PAD(type, sz) \
33  (sizeof(type) + (sz - ((sizeof(type) - 1) % (sz)) - 1))
34 #define KMP_GTID_DNE (-2)
35 
36 // Forward declaration of ident and ident_t
37 
38 struct ident;
39 typedef struct ident ident_t;
40 
41 // End of copied code.
42 // ----------------------------------------------------------------------------
43 
44 // We need to know the size of the area we can assume that the compiler(s)
45 // allocated for objects of type omp_lock_t and omp_nest_lock_t. The Intel
46 // compiler always allocates a pointer-sized area, as does visual studio.
47 //
48 // gcc however, only allocates 4 bytes for regular locks, even on 64-bit
49 // intel archs. It allocates at least 8 bytes for nested lock (more on
50 // recent versions), but we are bounded by the pointer-sized chunks that
51 // the Intel compiler allocates.
52 
53 #if KMP_OS_LINUX && defined(KMP_GOMP_COMPAT)
54 #define OMP_LOCK_T_SIZE sizeof(int)
55 #define OMP_NEST_LOCK_T_SIZE sizeof(void *)
56 #else
57 #define OMP_LOCK_T_SIZE sizeof(void *)
58 #define OMP_NEST_LOCK_T_SIZE sizeof(void *)
59 #endif
60 
61 // The Intel compiler allocates a 32-byte chunk for a critical section.
62 // Both gcc and visual studio only allocate enough space for a pointer.
63 // Sometimes we know that the space was allocated by the Intel compiler.
64 #define OMP_CRITICAL_SIZE sizeof(void *)
65 #define INTEL_CRITICAL_SIZE 32
66 
67 // lock flags
68 typedef kmp_uint32 kmp_lock_flags_t;
69 
70 #define kmp_lf_critical_section 1
71 
72 // When a lock table is used, the indices are of kmp_lock_index_t
73 typedef kmp_uint32 kmp_lock_index_t;
74 
75 // When memory allocated for locks are on the lock pool (free list),
76 // it is treated as structs of this type.
77 struct kmp_lock_pool {
78  union kmp_user_lock *next;
79  kmp_lock_index_t index;
80 };
81 
82 typedef struct kmp_lock_pool kmp_lock_pool_t;
83 
84 extern void __kmp_validate_locks(void);
85 
86 // ----------------------------------------------------------------------------
87 // There are 5 lock implementations:
88 // 1. Test and set locks.
89 // 2. futex locks (Linux* OS on x86 and
90 // Intel(R) Many Integrated Core Architecture)
91 // 3. Ticket (Lamport bakery) locks.
92 // 4. Queuing locks (with separate spin fields).
93 // 5. DRPA (Dynamically Reconfigurable Distributed Polling Area) locks
94 //
95 // and 3 lock purposes:
96 // 1. Bootstrap locks -- Used for a few locks available at library
97 // startup-shutdown time.
98 // These do not require non-negative global thread ID's.
99 // 2. Internal RTL locks -- Used everywhere else in the RTL
100 // 3. User locks (includes critical sections)
101 // ----------------------------------------------------------------------------
102 
103 // ============================================================================
104 // Lock implementations.
105 //
106 // Test and set locks.
107 //
108 // Non-nested test and set locks differ from the other lock kinds (except
109 // futex) in that we use the memory allocated by the compiler for the lock,
110 // rather than a pointer to it.
111 //
112 // On lin32, lin_32e, and win_32, the space allocated may be as small as 4
113 // bytes, so we have to use a lock table for nested locks, and avoid accessing
114 // the depth_locked field for non-nested locks.
115 //
116 // Information normally available to the tools, such as lock location, lock
117 // usage (normal lock vs. critical section), etc. is not available with test and
118 // set locks.
119 // ----------------------------------------------------------------------------
120 
121 struct kmp_base_tas_lock {
122  // KMP_LOCK_FREE(tas) => unlocked; locked: (gtid+1) of owning thread
123  std::atomic<kmp_int32> poll;
124  kmp_int32 depth_locked; // depth locked, for nested locks only
125 };
126 
127 typedef struct kmp_base_tas_lock kmp_base_tas_lock_t;
128 
129 union kmp_tas_lock {
130  kmp_base_tas_lock_t lk;
131  kmp_lock_pool_t pool; // make certain struct is large enough
132  double lk_align; // use worst case alignment; no cache line padding
133 };
134 
135 typedef union kmp_tas_lock kmp_tas_lock_t;
136 
137 // Static initializer for test and set lock variables. Usage:
138 // kmp_tas_lock_t xlock = KMP_TAS_LOCK_INITIALIZER( xlock );
139 #define KMP_TAS_LOCK_INITIALIZER(lock) \
140  { \
141  { KMP_LOCK_FREE(tas), 0 } \
142  }
143 
144 extern int __kmp_acquire_tas_lock(kmp_tas_lock_t *lck, kmp_int32 gtid);
145 extern int __kmp_test_tas_lock(kmp_tas_lock_t *lck, kmp_int32 gtid);
146 extern int __kmp_release_tas_lock(kmp_tas_lock_t *lck, kmp_int32 gtid);
147 extern void __kmp_init_tas_lock(kmp_tas_lock_t *lck);
148 extern void __kmp_destroy_tas_lock(kmp_tas_lock_t *lck);
149 
150 extern int __kmp_acquire_nested_tas_lock(kmp_tas_lock_t *lck, kmp_int32 gtid);
151 extern int __kmp_test_nested_tas_lock(kmp_tas_lock_t *lck, kmp_int32 gtid);
152 extern int __kmp_release_nested_tas_lock(kmp_tas_lock_t *lck, kmp_int32 gtid);
153 extern void __kmp_init_nested_tas_lock(kmp_tas_lock_t *lck);
154 extern void __kmp_destroy_nested_tas_lock(kmp_tas_lock_t *lck);
155 
156 #define KMP_LOCK_RELEASED 1
157 #define KMP_LOCK_STILL_HELD 0
158 #define KMP_LOCK_ACQUIRED_FIRST 1
159 #define KMP_LOCK_ACQUIRED_NEXT 0
160 #ifndef KMP_USE_FUTEX
161 #define KMP_USE_FUTEX \
162  (KMP_OS_LINUX && \
163  (KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_ARCH_ARM || KMP_ARCH_AARCH64))
164 #endif
165 #if KMP_USE_FUTEX
166 
167 // ----------------------------------------------------------------------------
168 // futex locks. futex locks are only available on Linux* OS.
169 //
170 // Like non-nested test and set lock, non-nested futex locks use the memory
171 // allocated by the compiler for the lock, rather than a pointer to it.
172 //
173 // Information normally available to the tools, such as lock location, lock
174 // usage (normal lock vs. critical section), etc. is not available with test and
175 // set locks. With non-nested futex locks, the lock owner is not even available.
176 // ----------------------------------------------------------------------------
177 
178 struct kmp_base_futex_lock {
179  volatile kmp_int32 poll; // KMP_LOCK_FREE(futex) => unlocked
180  // 2*(gtid+1) of owning thread, 0 if unlocked
181  // locked: (gtid+1) of owning thread
182  kmp_int32 depth_locked; // depth locked, for nested locks only
183 };
184 
185 typedef struct kmp_base_futex_lock kmp_base_futex_lock_t;
186 
187 union kmp_futex_lock {
188  kmp_base_futex_lock_t lk;
189  kmp_lock_pool_t pool; // make certain struct is large enough
190  double lk_align; // use worst case alignment
191  // no cache line padding
192 };
193 
194 typedef union kmp_futex_lock kmp_futex_lock_t;
195 
196 // Static initializer for futex lock variables. Usage:
197 // kmp_futex_lock_t xlock = KMP_FUTEX_LOCK_INITIALIZER( xlock );
198 #define KMP_FUTEX_LOCK_INITIALIZER(lock) \
199  { \
200  { KMP_LOCK_FREE(futex), 0 } \
201  }
202 
203 extern int __kmp_acquire_futex_lock(kmp_futex_lock_t *lck, kmp_int32 gtid);
204 extern int __kmp_test_futex_lock(kmp_futex_lock_t *lck, kmp_int32 gtid);
205 extern int __kmp_release_futex_lock(kmp_futex_lock_t *lck, kmp_int32 gtid);
206 extern void __kmp_init_futex_lock(kmp_futex_lock_t *lck);
207 extern void __kmp_destroy_futex_lock(kmp_futex_lock_t *lck);
208 
209 extern int __kmp_acquire_nested_futex_lock(kmp_futex_lock_t *lck,
210  kmp_int32 gtid);
211 extern int __kmp_test_nested_futex_lock(kmp_futex_lock_t *lck, kmp_int32 gtid);
212 extern int __kmp_release_nested_futex_lock(kmp_futex_lock_t *lck,
213  kmp_int32 gtid);
214 extern void __kmp_init_nested_futex_lock(kmp_futex_lock_t *lck);
215 extern void __kmp_destroy_nested_futex_lock(kmp_futex_lock_t *lck);
216 
217 #endif // KMP_USE_FUTEX
218 
219 // ----------------------------------------------------------------------------
220 // Ticket locks.
221 
222 #ifdef __cplusplus
223 
224 #ifdef _MSC_VER
225 // MSVC won't allow use of std::atomic<> in a union since it has non-trivial
226 // copy constructor.
227 
228 struct kmp_base_ticket_lock {
229  // `initialized' must be the first entry in the lock data structure!
230  std::atomic_bool initialized;
231  volatile union kmp_ticket_lock *self; // points to the lock union
232  ident_t const *location; // Source code location of omp_init_lock().
233  std::atomic_uint
234  next_ticket; // ticket number to give to next thread which acquires
235  std::atomic_uint now_serving; // ticket number for thread which holds the lock
236  std::atomic_int owner_id; // (gtid+1) of owning thread, 0 if unlocked
237  std::atomic_int depth_locked; // depth locked, for nested locks only
238  kmp_lock_flags_t flags; // lock specifics, e.g. critical section lock
239 };
240 #else
241 struct kmp_base_ticket_lock {
242  // `initialized' must be the first entry in the lock data structure!
243  std::atomic<bool> initialized;
244  volatile union kmp_ticket_lock *self; // points to the lock union
245  ident_t const *location; // Source code location of omp_init_lock().
246  std::atomic<unsigned>
247  next_ticket; // ticket number to give to next thread which acquires
248  std::atomic<unsigned>
249  now_serving; // ticket number for thread which holds the lock
250  std::atomic<int> owner_id; // (gtid+1) of owning thread, 0 if unlocked
251  std::atomic<int> depth_locked; // depth locked, for nested locks only
252  kmp_lock_flags_t flags; // lock specifics, e.g. critical section lock
253 };
254 #endif
255 
256 #else // __cplusplus
257 
258 struct kmp_base_ticket_lock;
259 
260 #endif // !__cplusplus
261 
262 typedef struct kmp_base_ticket_lock kmp_base_ticket_lock_t;
263 
264 union KMP_ALIGN_CACHE kmp_ticket_lock {
265  kmp_base_ticket_lock_t
266  lk; // This field must be first to allow static initializing.
267  kmp_lock_pool_t pool;
268  double lk_align; // use worst case alignment
269  char lk_pad[KMP_PAD(kmp_base_ticket_lock_t, CACHE_LINE)];
270 };
271 
272 typedef union kmp_ticket_lock kmp_ticket_lock_t;
273 
274 // Static initializer for simple ticket lock variables. Usage:
275 // kmp_ticket_lock_t xlock = KMP_TICKET_LOCK_INITIALIZER( xlock );
276 // Note the macro argument. It is important to make var properly initialized.
277 #define KMP_TICKET_LOCK_INITIALIZER(lock) \
278  { \
279  { true, &(lock), NULL, 0U, 0U, 0, -1 } \
280  }
281 
282 extern int __kmp_acquire_ticket_lock(kmp_ticket_lock_t *lck, kmp_int32 gtid);
283 extern int __kmp_test_ticket_lock(kmp_ticket_lock_t *lck, kmp_int32 gtid);
284 extern int __kmp_test_ticket_lock_with_cheks(kmp_ticket_lock_t *lck,
285  kmp_int32 gtid);
286 extern int __kmp_release_ticket_lock(kmp_ticket_lock_t *lck, kmp_int32 gtid);
287 extern void __kmp_init_ticket_lock(kmp_ticket_lock_t *lck);
288 extern void __kmp_destroy_ticket_lock(kmp_ticket_lock_t *lck);
289 
290 extern int __kmp_acquire_nested_ticket_lock(kmp_ticket_lock_t *lck,
291  kmp_int32 gtid);
292 extern int __kmp_test_nested_ticket_lock(kmp_ticket_lock_t *lck,
293  kmp_int32 gtid);
294 extern int __kmp_release_nested_ticket_lock(kmp_ticket_lock_t *lck,
295  kmp_int32 gtid);
296 extern void __kmp_init_nested_ticket_lock(kmp_ticket_lock_t *lck);
297 extern void __kmp_destroy_nested_ticket_lock(kmp_ticket_lock_t *lck);
298 
299 // ----------------------------------------------------------------------------
300 // Queuing locks.
301 
302 #if KMP_USE_ADAPTIVE_LOCKS
303 
304 struct kmp_adaptive_lock_info;
305 
306 typedef struct kmp_adaptive_lock_info kmp_adaptive_lock_info_t;
307 
308 #if KMP_DEBUG_ADAPTIVE_LOCKS
309 
310 struct kmp_adaptive_lock_statistics {
311  /* So we can get stats from locks that haven't been destroyed. */
312  kmp_adaptive_lock_info_t *next;
313  kmp_adaptive_lock_info_t *prev;
314 
315  /* Other statistics */
316  kmp_uint32 successfulSpeculations;
317  kmp_uint32 hardFailedSpeculations;
318  kmp_uint32 softFailedSpeculations;
319  kmp_uint32 nonSpeculativeAcquires;
320  kmp_uint32 nonSpeculativeAcquireAttempts;
321  kmp_uint32 lemmingYields;
322 };
323 
324 typedef struct kmp_adaptive_lock_statistics kmp_adaptive_lock_statistics_t;
325 
326 extern void __kmp_print_speculative_stats();
327 extern void __kmp_init_speculative_stats();
328 
329 #endif // KMP_DEBUG_ADAPTIVE_LOCKS
330 
331 struct kmp_adaptive_lock_info {
332  /* Values used for adaptivity.
333  Although these are accessed from multiple threads we don't access them
334  atomically, because if we miss updates it probably doesn't matter much. (It
335  just affects our decision about whether to try speculation on the lock). */
336  kmp_uint32 volatile badness;
337  kmp_uint32 volatile acquire_attempts;
338  /* Parameters of the lock. */
339  kmp_uint32 max_badness;
340  kmp_uint32 max_soft_retries;
341 
342 #if KMP_DEBUG_ADAPTIVE_LOCKS
343  kmp_adaptive_lock_statistics_t volatile stats;
344 #endif
345 };
346 
347 #endif // KMP_USE_ADAPTIVE_LOCKS
348 
349 struct kmp_base_queuing_lock {
350 
351  // `initialized' must be the first entry in the lock data structure!
352  volatile union kmp_queuing_lock
353  *initialized; // Points to the lock union if in initialized state.
354 
355  ident_t const *location; // Source code location of omp_init_lock().
356 
357  KMP_ALIGN(8) // tail_id must be 8-byte aligned!
358 
359  volatile kmp_int32
360  tail_id; // (gtid+1) of thread at tail of wait queue, 0 if empty
361  // Must be no padding here since head/tail used in 8-byte CAS
362  volatile kmp_int32
363  head_id; // (gtid+1) of thread at head of wait queue, 0 if empty
364  // Decl order assumes little endian
365  // bakery-style lock
366  volatile kmp_uint32
367  next_ticket; // ticket number to give to next thread which acquires
368  volatile kmp_uint32
369  now_serving; // ticket number for thread which holds the lock
370  volatile kmp_int32 owner_id; // (gtid+1) of owning thread, 0 if unlocked
371  kmp_int32 depth_locked; // depth locked, for nested locks only
372 
373  kmp_lock_flags_t flags; // lock specifics, e.g. critical section lock
374 };
375 
376 typedef struct kmp_base_queuing_lock kmp_base_queuing_lock_t;
377 
378 KMP_BUILD_ASSERT(offsetof(kmp_base_queuing_lock_t, tail_id) % 8 == 0);
379 
380 union KMP_ALIGN_CACHE kmp_queuing_lock {
381  kmp_base_queuing_lock_t
382  lk; // This field must be first to allow static initializing.
383  kmp_lock_pool_t pool;
384  double lk_align; // use worst case alignment
385  char lk_pad[KMP_PAD(kmp_base_queuing_lock_t, CACHE_LINE)];
386 };
387 
388 typedef union kmp_queuing_lock kmp_queuing_lock_t;
389 
390 extern int __kmp_acquire_queuing_lock(kmp_queuing_lock_t *lck, kmp_int32 gtid);
391 extern int __kmp_test_queuing_lock(kmp_queuing_lock_t *lck, kmp_int32 gtid);
392 extern int __kmp_release_queuing_lock(kmp_queuing_lock_t *lck, kmp_int32 gtid);
393 extern void __kmp_init_queuing_lock(kmp_queuing_lock_t *lck);
394 extern void __kmp_destroy_queuing_lock(kmp_queuing_lock_t *lck);
395 
396 extern int __kmp_acquire_nested_queuing_lock(kmp_queuing_lock_t *lck,
397  kmp_int32 gtid);
398 extern int __kmp_test_nested_queuing_lock(kmp_queuing_lock_t *lck,
399  kmp_int32 gtid);
400 extern int __kmp_release_nested_queuing_lock(kmp_queuing_lock_t *lck,
401  kmp_int32 gtid);
402 extern void __kmp_init_nested_queuing_lock(kmp_queuing_lock_t *lck);
403 extern void __kmp_destroy_nested_queuing_lock(kmp_queuing_lock_t *lck);
404 
405 #if KMP_USE_ADAPTIVE_LOCKS
406 
407 // ----------------------------------------------------------------------------
408 // Adaptive locks.
409 struct kmp_base_adaptive_lock {
410  kmp_base_queuing_lock qlk;
411  KMP_ALIGN(CACHE_LINE)
412  kmp_adaptive_lock_info_t
413  adaptive; // Information for the speculative adaptive lock
414 };
415 
416 typedef struct kmp_base_adaptive_lock kmp_base_adaptive_lock_t;
417 
418 union KMP_ALIGN_CACHE kmp_adaptive_lock {
419  kmp_base_adaptive_lock_t lk;
420  kmp_lock_pool_t pool;
421  double lk_align;
422  char lk_pad[KMP_PAD(kmp_base_adaptive_lock_t, CACHE_LINE)];
423 };
424 typedef union kmp_adaptive_lock kmp_adaptive_lock_t;
425 
426 #define GET_QLK_PTR(l) ((kmp_queuing_lock_t *)&(l)->lk.qlk)
427 
428 #endif // KMP_USE_ADAPTIVE_LOCKS
429 
430 // ----------------------------------------------------------------------------
431 // DRDPA ticket locks.
432 struct kmp_base_drdpa_lock {
433  // All of the fields on the first cache line are only written when
434  // initializing or reconfiguring the lock. These are relatively rare
435  // operations, so data from the first cache line will usually stay resident in
436  // the cache of each thread trying to acquire the lock.
437  //
438  // initialized must be the first entry in the lock data structure!
439  KMP_ALIGN_CACHE
440 
441  volatile union kmp_drdpa_lock
442  *initialized; // points to the lock union if in initialized state
443  ident_t const *location; // Source code location of omp_init_lock().
444  std::atomic<std::atomic<kmp_uint64> *> polls;
445  std::atomic<kmp_uint64> mask; // is 2**num_polls-1 for mod op
446  kmp_uint64 cleanup_ticket; // thread with cleanup ticket
447  std::atomic<kmp_uint64> *old_polls; // will deallocate old_polls
448  kmp_uint32 num_polls; // must be power of 2
449 
450  // next_ticket it needs to exist in a separate cache line, as it is
451  // invalidated every time a thread takes a new ticket.
452  KMP_ALIGN_CACHE
453 
454  std::atomic<kmp_uint64> next_ticket;
455 
456  // now_serving is used to store our ticket value while we hold the lock. It
457  // has a slightly different meaning in the DRDPA ticket locks (where it is
458  // written by the acquiring thread) than it does in the simple ticket locks
459  // (where it is written by the releasing thread).
460  //
461  // Since now_serving is only read and written in the critical section,
462  // it is non-volatile, but it needs to exist on a separate cache line,
463  // as it is invalidated at every lock acquire.
464  //
465  // Likewise, the vars used for nested locks (owner_id and depth_locked) are
466  // only written by the thread owning the lock, so they are put in this cache
467  // line. owner_id is read by other threads, so it must be declared volatile.
468  KMP_ALIGN_CACHE
469  kmp_uint64 now_serving; // doesn't have to be volatile
470  volatile kmp_uint32 owner_id; // (gtid+1) of owning thread, 0 if unlocked
471  kmp_int32 depth_locked; // depth locked
472  kmp_lock_flags_t flags; // lock specifics, e.g. critical section lock
473 };
474 
475 typedef struct kmp_base_drdpa_lock kmp_base_drdpa_lock_t;
476 
477 union KMP_ALIGN_CACHE kmp_drdpa_lock {
478  kmp_base_drdpa_lock_t
479  lk; // This field must be first to allow static initializing. */
480  kmp_lock_pool_t pool;
481  double lk_align; // use worst case alignment
482  char lk_pad[KMP_PAD(kmp_base_drdpa_lock_t, CACHE_LINE)];
483 };
484 
485 typedef union kmp_drdpa_lock kmp_drdpa_lock_t;
486 
487 extern int __kmp_acquire_drdpa_lock(kmp_drdpa_lock_t *lck, kmp_int32 gtid);
488 extern int __kmp_test_drdpa_lock(kmp_drdpa_lock_t *lck, kmp_int32 gtid);
489 extern int __kmp_release_drdpa_lock(kmp_drdpa_lock_t *lck, kmp_int32 gtid);
490 extern void __kmp_init_drdpa_lock(kmp_drdpa_lock_t *lck);
491 extern void __kmp_destroy_drdpa_lock(kmp_drdpa_lock_t *lck);
492 
493 extern int __kmp_acquire_nested_drdpa_lock(kmp_drdpa_lock_t *lck,
494  kmp_int32 gtid);
495 extern int __kmp_test_nested_drdpa_lock(kmp_drdpa_lock_t *lck, kmp_int32 gtid);
496 extern int __kmp_release_nested_drdpa_lock(kmp_drdpa_lock_t *lck,
497  kmp_int32 gtid);
498 extern void __kmp_init_nested_drdpa_lock(kmp_drdpa_lock_t *lck);
499 extern void __kmp_destroy_nested_drdpa_lock(kmp_drdpa_lock_t *lck);
500 
501 // ============================================================================
502 // Lock purposes.
503 // ============================================================================
504 
505 // Bootstrap locks.
506 //
507 // Bootstrap locks -- very few locks used at library initialization time.
508 // Bootstrap locks are currently implemented as ticket locks.
509 // They could also be implemented as test and set lock, but cannot be
510 // implemented with other lock kinds as they require gtids which are not
511 // available at initialization time.
512 
513 typedef kmp_ticket_lock_t kmp_bootstrap_lock_t;
514 
515 #define KMP_BOOTSTRAP_LOCK_INITIALIZER(lock) KMP_TICKET_LOCK_INITIALIZER((lock))
516 #define KMP_BOOTSTRAP_LOCK_INIT(lock) \
517  kmp_bootstrap_lock_t lock = KMP_TICKET_LOCK_INITIALIZER(lock)
518 
519 static inline int __kmp_acquire_bootstrap_lock(kmp_bootstrap_lock_t *lck) {
520  return __kmp_acquire_ticket_lock(lck, KMP_GTID_DNE);
521 }
522 
523 static inline int __kmp_test_bootstrap_lock(kmp_bootstrap_lock_t *lck) {
524  return __kmp_test_ticket_lock(lck, KMP_GTID_DNE);
525 }
526 
527 static inline void __kmp_release_bootstrap_lock(kmp_bootstrap_lock_t *lck) {
528  __kmp_release_ticket_lock(lck, KMP_GTID_DNE);
529 }
530 
531 static inline void __kmp_init_bootstrap_lock(kmp_bootstrap_lock_t *lck) {
532  __kmp_init_ticket_lock(lck);
533 }
534 
535 static inline void __kmp_destroy_bootstrap_lock(kmp_bootstrap_lock_t *lck) {
536  __kmp_destroy_ticket_lock(lck);
537 }
538 
539 // Internal RTL locks.
540 //
541 // Internal RTL locks are also implemented as ticket locks, for now.
542 //
543 // FIXME - We should go through and figure out which lock kind works best for
544 // each internal lock, and use the type declaration and function calls for
545 // that explicit lock kind (and get rid of this section).
546 
547 typedef kmp_ticket_lock_t kmp_lock_t;
548 
549 #define KMP_LOCK_INIT(lock) kmp_lock_t lock = KMP_TICKET_LOCK_INITIALIZER(lock)
550 
551 static inline int __kmp_acquire_lock(kmp_lock_t *lck, kmp_int32 gtid) {
552  return __kmp_acquire_ticket_lock(lck, gtid);
553 }
554 
555 static inline int __kmp_test_lock(kmp_lock_t *lck, kmp_int32 gtid) {
556  return __kmp_test_ticket_lock(lck, gtid);
557 }
558 
559 static inline void __kmp_release_lock(kmp_lock_t *lck, kmp_int32 gtid) {
560  __kmp_release_ticket_lock(lck, gtid);
561 }
562 
563 static inline void __kmp_init_lock(kmp_lock_t *lck) {
564  __kmp_init_ticket_lock(lck);
565 }
566 
567 static inline void __kmp_destroy_lock(kmp_lock_t *lck) {
568  __kmp_destroy_ticket_lock(lck);
569 }
570 
571 // User locks.
572 //
573 // Do not allocate objects of type union kmp_user_lock!!! This will waste space
574 // unless __kmp_user_lock_kind == lk_drdpa. Instead, check the value of
575 // __kmp_user_lock_kind and allocate objects of the type of the appropriate
576 // union member, and cast their addresses to kmp_user_lock_p.
577 
578 enum kmp_lock_kind {
579  lk_default = 0,
580  lk_tas,
581 #if KMP_USE_FUTEX
582  lk_futex,
583 #endif
584 #if KMP_USE_DYNAMIC_LOCK && KMP_USE_TSX
585  lk_hle,
586  lk_rtm_queuing,
587  lk_rtm_spin,
588 #endif
589  lk_ticket,
590  lk_queuing,
591  lk_drdpa,
592 #if KMP_USE_ADAPTIVE_LOCKS
593  lk_adaptive
594 #endif // KMP_USE_ADAPTIVE_LOCKS
595 };
596 
597 typedef enum kmp_lock_kind kmp_lock_kind_t;
598 
599 extern kmp_lock_kind_t __kmp_user_lock_kind;
600 
601 union kmp_user_lock {
602  kmp_tas_lock_t tas;
603 #if KMP_USE_FUTEX
604  kmp_futex_lock_t futex;
605 #endif
606  kmp_ticket_lock_t ticket;
607  kmp_queuing_lock_t queuing;
608  kmp_drdpa_lock_t drdpa;
609 #if KMP_USE_ADAPTIVE_LOCKS
610  kmp_adaptive_lock_t adaptive;
611 #endif // KMP_USE_ADAPTIVE_LOCKS
612  kmp_lock_pool_t pool;
613 };
614 
615 typedef union kmp_user_lock *kmp_user_lock_p;
616 
617 #if !KMP_USE_DYNAMIC_LOCK
618 
619 extern size_t __kmp_base_user_lock_size;
620 extern size_t __kmp_user_lock_size;
621 
622 extern kmp_int32 (*__kmp_get_user_lock_owner_)(kmp_user_lock_p lck);
623 
624 static inline kmp_int32 __kmp_get_user_lock_owner(kmp_user_lock_p lck) {
625  KMP_DEBUG_ASSERT(__kmp_get_user_lock_owner_ != NULL);
626  return (*__kmp_get_user_lock_owner_)(lck);
627 }
628 
629 extern int (*__kmp_acquire_user_lock_with_checks_)(kmp_user_lock_p lck,
630  kmp_int32 gtid);
631 
632 #if KMP_OS_LINUX && \
633  (KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_ARCH_ARM || KMP_ARCH_AARCH64)
634 
635 #define __kmp_acquire_user_lock_with_checks(lck, gtid) \
636  if (__kmp_user_lock_kind == lk_tas) { \
637  if (__kmp_env_consistency_check) { \
638  char const *const func = "omp_set_lock"; \
639  if ((sizeof(kmp_tas_lock_t) <= OMP_LOCK_T_SIZE) && \
640  lck->tas.lk.depth_locked != -1) { \
641  KMP_FATAL(LockNestableUsedAsSimple, func); \
642  } \
643  if ((gtid >= 0) && (lck->tas.lk.poll - 1 == gtid)) { \
644  KMP_FATAL(LockIsAlreadyOwned, func); \
645  } \
646  } \
647  if (lck->tas.lk.poll != 0 || \
648  !__kmp_atomic_compare_store_acq(&lck->tas.lk.poll, 0, gtid + 1)) { \
649  kmp_uint32 spins; \
650  kmp_uint64 time; \
651  KMP_FSYNC_PREPARE(lck); \
652  KMP_INIT_YIELD(spins); \
653  KMP_INIT_BACKOFF(time); \
654  do { \
655  KMP_YIELD_OVERSUB_ELSE_SPIN(spins, time); \
656  } while ( \
657  lck->tas.lk.poll != 0 || \
658  !__kmp_atomic_compare_store_acq(&lck->tas.lk.poll, 0, gtid + 1)); \
659  } \
660  KMP_FSYNC_ACQUIRED(lck); \
661  } else { \
662  KMP_DEBUG_ASSERT(__kmp_acquire_user_lock_with_checks_ != NULL); \
663  (*__kmp_acquire_user_lock_with_checks_)(lck, gtid); \
664  }
665 
666 #else
667 static inline int __kmp_acquire_user_lock_with_checks(kmp_user_lock_p lck,
668  kmp_int32 gtid) {
669  KMP_DEBUG_ASSERT(__kmp_acquire_user_lock_with_checks_ != NULL);
670  return (*__kmp_acquire_user_lock_with_checks_)(lck, gtid);
671 }
672 #endif
673 
674 extern int (*__kmp_test_user_lock_with_checks_)(kmp_user_lock_p lck,
675  kmp_int32 gtid);
676 
677 #if KMP_OS_LINUX && \
678  (KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_ARCH_ARM || KMP_ARCH_AARCH64)
679 
680 #include "kmp_i18n.h" /* AC: KMP_FATAL definition */
681 extern int __kmp_env_consistency_check; /* AC: copy from kmp.h here */
682 static inline int __kmp_test_user_lock_with_checks(kmp_user_lock_p lck,
683  kmp_int32 gtid) {
684  if (__kmp_user_lock_kind == lk_tas) {
685  if (__kmp_env_consistency_check) {
686  char const *const func = "omp_test_lock";
687  if ((sizeof(kmp_tas_lock_t) <= OMP_LOCK_T_SIZE) &&
688  lck->tas.lk.depth_locked != -1) {
689  KMP_FATAL(LockNestableUsedAsSimple, func);
690  }
691  }
692  return ((lck->tas.lk.poll == 0) &&
693  __kmp_atomic_compare_store_acq(&lck->tas.lk.poll, 0, gtid + 1));
694  } else {
695  KMP_DEBUG_ASSERT(__kmp_test_user_lock_with_checks_ != NULL);
696  return (*__kmp_test_user_lock_with_checks_)(lck, gtid);
697  }
698 }
699 #else
700 static inline int __kmp_test_user_lock_with_checks(kmp_user_lock_p lck,
701  kmp_int32 gtid) {
702  KMP_DEBUG_ASSERT(__kmp_test_user_lock_with_checks_ != NULL);
703  return (*__kmp_test_user_lock_with_checks_)(lck, gtid);
704 }
705 #endif
706 
707 extern int (*__kmp_release_user_lock_with_checks_)(kmp_user_lock_p lck,
708  kmp_int32 gtid);
709 
710 static inline void __kmp_release_user_lock_with_checks(kmp_user_lock_p lck,
711  kmp_int32 gtid) {
712  KMP_DEBUG_ASSERT(__kmp_release_user_lock_with_checks_ != NULL);
713  (*__kmp_release_user_lock_with_checks_)(lck, gtid);
714 }
715 
716 extern void (*__kmp_init_user_lock_with_checks_)(kmp_user_lock_p lck);
717 
718 static inline void __kmp_init_user_lock_with_checks(kmp_user_lock_p lck) {
719  KMP_DEBUG_ASSERT(__kmp_init_user_lock_with_checks_ != NULL);
720  (*__kmp_init_user_lock_with_checks_)(lck);
721 }
722 
723 // We need a non-checking version of destroy lock for when the RTL is
724 // doing the cleanup as it can't always tell if the lock is nested or not.
725 extern void (*__kmp_destroy_user_lock_)(kmp_user_lock_p lck);
726 
727 static inline void __kmp_destroy_user_lock(kmp_user_lock_p lck) {
728  KMP_DEBUG_ASSERT(__kmp_destroy_user_lock_ != NULL);
729  (*__kmp_destroy_user_lock_)(lck);
730 }
731 
732 extern void (*__kmp_destroy_user_lock_with_checks_)(kmp_user_lock_p lck);
733 
734 static inline void __kmp_destroy_user_lock_with_checks(kmp_user_lock_p lck) {
735  KMP_DEBUG_ASSERT(__kmp_destroy_user_lock_with_checks_ != NULL);
736  (*__kmp_destroy_user_lock_with_checks_)(lck);
737 }
738 
739 extern int (*__kmp_acquire_nested_user_lock_with_checks_)(kmp_user_lock_p lck,
740  kmp_int32 gtid);
741 
742 #if KMP_OS_LINUX && (KMP_ARCH_X86 || KMP_ARCH_X86_64)
743 
744 #define __kmp_acquire_nested_user_lock_with_checks(lck, gtid, depth) \
745  if (__kmp_user_lock_kind == lk_tas) { \
746  if (__kmp_env_consistency_check) { \
747  char const *const func = "omp_set_nest_lock"; \
748  if ((sizeof(kmp_tas_lock_t) <= OMP_NEST_LOCK_T_SIZE) && \
749  lck->tas.lk.depth_locked == -1) { \
750  KMP_FATAL(LockSimpleUsedAsNestable, func); \
751  } \
752  } \
753  if (lck->tas.lk.poll - 1 == gtid) { \
754  lck->tas.lk.depth_locked += 1; \
755  *depth = KMP_LOCK_ACQUIRED_NEXT; \
756  } else { \
757  if ((lck->tas.lk.poll != 0) || \
758  !__kmp_atomic_compare_store_acq(&lck->tas.lk.poll, 0, gtid + 1)) { \
759  kmp_uint32 spins; \
760  kmp_uint64 time; \
761  KMP_FSYNC_PREPARE(lck); \
762  KMP_INIT_YIELD(spins); \
763  KMP_INIT_BACKOFF(time); \
764  do { \
765  KMP_YIELD_OVERSUB_ELSE_SPIN(spins, time); \
766  } while ( \
767  (lck->tas.lk.poll != 0) || \
768  !__kmp_atomic_compare_store_acq(&lck->tas.lk.poll, 0, gtid + 1)); \
769  } \
770  lck->tas.lk.depth_locked = 1; \
771  *depth = KMP_LOCK_ACQUIRED_FIRST; \
772  } \
773  KMP_FSYNC_ACQUIRED(lck); \
774  } else { \
775  KMP_DEBUG_ASSERT(__kmp_acquire_nested_user_lock_with_checks_ != NULL); \
776  *depth = (*__kmp_acquire_nested_user_lock_with_checks_)(lck, gtid); \
777  }
778 
779 #else
780 static inline void
781 __kmp_acquire_nested_user_lock_with_checks(kmp_user_lock_p lck, kmp_int32 gtid,
782  int *depth) {
783  KMP_DEBUG_ASSERT(__kmp_acquire_nested_user_lock_with_checks_ != NULL);
784  *depth = (*__kmp_acquire_nested_user_lock_with_checks_)(lck, gtid);
785 }
786 #endif
787 
788 extern int (*__kmp_test_nested_user_lock_with_checks_)(kmp_user_lock_p lck,
789  kmp_int32 gtid);
790 
791 #if KMP_OS_LINUX && (KMP_ARCH_X86 || KMP_ARCH_X86_64)
792 static inline int __kmp_test_nested_user_lock_with_checks(kmp_user_lock_p lck,
793  kmp_int32 gtid) {
794  if (__kmp_user_lock_kind == lk_tas) {
795  int retval;
796  if (__kmp_env_consistency_check) {
797  char const *const func = "omp_test_nest_lock";
798  if ((sizeof(kmp_tas_lock_t) <= OMP_NEST_LOCK_T_SIZE) &&
799  lck->tas.lk.depth_locked == -1) {
800  KMP_FATAL(LockSimpleUsedAsNestable, func);
801  }
802  }
803  KMP_DEBUG_ASSERT(gtid >= 0);
804  if (lck->tas.lk.poll - 1 ==
805  gtid) { /* __kmp_get_tas_lock_owner( lck ) == gtid */
806  return ++lck->tas.lk.depth_locked; /* same owner, depth increased */
807  }
808  retval = ((lck->tas.lk.poll == 0) &&
809  __kmp_atomic_compare_store_acq(&lck->tas.lk.poll, 0, gtid + 1));
810  if (retval) {
811  KMP_MB();
812  lck->tas.lk.depth_locked = 1;
813  }
814  return retval;
815  } else {
816  KMP_DEBUG_ASSERT(__kmp_test_nested_user_lock_with_checks_ != NULL);
817  return (*__kmp_test_nested_user_lock_with_checks_)(lck, gtid);
818  }
819 }
820 #else
821 static inline int __kmp_test_nested_user_lock_with_checks(kmp_user_lock_p lck,
822  kmp_int32 gtid) {
823  KMP_DEBUG_ASSERT(__kmp_test_nested_user_lock_with_checks_ != NULL);
824  return (*__kmp_test_nested_user_lock_with_checks_)(lck, gtid);
825 }
826 #endif
827 
828 extern int (*__kmp_release_nested_user_lock_with_checks_)(kmp_user_lock_p lck,
829  kmp_int32 gtid);
830 
831 static inline int
832 __kmp_release_nested_user_lock_with_checks(kmp_user_lock_p lck,
833  kmp_int32 gtid) {
834  KMP_DEBUG_ASSERT(__kmp_release_nested_user_lock_with_checks_ != NULL);
835  return (*__kmp_release_nested_user_lock_with_checks_)(lck, gtid);
836 }
837 
838 extern void (*__kmp_init_nested_user_lock_with_checks_)(kmp_user_lock_p lck);
839 
840 static inline void
841 __kmp_init_nested_user_lock_with_checks(kmp_user_lock_p lck) {
842  KMP_DEBUG_ASSERT(__kmp_init_nested_user_lock_with_checks_ != NULL);
843  (*__kmp_init_nested_user_lock_with_checks_)(lck);
844 }
845 
846 extern void (*__kmp_destroy_nested_user_lock_with_checks_)(kmp_user_lock_p lck);
847 
848 static inline void
849 __kmp_destroy_nested_user_lock_with_checks(kmp_user_lock_p lck) {
850  KMP_DEBUG_ASSERT(__kmp_destroy_nested_user_lock_with_checks_ != NULL);
851  (*__kmp_destroy_nested_user_lock_with_checks_)(lck);
852 }
853 
854 // user lock functions which do not necessarily exist for all lock kinds.
855 //
856 // The "set" functions usually have wrapper routines that check for a NULL set
857 // function pointer and call it if non-NULL.
858 //
859 // In some cases, it makes sense to have a "get" wrapper function check for a
860 // NULL get function pointer and return NULL / invalid value / error code if
861 // the function pointer is NULL.
862 //
863 // In other cases, the calling code really should differentiate between an
864 // unimplemented function and one that is implemented but returning NULL /
865 // invalid value. If this is the case, no get function wrapper exists.
866 
867 extern int (*__kmp_is_user_lock_initialized_)(kmp_user_lock_p lck);
868 
869 // no set function; fields set during local allocation
870 
871 extern const ident_t *(*__kmp_get_user_lock_location_)(kmp_user_lock_p lck);
872 
873 static inline const ident_t *__kmp_get_user_lock_location(kmp_user_lock_p lck) {
874  if (__kmp_get_user_lock_location_ != NULL) {
875  return (*__kmp_get_user_lock_location_)(lck);
876  } else {
877  return NULL;
878  }
879 }
880 
881 extern void (*__kmp_set_user_lock_location_)(kmp_user_lock_p lck,
882  const ident_t *loc);
883 
884 static inline void __kmp_set_user_lock_location(kmp_user_lock_p lck,
885  const ident_t *loc) {
886  if (__kmp_set_user_lock_location_ != NULL) {
887  (*__kmp_set_user_lock_location_)(lck, loc);
888  }
889 }
890 
891 extern kmp_lock_flags_t (*__kmp_get_user_lock_flags_)(kmp_user_lock_p lck);
892 
893 extern void (*__kmp_set_user_lock_flags_)(kmp_user_lock_p lck,
894  kmp_lock_flags_t flags);
895 
896 static inline void __kmp_set_user_lock_flags(kmp_user_lock_p lck,
897  kmp_lock_flags_t flags) {
898  if (__kmp_set_user_lock_flags_ != NULL) {
899  (*__kmp_set_user_lock_flags_)(lck, flags);
900  }
901 }
902 
903 // The function which sets up all of the vtbl pointers for kmp_user_lock_t.
904 extern void __kmp_set_user_lock_vptrs(kmp_lock_kind_t user_lock_kind);
905 
906 // Macros for binding user lock functions.
907 #define KMP_BIND_USER_LOCK_TEMPLATE(nest, kind, suffix) \
908  { \
909  __kmp_acquire##nest##user_lock_with_checks_ = (int (*)( \
910  kmp_user_lock_p, kmp_int32))__kmp_acquire##nest##kind##_##suffix; \
911  __kmp_release##nest##user_lock_with_checks_ = (int (*)( \
912  kmp_user_lock_p, kmp_int32))__kmp_release##nest##kind##_##suffix; \
913  __kmp_test##nest##user_lock_with_checks_ = (int (*)( \
914  kmp_user_lock_p, kmp_int32))__kmp_test##nest##kind##_##suffix; \
915  __kmp_init##nest##user_lock_with_checks_ = \
916  (void (*)(kmp_user_lock_p))__kmp_init##nest##kind##_##suffix; \
917  __kmp_destroy##nest##user_lock_with_checks_ = \
918  (void (*)(kmp_user_lock_p))__kmp_destroy##nest##kind##_##suffix; \
919  }
920 
921 #define KMP_BIND_USER_LOCK(kind) KMP_BIND_USER_LOCK_TEMPLATE(_, kind, lock)
922 #define KMP_BIND_USER_LOCK_WITH_CHECKS(kind) \
923  KMP_BIND_USER_LOCK_TEMPLATE(_, kind, lock_with_checks)
924 #define KMP_BIND_NESTED_USER_LOCK(kind) \
925  KMP_BIND_USER_LOCK_TEMPLATE(_nested_, kind, lock)
926 #define KMP_BIND_NESTED_USER_LOCK_WITH_CHECKS(kind) \
927  KMP_BIND_USER_LOCK_TEMPLATE(_nested_, kind, lock_with_checks)
928 
929 // User lock table & lock allocation
930 /* On 64-bit Linux* OS (and OS X*) GNU compiler allocates only 4 bytems memory
931  for lock variable, which is not enough to store a pointer, so we have to use
932  lock indexes instead of pointers and maintain lock table to map indexes to
933  pointers.
934 
935 
936  Note: The first element of the table is not a pointer to lock! It is a
937  pointer to previously allocated table (or NULL if it is the first table).
938 
939  Usage:
940 
941  if ( OMP_LOCK_T_SIZE < sizeof( <lock> ) ) { // or OMP_NEST_LOCK_T_SIZE
942  Lock table is fully utilized. User locks are indexes, so table is used on
943  user lock operation.
944  Note: it may be the case (lin_32) that we don't need to use a lock
945  table for regular locks, but do need the table for nested locks.
946  }
947  else {
948  Lock table initialized but not actually used.
949  }
950 */
951 
952 struct kmp_lock_table {
953  kmp_lock_index_t used; // Number of used elements
954  kmp_lock_index_t allocated; // Number of allocated elements
955  kmp_user_lock_p *table; // Lock table.
956 };
957 
958 typedef struct kmp_lock_table kmp_lock_table_t;
959 
960 extern kmp_lock_table_t __kmp_user_lock_table;
961 extern kmp_user_lock_p __kmp_lock_pool;
962 
963 struct kmp_block_of_locks {
964  struct kmp_block_of_locks *next_block;
965  void *locks;
966 };
967 
968 typedef struct kmp_block_of_locks kmp_block_of_locks_t;
969 
970 extern kmp_block_of_locks_t *__kmp_lock_blocks;
971 extern int __kmp_num_locks_in_block;
972 
973 extern kmp_user_lock_p __kmp_user_lock_allocate(void **user_lock,
974  kmp_int32 gtid,
975  kmp_lock_flags_t flags);
976 extern void __kmp_user_lock_free(void **user_lock, kmp_int32 gtid,
977  kmp_user_lock_p lck);
978 extern kmp_user_lock_p __kmp_lookup_user_lock(void **user_lock,
979  char const *func);
980 extern void __kmp_cleanup_user_locks();
981 
982 #define KMP_CHECK_USER_LOCK_INIT() \
983  { \
984  if (!TCR_4(__kmp_init_user_locks)) { \
985  __kmp_acquire_bootstrap_lock(&__kmp_initz_lock); \
986  if (!TCR_4(__kmp_init_user_locks)) { \
987  TCW_4(__kmp_init_user_locks, TRUE); \
988  } \
989  __kmp_release_bootstrap_lock(&__kmp_initz_lock); \
990  } \
991  }
992 
993 #endif // KMP_USE_DYNAMIC_LOCK
994 
995 #undef KMP_PAD
996 #undef KMP_GTID_DNE
997 
998 #if KMP_USE_DYNAMIC_LOCK
999 // KMP_USE_DYNAMIC_LOCK enables dynamic dispatch of lock functions without
1000 // breaking the current compatibility. Essential functionality of this new code
1001 // is dynamic dispatch, but it also implements (or enables implementation of)
1002 // hinted user lock and critical section which will be part of OMP 4.5 soon.
1003 //
1004 // Lock type can be decided at creation time (i.e., lock initialization), and
1005 // subsequent lock function call on the created lock object requires type
1006 // extraction and call through jump table using the extracted type. This type
1007 // information is stored in two different ways depending on the size of the lock
1008 // object, and we differentiate lock types by this size requirement - direct and
1009 // indirect locks.
1010 //
1011 // Direct locks:
1012 // A direct lock object fits into the space created by the compiler for an
1013 // omp_lock_t object, and TAS/Futex lock falls into this category. We use low
1014 // one byte of the lock object as the storage for the lock type, and appropriate
1015 // bit operation is required to access the data meaningful to the lock
1016 // algorithms. Also, to differentiate direct lock from indirect lock, 1 is
1017 // written to LSB of the lock object. The newly introduced "hle" lock is also a
1018 // direct lock.
1019 //
1020 // Indirect locks:
1021 // An indirect lock object requires more space than the compiler-generated
1022 // space, and it should be allocated from heap. Depending on the size of the
1023 // compiler-generated space for the lock (i.e., size of omp_lock_t), this
1024 // omp_lock_t object stores either the address of the heap-allocated indirect
1025 // lock (void * fits in the object) or an index to the indirect lock table entry
1026 // that holds the address. Ticket/Queuing/DRDPA/Adaptive lock falls into this
1027 // category, and the newly introduced "rtm" lock is also an indirect lock which
1028 // was implemented on top of the Queuing lock. When the omp_lock_t object holds
1029 // an index (not lock address), 0 is written to LSB to differentiate the lock
1030 // from a direct lock, and the remaining part is the actual index to the
1031 // indirect lock table.
1032 
1033 #include <stdint.h> // for uintptr_t
1034 
1035 // Shortcuts
1036 #define KMP_USE_INLINED_TAS \
1037  (KMP_OS_LINUX && (KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_ARCH_ARM)) && 1
1038 #define KMP_USE_INLINED_FUTEX KMP_USE_FUTEX && 0
1039 
1040 // List of lock definitions; all nested locks are indirect locks.
1041 // hle lock is xchg lock prefixed with XACQUIRE/XRELEASE.
1042 // All nested locks are indirect lock types.
1043 #if KMP_USE_TSX
1044 #if KMP_USE_FUTEX
1045 #define KMP_FOREACH_D_LOCK(m, a) m(tas, a) m(futex, a) m(hle, a) m(rtm_spin, a)
1046 #define KMP_FOREACH_I_LOCK(m, a) \
1047  m(ticket, a) m(queuing, a) m(adaptive, a) m(drdpa, a) m(rtm_queuing, a) \
1048  m(nested_tas, a) m(nested_futex, a) m(nested_ticket, a) \
1049  m(nested_queuing, a) m(nested_drdpa, a)
1050 #else
1051 #define KMP_FOREACH_D_LOCK(m, a) m(tas, a) m(hle, a) m(rtm_spin, a)
1052 #define KMP_FOREACH_I_LOCK(m, a) \
1053  m(ticket, a) m(queuing, a) m(adaptive, a) m(drdpa, a) m(rtm_queuing, a) \
1054  m(nested_tas, a) m(nested_ticket, a) m(nested_queuing, a) \
1055  m(nested_drdpa, a)
1056 #endif // KMP_USE_FUTEX
1057 #define KMP_LAST_D_LOCK lockseq_rtm_spin
1058 #else
1059 #if KMP_USE_FUTEX
1060 #define KMP_FOREACH_D_LOCK(m, a) m(tas, a) m(futex, a)
1061 #define KMP_FOREACH_I_LOCK(m, a) \
1062  m(ticket, a) m(queuing, a) m(drdpa, a) m(nested_tas, a) m(nested_futex, a) \
1063  m(nested_ticket, a) m(nested_queuing, a) m(nested_drdpa, a)
1064 #define KMP_LAST_D_LOCK lockseq_futex
1065 #else
1066 #define KMP_FOREACH_D_LOCK(m, a) m(tas, a)
1067 #define KMP_FOREACH_I_LOCK(m, a) \
1068  m(ticket, a) m(queuing, a) m(drdpa, a) m(nested_tas, a) m(nested_ticket, a) \
1069  m(nested_queuing, a) m(nested_drdpa, a)
1070 #define KMP_LAST_D_LOCK lockseq_tas
1071 #endif // KMP_USE_FUTEX
1072 #endif // KMP_USE_TSX
1073 
1074 // Information used in dynamic dispatch
1075 #define KMP_LOCK_SHIFT \
1076  8 // number of low bits to be used as tag for direct locks
1077 #define KMP_FIRST_D_LOCK lockseq_tas
1078 #define KMP_FIRST_I_LOCK lockseq_ticket
1079 #define KMP_LAST_I_LOCK lockseq_nested_drdpa
1080 #define KMP_NUM_I_LOCKS \
1081  (locktag_nested_drdpa + 1) // number of indirect lock types
1082 
1083 // Base type for dynamic locks.
1084 typedef kmp_uint32 kmp_dyna_lock_t;
1085 
1086 // Lock sequence that enumerates all lock kinds. Always make this enumeration
1087 // consistent with kmp_lockseq_t in the include directory.
1088 typedef enum {
1089  lockseq_indirect = 0,
1090 #define expand_seq(l, a) lockseq_##l,
1091  KMP_FOREACH_D_LOCK(expand_seq, 0) KMP_FOREACH_I_LOCK(expand_seq, 0)
1092 #undef expand_seq
1093 } kmp_dyna_lockseq_t;
1094 
1095 // Enumerates indirect lock tags.
1096 typedef enum {
1097 #define expand_tag(l, a) locktag_##l,
1098  KMP_FOREACH_I_LOCK(expand_tag, 0)
1099 #undef expand_tag
1100 } kmp_indirect_locktag_t;
1101 
1102 // Utility macros that extract information from lock sequences.
1103 #define KMP_IS_D_LOCK(seq) \
1104  ((seq) >= KMP_FIRST_D_LOCK && (seq) <= KMP_LAST_D_LOCK)
1105 #define KMP_IS_I_LOCK(seq) \
1106  ((seq) >= KMP_FIRST_I_LOCK && (seq) <= KMP_LAST_I_LOCK)
1107 #define KMP_GET_I_TAG(seq) (kmp_indirect_locktag_t)((seq)-KMP_FIRST_I_LOCK)
1108 #define KMP_GET_D_TAG(seq) ((seq) << 1 | 1)
1109 
1110 // Enumerates direct lock tags starting from indirect tag.
1111 typedef enum {
1112 #define expand_tag(l, a) locktag_##l = KMP_GET_D_TAG(lockseq_##l),
1113  KMP_FOREACH_D_LOCK(expand_tag, 0)
1114 #undef expand_tag
1115 } kmp_direct_locktag_t;
1116 
1117 // Indirect lock type
1118 typedef struct {
1119  kmp_user_lock_p lock;
1120  kmp_indirect_locktag_t type;
1121 } kmp_indirect_lock_t;
1122 
1123 // Function tables for direct locks. Set/unset/test differentiate functions
1124 // with/without consistency checking.
1125 extern void (*__kmp_direct_init[])(kmp_dyna_lock_t *, kmp_dyna_lockseq_t);
1126 extern void (**__kmp_direct_destroy)(kmp_dyna_lock_t *);
1127 extern int (**__kmp_direct_set)(kmp_dyna_lock_t *, kmp_int32);
1128 extern int (**__kmp_direct_unset)(kmp_dyna_lock_t *, kmp_int32);
1129 extern int (**__kmp_direct_test)(kmp_dyna_lock_t *, kmp_int32);
1130 
1131 // Function tables for indirect locks. Set/unset/test differentiate functions
1132 // with/without consistency checking.
1133 extern void (*__kmp_indirect_init[])(kmp_user_lock_p);
1134 extern void (**__kmp_indirect_destroy)(kmp_user_lock_p);
1135 extern int (**__kmp_indirect_set)(kmp_user_lock_p, kmp_int32);
1136 extern int (**__kmp_indirect_unset)(kmp_user_lock_p, kmp_int32);
1137 extern int (**__kmp_indirect_test)(kmp_user_lock_p, kmp_int32);
1138 
1139 // Extracts direct lock tag from a user lock pointer
1140 #define KMP_EXTRACT_D_TAG(l) \
1141  (*((kmp_dyna_lock_t *)(l)) & ((1 << KMP_LOCK_SHIFT) - 1) & \
1142  -(*((kmp_dyna_lock_t *)(l)) & 1))
1143 
1144 // Extracts indirect lock index from a user lock pointer
1145 #define KMP_EXTRACT_I_INDEX(l) (*(kmp_lock_index_t *)(l) >> 1)
1146 
1147 // Returns function pointer to the direct lock function with l (kmp_dyna_lock_t
1148 // *) and op (operation type).
1149 #define KMP_D_LOCK_FUNC(l, op) __kmp_direct_##op[KMP_EXTRACT_D_TAG(l)]
1150 
1151 // Returns function pointer to the indirect lock function with l
1152 // (kmp_indirect_lock_t *) and op (operation type).
1153 #define KMP_I_LOCK_FUNC(l, op) \
1154  __kmp_indirect_##op[((kmp_indirect_lock_t *)(l))->type]
1155 
1156 // Initializes a direct lock with the given lock pointer and lock sequence.
1157 #define KMP_INIT_D_LOCK(l, seq) \
1158  __kmp_direct_init[KMP_GET_D_TAG(seq)]((kmp_dyna_lock_t *)l, seq)
1159 
1160 // Initializes an indirect lock with the given lock pointer and lock sequence.
1161 #define KMP_INIT_I_LOCK(l, seq) \
1162  __kmp_direct_init[0]((kmp_dyna_lock_t *)(l), seq)
1163 
1164 // Returns "free" lock value for the given lock type.
1165 #define KMP_LOCK_FREE(type) (locktag_##type)
1166 
1167 // Returns "busy" lock value for the given lock teyp.
1168 #define KMP_LOCK_BUSY(v, type) ((v) << KMP_LOCK_SHIFT | locktag_##type)
1169 
1170 // Returns lock value after removing (shifting) lock tag.
1171 #define KMP_LOCK_STRIP(v) ((v) >> KMP_LOCK_SHIFT)
1172 
1173 // Initializes global states and data structures for managing dynamic user
1174 // locks.
1175 extern void __kmp_init_dynamic_user_locks();
1176 
1177 // Allocates and returns an indirect lock with the given indirect lock tag.
1178 extern kmp_indirect_lock_t *
1179 __kmp_allocate_indirect_lock(void **, kmp_int32, kmp_indirect_locktag_t);
1180 
1181 // Cleans up global states and data structures for managing dynamic user locks.
1182 extern void __kmp_cleanup_indirect_user_locks();
1183 
1184 // Default user lock sequence when not using hinted locks.
1185 extern kmp_dyna_lockseq_t __kmp_user_lock_seq;
1186 
1187 // Jump table for "set lock location", available only for indirect locks.
1188 extern void (*__kmp_indirect_set_location[KMP_NUM_I_LOCKS])(kmp_user_lock_p,
1189  const ident_t *);
1190 #define KMP_SET_I_LOCK_LOCATION(lck, loc) \
1191  { \
1192  if (__kmp_indirect_set_location[(lck)->type] != NULL) \
1193  __kmp_indirect_set_location[(lck)->type]((lck)->lock, loc); \
1194  }
1195 
1196 // Jump table for "set lock flags", available only for indirect locks.
1197 extern void (*__kmp_indirect_set_flags[KMP_NUM_I_LOCKS])(kmp_user_lock_p,
1198  kmp_lock_flags_t);
1199 #define KMP_SET_I_LOCK_FLAGS(lck, flag) \
1200  { \
1201  if (__kmp_indirect_set_flags[(lck)->type] != NULL) \
1202  __kmp_indirect_set_flags[(lck)->type]((lck)->lock, flag); \
1203  }
1204 
1205 // Jump table for "get lock location", available only for indirect locks.
1206 extern const ident_t *(*__kmp_indirect_get_location[KMP_NUM_I_LOCKS])(
1207  kmp_user_lock_p);
1208 #define KMP_GET_I_LOCK_LOCATION(lck) \
1209  (__kmp_indirect_get_location[(lck)->type] != NULL \
1210  ? __kmp_indirect_get_location[(lck)->type]((lck)->lock) \
1211  : NULL)
1212 
1213 // Jump table for "get lock flags", available only for indirect locks.
1214 extern kmp_lock_flags_t (*__kmp_indirect_get_flags[KMP_NUM_I_LOCKS])(
1215  kmp_user_lock_p);
1216 #define KMP_GET_I_LOCK_FLAGS(lck) \
1217  (__kmp_indirect_get_flags[(lck)->type] != NULL \
1218  ? __kmp_indirect_get_flags[(lck)->type]((lck)->lock) \
1219  : NULL)
1220 
1221 // number of kmp_indirect_lock_t objects to be allocated together
1222 #define KMP_I_LOCK_CHUNK 1024
1223 // Keep at a power of 2 since it is used in multiplication & division
1224 KMP_BUILD_ASSERT(KMP_I_LOCK_CHUNK % 2 == 0);
1225 // number of row entries in the initial lock table
1226 #define KMP_I_LOCK_TABLE_INIT_NROW_PTRS 8
1227 
1228 // Lock table for indirect locks.
1229 typedef struct kmp_indirect_lock_table {
1230  kmp_indirect_lock_t **table; // blocks of indirect locks allocated
1231  kmp_uint32 nrow_ptrs; // number *table pointer entries in table
1232  kmp_lock_index_t next; // index to the next lock to be allocated
1233  struct kmp_indirect_lock_table *next_table;
1234 } kmp_indirect_lock_table_t;
1235 
1236 extern kmp_indirect_lock_table_t __kmp_i_lock_table;
1237 
1238 // Returns the indirect lock associated with the given index.
1239 // Returns nullptr if no lock at given index
1240 static inline kmp_indirect_lock_t *__kmp_get_i_lock(kmp_lock_index_t idx) {
1241  kmp_indirect_lock_table_t *lock_table = &__kmp_i_lock_table;
1242  while (lock_table) {
1243  kmp_lock_index_t max_locks = lock_table->nrow_ptrs * KMP_I_LOCK_CHUNK;
1244  if (idx < max_locks) {
1245  kmp_lock_index_t row = idx / KMP_I_LOCK_CHUNK;
1246  kmp_lock_index_t col = idx % KMP_I_LOCK_CHUNK;
1247  if (!lock_table->table[row] || idx >= lock_table->next)
1248  break;
1249  return &lock_table->table[row][col];
1250  }
1251  idx -= max_locks;
1252  lock_table = lock_table->next_table;
1253  }
1254  return nullptr;
1255 }
1256 
1257 // Number of locks in a lock block, which is fixed to "1" now.
1258 // TODO: No lock block implementation now. If we do support, we need to manage
1259 // lock block data structure for each indirect lock type.
1260 extern int __kmp_num_locks_in_block;
1261 
1262 // Fast lock table lookup without consistency checking
1263 #define KMP_LOOKUP_I_LOCK(l) \
1264  ((OMP_LOCK_T_SIZE < sizeof(void *)) \
1265  ? __kmp_get_i_lock(KMP_EXTRACT_I_INDEX(l)) \
1266  : *((kmp_indirect_lock_t **)(l)))
1267 
1268 // Used once in kmp_error.cpp
1269 extern kmp_int32 __kmp_get_user_lock_owner(kmp_user_lock_p, kmp_uint32);
1270 
1271 #else // KMP_USE_DYNAMIC_LOCK
1272 
1273 #define KMP_LOCK_BUSY(v, type) (v)
1274 #define KMP_LOCK_FREE(type) 0
1275 #define KMP_LOCK_STRIP(v) (v)
1276 
1277 #endif // KMP_USE_DYNAMIC_LOCK
1278 
1279 // data structure for using backoff within spin locks.
1280 typedef struct {
1281  kmp_uint32 step; // current step
1282  kmp_uint32 max_backoff; // upper bound of outer delay loop
1283  kmp_uint32 min_tick; // size of inner delay loop in ticks (machine-dependent)
1284 } kmp_backoff_t;
1285 
1286 // Runtime's default backoff parameters
1287 extern kmp_backoff_t __kmp_spin_backoff_params;
1288 
1289 // Backoff function
1290 extern void __kmp_spin_backoff(kmp_backoff_t *);
1291 
1292 #ifdef __cplusplus
1293 } // extern "C"
1294 #endif // __cplusplus
1295 
1296 #endif /* KMP_LOCK_H */
ident
Definition: kmp.h:235