[WIP] Taskgraphs

tests/6.0/taskgraph/test_taskgraph.c

@@ -0,0 +1,35 @@
+//===-- test_taskgraph.c ------------------------------------------------===//
+//
+// OpenMP API Version 6.0 Nov 2024
+//
+// Description
+// testTaskgraph():
+// Create a taskgraph
+//===----------------------------------------------------------------------===//
+
+#include <stdio.h>
+#include <assert.h>
+#include <stdlib.h>
+#include <omp.h>
+#include "ompvv.h"
+
+int testTaskgraph(void)
+{
+    #pragma omp parallel shared(x)
+    {
+        # pragma omp single
+        {
+            # pragma omp taskgraph
+            {
+            }
+        }
+    }
+    return 0;
+}
+
+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,65 @@
+//===-- 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 0 to N times
+//      - 0 if taskgraph record created prior to execution
+//      - N if taskgraph record is never created
+//   - 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 0 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 k = 0 ; k < 3 ; ++k)
+                        {
+                            # 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 0 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] != 3*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,60 @@
+//===-- test_taskgraph_if.c ------------------------------------------------===//
+//
+// OpenMP API Version 6.0 Nov 2024
+//
+// Description
+// testTaskgraphIf():
+// Call
+//  taskgraph i=0 if(true)  --> execute taskgraph construct, optionally creating a taskgraph record
+//  taskgraph i=1 if(false) --> execute taskgraph construct, not creating a record, nor replaying a previous record
+//  taskgraph i=2 if(true)  --> execute taskgraph construct, maybe replay taskgraph record, or optionally create a taskgraph record
+//
+// Ensures that the structured block is executed when if(false) is present
+// Ensures that tasks are executed three times
+//===----------------------------------------------------------------------===//
+
+#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)
+                {
+                    if (i == 1)
+                        ++x;
+
+                    # pragma omp task shared(y)
+                        ++y;
+                }
+            }
+        }
+    }
+
+    // the structured block must have been executed at least once on i=1
+    OMPVV_TEST_AND_SET_VERBOSE(errors, x != 1);
+
+    // the task must have executed 3 times
+    OMPVV_TEST_AND_SET_VERBOSE(errors, y != 3);
+
+    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,53 @@
+//===-- test_taskgraph_nogroup.c ------------------------------------------------===//
+//
+// OpenMP API Version 6.0 Nov 2024
+//
+// Description
+// testTaskgraphNoGroup():
+// Run a taskgraph nogroup construct N times with 1 task.
+// Ensures the structured block is executed from 0 to N times
+// Ensures the task is executed 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,62 @@
+//===-- 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 0 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
+            {
+                # pragma omp atomic update
+                    ++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 <= nthreads*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);
+}