From 83a1a52bdc7730a5f928b4c8e4ae3eb2cb53c806 Mon Sep 17 00:00:00 2001 From: Lukasz Jobczyk Date: Wed, 14 Apr 2021 14:40:23 +0000 Subject: [PATCH] Flush tlb only when new resource is bound Signed-off-by: Lukasz Jobczyk --- .../test/unit_test/test_files/igdrcl.config | 1 + .../debug_settings/debug_variables_base.inl | 1 + .../direct_submission/direct_submission_hw.h | 4 +- .../direct_submission_hw.inl | 15 +- .../dispatchers/blitter_dispatcher.h | 4 +- .../dispatchers/blitter_dispatcher.inl | 11 +- .../dispatchers/render_dispatcher.h | 4 +- .../dispatchers/render_dispatcher.inl | 15 +- .../linux/drm_direct_submission.h | 5 +- .../linux/drm_direct_submission.inl | 35 ++++ shared/source/os_interface/linux/drm_neo.h | 4 + .../direct_submission_tests.cpp | 14 +- .../linux/drm_direct_submission_tests.cpp | 156 ++++++++++++++++++ 13 files changed, 255 insertions(+), 14 deletions(-) diff --git a/opencl/test/unit_test/test_files/igdrcl.config b/opencl/test/unit_test/test_files/igdrcl.config index 8d69c8d66e..37b757ca0f 100644 --- a/opencl/test/unit_test/test_files/igdrcl.config +++ b/opencl/test/unit_test/test_files/igdrcl.config @@ -89,6 +89,7 @@ DirectSubmissionSemaphoreAddressing = -1 DirectSubmissionDisableCpuCacheFlush = -1 DirectSubmissionEnableDebugBuffer = 0 DirectSubmissionDiagnosticExecutionCount = 30 +DirectSubmissionNewResourceTlbFlush = -1 DirectSubmissionDisableCacheFlush = -1 DirectSubmissionDisableMonitorFence = 0 USMEvictAfterMigration = 1 diff --git a/shared/source/debug_settings/debug_variables_base.inl b/shared/source/debug_settings/debug_variables_base.inl index 94d786d20a..dd28ef7f64 100644 --- a/shared/source/debug_settings/debug_variables_base.inl +++ b/shared/source/debug_settings/debug_variables_base.inl @@ -163,6 +163,7 @@ DECLARE_DEBUG_VARIABLE(int32_t, DirectSubmissionOverrideBlitterSupport, -1, "Ove DECLARE_DEBUG_VARIABLE(int32_t, DirectSubmissionOverrideRenderSupport, -1, "Overrides default render support: -1: do not override, 0: disable engine support, 1: enable engine support with init start, 2: enable engine support without init start") DECLARE_DEBUG_VARIABLE(int32_t, DirectSubmissionOverrideComputeSupport, -1, "Overrides default compute support: -1: do not override, 0: disable engine support, 1: enable engine support with init start, 2: enable engine support without init start") DECLARE_DEBUG_VARIABLE(int32_t, DirectSubmissionDisableCacheFlush, -1, "-1: driver default, 0: additional cache flush is present 1: disable dispatching cache flush commands") +DECLARE_DEBUG_VARIABLE(int32_t, DirectSubmissionNewResourceTlbFlush, -1, "-1: driver default - flush when new resource is bound, 0: disabled, 1: enabled") DECLARE_DEBUG_VARIABLE(bool, USMEvictAfterMigration, true, "Evict USM allocation after implicit migration to GPU") DECLARE_DEBUG_VARIABLE(bool, DirectSubmissionDisableMonitorFence, false, "Disable dispatching monitor fence commands") diff --git a/shared/source/direct_submission/direct_submission_hw.h b/shared/source/direct_submission/direct_submission_hw.h index 93ebddcdf7..1450443f21 100644 --- a/shared/source/direct_submission/direct_submission_hw.h +++ b/shared/source/direct_submission/direct_submission_hw.h @@ -37,7 +37,7 @@ struct TagData { }; namespace UllsDefaults { -constexpr bool defaultDisableCacheFlush = false; +constexpr bool defaultDisableCacheFlush = true; constexpr bool defaultDisableMonitorFence = false; } // namespace UllsDefaults @@ -76,6 +76,8 @@ class DirectSubmissionHw { virtual bool allocateOsResources() = 0; virtual bool submit(uint64_t gpuAddress, size_t size) = 0; virtual bool handleResidency() = 0; + virtual void handleNewResourcesSubmission(); + virtual size_t getSizeNewResourceHandler(); virtual uint64_t switchRingBuffers(); virtual void handleSwitchRingBuffers() = 0; GraphicsAllocation *switchRingBuffersAllocations(); diff --git a/shared/source/direct_submission/direct_submission_hw.inl b/shared/source/direct_submission/direct_submission_hw.inl index 82dc95d269..a87f47937d 100644 --- a/shared/source/direct_submission/direct_submission_hw.inl +++ b/shared/source/direct_submission/direct_submission_hw.inl @@ -1,5 +1,5 @@ /* - * Copyright (C) 2020 Intel Corporation + * Copyright (C) 2020-2021 Intel Corporation * * SPDX-License-Identifier: MIT * @@ -261,6 +261,8 @@ inline size_t DirectSubmissionHw::getSizeDispatch() { size += Dispatcher::getSizeMonitorFence(*hwInfo); } + size += getSizeNewResourceHandler(); + return size; } @@ -329,6 +331,8 @@ bool DirectSubmissionHw::dispatchCommandBuffer(BatchBuffe buffersSwitched = true; } + handleNewResourcesSubmission(); + void *currentPosition = dispatchWorkloadSection(batchBuffer); if (ringStart) { @@ -376,6 +380,15 @@ inline size_t DirectSubmissionHw::getSizeDisablePrefetche return 0u; } +template +inline void DirectSubmissionHw::handleNewResourcesSubmission() { +} + +template +inline size_t DirectSubmissionHw::getSizeNewResourceHandler() { + return 0u; +} + template inline uint64_t DirectSubmissionHw::switchRingBuffers() { GraphicsAllocation *nextRingBuffer = switchRingBuffersAllocations(); diff --git a/shared/source/direct_submission/dispatchers/blitter_dispatcher.h b/shared/source/direct_submission/dispatchers/blitter_dispatcher.h index 1084c2b55e..08a2f2bb24 100644 --- a/shared/source/direct_submission/dispatchers/blitter_dispatcher.h +++ b/shared/source/direct_submission/dispatchers/blitter_dispatcher.h @@ -1,5 +1,5 @@ /* - * Copyright (C) 2020 Intel Corporation + * Copyright (C) 2020-2021 Intel Corporation * * SPDX-License-Identifier: MIT * @@ -23,6 +23,8 @@ class BlitterDispatcher : public Dispatcher { static size_t getSizeMonitorFence(const HardwareInfo &hwInfo); static void dispatchCacheFlush(LinearStream &cmdBuffer, const HardwareInfo &hwInfo); + static void dispatchTlbFlush(LinearStream &cmdBuffer); static size_t getSizeCacheFlush(const HardwareInfo &hwInfo); + static size_t getSizeTlbFlush(); }; } // namespace NEO diff --git a/shared/source/direct_submission/dispatchers/blitter_dispatcher.inl b/shared/source/direct_submission/dispatchers/blitter_dispatcher.inl index 0be1a8f9b0..85941140d1 100644 --- a/shared/source/direct_submission/dispatchers/blitter_dispatcher.inl +++ b/shared/source/direct_submission/dispatchers/blitter_dispatcher.inl @@ -1,5 +1,5 @@ /* - * Copyright (C) 2020 Intel Corporation + * Copyright (C) 2020-2021 Intel Corporation * * SPDX-License-Identifier: MIT * @@ -41,10 +41,19 @@ inline void BlitterDispatcher::dispatchCacheFlush(LinearStream &cmdBu EncodeMiFlushDW::programMiFlushDw(cmdBuffer, 0ull, 0ull, false, false); } +template +inline void BlitterDispatcher::dispatchTlbFlush(LinearStream &cmdBuffer) { +} + template inline size_t BlitterDispatcher::getSizeCacheFlush(const HardwareInfo &hwInfo) { size_t size = EncodeMiFlushDW::getMiFlushDwCmdSizeForDataWrite(); return size; } +template +inline size_t BlitterDispatcher::getSizeTlbFlush() { + return 0u; +} + } // namespace NEO diff --git a/shared/source/direct_submission/dispatchers/render_dispatcher.h b/shared/source/direct_submission/dispatchers/render_dispatcher.h index 85b07f32d5..d851c5398a 100644 --- a/shared/source/direct_submission/dispatchers/render_dispatcher.h +++ b/shared/source/direct_submission/dispatchers/render_dispatcher.h @@ -1,5 +1,5 @@ /* - * Copyright (C) 2020 Intel Corporation + * Copyright (C) 2020-2021 Intel Corporation * * SPDX-License-Identifier: MIT * @@ -23,6 +23,8 @@ class RenderDispatcher : public Dispatcher { static size_t getSizeMonitorFence(const HardwareInfo &hwInfo); static void dispatchCacheFlush(LinearStream &cmdBuffer, const HardwareInfo &hwInfo); + static void dispatchTlbFlush(LinearStream &cmdBuffer); static size_t getSizeCacheFlush(const HardwareInfo &hwInfo); + static size_t getSizeTlbFlush(); }; } // namespace NEO diff --git a/shared/source/direct_submission/dispatchers/render_dispatcher.inl b/shared/source/direct_submission/dispatchers/render_dispatcher.inl index cd49075e28..bcc4e05d5c 100644 --- a/shared/source/direct_submission/dispatchers/render_dispatcher.inl +++ b/shared/source/direct_submission/dispatchers/render_dispatcher.inl @@ -1,5 +1,5 @@ /* - * Copyright (C) 2020 Intel Corporation + * Copyright (C) 2020-2021 Intel Corporation * * SPDX-License-Identifier: MIT * @@ -52,10 +52,23 @@ inline void RenderDispatcher::dispatchCacheFlush(LinearStream &cmdBuf MemorySynchronizationCommands::addFullCacheFlush(cmdBuffer); } +template +inline void RenderDispatcher::dispatchTlbFlush(LinearStream &cmdBuffer) { + PipeControlArgs args(false); + args.tlbInvalidation = true; + args.pipeControlFlushEnable = true; + MemorySynchronizationCommands::addPipeControl(cmdBuffer, args); +} + template inline size_t RenderDispatcher::getSizeCacheFlush(const HardwareInfo &hwInfo) { size_t size = MemorySynchronizationCommands::getSizeForFullCacheFlush(); return size; } +template +inline size_t RenderDispatcher::getSizeTlbFlush() { + return MemorySynchronizationCommands::getSizeForSinglePipeControl(); +} + } // namespace NEO diff --git a/shared/source/direct_submission/linux/drm_direct_submission.h b/shared/source/direct_submission/linux/drm_direct_submission.h index a57cbdf87d..a790313bf6 100644 --- a/shared/source/direct_submission/linux/drm_direct_submission.h +++ b/shared/source/direct_submission/linux/drm_direct_submission.h @@ -1,5 +1,5 @@ /* - * Copyright (C) 2020 Intel Corporation + * Copyright (C) 2020-2021 Intel Corporation * * SPDX-License-Identifier: MIT * @@ -26,6 +26,9 @@ class DrmDirectSubmission : public DirectSubmissionHw { bool submit(uint64_t gpuAddress, size_t size) override; bool handleResidency() override; + bool isNewResourceHandleNeeded(); + void handleNewResourcesSubmission() override; + size_t getSizeNewResourceHandler() override; void handleSwitchRingBuffers() override; uint64_t updateTagValue() override; void getTagAddressValue(TagData &tagData) override; diff --git a/shared/source/direct_submission/linux/drm_direct_submission.inl b/shared/source/direct_submission/linux/drm_direct_submission.inl index 281dfb8f4c..3068d77412 100644 --- a/shared/source/direct_submission/linux/drm_direct_submission.inl +++ b/shared/source/direct_submission/linux/drm_direct_submission.inl @@ -89,6 +89,41 @@ bool DrmDirectSubmission::handleResidency() { return true; } +template +bool DrmDirectSubmission::isNewResourceHandleNeeded() { + auto osContextLinux = static_cast(&this->osContext); + auto newResourcesBound = osContextLinux->getDrm().getNewResourceBound(); + + if (DebugManager.flags.DirectSubmissionNewResourceTlbFlush.get() != -1) { + newResourcesBound = DebugManager.flags.DirectSubmissionNewResourceTlbFlush.get(); + } + + return newResourcesBound; +} + +template +void DrmDirectSubmission::handleNewResourcesSubmission() { + if (isNewResourceHandleNeeded()) { + Dispatcher::dispatchTlbFlush(this->ringCommandStream); + } + + auto osContextLinux = static_cast(&this->osContext); + if (!EngineHelpers::isBcs(osContextLinux->getEngineType())) { + osContextLinux->getDrm().setNewResourceBound(false); + } +} + +template +size_t DrmDirectSubmission::getSizeNewResourceHandler() { + size_t size = 0u; + + if (isNewResourceHandleNeeded()) { + size += Dispatcher::getSizeTlbFlush(); + } + + return size; +} + template void DrmDirectSubmission::handleSwitchRingBuffers() { if (this->ringStart) { diff --git a/shared/source/os_interface/linux/drm_neo.h b/shared/source/os_interface/linux/drm_neo.h index c39a03aaa2..11bb9aa7f2 100644 --- a/shared/source/os_interface/linux/drm_neo.h +++ b/shared/source/os_interface/linux/drm_neo.h @@ -174,6 +174,9 @@ class Drm { uint64_t getNextFenceVal(uint32_t vmHandleId) { return ++fenceVal[vmHandleId]; } uint64_t *getFenceAddr(uint32_t vmHandleId) { return &pagingFence[vmHandleId]; } + void setNewResourceBound(bool value) { this->newResourceBound = value; }; + bool getNewResourceBound() { return this->newResourceBound; }; + protected: int getQueueSliceCount(drm_i915_gem_context_param_sseu *sseu); bool translateTopologyInfo(const drm_i915_query_topology_info *queryTopologyInfo, int &sliceCount, int &subSliceCount, int &euCount); @@ -187,6 +190,7 @@ class Drm { bool bindAvailable = false; bool directSubmissionActive = false; bool contextDebugSupported = false; + bool newResourceBound = false; std::once_flag checkBindOnce; std::unique_ptr hwDeviceId; int deviceId = 0; diff --git a/shared/test/unit_test/direct_submission/direct_submission_tests.cpp b/shared/test/unit_test/direct_submission/direct_submission_tests.cpp index 5a3a5c8894..5ea3720dc9 100644 --- a/shared/test/unit_test/direct_submission/direct_submission_tests.cpp +++ b/shared/test/unit_test/direct_submission/direct_submission_tests.cpp @@ -903,7 +903,7 @@ HWTEST_F(DirectSubmissionTest, MockDirectSubmissionHw directSubmission(*pDevice, *osContext.get()); - EXPECT_FALSE(UllsDefaults::defaultDisableCacheFlush); + EXPECT_TRUE(UllsDefaults::defaultDisableCacheFlush); EXPECT_FALSE(UllsDefaults::defaultDisableMonitorFence); EXPECT_TRUE(directSubmission.disableCacheFlush); EXPECT_FALSE(directSubmission.disableMonitorFence); @@ -938,7 +938,7 @@ HWTEST_F(DirectSubmissionTest, MockDirectSubmissionHw directSubmission(*pDevice, *osContext.get()); - EXPECT_FALSE(UllsDefaults::defaultDisableCacheFlush); + EXPECT_TRUE(UllsDefaults::defaultDisableCacheFlush); EXPECT_FALSE(UllsDefaults::defaultDisableMonitorFence); EXPECT_TRUE(directSubmission.disableCacheFlush); EXPECT_FALSE(directSubmission.disableMonitorFence); @@ -973,7 +973,7 @@ HWTEST_F(DirectSubmissionTest, NEO::IoFunctions::mockFcloseCalled = 0u; MockDirectSubmissionHw directSubmission(*pDevice, *osContext.get()); - EXPECT_FALSE(UllsDefaults::defaultDisableCacheFlush); + EXPECT_TRUE(UllsDefaults::defaultDisableCacheFlush); EXPECT_FALSE(UllsDefaults::defaultDisableMonitorFence); EXPECT_TRUE(directSubmission.disableCacheFlush); EXPECT_FALSE(directSubmission.disableMonitorFence); @@ -1014,7 +1014,7 @@ HWTEST_F(DirectSubmissionTest, MockDirectSubmissionHw directSubmission(*pDevice, *osContext.get()); uint32_t expectedSemaphoreValue = directSubmission.currentQueueWorkCount; - EXPECT_FALSE(UllsDefaults::defaultDisableCacheFlush); + EXPECT_TRUE(UllsDefaults::defaultDisableCacheFlush); EXPECT_FALSE(UllsDefaults::defaultDisableMonitorFence); EXPECT_TRUE(directSubmission.disableCacheFlush); EXPECT_TRUE(directSubmission.disableMonitorFence); @@ -1039,7 +1039,7 @@ HWTEST_F(DirectSubmissionTest, EXPECT_EQ(expectedSize, directSubmission.ringCommandStream.getUsed()); EXPECT_EQ(expectedSemaphoreValue, directSubmission.currentQueueWorkCount); - EXPECT_FALSE(directSubmission.disableCacheFlush); + EXPECT_TRUE(directSubmission.disableCacheFlush); EXPECT_FALSE(directSubmission.disableMonitorFence); EXPECT_EQ(0u, directSubmission.workloadMode); EXPECT_EQ(nullptr, directSubmission.diagnostic.get()); @@ -1101,7 +1101,7 @@ HWTEST_F(DirectSubmissionTest, MockDirectSubmissionHw directSubmission(*pDevice, *osContext.get()); uint32_t expectedSemaphoreValue = directSubmission.currentQueueWorkCount; - EXPECT_FALSE(UllsDefaults::defaultDisableCacheFlush); + EXPECT_TRUE(UllsDefaults::defaultDisableCacheFlush); EXPECT_FALSE(UllsDefaults::defaultDisableMonitorFence); EXPECT_TRUE(directSubmission.disableCacheFlush); EXPECT_TRUE(directSubmission.disableMonitorFence); @@ -1127,7 +1127,7 @@ HWTEST_F(DirectSubmissionTest, EXPECT_EQ(expectedSize, directSubmission.ringCommandStream.getUsed()); EXPECT_EQ(expectedSemaphoreValue, directSubmission.currentQueueWorkCount); - EXPECT_FALSE(directSubmission.disableCacheFlush); + EXPECT_TRUE(directSubmission.disableCacheFlush); EXPECT_FALSE(directSubmission.disableMonitorFence); EXPECT_EQ(0u, directSubmission.workloadMode); EXPECT_EQ(nullptr, directSubmission.diagnostic.get()); diff --git a/shared/test/unit_test/direct_submission/linux/drm_direct_submission_tests.cpp b/shared/test/unit_test/direct_submission/linux/drm_direct_submission_tests.cpp index f64bc65e45..026eb58852 100644 --- a/shared/test/unit_test/direct_submission/linux/drm_direct_submission_tests.cpp +++ b/shared/test/unit_test/direct_submission/linux/drm_direct_submission_tests.cpp @@ -8,6 +8,8 @@ #include "shared/source/direct_submission/dispatchers/render_dispatcher.h" #include "shared/source/direct_submission/linux/drm_direct_submission.h" #include "shared/source/os_interface/linux/os_context_linux.h" +#include "shared/test/common/cmd_parse/hw_parse.h" +#include "shared/test/common/helpers/debug_manager_state_restore.h" #include "shared/test/common/helpers/ult_hw_config.h" #include "shared/test/common/mocks/mock_device.h" @@ -46,8 +48,11 @@ struct MockDrmDirectSubmission : public DrmDirectSubmissiongetHardwareInfo().platform.eRenderCoreFamily); EXPECT_EQ(directSubmissionSupported, hwHelper.isDirectSubmissionSupported() && executionEnvironment.rootDeviceEnvironments[0]->osInterface->get()->getDrm()->isVmBindAvailable()); } + +HWTEST_F(DrmDirectSubmissionTest, givenDirectSubmissionNewResourceTlbFlushWhenDispatchCommandBufferThenTlbIsFlushed) { + using PIPE_CONTROL = typename FamilyType::PIPE_CONTROL; + using Dispatcher = RenderDispatcher; + + DebugManagerStateRestore restorer; + DebugManager.flags.DirectSubmissionNewResourceTlbFlush.set(1); + + MockDrmDirectSubmission directSubmission(*device.get(), + *osContext.get()); + + bool ret = directSubmission.allocateResources(); + EXPECT_TRUE(ret); + + EXPECT_EQ(directSubmission.getSizeNewResourceHandler(), sizeof(PIPE_CONTROL)); + + directSubmission.handleNewResourcesSubmission(); + + HardwareParse hwParse; + hwParse.parsePipeControl = true; + hwParse.parseCommands(directSubmission.ringCommandStream, 0); + hwParse.findHardwareCommands(); + auto *pipeControl = hwParse.getCommand(); + EXPECT_TRUE(pipeControl->getTlbInvalidate()); + + EXPECT_EQ(directSubmission.getSizeNewResourceHandler(), sizeof(PIPE_CONTROL)); +} + +HWTEST_F(DrmDirectSubmissionTest, givenNewResourceBoundhWhenDispatchCommandBufferThenTlbIsFlushed) { + using PIPE_CONTROL = typename FamilyType::PIPE_CONTROL; + using Dispatcher = RenderDispatcher; + + DebugManagerStateRestore restorer; + DebugManager.flags.DirectSubmissionNewResourceTlbFlush.set(-1); + + MockDrmDirectSubmission directSubmission(*device.get(), + *osContext.get()); + + bool ret = directSubmission.allocateResources(); + EXPECT_TRUE(ret); + + auto drm = static_cast(executionEnvironment.rootDeviceEnvironments[0]->osInterface->get()->getDrm()); + drm->setNewResourceBound(true); + + EXPECT_EQ(directSubmission.getSizeNewResourceHandler(), sizeof(PIPE_CONTROL)); + + directSubmission.handleNewResourcesSubmission(); + + HardwareParse hwParse; + hwParse.parsePipeControl = true; + hwParse.parseCommands(directSubmission.ringCommandStream, 0); + hwParse.findHardwareCommands(); + auto *pipeControl = hwParse.getCommand(); + EXPECT_TRUE(pipeControl->getTlbInvalidate()); + EXPECT_FALSE(drm->getNewResourceBound()); + + EXPECT_EQ(directSubmission.getSizeNewResourceHandler(), 0u); +} + +HWTEST_F(DrmDirectSubmissionTest, givennoNewResourceBoundhWhenDispatchCommandBufferThenTlbIsNotFlushed) { + using PIPE_CONTROL = typename FamilyType::PIPE_CONTROL; + using Dispatcher = RenderDispatcher; + + DebugManagerStateRestore restorer; + DebugManager.flags.DirectSubmissionNewResourceTlbFlush.set(-1); + + MockDrmDirectSubmission directSubmission(*device.get(), + *osContext.get()); + + bool ret = directSubmission.allocateResources(); + EXPECT_TRUE(ret); + + auto drm = static_cast(executionEnvironment.rootDeviceEnvironments[0]->osInterface->get()->getDrm()); + drm->setNewResourceBound(false); + + EXPECT_EQ(directSubmission.getSizeNewResourceHandler(), 0u); + + directSubmission.handleNewResourcesSubmission(); + + HardwareParse hwParse; + hwParse.parsePipeControl = true; + hwParse.parseCommands(directSubmission.ringCommandStream, 0); + hwParse.findHardwareCommands(); + auto *pipeControl = hwParse.getCommand(); + EXPECT_EQ(pipeControl, nullptr); + EXPECT_FALSE(drm->getNewResourceBound()); + + EXPECT_EQ(directSubmission.getSizeNewResourceHandler(), 0u); +} + +HWTEST_F(DrmDirectSubmissionTest, givenDirectSubmissionNewResourceTlbFlusZeroAndNewResourceBoundhWhenDispatchCommandBufferThenTlbIsNotFlushed) { + using PIPE_CONTROL = typename FamilyType::PIPE_CONTROL; + using Dispatcher = RenderDispatcher; + + DebugManagerStateRestore restorer; + DebugManager.flags.DirectSubmissionNewResourceTlbFlush.set(0); + + MockDrmDirectSubmission directSubmission(*device.get(), + *osContext.get()); + + bool ret = directSubmission.allocateResources(); + EXPECT_TRUE(ret); + + auto drm = static_cast(executionEnvironment.rootDeviceEnvironments[0]->osInterface->get()->getDrm()); + drm->setNewResourceBound(true); + + EXPECT_EQ(directSubmission.getSizeNewResourceHandler(), 0u); + + directSubmission.handleNewResourcesSubmission(); + + HardwareParse hwParse; + hwParse.parsePipeControl = true; + hwParse.parseCommands(directSubmission.ringCommandStream, 0); + hwParse.findHardwareCommands(); + auto *pipeControl = hwParse.getCommand(); + EXPECT_EQ(pipeControl, nullptr); + EXPECT_FALSE(drm->getNewResourceBound()); + + EXPECT_EQ(directSubmission.getSizeNewResourceHandler(), 0u); +} + +HWTEST_F(DrmDirectSubmissionTest, givenBlitterDispatcherWhenHandleNewResourceThenDoNotFlushTlb) { + using MI_FLUSH = typename FamilyType::MI_FLUSH_DW; + using Dispatcher = BlitterDispatcher; + + auto osContext = std::make_unique(*executionEnvironment.rootDeviceEnvironments[0]->osInterface->get()->getDrm(), + 0u, device->getDeviceBitfield(), EngineTypeUsage{aub_stream::ENGINE_BCS, EngineUsage::Regular}, PreemptionMode::ThreadGroup, + false); + MockDrmDirectSubmission directSubmission(*device.get(), + *osContext.get()); + + bool ret = directSubmission.allocateResources(); + EXPECT_TRUE(ret); + + auto drm = static_cast(executionEnvironment.rootDeviceEnvironments[0]->osInterface->get()->getDrm()); + drm->setNewResourceBound(true); + + EXPECT_EQ(directSubmission.getSizeNewResourceHandler(), 0u); + + directSubmission.handleNewResourcesSubmission(); + + HardwareParse hwParse; + hwParse.parsePipeControl = true; + hwParse.parseCommands(directSubmission.ringCommandStream, 0); + hwParse.findHardwareCommands(); + auto *miFlush = hwParse.getCommand(); + EXPECT_EQ(miFlush, nullptr); + EXPECT_TRUE(drm->getNewResourceBound()); + + EXPECT_EQ(directSubmission.getSizeNewResourceHandler(), 0u); +} \ No newline at end of file