Revert "[OpenMP] Added the support for hidden helper task in RTL"

This reverts commit ed939f8.

Author: shiltian

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

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) */

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,62 +8454,11 @@ 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)
     __kmp_do_serial_initialize();
   __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();
-}

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,

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);
       }
     }