[WIP] Taskgraphs

tests/6.0/taskgraph/test_taskgraph.c

@@ -0,0 +1,40 @@
+//===-- test_taskgraph.c ------------------------------------------------===//
+//
+// OpenMP API Version 6.0 Nov 2024
+//
+// Description
+// testTaskgraph():
+// Create a taskgraph
+// Ensures the structured block is executed
+//===----------------------------------------------------------------------===//
+
+#include <stdio.h>
+#include <assert.h>
+#include <stdlib.h>
+#include <omp.h>
+#include "ompvv.h"
+
+int testTaskgraph(void)
+{
+    int errors = 0;
+    int x = 0;
+    #pragma omp parallel shared(x)
+    {
+        # pragma omp single
+        {
+            # pragma omp taskgraph
+            {
+                ++x;
+            }
+        }
+    }
+    OMPVV_TEST_AND_SET_VERBOSE(errors, x != 1);
+    return errors;
+}
+
+int main(void)
+{
+    int errors = 0;
+    OMPVV_TEST_AND_SET_VERBOSE(errors, testTaskgraph());
+    OMPVV_REPORT_AND_RETURN(errors);
+}

tests/6.0/taskgraph/test_taskgraph_heterogeneous.c

@@ -0,0 +1,63 @@
+//===-- test_taskgraph.c ------------------------------------------------===//
+//
+// OpenMP API Version 6.0 Nov 2024
+//
+// Description
+// testTaskgraphHeterogeneous():
+// Create a taskgraph, spawns 3 dependent tasks
+//  T1 -> T2 -> T3
+// with (T1, T3) on device, (T2) on host.
+//
+// Ensures that
+//   - the structured block is executed 1 to N times
+//   - 3*N tasks are executed/replayed
+//===----------------------------------------------------------------------===//
+
+#include <stdio.h>
+#include <assert.h>
+#include <stdlib.h>
+#include <omp.h>
+#include "ompvv.h"
+
+int testTaskgraphHeterogeneous(void)
+{
+    int errors = 0;
+
+    # define N 16
+    int x = 0;
+    int y = 0;
+
+    # pragma omp parallel shared(x, y)
+    {
+        # pragma omp single
+        {
+            for (int i = 0 ; i < N ; ++i)
+            {
+                # pragma omp taskgraph
+                {
+                    ++x;
+
+                    # pragma omp target nowait map(tofrom: y) depend(out: y) shared(y)
+                        ++y;
+
+                    # pragma omp task depend(out: y) shared(y)
+                        ++y;
+
+                    # pragma omp target nowait map(tofrom: y) depend(out: y) shared(y)
+                        ++y;
+                }
+            }
+        }
+    }
+
+    OMPVV_TEST_AND_SET_VERBOSE(errors, !(0 < x && x <= N));
+    OMPVV_TEST_AND_SET_VERBOSE(errors, y != 3*N);
+    return errors;
+}
+
+int main(void)
+{
+    int errors = 0;
+    OMPVV_TEST_AND_SET_VERBOSE(errors, testTaskgraphHeterogeneous());
+    OMPVV_REPORT_AND_RETURN(errors);
+}

tests/6.0/taskgraph/test_taskgraph_id.c

@@ -0,0 +1,73 @@
+//===-- test_taskgraph_id.c ------------------------------------------------===//
+//
+// OpenMP API Version 6.0 Nov 2024
+//
+// Description
+// testTaskgraphId():
+// M times, run N taskgraphs constructs with id '0<=i<N' that spawns 3 tasks
+//  T1 -> T2 -> T3
+// Ensure that each taskgraph' structured block executed 1 to M times
+// Ensure that each triplets executed precisely M times
+//===----------------------------------------------------------------------===//
+
+#include <stdio.h>
+#include <assert.h>
+#include <stdlib.h>
+#include <omp.h>
+#include "ompvv.h"
+
+int testTaskgraphGraphId(void)
+{
+    int errors = 0;
+
+    # define N 16
+    # define M 16
+
+    int x[N];
+    int y[N];
+    memset(x, 0, sizeof(x));
+    memset(y, 0, sizeof(y));
+
+    # pragma omp parallel shared(x, y)
+    {
+        # pragma omp single
+        {
+            for (int j = 0 ; j < M ; ++j)
+            {
+                for (int i = 0 ; i < N ; ++i)
+                {
+                    # pragma omp taskgraph graph_id(i)
+                    {
+                        ++x[i];
+                        for (int i = 0 ; i < 3 ; ++i)
+                        {
+                            # pragma omp task depend(out: y) shared(y)
+                            {
+                                # pragma omp atomic
+                                    ++y[i];
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    for (int i = 0 ; i < N ; ++i)
+    {
+        // each taskgraph strucuted block must have executed 1 to M times
+        OMPVV_TEST_AND_SET_VERBOSE(errors, !(0 < x[i] && x[i] <= M));
+
+        // each triplets must have executed M times
+        OMPVV_TEST_AND_SET_VERBOSE(errors, y[i] != M);
+    }
+
+    return errors;
+}
+
+int main(void)
+{
+    int errors = 0;
+    OMPVV_TEST_AND_SET_VERBOSE(errors, testTaskgraphGraphId());
+    OMPVV_REPORT_AND_RETURN(errors);
+}

tests/6.0/taskgraph/test_taskgraph_if.c

@@ -0,0 +1,59 @@
+//===-- test_taskgraph_if.c ------------------------------------------------===//
+//
+// OpenMP API Version 6.0 Nov 2024
+//
+// Description
+// testTaskgraphIf():
+// Call
+//  taskgraph if(0) --> execute taskgraph construct, optionally creating a taskgraph record
+//  taskgraph if(1) --> skip
+//  taskgraph if(2) --> execute taskgraph construct, maybe replay taskgraph
+//                      record, or optionally create a taskgraph record
+// ensures that the structured block is executed 1 or 2 times
+// ensures that tasks are executed twice
+//===----------------------------------------------------------------------===//
+
+#include <stdio.h>
+#include <assert.h>
+#include <stdlib.h>
+#include <omp.h>
+#include "ompvv.h"
+
+int testTaskgraphIf(void)
+{
+    int errors = 0;
+    int x = 0;
+    int y = 0;
+    #pragma omp parallel shared(x, y)
+    {
+        # pragma omp single
+        {
+            for (int i = 0 ; i < 3 ; ++i)
+            {
+                # pragma omp taskgraph if(i != 1)
+                {
+                    ++x;
+
+                    # pragma omp task shared(y)
+                        ++y;
+                }
+            }
+        }
+    }
+
+    // the structured block must have been executed once or twice
+    // (once if creating a taskgraph record, twice if creating no taskgraph record)
+    OMPVV_TEST_AND_SET_VERBOSE(errors, !(x == 1 || x == 2));
+
+    // the task must execute precisely twice
+    OMPVV_TEST_AND_SET_VERBOSE(errors, y != 2);
+
+    return errors;
+}
+
+int main(void)
+{
+    int errors = 0;
+    OMPVV_TEST_AND_SET_VERBOSE(errors, testTaskgraphIf());
+    OMPVV_REPORT_AND_RETURN(errors);
+}

tests/6.0/taskgraph/test_taskgraph_nogroup.c

@@ -0,0 +1,52 @@
+//===-- test_taskgraph.c ------------------------------------------------===//
+//
+// OpenMP API Version 6.0 Nov 2024
+//
+// Description
+// testTaskgraphNoGroup():
+// Run a taskgraph nogroup construct N times,
+// ensures the structured block is executed from 1 to N times
+//===----------------------------------------------------------------------===//
+
+#include <stdio.h>
+#include <assert.h>
+#include <stdlib.h>
+#include <omp.h>
+#include "ompvv.h"
+
+int testTaskgraphNoGroup(void)
+{
+    int errors = 0;
+
+    # define N 16
+    int x = 0;
+    int y = 0;
+    #pragma omp parallel shared(x, y)
+    {
+        # pragma omp single
+        {
+            for (int i = 0 ; i < N ; ++i)
+            {
+                # pragma omp taskgraph nogroup
+                {
+                    ++x;
+                    # pragma omp task shared(y)
+                    {
+                        # pragma omp atomic
+                            ++y;
+                    }
+                }
+            }
+        }
+    }
+    OMPVV_TEST_AND_SET_VERBOSE(errors, !(0 < x && x <= N));
+    OMPVV_TEST_AND_SET_VERBOSE(errors, y != N);
+    return errors;
+}
+
+int main(void)
+{
+    int errors = 0;
+    OMPVV_TEST_AND_SET_VERBOSE(errors, testTaskgraphNoGroup());
+    OMPVV_REPORT_AND_RETURN(errors);
+}

tests/6.0/taskgraph/test_taskgraph_parallel.c

@@ -0,0 +1,60 @@
+//===-- test_taskgraph.c ------------------------------------------------===//
+//
+// OpenMP API Version 6.0 Nov 2024
+//
+// Description
+// testTaskgraphParallel():
+// N times, have 'nthreads' threads call the same taskgraph construct
+//
+// ensure the structured block executed 1 to N times,
+// and the replayable task 'N*nthreads' times
+//===----------------------------------------------------------------------===//
+
+#include <stdio.h>
+#include <assert.h>
+#include <stdlib.h>
+#include <omp.h>
+#include "ompvv.h"
+
+int testTaskgraphParallel(void)
+{
+    int errors = 0;
+
+    # define N 16
+    int x = 0;
+    int y = 0;
+    int nthreads = -1;
+
+    #pragma omp parallel shared(x, y, nthreads)
+    {
+        # pragma omp single
+        {
+            nthreads = omp_get_num_threads();
+        }
+
+        for (int i = 0 ; i < N ; ++i)
+        {
+            # pragma omp taskgraph
+            {
+                ++x;
+                # pragma omp task shared(y)
+                {
+                    # pragma omp atomic
+                        ++y;
+                }
+            }
+        }
+    }
+    OMPVV_TEST_AND_SET_VERBOSE(errors, nthreads <= 0);
+    OMPVV_TEST_AND_SET_VERBOSE(errors, !(0 < x && x <= N));
+    OMPVV_TEST_AND_SET_VERBOSE(errors, y != nthreads*N);
+
+    return errors;
+}
+
+int main(void)
+{
+    int errors = 0;
+    OMPVV_TEST_AND_SET_VERBOSE(errors, testTaskgraphParallel());
+    OMPVV_REPORT_AND_RETURN(errors);
+}