Author: Shilei Tian Date: 2021-01-18T06:57:52-05:00 New Revision: 9bf843bdc88f89193939445828105d97ac83f963
URL: https://github.com/llvm/llvm-project/commit/9bf843bdc88f89193939445828105d97ac83f963 DIFF: https://github.com/llvm/llvm-project/commit/9bf843bdc88f89193939445828105d97ac83f963.diff LOG: Revert "[OpenMP] Added the support for hidden helper task in RTL" This reverts commit ed939f853da1f2266f00ea087f778fda88848f73. Added: Modified: openmp/runtime/src/kmp.h openmp/runtime/src/kmp_global.cpp openmp/runtime/src/kmp_runtime.cpp openmp/runtime/src/kmp_settings.cpp openmp/runtime/src/kmp_taskdeps.h openmp/runtime/src/kmp_tasking.cpp openmp/runtime/src/kmp_wait_release.h openmp/runtime/src/z_Linux_util.cpp openmp/runtime/test/worksharing/for/kmp_sch_simd_guided.c Removed: openmp/runtime/test/tasking/hidden_helper_task/common.h openmp/runtime/test/tasking/hidden_helper_task/depend.cpp openmp/runtime/test/tasking/hidden_helper_task/gtid.cpp openmp/runtime/test/tasking/hidden_helper_task/taskgroup.cpp ################################################################################ diff --git a/openmp/runtime/src/kmp.h b/openmp/runtime/src/kmp.h index 8a2d44d6bd48..983511042fa7 100644 --- a/openmp/runtime/src/kmp.h +++ b/openmp/runtime/src/kmp.h @@ -2334,8 +2334,7 @@ typedef struct kmp_tasking_flags { /* Total struct must be exactly 32 bits */ unsigned priority_specified : 1; /* set if the compiler provides priority setting for the task */ unsigned detachable : 1; /* 1 == can detach */ - unsigned hidden_helper : 1; /* 1 == hidden helper task */ - unsigned reserved : 8; /* reserved for compiler use */ + unsigned reserved : 9; /* reserved for compiler use */ /* Library flags */ /* Total library flags must be 16 bits */ unsigned tasktype : 1; /* task is either explicit(1) or implicit (0) */ @@ -2383,18 +2382,6 @@ struct kmp_taskdata { /* aligned during dynamic allocation */ kmp_depnode_t *td_depnode; // Pointer to graph node if this task has dependencies kmp_task_team_t *td_task_team; - // The parent task team. Usually we could access it via - // parent_task->td_task_team, but it is possible to be nullptr because of late - // initialization. Sometimes we must use it. Since the td_task_team of the - // encountering thread is never nullptr, we set it when this task is created. - kmp_task_team_t *td_parent_task_team; - // The global thread id of the encountering thread. We need it because when a - // regular task depends on a hidden helper task, and the hidden helper task - // is finished on a hidden helper thread, it will call __kmp_release_deps to - // release all dependences. If now the task is a regular task, we need to pass - // the encountering gtid such that the task will be picked up and executed by - // its encountering team instead of hidden helper team. - kmp_int32 encountering_gtid; size_t td_size_alloc; // Size of task structure, including shareds etc. #if defined(KMP_GOMP_COMPAT) // 4 or 8 byte integers for the loop bounds in GOMP_taskloop @@ -2462,16 +2449,10 @@ typedef struct kmp_base_task_team { kmp_int32 tt_max_threads; // # entries allocated for threads_data array kmp_int32 tt_found_proxy_tasks; // found proxy tasks since last barrier kmp_int32 tt_untied_task_encountered; - // There is hidden helper thread encountered in this task team so that we must - // wait when waiting on task team - kmp_int32 tt_hidden_helper_task_encountered; KMP_ALIGN_CACHE std::atomic<kmp_int32> tt_unfinished_threads; /* #threads still active */ - KMP_ALIGN_CACHE - std::atomic<kmp_int32> tt_unfinished_hidden_helper_tasks; - KMP_ALIGN_CACHE volatile kmp_uint32 tt_active; /* is the team still actively executing tasks */ @@ -2936,7 +2917,6 @@ extern volatile int __kmp_init_parallel; extern volatile int __kmp_init_monitor; #endif extern volatile int __kmp_init_user_locks; -extern volatile int __kmp_init_hidden_helper_threads; extern int __kmp_init_counter; extern int __kmp_root_counter; extern int __kmp_version; @@ -4005,45 +3985,6 @@ static inline void __kmp_resume_if_hard_paused() { extern void __kmp_omp_display_env(int verbose); -// 1: it is initializing hidden helper team -extern volatile int __kmp_init_hidden_helper; -// 1: the hidden helper team is done -extern volatile int __kmp_hidden_helper_team_done; -// 1: enable hidden helper task -extern kmp_int32 __kmp_enable_hidden_helper; -// Main thread of hidden helper team -extern kmp_info_t *__kmp_hidden_helper_main_thread; -// Descriptors for the hidden helper threads -extern kmp_info_t **__kmp_hidden_helper_threads; -// Number of hidden helper threads -extern kmp_int32 __kmp_hidden_helper_threads_num; -// Number of hidden helper tasks that have not been executed yet -extern std::atomic<kmp_int32> __kmp_unexecuted_hidden_helper_tasks; - -extern void __kmp_hidden_helper_initialize(); -extern void __kmp_hidden_helper_threads_initz_routine(); -extern void __kmp_do_initialize_hidden_helper_threads(); -extern void __kmp_hidden_helper_threads_initz_wait(); -extern void __kmp_hidden_helper_initz_release(); -extern void __kmp_hidden_helper_threads_deinitz_wait(); -extern void __kmp_hidden_helper_threads_deinitz_release(); -extern void __kmp_hidden_helper_main_thread_wait(); -extern void __kmp_hidden_helper_worker_thread_wait(); -extern void __kmp_hidden_helper_worker_thread_signal(); -extern void __kmp_hidden_helper_main_thread_release(); - -// Check whether a given thread is a hidden helper thread -#define KMP_HIDDEN_HELPER_THREAD(gtid) \ - ((gtid) >= 1 && (gtid) <= __kmp_hidden_helper_threads_num) - -#define KMP_HIDDEN_HELPER_WORKER_THREAD(gtid) \ - ((gtid) > 1 && (gtid) <= __kmp_hidden_helper_threads_num) - -// Map a gtid to a hidden helper thread. The first hidden helper thread, a.k.a -// main thread, is skipped. -#define KMP_GTID_TO_SHADOW_GTID(gtid) \ - ((gtid) % (__kmp_hidden_helper_threads_num - 1) + 2) - #ifdef __cplusplus } #endif diff --git a/openmp/runtime/src/kmp_global.cpp b/openmp/runtime/src/kmp_global.cpp index 4e0035e0e066..6c94196a4e5e 100644 --- a/openmp/runtime/src/kmp_global.cpp +++ b/openmp/runtime/src/kmp_global.cpp @@ -46,9 +46,6 @@ volatile int __kmp_init_gtid = FALSE; volatile int __kmp_init_common = FALSE; volatile int __kmp_init_middle = FALSE; volatile int __kmp_init_parallel = FALSE; -volatile int __kmp_init_hidden_helper = FALSE; -volatile int __kmp_init_hidden_helper_threads = FALSE; -volatile int __kmp_hidden_helper_team_done = FALSE; #if KMP_USE_MONITOR volatile int __kmp_init_monitor = 0; /* 1 - launched, 2 - actually started (Windows* OS only) */ diff --git a/openmp/runtime/src/kmp_runtime.cpp b/openmp/runtime/src/kmp_runtime.cpp index c69d41cf5cbb..87875a0e1bdc 100644 --- a/openmp/runtime/src/kmp_runtime.cpp +++ b/openmp/runtime/src/kmp_runtime.cpp @@ -3639,37 +3639,15 @@ int __kmp_register_root(int initial_thread) { } } - // When hidden helper task is enabled, __kmp_threads is organized as follows: - // 0: initial thread, also a regular OpenMP thread. - // [1, __kmp_hidden_helper_threads_num]: slots for hidden helper threads. - // [__kmp_hidden_helper_threads_num + 1, __kmp_threads_capacity): slots for - // regular OpenMP threads. - if (TCR_4(__kmp_init_hidden_helper_threads)) { - // Find an available thread slot for hidden helper thread. Slots for hidden - // helper threads start from 1 to __kmp_hidden_helper_threads_num. - for (gtid = 1; TCR_PTR(__kmp_threads[gtid]) != NULL && - gtid <= __kmp_hidden_helper_threads_num; - gtid++) - ; - KMP_ASSERT(gtid <= __kmp_hidden_helper_threads_num); - KA_TRACE(1, ("__kmp_register_root: found slot in threads array for " - "hidden helper thread: T#%d\n", - gtid)); - } else { - /* find an available thread slot */ - // Don't reassign the zero slot since we need that to only be used by - // initial thread. Slots for hidden helper threads should also be skipped. - if (initial_thread && __kmp_threads[0] == NULL) { - gtid = 0; - } else { - for (gtid = __kmp_hidden_helper_threads_num + 1; - TCR_PTR(__kmp_threads[gtid]) != NULL; gtid++) - ; - } - KA_TRACE( - 1, ("__kmp_register_root: found slot in threads array: T#%d\n", gtid)); - KMP_ASSERT(gtid < __kmp_threads_capacity); - } + /* find an available thread slot */ + /* Don't reassign the zero slot since we need that to only be used by initial + thread */ + for (gtid = (initial_thread ? 0 : 1); TCR_PTR(__kmp_threads[gtid]) != NULL; + gtid++) + ; + KA_TRACE(1, + ("__kmp_register_root: found slot in threads array: T#%d\n", gtid)); + KMP_ASSERT(gtid < __kmp_threads_capacity); /* update global accounting */ __kmp_all_nth++; @@ -4320,20 +4298,8 @@ kmp_info_t *__kmp_allocate_thread(kmp_root_t *root, kmp_team_t *team, #endif KMP_MB(); - - { - int new_start_gtid = TCR_4(__kmp_init_hidden_helper_threads) - ? 1 - : __kmp_hidden_helper_threads_num + 1; - - for (new_gtid = new_start_gtid; TCR_PTR(__kmp_threads[new_gtid]) != NULL; - ++new_gtid) { - KMP_DEBUG_ASSERT(new_gtid < __kmp_threads_capacity); - } - - if (TCR_4(__kmp_init_hidden_helper_threads)) { - KMP_DEBUG_ASSERT(new_gtid <= __kmp_hidden_helper_threads_num); - } + for (new_gtid = 1; TCR_PTR(__kmp_threads[new_gtid]) != NULL; ++new_gtid) { + KMP_DEBUG_ASSERT(new_gtid < __kmp_threads_capacity); } /* allocate space for it. */ @@ -6267,15 +6233,6 @@ void __kmp_internal_end_thread(int gtid_req) { return; } - // If hidden helper team has been initialized, we need to deinit it - if (TCR_4(__kmp_init_hidden_helper)) { - TCW_SYNC_4(__kmp_hidden_helper_team_done, TRUE); - // First release the main thread to let it continue its work - __kmp_hidden_helper_main_thread_release(); - // Wait until the hidden helper team has been destroyed - __kmp_hidden_helper_threads_deinitz_wait(); - } - KMP_MB(); /* Flush all pending memory write invalidates. */ /* find out who we are and what we should do */ @@ -7152,41 +7109,6 @@ void __kmp_parallel_initialize(void) { __kmp_release_bootstrap_lock(&__kmp_initz_lock); } -void __kmp_hidden_helper_initialize() { - if (TCR_4(__kmp_init_hidden_helper)) - return; - - // __kmp_parallel_initialize is required before we initialize hidden helper - if (!TCR_4(__kmp_init_parallel)) - __kmp_parallel_initialize(); - - // Double check. Note that this double check should not be placed before - // __kmp_parallel_initialize as it will cause dead lock. - __kmp_acquire_bootstrap_lock(&__kmp_initz_lock); - if (TCR_4(__kmp_init_hidden_helper)) { - __kmp_release_bootstrap_lock(&__kmp_initz_lock); - return; - } - - // Set the count of hidden helper tasks to be executed to zero - KMP_ATOMIC_ST_REL(&__kmp_unexecuted_hidden_helper_tasks, 0); - - // Set the global variable indicating that we're initializing hidden helper - // team/threads - TCW_SYNC_4(__kmp_init_hidden_helper_threads, TRUE); - - // Platform independent initialization - __kmp_do_initialize_hidden_helper_threads(); - - // Wait here for the finish of initialization of hidden helper teams - __kmp_hidden_helper_threads_initz_wait(); - - // We have finished hidden helper initialization - TCW_SYNC_4(__kmp_init_hidden_helper, TRUE); - - __kmp_release_bootstrap_lock(&__kmp_initz_lock); -} - /* ------------------------------------------------------------------------ */ void __kmp_run_before_invoked_task(int gtid, int tid, kmp_info_t *this_thr, @@ -8532,6 +8454,7 @@ int __kmp_pause_resource(kmp_pause_status_t level) { } } + void __kmp_omp_display_env(int verbose) { __kmp_acquire_bootstrap_lock(&__kmp_initz_lock); if (__kmp_init_serial == 0) @@ -8539,55 +8462,3 @@ void __kmp_omp_display_env(int verbose) { __kmp_display_env_impl(!verbose, verbose); __kmp_release_bootstrap_lock(&__kmp_initz_lock); } - -// Globals and functions for hidden helper task -kmp_info_t **__kmp_hidden_helper_threads; -kmp_info_t *__kmp_hidden_helper_main_thread; -kmp_int32 __kmp_hidden_helper_threads_num = 8; -std::atomic<kmp_int32> __kmp_unexecuted_hidden_helper_tasks; -kmp_int32 __kmp_enable_hidden_helper = TRUE; - -namespace { -std::atomic<kmp_int32> __kmp_hit_hidden_helper_threads_num; - -void __kmp_hidden_helper_wrapper_fn(int *gtid, int *, ...) { - // This is an explicit synchronization on all hidden helper threads in case - // that when a regular thread pushes a hidden helper task to one hidden - // helper thread, the thread has not been awaken once since they're released - // by the main thread after creating the team. - KMP_ATOMIC_INC(&__kmp_hit_hidden_helper_threads_num); - while (KMP_ATOMIC_LD_ACQ(&__kmp_hit_hidden_helper_threads_num) != - __kmp_hidden_helper_threads_num) - ; - - // If main thread, then wait for signal - if (__kmpc_master(nullptr, *gtid)) { - // First, unset the initial state and release the initial thread - TCW_4(__kmp_init_hidden_helper_threads, FALSE); - __kmp_hidden_helper_initz_release(); - __kmp_hidden_helper_main_thread_wait(); - // Now wake up all worker threads - for (int i = 1; i < __kmp_hit_hidden_helper_threads_num; ++i) { - __kmp_hidden_helper_worker_thread_signal(); - } - } -} -} // namespace - -void __kmp_hidden_helper_threads_initz_routine() { - // Create a new root for hidden helper team/threads - const int gtid = __kmp_register_root(TRUE); - __kmp_hidden_helper_main_thread = __kmp_threads[gtid]; - __kmp_hidden_helper_threads = &__kmp_threads[gtid]; - __kmp_hidden_helper_main_thread->th.th_set_nproc = - __kmp_hidden_helper_threads_num; - - KMP_ATOMIC_ST_REL(&__kmp_hit_hidden_helper_threads_num, 0); - - __kmpc_fork_call(nullptr, 0, __kmp_hidden_helper_wrapper_fn); - - // Set the initialization flag to FALSE - TCW_SYNC_4(__kmp_init_hidden_helper, FALSE); - - __kmp_hidden_helper_threads_deinitz_release(); -} diff --git a/openmp/runtime/src/kmp_settings.cpp b/openmp/runtime/src/kmp_settings.cpp index 18093b31ee56..bfcd1faecdc0 100644 --- a/openmp/runtime/src/kmp_settings.cpp +++ b/openmp/runtime/src/kmp_settings.cpp @@ -503,11 +503,6 @@ int __kmp_initial_threads_capacity(int req_nproc) { if (nth < (4 * __kmp_xproc)) nth = (4 * __kmp_xproc); - // If hidden helper task is enabled, we initialize the thread capacity with - // extra - // __kmp_hidden_helper_threads_num. - nth += __kmp_hidden_helper_threads_num; - if (nth > __kmp_max_nth) nth = __kmp_max_nth; @@ -1166,33 +1161,6 @@ static void __kmp_stg_parse_num_threads(char const *name, char const *value, K_DIAG(1, ("__kmp_dflt_team_nth == %d\n", __kmp_dflt_team_nth)); } // __kmp_stg_parse_num_threads -static void __kmp_stg_parse_num_hidden_helper_threads(char const *name, - char const *value, - void *data) { - __kmp_stg_parse_int(name, value, 0, 16, &__kmp_hidden_helper_threads_num); - // If the number of hidden helper threads is zero, we disable hidden helper - // task - if (__kmp_hidden_helper_threads_num == 0) { - __kmp_enable_hidden_helper = FALSE; - } -} // __kmp_stg_parse_num_hidden_helper_threads - -static void __kmp_stg_print_num_hidden_helper_threads(kmp_str_buf_t *buffer, - char const *name, - void *data) { - __kmp_stg_print_int(buffer, name, __kmp_hidden_helper_threads_num); -} // __kmp_stg_print_num_hidden_helper_threads - -static void __kmp_stg_parse_use_hidden_helper(char const *name, - char const *value, void *data) { - __kmp_stg_parse_bool(name, value, &__kmp_enable_hidden_helper); -} // __kmp_stg_parse_use_hidden_helper - -static void __kmp_stg_print_use_hidden_helper(kmp_str_buf_t *buffer, - char const *name, void *data) { - __kmp_stg_print_bool(buffer, name, __kmp_enable_hidden_helper); -} // __kmp_stg_print_use_hidden_helper - static void __kmp_stg_print_num_threads(kmp_str_buf_t *buffer, char const *name, void *data) { if (__kmp_env_format) { @@ -5024,11 +4992,6 @@ static kmp_setting_t __kmp_stg_table[] = { __kmp_stg_print_omp_cancellation, NULL, 0, 0}, {"OMP_ALLOCATOR", __kmp_stg_parse_allocator, __kmp_stg_print_allocator, NULL, 0, 0}, - {"LIBOMP_USE_HIDDEN_HELPER_TASK", __kmp_stg_parse_use_hidden_helper, - __kmp_stg_print_use_hidden_helper, NULL, 0, 0}, - {"LIBOMP_NUM_HIDDEN_HELPER_THREADS", - __kmp_stg_parse_num_hidden_helper_threads, - __kmp_stg_print_num_hidden_helper_threads, NULL, 0, 0}, #if OMPT_SUPPORT {"OMP_TOOL", __kmp_stg_parse_omp_tool, __kmp_stg_print_omp_tool, NULL, 0, diff --git a/openmp/runtime/src/kmp_taskdeps.h b/openmp/runtime/src/kmp_taskdeps.h index a1ddf3638433..4e5f8851f6b2 100644 --- a/openmp/runtime/src/kmp_taskdeps.h +++ b/openmp/runtime/src/kmp_taskdeps.h @@ -119,7 +119,6 @@ static inline void __kmp_release_deps(kmp_int32 gtid, kmp_taskdata_t *task) { KMP_RELEASE_DEPNODE(gtid, node); kmp_depnode_list_t *next; - kmp_taskdata_t *next_taskdata; for (kmp_depnode_list_t *p = node->dn.successors; p; p = next) { kmp_depnode_t *successor = p->node; kmp_int32 npredecessors = KMP_ATOMIC_DEC(&successor->dn.npredecessors) - 1; @@ -132,24 +131,7 @@ static inline void __kmp_release_deps(kmp_int32 gtid, kmp_taskdata_t *task) { KA_TRACE(20, ("__kmp_release_deps: T#%d successor %p of %p scheduled " "for execution.\n", gtid, successor->dn.task, task)); - // If a regular task depending on a hidden helper task, when the - // hidden helper task is done, the regular task should be executed by - // its encountering team. - if (KMP_HIDDEN_HELPER_THREAD(gtid)) { - // Hidden helper thread can only execute hidden helper tasks - KMP_ASSERT(task->td_flags.hidden_helper); - next_taskdata = KMP_TASK_TO_TASKDATA(successor->dn.task); - // If the dependent task is a regular task, we need to push to its - // encountering thread's queue; otherwise, it can be pushed to its own - // queue. - if (!next_taskdata->td_flags.hidden_helper) { - __kmp_omp_task(task->encountering_gtid, successor->dn.task, false); - } else { - __kmp_omp_task(gtid, successor->dn.task, false); - } - } else { - __kmp_omp_task(gtid, successor->dn.task, false); - } + __kmp_omp_task(gtid, successor->dn.task, false); } } diff --git a/openmp/runtime/src/kmp_tasking.cpp b/openmp/runtime/src/kmp_tasking.cpp index ffc98b8ee9c9..80352e8c0dc3 100644 --- a/openmp/runtime/src/kmp_tasking.cpp +++ b/openmp/runtime/src/kmp_tasking.cpp @@ -325,12 +325,6 @@ static void __kmp_realloc_task_deque(kmp_info_t *thread, static kmp_int32 __kmp_push_task(kmp_int32 gtid, kmp_task_t *task) { kmp_info_t *thread = __kmp_threads[gtid]; kmp_taskdata_t *taskdata = KMP_TASK_TO_TASKDATA(task); - - if (taskdata->td_flags.hidden_helper) { - gtid = KMP_GTID_TO_SHADOW_GTID(gtid); - thread = __kmp_threads[gtid]; - } - kmp_task_team_t *task_team = thread->th.th_task_team; kmp_int32 tid = __kmp_tid_from_gtid(gtid); kmp_thread_data_t *thread_data; @@ -369,9 +363,7 @@ static kmp_int32 __kmp_push_task(kmp_int32 gtid, kmp_task_t *task) { // Find tasking deque specific to encountering thread thread_data = &task_team->tt.tt_threads_data[tid]; - // No lock needed since only owner can allocate. If the task is hidden_helper, - // we don't need it either because we have initialized the dequeue for hidden - // helper thread data. + // No lock needed since only owner can allocate if (UNLIKELY(thread_data->td.td_deque == NULL)) { __kmp_alloc_task_deque(thread, thread_data); } @@ -437,12 +429,6 @@ static kmp_int32 __kmp_push_task(kmp_int32 gtid, kmp_task_t *task) { __kmp_release_bootstrap_lock(&thread_data->td.td_deque_lock); - // Signal one worker thread to execute the task - if (taskdata->td_flags.hidden_helper) { - // Wake hidden helper threads up if they're sleeping - __kmp_hidden_helper_worker_thread_signal(); - } - return TASK_SUCCESSFULLY_PUSHED; } @@ -735,6 +721,7 @@ static void __kmp_free_task(kmp_int32 gtid, kmp_taskdata_t *taskdata, #else /* ! USE_FAST_MEMORY */ __kmp_thread_free(thread, taskdata); #endif + KA_TRACE(20, ("__kmp_free_task: T#%d freed task %p\n", gtid, taskdata)); } @@ -932,12 +919,6 @@ static void __kmp_task_finish(kmp_int32 gtid, kmp_task_t *task, __ompt_task_finish(task, resumed_task, ompt_task_complete); #endif - if (taskdata->td_flags.hidden_helper) { - KMP_DEBUG_ASSERT(taskdata->td_parent_task_team); - KMP_ATOMIC_DEC( - &taskdata->td_parent_task_team->tt.tt_unfinished_hidden_helper_tasks); - } - // Only need to keep track of count if team parallel and tasking not // serialized, or task is detachable and event has already been fulfilled if (!(taskdata->td_flags.team_serial || taskdata->td_flags.tasking_ser) || @@ -1190,8 +1171,6 @@ kmp_task_t *__kmp_task_alloc(ident_t *loc_ref, kmp_int32 gtid, kmp_task_t *task; kmp_taskdata_t *taskdata; kmp_info_t *thread = __kmp_threads[gtid]; - kmp_info_t *encountering_thread = thread; - kmp_int32 encountering_gtid = gtid; kmp_team_t *team = thread->th.th_team; kmp_taskdata_t *parent_task = thread->th.th_current_task; size_t shareds_offset; @@ -1199,26 +1178,6 @@ kmp_task_t *__kmp_task_alloc(ident_t *loc_ref, kmp_int32 gtid, if (UNLIKELY(!TCR_4(__kmp_init_middle))) __kmp_middle_initialize(); - if (flags->hidden_helper) { - if (__kmp_enable_hidden_helper) { - if (!TCR_4(__kmp_init_hidden_helper)) - __kmp_hidden_helper_initialize(); - - // For a hidden helper task encountered by a regular thread, we will push - // the task to the (gtid%__kmp_hidden_helper_threads_num)-th hidden helper - // thread. - if (!KMP_HIDDEN_HELPER_THREAD(gtid)) { - thread = __kmp_threads[KMP_GTID_TO_SHADOW_GTID(gtid)]; - team = thread->th.th_team; - // We don't change the parent-child relation for hidden helper task as - // we need that to do per-task-region synchronization. - } - } else { - // If the hidden helper task is not enabled, reset the flag to FALSE. - flags->hidden_helper = FALSE; - } - } - KA_TRACE(10, ("__kmp_task_alloc(enter): T#%d loc=%p, flags=(0x%x) " "sizeof_task=%ld sizeof_shared=%ld entry=%p\n", gtid, loc_ref, *((kmp_int32 *)flags), sizeof_kmp_task_t, @@ -1229,7 +1188,6 @@ kmp_task_t *__kmp_task_alloc(ident_t *loc_ref, kmp_int32 gtid, } flags->final = 1; } - if (flags->tiedness == TASK_UNTIED && !team->t.t_serialized) { // Untied task encountered causes the TSC algorithm to check entire deque of // the victim thread. If no untied task encountered, then checking the head @@ -1290,13 +1248,13 @@ kmp_task_t *__kmp_task_alloc(ident_t *loc_ref, kmp_int32 gtid, KA_TRACE(30, ("__kmp_task_alloc: T#%d Second malloc size: %ld\n", gtid, sizeof_shareds)); - // Avoid double allocation here by combining shareds with taskdata +// Avoid double allocation here by combining shareds with taskdata #if USE_FAST_MEMORY - taskdata = (kmp_taskdata_t *)__kmp_fast_allocate( - encountering_thread, shareds_offset + sizeof_shareds); + taskdata = (kmp_taskdata_t *)__kmp_fast_allocate(thread, shareds_offset + + sizeof_shareds); #else /* ! USE_FAST_MEMORY */ - taskdata = (kmp_taskdata_t *)__kmp_thread_malloc( - encountering_thread, shareds_offset + sizeof_shareds); + taskdata = (kmp_taskdata_t *)__kmp_thread_malloc(thread, shareds_offset + + sizeof_shareds); #endif /* USE_FAST_MEMORY */ ANNOTATE_HAPPENS_AFTER(taskdata); @@ -1324,7 +1282,7 @@ kmp_task_t *__kmp_task_alloc(ident_t *loc_ref, kmp_int32 gtid, taskdata->td_task_id = KMP_GEN_TASK_ID(); taskdata->td_team = team; - taskdata->td_alloc_thread = encountering_thread; + taskdata->td_alloc_thread = thread; taskdata->td_parent = parent_task; taskdata->td_level = parent_task->td_level + 1; // increment nesting level KMP_ATOMIC_ST_RLX(&taskdata->td_untied_count, 0); @@ -1343,9 +1301,6 @@ kmp_task_t *__kmp_task_alloc(ident_t *loc_ref, kmp_int32 gtid, taskdata->td_flags.destructors_thunk = flags->destructors_thunk; taskdata->td_flags.proxy = flags->proxy; taskdata->td_flags.detachable = flags->detachable; - taskdata->td_flags.hidden_helper = flags->hidden_helper; - taskdata->td_parent_task_team = encountering_thread->th.th_task_team; - taskdata->encountering_gtid = encountering_gtid; taskdata->td_task_team = thread->th.th_task_team; taskdata->td_size_alloc = shareds_offset + sizeof_shareds; taskdata->td_flags.tasktype = TASK_EXPLICIT; @@ -1403,17 +1358,6 @@ kmp_task_t *__kmp_task_alloc(ident_t *loc_ref, kmp_int32 gtid, } } - if (flags->hidden_helper) { - // Increment the number of hidden helper tasks to be executed - KMP_ATOMIC_INC(&__kmp_unexecuted_hidden_helper_tasks); - if (kmp_task_team_t *parent_team = taskdata->td_parent_task_team) { - KMP_ATOMIC_INC(&parent_team->tt.tt_unfinished_hidden_helper_tasks); - if (!parent_team->tt.tt_hidden_helper_task_encountered) { - TCW_4(parent_team->tt.tt_hidden_helper_task_encountered, TRUE); - } - } - } - KA_TRACE(20, ("__kmp_task_alloc(exit): T#%d created task %p parent=%p\n", gtid, taskdata, taskdata->td_parent)); ANNOTATE_HAPPENS_BEFORE(task); @@ -1451,14 +1395,6 @@ kmp_task_t *__kmpc_omp_target_task_alloc(ident_t *loc_ref, kmp_int32 gtid, size_t sizeof_shareds, kmp_routine_entry_t task_entry, kmp_int64 device_id) { - if (__kmp_enable_hidden_helper) { - auto &input_flags = reinterpret_cast<kmp_tasking_flags_t &>(flags); - input_flags.hidden_helper = TRUE; - // Hidden helper thread is always final for now because it is created by the - // compiler and used only for async offloading - input_flags.final = TRUE; - } - return __kmpc_omp_task_alloc(loc_ref, gtid, flags, sizeof_kmp_task_t, sizeof_shareds, task_entry); } @@ -1531,13 +1467,6 @@ static void __kmp_invoke_task(kmp_int32 gtid, kmp_task_t *task, } #endif - // Decreament the counter of hidden helper tasks to be executed - if (taskdata->td_flags.hidden_helper) { - // Hidden helper tasks can only be executed by hidden helper threads - KMP_ASSERT(KMP_HIDDEN_HELPER_THREAD(gtid)); - KMP_ATOMIC_DEC(&__kmp_unexecuted_hidden_helper_tasks); - } - // Proxy tasks are not handled by the runtime if (taskdata->td_flags.proxy != TASK_PROXY) { ANNOTATE_HAPPENS_AFTER(task); @@ -1935,12 +1864,6 @@ static kmp_int32 __kmpc_omp_taskwait_template(ident_t *loc_ref, kmp_int32 gtid, must_wait = must_wait || (thread->th.th_task_team != NULL && thread->th.th_task_team->tt.tt_found_proxy_tasks); - // If hidden helper thread is encountered, we must enable wait here. - must_wait = - must_wait || - (__kmp_enable_hidden_helper && thread->th.th_task_team != NULL && - thread->th.th_task_team->tt.tt_hidden_helper_task_encountered); - if (must_wait) { kmp_flag_32<false, false> flag( RCAST(std::atomic<kmp_uint32> *, @@ -2907,11 +2830,6 @@ static inline int __kmp_execute_tasks_template( thread->th.th_reap_state = KMP_NOT_SAFE_TO_REAP; threads_data = (kmp_thread_data_t *)TCR_PTR(task_team->tt.tt_threads_data); - - // This can happen when hidden helper task is enabled - if (__kmp_enable_hidden_helper && threads_data == nullptr) - return FALSE; - KMP_DEBUG_ASSERT(threads_data != NULL); nthreads = task_team->tt.tt_nproc; @@ -2996,8 +2914,8 @@ static inline int __kmp_execute_tasks_template( } } - if (task == NULL) - break; // break out of tasking loop + if (task == NULL) // break out of tasking loop + break; // Found a task; execute it #if USE_ITT_BUILD && USE_ITT_NOTIFY @@ -3471,8 +3389,6 @@ static kmp_task_team_t *__kmp_allocate_task_team(kmp_info_t *thread, task_team->tt.tt_nproc = nthreads = team->t.t_nproc; KMP_ATOMIC_ST_REL(&task_team->tt.tt_unfinished_threads, nthreads); - KMP_ATOMIC_ST_REL(&task_team->tt.tt_unfinished_hidden_helper_tasks, 0); - TCW_4(task_team->tt.tt_hidden_helper_task_encountered, FALSE); TCW_4(task_team->tt.tt_active, TRUE); KA_TRACE(20, ("__kmp_allocate_task_team: T#%d exiting; task_team = %p " @@ -3645,26 +3561,6 @@ void __kmp_task_team_setup(kmp_info_t *this_thr, kmp_team_t *team, int always) { ((team != NULL) ? team->t.t_id : -1), other_team)); } } - - // For regular thread, task enabling should be called when the task is going - // to be pushed to a dequeue. However, for the hidden helper thread, we need - // it ahead of time so that some operations can be performed without race - // condition. - if (this_thr == __kmp_hidden_helper_main_thread) { - for (int i = 0; i < 2; ++i) { - kmp_task_team_t *task_team = team->t.t_task_team[i]; - if (KMP_TASKING_ENABLED(task_team)) { - continue; - } - __kmp_enable_tasking(task_team, this_thr); - for (int j = 0; j < task_team->tt.tt_nproc; ++j) { - kmp_thread_data_t *thread_data = &task_team->tt.tt_threads_data[j]; - if (thread_data->td.td_deque == NULL) { - __kmp_alloc_task_deque(__kmp_hidden_helper_threads[j], thread_data); - } - } - } - } } // __kmp_task_team_sync: Propagation of task team data from team to threads @@ -3733,11 +3629,6 @@ void __kmp_task_team_wait( TCW_PTR(this_thr->th.th_task_team, NULL); } - - if (__kmp_enable_hidden_helper && task_team && - task_team->tt.tt_hidden_helper_task_encountered) - while (KMP_ATOMIC_LD_ACQ(&task_team->tt.tt_unfinished_hidden_helper_tasks)) - ; } // __kmp_tasking_barrier: diff --git a/openmp/runtime/src/kmp_wait_release.h b/openmp/runtime/src/kmp_wait_release.h index bb7a3e0d483d..76a5625c654e 100644 --- a/openmp/runtime/src/kmp_wait_release.h +++ b/openmp/runtime/src/kmp_wait_release.h @@ -389,26 +389,6 @@ final_spin=FALSE) break; } - // For hidden helper thread, if task_team is nullptr, it means the main - // thread has not released the barrier. We cannot wait here because once the - // main thread releases all children barriers, all hidden helper threads are - // still sleeping. This leads to a problem that following configuration, - // such as task team sync, will not be performed such that this thread does - // not have task team. Usually it is not bad. However, a corner case is, - // when the first task encountered is an untied task, the check in - // __kmp_task_alloc will crash because it uses the task team pointer without - // checking whether it is nullptr. It is probably under some kind of - // assumption. - if (task_team && KMP_HIDDEN_HELPER_WORKER_THREAD(th_gtid) && - !TCR_4(__kmp_hidden_helper_team_done)) { - // If there is still hidden helper tasks to be executed, the hidden helper - // thread will not enter a waiting status. - if (KMP_ATOMIC_LD_ACQ(&__kmp_unexecuted_hidden_helper_tasks) == 0) { - __kmp_hidden_helper_worker_thread_wait(); - } - continue; - } - // Don't suspend if KMP_BLOCKTIME is set to "infinite" if (__kmp_dflt_blocktime == KMP_MAX_BLOCKTIME && __kmp_pause_status != kmp_soft_paused) diff --git a/openmp/runtime/src/z_Linux_util.cpp b/openmp/runtime/src/z_Linux_util.cpp index 95feafbec8e5..105cffdefc2d 100644 --- a/openmp/runtime/src/z_Linux_util.cpp +++ b/openmp/runtime/src/z_Linux_util.cpp @@ -25,7 +25,6 @@ #include <alloca.h> #endif #include <math.h> // HUGE_VAL. -#include <semaphore.h> #include <sys/resource.h> #include <sys/syscall.h> #include <sys/time.h> @@ -2448,7 +2447,7 @@ int __kmp_invoke_microtask(microtask_t pkfn, int gtid, int tid, int argc, , void **exit_frame_ptr #endif -) { + ) { #if OMPT_SUPPORT *exit_frame_ptr = OMPT_GET_FRAME_ADDRESS(0); #endif @@ -2527,165 +2526,4 @@ int __kmp_invoke_microtask(microtask_t pkfn, int gtid, int tid, int argc, #endif -// Functions for hidden helper task -namespace { -// Condition variable for initializing hidden helper team -pthread_cond_t hidden_helper_threads_initz_cond_var; -pthread_mutex_t hidden_helper_threads_initz_lock; -volatile int hidden_helper_initz_signaled = FALSE; - -// Condition variable for deinitializing hidden helper team -pthread_cond_t hidden_helper_threads_deinitz_cond_var; -pthread_mutex_t hidden_helper_threads_deinitz_lock; -volatile int hidden_helper_deinitz_signaled = FALSE; - -// Condition variable for the wrapper function of main thread -pthread_cond_t hidden_helper_main_thread_cond_var; -pthread_mutex_t hidden_helper_main_thread_lock; -volatile int hidden_helper_main_thread_signaled = FALSE; - -// Semaphore for worker threads. We don't use condition variable here in case -// that when multiple signals are sent at the same time, only one thread might -// be waken. -sem_t hidden_helper_task_sem; -} // namespace - -void __kmp_hidden_helper_worker_thread_wait() { - int status = sem_wait(&hidden_helper_task_sem); - KMP_CHECK_SYSFAIL("sem_wait", status); -} - -void __kmp_do_initialize_hidden_helper_threads() { - // Initialize condition variable - int status = - pthread_cond_init(&hidden_helper_threads_initz_cond_var, nullptr); - KMP_CHECK_SYSFAIL("pthread_cond_init", status); - - status = pthread_cond_init(&hidden_helper_threads_deinitz_cond_var, nullptr); - KMP_CHECK_SYSFAIL("pthread_cond_init", status); - - status = pthread_cond_init(&hidden_helper_main_thread_cond_var, nullptr); - KMP_CHECK_SYSFAIL("pthread_cond_init", status); - - status = pthread_mutex_init(&hidden_helper_threads_initz_lock, nullptr); - KMP_CHECK_SYSFAIL("pthread_mutex_init", status); - - status = pthread_mutex_init(&hidden_helper_threads_deinitz_lock, nullptr); - KMP_CHECK_SYSFAIL("pthread_mutex_init", status); - - status = pthread_mutex_init(&hidden_helper_main_thread_lock, nullptr); - KMP_CHECK_SYSFAIL("pthread_mutex_init", status); - - // Initialize the semaphore - status = sem_init(&hidden_helper_task_sem, 0, 0); - KMP_CHECK_SYSFAIL("sem_init", status); - - // Create a new thread to finish initialization - pthread_t handle; - status = pthread_create( - &handle, nullptr, - [](void *) -> void * { - __kmp_hidden_helper_threads_initz_routine(); - return nullptr; - }, - nullptr); - KMP_CHECK_SYSFAIL("pthread_create", status); -} - -void __kmp_hidden_helper_threads_initz_wait() { - // Initial thread waits here for the completion of the initialization. The - // condition variable will be notified by main thread of hidden helper teams. - int status = pthread_mutex_lock(&hidden_helper_threads_initz_lock); - KMP_CHECK_SYSFAIL("pthread_mutex_lock", status); - - if (!TCR_4(hidden_helper_initz_signaled)) { - status = pthread_cond_wait(&hidden_helper_threads_initz_cond_var, - &hidden_helper_threads_initz_lock); - KMP_CHECK_SYSFAIL("pthread_cond_wait", status); - } - - status = pthread_mutex_unlock(&hidden_helper_threads_initz_lock); - KMP_CHECK_SYSFAIL("pthread_mutex_unlock", status); -} - -void __kmp_hidden_helper_initz_release() { - // After all initialization, reset __kmp_init_hidden_helper_threads to false. - int status = pthread_mutex_lock(&hidden_helper_threads_initz_lock); - KMP_CHECK_SYSFAIL("pthread_mutex_lock", status); - - status = pthread_cond_signal(&hidden_helper_threads_initz_cond_var); - KMP_CHECK_SYSFAIL("pthread_cond_wait", status); - - TCW_SYNC_4(hidden_helper_initz_signaled, TRUE); - - status = pthread_mutex_unlock(&hidden_helper_threads_initz_lock); - KMP_CHECK_SYSFAIL("pthread_mutex_unlock", status); -} - -void __kmp_hidden_helper_main_thread_wait() { - // The main thread of hidden helper team will be blocked here. The - // condition variable can only be signal in the destructor of RTL. - int status = pthread_mutex_lock(&hidden_helper_main_thread_lock); - KMP_CHECK_SYSFAIL("pthread_mutex_lock", status); - - if (!TCR_4(hidden_helper_main_thread_signaled)) { - status = pthread_cond_wait(&hidden_helper_main_thread_cond_var, - &hidden_helper_main_thread_lock); - KMP_CHECK_SYSFAIL("pthread_cond_wait", status); - } - - status = pthread_mutex_unlock(&hidden_helper_main_thread_lock); - KMP_CHECK_SYSFAIL("pthread_mutex_unlock", status); -} - -void __kmp_hidden_helper_main_thread_release() { - // The initial thread of OpenMP RTL should call this function to wake up the - // main thread of hidden helper team. - int status = pthread_mutex_lock(&hidden_helper_main_thread_lock); - KMP_CHECK_SYSFAIL("pthread_mutex_lock", status); - - status = pthread_cond_signal(&hidden_helper_main_thread_cond_var); - KMP_CHECK_SYSFAIL("pthread_cond_signal", status); - - // The hidden helper team is done here - TCW_SYNC_4(hidden_helper_main_thread_signaled, TRUE); - - status = pthread_mutex_unlock(&hidden_helper_main_thread_lock); - KMP_CHECK_SYSFAIL("pthread_mutex_unlock", status); -} - -void __kmp_hidden_helper_worker_thread_signal() { - int status = sem_post(&hidden_helper_task_sem); - KMP_CHECK_SYSFAIL("sem_post", status); -} - -void __kmp_hidden_helper_threads_deinitz_wait() { - // Initial thread waits here for the completion of the deinitialization. The - // condition variable will be notified by main thread of hidden helper teams. - int status = pthread_mutex_lock(&hidden_helper_threads_deinitz_lock); - KMP_CHECK_SYSFAIL("pthread_mutex_lock", status); - - if (!TCR_4(hidden_helper_deinitz_signaled)) { - status = pthread_cond_wait(&hidden_helper_threads_deinitz_cond_var, - &hidden_helper_threads_deinitz_lock); - KMP_CHECK_SYSFAIL("pthread_cond_wait", status); - } - - status = pthread_mutex_unlock(&hidden_helper_threads_deinitz_lock); - KMP_CHECK_SYSFAIL("pthread_mutex_unlock", status); -} - -void __kmp_hidden_helper_threads_deinitz_release() { - int status = pthread_mutex_lock(&hidden_helper_threads_deinitz_lock); - KMP_CHECK_SYSFAIL("pthread_mutex_lock", status); - - status = pthread_cond_signal(&hidden_helper_threads_deinitz_cond_var); - KMP_CHECK_SYSFAIL("pthread_cond_wait", status); - - TCW_SYNC_4(hidden_helper_deinitz_signaled, TRUE); - - status = pthread_mutex_unlock(&hidden_helper_threads_deinitz_lock); - KMP_CHECK_SYSFAIL("pthread_mutex_unlock", status); -} - // end of file // diff --git a/openmp/runtime/test/tasking/hidden_helper_task/common.h b/openmp/runtime/test/tasking/hidden_helper_task/common.h deleted file mode 100644 index 0761091e11df..000000000000 --- a/openmp/runtime/test/tasking/hidden_helper_task/common.h +++ /dev/null @@ -1,59 +0,0 @@ -#include <cassert> -#include <iostream> -#include <string> - -extern "C" { -struct ident_t; - -using kmp_int32 = int32_t; -using kmp_int64 = int64_t; -using kmp_routine_entry_t = kmp_int32 (*)(kmp_int32, void *); -using kmp_intptr_t = intptr_t; - -typedef struct kmp_depend_info { - kmp_intptr_t base_addr; - size_t len; - struct { - bool in : 1; - bool out : 1; - bool mtx : 1; - } flags; -} kmp_depend_info_t; - -typedef union kmp_cmplrdata { - kmp_int32 priority; - kmp_routine_entry_t destructors; -} kmp_cmplrdata_t; - -typedef struct kmp_task { - void *shareds; - kmp_routine_entry_t routine; - kmp_int32 part_id; - kmp_cmplrdata_t data1; - kmp_cmplrdata_t data2; -} kmp_task_t; - -int32_t __kmpc_global_thread_num(void *); -kmp_task_t *__kmpc_omp_task_alloc(ident_t *, kmp_int32, kmp_int32, size_t, - size_t, kmp_routine_entry_t); -kmp_task_t *__kmpc_omp_target_task_alloc(ident_t *, kmp_int32, kmp_int32, - size_t, size_t, kmp_routine_entry_t, - kmp_int64); -kmp_int32 __kmpc_omp_taskwait(ident_t *, kmp_int32); -kmp_int32 __kmpc_omp_task(ident_t *, kmp_int32, kmp_task_t *); -kmp_int32 __kmpc_omp_task_with_deps(ident_t *loc_ref, kmp_int32 gtid, - kmp_task_t *new_task, kmp_int32 ndeps, - kmp_depend_info_t *dep_list, - kmp_int32 ndeps_noalias, - kmp_depend_info_t *noalias_dep_list); -void __kmpc_taskgroup(ident_t *, kmp_int32); -void __kmpc_end_taskgroup(ident_t *, kmp_int32); -} - -static kmp_int32 get_num_hidden_helper_threads() { - static kmp_int32 __kmp_hidden_helper_threads_num = 8; - if (const char *env = std::getenv("LIBOMP_NUM_HIDDEN_HELPER_THREADS")) { - return std::stoi(env); - } - return __kmp_hidden_helper_threads_num; -} diff --git a/openmp/runtime/test/tasking/hidden_helper_task/depend.cpp b/openmp/runtime/test/tasking/hidden_helper_task/depend.cpp deleted file mode 100644 index 3eb28607e462..000000000000 --- a/openmp/runtime/test/tasking/hidden_helper_task/depend.cpp +++ /dev/null @@ -1,131 +0,0 @@ -// RUN: %libomp-cxx-compile-and-run - -/* - * This test aims to check whether hidden helper task can work with regular task - * in terms of dependences. It is equivalent to the following code: - * - * #pragma omp parallel - * for (int i = 0; i < N; ++i) { - * int data = -1; - * #pragma omp task shared(data) depend(out: data) - * { - * data = 1; - * } - * #pragma omp hidden helper task shared(data) depend(inout: data) - * { - * data += 2; - * } - * #pragma omp hidden helper task shared(data) depend(inout: data) - * { - * data += 4; - * } - * #pragma omp task shared(data) depend(inout: data) - * { - * data += 8; - * } - * #pragma omp taskwait - * assert(data == 15); - * } - */ - -#include "common.h" - -extern "C" { -struct kmp_task_t_with_privates { - kmp_task_t task; -}; - -struct anon { - int32_t *data; -}; -} - -template <int I> -kmp_int32 omp_task_entry(kmp_int32 gtid, kmp_task_t_with_privates *task) { - auto shareds = reinterpret_cast<anon *>(task->task.shareds); - auto p = shareds->data; - *p += I; - return 0; -} - -int main(int argc, char *argv[]) { - constexpr const int N = 1024; -#pragma omp parallel for - for (int i = 0; i < N; ++i) { - int32_t gtid = __kmpc_global_thread_num(nullptr); - int32_t data = 0; - - // Task 1 - auto task1 = __kmpc_omp_task_alloc( - nullptr, gtid, 1, sizeof(kmp_task_t_with_privates), sizeof(anon), - reinterpret_cast<kmp_routine_entry_t>(omp_task_entry<1>)); - - auto shareds = reinterpret_cast<anon *>(task1->shareds); - shareds->data = &data; - - kmp_depend_info_t depinfo1; - depinfo1.base_addr = reinterpret_cast<intptr_t>(&data); - depinfo1.flags.out = 1; - depinfo1.len = 4; - - __kmpc_omp_task_with_deps(nullptr, gtid, task1, 1, &depinfo1, 0, nullptr); - - // Task 2 - auto task2 = __kmpc_omp_target_task_alloc( - nullptr, gtid, 1, sizeof(kmp_task_t_with_privates), sizeof(anon), - reinterpret_cast<kmp_routine_entry_t>(omp_task_entry<2>), -1); - - shareds = reinterpret_cast<anon *>(task2->shareds); - shareds->data = &data; - - kmp_depend_info_t depinfo2; - depinfo2.base_addr = reinterpret_cast<intptr_t>(&data); - depinfo2.flags.in = 1; - depinfo2.flags.out = 1; - depinfo2.len = 4; - - __kmpc_omp_task_with_deps(nullptr, gtid, task2, 1, &depinfo2, 0, nullptr); - - // Task 3 - auto task3 = __kmpc_omp_target_task_alloc( - nullptr, gtid, 1, sizeof(kmp_task_t_with_privates), sizeof(anon), - reinterpret_cast<kmp_routine_entry_t>(omp_task_entry<4>), -1); - - shareds = reinterpret_cast<anon *>(task3->shareds); - shareds->data = &data; - - kmp_depend_info_t depinfo3; - depinfo3.base_addr = reinterpret_cast<intptr_t>(&data); - depinfo3.flags.in = 1; - depinfo3.flags.out = 1; - depinfo3.len = 4; - - __kmpc_omp_task_with_deps(nullptr, gtid, task3, 1, &depinfo3, 0, nullptr); - - // Task 4 - auto task4 = __kmpc_omp_task_alloc( - nullptr, gtid, 1, sizeof(kmp_task_t_with_privates), sizeof(anon), - reinterpret_cast<kmp_routine_entry_t>(omp_task_entry<8>)); - - shareds = reinterpret_cast<anon *>(task4->shareds); - shareds->data = &data; - - kmp_depend_info_t depinfo4; - depinfo4.base_addr = reinterpret_cast<intptr_t>(&data); - depinfo4.flags.in = 1; - depinfo4.flags.out = 1; - depinfo4.len = 4; - - __kmpc_omp_task_with_deps(nullptr, gtid, task4, 1, &depinfo4, 0, nullptr); - - // Wait for all tasks - __kmpc_omp_taskwait(nullptr, gtid); - - assert(data == 15); - } - - std::cout << "PASS\n"; - return 0; -} - -// CHECK: PASS diff --git a/openmp/runtime/test/tasking/hidden_helper_task/gtid.cpp b/openmp/runtime/test/tasking/hidden_helper_task/gtid.cpp deleted file mode 100644 index d5af89553caf..000000000000 --- a/openmp/runtime/test/tasking/hidden_helper_task/gtid.cpp +++ /dev/null @@ -1,132 +0,0 @@ -// RUN: %libomp-cxx-compile-and-run - -/* - * This test aims to check whether hidden helper thread has right gtid. We also - * test if there is mixed dependences between regular tasks and hidden helper - * tasks, the tasks are executed by right set of threads. It is equivalent to - * the following code: - * - * #pragma omp parallel for - * for (int i = 0; i < N; ++i) { - * int data1 = -1, data2 = -1, data3 = -1; - * int depvar; - * #pragma omp task shared(data1) depend(inout: depvar) - * { - * data1 = omp_get_global_thread_id(); - * } - * #pragma omp task hidden helper shared(data2) depend(inout: depvar) - * { - * data2 = omp_get_global_thread_id(); - * } - * #pragma omp task shared(data3) depend(inout: depvar) - * { - * data3 = omp_get_global_thread_id(); - * } - * #pragma omp taskwait - * assert(data1 == 0 || data1 > __kmp_num_hidden_helper_threads); - * assert(data2 > 0 && data2 <= __kmp_num_hidden_helper_threads); - * assert(data3 == 0 || data3 > __kmp_num_hidden_helper_threads); - * } - */ - -#include "common.h" - -extern "C" { -struct kmp_task_t_with_privates { - kmp_task_t task; -}; - -struct anon { - int32_t *data; -}; -} - -kmp_int32 __kmp_hidden_helper_threads_num; - -kmp_int32 omp_task_entry(kmp_int32 gtid, kmp_task_t_with_privates *task) { - auto shareds = reinterpret_cast<anon *>(task->task.shareds); - auto p = shareds->data; - *p = __kmpc_global_thread_num(nullptr); - return 0; -} - -template <bool hidden_helper_task> void assert_gtid(int v) { - if (__kmp_hidden_helper_threads_num) { - if (hidden_helper_task) { - assert(v > 0 && v <= __kmp_hidden_helper_threads_num); - } else { - assert(v == 0 || v > __kmp_hidden_helper_threads_num); - } - } else { - assert(v >= 0); - } -} - -int main(int argc, char *argv[]) { - __kmp_hidden_helper_threads_num = get_num_hidden_helper_threads(); - - constexpr const int N = 1024; -#pragma omp parallel for - for (int i = 0; i < N; ++i) { - int32_t data1 = -1, data2 = -1, data3 = -1; - int depvar; - int32_t gtid = __kmpc_global_thread_num(nullptr); - - // Task 1, regular task - auto task1 = __kmpc_omp_task_alloc( - nullptr, gtid, 1, sizeof(kmp_task_t_with_privates), sizeof(anon), - reinterpret_cast<kmp_routine_entry_t>(omp_task_entry)); - auto shareds = reinterpret_cast<anon *>(task1->shareds); - shareds->data = &data1; - - kmp_depend_info_t depinfo1; - depinfo1.base_addr = reinterpret_cast<intptr_t>(&depvar); - depinfo1.flags.in = 1; - depinfo1.flags.out = 1; - depinfo1.len = 4; - - __kmpc_omp_task_with_deps(nullptr, gtid, task1, 1, &depinfo1, 0, nullptr); - - // Task 2, hidden helper task - auto task2 = __kmpc_omp_target_task_alloc( - nullptr, gtid, 1, sizeof(kmp_task_t_with_privates), sizeof(anon), - reinterpret_cast<kmp_routine_entry_t>(omp_task_entry), -1); - shareds = reinterpret_cast<anon *>(task2->shareds); - shareds->data = &data2; - - kmp_depend_info_t depinfo2; - depinfo2.base_addr = reinterpret_cast<intptr_t>(&depvar); - depinfo2.flags.in = 1; - depinfo2.flags.out = 1; - depinfo2.len = 4; - - __kmpc_omp_task_with_deps(nullptr, gtid, task2, 1, &depinfo2, 0, nullptr); - - // Task 3, regular task - auto task3 = __kmpc_omp_task_alloc( - nullptr, gtid, 1, sizeof(kmp_task_t_with_privates), sizeof(anon), - reinterpret_cast<kmp_routine_entry_t>(omp_task_entry)); - shareds = reinterpret_cast<anon *>(task3->shareds); - shareds->data = &data3; - - kmp_depend_info_t depinfo3; - depinfo3.base_addr = reinterpret_cast<intptr_t>(&depvar); - depinfo3.flags.in = 1; - depinfo3.flags.out = 1; - depinfo3.len = 4; - - __kmpc_omp_task_with_deps(nullptr, gtid, task3, 1, &depinfo3, 0, nullptr); - - __kmpc_omp_taskwait(nullptr, gtid); - - // FIXME: 8 here is not accurate - assert_gtid<false>(data1); - assert_gtid<true>(data2); - assert_gtid<false>(data3); - } - - std::cout << "PASS\n"; - return 0; -} - -// CHECK: PASS diff --git a/openmp/runtime/test/tasking/hidden_helper_task/taskgroup.cpp b/openmp/runtime/test/tasking/hidden_helper_task/taskgroup.cpp deleted file mode 100644 index 551e4d302946..000000000000 --- a/openmp/runtime/test/tasking/hidden_helper_task/taskgroup.cpp +++ /dev/null @@ -1,78 +0,0 @@ -// RUN: %libomp-cxx-compile-and-run - -/* - * This test aims to check whether hidden helper task can work with regular task - * in terms of dependences. It is equivalent to the following code: - * - * #pragma omp parallel - * for (int i = 0; i < N; ++i) { - * int data1 = 0, data2 = 0; - * #pragma omp taskgroup - * { - * #pragma omp hidden helper task shared(data1) - * { - * data1 = 1; - * } - * #pragma omp hidden helper task shared(data2) - * { - * data2 = 2; - * } - * } - * assert(data1 == 1); - * assert(data2 == 2); - * } - */ - -#include "common.h" - -extern "C" { -struct kmp_task_t_with_privates { - kmp_task_t task; -}; - -struct anon { - int32_t *data; -}; -} - -template <int I> -kmp_int32 omp_task_entry(kmp_int32 gtid, kmp_task_t_with_privates *task) { - auto shareds = reinterpret_cast<anon *>(task->task.shareds); - auto p = shareds->data; - *p = I; - return 0; -} - -int main(int argc, char *argv[]) { - constexpr const int N = 1024; -#pragma omp parallel for - for (int i = 0; i < N; ++i) { - int32_t gtid = __kmpc_global_thread_num(nullptr); - int32_t data1 = 0, data2 = 0; - __kmpc_taskgroup(nullptr, gtid); - - auto task1 = __kmpc_omp_target_task_alloc( - nullptr, gtid, 1, sizeof(kmp_task_t_with_privates), sizeof(anon), - reinterpret_cast<kmp_routine_entry_t>(omp_task_entry<1>), -1); - auto shareds = reinterpret_cast<anon *>(task1->shareds); - shareds->data = &data1; - __kmpc_omp_task(nullptr, gtid, task1); - - auto task2 = __kmpc_omp_target_task_alloc( - nullptr, gtid, 1, sizeof(kmp_task_t_with_privates), sizeof(anon), - reinterpret_cast<kmp_routine_entry_t>(omp_task_entry<2>), -1); - shareds = reinterpret_cast<anon *>(task2->shareds); - shareds->data = &data2; - __kmpc_omp_task(nullptr, gtid, task2); - - __kmpc_end_taskgroup(nullptr, gtid); - - assert(data1 == 1); - assert(data2 == 2); - } - - std::cout << "PASS\n"; - return 0; -} - -// CHECK: PASS diff --git a/openmp/runtime/test/worksharing/for/kmp_sch_simd_guided.c b/openmp/runtime/test/worksharing/for/kmp_sch_simd_guided.c index 5ec46520fe25..cfc2d870f1a8 100644 --- a/openmp/runtime/test/worksharing/for/kmp_sch_simd_guided.c +++ b/openmp/runtime/test/worksharing/for/kmp_sch_simd_guided.c @@ -5,7 +5,6 @@ value 46 to the OpenMP RTL. Test uses numerous loop parameter combinations. */ #include <stdio.h> -#include <stdlib.h> #include <omp.h> #if defined(WIN32) || defined(_WIN32) @@ -48,9 +47,6 @@ extern int __kmpc_dispatch_next_8(id*, int, void*, void*, void*, void*); // End of definitions copied from OpenMP RTL. // --------------------------------------------------------------------------- static id loc = {0, 2, 0, 0, ";file;func;0;0;;"}; -// This variable is defined in OpenMP RTL but we can't have it exposed so we -// need to redefine it here. -static int __kmp_hidden_helper_threads_num = 8; // --------------------------------------------------------------------------- int run_loop_64(i64 loop_lb, i64 loop_ub, i64 loop_st, int loop_chunk) { @@ -62,9 +58,6 @@ int run_loop_64(i64 loop_lb, i64 loop_ub, i64 loop_st, int loop_chunk) { int rc; int tid = omp_get_thread_num(); int gtid = tid; - if (gtid) { - gtid += __kmp_hidden_helper_threads_num; - } int last; #if DEBUG printf("run_loop_<%d>(lb=%d, ub=%d, st=%d, ch=%d)\n", @@ -217,9 +210,6 @@ int run_loop_32(int loop_lb, int loop_ub, int loop_st, int loop_chunk) { int rc; int tid = omp_get_thread_num(); int gtid = tid; - if (gtid) { - gtid += __kmp_hidden_helper_threads_num; - } int last; #if DEBUG printf("run_loop_<%d>(lb=%d, ub=%d, st=%d, ch=%d)\n", @@ -407,13 +397,6 @@ int run_32(int num_th) // --------------------------------------------------------------------------- int main() { - { - const char *env = getenv("LIBOMP_NUM_HIDDEN_HELPER_THREADS"); - if (env) { - __kmp_hidden_helper_threads_num = atoi(env); - } - } - int n, err = 0; for (n = 1; n <= 4; ++ n) { err += run_32(n); _______________________________________________ llvm-branch-commits mailing list llvm-branch-commits@lists.llvm.org https://lists.llvm.org/cgi-bin/mailman/listinfo/llvm-branch-commits