[OpenMP] Allocate depnodes on heap not stack in __kmpc_omp_taskwait_deps_51

This patch contains the fix for the work-stealing stack clobber with
task graph dependency nodes. A straightforward-seeming fix is to just
use heap allocation instead of stack allocation for the problematic
nodes in question.  This also allows us to revert the fix from PR85963:

  #85963

There may be some concern that despite fixing the issue, using heap rather
than stack allocation may have a negative performance impact. However
this does not appear to be the case: in fact I measured a small
performance boost with this patch, i.e. over 100 runs of the OpenMP_VV
test_taskwait_depend.c test with the iteration count N increased to
1024000, five times before & after the patch is applied:

pre-patch
=========

  real    0m30.635s
  user    45m55.276s
  sys     1m24.537s

  real    0m30.943s
  user    47m5.018s
  sys     1m19.218s

  real    0m30.573s
  user    45m56.023s
  sys     1m21.273s

  real    0m30.955s
  user    47m6.567s
  sys     1m25.121s

  real    0m30.712s
  user    46m51.830s
  sys     1m22.085s

with patch
==========

  real    0m28.245s
  user    39m16.057s
  sys     1m11.156s

  real    0m28.385s
  user    39m35.553s
  sys     1m16.413s

  real    0m28.421s
  user    39m42.498s
  sys     1m16.783s

  real    0m29.207s
  user    39m5.006s
  sys     1m10.247s

  real    0m29.118s
  user    38m30.484s
  sys     1m14.027s

(On an AMD system with 64 cores/256 hw threads.)

This is probably because we no longer need the wait loop in
__kmpc_omp_taskwait_deps_51.

Author: jtb20

openmp/runtime/src/kmp_taskdeps.cpp

@@ -1009,13 +1009,16 @@ void __kmpc_omp_taskwait_deps_51(ident_t *loc_ref, kmp_int32 gtid,
     return;
   }
 
-  kmp_depnode_t node = {0};
-  __kmp_init_node(&node);
-#if KMP_DEBUG
-  node.dn.on_stack = thread;
+#if USE_FAST_MEMORY
+  kmp_depnode_t *node =
+      (kmp_depnode_t *)__kmp_fast_allocate(thread, sizeof(kmp_depnode_t));
+#else
+  kmp_depnode_t *node =
+      (kmp_depnode_t *)__kmp_thread_malloc(thread, sizeof(kmp_depnode_t));
 #endif
+  __kmp_init_node(node);
 
-  if (!__kmp_check_deps(gtid, &node, NULL, &current_task->td_dephash,
+  if (!__kmp_check_deps(gtid, node, NULL, &current_task->td_dephash,
                         DEP_BARRIER, ndeps, dep_list, ndeps_noalias,
                         noalias_dep_list)) {
     KA_TRACE(10, ("__kmpc_omp_taskwait_deps(exit): T#%d has no blocking "
@@ -1029,20 +1032,14 @@ void __kmpc_omp_taskwait_deps_51(ident_t *loc_ref, kmp_int32 gtid,
 
   int thread_finished = FALSE;
   kmp_flag_32<false, false> flag(
-      (std::atomic<kmp_uint32> *)&node.dn.npredecessors, 0U);
-  while (node.dn.npredecessors > 0) {
+      (std::atomic<kmp_uint32> *)&node->dn.npredecessors, 0U);
+  while (node->dn.npredecessors > 0) {
     flag.execute_tasks(thread, gtid, FALSE,
                        &thread_finished USE_ITT_BUILD_ARG(NULL),
                        __kmp_task_stealing_constraint);
   }
 
-  // Wait until the last __kmp_release_deps is finished before we free the
-  // current stack frame holding the "node" variable; once its nrefs count
-  // reaches 1, we're sure nobody else can try to reference it again.
-  kmp_int32 nrefs;
-  while ((nrefs = node.dn.nrefs) > 1)
-    KMP_YIELD(TRUE);
-  KMP_DEBUG_ASSERT(nrefs == 1);
+  __kmp_node_deref(thread, node);
 
 #if OMPT_SUPPORT
   __ompt_taskwait_dep_finish(current_task, taskwait_task_data);