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