Implement submit_barrier benchmark

for mesuring performance of ext_oneapi_submit_barrier
and ext_oneapi_get_last_event.

This is in preparation for optimizing in-order queue
path (we plan to stop storing last event in the
queue).

Signed-off-by: Igor Chorazewicz <[email protected]>

Author: igchor

source/benchmarks/api_overhead_benchmark/definitions/submit_barrier.h

@@ -0,0 +1,38 @@
+/*
+ * Copyright (C) 2022-2025 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#pragma once
+
+#include "framework/argument/basic_argument.h"
+#include "framework/test_case/test_case.h"
+
+struct SubmitBarrierArguments : TestCaseArgumentContainer {
+    BooleanArgument useHostTasks;
+    BooleanArgument inOrderQueue;
+    BooleanArgument useEvents;
+    BooleanArgument submitBarrier;
+    BooleanArgument getLastEvent;
+
+    SubmitBarrierArguments()
+        : useHostTasks(*this, "UseHostTasks", "Submit SYCL host task after kernel enqueue"),
+          inOrderQueue(*this, "Ioq", "Create the queue with the in_order property"),
+          useEvents(*this, "UseEvents", "Use events when enqueuing kernels. When false, SYCL will use eventless enqueue functions."),
+          submitBarrier(*this, "SubmitBarrier", "Whether to measure ext_oneapi_submit_barrier time"),
+          getLastEvent(*this, "GetLastEvent", "Whether to measure ext_oneapi_get_last_event time") {}
+};
+
+struct SubmitBarrier : TestCase<SubmitBarrierArguments> {
+    using TestCase<SubmitBarrierArguments>::TestCase;
+
+    std::string getTestCaseName() const override {
+        return "SubmitBarrier";
+    }
+
+    std::string getHelp() const override {
+        return "measures time spent in submitting a barrier to a SYCL (or SYCL-like) queue on CPU and getting last event.";
+    }
+};

source/benchmarks/api_overhead_benchmark/gtest/submit_barrier.cpp

@@ -0,0 +1,39 @@
+/*
+ * Copyright (C) 2022-2025 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#include "definitions/submit_barrier.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<SubmitBarrier> registerTestCase{};
+
+class SubmitBarrierTest : public ::testing::TestWithParam<std::tuple<Api, bool, bool, bool, bool>> {
+};
+
+TEST_P(SubmitBarrierTest, Test) {
+    SubmitBarrierArguments args{};
+    args.api = std::get<0>(GetParam());
+    args.inOrderQueue = std::get<1>(GetParam());
+    args.useEvents = std::get<2>(GetParam());
+    args.submitBarrier = std::get<3>(GetParam());
+    args.getLastEvent = std::get<4>(GetParam());
+    SubmitBarrier test;
+    test.run(args);
+}
+
+INSTANTIATE_TEST_SUITE_P(
+    SubmitBarrierTest,
+    SubmitBarrierTest,
+    ::testing::Combine(
+        ::CommonGtestArgs::allApis(),
+        ::testing::Values(false, true),   // inOrderQueue
+        ::testing::Values(false, true),   // useEvents
+        ::testing::Values(false, true),   // submitBarrier
+        ::testing::Values(false, true))); // getLastEvent

source/benchmarks/api_overhead_benchmark/implementations/sycl/submit_barrier_sycl.cpp

@@ -0,0 +1,88 @@
+/*
+ * Copyright (C) 2023-2025 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#include "framework/test_case/register_test_case.h"
+#include "framework/utility/timer.h"
+
+#include "definitions/submit_barrier.h"
+
+#include <sycl/sycl.hpp>
+
+static TestResult run(const SubmitBarrierArguments &arguments, Statistics &statistics) {
+    MeasurementFields typeSelector(MeasurementUnit::Microseconds, MeasurementType::Cpu);
+
+    if (isNoopRun() || (arguments.getLastEvent && !arguments.inOrderQueue)) {
+        statistics.pushUnitAndType(typeSelector.getUnit(), typeSelector.getType());
+        return TestResult::Nooped;
+    }
+
+    // Setup
+    sycl::queue queue{arguments.inOrderQueue ? sycl::property_list{sycl::property::queue::in_order()} : sycl::property_list{}};
+
+    Timer timer;
+    const size_t gws = 1u;
+    const size_t lws = 1u;
+    sycl::nd_range<1> range(gws, lws);
+
+    // Create kernel
+    int kernelOperationsCount = 10000;
+    const auto eat_time = [=]([[maybe_unused]] auto u) {
+        if (kernelOperationsCount > 4) {
+            volatile int value = kernelOperationsCount;
+            while (--value)
+                ;
+        }
+    };
+
+    // Warmup
+    for (auto iteration = 0u; iteration < 10; iteration++) {
+        queue.parallel_for(range, eat_time);
+
+        if (arguments.submitBarrier) {
+            queue.ext_oneapi_submit_barrier();
+        }
+
+        if (arguments.getLastEvent) {
+            queue.ext_oneapi_get_last_event();
+        }
+    }
+    queue.wait();
+
+    // Benchmark
+    for (auto i = 0u; i < arguments.iterations; i++) {
+        if (!arguments.useEvents) {
+            sycl::ext::oneapi::experimental::nd_launch(queue, range, eat_time);
+        } else {
+            queue.parallel_for(range, eat_time);
+        }
+
+        if (arguments.useHostTasks) {
+            queue.submit([&](sycl::handler &cgh) {
+                cgh.host_task([=]() { eat_time(0); });
+            });
+        }
+
+        timer.measureStart();
+
+        if (arguments.submitBarrier) {
+            queue.ext_oneapi_submit_barrier();
+        }
+
+        if (arguments.getLastEvent) {
+            queue.ext_oneapi_get_last_event();
+        }
+
+        timer.measureEnd();
+
+        statistics.pushValue(timer.get(), typeSelector.getUnit(), typeSelector.getType());
+    }
+    queue.wait();
+
+    return TestResult::Success;
+}
+
+[[maybe_unused]] static RegisterTestCaseImplementation<SubmitBarrier> registerTestCase(run, Api::SYCL);