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 { ATOMIC_VAR_INIT(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 { \ 280 ATOMIC_VAR_INIT(true) \ 281 , &(lock), NULL, ATOMIC_VAR_INIT(0U), ATOMIC_VAR_INIT(0U), \ 282 ATOMIC_VAR_INIT(0), ATOMIC_VAR_INIT(-1) \ 283 } \ 284 } 285 286 extern int __kmp_acquire_ticket_lock(kmp_ticket_lock_t *lck, kmp_int32 gtid); 287 extern int __kmp_test_ticket_lock(kmp_ticket_lock_t *lck, kmp_int32 gtid); 288 extern int __kmp_test_ticket_lock_with_cheks(kmp_ticket_lock_t *lck, 289 kmp_int32 gtid); 290 extern int __kmp_release_ticket_lock(kmp_ticket_lock_t *lck, kmp_int32 gtid); 291 extern void __kmp_init_ticket_lock(kmp_ticket_lock_t *lck); 292 extern void __kmp_destroy_ticket_lock(kmp_ticket_lock_t *lck); 293 294 extern int __kmp_acquire_nested_ticket_lock(kmp_ticket_lock_t *lck, 295 kmp_int32 gtid); 296 extern int __kmp_test_nested_ticket_lock(kmp_ticket_lock_t *lck, 297 kmp_int32 gtid); 298 extern int __kmp_release_nested_ticket_lock(kmp_ticket_lock_t *lck, 299 kmp_int32 gtid); 300 extern void __kmp_init_nested_ticket_lock(kmp_ticket_lock_t *lck); 301 extern void __kmp_destroy_nested_ticket_lock(kmp_ticket_lock_t *lck); 302 303 // ---------------------------------------------------------------------------- 304 // Queuing locks. 305 306 #if KMP_USE_ADAPTIVE_LOCKS 307 308 struct kmp_adaptive_lock_info; 309 310 typedef struct kmp_adaptive_lock_info kmp_adaptive_lock_info_t; 311 312 #if KMP_DEBUG_ADAPTIVE_LOCKS 313 314 struct kmp_adaptive_lock_statistics { 315 /* So we can get stats from locks that haven't been destroyed. */ 316 kmp_adaptive_lock_info_t *next; 317 kmp_adaptive_lock_info_t *prev; 318 319 /* Other statistics */ 320 kmp_uint32 successfulSpeculations; 321 kmp_uint32 hardFailedSpeculations; 322 kmp_uint32 softFailedSpeculations; 323 kmp_uint32 nonSpeculativeAcquires; 324 kmp_uint32 nonSpeculativeAcquireAttempts; 325 kmp_uint32 lemmingYields; 326 }; 327 328 typedef struct kmp_adaptive_lock_statistics kmp_adaptive_lock_statistics_t; 329 330 extern void __kmp_print_speculative_stats(); 331 extern void __kmp_init_speculative_stats(); 332 333 #endif // KMP_DEBUG_ADAPTIVE_LOCKS 334 335 struct kmp_adaptive_lock_info { 336 /* Values used for adaptivity. 337 Although these are accessed from multiple threads we don't access them 338 atomically, because if we miss updates it probably doesn't matter much. (It 339 just affects our decision about whether to try speculation on the lock). */ 340 kmp_uint32 volatile badness; 341 kmp_uint32 volatile acquire_attempts; 342 /* Parameters of the lock. */ 343 kmp_uint32 max_badness; 344 kmp_uint32 max_soft_retries; 345 346 #if KMP_DEBUG_ADAPTIVE_LOCKS 347 kmp_adaptive_lock_statistics_t volatile stats; 348 #endif 349 }; 350 351 #endif // KMP_USE_ADAPTIVE_LOCKS 352 353 struct kmp_base_queuing_lock { 354 355 // `initialized' must be the first entry in the lock data structure! 356 volatile union kmp_queuing_lock 357 *initialized; // Points to the lock union if in initialized state. 358 359 ident_t const *location; // Source code location of omp_init_lock(). 360 361 KMP_ALIGN(8) // tail_id must be 8-byte aligned! 362 363 volatile kmp_int32 364 tail_id; // (gtid+1) of thread at tail of wait queue, 0 if empty 365 // Must be no padding here since head/tail used in 8-byte CAS 366 volatile kmp_int32 367 head_id; // (gtid+1) of thread at head of wait queue, 0 if empty 368 // Decl order assumes little endian 369 // bakery-style lock 370 volatile kmp_uint32 371 next_ticket; // ticket number to give to next thread which acquires 372 volatile kmp_uint32 373 now_serving; // ticket number for thread which holds the lock 374 volatile kmp_int32 owner_id; // (gtid+1) of owning thread, 0 if unlocked 375 kmp_int32 depth_locked; // depth locked, for nested locks only 376 377 kmp_lock_flags_t flags; // lock specifics, e.g. critical section lock 378 }; 379 380 typedef struct kmp_base_queuing_lock kmp_base_queuing_lock_t; 381 382 KMP_BUILD_ASSERT(offsetof(kmp_base_queuing_lock_t, tail_id) % 8 == 0); 383 384 union KMP_ALIGN_CACHE kmp_queuing_lock { 385 kmp_base_queuing_lock_t 386 lk; // This field must be first to allow static initializing. 387 kmp_lock_pool_t pool; 388 double lk_align; // use worst case alignment 389 char lk_pad[KMP_PAD(kmp_base_queuing_lock_t, CACHE_LINE)]; 390 }; 391 392 typedef union kmp_queuing_lock kmp_queuing_lock_t; 393 394 extern int __kmp_acquire_queuing_lock(kmp_queuing_lock_t *lck, kmp_int32 gtid); 395 extern int __kmp_test_queuing_lock(kmp_queuing_lock_t *lck, kmp_int32 gtid); 396 extern int __kmp_release_queuing_lock(kmp_queuing_lock_t *lck, kmp_int32 gtid); 397 extern void __kmp_init_queuing_lock(kmp_queuing_lock_t *lck); 398 extern void __kmp_destroy_queuing_lock(kmp_queuing_lock_t *lck); 399 400 extern int __kmp_acquire_nested_queuing_lock(kmp_queuing_lock_t *lck, 401 kmp_int32 gtid); 402 extern int __kmp_test_nested_queuing_lock(kmp_queuing_lock_t *lck, 403 kmp_int32 gtid); 404 extern int __kmp_release_nested_queuing_lock(kmp_queuing_lock_t *lck, 405 kmp_int32 gtid); 406 extern void __kmp_init_nested_queuing_lock(kmp_queuing_lock_t *lck); 407 extern void __kmp_destroy_nested_queuing_lock(kmp_queuing_lock_t *lck); 408 409 #if KMP_USE_ADAPTIVE_LOCKS 410 411 // ---------------------------------------------------------------------------- 412 // Adaptive locks. 413 struct kmp_base_adaptive_lock { 414 kmp_base_queuing_lock qlk; 415 KMP_ALIGN(CACHE_LINE) 416 kmp_adaptive_lock_info_t 417 adaptive; // Information for the speculative adaptive lock 418 }; 419 420 typedef struct kmp_base_adaptive_lock kmp_base_adaptive_lock_t; 421 422 union KMP_ALIGN_CACHE kmp_adaptive_lock { 423 kmp_base_adaptive_lock_t lk; 424 kmp_lock_pool_t pool; 425 double lk_align; 426 char lk_pad[KMP_PAD(kmp_base_adaptive_lock_t, CACHE_LINE)]; 427 }; 428 typedef union kmp_adaptive_lock kmp_adaptive_lock_t; 429 430 #define GET_QLK_PTR(l) ((kmp_queuing_lock_t *)&(l)->lk.qlk) 431 432 #endif // KMP_USE_ADAPTIVE_LOCKS 433 434 // ---------------------------------------------------------------------------- 435 // DRDPA ticket locks. 436 struct kmp_base_drdpa_lock { 437 // All of the fields on the first cache line are only written when 438 // initializing or reconfiguring the lock. These are relatively rare 439 // operations, so data from the first cache line will usually stay resident in 440 // the cache of each thread trying to acquire the lock. 441 // 442 // initialized must be the first entry in the lock data structure! 443 KMP_ALIGN_CACHE 444 445 volatile union kmp_drdpa_lock 446 *initialized; // points to the lock union if in initialized state 447 ident_t const *location; // Source code location of omp_init_lock(). 448 std::atomic<std::atomic<kmp_uint64> *> polls; 449 std::atomic<kmp_uint64> mask; // is 2**num_polls-1 for mod op 450 kmp_uint64 cleanup_ticket; // thread with cleanup ticket 451 std::atomic<kmp_uint64> *old_polls; // will deallocate old_polls 452 kmp_uint32 num_polls; // must be power of 2 453 454 // next_ticket it needs to exist in a separate cache line, as it is 455 // invalidated every time a thread takes a new ticket. 456 KMP_ALIGN_CACHE 457 458 std::atomic<kmp_uint64> next_ticket; 459 460 // now_serving is used to store our ticket value while we hold the lock. It 461 // has a slightly different meaning in the DRDPA ticket locks (where it is 462 // written by the acquiring thread) than it does in the simple ticket locks 463 // (where it is written by the releasing thread). 464 // 465 // Since now_serving is only read and written in the critical section, 466 // it is non-volatile, but it needs to exist on a separate cache line, 467 // as it is invalidated at every lock acquire. 468 // 469 // Likewise, the vars used for nested locks (owner_id and depth_locked) are 470 // only written by the thread owning the lock, so they are put in this cache 471 // line. owner_id is read by other threads, so it must be declared volatile. 472 KMP_ALIGN_CACHE 473 kmp_uint64 now_serving; // doesn't have to be volatile 474 volatile kmp_uint32 owner_id; // (gtid+1) of owning thread, 0 if unlocked 475 kmp_int32 depth_locked; // depth locked 476 kmp_lock_flags_t flags; // lock specifics, e.g. critical section lock 477 }; 478 479 typedef struct kmp_base_drdpa_lock kmp_base_drdpa_lock_t; 480 481 union KMP_ALIGN_CACHE kmp_drdpa_lock { 482 kmp_base_drdpa_lock_t 483 lk; // This field must be first to allow static initializing. */ 484 kmp_lock_pool_t pool; 485 double lk_align; // use worst case alignment 486 char lk_pad[KMP_PAD(kmp_base_drdpa_lock_t, CACHE_LINE)]; 487 }; 488 489 typedef union kmp_drdpa_lock kmp_drdpa_lock_t; 490 491 extern int __kmp_acquire_drdpa_lock(kmp_drdpa_lock_t *lck, kmp_int32 gtid); 492 extern int __kmp_test_drdpa_lock(kmp_drdpa_lock_t *lck, kmp_int32 gtid); 493 extern int __kmp_release_drdpa_lock(kmp_drdpa_lock_t *lck, kmp_int32 gtid); 494 extern void __kmp_init_drdpa_lock(kmp_drdpa_lock_t *lck); 495 extern void __kmp_destroy_drdpa_lock(kmp_drdpa_lock_t *lck); 496 497 extern int __kmp_acquire_nested_drdpa_lock(kmp_drdpa_lock_t *lck, 498 kmp_int32 gtid); 499 extern int __kmp_test_nested_drdpa_lock(kmp_drdpa_lock_t *lck, kmp_int32 gtid); 500 extern int __kmp_release_nested_drdpa_lock(kmp_drdpa_lock_t *lck, 501 kmp_int32 gtid); 502 extern void __kmp_init_nested_drdpa_lock(kmp_drdpa_lock_t *lck); 503 extern void __kmp_destroy_nested_drdpa_lock(kmp_drdpa_lock_t *lck); 504 505 // ============================================================================ 506 // Lock purposes. 507 // ============================================================================ 508 509 // Bootstrap locks. 510 // 511 // Bootstrap locks -- very few locks used at library initialization time. 512 // Bootstrap locks are currently implemented as ticket locks. 513 // They could also be implemented as test and set lock, but cannot be 514 // implemented with other lock kinds as they require gtids which are not 515 // available at initialization time. 516 517 typedef kmp_ticket_lock_t kmp_bootstrap_lock_t; 518 519 #define KMP_BOOTSTRAP_LOCK_INITIALIZER(lock) KMP_TICKET_LOCK_INITIALIZER((lock)) 520 #define KMP_BOOTSTRAP_LOCK_INIT(lock) \ 521 kmp_bootstrap_lock_t lock = KMP_TICKET_LOCK_INITIALIZER(lock) 522 523 static inline int __kmp_acquire_bootstrap_lock(kmp_bootstrap_lock_t *lck) { 524 return __kmp_acquire_ticket_lock(lck, KMP_GTID_DNE); 525 } 526 527 static inline int __kmp_test_bootstrap_lock(kmp_bootstrap_lock_t *lck) { 528 return __kmp_test_ticket_lock(lck, KMP_GTID_DNE); 529 } 530 531 static inline void __kmp_release_bootstrap_lock(kmp_bootstrap_lock_t *lck) { 532 __kmp_release_ticket_lock(lck, KMP_GTID_DNE); 533 } 534 535 static inline void __kmp_init_bootstrap_lock(kmp_bootstrap_lock_t *lck) { 536 __kmp_init_ticket_lock(lck); 537 } 538 539 static inline void __kmp_destroy_bootstrap_lock(kmp_bootstrap_lock_t *lck) { 540 __kmp_destroy_ticket_lock(lck); 541 } 542 543 // Internal RTL locks. 544 // 545 // Internal RTL locks are also implemented as ticket locks, for now. 546 // 547 // FIXME - We should go through and figure out which lock kind works best for 548 // each internal lock, and use the type declaration and function calls for 549 // that explicit lock kind (and get rid of this section). 550 551 typedef kmp_ticket_lock_t kmp_lock_t; 552 553 #define KMP_LOCK_INIT(lock) kmp_lock_t lock = KMP_TICKET_LOCK_INITIALIZER(lock) 554 555 static inline int __kmp_acquire_lock(kmp_lock_t *lck, kmp_int32 gtid) { 556 return __kmp_acquire_ticket_lock(lck, gtid); 557 } 558 559 static inline int __kmp_test_lock(kmp_lock_t *lck, kmp_int32 gtid) { 560 return __kmp_test_ticket_lock(lck, gtid); 561 } 562 563 static inline void __kmp_release_lock(kmp_lock_t *lck, kmp_int32 gtid) { 564 __kmp_release_ticket_lock(lck, gtid); 565 } 566 567 static inline void __kmp_init_lock(kmp_lock_t *lck) { 568 __kmp_init_ticket_lock(lck); 569 } 570 571 static inline void __kmp_destroy_lock(kmp_lock_t *lck) { 572 __kmp_destroy_ticket_lock(lck); 573 } 574 575 // User locks. 576 // 577 // Do not allocate objects of type union kmp_user_lock!!! This will waste space 578 // unless __kmp_user_lock_kind == lk_drdpa. Instead, check the value of 579 // __kmp_user_lock_kind and allocate objects of the type of the appropriate 580 // union member, and cast their addresses to kmp_user_lock_p. 581 582 enum kmp_lock_kind { 583 lk_default = 0, 584 lk_tas, 585 #if KMP_USE_FUTEX 586 lk_futex, 587 #endif 588 #if KMP_USE_DYNAMIC_LOCK && KMP_USE_TSX 589 lk_hle, 590 lk_rtm_queuing, 591 lk_rtm_spin, 592 #endif 593 lk_ticket, 594 lk_queuing, 595 lk_drdpa, 596 #if KMP_USE_ADAPTIVE_LOCKS 597 lk_adaptive 598 #endif // KMP_USE_ADAPTIVE_LOCKS 599 }; 600 601 typedef enum kmp_lock_kind kmp_lock_kind_t; 602 603 extern kmp_lock_kind_t __kmp_user_lock_kind; 604 605 union kmp_user_lock { 606 kmp_tas_lock_t tas; 607 #if KMP_USE_FUTEX 608 kmp_futex_lock_t futex; 609 #endif 610 kmp_ticket_lock_t ticket; 611 kmp_queuing_lock_t queuing; 612 kmp_drdpa_lock_t drdpa; 613 #if KMP_USE_ADAPTIVE_LOCKS 614 kmp_adaptive_lock_t adaptive; 615 #endif // KMP_USE_ADAPTIVE_LOCKS 616 kmp_lock_pool_t pool; 617 }; 618 619 typedef union kmp_user_lock *kmp_user_lock_p; 620 621 #if !KMP_USE_DYNAMIC_LOCK 622 623 extern size_t __kmp_base_user_lock_size; 624 extern size_t __kmp_user_lock_size; 625 626 extern kmp_int32 (*__kmp_get_user_lock_owner_)(kmp_user_lock_p lck); 627 628 static inline kmp_int32 __kmp_get_user_lock_owner(kmp_user_lock_p lck) { 629 KMP_DEBUG_ASSERT(__kmp_get_user_lock_owner_ != NULL); 630 return (*__kmp_get_user_lock_owner_)(lck); 631 } 632 633 extern int (*__kmp_acquire_user_lock_with_checks_)(kmp_user_lock_p lck, 634 kmp_int32 gtid); 635 636 #if KMP_OS_LINUX && \ 637 (KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_ARCH_ARM || KMP_ARCH_AARCH64) 638 639 #define __kmp_acquire_user_lock_with_checks(lck, gtid) \ 640 if (__kmp_user_lock_kind == lk_tas) { \ 641 if (__kmp_env_consistency_check) { \ 642 char const *const func = "omp_set_lock"; \ 643 if ((sizeof(kmp_tas_lock_t) <= OMP_LOCK_T_SIZE) && \ 644 lck->tas.lk.depth_locked != -1) { \ 645 KMP_FATAL(LockNestableUsedAsSimple, func); \ 646 } \ 647 if ((gtid >= 0) && (lck->tas.lk.poll - 1 == gtid)) { \ 648 KMP_FATAL(LockIsAlreadyOwned, func); \ 649 } \ 650 } \ 651 if (lck->tas.lk.poll != 0 || \ 652 !__kmp_atomic_compare_store_acq(&lck->tas.lk.poll, 0, gtid + 1)) { \ 653 kmp_uint32 spins; \ 654 KMP_FSYNC_PREPARE(lck); \ 655 KMP_INIT_YIELD(spins); \ 656 do { \ 657 KMP_YIELD_OVERSUB_ELSE_SPIN(spins); \ 658 } while (lck->tas.lk.poll != 0 || !__kmp_atomic_compare_store_acq( \ 659 &lck->tas.lk.poll, 0, gtid + 1)); \ 660 } \ 661 KMP_FSYNC_ACQUIRED(lck); \ 662 } else { \ 663 KMP_DEBUG_ASSERT(__kmp_acquire_user_lock_with_checks_ != NULL); \ 664 (*__kmp_acquire_user_lock_with_checks_)(lck, gtid); \ 665 } 666 667 #else 668 static inline int __kmp_acquire_user_lock_with_checks(kmp_user_lock_p lck, 669 kmp_int32 gtid) { 670 KMP_DEBUG_ASSERT(__kmp_acquire_user_lock_with_checks_ != NULL); 671 return (*__kmp_acquire_user_lock_with_checks_)(lck, gtid); 672 } 673 #endif 674 675 extern int (*__kmp_test_user_lock_with_checks_)(kmp_user_lock_p lck, 676 kmp_int32 gtid); 677 678 #if KMP_OS_LINUX && \ 679 (KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_ARCH_ARM || KMP_ARCH_AARCH64) 680 681 #include "kmp_i18n.h" /* AC: KMP_FATAL definition */ 682 extern int __kmp_env_consistency_check; /* AC: copy from kmp.h here */ 683 static inline int __kmp_test_user_lock_with_checks(kmp_user_lock_p lck, 684 kmp_int32 gtid) { 685 if (__kmp_user_lock_kind == lk_tas) { 686 if (__kmp_env_consistency_check) { 687 char const *const func = "omp_test_lock"; 688 if ((sizeof(kmp_tas_lock_t) <= OMP_LOCK_T_SIZE) && 689 lck->tas.lk.depth_locked != -1) { 690 KMP_FATAL(LockNestableUsedAsSimple, func); 691 } 692 } 693 return ((lck->tas.lk.poll == 0) && 694 __kmp_atomic_compare_store_acq(&lck->tas.lk.poll, 0, gtid + 1)); 695 } else { 696 KMP_DEBUG_ASSERT(__kmp_test_user_lock_with_checks_ != NULL); 697 return (*__kmp_test_user_lock_with_checks_)(lck, gtid); 698 } 699 } 700 #else 701 static inline int __kmp_test_user_lock_with_checks(kmp_user_lock_p lck, 702 kmp_int32 gtid) { 703 KMP_DEBUG_ASSERT(__kmp_test_user_lock_with_checks_ != NULL); 704 return (*__kmp_test_user_lock_with_checks_)(lck, gtid); 705 } 706 #endif 707 708 extern int (*__kmp_release_user_lock_with_checks_)(kmp_user_lock_p lck, 709 kmp_int32 gtid); 710 711 static inline void __kmp_release_user_lock_with_checks(kmp_user_lock_p lck, 712 kmp_int32 gtid) { 713 KMP_DEBUG_ASSERT(__kmp_release_user_lock_with_checks_ != NULL); 714 (*__kmp_release_user_lock_with_checks_)(lck, gtid); 715 } 716 717 extern void (*__kmp_init_user_lock_with_checks_)(kmp_user_lock_p lck); 718 719 static inline void __kmp_init_user_lock_with_checks(kmp_user_lock_p lck) { 720 KMP_DEBUG_ASSERT(__kmp_init_user_lock_with_checks_ != NULL); 721 (*__kmp_init_user_lock_with_checks_)(lck); 722 } 723 724 // We need a non-checking version of destroy lock for when the RTL is 725 // doing the cleanup as it can't always tell if the lock is nested or not. 726 extern void (*__kmp_destroy_user_lock_)(kmp_user_lock_p lck); 727 728 static inline void __kmp_destroy_user_lock(kmp_user_lock_p lck) { 729 KMP_DEBUG_ASSERT(__kmp_destroy_user_lock_ != NULL); 730 (*__kmp_destroy_user_lock_)(lck); 731 } 732 733 extern void (*__kmp_destroy_user_lock_with_checks_)(kmp_user_lock_p lck); 734 735 static inline void __kmp_destroy_user_lock_with_checks(kmp_user_lock_p lck) { 736 KMP_DEBUG_ASSERT(__kmp_destroy_user_lock_with_checks_ != NULL); 737 (*__kmp_destroy_user_lock_with_checks_)(lck); 738 } 739 740 extern int (*__kmp_acquire_nested_user_lock_with_checks_)(kmp_user_lock_p lck, 741 kmp_int32 gtid); 742 743 #if KMP_OS_LINUX && (KMP_ARCH_X86 || KMP_ARCH_X86_64) 744 745 #define __kmp_acquire_nested_user_lock_with_checks(lck, gtid, depth) \ 746 if (__kmp_user_lock_kind == lk_tas) { \ 747 if (__kmp_env_consistency_check) { \ 748 char const *const func = "omp_set_nest_lock"; \ 749 if ((sizeof(kmp_tas_lock_t) <= OMP_NEST_LOCK_T_SIZE) && \ 750 lck->tas.lk.depth_locked == -1) { \ 751 KMP_FATAL(LockSimpleUsedAsNestable, func); \ 752 } \ 753 } \ 754 if (lck->tas.lk.poll - 1 == gtid) { \ 755 lck->tas.lk.depth_locked += 1; \ 756 *depth = KMP_LOCK_ACQUIRED_NEXT; \ 757 } else { \ 758 if ((lck->tas.lk.poll != 0) || \ 759 !__kmp_atomic_compare_store_acq(&lck->tas.lk.poll, 0, gtid + 1)) { \ 760 kmp_uint32 spins; \ 761 KMP_FSYNC_PREPARE(lck); \ 762 KMP_INIT_YIELD(spins); \ 763 do { \ 764 KMP_YIELD_OVERSUB_ELSE_SPIN(spins); \ 765 } while ( \ 766 (lck->tas.lk.poll != 0) || \ 767 !__kmp_atomic_compare_store_acq(&lck->tas.lk.poll, 0, gtid + 1)); \ 768 } \ 769 lck->tas.lk.depth_locked = 1; \ 770 *depth = KMP_LOCK_ACQUIRED_FIRST; \ 771 } \ 772 KMP_FSYNC_ACQUIRED(lck); \ 773 } else { \ 774 KMP_DEBUG_ASSERT(__kmp_acquire_nested_user_lock_with_checks_ != NULL); \ 775 *depth = (*__kmp_acquire_nested_user_lock_with_checks_)(lck, gtid); \ 776 } 777 778 #else 779 static inline void 780 __kmp_acquire_nested_user_lock_with_checks(kmp_user_lock_p lck, kmp_int32 gtid, 781 int *depth) { 782 KMP_DEBUG_ASSERT(__kmp_acquire_nested_user_lock_with_checks_ != NULL); 783 *depth = (*__kmp_acquire_nested_user_lock_with_checks_)(lck, gtid); 784 } 785 #endif 786 787 extern int (*__kmp_test_nested_user_lock_with_checks_)(kmp_user_lock_p lck, 788 kmp_int32 gtid); 789 790 #if KMP_OS_LINUX && (KMP_ARCH_X86 || KMP_ARCH_X86_64) 791 static inline int __kmp_test_nested_user_lock_with_checks(kmp_user_lock_p lck, 792 kmp_int32 gtid) { 793 if (__kmp_user_lock_kind == lk_tas) { 794 int retval; 795 if (__kmp_env_consistency_check) { 796 char const *const func = "omp_test_nest_lock"; 797 if ((sizeof(kmp_tas_lock_t) <= OMP_NEST_LOCK_T_SIZE) && 798 lck->tas.lk.depth_locked == -1) { 799 KMP_FATAL(LockSimpleUsedAsNestable, func); 800 } 801 } 802 KMP_DEBUG_ASSERT(gtid >= 0); 803 if (lck->tas.lk.poll - 1 == 804 gtid) { /* __kmp_get_tas_lock_owner( lck ) == gtid */ 805 return ++lck->tas.lk.depth_locked; /* same owner, depth increased */ 806 } 807 retval = ((lck->tas.lk.poll == 0) && 808 __kmp_atomic_compare_store_acq(&lck->tas.lk.poll, 0, gtid + 1)); 809 if (retval) { 810 KMP_MB(); 811 lck->tas.lk.depth_locked = 1; 812 } 813 return retval; 814 } else { 815 KMP_DEBUG_ASSERT(__kmp_test_nested_user_lock_with_checks_ != NULL); 816 return (*__kmp_test_nested_user_lock_with_checks_)(lck, gtid); 817 } 818 } 819 #else 820 static inline int __kmp_test_nested_user_lock_with_checks(kmp_user_lock_p lck, 821 kmp_int32 gtid) { 822 KMP_DEBUG_ASSERT(__kmp_test_nested_user_lock_with_checks_ != NULL); 823 return (*__kmp_test_nested_user_lock_with_checks_)(lck, gtid); 824 } 825 #endif 826 827 extern int (*__kmp_release_nested_user_lock_with_checks_)(kmp_user_lock_p lck, 828 kmp_int32 gtid); 829 830 static inline int 831 __kmp_release_nested_user_lock_with_checks(kmp_user_lock_p lck, 832 kmp_int32 gtid) { 833 KMP_DEBUG_ASSERT(__kmp_release_nested_user_lock_with_checks_ != NULL); 834 return (*__kmp_release_nested_user_lock_with_checks_)(lck, gtid); 835 } 836 837 extern void (*__kmp_init_nested_user_lock_with_checks_)(kmp_user_lock_p lck); 838 839 static inline void 840 __kmp_init_nested_user_lock_with_checks(kmp_user_lock_p lck) { 841 KMP_DEBUG_ASSERT(__kmp_init_nested_user_lock_with_checks_ != NULL); 842 (*__kmp_init_nested_user_lock_with_checks_)(lck); 843 } 844 845 extern void (*__kmp_destroy_nested_user_lock_with_checks_)(kmp_user_lock_p lck); 846 847 static inline void 848 __kmp_destroy_nested_user_lock_with_checks(kmp_user_lock_p lck) { 849 KMP_DEBUG_ASSERT(__kmp_destroy_nested_user_lock_with_checks_ != NULL); 850 (*__kmp_destroy_nested_user_lock_with_checks_)(lck); 851 } 852 853 // user lock functions which do not necessarily exist for all lock kinds. 854 // 855 // The "set" functions usually have wrapper routines that check for a NULL set 856 // function pointer and call it if non-NULL. 857 // 858 // In some cases, it makes sense to have a "get" wrapper function check for a 859 // NULL get function pointer and return NULL / invalid value / error code if 860 // the function pointer is NULL. 861 // 862 // In other cases, the calling code really should differentiate between an 863 // unimplemented function and one that is implemented but returning NULL / 864 // invalid value. If this is the case, no get function wrapper exists. 865 866 extern int (*__kmp_is_user_lock_initialized_)(kmp_user_lock_p lck); 867 868 // no set function; fields set during local allocation 869 870 extern const ident_t *(*__kmp_get_user_lock_location_)(kmp_user_lock_p lck); 871 872 static inline const ident_t *__kmp_get_user_lock_location(kmp_user_lock_p lck) { 873 if (__kmp_get_user_lock_location_ != NULL) { 874 return (*__kmp_get_user_lock_location_)(lck); 875 } else { 876 return NULL; 877 } 878 } 879 880 extern void (*__kmp_set_user_lock_location_)(kmp_user_lock_p lck, 881 const ident_t *loc); 882 883 static inline void __kmp_set_user_lock_location(kmp_user_lock_p lck, 884 const ident_t *loc) { 885 if (__kmp_set_user_lock_location_ != NULL) { 886 (*__kmp_set_user_lock_location_)(lck, loc); 887 } 888 } 889 890 extern kmp_lock_flags_t (*__kmp_get_user_lock_flags_)(kmp_user_lock_p lck); 891 892 extern void (*__kmp_set_user_lock_flags_)(kmp_user_lock_p lck, 893 kmp_lock_flags_t flags); 894 895 static inline void __kmp_set_user_lock_flags(kmp_user_lock_p lck, 896 kmp_lock_flags_t flags) { 897 if (__kmp_set_user_lock_flags_ != NULL) { 898 (*__kmp_set_user_lock_flags_)(lck, flags); 899 } 900 } 901 902 // The function which sets up all of the vtbl pointers for kmp_user_lock_t. 903 extern void __kmp_set_user_lock_vptrs(kmp_lock_kind_t user_lock_kind); 904 905 // Macros for binding user lock functions. 906 #define KMP_BIND_USER_LOCK_TEMPLATE(nest, kind, suffix) \ 907 { \ 908 __kmp_acquire##nest##user_lock_with_checks_ = (int (*)( \ 909 kmp_user_lock_p, kmp_int32))__kmp_acquire##nest##kind##_##suffix; \ 910 __kmp_release##nest##user_lock_with_checks_ = (int (*)( \ 911 kmp_user_lock_p, kmp_int32))__kmp_release##nest##kind##_##suffix; \ 912 __kmp_test##nest##user_lock_with_checks_ = (int (*)( \ 913 kmp_user_lock_p, kmp_int32))__kmp_test##nest##kind##_##suffix; \ 914 __kmp_init##nest##user_lock_with_checks_ = \ 915 (void (*)(kmp_user_lock_p))__kmp_init##nest##kind##_##suffix; \ 916 __kmp_destroy##nest##user_lock_with_checks_ = \ 917 (void (*)(kmp_user_lock_p))__kmp_destroy##nest##kind##_##suffix; \ 918 } 919 920 #define KMP_BIND_USER_LOCK(kind) KMP_BIND_USER_LOCK_TEMPLATE(_, kind, lock) 921 #define KMP_BIND_USER_LOCK_WITH_CHECKS(kind) \ 922 KMP_BIND_USER_LOCK_TEMPLATE(_, kind, lock_with_checks) 923 #define KMP_BIND_NESTED_USER_LOCK(kind) \ 924 KMP_BIND_USER_LOCK_TEMPLATE(_nested_, kind, lock) 925 #define KMP_BIND_NESTED_USER_LOCK_WITH_CHECKS(kind) \ 926 KMP_BIND_USER_LOCK_TEMPLATE(_nested_, kind, lock_with_checks) 927 928 // User lock table & lock allocation 929 /* On 64-bit Linux* OS (and OS X*) GNU compiler allocates only 4 bytems memory 930 for lock variable, which is not enough to store a pointer, so we have to use 931 lock indexes instead of pointers and maintain lock table to map indexes to 932 pointers. 933 934 935 Note: The first element of the table is not a pointer to lock! It is a 936 pointer to previously allocated table (or NULL if it is the first table). 937 938 Usage: 939 940 if ( OMP_LOCK_T_SIZE < sizeof( <lock> ) ) { // or OMP_NEST_LOCK_T_SIZE 941 Lock table is fully utilized. User locks are indexes, so table is used on 942 user lock operation. 943 Note: it may be the case (lin_32) that we don't need to use a lock 944 table for regular locks, but do need the table for nested locks. 945 } 946 else { 947 Lock table initialized but not actually used. 948 } 949 */ 950 951 struct kmp_lock_table { 952 kmp_lock_index_t used; // Number of used elements 953 kmp_lock_index_t allocated; // Number of allocated elements 954 kmp_user_lock_p *table; // Lock table. 955 }; 956 957 typedef struct kmp_lock_table kmp_lock_table_t; 958 959 extern kmp_lock_table_t __kmp_user_lock_table; 960 extern kmp_user_lock_p __kmp_lock_pool; 961 962 struct kmp_block_of_locks { 963 struct kmp_block_of_locks *next_block; 964 void *locks; 965 }; 966 967 typedef struct kmp_block_of_locks kmp_block_of_locks_t; 968 969 extern kmp_block_of_locks_t *__kmp_lock_blocks; 970 extern int __kmp_num_locks_in_block; 971 972 extern kmp_user_lock_p __kmp_user_lock_allocate(void **user_lock, 973 kmp_int32 gtid, 974 kmp_lock_flags_t flags); 975 extern void __kmp_user_lock_free(void **user_lock, kmp_int32 gtid, 976 kmp_user_lock_p lck); 977 extern kmp_user_lock_p __kmp_lookup_user_lock(void **user_lock, 978 char const *func); 979 extern void __kmp_cleanup_user_locks(); 980 981 #define KMP_CHECK_USER_LOCK_INIT() \ 982 { \ 983 if (!TCR_4(__kmp_init_user_locks)) { \ 984 __kmp_acquire_bootstrap_lock(&__kmp_initz_lock); \ 985 if (!TCR_4(__kmp_init_user_locks)) { \ 986 TCW_4(__kmp_init_user_locks, TRUE); \ 987 } \ 988 __kmp_release_bootstrap_lock(&__kmp_initz_lock); \ 989 } \ 990 } 991 992 #endif // KMP_USE_DYNAMIC_LOCK 993 994 #undef KMP_PAD 995 #undef KMP_GTID_DNE 996 997 #if KMP_USE_DYNAMIC_LOCK 998 // KMP_USE_DYNAMIC_LOCK enables dynamic dispatch of lock functions without 999 // breaking the current compatibility. Essential functionality of this new code 1000 // is dynamic dispatch, but it also implements (or enables implementation of) 1001 // hinted user lock and critical section which will be part of OMP 4.5 soon. 1002 // 1003 // Lock type can be decided at creation time (i.e., lock initialization), and 1004 // subsequent lock function call on the created lock object requires type 1005 // extraction and call through jump table using the extracted type. This type 1006 // information is stored in two different ways depending on the size of the lock 1007 // object, and we differentiate lock types by this size requirement - direct and 1008 // indirect locks. 1009 // 1010 // Direct locks: 1011 // A direct lock object fits into the space created by the compiler for an 1012 // omp_lock_t object, and TAS/Futex lock falls into this category. We use low 1013 // one byte of the lock object as the storage for the lock type, and appropriate 1014 // bit operation is required to access the data meaningful to the lock 1015 // algorithms. Also, to differentiate direct lock from indirect lock, 1 is 1016 // written to LSB of the lock object. The newly introduced "hle" lock is also a 1017 // direct lock. 1018 // 1019 // Indirect locks: 1020 // An indirect lock object requires more space than the compiler-generated 1021 // space, and it should be allocated from heap. Depending on the size of the 1022 // compiler-generated space for the lock (i.e., size of omp_lock_t), this 1023 // omp_lock_t object stores either the address of the heap-allocated indirect 1024 // lock (void * fits in the object) or an index to the indirect lock table entry 1025 // that holds the address. Ticket/Queuing/DRDPA/Adaptive lock falls into this 1026 // category, and the newly introduced "rtm" lock is also an indirect lock which 1027 // was implemented on top of the Queuing lock. When the omp_lock_t object holds 1028 // an index (not lock address), 0 is written to LSB to differentiate the lock 1029 // from a direct lock, and the remaining part is the actual index to the 1030 // indirect lock table. 1031 1032 #include <stdint.h> // for uintptr_t 1033 1034 // Shortcuts 1035 #define KMP_USE_INLINED_TAS \ 1036 (KMP_OS_LINUX && (KMP_ARCH_X86 || KMP_ARCH_X86_64 || KMP_ARCH_ARM)) && 1 1037 #define KMP_USE_INLINED_FUTEX KMP_USE_FUTEX && 0 1038 1039 // List of lock definitions; all nested locks are indirect locks. 1040 // hle lock is xchg lock prefixed with XACQUIRE/XRELEASE. 1041 // All nested locks are indirect lock types. 1042 #if KMP_USE_TSX 1043 #if KMP_USE_FUTEX 1044 #define KMP_FOREACH_D_LOCK(m, a) m(tas, a) m(futex, a) m(hle, a) m(rtm_spin, a) 1045 #define KMP_FOREACH_I_LOCK(m, a) \ 1046 m(ticket, a) m(queuing, a) m(adaptive, a) m(drdpa, a) m(rtm_queuing, a) \ 1047 m(nested_tas, a) m(nested_futex, a) m(nested_ticket, a) \ 1048 m(nested_queuing, a) m(nested_drdpa, a) 1049 #else 1050 #define KMP_FOREACH_D_LOCK(m, a) m(tas, a) m(hle, a) m(rtm_spin, a) 1051 #define KMP_FOREACH_I_LOCK(m, a) \ 1052 m(ticket, a) m(queuing, a) m(adaptive, a) m(drdpa, a) m(rtm_queuing, a) \ 1053 m(nested_tas, a) m(nested_ticket, a) m(nested_queuing, a) \ 1054 m(nested_drdpa, a) 1055 #endif // KMP_USE_FUTEX 1056 #define KMP_LAST_D_LOCK lockseq_rtm_spin 1057 #else 1058 #if KMP_USE_FUTEX 1059 #define KMP_FOREACH_D_LOCK(m, a) m(tas, a) m(futex, a) 1060 #define KMP_FOREACH_I_LOCK(m, a) \ 1061 m(ticket, a) m(queuing, a) m(drdpa, a) m(nested_tas, a) m(nested_futex, a) \ 1062 m(nested_ticket, a) m(nested_queuing, a) m(nested_drdpa, a) 1063 #define KMP_LAST_D_LOCK lockseq_futex 1064 #else 1065 #define KMP_FOREACH_D_LOCK(m, a) m(tas, a) 1066 #define KMP_FOREACH_I_LOCK(m, a) \ 1067 m(ticket, a) m(queuing, a) m(drdpa, a) m(nested_tas, a) m(nested_ticket, a) \ 1068 m(nested_queuing, a) m(nested_drdpa, a) 1069 #define KMP_LAST_D_LOCK lockseq_tas 1070 #endif // KMP_USE_FUTEX 1071 #endif // KMP_USE_TSX 1072 1073 // Information used in dynamic dispatch 1074 #define KMP_LOCK_SHIFT \ 1075 8 // number of low bits to be used as tag for direct locks 1076 #define KMP_FIRST_D_LOCK lockseq_tas 1077 #define KMP_FIRST_I_LOCK lockseq_ticket 1078 #define KMP_LAST_I_LOCK lockseq_nested_drdpa 1079 #define KMP_NUM_I_LOCKS \ 1080 (locktag_nested_drdpa + 1) // number of indirect lock types 1081 1082 // Base type for dynamic locks. 1083 typedef kmp_uint32 kmp_dyna_lock_t; 1084 1085 // Lock sequence that enumerates all lock kinds. Always make this enumeration 1086 // consistent with kmp_lockseq_t in the include directory. 1087 typedef enum { 1088 lockseq_indirect = 0, 1089 #define expand_seq(l, a) lockseq_##l, 1090 KMP_FOREACH_D_LOCK(expand_seq, 0) KMP_FOREACH_I_LOCK(expand_seq, 0) 1091 #undef expand_seq 1092 } kmp_dyna_lockseq_t; 1093 1094 // Enumerates indirect lock tags. 1095 typedef enum { 1096 #define expand_tag(l, a) locktag_##l, 1097 KMP_FOREACH_I_LOCK(expand_tag, 0) 1098 #undef expand_tag 1099 } kmp_indirect_locktag_t; 1100 1101 // Utility macros that extract information from lock sequences. 1102 #define KMP_IS_D_LOCK(seq) \ 1103 ((seq) >= KMP_FIRST_D_LOCK && (seq) <= KMP_LAST_D_LOCK) 1104 #define KMP_IS_I_LOCK(seq) \ 1105 ((seq) >= KMP_FIRST_I_LOCK && (seq) <= KMP_LAST_I_LOCK) 1106 #define KMP_GET_I_TAG(seq) (kmp_indirect_locktag_t)((seq)-KMP_FIRST_I_LOCK) 1107 #define KMP_GET_D_TAG(seq) ((seq) << 1 | 1) 1108 1109 // Enumerates direct lock tags starting from indirect tag. 1110 typedef enum { 1111 #define expand_tag(l, a) locktag_##l = KMP_GET_D_TAG(lockseq_##l), 1112 KMP_FOREACH_D_LOCK(expand_tag, 0) 1113 #undef expand_tag 1114 } kmp_direct_locktag_t; 1115 1116 // Indirect lock type 1117 typedef struct { 1118 kmp_user_lock_p lock; 1119 kmp_indirect_locktag_t type; 1120 } kmp_indirect_lock_t; 1121 1122 // Function tables for direct locks. Set/unset/test differentiate functions 1123 // with/without consistency checking. 1124 extern void (*__kmp_direct_init[])(kmp_dyna_lock_t *, kmp_dyna_lockseq_t); 1125 extern void (**__kmp_direct_destroy)(kmp_dyna_lock_t *); 1126 extern int (**__kmp_direct_set)(kmp_dyna_lock_t *, kmp_int32); 1127 extern int (**__kmp_direct_unset)(kmp_dyna_lock_t *, kmp_int32); 1128 extern int (**__kmp_direct_test)(kmp_dyna_lock_t *, kmp_int32); 1129 1130 // Function tables for indirect locks. Set/unset/test differentiate functions 1131 // with/without consistency checking. 1132 extern void (*__kmp_indirect_init[])(kmp_user_lock_p); 1133 extern void (**__kmp_indirect_destroy)(kmp_user_lock_p); 1134 extern int (**__kmp_indirect_set)(kmp_user_lock_p, kmp_int32); 1135 extern int (**__kmp_indirect_unset)(kmp_user_lock_p, kmp_int32); 1136 extern int (**__kmp_indirect_test)(kmp_user_lock_p, kmp_int32); 1137 1138 // Extracts direct lock tag from a user lock pointer 1139 #define KMP_EXTRACT_D_TAG(l) \ 1140 (*((kmp_dyna_lock_t *)(l)) & ((1 << KMP_LOCK_SHIFT) - 1) & \ 1141 -(*((kmp_dyna_lock_t *)(l)) & 1)) 1142 1143 // Extracts indirect lock index from a user lock pointer 1144 #define KMP_EXTRACT_I_INDEX(l) (*(kmp_lock_index_t *)(l) >> 1) 1145 1146 // Returns function pointer to the direct lock function with l (kmp_dyna_lock_t 1147 // *) and op (operation type). 1148 #define KMP_D_LOCK_FUNC(l, op) __kmp_direct_##op[KMP_EXTRACT_D_TAG(l)] 1149 1150 // Returns function pointer to the indirect lock function with l 1151 // (kmp_indirect_lock_t *) and op (operation type). 1152 #define KMP_I_LOCK_FUNC(l, op) \ 1153 __kmp_indirect_##op[((kmp_indirect_lock_t *)(l))->type] 1154 1155 // Initializes a direct lock with the given lock pointer and lock sequence. 1156 #define KMP_INIT_D_LOCK(l, seq) \ 1157 __kmp_direct_init[KMP_GET_D_TAG(seq)]((kmp_dyna_lock_t *)l, seq) 1158 1159 // Initializes an indirect lock with the given lock pointer and lock sequence. 1160 #define KMP_INIT_I_LOCK(l, seq) \ 1161 __kmp_direct_init[0]((kmp_dyna_lock_t *)(l), seq) 1162 1163 // Returns "free" lock value for the given lock type. 1164 #define KMP_LOCK_FREE(type) (locktag_##type) 1165 1166 // Returns "busy" lock value for the given lock teyp. 1167 #define KMP_LOCK_BUSY(v, type) ((v) << KMP_LOCK_SHIFT | locktag_##type) 1168 1169 // Returns lock value after removing (shifting) lock tag. 1170 #define KMP_LOCK_STRIP(v) ((v) >> KMP_LOCK_SHIFT) 1171 1172 // Initializes global states and data structures for managing dynamic user 1173 // locks. 1174 extern void __kmp_init_dynamic_user_locks(); 1175 1176 // Allocates and returns an indirect lock with the given indirect lock tag. 1177 extern kmp_indirect_lock_t * 1178 __kmp_allocate_indirect_lock(void **, kmp_int32, kmp_indirect_locktag_t); 1179 1180 // Cleans up global states and data structures for managing dynamic user locks. 1181 extern void __kmp_cleanup_indirect_user_locks(); 1182 1183 // Default user lock sequence when not using hinted locks. 1184 extern kmp_dyna_lockseq_t __kmp_user_lock_seq; 1185 1186 // Jump table for "set lock location", available only for indirect locks. 1187 extern void (*__kmp_indirect_set_location[KMP_NUM_I_LOCKS])(kmp_user_lock_p, 1188 const ident_t *); 1189 #define KMP_SET_I_LOCK_LOCATION(lck, loc) \ 1190 { \ 1191 if (__kmp_indirect_set_location[(lck)->type] != NULL) \ 1192 __kmp_indirect_set_location[(lck)->type]((lck)->lock, loc); \ 1193 } 1194 1195 // Jump table for "set lock flags", available only for indirect locks. 1196 extern void (*__kmp_indirect_set_flags[KMP_NUM_I_LOCKS])(kmp_user_lock_p, 1197 kmp_lock_flags_t); 1198 #define KMP_SET_I_LOCK_FLAGS(lck, flag) \ 1199 { \ 1200 if (__kmp_indirect_set_flags[(lck)->type] != NULL) \ 1201 __kmp_indirect_set_flags[(lck)->type]((lck)->lock, flag); \ 1202 } 1203 1204 // Jump table for "get lock location", available only for indirect locks. 1205 extern const ident_t *(*__kmp_indirect_get_location[KMP_NUM_I_LOCKS])( 1206 kmp_user_lock_p); 1207 #define KMP_GET_I_LOCK_LOCATION(lck) \ 1208 (__kmp_indirect_get_location[(lck)->type] != NULL \ 1209 ? __kmp_indirect_get_location[(lck)->type]((lck)->lock) \ 1210 : NULL) 1211 1212 // Jump table for "get lock flags", available only for indirect locks. 1213 extern kmp_lock_flags_t (*__kmp_indirect_get_flags[KMP_NUM_I_LOCKS])( 1214 kmp_user_lock_p); 1215 #define KMP_GET_I_LOCK_FLAGS(lck) \ 1216 (__kmp_indirect_get_flags[(lck)->type] != NULL \ 1217 ? __kmp_indirect_get_flags[(lck)->type]((lck)->lock) \ 1218 : NULL) 1219 1220 #define KMP_I_LOCK_CHUNK \ 1221 1024 // number of kmp_indirect_lock_t objects to be allocated together 1222 1223 // Lock table for indirect locks. 1224 typedef struct kmp_indirect_lock_table { 1225 kmp_indirect_lock_t **table; // blocks of indirect locks allocated 1226 kmp_lock_index_t size; // size of the indirect lock table 1227 kmp_lock_index_t next; // index to the next lock to be allocated 1228 } kmp_indirect_lock_table_t; 1229 1230 extern kmp_indirect_lock_table_t __kmp_i_lock_table; 1231 1232 // Returns the indirect lock associated with the given index. 1233 #define KMP_GET_I_LOCK(index) \ 1234 (*(__kmp_i_lock_table.table + (index) / KMP_I_LOCK_CHUNK) + \ 1235 (index) % KMP_I_LOCK_CHUNK) 1236 1237 // Number of locks in a lock block, which is fixed to "1" now. 1238 // TODO: No lock block implementation now. If we do support, we need to manage 1239 // lock block data structure for each indirect lock type. 1240 extern int __kmp_num_locks_in_block; 1241 1242 // Fast lock table lookup without consistency checking 1243 #define KMP_LOOKUP_I_LOCK(l) \ 1244 ((OMP_LOCK_T_SIZE < sizeof(void *)) ? KMP_GET_I_LOCK(KMP_EXTRACT_I_INDEX(l)) \ 1245 : *((kmp_indirect_lock_t **)(l))) 1246 1247 // Used once in kmp_error.cpp 1248 extern kmp_int32 __kmp_get_user_lock_owner(kmp_user_lock_p, kmp_uint32); 1249 1250 #else // KMP_USE_DYNAMIC_LOCK 1251 1252 #define KMP_LOCK_BUSY(v, type) (v) 1253 #define KMP_LOCK_FREE(type) 0 1254 #define KMP_LOCK_STRIP(v) (v) 1255 1256 #endif // KMP_USE_DYNAMIC_LOCK 1257 1258 // data structure for using backoff within spin locks. 1259 typedef struct { 1260 kmp_uint32 step; // current step 1261 kmp_uint32 max_backoff; // upper bound of outer delay loop 1262 kmp_uint32 min_tick; // size of inner delay loop in ticks (machine-dependent) 1263 } kmp_backoff_t; 1264 1265 // Runtime's default backoff parameters 1266 extern kmp_backoff_t __kmp_spin_backoff_params; 1267 1268 // Backoff function 1269 extern void __kmp_spin_backoff(kmp_backoff_t *); 1270 1271 #ifdef __cplusplus 1272 } // extern "C" 1273 #endif // __cplusplus 1274 1275 #endif /* KMP_LOCK_H */ 1276