Update programming STATE_COMPUTE_MODE

fhazubski-Intel · Compute-Runtime-Automation · commit 0f54a5791060 · 2022-03-07T16:23:59.000+01:00
Remove function clearComputeModePropertiesIfNeeded.
If a field has to be programmed unconditionally, ignore isDirty flag.

Related-To: NEO-6728

Signed-off-by: Filip Hazubski &lt;filip.hazubski@intel.com&gt;
diff --git a/level_zero/core/source/cmdlist/cmdlist_hw.h b/level_zero/core/source/cmdlist/cmdlist_hw.h
@@ -225,7 +225,6 @@ struct CommandListCoreFamily : CommandListImp {
     ze_result_t appendLaunchKernelSplit(ze_kernel_handle_t hKernel, const ze_group_count_t *pThreadGroupDimensions, ze_event_handle_t hEvent);
     ze_result_t prepareIndirectParams(const ze_group_count_t *pThreadGroupDimensions);
     void updateStreamProperties(Kernel &kernel, bool isMultiOsContextCapable, bool isCooperative);
-    virtual void clearComputeModePropertiesIfNeeded(bool requiresCoherency, uint32_t numGrfRequired, uint32_t threadArbitrationPolicy);
     void clearCommandsToPatch();
 
     void applyMemoryRangesBarrier(uint32_t numRanges, const size_t *pRangeSizes,
diff --git a/level_zero/core/source/cmdlist/cmdlist_hw.inl b/level_zero/core/source/cmdlist/cmdlist_hw.inl
@@ -2255,15 +2255,11 @@ void CommandListCoreFamily<gfxCoreFamily>::updateStreamProperties(Kernel &kernel
     finalStreamState.stateComputeMode.setProperties(false, kernelAttributes.numGrfRequired, this->threadArbitrationPolicy);
 
     if (finalStreamState.stateComputeMode.isDirty()) {
-        clearComputeModePropertiesIfNeeded(false, kernelAttributes.numGrfRequired, this->threadArbitrationPolicy);
         NEO::EncodeWA<GfxFamily>::encodeAdditionalPipelineSelect(neoDevice, *commandContainer.getCommandStream(), true);
         NEO::EncodeComputeMode<GfxFamily>::programComputeModeCommand(*commandContainer.getCommandStream(), finalStreamState.stateComputeMode, hwInfo);
         NEO::EncodeWA<GfxFamily>::encodeAdditionalPipelineSelect(neoDevice, *commandContainer.getCommandStream(), false);
     }
 }
-template <GFXCORE_FAMILY gfxCoreFamily>
-void CommandListCoreFamily<gfxCoreFamily>::clearComputeModePropertiesIfNeeded(bool requiresCoherency, uint32_t numGrfRequired, uint32_t threadArbitrationPolicy) {
-}
 
 template <GFXCORE_FAMILY gfxCoreFamily>
 void CommandListCoreFamily<gfxCoreFamily>::clearCommandsToPatch() {
diff --git a/level_zero/core/source/gen12lp/cmdlist_gen12lp.cpp b/level_zero/core/source/gen12lp/cmdlist_gen12lp.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2020-2021 Intel Corporation
+ * Copyright (C) 2020-2022 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -15,11 +15,6 @@
 #include "cmdlist_extended.inl"
 
 namespace L0 {
-template <>
-void CommandListCoreFamily<IGFX_GEN12LP_CORE>::clearComputeModePropertiesIfNeeded(bool requiresCoherency, uint32_t numGrfRequired, uint32_t threadArbitrationPolicy) {
-    finalStreamState.stateComputeMode = {};
-    finalStreamState.stateComputeMode.setProperties(false, numGrfRequired, threadArbitrationPolicy);
-}
 
 template struct CommandListCoreFamily<IGFX_GEN12LP_CORE>;
 template struct CommandListCoreFamilyImmediate<IGFX_GEN12LP_CORE>;
diff --git a/level_zero/core/source/xe_hp_core/cmdlist_xe_hp_core.cpp b/level_zero/core/source/xe_hp_core/cmdlist_xe_hp_core.cpp
@@ -14,11 +14,6 @@
 #include "cmdlist_extended.inl"
 
 namespace L0 {
-template <>
-void CommandListCoreFamily<IGFX_XE_HP_CORE>::clearComputeModePropertiesIfNeeded(bool requiresCoherency, uint32_t numGrfRequired, uint32_t threadArbitrationPolicy) {
-    finalStreamState.stateComputeMode = {};
-    finalStreamState.stateComputeMode.setProperties(requiresCoherency, numGrfRequired, threadArbitrationPolicy);
-}
 
 template struct CommandListCoreFamily<IGFX_XE_HP_CORE>;
 template struct CommandListCoreFamilyImmediate<IGFX_XE_HP_CORE>;
diff --git a/level_zero/core/source/xe_hpg_core/CMakeLists.txt b/level_zero/core/source/xe_hpg_core/CMakeLists.txt
@@ -1,5 +1,5 @@
 #
-# Copyright (C) 2021 Intel Corporation
+# Copyright (C) 2021-2022 Intel Corporation
 #
 # SPDX-License-Identifier: MIT
 #
@@ -9,7 +9,6 @@ if(SUPPORT_XE_HPG_CORE)
       ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
       ${CMAKE_CURRENT_SOURCE_DIR}/cmdlist_xe_hpg_core.cpp
       ${CMAKE_CURRENT_SOURCE_DIR}/cmdlist_xe_hpg_core.h
-      ${CMAKE_CURRENT_SOURCE_DIR}/cmdlist_xe_hpg_core.inl
       ${CMAKE_CURRENT_SOURCE_DIR}/debugger_xe_hpg_core.cpp
       ${CMAKE_CURRENT_SOURCE_DIR}/image_xe_hpg_core.inl
       ${CMAKE_CURRENT_SOURCE_DIR}/sampler_xe_hpg_core.inl
diff --git a/level_zero/core/source/xe_hpg_core/cmdlist_xe_hpg_core.cpp b/level_zero/core/source/xe_hpg_core/cmdlist_xe_hpg_core.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2021 Intel Corporation
+ * Copyright (C) 2021-2022 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -14,11 +14,6 @@
 #include "cmdlist_extended.inl"
 
 namespace L0 {
-template <>
-void CommandListCoreFamily<IGFX_XE_HPG_CORE>::clearComputeModePropertiesIfNeeded(bool requiresCoherency, uint32_t numGrfRequired, uint32_t threadArbitrationPolicy) {
-    finalStreamState.stateComputeMode = {};
-    finalStreamState.stateComputeMode.setProperties(requiresCoherency, numGrfRequired, threadArbitrationPolicy);
-}
 
 template struct CommandListCoreFamily<IGFX_XE_HPG_CORE>;
 template struct CommandListCoreFamilyImmediate<IGFX_XE_HPG_CORE>;
diff --git a/level_zero/core/source/xe_hpg_core/cmdlist_xe_hpg_core.h b/level_zero/core/source/xe_hpg_core/cmdlist_xe_hpg_core.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2021 Intel Corporation
+ * Copyright (C) 2021-2022 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -15,7 +15,6 @@ namespace L0 {
 template <PRODUCT_FAMILY productFamily>
 struct CommandListProductFamily : public CommandListCoreFamily<IGFX_XE_HPG_CORE> {
     using CommandListCoreFamily::CommandListCoreFamily;
-    void clearComputeModePropertiesIfNeeded(bool requiresCoherency, uint32_t numGrfRequired, uint32_t threadArbitrationPolicy) override;
 };
 template <PRODUCT_FAMILY gfxProductFamily>
 struct CommandListImmediateProductFamily : public CommandListCoreFamilyImmediate<IGFX_XE_HPG_CORE> {
diff --git a/level_zero/core/source/xe_hpg_core/cmdlist_xe_hpg_core.inl b/level_zero/core/source/xe_hpg_core/cmdlist_xe_hpg_core.inl
diff --git a/level_zero/core/source/xe_hpg_core/dg2/cmdlist_dg2.cpp b/level_zero/core/source/xe_hpg_core/dg2/cmdlist_dg2.cpp
@@ -1,12 +1,11 @@
 /*
- * Copyright (C) 2021 Intel Corporation
+ * Copyright (C) 2021-2022 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
  */
 
 #include "level_zero/core/source/xe_hpg_core/cmdlist_xe_hpg_core.h"
-#include "level_zero/core/source/xe_hpg_core/cmdlist_xe_hpg_core.inl"
 
 namespace L0 {
 static CommandListPopulateFactory<IGFX_DG2, CommandListProductFamily<IGFX_DG2>>
diff --git a/level_zero/core/test/unit_tests/mocks/mock_cmdlist.h b/level_zero/core/test/unit_tests/mocks/mock_cmdlist.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2020-2021 Intel Corporation
+ * Copyright (C) 2020-2022 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -40,7 +40,6 @@ struct WhiteBox<::L0::CommandListCoreFamily<gfxCoreFamily>>
     using BaseClass::appendWriteKernelTimestamp;
     using BaseClass::applyMemoryRangesBarrier;
     using BaseClass::clearCommandsToPatch;
-    using BaseClass::clearComputeModePropertiesIfNeeded;
     using BaseClass::cmdQImmediate;
     using BaseClass::commandContainer;
     using BaseClass::commandListPerThreadScratchSize;
diff --git a/level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_4.cpp b/level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_4.cpp
@@ -736,31 +736,7 @@ HWTEST2_F(CommandListAppendLaunchKernel, GivenComputeModeTraitsSetToFalsePropert
     const_cast<NEO::KernelDescriptor *>(&kernel.getKernelDescriptor())->kernelAttributes.numGrfRequired = 0x80;
     pCommandList->updateStreamProperties(kernel, false, false);
     EXPECT_TRUE(pCommandList->finalStreamState.stateComputeMode.largeGrfMode.isDirty);
-    EXPECT_TRUE(pCommandList->finalStreamState.stateComputeMode.isCoherencyRequired.isDirty);
-}
-
-struct ForceNonCoherentMode {
-    template <PRODUCT_FAMILY productFamily>
-    static constexpr bool isMatched() {
-        if (productFamily == IGFX_BROADWELL)
-            return false;
-        return TestTraits<NEO::ToGfxCoreFamily<productFamily>::get()>::forceGpuNonCoherent;
-    }
-};
-
-HWTEST2_F(CommandListCreate, GivenComputeModePropertiesWhenClearComputeModePropertiesIfNeededIsCalledThenCoherencyFieldIsSetToFalse, ForceNonCoherentMode) {
-    DebugManagerStateRestore restorer;
-    Mock<::L0::Kernel> kernel;
-    auto pMockModule = std::unique_ptr<Module>(new Mock<Module>(device, nullptr));
-    kernel.module = pMockModule.get();
-    auto commandList = std::make_unique<WhiteBox<::L0::CommandListCoreFamily<gfxCoreFamily>>>();
-    auto result = commandList->initialize(device, NEO::EngineGroupType::Compute, 0u);
-    ASSERT_EQ(ZE_RESULT_SUCCESS, result);
-    const_cast<NEO::KernelDescriptor *>(&kernel.getKernelDescriptor())->kernelAttributes.numGrfRequired = 0x100;
-    commandList->clearComputeModePropertiesIfNeeded(false, 0, 0);
-    EXPECT_EQ(commandList->finalStreamState.stateComputeMode.isCoherencyRequired.value, 0);
-    commandList->clearComputeModePropertiesIfNeeded(true, 0, 0);
-    EXPECT_EQ(commandList->finalStreamState.stateComputeMode.isCoherencyRequired.value, 0);
+    EXPECT_FALSE(pCommandList->finalStreamState.stateComputeMode.isCoherencyRequired.isDirty);
 }
 
 HWTEST2_F(CommandListAppendLaunchKernel, GivenComputeModePropertiesWhenPropertesNotChangedThenAllFieldsAreNotDirty, IsAtLeastSkl) {
diff --git a/level_zero/core/test/unit_tests/xe_hpg_core/test_cmdlist_xe_hpg_core.cpp b/level_zero/core/test/unit_tests/xe_hpg_core/test_cmdlist_xe_hpg_core.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2021 Intel Corporation
+ * Copyright (C) 2021-2022 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -347,7 +347,7 @@ HWTEST2_F(CommandListCreate, GivenComputeModePropertiesWhenUpdateStreamPropertie
     const_cast<NEO::KernelDescriptor *>(&kernel.getKernelDescriptor())->kernelAttributes.numGrfRequired = 0x80;
     pCommandList->updateStreamProperties(kernel, false, false);
     EXPECT_TRUE(pCommandList->finalStreamState.stateComputeMode.largeGrfMode.isDirty);
-    EXPECT_TRUE(pCommandList->finalStreamState.stateComputeMode.isCoherencyRequired.isDirty);
+    EXPECT_FALSE(pCommandList->finalStreamState.stateComputeMode.isCoherencyRequired.isDirty);
 }
 struct ProgramDirtyFieldsInComputeMode {
     template <PRODUCT_FAMILY productFamily>
diff --git a/shared/source/command_container/command_encoder_xehp_and_later.inl b/shared/source/command_container/command_encoder_xehp_and_later.inl
@@ -514,17 +514,13 @@ void EncodeComputeMode<Family>::programComputeModeCommand(LinearStream &csr, Sta
     STATE_COMPUTE_MODE stateComputeMode = Family::cmdInitStateComputeMode;
     auto maskBits = stateComputeMode.getMaskBits();
 
-    if (properties.isCoherencyRequired.isDirty) {
-        FORCE_NON_COHERENT coherencyValue = !properties.isCoherencyRequired.value ? FORCE_NON_COHERENT::FORCE_NON_COHERENT_FORCE_GPU_NON_COHERENT
-                                                                                  : FORCE_NON_COHERENT::FORCE_NON_COHERENT_FORCE_DISABLED;
-        stateComputeMode.setForceNonCoherent(coherencyValue);
-        maskBits |= Family::stateComputeModeForceNonCoherentMask;
-    }
+    FORCE_NON_COHERENT coherencyValue = (properties.isCoherencyRequired.value == 1) ? FORCE_NON_COHERENT::FORCE_NON_COHERENT_FORCE_DISABLED
+                                                                                    : FORCE_NON_COHERENT::FORCE_NON_COHERENT_FORCE_GPU_NON_COHERENT;
+    stateComputeMode.setForceNonCoherent(coherencyValue);
+    maskBits |= Family::stateComputeModeForceNonCoherentMask;
 
-    if (properties.largeGrfMode.isDirty) {
-        stateComputeMode.setLargeGrfMode(properties.largeGrfMode.value);
-        maskBits |= Family::stateComputeModeLargeGrfModeMask;
-    }
+    stateComputeMode.setLargeGrfMode(properties.largeGrfMode.value == 1);
+    maskBits |= Family::stateComputeModeLargeGrfModeMask;
 
     if (DebugManager.flags.ForceMultiGpuAtomics.get() != -1) {
         stateComputeMode.setForceDisableSupportForMultiGpuAtomics(!!DebugManager.flags.ForceMultiGpuAtomics.get());
diff --git a/shared/source/gen12lp/command_encoder_gen12lp.cpp b/shared/source/gen12lp/command_encoder_gen12lp.cpp
@@ -40,12 +40,10 @@ void EncodeComputeMode<Family>::programComputeModeCommand(LinearStream &csr, Sta
     STATE_COMPUTE_MODE stateComputeMode = Family::cmdInitStateComputeMode;
     auto maskBits = stateComputeMode.getMaskBits();
 
-    if (properties.isCoherencyRequired.isDirty) {
-        FORCE_NON_COHERENT coherencyValue = !properties.isCoherencyRequired.value ? FORCE_NON_COHERENT::FORCE_NON_COHERENT_FORCE_GPU_NON_COHERENT
-                                                                                  : FORCE_NON_COHERENT::FORCE_NON_COHERENT_FORCE_DISABLED;
-        stateComputeMode.setForceNonCoherent(coherencyValue);
-        maskBits |= Family::stateComputeModeForceNonCoherentMask;
-    }
+    FORCE_NON_COHERENT coherencyValue = (properties.isCoherencyRequired.value == 1) ? FORCE_NON_COHERENT::FORCE_NON_COHERENT_FORCE_DISABLED
+                                                                                    : FORCE_NON_COHERENT::FORCE_NON_COHERENT_FORCE_GPU_NON_COHERENT;
+    stateComputeMode.setForceNonCoherent(coherencyValue);
+    maskBits |= Family::stateComputeModeForceNonCoherentMask;
 
     stateComputeMode.setMaskBits(maskBits);
 
diff --git a/shared/source/os_interface/hw_info_config.h b/shared/source/os_interface/hw_info_config.h
@@ -85,6 +85,7 @@ class HwInfoConfig {
     virtual uint32_t computeMaxNeededSubSliceSpace(const HardwareInfo &hwInfo) const = 0;
     virtual bool getUuid(Device *device, std::array<uint8_t, HwInfoConfig::uuidSize> &uuid) const = 0;
     virtual bool isFlushTaskAllowed() const = 0;
+    virtual bool programAllStateComputeCommandFields() const = 0;
     MOCKABLE_VIRTUAL ~HwInfoConfig() = default;
 
   protected:
@@ -154,6 +155,7 @@ class HwInfoConfigHw : public HwInfoConfig {
     uint32_t computeMaxNeededSubSliceSpace(const HardwareInfo &hwInfo) const override;
     bool getUuid(Device *device, std::array<uint8_t, HwInfoConfig::uuidSize> &uuid) const override;
     bool isFlushTaskAllowed() const override;
+    bool programAllStateComputeCommandFields() const override;
 
   protected:
     HwInfoConfigHw() = default;
diff --git a/shared/source/os_interface/hw_info_config.inl b/shared/source/os_interface/hw_info_config.inl
@@ -292,4 +292,10 @@ template <PRODUCT_FAMILY gfxProduct>
 bool HwInfoConfigHw<gfxProduct>::isFlushTaskAllowed() const {
     return false;
 }
+
+template <PRODUCT_FAMILY gfxProduct>
+bool HwInfoConfigHw<gfxProduct>::programAllStateComputeCommandFields() const {
+    return false;
+}
+
 } // namespace NEO
diff --git a/shared/source/xe_hpg_core/command_encoder_xe_hpg_core.cpp b/shared/source/xe_hpg_core/command_encoder_xe_hpg_core.cpp
@@ -127,25 +127,32 @@ void EncodeComputeMode<Family>::programComputeModeCommand(LinearStream &csr, Sta
     STATE_COMPUTE_MODE stateComputeMode = Family::cmdInitStateComputeMode;
     auto maskBits = stateComputeMode.getMaskBits();
 
-    if (properties.zPassAsyncComputeThreadLimit.isDirty) {
+    auto &hwInfoConfig = *HwInfoConfig::get(hwInfo.platform.eProductFamily);
+    bool ignoreIsDirty = hwInfoConfig.programAllStateComputeCommandFields();
+
+    if (properties.zPassAsyncComputeThreadLimit.isDirty ||
+        (ignoreIsDirty && (properties.zPassAsyncComputeThreadLimit.value != -1))) {
         auto limitValue = static_cast<Z_PASS_ASYNC_COMPUTE_THREAD_LIMIT>(properties.zPassAsyncComputeThreadLimit.value);
         stateComputeMode.setZPassAsyncComputeThreadLimit(limitValue);
         maskBits |= Family::stateComputeModeZPassAsyncComputeThreadLimitMask;
     }
 
-    if (properties.pixelAsyncComputeThreadLimit.isDirty) {
+    if (properties.pixelAsyncComputeThreadLimit.isDirty ||
+        (ignoreIsDirty && (properties.pixelAsyncComputeThreadLimit.value != -1))) {
         auto limitValue = static_cast<PIXEL_ASYNC_COMPUTE_THREAD_LIMIT>(properties.pixelAsyncComputeThreadLimit.value);
         stateComputeMode.setPixelAsyncComputeThreadLimit(limitValue);
         maskBits |= Family::stateComputeModePixelAsyncComputeThreadLimitMask;
     }
 
-    if (properties.largeGrfMode.isDirty) {
-        stateComputeMode.setLargeGrfMode(properties.largeGrfMode.value);
+    if (properties.largeGrfMode.isDirty || ignoreIsDirty) {
+        stateComputeMode.setLargeGrfMode(properties.largeGrfMode.value == 1);
         maskBits |= Family::stateComputeModeLargeGrfModeMask;
     }
 
     stateComputeMode.setMaskBits(maskBits);
 
+    hwInfoConfig.setForceNonCoherent(&stateComputeMode, properties);
+
     HwInfoConfig::get(hwInfo.platform.eProductFamily)->setForceNonCoherent(&stateComputeMode, properties);
 
     auto buffer = csr.getSpaceForCmd<STATE_COMPUTE_MODE>();
diff --git a/shared/source/xe_hpg_core/os_agnostic_hw_info_config_dg2.inl b/shared/source/xe_hpg_core/os_agnostic_hw_info_config_dg2.inl
@@ -73,16 +73,14 @@ void HwInfoConfigHw<gfxProduct>::setForceNonCoherent(void *const statePtr, const
     using STATE_COMPUTE_MODE = typename XE_HPG_COREFamily::STATE_COMPUTE_MODE;
     using FORCE_NON_COHERENT = typename STATE_COMPUTE_MODE::FORCE_NON_COHERENT;
 
-    if (properties.isCoherencyRequired.isDirty) {
-        STATE_COMPUTE_MODE &stateComputeMode = *static_cast<STATE_COMPUTE_MODE *>(statePtr);
-        FORCE_NON_COHERENT coherencyValue = !properties.isCoherencyRequired.value ? FORCE_NON_COHERENT::FORCE_NON_COHERENT_FORCE_GPU_NON_COHERENT
-                                                                                  : FORCE_NON_COHERENT::FORCE_NON_COHERENT_FORCE_DISABLED;
-        stateComputeMode.setForceNonCoherent(coherencyValue);
-
-        auto mask = stateComputeMode.getMaskBits();
-        mask |= XE_HPG_COREFamily::stateComputeModeForceNonCoherentMask;
-        stateComputeMode.setMaskBits(mask);
-    }
+    STATE_COMPUTE_MODE &stateComputeMode = *static_cast<STATE_COMPUTE_MODE *>(statePtr);
+    FORCE_NON_COHERENT coherencyValue = (properties.isCoherencyRequired.value == 1) ? FORCE_NON_COHERENT::FORCE_NON_COHERENT_FORCE_DISABLED
+                                                                                    : FORCE_NON_COHERENT::FORCE_NON_COHERENT_FORCE_GPU_NON_COHERENT;
+    stateComputeMode.setForceNonCoherent(coherencyValue);
+
+    auto mask = stateComputeMode.getMaskBits();
+    mask |= XE_HPG_COREFamily::stateComputeModeForceNonCoherentMask;
+    stateComputeMode.setMaskBits(mask);
 }
 
 template <>
@@ -172,3 +170,8 @@ template <>
 bool HwInfoConfigHw<gfxProduct>::isFlushTaskAllowed() const {
     return true;
 }
+
+template <>
+bool HwInfoConfigHw<gfxProduct>::programAllStateComputeCommandFields() const {
+    return true;
+}
diff --git a/shared/test/common/gen12lp/test_encode_gen12lp.cpp b/shared/test/common/gen12lp/test_encode_gen12lp.cpp
@@ -25,20 +25,13 @@ GEN12LPTEST_F(CommandEncodeGen12LpTest, whenProgrammingStateComputeModeThenPrope
     auto pLinearStream = std::make_unique<LinearStream>(buffer, sizeof(buffer));
     EncodeComputeMode<FamilyType>::programComputeModeCommand(*pLinearStream, properties, *defaultHwInfo);
     auto pScm = reinterpret_cast<STATE_COMPUTE_MODE *>(pLinearStream->getCpuBase());
-    EXPECT_EQ(0u, pScm->getMaskBits());
-    EXPECT_EQ(STATE_COMPUTE_MODE::FORCE_NON_COHERENT_FORCE_DISABLED, pScm->getForceNonCoherent());
-
-    properties.isCoherencyRequired.value = 0;
-    pLinearStream = std::make_unique<LinearStream>(buffer, sizeof(buffer));
-    EncodeComputeMode<FamilyType>::programComputeModeCommand(*pLinearStream, properties, *defaultHwInfo);
-    pScm = reinterpret_cast<STATE_COMPUTE_MODE *>(pLinearStream->getCpuBase());
-    EXPECT_EQ(0u, pScm->getMaskBits());
-    EXPECT_EQ(STATE_COMPUTE_MODE::FORCE_NON_COHERENT_FORCE_DISABLED, pScm->getForceNonCoherent());
+    EXPECT_EQ(FamilyType::stateComputeModeForceNonCoherentMask, pScm->getMaskBits());
+    EXPECT_EQ(STATE_COMPUTE_MODE::FORCE_NON_COHERENT_FORCE_GPU_NON_COHERENT, pScm->getForceNonCoherent());
 
-    properties.isCoherencyRequired.isDirty = true;
+    properties.isCoherencyRequired.value = 1;
     pLinearStream = std::make_unique<LinearStream>(buffer, sizeof(buffer));
     EncodeComputeMode<FamilyType>::programComputeModeCommand(*pLinearStream, properties, *defaultHwInfo);
     pScm = reinterpret_cast<STATE_COMPUTE_MODE *>(pLinearStream->getCpuBase());
     EXPECT_EQ(FamilyType::stateComputeModeForceNonCoherentMask, pScm->getMaskBits());
-    EXPECT_EQ(STATE_COMPUTE_MODE::FORCE_NON_COHERENT_FORCE_GPU_NON_COHERENT, pScm->getForceNonCoherent());
+    EXPECT_EQ(STATE_COMPUTE_MODE::FORCE_NON_COHERENT_FORCE_DISABLED, pScm->getForceNonCoherent());
 }
diff --git a/shared/test/common/mocks/mock_hw_info_config.cpp b/shared/test/common/mocks/mock_hw_info_config.cpp
@@ -282,4 +282,9 @@ bool HwInfoConfigHw<IGFX_UNKNOWN>::isFlushTaskAllowed() const {
     return false;
 }
 
+template <>
+bool HwInfoConfigHw<IGFX_UNKNOWN>::programAllStateComputeCommandFields() const {
+    return false;
+}
+
 } //namespace NEO
diff --git a/shared/test/common/xe_hp_core/test_encode_xe_hp_core.cpp b/shared/test/common/xe_hp_core/test_encode_xe_hp_core.cpp
diff --git a/shared/test/common/xe_hpg_core/dg2/test_encode_dg2.cpp b/shared/test/common/xe_hpg_core/dg2/test_encode_dg2.cpp
diff --git a/shared/test/unit_test/encoders/test_encode_grf_mode_xe_hp_and_later.cpp b/shared/test/unit_test/encoders/test_encode_grf_mode_xe_hp_and_later.cpp

Original file line number	Diff line number	Diff line change
`@@ -2255,15 +2255,11 @@ void CommandListCoreFamily<gfxCoreFamily>::updateStreamProperties(Kernel &kernel`
`2255`	`2255`	`finalStreamState.stateComputeMode.setProperties(false, kernelAttributes.numGrfRequired, this->threadArbitrationPolicy);`
`2256`	`2256`
`2257`	`2257`	`if (finalStreamState.stateComputeMode.isDirty()) {`
`2258`		`- clearComputeModePropertiesIfNeeded(false, kernelAttributes.numGrfRequired, this->threadArbitrationPolicy);`
`2259`	`2258`	`NEO::EncodeWA<GfxFamily>::encodeAdditionalPipelineSelect(neoDevice, *commandContainer.getCommandStream(), true);`
`2260`	`2259`	`NEO::EncodeComputeMode<GfxFamily>::programComputeModeCommand(*commandContainer.getCommandStream(), finalStreamState.stateComputeMode, hwInfo);`
`2261`	`2260`	`NEO::EncodeWA<GfxFamily>::encodeAdditionalPipelineSelect(neoDevice, *commandContainer.getCommandStream(), false);`
`2262`	`2261`	`}`
`2263`	`2262`	`}`
`2264`		`-template <GFXCORE_FAMILY gfxCoreFamily>`
`2265`		`-void CommandListCoreFamily<gfxCoreFamily>::clearComputeModePropertiesIfNeeded(bool requiresCoherency, uint32_t numGrfRequired, uint32_t threadArbitrationPolicy) {`
`2266`		`-}`
`2267`	`2263`
`2268`	`2264`	`template <GFXCORE_FAMILY gfxCoreFamily>`
`2269`	`2265`	`void CommandListCoreFamily<gfxCoreFamily>::clearCommandsToPatch() {`
Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,5 @@`
`1`	`1`	`#`
`2`		`-# Copyright (C) 2021 Intel Corporation`
	`2`	`+# Copyright (C) 2021-2022 Intel Corporation`
`3`	`3`	`#`
`4`	`4`	`# SPDX-License-Identifier: MIT`
`5`	`5`	`#`
`@@ -9,7 +9,6 @@ if(SUPPORT_XE_HPG_CORE)`
`9`	`9`	`${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt`
`10`	`10`	`${CMAKE_CURRENT_SOURCE_DIR}/cmdlist_xe_hpg_core.cpp`
`11`	`11`	`${CMAKE_CURRENT_SOURCE_DIR}/cmdlist_xe_hpg_core.h`
`12`		`- ${CMAKE_CURRENT_SOURCE_DIR}/cmdlist_xe_hpg_core.inl`
`13`	`12`	`${CMAKE_CURRENT_SOURCE_DIR}/debugger_xe_hpg_core.cpp`
`14`	`13`	`${CMAKE_CURRENT_SOURCE_DIR}/image_xe_hpg_core.inl`
`15`	`14`	`${CMAKE_CURRENT_SOURCE_DIR}/sampler_xe_hpg_core.inl`
Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,5 @@`
`1`	`1`	`/*`
`2`		`- * Copyright (C) 2021 Intel Corporation`
	`2`	`+ * Copyright (C) 2021-2022 Intel Corporation`
`3`	`3`	`*`
`4`	`4`	`* SPDX-License-Identifier: MIT`
`5`	`5`	`*`
`@@ -15,7 +15,6 @@ namespace L0 {`
`15`	`15`	`template <PRODUCT_FAMILY productFamily>`
`16`	`16`	`struct CommandListProductFamily : public CommandListCoreFamily<IGFX_XE_HPG_CORE> {`
`17`	`17`	`using CommandListCoreFamily::CommandListCoreFamily;`
`18`		`- void clearComputeModePropertiesIfNeeded(bool requiresCoherency, uint32_t numGrfRequired, uint32_t threadArbitrationPolicy) override;`
`19`	`18`	`};`
`20`	`19`	`template <PRODUCT_FAMILY gfxProductFamily>`
`21`	`20`	`struct CommandListImmediateProductFamily : public CommandListCoreFamilyImmediate<IGFX_XE_HPG_CORE> {`
Original file line number	Diff line number	Diff line change
`@@ -1,12 +1,11 @@`
`1`	`1`	`/*`
`2`		`- * Copyright (C) 2021 Intel Corporation`
	`2`	`+ * Copyright (C) 2021-2022 Intel Corporation`
`3`	`3`	`*`
`4`	`4`	`* SPDX-License-Identifier: MIT`
`5`	`5`	`*`
`6`	`6`	`*/`
`7`	`7`
`8`	`8`	`#include "level_zero/core/source/xe_hpg_core/cmdlist_xe_hpg_core.h"`
`9`		`-#include "level_zero/core/source/xe_hpg_core/cmdlist_xe_hpg_core.inl"`
`10`	`9`
`11`	`10`	`namespace L0 {`
`12`	`11`	`static CommandListPopulateFactory<IGFX_DG2, CommandListProductFamily<IGFX_DG2>>`
Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,5 @@`
`1`	`1`	`/*`
`2`		`- * Copyright (C) 2020-2021 Intel Corporation`
	`2`	`+ * Copyright (C) 2020-2022 Intel Corporation`
`3`	`3`	`*`
`4`	`4`	`* SPDX-License-Identifier: MIT`
`5`	`5`	`*`
`@@ -40,7 +40,6 @@ struct WhiteBox<::L0::CommandListCoreFamily<gfxCoreFamily>>`
`40`	`40`	`using BaseClass::appendWriteKernelTimestamp;`
`41`	`41`	`using BaseClass::applyMemoryRangesBarrier;`
`42`	`42`	`using BaseClass::clearCommandsToPatch;`
`43`		`- using BaseClass::clearComputeModePropertiesIfNeeded;`
`44`	`43`	`using BaseClass::cmdQImmediate;`
`45`	`44`	`using BaseClass::commandContainer;`
`46`	`45`	`using BaseClass::commandListPerThreadScratchSize;`