From 9121209c4121467f407943055265c3b3aab55673 Mon Sep 17 00:00:00 2001 From: "Dunajski, Bartosz" Date: Mon, 11 Dec 2023 17:19:26 +0000 Subject: [PATCH] feature: api support for Event sync mode Related-To: NEO-8179 Signed-off-by: Dunajski, Bartosz --- level_zero/core/source/cmdlist/cmdlist_hw.inl | 2 +- .../driver/driver_handle_imp_helper.cpp | 1 + level_zero/core/source/event/event.h | 3 + level_zero/core/source/event/event_impl.inl | 21 ++++++- .../test_cmdlist_append_launch_kernel_3.cpp | 61 ++++++++++++++++++- level_zero/include/ze_intel_gpu.h | 6 +- 6 files changed, 88 insertions(+), 6 deletions(-) diff --git a/level_zero/core/source/cmdlist/cmdlist_hw.inl b/level_zero/core/source/cmdlist/cmdlist_hw.inl index 305169bdb8..3d97e8e25e 100644 --- a/level_zero/core/source/cmdlist/cmdlist_hw.inl +++ b/level_zero/core/source/cmdlist/cmdlist_hw.inl @@ -2589,7 +2589,7 @@ void CommandListCoreFamily::appendSignalInOrderDependencyCounter( appendSdiInOrderCounterSignalling(inOrderExecInfo->getHostCounterAllocation()->getGpuAddress(), signalValue); } - if ((NEO::debugManager.flags.ProgramUserInterruptOnResolvedDependency.get() == 1) && signalEvent && signalEvent->isKmdWaitModeEnabled()) { + if ((NEO::debugManager.flags.ProgramUserInterruptOnResolvedDependency.get() == 1) && signalEvent && signalEvent->isInterruptModeEnabled()) { NEO::EnodeUserInterrupt::encode(*cmdStream); } } diff --git a/level_zero/core/source/driver/driver_handle_imp_helper.cpp b/level_zero/core/source/driver/driver_handle_imp_helper.cpp index d94edc554f..7bb271ab35 100644 --- a/level_zero/core/source/driver/driver_handle_imp_helper.cpp +++ b/level_zero/core/source/driver/driver_handle_imp_helper.cpp @@ -33,5 +33,6 @@ const std::vector> DriverHandleImp::extensionsS {ZE_INTEL_DEVICE_MODULE_DP_PROPERTIES_EXP_NAME, ZE_INTEL_DEVICE_MODULE_DP_PROPERTIES_EXP_VERSION_CURRENT}, {ZE_EVENT_POOL_COUNTER_BASED_EXP_NAME, ZE_EVENT_POOL_COUNTER_BASED_EXP_VERSION_CURRENT}, {ZE_INTEL_COMMAND_LIST_MEMORY_SYNC, ZE_INTEL_COMMAND_LIST_MEMORY_SYNC_EXP_VERSION_CURRENT}, + {ZE_INTEL_EVENT_SYNC_MODE_EXP_NAME, ZE_INTEL_EVENT_SYNC_MODE_EXP_VERSION_CURRENT}, }; } // namespace L0 diff --git a/level_zero/core/source/event/event.h b/level_zero/core/source/event/event.h index cb26c5380d..27cc0b19f0 100644 --- a/level_zero/core/source/event/event.h +++ b/level_zero/core/source/event/event.h @@ -256,7 +256,9 @@ struct Event : _ze_event_handle_t { bool hasKerneMappedTsCapability = false; std::shared_ptr &getInOrderExecInfo() { return inOrderExecInfo; } void enableKmdWaitMode() { kmdWaitMode = true; } + void enableInterruptMode() { interruptMode = true; } bool isKmdWaitModeEnabled() const { return kmdWaitMode; } + bool isInterruptModeEnabled() const { return interruptMode; } void unsetInOrderExecInfo(); protected: @@ -317,6 +319,7 @@ struct Event : _ze_event_handle_t { bool signalAllEventPackets = false; bool isFromIpcPool = false; bool kmdWaitMode = false; + bool interruptMode = false; uint64_t timestampRefreshIntervalInNanoSec = 0; }; diff --git a/level_zero/core/source/event/event_impl.inl b/level_zero/core/source/event/event_impl.inl index 860ad428c3..85cea7749e 100644 --- a/level_zero/core/source/event/event_impl.inl +++ b/level_zero/core/source/event/event_impl.inl @@ -88,10 +88,29 @@ Event *Event::create(EventPool *eventPool, const ze_event_desc_t *desc, Device * event->enableCounterBasedMode(true); } - if (NEO::debugManager.flags.WaitForUserFenceOnEventHostSynchronize.get() == 1) { + auto extendedDesc = reinterpret_cast(desc->pNext); + + bool interruptMode = false; + bool kmdWaitMode = false; + + if (extendedDesc && (extendedDesc->stype == ZE_INTEL_STRUCTURE_TYPE_EVENT_SYNC_MODE_EXP_DESC)) { + auto eventSyncModeDesc = reinterpret_cast(extendedDesc); + + interruptMode = (eventSyncModeDesc->syncModeFlags & ZE_INTEL_EVENT_SYNC_MODE_EXP_FLAG_SIGNAL_INTERRUPT); + kmdWaitMode = (eventSyncModeDesc->syncModeFlags & ZE_INTEL_EVENT_SYNC_MODE_EXP_FLAG_LOW_POWER_WAIT); + } + + interruptMode |= (NEO::debugManager.flags.WaitForUserFenceOnEventHostSynchronize.get() == 1); + kmdWaitMode |= (NEO::debugManager.flags.WaitForUserFenceOnEventHostSynchronize.get() == 1); + + if (kmdWaitMode) { event->enableKmdWaitMode(); } + if (interruptMode) { + event->enableInterruptMode(); + } + return event; } diff --git a/level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_append_launch_kernel_3.cpp b/level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_append_launch_kernel_3.cpp index 4977876b1e..771bbe2b03 100644 --- a/level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_append_launch_kernel_3.cpp +++ b/level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_append_launch_kernel_3.cpp @@ -891,6 +891,10 @@ HWTEST2_F(InOrderCmdListTests, givenDriverHandleWhenAskingForExtensionsThenRetur it = std::find_if(extensionProperties.begin(), extensionProperties.end(), [](const auto &extension) { return (strcmp(extension.name, ZE_INTEL_COMMAND_LIST_MEMORY_SYNC) == 0); }); EXPECT_NE(it, extensionProperties.end()); EXPECT_EQ((*it).version, ZE_INTEL_COMMAND_LIST_MEMORY_SYNC_EXP_VERSION_CURRENT); + + it = std::find_if(extensionProperties.begin(), extensionProperties.end(), [](const auto &extension) { return (strcmp(extension.name, ZE_INTEL_EVENT_SYNC_MODE_EXP_NAME) == 0); }); + EXPECT_NE(it, extensionProperties.end()); + EXPECT_EQ((*it).version, ZE_INTEL_EVENT_SYNC_MODE_EXP_VERSION_CURRENT); } HWTEST2_F(InOrderCmdListTests, givenCmdListWhenAskingForQwordDataSizeThenReturnFalse, IsAtLeastSkl) { @@ -899,6 +903,58 @@ HWTEST2_F(InOrderCmdListTests, givenCmdListWhenAskingForQwordDataSizeThenReturnF EXPECT_FALSE(immCmdList->isQwordInOrderCounter()); } +HWTEST2_F(InOrderCmdListTests, givenInvalidPnextStructWhenCreatingEventThenIgnore, IsAtLeastSkl) { + ze_event_pool_desc_t eventPoolDesc = {}; + eventPoolDesc.flags = ZE_EVENT_POOL_FLAG_HOST_VISIBLE; + eventPoolDesc.count = 1; + + auto eventPool = std::unique_ptr(EventPool::create(driverHandle.get(), context, 0, nullptr, &eventPoolDesc, returnValue)); + + ze_event_desc_t extStruct = {ZE_STRUCTURE_TYPE_FORCE_UINT32}; + ze_event_desc_t eventDesc = {}; + eventDesc.pNext = &extStruct; + + auto event0 = DestroyableZeUniquePtr(static_cast(Event::create(eventPool.get(), &eventDesc, device))); + + EXPECT_NE(nullptr, event0.get()); +} + +HWTEST2_F(InOrderCmdListTests, givenEventSyncModeDescPassedWhenCreatingEventThenEnableNewModes, IsAtLeastSkl) { + ze_event_pool_desc_t eventPoolDesc = {}; + eventPoolDesc.flags = ZE_EVENT_POOL_FLAG_HOST_VISIBLE; + eventPoolDesc.count = 4; + + auto eventPool = std::unique_ptr(EventPool::create(driverHandle.get(), context, 0, nullptr, &eventPoolDesc, returnValue)); + + ze_intel_event_sync_mode_exp_desc_t syncModeDesc = {ZE_INTEL_STRUCTURE_TYPE_EVENT_SYNC_MODE_EXP_DESC}; + ze_event_desc_t eventDesc = {}; + eventDesc.pNext = &syncModeDesc; + + eventDesc.index = 0; + syncModeDesc.syncModeFlags = 0; + auto event0 = DestroyableZeUniquePtr(static_cast(Event::create(eventPool.get(), &eventDesc, device))); + EXPECT_FALSE(event0->isInterruptModeEnabled()); + EXPECT_FALSE(event0->isKmdWaitModeEnabled()); + + eventDesc.index = 1; + syncModeDesc.syncModeFlags = ZE_INTEL_EVENT_SYNC_MODE_EXP_FLAG_SIGNAL_INTERRUPT; + auto event1 = DestroyableZeUniquePtr(static_cast(Event::create(eventPool.get(), &eventDesc, device))); + EXPECT_TRUE(event1->isInterruptModeEnabled()); + EXPECT_FALSE(event1->isKmdWaitModeEnabled()); + + eventDesc.index = 2; + syncModeDesc.syncModeFlags = ZE_INTEL_EVENT_SYNC_MODE_EXP_FLAG_LOW_POWER_WAIT; + auto event2 = DestroyableZeUniquePtr(static_cast(Event::create(eventPool.get(), &eventDesc, device))); + EXPECT_FALSE(event2->isInterruptModeEnabled()); + EXPECT_TRUE(event2->isKmdWaitModeEnabled()); + + eventDesc.index = 3; + syncModeDesc.syncModeFlags = ZE_INTEL_EVENT_SYNC_MODE_EXP_FLAG_SIGNAL_INTERRUPT | ZE_INTEL_EVENT_SYNC_MODE_EXP_FLAG_LOW_POWER_WAIT; + auto event3 = DestroyableZeUniquePtr(static_cast(Event::create(eventPool.get(), &eventDesc, device))); + EXPECT_TRUE(event3->isInterruptModeEnabled()); + EXPECT_TRUE(event3->isKmdWaitModeEnabled()); +} + HWTEST2_F(InOrderCmdListTests, givenQueueFlagWhenCreatingCmdListThenEnableRelaxedOrdering, IsAtLeastXeHpCore) { NEO::debugManager.flags.ForceInOrderImmediateCmdListExecution.set(-1); @@ -1046,7 +1102,9 @@ HWTEST2_F(InOrderCmdListTests, givenDebugFlagSetWhenEventHostSyncCalledThenCallW auto eventPool = createEvents(2, false); EXPECT_TRUE(events[0]->isKmdWaitModeEnabled()); + EXPECT_TRUE(events[0]->isInterruptModeEnabled()); EXPECT_TRUE(events[1]->isKmdWaitModeEnabled()); + EXPECT_TRUE(events[1]->isInterruptModeEnabled()); EXPECT_EQ(ZE_RESULT_NOT_READY, events[0]->hostSynchronize(2)); @@ -1297,6 +1355,7 @@ HWTEST2_F(InOrderCmdListTests, givenDebugFlagSetWhenDispatchingStoreDataImmThenP events[0]->makeCounterBasedInitiallyDisabled(); EXPECT_FALSE(events[1]->isKmdWaitModeEnabled()); + EXPECT_FALSE(events[1]->isInterruptModeEnabled()); auto immCmdList = createImmCmdList(); @@ -1339,7 +1398,7 @@ HWTEST2_F(InOrderCmdListTests, givenDebugFlagSetWhenDispatchingStoreDataImmThenP // signal Event with kmd wait mode offset = cmdStream->getUsed(); - events[1]->enableKmdWaitMode(); + events[1]->enableInterruptMode(); immCmdList->appendBarrier(events[1]->toHandle(), 1, &eventHandle, false); validateInterrupt(true); } diff --git a/level_zero/include/ze_intel_gpu.h b/level_zero/include/ze_intel_gpu.h index c2436b45db..edc52b29b5 100644 --- a/level_zero/include/ze_intel_gpu.h +++ b/level_zero/include/ze_intel_gpu.h @@ -93,10 +93,10 @@ typedef struct _ze_intel_device_command_list_wait_on_memory_data_size_exp_desc_t uint32_t cmdListWaitOnMemoryDataSizeInBytes; /// Defines supported data size for zexCommandListAppendWaitOnMemory[64] API } ze_intel_device_command_list_wait_on_memory_data_size_exp_desc_t; -#ifndef ZE_INTEL_EVENT_SYNC_MODE +#ifndef ZE_INTEL_EVENT_SYNC_MODE_EXP_NAME /// @brief Event sync mode extension name -#define ZE_INTEL_EVENT_SYNC_MODE "ZE_intel_experimental_event_sync_mode" -#endif // ZE_INTEL_EVENT_SYNC_MODE +#define ZE_INTEL_EVENT_SYNC_MODE_EXP_NAME "ZE_intel_experimental_event_sync_mode" +#endif // ZE_INTEL_EVENT_SYNC_MODE_EXP_NAME /////////////////////////////////////////////////////////////////////////////// /// @brief Event sync mode extension Version(s)