From 8b64be9a283beafb9c87c5f497e28d82a3c30e85 Mon Sep 17 00:00:00 2001 From: "Ptak, Slawomir" Date: Tue, 26 Aug 2025 13:41:17 +0000 Subject: [PATCH 1/4] [SYCL] Introduce unit test kernel wrapper functions for single_task --- .../helpers/CommandSubmitWrappers.hpp | 33 +++++++++++++ sycl/unittests/scheduler/InOrderQueueDeps.cpp | 47 ++++++++++--------- sycl/unittests/scheduler/SchedulerTest.hpp | 2 +- 3 files changed, 58 insertions(+), 24 deletions(-) create mode 100644 sycl/unittests/helpers/CommandSubmitWrappers.hpp diff --git a/sycl/unittests/helpers/CommandSubmitWrappers.hpp b/sycl/unittests/helpers/CommandSubmitWrappers.hpp new file mode 100644 index 0000000000000..6dbd4ed280180 --- /dev/null +++ b/sycl/unittests/helpers/CommandSubmitWrappers.hpp @@ -0,0 +1,33 @@ +//==-- CommandSubmitWrappers.hpp --- -----==// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include +#include + +using namespace sycl; + +template +event single_task_wrapper(bool Shortcut, queue &Q, const KernelType &KernelFunc) { + if (Shortcut) { + return Q.single_task(KernelFunc); + } else { + return Q.submit([&](handler &cgh) { cgh.single_task(KernelFunc); }); + } +} + +template +event single_task_wrapper(bool Shortcut, queue &Q, event DepEvent, const KernelType &KernelFunc) { + if (Shortcut) { + return Q.single_task(DepEvent, KernelFunc); + } else { + return Q.submit([&](handler &cgh) { + cgh.depends_on(DepEvent); + cgh.single_task(KernelFunc); + }); + } +} \ No newline at end of file diff --git a/sycl/unittests/scheduler/InOrderQueueDeps.cpp b/sycl/unittests/scheduler/InOrderQueueDeps.cpp index dc9bd42de84a7..b2376bdf1e79b 100644 --- a/sycl/unittests/scheduler/InOrderQueueDeps.cpp +++ b/sycl/unittests/scheduler/InOrderQueueDeps.cpp @@ -11,6 +11,7 @@ #include #include +#include #include #include @@ -44,7 +45,7 @@ ur_result_t redefinedEnqueueMemUnmap(void *pParams) { return UR_RESULT_SUCCESS; } -TEST_F(SchedulerTest, InOrderQueueDeps) { +TEST_P(SchedulerTest, InOrderQueueDeps) { sycl::unittest::UrMock<> Mock; sycl::platform Plt = sycl::platform(); mock::getCallbacks().set_before_callback("urEnqueueMemBufferReadRect", @@ -95,15 +96,12 @@ ur_result_t redefinedEnqueueEventsWaitWithBarrierExt(void *pParams) { return UR_RESULT_SUCCESS; } -sycl::event submitKernel(sycl::queue &Q) { - return Q.submit([&](handler &cgh) { cgh.single_task([]() {}); }); -} - -TEST_F(SchedulerTest, InOrderQueueIsolatedDeps) { +TEST_P(SchedulerTest, InOrderQueueIsolatedDeps) { // Check that isolated kernels (i.e. those that don't modify the graph) // are handled properly during filtering. sycl::unittest::UrMock<> Mock; sycl::platform Plt = sycl::platform(); + bool ShortcutSubmitFunction = GetParam(); mock::getCallbacks().set_before_callback( "urEnqueueEventsWaitWithBarrierExt", &redefinedEnqueueEventsWaitWithBarrierExt); @@ -112,14 +110,17 @@ TEST_F(SchedulerTest, InOrderQueueIsolatedDeps) { context Ctx{Plt.get_devices()[0]}; queue Q1{Ctx, default_selector_v, property::queue::in_order()}; { - event E = submitKernel(Q1); + event E = single_task_wrapper(ShortcutSubmitFunction, + Q1, []() {}); Q1.ext_oneapi_submit_barrier({E}); EXPECT_FALSE(BarrierCalled); } queue Q2{Ctx, default_selector_v, property::queue::in_order()}; { - event E1 = submitKernel(Q1); - event E2 = submitKernel(Q2); + event E1 = single_task_wrapper(ShortcutSubmitFunction, + Q1, []() {}); + event E2 = single_task_wrapper(ShortcutSubmitFunction, + Q2, []() {}); ExpectedEvent = detail::getSyclObjImpl(E2)->getHandle(); Q1.ext_oneapi_submit_barrier({E1, E2}); EXPECT_TRUE(BarrierCalled); @@ -134,9 +135,10 @@ inline ur_result_t customEnqueueKernelLaunch(void *pParams) { return UR_RESULT_SUCCESS; } -TEST_F(SchedulerTest, TwoInOrderQueuesOnSameContext) { +TEST_P(SchedulerTest, TwoInOrderQueuesOnSameContext) { KernelEventListSize.clear(); sycl::unittest::UrMock<> Mock; + bool ShortcutSubmitFunction = GetParam(); mock::getCallbacks().set_before_callback("urEnqueueKernelLaunch", &customEnqueueKernelLaunch); @@ -147,12 +149,10 @@ TEST_F(SchedulerTest, TwoInOrderQueuesOnSameContext) { queue InOrderQueueSecond{Ctx, default_selector_v, property::queue::in_order()}; - event EvFirst = InOrderQueueFirst.submit( - [&](sycl::handler &CGH) { CGH.single_task([] {}); }); - std::ignore = InOrderQueueSecond.submit([&](sycl::handler &CGH) { - CGH.depends_on(EvFirst); - CGH.single_task([] {}); - }); + event EvFirst = single_task_wrapper(ShortcutSubmitFunction, + InOrderQueueFirst, []() {}); + std::ignore = single_task_wrapper(ShortcutSubmitFunction, + InOrderQueueSecond, EvFirst, []() {}); InOrderQueueFirst.wait(); InOrderQueueSecond.wait(); @@ -162,9 +162,10 @@ TEST_F(SchedulerTest, TwoInOrderQueuesOnSameContext) { EXPECT_EQ(KernelEventListSize[1] /*EventsCount*/, 1u); } -TEST_F(SchedulerTest, InOrderQueueNoSchedulerPath) { +TEST_P(SchedulerTest, InOrderQueueNoSchedulerPath) { KernelEventListSize.clear(); sycl::unittest::UrMock<> Mock; + bool ShortcutSubmitFunction = GetParam(); mock::getCallbacks().set_before_callback("urEnqueueKernelLaunch", &customEnqueueKernelLaunch); @@ -173,12 +174,10 @@ TEST_F(SchedulerTest, InOrderQueueNoSchedulerPath) { context Ctx{Plt}; queue InOrderQueue{Ctx, default_selector_v, property::queue::in_order()}; - event EvFirst = InOrderQueue.submit( - [&](sycl::handler &CGH) { CGH.single_task([] {}); }); - std::ignore = InOrderQueue.submit([&](sycl::handler &CGH) { - CGH.depends_on(EvFirst); - CGH.single_task([] {}); - }); + event EvFirst = single_task_wrapper(ShortcutSubmitFunction, + InOrderQueue, []() {}); + std::ignore = single_task_wrapper(ShortcutSubmitFunction, + InOrderQueue, EvFirst, []() {}); InOrderQueue.wait(); @@ -190,3 +189,5 @@ TEST_F(SchedulerTest, InOrderQueueNoSchedulerPath) { } } // anonymous namespace + +INSTANTIATE_TEST_SUITE_P(SchedulerTestInstance, SchedulerTest, testing::Values(true, false)); \ No newline at end of file diff --git a/sycl/unittests/scheduler/SchedulerTest.hpp b/sycl/unittests/scheduler/SchedulerTest.hpp index a453368592a40..0a9829c27849e 100644 --- a/sycl/unittests/scheduler/SchedulerTest.hpp +++ b/sycl/unittests/scheduler/SchedulerTest.hpp @@ -12,7 +12,7 @@ #include -class SchedulerTest : public ::testing::Test { +class SchedulerTest : public testing::TestWithParam { protected: sycl::async_handler MAsyncHandler = [](sycl::exception_list ExceptionList) { for (std::exception_ptr ExceptionPtr : ExceptionList) { From 6586e3b039dce333e072ff3b4554ffb3d0b73f34 Mon Sep 17 00:00:00 2001 From: "Ptak, Slawomir" Date: Tue, 26 Aug 2025 13:49:40 +0000 Subject: [PATCH 2/4] Fix formatting and var name --- .../helpers/CommandSubmitWrappers.hpp | 37 ++++++++++--------- sycl/unittests/scheduler/InOrderQueueDeps.cpp | 27 +++++++------- 2 files changed, 34 insertions(+), 30 deletions(-) diff --git a/sycl/unittests/helpers/CommandSubmitWrappers.hpp b/sycl/unittests/helpers/CommandSubmitWrappers.hpp index 6dbd4ed280180..a6f20229053df 100644 --- a/sycl/unittests/helpers/CommandSubmitWrappers.hpp +++ b/sycl/unittests/helpers/CommandSubmitWrappers.hpp @@ -11,23 +11,26 @@ using namespace sycl; -template -event single_task_wrapper(bool Shortcut, queue &Q, const KernelType &KernelFunc) { - if (Shortcut) { - return Q.single_task(KernelFunc); - } else { - return Q.submit([&](handler &cgh) { cgh.single_task(KernelFunc); }); - } +template +event single_task_wrapper(bool ShortcutSubmitFunction, queue &Q, + const KernelType &KernelFunc) { + if (ShortcutSubmitFunction) { + return Q.single_task(KernelFunc); + } else { + return Q.submit( + [&](handler &cgh) { cgh.single_task(KernelFunc); }); + } } -template -event single_task_wrapper(bool Shortcut, queue &Q, event DepEvent, const KernelType &KernelFunc) { - if (Shortcut) { - return Q.single_task(DepEvent, KernelFunc); - } else { - return Q.submit([&](handler &cgh) { - cgh.depends_on(DepEvent); - cgh.single_task(KernelFunc); - }); - } +template +event single_task_wrapper(bool ShortcutSubmitFunction, queue &Q, event DepEvent, + const KernelType &KernelFunc) { + if (ShortcutSubmitFunction) { + return Q.single_task(DepEvent, KernelFunc); + } else { + return Q.submit([&](handler &cgh) { + cgh.depends_on(DepEvent); + cgh.single_task(KernelFunc); + }); + } } \ No newline at end of file diff --git a/sycl/unittests/scheduler/InOrderQueueDeps.cpp b/sycl/unittests/scheduler/InOrderQueueDeps.cpp index b2376bdf1e79b..1a8c1aaf77712 100644 --- a/sycl/unittests/scheduler/InOrderQueueDeps.cpp +++ b/sycl/unittests/scheduler/InOrderQueueDeps.cpp @@ -9,9 +9,9 @@ #include "SchedulerTest.hpp" #include "SchedulerTestUtils.hpp" +#include #include #include -#include #include #include @@ -110,17 +110,17 @@ TEST_P(SchedulerTest, InOrderQueueIsolatedDeps) { context Ctx{Plt.get_devices()[0]}; queue Q1{Ctx, default_selector_v, property::queue::in_order()}; { - event E = single_task_wrapper(ShortcutSubmitFunction, - Q1, []() {}); + event E = + single_task_wrapper(ShortcutSubmitFunction, Q1, []() {}); Q1.ext_oneapi_submit_barrier({E}); EXPECT_FALSE(BarrierCalled); } queue Q2{Ctx, default_selector_v, property::queue::in_order()}; { - event E1 = single_task_wrapper(ShortcutSubmitFunction, - Q1, []() {}); - event E2 = single_task_wrapper(ShortcutSubmitFunction, - Q2, []() {}); + event E1 = + single_task_wrapper(ShortcutSubmitFunction, Q1, []() {}); + event E2 = + single_task_wrapper(ShortcutSubmitFunction, Q2, []() {}); ExpectedEvent = detail::getSyclObjImpl(E2)->getHandle(); Q1.ext_oneapi_submit_barrier({E1, E2}); EXPECT_TRUE(BarrierCalled); @@ -150,9 +150,9 @@ TEST_P(SchedulerTest, TwoInOrderQueuesOnSameContext) { property::queue::in_order()}; event EvFirst = single_task_wrapper(ShortcutSubmitFunction, - InOrderQueueFirst, []() {}); - std::ignore = single_task_wrapper(ShortcutSubmitFunction, - InOrderQueueSecond, EvFirst, []() {}); + InOrderQueueFirst, []() {}); + std::ignore = single_task_wrapper( + ShortcutSubmitFunction, InOrderQueueSecond, EvFirst, []() {}); InOrderQueueFirst.wait(); InOrderQueueSecond.wait(); @@ -175,9 +175,9 @@ TEST_P(SchedulerTest, InOrderQueueNoSchedulerPath) { queue InOrderQueue{Ctx, default_selector_v, property::queue::in_order()}; event EvFirst = single_task_wrapper(ShortcutSubmitFunction, - InOrderQueue, []() {}); + InOrderQueue, []() {}); std::ignore = single_task_wrapper(ShortcutSubmitFunction, - InOrderQueue, EvFirst, []() {}); + InOrderQueue, EvFirst, []() {}); InOrderQueue.wait(); @@ -190,4 +190,5 @@ TEST_P(SchedulerTest, InOrderQueueNoSchedulerPath) { } // anonymous namespace -INSTANTIATE_TEST_SUITE_P(SchedulerTestInstance, SchedulerTest, testing::Values(true, false)); \ No newline at end of file +INSTANTIATE_TEST_SUITE_P(SchedulerTestInstance, SchedulerTest, + testing::Values(true, false)); \ No newline at end of file From 067e8e75d23d9470555c42ccf804831dec66d5c3 Mon Sep 17 00:00:00 2001 From: "Ptak, Slawomir" Date: Thu, 28 Aug 2025 08:35:42 +0000 Subject: [PATCH 3/4] Address review comments --- .../helpers/CommandSubmitWrappers.hpp | 29 +++++++++---- sycl/unittests/scheduler/InOrderQueueDeps.cpp | 41 ++++++++++--------- 2 files changed, 44 insertions(+), 26 deletions(-) diff --git a/sycl/unittests/helpers/CommandSubmitWrappers.hpp b/sycl/unittests/helpers/CommandSubmitWrappers.hpp index a6f20229053df..1255e697ccdd3 100644 --- a/sycl/unittests/helpers/CommandSubmitWrappers.hpp +++ b/sycl/unittests/helpers/CommandSubmitWrappers.hpp @@ -1,4 +1,4 @@ -//==-- CommandSubmitWrappers.hpp --- -----==// +//==-- CommandSubmitWrappers.hpp ----- Wrappers for command submission -----==// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. @@ -6,15 +6,27 @@ // //===----------------------------------------------------------------------===// +#pragma once + #include #include -using namespace sycl; +namespace sycl { + +inline namespace _V1 { +namespace unittest { + +// Wrappers introduced in this file allow for running unit tests +// with two command submission types: Using a handler and handler-less +// shortcut functions. +// This increases the test coverage, especially for the cases, +// where the command submission path implementation differes significantly +// between those two models. template -event single_task_wrapper(bool ShortcutSubmitFunction, queue &Q, +event single_task_wrapper(bool UseShortcutFunction, queue &Q, const KernelType &KernelFunc) { - if (ShortcutSubmitFunction) { + if (UseShortcutFunction) { return Q.single_task(KernelFunc); } else { return Q.submit( @@ -23,9 +35,9 @@ event single_task_wrapper(bool ShortcutSubmitFunction, queue &Q, } template -event single_task_wrapper(bool ShortcutSubmitFunction, queue &Q, event DepEvent, +event single_task_wrapper(bool UseShortcutFunction, queue &Q, event &DepEvent, const KernelType &KernelFunc) { - if (ShortcutSubmitFunction) { + if (UseShortcutFunction) { return Q.single_task(DepEvent, KernelFunc); } else { return Q.submit([&](handler &cgh) { @@ -33,4 +45,7 @@ event single_task_wrapper(bool ShortcutSubmitFunction, queue &Q, event DepEvent, cgh.single_task(KernelFunc); }); } -} \ No newline at end of file +} +} // namespace unittest +} // namespace _V1 +} // namespace sycl diff --git a/sycl/unittests/scheduler/InOrderQueueDeps.cpp b/sycl/unittests/scheduler/InOrderQueueDeps.cpp index 1a8c1aaf77712..599f84f374cb4 100644 --- a/sycl/unittests/scheduler/InOrderQueueDeps.cpp +++ b/sycl/unittests/scheduler/InOrderQueueDeps.cpp @@ -101,7 +101,7 @@ TEST_P(SchedulerTest, InOrderQueueIsolatedDeps) { // are handled properly during filtering. sycl::unittest::UrMock<> Mock; sycl::platform Plt = sycl::platform(); - bool ShortcutSubmitFunction = GetParam(); + bool UseShortcutFunction = GetParam(); mock::getCallbacks().set_before_callback( "urEnqueueEventsWaitWithBarrierExt", &redefinedEnqueueEventsWaitWithBarrierExt); @@ -110,17 +110,17 @@ TEST_P(SchedulerTest, InOrderQueueIsolatedDeps) { context Ctx{Plt.get_devices()[0]}; queue Q1{Ctx, default_selector_v, property::queue::in_order()}; { - event E = - single_task_wrapper(ShortcutSubmitFunction, Q1, []() {}); + event E = sycl::unittest::single_task_wrapper( + UseShortcutFunction, Q1, []() {}); Q1.ext_oneapi_submit_barrier({E}); EXPECT_FALSE(BarrierCalled); } queue Q2{Ctx, default_selector_v, property::queue::in_order()}; { - event E1 = - single_task_wrapper(ShortcutSubmitFunction, Q1, []() {}); - event E2 = - single_task_wrapper(ShortcutSubmitFunction, Q2, []() {}); + event E1 = sycl::unittest::single_task_wrapper( + UseShortcutFunction, Q1, []() {}); + event E2 = sycl::unittest::single_task_wrapper( + UseShortcutFunction, Q2, []() {}); ExpectedEvent = detail::getSyclObjImpl(E2)->getHandle(); Q1.ext_oneapi_submit_barrier({E1, E2}); EXPECT_TRUE(BarrierCalled); @@ -138,7 +138,7 @@ inline ur_result_t customEnqueueKernelLaunch(void *pParams) { TEST_P(SchedulerTest, TwoInOrderQueuesOnSameContext) { KernelEventListSize.clear(); sycl::unittest::UrMock<> Mock; - bool ShortcutSubmitFunction = GetParam(); + bool UseShortcutFunction = GetParam(); mock::getCallbacks().set_before_callback("urEnqueueKernelLaunch", &customEnqueueKernelLaunch); @@ -149,10 +149,10 @@ TEST_P(SchedulerTest, TwoInOrderQueuesOnSameContext) { queue InOrderQueueSecond{Ctx, default_selector_v, property::queue::in_order()}; - event EvFirst = single_task_wrapper(ShortcutSubmitFunction, - InOrderQueueFirst, []() {}); - std::ignore = single_task_wrapper( - ShortcutSubmitFunction, InOrderQueueSecond, EvFirst, []() {}); + event EvFirst = sycl::unittest::single_task_wrapper( + UseShortcutFunction, InOrderQueueFirst, []() {}); + std::ignore = sycl::unittest::single_task_wrapper( + UseShortcutFunction, InOrderQueueSecond, EvFirst, []() {}); InOrderQueueFirst.wait(); InOrderQueueSecond.wait(); @@ -165,7 +165,7 @@ TEST_P(SchedulerTest, TwoInOrderQueuesOnSameContext) { TEST_P(SchedulerTest, InOrderQueueNoSchedulerPath) { KernelEventListSize.clear(); sycl::unittest::UrMock<> Mock; - bool ShortcutSubmitFunction = GetParam(); + bool UseShortcutFunction = GetParam(); mock::getCallbacks().set_before_callback("urEnqueueKernelLaunch", &customEnqueueKernelLaunch); @@ -174,10 +174,10 @@ TEST_P(SchedulerTest, InOrderQueueNoSchedulerPath) { context Ctx{Plt}; queue InOrderQueue{Ctx, default_selector_v, property::queue::in_order()}; - event EvFirst = single_task_wrapper(ShortcutSubmitFunction, - InOrderQueue, []() {}); - std::ignore = single_task_wrapper(ShortcutSubmitFunction, - InOrderQueue, EvFirst, []() {}); + event EvFirst = sycl::unittest::single_task_wrapper( + UseShortcutFunction, InOrderQueue, []() {}); + std::ignore = sycl::unittest::single_task_wrapper( + UseShortcutFunction, InOrderQueue, EvFirst, []() {}); InOrderQueue.wait(); @@ -190,5 +190,8 @@ TEST_P(SchedulerTest, InOrderQueueNoSchedulerPath) { } // anonymous namespace -INSTANTIATE_TEST_SUITE_P(SchedulerTestInstance, SchedulerTest, - testing::Values(true, false)); \ No newline at end of file +INSTANTIATE_TEST_SUITE_P( + SchedulerTestInstance, SchedulerTest, + testing::Values( + true, + false)); /* Whether to use the shortcut command submission function */ \ No newline at end of file From 72f62a7ee23d705840aec8db1f9e0394fb5430d3 Mon Sep 17 00:00:00 2001 From: "Ptak, Slawomir" Date: Thu, 28 Aug 2025 08:39:05 +0000 Subject: [PATCH 4/4] Fix formatting --- sycl/unittests/scheduler/InOrderQueueDeps.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/sycl/unittests/scheduler/InOrderQueueDeps.cpp b/sycl/unittests/scheduler/InOrderQueueDeps.cpp index 599f84f374cb4..6467ff7a2809d 100644 --- a/sycl/unittests/scheduler/InOrderQueueDeps.cpp +++ b/sycl/unittests/scheduler/InOrderQueueDeps.cpp @@ -194,4 +194,4 @@ INSTANTIATE_TEST_SUITE_P( SchedulerTestInstance, SchedulerTest, testing::Values( true, - false)); /* Whether to use the shortcut command submission function */ \ No newline at end of file + false)); /* Whether to use the shortcut command submission function */