Lines Matching refs:gtid

39 static void __kmp_bottom_half_finish_proxy(kmp_int32 gtid, kmp_task_t *ptask);
42 int __kmp_taskloop_task(int gtid, void *ptask);
54 static void __kmp_trace_task_stack(kmp_int32 gtid, in __kmp_trace_task_stack() argument
66 location, gtid, entries, task_stack->ts_first_block, stack_top)); in __kmp_trace_task_stack()
93 location, gtid, entries, stack_top, tied_task)); in __kmp_trace_task_stack()
99 location, gtid)); in __kmp_trace_task_stack()
108 static void __kmp_init_task_stack(kmp_int32 gtid, in __kmp_init_task_stack() argument
129 static void __kmp_free_task_stack(kmp_int32 gtid, in __kmp_free_task_stack() argument
158 static void __kmp_push_task_stack(kmp_int32 gtid, kmp_info_t *thread, in __kmp_push_task_stack() argument
162 &thread->th.th_task_team->tt.tt_threads_data[__kmp_tid_from_gtid(gtid)]; in __kmp_push_task_stack()
174 gtid, thread, tied_task)); in __kmp_push_task_stack()
203 gtid, tied_task, new_block)); in __kmp_push_task_stack()
206 KA_TRACE(20, ("__kmp_push_task_stack(exit): GTID: %d; TASK: %p\n", gtid, in __kmp_push_task_stack()
217 static void __kmp_pop_task_stack(kmp_int32 gtid, kmp_info_t *thread, in __kmp_pop_task_stack() argument
221 &thread->th.th_task_team->tt_threads_data[__kmp_tid_from_gtid(gtid)]; in __kmp_pop_task_stack()
233 KA_TRACE(20, ("__kmp_pop_task_stack(enter): GTID: %d; THREAD: %p\n", gtid, in __kmp_pop_task_stack()
254 KA_TRACE(20, ("__kmp_pop_task_stack(exit): GTID: %d; TASK: %p\n", gtid, in __kmp_pop_task_stack()
263 static bool __kmp_task_is_allowed(int gtid, const kmp_int32 is_constrained, argument
295 if (__kmp_test_lock(node->dn.mtx_locks[i], gtid))
299 __kmp_release_lock(node->dn.mtx_locks[j], gtid);
402 static kmp_int32 __kmp_push_priority_task(kmp_int32 gtid, kmp_info_t *thread, argument
409 gtid, taskdata, pri));
444 __kmp_task_is_allowed(gtid, __kmp_task_stealing_constraint, taskdata,
449 gtid, taskdata));
469 gtid, taskdata, thread_data->td.td_deque_ntasks,
477 static kmp_int32 __kmp_push_task(kmp_int32 gtid, kmp_task_t *task) { argument
478 kmp_info_t *thread = __kmp_threads[gtid];
485 !KMP_HIDDEN_HELPER_THREAD(gtid))) {
486 kmp_int32 shadow_gtid = KMP_GTID_TO_SHADOW_GTID(gtid);
494 kmp_int32 tid = __kmp_tid_from_gtid(gtid);
498 ("__kmp_push_task: T#%d trying to push task %p.\n", gtid, taskdata));
508 gtid, counter, taskdata));
515 gtid, taskdata));
531 return __kmp_push_priority_task(gtid, thread, taskdata, task_team, pri);
549 __kmp_task_is_allowed(gtid, __kmp_task_stealing_constraint, taskdata,
553 gtid, taskdata));
572 __kmp_task_is_allowed(gtid, __kmp_task_stealing_constraint, taskdata,
577 gtid, taskdata));
600 gtid, taskdata, thread_data->td.td_deque_ntasks,
670 static void __kmp_task_start(kmp_int32 gtid, kmp_task_t *task, argument
673 kmp_info_t *thread = __kmp_threads[gtid];
677 gtid, taskdata, current_task));
689 __kmp_push_task_stack(gtid, thread, taskdata);
710 KA_TRACE(10, ("__kmp_task_start(exit): T#%d task=%p\n", gtid, taskdata));
738 kmp_int32 gtid) { argument
741 if (__kmp_threads[gtid]->th.ompt_thread_info.ompt_task_yielded) {
743 __kmp_threads[gtid]->th.ompt_thread_info.ompt_task_yielded = 0;
775 static void __kmpc_omp_task_begin_if0_template(ident_t *loc_ref, kmp_int32 gtid, argument
780 kmp_taskdata_t *current_task = __kmp_threads[gtid]->th.th_current_task;
784 gtid, loc_ref, taskdata, current_task));
793 gtid, counter, taskdata));
798 __kmp_task_start(gtid, task, current_task);
816 __ompt_task_start(task, current_task, gtid);
820 KA_TRACE(10, ("__kmpc_omp_task_begin_if0(exit): T#%d loc=%p task=%p,\n", gtid,
826 static void __kmpc_omp_task_begin_if0_ompt(ident_t *loc_ref, kmp_int32 gtid, argument
830 __kmpc_omp_task_begin_if0_template<true>(loc_ref, gtid, task, frame_address,
849 void __kmpc_omp_task_begin_if0(ident_t *loc_ref, kmp_int32 gtid, argument
853 OMPT_STORE_RETURN_ADDRESS(gtid);
854 __kmpc_omp_task_begin_if0_ompt(loc_ref, gtid, task,
856 OMPT_LOAD_RETURN_ADDRESS(gtid));
860 __kmpc_omp_task_begin_if0_template<false>(loc_ref, gtid, task, NULL, NULL);
866 void __kmpc_omp_task_begin(ident_t *loc_ref, kmp_int32 gtid, kmp_task_t *task) { argument
867 kmp_taskdata_t *current_task = __kmp_threads[gtid]->th.th_current_task;
872 gtid, loc_ref, KMP_TASK_TO_TASKDATA(task), current_task));
874 __kmp_task_start(gtid, task, current_task);
876 KA_TRACE(10, ("__kmpc_omp_task_begin(exit): T#%d loc=%p task=%p,\n", gtid,
887 static void __kmp_free_task(kmp_int32 gtid, kmp_taskdata_t *taskdata, argument
889 KA_TRACE(30, ("__kmp_free_task: T#%d freeing data from task %p\n", gtid,
934 KA_TRACE(20, ("__kmp_free_task: T#%d freed task %p\n", gtid, taskdata));
943 static void __kmp_free_task_and_ancestors(kmp_int32 gtid, argument
962 gtid, taskdata));
965 __kmp_free_task(gtid, taskdata, thread);
986 gtid, taskdata));
1002 gtid, taskdata, children));
1037 static void __kmp_task_finish(kmp_int32 gtid, kmp_task_t *task, argument
1040 kmp_info_t *thread = __kmp_threads[gtid];
1052 gtid, taskdata, resumed_task));
1063 __kmp_pop_task_stack(gtid, thread, taskdata);
1074 gtid, counter, taskdata));
1087 gtid, taskdata, resumed_task));
1116 destr_thunk(gtid, task);
1128 __kmp_acquire_tas_lock(&taskdata->td_allow_completion_event.lock, gtid);
1149 __kmp_release_tas_lock(&taskdata->td_allow_completion_event.lock, gtid);
1163 __kmpc_give_task(task, __kmp_tid_from_gtid(gtid));
1164 if (KMP_HIDDEN_HELPER_THREAD(gtid))
1183 __kmp_release_deps(gtid, taskdata);
1200 __kmp_release_deps(gtid, taskdata);
1212 KMP_ASSERT(KMP_HIDDEN_HELPER_THREAD(gtid));
1219 gtid, taskdata, children));
1227 __kmp_free_task_and_ancestors(gtid, taskdata, thread);
1248 gtid, taskdata, resumed_task));
1255 kmp_int32 gtid, argument
1258 gtid, loc_ref, KMP_TASK_TO_TASKDATA(task)));
1259 KMP_DEBUG_ASSERT(gtid >= 0);
1261 __kmp_task_finish<ompt>(gtid, task, NULL);
1264 gtid, loc_ref, KMP_TASK_TO_TASKDATA(task)));
1281 void __kmpc_omp_task_complete_if0_ompt(ident_t *loc_ref, kmp_int32 gtid, argument
1283 __kmpc_omp_task_complete_if0_template<true>(loc_ref, gtid, task);
1292 void __kmpc_omp_task_complete_if0(ident_t *loc_ref, kmp_int32 gtid, argument
1296 __kmpc_omp_task_complete_if0_ompt(loc_ref, gtid, task);
1300 __kmpc_omp_task_complete_if0_template<false>(loc_ref, gtid, task);
1306 void __kmpc_omp_task_complete(ident_t *loc_ref, kmp_int32 gtid, argument
1308 KA_TRACE(10, ("__kmpc_omp_task_complete(enter): T#%d loc=%p task=%p\n", gtid,
1311 __kmp_task_finish<false>(gtid, task,
1314 KA_TRACE(10, ("__kmpc_omp_task_complete(exit): T#%d loc=%p task=%p\n", gtid,
1457 kmp_task_t *__kmp_task_alloc(ident_t *loc_ref, kmp_int32 gtid, argument
1463 kmp_info_t *thread = __kmp_threads[gtid];
1483 gtid, loc_ref, *((kmp_int32 *)flags), sizeof_kmp_task_t,
1517 gtid));
1527 ("T#%d enabling tasking in __kmp_task_alloc for proxy task\n", gtid));
1551 KA_TRACE(30, ("__kmp_task_alloc: T#%d First malloc size: %ld\n", gtid,
1553 KA_TRACE(30, ("__kmp_task_alloc: T#%d Second malloc size: %ld\n", gtid,
1609 kmp_info_t *shadow_thread = __kmp_threads[KMP_GTID_TO_SHADOW_GTID(gtid)];
1650 __ompt_task_init(taskdata, gtid);
1680 gtid, taskdata, taskdata->td_parent));
1685 kmp_task_t *__kmpc_omp_task_alloc(ident_t *loc_ref, kmp_int32 gtid, argument
1691 __kmp_assert_valid_gtid(gtid);
1696 gtid, loc_ref, input_flags->tiedness ? "tied " : "untied",
1701 retval = __kmp_task_alloc(loc_ref, gtid, input_flags, sizeof_kmp_task_t,
1704 KA_TRACE(20, ("__kmpc_omp_task_alloc(exit): T#%d retval %p\n", gtid, retval));
1709 kmp_task_t *__kmpc_omp_target_task_alloc(ident_t *loc_ref, kmp_int32 gtid, argument
1723 return __kmpc_omp_task_alloc(loc_ref, gtid, flags, sizeof_kmp_task_t,
1741 __kmpc_omp_reg_task_with_affinity(ident_t *loc_ref, kmp_int32 gtid, argument
1756 __kmp_invoke_task(kmp_int32 gtid, kmp_task_t *task, argument
1763 gtid, taskdata, current_task));
1772 gtid, taskdata));
1774 __kmp_bottom_half_finish_proxy(gtid, task);
1778 gtid, taskdata, current_task));
1789 thread = __kmp_threads[gtid];
1801 __kmp_task_start(gtid, task, current_task); // OMPT only if not discarded
1808 thread = __kmp_threads[gtid];
1865 __ompt_task_start(task, current_task, gtid);
1891 thread = __kmp_threads[gtid];
1917 (*(task->routine))(gtid, task);
1945 __kmp_task_finish<true>(gtid, task, current_task);
1948 __kmp_task_finish<false>(gtid, task, current_task);
1959 gtid, taskdata, current_task));
1973 kmp_int32 __kmpc_omp_task_parts(ident_t *loc_ref, kmp_int32 gtid, argument
1977 KA_TRACE(10, ("__kmpc_omp_task_parts(enter): T#%d loc=%p task=%p\n", gtid,
1997 if (__kmp_push_task(gtid, new_task) == TASK_NOT_PUSHED) // if cannot defer
1999 kmp_taskdata_t *current_task = __kmp_threads[gtid]->th.th_current_task;
2001 __kmp_invoke_task(gtid, new_task, current_task);
2008 gtid, loc_ref, new_taskdata));
2029 kmp_int32 __kmp_omp_task(kmp_int32 gtid, kmp_task_t *new_task, argument
2083 __kmp_push_task(gtid, new_task) == TASK_NOT_PUSHED) // if cannot defer
2085 kmp_taskdata_t *current_task = __kmp_threads[gtid]->th.th_current_task;
2088 __kmp_invoke_task(gtid, new_task, current_task);
2091 kmp_info_t *this_thr = __kmp_threads[gtid];
2119 kmp_int32 __kmpc_omp_task(ident_t *loc_ref, kmp_int32 gtid, argument
2127 KA_TRACE(10, ("__kmpc_omp_task(enter): T#%d loc=%p task=%p\n", gtid, loc_ref,
2129 __kmp_assert_valid_gtid(gtid);
2135 OMPT_STORE_RETURN_ADDRESS(gtid);
2147 OMPT_LOAD_RETURN_ADDRESS(gtid));
2160 res = __kmp_omp_task(gtid, new_task, true);
2164 gtid, loc_ref, new_taskdata));
2186 kmp_int32 __kmp_omp_taskloop_task(ident_t *loc_ref, kmp_int32 gtid, argument
2194 KA_TRACE(10, ("__kmpc_omp_task(enter): T#%d loc=%p task=%p\n", gtid, loc_ref,
2212 res = __kmp_omp_task(gtid, new_task, true);
2216 gtid, loc_ref, new_taskdata));
2226 static kmp_int32 __kmpc_omp_taskwait_template(ident_t *loc_ref, kmp_int32 gtid, argument
2234 KA_TRACE(10, ("__kmpc_omp_taskwait(enter): T#%d loc=%p\n", gtid, loc_ref));
2235 KMP_DEBUG_ASSERT(gtid >= 0);
2238 thread = __kmp_threads[gtid];
2272 taskdata->td_taskwait_thread = gtid + 1;
2298 flag.execute_tasks(thread, gtid, FALSE,
2331 gtid, taskdata));
2338 static kmp_int32 __kmpc_omp_taskwait_ompt(ident_t *loc_ref, kmp_int32 gtid, argument
2341 return __kmpc_omp_taskwait_template<true>(loc_ref, gtid, frame_address,
2348 kmp_int32 __kmpc_omp_taskwait(ident_t *loc_ref, kmp_int32 gtid) { argument
2351 OMPT_STORE_RETURN_ADDRESS(gtid);
2352 return __kmpc_omp_taskwait_ompt(loc_ref, gtid, OMPT_GET_FRAME_ADDRESS(0),
2353 OMPT_LOAD_RETURN_ADDRESS(gtid));
2356 return __kmpc_omp_taskwait_template<false>(loc_ref, gtid, NULL, NULL);
2360 kmp_int32 __kmpc_omp_taskyield(ident_t *loc_ref, kmp_int32 gtid, int end_part) { argument
2369 gtid, loc_ref, end_part));
2370 __kmp_assert_valid_gtid(gtid);
2373 thread = __kmp_threads[gtid];
2383 taskdata->td_taskwait_thread = gtid + 1;
2400 thread, gtid, (kmp_flag_32<> *)NULL, FALSE,
2421 gtid, taskdata));
2525 void *__kmp_task_reduction_init(int gtid, int num, T *data) { argument
2526 __kmp_assert_valid_gtid(gtid);
2527 kmp_info_t *thread = __kmp_threads[gtid];
2538 gtid, tg));
2542 gtid, tg, num));
2593 void *__kmpc_task_reduction_init(int gtid, int num, void *data) { argument
2605 return __kmp_task_reduction_init(gtid, num, (kmp_task_red_input_t *)data);
2620 void *__kmpc_taskred_init(int gtid, int num, void *data) { argument
2632 return __kmp_task_reduction_init(gtid, num, (kmp_taskred_input_t *)data);
2663 void *__kmpc_task_reduction_get_th_data(int gtid, void *tskgrp, void *data) { argument
2664 __kmp_assert_valid_gtid(gtid);
2665 kmp_info_t *thread = __kmp_threads[gtid];
2784 void *__kmp_task_reduction_modifier_init(ident_t *loc, int gtid, int is_ws, argument
2786 __kmp_assert_valid_gtid(gtid);
2787 kmp_info_t *thr = __kmp_threads[gtid];
2789 __kmpc_taskgroup(loc, gtid); // form new taskgroup first
2793 gtid, thr->th.th_current_task->td_taskgroup));
2806 tg = (kmp_taskgroup_t *)__kmp_task_reduction_init<T>(gtid, num, data);
2842 void *__kmpc_task_reduction_modifier_init(ident_t *loc, int gtid, int is_ws, argument
2844 return __kmp_task_reduction_modifier_init(loc, gtid, is_ws, num,
2862 void *__kmpc_taskred_modifier_init(ident_t *loc, int gtid, int is_ws, int num, argument
2864 return __kmp_task_reduction_modifier_init(loc, gtid, is_ws, num,
2876 void __kmpc_task_reduction_modifier_fini(ident_t *loc, int gtid, int is_ws) { argument
2877 __kmpc_end_taskgroup(loc, gtid);
2881 void __kmpc_taskgroup(ident_t *loc, int gtid) { argument
2882 __kmp_assert_valid_gtid(gtid);
2883 kmp_info_t *thread = __kmp_threads[gtid];
2887 KA_TRACE(10, ("__kmpc_taskgroup: T#%d loc=%p group=%p\n", gtid, loc, tg_new));
2898 void *codeptr = OMPT_LOAD_RETURN_ADDRESS(gtid);
2915 void __kmpc_end_taskgroup(ident_t *loc, int gtid) { argument
2916 __kmp_assert_valid_gtid(gtid);
2917 kmp_info_t *thread = __kmp_threads[gtid];
2932 codeptr = OMPT_LOAD_RETURN_ADDRESS(gtid);
2938 KA_TRACE(10, ("__kmpc_end_taskgroup(enter): T#%d loc=%p\n", gtid, loc));
2946 taskdata->td_taskwait_thread = gtid + 1;
2971 flag.execute_tasks(thread, gtid, FALSE,
3047 gtid, taskdata));
3058 static kmp_task_t *__kmp_get_priority_task(kmp_int32 gtid, argument
3068 20, ("__kmp_get_priority_task(exit #1): T#%d No tasks to get\n", gtid));
3100 current = __kmp_threads[gtid]->th.th_current_task;
3102 if (__kmp_task_is_allowed(gtid, is_constrained, taskdata, current)) {
3112 gtid, thread_data, task_team, deque_ntasks, target,
3123 if (__kmp_task_is_allowed(gtid, is_constrained, taskdata, current)) {
3135 gtid, thread_data, task_team, deque_ntasks,
3159 static kmp_task_t *__kmp_remove_my_task(kmp_info_t *thread, kmp_int32 gtid, argument
3171 thread_data = &task_team->tt.tt_threads_data[__kmp_tid_from_gtid(gtid)];
3174 gtid, thread_data->td.td_deque_ntasks,
3181 gtid, thread_data->td.td_deque_ntasks,
3193 gtid, thread_data->td.td_deque_ntasks,
3202 if (!__kmp_task_is_allowed(gtid, is_constrained, taskdata,
3209 gtid, thread_data->td.td_deque_ntasks,
3221 gtid, taskdata, thread_data->td.td_deque_ntasks,
3231 static kmp_task_t *__kmp_steal_task(kmp_int32 victim_tid, kmp_int32 gtid, argument
3256 gtid, __kmp_gtid_from_thread(victim_thr), task_team,
3263 gtid, __kmp_gtid_from_thread(victim_thr), task_team,
3277 gtid, __kmp_gtid_from_thread(victim_thr), task_team, ntasks,
3283 current = __kmp_threads[gtid]->th.th_current_task;
3285 if (__kmp_task_is_allowed(gtid, is_constrained, taskdata, current)) {
3295 gtid, __kmp_gtid_from_thread(victim_thr), task_team, ntasks,
3306 if (__kmp_task_is_allowed(gtid, is_constrained, taskdata, current)) {
3317 gtid, __kmp_gtid_from_thread(victim_thr), task_team, ntasks,
3344 gtid, count + 1, task_team));
3355 gtid, taskdata, __kmp_gtid_from_thread(victim_thr), task_team,
3373 kmp_info_t *thread, kmp_int32 gtid, C *flag, int final_spin, argument
3386 KMP_DEBUG_ASSERT(thread == __kmp_threads[gtid]);
3393 gtid, final_spin, *thread_finished));
3409 task = __kmp_get_priority_task(gtid, task_team, is_constrained);
3412 task = __kmp_remove_my_task(thread, gtid, task_team, is_constrained);
3466 __kmp_steal_task(victim_tid, gtid, task_team, unfinished_threads,
3491 itt_sync_obj = __kmp_itt_barrier_object(gtid, bs_forkjoin_barrier);
3496 __kmp_invoke_task(gtid, task, current_task);
3510 gtid));
3522 gtid));
3543 gtid, count, task_team));
3556 gtid));
3565 ("__kmp_execute_tasks_template: T#%d no more tasks\n", gtid));
3577 gtid));
3588 ("__kmp_execute_tasks_template: T#%d can't find work\n", gtid));
3596 kmp_info_t *thread, kmp_int32 gtid, kmp_flag_32<C, S> *flag, int final_spin, argument
3600 thread, gtid, flag, final_spin,
3606 kmp_info_t *thread, kmp_int32 gtid, kmp_flag_64<C, S> *flag, int final_spin, argument
3610 thread, gtid, flag, final_spin,
3616 kmp_info_t *thread, kmp_int32 gtid, kmp_atomic_flag_64<C, S> *flag, argument
3620 thread, gtid, flag, final_spin,
3625 kmp_info_t *thread, kmp_int32 gtid, kmp_flag_oncore *flag, int final_spin, argument
3629 thread, gtid, flag, final_spin,
3806 __kmp_free_task_stack(__kmp_thread_from_gtid(gtid), thread_data);
4324 void __kmp_tasking_barrier(kmp_team_t *team, kmp_info_t *thread, int gtid) { argument
4335 while (!spin_flag.execute_tasks(thread, gtid, TRUE,
4488 static void __kmp_bottom_half_finish_proxy(kmp_int32 gtid, kmp_task_t *ptask) { argument
4490 kmp_info_t *thread = __kmp_threads[gtid];
4502 __kmp_release_deps(gtid, taskdata);
4503 __kmp_free_task_and_ancestors(gtid, taskdata, thread);
4514 void __kmpc_proxy_task_completed(kmp_int32 gtid, kmp_task_t *ptask) { argument
4519 gtid, taskdata));
4520 __kmp_assert_valid_gtid(gtid);
4525 __kmp_bottom_half_finish_proxy(gtid, ptask);
4529 gtid, taskdata));
4601 kmp_event_t *__kmpc_task_allow_completion_event(ident_t *loc_ref, int gtid, argument
4617 int gtid = __kmp_get_gtid(); local
4622 __kmp_acquire_tas_lock(&event->lock, gtid);
4634 __kmp_release_tas_lock(&event->lock, gtid);
4644 if (gtid >= 0) {
4648 __kmpc_proxy_task_completed(gtid, ptask);
4874 void __kmp_taskloop_linear(ident_t *loc, int gtid, kmp_task_t *task, argument
4891 kmp_info_t *thread = __kmp_threads[gtid];
4902 gtid, num_tasks, grainsize, extras, last_chunk, lower, upper,
4958 gtid, i, next_task, lower, upper, st,
4962 __kmp_omp_taskloop_task(NULL, gtid, next_task,
4971 __kmp_omp_task(gtid, next_task, true); // schedule new task
4976 __kmp_task_start(gtid, task, current_task); // make internal bookkeeping
4978 __kmp_task_finish<false>(gtid, task, current_task);
5011 int __kmp_taskloop_task(int gtid, void *ptask) { argument
5036 gtid, taskdata, num_tasks, grainsize, extras, last_chunk, *lb, *ub,
5041 __kmp_taskloop_recur(NULL, gtid, task, lb, ub, st, ub_glob, num_tasks,
5048 __kmp_taskloop_linear(NULL, gtid, task, lb, ub, st, ub_glob, num_tasks,
5055 KA_TRACE(40, ("__kmp_taskloop_task(exit): T#%d\n", gtid));
5077 void __kmp_taskloop_recur(ident_t *loc, int gtid, kmp_task_t *task, argument
5093 gtid, taskdata, num_tasks, grainsize, extras, last_chunk, *lb, *ub,
5097 kmp_info_t *thread = __kmp_threads[gtid];
5154 __kmpc_omp_task_alloc(loc, gtid, 1, 3 * sizeof(void *),
5183 __kmp_omp_taskloop_task(NULL, gtid, new_task, codeptr_ra);
5185 __kmp_omp_task(gtid, new_task, true); // schedule new task
5190 __kmp_taskloop_recur(loc, gtid, task, lb, ub, st, ub_glob, n_tsk0, gr_size0,
5197 __kmp_taskloop_linear(loc, gtid, task, lb, ub, st, ub_glob, n_tsk0,
5204 KA_TRACE(40, ("__kmp_taskloop_recur(exit): T#%d\n", gtid));
5207 static void __kmp_taskloop(ident_t *loc, int gtid, kmp_task_t *task, int if_val, argument
5215 OMPT_STORE_RETURN_ADDRESS(gtid);
5217 __kmpc_taskgroup(loc, gtid);
5235 kmp_info_t *thread = __kmp_threads[gtid];
5240 gtid, taskdata, lower, upper, st, grainsize, sched, modifier,
5252 KA_TRACE(20, ("__kmp_taskloop(exit): T#%d zero-trip loop\n", gtid));
5254 __kmp_task_start(gtid, task, current_task);
5256 __kmp_task_finish<false>(gtid, task, current_task);
5326 __kmp_taskloop_linear(loc, gtid, task, lb, ub, st, ub_glob, num_tasks,
5337 gtid, tc, num_tasks, num_tasks_min, grainsize, extras,
5339 __kmp_taskloop_recur(loc, gtid, task, lb, ub, st, ub_glob, num_tasks,
5348 gtid, tc, num_tasks, num_tasks_min, grainsize, extras,
5350 __kmp_taskloop_linear(loc, gtid, task, lb, ub, st, ub_glob, num_tasks,
5368 OMPT_STORE_RETURN_ADDRESS(gtid);
5370 __kmpc_end_taskgroup(loc, gtid);
5372 KA_TRACE(20, ("__kmp_taskloop(exit): T#%d\n", gtid));
5391 void __kmpc_taskloop(ident_t *loc, int gtid, kmp_task_t *task, int if_val, argument
5394 __kmp_assert_valid_gtid(gtid);
5395 KA_TRACE(20, ("__kmpc_taskloop(enter): T#%d\n", gtid));
5396 __kmp_taskloop(loc, gtid, task, if_val, lb, ub, st, nogroup, sched, grainsize,
5398 KA_TRACE(20, ("__kmpc_taskloop(exit): T#%d\n", gtid));
5418 void __kmpc_taskloop_5(ident_t *loc, int gtid, kmp_task_t *task, int if_val, argument
5422 __kmp_assert_valid_gtid(gtid);
5423 KA_TRACE(20, ("__kmpc_taskloop_5(enter): T#%d\n", gtid));
5424 __kmp_taskloop(loc, gtid, task, if_val, lb, ub, st, nogroup, sched, grainsize,
5426 KA_TRACE(20, ("__kmpc_taskloop_5(exit): T#%d\n", gtid));
5437 void **__kmpc_omp_get_target_async_handle_ptr(kmp_int32 gtid) { argument
5438 if (gtid == KMP_GTID_DNE)
5441 kmp_info_t *thread = __kmp_thread_from_gtid(gtid);
5458 bool __kmpc_omp_has_task_team(kmp_int32 gtid) { argument
5459 if (gtid == KMP_GTID_DNE)
5462 kmp_info_t *thread = __kmp_thread_from_gtid(gtid);
5496 KA_TRACE(10, ("__kmp_print_tdg_dot(enter): T#%d tdg_id=%d \n", gtid, tdg_id));
5522 KA_TRACE(10, ("__kmp_print_tdg_dot(exit): T#%d tdg_id=%d \n", gtid, tdg_id));
5529 void __kmp_exec_tdg(kmp_int32 gtid, kmp_tdg_info_t *tdg) { argument
5531 KA_TRACE(10, ("__kmp_exec_tdg(enter): T#%d tdg_id=%d num_roots=%d\n", gtid,
5538 kmp_info_t *thread = __kmp_threads[gtid];
5542 __kmpc_taskred_init(gtid, tdg->rec_num_taskred, tdg->rec_taskred_data);
5571 __kmp_omp_task(gtid, this_record_map[this_root_tasks[j]].task, true);
5573 KA_TRACE(10, ("__kmp_exec_tdg(exit): T#%d tdg_id=%d num_roots=%d\n", gtid,
5582 static inline void __kmp_start_record(kmp_int32 gtid, argument
5622 kmp_int32 __kmpc_start_record_task(ident_t *loc_ref, kmp_int32 gtid, argument
5629 gtid, loc_ref, input_flags, tdg_id));
5636 gtid, loc_ref, input_flags, tdg_id));
5640 __kmpc_taskgroup(loc_ref, gtid);
5643 __kmp_exec_tdg(gtid, tdg);
5648 __kmp_start_record(gtid, flags, tdg_id);
5653 gtid, tdg_id, res ? "record" : "execute"));
5660 void __kmp_end_record(kmp_int32 gtid, kmp_tdg_info_t *tdg) { argument
5668 kmp_info_t *thread = __kmp_threads[gtid];
5706 void __kmpc_end_record_task(ident_t *loc_ref, kmp_int32 gtid, argument
5712 gtid, loc_ref, tdg_id, input_flags));
5715 __kmpc_end_taskgroup(loc_ref, gtid);
5717 __kmp_end_record(gtid, tdg);
5721 gtid, loc_ref, tdg_id));