Fix for adding MI_SEMAPHORE_WAIT & reset L0 Event

Signed-off-by: Daria Hinz <daria.hinz@intel.com>
2025-12-27 07:44:16 +08:00 · 2021-01-27 18:41:04 +00:00
parent 0b2022cf85
commit 64d772d366
11 changed files with 320 additions and 102 deletions
--- a/level_zero/core/source/cmdlist/cmdlist_hw.inl
+++ b/level_zero/core/source/cmdlist/cmdlist_hw.inl
@@ -635,22 +635,6 @@ ze_result_t CommandListCoreFamily<gfxCoreFamily>::appendMemAdvise(ze_device_hand
    return ZE_RESULT_ERROR_UNKNOWN;
 }

-template <GFXCORE_FAMILY gfxCoreFamily>
-ze_result_t CommandListCoreFamily<gfxCoreFamily>::appendLaunchKernelSplit(ze_kernel_handle_t hKernel,
-                                                                          const ze_group_count_t *pThreadGroupDimensions,
-                                                                          ze_event_handle_t hEvent) {
-    return appendLaunchKernelWithParams(hKernel, pThreadGroupDimensions, nullptr, false, false);
-}
-
-template <GFXCORE_FAMILY gfxCoreFamily>
-void CommandListCoreFamily<gfxCoreFamily>::appendEventForProfilingAllWalkers(ze_event_handle_t hEvent, bool beforeWalker) {
-    if (beforeWalker) {
-        appendEventForProfiling(hEvent, true);
-    } else {
-        appendSignalEventPostWalker(hEvent);
-    }
-}
-
 template <GFXCORE_FAMILY gfxCoreFamily>
 ze_result_t CommandListCoreFamily<gfxCoreFamily>::appendMemoryCopyKernelWithGA(void *dstPtr,
                                                                               NEO::GraphicsAllocation *dstPtrAlloc,
@@ -1464,6 +1448,7 @@ ze_result_t CommandListCoreFamily<gfxCoreFamily>::appendSignalEvent(ze_event_han
            commandContainer.getDevice()->getHardwareInfo(),
            args);
    }
+
    return ZE_RESULT_SUCCESS;
 }

@@ -1473,25 +1458,30 @@ ze_result_t CommandListCoreFamily<gfxCoreFamily>::appendEventReset(ze_event_hand
    auto event = Event::fromHandle(hEvent);

    uint64_t baseAddr = event->getGpuAddress();
-    size_t eventOffset = 0;
+    uint32_t packetsToReset = 1;
+
    if (event->isTimestampEvent) {
-        eventOffset = offsetof(TimestampPacketStorage::Packet, contextEnd);
+        baseAddr += offsetof(TimestampPacketStorage::Packet, contextEnd);
+        packetsToReset = event->getPacketsInUse() ? event->getPacketsInUse() : NEO::TimestampPacketSizeControl::preferredPacketCount;
    }
    commandContainer.addToResidencyContainer(&event->getAllocation());
    if (isCopyOnly()) {
-        NEO::EncodeMiFlushDW<GfxFamily>::programMiFlushDw(*commandContainer.getCommandStream(), event->getGpuAddress(), Event::STATE_CLEARED, false, true);
+        NEO::EncodeMiFlushDW<GfxFamily>::programMiFlushDw(*commandContainer.getCommandStream(), baseAddr, Event::STATE_CLEARED, false, true);
    } else {
        NEO::PipeControlArgs args;
        args.dcFlushEnable = (!event->signalScope) ? false : true;
-        NEO::MemorySynchronizationCommands<GfxFamily>::addPipeControlAndProgramPostSyncOperation(
-            *commandContainer.getCommandStream(),
-            POST_SYNC_OPERATION::POST_SYNC_OPERATION_WRITE_IMMEDIATE_DATA,
-            ptrOffset(baseAddr, eventOffset),
-            Event::STATE_CLEARED,
-            commandContainer.getDevice()->getHardwareInfo(),
-            args);
+        for (uint32_t i = 0u; i < packetsToReset; i++) {
+            NEO::MemorySynchronizationCommands<GfxFamily>::addPipeControlAndProgramPostSyncOperation(
+                *commandContainer.getCommandStream(),
+                POST_SYNC_OPERATION::POST_SYNC_OPERATION_WRITE_IMMEDIATE_DATA,
+                baseAddr,
+                Event::STATE_CLEARED,
+                commandContainer.getDevice()->getHardwareInfo(),
+                args);
+            baseAddr += sizeof(struct TimestampPacketStorage::Packet);
+        }
    }
-
+    event->resetPackets();
    return ZE_RESULT_SUCCESS;
 }

@@ -1524,15 +1514,20 @@ ze_result_t CommandListCoreFamily<gfxCoreFamily>::appendWaitOnEvents(uint32_t nu
    for (uint32_t i = 0; i < numEvents; i++) {
        auto event = Event::fromHandle(phEvent[i]);
        commandContainer.addToResidencyContainer(&event->getAllocation());
-
        gpuAddr = event->getGpuAddress();
+        uint32_t packetsToWait = event->getPacketsInUse() ? event->getPacketsInUse() : 1;
+
        if (event->isTimestampEvent) {
            gpuAddr += offsetof(TimestampPacketStorage::Packet, contextEnd);
        }
-        NEO::EncodeSempahore<GfxFamily>::addMiSemaphoreWaitCommand(*commandContainer.getCommandStream(),
-                                                                   gpuAddr,
-                                                                   eventStateClear,
-                                                                   COMPARE_OPERATION::COMPARE_OPERATION_SAD_NOT_EQUAL_SDD);
+        for (uint32_t i = 0u; i < packetsToWait; i++) {
+            NEO::EncodeSempahore<GfxFamily>::addMiSemaphoreWaitCommand(*commandContainer.getCommandStream(),
+                                                                       gpuAddr,
+                                                                       eventStateClear,
+                                                                       COMPARE_OPERATION::COMPARE_OPERATION_SAD_NOT_EQUAL_SDD);
+
+            gpuAddr += sizeof(struct TimestampPacketStorage::Packet);
+        }
    }

    return ZE_RESULT_SUCCESS;
--- a/level_zero/core/source/cmdlist/cmdlist_hw_base.inl
+++ b/level_zero/core/source/cmdlist/cmdlist_hw_base.inl
@@ -31,6 +31,22 @@ size_t CommandListCoreFamily<gfxCoreFamily>::getReserveSshSize() {
    return helper.getRenderSurfaceStateSize();
 }

+template <GFXCORE_FAMILY gfxCoreFamily>
+ze_result_t CommandListCoreFamily<gfxCoreFamily>::appendLaunchKernelSplit(ze_kernel_handle_t hKernel,
+                                                                          const ze_group_count_t *pThreadGroupDimensions,
+                                                                          ze_event_handle_t hEvent) {
+    return appendLaunchKernelWithParams(hKernel, pThreadGroupDimensions, nullptr, false, false);
+}
+
+template <GFXCORE_FAMILY gfxCoreFamily>
+void CommandListCoreFamily<gfxCoreFamily>::appendEventForProfilingAllWalkers(ze_event_handle_t hEvent, bool beforeWalker) {
+    if (beforeWalker) {
+        appendEventForProfiling(hEvent, true);
+    } else {
+        appendSignalEventPostWalker(hEvent);
+    }
+}
+
 template <GFXCORE_FAMILY gfxCoreFamily>
 ze_result_t CommandListCoreFamily<gfxCoreFamily>::appendLaunchKernelWithParams(ze_kernel_handle_t hKernel,
                                                                               const ze_group_count_t *pThreadGroupDimensions,
@@ -86,6 +102,7 @@ ze_result_t CommandListCoreFamily<gfxCoreFamily>::appendLaunchKernelWithParams(z
                                                 isPredicate,
                                                 kernel,
                                                 0,
+                                                 false,
                                                 device->getNEODevice(),
                                                 commandListPreemptionMode,
                                                 this->containsStatelessUncachedResource,
--- a/level_zero/core/source/event/event.cpp
+++ b/level_zero/core/source/event/event.cpp
@@ -241,17 +241,29 @@ ze_result_t Event::destroy() {
    return ZE_RESULT_SUCCESS;
 }

+ze_result_t EventImp::queryStatusKernelTimestamp() {
+    assignTimestampData(hostAddress);
+    uint32_t packetsToCheck = packetsInUse ? packetsInUse : 1;
+
+    for (uint32_t i = 0; i < packetsToCheck; i++) {
+        auto &packet = timestampsData->packets[i];
+        if (packet.contextEnd == Event::STATE_CLEARED) {
+            return ZE_RESULT_NOT_READY;
+        }
+    }
+    return ZE_RESULT_SUCCESS;
+}
+
 ze_result_t EventImp::queryStatus() {
    uint64_t *hostAddr = static_cast<uint64_t *>(hostAddress);
    uint32_t queryVal = Event::STATE_CLEARED;
+
    if (metricStreamer != nullptr) {
        *hostAddr = metricStreamer->getNotificationState();
    }
    this->csr->downloadAllocations();
    if (isTimestampEvent) {
-        auto baseAddr = reinterpret_cast<uint64_t>(hostAddress);
-        auto timeStampAddress = baseAddr + offsetof(TimestampPacketStorage::Packet, contextEnd);
-        hostAddr = reinterpret_cast<uint64_t *>(timeStampAddress);
+        return queryStatusKernelTimestamp();
    }
    memcpy_s(static_cast<void *>(&queryVal), sizeof(uint32_t), static_cast<void *>(hostAddr), sizeof(uint32_t));
    return queryVal == Event::STATE_CLEARED ? ZE_RESULT_NOT_READY : ZE_RESULT_SUCCESS;
@@ -343,7 +355,6 @@ ze_result_t EventImp::reset() {
    if (allocOnDevice) {
        return ZE_RESULT_SUCCESS;
    }
-
    resetPackets();
    return hostEventSetValue(Event::STATE_INITIAL);
 }
--- a/level_zero/core/source/event/event.h
+++ b/level_zero/core/source/event/event.h
@@ -53,7 +53,7 @@ struct Event : _ze_event_handle_t {
    virtual uint64_t getGpuAddress();

    void *hostAddress = nullptr;
-    uint32_t packetsInUse;
+    uint32_t packetsInUse = 0;
    uint64_t gpuAddress = 0u;

    ze_event_scope_flags_t signalScope = 0u;
@@ -96,6 +96,7 @@ struct EventImp : public Event {

  protected:
    ze_result_t calculateProfilingData();
+    ze_result_t queryStatusKernelTimestamp();
    ze_result_t hostEventSetValue(uint32_t eventValue);
    ze_result_t hostEventSetValueTimestamps(uint32_t eventVal);
    void assignTimestampData(void *address);
--- a/level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_2.cpp
+++ b/level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_2.cpp
@@ -1122,6 +1122,51 @@ HWTEST2_F(CommandListCreate, givenCopyCommandListWhenTimestampPassedToMemoryCopy
    EXPECT_EQ(cmdList.end(), itor);
 }

+HWTEST2_F(CommandListCreate, givenEventWhenInvokingAppendMemoryCopyThenPostSyncIsAdded, Platforms) {
+    using GfxFamily = typename NEO::GfxFamilyMapper<gfxCoreFamily>::GfxFamily;
+    using PIPE_CONTROL = typename FamilyType::PIPE_CONTROL;
+    using POST_SYNC_OPERATION = typename PIPE_CONTROL::POST_SYNC_OPERATION;
+
+    ze_result_t result = ZE_RESULT_SUCCESS;
+    std::unique_ptr<L0::CommandList> commandList(CommandList::create(productFamily, device, NEO::EngineGroupType::RenderCompute, result));
+
+    void *srcPtr = reinterpret_cast<void *>(0x1234);
+    void *dstPtr = reinterpret_cast<void *>(0x2345);
+
+    ze_event_pool_desc_t eventPoolDesc = {};
+    eventPoolDesc.count = 1;
+
+    ze_event_desc_t eventDesc = {};
+    eventDesc.index = 0;
+    eventDesc.signal = ZE_EVENT_SCOPE_FLAG_HOST;
+
+    auto eventPool = std::unique_ptr<L0::EventPool>(L0::EventPool::create(driverHandle.get(), 0, nullptr, &eventPoolDesc));
+    auto event = std::unique_ptr<L0::Event>(L0::Event::create(eventPool.get(), &eventDesc, device));
+
+    result = commandList->appendMemoryCopy(dstPtr, srcPtr, 0x1001, event->toHandle(), 0, nullptr);
+    EXPECT_EQ(0u, event->getPacketsInUse());
+
+    GenCmdList cmdList;
+    ASSERT_TRUE(FamilyType::PARSE::parseCommandBuffer(
+        cmdList, ptrOffset(commandList->commandContainer.getCommandStream()->getCpuBase(), 0), commandList->commandContainer.getCommandStream()->getUsed()));
+
+    auto itorPC = findAll<PIPE_CONTROL *>(cmdList.begin(), cmdList.end());
+    ASSERT_NE(0u, itorPC.size());
+    uint32_t postSyncFound = 0;
+    for (auto it : itorPC) {
+        auto cmd = genCmdCast<PIPE_CONTROL *>(*it);
+        if (cmd->getPostSyncOperation() == POST_SYNC_OPERATION::POST_SYNC_OPERATION_WRITE_IMMEDIATE_DATA) {
+            EXPECT_TRUE(cmd->getCommandStreamerStallEnable());
+            EXPECT_EQ(cmd->getImmediateData(), Event::STATE_SIGNALED);
+            auto gpuAddress = event->getGpuAddress();
+            EXPECT_EQ(cmd->getAddressHigh(), gpuAddress >> 32u);
+            EXPECT_EQ(cmd->getAddress(), uint32_t(gpuAddress));
+            postSyncFound++;
+        }
+    }
+    EXPECT_EQ(1u, postSyncFound);
+}
+
 using SupportedPlatforms = IsWithinProducts<IGFX_SKYLAKE, IGFX_DG1>;
 HWTEST2_F(CommandListCreate, givenCommandListThenSshCorrectlyReserved, SupportedPlatforms) {
    MockCommandListHw<gfxCoreFamily> commandList;
@@ -1239,5 +1284,6 @@ HWTEST2_F(CommandListCreate, givenCommandListWhenTimestampPassedToMemoryCopyThen
        EXPECT_TRUE(cmd->getDcFlushEnable());
    }
 }
+
 } // namespace ult
 } // namespace L0
--- a/level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_append_event_reset.cpp
+++ b/level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_append_event_reset.cpp
@@ -147,7 +147,7 @@ HWTEST2_F(CommandListAppendEventReset, givenTimestampEventUsedInResetThenPipeCon

    auto itorPC = findAll<PIPE_CONTROL *>(cmdList.begin(), cmdList.end());
    ASSERT_NE(0u, itorPC.size());
-    bool postSyncFound = false;
+    uint32_t postSyncFound = 0u;
    for (auto it : itorPC) {
        auto cmd = genCmdCast<PIPE_CONTROL *>(*it);
        if (cmd->getPostSyncOperation() == POST_SYNC_OPERATION::POST_SYNC_OPERATION_WRITE_IMMEDIATE_DATA) {
@@ -156,10 +156,54 @@ HWTEST2_F(CommandListAppendEventReset, givenTimestampEventUsedInResetThenPipeCon
            EXPECT_EQ(cmd->getAddressHigh(), gpuAddress >> 32u);
            EXPECT_EQ(cmd->getAddress(), uint32_t(gpuAddress));
            EXPECT_FALSE(cmd->getDcFlushEnable());
-            postSyncFound = true;
+            postSyncFound++;
+            gpuAddress += sizeof(struct TimestampPacketStorage::Packet);
        }
    }
-    ASSERT_TRUE(postSyncFound);
+    ASSERT_EQ(NEO::TimestampPacketSizeControl::preferredPacketCount, postSyncFound);
+}
+
+HWTEST2_F(CommandListAppendEventReset, givenTimestampEventUsedInResetWhenMoreThanOnePacketThenPipeControlAppendedCorrectly, SklPlusMatcher) {
+    using GfxFamily = typename NEO::GfxFamilyMapper<gfxCoreFamily>::GfxFamily;
+    using PIPE_CONTROL = typename FamilyType::PIPE_CONTROL;
+    using POST_SYNC_OPERATION = typename PIPE_CONTROL::POST_SYNC_OPERATION;
+    auto &commandContainer = commandList->commandContainer;
+
+    ze_event_pool_desc_t eventPoolDesc = {};
+    eventPoolDesc.count = 1;
+    eventPoolDesc.flags = ZE_EVENT_POOL_FLAG_KERNEL_TIMESTAMP;
+
+    ze_event_desc_t eventDesc = {};
+    eventDesc.index = 0;
+    auto eventPool = std::unique_ptr<L0::EventPool>(L0::EventPool::create(driverHandle.get(), 0, nullptr, &eventPoolDesc));
+    auto event = std::unique_ptr<L0::Event>(L0::Event::create(eventPool.get(), &eventDesc, device));
+
+    event->packetsInUse = 3;
+    commandList->appendEventReset(event->toHandle());
+
+    ASSERT_EQ(0u, event->getPacketsInUse());
+    auto gpuAddress = event->getGpuAddress() + offsetof(TimestampPacketStorage::Packet, contextEnd);
+
+    GenCmdList cmdList;
+    ASSERT_TRUE(FamilyType::PARSE::parseCommandBuffer(
+        cmdList, ptrOffset(commandContainer.getCommandStream()->getCpuBase(), 0), commandContainer.getCommandStream()->getUsed()));
+
+    auto itorPC = findAll<PIPE_CONTROL *>(cmdList.begin(), cmdList.end());
+    ASSERT_NE(0u, itorPC.size());
+    uint32_t postSyncFound = 0;
+    for (auto it : itorPC) {
+        auto cmd = genCmdCast<PIPE_CONTROL *>(*it);
+        if (cmd->getPostSyncOperation() == POST_SYNC_OPERATION::POST_SYNC_OPERATION_WRITE_IMMEDIATE_DATA) {
+            EXPECT_EQ(cmd->getImmediateData(), Event::STATE_CLEARED);
+            EXPECT_TRUE(cmd->getCommandStreamerStallEnable());
+            EXPECT_EQ(cmd->getAddressHigh(), gpuAddress >> 32u);
+            EXPECT_EQ(cmd->getAddress(), uint32_t(gpuAddress));
+            EXPECT_FALSE(cmd->getDcFlushEnable());
+            postSyncFound++;
+            gpuAddress += sizeof(struct TimestampPacketStorage::Packet);
+        }
+    }
+    ASSERT_EQ(3u, postSyncFound);
 }

 HWTEST2_F(CommandListAppendEventReset, givenEventWithHostScopeUsedInResetThenPipeControlWithDcFlushAppended, SklPlusMatcher) {
--- a/level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_append_wait_on_events.cpp
+++ b/level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_append_wait_on_events.cpp
@@ -101,6 +101,53 @@ HWTEST_F(CommandListAppendWaitOnEvent, WhenAppendingWaitOnEventsThenEventGraphic
    }
 }

+HWTEST_F(CommandListAppendWaitOnEvent, WhenAppendingWaitOnTimestampEventWithThreePacketsThenSemaphoreWaitCmdIsGeneratedThreeTimes) {
+    using MI_SEMAPHORE_WAIT = typename FamilyType::MI_SEMAPHORE_WAIT;
+    auto usedSpaceBefore = commandList->commandContainer.getCommandStream()->getUsed();
+
+    ze_event_pool_desc_t eventPoolDesc = {};
+    eventPoolDesc.count = 1;
+    eventPoolDesc.flags = ZE_EVENT_POOL_FLAG_KERNEL_TIMESTAMP;
+
+    ze_event_desc_t eventDesc = {};
+    eventDesc.index = 0;
+    auto eventPool = std::unique_ptr<L0::EventPool>(L0::EventPool::create(driverHandle.get(), 0, nullptr, &eventPoolDesc));
+    auto event = std::unique_ptr<L0::Event>(L0::Event::create(eventPool.get(), &eventDesc, device));
+
+    event->packetsInUse = 3;
+    ze_event_handle_t hEventHandle = event->toHandle();
+    auto result = commandList->appendWaitOnEvents(1, &hEventHandle);
+    ASSERT_EQ(ZE_RESULT_SUCCESS, result);
+    auto usedSpaceAfter = commandList->commandContainer.getCommandStream()->getUsed();
+    ASSERT_GT(usedSpaceAfter, usedSpaceBefore);
+
+    auto gpuAddress = event->getGpuAddress() + offsetof(TimestampPacketStorage::Packet, contextEnd);
+
+    GenCmdList cmdList;
+    ASSERT_TRUE(FamilyType::PARSE::parseCommandBuffer(cmdList,
+                                                      ptrOffset(commandList->commandContainer.getCommandStream()->getCpuBase(), 0),
+                                                      usedSpaceAfter));
+
+    auto itorSW = findAll<MI_SEMAPHORE_WAIT *>(cmdList.begin(), cmdList.end());
+    ASSERT_NE(0u, itorSW.size());
+    uint32_t semaphoreWaitsFound = 0;
+
+    for (auto it : itorSW) {
+        auto cmd = genCmdCast<MI_SEMAPHORE_WAIT *>(*it);
+        auto addressSpace = device->getHwInfo().capabilityTable.gpuAddressSpace;
+
+        EXPECT_EQ(MI_SEMAPHORE_WAIT::COMPARE_OPERATION::COMPARE_OPERATION_SAD_NOT_EQUAL_SDD,
+                  cmd->getCompareOperation());
+        EXPECT_EQ(cmd->getSemaphoreDataDword(), static_cast<uint32_t>(-1));
+        EXPECT_EQ(gpuAddress & addressSpace, cmd->getSemaphoreGraphicsAddress() & addressSpace);
+        EXPECT_EQ(MI_SEMAPHORE_WAIT::WAIT_MODE::WAIT_MODE_POLLING_MODE, cmd->getWaitMode());
+
+        semaphoreWaitsFound++;
+        gpuAddress += sizeof(struct TimestampPacketStorage::Packet);
+    }
+    ASSERT_EQ(3u, semaphoreWaitsFound);
+}
+
 HWTEST_F(CommandListAppendWaitOnEvent, givenEventWithWaitScopeFlagDeviceWhenAppendingWaitOnEventThenPCWithDcFlushIsGenerated) {
    using PIPE_CONTROL = typename FamilyType::PIPE_CONTROL;
    auto usedSpaceBefore = commandList->commandContainer.getCommandStream()->getUsed();
--- a/level_zero/core/test/unit_tests/sources/event/test_event.cpp
+++ b/level_zero/core/test/unit_tests/sources/event/test_event.cpp
@@ -128,6 +128,32 @@ TEST_F(EventPoolCreate, GivenNoDeviceThenEventPoolIsCreated) {
    eventPool->destroy();
 }

+TEST_F(EventCreate, givenEventWhenSignaledAndResetFromTheHostThenCorrectDataAreSet) {
+    ze_event_pool_desc_t eventPoolDesc = {};
+    eventPoolDesc.count = 1;
+    eventPoolDesc.flags = ZE_EVENT_POOL_FLAG_HOST_VISIBLE;
+
+    ze_event_desc_t eventDesc = {};
+    eventDesc.index = 0;
+    eventDesc.signal = ZE_EVENT_SCOPE_FLAG_HOST;
+
+    auto eventPool = std::unique_ptr<L0::EventPool>(L0::EventPool::create(driverHandle.get(), 0, nullptr, &eventPoolDesc));
+    ASSERT_NE(nullptr, eventPool);
+    auto event = std::unique_ptr<L0::Event>(L0::Event::create(eventPool.get(), &eventDesc, device));
+    ASSERT_NE(nullptr, event);
+
+    ze_result_t result = event->queryStatus();
+    EXPECT_EQ(ZE_RESULT_NOT_READY, result);
+
+    event->hostSignal();
+    result = event->queryStatus();
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+
+    event->reset();
+    result = event->queryStatus();
+    EXPECT_EQ(ZE_RESULT_NOT_READY, result);
+}
+
 TEST_F(EventPoolCreate, GivenDeviceThenEventPoolIsCreated) {
    ze_event_pool_desc_t eventPoolDesc = {
        ZE_STRUCTURE_TYPE_EVENT_POOL_DESC,
@@ -240,6 +266,28 @@ TEST_F(TimestampEventCreate, givenEventTimestampsCreatedWhenResetIsInvokeThenCor
    EXPECT_EQ(0u, event->getPacketsInUse());
 }

+TEST_F(TimestampEventCreate, givenEventWhenSignaledAndResetFromTheHostThenCorrectDataAreSet) {
+    EXPECT_NE(nullptr, event->timestampsData);
+
+    event->hostSignal();
+    ze_result_t result = event->queryStatus();
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+
+    event->reset();
+    result = event->queryStatus();
+    EXPECT_EQ(ZE_RESULT_NOT_READY, result);
+
+    for (auto i = 0u; i < NEO::TimestampPacketSizeControl::preferredPacketCount; i++) {
+        auto &packet = event->timestampsData->packets[i];
+        EXPECT_EQ(Event::State::STATE_INITIAL, packet.contextStart);
+        EXPECT_EQ(Event::State::STATE_INITIAL, packet.globalStart);
+        EXPECT_EQ(Event::State::STATE_INITIAL, packet.contextEnd);
+        EXPECT_EQ(Event::State::STATE_INITIAL, packet.globalEnd);
+    }
+
+    EXPECT_EQ(0u, event->getPacketsInUse());
+}
+
 TEST_F(TimestampEventCreate, givenSingleTimestampEventThenAllocationSizeCreatedForAllTimestamps) {
    auto allocation = &eventPool->getAllocation();
    ASSERT_NE(nullptr, allocation);
--- a/shared/source/command_container/command_encoder.h
+++ b/shared/source/command_container/command_encoder.h
@@ -35,6 +35,7 @@ struct EncodeDispatchKernel {
                       bool isPredicate,
                       DispatchKernelEncoderI *dispatchInterface,
                       uint64_t eventAddress,
+                       bool isTimestampEvent,
                       Device *device,
                       PreemptionMode preemptionMode,
                       bool &requiresUncachedMocs,
--- a/shared/source/command_container/command_encoder_bdw_plus.inl
+++ b/shared/source/command_container/command_encoder_bdw_plus.inl
@@ -25,7 +25,7 @@ namespace NEO {
 template <typename Family>
 void EncodeDispatchKernel<Family>::encode(CommandContainer &container,
                                          const void *pThreadGroupDimensions, bool isIndirect, bool isPredicate, DispatchKernelEncoderI *dispatchInterface,
-                                          uint64_t eventAddress, Device *device, PreemptionMode preemptionMode, bool &requiresUncachedMocs,
+                                          uint64_t eventAddress, bool isTimestampEvent, Device *device, PreemptionMode preemptionMode, bool &requiresUncachedMocs,
                                          uint32_t &partitionCount) {

    using MEDIA_STATE_FLUSH = typename Family::MEDIA_STATE_FLUSH;
--- a/shared/test/unit_test/encoders/test_encode_dispatch_kernel.cpp
+++ b/shared/test/unit_test/encoders/test_encode_dispatch_kernel.cpp
@@ -47,9 +47,10 @@ HWTEST_F(CommandEncodeStatesTest, givenenDispatchInterfaceWhenDispatchKernelThen
    uint32_t dims[] = {2, 1, 1};
    std::unique_ptr<MockDispatchKernelEncoder> dispatchInterface(new MockDispatchKernelEncoder());
    bool requiresUncachedMocs = false;
+
    uint32_t partitionCount = 0;
-    EncodeDispatchKernel<FamilyType>::encode(*cmdContainer.get(), dims, false, false, dispatchInterface.get(), 0, pDevice,
-                                             NEO::PreemptionMode::Disabled, requiresUncachedMocs, partitionCount);
+    EncodeDispatchKernel<FamilyType>::encode(*cmdContainer.get(), dims, false, false, dispatchInterface.get(), 0, false,
+                                             pDevice, NEO::PreemptionMode::Disabled, requiresUncachedMocs, partitionCount);

    GenCmdList commands;
    CmdParse<FamilyType>::parseCommandBuffer(commands, ptrOffset(cmdContainer->getCommandStream()->getCpuBase(), 0), cmdContainer->getCommandStream()->getUsed());
@@ -76,6 +77,7 @@ HWTEST_F(CommandEncodeStatesUncachedMocsTests, whenEncodingDispatchKernelWithUnc
                                             false,
                                             dispatchInterface.get(),
                                             0,
+                                             false,
                                             pDevice,
                                             NEO::PreemptionMode::Disabled,
                                             requiresUncachedMocs,
@@ -112,6 +114,7 @@ HWTEST_F(CommandEncodeStatesUncachedMocsTests, whenEncodingDispatchKernelWithUnc
                                             false,
                                             dispatchInterface.get(),
                                             0,
+                                             false,
                                             pDevice,
                                             NEO::PreemptionMode::Disabled,
                                             requiresUncachedMocs,
@@ -148,6 +151,7 @@ HWTEST_F(CommandEncodeStatesUncachedMocsTests, whenEncodingDispatchKernelWithNon
                                             false,
                                             dispatchInterface.get(),
                                             0,
+                                             false,
                                             pDevice,
                                             NEO::PreemptionMode::Disabled,
                                             requiresUncachedMocs,
@@ -184,6 +188,7 @@ HWTEST_F(CommandEncodeStatesUncachedMocsTests, whenEncodingDispatchKernelWithNon
                                             false,
                                             dispatchInterface.get(),
                                             0,
+                                             false,
                                             pDevice,
                                             NEO::PreemptionMode::Disabled,
                                             requiresUncachedMocs,
@@ -218,6 +223,7 @@ HWTEST_F(CommandEncodeStatesUncachedMocsTests, whenEncodingDispatchKernelWithNon
                                             false,
                                             dispatchInterface.get(),
                                             0,
+                                             false,
                                             pDevice,
                                             NEO::PreemptionMode::Disabled,
                                             requiresUncachedMocs,
@@ -244,8 +250,8 @@ HWTEST_F(CommandEncodeStatesTest, givenCommandContainerWithUsedAvailableSizeWhen

    bool requiresUncachedMocs = false;
    uint32_t partitionCount = 0;
-    EncodeDispatchKernel<FamilyType>::encode(*cmdContainer.get(), dims, false, false, dispatchInterface.get(), 0, pDevice,
-                                             NEO::PreemptionMode::Disabled, requiresUncachedMocs, partitionCount);
+    EncodeDispatchKernel<FamilyType>::encode(*cmdContainer.get(), dims, false, false, dispatchInterface.get(), 0, false,
+                                             pDevice, NEO::PreemptionMode::Disabled, requiresUncachedMocs, partitionCount);

    auto cmdBuffersCountAfter = cmdContainer->getCmdBufferAllocations().size();

@@ -261,8 +267,8 @@ HWCMDTEST_F(IGFX_GEN8_CORE, CommandEncodeStatesTest, givenSlmTotalSizeGraterThan

    bool requiresUncachedMocs = false;
    uint32_t partitionCount = 0;
-    EncodeDispatchKernel<FamilyType>::encode(*cmdContainer.get(), dims, false, false, dispatchInterface.get(), 0, pDevice,
-                                             NEO::PreemptionMode::Disabled, requiresUncachedMocs, partitionCount);
+    EncodeDispatchKernel<FamilyType>::encode(*cmdContainer.get(), dims, false, false, dispatchInterface.get(), 0, false,
+                                             pDevice, NEO::PreemptionMode::Disabled, requiresUncachedMocs, partitionCount);

    auto interfaceDescriptorData = static_cast<INTERFACE_DESCRIPTOR_DATA *>(cmdContainer->getIddBlock());

@@ -281,8 +287,8 @@ HWCMDTEST_F(IGFX_GEN8_CORE, CommandEncodeStatesTest, givenSlmTotalSizeEqualZeroW

    bool requiresUncachedMocs = false;
    uint32_t partitionCount = 0;
-    EncodeDispatchKernel<FamilyType>::encode(*cmdContainer.get(), dims, false, false, dispatchInterface.get(), 0, pDevice,
-                                             NEO::PreemptionMode::Disabled, requiresUncachedMocs, partitionCount);
+    EncodeDispatchKernel<FamilyType>::encode(*cmdContainer.get(), dims, false, false, dispatchInterface.get(), 0, false,
+                                             pDevice, NEO::PreemptionMode::Disabled, requiresUncachedMocs, partitionCount);

    auto interfaceDescriptorData = static_cast<INTERFACE_DESCRIPTOR_DATA *>(cmdContainer->getIddBlock());

@@ -316,8 +322,8 @@ HWCMDTEST_F(IGFX_GEN8_CORE, CommandEncodeStatesTest, givenOneBindingTableEntryWh

    bool requiresUncachedMocs = false;
    uint32_t partitionCount = 0;
-    EncodeDispatchKernel<FamilyType>::encode(*cmdContainer.get(), dims, false, false, dispatchInterface.get(), 0, pDevice,
-                                             NEO::PreemptionMode::Disabled, requiresUncachedMocs, partitionCount);
+    EncodeDispatchKernel<FamilyType>::encode(*cmdContainer.get(), dims, false, false, dispatchInterface.get(), 0, false,
+                                             pDevice, NEO::PreemptionMode::Disabled, requiresUncachedMocs, partitionCount);
    auto interfaceDescriptorData = static_cast<INTERFACE_DESCRIPTOR_DATA *>(cmdContainer->getIddBlock());

    EXPECT_EQ(interfaceDescriptorData->getBindingTablePointer(), expectedOffset);
@@ -346,8 +352,8 @@ HWCMDTEST_F(IGFX_GEN8_CORE, CommandEncodeStatesTest, giveNumBindingTableZeroWhen

    bool requiresUncachedMocs = false;
    uint32_t partitionCount = 0;
-    EncodeDispatchKernel<FamilyType>::encode(*cmdContainer.get(), dims, false, false, dispatchInterface.get(), 0, pDevice,
-                                             NEO::PreemptionMode::Disabled, requiresUncachedMocs, partitionCount);
+    EncodeDispatchKernel<FamilyType>::encode(*cmdContainer.get(), dims, false, false, dispatchInterface.get(), 0, false,
+                                             pDevice, NEO::PreemptionMode::Disabled, requiresUncachedMocs, partitionCount);
    auto interfaceDescriptorData = static_cast<INTERFACE_DESCRIPTOR_DATA *>(cmdContainer->getIddBlock());

    EXPECT_EQ(interfaceDescriptorData->getBindingTablePointer(), 0u);
@@ -374,8 +380,8 @@ HWCMDTEST_F(IGFX_GEN8_CORE, CommandEncodeStatesTest, giveNumSamplersOneWhenDispa

    bool requiresUncachedMocs = false;
    uint32_t partitionCount = 0;
-    EncodeDispatchKernel<FamilyType>::encode(*cmdContainer.get(), dims, false, false, dispatchInterface.get(), 0, pDevice,
-                                             NEO::PreemptionMode::Disabled, requiresUncachedMocs, partitionCount);
+    EncodeDispatchKernel<FamilyType>::encode(*cmdContainer.get(), dims, false, false, dispatchInterface.get(), 0, false,
+                                             pDevice, NEO::PreemptionMode::Disabled, requiresUncachedMocs, partitionCount);
    auto interfaceDescriptorData = static_cast<INTERFACE_DESCRIPTOR_DATA *>(cmdContainer->getIddBlock());

    auto borderColorOffsetInDsh = usedBefore;
@@ -408,8 +414,9 @@ HWCMDTEST_F(IGFX_GEN8_CORE, CommandEncodeStatesTest, giveNumSamplersZeroWhenDisp

    bool requiresUncachedMocs = false;
    uint32_t partitionCount = 0;
-    EncodeDispatchKernel<FamilyType>::encode(*cmdContainer.get(), dims, false, false, dispatchInterface.get(), 0, pDevice,
+    EncodeDispatchKernel<FamilyType>::encode(*cmdContainer.get(), dims, false, false, dispatchInterface.get(), 0, false, pDevice,
                                             NEO::PreemptionMode::Disabled, requiresUncachedMocs, partitionCount);
+
    auto interfaceDescriptorData = static_cast<INTERFACE_DESCRIPTOR_DATA *>(cmdContainer->getIddBlock());

    auto borderColorOffsetInDsh = usedBefore;
@@ -432,8 +439,8 @@ HWTEST_F(CommandEncodeStatesTest, givenIndirectOffsetsCountsWhenDispatchingKerne

    bool requiresUncachedMocs = false;
    uint32_t partitionCount = 0;
-    EncodeDispatchKernel<FamilyType>::encode(*cmdContainer.get(), dims, true, false, dispatchInterface.get(), 0, pDevice,
-                                             NEO::PreemptionMode::Disabled, requiresUncachedMocs, partitionCount);
+    EncodeDispatchKernel<FamilyType>::encode(*cmdContainer.get(), dims, true, false, dispatchInterface.get(), 0, false,
+                                             pDevice, NEO::PreemptionMode::Disabled, requiresUncachedMocs, partitionCount);

    GenCmdList commands;
    CmdParse<FamilyType>::parseCommandBuffer(commands, ptrOffset(cmdContainer->getCommandStream()->getCpuBase(), 0), cmdContainer->getCommandStream()->getUsed());
@@ -460,8 +467,8 @@ HWTEST_F(CommandEncodeStatesTest, givenIndarectOffsetsSizeWhenDispatchingKernelT

    bool requiresUncachedMocs = false;
    uint32_t partitionCount = 0;
-    EncodeDispatchKernel<FamilyType>::encode(*cmdContainer.get(), dims, true, false, dispatchInterface.get(), 0, pDevice,
-                                             NEO::PreemptionMode::Disabled, requiresUncachedMocs, partitionCount);
+    EncodeDispatchKernel<FamilyType>::encode(*cmdContainer.get(), dims, true, false, dispatchInterface.get(), 0, false,
+                                             pDevice, NEO::PreemptionMode::Disabled, requiresUncachedMocs, partitionCount);

    GenCmdList commands;
    CmdParse<FamilyType>::parseCommandBuffer(commands, ptrOffset(cmdContainer->getCommandStream()->getCpuBase(), 0), cmdContainer->getCommandStream()->getUsed());
@@ -500,8 +507,8 @@ HWCMDTEST_F(IGFX_GEN8_CORE, CommandEncodeStatesTest, givenForceBtpPrefetchModeDe
        cmdContainer->initialize(pDevice);
        bool requiresUncachedMocs = false;
        uint32_t partitionCount = 0;
-        EncodeDispatchKernel<FamilyType>::encode(*cmdContainer.get(), dims, false, false, dispatchInterface.get(), 0, pDevice,
-                                                 NEO::PreemptionMode::Disabled, requiresUncachedMocs, partitionCount);
+        EncodeDispatchKernel<FamilyType>::encode(*cmdContainer.get(), dims, false, false, dispatchInterface.get(), 0, false,
+                                                 pDevice, NEO::PreemptionMode::Disabled, requiresUncachedMocs, partitionCount);

        auto dsh = cmdContainer->getIndirectHeap(HeapType::DYNAMIC_STATE);

@@ -532,8 +539,8 @@ HWCMDTEST_F(IGFX_GEN8_CORE, CommandEncodeStatesTest, givenForceBtpPrefetchModeDe

        bool requiresUncachedMocs = false;
        uint32_t partitionCount = 0;
-        EncodeDispatchKernel<FamilyType>::encode(*cmdContainer.get(), dims, false, false, dispatchInterface.get(), 0, pDevice,
-                                                 NEO::PreemptionMode::Disabled, requiresUncachedMocs, partitionCount);
+        EncodeDispatchKernel<FamilyType>::encode(*cmdContainer.get(), dims, false, false, dispatchInterface.get(), 0, false,
+                                                 pDevice, NEO::PreemptionMode::Disabled, requiresUncachedMocs, partitionCount);

        auto dsh = cmdContainer->getIndirectHeap(HeapType::DYNAMIC_STATE);

@@ -559,8 +566,8 @@ HWCMDTEST_F(IGFX_GEN8_CORE, CommandEncodeStatesTest, givenForceBtpPrefetchModeDe

        bool requiresUncachedMocs = false;
        uint32_t partitionCount = 0;
-        EncodeDispatchKernel<FamilyType>::encode(*cmdContainer.get(), dims, false, false, dispatchInterface.get(), 0, pDevice,
-                                                 NEO::PreemptionMode::Disabled, requiresUncachedMocs, partitionCount);
+        EncodeDispatchKernel<FamilyType>::encode(*cmdContainer.get(), dims, false, false, dispatchInterface.get(), 0, false,
+                                                 pDevice, NEO::PreemptionMode::Disabled, requiresUncachedMocs, partitionCount);

        auto dsh = cmdContainer->getIndirectHeap(HeapType::DYNAMIC_STATE);

@@ -590,8 +597,8 @@ HWCMDTEST_F(IGFX_GEN8_CORE, CommandEncodeStatesTest, givenCleanHeapsAndSlmNotCha

    bool requiresUncachedMocs = false;
    uint32_t partitionCount = 0;
-    EncodeDispatchKernel<FamilyType>::encode(*cmdContainer.get(), dims, false, false, dispatchInterface.get(), 0, pDevice,
-                                             NEO::PreemptionMode::Disabled, requiresUncachedMocs, partitionCount);
+    EncodeDispatchKernel<FamilyType>::encode(*cmdContainer.get(), dims, false, false, dispatchInterface.get(), 0, false,
+                                             pDevice, NEO::PreemptionMode::Disabled, requiresUncachedMocs, partitionCount);

    GenCmdList commands;
    CmdParse<FamilyType>::parseCommandBuffer(commands, ptrOffset(cmdContainer->getCommandStream()->getCpuBase(), 0), cmdContainer->getCommandStream()->getUsed());
@@ -614,8 +621,8 @@ HWCMDTEST_F(IGFX_GEN8_CORE, CommandEncodeStatesTest, givenCleanHeapsAndSlmNotCha

    bool requiresUncachedMocs = true;
    uint32_t partitionCount = 0;
-    EncodeDispatchKernel<FamilyType>::encode(*cmdContainer.get(), dims, false, false, dispatchInterface.get(), 0, pDevice,
-                                             NEO::PreemptionMode::Disabled, requiresUncachedMocs, partitionCount);
+    EncodeDispatchKernel<FamilyType>::encode(*cmdContainer.get(), dims, false, false, dispatchInterface.get(), 0, false,
+                                             pDevice, NEO::PreemptionMode::Disabled, requiresUncachedMocs, partitionCount);

    GenCmdList commands;
    CmdParse<FamilyType>::parseCommandBuffer(commands, ptrOffset(cmdContainer->getCommandStream()->getCpuBase(), 0), cmdContainer->getCommandStream()->getUsed());
@@ -641,8 +648,8 @@ HWCMDTEST_F(IGFX_GEN8_CORE, CommandEncodeStatesTest, givenDirtyHeapsAndSlmNotCha

    bool requiresUncachedMocs = false;
    uint32_t partitionCount = 0;
-    EncodeDispatchKernel<FamilyType>::encode(*cmdContainer.get(), dims, false, false, dispatchInterface.get(), 0, pDevice,
-                                             NEO::PreemptionMode::Disabled, requiresUncachedMocs, partitionCount);
+    EncodeDispatchKernel<FamilyType>::encode(*cmdContainer.get(), dims, false, false, dispatchInterface.get(), 0, false,
+                                             pDevice, NEO::PreemptionMode::Disabled, requiresUncachedMocs, partitionCount);

    GenCmdList commands;
    CmdParse<FamilyType>::parseCommandBuffer(commands, ptrOffset(cmdContainer->getCommandStream()->getCpuBase(), 0), cmdContainer->getCommandStream()->getUsed());
@@ -664,8 +671,8 @@ HWCMDTEST_F(IGFX_GEN8_CORE, CommandEncodeStatesTest, givenDirtyHeapsWhenDispatch

    bool requiresUncachedMocs = false;
    uint32_t partitionCount = 0;
-    EncodeDispatchKernel<FamilyType>::encode(*cmdContainer.get(), dims, false, false, dispatchInterface.get(), 0, pDevice,
-                                             NEO::PreemptionMode::Disabled, requiresUncachedMocs, partitionCount);
+    EncodeDispatchKernel<FamilyType>::encode(*cmdContainer.get(), dims, false, false, dispatchInterface.get(), 0, false,
+                                             pDevice, NEO::PreemptionMode::Disabled, requiresUncachedMocs, partitionCount);

    GenCmdList cmdList;
    CmdParse<FamilyType>::parseCommandBuffer(cmdList, ptrOffset(cmdContainer->getCommandStream()->getCpuBase(), 0), cmdContainer->getCommandStream()->getUsed());
@@ -704,8 +711,8 @@ HWCMDTEST_F(IGFX_GEN8_CORE, CommandEncodeStatesTest, givenCleanHeapsAndSlmChange

    bool requiresUncachedMocs = false;
    uint32_t partitionCount = 0;
-    EncodeDispatchKernel<FamilyType>::encode(*cmdContainer.get(), dims, false, false, dispatchInterface.get(), 0, pDevice,
-                                             NEO::PreemptionMode::Disabled, requiresUncachedMocs, partitionCount);
+    EncodeDispatchKernel<FamilyType>::encode(*cmdContainer.get(), dims, false, false, dispatchInterface.get(), 0, false,
+                                             pDevice, NEO::PreemptionMode::Disabled, requiresUncachedMocs, partitionCount);

    GenCmdList commands;
    CmdParse<FamilyType>::parseCommandBuffer(commands, ptrOffset(cmdContainer->getCommandStream()->getCpuBase(), 0), cmdContainer->getCommandStream()->getUsed());
@@ -728,8 +735,8 @@ HWCMDTEST_F(IGFX_GEN8_CORE, CommandEncodeStatesTest, giveNextIddInBlockZeorWhenD

    bool requiresUncachedMocs = false;
    uint32_t partitionCount = 0;
-    EncodeDispatchKernel<FamilyType>::encode(*cmdContainer.get(), dims, false, false, dispatchInterface.get(), 0, pDevice,
-                                             NEO::PreemptionMode::Disabled, requiresUncachedMocs, partitionCount);
+    EncodeDispatchKernel<FamilyType>::encode(*cmdContainer.get(), dims, false, false, dispatchInterface.get(), 0, false,
+                                             pDevice, NEO::PreemptionMode::Disabled, requiresUncachedMocs, partitionCount);

    GenCmdList commands;
    CmdParse<FamilyType>::parseCommandBuffer(commands, ptrOffset(cmdContainer->getCommandStream()->getCpuBase(), 0), cmdContainer->getCommandStream()->getUsed());
@@ -764,8 +771,8 @@ HWTEST2_F(EncodeDispatchKernelTest, givenBindfulKernelWhenDispatchingKernelThenS
    auto usedBefore = cmdContainer->getIndirectHeap(HeapType::SURFACE_STATE)->getUsed();
    bool requiresUncachedMocs = false;
    uint32_t partitionCount = 0;
-    EncodeDispatchKernel<FamilyType>::encode(*cmdContainer.get(), dims, false, false, dispatchInterface.get(), 0, pDevice,
-                                             NEO::PreemptionMode::Disabled, requiresUncachedMocs, partitionCount);
+    EncodeDispatchKernel<FamilyType>::encode(*cmdContainer.get(), dims, false, false, dispatchInterface.get(), 0, false,
+                                             pDevice, NEO::PreemptionMode::Disabled, requiresUncachedMocs, partitionCount);
    auto usedAfter = cmdContainer->getIndirectHeap(HeapType::SURFACE_STATE)->getUsed();

    EXPECT_NE(usedAfter, usedBefore);
@@ -793,8 +800,8 @@ HWTEST2_F(EncodeDispatchKernelTest, givenBindlessKernelWhenDispatchingKernelThen
    bool requiresUncachedMocs = false;
    auto usedBefore = cmdContainer->getIndirectHeap(HeapType::SURFACE_STATE)->getUsed();
    uint32_t partitionCount = 0;
-    EncodeDispatchKernel<FamilyType>::encode(*cmdContainer.get(), dims, false, false, dispatchInterface.get(), 0, pDevice,
-                                             NEO::PreemptionMode::Disabled, requiresUncachedMocs, partitionCount);
+    EncodeDispatchKernel<FamilyType>::encode(*cmdContainer.get(), dims, false, false, dispatchInterface.get(), 0, false,
+                                             pDevice, NEO::PreemptionMode::Disabled, requiresUncachedMocs, partitionCount);
    auto usedAfter = cmdContainer->getIndirectHeap(HeapType::SURFACE_STATE)->getUsed();

    EXPECT_EQ(usedAfter, usedBefore);
@@ -852,8 +859,8 @@ HWTEST_F(EncodeDispatchKernelTest, givenNonBindlessOrStatelessArgWhenDispatching

    bool requiresUncachedMocs = false;
    uint32_t partitionCount = 0;
-    EncodeDispatchKernel<FamilyType>::encode(*cmdContainer.get(), dims, false, false, dispatchInterface.get(), 0, pDevice,
-                                             NEO::PreemptionMode::Disabled, requiresUncachedMocs, partitionCount);
+    EncodeDispatchKernel<FamilyType>::encode(*cmdContainer.get(), dims, false, false, dispatchInterface.get(), 0, false,
+                                             pDevice, NEO::PreemptionMode::Disabled, requiresUncachedMocs, partitionCount);
    EXPECT_EQ(pattern, *patchLocation);

    iOpenCL::SPatchSamplerKernelArgument samplerArg = {};
@@ -877,8 +884,8 @@ HWTEST_F(EncodeDispatchKernelTest, givenNonBindlessOrStatelessArgWhenDispatching

    ioh->replaceBuffer(ioh->getCpuBase(), ioh->getMaxAvailableSpace());
    memset(ioh->getCpuBase(), 0, ioh->getMaxAvailableSpace());
-    EncodeDispatchKernel<FamilyType>::encode(*cmdContainer.get(), dims, false, false, dispatchInterface.get(), 0, pDevice,
-                                             NEO::PreemptionMode::Disabled, requiresUncachedMocs, partitionCount);
+    EncodeDispatchKernel<FamilyType>::encode(*cmdContainer.get(), dims, false, false, dispatchInterface.get(), 0, false,
+                                             pDevice, NEO::PreemptionMode::Disabled, requiresUncachedMocs, partitionCount);
    EXPECT_THAT(ptrOffset(ioh->getCpuBase(), iohOffset), MemoryZeroed(ioh->getMaxAvailableSpace() - iohOffset));
 }

@@ -1106,8 +1113,8 @@ HWTEST_F(BindlessCommandEncodeStatesTesttt, givenBindlessKernelWhenBindlessModeE
    bool requiresUncachedMocs = false;
    EXPECT_EQ(commandContainer->getIndirectHeap(HeapType::SURFACE_STATE), nullptr);
    uint32_t partitionCount = 0;
-    EncodeDispatchKernel<FamilyType>::encode(*commandContainer.get(), dims, false, false, dispatchInterface.get(), 0, pDevice,
-                                             NEO::PreemptionMode::Disabled, requiresUncachedMocs, partitionCount);
+    EncodeDispatchKernel<FamilyType>::encode(*commandContainer.get(), dims, false, false, dispatchInterface.get(), 0, false,
+                                             pDevice, NEO::PreemptionMode::Disabled, requiresUncachedMocs, partitionCount);
    EXPECT_EQ(commandContainer->getIndirectHeap(HeapType::SURFACE_STATE), nullptr);
 }

@@ -1139,8 +1146,9 @@ HWTEST_F(BindlessCommandEncodeStatesTesttt, givenBindfulKernelWhenBindlessModeEn
    bool requiresUncachedMocs = false;
    EXPECT_EQ(commandContainer->getIndirectHeap(HeapType::SURFACE_STATE), nullptr);
    uint32_t partitionCount = 0;
-    EncodeDispatchKernel<FamilyType>::encode(*commandContainer.get(), dims, false, false, dispatchInterface.get(), 0, pDevice,
-                                             NEO::PreemptionMode::Disabled, requiresUncachedMocs, partitionCount);
+    EncodeDispatchKernel<FamilyType>::encode(*commandContainer.get(), dims, false, false, dispatchInterface.get(), 0, false,
+                                             pDevice, NEO::PreemptionMode::Disabled, requiresUncachedMocs, partitionCount);
+
    EXPECT_NE(commandContainer->getIndirectHeap(HeapType::SURFACE_STATE), nullptr);
 }

@@ -1172,16 +1180,16 @@ HWTEST_F(BindlessCommandEncodeStatesTesttt, givenBindlessModeEnabledWhenDispatch
    bool requiresUncachedMocs = false;
    EXPECT_EQ(commandContainer->getIndirectHeap(HeapType::SURFACE_STATE), nullptr);
    uint32_t partitionCount = 0;
-    EncodeDispatchKernel<FamilyType>::encode(*commandContainer.get(), dims, false, false, dispatchInterface.get(), 0, pDevice,
-                                             NEO::PreemptionMode::Disabled, requiresUncachedMocs, partitionCount);
+    EncodeDispatchKernel<FamilyType>::encode(*commandContainer.get(), dims, false, false, dispatchInterface.get(), 0, false,
+                                             pDevice, NEO::PreemptionMode::Disabled, requiresUncachedMocs, partitionCount);
    auto sshBefore = commandContainer->getIndirectHeap(HeapType::SURFACE_STATE);
-    EncodeDispatchKernel<FamilyType>::encode(*commandContainer.get(), dims, false, false, dispatchInterface.get(), 0, pDevice,
-                                             NEO::PreemptionMode::Disabled, requiresUncachedMocs, partitionCount);
-    EncodeDispatchKernel<FamilyType>::encode(*commandContainer.get(), dims, false, false, dispatchInterface.get(), 0, pDevice,
-                                             NEO::PreemptionMode::Disabled, requiresUncachedMocs, partitionCount);
+    EncodeDispatchKernel<FamilyType>::encode(*commandContainer.get(), dims, false, false, dispatchInterface.get(), 0, false,
+                                             pDevice, NEO::PreemptionMode::Disabled, requiresUncachedMocs, partitionCount);
+    EncodeDispatchKernel<FamilyType>::encode(*commandContainer.get(), dims, false, false, dispatchInterface.get(), 0, false,
+                                             pDevice, NEO::PreemptionMode::Disabled, requiresUncachedMocs, partitionCount);
    auto sshAfter = commandContainer->getIndirectHeap(HeapType::SURFACE_STATE);
-    EncodeDispatchKernel<FamilyType>::encode(*commandContainer.get(), dims, false, false, dispatchInterface.get(), 0, pDevice,
-                                             NEO::PreemptionMode::Disabled, requiresUncachedMocs, partitionCount);
+    EncodeDispatchKernel<FamilyType>::encode(*commandContainer.get(), dims, false, false, dispatchInterface.get(), 0, false,
+                                             pDevice, NEO::PreemptionMode::Disabled, requiresUncachedMocs, partitionCount);
    EXPECT_EQ(sshBefore, sshAfter);
 }

@@ -1209,8 +1217,8 @@ HWTEST_F(BindlessCommandEncodeStatesTest, givenGlobalBindlessHeapsWhenDispatchin

    bool requiresUncachedMocs = false;
    uint32_t partitionCount = 0;
-    EncodeDispatchKernel<FamilyType>::encode(*cmdContainer.get(), dims, false, false, dispatchInterface.get(), 0, pDevice,
-                                             NEO::PreemptionMode::Disabled, requiresUncachedMocs, partitionCount);
+    EncodeDispatchKernel<FamilyType>::encode(*cmdContainer.get(), dims, false, false, dispatchInterface.get(), 0, false,
+                                             pDevice, NEO::PreemptionMode::Disabled, requiresUncachedMocs, partitionCount);
    EXPECT_NE(std::find(cmdContainer->getResidencyContainer().begin(), cmdContainer->getResidencyContainer().end(), pDevice->getBindlessHeapsHelper()->getHeap(BindlessHeapsHelper::GLOBAL_DSH)->getGraphicsAllocation()), cmdContainer->getResidencyContainer().end());
 }

@@ -1237,7 +1245,7 @@ HWTEST_F(BindlessCommandEncodeStatesTest, givenBindlessModeDisabledelWithSampler

    bool requiresUncachedMocs = false;
    uint32_t partitionCount = 0;
-    EncodeDispatchKernel<FamilyType>::encode(*cmdContainer.get(), dims, false, false, dispatchInterface.get(), 0, pDevice,
-                                             NEO::PreemptionMode::Disabled, requiresUncachedMocs, partitionCount);
+    EncodeDispatchKernel<FamilyType>::encode(*cmdContainer.get(), dims, false, false, dispatchInterface.get(), 0, false,
+                                             pDevice, NEO::PreemptionMode::Disabled, requiresUncachedMocs, partitionCount);
    EXPECT_EQ(std::find(cmdContainer->getResidencyContainer().begin(), cmdContainer->getResidencyContainer().end(), pDevice->getBindlessHeapsHelper()->getHeap(BindlessHeapsHelper::GLOBAL_DSH)->getGraphicsAllocation()), cmdContainer->getResidencyContainer().end());
 }