[SYCL] Introduce unit test kernel wrapper functions for single_task

Author: slawekptak

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 <sycl/event.hpp>
+#include <sycl/handler.hpp>
+
+using namespace sycl;
+
+template<typename KernelName, typename KernelType>
+event single_task_wrapper(bool Shortcut, queue &Q, const KernelType &KernelFunc) {
+	if (Shortcut) {
+		return Q.single_task<KernelName>(KernelFunc);
+	} else {
+		return Q.submit([&](handler &cgh) { cgh.single_task<KernelName>(KernelFunc); });
+	}
+}
+
+template<typename KernelName, typename KernelType>
+event single_task_wrapper(bool Shortcut, queue &Q, event DepEvent, const KernelType &KernelFunc) {
+	if (Shortcut) {
+		return Q.single_task<KernelName>(DepEvent, KernelFunc);
+	} else {
+		return Q.submit([&](handler &cgh) {
+			cgh.depends_on(DepEvent);
+			cgh.single_task<KernelName>(KernelFunc);
+		});
+	}
+}

sycl/unittests/scheduler/InOrderQueueDeps.cpp

@@ -11,6 +11,7 @@
 
 #include <helpers/TestKernel.hpp>
 #include <helpers/UrMock.hpp>
+#include <helpers/CommandSubmitWrappers.hpp>
 #include <sycl/usm.hpp>
 
 #include <iostream>
@@ -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<TestKernel>([]() {}); });
-}
-
-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<TestKernel>(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<TestKernel>(ShortcutSubmitFunction,
+      Q1, []() {});
+    event E2 = single_task_wrapper<TestKernel>(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<TestKernel>([] {}); });
-  std::ignore = InOrderQueueSecond.submit([&](sycl::handler &CGH) {
-    CGH.depends_on(EvFirst);
-    CGH.single_task<TestKernel>([] {});
-  });
+  event EvFirst = single_task_wrapper<TestKernel>(ShortcutSubmitFunction,
+    InOrderQueueFirst, []() {});
+  std::ignore = single_task_wrapper<TestKernel>(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<TestKernel>([] {}); });
-  std::ignore = InOrderQueue.submit([&](sycl::handler &CGH) {
-    CGH.depends_on(EvFirst);
-    CGH.single_task<TestKernel>([] {});
-  });
+  event EvFirst = single_task_wrapper<TestKernel>(ShortcutSubmitFunction,
+    InOrderQueue, []() {});
+  std::ignore = single_task_wrapper<TestKernel>(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));

sycl/unittests/scheduler/SchedulerTest.hpp

@@ -12,7 +12,7 @@
 
 #include <gtest/gtest.h>
 
-class SchedulerTest : public ::testing::Test {
+class SchedulerTest : public testing::TestWithParam<bool> {
 protected:
   sycl::async_handler MAsyncHandler = [](sycl::exception_list ExceptionList) {
     for (std::exception_ptr ExceptionPtr : ExceptionList) {