[runtime] Fixed hang when explicit task created inside a taskloop.

[AndreyChurbanov]

Summary

Added missed initialization of the td_last_tied field for taskloop tasks.

Without this the test hang because of task-stealing-constraint mistakenly prevented child tasks to be executed by the parent.

[AndreyChurbanov]

Adde check of task tiedness, and comment on why this is needed.

[hbae]

LGTM.

openmp/runtime/src/kmp_tasking.cpp

#endif /* USE_FAST_MEMORY */
   if (task->shareds != NULL) { // need setup shareds pointer
     shareds_offset = (char *)task_src->shareds - (char *)taskdata_src;
     task->shareds = &((char *)taskdata)[shareds_offset];
     KMP_DEBUG_ASSERT((((kmp_uintptr_t)task->shareds) & (sizeof(void *) - 1)) ==
                      0);
   }
   taskdata->td_alloc_thread = thread;
   taskdata->td_parent = parent_task;
-  taskdata->td_taskgroup =
-      parent_task
-          ->td_taskgroup; // task inherits the taskgroup from the parent task
+  // task inherits the taskgroup from the parent task
+  taskdata->td_taskgroup = parent_task->td_taskgroup;
+  // tied task needs to initialize the td_last_tied at creation,
+  // untied one does this when it is scheduled for execution
+  if (taskdata->td_flags.tiedness == TASK_TIED)
+    taskdata->td_last_tied = taskdata;
 
   // Only need to keep track of child task counts if team parallel and tasking
   // not serialized
   if (!(taskdata->td_flags.team_serial || taskdata->td_flags.tasking_ser)) {
     KMP_ATOMIC_INC(&parent_task->td_incomplete_child_tasks);
     if (parent_task->td_taskgroup)
       KMP_ATOMIC_INC(&parent_task->td_taskgroup->count);
     // Only need to keep track of allocated child tasks for explicit tasks since

openmp/runtime/test/tasking/omp_task_red_taskloop.c

+// RUN: %libomp-compile-and-run
+
+#include <stdio.h>
+#include <omp.h>
+
+int r;
+
+int work(int k, int l)
+{
+  return k + l + 1;
+}
+void bar(int i) {
+  #pragma omp taskgroup task_reduction(+:r)
+ { int th_gen = omp_get_thread_num();
+  #pragma omp task in_reduction(+:r) firstprivate(i, th_gen)
+  {
+    r += work(i, 0);
+printf("executing task (%d, 0), th %d (gen by th %d)\n", i, omp_get_thread_num(), th_gen);
+  }
+  #pragma omp task in_reduction(+:r) firstprivate(i, th_gen)
+  {
+    r += work(i, 1);
+printf("executing task (%d, 1), th %d (gen by th %d)\n", i, omp_get_thread_num(), th_gen);
+  }
+ }
+}
+int foo() {
+  int i;
+  int th_gen = omp_get_thread_num();
+  #pragma omp taskgroup task_reduction(+:r)
+  {
+    bar(0);
+  }
+printf("th %d passed bar0\n", th_gen);
+  #pragma omp taskloop reduction(+:r) firstprivate(th_gen)
+  for (i = 1; i < 4; ++i) {
+    bar(i);
+printf("th %d (gen by th %d) passed bar%d in taskloop\n", omp_get_thread_num(), th_gen, i);
+//  #pragma omp task in_reduction(+:r)
+    r += i;
+  }
+  return 0;
+}
+// res = 2*((1+2)+(2+3)+(3+4)+(4+5)+1+2+3) = 60
+#define res 60
+int main()
+{
+  r = 0;
+  #pragma omp parallel num_threads(2)
+    foo();
+  if (r == res) {
+    return 0;
+  } else {
+    printf("error r = %d (!= %d)\n", r, res);
+    return 1;
+  }
+}