Lines Matching +defs:a +defs:code
22 the Altix. Requires user code to be linked with -lrt. */
215 /*! To mark a 'barrier' directive in user code */
226 /*! To mark a static loop in OMPT callbacks */
228 /*! To mark a sections directive in OMPT callbacks */
230 /*! To mark a distribute construct in OMPT callbacks */
235 should be used in a different flag. */
245 * The ident structure that describes a source location.
259 which describe the source file, the function and a pair
289 /* Pack two 32-bit signed integers into a 64-bit signed integer */
307 while ((*(_x) >= '0' && *(_x) <= '9') || (*(_x) >= 'a' && *(_x) <= 'z') || \
368 * Describes the loop schedule to be used for a parallel for loop.
411 /* For the "nomerge" versions, kmp_dispatch_next*() will always return a
451 Since we're passing a full 32 bit value, we can use a couple of high bits
457 code won't ever see schedules with these bits set. */
565 // 0: (packed_reduction_method & 0x000000FF) is a 'enum barrier_type' value of
568 // 1: (packed_reduction_method & 0x0000FF00) is a reduction method that will
571 // so that the bits of 0-th byte are empty, so no need to execute a shift
804 // Factory functions to allocate/deallocate a mask
1034 // We need to avoid using -1 as a GTID as +1 is added to the gtid
1035 // when storing it in a lock, and the value 0 is reserved.
1180 // VE's pthread supports only up to 64 threads per a VE process.
1248 /* Calculate new number of monitor wakeups for a specific block time based on
1257 /* Calculate number of intervals for a specific block time based on
1417 : "=a"(p->eax), "=b"(p->ebx), "=c"(p->ecx), "=d"(p->edx)
1418 : "a"(leaf), "c"(subleaf));
1488 // in 32-bit mode: a, b, c, and d;
1491 : "a"(timeLo), "d"(timeHi), "c"(hint)
1503 : "a"(cacheline)
1518 // in 32-bit mode: a, b, c, and d;
1521 : "a"(timeLo), "d"(timeHi), "c"(hint)
1622 // requested. Uses a timed TPAUSE, and exponential backoff. If TPAUSE isn't
1727 long nswap; /* the number of times a process was "swapped" out of memory */
1730 long nvcsw; /* the number of times a context switch was voluntarily */
1731 long nivcsw; /* the number of times a context switch was forced */
1745 The type for a microtask which gets passed to @ref __kmpc_fork_call().
1875 // Shared barrier data that exists inside a single unit of the scheduling
1888 unsigned use_hier : 1; // Used in KMP_USE_HIER_SCHED code
1889 unsigned use_hybrid : 1; // Used in KMP_WEIGHTED_ITERATIONS_SUPPORTED code
1909 // a) parm3 is properly aligned and
1949 // a) parm3 is properly aligned and
2025 std::atomic<kmp_uint32> steal_flag; // static_steal only, state of a buffer
2071 // machines (> 48 cores). Performance analysis showed that a cache thrash
2147 bs_last_barrier /* Just a placeholder to mark the end */
2184 int task_thread_limit; /* internal control for thread-limit-var of a task*/
2227 // arrives to a barrier.
2249 // increased by 1 when the primary thread arrives to a barrier, the second
2260 threads when a condition changes. This is to workaround an NPTL bug where
2276 /* Number of threads to release via a <cond_broadcast> or a <cond_signal> */
2323 within debugee process, but it is a *new* handle which does *not* equal to
2362 #define KMP_CHECK_UPDATE(a, b) \
2363 if ((a) != (b)) \
2364 (a) = (b)
2365 #define KMP_CHECK_UPDATE_SYNC(a, b) \
2366 if ((a) != (b)) \
2367 TCW_SYNC_PTR((a), (b))
2448 // The tt_found_tasks flag is a signal to all threads in the team that tasks
2518 struct { // flag as a set of 8 bits
2619 /// Represents a TDG node
2631 /// Represent a TDG's current status
2638 /// Structure that contains a TDG
2641 kmp_taskgraph_flags_t tdg_flags; // Flags related to a TDG
2716 code path */
2717 unsigned destructors_thunk : 1; /* set if the compiler creates a thunk to
2719 unsigned proxy : 1; /* task is a proxy task (it will be executed outside the
2790 // GOMP sends in a copy function for copy constructors
2798 bool is_taskgraph = 0; // whether the task is within a TDG
2799 kmp_tdg_info_t *tdg; // used to associate task with a TDG
2910 kmp_int32 nteams; // number of teams in a league
2914 // This struct stores a thread that acts as a "root" for a contention
2917 // This struct therefore also stores a thread_limit associated with
2918 // that contention group, and a counter to track the number of threads
2919 // active in that contention group. Each thread has a list of these: CG
2921 // the thread itself, whereas other workers in the CG will have a
2923 // root. When a thread encounters a teams construct, it will add a new
2924 // entry to the front of its list, because it now roots a new CG.
2926 kmp_info_p *cg_root; // "root" thread for a contention group
2950 int th_team_nproc; /* number of threads in a team */
2958 /* at the start of a barrier, and the values stored in the team are used */
2959 /* at points in the code where the team struct is no longer guaranteed */
3022 volatile void *th_sleep_loc; // this points at a kmp_flag<T>
3115 // t_inline_argv. Historically, we have supported at least 96 bytes. Using a
3204 // Using CACHE_LINE=64 reduces memory footprint, but causes a big perf
3268 volatile int r_active; /* TRUE if some region in a nest has > 1 thread */
3269 // keeps a count of active parallel regions per root
3467 // maximum total number of concurrently-existing threads in a contention group
3469 extern int __kmp_task_max_nth; // max threads used in a task
3470 extern int __kmp_teams_max_nth; // max threads used in a teams construct
3473 extern int __kmp_dflt_team_nth; /* default number of threads in a parallel
3474 region a la OMP_NUM_THREADS */
3565 // Number of soft retries before it counts as a hard retry.
3567 // Badness is a bit mask : 0,1,3,7,15,... on each hard failure we move one to
4071 fork_context_gnu, /**< Called from GNU generated code, so must not invoke the
4073 fork_context_intel, /**< Called from Intel generated code. */
4393 // __kmp_tdg_is_recording: check whether a given TDG is recording
4602 // Check whether a given thread is a hidden helper thread
4615 // Map a gtid to a hidden helper thread. The first hidden helper thread, a.k.a
4711 /// This class safely opens and closes a C-style FILE* object using RAII
4715 /// a FILE* object e.g., fprintf().
4744 int code = errno;
4746 __kmp_fatal(KMP_MSG(CantOpenFileForReading, filename), KMP_ERR(code),
4749 __kmp_fatal(KMP_MSG(CantOpenFileForReading, filename), KMP_ERR(code),