[OpenMP] Fix if0 task with dependencies

[jlpeyton]

Summary

The current GOMP interface for if0 tasks does not take into
account task dependencies. Add the check and wait for dependencies.

Fixes: https://bugs.llvm.org/show_bug.cgi?id=46573

[jdoerfert]

openmp/runtime/src/kmp_gsupport.cpp

1267

could we have something other than 8 in the condition? Is there an enum value or can we create at least a local variable with the value?

[jlpeyton]

Added enum for GOMP task flags.

[jlpeyton]

Add #pragma omp task if(0) depend() version of taskwait depend test.

[protze.joachim]

LGTM, the relevant OMPT tests pass with this patch

openmp/runtime/src/kmp_gsupport.cpp

 
 #include "kmp.h"
 #include "kmp_atomic.h"
 
 #if OMPT_SUPPORT
 #include "ompt-specific.h"
 #endif
 
+enum {
+  KMP_GOMP_TASK_UNTIED_FLAG = 1,
+  KMP_GOMP_TASK_FINAL_FLAG = 2,
+  KMP_GOMP_TASK_DEPENDS_FLAG = 8
+};
+
 // This class helps convert gomp dependency info into
 // kmp_depend_info_t structures
 class kmp_gomp_depends_info_t {
   void **depend;
   kmp_int32 num_deps;
   size_t num_out, num_mutexinout, num_in;
   size_t offset;
 
void KMP_EXPAND_NAME(KMP_API_NAME_GOMP_TASK)(void (*func)(void *), void *data,
   MKLOC(loc, "GOMP_task");
   int gtid = __kmp_entry_gtid();
   kmp_int32 flags = 0;
   kmp_tasking_flags_t *input_flags = (kmp_tasking_flags_t *)&flags;
 
   KA_TRACE(20, ("GOMP_task: T#%d\n", gtid));
 
   // The low-order bit is the "untied" flag
-  if (!(gomp_flags & 1)) {
+  if (!(gomp_flags & KMP_GOMP_TASK_UNTIED_FLAG)) {
     input_flags->tiedness = 1;
   }
   // The second low-order bit is the "final" flag
-  if (gomp_flags & 2) {
+  if (gomp_flags & KMP_GOMP_TASK_FINAL_FLAG) {
     input_flags->final = 1;
   }
   input_flags->native = 1;
   // __kmp_task_alloc() sets up all other flags
 
   if (!if_cond) {
     arg_size = 0;
   }
#if OMPT_SUPPORT
   if (ompt_enabled.enabled) {
     OMPT_STORE_RETURN_ADDRESS(gtid);
     current_task = __kmp_threads[gtid]->th.th_current_task;
     current_task->ompt_task_info.frame.enter_frame.ptr = OMPT_GET_FRAME_ADDRESS(0);
   }
 #endif
 
   if (if_cond) {
-    if (gomp_flags & 8) {
+    if (gomp_flags & KMP_GOMP_TASK_DEPENDS_FLAG) {
       KMP_ASSERT(depend);
       kmp_gomp_depends_info_t gomp_depends(depend);
       kmp_int32 ndeps = gomp_depends.get_num_deps();
       kmp_depend_info_t dep_list[ndeps];
       for (kmp_int32 i = 0; i < ndeps; i++)
         dep_list[i] = gomp_depends.get_kmp_depend(i);
       __kmpc_omp_task_with_deps(&loc, gtid, task, ndeps, dep_list, 0, NULL);
     } else {
if (ompt_enabled.enabled) {
       taskdata = KMP_TASK_TO_TASKDATA(task);
       oldInfo = thread->th.ompt_thread_info;
       thread->th.ompt_thread_info.wait_id = 0;
       thread->th.ompt_thread_info.state = ompt_state_work_parallel;
       taskdata->ompt_task_info.frame.exit_frame.ptr = OMPT_GET_FRAME_ADDRESS(0);
       OMPT_STORE_RETURN_ADDRESS(gtid);
     }
 #endif
+    if (gomp_flags & KMP_GOMP_TASK_DEPENDS_FLAG) {
+      KMP_ASSERT(depend);
+      kmp_gomp_depends_info_t gomp_depends(depend);
+      kmp_int32 ndeps = gomp_depends.get_num_deps();
+      kmp_depend_info_t dep_list[ndeps];
+      for (kmp_int32 i = 0; i < ndeps; i++)
+        dep_list[i] = gomp_depends.get_kmp_depend(i);
+      __kmpc_omp_wait_deps(&loc, gtid, ndeps, dep_list, 0, NULL);
+    }
 
     __kmpc_omp_task_begin_if0(&loc, gtid, task);
     func(data);
     __kmpc_omp_task_complete_if0(&loc, gtid, task);
 
 #if OMPT_SUPPORT
     if (ompt_enabled.enabled) {
       thread->th.ompt_thread_info = oldInfo;

openmp/runtime/test/tasking/taskdep_if0.c

+// RUN: %libomp-compile-and-run
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <omp.h>
+#include "omp_my_sleep.h"
+
+int a = 0;
+
+void task1() {
+  my_sleep(0.5);
+  a = 10;
+}
+
+void task2() {
+  a++;
+}
+
+int main(int argc, char** argv)
+{
+  #pragma omp parallel shared(argc) num_threads(2)
+  {
+    #pragma omp single
+    {
+      #pragma omp task depend(out: a)
+      task1();
+
+      #pragma omp task if(0) depend(inout: a)
+      task2();
+    }
+  }
+  if (a != 11) {
+    fprintf(stderr, "fail: expected 11, but a is %d\n", a);
+    exit(1);
+  } else {
+    printf("pass\n");
+  }
+  return 0;
+}

openmp/runtime/test/tasking/taskdep_if0_2.c

+// RUN: %libomp-compile-and-run
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <omp.h>
+#include "omp_my_sleep.h"
+
+int a = 0, b = 0;
+int task_grabbed = 0, task_can_proceed = 0;
+int task2_grabbed = 0, task2_can_proceed = 0;
+
+static void wait_on_flag(int *flag) {
+  int flag_value;
+  int timelimit = 30;
+  int secs = 0;
+  do {
+    #pragma omp atomic read
+    flag_value = *flag;
+    my_sleep(1.0);
+    secs++;
+    if (secs == timelimit) {
+      fprintf(stderr, "error: timeout in wait_on_flag()\n");
+      exit(EXIT_FAILURE);
+    }
+  } while (flag_value == 0);
+}
+
+static void signal_flag(int *flag) {
+  #pragma omp atomic
+  (*flag)++;
+}
+
+int main(int argc, char** argv) {
+
+  // Ensure two threads are running
+  int num_threads = omp_get_max_threads();
+  if (num_threads < 2)
+    omp_set_num_threads(2);
+
+  #pragma omp parallel shared(a)
+  {
+    int a_value;
+    // Let us be extra safe here
+    if (omp_get_num_threads() > 1) {
+      #pragma omp single nowait
+      {
+        // Schedule independent child task that
+        // waits to be flagged after sebsequent taskwait depend()
+        #pragma omp task
+        {
+          signal_flag(&task_grabbed);
+          wait_on_flag(&task_can_proceed);
+        }
+        // Let another worker thread grab the task to execute
+        wait_on_flag(&task_grabbed);
+        // This should be ignored since the task above has
+        // no dependency information
+        #pragma omp task if(0) depend(inout: a)
+        {}
+        // Signal the independent task to proceed
+        signal_flag(&task_can_proceed);
+
+        // Schedule child task with dependencies that taskwait does
+        // not care about
+        #pragma omp task depend(inout: b)
+        {
+          signal_flag(&task2_grabbed);
+          wait_on_flag(&task2_can_proceed);
+          #pragma omp atomic
+          b++;
+        }
+        // Let another worker thread grab the task to execute
+        wait_on_flag(&task2_grabbed);
+        // This should be ignored since the task above has
+        // dependency information on b instead of a
+        #pragma omp task if(0) depend(inout: a)
+        {}
+        // Signal the task to proceed
+        signal_flag(&task2_can_proceed);
+
+        // Generate one child task for taskwait
+        #pragma omp task shared(a) depend(inout: a)
+        {
+          my_sleep(1.0);
+          #pragma omp atomic
+          a++;
+        }
+        #pragma omp task if(0) depend(inout: a)
+        {}
+
+        #pragma omp atomic read
+        a_value = a;
+
+        if (a_value != 1) {
+          fprintf(stderr, "error: dependent task was not executed before "
+                          "taskwait finished\n");
+          exit(EXIT_FAILURE);
+        }
+      } // #pragma omp single
+    } // if (num_threads > 1)
+  } // #pragma omp parallel
+
+  return EXIT_SUCCESS;
+}