intel/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2026-01-07 12:42:54 +08:00
Code Issues Packages Projects Releases Wiki Activity

Rename core family names to meet naming convention

Browse Source 
Signed-off-by: Mateusz Jablonski <mateusz.jablonski@intel.com>
This commit is contained in:
Mateusz Jablonski
2022-07-25 15:30:11 +00:00
committed by Compute-Runtime-Automation
parent c200c6e2dd
commit 8424b27754
292 changed files with 673 additions and 673 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
shared/test/common/gen11/cmd_parse_gen11.cpp
View File

@@ -6,8 +6,8 @@
*/
#include "shared/source/gen11/hw_cmds_base.h"
using GenStruct = NEO::GEN11;
using GenGfxFamily = NEO::ICLFamily;
using GenStruct = NEO::Gen11;
using GenGfxFamily = NEO::Gen11Family;
#include "shared/test/common/cmd_parse/cmd_parse_base.inl"
#include "shared/test/common/cmd_parse/cmd_parse_base_mi_arb.inl"
@@ -83,8 +83,8 @@ const char *CmdParse<GenGfxFamily>::getCommandNameHwSpecific(void *cmd) {
template struct CmdParse<GenGfxFamily>;
namespace NEO {
template void HardwareParse::findHardwareCommands<ICLFamily>();
template void HardwareParse::findHardwareCommands<ICLFamily>(IndirectHeap *);
template const void *HardwareParse::getStatelessArgumentPointer<ICLFamily>(const KernelInfo &kernelInfo, uint32_t indexArg, IndirectHeap &ioh, uint32_t rootDeviceIndex);
template const typename ICLFamily::RENDER_SURFACE_STATE *HardwareParse::getSurfaceState<ICLFamily>(IndirectHeap *ssh, uint32_t index);
template void HardwareParse::findHardwareCommands<Gen11Family>();
template void HardwareParse::findHardwareCommands<Gen11Family>(IndirectHeap *);
template const void *HardwareParse::getStatelessArgumentPointer<Gen11Family>(const KernelInfo &kernelInfo, uint32_t indexArg, IndirectHeap &ioh, uint32_t rootDeviceIndex);
template const typename Gen11Family::RENDER_SURFACE_STATE *HardwareParse::getSurfaceState<Gen11Family>(IndirectHeap *ssh, uint32_t index);
} // namespace NEO

4
shared/test/common/gen11/unit_test_helper_gen11.cpp
View File

@@ -13,7 +13,7 @@
namespace NEO {
using Family = ICLFamily;
using Family = Gen11Family;
template <>
uint32_t UnitTestHelper<Family>::getDebugModeRegisterOffset() {
@@ -35,5 +35,5 @@ uint32_t UnitTestHelper<Family>::getTdCtlRegisterValue() {
return (1u << 7) | (1u << 4);
}
template struct UnitTestHelper<ICLFamily>;
template struct UnitTestHelper<Gen11Family>;
} // namespace NEO

12
shared/test/common/gen12lp/cmd_parse_gen12lp.cpp
View File

@@ -6,8 +6,8 @@
*/
#include "shared/source/gen12lp/hw_cmds_base.h"
using GenStruct = NEO::GEN12LP;
using GenGfxFamily = NEO::TGLLPFamily;
using GenStruct = NEO::Gen12Lp;
using GenGfxFamily = NEO::Gen12LpFamily;
#include "shared/test/common/cmd_parse/cmd_parse_base.inl"
#include "shared/test/common/cmd_parse/cmd_parse_compute_mode.inl"
@@ -126,8 +126,8 @@ const char *CmdParse<GenGfxFamily>::getCommandNameHwSpecific(void *cmd) {
template struct CmdParse<GenGfxFamily>;
namespace NEO {
template void HardwareParse::findHardwareCommands<TGLLPFamily>();
template void HardwareParse::findHardwareCommands<TGLLPFamily>(IndirectHeap *);
template const void *HardwareParse::getStatelessArgumentPointer<TGLLPFamily>(const KernelInfo &kernelInfo, uint32_t indexArg, IndirectHeap &ioh, uint32_t rootDeviceIndex);
template const typename TGLLPFamily::RENDER_SURFACE_STATE *HardwareParse::getSurfaceState<TGLLPFamily>(IndirectHeap *ssh, uint32_t index);
template void HardwareParse::findHardwareCommands<Gen12LpFamily>();
template void HardwareParse::findHardwareCommands<Gen12LpFamily>(IndirectHeap *);
template const void *HardwareParse::getStatelessArgumentPointer<Gen12LpFamily>(const KernelInfo &kernelInfo, uint32_t indexArg, IndirectHeap &ioh, uint32_t rootDeviceIndex);
template const typename Gen12LpFamily::RENDER_SURFACE_STATE *HardwareParse::getSurfaceState<Gen12LpFamily>(IndirectHeap *ssh, uint32_t index);
} // namespace NEO

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

@@ -14,7 +14,7 @@
namespace NEO {
using Family = TGLLPFamily;
using Family = Gen12LpFamily;
template <>
bool UnitTestHelper<Family>::isL3ConfigProgrammable() {

12
shared/test/common/gen8/cmd_parse_gen8.cpp
View File

@@ -6,8 +6,8 @@
*/
#include "shared/source/gen8/hw_cmds_base.h"
using GenStruct = NEO::GEN8;
using GenGfxFamily = NEO::BDWFamily;
using GenStruct = NEO::Gen8;
using GenGfxFamily = NEO::Gen8Family;
#include "shared/test/common/cmd_parse/cmd_parse_base.inl"
#include "shared/test/common/cmd_parse/cmd_parse_base_mi_arb.inl"
@@ -65,8 +65,8 @@ const char *CmdParse<GenGfxFamily>::getCommandNameHwSpecific(void *cmd) {
template struct CmdParse<GenGfxFamily>;
namespace NEO {
template void HardwareParse::findHardwareCommands<BDWFamily>();
template void HardwareParse::findHardwareCommands<BDWFamily>(IndirectHeap *);
template const void *HardwareParse::getStatelessArgumentPointer<BDWFamily>(const KernelInfo &kernelInfo, uint32_t indexArg, IndirectHeap &ioh, uint32_t rootDeviceIndex);
template const typename BDWFamily::RENDER_SURFACE_STATE *HardwareParse::getSurfaceState<BDWFamily>(IndirectHeap *ssh, uint32_t index);
template void HardwareParse::findHardwareCommands<Gen8Family>();
template void HardwareParse::findHardwareCommands<Gen8Family>(IndirectHeap *);
template const void *HardwareParse::getStatelessArgumentPointer<Gen8Family>(const KernelInfo &kernelInfo, uint32_t indexArg, IndirectHeap &ioh, uint32_t rootDeviceIndex);
template const typename Gen8Family::RENDER_SURFACE_STATE *HardwareParse::getSurfaceState<Gen8Family>(IndirectHeap *ssh, uint32_t index);
} // namespace NEO

4
shared/test/common/gen8/unit_test_helper_gen8.cpp
View File

@@ -13,7 +13,7 @@
namespace NEO {
using Family = BDWFamily;
using Family = Gen8Family;
template <>
uint32_t UnitTestHelper<Family>::getDebugModeRegisterOffset() {
@@ -35,5 +35,5 @@ uint32_t UnitTestHelper<Family>::getTdCtlRegisterValue() {
return (1u << 7) | (1u << 4);
}
template struct UnitTestHelper<BDWFamily>;
template struct UnitTestHelper<Gen8Family>;
} // namespace NEO

12
shared/test/common/gen9/cmd_parse_gen9.cpp
View File

@@ -6,8 +6,8 @@
*/
#include "shared/source/gen9/hw_cmds_base.h"
using GenStruct = NEO::GEN9;
using GenGfxFamily = NEO::SKLFamily;
using GenStruct = NEO::Gen9;
using GenGfxFamily = NEO::Gen9Family;
#include "shared/test/common/cmd_parse/cmd_parse_base.inl"
#include "shared/test/common/cmd_parse/cmd_parse_base_mi_arb.inl"
@@ -83,8 +83,8 @@ const char *CmdParse<GenGfxFamily>::getCommandNameHwSpecific(void *cmd) {
template struct CmdParse<GenGfxFamily>;
namespace NEO {
template void HardwareParse::findHardwareCommands<SKLFamily>();
template void HardwareParse::findHardwareCommands<SKLFamily>(IndirectHeap *);
template const void *HardwareParse::getStatelessArgumentPointer<SKLFamily>(const KernelInfo &kernelInfo, uint32_t indexArg, IndirectHeap &ioh, uint32_t rootDeviceIndex);
template const typename SKLFamily::RENDER_SURFACE_STATE *HardwareParse::getSurfaceState<SKLFamily>(IndirectHeap *ssh, uint32_t index);
template void HardwareParse::findHardwareCommands<Gen9Family>();
template void HardwareParse::findHardwareCommands<Gen9Family>(IndirectHeap *);
template const void *HardwareParse::getStatelessArgumentPointer<Gen9Family>(const KernelInfo &kernelInfo, uint32_t indexArg, IndirectHeap &ioh, uint32_t rootDeviceIndex);
template const typename Gen9Family::RENDER_SURFACE_STATE *HardwareParse::getSurfaceState<Gen9Family>(IndirectHeap *ssh, uint32_t index);
} // namespace NEO

2
shared/test/common/gen9/unit_test_helper_gen9.cpp
View File

@@ -12,7 +12,7 @@
#include "shared/test/common/helpers/unit_test_helper_bdw_and_later.inl"
namespace NEO {
using Family = SKLFamily;
using Family = Gen9Family;
template <>
bool UnitTestHelper<Family>::isPipeControlWArequired(const HardwareInfo &hwInfo) {

4
shared/test/common/libult/gen11.cpp
View File

@@ -12,7 +12,7 @@
namespace NEO {
typedef ICLFamily Family;
typedef Gen11Family Family;
constexpr auto gfxCore = IGFX_GEN11_CORE;
@@ -33,5 +33,5 @@ static enableGen11 enable;
static MockDebuggerL0HwPopulateFactory<gfxCore, Family> mockDebuggerGen11;
template class UltCommandStreamReceiver<ICLFamily>;
template class UltCommandStreamReceiver<Gen11Family>;
} // namespace NEO

4
shared/test/common/libult/gen12lp.cpp
View File

@@ -12,7 +12,7 @@
namespace NEO {
typedef TGLLPFamily Family;
typedef Gen12LpFamily Family;
constexpr auto gfxCore = IGFX_GEN12LP_CORE;
@@ -32,5 +32,5 @@ struct enableGen12LP {
static enableGen12LP enable;
static MockDebuggerL0HwPopulateFactory<gfxCore, Family> mockDebuggerGen12lp;
template class UltCommandStreamReceiver<TGLLPFamily>;
template class UltCommandStreamReceiver<Gen12LpFamily>;
} // namespace NEO

4
shared/test/common/libult/gen8.cpp
View File

@@ -12,7 +12,7 @@
namespace NEO {
typedef BDWFamily Family;
typedef Gen8Family Family;
constexpr auto gfxCore = IGFX_GEN8_CORE;
@@ -32,5 +32,5 @@ struct enableGen8 {
static enableGen8 enable;
static MockDebuggerL0HwPopulateFactory<gfxCore, Family> mockDebuggerGen8;
template class UltCommandStreamReceiver<BDWFamily>;
template class UltCommandStreamReceiver<Gen8Family>;
} // namespace NEO

4
shared/test/common/libult/gen9.cpp
View File

@@ -12,7 +12,7 @@
namespace NEO {
typedef SKLFamily Family;
typedef Gen9Family Family;
constexpr auto gfxCore = IGFX_GEN9_CORE;
@@ -33,5 +33,5 @@ static enableGen9 enable;
static MockDebuggerL0HwPopulateFactory<gfxCore, Family> mockDebuggerGen9;
template class UltCommandStreamReceiver<SKLFamily>;
template class UltCommandStreamReceiver<Gen9Family>;
} // namespace NEO

4
shared/test/common/libult/xe_hpc_core.cpp
View File

@@ -12,7 +12,7 @@
namespace NEO {
typedef XE_HPC_COREFamily Family;
typedef XeHpcCoreFamily Family;
constexpr auto gfxCore = IGFX_XE_HPC_CORE;
@@ -32,5 +32,5 @@ struct enableXeHpcCore {
static enableXeHpcCore enable;
static MockDebuggerL0HwPopulateFactory<gfxCore, Family> mockDebuggerXeHpcCore;
template class UltCommandStreamReceiver<XE_HPC_COREFamily>;
template class UltCommandStreamReceiver<XeHpcCoreFamily>;
} // namespace NEO

4
shared/test/common/libult/xe_hpg_core.cpp
View File

@@ -12,7 +12,7 @@
namespace NEO {
typedef XE_HPG_COREFamily Family;
typedef XeHpgCoreFamily Family;
constexpr auto gfxCore = IGFX_XE_HPG_CORE;
@@ -32,5 +32,5 @@ struct enableXeHpgCore {
static enableXeHpgCore enable;
static MockDebuggerL0HwPopulateFactory<gfxCore, Family> mockDebuggerXeHpgCore;
template class UltCommandStreamReceiver<XE_HPG_COREFamily>;
template class UltCommandStreamReceiver<XeHpgCoreFamily>;
} // namespace NEO

2
shared/test/common/test_configuration/aub_tests/gen11/aub_tests_configuration_gen11.cpp
View File

@@ -10,4 +10,4 @@
using namespace NEO;
template AubTestsConfig getAubTestsConfig<ICLFamily>();
template AubTestsConfig getAubTestsConfig<Gen11Family>();

2
shared/test/common/test_configuration/aub_tests/gen12lp/aub_tests_configuration_gen12lp.cpp
View File

@@ -11,7 +11,7 @@
using namespace NEO;
template <>
AubTestsConfig getAubTestsConfig<TGLLPFamily>() {
AubTestsConfig getAubTestsConfig<Gen12LpFamily>() {
AubTestsConfig aubTestsConfig;
aubTestsConfig.testCanonicalAddress = false;
return aubTestsConfig;

2
shared/test/common/test_configuration/aub_tests/gen8/aub_tests_configuration_gen8.cpp
View File

@@ -10,4 +10,4 @@
using namespace NEO;
template AubTestsConfig getAubTestsConfig<BDWFamily>();
template AubTestsConfig getAubTestsConfig<Gen8Family>();

2
shared/test/common/test_configuration/aub_tests/gen9/aub_tests_configuration_gen9.cpp
View File

@@ -10,4 +10,4 @@
using namespace NEO;
template AubTestsConfig getAubTestsConfig<SKLFamily>();
template AubTestsConfig getAubTestsConfig<Gen9Family>();

2
shared/test/common/test_configuration/aub_tests/xe_hpc_core/aub_tests_configuration_xe_hpc_core.cpp
View File

@@ -11,7 +11,7 @@
using namespace NEO;
template <>
AubTestsConfig getAubTestsConfig<XE_HPC_COREFamily>() {
AubTestsConfig getAubTestsConfig<XeHpcCoreFamily>() {
AubTestsConfig aubTestsConfig;
aubTestsConfig.testCanonicalAddress = false;
return aubTestsConfig;

2
shared/test/common/test_configuration/aub_tests/xe_hpg_core/aub_tests_configuration_xe_hpg_core.cpp
View File

@@ -11,7 +11,7 @@
using namespace NEO;
template <>
AubTestsConfig getAubTestsConfig<XE_HPG_COREFamily>() {
AubTestsConfig getAubTestsConfig<XeHpgCoreFamily>() {
AubTestsConfig aubTestsConfig;
aubTestsConfig.testCanonicalAddress = true;
return aubTestsConfig;

6
shared/test/common/test_macros/hw_test.h
View File

@@ -17,7 +17,7 @@
#include "test_mode.h"
// Macros to provide template based testing.
// Test can use FamilyType in the test -- equivalent to SKLFamily
// Test can use FamilyType in the test -- equivalent to Gen9Family
#define HWTEST_TEST_(test_suite_name, test_name, parent_class, parent_id, SetUpT_name, TearDownT_name) \
CHECK_TEST_NAME_LENGTH(test_suite_name, test_name) \
\
@@ -219,7 +219,7 @@
::testing::internal::GetTypeId<test_fixture>(), setUpT, tearDownT)
// Macros to provide template based testing.
// Test can use FamilyType in the test -- equivalent to SKLFamily
// Test can use FamilyType in the test -- equivalent to Gen9Family
#define HWCMDTEST_TEST_(cmdset_gen_base, test_suite_name, test_name, parent_class, parent_id) \
CHECK_TEST_NAME_LENGTH(test_suite_name, test_name) \
\
@@ -281,7 +281,7 @@
::testing::internal::GetTypeId<test_fixture>())
// Equivalent Hw specific macro for permuted tests
// Test can use FamilyType in the test -- equivalent to SKLFamily
// Test can use FamilyType in the test -- equivalent to Gen9Family
#define HWTEST_P(test_suite_name, test_name) \
CHECK_TEST_NAME_LENGTH(test_suite_name, test_name) \
class GTEST_TEST_CLASS_NAME_(test_suite_name, test_name) : public test_suite_name { \

4
shared/test/common/xe_hpc_core/cmd_parse_xe_hpc_core.cpp
View File

@@ -6,8 +6,8 @@
*/
#include "shared/source/xe_hpc_core/hw_cmds_xe_hpc_core_base.h"
using GenStruct = NEO::XE_HPC_CORE;
using GenGfxFamily = NEO::XE_HPC_COREFamily;
using GenStruct = NEO::XeHpcCore;
using GenGfxFamily = NEO::XeHpcCoreFamily;
#include "shared/test/common/cmd_parse/gen_cmd_parse.h"

2
shared/test/common/xe_hpc_core/test_preemption_xe_hpc_core.cpp
View File

@@ -11,7 +11,7 @@
using namespace NEO;
template <>
PreemptionTestHwDetails getPreemptionTestHwDetails<XE_HPC_COREFamily>() {
PreemptionTestHwDetails getPreemptionTestHwDetails<XeHpcCoreFamily>() {
PreemptionTestHwDetails ret;
ret.modeToRegValueMap[PreemptionMode::ThreadGroup] = DwordBuilder::build(1, true) | DwordBuilder::build(2, true, false);
ret.modeToRegValueMap[PreemptionMode::MidBatch] = DwordBuilder::build(2, true) | DwordBuilder::build(1, true, false);

2
shared/test/common/xe_hpc_core/unit_test_helper_xe_hpc_core.cpp
View File

@@ -12,7 +12,7 @@
#include "shared/test/common/helpers/unit_test_helper.inl"
#include "shared/test/common/helpers/unit_test_helper_xehp_and_later.inl"
using Family = NEO::XE_HPC_COREFamily;
using Family = NEO::XeHpcCoreFamily;
#include "unit_test_helper_xe_hpc_core_extra.inl"

6
shared/test/common/xe_hpg_core/cmd_parse_xe_hpg_core.cpp
View File

@@ -6,8 +6,8 @@
*/
#include "shared/source/xe_hpg_core/hw_cmds_xe_hpg_core_base.h"
using GenStruct = NEO::XE_HPG_CORE;
using GenGfxFamily = NEO::XE_HPG_COREFamily;
using GenStruct = NEO::XeHpgCore;
using GenGfxFamily = NEO::XeHpgCoreFamily;
#include "shared/test/common/cmd_parse/cmd_parse_xehp_and_later.inl"
template const typename GenGfxFamily::RENDER_SURFACE_STATE *NEO::HardwareParse::getSurfaceState<GenGfxFamily>(IndirectHeap *ssh, uint32_t index);
template const typename GenGfxFamily::RENDER_SURFACE_STATE *NEO::HardwareParse::getSurfaceState<GenGfxFamily>(IndirectHeap *ssh, uint32_t index);

2
shared/test/common/xe_hpg_core/test_preemption_xe_hpg_core.cpp
View File

@@ -11,7 +11,7 @@
using namespace NEO;
template <>
PreemptionTestHwDetails getPreemptionTestHwDetails<XE_HPG_COREFamily>() {
PreemptionTestHwDetails getPreemptionTestHwDetails<XeHpgCoreFamily>() {
PreemptionTestHwDetails ret;
ret.modeToRegValueMap[PreemptionMode::ThreadGroup] = DwordBuilder::build(1, true) | DwordBuilder::build(2, true, false);
ret.modeToRegValueMap[PreemptionMode::MidBatch] = DwordBuilder::build(2, true) | DwordBuilder::build(1, true, false);

2
shared/test/common/xe_hpg_core/unit_test_helper_xe_hpg_core.cpp
View File

@@ -10,7 +10,7 @@
#include "shared/test/common/helpers/unit_test_helper.h"
#include "shared/test/common/helpers/unit_test_helper.inl"
#include "shared/test/common/helpers/unit_test_helper_xehp_and_later.inl"
using Family = NEO::XE_HPG_COREFamily;
using Family = NEO::XeHpgCoreFamily;
namespace NEO {
template <>

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

@@ -19,12 +19,12 @@
using namespace NEO;
struct Gen11CoherencyRequirements : public ::testing::Test {
typedef typename ICLFamily::MI_LOAD_REGISTER_IMM MI_LOAD_REGISTER_IMM;
typedef typename Gen11Family::MI_LOAD_REGISTER_IMM MI_LOAD_REGISTER_IMM;
struct myCsr : public CommandStreamReceiverHw<ICLFamily> {
struct myCsr : public CommandStreamReceiverHw<Gen11Family> {
using CommandStreamReceiver::commandStream;
using CommandStreamReceiver::streamProperties;
myCsr(ExecutionEnvironment &executionEnvironment) : CommandStreamReceiverHw<ICLFamily>(executionEnvironment, 0, 1){};
myCsr(ExecutionEnvironment &executionEnvironment) : CommandStreamReceiverHw<Gen11Family>(executionEnvironment, 0, 1){};
CsrSizeRequestFlags *getCsrRequestFlags() { return &csrSizeRequestFlags; }
};
@@ -105,7 +105,7 @@ struct Gen11CoherencyProgramingTest : public Gen11CoherencyRequirements {
void findMmio(bool expectToBeProgrammed, uint32_t registerAddress) {
HardwareParse hwParser;
hwParser.parseCommands<ICLFamily>(csr->commandStream, startOffset);
hwParser.parseCommands<Gen11Family>(csr->commandStream, startOffset);
bool foundOne = false;
for (auto it = hwParser.cmdList.begin(); it != hwParser.cmdList.end(); it++) {

10
shared/test/unit_test/gen11/icllp/test_program_media_sampler_icllp.cpp
View File

@@ -19,13 +19,13 @@
using namespace NEO;
struct Gen11MediaSamplerProgramingTest : public ::testing::Test {
typedef typename ICLFamily::MI_LOAD_REGISTER_IMM MI_LOAD_REGISTER_IMM;
typedef typename ICLFamily::PIPE_CONTROL PIPE_CONTROL;
typedef typename Gen11Family::MI_LOAD_REGISTER_IMM MI_LOAD_REGISTER_IMM;
typedef typename Gen11Family::PIPE_CONTROL PIPE_CONTROL;
struct myCsr : public CommandStreamReceiverHw<ICLFamily> {
struct myCsr : public CommandStreamReceiverHw<Gen11Family> {
using CommandStreamReceiver::commandStream;
using CommandStreamReceiverHw<ICLFamily>::programMediaSampler;
myCsr(ExecutionEnvironment &executionEnvironment) : CommandStreamReceiverHw<ICLFamily>(executionEnvironment, 0, 1){};
using CommandStreamReceiverHw<Gen11Family>::programMediaSampler;
myCsr(ExecutionEnvironment &executionEnvironment) : CommandStreamReceiverHw<Gen11Family>(executionEnvironment, 0, 1){};
void overrideLastVmeSubliceConfig(bool value) {
lastVmeSubslicesConfig = value;
}

2
shared/test/unit_test/gen11/preamble_tests_gen11.cpp
View File

@@ -11,7 +11,7 @@
#include "gtest/gtest.h"
using namespace NEO;
typedef ICLFamily GfxFamily;
typedef Gen11Family GfxFamily;
#include "shared/test/unit_test/source_level_debugger/source_level_debugger_preamble_test.inl"

36
shared/test/unit_test/gen11/test_preamble_gen11.cpp
View File

@@ -18,12 +18,12 @@ using namespace NEO;
typedef PreambleFixture IclSlm;
GEN11TEST_F(IclSlm, WhenL3ConfigIsDispatchedThenProperRegisterAddressAndValueAreProgrammed) {
typedef ICLFamily::MI_LOAD_REGISTER_IMM MI_LOAD_REGISTER_IMM;
typedef Gen11Family::MI_LOAD_REGISTER_IMM MI_LOAD_REGISTER_IMM;
LinearStream &cs = linearStream;
uint32_t l3Config = PreambleHelper<FamilyType>::getL3Config(*defaultHwInfo, true);
PreambleHelper<FamilyType>::programL3(&cs, l3Config);
parseCommands<ICLFamily>(cs);
parseCommands<Gen11Family>(cs);
auto itorLRI = find<MI_LOAD_REGISTER_IMM *>(cmdList.begin(), cmdList.end());
ASSERT_NE(cmdList.end(), itorLRI);
@@ -57,14 +57,14 @@ GEN11TEST_F(Gen11UrbEntryAllocationSize, WhenPreambleRetrievesUrbEntryAllocation
typedef PreambleVfeState Gen11PreambleVfeState;
GEN11TEST_F(Gen11PreambleVfeState, GivenWaOffWhenProgrammingVfeStateThenProgrammingIsCorrect) {
typedef typename ICLFamily::PIPE_CONTROL PIPE_CONTROL;
typedef typename Gen11Family::PIPE_CONTROL PIPE_CONTROL;
testWaTable->flags.waSendMIFLUSHBeforeVFE = 0;
LinearStream &cs = linearStream;
auto pVfeCmd = PreambleHelper<ICLFamily>::getSpaceForVfeState(&linearStream, pDevice->getHardwareInfo(), EngineGroupType::RenderCompute);
auto pVfeCmd = PreambleHelper<Gen11Family>::getSpaceForVfeState(&linearStream, pDevice->getHardwareInfo(), EngineGroupType::RenderCompute);
StreamProperties emptyProperties{};
PreambleHelper<ICLFamily>::programVfeState(pVfeCmd, pDevice->getHardwareInfo(), 0u, 0, 168u, emptyProperties, nullptr);
PreambleHelper<Gen11Family>::programVfeState(pVfeCmd, pDevice->getHardwareInfo(), 0u, 0, 168u, emptyProperties, nullptr);
parseCommands<ICLFamily>(cs);
parseCommands<Gen11Family>(cs);
auto itorPC = find<PIPE_CONTROL *>(cmdList.begin(), cmdList.end());
ASSERT_NE(cmdList.end(), itorPC);
@@ -77,14 +77,14 @@ GEN11TEST_F(Gen11PreambleVfeState, GivenWaOffWhenProgrammingVfeStateThenProgramm
}
GEN11TEST_F(Gen11PreambleVfeState, GivenWaOnWhenProgrammingVfeStateThenProgrammingIsCorrect) {
typedef typename ICLFamily::PIPE_CONTROL PIPE_CONTROL;
typedef typename Gen11Family::PIPE_CONTROL PIPE_CONTROL;
testWaTable->flags.waSendMIFLUSHBeforeVFE = 1;
LinearStream &cs = linearStream;
auto pVfeCmd = PreambleHelper<ICLFamily>::getSpaceForVfeState(&linearStream, pDevice->getHardwareInfo(), EngineGroupType::RenderCompute);
auto pVfeCmd = PreambleHelper<Gen11Family>::getSpaceForVfeState(&linearStream, pDevice->getHardwareInfo(), EngineGroupType::RenderCompute);
StreamProperties emptyProperties{};
PreambleHelper<ICLFamily>::programVfeState(pVfeCmd, pDevice->getHardwareInfo(), 0u, 0, 168u, emptyProperties, nullptr);
PreambleHelper<Gen11Family>::programVfeState(pVfeCmd, pDevice->getHardwareInfo(), 0u, 0, 168u, emptyProperties, nullptr);
parseCommands<ICLFamily>(cs);
parseCommands<Gen11Family>(cs);
auto itorPC = find<PIPE_CONTROL *>(cmdList.begin(), cmdList.end());
ASSERT_NE(cmdList.end(), itorPC);
@@ -119,8 +119,8 @@ typedef PreambleFixture ThreadArbitrationGen11;
GEN11TEST_F(ThreadArbitrationGen11, givenPreambleWhenItIsProgrammedThenThreadArbitrationIsNotSet) {
DebugManagerStateRestore dbgRestore;
DebugManager.flags.ForcePreemptionMode.set(static_cast<int32_t>(PreemptionMode::Disabled));
typedef ICLFamily::MI_LOAD_REGISTER_IMM MI_LOAD_REGISTER_IMM;
typedef ICLFamily::PIPE_CONTROL PIPE_CONTROL;
typedef Gen11Family::MI_LOAD_REGISTER_IMM MI_LOAD_REGISTER_IMM;
typedef Gen11Family::PIPE_CONTROL PIPE_CONTROL;
LinearStream &cs = linearStream;
uint32_t l3Config = PreambleHelper<FamilyType>::getL3Config(*defaultHwInfo, true);
MockDevice mockDevice;
@@ -136,14 +136,14 @@ GEN11TEST_F(ThreadArbitrationGen11, givenPreambleWhenItIsProgrammedThenThreadArb
ASSERT_EQ(nullptr, cmd);
MockDevice device;
EXPECT_EQ(0u, PreambleHelper<ICLFamily>::getAdditionalCommandsSize(device));
EXPECT_EQ(0u, PreambleHelper<Gen11Family>::getAdditionalCommandsSize(device));
}
GEN11TEST_F(ThreadArbitrationGen11, whenThreadArbitrationPolicyIsProgrammedThenCorrectValuesAreSet) {
DebugManagerStateRestore dbgRestore;
DebugManager.flags.ForcePreemptionMode.set(static_cast<int32_t>(PreemptionMode::Disabled));
typedef ICLFamily::MI_LOAD_REGISTER_IMM MI_LOAD_REGISTER_IMM;
typedef ICLFamily::PIPE_CONTROL PIPE_CONTROL;
typedef Gen11Family::MI_LOAD_REGISTER_IMM MI_LOAD_REGISTER_IMM;
typedef Gen11Family::PIPE_CONTROL PIPE_CONTROL;
LinearStream &cs = linearStream;
MockDevice mockDevice;
StreamProperties streamProperties{};
@@ -161,15 +161,15 @@ GEN11TEST_F(ThreadArbitrationGen11, whenThreadArbitrationPolicyIsProgrammedThenC
EXPECT_EQ(RowChickenReg4::regDataForArbitrationPolicy[ThreadArbitrationPolicy::RoundRobin], cmd->getDataDword());
MockDevice device;
EXPECT_EQ(0u, PreambleHelper<ICLFamily>::getAdditionalCommandsSize(device));
EXPECT_EQ(0u, PreambleHelper<Gen11Family>::getAdditionalCommandsSize(device));
}
GEN11TEST_F(ThreadArbitrationGen11, GivenDefaultWhenProgrammingPreambleThenArbitrationPolicyIsRoundRobin) {
EXPECT_EQ(ThreadArbitrationPolicy::RoundRobinAfterDependency, HwHelperHw<ICLFamily>::get().getDefaultThreadArbitrationPolicy());
EXPECT_EQ(ThreadArbitrationPolicy::RoundRobinAfterDependency, HwHelperHw<Gen11Family>::get().getDefaultThreadArbitrationPolicy());
}
GEN11TEST_F(ThreadArbitrationGen11, whenGetSupportThreadArbitrationPoliciesIsCalledThenAllPoliciesAreReturned) {
auto supportedPolicies = PreambleHelper<ICLFamily>::getSupportedThreadArbitrationPolicies();
auto supportedPolicies = PreambleHelper<Gen11Family>::getSupportedThreadArbitrationPolicies();
EXPECT_EQ(3u, supportedPolicies.size());
EXPECT_NE(supportedPolicies.end(), std::find(supportedPolicies.begin(),

2
shared/test/unit_test/gen11/test_preemption_gen11.cpp
View File

@@ -18,7 +18,7 @@
using namespace NEO;
template <>
PreemptionTestHwDetails getPreemptionTestHwDetails<ICLFamily>() {
PreemptionTestHwDetails getPreemptionTestHwDetails<Gen11Family>() {
PreemptionTestHwDetails ret;
ret.modeToRegValueMap[PreemptionMode::ThreadGroup] = DwordBuilder::build(1, true) | DwordBuilder::build(2, true, false);
ret.modeToRegValueMap[PreemptionMode::MidBatch] = DwordBuilder::build(2, true) | DwordBuilder::build(1, true, false);

16
shared/test/unit_test/gen12lp/image_surface_state_tests_gen12lp.cpp
View File

@@ -14,28 +14,28 @@ using namespace NEO;
using ImageSurfaceStateTestsGen12LP = ImageSurfaceStateTests;
GEN12LPTEST_F(ImageSurfaceStateTestsGen12LP, givenGmmWithMediaCompressedWhenSetFlagsForMediaCompressionThenAuxiliarySurfaceNoneIsSetAndMemoryCompressionEnable) {
auto size = sizeof(typename TGLLPFamily::RENDER_SURFACE_STATE);
auto size = sizeof(typename Gen12LpFamily::RENDER_SURFACE_STATE);
auto surfaceState = std::make_unique<char[]>(size);
auto castSurfaceState = reinterpret_cast<typename TGLLPFamily::RENDER_SURFACE_STATE *>(surfaceState.get());
castSurfaceState->setAuxiliarySurfaceMode(TGLLPFamily::RENDER_SURFACE_STATE::AUXILIARY_SURFACE_MODE::AUXILIARY_SURFACE_MODE_AUX_CCS_E);
auto castSurfaceState = reinterpret_cast<typename Gen12LpFamily::RENDER_SURFACE_STATE *>(surfaceState.get());
castSurfaceState->setAuxiliarySurfaceMode(Gen12LpFamily::RENDER_SURFACE_STATE::AUXILIARY_SURFACE_MODE::AUXILIARY_SURFACE_MODE_AUX_CCS_E);
mockGmm->gmmResourceInfo->getResourceFlags()->Info.MediaCompressed = false;
EncodeSurfaceState<FamilyType>::setFlagsForMediaCompression(castSurfaceState, mockGmm.get());
EXPECT_EQ(castSurfaceState->getAuxiliarySurfaceMode(), TGLLPFamily::RENDER_SURFACE_STATE::AUXILIARY_SURFACE_MODE::AUXILIARY_SURFACE_MODE_AUX_CCS_E);
EXPECT_EQ(castSurfaceState->getAuxiliarySurfaceMode(), Gen12LpFamily::RENDER_SURFACE_STATE::AUXILIARY_SURFACE_MODE::AUXILIARY_SURFACE_MODE_AUX_CCS_E);
EXPECT_EQ(castSurfaceState->getMemoryCompressionEnable(), false);
mockGmm->gmmResourceInfo->getResourceFlags()->Info.MediaCompressed = true;
EncodeSurfaceState<FamilyType>::setFlagsForMediaCompression(castSurfaceState, mockGmm.get());
EXPECT_EQ(castSurfaceState->getAuxiliarySurfaceMode(), TGLLPFamily::RENDER_SURFACE_STATE::AUXILIARY_SURFACE_MODE::AUXILIARY_SURFACE_MODE_AUX_NONE);
EXPECT_EQ(castSurfaceState->getAuxiliarySurfaceMode(), Gen12LpFamily::RENDER_SURFACE_STATE::AUXILIARY_SURFACE_MODE::AUXILIARY_SURFACE_MODE_AUX_NONE);
EXPECT_EQ(castSurfaceState->getMemoryCompressionEnable(), true);
}
GEN12LPTEST_F(ImageSurfaceStateTestsGen12LP, givenGmmWhenSetClearColorParamsThenClearValueAddressEnable) {
auto size = sizeof(typename TGLLPFamily::RENDER_SURFACE_STATE);
auto size = sizeof(typename Gen12LpFamily::RENDER_SURFACE_STATE);
auto surfaceState = std::make_unique<char[]>(size);
auto castSurfaceState = reinterpret_cast<typename TGLLPFamily::RENDER_SURFACE_STATE *>(surfaceState.get());
auto castSurfaceState = reinterpret_cast<typename Gen12LpFamily::RENDER_SURFACE_STATE *>(surfaceState.get());
mockGmm->gmmResourceInfo->getResourceFlags()->Gpu.IndirectClearColor = true;
EncodeSurfaceState<TGLLPFamily>::setClearColorParams(castSurfaceState, mockGmm.get());
EncodeSurfaceState<Gen12LpFamily>::setClearColorParams(castSurfaceState, mockGmm.get());
EXPECT_EQ(castSurfaceState->getClearValueAddressEnable(), true);
}

16
shared/test/unit_test/gen12lp/test_preamble_gen12lp.cpp
View File

@@ -19,14 +19,14 @@ typedef PreambleFixture TglLpSlm;
HWTEST2_F(TglLpSlm, givenTglLpWhenPreambleIsBeingProgrammedThenThreadArbitrationPolicyIsIgnored, IsTGLLP) {
DebugManagerStateRestore dbgRestore;
DebugManager.flags.ForcePreemptionMode.set(static_cast<int32_t>(PreemptionMode::Disabled));
typedef TGLLPFamily::MI_LOAD_REGISTER_IMM MI_LOAD_REGISTER_IMM;
typedef Gen12LpFamily::MI_LOAD_REGISTER_IMM MI_LOAD_REGISTER_IMM;
LinearStream &cs = linearStream;
uint32_t l3Config = PreambleHelper<TGLLPFamily>::getL3Config(pDevice->getHardwareInfo(), true);
uint32_t l3Config = PreambleHelper<Gen12LpFamily>::getL3Config(pDevice->getHardwareInfo(), true);
MockDevice mockDevice;
PreambleHelper<TGLLPFamily>::programPreamble(&linearStream, mockDevice, l3Config,
nullptr, nullptr);
PreambleHelper<Gen12LpFamily>::programPreamble(&linearStream, mockDevice, l3Config,
nullptr, nullptr);
parseCommands<TGLLPFamily>(cs);
parseCommands<Gen12LpFamily>(cs);
// parse through commands and ensure that 0xE404 is not being programmed
EXPECT_EQ(0U, countMmio<FamilyType>(cmdList.begin(), cmdList.end(), 0xE404));
@@ -34,18 +34,18 @@ HWTEST2_F(TglLpSlm, givenTglLpWhenPreambleIsBeingProgrammedThenThreadArbitration
HWTEST2_F(TglLpSlm, WhenCheckingL3IsConfigurableThenExpectItToBeFalse, IsTGLLP) {
bool isL3Programmable =
PreambleHelper<TGLLPFamily>::isL3Configurable(*defaultHwInfo);
PreambleHelper<Gen12LpFamily>::isL3Configurable(*defaultHwInfo);
EXPECT_FALSE(isL3Programmable);
}
HWTEST2_F(TglLpSlm, WhenPreambleIsCreatedThenSlmIsDisabled, IsTGLLP) {
typedef TGLLPFamily::MI_LOAD_REGISTER_IMM MI_LOAD_REGISTER_IMM;
typedef Gen12LpFamily::MI_LOAD_REGISTER_IMM MI_LOAD_REGISTER_IMM;
LinearStream &cs = linearStream;
uint32_t l3Config = PreambleHelper<FamilyType>::getL3Config(pDevice->getHardwareInfo(), true);
PreambleHelper<FamilyType>::programL3(&cs, l3Config);
parseCommands<TGLLPFamily>(cs);
parseCommands<Gen12LpFamily>(cs);
auto itorLRI = find<MI_LOAD_REGISTER_IMM *>(cmdList.begin(), cmdList.end());
ASSERT_EQ(cmdList.end(), itorLRI);

2
shared/test/unit_test/gen12lp/test_preemption_gen12lp.cpp
View File

@@ -14,7 +14,7 @@
using namespace NEO;
template <>
PreemptionTestHwDetails getPreemptionTestHwDetails<TGLLPFamily>() {
PreemptionTestHwDetails getPreemptionTestHwDetails<Gen12LpFamily>() {
PreemptionTestHwDetails ret;
ret.modeToRegValueMap[PreemptionMode::ThreadGroup] = DwordBuilder::build(1, true) | DwordBuilder::build(2, true, false);
ret.modeToRegValueMap[PreemptionMode::MidBatch] = DwordBuilder::build(2, true) | DwordBuilder::build(1, true, false);

32
shared/test/unit_test/gen8/test_preamble_gen8.cpp
View File

@@ -17,18 +17,18 @@ using namespace NEO;
typedef PreambleFixture BdwSlm;
BDWTEST_F(BdwSlm, WhenL3ConfigIsDispatchedThenProperRegisterAddressAndValueAreProgrammed) {
typedef BDWFamily::MI_LOAD_REGISTER_IMM MI_LOAD_REGISTER_IMM;
typedef Gen8Family::MI_LOAD_REGISTER_IMM MI_LOAD_REGISTER_IMM;
LinearStream &cs = linearStream;
uint32_t l3Config = PreambleHelper<BDWFamily>::getL3Config(*defaultHwInfo, true);
PreambleHelper<BDWFamily>::programL3(&cs, l3Config);
uint32_t l3Config = PreambleHelper<Gen8Family>::getL3Config(*defaultHwInfo, true);
PreambleHelper<Gen8Family>::programL3(&cs, l3Config);
parseCommands<BDWFamily>(cs);
parseCommands<Gen8Family>(cs);
auto itorLRI = find<MI_LOAD_REGISTER_IMM *>(cmdList.begin(), cmdList.end());
ASSERT_NE(cmdList.end(), itorLRI);
const auto &lri = *reinterpret_cast<MI_LOAD_REGISTER_IMM *>(*itorLRI);
auto registerOffset = L3CNTLRegisterOffset<BDWFamily>::registerOffset;
auto registerOffset = L3CNTLRegisterOffset<Gen8Family>::registerOffset;
EXPECT_EQ(registerOffset, lri.getRegisterOffset());
EXPECT_EQ(1u, lri.getDataDword() & 1);
}
@@ -62,17 +62,17 @@ BDWTEST_F(Gen8L3Config, WhenPreambleIsCreatedThenL3ProgrammingIsCorrect) {
bool isL3Programmable;
l3ConfigDifference =
PreambleHelper<BDWFamily>::getL3Config(*defaultHwInfo, true) !=
PreambleHelper<BDWFamily>::getL3Config(*defaultHwInfo, false);
PreambleHelper<Gen8Family>::getL3Config(*defaultHwInfo, true) !=
PreambleHelper<Gen8Family>::getL3Config(*defaultHwInfo, false);
isL3Programmable =
PreambleHelper<BDWFamily>::isL3Configurable(*defaultHwInfo);
PreambleHelper<Gen8Family>::isL3Configurable(*defaultHwInfo);
EXPECT_EQ(l3ConfigDifference, isL3Programmable);
}
typedef PreambleFixture ThreadArbitrationGen8;
BDWTEST_F(ThreadArbitrationGen8, givenPolicyWhenThreadArbitrationProgrammedThenDoNothing) {
typedef BDWFamily::MI_LOAD_REGISTER_IMM MI_LOAD_REGISTER_IMM;
typedef Gen8Family::MI_LOAD_REGISTER_IMM MI_LOAD_REGISTER_IMM;
LinearStream &cs = linearStream;
StreamProperties streamProperties{};
@@ -82,12 +82,12 @@ BDWTEST_F(ThreadArbitrationGen8, givenPolicyWhenThreadArbitrationProgrammedThenD
EXPECT_EQ(0u, cs.getUsed());
MockDevice device;
EXPECT_EQ(0u, PreambleHelper<BDWFamily>::getAdditionalCommandsSize(device));
EXPECT_EQ(ThreadArbitrationPolicy::AgeBased, HwHelperHw<BDWFamily>::get().getDefaultThreadArbitrationPolicy());
EXPECT_EQ(0u, PreambleHelper<Gen8Family>::getAdditionalCommandsSize(device));
EXPECT_EQ(ThreadArbitrationPolicy::AgeBased, HwHelperHw<Gen8Family>::get().getDefaultThreadArbitrationPolicy());
}
BDWTEST_F(ThreadArbitrationGen8, whenGetSupportThreadArbitrationPoliciesIsCalledThenEmptyVectorIsReturned) {
auto supportedPolicies = PreambleHelper<BDWFamily>::getSupportedThreadArbitrationPolicies();
auto supportedPolicies = PreambleHelper<Gen8Family>::getSupportedThreadArbitrationPolicies();
EXPECT_EQ(0u, supportedPolicies.size());
}
@@ -99,14 +99,14 @@ BDWTEST_F(Gen8UrbEntryAllocationSize, WhenPreambleIsCreatedThenUrbEntryAllocatio
}
BDWTEST_F(PreambleVfeState, WhenProgrammingVfeStateThenProgrammingIsCorrect) {
typedef BDWFamily::PIPE_CONTROL PIPE_CONTROL;
typedef Gen8Family::PIPE_CONTROL PIPE_CONTROL;
LinearStream &cs = linearStream;
auto pVfeCmd = PreambleHelper<BDWFamily>::getSpaceForVfeState(&linearStream, *defaultHwInfo, EngineGroupType::RenderCompute);
auto pVfeCmd = PreambleHelper<Gen8Family>::getSpaceForVfeState(&linearStream, *defaultHwInfo, EngineGroupType::RenderCompute);
StreamProperties emptyProperties{};
PreambleHelper<BDWFamily>::programVfeState(pVfeCmd, *defaultHwInfo, 0u, 0, 168u, emptyProperties, nullptr);
PreambleHelper<Gen8Family>::programVfeState(pVfeCmd, *defaultHwInfo, 0u, 0, 168u, emptyProperties, nullptr);
parseCommands<BDWFamily>(cs);
parseCommands<Gen8Family>(cs);
auto itorPC = find<PIPE_CONTROL *>(cmdList.begin(), cmdList.end());
ASSERT_NE(cmdList.end(), itorPC);

2
shared/test/unit_test/gen8/test_preemption_gen8.cpp
View File

@@ -16,7 +16,7 @@
using namespace NEO;
template <>
PreemptionTestHwDetails getPreemptionTestHwDetails<BDWFamily>() {
PreemptionTestHwDetails getPreemptionTestHwDetails<Gen8Family>() {
PreemptionTestHwDetails ret;
ret.modeToRegValueMap[PreemptionMode::ThreadGroup] = 0;
ret.modeToRegValueMap[PreemptionMode::MidBatch] = (1 << 2);

22
shared/test/unit_test/gen9/preamble_tests_gen9.cpp
View File

@@ -13,7 +13,7 @@
#include "gtest/gtest.h"
using namespace NEO;
typedef SKLFamily GfxFamily;
typedef Gen9Family GfxFamily;
#include "shared/test/unit_test/source_level_debugger/source_level_debugger_preamble_test.inl"
@@ -68,15 +68,15 @@ using ThreadArbitrationGen9 = PreambleFixture;
GEN9TEST_F(ThreadArbitrationGen9, givenPreambleWhenItIsProgrammedThenThreadArbitrationIsNotSet) {
DebugManagerStateRestore dbgRestore;
DebugManager.flags.ForcePreemptionMode.set(static_cast<int32_t>(PreemptionMode::Disabled));
typedef SKLFamily::MI_LOAD_REGISTER_IMM MI_LOAD_REGISTER_IMM;
typedef SKLFamily::PIPE_CONTROL PIPE_CONTROL;
typedef Gen9Family::MI_LOAD_REGISTER_IMM MI_LOAD_REGISTER_IMM;
typedef Gen9Family::PIPE_CONTROL PIPE_CONTROL;
LinearStream &cs = linearStream;
uint32_t l3Config = PreambleHelper<FamilyType>::getL3Config(*defaultHwInfo, true);
MockDevice mockDevice;
PreambleHelper<SKLFamily>::programPreamble(&linearStream, mockDevice, l3Config,
nullptr, nullptr);
PreambleHelper<Gen9Family>::programPreamble(&linearStream, mockDevice, l3Config,
nullptr, nullptr);
parseCommands<SKLFamily>(cs);
parseCommands<Gen9Family>(cs);
auto ppC = find<PIPE_CONTROL *>(cmdList.begin(), cmdList.end());
ASSERT_EQ(cmdList.end(), ppC);
@@ -89,21 +89,21 @@ GEN9TEST_F(ThreadArbitrationGen9, givenPreambleWhenItIsProgrammedThenThreadArbit
EXPECT_NE(0x100u, lri.getDataDword());
MockDevice device;
EXPECT_EQ(0u, PreambleHelper<SKLFamily>::getAdditionalCommandsSize(device));
EXPECT_EQ(0u, PreambleHelper<Gen9Family>::getAdditionalCommandsSize(device));
}
GEN9TEST_F(ThreadArbitrationGen9, whenThreadArbitrationPolicyIsProgrammedThenCorrectValuesAreSet) {
DebugManagerStateRestore dbgRestore;
DebugManager.flags.ForcePreemptionMode.set(static_cast<int32_t>(PreemptionMode::Disabled));
typedef SKLFamily::MI_LOAD_REGISTER_IMM MI_LOAD_REGISTER_IMM;
typedef SKLFamily::PIPE_CONTROL PIPE_CONTROL;
typedef Gen9Family::MI_LOAD_REGISTER_IMM MI_LOAD_REGISTER_IMM;
typedef Gen9Family::PIPE_CONTROL PIPE_CONTROL;
LinearStream &cs = linearStream;
MockDevice mockDevice;
StreamProperties streamProperties{};
streamProperties.stateComputeMode.threadArbitrationPolicy.set(ThreadArbitrationPolicy::RoundRobin);
EncodeComputeMode<FamilyType>::programComputeModeCommand(linearStream, streamProperties.stateComputeMode, *defaultHwInfo, nullptr);
parseCommands<SKLFamily>(cs);
parseCommands<Gen9Family>(cs);
auto ppC = find<PIPE_CONTROL *>(cmdList.begin(), cmdList.end());
ASSERT_NE(ppC, cmdList.end());
@@ -116,5 +116,5 @@ GEN9TEST_F(ThreadArbitrationGen9, whenThreadArbitrationPolicyIsProgrammedThenCor
EXPECT_EQ(0x100u, lri.getDataDword());
MockDevice device;
EXPECT_EQ(0u, PreambleHelper<SKLFamily>::getAdditionalCommandsSize(device));
EXPECT_EQ(0u, PreambleHelper<Gen9Family>::getAdditionalCommandsSize(device));
}

2
shared/test/unit_test/gen9/test_preemption_gen9.cpp
View File

@@ -20,7 +20,7 @@
using namespace NEO;
template <>
PreemptionTestHwDetails getPreemptionTestHwDetails<SKLFamily>() {
PreemptionTestHwDetails getPreemptionTestHwDetails<Gen9Family>() {
PreemptionTestHwDetails ret;
ret.modeToRegValueMap[PreemptionMode::ThreadGroup] = DwordBuilder::build(1, true) | DwordBuilder::build(2, true, false);
ret.modeToRegValueMap[PreemptionMode::MidBatch] = DwordBuilder::build(2, true) | DwordBuilder::build(1, true, false);

4
shared/test/unit_test/xe_hpg_core/dg2/hw_info_config_tests_dg2.cpp
View File

@@ -342,12 +342,12 @@ DG2TEST_F(HwInfoConfigTestDg2, givenDg2WhenSetForceNonCoherentThenProperFlagSet)
properties.isCoherencyRequired.set(false);
hwInfoConfig->setForceNonCoherent(&stateComputeMode, properties);
EXPECT_EQ(FORCE_NON_COHERENT::FORCE_NON_COHERENT_FORCE_GPU_NON_COHERENT, stateComputeMode.getForceNonCoherent());
EXPECT_EQ(XE_HPG_COREFamily::stateComputeModeForceNonCoherentMask, stateComputeMode.getMaskBits());
EXPECT_EQ(XeHpgCoreFamily::stateComputeModeForceNonCoherentMask, stateComputeMode.getMaskBits());
properties.isCoherencyRequired.set(true);
hwInfoConfig->setForceNonCoherent(&stateComputeMode, properties);
EXPECT_EQ(FORCE_NON_COHERENT::FORCE_NON_COHERENT_FORCE_DISABLED, stateComputeMode.getForceNonCoherent());
EXPECT_EQ(XE_HPG_COREFamily::stateComputeModeForceNonCoherentMask, stateComputeMode.getMaskBits());
EXPECT_EQ(XeHpgCoreFamily::stateComputeModeForceNonCoherentMask, stateComputeMode.getMaskBits());
}
DG2TEST_F(HwInfoConfigTestDg2, givenEnabledSliceInNonStandardConfigWhenComputeUnitsUsedForScratchThenProperCalculationIsReturned) {