From f4bfb3b28cc0b80451b38399396a4c0e68c7f292 Mon Sep 17 00:00:00 2001 From: "Larsen, Steffen" Date: Wed, 10 Sep 2025 08:41:08 -0700 Subject: [PATCH 1/5] [SYCL][BindlessImages] Fix external semaphore dependencies and return events This commit fixes an issue where bindless images semaphore operations (signal/wait) would neither use dependency events of the submission nor return the corresponding event from the backend operation. This commit fixes both of these issues. Signed-off-by: Larsen, Steffen --- sycl/source/detail/scheduler/commands.cpp | 6 +- .../Extensions/BindlessImages/CMakeLists.txt | 3 + .../Extensions/BindlessImages/Semaphores.cpp | 127 ++++++++++++++++++ sycl/unittests/Extensions/CMakeLists.txt | 1 + 4 files changed, 135 insertions(+), 2 deletions(-) create mode 100644 sycl/unittests/Extensions/BindlessImages/CMakeLists.txt create mode 100644 sycl/unittests/Extensions/BindlessImages/Semaphores.cpp diff --git a/sycl/source/detail/scheduler/commands.cpp b/sycl/source/detail/scheduler/commands.cpp index dad5d976b3114..bac765cb8d1e5 100644 --- a/sycl/source/detail/scheduler/commands.cpp +++ b/sycl/source/detail/scheduler/commands.cpp @@ -3687,7 +3687,8 @@ ur_result_t ExecCGCommand::enqueueImpQueue() { return Adapter .call_nocheck( MQueue->getHandleRef(), SemWait->getExternalSemaphore(), - OptWaitValue.has_value(), WaitValue, 0, nullptr, nullptr); + OptWaitValue.has_value(), WaitValue, RawEvents.size(), + RawEvents.data(), Event); } case CGType::SemaphoreSignal: { assert(MQueue && @@ -3700,7 +3701,8 @@ ur_result_t ExecCGCommand::enqueueImpQueue() { return Adapter .call_nocheck( MQueue->getHandleRef(), SemSignal->getExternalSemaphore(), - OptSignalValue.has_value(), SignalValue, 0, nullptr, nullptr); + OptSignalValue.has_value(), SignalValue, RawEvents.size(), + RawEvents.data(), Event); } case CGType::AsyncAlloc: { // NO-OP. Async alloc calls adapter immediately in order to return a valid diff --git a/sycl/unittests/Extensions/BindlessImages/CMakeLists.txt b/sycl/unittests/Extensions/BindlessImages/CMakeLists.txt new file mode 100644 index 0000000000000..3745a8cec0fbc --- /dev/null +++ b/sycl/unittests/Extensions/BindlessImages/CMakeLists.txt @@ -0,0 +1,3 @@ +add_sycl_unittest(BindlessImagesExtensionTests OBJECT + Semaphores.cpp +) diff --git a/sycl/unittests/Extensions/BindlessImages/Semaphores.cpp b/sycl/unittests/Extensions/BindlessImages/Semaphores.cpp new file mode 100644 index 0000000000000..ef9230802e9e0 --- /dev/null +++ b/sycl/unittests/Extensions/BindlessImages/Semaphores.cpp @@ -0,0 +1,127 @@ +#include + +#include + +#include +#include +#include +#include + +namespace syclexp = sycl::ext::oneapi::experimental; + +constexpr uint64_t WaitValue = 42; +constexpr uint64_t SignalValue = 24; + +thread_local int urBindlessImagesWaitExternalSemaphoreExp_counter = 0; +thread_local bool urBindlessImagesWaitExternalSemaphoreExp_expectHasWaitValue = + false; +inline ur_result_t +urBindlessImagesWaitExternalSemaphoreExp_replace(void *pParams) { + ++urBindlessImagesWaitExternalSemaphoreExp_counter; + ur_bindless_images_wait_external_semaphore_exp_params_t Params = + *reinterpret_cast< + ur_bindless_images_wait_external_semaphore_exp_params_t *>(pParams); + EXPECT_EQ(*Params.phasWaitValue, + urBindlessImagesWaitExternalSemaphoreExp_expectHasWaitValue); + if (urBindlessImagesWaitExternalSemaphoreExp_expectHasWaitValue) { + EXPECT_EQ(*Params.pwaitValue, WaitValue); + } + EXPECT_EQ(*Params.pphEvent, nullptr); + EXPECT_EQ(*Params.pnumEventsInWaitList, uint32_t{0}); + EXPECT_NE(*Params.pphEventWaitList, nullptr); + return UR_RESULT_SUCCESS; +} + +thread_local int urBindlessImagesSignalExternalSemaphoreExp_counter = 0; +thread_local bool + urBindlessImagesSignalExternalSemaphoreExp_expectHasSignalValue = false; +thread_local uint32_t + urBindlessImagesSignalExternalSemaphoreExp_expectedNumWaitEvents = 0; +inline ur_result_t +urBindlessImagesSignalExternalSemaphoreExp_replace(void *pParams) { + ++urBindlessImagesSignalExternalSemaphoreExp_counter; + ur_bindless_images_signal_external_semaphore_exp_params_t Params = + *reinterpret_cast< + ur_bindless_images_signal_external_semaphore_exp_params_t *>(pParams); + EXPECT_EQ(*Params.pphEvent, nullptr); + EXPECT_EQ(*Params.phasSignalValue, + urBindlessImagesSignalExternalSemaphoreExp_expectHasSignalValue); + if (urBindlessImagesSignalExternalSemaphoreExp_expectHasSignalValue) { + EXPECT_EQ(*Params.psignalValue, SignalValue); + } + if (urBindlessImagesSignalExternalSemaphoreExp_expectedNumWaitEvents) { + EXPECT_NE(*Params.pphEvent, nullptr); + } + + else { + EXPECT_EQ(*Params.pphEvent, nullptr); + } + EXPECT_EQ(*Params.pnumEventsInWaitList, + urBindlessImagesSignalExternalSemaphoreExp_expectedNumWaitEvents); + EXPECT_NE(*Params.pphEventWaitList, nullptr); + return UR_RESULT_SUCCESS; +} + +TEST(BindlessImagesExtensionTests, ExternalSemaphoreWait) { + sycl::unittest::UrMock<> Mock; + mock::getCallbacks().set_replace_callback( + "urBindlessImagesWaitExternalSemaphoreExp", + &urBindlessImagesWaitExternalSemaphoreExp_replace); + urBindlessImagesWaitExternalSemaphoreExp_counter = 0; + + sycl::queue Q; + syclexp::external_semaphore DummySemaphore{}; + + urBindlessImagesWaitExternalSemaphoreExp_expectHasWaitValue = false; + Q.ext_oneapi_wait_external_semaphore(DummySemaphore); + EXPECT_EQ(urBindlessImagesWaitExternalSemaphoreExp_counter, 1); + + urBindlessImagesWaitExternalSemaphoreExp_expectHasWaitValue = true; + Q.ext_oneapi_wait_external_semaphore(DummySemaphore, WaitValue); + EXPECT_EQ(urBindlessImagesWaitExternalSemaphoreExp_counter, 2); +} + +TEST(BindlessImagesExtensionTests, ExternalSemaphoreSignal) { + sycl::unittest::UrMock<> Mock; + mock::getCallbacks().set_replace_callback( + "urBindlessImagesSignalExternalSemaphoreExp", + &urBindlessImagesSignalExternalSemaphoreExp_replace); + urBindlessImagesSignalExternalSemaphoreExp_counter = 0; + + sycl::queue Q; + syclexp::external_semaphore DummySemaphore{}; + + urBindlessImagesSignalExternalSemaphoreExp_expectHasSignalValue = false; + urBindlessImagesSignalExternalSemaphoreExp_expectedNumWaitEvents = 0; + Q.ext_oneapi_signal_external_semaphore(DummySemaphore); + EXPECT_EQ(urBindlessImagesSignalExternalSemaphoreExp_counter, 1); + + urBindlessImagesSignalExternalSemaphoreExp_expectHasSignalValue = true; + urBindlessImagesSignalExternalSemaphoreExp_expectedNumWaitEvents = 0; + Q.ext_oneapi_signal_external_semaphore(DummySemaphore, SignalValue); + EXPECT_EQ(urBindlessImagesSignalExternalSemaphoreExp_counter, 2); + + urBindlessImagesSignalExternalSemaphoreExp_expectHasSignalValue = false; + urBindlessImagesSignalExternalSemaphoreExp_expectedNumWaitEvents = 1; + Q.ext_oneapi_signal_external_semaphore(DummySemaphore, sycl::event{}); + EXPECT_EQ(urBindlessImagesSignalExternalSemaphoreExp_counter, 3); + + urBindlessImagesSignalExternalSemaphoreExp_expectHasSignalValue = true; + urBindlessImagesSignalExternalSemaphoreExp_expectedNumWaitEvents = 1; + Q.ext_oneapi_signal_external_semaphore(DummySemaphore, SignalValue, + sycl::event{}); + EXPECT_EQ(urBindlessImagesSignalExternalSemaphoreExp_counter, 4); + + std::vector DummyEventList(2); + + urBindlessImagesSignalExternalSemaphoreExp_expectHasSignalValue = false; + urBindlessImagesSignalExternalSemaphoreExp_expectedNumWaitEvents = 2; + Q.ext_oneapi_signal_external_semaphore(DummySemaphore, DummyEventList); + EXPECT_EQ(urBindlessImagesSignalExternalSemaphoreExp_counter, 5); + + urBindlessImagesSignalExternalSemaphoreExp_expectHasSignalValue = true; + urBindlessImagesSignalExternalSemaphoreExp_expectedNumWaitEvents = 2; + Q.ext_oneapi_signal_external_semaphore(DummySemaphore, SignalValue, + DummyEventList); + EXPECT_EQ(urBindlessImagesSignalExternalSemaphoreExp_counter, 6); +} diff --git a/sycl/unittests/Extensions/CMakeLists.txt b/sycl/unittests/Extensions/CMakeLists.txt index 59d57f0851ec1..32d1b34a99311 100644 --- a/sycl/unittests/Extensions/CMakeLists.txt +++ b/sycl/unittests/Extensions/CMakeLists.txt @@ -26,6 +26,7 @@ add_sycl_unittest(ExtensionsTests OBJECT USMPrefetch.cpp ) +add_subdirectory(BindlessImages) add_subdirectory(CommandGraph) add_subdirectory(VirtualFunctions) add_subdirectory(VirtualMemory) From 09b97d95dccddc95c285fde1e722119e91f199d7 Mon Sep 17 00:00:00 2001 From: "Larsen, Steffen" Date: Wed, 10 Sep 2025 21:55:02 -0700 Subject: [PATCH 2/5] Avoid assertion for null handle Signed-off-by: Larsen, Steffen --- sycl/unittests/Extensions/BindlessImages/Semaphores.cpp | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/sycl/unittests/Extensions/BindlessImages/Semaphores.cpp b/sycl/unittests/Extensions/BindlessImages/Semaphores.cpp index ef9230802e9e0..df4832f572b1b 100644 --- a/sycl/unittests/Extensions/BindlessImages/Semaphores.cpp +++ b/sycl/unittests/Extensions/BindlessImages/Semaphores.cpp @@ -70,7 +70,9 @@ TEST(BindlessImagesExtensionTests, ExternalSemaphoreWait) { urBindlessImagesWaitExternalSemaphoreExp_counter = 0; sycl::queue Q; + int DummyInt = 0; syclexp::external_semaphore DummySemaphore{}; + DummySemaphore.raw_handle = &DummyInt; urBindlessImagesWaitExternalSemaphoreExp_expectHasWaitValue = false; Q.ext_oneapi_wait_external_semaphore(DummySemaphore); @@ -89,7 +91,9 @@ TEST(BindlessImagesExtensionTests, ExternalSemaphoreSignal) { urBindlessImagesSignalExternalSemaphoreExp_counter = 0; sycl::queue Q; + int DummyInt = 0; syclexp::external_semaphore DummySemaphore{}; + DummySemaphore.raw_handle = &DummyInt; urBindlessImagesSignalExternalSemaphoreExp_expectHasSignalValue = false; urBindlessImagesSignalExternalSemaphoreExp_expectedNumWaitEvents = 0; From 213b199505aa8e29fcb2eb37861869c67fcdf772 Mon Sep 17 00:00:00 2001 From: "Larsen, Steffen" Date: Wed, 10 Sep 2025 22:52:46 -0700 Subject: [PATCH 3/5] Fix dummy cast Signed-off-by: Larsen, Steffen --- .../Extensions/BindlessImages/Semaphores.cpp | 12 ++++++++++-- 1 file changed, 10 insertions(+), 2 deletions(-) diff --git a/sycl/unittests/Extensions/BindlessImages/Semaphores.cpp b/sycl/unittests/Extensions/BindlessImages/Semaphores.cpp index df4832f572b1b..9229964159e56 100644 --- a/sycl/unittests/Extensions/BindlessImages/Semaphores.cpp +++ b/sycl/unittests/Extensions/BindlessImages/Semaphores.cpp @@ -70,9 +70,13 @@ TEST(BindlessImagesExtensionTests, ExternalSemaphoreWait) { urBindlessImagesWaitExternalSemaphoreExp_counter = 0; sycl::queue Q; + + // Create a dummy external semaphore and set the raw handle to some dummy. + // The mock implementation should never access the handle, so this is safe. int DummyInt = 0; syclexp::external_semaphore DummySemaphore{}; - DummySemaphore.raw_handle = &DummyInt; + DummySemaphore.raw_handle = + reinterpret_cast(&DummyInt); urBindlessImagesWaitExternalSemaphoreExp_expectHasWaitValue = false; Q.ext_oneapi_wait_external_semaphore(DummySemaphore); @@ -91,9 +95,13 @@ TEST(BindlessImagesExtensionTests, ExternalSemaphoreSignal) { urBindlessImagesSignalExternalSemaphoreExp_counter = 0; sycl::queue Q; + + // Create a dummy external semaphore and set the raw handle to some dummy. + // The mock implementation should never access the handle, so this is safe. int DummyInt = 0; syclexp::external_semaphore DummySemaphore{}; - DummySemaphore.raw_handle = &DummyInt; + DummySemaphore.raw_handle = + reinterpret_cast(&DummyInt); urBindlessImagesSignalExternalSemaphoreExp_expectHasSignalValue = false; urBindlessImagesSignalExternalSemaphoreExp_expectedNumWaitEvents = 0; From 680dcc76912c1bedc59d7e04d8575eb5ce5f691d Mon Sep 17 00:00:00 2001 From: "Larsen, Steffen" Date: Wed, 10 Sep 2025 23:46:44 -0700 Subject: [PATCH 4/5] Fix handle types Signed-off-by: Larsen, Steffen --- .../Extensions/BindlessImages/Semaphores.cpp | 50 +++++++++++-------- 1 file changed, 30 insertions(+), 20 deletions(-) diff --git a/sycl/unittests/Extensions/BindlessImages/Semaphores.cpp b/sycl/unittests/Extensions/BindlessImages/Semaphores.cpp index 9229964159e56..77fbd9337d5cb 100644 --- a/sycl/unittests/Extensions/BindlessImages/Semaphores.cpp +++ b/sycl/unittests/Extensions/BindlessImages/Semaphores.cpp @@ -49,16 +49,14 @@ urBindlessImagesSignalExternalSemaphoreExp_replace(void *pParams) { if (urBindlessImagesSignalExternalSemaphoreExp_expectHasSignalValue) { EXPECT_EQ(*Params.psignalValue, SignalValue); } - if (urBindlessImagesSignalExternalSemaphoreExp_expectedNumWaitEvents) { - EXPECT_NE(*Params.pphEvent, nullptr); - } - - else { - EXPECT_EQ(*Params.pphEvent, nullptr); - } EXPECT_EQ(*Params.pnumEventsInWaitList, urBindlessImagesSignalExternalSemaphoreExp_expectedNumWaitEvents); - EXPECT_NE(*Params.pphEventWaitList, nullptr); + if (urBindlessImagesSignalExternalSemaphoreExp_expectedNumWaitEvents) { + EXPECT_NE(*Params.pphEventWaitList, nullptr); + } else { + EXPECT_EQ(*Params.pphEventWaitList, nullptr); + } + EXPECT_NE(*Params.pphEvent, nullptr); return UR_RESULT_SUCCESS; } @@ -78,10 +76,16 @@ TEST(BindlessImagesExtensionTests, ExternalSemaphoreWait) { DummySemaphore.raw_handle = reinterpret_cast(&DummyInt); + DummySemaphore.handle_type = + syclexp::external_semaphore_handle_type::opaque_fd; + urBindlessImagesWaitExternalSemaphoreExp_expectHasWaitValue = false; Q.ext_oneapi_wait_external_semaphore(DummySemaphore); EXPECT_EQ(urBindlessImagesWaitExternalSemaphoreExp_counter, 1); + DummySemaphore.handle_type = + syclexp::external_semaphore_handle_type::timeline_fd; + urBindlessImagesWaitExternalSemaphoreExp_expectHasWaitValue = true; Q.ext_oneapi_wait_external_semaphore(DummySemaphore, WaitValue); EXPECT_EQ(urBindlessImagesWaitExternalSemaphoreExp_counter, 2); @@ -103,32 +107,38 @@ TEST(BindlessImagesExtensionTests, ExternalSemaphoreSignal) { DummySemaphore.raw_handle = reinterpret_cast(&DummyInt); + std::vector DummyEventList(2); + + DummySemaphore.handle_type = + syclexp::external_semaphore_handle_type::opaque_fd; + urBindlessImagesSignalExternalSemaphoreExp_expectHasSignalValue = false; urBindlessImagesSignalExternalSemaphoreExp_expectedNumWaitEvents = 0; Q.ext_oneapi_signal_external_semaphore(DummySemaphore); EXPECT_EQ(urBindlessImagesSignalExternalSemaphoreExp_counter, 1); - urBindlessImagesSignalExternalSemaphoreExp_expectHasSignalValue = true; - urBindlessImagesSignalExternalSemaphoreExp_expectedNumWaitEvents = 0; - Q.ext_oneapi_signal_external_semaphore(DummySemaphore, SignalValue); - EXPECT_EQ(urBindlessImagesSignalExternalSemaphoreExp_counter, 2); - urBindlessImagesSignalExternalSemaphoreExp_expectHasSignalValue = false; urBindlessImagesSignalExternalSemaphoreExp_expectedNumWaitEvents = 1; Q.ext_oneapi_signal_external_semaphore(DummySemaphore, sycl::event{}); + EXPECT_EQ(urBindlessImagesSignalExternalSemaphoreExp_counter, 2); + + urBindlessImagesSignalExternalSemaphoreExp_expectHasSignalValue = false; + urBindlessImagesSignalExternalSemaphoreExp_expectedNumWaitEvents = 2; + Q.ext_oneapi_signal_external_semaphore(DummySemaphore, DummyEventList); EXPECT_EQ(urBindlessImagesSignalExternalSemaphoreExp_counter, 3); + DummySemaphore.handle_type = + syclexp::external_semaphore_handle_type::timeline_fd; + + urBindlessImagesSignalExternalSemaphoreExp_expectHasSignalValue = true; + urBindlessImagesSignalExternalSemaphoreExp_expectedNumWaitEvents = 0; + Q.ext_oneapi_signal_external_semaphore(DummySemaphore, SignalValue); + EXPECT_EQ(urBindlessImagesSignalExternalSemaphoreExp_counter, 4); + urBindlessImagesSignalExternalSemaphoreExp_expectHasSignalValue = true; urBindlessImagesSignalExternalSemaphoreExp_expectedNumWaitEvents = 1; Q.ext_oneapi_signal_external_semaphore(DummySemaphore, SignalValue, sycl::event{}); - EXPECT_EQ(urBindlessImagesSignalExternalSemaphoreExp_counter, 4); - - std::vector DummyEventList(2); - - urBindlessImagesSignalExternalSemaphoreExp_expectHasSignalValue = false; - urBindlessImagesSignalExternalSemaphoreExp_expectedNumWaitEvents = 2; - Q.ext_oneapi_signal_external_semaphore(DummySemaphore, DummyEventList); EXPECT_EQ(urBindlessImagesSignalExternalSemaphoreExp_counter, 5); urBindlessImagesSignalExternalSemaphoreExp_expectHasSignalValue = true; From f5fd9a82ef6512f022c2215656993eacafa4eedb Mon Sep 17 00:00:00 2001 From: "Larsen, Steffen" Date: Thu, 11 Sep 2025 03:31:24 -0700 Subject: [PATCH 5/5] Fix mock device events and test checks Signed-off-by: Larsen, Steffen --- .../Extensions/BindlessImages/Semaphores.cpp | 30 +++++++++++++------ 1 file changed, 21 insertions(+), 9 deletions(-) diff --git a/sycl/unittests/Extensions/BindlessImages/Semaphores.cpp b/sycl/unittests/Extensions/BindlessImages/Semaphores.cpp index 77fbd9337d5cb..adc9a0186d35b 100644 --- a/sycl/unittests/Extensions/BindlessImages/Semaphores.cpp +++ b/sycl/unittests/Extensions/BindlessImages/Semaphores.cpp @@ -2,6 +2,7 @@ #include +#include #include #include #include @@ -26,9 +27,9 @@ urBindlessImagesWaitExternalSemaphoreExp_replace(void *pParams) { if (urBindlessImagesWaitExternalSemaphoreExp_expectHasWaitValue) { EXPECT_EQ(*Params.pwaitValue, WaitValue); } - EXPECT_EQ(*Params.pphEvent, nullptr); EXPECT_EQ(*Params.pnumEventsInWaitList, uint32_t{0}); - EXPECT_NE(*Params.pphEventWaitList, nullptr); + EXPECT_EQ(*Params.pphEventWaitList, nullptr); + EXPECT_NE(*Params.pphEvent, nullptr); return UR_RESULT_SUCCESS; } @@ -43,7 +44,6 @@ urBindlessImagesSignalExternalSemaphoreExp_replace(void *pParams) { ur_bindless_images_signal_external_semaphore_exp_params_t Params = *reinterpret_cast< ur_bindless_images_signal_external_semaphore_exp_params_t *>(pParams); - EXPECT_EQ(*Params.pphEvent, nullptr); EXPECT_EQ(*Params.phasSignalValue, urBindlessImagesSignalExternalSemaphoreExp_expectHasSignalValue); if (urBindlessImagesSignalExternalSemaphoreExp_expectHasSignalValue) { @@ -102,12 +102,24 @@ TEST(BindlessImagesExtensionTests, ExternalSemaphoreSignal) { // Create a dummy external semaphore and set the raw handle to some dummy. // The mock implementation should never access the handle, so this is safe. - int DummyInt = 0; + int DummyInt1 = 0, DummyInt2 = 0; syclexp::external_semaphore DummySemaphore{}; DummySemaphore.raw_handle = - reinterpret_cast(&DummyInt); - - std::vector DummyEventList(2); + reinterpret_cast(&DummyInt1); + + // We create dummy events with dummy UR handles to make the runtime think we + // pass actual device events. + auto DummyEventImpl1 = sycl::detail::event_impl::create_device_event( + *sycl::detail::getSyclObjImpl(Q)); + auto DummyEventImpl2 = sycl::detail::event_impl::create_device_event( + *sycl::detail::getSyclObjImpl(Q)); + DummyEventImpl1->setHandle(reinterpret_cast(&DummyInt1)); + DummyEventImpl2->setHandle(reinterpret_cast(&DummyInt2)); + sycl::event DummyEvent1 = + sycl::detail::createSyclObjFromImpl(DummyEventImpl1); + sycl::event DummyEvent2 = + sycl::detail::createSyclObjFromImpl(DummyEventImpl2); + std::vector DummyEventList{DummyEvent1, DummyEvent2}; DummySemaphore.handle_type = syclexp::external_semaphore_handle_type::opaque_fd; @@ -119,7 +131,7 @@ TEST(BindlessImagesExtensionTests, ExternalSemaphoreSignal) { urBindlessImagesSignalExternalSemaphoreExp_expectHasSignalValue = false; urBindlessImagesSignalExternalSemaphoreExp_expectedNumWaitEvents = 1; - Q.ext_oneapi_signal_external_semaphore(DummySemaphore, sycl::event{}); + Q.ext_oneapi_signal_external_semaphore(DummySemaphore, DummyEvent1); EXPECT_EQ(urBindlessImagesSignalExternalSemaphoreExp_counter, 2); urBindlessImagesSignalExternalSemaphoreExp_expectHasSignalValue = false; @@ -138,7 +150,7 @@ TEST(BindlessImagesExtensionTests, ExternalSemaphoreSignal) { urBindlessImagesSignalExternalSemaphoreExp_expectHasSignalValue = true; urBindlessImagesSignalExternalSemaphoreExp_expectedNumWaitEvents = 1; Q.ext_oneapi_signal_external_semaphore(DummySemaphore, SignalValue, - sycl::event{}); + DummyEvent1); EXPECT_EQ(urBindlessImagesSignalExternalSemaphoreExp_counter, 5); urBindlessImagesSignalExternalSemaphoreExp_expectHasSignalValue = true;