feature: api support for Event sync mode

Related-To: NEO-8179

Signed-off-by: Dunajski, Bartosz <bartosz.dunajski@intel.com>

level_zero/core/source/cmdlist/cmdlist_hw.inl

@@ -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);
     }
 }

level_zero/core/source/driver/driver_handle_imp_helper.cpp

@@ -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

level_zero/core/source/event/event.h

@@ -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;
 };
 

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<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;
 }
 

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<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);
 }

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; /// <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"
+#define ZE_INTEL_EVENT_SYNC_MODE_EXP_NAME "ZE_intel_experimental_event_sync_mode"
-#endif // ZE_INTEL_EVENT_SYNC_MODE
+#endif // ZE_INTEL_EVENT_SYNC_MODE_EXP_NAME
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Event sync mode extension Version(s)