Rework Graph API tests

Signed-off-by: Pablo Reble <[email protected]>

Author: reble

source/benchmarks/graph_api_benchmark/definitions/submit_exec_graph.h

@@ -0,0 +1,38 @@
+/*
+ * Copyright (C) 2024-2025 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#pragma once
+
+#include "framework/argument/basic_argument.h"
+#include "framework/test_case/test_case.h"
+
+struct SubmitGraphArguments : TestCaseArgumentContainer {
+    BooleanArgument useProfiling;
+    BooleanArgument inOrderQueue;
+    PositiveIntegerArgument numKernels;
+    PositiveIntegerArgument kernelExecutionTime;
+    BooleanArgument measureCompletionTime;
+
+    SubmitGraphArguments()
+        : useProfiling(*this, "Profiling", "Create the queue with the enable_profiling property"),
+          inOrderQueue(*this, "InOrderQueue", "Create the queue with the in_order property"),
+          numKernels(*this, "NumKernels", "Number of kernels to submit to the queue"),
+          kernelExecutionTime(*this, "KernelExecutionTime", "Approximately how long a single kernel executes, in us"),
+          measureCompletionTime(*this, "MeasureCompletionTime", "Measures time taken to complete the submission (default is to measure only submit calls)") {}
+};
+
+struct SubmitGraph : TestCase<SubmitGraphArguments> {
+    using TestCase<SubmitGraphArguments>::TestCase;
+
+    std::string getTestCaseName() const override {
+        return "SubmitGraph";
+    }
+
+    std::string getHelp() const override {
+        return "measures time spent in submitting a graph to a SYCL (or SYCL-like) queue on CPU.";
+    }
+};

source/benchmarks/graph_api_benchmark/definitions/submit_graph.h

@@ -0,0 +1,41 @@
+/*
+ * Copyright (C) 2024-2025 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#include "definitions/submit_graph.h"
+
+#include "framework/test_case/register_test_case.h"
+#include "framework/utility/common_gtest_args.h"
+
+#include <gtest/gtest.h>
+
+[[maybe_unused]] static const inline RegisterTestCase<SubmitGraph> registerTestCase{};
+
+class SubmitGraphTest : public ::testing::TestWithParam<std::tuple<Api, bool, bool, size_t, size_t, bool>> {
+};
+
+TEST_P(SubmitGraphTest, Test) {
+    SubmitGraphArguments args{};
+    args.api = std::get<0>(GetParam());
+    args.useProfiling = std::get<1>(GetParam());
+    args.inOrderQueue = std::get<2>(GetParam());
+    args.numKernels = std::get<3>(GetParam());
+    args.kernelExecutionTime = std::get<4>(GetParam());
+    args.measureCompletionTime = std::get<5>(GetParam());
+    SubmitGraph test;
+    test.run(args);
+}
+
+INSTANTIATE_TEST_SUITE_P(
+    SubmitGraphTest,
+    SubmitGraphTest,
+    ::testing::Combine(
+        ::CommonGtestArgs::allApis(),
+        ::testing::Values(false, true),      // useProfiling
+        ::testing::Values(false, true),      // inOrderQueue
+        ::testing::Values(4u, 8u, 16u, 32u), // numKernels
+        ::testing::Values(1u),               // kernelExecutionTime
+        ::testing::Values(false, true)));    // measureCompletionTime

source/benchmarks/graph_api_benchmark/gtest/submit_exec_graph.cpp

@@ -0,0 +1,106 @@
+/*
+ * Copyright (C) 2024-2025 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#include "framework/test_case/register_test_case.h"
+#include "framework/utility/timer.h"
+
+#include "definitions/submit_graph.h"
+
+#include <gtest/gtest.h>
+#include <sycl/sycl.hpp>
+#if __has_include(<sycl/ext/oneapi/experimental/graph.hpp>)
+#include <sycl/ext/oneapi/experimental/graph.hpp>
+#define HAS_SYCL_GRAPH
+#endif
+
+static auto enableProfiling = sycl::property::queue::enable_profiling();
+static auto inOrder = sycl::property::queue::in_order();
+
+[[maybe_unused]] static const sycl::property_list queueProps[] = {
+    sycl::property_list{},
+    sycl::property_list{enableProfiling},
+    sycl::property_list{inOrder},
+    sycl::property_list{inOrder, enableProfiling},
+};
+
+static TestResult run([[maybe_unused]] const SubmitGraphArguments &arguments, Statistics &statistics) {
+    try {
+        MeasurementFields typeSelector(MeasurementUnit::Microseconds, MeasurementType::Cpu);
+
+        if (isNoopRun()) {
+            statistics.pushUnitAndType(typeSelector.getUnit(), typeSelector.getType());
+            return TestResult::Nooped;
+        }
+
+#if defined(HAS_SYCL_GRAPH)
+        // Setup
+        auto queuePropsIndex = 0;
+        queuePropsIndex |= arguments.useProfiling ? 0x1 : 0;
+        queuePropsIndex |= arguments.inOrderQueue ? 0x2 : 0;
+        sycl::queue queue{queueProps[queuePropsIndex]};
+
+        Timer timer;
+        const size_t gws = 1u;
+        const size_t lws = 1u;
+        sycl::nd_range<1> range(gws, lws);
+
+        // Create kernel
+        int kernelOperationsCount = static_cast<int>(arguments.kernelExecutionTime);
+        [[maybe_unused]] const auto eat_time = [=]([[maybe_unused]] auto u) {
+            volatile int value = 1u;
+            for (int i = 0; i < kernelOperationsCount; i++) {
+                value /= 2;
+                value *= 2;
+            }
+        };
+
+        // Building the graph without explicit dependencies
+        sycl::ext::oneapi::experimental::command_graph graph(queue.get_context(), queue.get_device());
+        graph.begin_recording(queue);
+        for (auto iteration = 0u; iteration < arguments.numKernels; iteration++) {
+            queue.parallel_for(range, eat_time);
+        }
+        graph.end_recording();
+
+        // Finalize the graph
+        auto executable_graph = graph.finalize();
+
+        // Warmup
+        queue.submit([&](sycl::handler &cgh) {
+            cgh.ext_oneapi_graph(executable_graph);
+        });
+        queue.wait();
+
+        // Benchmark
+        for (auto i = 0u; i < arguments.iterations; i++) {
+            timer.measureStart();
+            queue.submit([&](sycl::handler &cgh) {
+                cgh.ext_oneapi_graph(executable_graph);
+            });
+
+            if (!arguments.measureCompletionTime) {
+                timer.measureEnd();
+            }
+
+            queue.wait();
+
+            if (arguments.measureCompletionTime) {
+                timer.measureEnd();
+            }
+            statistics.pushValue(timer.get(), typeSelector.getUnit(), typeSelector.getType());
+        }
+
+#endif
+    } catch (sycl::exception &e) {
+        std::cerr << "Caught SYCL exception: " << e.what() << "\n";
+        return TestResult::Error;
+    }
+
+    return TestResult::Success;
+}
+
+[[maybe_unused]] static RegisterTestCaseImplementation<SubmitGraph> registerTestCase(run, Api::SYCL);