[OpenMP] Fix bug 50022

[tianshilei1992]

Summary

Bug 50022 [0] reports target nowait fails in certain case, which is added in this
patch. The root cause of the failure is, when the second task is created, its
parent's td_incomplete_child_tasks will not be incremented because there is no
parallel region here thus its team is serialized. Therefore, when the initial
thread is waiting for its unfinished children tasks, it thought there is only
one, the first task, because it is hidden helper task, so it is tracked. The
second task will only be pushed to the queue when the first task is finished.
However, when the first task finishes, it first decrements the counter of its
parent, and then release dependences. Once the counter is decremented, the thread
will move on because its counter is reset, but actually, the second task has not
been executed at all. As a result, since in this case, the main function finishes,
then libomp starts to destroy. When the second task is pushed somewhere, all
some of the structures might already have already been destroyed, then anything
could happen.

This patch simply moves __kmp_release_deps ahead of decrement of the counter.
In this way, we can make sure that the initial thread is aware of the existence
of another task(s) so it will not move on. In addition, in order to tackle
dependence chain starting with hidden helper thread, when hidden helper task is
encountered, we force the task to release dependences.

Reference:
[0] https://bugs.llvm.org/show_bug.cgi?id=50022

[tianshilei1992]

Ping.

@ye-luo Can you also try if this patch (plus those that already landed) can fix the issue in QMCPack?

[ye-luo]

In D106519#2900838, @tianshilei1992 wrote:

Ping.

@ye-luo Can you also try if this patch (plus those that already landed) can fix the issue in QMCPack?

It fixes the bug but doesn't help QMCPACK.

[tianshilei1992]

In D106519#2901272, @ye-luo wrote:

In D106519#2900838, @tianshilei1992 wrote:

Ping.

@ye-luo Can you also try if this patch (plus those that already landed) can fix the issue in QMCPack?

It fixes the bug but doesn't help QMCPACK.

Okay thanks. Then QMCPack is because of another issue.

[AndreyChurbanov]

LGTM

openmp/libomptarget/test/offloading/bug50022.cpp

+// RUN: %libomptarget-compilexx-and-run-generic
+
+#include <cassert>
+#include <iostream>
+#include <stdexcept>
+
+int main(int argc, char *argv[]) {
+  int a = 0;
+  std::cout << "outside a = " << a << " addr " << &a << std::endl;
+#pragma omp target map(tofrom : a) depend(out : a) nowait
+  {
+    int sum = 0;
+    for (int i = 0; i < 100000; i++)
+      sum++;
+    a = 1;
+  }
+
+#pragma omp task depend(inout : a) shared(a)
+  {
+    std::cout << "a = " << a << " addr " << &a << std::endl;
+    if (a != 1)
+      throw std::runtime_error("wrong result!");
+    a = 2;
+  }
+
+#pragma omp task depend(inout : a) shared(a)
+  {
+    std::cout << "a = " << a << " addr " << &a << std::endl;
+    if (a != 2)
+      throw std::runtime_error("wrong result!");
+    a = 3;
+  }
+
+#pragma omp taskwait
+
+  assert(a == 3 && "wrong result!");
+
+  return 0;
+}

openmp/runtime/src/kmp_tasking.cpp

if (ompt)
       __ompt_task_finish(task, resumed_task, ompt_task_complete);
 #endif
 
     // 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) ||
         taskdata->td_flags.detachable == TASK_DETACHABLE ||
         taskdata->td_flags.hidden_helper) {
+      __kmp_release_deps(gtid, taskdata);
       // Predecrement simulated by "- 1" calculation
       children =
           KMP_ATOMIC_DEC(&taskdata->td_parent->td_incomplete_child_tasks) - 1;
       KMP_DEBUG_ASSERT(children >= 0);
       if (taskdata->td_taskgroup)
         KMP_ATOMIC_DEC(&taskdata->td_taskgroup->count);
-      __kmp_release_deps(gtid, taskdata);
-    } else if (task_team && task_team->tt.tt_found_proxy_tasks) {
-      // if we found proxy tasks there could exist a dependency chain
-      // with the proxy task as origin
+    } else if (task_team && (task_team->tt.tt_found_proxy_tasks ||
+                             task_team->tt.tt_hidden_helper_task_encountered)) {
+      // if we found proxy or hidden helper tasks there could exist a dependency
+      // chain with the proxy task as origin
       __kmp_release_deps(gtid, taskdata);
     }
     // td_flags.executing must be marked as 0 after __kmp_release_deps has been
     // called. Othertwise, if a task is executed immediately from the
     // release_deps code, the flag will be reset to 1 again by this same
     // function
     KMP_DEBUG_ASSERT(taskdata->td_flags.executing == 1);
     taskdata->td_flags.executing = 0; // suspend the finishing task