Media
/
compute-runtime
mirror of https://github.com/intel/compute-runtime.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

feature: api support for Event sync mode 

Related-To: NEO-8179

Signed-off-by: Dunajski, Bartosz <bartosz.dunajski@intel.com>
This commit is contained in:
Dunajski, Bartosz 2023-12-11 17:19:26 +00:00 committed by Compute-Runtime-Automation
parent 7aef2440aa
commit 9121209c41
6 changed files with 88 additions and 6 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
level_zero/core/source/cmdlist/cmdlist_hw.inl
View File

@ -2589,7 +2589,7 @@ void CommandListCoreFamily<gfxCoreFamily>::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<GfxFamily>::encode(*cmdStream);
}
}

1
level_zero/core/source/driver/driver_handle_imp_helper.cpp
View File

@ -33,5 +33,6 @@ const std::vector<std::pair<std::string, uint32_t>> 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

3
level_zero/core/source/event/event.h
View File

@ -256,7 +256,9 @@ struct Event : _ze_event_handle_t {
bool hasKerneMappedTsCapability = false;
std::shared_ptr<NEO::InOrderExecInfo> &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;
};

21
level_zero/core/source/event/event_impl.inl
View File

@ -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<const ze_base_desc_t *>(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<const ze_intel_event_sync_mode_exp_desc_t *>(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;
}

61
level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_append_launch_kernel_3.cpp
View File

@ -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<L0::EventPool>(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<FixtureMockEvent>(static_cast<FixtureMockEvent *>(Event::create<typename FamilyType::TimestampPacketType>(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<L0::EventPool>(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<FixtureMockEvent>(static_cast<FixtureMockEvent *>(Event::create<typename FamilyType::TimestampPacketType>(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<FixtureMockEvent>(static_cast<FixtureMockEvent *>(Event::create<typename FamilyType::TimestampPacketType>(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<FixtureMockEvent>(static_cast<FixtureMockEvent *>(Event::create<typename FamilyType::TimestampPacketType>(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<FixtureMockEvent>(static_cast<FixtureMockEvent *>(Event::create<typename FamilyType::TimestampPacketType>(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<FamilyType>(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<gfxCoreFamily>();
@ -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);
}

6
level_zero/include/ze_intel_gpu.h
View File

@ -93,10 +93,10 @@ typedef struct _ze_intel_device_command_list_wait_on_memory_data_size_exp_desc_t
uint32_t cmdListWaitOnMemoryDataSizeInBytes; /// <out> 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)