intel/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2025-12-20 00:24:58 +08:00
Code Issues Packages Projects Releases Wiki Activity

Remove redundant value CsrSizeRequestFlags::numGrfRequiredChanged

Browse Source 
Related-To: NEO-5995

Signed-off-by: Filip Hazubski <filip.hazubski@intel.com>
This commit is contained in:
Filip Hazubski
2022-03-14 16:40:32 +00:00
committed by Compute-Runtime-Automation
parent adc5fb30d7
commit 32b0f7b014
34 changed files with 72 additions and 207 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
level_zero/core/source/cmdlist/cmdlist_hw_immediate.inl
View File

@@ -33,7 +33,7 @@ ze_result_t CommandListCoreFamilyImmediate<gfxCoreFamily>::executeCommandListImm
nullptr, //flushStampReference
NEO::QueueThrottle::MEDIUM, //throttle
this->getCommandListPreemptionMode(), //preemptionMode
this->commandContainer.lastSentNumGrfRequired, //numGrfRequired
GrfConfig::NotApplicable, //numGrfRequired
NEO::L3CachingSettings::l3CacheOn, //l3CacheSettings
this->requiredStreamState.stateComputeMode.threadArbitrationPolicy.value, //threadArbitrationPolicy
NEO::AdditionalKernelExecInfo::NotApplicable, //additionalKernelExecInfo

8
opencl/test/unit_test/gen11/coherency_tests_gen11.cpp
View File

@@ -46,19 +46,19 @@ struct Gen11CoherencyRequirements : public ::testing::Test {
GEN11TEST_F(Gen11CoherencyRequirements, GivenSettingsWhenCoherencyRequestedThenProgrammingIsCorrect) {
auto lriSize = sizeof(MI_LOAD_REGISTER_IMM);
overrideCoherencyRequest(false, false);
EXPECT_FALSE(csr->isComputeModeNeeded());
EXPECT_FALSE(csr->streamProperties.stateComputeMode.isDirty());
overrideCoherencyRequest(false, true);
EXPECT_FALSE(csr->isComputeModeNeeded());
EXPECT_FALSE(csr->streamProperties.stateComputeMode.isDirty());
overrideCoherencyRequest(true, true);
auto retSize = csr->getCmdSizeForComputeMode();
EXPECT_TRUE(csr->isComputeModeNeeded());
EXPECT_TRUE(csr->streamProperties.stateComputeMode.isDirty());
EXPECT_EQ(lriSize, retSize);
overrideCoherencyRequest(true, false);
retSize = csr->getCmdSizeForComputeMode();
EXPECT_TRUE(csr->isComputeModeNeeded());
EXPECT_TRUE(csr->streamProperties.stateComputeMode.isDirty());
EXPECT_EQ(lriSize, retSize);
}

16
opencl/test/unit_test/gen12lp/coherency_tests_gen12lp.inl
View File

@@ -72,19 +72,19 @@ GEN12LPTEST_F(Gen12LpCoherencyRequirements, GivenNoSharedHandlesWhenGettingCmdSi
}
overrideCoherencyRequest(false, false, false);
EXPECT_FALSE(csr->isComputeModeNeeded());
EXPECT_FALSE(csr->streamProperties.stateComputeMode.isDirty());
overrideCoherencyRequest(false, true, false);
EXPECT_FALSE(csr->isComputeModeNeeded());
EXPECT_FALSE(csr->streamProperties.stateComputeMode.isDirty());
overrideCoherencyRequest(true, true, false);
auto retSize = csr->getCmdSizeForComputeMode();
EXPECT_TRUE(csr->isComputeModeNeeded());
EXPECT_TRUE(csr->streamProperties.stateComputeMode.isDirty());
EXPECT_EQ(cmdsSize, retSize);
overrideCoherencyRequest(true, false, false);
retSize = csr->getCmdSizeForComputeMode();
EXPECT_TRUE(csr->isComputeModeNeeded());
EXPECT_TRUE(csr->streamProperties.stateComputeMode.isDirty());
EXPECT_EQ(cmdsSize, retSize);
}
@@ -99,19 +99,19 @@ GEN12LPTEST_F(Gen12LpCoherencyRequirements, GivenSharedHandlesWhenGettingCmdSize
}
overrideCoherencyRequest(false, false, true);
EXPECT_FALSE(csr->isComputeModeNeeded());
EXPECT_FALSE(csr->streamProperties.stateComputeMode.isDirty());
overrideCoherencyRequest(false, true, true);
EXPECT_FALSE(csr->isComputeModeNeeded());
EXPECT_FALSE(csr->streamProperties.stateComputeMode.isDirty());
overrideCoherencyRequest(true, true, true);
auto retSize = csr->getCmdSizeForComputeMode();
EXPECT_TRUE(csr->isComputeModeNeeded());
EXPECT_TRUE(csr->streamProperties.stateComputeMode.isDirty());
EXPECT_EQ(cmdsSize, retSize);
overrideCoherencyRequest(true, false, true);
retSize = csr->getCmdSizeForComputeMode();
EXPECT_TRUE(csr->isComputeModeNeeded());
EXPECT_TRUE(csr->streamProperties.stateComputeMode.isDirty());
EXPECT_EQ(cmdsSize, retSize);
}

1
shared/source/command_container/cmdcontainer.cpp
View File

@@ -154,7 +154,6 @@ void CommandContainer::reset() {
iddBlock = nullptr;
nextIddInBlock = this->getNumIddPerBlock();
lastSentNumGrfRequired = 0;
lastPipelineSelectModeRequired = false;
lastSentUseGlobalAtomics = false;
}

1
shared/source/command_container/cmdcontainer.h
View File

@@ -77,7 +77,6 @@ class CommandContainer : public NonCopyableOrMovableClass {
uint32_t slmSize = std::numeric_limits<uint32_t>::max();
uint32_t nextIddInBlock = 0;
uint32_t lastSentNumGrfRequired = 0;
bool lastPipelineSelectModeRequired = false;
bool lastSentUseGlobalAtomics = false;

1
shared/source/command_stream/command_stream_receiver.h
View File

@@ -384,7 +384,6 @@ class CommandStreamReceiver {
std::chrono::microseconds gpuHangCheckPeriod{500'000};
uint32_t lastSentL3Config = 0;
uint32_t latestSentStatelessMocsConfig = 0;
uint32_t lastSentNumGrfRequired = GrfConfig::DefaultGrfNumber;
uint64_t lastSentSliceCount = QueueSliceCount::defaultSliceCount;
uint32_t requiredScratchSize = 0;

1
shared/source/command_stream/command_stream_receiver_hw.h
View File

@@ -75,7 +75,6 @@ class CommandStreamReceiverHw : public CommandStreamReceiver {
size_t getCmdSizeForComputeMode();
MOCKABLE_VIRTUAL bool hasSharedHandles();
bool isComputeModeNeeded() const;
bool isPipelineSelectAlreadyProgrammed() const;
void programComputeMode(LinearStream &csr, DispatchFlags &dispatchFlags, const HardwareInfo &hwInfo);

11
shared/source/command_stream/command_stream_receiver_hw_base.inl
View File

@@ -268,10 +268,6 @@ CompletionStamp CommandStreamReceiverHw<GfxFamily>::flushTask(
dispatchFlags.pipelineSelectArgs.specialPipelineSelectMode,
hwInfo);
if (dispatchFlags.numGrfRequired == GrfConfig::NotApplicable) {
dispatchFlags.numGrfRequired = lastSentNumGrfRequired;
}
auto requiresCoherency = hwHelper.forceNonGpuCoherencyWA(dispatchFlags.requiresCoherency);
this->streamProperties.stateComputeMode.setProperties(requiresCoherency, dispatchFlags.numGrfRequired,
dispatchFlags.threadArbitrationPolicy, hwInfo);
@@ -281,9 +277,6 @@ CompletionStamp CommandStreamReceiverHw<GfxFamily>::flushTask(
csrSizeRequestFlags.mediaSamplerConfigChanged = this->lastMediaSamplerConfig != static_cast<int8_t>(dispatchFlags.pipelineSelectArgs.mediaSamplerRequired);
csrSizeRequestFlags.specialPipelineSelectModeChanged = isSpecialPipelineSelectModeChanged;
csrSizeRequestFlags.numGrfRequiredChanged = this->lastSentNumGrfRequired != dispatchFlags.numGrfRequired;
lastSentNumGrfRequired = dispatchFlags.numGrfRequired;
csrSizeRequestFlags.activePartitionsChanged = isProgramActivePartitionConfigRequired();
auto force32BitAllocations = getMemoryManager()->peekForce32BitAllocations();
@@ -809,7 +802,7 @@ size_t CommandStreamReceiverHw<GfxFamily>::getRequiredCmdStreamSize(const Dispat
size += sizeof(typename GfxFamily::MI_BATCH_BUFFER_START);
size += getCmdSizeForL3Config();
if (isComputeModeNeeded()) {
if (this->streamProperties.stateComputeMode.isDirty()) {
size += getCmdSizeForComputeMode();
}
size += getCmdSizeForMediaSampler(dispatchFlags.pipelineSelectArgs.mediaSamplerRequired);
@@ -1373,7 +1366,7 @@ inline MemoryCompressionState CommandStreamReceiverHw<GfxFamily>::getMemoryCompr
template <typename GfxFamily>
inline bool CommandStreamReceiverHw<GfxFamily>::isPipelineSelectAlreadyProgrammed() const {
const auto &hwInfoConfig = *HwInfoConfig::get(peekHwInfo().platform.eProductFamily);
return isComputeModeNeeded() && hwInfoConfig.is3DPipelineSelectWARequired() && isRcs();
return this->streamProperties.stateComputeMode.isDirty() && hwInfoConfig.is3DPipelineSelectWARequired() && isRcs();
}
template <typename GfxFamily>

9
shared/source/command_stream/command_stream_receiver_hw_tgllp_and_later.inl
View File

@@ -9,25 +9,18 @@
#include "shared/source/command_stream/command_stream_receiver_hw.h"
#include "shared/source/device/device.h"
#include "shared/source/helpers/pipe_control_args.h"
#include "shared/source/helpers/state_compute_mode_helper.h"
#include "shared/source/os_interface/hw_info_config.h"
namespace NEO {
template <typename GfxFamily>
void CommandStreamReceiverHw<GfxFamily>::programComputeMode(LinearStream &stream, DispatchFlags &dispatchFlags, const HardwareInfo &hwInfo) {
if (isComputeModeNeeded()) {
if (this->streamProperties.stateComputeMode.isDirty()) {
EncodeComputeMode<GfxFamily>::programComputeModeCommandWithSynchronization(
stream, this->streamProperties.stateComputeMode, dispatchFlags.pipelineSelectArgs,
hasSharedHandles(), hwInfo, isRcs());
}
}
template <typename GfxFamily>
inline bool CommandStreamReceiverHw<GfxFamily>::isComputeModeNeeded() const {
return StateComputeModeHelper<Family>::isStateComputeModeRequired(csrSizeRequestFlags, false) ||
this->streamProperties.stateComputeMode.isDirty();
}
template <>
inline void CommandStreamReceiverHw<Family>::addPipeControlBeforeStateBaseAddress(LinearStream &commandStream) {
PipeControlArgs args;

1
shared/source/command_stream/csr_definitions.h
View File

@@ -123,7 +123,6 @@ struct CsrSizeRequestFlags {
bool preemptionRequestChanged = false;
bool mediaSamplerConfigChanged = false;
bool hasSharedHandles = false;
bool numGrfRequiredChanged = false;
bool specialPipelineSelectModeChanged = false;
bool activePartitionsChanged = false;
};

6
shared/source/command_stream/stream_properties.cpp
View File

@@ -19,8 +19,10 @@ void StateComputeModeProperties::setProperties(bool requiresCoherency, uint32_t
int32_t isCoherencyRequired = (requiresCoherency ? 1 : 0);
this->isCoherencyRequired.set(isCoherencyRequired);
int32_t largeGrfMode = (numGrfRequired == GrfConfig::LargeGrfNumber ? 1 : 0);
this->largeGrfMode.set(largeGrfMode);
if (this->largeGrfMode.value == -1 || numGrfRequired != GrfConfig::NotApplicable) {
int32_t largeGrfMode = (numGrfRequired == GrfConfig::LargeGrfNumber ? 1 : 0);
this->largeGrfMode.set(largeGrfMode);
}
int32_t zPassAsyncComputeThreadLimit = -1;
if (DebugManager.flags.ForceZPassAsyncComputeThreadLimit.get() != -1) {

4
shared/source/enable_cores.cmake
View File

@@ -160,10 +160,6 @@ macro(macro_for_each_core_type)
endif()
endforeach()
set(SRC_FILE "${CORE_COREX_PREFIX}/state_compute_mode_helper_${CORE_TYPE_LOWER}.cpp")
if(EXISTS ${SRC_FILE})
list(APPEND CORE_SRCS_${CORE_TYPE}_CPP_BASE ${SRC_FILE})
endif()
if(EXISTS ${GENERATED_COREX_PREFIX}/hw_cmds_generated_${CORE_TYPE_LOWER}.inl)
list(APPEND CORE_SRCS_${CORE_TYPE}_H_BASE "${GENERATED_COREX_PREFIX}/hw_cmds_generated_${CORE_TYPE_LOWER}.inl")
endif()

7
shared/source/gen11/command_stream_receiver_hw_gen11.cpp
View File

@@ -19,18 +19,13 @@ static auto gfxCore = IGFX_GEN11_CORE;
template <>
void CommandStreamReceiverHw<Family>::programComputeMode(LinearStream &stream, DispatchFlags &dispatchFlags, const HardwareInfo &hwInfo) {
if (this->isComputeModeNeeded()) {
if (this->streamProperties.stateComputeMode.isCoherencyRequired.isDirty) {
EncodeComputeMode<Family>::programComputeModeCommandWithSynchronization(
stream, this->streamProperties.stateComputeMode, dispatchFlags.pipelineSelectArgs,
hasSharedHandles(), hwInfo, isRcs());
}
}
template <typename GfxFamily>
inline bool CommandStreamReceiverHw<GfxFamily>::isComputeModeNeeded() const {
return this->streamProperties.stateComputeMode.isCoherencyRequired.isDirty;
}
template <>
void CommandStreamReceiverHw<Family>::programMediaSampler(LinearStream &stream, DispatchFlags &dispatchFlags) {
using PWR_CLK_STATE_REGISTER = Family::PWR_CLK_STATE_REGISTER;

17
shared/source/gen12lp/state_compute_mode_helper_gen12lp.cpp
View File

@@ -1,17 +0,0 @@
/*
* Copyright (C) 2019-2021 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "shared/source/helpers/state_compute_mode_helper.h"
namespace NEO {
template <>
bool StateComputeModeHelper<TGLLPFamily>::isStateComputeModeRequired(const CsrSizeRequestFlags &csrSizeRequestFlags, bool isThreadArbitionPolicyProgrammed) {
return csrSizeRequestFlags.numGrfRequiredChanged;
}
} // namespace NEO

5
shared/source/gen8/command_stream_receiver_hw_gen8.cpp
View File

@@ -19,11 +19,6 @@ template <>
void CommandStreamReceiverHw<Family>::programComputeMode(LinearStream &stream, DispatchFlags &dispatchFlags, const HardwareInfo &hwInfo) {
}
template <typename GfxFamily>
inline bool CommandStreamReceiverHw<GfxFamily>::isComputeModeNeeded() const {
return false;
}
template <>
void populateFactoryTable<CommandStreamReceiverHw<Family>>() {
extern CommandStreamReceiverCreateFunc commandStreamReceiverFactory[2 * IGFX_MAX_CORE];

5
shared/source/gen9/command_stream_receiver_hw_gen9.cpp
View File

@@ -19,11 +19,6 @@ template <>
void CommandStreamReceiverHw<Family>::programComputeMode(LinearStream &stream, DispatchFlags &dispatchFlags, const HardwareInfo &hwInfo) {
}
template <typename GfxFamily>
inline bool CommandStreamReceiverHw<GfxFamily>::isComputeModeNeeded() const {
return false;
}
template <>
void populateFactoryTable<CommandStreamReceiverHw<Family>>() {
extern CommandStreamReceiverCreateFunc commandStreamReceiverFactory[2 * IGFX_MAX_CORE];

1
shared/source/helpers/CMakeLists.txt
View File

@@ -116,7 +116,6 @@ set(NEO_CORE_HELPERS
${CMAKE_CURRENT_SOURCE_DIR}/state_base_address_bdw_and_later.inl
${CMAKE_CURRENT_SOURCE_DIR}/state_base_address_icllp_and_later.inl
${CMAKE_CURRENT_SOURCE_DIR}/state_base_address_skl.inl
${CMAKE_CURRENT_SOURCE_DIR}/state_compute_mode_helper.h
${CMAKE_CURRENT_SOURCE_DIR}/stdio.h
${CMAKE_CURRENT_SOURCE_DIR}/string.h
${CMAKE_CURRENT_SOURCE_DIR}/string_helpers.h

18
shared/source/helpers/state_compute_mode_helper.h
View File

@@ -1,18 +0,0 @@
/*
* Copyright (C) 2019-2020 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#pragma once
#include "shared/source/command_stream/csr_definitions.h"
#include "hw_cmds.h"
namespace NEO {
template <typename GfxFamily>
struct StateComputeModeHelper {
static bool isStateComputeModeRequired(const CsrSizeRequestFlags &csrSizeRequestFlags, bool isThreadArbitionPolicyProgrammed);
};
} // namespace NEO

17
shared/source/xe_hp_core/state_compute_mode_helper_xe_hp_core.cpp
View File

@@ -1,17 +0,0 @@
/*
* Copyright (C) 2021 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "shared/source/helpers/state_compute_mode_helper.h"
namespace NEO {
template <>
bool StateComputeModeHelper<XeHpFamily>::isStateComputeModeRequired(const CsrSizeRequestFlags &csrSizeRequestFlags, bool isThreadArbitionPolicyProgrammed) {
return csrSizeRequestFlags.numGrfRequiredChanged;
}
} // namespace NEO

1
shared/source/xe_hpc_core/command_stream_receiver_hw_xe_hpc_core.cpp
View File

@@ -16,7 +16,6 @@ using Family = NEO::XE_HPC_COREFamily;
#include "shared/source/command_stream/command_stream_receiver_hw_xehp_and_later.inl"
#include "shared/source/helpers/blit_commands_helper_xehp_and_later.inl"
#include "shared/source/helpers/populate_factory.h"
#include "shared/source/helpers/state_compute_mode_helper.h"
namespace NEO {
static auto gfxCore = IGFX_XE_HPC_CORE;

21
shared/source/xe_hpc_core/state_compute_mode_helper_xe_hpc_core.cpp
View File

@@ -1,21 +0,0 @@
/*
* Copyright (C) 2020-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "shared/source/helpers/state_compute_mode_helper.h"
namespace NEO {
using Family = XE_HPC_COREFamily;
template <>
bool StateComputeModeHelper<Family>::isStateComputeModeRequired(const CsrSizeRequestFlags &csrSizeRequestFlags, bool isThreadArbitionPolicyProgrammed) {
return csrSizeRequestFlags.numGrfRequiredChanged;
}
template struct StateComputeModeHelper<Family>;
} // namespace NEO

17
shared/source/xe_hpg_core/state_compute_mode_helper_xe_hpg_core.cpp
View File

@@ -1,17 +0,0 @@
/*
* Copyright (C) 2021 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "shared/source/helpers/state_compute_mode_helper.h"
namespace NEO {
template <>
bool StateComputeModeHelper<XE_HPG_COREFamily>::isStateComputeModeRequired(const CsrSizeRequestFlags &csrSizeRequestFlags, bool isThreadArbitionPolicyProgrammed) {
return csrSizeRequestFlags.numGrfRequiredChanged;
}
} // namespace NEO

2
shared/test/common/gen12lp/test_command_encoder_gen12lp.cpp
View File

@@ -32,7 +32,7 @@ GEN12LPTEST_F(CommandEncoderTest, WhenAdjustComputeModeIsCalledThenStateComputeM
// Adjust the State Compute Mode which sets FORCE_NON_COHERENT_FORCE_GPU_NON_COHERENT
StreamProperties properties{};
properties.stateComputeMode.setProperties(false, cmdContainer.lastSentNumGrfRequired, 0, *defaultHwInfo);
properties.stateComputeMode.setProperties(false, GrfConfig::DefaultGrfNumber, 0, *defaultHwInfo);
NEO::EncodeComputeMode<FamilyType>::programComputeModeCommand(*cmdContainer.getCommandStream(),
properties.stateComputeMode, *defaultHwInfo);

2
shared/test/unit_test/command_container/command_container_tests.cpp
View File

@@ -241,13 +241,11 @@ TEST_F(CommandContainerTest, givenCommandContainerWhenResetThenStateIsReset) {
cmdContainer.initialize(pDevice, nullptr);
LinearStream stream;
uint32_t usedSize = 1;
cmdContainer.lastSentNumGrfRequired = 64;
cmdContainer.getCommandStream()->getSpace(usedSize);
EXPECT_EQ(usedSize, cmdContainer.getCommandStream()->getUsed());
cmdContainer.reset();
EXPECT_NE(usedSize, cmdContainer.getCommandStream()->getUsed());
EXPECT_EQ(0u, cmdContainer.getCommandStream()->getUsed());
EXPECT_EQ(0u, cmdContainer.lastSentNumGrfRequired);
EXPECT_EQ(cmdContainer.getIddBlock(), nullptr);
EXPECT_EQ(cmdContainer.getNumIddPerBlock(), defaultNumIddsPerBlock);
}

2
shared/test/unit_test/command_stream/compute_mode_tests.h
View File

@@ -56,9 +56,7 @@ struct ComputeModeRequirements : public ::testing::Test {
uint32_t numGrfRequired) {
auto csrHw = getCsrHw<FamilyType>();
csrHw->hasSharedHandlesReturnValue = 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);

6
shared/test/unit_test/command_stream/compute_mode_tests_pvc_and_later.cpp
View File

@@ -19,15 +19,15 @@ HWTEST2_F(ComputeModeRequirementsPvcAndLater, givenComputeModeCmdSizeWhenLargeGr
auto cmdSize = sizeof(STATE_COMPUTE_MODE) + sizeof(PIPE_CONTROL);
overrideComputeModeRequest<FamilyType>(false, false, false, false, 128u);
EXPECT_FALSE(getCsrHw<FamilyType>()->isComputeModeNeeded());
EXPECT_FALSE(getCsrHw<FamilyType>()->streamProperties.stateComputeMode.isDirty());
overrideComputeModeRequest<FamilyType>(false, false, false, true, 256u);
auto retSize = getCsrHw<FamilyType>()->getCmdSizeForComputeMode();
EXPECT_TRUE(getCsrHw<FamilyType>()->isComputeModeNeeded());
EXPECT_TRUE(getCsrHw<FamilyType>()->streamProperties.stateComputeMode.isDirty());
EXPECT_EQ(cmdSize, retSize);
overrideComputeModeRequest<FamilyType>(true, false, false, true, 256u);
retSize = getCsrHw<FamilyType>()->getCmdSizeForComputeMode();
EXPECT_TRUE(getCsrHw<FamilyType>()->isComputeModeNeeded());
EXPECT_TRUE(getCsrHw<FamilyType>()->streamProperties.stateComputeMode.isDirty());
EXPECT_EQ(cmdSize, retSize);
}

24
shared/test/unit_test/command_stream/compute_mode_tests_xehp_and_later.cpp
View File

@@ -32,19 +32,19 @@ HWCMDTEST_F(IGFX_XE_HP_CORE, ComputeModeRequirements, givenCoherencyWithoutShare
}
overrideComputeModeRequest<FamilyType>(false, false, false);
EXPECT_FALSE(getCsrHw<FamilyType>()->isComputeModeNeeded());
EXPECT_FALSE(getCsrHw<FamilyType>()->streamProperties.stateComputeMode.isDirty());
overrideComputeModeRequest<FamilyType>(false, true, false);
EXPECT_FALSE(getCsrHw<FamilyType>()->isComputeModeNeeded());
EXPECT_FALSE(getCsrHw<FamilyType>()->streamProperties.stateComputeMode.isDirty());
overrideComputeModeRequest<FamilyType>(true, true, false);
auto retSize = getCsrHw<FamilyType>()->getCmdSizeForComputeMode();
EXPECT_TRUE(getCsrHw<FamilyType>()->isComputeModeNeeded());
EXPECT_TRUE(getCsrHw<FamilyType>()->streamProperties.stateComputeMode.isDirty());
EXPECT_EQ(cmdsSize, retSize);
overrideComputeModeRequest<FamilyType>(true, false, false);
retSize = getCsrHw<FamilyType>()->getCmdSizeForComputeMode();
EXPECT_TRUE(getCsrHw<FamilyType>()->isComputeModeNeeded());
EXPECT_TRUE(getCsrHw<FamilyType>()->streamProperties.stateComputeMode.isDirty());
EXPECT_EQ(cmdsSize, retSize);
}
@@ -58,10 +58,10 @@ HWCMDTEST_F(IGFX_XE_HP_CORE, ComputeModeRequirements, givenCoherencyWithSharedHa
std::ignore = isExtendedWARequired;
overrideComputeModeRequest<FamilyType>(false, false, true);
EXPECT_FALSE(getCsrHw<FamilyType>()->isComputeModeNeeded());
EXPECT_FALSE(getCsrHw<FamilyType>()->streamProperties.stateComputeMode.isDirty());
overrideComputeModeRequest<FamilyType>(false, true, true);
EXPECT_FALSE(getCsrHw<FamilyType>()->isComputeModeNeeded());
EXPECT_FALSE(getCsrHw<FamilyType>()->streamProperties.stateComputeMode.isDirty());
auto cmdsSize = sizeof(STATE_COMPUTE_MODE) + sizeof(PIPE_CONTROL);
if (isBasicWARequired) {
@@ -70,12 +70,12 @@ HWCMDTEST_F(IGFX_XE_HP_CORE, ComputeModeRequirements, givenCoherencyWithSharedHa
overrideComputeModeRequest<FamilyType>(true, true, true);
auto retSize = getCsrHw<FamilyType>()->getCmdSizeForComputeMode();
EXPECT_TRUE(getCsrHw<FamilyType>()->isComputeModeNeeded());
EXPECT_TRUE(getCsrHw<FamilyType>()->streamProperties.stateComputeMode.isDirty());
EXPECT_EQ(cmdsSize, retSize);
overrideComputeModeRequest<FamilyType>(true, false, true);
retSize = getCsrHw<FamilyType>()->getCmdSizeForComputeMode();
EXPECT_TRUE(getCsrHw<FamilyType>()->isComputeModeNeeded());
EXPECT_TRUE(getCsrHw<FamilyType>()->streamProperties.stateComputeMode.isDirty());
EXPECT_EQ(cmdsSize, retSize);
}
@@ -340,7 +340,7 @@ HWCMDTEST_F(IGFX_XE_HP_CORE, ComputeModeRequirements, givenComputeModeCmdSizeWhe
using PIPE_CONTROL = typename FamilyType::PIPE_CONTROL;
overrideComputeModeRequest<FamilyType>(false, false, false, false, 128u);
EXPECT_FALSE(getCsrHw<FamilyType>()->isComputeModeNeeded());
EXPECT_FALSE(getCsrHw<FamilyType>()->streamProperties.stateComputeMode.isDirty());
const auto &hwInfoConfig = *HwInfoConfig::get(productFamily);
const auto &[isBasicWARequired, isExtendedWARequired] = hwInfoConfig.isPipeControlPriorToNonPipelinedStateCommandsWARequired(*defaultHwInfo, csr->isRcs());
@@ -353,12 +353,12 @@ HWCMDTEST_F(IGFX_XE_HP_CORE, ComputeModeRequirements, givenComputeModeCmdSizeWhe
overrideComputeModeRequest<FamilyType>(false, false, false, true, 256u);
auto retSize = getCsrHw<FamilyType>()->getCmdSizeForComputeMode();
EXPECT_TRUE(getCsrHw<FamilyType>()->isComputeModeNeeded());
EXPECT_TRUE(getCsrHw<FamilyType>()->streamProperties.stateComputeMode.isDirty());
EXPECT_EQ(cmdSize, retSize);
overrideComputeModeRequest<FamilyType>(true, false, false, true, 256u);
retSize = getCsrHw<FamilyType>()->getCmdSizeForComputeMode();
EXPECT_TRUE(getCsrHw<FamilyType>()->isComputeModeNeeded());
EXPECT_TRUE(getCsrHw<FamilyType>()->streamProperties.stateComputeMode.isDirty());
EXPECT_EQ(cmdSize, retSize);
}
@@ -421,7 +421,7 @@ HWCMDTEST_F(IGFX_XE_HP_CORE, ComputeModeRequirements, givenComputeModeProgrammin
LinearStream stream(buff, 1024);
overrideComputeModeRequest<FamilyType>(false, false, false, false, 256u);
EXPECT_FALSE(getCsrHw<FamilyType>()->isComputeModeNeeded());
EXPECT_FALSE(getCsrHw<FamilyType>()->streamProperties.stateComputeMode.isDirty());
}
HWTEST2_F(ComputeModeRequirements, givenComputeModeProgrammingWhenRequiredGRFNumberIsLowerThan128ThenSmallGRFModeIsProgrammed, ForceNonCoherentSupportedMatcher) {

1
shared/test/unit_test/encoders/test_encode_dispatch_kernel_pvc_and_later.cpp
View File

@@ -71,7 +71,6 @@ HWTEST2_F(CommandEncodeStatesTestPvcAndLater, givenVariousValuesWhenCallingSetBa
HWCMDTEST_F(IGFX_XE_HP_CORE, CommandEncodeStatesTestPvcAndLater, givenCommandContainerWhenNumGrfRequiredIsGreaterThanDefaultThenLargeGrfModeEnabled) {
using PIPELINE_SELECT = typename FamilyType::PIPELINE_SELECT;
using STATE_COMPUTE_MODE = typename FamilyType::STATE_COMPUTE_MODE;
cmdContainer->lastSentNumGrfRequired = GrfConfig::DefaultGrfNumber;
StreamProperties streamProperties{};
streamProperties.stateComputeMode.setProperties(false, GrfConfig::LargeGrfNumber, 0u, *defaultHwInfo);
EncodeComputeMode<FamilyType>::programComputeModeCommand(*cmdContainer->getCommandStream(), streamProperties.stateComputeMode, *defaultHwInfo);

3
shared/test/unit_test/encoders/test_encode_grf_mode_xe_hp_and_later.cpp
View File

@@ -20,9 +20,8 @@ using CommandEncodeStatesTest = Test<CommandEncodeStatesFixture>;
HWCMDTEST_F(IGFX_XE_HP_CORE, CommandEncodeStatesTest, givenCommandContainerWhenNumGrfRequiredIsDefaultThenLargeGrfModeDisabled) {
using PIPELINE_SELECT = typename FamilyType::PIPELINE_SELECT;
using STATE_COMPUTE_MODE = typename FamilyType::STATE_COMPUTE_MODE;
cmdContainer->lastSentNumGrfRequired = 0;
StreamProperties streamProperties{};
streamProperties.stateComputeMode.setProperties(false, cmdContainer->lastSentNumGrfRequired + 1, 0u, *defaultHwInfo);
streamProperties.stateComputeMode.setProperties(false, GrfConfig::DefaultGrfNumber, 0u, *defaultHwInfo);
EncodeComputeMode<FamilyType>::programComputeModeCommand(*cmdContainer->getCommandStream(), streamProperties.stateComputeMode, *defaultHwInfo);
GenCmdList commands;

26
shared/test/unit_test/gen12lp/compute_mode_tests_gen12lp.inl
View File

@@ -19,14 +19,14 @@ HWTEST2_F(ComputeModeRequirements, givenCsrRequestFlagsWithSharedHandlesWhenComm
overrideComputeModeRequest<FamilyType>(false, false, true);
EXPECT_FALSE(getCsrHw<FamilyType>()->isComputeModeNeeded());
EXPECT_FALSE(getCsrHw<FamilyType>()->streamProperties.stateComputeMode.isDirty());
getCsrHw<FamilyType>()->programComputeMode(stream, flags, *defaultHwInfo);
EXPECT_EQ(0u, stream.getUsed());
stream.replaceBuffer(buff, 1024);
overrideComputeModeRequest<FamilyType>(false, true, true);
EXPECT_FALSE(getCsrHw<FamilyType>()->isComputeModeNeeded());
EXPECT_FALSE(getCsrHw<FamilyType>()->streamProperties.stateComputeMode.isDirty());
getCsrHw<FamilyType>()->programComputeMode(stream, flags, *defaultHwInfo);
EXPECT_EQ(0u, stream.getUsed());
@@ -34,7 +34,7 @@ HWTEST2_F(ComputeModeRequirements, givenCsrRequestFlagsWithSharedHandlesWhenComm
overrideComputeModeRequest<FamilyType>(true, true, true);
auto retSize = getCsrHw<FamilyType>()->getCmdSizeForComputeMode();
EXPECT_TRUE(getCsrHw<FamilyType>()->isComputeModeNeeded());
EXPECT_TRUE(getCsrHw<FamilyType>()->streamProperties.stateComputeMode.isDirty());
EXPECT_EQ(cmdsSize, retSize);
getCsrHw<FamilyType>()->programComputeMode(stream, flags, *defaultHwInfo);
EXPECT_EQ(cmdsSize, stream.getUsed());
@@ -43,7 +43,7 @@ HWTEST2_F(ComputeModeRequirements, givenCsrRequestFlagsWithSharedHandlesWhenComm
overrideComputeModeRequest<FamilyType>(true, false, true);
retSize = getCsrHw<FamilyType>()->getCmdSizeForComputeMode();
EXPECT_TRUE(getCsrHw<FamilyType>()->isComputeModeNeeded());
EXPECT_TRUE(getCsrHw<FamilyType>()->streamProperties.stateComputeMode.isDirty());
EXPECT_EQ(cmdsSize, retSize);
getCsrHw<FamilyType>()->programComputeMode(stream, flags, *defaultHwInfo);
EXPECT_EQ(cmdsSize, stream.getUsed());
@@ -52,7 +52,7 @@ HWTEST2_F(ComputeModeRequirements, givenCsrRequestFlagsWithSharedHandlesWhenComm
overrideComputeModeRequest<FamilyType>(false, false, true, true, 127u);
retSize = getCsrHw<FamilyType>()->getCmdSizeForComputeMode();
EXPECT_TRUE(getCsrHw<FamilyType>()->isComputeModeNeeded());
EXPECT_TRUE(getCsrHw<FamilyType>()->streamProperties.stateComputeMode.isDirty());
EXPECT_EQ(cmdsSize, retSize);
getCsrHw<FamilyType>()->programComputeMode(stream, flags, *defaultHwInfo);
EXPECT_EQ(cmdsSize, stream.getUsed());
@@ -70,7 +70,7 @@ HWTEST2_F(ComputeModeRequirements, givenCsrRequestFlagsWithoutSharedHandlesWhenC
overrideComputeModeRequest<FamilyType>(false, false, false);
EXPECT_FALSE(getCsrHw<FamilyType>()->isComputeModeNeeded());
EXPECT_FALSE(getCsrHw<FamilyType>()->streamProperties.stateComputeMode.isDirty());
getCsrHw<FamilyType>()->programComputeMode(stream, flags, *defaultHwInfo);
EXPECT_EQ(0u, stream.getUsed());
@@ -78,7 +78,7 @@ HWTEST2_F(ComputeModeRequirements, givenCsrRequestFlagsWithoutSharedHandlesWhenC
overrideComputeModeRequest<FamilyType>(true, true, false);
auto retSize = getCsrHw<FamilyType>()->getCmdSizeForComputeMode();
EXPECT_TRUE(getCsrHw<FamilyType>()->isComputeModeNeeded());
EXPECT_TRUE(getCsrHw<FamilyType>()->streamProperties.stateComputeMode.isDirty());
EXPECT_EQ(cmdsSize, retSize);
getCsrHw<FamilyType>()->programComputeMode(stream, flags, *defaultHwInfo);
EXPECT_EQ(cmdsSize, stream.getUsed());
@@ -87,7 +87,7 @@ HWTEST2_F(ComputeModeRequirements, givenCsrRequestFlagsWithoutSharedHandlesWhenC
overrideComputeModeRequest<FamilyType>(true, false, false);
retSize = getCsrHw<FamilyType>()->getCmdSizeForComputeMode();
EXPECT_TRUE(getCsrHw<FamilyType>()->isComputeModeNeeded());
EXPECT_TRUE(getCsrHw<FamilyType>()->streamProperties.stateComputeMode.isDirty());
EXPECT_EQ(cmdsSize, retSize);
getCsrHw<FamilyType>()->programComputeMode(stream, flags, *defaultHwInfo);
EXPECT_EQ(cmdsSize, stream.getUsed());
@@ -96,7 +96,7 @@ HWTEST2_F(ComputeModeRequirements, givenCsrRequestFlagsWithoutSharedHandlesWhenC
overrideComputeModeRequest<FamilyType>(false, false, false, true, 127u);
retSize = getCsrHw<FamilyType>()->getCmdSizeForComputeMode();
EXPECT_TRUE(getCsrHw<FamilyType>()->isComputeModeNeeded());
EXPECT_TRUE(getCsrHw<FamilyType>()->streamProperties.stateComputeMode.isDirty());
EXPECT_EQ(cmdsSize, retSize);
getCsrHw<FamilyType>()->programComputeMode(stream, flags, *defaultHwInfo);
EXPECT_EQ(cmdsSize, stream.getUsed());
@@ -116,7 +116,7 @@ HWTEST2_F(ComputeModeRequirements, givenCsrRequestOnEngineCCSWhenCommandSizeIsCa
overrideComputeModeRequest<FamilyType>(false, false, false);
EXPECT_FALSE(getCsrHw<FamilyType>()->isComputeModeNeeded());
EXPECT_FALSE(getCsrHw<FamilyType>()->streamProperties.stateComputeMode.isDirty());
getCsrHw<FamilyType>()->programComputeMode(stream, flags, *defaultHwInfo);
EXPECT_EQ(0u, stream.getUsed());
@@ -124,7 +124,7 @@ HWTEST2_F(ComputeModeRequirements, givenCsrRequestOnEngineCCSWhenCommandSizeIsCa
overrideComputeModeRequest<FamilyType>(true, true, false);
auto retSize = getCsrHw<FamilyType>()->getCmdSizeForComputeMode();
EXPECT_TRUE(getCsrHw<FamilyType>()->isComputeModeNeeded());
EXPECT_TRUE(getCsrHw<FamilyType>()->streamProperties.stateComputeMode.isDirty());
EXPECT_EQ(cmdsSize, retSize);
getCsrHw<FamilyType>()->programComputeMode(stream, flags, *defaultHwInfo);
EXPECT_EQ(cmdsSize, stream.getUsed());
@@ -133,7 +133,7 @@ HWTEST2_F(ComputeModeRequirements, givenCsrRequestOnEngineCCSWhenCommandSizeIsCa
overrideComputeModeRequest<FamilyType>(true, false, false);
retSize = getCsrHw<FamilyType>()->getCmdSizeForComputeMode();
EXPECT_TRUE(getCsrHw<FamilyType>()->isComputeModeNeeded());
EXPECT_TRUE(getCsrHw<FamilyType>()->streamProperties.stateComputeMode.isDirty());
EXPECT_EQ(cmdsSize, retSize);
getCsrHw<FamilyType>()->programComputeMode(stream, flags, *defaultHwInfo);
EXPECT_EQ(cmdsSize, stream.getUsed());
@@ -142,7 +142,7 @@ HWTEST2_F(ComputeModeRequirements, givenCsrRequestOnEngineCCSWhenCommandSizeIsCa
overrideComputeModeRequest<FamilyType>(false, false, false, true, 127u);
retSize = getCsrHw<FamilyType>()->getCmdSizeForComputeMode();
EXPECT_TRUE(getCsrHw<FamilyType>()->isComputeModeNeeded());
EXPECT_TRUE(getCsrHw<FamilyType>()->streamProperties.stateComputeMode.isDirty());
EXPECT_EQ(cmdsSize, retSize);
getCsrHw<FamilyType>()->programComputeMode(stream, flags, *defaultHwInfo);
EXPECT_EQ(cmdsSize, stream.getUsed());

8
shared/test/unit_test/xe_hp_core/compute_mode_tests_xe_hp_core.cpp
View File

@@ -108,18 +108,18 @@ HWTEST2_F(ComputeModeRequirements, GivenProgramExtendedPipeControlPriorToNonPipe
auto cmdsSize = sizeof(STATE_COMPUTE_MODE) + sizeof(PIPE_CONTROL);
overrideComputeModeRequest<FamilyType>(false, false, false);
EXPECT_FALSE(getCsrHw<FamilyType>()->isComputeModeNeeded());
EXPECT_FALSE(getCsrHw<FamilyType>()->streamProperties.stateComputeMode.isDirty());
overrideComputeModeRequest<FamilyType>(false, true, false);
EXPECT_FALSE(getCsrHw<FamilyType>()->isComputeModeNeeded());
EXPECT_FALSE(getCsrHw<FamilyType>()->streamProperties.stateComputeMode.isDirty());
overrideComputeModeRequest<FamilyType>(true, true, false);
auto retSize = getCsrHw<FamilyType>()->getCmdSizeForComputeMode();
EXPECT_TRUE(getCsrHw<FamilyType>()->isComputeModeNeeded());
EXPECT_TRUE(getCsrHw<FamilyType>()->streamProperties.stateComputeMode.isDirty());
EXPECT_EQ(cmdsSize, retSize);
overrideComputeModeRequest<FamilyType>(true, false, false);
retSize = getCsrHw<FamilyType>()->getCmdSizeForComputeMode();
EXPECT_TRUE(getCsrHw<FamilyType>()->isComputeModeNeeded());
EXPECT_TRUE(getCsrHw<FamilyType>()->streamProperties.stateComputeMode.isDirty());
EXPECT_EQ(cmdsSize, retSize);
}

9
shared/test/unit_test/xe_hpc_core/compute_mode_tests_xe_hpc_core.cpp
View File

@@ -5,7 +5,6 @@
*
*/
#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"
@@ -79,11 +78,11 @@ HWTEST2_F(XeHpcComputeModeRequirements, givenCoherencyWithoutSharedHandlesWhenCo
auto cmdsSize = sizeof(STATE_COMPUTE_MODE) + sizeof(PIPE_CONTROL);
overrideComputeModeRequest<FamilyType>(false, false, false, false);
EXPECT_FALSE(getCsrHw<FamilyType>()->isComputeModeNeeded());
EXPECT_FALSE(getCsrHw<FamilyType>()->streamProperties.stateComputeMode.isDirty());
overrideComputeModeRequest<FamilyType>(false, false, false, true);
auto retSize = getCsrHw<FamilyType>()->getCmdSizeForComputeMode();
EXPECT_TRUE(getCsrHw<FamilyType>()->isComputeModeNeeded());
EXPECT_TRUE(getCsrHw<FamilyType>()->streamProperties.stateComputeMode.isDirty());
EXPECT_EQ(cmdsSize, retSize);
}
@@ -96,11 +95,11 @@ HWTEST2_F(XeHpcComputeModeRequirements, givenNumGrfRequiredChangedWhenCommandSiz
auto numGrfRequired = 128u;
auto numGrfRequiredChanged = false;
overrideComputeModeRequest<FamilyType>(false, false, false, numGrfRequiredChanged, numGrfRequired);
EXPECT_FALSE(getCsrHw<FamilyType>()->isComputeModeNeeded());
EXPECT_FALSE(getCsrHw<FamilyType>()->streamProperties.stateComputeMode.isDirty());
numGrfRequiredChanged = true;
overrideComputeModeRequest<FamilyType>(false, false, false, numGrfRequiredChanged, numGrfRequired);
EXPECT_TRUE(getCsrHw<FamilyType>()->isComputeModeNeeded());
EXPECT_TRUE(getCsrHw<FamilyType>()->streamProperties.stateComputeMode.isDirty());
EXPECT_EQ(sizeof(STATE_COMPUTE_MODE) + sizeof(PIPE_CONTROL), getCsrHw<FamilyType>()->getCmdSizeForComputeMode());
}

18
shared/test/unit_test/xe_hpg_core/compute_mode_tests_xe_hpg_core.cpp
View File

@@ -104,18 +104,18 @@ XE_HPG_CORETEST_F(ComputeModeRequirementsXeHpgCore, givenComputeModeCmdSizeWhenL
using PIPE_CONTROL = typename FamilyType::PIPE_CONTROL;
overrideComputeModeRequest<FamilyType>(false, false, false, false, 128u);
EXPECT_FALSE(getCsrHw<FamilyType>()->isComputeModeNeeded());
EXPECT_FALSE(getCsrHw<FamilyType>()->streamProperties.stateComputeMode.isDirty());
auto cmdSize = sizeof(STATE_COMPUTE_MODE) + sizeof(PIPE_CONTROL);
overrideComputeModeRequest<FamilyType>(false, false, false, true, 256u);
auto retSize = getCsrHw<FamilyType>()->getCmdSizeForComputeMode();
EXPECT_TRUE(getCsrHw<FamilyType>()->isComputeModeNeeded());
EXPECT_TRUE(getCsrHw<FamilyType>()->streamProperties.stateComputeMode.isDirty());
EXPECT_EQ(cmdSize, retSize);
overrideComputeModeRequest<FamilyType>(true, false, false, true, 256u);
retSize = getCsrHw<FamilyType>()->getCmdSizeForComputeMode();
EXPECT_TRUE(getCsrHw<FamilyType>()->isComputeModeNeeded());
EXPECT_TRUE(getCsrHw<FamilyType>()->streamProperties.stateComputeMode.isDirty());
EXPECT_EQ(cmdSize, retSize);
}
@@ -125,21 +125,21 @@ XE_HPG_CORETEST_F(ComputeModeRequirementsXeHpgCore, givenCoherencyWithSharedHand
using PIPE_CONTROL = typename FamilyType::PIPE_CONTROL;
overrideComputeModeRequest<FamilyType>(false, false, true);
EXPECT_FALSE(getCsrHw<FamilyType>()->isComputeModeNeeded());
EXPECT_FALSE(getCsrHw<FamilyType>()->streamProperties.stateComputeMode.isDirty());
overrideComputeModeRequest<FamilyType>(false, true, true);
EXPECT_FALSE(getCsrHw<FamilyType>()->isComputeModeNeeded());
EXPECT_FALSE(getCsrHw<FamilyType>()->streamProperties.stateComputeMode.isDirty());
auto cmdsSize = sizeof(STATE_COMPUTE_MODE) + (2 * sizeof(PIPE_CONTROL));
overrideComputeModeRequest<FamilyType>(true, true, true);
auto retSize = getCsrHw<FamilyType>()->getCmdSizeForComputeMode();
EXPECT_TRUE(getCsrHw<FamilyType>()->isComputeModeNeeded());
EXPECT_TRUE(getCsrHw<FamilyType>()->streamProperties.stateComputeMode.isDirty());
EXPECT_EQ(cmdsSize, retSize);
overrideComputeModeRequest<FamilyType>(true, false, true);
retSize = getCsrHw<FamilyType>()->getCmdSizeForComputeMode();
EXPECT_TRUE(getCsrHw<FamilyType>()->isComputeModeNeeded());
EXPECT_TRUE(getCsrHw<FamilyType>()->streamProperties.stateComputeMode.isDirty());
EXPECT_EQ(cmdsSize, retSize);
}
@@ -151,10 +151,10 @@ XE_HPG_CORETEST_F(ComputeModeRequirementsXeHpgCore, givenCoherencyWithoutSharedH
auto cmdsSize = sizeof(STATE_COMPUTE_MODE) + sizeof(PIPE_CONTROL);
overrideComputeModeRequest<FamilyType>(false, false, false, false);
EXPECT_FALSE(getCsrHw<FamilyType>()->isComputeModeNeeded());
EXPECT_FALSE(getCsrHw<FamilyType>()->streamProperties.stateComputeMode.isDirty());
overrideComputeModeRequest<FamilyType>(false, false, false, true);
auto retSize = getCsrHw<FamilyType>()->getCmdSizeForComputeMode();
EXPECT_TRUE(getCsrHw<FamilyType>()->isComputeModeNeeded());
EXPECT_TRUE(getCsrHw<FamilyType>()->streamProperties.stateComputeMode.isDirty());
EXPECT_EQ(cmdsSize, retSize);
}

8
shared/test/unit_test/xe_hpg_core/dg2/compute_mode_tests_dg2.cpp
View File

@@ -173,18 +173,18 @@ HWTEST2_F(ComputeModeRequirements, GivenProgramExtendedPipeControlPriorToNonPipe
auto cmdsSize = sizeof(STATE_COMPUTE_MODE) + sizeof(PIPE_CONTROL);
overrideComputeModeRequest<FamilyType>(false, false, false);
EXPECT_FALSE(getCsrHw<FamilyType>()->isComputeModeNeeded());
EXPECT_FALSE(getCsrHw<FamilyType>()->streamProperties.stateComputeMode.isDirty());
overrideComputeModeRequest<FamilyType>(false, true, false);
EXPECT_FALSE(getCsrHw<FamilyType>()->isComputeModeNeeded());
EXPECT_FALSE(getCsrHw<FamilyType>()->streamProperties.stateComputeMode.isDirty());
overrideComputeModeRequest<FamilyType>(true, true, false);
auto retSize = getCsrHw<FamilyType>()->getCmdSizeForComputeMode();
EXPECT_TRUE(getCsrHw<FamilyType>()->isComputeModeNeeded());
EXPECT_TRUE(getCsrHw<FamilyType>()->streamProperties.stateComputeMode.isDirty());
EXPECT_EQ(cmdsSize, retSize);
overrideComputeModeRequest<FamilyType>(true, false, false);
retSize = getCsrHw<FamilyType>()->getCmdSizeForComputeMode();
EXPECT_TRUE(getCsrHw<FamilyType>()->isComputeModeNeeded());
EXPECT_TRUE(getCsrHw<FamilyType>()->streamProperties.stateComputeMode.isDirty());
EXPECT_EQ(cmdsSize, retSize);
}