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

Introduce getHelper - common getter for HwInfoConfig and HwHelper

Browse Source 
Related-To: NEO-6853
Signed-off-by: Kamil Kopryk <kamil.kopryk@intel.com>

Added getHelper common getter for hwInfoConfig and hwHelper
and use it as CoreHelper(HwHelper) and ProductHelper(HwInfoConfig)
This commit is contained in:
Kamil Kopryk
2022-11-08 16:16:37 +00:00
committed by Compute-Runtime-Automation
parent eb349484f1
commit 46098e0e17
20 changed files with 140 additions and 103 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
opencl/test/unit_test/helpers/hw_helper_tests.cpp
View File

@@ -1040,11 +1040,11 @@ using HwInfoConfigCommonTest = Test<DeviceFixture>;
HWTEST2_F(HwInfoConfigCommonTest, givenBlitterPreferenceWhenEnablingBlitterOperationsSupportThenHonorThePreference, IsAtLeastGen12lp) {
HardwareInfo hardwareInfo = *defaultHwInfo;
auto &hwInfoConfig = getHwInfoConfig();
auto &productHelper = getHelper<ProductHelper>();
hwInfoConfig.configureHardwareCustom(&hardwareInfo, nullptr);
productHelper.configureHardwareCustom(&hardwareInfo, nullptr);
const auto expectedBlitterSupport = hwInfoConfig.obtainBlitterPreference(hardwareInfo);
const auto expectedBlitterSupport = productHelper.obtainBlitterPreference(hardwareInfo);
EXPECT_EQ(expectedBlitterSupport, hardwareInfo.capabilityTable.blitterOperationsSupported);
}
@@ -1080,14 +1080,14 @@ TEST_F(HwHelperTest, givenInvalidEngineTypeWhenGettingEngineGroupTypeThenThrow)
HWTEST2_F(HwInfoConfigCommonTest, givenDebugFlagSetWhenEnablingBlitterOperationsSupportThenHonorTheFlag, IsAtLeastGen12lp) {
DebugManagerStateRestore restore{};
HardwareInfo hardwareInfo = *defaultHwInfo;
auto &hwInfoConfig = getHwInfoConfig();
auto &productHelper = getHelper<ProductHelper>();
DebugManager.flags.EnableBlitterOperationsSupport.set(1);
hwInfoConfig.configureHardwareCustom(&hardwareInfo, nullptr);
productHelper.configureHardwareCustom(&hardwareInfo, nullptr);
EXPECT_TRUE(hardwareInfo.capabilityTable.blitterOperationsSupported);
DebugManager.flags.EnableBlitterOperationsSupport.set(0);
hwInfoConfig.configureHardwareCustom(&hardwareInfo, nullptr);
productHelper.configureHardwareCustom(&hardwareInfo, nullptr);
EXPECT_FALSE(hardwareInfo.capabilityTable.blitterOperationsSupported);
}

10
opencl/test/unit_test/xe_hp_core/hw_helper_tests_xe_hp_core.cpp
View File

@@ -202,27 +202,27 @@ using HwInfoConfigTestXE_HP_CORE = Test<DeviceFixture>;
XE_HP_CORE_TEST_F(HwInfoConfigTestXE_HP_CORE, givenDebugVariableSetWhenConfigureIsCalledThenSetupBlitterOperationsSupportedFlag) {
DebugManagerStateRestore restore;
auto &hwInfoConfig = getHwInfoConfig();
auto &productHelper = getHelper<ProductHelper>();
HardwareInfo hwInfo = *defaultHwInfo;
DebugManager.flags.EnableBlitterOperationsSupport.set(0);
hwInfoConfig.configureHardwareCustom(&hwInfo, nullptr);
productHelper.configureHardwareCustom(&hwInfo, nullptr);
EXPECT_FALSE(hwInfo.capabilityTable.blitterOperationsSupported);
DebugManager.flags.EnableBlitterOperationsSupport.set(1);
hwInfoConfig.configureHardwareCustom(&hwInfo, nullptr);
productHelper.configureHardwareCustom(&hwInfo, nullptr);
EXPECT_TRUE(hwInfo.capabilityTable.blitterOperationsSupported);
}
XE_HP_CORE_TEST_F(HwInfoConfigTestXE_HP_CORE, givenMultitileConfigWhenConfiguringHwInfoThenEnableBlitter) {
auto &hwInfoConfig = getHwInfoConfig();
auto &productHelper = getHelper<ProductHelper>();
HardwareInfo hwInfo = *defaultHwInfo;
for (uint32_t tileCount = 0; tileCount <= 4; tileCount++) {
hwInfo.gtSystemInfo.MultiTileArchInfo.TileCount = tileCount;
hwInfoConfig.configureHardwareCustom(&hwInfo, nullptr);
productHelper.configureHardwareCustom(&hwInfo, nullptr);
EXPECT_EQ(true, hwInfo.capabilityTable.blitterOperationsSupported);
}

22
opencl/test/unit_test/xe_hp_core/xehp/test_hw_info_config_xehp.inl
View File

@@ -24,26 +24,26 @@ using namespace NEO;
using XeHPHwInfoConfig = Test<DeviceFixture>;
XEHPTEST_F(XeHPHwInfoConfig, givenXeHPMultiConfigWhenConfigureHardwareCustomIsCalledThenCapabilityTableIsSetProperly) {
auto &hwInfoConfig = getHwInfoConfig();
auto &productHelper = getHelper<ProductHelper>();
HardwareInfo hwInfo = *defaultHwInfo;
hwInfo.featureTable.flags.ftrE2ECompression = true;
hwInfo.gtSystemInfo.EUCount = 256u;
hwInfoConfig.configureHardwareCustom(&hwInfo, nullptr);
productHelper.configureHardwareCustom(&hwInfo, nullptr);
EXPECT_FALSE(hwInfo.capabilityTable.ftrRenderCompressedBuffers);
EXPECT_FALSE(hwInfo.capabilityTable.ftrRenderCompressedImages);
hwInfo.gtSystemInfo.EUCount = 512u;
hwInfoConfig.configureHardwareCustom(&hwInfo, nullptr);
productHelper.configureHardwareCustom(&hwInfo, nullptr);
EXPECT_TRUE(hwInfo.capabilityTable.ftrRenderCompressedBuffers);
EXPECT_TRUE(hwInfo.capabilityTable.ftrRenderCompressedImages);
}
XEHPTEST_F(XeHPHwInfoConfig, givenXeHPWhenConfiguringThenDisableRcs) {
auto &hwInfoConfig = getHwInfoConfig();
auto &productHelper = getHelper<ProductHelper>();
HardwareInfo hwInfo = *defaultHwInfo;
hwInfoConfig.configureHardwareCustom(&hwInfo, nullptr);
productHelper.configureHardwareCustom(&hwInfo, nullptr);
EXPECT_FALSE(hwInfo.featureTable.flags.ftrRcsNode);
}
@@ -51,10 +51,10 @@ XEHPTEST_F(XeHPHwInfoConfig, givenDebugVariableSetWhenConfiguringThenEnableRcs)
DebugManagerStateRestore restore;
DebugManager.flags.NodeOrdinal.set(static_cast<int32_t>(aub_stream::EngineType::ENGINE_RCS));
auto &hwInfoConfig = getHwInfoConfig();
auto &productHelper = getHelper<ProductHelper>();
HardwareInfo hwInfo = *defaultHwInfo;
hwInfoConfig.configureHardwareCustom(&hwInfo, nullptr);
productHelper.configureHardwareCustom(&hwInfo, nullptr);
EXPECT_TRUE(hwInfo.featureTable.flags.ftrRcsNode);
}
@@ -65,7 +65,7 @@ XEHPTEST_F(XeHPHwInfoConfig, givenXeHpWhenCallingGetDeviceMemoryNameThenHbmIsRet
}
XEHPTEST_F(XeHPHwInfoConfig, givenA0OrA1SteppingWhenAskingIfExtraParametersAreInvalidThenReturnTrue) {
auto &hwInfoConfig = getHwInfoConfig();
auto &productHelper = getHelper<ProductHelper>();
std::array<std::pair<uint32_t, bool>, 4> revisions = {
{{REVISION_A0, true},
{REVISION_A1, true},
@@ -74,11 +74,11 @@ XEHPTEST_F(XeHPHwInfoConfig, givenA0OrA1SteppingWhenAskingIfExtraParametersAreIn
for (const auto &[revision, paramBool] : revisions) {
auto hwInfo = *defaultHwInfo;
hwInfo.platform.usRevId = hwInfoConfig.getHwRevIdFromStepping(revision, hwInfo);
hwInfo.platform.usRevId = productHelper.getHwRevIdFromStepping(revision, hwInfo);
hwInfoConfig.configureHardwareCustom(&hwInfo, nullptr);
productHelper.configureHardwareCustom(&hwInfo, nullptr);
EXPECT_EQ(paramBool, hwInfoConfig.extraParametersInvalid(hwInfo));
EXPECT_EQ(paramBool, productHelper.extraParametersInvalid(hwInfo));
}
}

10
opencl/test/unit_test/xe_hpc_core/hw_helper_tests_xe_hpc_core.cpp
View File

@@ -663,26 +663,26 @@ XE_HPC_CORETEST_F(HwInfoConfigTestXeHpcCore, givenDefaultHwInfoConfigHwWhenGetti
XE_HPC_CORETEST_F(HwInfoConfigTestXeHpcCore, givenDebugVariableSetWhenConfigureIsCalledThenSetupBlitterOperationsSupportedFlag) {
DebugManagerStateRestore restore;
auto &hwInfoConfig = getHwInfoConfig();
auto &productHelper = getHelper<ProductHelper>();
HardwareInfo hwInfo = *defaultHwInfo;
DebugManager.flags.EnableBlitterOperationsSupport.set(0);
hwInfoConfig.configureHardwareCustom(&hwInfo, nullptr);
productHelper.configureHardwareCustom(&hwInfo, nullptr);
EXPECT_FALSE(hwInfo.capabilityTable.blitterOperationsSupported);
DebugManager.flags.EnableBlitterOperationsSupport.set(1);
hwInfoConfig.configureHardwareCustom(&hwInfo, nullptr);
productHelper.configureHardwareCustom(&hwInfo, nullptr);
EXPECT_TRUE(hwInfo.capabilityTable.blitterOperationsSupported);
}
XE_HPC_CORETEST_F(HwInfoConfigTestXeHpcCore, givenMultitileConfigWhenConfiguringHwInfoThenEnableBlitter) {
auto &hwInfoConfig = getHwInfoConfig();
auto &productHelper = getHelper<ProductHelper>();
HardwareInfo hwInfo = *defaultHwInfo;
for (uint32_t tileCount = 0; tileCount <= 4; tileCount++) {
hwInfo.gtSystemInfo.MultiTileArchInfo.TileCount = tileCount;
hwInfoConfig.configureHardwareCustom(&hwInfo, nullptr);
productHelper.configureHardwareCustom(&hwInfo, nullptr);
EXPECT_EQ(true, hwInfo.capabilityTable.blitterOperationsSupported);
}

28
shared/source/device/device_caps.cpp
View File

@@ -9,6 +9,7 @@
#include "shared/source/compiler_interface/compiler_interface.h"
#include "shared/source/debugger/debugger.h"
#include "shared/source/device/device.h"
#include "shared/source/execution_environment/root_device_environment.h"
#include "shared/source/helpers/api_specific_config.h"
#include "shared/source/helpers/basic_math.h"
#include "shared/source/helpers/hw_helper.h"
@@ -33,10 +34,10 @@ size_t Device::getMaxParameterSizeFromIGC() const {
void Device::initializeCaps() {
auto &hwInfo = getHardwareInfo();
auto hwInfoConfig = HwInfoConfig::get(hwInfo.platform.eProductFamily);
auto addressing32bitAllowed = is64bit;
auto &hwHelper = HwHelper::get(hwInfo.platform.eRenderCoreFamily);
auto &productHelper = this->getRootDeviceEnvironment().getHelper<NEO::ProductHelper>();
auto &coreHelper = this->getRootDeviceEnvironment().getHelper<NEO::CoreHelper>();
bool ocl21FeaturesEnabled = hwInfo.capabilityTable.supportsOcl21Features;
if (DebugManager.flags.ForceOCLVersion.get() != 0) {
@@ -57,7 +58,7 @@ void Device::initializeCaps() {
deviceInfo.addressBits = 64;
deviceInfo.ilVersion = spirvWithVersion;
//copy system info to prevent misaligned reads
// copy system info to prevent misaligned reads
const auto systemInfo = hwInfo.gtSystemInfo;
deviceInfo.globalMemCachelineSize = 64;
@@ -78,8 +79,9 @@ void Device::initializeCaps() {
deviceInfo.globalMemSize = alignDown(deviceInfo.globalMemSize, MemoryConstants::pageSize);
deviceInfo.maxMemAllocSize = std::min(deviceInfo.globalMemSize, deviceInfo.maxMemAllocSize); // if globalMemSize was reduced for 32b
uint32_t subDeviceCount = HwHelper::getSubDevicesCount(&getHardwareInfo());
bool platformImplicitScaling = hwHelper.platformSupportsImplicitScaling(hwInfo);
uint32_t subDeviceCount = coreHelper.getSubDevicesCount(&getHardwareInfo());
bool platformImplicitScaling = coreHelper.platformSupportsImplicitScaling(hwInfo);
if (((NEO::ImplicitScalingHelper::isImplicitScalingEnabled(
getDeviceBitfield(), platformImplicitScaling))) &&
@@ -89,7 +91,7 @@ void Device::initializeCaps() {
if (!areSharedSystemAllocationsAllowed()) {
deviceInfo.maxMemAllocSize = ApiSpecificConfig::getReducedMaxAllocSize(deviceInfo.maxMemAllocSize);
deviceInfo.maxMemAllocSize = std::min(deviceInfo.maxMemAllocSize, hwHelper.getMaxMemAllocSize());
deviceInfo.maxMemAllocSize = std::min(deviceInfo.maxMemAllocSize, coreHelper.getMaxMemAllocSize());
}
// Some specific driver model configurations may impose additional limitations
@@ -116,7 +118,7 @@ void Device::initializeCaps() {
deviceInfo.numThreadsPerEU = 0;
auto simdSizeUsed = DebugManager.flags.UseMaxSimdSizeToDeduceMaxWorkgroupSize.get()
? CommonConstants::maximalSimdSize
: hwHelper.getMinimalSIMDSize();
: coreHelper.getMinimalSIMDSize();
deviceInfo.maxNumEUsPerSubSlice = (systemInfo.EuCountPerPoolMin == 0 || hwInfo.featureTable.flags.ftrPooledEuEnabled == 0)
? (systemInfo.EUCount / systemInfo.SubSliceCount)
@@ -130,8 +132,8 @@ void Device::initializeCaps() {
deviceInfo.maxNumEUsPerDualSubSlice = deviceInfo.maxNumEUsPerSubSlice;
}
deviceInfo.numThreadsPerEU = systemInfo.ThreadCount / systemInfo.EUCount;
deviceInfo.threadsPerEUConfigs = hwHelper.getThreadsPerEUConfigs();
auto maxWS = hwInfoConfig->getMaxThreadsForWorkgroupInDSSOrSS(hwInfo, static_cast<uint32_t>(deviceInfo.maxNumEUsPerSubSlice), static_cast<uint32_t>(deviceInfo.maxNumEUsPerDualSubSlice)) * simdSizeUsed;
deviceInfo.threadsPerEUConfigs = coreHelper.getThreadsPerEUConfigs();
auto maxWS = productHelper.getMaxThreadsForWorkgroupInDSSOrSS(hwInfo, static_cast<uint32_t>(deviceInfo.maxNumEUsPerSubSlice), static_cast<uint32_t>(deviceInfo.maxNumEUsPerDualSubSlice)) * simdSizeUsed;
maxWS = Math::prevPowerOfTwo(maxWS);
deviceInfo.maxWorkGroupSize = std::min(maxWS, 1024u);
@@ -143,10 +145,10 @@ void Device::initializeCaps() {
deviceInfo.maxWorkItemSizes[0] = deviceInfo.maxWorkGroupSize;
deviceInfo.maxWorkItemSizes[1] = deviceInfo.maxWorkGroupSize;
deviceInfo.maxWorkItemSizes[2] = deviceInfo.maxWorkGroupSize;
deviceInfo.maxSamplers = hwHelper.getMaxNumSamplers();
deviceInfo.maxSamplers = coreHelper.getMaxNumSamplers();
deviceInfo.computeUnitsUsedForScratch = hwHelper.getComputeUnitsUsedForScratch(&hwInfo);
deviceInfo.maxFrontEndThreads = HwHelper::getMaxThreadsForVfe(hwInfo);
deviceInfo.computeUnitsUsedForScratch = coreHelper.getComputeUnitsUsedForScratch(&hwInfo);
deviceInfo.maxFrontEndThreads = coreHelper.getMaxThreadsForVfe(hwInfo);
deviceInfo.localMemSize = hwInfo.capabilityTable.slmSize * KB;
if (DebugManager.flags.OverrideSlmSize.get() != -1) {
@@ -162,7 +164,7 @@ void Device::initializeCaps() {
deviceInfo.printfBufferSize = 4 * MB;
deviceInfo.maxClockFrequency = hwInfo.capabilityTable.maxRenderFrequency;
deviceInfo.maxSubGroups = hwHelper.getDeviceSubGroupSizes();
deviceInfo.maxSubGroups = coreHelper.getDeviceSubGroupSizes();
deviceInfo.vmeAvcSupportsPreemption = hwInfo.capabilityTable.ftrSupportsVmeAvcPreemption;

17
shared/source/execution_environment/root_device_environment.cpp
View File

@@ -163,4 +163,21 @@ void RootDeviceEnvironment::limitNumberOfCcs(uint32_t numberOfCcs) {
bool RootDeviceEnvironment::isNumberOfCcsLimited() const {
return limitedNumberOfCcs;
}
template <typename HelperType>
HelperType &RootDeviceEnvironment::getHelper() const {
if constexpr (std::is_same_v<HelperType, ProductHelper>) {
auto &hwInfoConfig = *HwInfoConfig::get(this->getHardwareInfo()->platform.eProductFamily);
return hwInfoConfig;
}
if constexpr (std::is_same_v<HelperType, CoreHelper>) {
auto &hwHelper = HwHelper::get(this->getHardwareInfo()->platform.eRenderCoreFamily);
return hwHelper;
}
}
template ProductHelper &RootDeviceEnvironment::getHelper() const;
template CoreHelper &RootDeviceEnvironment::getHelper() const;
} // namespace NEO

8
shared/source/execution_environment/root_device_environment.h
View File

@@ -35,8 +35,12 @@ class OSTime;
class SipKernel;
class SWTagsManager;
class HwInfoConfig;
class HwHelper;
struct HardwareInfo;
using CoreHelper = HwHelper;
using ProductHelper = HwInfoConfig;
struct RootDeviceEnvironment {
protected:
std::unique_ptr<HardwareInfo> hwInfo;
@@ -69,6 +73,9 @@ struct RootDeviceEnvironment {
bool isNumberOfCcsLimited() const;
const HwInfoConfig &getHwInfoConfig() const;
template <typename HelperType>
HelperType &getHelper() const;
std::unique_ptr<SipKernel> sipKernels[static_cast<uint32_t>(SipKernelType::COUNT)];
std::unique_ptr<GmmHelper> gmmHelper;
std::unique_ptr<OSInterface> osInterface;
@@ -91,4 +98,5 @@ struct RootDeviceEnvironment {
private:
std::mutex mtx;
};
} // namespace NEO

10
shared/test/common/fixtures/device_fixture.cpp
View File

@@ -8,6 +8,7 @@
#include "shared/test/common/fixtures/device_fixture.h"
#include "shared/source/built_ins/sip.h"
#include "shared/source/execution_environment/root_device_environment.h"
#include "gtest/gtest.h"
@@ -38,8 +39,13 @@ MockDevice *DeviceFixture::createWithUsDeviceIdRevId(unsigned short usDeviceId,
return MockDevice::createWithNewExecutionEnvironment<MockDevice>(&hardwareInfo);
}
const HwInfoConfig &DeviceFixture::getHwInfoConfig() const {
return this->pDevice->getRootDeviceEnvironment().getHwInfoConfig();
template <typename HelperType>
HelperType &DeviceFixture::getHelper() const {
auto &helper = this->pDevice->getRootDeviceEnvironment().getHelper<HelperType>();
return helper;
}
template ProductHelper &DeviceFixture::getHelper<ProductHelper>() const;
template CoreHelper &DeviceFixture::getHelper<CoreHelper>() const;
} // namespace NEO

5
shared/test/common/fixtures/device_fixture.h
View File

@@ -23,6 +23,9 @@ struct DeviceFixture {
HardwareInfo hardwareInfo = {};
PLATFORM platformHelper = {};
const uint32_t rootDeviceIndex = 0u;
const HwInfoConfig &getHwInfoConfig() const;
template <typename HelperType>
HelperType &getHelper() const;
};
} // namespace NEO

4
shared/test/unit_test/gen12lp/dg1/linux/hw_info_config_tests_dg1.cpp
View File

@@ -21,13 +21,13 @@ using namespace NEO;
DG1TEST_F(HwInfoConfigTestLinuxDg1, GivenDG1WhenConfigureHardwareCustomThenMTPIsNotSet) {
HardwareInfo hardwareInfo = *defaultHwInfo;
auto &hwInfoConfig = getHwInfoConfig();
auto &productHelper = getHelper<ProductHelper>();
OSInterface osIface;
hardwareInfo.capabilityTable.defaultPreemptionMode = PreemptionMode::ThreadGroup;
PreemptionHelper::adjustDefaultPreemptionMode(hardwareInfo.capabilityTable, true, true, true);
hwInfoConfig.configureHardwareCustom(&hardwareInfo, &osIface);
productHelper.configureHardwareCustom(&hardwareInfo, &osIface);
EXPECT_FALSE(hardwareInfo.featureTable.flags.ftrGpGpuMidThreadLevelPreempt);
}

16
shared/test/unit_test/gen12lp/dg1/test_hw_info_config_dg1.cpp
View File

@@ -33,20 +33,20 @@ DG1TEST_F(Dg1HwInfoConfig, givenInvalidSystemInfoWhenSettingHardwareInfoThenExpe
}
DG1TEST_F(Dg1HwInfoConfig, givenA0SteppingAndDg1PlatformWhenAskingIfWAIsRequiredThenReturnTrue) {
auto &hwInfoConfig = getHwInfoConfig();
auto &productHelper = getHelper<ProductHelper>();
std::array<std::pair<uint32_t, bool>, 2> revisions = {
{{REVISION_A0, true},
{REVISION_B, false}}};
for (const auto &[revision, paramBool] : revisions) {
auto hwInfo = *defaultHwInfo;
hwInfo.platform.usRevId = hwInfoConfig.getHwRevIdFromStepping(revision, hwInfo);
hwInfo.platform.usRevId = productHelper.getHwRevIdFromStepping(revision, hwInfo);
hwInfoConfig.configureHardwareCustom(&hwInfo, nullptr);
productHelper.configureHardwareCustom(&hwInfo, nullptr);
EXPECT_EQ(paramBool, hwInfoConfig.pipeControlWARequired(hwInfo));
EXPECT_EQ(paramBool, hwInfoConfig.imagePitchAlignmentWARequired(hwInfo));
EXPECT_EQ(paramBool, hwInfoConfig.isForceEmuInt32DivRemSPWARequired(hwInfo));
EXPECT_EQ(paramBool, productHelper.pipeControlWARequired(hwInfo));
EXPECT_EQ(paramBool, productHelper.imagePitchAlignmentWARequired(hwInfo));
EXPECT_EQ(paramBool, productHelper.isForceEmuInt32DivRemSPWARequired(hwInfo));
}
}
@@ -111,11 +111,11 @@ DG1TEST_F(Dg1HwInfo, whenPlatformIsDg1ThenExpectSvmIsSet) {
}
DG1TEST_F(Dg1HwInfoConfig, whenConfigureHwInfoThenBlitterSupportIsEnabled) {
auto &hwInfoConfig = getHwInfoConfig();
auto &productHelper = getHelper<ProductHelper>();
auto hardwareInfo = *defaultHwInfo;
hardwareInfo.capabilityTable.blitterOperationsSupported = false;
hwInfoConfig.configureHardwareCustom(&hardwareInfo, nullptr);
productHelper.configureHardwareCustom(&hardwareInfo, nullptr);
EXPECT_TRUE(hardwareInfo.capabilityTable.blitterOperationsSupported);
}

8
shared/test/unit_test/gen12lp/rkl/test_hw_info_config_rkl.cpp
View File

@@ -122,7 +122,7 @@ RKLTEST_F(RklHwInfo, givenHwInfoConfigWhenGetCommandsStreamPropertiesSupportThen
using RklHwInfoConfig = Test<DeviceFixture>;
RKLTEST_F(RklHwInfoConfig, givenA0OrBSteppingAndRklPlatformWhenAskingIfWAIsRequiredThenReturnTrue) {
auto &hwInfoConfig = getHwInfoConfig();
auto &productHelper = getHelper<ProductHelper>();
std::array<std::pair<uint32_t, bool>, 3> revisions = {
{{REVISION_A0, true},
{REVISION_B, true},
@@ -130,11 +130,11 @@ RKLTEST_F(RklHwInfoConfig, givenA0OrBSteppingAndRklPlatformWhenAskingIfWAIsRequi
for (const auto &[revision, paramBool] : revisions) {
auto hwInfo = *defaultHwInfo;
hwInfo.platform.usRevId = hwInfoConfig.getHwRevIdFromStepping(revision, hwInfo);
hwInfo.platform.usRevId = productHelper.getHwRevIdFromStepping(revision, hwInfo);
hwInfoConfig.configureHardwareCustom(&hwInfo, nullptr);
productHelper.configureHardwareCustom(&hwInfo, nullptr);
EXPECT_EQ(paramBool, hwInfoConfig.isForceEmuInt32DivRemSPWARequired(hwInfo));
EXPECT_EQ(paramBool, productHelper.isForceEmuInt32DivRemSPWARequired(hwInfo));
}
}

12
shared/test/unit_test/gen12lp/tgllp/hw_info_config_tests_tgllp.cpp
View File

@@ -91,7 +91,7 @@ TGLLPTEST_F(HwInfoConfigTestTgllp, whenUsingCorrectConfigValueThenCorrectHwInfoI
}
TGLLPTEST_F(HwInfoConfigTestTgllp, givenA0SteppingAndTgllpPlatformWhenAskingIfWAIsRequiredThenReturnTrue) {
auto &hwInfoConfig = getHwInfoConfig();
auto &productHelper = getHelper<ProductHelper>();
std::array<std::pair<uint32_t, bool>, 3> revisions = {
{{REVISION_A0, true},
{REVISION_B, false},
@@ -99,12 +99,12 @@ TGLLPTEST_F(HwInfoConfigTestTgllp, givenA0SteppingAndTgllpPlatformWhenAskingIfWA
for (const auto &[revision, paramBool] : revisions) {
auto hwInfo = *defaultHwInfo;
hwInfo.platform.usRevId = hwInfoConfig.getHwRevIdFromStepping(revision, hwInfo);
hwInfoConfig.configureHardwareCustom(&hwInfo, nullptr);
hwInfo.platform.usRevId = productHelper.getHwRevIdFromStepping(revision, hwInfo);
productHelper.configureHardwareCustom(&hwInfo, nullptr);
EXPECT_EQ(paramBool, hwInfoConfig.pipeControlWARequired(hwInfo));
EXPECT_EQ(paramBool, hwInfoConfig.imagePitchAlignmentWARequired(hwInfo));
EXPECT_EQ(paramBool, hwInfoConfig.isForceEmuInt32DivRemSPWARequired(hwInfo));
EXPECT_EQ(paramBool, productHelper.pipeControlWARequired(hwInfo));
EXPECT_EQ(paramBool, productHelper.imagePitchAlignmentWARequired(hwInfo));
EXPECT_EQ(paramBool, productHelper.isForceEmuInt32DivRemSPWARequired(hwInfo));
}
}

6
shared/test/unit_test/os_interface/linux/hw_info_config_linux_tests.h
View File

@@ -55,8 +55,10 @@ struct HwInfoConfigTestLinux : public HwInfoConfigTest {
HwInfoConfigTest::TearDown();
}
const HwInfoConfig &getHwInfoConfig() {
return executionEnvironment->rootDeviceEnvironments[0]->getHwInfoConfig();
template <typename HelperType>
HelperType &getHelper() const {
auto &helper = executionEnvironment->rootDeviceEnvironments[0]->getHelper<HelperType>();
return helper;
}
OSInterface *osInterface;

8
shared/test/unit_test/xe_hp_core/xe_hp_sdv/linux/hw_info_config_tests_xe_hp_sdv.cpp
View File

@@ -23,15 +23,15 @@ struct HwInfoConfigTestLinuxXeHp : HwInfoConfigTestLinux {
};
XEHPTEST_F(HwInfoConfigTestLinuxXeHp, WhenConfiguringHwInfoThenZeroIsReturned) {
auto hwInfoConfig = HwInfoConfig::get(productFamily);
int ret = hwInfoConfig->configureHwInfoDrm(&pInHwInfo, &outHwInfo, osInterface);
auto &productHelper = getHelper<ProductHelper>();
int ret = productHelper.configureHwInfoDrm(&pInHwInfo, &outHwInfo, osInterface);
EXPECT_EQ(0, ret);
}
XEHPTEST_F(HwInfoConfigTestLinuxXeHp, GivenXeHpSdvWhenConfigureHardwareCustomThenKmdNotifyIsEnabled) {
auto &hwInfoConfig = getHwInfoConfig();
auto &productHelper = getHelper<ProductHelper>();
hwInfoConfig.configureHardwareCustom(&pInHwInfo, osInterface);
productHelper.configureHardwareCustom(&pInHwInfo, osInterface);
EXPECT_TRUE(pInHwInfo.capabilityTable.kmdNotifyProperties.enableKmdNotify);
EXPECT_EQ(150ll, pInHwInfo.capabilityTable.kmdNotifyProperties.delayKmdNotifyMicroseconds);
EXPECT_TRUE(pInHwInfo.capabilityTable.kmdNotifyProperties.enableQuickKmdSleepForDirectSubmission);

10
shared/test/unit_test/xe_hpc_core/pvc/linux/hw_info_config_tests_pvc.cpp
View File

@@ -35,27 +35,27 @@ PVCTEST_F(HwInfoConfigTestLinuxPvc, WhenConfiguringHwInfoThenZeroIsReturned) {
}
PVCTEST_F(HwInfoConfigTestLinuxPvc, given57bAddressSpaceWhenConfiguringHwInfoThenSetFtrFlag) {
auto &hwInfoConfig = getHwInfoConfig();
auto &productHelper = getHelper<ProductHelper>();
outHwInfo.featureTable.flags.ftr57bGPUAddressing = false;
outHwInfo.platform.eRenderCoreFamily = defaultHwInfo->platform.eRenderCoreFamily;
outHwInfo.capabilityTable.gpuAddressSpace = maxNBitValue(48);
int ret = hwInfoConfig.configureHardwareCustom(&outHwInfo, osInterface);
int ret = productHelper.configureHardwareCustom(&outHwInfo, osInterface);
EXPECT_EQ(0, ret);
EXPECT_FALSE(outHwInfo.featureTable.flags.ftr57bGPUAddressing);
outHwInfo.capabilityTable.gpuAddressSpace = maxNBitValue(57);
ret = hwInfoConfig.configureHardwareCustom(&outHwInfo, osInterface);
ret = productHelper.configureHardwareCustom(&outHwInfo, osInterface);
EXPECT_EQ(0, ret);
auto value = outHwInfo.featureTable.flags.ftr57bGPUAddressing;
EXPECT_EQ(1u, value);
}
PVCTEST_F(HwInfoConfigTestLinuxPvc, GivenPvcWhenConfigureHardwareCustomThenKmdNotifyIsEnabled) {
auto &hwInfoConfig = getHwInfoConfig();
auto &productHelper = getHelper<ProductHelper>();
OSInterface osIface;
hwInfoConfig.configureHardwareCustom(&pInHwInfo, &osIface);
productHelper.configureHardwareCustom(&pInHwInfo, &osIface);
EXPECT_TRUE(pInHwInfo.capabilityTable.kmdNotifyProperties.enableKmdNotify);
EXPECT_EQ(150ll, pInHwInfo.capabilityTable.kmdNotifyProperties.delayKmdNotifyMicroseconds);
EXPECT_TRUE(pInHwInfo.capabilityTable.kmdNotifyProperties.enableQuickKmdSleepForDirectSubmission);

8
shared/test/unit_test/xe_hpc_core/pvc/test_hw_info_config_pvc.cpp
View File

@@ -186,10 +186,10 @@ PVCTEST_F(PvcHwInfoConfig, givenHwInfoConfigAndProgramExtendedPipeControlPriorTo
}
PVCTEST_F(PvcHwInfoConfig, givenPvcWhenConfiguringThenDisableCccs) {
auto &hwInfoConfig = getHwInfoConfig();
auto &productHelper = getHelper<ProductHelper>();
HardwareInfo hwInfo = *defaultHwInfo;
hwInfoConfig.configureHardwareCustom(&hwInfo, nullptr);
productHelper.configureHardwareCustom(&hwInfo, nullptr);
EXPECT_FALSE(hwInfo.featureTable.flags.ftrRcsNode);
}
@@ -197,10 +197,10 @@ PVCTEST_F(PvcHwInfoConfig, givenDebugVariableSetWhenConfiguringThenEnableCccs) {
DebugManagerStateRestore restore;
DebugManager.flags.NodeOrdinal.set(static_cast<int32_t>(aub_stream::EngineType::ENGINE_CCCS));
auto &hwInfoConfig = getHwInfoConfig();
auto &productHelper = getHelper<ProductHelper>();
HardwareInfo hwInfo = *defaultHwInfo;
hwInfoConfig.configureHardwareCustom(&hwInfo, nullptr);
productHelper.configureHardwareCustom(&hwInfo, nullptr);
EXPECT_TRUE(hwInfo.featureTable.flags.ftrRcsNode);
}

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

@@ -123,7 +123,7 @@ DG2TEST_F(HwInfoConfigTestDg2, whenAdjustingDefaultEngineTypeThenSelectEngineTyp
}
DG2TEST_F(HwInfoConfigTestDg2, givenA0OrA1SteppingWhenAskingIfWAIsRequiredThenReturnTrue) {
auto &hwInfoConfig = getHwInfoConfig();
auto &productHelper = getHelper<ProductHelper>();
std::array<std::pair<uint32_t, bool>, 4> revisions = {
{{REVISION_A0, true},
{REVISION_A1, true},
@@ -132,13 +132,13 @@ DG2TEST_F(HwInfoConfigTestDg2, givenA0OrA1SteppingWhenAskingIfWAIsRequiredThenRe
for (const auto &[revision, paramBool] : revisions) {
auto hwInfo = *defaultHwInfo;
hwInfo.platform.usRevId = hwInfoConfig.getHwRevIdFromStepping(revision, hwInfo);
hwInfo.platform.usRevId = productHelper.getHwRevIdFromStepping(revision, hwInfo);
hwInfoConfig.configureHardwareCustom(&hwInfo, nullptr);
productHelper.configureHardwareCustom(&hwInfo, nullptr);
EXPECT_EQ(paramBool, hwInfoConfig.isDefaultEngineTypeAdjustmentRequired(hwInfo));
EXPECT_EQ(paramBool, hwInfoConfig.isAllocationSizeAdjustmentRequired(hwInfo));
EXPECT_EQ(paramBool, hwInfoConfig.isPrefetchDisablingRequired(hwInfo));
EXPECT_EQ(paramBool, productHelper.isDefaultEngineTypeAdjustmentRequired(hwInfo));
EXPECT_EQ(paramBool, productHelper.isAllocationSizeAdjustmentRequired(hwInfo));
EXPECT_EQ(paramBool, productHelper.isPrefetchDisablingRequired(hwInfo));
}
}
@@ -238,7 +238,7 @@ DG2TEST_F(HwInfoConfigTestDg2, givenDg2WhenIsBlitterForImagesSupportedIsCalledTh
}
DG2TEST_F(HwInfoConfigTestDg2, givenB0rCSteppingWhenAskingIfTile64With3DSurfaceOnBCSIsSupportedThenReturnTrue) {
auto &hwInfoConfig = getHwInfoConfig();
auto &productHelper = getHelper<ProductHelper>();
std::array<std::pair<uint32_t, bool>, 4> revisions = {
{{REVISION_A0, false},
{REVISION_A1, false},
@@ -247,32 +247,32 @@ DG2TEST_F(HwInfoConfigTestDg2, givenB0rCSteppingWhenAskingIfTile64With3DSurfaceO
for (const auto &[revision, paramBool] : revisions) {
auto hwInfo = *defaultHwInfo;
hwInfo.platform.usRevId = hwInfoConfig.getHwRevIdFromStepping(revision, hwInfo);
hwInfo.platform.usRevId = productHelper.getHwRevIdFromStepping(revision, hwInfo);
hwInfoConfig.configureHardwareCustom(&hwInfo, nullptr);
productHelper.configureHardwareCustom(&hwInfo, nullptr);
EXPECT_EQ(paramBool, hwInfoConfig.isTile64With3DSurfaceOnBCSSupported(hwInfo));
EXPECT_EQ(paramBool, productHelper.isTile64With3DSurfaceOnBCSSupported(hwInfo));
}
}
DG2TEST_F(HwInfoConfigTestDg2, givenA0SteppingAnd128EuWhenConfigureCalledThenDisableCompression) {
auto &hwInfoConfig = getHwInfoConfig();
auto &productHelper = getHelper<ProductHelper>();
for (uint8_t revision : {REVISION_A0, REVISION_A1}) {
for (uint32_t euCount : {127, 128, 129}) {
HardwareInfo hwInfo = *defaultHwInfo;
hwInfo.featureTable.flags.ftrE2ECompression = true;
hwInfo.platform.usRevId = hwInfoConfig.getHwRevIdFromStepping(revision, hwInfo);
hwInfo.platform.usRevId = productHelper.getHwRevIdFromStepping(revision, hwInfo);
hwInfo.gtSystemInfo.EUCount = euCount;
hwInfoConfig.configureHardwareCustom(&hwInfo, nullptr);
productHelper.configureHardwareCustom(&hwInfo, nullptr);
auto compressionExpected = (euCount == 128) ? true : (revision != REVISION_A0);
EXPECT_EQ(compressionExpected, hwInfo.capabilityTable.ftrRenderCompressedBuffers);
EXPECT_EQ(compressionExpected, hwInfo.capabilityTable.ftrRenderCompressedImages);
EXPECT_EQ(compressionExpected, hwInfoConfig.allowCompression(hwInfo));
EXPECT_EQ(compressionExpected, productHelper.allowCompression(hwInfo));
}
}
}

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

@@ -29,10 +29,10 @@ DG2TEST_F(HwInfoConfigTestLinuxDg2, WhenConfiguringHwInfoThenZeroIsReturned) {
}
DG2TEST_F(HwInfoConfigTestLinuxDg2, GivenDg2WhenConfigureHardwareCustomThenKmdNotifyIsEnabled) {
auto &hwInfoConfig = getHwInfoConfig();
auto &productHelper = getHelper<ProductHelper>();
OSInterface osIface;
hwInfoConfig.configureHardwareCustom(&pInHwInfo, &osIface);
productHelper.configureHardwareCustom(&pInHwInfo, &osIface);
EXPECT_TRUE(pInHwInfo.capabilityTable.kmdNotifyProperties.enableKmdNotify);
EXPECT_EQ(150ll, pInHwInfo.capabilityTable.kmdNotifyProperties.delayKmdNotifyMicroseconds);
EXPECT_TRUE(pInHwInfo.capabilityTable.kmdNotifyProperties.enableQuickKmdSleepForDirectSubmission);

17
shared/test/unit_test/xe_hpg_core/hw_helper_tests_xe_hpg_core.cpp
View File

@@ -23,19 +23,18 @@ XE_HPG_CORETEST_F(HwHelperTestXeHpgCore, givenDifferentBufferSizesWhenEnableStat
DebugManagerStateRestore restore;
DebugManager.flags.EnableStatelessCompression.set(1);
auto &helper = HwHelper::get(renderCoreFamily);
auto &coreHelper = getHelper<CoreHelper>();
const size_t sizesToCheck[] = {1, 128, 256, 1024, 2048};
for (size_t size : sizesToCheck) {
EXPECT_TRUE(helper.isBufferSizeSuitableForCompression(size, *defaultHwInfo));
EXPECT_TRUE(coreHelper.isBufferSizeSuitableForCompression(size, *defaultHwInfo));
}
}
XE_HPG_CORETEST_F(HwHelperTestXeHpgCore, givenDebugFlagWhenCheckingIfBufferIsSuitableThenReturnCorrectValue) {
DebugManagerStateRestore restore;
auto &helper = HwHelper::get(renderCoreFamily);
auto &coreHelper = getHelper<CoreHelper>();
const size_t sizesToCheck[] = {1, 128, 256, 1024, 2048};
for (int32_t debugFlag : {-1, 0, 1}) {
@@ -43,9 +42,9 @@ XE_HPG_CORETEST_F(HwHelperTestXeHpgCore, givenDebugFlagWhenCheckingIfBufferIsSui
for (size_t size : sizesToCheck) {
if (debugFlag == 1) {
EXPECT_TRUE(helper.isBufferSizeSuitableForCompression(size, *defaultHwInfo));
EXPECT_TRUE(coreHelper.isBufferSizeSuitableForCompression(size, *defaultHwInfo));
} else {
EXPECT_FALSE(helper.isBufferSizeSuitableForCompression(size, *defaultHwInfo));
EXPECT_FALSE(coreHelper.isBufferSizeSuitableForCompression(size, *defaultHwInfo));
}
}
}
@@ -55,16 +54,16 @@ using HwInfoConfigTestXeHpgCore = Test<DeviceFixture>;
XE_HPG_CORETEST_F(HwInfoConfigTestXeHpgCore, givenDebugVariableSetWhenConfigureIsCalledThenSetupBlitterOperationsSupportedFlag) {
DebugManagerStateRestore restore;
auto &hwInfoConfig = getHwInfoConfig();
auto &productHelper = getHelper<ProductHelper>();
HardwareInfo hwInfo = *defaultHwInfo;
DebugManager.flags.EnableBlitterOperationsSupport.set(0);
hwInfoConfig.configureHardwareCustom(&hwInfo, nullptr);
productHelper.configureHardwareCustom(&hwInfo, nullptr);
EXPECT_FALSE(hwInfo.capabilityTable.blitterOperationsSupported);
DebugManager.flags.EnableBlitterOperationsSupport.set(1);
hwInfoConfig.configureHardwareCustom(&hwInfo, nullptr);
productHelper.configureHardwareCustom(&hwInfo, nullptr);
EXPECT_TRUE(hwInfo.capabilityTable.blitterOperationsSupported);
}