Move compute mode tests from opencl to shared

Signed-off-by: Mateusz Jablonski <mateusz.jablonski@intel.com>

shared/test/common/xe_hpc_core/excludes_xe_hpc_core.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2021 Intel Corporation
+ * Copyright (C) 2021-2022 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -12,3 +12,12 @@ HWTEST_EXCLUDE_PRODUCT(CommandEncodeStatesTest, givenOverrideSlmTotalSizeDebugVa
 HWTEST_EXCLUDE_PRODUCT(WalkerPartitionTests, givenMiAtomicWhenItIsProgrammedThenAllFieldsAreSetCorrectly, IGFX_XE_HPC_CORE);
 HWTEST_EXCLUDE_PRODUCT(WalkerPartitionTests, givenProgramBatchBufferStartCommandWhenItIsCalledThenCommandIsProgrammedCorrectly, IGFX_XE_HPC_CORE);
 HWTEST_EXCLUDE_PRODUCT(XeHPAndLaterPreemptionTests, GivenDebuggerUsedWhenProgrammingStateSipThenStateSipIsAdded, IGFX_XE_HPC_CORE);
+HWTEST_EXCLUDE_PRODUCT(ComputeModeRequirements, givenComputeModeProgrammingWhenLargeGrfModeDoesntChangeThenSCMIsNotAdded, IGFX_XE_HPC_CORE);
+HWTEST_EXCLUDE_PRODUCT(ComputeModeRequirements, givenCoherencyWithoutSharedHandlesWhenCommandSizeIsCalculatedThenCorrectCommandSizeIsReturned, IGFX_XE_HPC_CORE);
+HWTEST_EXCLUDE_PRODUCT(ComputeModeRequirements, givenCoherencyWithSharedHandlesWhenCommandSizeIsCalculatedThenCorrectCommandSizeIsReturned, IGFX_XE_HPC_CORE);
+HWTEST_EXCLUDE_PRODUCT(ComputeModeRequirements, givenCoherencyWithoutSharedHandlesWhenComputeModeIsProgrammedThenCorrectCommandsAreAdded_ForceNonCoherentSupportedMatcher, IGFX_XE_HPC_CORE);
+HWTEST_EXCLUDE_PRODUCT(ComputeModeRequirements, givenCoherencyWithSharedHandlesWhenComputeModeIsProgrammedThenCorrectCommandsAreAdded_ForceNonCoherentSupportedMatcher, IGFX_XE_HPC_CORE);
+HWTEST_EXCLUDE_PRODUCT(ComputeModeRequirements, givenComputeModeCmdSizeWhenLargeGrfModeChangeIsRequiredThenSCMCommandSizeIsCalculated, IGFX_XE_HPC_CORE);
+HWTEST_EXCLUDE_PRODUCT(ComputeModeRequirements, givenComputeModeProgrammingWhenLargeGrfModeChangeIsRequiredThenCorrectCommandsAreAdded_ForceNonCoherentSupportedMatcher, IGFX_XE_HPC_CORE);
+HWTEST_EXCLUDE_PRODUCT(ComputeModeRequirements, givenComputeModeProgrammingWhenRequiredGRFNumberIsLowerThan128ThenSmallGRFModeIsProgrammed_ForceNonCoherentSupportedMatcher, IGFX_XE_HPC_CORE);
+HWTEST_EXCLUDE_PRODUCT(ComputeModeRequirements, givenComputeModeProgrammingWhenRequiredGRFNumberIsGreaterThan128ThenLargeGRFModeIsProgrammed_ForceNonCoherentSupportedMatcher, IGFX_XE_HPC_CORE);

shared/test/unit_test/command_stream/CMakeLists.txt

@@ -1,5 +1,5 @@
 #
-# Copyright (C) 2021 Intel Corporation
+# Copyright (C) 2021-2022 Intel Corporation
 #
 # SPDX-License-Identifier: MIT
 #
@@ -13,6 +13,7 @@ set(NEO_SHARED_tests_command_stream
     ${CMAKE_CURRENT_SOURCE_DIR}/aub_subcapture_tests.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/command_stream_receiver_simulated_tests.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/command_stream_receiver_tests.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/compute_mode_tests.h
     ${CMAKE_CURRENT_SOURCE_DIR}/linear_stream_tests.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}${BRANCH_DIR_SUFFIX}stream_properties_tests.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/stream_properties_tests_common.cpp
@@ -25,10 +26,17 @@ if(TESTS_XEHP_AND_LATER)
   list(APPEND NEO_SHARED_tests_command_stream
        ${CMAKE_CURRENT_SOURCE_DIR}/aub_command_stream_receiver_tests_xehp_and_later.cpp
        ${CMAKE_CURRENT_SOURCE_DIR}/command_stream_receiver_simulated_common_hw_tests_xehp_and_later.cpp
+       ${CMAKE_CURRENT_SOURCE_DIR}/compute_mode_tests_xehp_and_later.cpp
        ${CMAKE_CURRENT_SOURCE_DIR}/tbx_command_stream_receiver_tests_xehp_and_later.cpp
   )
 endif()
 
+if(TESTS_PVC_AND_LATER)
+  list(APPEND NEO_SHARED_tests_command_stream
+       ${CMAKE_CURRENT_SOURCE_DIR}/compute_mode_tests_pvc_and_later.cpp
+  )
+endif()
+
 target_sources(${TARGET_NAME} PRIVATE ${NEO_SHARED_tests_command_stream})
 
 add_subdirectories()

shared/test/unit_test/command_stream/compute_mode_tests.h

@@ -0,0 +1,94 @@
+/*
+ * Copyright (C) 2019-2022 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#pragma once
+#include "shared/source/command_stream/command_stream_receiver_hw.h"
+#include "shared/source/helpers/hw_helper.h"
+#include "shared/test/common/cmd_parse/hw_parse.h"
+#include "shared/test/common/libult/ult_command_stream_receiver.h"
+#include "shared/test/common/mocks/mock_device.h"
+#include "shared/test/common/test_macros/test.h"
+
+using namespace NEO;
+
+struct ComputeModeRequirements : public ::testing::Test {
+    template <typename FamilyType>
+    struct myCsr : public UltCommandStreamReceiver<FamilyType> {
+        using CommandStreamReceiver::commandStream;
+        using CommandStreamReceiver::streamProperties;
+        myCsr(ExecutionEnvironment &executionEnvironment, const DeviceBitfield deviceBitfield)
+            : UltCommandStreamReceiver<FamilyType>(executionEnvironment, 0, deviceBitfield){};
+        CsrSizeRequestFlags *getCsrRequestFlags() { return &this->csrSizeRequestFlags; }
+    };
+    void makeResidentSharedAlloc() {
+        csr->getResidencyAllocations().push_back(alloc);
+    }
+
+    template <typename FamilyType>
+    void overrideComputeModeRequest(bool reqestChanged, bool requireCoherency, bool hasSharedHandles,
+                                    bool modifyThreadArbitrationPolicy = false, bool numGrfRequiredChanged = false,
+                                    uint32_t numGrfRequired = 128u) {
+        overrideComputeModeRequest<FamilyType>(reqestChanged, requireCoherency, hasSharedHandles, numGrfRequiredChanged, numGrfRequired);
+        if (modifyThreadArbitrationPolicy) {
+            auto &hwHelper = NEO::HwHelper::get(device->getHardwareInfo().platform.eRenderCoreFamily);
+            auto csrHw = getCsrHw<FamilyType>();
+            csrHw->streamProperties.stateComputeMode.threadArbitrationPolicy.value = hwHelper.getDefaultThreadArbitrationPolicy();
+            csrHw->streamProperties.stateComputeMode.threadArbitrationPolicy.isDirty = true;
+        }
+    }
+
+    template <typename FamilyType>
+    void overrideComputeModeRequest(bool coherencyRequestChanged,
+                                    bool requireCoherency,
+                                    bool hasSharedHandles,
+                                    bool numGrfRequiredChanged,
+                                    uint32_t numGrfRequired) {
+        auto csrHw = getCsrHw<FamilyType>();
+        csrHw->getCsrRequestFlags()->hasSharedHandles = hasSharedHandles;
+        csrHw->getCsrRequestFlags()->numGrfRequiredChanged = numGrfRequiredChanged;
+        flags.requiresCoherency = requireCoherency;
+        flags.numGrfRequired = numGrfRequired;
+        csrHw->streamProperties.stateComputeMode.isCoherencyRequired.value = requireCoherency;
+        csrHw->streamProperties.stateComputeMode.isCoherencyRequired.isDirty = coherencyRequestChanged;
+        csrHw->streamProperties.stateComputeMode.largeGrfMode.value = (numGrfRequired == GrfConfig::LargeGrfNumber);
+        csrHw->streamProperties.stateComputeMode.largeGrfMode.isDirty = numGrfRequiredChanged;
+        if (hasSharedHandles) {
+            makeResidentSharedAlloc();
+        }
+    }
+
+    template <typename FamilyType>
+    myCsr<FamilyType> *getCsrHw() {
+        return static_cast<myCsr<FamilyType> *>(csr);
+    }
+
+    template <typename FamilyType>
+    void SetUpImpl() {
+        SetUpImpl<FamilyType>(defaultHwInfo.get());
+    }
+
+    template <typename FamilyType>
+    void SetUpImpl(const NEO::HardwareInfo *hardwareInfo) {
+        device.reset(MockDevice::createWithNewExecutionEnvironment<MockDevice>(hardwareInfo));
+        device->executionEnvironment->rootDeviceEnvironments[0]->setHwInfo(hardwareInfo);
+        csr = new myCsr<FamilyType>(*device->executionEnvironment, device->getDeviceBitfield());
+
+        device->resetCommandStreamReceiver(csr);
+        AllocationProperties properties(device->getRootDeviceIndex(), false, MemoryConstants::pageSize, GraphicsAllocation::AllocationType::SHARED_BUFFER, false, {});
+
+        alloc = device->getMemoryManager()->createGraphicsAllocationFromSharedHandle(static_cast<osHandle>(123), properties, false, false);
+    }
+
+    void TearDown() override {
+        device->getMemoryManager()->freeGraphicsMemory(alloc);
+    }
+
+    CommandStreamReceiver *csr = nullptr;
+    std::unique_ptr<MockDevice> device;
+    DispatchFlags flags{{}, nullptr, {}, nullptr, QueueThrottle::MEDIUM, PreemptionMode::Disabled, GrfConfig::DefaultGrfNumber, L3CachingSettings::l3CacheOn, ThreadArbitrationPolicy::NotPresent, AdditionalKernelExecInfo::NotApplicable, KernelExecutionType::NotApplicable, MemoryCompressionState::NotApplicable, QueueSliceCount::defaultSliceCount, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false};
+    GraphicsAllocation *alloc = nullptr;
+};

shared/test/unit_test/command_stream/compute_mode_tests_pvc_and_later.cpp

@@ -0,0 +1,32 @@
+/*
+ * Copyright (C) 2021-2022 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#include "shared/test/unit_test/command_stream/compute_mode_tests.h"
+
+using namespace NEO;
+
+using ComputeModeRequirementsPvcAndLater = ComputeModeRequirements;
+
+HWTEST2_F(ComputeModeRequirementsPvcAndLater, givenComputeModeCmdSizeWhenLargeGrfModeChangeIsRequiredThenSCMAndPcCommandsSizeIsCalculated, IsXeHpcCore) {
+    SetUpImpl<FamilyType>();
+    using STATE_COMPUTE_MODE = typename FamilyType::STATE_COMPUTE_MODE;
+    using PIPE_CONTROL = typename FamilyType::PIPE_CONTROL;
+
+    auto cmdSize = sizeof(STATE_COMPUTE_MODE) + sizeof(PIPE_CONTROL);
+
+    overrideComputeModeRequest<FamilyType>(false, false, false, false, 128u);
+    auto retSize = getCsrHw<FamilyType>()->getCmdSizeForComputeMode();
+    EXPECT_EQ(0u, retSize);
+
+    overrideComputeModeRequest<FamilyType>(false, false, false, true, 256u);
+    retSize = getCsrHw<FamilyType>()->getCmdSizeForComputeMode();
+    EXPECT_EQ(cmdSize, retSize);
+
+    overrideComputeModeRequest<FamilyType>(true, false, false, true, 256u);
+    retSize = getCsrHw<FamilyType>()->getCmdSizeForComputeMode();
+    EXPECT_EQ(cmdSize, retSize);
+}

shared/test/unit_test/command_stream/compute_mode_tests_xehp_and_later.cpp

@@ -0,0 +1,407 @@
+/*
+ * Copyright (C) 2021-2022 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#include "shared/source/helpers/ptr_math.h"
+#include "shared/test/common/helpers/debug_manager_state_restore.h"
+#include "shared/test/common/helpers/unit_test_helper.h"
+#include "shared/test/common/mocks/mock_allocation_properties.h"
+#include "shared/test/common/mocks/mock_device.h"
+#include "shared/test/common/test_macros/test.h"
+#include "shared/test/unit_test/command_stream/compute_mode_tests.h"
+
+#include "test_traits_common.h"
+
+using namespace NEO;
+
+HWCMDTEST_F(IGFX_XE_HP_CORE, ComputeModeRequirements, givenCoherencyWithoutSharedHandlesWhenCommandSizeIsCalculatedThenCorrectCommandSizeIsReturned) {
+    using STATE_COMPUTE_MODE = typename FamilyType::STATE_COMPUTE_MODE;
+    SetUpImpl<FamilyType>();
+
+    auto cmdsSize = sizeof(STATE_COMPUTE_MODE);
+
+    overrideComputeModeRequest<FamilyType>(false, false, false);
+    auto retSize = getCsrHw<FamilyType>()->getCmdSizeForComputeMode();
+    EXPECT_EQ(0u, retSize);
+
+    overrideComputeModeRequest<FamilyType>(false, true, false);
+    retSize = getCsrHw<FamilyType>()->getCmdSizeForComputeMode();
+    EXPECT_EQ(0u, retSize);
+
+    overrideComputeModeRequest<FamilyType>(true, true, false);
+    retSize = getCsrHw<FamilyType>()->getCmdSizeForComputeMode();
+    EXPECT_EQ(cmdsSize, retSize);
+
+    overrideComputeModeRequest<FamilyType>(true, false, false);
+    retSize = getCsrHw<FamilyType>()->getCmdSizeForComputeMode();
+    EXPECT_EQ(cmdsSize, retSize);
+}
+
+HWCMDTEST_F(IGFX_XE_HP_CORE, ComputeModeRequirements, givenCoherencyWithSharedHandlesWhenCommandSizeIsCalculatedThenCorrectCommandSizeIsReturned) {
+    SetUpImpl<FamilyType>();
+    using STATE_COMPUTE_MODE = typename FamilyType::STATE_COMPUTE_MODE;
+    using PIPE_CONTROL = typename FamilyType::PIPE_CONTROL;
+
+    auto cmdsSize = 0u;
+
+    overrideComputeModeRequest<FamilyType>(false, false, true);
+    auto retSize = getCsrHw<FamilyType>()->getCmdSizeForComputeMode();
+    EXPECT_EQ(cmdsSize, retSize);
+
+    overrideComputeModeRequest<FamilyType>(false, true, true);
+    retSize = getCsrHw<FamilyType>()->getCmdSizeForComputeMode();
+    EXPECT_EQ(cmdsSize, retSize);
+
+    cmdsSize = sizeof(STATE_COMPUTE_MODE) + sizeof(PIPE_CONTROL);
+
+    overrideComputeModeRequest<FamilyType>(true, true, true);
+    retSize = getCsrHw<FamilyType>()->getCmdSizeForComputeMode();
+    EXPECT_EQ(cmdsSize, retSize);
+
+    overrideComputeModeRequest<FamilyType>(true, false, true);
+    retSize = getCsrHw<FamilyType>()->getCmdSizeForComputeMode();
+    EXPECT_EQ(cmdsSize, retSize);
+}
+
+struct ForceNonCoherentSupportedMatcher {
+    template <PRODUCT_FAMILY productFamily>
+    static constexpr bool isMatched() {
+        if constexpr (HwMapper<productFamily>::GfxProduct::supportsCmdSet(IGFX_XE_HP_CORE)) {
+            return TestTraits<NEO::ToGfxCoreFamily<productFamily>::get()>::forceNonCoherentSupported;
+        }
+        return false;
+    }
+};
+
+HWTEST2_F(ComputeModeRequirements, givenCoherencyWithoutSharedHandlesWhenComputeModeIsProgrammedThenCorrectCommandsAreAdded, ForceNonCoherentSupportedMatcher) {
+    SetUpImpl<FamilyType>();
+    using STATE_COMPUTE_MODE = typename FamilyType::STATE_COMPUTE_MODE;
+
+    auto cmdsSize = sizeof(STATE_COMPUTE_MODE);
+    char buff[1024] = {0};
+    LinearStream stream(buff, 1024);
+
+    auto expectedScmCmd = FamilyType::cmdInitStateComputeMode;
+    expectedScmCmd.setForceNonCoherent(STATE_COMPUTE_MODE::FORCE_NON_COHERENT_FORCE_GPU_NON_COHERENT);
+    auto expectedBitsMask = FamilyType::stateComputeModeForceNonCoherentMask | FamilyType::stateComputeModeLargeGrfModeMask;
+
+    overrideComputeModeRequest<FamilyType>(true, false, false, false, true);
+    getCsrHw<FamilyType>()->programComputeMode(stream, flags, *defaultHwInfo);
+    EXPECT_EQ(cmdsSize, stream.getUsed());
+
+    auto scmCmd = reinterpret_cast<STATE_COMPUTE_MODE *>(stream.getCpuBase());
+    EXPECT_TRUE(isValueSet(scmCmd->getMaskBits(), expectedBitsMask));
+    expectedScmCmd.setMaskBits(scmCmd->getMaskBits());
+    EXPECT_TRUE(memcmp(&expectedScmCmd, scmCmd, sizeof(STATE_COMPUTE_MODE)) == 0);
+
+    auto startOffset = stream.getUsed();
+
+    overrideComputeModeRequest<FamilyType>(true, true, false, false, true);
+    getCsrHw<FamilyType>()->programComputeMode(stream, flags, *defaultHwInfo);
+    EXPECT_EQ(cmdsSize * 2, stream.getUsed());
+
+    expectedScmCmd = FamilyType::cmdInitStateComputeMode;
+    expectedScmCmd.setForceNonCoherent(STATE_COMPUTE_MODE::FORCE_NON_COHERENT_FORCE_DISABLED);
+    scmCmd = reinterpret_cast<STATE_COMPUTE_MODE *>(ptrOffset(stream.getCpuBase(), startOffset));
+    EXPECT_TRUE(isValueSet(scmCmd->getMaskBits(), expectedBitsMask));
+    expectedScmCmd.setMaskBits(scmCmd->getMaskBits());
+    EXPECT_TRUE(memcmp(&expectedScmCmd, scmCmd, sizeof(STATE_COMPUTE_MODE)) == 0);
+}
+
+HWTEST2_F(ComputeModeRequirements, givenCoherencyWithSharedHandlesWhenComputeModeIsProgrammedThenCorrectCommandsAreAdded, ForceNonCoherentSupportedMatcher) {
+    SetUpImpl<FamilyType>();
+    using STATE_COMPUTE_MODE = typename FamilyType::STATE_COMPUTE_MODE;
+    using PIPE_CONTROL = typename FamilyType::PIPE_CONTROL;
+
+    auto cmdsSize = sizeof(STATE_COMPUTE_MODE) + sizeof(PIPE_CONTROL);
+    char buff[1024] = {0};
+    LinearStream stream(buff, 1024);
+
+    auto expectedScmCmd = FamilyType::cmdInitStateComputeMode;
+    expectedScmCmd.setForceNonCoherent(STATE_COMPUTE_MODE::FORCE_NON_COHERENT_FORCE_GPU_NON_COHERENT);
+    auto expectedBitsMask = FamilyType::stateComputeModeForceNonCoherentMask | FamilyType::stateComputeModeLargeGrfModeMask;
+
+    auto expectedPcCmd = FamilyType::cmdInitPipeControl;
+
+    overrideComputeModeRequest<FamilyType>(true, false, true, false, true);
+    getCsrHw<FamilyType>()->programComputeMode(stream, flags, *defaultHwInfo);
+    EXPECT_EQ(cmdsSize, stream.getUsed());
+
+    auto scmCmd = reinterpret_cast<STATE_COMPUTE_MODE *>(stream.getCpuBase());
+    EXPECT_TRUE(isValueSet(scmCmd->getMaskBits(), expectedBitsMask));
+    expectedScmCmd.setMaskBits(scmCmd->getMaskBits());
+    EXPECT_TRUE(memcmp(&expectedScmCmd, scmCmd, sizeof(STATE_COMPUTE_MODE)) == 0);
+
+    auto pcCmd = reinterpret_cast<PIPE_CONTROL *>(ptrOffset(stream.getCpuBase(), sizeof(STATE_COMPUTE_MODE)));
+    EXPECT_TRUE(memcmp(&expectedPcCmd, pcCmd, sizeof(PIPE_CONTROL)) == 0);
+
+    auto startOffset = stream.getUsed();
+
+    overrideComputeModeRequest<FamilyType>(true, true, true, false, true);
+    getCsrHw<FamilyType>()->programComputeMode(stream, flags, *defaultHwInfo);
+    EXPECT_EQ(cmdsSize * 2, stream.getUsed());
+
+    expectedScmCmd = FamilyType::cmdInitStateComputeMode;
+    expectedScmCmd.setForceNonCoherent(STATE_COMPUTE_MODE::FORCE_NON_COHERENT_FORCE_DISABLED);
+    scmCmd = reinterpret_cast<STATE_COMPUTE_MODE *>(ptrOffset(stream.getCpuBase(), startOffset));
+    EXPECT_TRUE(isValueSet(scmCmd->getMaskBits(), expectedBitsMask));
+    expectedScmCmd.setMaskBits(scmCmd->getMaskBits());
+    EXPECT_TRUE(memcmp(&expectedScmCmd, scmCmd, sizeof(STATE_COMPUTE_MODE)) == 0);
+
+    pcCmd = reinterpret_cast<PIPE_CONTROL *>(ptrOffset(stream.getCpuBase(), startOffset + sizeof(STATE_COMPUTE_MODE)));
+    EXPECT_TRUE(memcmp(&expectedPcCmd, pcCmd, sizeof(PIPE_CONTROL)) == 0);
+}
+
+HWTEST2_F(ComputeModeRequirements, givenCoherencyRequirementWithoutSharedHandlesWhenFlushTaskCalledThenProgramCmdOnlyIfChanged, ForceNonCoherentSupportedMatcher) {
+    SetUpImpl<FamilyType>();
+    using STATE_COMPUTE_MODE = typename FamilyType::STATE_COMPUTE_MODE;
+    using PIPE_CONTROL = typename FamilyType::PIPE_CONTROL;
+
+    auto startOffset = getCsrHw<FamilyType>()->commandStream.getUsed();
+
+    auto graphicAlloc = csr->getMemoryManager()->allocateGraphicsMemoryWithProperties(MockAllocationProperties{csr->getRootDeviceIndex(), MemoryConstants::pageSize});
+    IndirectHeap stream(graphicAlloc);
+
+    auto flushTask = [&](bool coherencyRequired) {
+        flags.requiresCoherency = coherencyRequired;
+        startOffset = getCsrHw<FamilyType>()->commandStream.getUsed();
+        csr->flushTask(stream, 0, stream, stream, stream, 0, flags, *device);
+    };
+
+    auto findCmd = [&](bool expectToBeProgrammed, bool expectCoherent) {
+        HardwareParse hwParser;
+        hwParser.parseCommands<FamilyType>(getCsrHw<FamilyType>()->commandStream, startOffset);
+        bool foundOne = false;
+
+        typename STATE_COMPUTE_MODE::FORCE_NON_COHERENT expectedCoherentValue = expectCoherent ? STATE_COMPUTE_MODE::FORCE_NON_COHERENT_FORCE_DISABLED : STATE_COMPUTE_MODE::FORCE_NON_COHERENT_FORCE_GPU_NON_COHERENT;
+        uint32_t expectedCoherentMask = FamilyType::stateComputeModeForceNonCoherentMask;
+
+        for (auto it = hwParser.cmdList.begin(); it != hwParser.cmdList.end(); it++) {
+            auto cmd = genCmdCast<STATE_COMPUTE_MODE *>(*it);
+            if (cmd) {
+                EXPECT_EQ(expectedCoherentValue, cmd->getForceNonCoherent());
+                EXPECT_TRUE(isValueSet(cmd->getMaskBits(), expectedCoherentMask));
+                EXPECT_FALSE(foundOne);
+                foundOne = true;
+                auto pc = genCmdCast<PIPE_CONTROL *>(*(++it));
+                EXPECT_EQ(nullptr, pc);
+            }
+        }
+        EXPECT_EQ(expectToBeProgrammed, foundOne);
+    };
+
+    flushTask(false);
+    findCmd(true, false); // first time
+
+    flushTask(false);
+    findCmd(false, false); // not changed
+
+    flushTask(true);
+    findCmd(true, true); // changed
+
+    flushTask(true);
+    findCmd(false, true); // not changed
+
+    flushTask(false);
+    findCmd(true, false); // changed
+
+    flushTask(false);
+    findCmd(false, false); // not changed
+    csr->getMemoryManager()->freeGraphicsMemory(graphicAlloc);
+}
+
+HWTEST2_F(ComputeModeRequirements, givenCoherencyRequirementWithSharedHandlesWhenFlushTaskCalledThenProgramCmdsWhenNeeded, ForceNonCoherentSupportedMatcher) {
+    SetUpImpl<FamilyType>();
+    using STATE_COMPUTE_MODE = typename FamilyType::STATE_COMPUTE_MODE;
+    using PIPE_CONTROL = typename FamilyType::PIPE_CONTROL;
+
+    auto startOffset = getCsrHw<FamilyType>()->commandStream.getUsed();
+    auto graphicsAlloc = csr->getMemoryManager()->allocateGraphicsMemoryWithProperties(MockAllocationProperties{csr->getRootDeviceIndex(), MemoryConstants::pageSize});
+    IndirectHeap stream(graphicsAlloc);
+
+    auto flushTask = [&](bool coherencyRequired) {
+        flags.requiresCoherency = coherencyRequired;
+        makeResidentSharedAlloc();
+
+        startOffset = getCsrHw<FamilyType>()->commandStream.getUsed();
+        csr->flushTask(stream, 0, stream, stream, stream, 0, flags, *device);
+    };
+
+    auto flushTaskAndFindCmds = [&](bool expectCoherent, bool areCommandsProgrammed) {
+        flushTask(expectCoherent);
+        HardwareParse hwParser;
+        hwParser.parseCommands<FamilyType>(getCsrHw<FamilyType>()->commandStream, startOffset);
+        bool foundOne = false;
+
+        typename STATE_COMPUTE_MODE::FORCE_NON_COHERENT expectedCoherentValue = expectCoherent ? STATE_COMPUTE_MODE::FORCE_NON_COHERENT_FORCE_DISABLED : STATE_COMPUTE_MODE::FORCE_NON_COHERENT_FORCE_GPU_NON_COHERENT;
+        uint32_t expectedCoherentMask = FamilyType::stateComputeModeForceNonCoherentMask;
+
+        for (auto it = hwParser.cmdList.begin(); it != hwParser.cmdList.end(); it++) {
+            auto cmd = genCmdCast<STATE_COMPUTE_MODE *>(*it);
+            if (cmd) {
+                EXPECT_EQ(expectedCoherentValue, cmd->getForceNonCoherent());
+                EXPECT_TRUE(isValueSet(cmd->getMaskBits(), expectedCoherentMask));
+                EXPECT_FALSE(foundOne);
+                foundOne = true;
+                auto pc = genCmdCast<PIPE_CONTROL *>(*(++it));
+                EXPECT_NE(nullptr, pc);
+            }
+        }
+        EXPECT_EQ(foundOne, areCommandsProgrammed);
+    };
+
+    flushTaskAndFindCmds(false, true);  // first time
+    flushTaskAndFindCmds(false, false); // not changed
+    flushTaskAndFindCmds(true, true);   // changed
+    flushTaskAndFindCmds(true, false);  // not changed
+    flushTaskAndFindCmds(false, true);  // changed
+    flushTaskAndFindCmds(false, false); // not changed
+
+    csr->getMemoryManager()->freeGraphicsMemory(graphicsAlloc);
+}
+
+HWTEST2_F(ComputeModeRequirements, givenFlushWithoutSharedHandlesWhenPreviouslyUsedThenPcAndSCMAreNotProgrammed, ForceNonCoherentSupportedMatcher) {
+    SetUpImpl<FamilyType>();
+    using STATE_COMPUTE_MODE = typename FamilyType::STATE_COMPUTE_MODE;
+    using PIPE_CONTROL = typename FamilyType::PIPE_CONTROL;
+
+    auto graphicAlloc = csr->getMemoryManager()->allocateGraphicsMemoryWithProperties(MockAllocationProperties{csr->getRootDeviceIndex(), MemoryConstants::pageSize});
+    IndirectHeap stream(graphicAlloc);
+
+    makeResidentSharedAlloc();
+    csr->flushTask(stream, 0, stream, stream, stream, 0, flags, *device);
+    EXPECT_TRUE(getCsrHw<FamilyType>()->getCsrRequestFlags()->hasSharedHandles);
+    auto startOffset = getCsrHw<FamilyType>()->commandStream.getUsed();
+
+    csr->flushTask(stream, 0, stream, stream, stream, 0, flags, *device);
+    EXPECT_TRUE(getCsrHw<FamilyType>()->getCsrRequestFlags()->hasSharedHandles);
+
+    HardwareParse hwParser;
+    hwParser.parseCommands<FamilyType>(getCsrHw<FamilyType>()->commandStream, startOffset);
+
+    EXPECT_EQ(0u, hwParser.cmdList.size());
+
+    csr->getMemoryManager()->freeGraphicsMemory(graphicAlloc);
+}
+
+HWCMDTEST_F(IGFX_XE_HP_CORE, ComputeModeRequirements, givenComputeModeCmdSizeWhenLargeGrfModeChangeIsRequiredThenSCMCommandSizeIsCalculated) {
+    SetUpImpl<FamilyType>();
+    using STATE_COMPUTE_MODE = typename FamilyType::STATE_COMPUTE_MODE;
+    using PIPE_CONTROL = typename FamilyType::PIPE_CONTROL;
+
+    auto cmdSize = 0u;
+
+    overrideComputeModeRequest<FamilyType>(false, false, false, false, 128u);
+    auto retSize = getCsrHw<FamilyType>()->getCmdSizeForComputeMode();
+    EXPECT_EQ(cmdSize, retSize);
+
+    cmdSize = sizeof(STATE_COMPUTE_MODE);
+
+    overrideComputeModeRequest<FamilyType>(false, false, false, true, 256u);
+    retSize = getCsrHw<FamilyType>()->getCmdSizeForComputeMode();
+    EXPECT_EQ(cmdSize, retSize);
+
+    overrideComputeModeRequest<FamilyType>(true, false, false, true, 256u);
+    retSize = getCsrHw<FamilyType>()->getCmdSizeForComputeMode();
+    EXPECT_EQ(cmdSize, retSize);
+}
+
+HWTEST2_F(ComputeModeRequirements, givenComputeModeProgrammingWhenLargeGrfModeChangeIsRequiredThenCorrectCommandsAreAdded, ForceNonCoherentSupportedMatcher) {
+    SetUpImpl<FamilyType>();
+    using STATE_COMPUTE_MODE = typename FamilyType::STATE_COMPUTE_MODE;
+    using PIPE_CONTROL = typename FamilyType::PIPE_CONTROL;
+
+    auto cmdsSize = sizeof(STATE_COMPUTE_MODE);
+    char buff[1024];
+    LinearStream stream(buff, 1024);
+
+    auto expectedScmCmd = FamilyType::cmdInitStateComputeMode;
+    expectedScmCmd.setForceNonCoherent(STATE_COMPUTE_MODE::FORCE_NON_COHERENT_FORCE_GPU_NON_COHERENT);
+    auto expectedBitsMask = FamilyType::stateComputeModeForceNonCoherentMask | FamilyType::stateComputeModeLargeGrfModeMask;
+
+    expectedScmCmd.setLargeGrfMode(true);
+
+    overrideComputeModeRequest<FamilyType>(true, false, false, true, 256u);
+    getCsrHw<FamilyType>()->programComputeMode(stream, flags, *defaultHwInfo);
+    EXPECT_EQ(cmdsSize, stream.getUsed());
+
+    auto scmCmd = reinterpret_cast<STATE_COMPUTE_MODE *>(stream.getCpuBase());
+    EXPECT_TRUE(isValueSet(scmCmd->getMaskBits(), expectedBitsMask));
+    expectedScmCmd.setMaskBits(scmCmd->getMaskBits());
+    EXPECT_TRUE(memcmp(&expectedScmCmd, scmCmd, sizeof(STATE_COMPUTE_MODE)) == 0);
+
+    auto startOffset = stream.getUsed();
+
+    overrideComputeModeRequest<FamilyType>(true, false, false, true, 128u);
+    getCsrHw<FamilyType>()->programComputeMode(stream, flags, *defaultHwInfo);
+    EXPECT_EQ(cmdsSize * 2, stream.getUsed());
+
+    expectedScmCmd = FamilyType::cmdInitStateComputeMode;
+    expectedScmCmd.setLargeGrfMode(false);
+    expectedScmCmd.setForceNonCoherent(STATE_COMPUTE_MODE::FORCE_NON_COHERENT_FORCE_GPU_NON_COHERENT);
+    scmCmd = reinterpret_cast<STATE_COMPUTE_MODE *>(ptrOffset(stream.getCpuBase(), startOffset));
+    EXPECT_TRUE(isValueSet(scmCmd->getMaskBits(), expectedBitsMask));
+    expectedScmCmd.setMaskBits(scmCmd->getMaskBits());
+    EXPECT_TRUE(memcmp(&expectedScmCmd, scmCmd, sizeof(STATE_COMPUTE_MODE)) == 0);
+}
+
+HWCMDTEST_F(IGFX_XE_HP_CORE, ComputeModeRequirements, givenComputeModeProgrammingWhenLargeGrfModeDoesntChangeThenSCMIsNotAdded) {
+    SetUpImpl<FamilyType>();
+
+    char buff[1024];
+    LinearStream stream(buff, 1024);
+
+    overrideComputeModeRequest<FamilyType>(false, false, false, false, 256u);
+    getCsrHw<FamilyType>()->programComputeMode(stream, flags, *defaultHwInfo);
+    EXPECT_EQ(0u, stream.getUsed());
+}
+
+HWTEST2_F(ComputeModeRequirements, givenComputeModeProgrammingWhenRequiredGRFNumberIsLowerThan128ThenSmallGRFModeIsProgrammed, ForceNonCoherentSupportedMatcher) {
+    SetUpImpl<FamilyType>();
+    using STATE_COMPUTE_MODE = typename FamilyType::STATE_COMPUTE_MODE;
+
+    auto cmdsSize = sizeof(STATE_COMPUTE_MODE);
+    char buff[1024];
+    LinearStream stream(buff, 1024);
+
+    auto expectedScmCmd = FamilyType::cmdInitStateComputeMode;
+    expectedScmCmd.setLargeGrfMode(false);
+    expectedScmCmd.setForceNonCoherent(STATE_COMPUTE_MODE::FORCE_NON_COHERENT_FORCE_GPU_NON_COHERENT);
+    auto expectedBitsMask = FamilyType::stateComputeModeForceNonCoherentMask | FamilyType::stateComputeModeLargeGrfModeMask;
+
+    overrideComputeModeRequest<FamilyType>(true, false, false, true, 127u);
+    getCsrHw<FamilyType>()->programComputeMode(stream, flags, *defaultHwInfo);
+    EXPECT_EQ(cmdsSize, stream.getUsed());
+
+    auto scmCmd = reinterpret_cast<STATE_COMPUTE_MODE *>(stream.getCpuBase());
+    EXPECT_TRUE(isValueSet(scmCmd->getMaskBits(), expectedBitsMask));
+    expectedScmCmd.setMaskBits(scmCmd->getMaskBits());
+    EXPECT_TRUE(memcmp(&expectedScmCmd, scmCmd, sizeof(STATE_COMPUTE_MODE)) == 0);
+}
+
+HWTEST2_F(ComputeModeRequirements, givenComputeModeProgrammingWhenRequiredGRFNumberIsGreaterThan128ThenLargeGRFModeIsProgrammed, ForceNonCoherentSupportedMatcher) {
+    SetUpImpl<FamilyType>();
+    using STATE_COMPUTE_MODE = typename FamilyType::STATE_COMPUTE_MODE;
+    using PIPE_CONTROL = typename FamilyType::PIPE_CONTROL;
+
+    auto cmdsSize = sizeof(STATE_COMPUTE_MODE);
+    char buff[1024];
+    LinearStream stream(buff, 1024);
+
+    auto expectedScmCmd = FamilyType::cmdInitStateComputeMode;
+    expectedScmCmd.setForceNonCoherent(STATE_COMPUTE_MODE::FORCE_NON_COHERENT_FORCE_GPU_NON_COHERENT);
+    expectedScmCmd.setLargeGrfMode(true);
+    auto expectedBitsMask = FamilyType::stateComputeModeForceNonCoherentMask | FamilyType::stateComputeModeLargeGrfModeMask;
+
+    overrideComputeModeRequest<FamilyType>(true, false, false, true, 256u);
+    getCsrHw<FamilyType>()->programComputeMode(stream, flags, *defaultHwInfo);
+    EXPECT_EQ(cmdsSize, stream.getUsed());
+
+    auto scmCmd = reinterpret_cast<STATE_COMPUTE_MODE *>(stream.getCpuBase());
+    EXPECT_TRUE(isValueSet(scmCmd->getMaskBits(), expectedBitsMask));
+    expectedScmCmd.setMaskBits(scmCmd->getMaskBits());
+    EXPECT_TRUE(memcmp(&expectedScmCmd, scmCmd, sizeof(STATE_COMPUTE_MODE)) == 0);
+}

shared/test/unit_test/gen12lp/CMakeLists.txt

@@ -1,5 +1,5 @@
 #
-# Copyright (C) 2021 Intel Corporation
+# Copyright (C) 2021-2022 Intel Corporation
 #
 # SPDX-License-Identifier: MIT
 #
@@ -9,6 +9,7 @@ if(TESTS_GEN12LP)
                  ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
                  ${CMAKE_CURRENT_SOURCE_DIR}/aub_command_stream_receiver_tests_gen12lp.inl
                  ${CMAKE_CURRENT_SOURCE_DIR}/command_stream_receiver_simulated_common_hw_tests_gen12lp.inl
+                 ${CMAKE_CURRENT_SOURCE_DIR}/compute_mode_tests_gen12lp.inl
                  ${CMAKE_CURRENT_SOURCE_DIR}/gen12lp_shared_tests_wrapper.cpp
                  ${CMAKE_CURRENT_SOURCE_DIR}/hw_cmds_gen12lp_tests.cpp
   )

shared/test/unit_test/gen12lp/compute_mode_tests_gen12lp.inl

@@ -0,0 +1,144 @@
+/*
+ * Copyright (C) 2019-2022 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#include "shared/test/unit_test/command_stream/compute_mode_tests.h"
+
+HWTEST2_F(ComputeModeRequirements, givenCsrRequestFlagsWithSharedHandlesWhenCommandSizeIsCalculatedThenCorrectCommandSizeIsReturned, IsTGLLP) {
+    SetUpImpl<FamilyType>();
+    using STATE_COMPUTE_MODE = typename FamilyType::STATE_COMPUTE_MODE;
+    using PIPE_CONTROL = typename FamilyType::PIPE_CONTROL;
+    using PIPELINE_SELECT = typename FamilyType::PIPELINE_SELECT;
+
+    auto cmdsSize = sizeof(STATE_COMPUTE_MODE) + 3 * sizeof(PIPE_CONTROL) + 2 * sizeof(PIPELINE_SELECT);
+    char buff[1024];
+    LinearStream stream(buff, 1024);
+
+    overrideComputeModeRequest<FamilyType>(false, false, true);
+
+    auto retSize = getCsrHw<FamilyType>()->getCmdSizeForComputeMode();
+    EXPECT_EQ(0u, retSize);
+    getCsrHw<FamilyType>()->programComputeMode(stream, flags, *defaultHwInfo);
+    EXPECT_EQ(0u, stream.getUsed());
+
+    stream.replaceBuffer(buff, 1024);
+    overrideComputeModeRequest<FamilyType>(false, true, true);
+
+    retSize = getCsrHw<FamilyType>()->getCmdSizeForComputeMode();
+    EXPECT_EQ(0u, retSize);
+    getCsrHw<FamilyType>()->programComputeMode(stream, flags, *defaultHwInfo);
+    EXPECT_EQ(0u, stream.getUsed());
+
+    stream.replaceBuffer(buff, 1024);
+    overrideComputeModeRequest<FamilyType>(true, true, true);
+
+    retSize = getCsrHw<FamilyType>()->getCmdSizeForComputeMode();
+    EXPECT_EQ(cmdsSize, retSize);
+    getCsrHw<FamilyType>()->programComputeMode(stream, flags, *defaultHwInfo);
+    EXPECT_EQ(cmdsSize, stream.getUsed());
+
+    stream.replaceBuffer(buff, 1024);
+    overrideComputeModeRequest<FamilyType>(true, false, true);
+
+    retSize = getCsrHw<FamilyType>()->getCmdSizeForComputeMode();
+    EXPECT_EQ(cmdsSize, retSize);
+    getCsrHw<FamilyType>()->programComputeMode(stream, flags, *defaultHwInfo);
+    EXPECT_EQ(cmdsSize, stream.getUsed());
+
+    stream.replaceBuffer(buff, 1024);
+    overrideComputeModeRequest<FamilyType>(false, false, true, true, 127u);
+
+    retSize = getCsrHw<FamilyType>()->getCmdSizeForComputeMode();
+    EXPECT_EQ(cmdsSize, retSize);
+    getCsrHw<FamilyType>()->programComputeMode(stream, flags, *defaultHwInfo);
+    EXPECT_EQ(cmdsSize, stream.getUsed());
+}
+
+HWTEST2_F(ComputeModeRequirements, givenCsrRequestFlagsWithoutSharedHandlesWhenCommandSizeIsCalculatedThenCorrectCommandSizeIsReturned, IsTGLLP) {
+    SetUpImpl<FamilyType>();
+    using STATE_COMPUTE_MODE = typename FamilyType::STATE_COMPUTE_MODE;
+    using PIPE_CONTROL = typename FamilyType::PIPE_CONTROL;
+    using PIPELINE_SELECT = typename FamilyType::PIPELINE_SELECT;
+
+    auto cmdsSize = sizeof(STATE_COMPUTE_MODE) + 2 * sizeof(PIPE_CONTROL) + 2 * sizeof(PIPELINE_SELECT);
+    char buff[1024];
+    LinearStream stream(buff, 1024);
+
+    overrideComputeModeRequest<FamilyType>(false, false, false);
+
+    auto retSize = getCsrHw<FamilyType>()->getCmdSizeForComputeMode();
+    EXPECT_EQ(0u, retSize);
+    getCsrHw<FamilyType>()->programComputeMode(stream, flags, *defaultHwInfo);
+    EXPECT_EQ(0u, stream.getUsed());
+
+    stream.replaceBuffer(buff, 1024);
+    overrideComputeModeRequest<FamilyType>(true, true, false);
+
+    retSize = getCsrHw<FamilyType>()->getCmdSizeForComputeMode();
+    EXPECT_EQ(cmdsSize, retSize);
+    getCsrHw<FamilyType>()->programComputeMode(stream, flags, *defaultHwInfo);
+    EXPECT_EQ(cmdsSize, stream.getUsed());
+
+    stream.replaceBuffer(buff, 1024);
+    overrideComputeModeRequest<FamilyType>(true, false, false);
+
+    retSize = getCsrHw<FamilyType>()->getCmdSizeForComputeMode();
+    EXPECT_EQ(cmdsSize, retSize);
+    getCsrHw<FamilyType>()->programComputeMode(stream, flags, *defaultHwInfo);
+    EXPECT_EQ(cmdsSize, stream.getUsed());
+
+    stream.replaceBuffer(buff, 1024);
+    overrideComputeModeRequest<FamilyType>(false, false, false, true, 127u);
+
+    retSize = getCsrHw<FamilyType>()->getCmdSizeForComputeMode();
+    EXPECT_EQ(cmdsSize, retSize);
+    getCsrHw<FamilyType>()->programComputeMode(stream, flags, *defaultHwInfo);
+    EXPECT_EQ(cmdsSize, stream.getUsed());
+}
+
+HWTEST2_F(ComputeModeRequirements, givenCsrRequestOnEngineCCSWhenCommandSizeIsCalculatedThenCorrectCommandSizeIsReturned, IsTGLLP) {
+    auto hwInfo = *defaultHwInfo;
+    hwInfo.featureTable.flags.ftrCCSNode = true;
+    hwInfo.capabilityTable.defaultEngineType = aub_stream::ENGINE_CCS;
+
+    SetUpImpl<FamilyType>(&hwInfo);
+    using STATE_COMPUTE_MODE = typename FamilyType::STATE_COMPUTE_MODE;
+
+    auto cmdsSize = sizeof(STATE_COMPUTE_MODE);
+    char buff[1024];
+    LinearStream stream(buff, 1024);
+
+    overrideComputeModeRequest<FamilyType>(false, false, false);
+
+    auto retSize = getCsrHw<FamilyType>()->getCmdSizeForComputeMode();
+    EXPECT_EQ(0u, retSize);
+    getCsrHw<FamilyType>()->programComputeMode(stream, flags, *defaultHwInfo);
+    EXPECT_EQ(0u, stream.getUsed());
+
+    stream.replaceBuffer(buff, 1024);
+    overrideComputeModeRequest<FamilyType>(true, true, false);
+
+    retSize = getCsrHw<FamilyType>()->getCmdSizeForComputeMode();
+    EXPECT_EQ(cmdsSize, retSize);
+    getCsrHw<FamilyType>()->programComputeMode(stream, flags, *defaultHwInfo);
+    EXPECT_EQ(cmdsSize, stream.getUsed());
+
+    stream.replaceBuffer(buff, 1024);
+    overrideComputeModeRequest<FamilyType>(true, false, false);
+
+    retSize = getCsrHw<FamilyType>()->getCmdSizeForComputeMode();
+    EXPECT_EQ(cmdsSize, retSize);
+    getCsrHw<FamilyType>()->programComputeMode(stream, flags, *defaultHwInfo);
+    EXPECT_EQ(cmdsSize, stream.getUsed());
+
+    stream.replaceBuffer(buff, 1024);
+    overrideComputeModeRequest<FamilyType>(false, false, false, true, 127u);
+
+    retSize = getCsrHw<FamilyType>()->getCmdSizeForComputeMode();
+    EXPECT_EQ(cmdsSize, retSize);
+    getCsrHw<FamilyType>()->programComputeMode(stream, flags, *defaultHwInfo);
+    EXPECT_EQ(cmdsSize, stream.getUsed());
+}

shared/test/unit_test/gen12lp/gen12lp_shared_tests_wrapper.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2021 Intel Corporation
+ * Copyright (C) 2021-2022 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -7,3 +7,4 @@
 
 #include "shared/test/unit_test/gen12lp/aub_command_stream_receiver_tests_gen12lp.inl"
 #include "shared/test/unit_test/gen12lp/command_stream_receiver_simulated_common_hw_tests_gen12lp.inl"
+#include "shared/test/unit_test/gen12lp/compute_mode_tests_gen12lp.inl"

shared/test/unit_test/xe_hp_core/CMakeLists.txt

@@ -1,5 +1,5 @@
 #
-# Copyright (C) 2021 Intel Corporation
+# Copyright (C) 2021-2022 Intel Corporation
 #
 # SPDX-License-Identifier: MIT
 #
@@ -7,6 +7,7 @@
 if(TESTS_XE_HP_CORE)
   set(NEO_SHARED_tests_xe_hp_core
       ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
+      ${CMAKE_CURRENT_SOURCE_DIR}/compute_mode_tests_xe_hp_core.cpp
       ${CMAKE_CURRENT_SOURCE_DIR}/hw_cmds_xe_hp_core_tests.cpp
   )
 

shared/test/unit_test/xe_hp_core/compute_mode_tests_xe_hp_core.cpp

@@ -0,0 +1,125 @@
+/*
+ * Copyright (C) 2021-2022 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#include "shared/test/common/helpers/debug_manager_state_restore.h"
+#include "shared/test/common/test_macros/test.h"
+#include "shared/test/unit_test/command_stream/compute_mode_tests.h"
+
+using namespace NEO;
+
+HWTEST2_F(ComputeModeRequirements, GivenProgramPipeControlPriorToNonPipelinedStateCommandThenCorrectCommandsAreAdded, IsXEHP) {
+    DebugManagerStateRestore dbgRestorer;
+    DebugManager.flags.ProgramPipeControlPriorToNonPipelinedStateCommand.set(true);
+
+    SetUpImpl<FamilyType>();
+
+    using STATE_COMPUTE_MODE = typename FamilyType::STATE_COMPUTE_MODE;
+    using PIPE_CONTROL = typename FamilyType::PIPE_CONTROL;
+
+    auto cmdsSize = sizeof(STATE_COMPUTE_MODE) + sizeof(PIPE_CONTROL);
+    char buff[1024] = {0};
+    LinearStream stream(buff, 1024);
+
+    auto expectedScmCmd = FamilyType::cmdInitStateComputeMode;
+    expectedScmCmd.setForceNonCoherent(STATE_COMPUTE_MODE::FORCE_NON_COHERENT_FORCE_GPU_NON_COHERENT);
+    auto expectedBitsMask = FamilyType::stateComputeModeForceNonCoherentMask | FamilyType::stateComputeModeLargeGrfModeMask;
+
+    overrideComputeModeRequest<FamilyType>(true, false, false, false, true);
+    getCsrHw<FamilyType>()->programComputeMode(stream, flags, *defaultHwInfo);
+    EXPECT_EQ(cmdsSize, stream.getUsed());
+
+    auto startOffset = getCsrHw<FamilyType>()->commandStream.getUsed();
+
+    HardwareParse hwParser;
+    hwParser.parseCommands<FamilyType>(stream, startOffset);
+
+    auto pipeControlIterator = find<PIPE_CONTROL *>(hwParser.cmdList.begin(), hwParser.cmdList.end());
+    auto pipeControlCmd = genCmdCast<PIPE_CONTROL *>(*pipeControlIterator);
+
+    EXPECT_TRUE(pipeControlCmd->getHdcPipelineFlush());
+    EXPECT_TRUE(pipeControlCmd->getAmfsFlushEnable());
+    EXPECT_TRUE(pipeControlCmd->getCommandStreamerStallEnable());
+    EXPECT_TRUE(pipeControlCmd->getInstructionCacheInvalidateEnable());
+    EXPECT_TRUE(pipeControlCmd->getTextureCacheInvalidationEnable());
+    EXPECT_TRUE(pipeControlCmd->getConstantCacheInvalidationEnable());
+    EXPECT_TRUE(pipeControlCmd->getStateCacheInvalidationEnable());
+
+    auto stateComputeModelCmd = reinterpret_cast<STATE_COMPUTE_MODE *>(ptrOffset(stream.getCpuBase(), sizeof(PIPE_CONTROL)));
+    EXPECT_TRUE(isValueSet(stateComputeModelCmd->getMaskBits(), expectedBitsMask));
+    expectedScmCmd.setMaskBits(stateComputeModelCmd->getMaskBits());
+    EXPECT_TRUE(memcmp(&expectedScmCmd, stateComputeModelCmd, sizeof(STATE_COMPUTE_MODE)) == 0);
+}
+
+HWTEST2_F(ComputeModeRequirements, GivenMultipleCCSEnabledSetupThenCorrectCommandsAreAdded, IsXEHP) {
+    HardwareInfo hwInfo = *defaultHwInfo;
+    hwInfo.gtSystemInfo.CCSInfo.NumberOfCCSEnabled = 2;
+
+    SetUpImpl<FamilyType>(&hwInfo);
+
+    using STATE_COMPUTE_MODE = typename FamilyType::STATE_COMPUTE_MODE;
+    using PIPE_CONTROL = typename FamilyType::PIPE_CONTROL;
+
+    auto cmdsSize = sizeof(STATE_COMPUTE_MODE) + sizeof(PIPE_CONTROL);
+    char buff[1024] = {0};
+    LinearStream stream(buff, 1024);
+
+    auto expectedScmCmd = FamilyType::cmdInitStateComputeMode;
+    expectedScmCmd.setForceNonCoherent(STATE_COMPUTE_MODE::FORCE_NON_COHERENT_FORCE_GPU_NON_COHERENT);
+    auto expectedBitsMask = FamilyType::stateComputeModeForceNonCoherentMask | FamilyType::stateComputeModeLargeGrfModeMask;
+
+    overrideComputeModeRequest<FamilyType>(true, false, false, false, true);
+    getCsrHw<FamilyType>()->programComputeMode(stream, flags, hwInfo);
+    EXPECT_EQ(cmdsSize, stream.getUsed());
+
+    auto startOffset = getCsrHw<FamilyType>()->commandStream.getUsed();
+
+    HardwareParse hwParser;
+    hwParser.parseCommands<FamilyType>(stream, startOffset);
+
+    auto pipeControlIterator = find<PIPE_CONTROL *>(hwParser.cmdList.begin(), hwParser.cmdList.end());
+    auto pipeControlCmd = genCmdCast<PIPE_CONTROL *>(*pipeControlIterator);
+
+    EXPECT_TRUE(pipeControlCmd->getHdcPipelineFlush());
+    EXPECT_TRUE(pipeControlCmd->getAmfsFlushEnable());
+    EXPECT_TRUE(pipeControlCmd->getCommandStreamerStallEnable());
+    EXPECT_TRUE(pipeControlCmd->getInstructionCacheInvalidateEnable());
+    EXPECT_TRUE(pipeControlCmd->getTextureCacheInvalidationEnable());
+    EXPECT_TRUE(pipeControlCmd->getConstantCacheInvalidationEnable());
+    EXPECT_TRUE(pipeControlCmd->getStateCacheInvalidationEnable());
+
+    auto stateComputeModelCmd = reinterpret_cast<STATE_COMPUTE_MODE *>(ptrOffset(stream.getCpuBase(), sizeof(PIPE_CONTROL)));
+    EXPECT_TRUE(isValueSet(stateComputeModelCmd->getMaskBits(), expectedBitsMask));
+    expectedScmCmd.setMaskBits(stateComputeModelCmd->getMaskBits());
+    EXPECT_TRUE(memcmp(&expectedScmCmd, stateComputeModelCmd, sizeof(STATE_COMPUTE_MODE)) == 0);
+}
+
+HWTEST2_F(ComputeModeRequirements, GivenProgramPipeControlPriorToNonPipelinedStateCommandThenCommandSizeIsCalculatedAndCorrectCommandSizeIsReturned, IsXEHP) {
+    DebugManagerStateRestore dbgRestorer;
+    DebugManager.flags.ProgramPipeControlPriorToNonPipelinedStateCommand.set(true);
+
+    using STATE_COMPUTE_MODE = typename FamilyType::STATE_COMPUTE_MODE;
+    using PIPE_CONTROL = typename FamilyType::PIPE_CONTROL;
+    SetUpImpl<FamilyType>();
+
+    auto cmdsSize = sizeof(STATE_COMPUTE_MODE) + sizeof(PIPE_CONTROL);
+
+    overrideComputeModeRequest<FamilyType>(false, false, false);
+    auto retSize = getCsrHw<FamilyType>()->getCmdSizeForComputeMode();
+    EXPECT_EQ(0u, retSize);
+
+    overrideComputeModeRequest<FamilyType>(false, true, false);
+    retSize = getCsrHw<FamilyType>()->getCmdSizeForComputeMode();
+    EXPECT_EQ(0u, retSize);
+
+    overrideComputeModeRequest<FamilyType>(true, true, false);
+    retSize = getCsrHw<FamilyType>()->getCmdSizeForComputeMode();
+    EXPECT_EQ(cmdsSize, retSize);
+
+    overrideComputeModeRequest<FamilyType>(true, false, false);
+    retSize = getCsrHw<FamilyType>()->getCmdSizeForComputeMode();
+    EXPECT_EQ(cmdsSize, retSize);
+}

shared/test/unit_test/xe_hpc_core/CMakeLists.txt

@@ -9,6 +9,7 @@ if(TESTS_XE_HPC_CORE)
       ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
       ${CMAKE_CURRENT_SOURCE_DIR}/aub_command_stream_receiver_2_tests_xe_hpc_core.cpp
       ${CMAKE_CURRENT_SOURCE_DIR}/cmd_parse_tests_xe_hpc_core.cpp
+      ${CMAKE_CURRENT_SOURCE_DIR}/compute_mode_tests_xe_hpc_core.cpp
       ${CMAKE_CURRENT_SOURCE_DIR}/dispatch_walker_tests_xe_hpc_core.cpp
       ${CMAKE_CURRENT_SOURCE_DIR}/hw_cmds_xe_hpc_core_tests.cpp
       ${CMAKE_CURRENT_SOURCE_DIR}/hw_helper_xe_hpc_core_tests.cpp

shared/test/unit_test/xe_hpc_core/compute_mode_tests_xe_hpc_core.cpp

@@ -0,0 +1,441 @@
+/*
+ * Copyright (C) 2021-2022 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#include "shared/source/helpers/state_compute_mode_helper.h"
+#include "shared/source/kernel/grf_config.h"
+#include "shared/test/common/helpers/debug_manager_state_restore.h"
+#include "shared/test/common/helpers/unit_test_helper.h"
+#include "shared/test/common/mocks/mock_allocation_properties.h"
+#include "shared/test/unit_test/command_stream/compute_mode_tests.h"
+
+using namespace NEO;
+
+using ThreadArbitrationPvc = ::testing::Test;
+PVCTEST_F(ThreadArbitrationPvc, givenPvcWhenCallgetDefaultThreadArbitrationPolicyThenAgeBasedisReturned) {
+    EXPECT_EQ(ThreadArbitrationPolicy::AgeBased, HwHelperHw<FamilyType>::get().getDefaultThreadArbitrationPolicy());
+}
+
+using PvcComputeModeRequirements = ComputeModeRequirements;
+
+PVCTEST_F(PvcComputeModeRequirements, givenNewRequiredThreadArbitrationPolicyWhenComputeModeIsProgrammedThenStateComputeIsProgrammedAgain) {
+    SetUpImpl<FamilyType>();
+    using STATE_COMPUTE_MODE = typename FamilyType::STATE_COMPUTE_MODE;
+    using PIPE_CONTROL = typename FamilyType::PIPE_CONTROL;
+    using EU_THREAD_SCHEDULING_MODE_OVERRIDE = typename STATE_COMPUTE_MODE::EU_THREAD_SCHEDULING_MODE_OVERRIDE;
+
+    auto cmdsSize = sizeof(STATE_COMPUTE_MODE) + sizeof(PIPE_CONTROL);
+    char buff[1024] = {0};
+    LinearStream stream(buff, 1024);
+    auto &hwHelper = NEO::HwHelper::get(device->getHardwareInfo().platform.eRenderCoreFamily);
+    auto newEuThreadSchedulingMode = hwHelper.getDefaultThreadArbitrationPolicy();
+    auto expectedEuThreadSchedulingMode = static_cast<EU_THREAD_SCHEDULING_MODE_OVERRIDE>(UnitTestHelper<FamilyType>::getAppropriateThreadArbitrationPolicy(newEuThreadSchedulingMode));
+
+    auto expectedScmCmd = FamilyType::cmdInitStateComputeMode;
+    expectedScmCmd.setForceNonCoherent(STATE_COMPUTE_MODE::FORCE_NON_COHERENT_FORCE_GPU_NON_COHERENT);
+    expectedScmCmd.setMaskBits(FamilyType::stateComputeModeForceNonCoherentMask | FamilyType::stateComputeModeLargeGrfModeMask | FamilyType::stateComputeModeEuThreadSchedulingModeOverrideMask);
+    expectedScmCmd.setEuThreadSchedulingModeOverride(expectedEuThreadSchedulingMode);
+
+    overrideComputeModeRequest<FamilyType>(true, false, false, true, true);
+    getCsrHw<FamilyType>()->programComputeMode(stream, flags, *defaultHwInfo);
+    EXPECT_EQ(cmdsSize, stream.getUsed());
+
+    auto scmCmd = reinterpret_cast<STATE_COMPUTE_MODE *>(ptrOffset(stream.getCpuBase(), sizeof(PIPE_CONTROL)));
+    EXPECT_TRUE(memcmp(&expectedScmCmd, scmCmd, sizeof(STATE_COMPUTE_MODE)) == 0);
+
+    EXPECT_EQ(expectedEuThreadSchedulingMode, static_cast<STATE_COMPUTE_MODE *>(ptrOffset(stream.getCpuBase(), sizeof(PIPE_CONTROL)))->getEuThreadSchedulingModeOverride());
+}
+
+PVCTEST_F(PvcComputeModeRequirements, givenRequiredThreadArbitrationPolicyAlreadySetWhenComputeModeIsProgrammedThenStateComputeIsNotProgrammedAgain) {
+    SetUpImpl<FamilyType>();
+    using STATE_COMPUTE_MODE = typename FamilyType::STATE_COMPUTE_MODE;
+
+    auto cmdsSize = 0u;
+    char buff[1024] = {0};
+    LinearStream stream(buff, 1024);
+
+    auto expectedScmCmd = FamilyType::cmdInitStateComputeMode;
+    expectedScmCmd.setForceNonCoherent(STATE_COMPUTE_MODE::FORCE_NON_COHERENT_FORCE_GPU_NON_COHERENT);
+    expectedScmCmd.setMaskBits(FamilyType::stateComputeModeForceNonCoherentMask | FamilyType::stateComputeModeLargeGrfModeMask);
+
+    getCsrHw<FamilyType>()->programComputeMode(stream, flags, *defaultHwInfo);
+    EXPECT_EQ(cmdsSize, stream.getUsed());
+
+    auto scmCmd = reinterpret_cast<STATE_COMPUTE_MODE *>(stream.getCpuBase());
+    EXPECT_FALSE(memcmp(&expectedScmCmd, scmCmd, sizeof(STATE_COMPUTE_MODE)) == 0);
+
+    EXPECT_NE(STATE_COMPUTE_MODE::EU_THREAD_SCHEDULING_MODE_OVERRIDE::EU_THREAD_SCHEDULING_MODE_OVERRIDE_ROUND_ROBIN, static_cast<STATE_COMPUTE_MODE *>(stream.getCpuBase())->getEuThreadSchedulingModeOverride());
+}
+
+PVCTEST_F(PvcComputeModeRequirements, givenCoherencyWithoutSharedHandlesWhenCommandSizeIsCalculatedThenCorrectCommandSizeIsReturned) {
+    using STATE_COMPUTE_MODE = typename FamilyType::STATE_COMPUTE_MODE;
+    using PIPE_CONTROL = typename FamilyType::PIPE_CONTROL;
+
+    SetUpImpl<FamilyType>();
+
+    auto cmdsSize = sizeof(STATE_COMPUTE_MODE) + sizeof(PIPE_CONTROL);
+
+    overrideComputeModeRequest<FamilyType>(false, false, false, false);
+    auto retSize = getCsrHw<FamilyType>()->getCmdSizeForComputeMode();
+    EXPECT_EQ(0u, retSize);
+
+    overrideComputeModeRequest<FamilyType>(false, false, false, true);
+    retSize = getCsrHw<FamilyType>()->getCmdSizeForComputeMode();
+    EXPECT_EQ(cmdsSize, retSize);
+}
+
+PVCTEST_F(PvcComputeModeRequirements, givenNumGrfRequiredChangedWhenCommandSizeIsCalculatedThenCorrectCommandSizeIsReturned) {
+    using STATE_COMPUTE_MODE = typename FamilyType::STATE_COMPUTE_MODE;
+    using PIPE_CONTROL = typename FamilyType::PIPE_CONTROL;
+
+    SetUpImpl<FamilyType>();
+
+    auto numGrfRequired = 128u;
+    auto numGrfRequiredChanged = false;
+    overrideComputeModeRequest<FamilyType>(false, false, false, numGrfRequiredChanged, numGrfRequired);
+    EXPECT_EQ(0u, getCsrHw<FamilyType>()->getCmdSizeForComputeMode());
+
+    numGrfRequiredChanged = true;
+    overrideComputeModeRequest<FamilyType>(false, false, false, numGrfRequiredChanged, numGrfRequired);
+    EXPECT_EQ(sizeof(STATE_COMPUTE_MODE) + sizeof(PIPE_CONTROL), getCsrHw<FamilyType>()->getCmdSizeForComputeMode());
+}
+
+PVCTEST_F(PvcComputeModeRequirements, givenComputeModeProgrammingWhenLargeGrfModeDoesntChangeButRequiredThreadArbitrationPolicyIsNewThenSCMIsReloaded) {
+    SetUpImpl<FamilyType>();
+    using STATE_COMPUTE_MODE = typename FamilyType::STATE_COMPUTE_MODE;
+    using PIPE_CONTROL = typename FamilyType::PIPE_CONTROL;
+
+    char buff[1024];
+    LinearStream stream(buff, 1024);
+    auto cmdsSize = sizeof(STATE_COMPUTE_MODE) + sizeof(PIPE_CONTROL);
+
+    overrideComputeModeRequest<FamilyType>(false, false, false, true);
+    getCsrHw<FamilyType>()->programComputeMode(stream, flags, *defaultHwInfo);
+    EXPECT_EQ(cmdsSize, stream.getUsed());
+}
+
+PVCTEST_F(PvcComputeModeRequirements, givenComputeModeProgrammingWhenLargeGrfModeChangedThenSCMIsReloadedAndLargeGrfModeProgrammed) {
+    SetUpImpl<FamilyType>();
+    using STATE_COMPUTE_MODE = typename FamilyType::STATE_COMPUTE_MODE;
+    using PIPE_CONTROL = typename FamilyType::PIPE_CONTROL;
+
+    char buff[1024];
+    LinearStream stream(buff, 1024);
+    auto cmdsSize = sizeof(STATE_COMPUTE_MODE) + sizeof(PIPE_CONTROL);
+    uint32_t numGrfRequired = GrfConfig::LargeGrfNumber;
+
+    overrideComputeModeRequest<FamilyType>(false, false, false, true, numGrfRequired);
+    getCsrHw<FamilyType>()->programComputeMode(stream, flags, *defaultHwInfo);
+    EXPECT_EQ(cmdsSize, stream.getUsed());
+
+    EXPECT_TRUE(static_cast<STATE_COMPUTE_MODE *>(ptrOffset(stream.getCpuBase(), sizeof(PIPE_CONTROL)))->getLargeGrfMode());
+}
+
+PVCTEST_F(PvcComputeModeRequirements, givenComputeModeProgrammingWhenLargeGrfRequiredChangedButValueIsDefaultThenSCMIsReloadedButLargeGrfModeNotProgrammed) {
+    SetUpImpl<FamilyType>();
+    using STATE_COMPUTE_MODE = typename FamilyType::STATE_COMPUTE_MODE;
+    using PIPE_CONTROL = typename FamilyType::PIPE_CONTROL;
+
+    char buff[1024];
+    LinearStream stream(buff, 1024);
+    auto cmdsSize = sizeof(STATE_COMPUTE_MODE) + sizeof(PIPE_CONTROL);
+    uint32_t numGrfRequired = GrfConfig::DefaultGrfNumber;
+
+    overrideComputeModeRequest<FamilyType>(false, false, false, true, numGrfRequired);
+    getCsrHw<FamilyType>()->programComputeMode(stream, flags, *defaultHwInfo);
+    EXPECT_EQ(cmdsSize, stream.getUsed());
+    EXPECT_FALSE(static_cast<STATE_COMPUTE_MODE *>(stream.getCpuBase())->getLargeGrfMode());
+}
+
+PVCTEST_F(PvcComputeModeRequirements, giventhreadArbitrationPolicyWithoutSharedHandlesWhenFlushTaskCalledThenProgramCmdOnlyIfChanged) {
+    SetUpImpl<FamilyType>();
+    using STATE_COMPUTE_MODE = typename FamilyType::STATE_COMPUTE_MODE;
+    using PIPE_CONTROL = typename FamilyType::PIPE_CONTROL;
+
+    auto startOffset = getCsrHw<FamilyType>()->commandStream.getUsed();
+
+    auto graphicAlloc = csr->getMemoryManager()->allocateGraphicsMemoryWithProperties(MockAllocationProperties{csr->getRootDeviceIndex(), MemoryConstants::pageSize});
+    IndirectHeap stream(graphicAlloc);
+
+    auto flushTask = [&](bool threadArbitrationPolicyChanged) {
+        if (threadArbitrationPolicyChanged) {
+            getCsrHw<FamilyType>()->streamProperties.stateComputeMode.threadArbitrationPolicy.value = -1;
+        }
+        startOffset = getCsrHw<FamilyType>()->commandStream.getUsed();
+        csr->flushTask(stream, 0, stream, stream, stream, 0, flags, *device);
+    };
+
+    auto findCmd = [&](bool expectToBeProgrammed) {
+        HardwareParse hwParser;
+        hwParser.parseCommands<FamilyType>(getCsrHw<FamilyType>()->commandStream, startOffset);
+        bool foundOne = false;
+
+        uint32_t expectedCoherentMask = FamilyType::stateComputeModeEuThreadSchedulingModeOverrideMask |
+                                        FamilyType::stateComputeModeLargeGrfModeMask |
+                                        FamilyType::stateComputeModeForceNonCoherentMask;
+
+        for (auto it = hwParser.cmdList.begin(); it != hwParser.cmdList.end(); it++) {
+            auto cmd = genCmdCast<STATE_COMPUTE_MODE *>(*it);
+            if (cmd) {
+                EXPECT_EQ(expectedCoherentMask, cmd->getMaskBits());
+                EXPECT_FALSE(foundOne);
+                foundOne = true;
+                auto pc = genCmdCast<PIPE_CONTROL *>(*(++it));
+                EXPECT_EQ(nullptr, pc);
+            }
+        }
+        EXPECT_EQ(expectToBeProgrammed, foundOne);
+    };
+
+    getCsrHw<FamilyType>()->streamProperties.stateComputeMode.setProperties(flags.requiresCoherency, flags.numGrfRequired,
+                                                                            flags.threadArbitrationPolicy);
+
+    flushTask(true);
+    findCmd(true); // first time
+
+    flushTask(false);
+    findCmd(false); // not changed
+
+    flushTask(true);
+    findCmd(true); // changed
+
+    csr->getMemoryManager()->freeGraphicsMemory(graphicAlloc);
+}
+
+PVCTEST_F(PvcComputeModeRequirements, givenCoherencyWithoutSharedHandlesWhenComputeModeIsProgrammedThenCorrectCommandsAreAdded) {
+    SetUpImpl<FamilyType>();
+    using STATE_COMPUTE_MODE = typename FamilyType::STATE_COMPUTE_MODE;
+    using PIPE_CONTROL = typename FamilyType::PIPE_CONTROL;
+
+    auto cmdsSize = sizeof(STATE_COMPUTE_MODE) + sizeof(PIPE_CONTROL);
+    char buff[1024] = {0};
+    LinearStream stream(buff, 1024);
+
+    auto expectedScmCmd = FamilyType::cmdInitStateComputeMode;
+    expectedScmCmd.setForceNonCoherent(STATE_COMPUTE_MODE::FORCE_NON_COHERENT_FORCE_GPU_NON_COHERENT);
+    expectedScmCmd.setEuThreadSchedulingModeOverride(STATE_COMPUTE_MODE::EU_THREAD_SCHEDULING_MODE_OVERRIDE_OLDEST_FIRST);
+    expectedScmCmd.setMaskBits(FamilyType::stateComputeModeForceNonCoherentMask | FamilyType::stateComputeModeLargeGrfModeMask |
+                               FamilyType::stateComputeModeEuThreadSchedulingModeOverrideMask);
+
+    overrideComputeModeRequest<FamilyType>(true, false, false, true, true);
+    getCsrHw<FamilyType>()->programComputeMode(stream, flags, *defaultHwInfo);
+    EXPECT_EQ(cmdsSize, stream.getUsed());
+
+    auto scmCmd = reinterpret_cast<STATE_COMPUTE_MODE *>(ptrOffset(stream.getCpuBase(), sizeof(PIPE_CONTROL)));
+    EXPECT_TRUE(memcmp(&expectedScmCmd, scmCmd, sizeof(STATE_COMPUTE_MODE)) == 0);
+
+    auto startOffset = stream.getUsed() + sizeof(PIPE_CONTROL);
+
+    overrideComputeModeRequest<FamilyType>(true, true, false, true, true);
+    getCsrHw<FamilyType>()->programComputeMode(stream, flags, *defaultHwInfo);
+    EXPECT_EQ(cmdsSize * 2, stream.getUsed());
+
+    expectedScmCmd = FamilyType::cmdInitStateComputeMode;
+    expectedScmCmd.setForceNonCoherent(STATE_COMPUTE_MODE::FORCE_NON_COHERENT_FORCE_DISABLED);
+    expectedScmCmd.setEuThreadSchedulingModeOverride(STATE_COMPUTE_MODE::EU_THREAD_SCHEDULING_MODE_OVERRIDE_OLDEST_FIRST);
+    expectedScmCmd.setMaskBits(FamilyType::stateComputeModeForceNonCoherentMask | FamilyType::stateComputeModeLargeGrfModeMask |
+                               FamilyType::stateComputeModeEuThreadSchedulingModeOverrideMask);
+    scmCmd = reinterpret_cast<STATE_COMPUTE_MODE *>(ptrOffset(stream.getCpuBase(), startOffset));
+    EXPECT_TRUE(memcmp(&expectedScmCmd, scmCmd, sizeof(STATE_COMPUTE_MODE)) == 0);
+}
+
+PVCTEST_F(PvcComputeModeRequirements, givenCoherencyWithSharedHandlesWhenComputeModeIsProgrammedThenCorrectCommandsAreAdded) {
+    SetUpImpl<FamilyType>();
+    using STATE_COMPUTE_MODE = typename FamilyType::STATE_COMPUTE_MODE;
+    using PIPE_CONTROL = typename FamilyType::PIPE_CONTROL;
+
+    auto cmdsSize = sizeof(STATE_COMPUTE_MODE) + 2 * sizeof(PIPE_CONTROL);
+    char buff[1024] = {0};
+    LinearStream stream(buff, 1024);
+
+    auto expectedScmCmd = FamilyType::cmdInitStateComputeMode;
+    expectedScmCmd.setForceNonCoherent(STATE_COMPUTE_MODE::FORCE_NON_COHERENT_FORCE_GPU_NON_COHERENT);
+    expectedScmCmd.setEuThreadSchedulingModeOverride(STATE_COMPUTE_MODE::EU_THREAD_SCHEDULING_MODE_OVERRIDE_OLDEST_FIRST);
+    expectedScmCmd.setMaskBits(FamilyType::stateComputeModeForceNonCoherentMask | FamilyType::stateComputeModeLargeGrfModeMask |
+                               FamilyType::stateComputeModeEuThreadSchedulingModeOverrideMask);
+
+    auto expectedPcCmd = FamilyType::cmdInitPipeControl;
+
+    overrideComputeModeRequest<FamilyType>(true, false, true, true, true);
+    getCsrHw<FamilyType>()->programComputeMode(stream, flags, *defaultHwInfo);
+    EXPECT_EQ(cmdsSize, stream.getUsed());
+
+    auto scmCmd = reinterpret_cast<STATE_COMPUTE_MODE *>(ptrOffset(stream.getCpuBase(), sizeof(PIPE_CONTROL)));
+    EXPECT_TRUE(memcmp(&expectedScmCmd, scmCmd, sizeof(STATE_COMPUTE_MODE)) == 0);
+
+    auto pcCmd = reinterpret_cast<PIPE_CONTROL *>(ptrOffset(stream.getCpuBase(), sizeof(PIPE_CONTROL) + sizeof(STATE_COMPUTE_MODE)));
+    EXPECT_TRUE(memcmp(&expectedPcCmd, pcCmd, sizeof(PIPE_CONTROL)) == 0);
+
+    auto startOffset = stream.getUsed();
+
+    overrideComputeModeRequest<FamilyType>(true, true, true, true, true);
+    getCsrHw<FamilyType>()->programComputeMode(stream, flags, *defaultHwInfo);
+    EXPECT_EQ(cmdsSize * 2, stream.getUsed());
+
+    expectedScmCmd = FamilyType::cmdInitStateComputeMode;
+    expectedScmCmd.setForceNonCoherent(STATE_COMPUTE_MODE::FORCE_NON_COHERENT_FORCE_DISABLED);
+    expectedScmCmd.setEuThreadSchedulingModeOverride(STATE_COMPUTE_MODE::EU_THREAD_SCHEDULING_MODE_OVERRIDE_OLDEST_FIRST);
+    expectedScmCmd.setMaskBits(FamilyType::stateComputeModeForceNonCoherentMask | FamilyType::stateComputeModeLargeGrfModeMask |
+                               FamilyType::stateComputeModeEuThreadSchedulingModeOverrideMask);
+    scmCmd = reinterpret_cast<STATE_COMPUTE_MODE *>(ptrOffset(stream.getCpuBase(), sizeof(PIPE_CONTROL) + startOffset));
+    EXPECT_TRUE(memcmp(&expectedScmCmd, scmCmd, sizeof(STATE_COMPUTE_MODE)) == 0);
+
+    pcCmd = reinterpret_cast<PIPE_CONTROL *>(ptrOffset(stream.getCpuBase(), sizeof(PIPE_CONTROL) + startOffset + sizeof(STATE_COMPUTE_MODE)));
+    EXPECT_TRUE(memcmp(&expectedPcCmd, pcCmd, sizeof(PIPE_CONTROL)) == 0);
+}
+
+PVCTEST_F(PvcComputeModeRequirements, givenComputeModeProgrammingWhenLargeGrfModeChangeIsRequiredThenCorrectCommandsAreAdded) {
+    SetUpImpl<FamilyType>();
+    using STATE_COMPUTE_MODE = typename FamilyType::STATE_COMPUTE_MODE;
+    using PIPE_CONTROL = typename FamilyType::PIPE_CONTROL;
+
+    auto cmdsSize = sizeof(STATE_COMPUTE_MODE) + sizeof(PIPE_CONTROL);
+    char buff[1024];
+    LinearStream stream(buff, 1024);
+
+    auto expectedScmCmd = FamilyType::cmdInitStateComputeMode;
+    expectedScmCmd.setLargeGrfMode(true);
+    expectedScmCmd.setForceNonCoherent(STATE_COMPUTE_MODE::FORCE_NON_COHERENT_FORCE_GPU_NON_COHERENT);
+    expectedScmCmd.setEuThreadSchedulingModeOverride(STATE_COMPUTE_MODE::EU_THREAD_SCHEDULING_MODE_OVERRIDE_OLDEST_FIRST);
+    expectedScmCmd.setMaskBits(FamilyType::stateComputeModeForceNonCoherentMask | FamilyType::stateComputeModeLargeGrfModeMask |
+                               FamilyType::stateComputeModeEuThreadSchedulingModeOverrideMask);
+
+    overrideComputeModeRequest<FamilyType>(true, false, false, true, true, 256u);
+    getCsrHw<FamilyType>()->programComputeMode(stream, flags, *defaultHwInfo);
+    EXPECT_EQ(cmdsSize, stream.getUsed());
+
+    auto scmCmd = reinterpret_cast<STATE_COMPUTE_MODE *>(ptrOffset(stream.getCpuBase(), sizeof(PIPE_CONTROL)));
+    EXPECT_TRUE(memcmp(&expectedScmCmd, scmCmd, sizeof(STATE_COMPUTE_MODE)) == 0);
+
+    auto startOffset = stream.getUsed() + sizeof(PIPE_CONTROL);
+
+    overrideComputeModeRequest<FamilyType>(true, false, false, true, true, 128u);
+    getCsrHw<FamilyType>()->programComputeMode(stream, flags, *defaultHwInfo);
+    EXPECT_EQ(cmdsSize * 2, stream.getUsed());
+
+    expectedScmCmd = FamilyType::cmdInitStateComputeMode;
+    expectedScmCmd.setLargeGrfMode(false);
+    expectedScmCmd.setForceNonCoherent(STATE_COMPUTE_MODE::FORCE_NON_COHERENT_FORCE_GPU_NON_COHERENT);
+    expectedScmCmd.setEuThreadSchedulingModeOverride(STATE_COMPUTE_MODE::EU_THREAD_SCHEDULING_MODE_OVERRIDE_OLDEST_FIRST);
+    expectedScmCmd.setMaskBits(FamilyType::stateComputeModeForceNonCoherentMask | FamilyType::stateComputeModeLargeGrfModeMask |
+                               FamilyType::stateComputeModeEuThreadSchedulingModeOverrideMask);
+    scmCmd = reinterpret_cast<STATE_COMPUTE_MODE *>(ptrOffset(stream.getCpuBase(), startOffset));
+    EXPECT_TRUE(memcmp(&expectedScmCmd, scmCmd, sizeof(STATE_COMPUTE_MODE)) == 0);
+}
+
+PVCTEST_F(PvcComputeModeRequirements, givenComputeModeProgrammingWhenRequiredGRFNumberIsLowerThan128ThenSmallGRFModeIsProgrammed) {
+    SetUpImpl<FamilyType>();
+    using STATE_COMPUTE_MODE = typename FamilyType::STATE_COMPUTE_MODE;
+    using PIPE_CONTROL = typename FamilyType::PIPE_CONTROL;
+
+    auto cmdsSize = sizeof(STATE_COMPUTE_MODE) + sizeof(PIPE_CONTROL);
+    char buff[1024];
+    LinearStream stream(buff, 1024);
+
+    auto expectedScmCmd = FamilyType::cmdInitStateComputeMode;
+    expectedScmCmd.setLargeGrfMode(false);
+    expectedScmCmd.setForceNonCoherent(STATE_COMPUTE_MODE::FORCE_NON_COHERENT_FORCE_GPU_NON_COHERENT);
+    expectedScmCmd.setEuThreadSchedulingModeOverride(STATE_COMPUTE_MODE::EU_THREAD_SCHEDULING_MODE_OVERRIDE_OLDEST_FIRST);
+    expectedScmCmd.setMaskBits(FamilyType::stateComputeModeForceNonCoherentMask | FamilyType::stateComputeModeLargeGrfModeMask |
+                               FamilyType::stateComputeModeEuThreadSchedulingModeOverrideMask);
+
+    overrideComputeModeRequest<FamilyType>(true, false, false, true, true, 127u);
+    getCsrHw<FamilyType>()->programComputeMode(stream, flags, *defaultHwInfo);
+    EXPECT_EQ(cmdsSize, stream.getUsed());
+
+    auto scmCmd = reinterpret_cast<STATE_COMPUTE_MODE *>(ptrOffset(stream.getCpuBase(), sizeof(PIPE_CONTROL)));
+    EXPECT_TRUE(memcmp(&expectedScmCmd, scmCmd, sizeof(STATE_COMPUTE_MODE)) == 0);
+}
+
+PVCTEST_F(PvcComputeModeRequirements, givenComputeModeProgrammingThenCorrectCommandsAreAdded) {
+    SetUpImpl<FamilyType>();
+
+    using STATE_COMPUTE_MODE = typename FamilyType::STATE_COMPUTE_MODE;
+    using PIPE_CONTROL = typename FamilyType::PIPE_CONTROL;
+
+    auto cmdsSize = sizeof(STATE_COMPUTE_MODE) + sizeof(PIPE_CONTROL);
+    char buff[1024] = {0};
+    LinearStream stream(buff, 1024);
+
+    auto expectedScmCmd = FamilyType::cmdInitStateComputeMode;
+    expectedScmCmd.setForceNonCoherent(STATE_COMPUTE_MODE::FORCE_NON_COHERENT_FORCE_GPU_NON_COHERENT);
+    expectedScmCmd.setEuThreadSchedulingModeOverride(STATE_COMPUTE_MODE::EU_THREAD_SCHEDULING_MODE_OVERRIDE_OLDEST_FIRST);
+    expectedScmCmd.setMaskBits(FamilyType::stateComputeModeForceNonCoherentMask | FamilyType::stateComputeModeLargeGrfModeMask |
+                               FamilyType::stateComputeModeEuThreadSchedulingModeOverrideMask);
+
+    overrideComputeModeRequest<FamilyType>(true, false, false, true, true);
+    getCsrHw<FamilyType>()->programComputeMode(stream, flags, *defaultHwInfo);
+    EXPECT_EQ(cmdsSize, stream.getUsed());
+
+    auto startOffset = getCsrHw<FamilyType>()->commandStream.getUsed();
+
+    HardwareParse hwParser;
+    hwParser.parseCommands<FamilyType>(stream, startOffset);
+
+    auto pipeControlIterator = find<PIPE_CONTROL *>(hwParser.cmdList.begin(), hwParser.cmdList.end());
+    auto pipeControlCmd = genCmdCast<PIPE_CONTROL *>(*pipeControlIterator);
+
+    EXPECT_TRUE(pipeControlCmd->getHdcPipelineFlush());
+    EXPECT_TRUE(pipeControlCmd->getAmfsFlushEnable());
+    EXPECT_TRUE(pipeControlCmd->getCommandStreamerStallEnable());
+    EXPECT_TRUE(pipeControlCmd->getInstructionCacheInvalidateEnable());
+    EXPECT_TRUE(pipeControlCmd->getTextureCacheInvalidationEnable());
+    EXPECT_TRUE(pipeControlCmd->getUnTypedDataPortCacheFlush());
+    EXPECT_TRUE(pipeControlCmd->getConstantCacheInvalidationEnable());
+    EXPECT_TRUE(pipeControlCmd->getStateCacheInvalidationEnable());
+
+    auto stateComputeModelCmd = reinterpret_cast<STATE_COMPUTE_MODE *>(ptrOffset(stream.getCpuBase(), sizeof(PIPE_CONTROL)));
+    expectedScmCmd.setMaskBits(stateComputeModelCmd->getMaskBits());
+    EXPECT_TRUE(memcmp(&expectedScmCmd, stateComputeModelCmd, sizeof(STATE_COMPUTE_MODE)) == 0);
+}
+
+PVCTEST_F(PvcComputeModeRequirements, givenProgramPipeControlPriorToNonPipelinedStateCommandThenCorrectCommandsAreAdded) {
+    DebugManagerStateRestore dbgRestorer;
+    DebugManager.flags.ProgramPipeControlPriorToNonPipelinedStateCommand.set(true);
+
+    HardwareInfo hwInfo = *defaultHwInfo;
+    hwInfo.gtSystemInfo.CCSInfo.NumberOfCCSEnabled = 1;
+
+    SetUpImpl<FamilyType>(&hwInfo);
+
+    using STATE_COMPUTE_MODE = typename FamilyType::STATE_COMPUTE_MODE;
+    using PIPE_CONTROL = typename FamilyType::PIPE_CONTROL;
+
+    auto cmdsSize = sizeof(STATE_COMPUTE_MODE) + sizeof(PIPE_CONTROL);
+    char buff[1024] = {0};
+    LinearStream stream(buff, 1024);
+
+    auto expectedScmCmd = FamilyType::cmdInitStateComputeMode;
+    expectedScmCmd.setForceNonCoherent(STATE_COMPUTE_MODE::FORCE_NON_COHERENT_FORCE_GPU_NON_COHERENT);
+    expectedScmCmd.setEuThreadSchedulingModeOverride(STATE_COMPUTE_MODE::EU_THREAD_SCHEDULING_MODE_OVERRIDE_OLDEST_FIRST);
+    expectedScmCmd.setMaskBits(FamilyType::stateComputeModeForceNonCoherentMask | FamilyType::stateComputeModeLargeGrfModeMask |
+                               FamilyType::stateComputeModeEuThreadSchedulingModeOverrideMask);
+
+    overrideComputeModeRequest<FamilyType>(true, false, false, true, true);
+    getCsrHw<FamilyType>()->programComputeMode(stream, flags, hwInfo);
+    EXPECT_EQ(cmdsSize, stream.getUsed());
+
+    auto startOffset = getCsrHw<FamilyType>()->commandStream.getUsed();
+
+    HardwareParse hwParser;
+    hwParser.parseCommands<FamilyType>(stream, startOffset);
+
+    auto pipeControlIterator = find<PIPE_CONTROL *>(hwParser.cmdList.begin(), hwParser.cmdList.end());
+    auto pipeControlCmd = genCmdCast<PIPE_CONTROL *>(*pipeControlIterator);
+
+    EXPECT_TRUE(pipeControlCmd->getHdcPipelineFlush());
+    EXPECT_TRUE(pipeControlCmd->getAmfsFlushEnable());
+    EXPECT_TRUE(pipeControlCmd->getCommandStreamerStallEnable());
+    EXPECT_TRUE(pipeControlCmd->getInstructionCacheInvalidateEnable());
+    EXPECT_TRUE(pipeControlCmd->getTextureCacheInvalidationEnable());
+    EXPECT_TRUE(pipeControlCmd->getUnTypedDataPortCacheFlush());
+    EXPECT_TRUE(pipeControlCmd->getConstantCacheInvalidationEnable());
+    EXPECT_TRUE(pipeControlCmd->getStateCacheInvalidationEnable());
+
+    auto stateComputeModelCmd = reinterpret_cast<STATE_COMPUTE_MODE *>(ptrOffset(stream.getCpuBase(), sizeof(PIPE_CONTROL)));
+    expectedScmCmd.setMaskBits(stateComputeModelCmd->getMaskBits());
+    EXPECT_TRUE(memcmp(&expectedScmCmd, stateComputeModelCmd, sizeof(STATE_COMPUTE_MODE)) == 0);
+}

shared/test/unit_test/xe_hpg_core/CMakeLists.txt

@@ -7,6 +7,7 @@
 if(TESTS_XE_HPG_CORE)
   set(NEO_SHARED_tests_xe_hpg_core
       ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
+      ${CMAKE_CURRENT_SOURCE_DIR}/compute_mode_tests_xe_hpg_core.cpp
       ${CMAKE_CURRENT_SOURCE_DIR}/hw_cmds_xe_hpg_core_tests.cpp
       ${CMAKE_CURRENT_SOURCE_DIR}/test_encode_dispatch_kernel_xe_hpg_core.cpp
   )

shared/test/unit_test/xe_hpg_core/compute_mode_tests_xe_hpg_core.cpp

@@ -0,0 +1,82 @@
+/*
+ * Copyright (C) 2021-2022 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#include "shared/source/helpers/ptr_math.h"
+#include "shared/test/common/helpers/debug_manager_state_restore.h"
+#include "shared/test/common/helpers/unit_test_helper.h"
+#include "shared/test/common/mocks/mock_allocation_properties.h"
+#include "shared/test/common/mocks/mock_device.h"
+#include "shared/test/unit_test/command_stream/compute_mode_tests.h"
+
+using namespace NEO;
+
+using ComputeModeRequirementsXeHpgCore = ComputeModeRequirements;
+
+XE_HPG_CORETEST_F(ComputeModeRequirementsXeHpgCore, GivenVariousSettingsWhenComputeModeIsProgrammedThenThreadLimitsAreCorrectlySet) {
+    using STATE_COMPUTE_MODE = typename FamilyType::STATE_COMPUTE_MODE;
+
+    DebugManagerStateRestore restorer;
+    SetUpImpl<FamilyType>();
+    overrideComputeModeRequest<FamilyType>(false, false, false, true, 128u);
+
+    auto defaultScmCmd = FamilyType::cmdInitStateComputeMode;
+    EXPECT_EQ(STATE_COMPUTE_MODE::Z_PASS_ASYNC_COMPUTE_THREAD_LIMIT_MAX_60, defaultScmCmd.getZPassAsyncComputeThreadLimit());
+    EXPECT_EQ(STATE_COMPUTE_MODE::PIXEL_ASYNC_COMPUTE_THREAD_LIMIT_DISABLED, defaultScmCmd.getPixelAsyncComputeThreadLimit());
+
+    char buff[1024];
+    auto pCsr = getCsrHw<FamilyType>();
+    struct {
+        typename STATE_COMPUTE_MODE::Z_PASS_ASYNC_COMPUTE_THREAD_LIMIT zPassThreadLimit;
+        typename STATE_COMPUTE_MODE::PIXEL_ASYNC_COMPUTE_THREAD_LIMIT pixelThreadLimit;
+    } testValues[] = {
+        {STATE_COMPUTE_MODE::Z_PASS_ASYNC_COMPUTE_THREAD_LIMIT_MAX_60, STATE_COMPUTE_MODE::PIXEL_ASYNC_COMPUTE_THREAD_LIMIT_DISABLED},
+        {STATE_COMPUTE_MODE::Z_PASS_ASYNC_COMPUTE_THREAD_LIMIT_MAX_60, STATE_COMPUTE_MODE::PIXEL_ASYNC_COMPUTE_THREAD_LIMIT_MAX_2},
+        {STATE_COMPUTE_MODE::Z_PASS_ASYNC_COMPUTE_THREAD_LIMIT_MAX_60, STATE_COMPUTE_MODE::PIXEL_ASYNC_COMPUTE_THREAD_LIMIT_MAX_8},
+        {STATE_COMPUTE_MODE::Z_PASS_ASYNC_COMPUTE_THREAD_LIMIT_MAX_60, STATE_COMPUTE_MODE::PIXEL_ASYNC_COMPUTE_THREAD_LIMIT_MAX_16},
+        {STATE_COMPUTE_MODE::Z_PASS_ASYNC_COMPUTE_THREAD_LIMIT_MAX_60, STATE_COMPUTE_MODE::PIXEL_ASYNC_COMPUTE_THREAD_LIMIT_MAX_24},
+        {STATE_COMPUTE_MODE::Z_PASS_ASYNC_COMPUTE_THREAD_LIMIT_MAX_60, STATE_COMPUTE_MODE::PIXEL_ASYNC_COMPUTE_THREAD_LIMIT_MAX_32},
+        {STATE_COMPUTE_MODE::Z_PASS_ASYNC_COMPUTE_THREAD_LIMIT_MAX_60, STATE_COMPUTE_MODE::PIXEL_ASYNC_COMPUTE_THREAD_LIMIT_MAX_40},
+        {STATE_COMPUTE_MODE::Z_PASS_ASYNC_COMPUTE_THREAD_LIMIT_MAX_60, STATE_COMPUTE_MODE::PIXEL_ASYNC_COMPUTE_THREAD_LIMIT_MAX_48},
+        {STATE_COMPUTE_MODE::Z_PASS_ASYNC_COMPUTE_THREAD_LIMIT_MAX_64, STATE_COMPUTE_MODE::PIXEL_ASYNC_COMPUTE_THREAD_LIMIT_DISABLED},
+        {STATE_COMPUTE_MODE::Z_PASS_ASYNC_COMPUTE_THREAD_LIMIT_MAX_56, STATE_COMPUTE_MODE::PIXEL_ASYNC_COMPUTE_THREAD_LIMIT_DISABLED},
+        {STATE_COMPUTE_MODE::Z_PASS_ASYNC_COMPUTE_THREAD_LIMIT_MAX_48, STATE_COMPUTE_MODE::PIXEL_ASYNC_COMPUTE_THREAD_LIMIT_DISABLED},
+    };
+
+    for (auto testValue : testValues) {
+        DebugManager.flags.ForceZPassAsyncComputeThreadLimit.set(testValue.zPassThreadLimit);
+        DebugManager.flags.ForcePixelAsyncComputeThreadLimit.set(testValue.pixelThreadLimit);
+
+        pCsr->streamProperties.stateComputeMode = {};
+        pCsr->streamProperties.stateComputeMode.setProperties(false, 0u, 0u);
+        LinearStream stream(buff, 1024);
+        pCsr->programComputeMode(stream, flags, *defaultHwInfo);
+        EXPECT_EQ(sizeof(STATE_COMPUTE_MODE), stream.getUsed());
+
+        auto pScmCmd = reinterpret_cast<STATE_COMPUTE_MODE *>(stream.getCpuBase());
+        EXPECT_EQ(testValue.zPassThreadLimit, pScmCmd->getZPassAsyncComputeThreadLimit());
+        EXPECT_EQ(testValue.pixelThreadLimit, pScmCmd->getPixelAsyncComputeThreadLimit());
+
+        auto expectedFields = FamilyType::stateComputeModeZPassAsyncComputeThreadLimitMask |
+                              FamilyType::stateComputeModePixelAsyncComputeThreadLimitMask;
+        EXPECT_TRUE(isValueSet(pScmCmd->getMaskBits(), expectedFields));
+    }
+
+    DebugManager.flags.ForceZPassAsyncComputeThreadLimit.set(-1);
+    DebugManager.flags.ForcePixelAsyncComputeThreadLimit.set(-1);
+
+    pCsr->streamProperties.stateComputeMode = {};
+    pCsr->streamProperties.stateComputeMode.setProperties(false, 0u, 0u);
+    LinearStream stream(buff, 1024);
+    pCsr->programComputeMode(stream, flags, *defaultHwInfo);
+    EXPECT_EQ(sizeof(STATE_COMPUTE_MODE), stream.getUsed());
+
+    auto pScmCmd = reinterpret_cast<STATE_COMPUTE_MODE *>(stream.getCpuBase());
+    EXPECT_EQ(STATE_COMPUTE_MODE::Z_PASS_ASYNC_COMPUTE_THREAD_LIMIT_MAX_60, pScmCmd->getZPassAsyncComputeThreadLimit());
+    EXPECT_EQ(STATE_COMPUTE_MODE::PIXEL_ASYNC_COMPUTE_THREAD_LIMIT_DISABLED, pScmCmd->getPixelAsyncComputeThreadLimit());
+    EXPECT_FALSE(isValueSet(pScmCmd->getMaskBits(), FamilyType::stateComputeModeZPassAsyncComputeThreadLimitMask));
+    EXPECT_FALSE(isValueSet(pScmCmd->getMaskBits(), FamilyType::stateComputeModePixelAsyncComputeThreadLimitMask));
+}

shared/test/unit_test/xe_hpg_core/dg2/CMakeLists.txt

@@ -0,0 +1,13 @@
+#
+# Copyright (C) 2022 Intel Corporation
+#
+# SPDX-License-Identifier: MIT
+#
+
+if(TESTS_DG2)
+  target_sources(neo_shared_tests PRIVATE
+                 ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
+                 ${CMAKE_CURRENT_SOURCE_DIR}/compute_mode_tests_dg2.cpp
+  )
+endif()
+

shared/test/unit_test/xe_hpg_core/dg2/compute_mode_tests_dg2.cpp

@@ -0,0 +1,138 @@
+/*
+ * Copyright (C) 2021-2022 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#include "shared/source/helpers/ptr_math.h"
+#include "shared/test/common/helpers/debug_manager_state_restore.h"
+#include "shared/test/common/helpers/engine_descriptor_helper.h"
+#include "shared/test/common/helpers/unit_test_helper.h"
+#include "shared/test/common/mocks/mock_allocation_properties.h"
+#include "shared/test/common/mocks/mock_device.h"
+#include "shared/test/common/mocks/mock_os_context.h"
+#include "shared/test/common/test_macros/test.h"
+#include "shared/test/unit_test/command_stream/compute_mode_tests.h"
+
+#include "test_traits_common.h"
+
+using namespace NEO;
+
+HWTEST2_F(ComputeModeRequirements, GivenProgramPipeControlPriorToNonPipelinedStateCommandThenCorrectCommandsAreAdded, IsDG2) {
+    DebugManagerStateRestore dbgRestorer;
+    DebugManager.flags.ProgramPipeControlPriorToNonPipelinedStateCommand.set(true);
+
+    SetUpImpl<FamilyType>();
+
+    using STATE_COMPUTE_MODE = typename FamilyType::STATE_COMPUTE_MODE;
+    using PIPE_CONTROL = typename FamilyType::PIPE_CONTROL;
+
+    auto cmdsSize = sizeof(STATE_COMPUTE_MODE) + sizeof(PIPE_CONTROL);
+    char buff[1024] = {0};
+    LinearStream stream(buff, 1024);
+
+    auto expectedScmCmd = FamilyType::cmdInitStateComputeMode;
+    expectedScmCmd.setForceNonCoherent(STATE_COMPUTE_MODE::FORCE_NON_COHERENT_FORCE_GPU_NON_COHERENT);
+    auto expectedBitsMask = FamilyType::stateComputeModeForceNonCoherentMask | FamilyType::stateComputeModeLargeGrfModeMask;
+
+    overrideComputeModeRequest<FamilyType>(true, false, false, false, true);
+    getCsrHw<FamilyType>()->programComputeMode(stream, flags, *defaultHwInfo);
+    EXPECT_EQ(cmdsSize, stream.getUsed());
+
+    auto startOffset = getCsrHw<FamilyType>()->commandStream.getUsed();
+
+    HardwareParse hwParser;
+    hwParser.parseCommands<FamilyType>(stream, startOffset);
+
+    auto pipeControlIterator = find<PIPE_CONTROL *>(hwParser.cmdList.begin(), hwParser.cmdList.end());
+    auto pipeControlCmd = genCmdCast<PIPE_CONTROL *>(*pipeControlIterator);
+
+    EXPECT_TRUE(pipeControlCmd->getHdcPipelineFlush());
+    EXPECT_TRUE(pipeControlCmd->getAmfsFlushEnable());
+    EXPECT_TRUE(pipeControlCmd->getCommandStreamerStallEnable());
+    EXPECT_TRUE(pipeControlCmd->getInstructionCacheInvalidateEnable());
+    EXPECT_TRUE(pipeControlCmd->getTextureCacheInvalidationEnable());
+    EXPECT_TRUE(pipeControlCmd->getUnTypedDataPortCacheFlush());
+    EXPECT_TRUE(pipeControlCmd->getConstantCacheInvalidationEnable());
+    EXPECT_TRUE(pipeControlCmd->getStateCacheInvalidationEnable());
+
+    auto stateComputeModelCmd = reinterpret_cast<STATE_COMPUTE_MODE *>(ptrOffset(stream.getCpuBase(), sizeof(PIPE_CONTROL)));
+    EXPECT_TRUE(isValueSet(stateComputeModelCmd->getMaskBits(), expectedBitsMask));
+    expectedScmCmd.setMaskBits(stateComputeModelCmd->getMaskBits());
+    EXPECT_TRUE(memcmp(&expectedScmCmd, stateComputeModelCmd, sizeof(STATE_COMPUTE_MODE)) == 0);
+}
+
+HWTEST2_F(ComputeModeRequirements, GivenMultipleCCSEnabledSetupThenCorrectCommandsAreAdded, IsDG2) {
+    HardwareInfo hwInfo = *defaultHwInfo;
+    hwInfo.gtSystemInfo.CCSInfo.NumberOfCCSEnabled = 2;
+
+    SetUpImpl<FamilyType>(&hwInfo);
+    MockOsContext ccsOsContext(0, EngineDescriptorHelper::getDefaultDescriptor({aub_stream::ENGINE_CCS, EngineUsage::Regular}));
+
+    getCsrHw<FamilyType>()->setupContext(ccsOsContext);
+
+    using STATE_COMPUTE_MODE = typename FamilyType::STATE_COMPUTE_MODE;
+    using PIPE_CONTROL = typename FamilyType::PIPE_CONTROL;
+
+    auto cmdsSize = sizeof(STATE_COMPUTE_MODE) + sizeof(PIPE_CONTROL);
+    char buff[1024] = {0};
+    LinearStream stream(buff, 1024);
+
+    auto expectedScmCmd = FamilyType::cmdInitStateComputeMode;
+    expectedScmCmd.setForceNonCoherent(STATE_COMPUTE_MODE::FORCE_NON_COHERENT_FORCE_GPU_NON_COHERENT);
+    auto expectedBitsMask = FamilyType::stateComputeModeForceNonCoherentMask | FamilyType::stateComputeModeLargeGrfModeMask;
+
+    overrideComputeModeRequest<FamilyType>(true, false, false, false, true);
+    getCsrHw<FamilyType>()->programComputeMode(stream, flags, hwInfo);
+    EXPECT_EQ(cmdsSize, stream.getUsed());
+
+    auto startOffset = getCsrHw<FamilyType>()->commandStream.getUsed();
+
+    HardwareParse hwParser;
+    hwParser.parseCommands<FamilyType>(stream, startOffset);
+
+    auto pipeControlIterator = find<PIPE_CONTROL *>(hwParser.cmdList.begin(), hwParser.cmdList.end());
+    auto pipeControlCmd = genCmdCast<PIPE_CONTROL *>(*pipeControlIterator);
+
+    EXPECT_TRUE(pipeControlCmd->getHdcPipelineFlush());
+    EXPECT_TRUE(pipeControlCmd->getAmfsFlushEnable());
+    EXPECT_TRUE(pipeControlCmd->getCommandStreamerStallEnable());
+    EXPECT_TRUE(pipeControlCmd->getInstructionCacheInvalidateEnable());
+    EXPECT_TRUE(pipeControlCmd->getTextureCacheInvalidationEnable());
+    EXPECT_TRUE(pipeControlCmd->getUnTypedDataPortCacheFlush());
+    EXPECT_TRUE(pipeControlCmd->getConstantCacheInvalidationEnable());
+    EXPECT_TRUE(pipeControlCmd->getStateCacheInvalidationEnable());
+
+    auto stateComputeModelCmd = reinterpret_cast<STATE_COMPUTE_MODE *>(ptrOffset(stream.getCpuBase(), sizeof(PIPE_CONTROL)));
+    EXPECT_TRUE(isValueSet(stateComputeModelCmd->getMaskBits(), expectedBitsMask));
+    expectedScmCmd.setMaskBits(stateComputeModelCmd->getMaskBits());
+    EXPECT_TRUE(memcmp(&expectedScmCmd, stateComputeModelCmd, sizeof(STATE_COMPUTE_MODE)) == 0);
+}
+
+HWTEST2_F(ComputeModeRequirements, GivenProgramPipeControlPriorToNonPipelinedStateCommandThenCommandSizeIsCalculatedAndCorrectCommandSizeIsReturned, IsDG2) {
+    DebugManagerStateRestore dbgRestorer;
+    DebugManager.flags.ProgramPipeControlPriorToNonPipelinedStateCommand.set(true);
+
+    using STATE_COMPUTE_MODE = typename FamilyType::STATE_COMPUTE_MODE;
+    using PIPE_CONTROL = typename FamilyType::PIPE_CONTROL;
+    SetUpImpl<FamilyType>();
+
+    auto cmdsSize = sizeof(STATE_COMPUTE_MODE) + sizeof(PIPE_CONTROL);
+
+    overrideComputeModeRequest<FamilyType>(false, false, false);
+    auto retSize = getCsrHw<FamilyType>()->getCmdSizeForComputeMode();
+    EXPECT_EQ(0u, retSize);
+
+    overrideComputeModeRequest<FamilyType>(false, true, false);
+    retSize = getCsrHw<FamilyType>()->getCmdSizeForComputeMode();
+    EXPECT_EQ(0u, retSize);
+
+    overrideComputeModeRequest<FamilyType>(true, true, false);
+    retSize = getCsrHw<FamilyType>()->getCmdSizeForComputeMode();
+    EXPECT_EQ(cmdsSize, retSize);
+
+    overrideComputeModeRequest<FamilyType>(true, false, false);
+    retSize = getCsrHw<FamilyType>()->getCmdSizeForComputeMode();
+    EXPECT_EQ(cmdsSize, retSize);
+}