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

Move HwInfoConfig & HwHelper ownership to RootDeviceEnvironment

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

Use RootDeviceEnvironment getHelper<ProductHelper> for
- configureHwInfoWddm
- configureHwInfoDrm

Use RootDeviceEnvironment getHelper<CoreHelper> for
- getMaxNumSamplers
- adjustDefaultEngineType
This commit is contained in:
Kamil Kopryk
2022-11-14 14:52:40 +00:00
committed by Compute-Runtime-Automation
parent ab6e989eb3
commit 4aee34702e
45 changed files with 321 additions and 290 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
level_zero/core/test/unit_tests/sources/cmdqueue/test_cmdqueue_3.cpp
View File

@@ -629,10 +629,14 @@ struct EngineInstancedDeviceExecuteTests : public ::testing::Test {
DebugManager.flags.CreateMultipleSubDevices.set(numGenericSubDevices); DebugManager.flags.CreateMultipleSubDevices.set(numGenericSubDevices);
auto executionEnvironment = std::make_unique<NEO::MockExecutionEnvironment>(); auto executionEnvironment = std::make_unique<NEO::MockExecutionEnvironment>();
auto hwInfo = executionEnvironment->rootDeviceEnvironments[0]->getMutableHardwareInfo();
auto &rootDeviceEnvironment = *executionEnvironment->rootDeviceEnvironments[0].get();
auto hwInfo = rootDeviceEnvironment.getMutableHardwareInfo();
hwInfo->gtSystemInfo.CCSInfo.NumberOfCCSEnabled = numCcs; hwInfo->gtSystemInfo.CCSInfo.NumberOfCCSEnabled = numCcs;
hwInfo->featureTable.flags.ftrCCSNode = (numCcs > 0); hwInfo->featureTable.flags.ftrCCSNode = (numCcs > 0);
HwHelper::get(hwInfo->platform.eRenderCoreFamily).adjustDefaultEngineType(hwInfo);
auto &coreHelper = rootDeviceEnvironment.getHelper<CoreHelper>();
coreHelper.adjustDefaultEngineType(hwInfo);
if (!multiCcsDevice(*hwInfo, numCcs)) { if (!multiCcsDevice(*hwInfo, numCcs)) {
return false; return false;

2
opencl/test/unit_test/device/device_caps_tests.cpp
View File

@@ -115,7 +115,7 @@ TEST_F(DeviceGetCapsTest, WhenCreatingDeviceThenCapsArePopulatedCorrectly) {
const auto &caps = device->getDeviceInfo(); const auto &caps = device->getDeviceInfo();
const auto &sharedCaps = device->getSharedDeviceInfo(); const auto &sharedCaps = device->getSharedDeviceInfo();
const auto &sysInfo = defaultHwInfo->gtSystemInfo; const auto &sysInfo = defaultHwInfo->gtSystemInfo;
auto &hwHelper = HwHelper::get(defaultHwInfo->platform.eRenderCoreFamily); auto &hwHelper = device->getRootDeviceEnvironment().getHelper<CoreHelper>();
EXPECT_NE(nullptr, caps.builtInKernels); EXPECT_NE(nullptr, caps.builtInKernels);

4
opencl/test/unit_test/device/device_tests.cpp
View File

@@ -385,8 +385,8 @@ TEST(DeviceCreation, givenMultiRootDeviceWhenTheyAreCreatedThenEachDeviceHasSepe
HWTEST_F(DeviceTest, givenDeviceWhenAskingForDefaultEngineThenReturnValidValue) { HWTEST_F(DeviceTest, givenDeviceWhenAskingForDefaultEngineThenReturnValidValue) {
ExecutionEnvironment *executionEnvironment = platform()->peekExecutionEnvironment(); ExecutionEnvironment *executionEnvironment = platform()->peekExecutionEnvironment();
executionEnvironment->prepareRootDeviceEnvironments(1u); executionEnvironment->prepareRootDeviceEnvironments(1u);
auto &hwHelper = HwHelperHw<FamilyType>::get(); auto &coreHelper = getHelper<CoreHelper>();
hwHelper.adjustDefaultEngineType(executionEnvironment->rootDeviceEnvironments[0]->getMutableHardwareInfo()); coreHelper.adjustDefaultEngineType(executionEnvironment->rootDeviceEnvironments[0]->getMutableHardwareInfo());
auto device = std::unique_ptr<MockDevice>(Device::create<MockDevice>(executionEnvironment, 0)); auto device = std::unique_ptr<MockDevice>(Device::create<MockDevice>(executionEnvironment, 0));
auto osContext = device->getDefaultEngine().osContext; auto osContext = device->getDefaultEngine().osContext;

6
opencl/test/unit_test/device/sub_device_tests.cpp
View File

@@ -327,11 +327,13 @@ struct EngineInstancedDeviceTests : public ::testing::Test {
auto executionEnvironment = std::make_unique<MockExecutionEnvironment>(); auto executionEnvironment = std::make_unique<MockExecutionEnvironment>();
executionEnvironment->rootDeviceEnvironments[0]->initGmm(); executionEnvironment->rootDeviceEnvironments[0]->initGmm();
auto hwInfo = executionEnvironment->rootDeviceEnvironments[0]->getMutableHardwareInfo(); auto &rootDeviceEnvironment = *executionEnvironment->rootDeviceEnvironments[0].get();
auto hwInfo = rootDeviceEnvironment.getMutableHardwareInfo();
hwInfo->gtSystemInfo.CCSInfo.NumberOfCCSEnabled = numCcs; hwInfo->gtSystemInfo.CCSInfo.NumberOfCCSEnabled = numCcs;
hwInfo->featureTable.flags.ftrCCSNode = (numCcs > 0); hwInfo->featureTable.flags.ftrCCSNode = (numCcs > 0);
hwInfo->capabilityTable.blitterOperationsSupported = true; hwInfo->capabilityTable.blitterOperationsSupported = true;
HwHelper::get(hwInfo->platform.eRenderCoreFamily).adjustDefaultEngineType(hwInfo); auto &coreHelper = rootDeviceEnvironment.getHelper<CoreHelper>();
coreHelper.adjustDefaultEngineType(hwInfo);
if (!multiCcsDevice(*hwInfo, numCcs)) { if (!multiCcsDevice(*hwInfo, numCcs)) {
return false; return false;

4
opencl/test/unit_test/gen12lp/hw_helper_tests_gen12lp.inl
View File

@@ -86,8 +86,8 @@ GEN12LPTEST_F(HwHelperTestGen12Lp, WhenGettingPitchAlignmentForImageThenCorrectV
GEN12LPTEST_F(HwHelperTestGen12Lp, WhenAdjustingDefaultEngineTypeThenRcsIsSet) { GEN12LPTEST_F(HwHelperTestGen12Lp, WhenAdjustingDefaultEngineTypeThenRcsIsSet) {
hardwareInfo.featureTable.flags.ftrCCSNode = false; hardwareInfo.featureTable.flags.ftrCCSNode = false;
auto &helper = HwHelper::get(renderCoreFamily); auto &coreHelper = getHelper<CoreHelper>();
helper.adjustDefaultEngineType(&hardwareInfo); coreHelper.adjustDefaultEngineType(&hardwareInfo);
EXPECT_EQ(aub_stream::ENGINE_RCS, hardwareInfo.capabilityTable.defaultEngineType); EXPECT_EQ(aub_stream::ENGINE_RCS, hardwareInfo.capabilityTable.defaultEngineType);
} }

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

@@ -97,8 +97,8 @@ XE_HPC_CORETEST_F(HwHelperTestsXeHpcCore, givenXeHpcWhenAskedForMinimialSimdThen
} }
XE_HPC_CORETEST_F(HwHelperTestsXeHpcCore, whenQueryingMaxNumSamplersThenReturnZero) { XE_HPC_CORETEST_F(HwHelperTestsXeHpcCore, whenQueryingMaxNumSamplersThenReturnZero) {
auto &helper = HwHelper::get(renderCoreFamily); auto &coreHelper = getHelper<CoreHelper>();
EXPECT_EQ(0u, helper.getMaxNumSamplers()); EXPECT_EQ(0u, coreHelper.getMaxNumSamplers());
} }
XE_HPC_CORETEST_F(HwHelperTestsXeHpcCore, GivenBarrierEncodingWhenCallingGetBarriersCountFromHasBarrierThenNumberOfBarriersIsReturned) { XE_HPC_CORETEST_F(HwHelperTestsXeHpcCore, GivenBarrierEncodingWhenCallingGetBarriersCountFromHasBarrierThenNumberOfBarriersIsReturned) {

5
shared/source/os_interface/hw_info_config.h
View File

@@ -28,6 +28,7 @@ struct StateComputeModePropertiesSupport;
class HwInfoConfig; class HwInfoConfig;
class GraphicsAllocation; class GraphicsAllocation;
class MemoryManager; class MemoryManager;
struct RootDeviceEnvironment;
class OSInterface; class OSInterface;
enum class DriverModelType; enum class DriverModelType;
@@ -48,8 +49,8 @@ class HwInfoConfig {
} }
static constexpr uint32_t uuidSize = 16u; static constexpr uint32_t uuidSize = 16u;
static constexpr uint32_t luidSize = 8u; static constexpr uint32_t luidSize = 8u;
int configureHwInfoWddm(const HardwareInfo *inHwInfo, HardwareInfo *outHwInfo, OSInterface *osIface); int configureHwInfoWddm(const HardwareInfo *inHwInfo, HardwareInfo *outHwInfo, const RootDeviceEnvironment &rootDeviceEnvironemnt);
int configureHwInfoDrm(const HardwareInfo *inHwInfo, HardwareInfo *outHwInfo, OSInterface *osIface); int configureHwInfoDrm(const HardwareInfo *inHwInfo, HardwareInfo *outHwInfo, const RootDeviceEnvironment &rootDeviceEnvironemnt);
virtual int configureHardwareCustom(HardwareInfo *hwInfo, OSInterface *osIface) const = 0; virtual int configureHardwareCustom(HardwareInfo *hwInfo, OSInterface *osIface) const = 0;
virtual void adjustPlatformForProductFamily(HardwareInfo *hwInfo) = 0; virtual void adjustPlatformForProductFamily(HardwareInfo *hwInfo) = 0;
virtual void adjustSamplerState(void *sampler, const HardwareInfo &hwInfo) = 0; virtual void adjustSamplerState(void *sampler, const HardwareInfo &hwInfo) = 0;

8
shared/source/os_interface/linux/hw_info_config_drm.cpp
View File

@@ -7,6 +7,7 @@
#include "shared/source/command_stream/preemption.h" #include "shared/source/command_stream/preemption.h"
#include "shared/source/debug_settings/debug_settings_manager.h" #include "shared/source/debug_settings/debug_settings_manager.h"
#include "shared/source/execution_environment/root_device_environment.h"
#include "shared/source/helpers/compiler_hw_info_config.h" #include "shared/source/helpers/compiler_hw_info_config.h"
#include "shared/source/helpers/constants.h" #include "shared/source/helpers/constants.h"
#include "shared/source/helpers/hw_helper.h" #include "shared/source/helpers/hw_helper.h"
@@ -63,9 +64,10 @@ int configureCacheInfo(HardwareInfo *hwInfo) {
return 0; return 0;
} }
int HwInfoConfig::configureHwInfoDrm(const HardwareInfo *inHwInfo, HardwareInfo *outHwInfo, OSInterface *osIface) { int HwInfoConfig::configureHwInfoDrm(const HardwareInfo *inHwInfo, HardwareInfo *outHwInfo, const RootDeviceEnvironment &rootDeviceEnvironemnt) {
int ret = 0; int ret = 0;
Drm *drm = osIface->getDriverModel()->as<Drm>(); auto osInterface = rootDeviceEnvironemnt.osInterface.get();
Drm *drm = osInterface->getDriverModel()->as<Drm>();
*outHwInfo = *inHwInfo; *outHwInfo = *inHwInfo;
auto platform = &outHwInfo->platform; auto platform = &outHwInfo->platform;
@@ -128,7 +130,7 @@ int HwInfoConfig::configureHwInfoDrm(const HardwareInfo *inHwInfo, HardwareInfo
int maxGpuFreq = 0; int maxGpuFreq = 0;
drm->getMaxGpuFrequency(*outHwInfo, maxGpuFreq); drm->getMaxGpuFrequency(*outHwInfo, maxGpuFreq);
ret = configureHardwareCustom(outHwInfo, osIface); ret = configureHardwareCustom(outHwInfo, osInterface);
if (ret != 0) { if (ret != 0) {
*outHwInfo = {}; *outHwInfo = {};
return ret; return ret;

4
shared/source/os_interface/linux/hw_info_config_wddm_stub.cpp
View File

@@ -1,5 +1,5 @@
/* /*
* Copyright (C) 2021 Intel Corporation * Copyright (C) 2021-2022 Intel Corporation
* *
* SPDX-License-Identifier: MIT * SPDX-License-Identifier: MIT
* *
@@ -10,7 +10,7 @@
namespace NEO { namespace NEO {
int HwInfoConfig::configureHwInfoWddm(const HardwareInfo *inHwInfo, HardwareInfo *outHwInfo, OSInterface *osIface) { int HwInfoConfig::configureHwInfoWddm(const HardwareInfo *inHwInfo, HardwareInfo *outHwInfo, const RootDeviceEnvironment &rootDeviceEnvironemnt) {
UNRECOVERABLE_IF(true); UNRECOVERABLE_IF(true);
return {}; return {};
} }

6
shared/source/os_interface/linux/os_interface_linux.cpp
View File

@@ -1,5 +1,5 @@
/* /*
* Copyright (C) 2020-2021 Intel Corporation * Copyright (C) 2020-2022 Intel Corporation
* *
* SPDX-License-Identifier: MIT * SPDX-License-Identifier: MIT
* *
@@ -42,8 +42,8 @@ bool initDrmOsInterface(std::unique_ptr<HwDeviceId> &&hwDeviceId, uint32_t rootD
dstOsInterface.reset(new OSInterface()); dstOsInterface.reset(new OSInterface());
dstOsInterface->setDriverModel(std::unique_ptr<DriverModel>(drm)); dstOsInterface->setDriverModel(std::unique_ptr<DriverModel>(drm));
auto hardwareInfo = rootDeviceEnv->getMutableHardwareInfo(); auto hardwareInfo = rootDeviceEnv->getMutableHardwareInfo();
HwInfoConfig *hwConfig = HwInfoConfig::get(hardwareInfo->platform.eProductFamily); auto &productHelper = rootDeviceEnv->getHelper<ProductHelper>();
if (hwConfig->configureHwInfoDrm(hardwareInfo, hardwareInfo, dstOsInterface.get())) { if (productHelper.configureHwInfoDrm(hardwareInfo, hardwareInfo, *rootDeviceEnv)) {
return false; return false;
} }
rootDeviceEnv->memoryOperationsInterface = DrmMemoryOperationsHandler::create(*drm, rootDeviceIndex); rootDeviceEnv->memoryOperationsInterface = DrmMemoryOperationsHandler::create(*drm, rootDeviceIndex);

5
shared/source/os_interface/windows/hw_info_config_drm_stub.cpp
View File

@@ -1,16 +1,17 @@
/* /*
* Copyright (C) 2021 Intel Corporation * Copyright (C) 2021-2022 Intel Corporation
* *
* SPDX-License-Identifier: MIT * SPDX-License-Identifier: MIT
* *
*/ */
#include "shared/source/execution_environment/root_device_environment.h"
#include "shared/source/helpers/debug_helpers.h" #include "shared/source/helpers/debug_helpers.h"
#include "shared/source/os_interface/hw_info_config.h" #include "shared/source/os_interface/hw_info_config.h"
namespace NEO { namespace NEO {
int HwInfoConfig::configureHwInfoDrm(const HardwareInfo *inHwInfo, HardwareInfo *outHwInfo, OSInterface *osIface) { int HwInfoConfig::configureHwInfoDrm(const HardwareInfo *inHwInfo, HardwareInfo *outHwInfo, const RootDeviceEnvironment &rootDeviceEnvironemnt) {
UNRECOVERABLE_IF(true); UNRECOVERABLE_IF(true);
return {}; return {};
} }

16
shared/source/os_interface/windows/hw_info_config_wddm.cpp
View File

@@ -7,6 +7,7 @@
#include "shared/source/command_stream/preemption.h" #include "shared/source/command_stream/preemption.h"
#include "shared/source/debug_settings/debug_settings_manager.h" #include "shared/source/debug_settings/debug_settings_manager.h"
#include "shared/source/execution_environment/root_device_environment.h"
#include "shared/source/helpers/compiler_hw_info_config.h" #include "shared/source/helpers/compiler_hw_info_config.h"
#include "shared/source/helpers/constants.h" #include "shared/source/helpers/constants.h"
#include "shared/source/helpers/hw_helper.h" #include "shared/source/helpers/hw_helper.h"
@@ -17,16 +18,16 @@
namespace NEO { namespace NEO {
int HwInfoConfig::configureHwInfoWddm(const HardwareInfo *inHwInfo, HardwareInfo *outHwInfo, OSInterface *osIface) { int HwInfoConfig::configureHwInfoWddm(const HardwareInfo *inHwInfo, HardwareInfo *outHwInfo, const RootDeviceEnvironment &rootDeviceEnvironemnt) {
auto &hwHelper = HwHelper::get(outHwInfo->platform.eRenderCoreFamily); auto &coreHelper = rootDeviceEnvironemnt.getHelper<CoreHelper>();
auto &hwInfoConfig = *HwInfoConfig::get(outHwInfo->platform.eProductFamily); auto &productHelper = rootDeviceEnvironemnt.getHelper<ProductHelper>();
auto compilerHwInfoConfig = CompilerHwInfoConfig::get(outHwInfo->platform.eProductFamily); auto compilerHwInfoConfig = CompilerHwInfoConfig::get(outHwInfo->platform.eProductFamily);
outHwInfo->capabilityTable.ftrSvm = outHwInfo->featureTable.flags.ftrSVM; outHwInfo->capabilityTable.ftrSvm = outHwInfo->featureTable.flags.ftrSVM;
hwHelper.adjustDefaultEngineType(outHwInfo); coreHelper.adjustDefaultEngineType(outHwInfo);
outHwInfo->capabilityTable.defaultEngineType = getChosenEngineType(*outHwInfo); outHwInfo->capabilityTable.defaultEngineType = getChosenEngineType(*outHwInfo);
hwInfoConfig.setCapabilityCoherencyFlag(*outHwInfo, outHwInfo->capabilityTable.ftrSupportsCoherency); productHelper.setCapabilityCoherencyFlag(*outHwInfo, outHwInfo->capabilityTable.ftrSupportsCoherency);
outHwInfo->capabilityTable.ftrSupportsCoherency &= inHwInfo->featureTable.flags.ftrL3IACoherency; outHwInfo->capabilityTable.ftrSupportsCoherency &= inHwInfo->featureTable.flags.ftrL3IACoherency;
PreemptionHelper::adjustDefaultPreemptionMode(outHwInfo->capabilityTable, PreemptionHelper::adjustDefaultPreemptionMode(outHwInfo->capabilityTable,
@@ -38,7 +39,7 @@ int HwInfoConfig::configureHwInfoWddm(const HardwareInfo *inHwInfo, HardwareInfo
outHwInfo->gtSystemInfo.CsrSizeInMb = static_cast<uint32_t>(DebugManager.flags.OverridePreemptionSurfaceSizeInMb.get()); outHwInfo->gtSystemInfo.CsrSizeInMb = static_cast<uint32_t>(DebugManager.flags.OverridePreemptionSurfaceSizeInMb.get());
} }
outHwInfo->capabilityTable.requiredPreemptionSurfaceSize = outHwInfo->gtSystemInfo.CsrSizeInMb * MemoryConstants::megaByte; outHwInfo->capabilityTable.requiredPreemptionSurfaceSize = outHwInfo->gtSystemInfo.CsrSizeInMb * MemoryConstants::megaByte;
hwHelper.adjustPreemptionSurfaceSize(outHwInfo->capabilityTable.requiredPreemptionSurfaceSize); coreHelper.adjustPreemptionSurfaceSize(outHwInfo->capabilityTable.requiredPreemptionSurfaceSize);
auto &kmdNotifyProperties = outHwInfo->capabilityTable.kmdNotifyProperties; auto &kmdNotifyProperties = outHwInfo->capabilityTable.kmdNotifyProperties;
KmdNotifyHelper::overrideFromDebugVariable(DebugManager.flags.OverrideEnableKmdNotify.get(), kmdNotifyProperties.enableKmdNotify); KmdNotifyHelper::overrideFromDebugVariable(DebugManager.flags.OverrideEnableKmdNotify.get(), kmdNotifyProperties.enableKmdNotify);
@@ -50,8 +51,9 @@ int HwInfoConfig::configureHwInfoWddm(const HardwareInfo *inHwInfo, HardwareInfo
KmdNotifyHelper::overrideFromDebugVariable(DebugManager.flags.OverrideEnableQuickKmdSleepForDirectSubmission.get(), kmdNotifyProperties.enableQuickKmdSleepForDirectSubmission); KmdNotifyHelper::overrideFromDebugVariable(DebugManager.flags.OverrideEnableQuickKmdSleepForDirectSubmission.get(), kmdNotifyProperties.enableQuickKmdSleepForDirectSubmission);
KmdNotifyHelper::overrideFromDebugVariable(DebugManager.flags.OverrideDelayQuickKmdSleepForDirectSubmissionMicroseconds.get(), kmdNotifyProperties.delayQuickKmdSleepForDirectSubmissionMicroseconds); KmdNotifyHelper::overrideFromDebugVariable(DebugManager.flags.OverrideDelayQuickKmdSleepForDirectSubmissionMicroseconds.get(), kmdNotifyProperties.delayQuickKmdSleepForDirectSubmissionMicroseconds);
auto osInterface = rootDeviceEnvironemnt.osInterface.get();
// Product specific config // Product specific config
int ret = configureHardwareCustom(outHwInfo, osIface); int ret = configureHardwareCustom(outHwInfo, osInterface);
if (ret != 0) { if (ret != 0) {
*outHwInfo = {}; *outHwInfo = {};
} }

3
shared/source/os_interface/windows/wddm/wddm.cpp
View File

@@ -94,7 +94,6 @@ bool Wddm::init() {
hardwareInfo->featureTable = *featureTable; hardwareInfo->featureTable = *featureTable;
hardwareInfo->workaroundTable = *workaroundTable; hardwareInfo->workaroundTable = *workaroundTable;
hardwareInfo->gtSystemInfo = *gtSystemInfo; hardwareInfo->gtSystemInfo = *gtSystemInfo;
hardwareInfo->capabilityTable = hardwareInfoTable[productFamily]->capabilityTable; hardwareInfo->capabilityTable = hardwareInfoTable[productFamily]->capabilityTable;
hardwareInfo->capabilityTable.maxRenderFrequency = maxRenderFrequency; hardwareInfo->capabilityTable.maxRenderFrequency = maxRenderFrequency;
hardwareInfo->capabilityTable.instrumentationEnabled = hardwareInfo->capabilityTable.instrumentationEnabled =
@@ -102,7 +101,7 @@ bool Wddm::init() {
auto &productHelper = rootDeviceEnvironment.getHelper<ProductHelper>(); auto &productHelper = rootDeviceEnvironment.getHelper<ProductHelper>();
productHelper.adjustPlatformForProductFamily(hardwareInfo); productHelper.adjustPlatformForProductFamily(hardwareInfo);
if (productHelper.configureHwInfoWddm(hardwareInfo, hardwareInfo, nullptr)) { if (productHelper.configureHwInfoWddm(hardwareInfo, hardwareInfo, rootDeviceEnvironment)) {
return false; return false;
} }
setPlatformSupportEvictIfNecessaryFlag(productHelper); setPlatformSupportEvictIfNecessaryFlag(productHelper);

11
shared/test/unit_test/gen11/ehl/linux/hw_info_config_tests_ehl.cpp
View File

@@ -19,8 +19,8 @@ struct HwInfoConfigTestLinuxEhl : HwInfoConfigTestLinux {
}; };
EHLTEST_F(HwInfoConfigTestLinuxEhl, GivenEhlThenHwInfoIsCorrect) { EHLTEST_F(HwInfoConfigTestLinuxEhl, GivenEhlThenHwInfoIsCorrect) {
auto hwInfoConfig = HwInfoConfigHw<IGFX_ELKHARTLAKE>::get(); auto &productHelper = getHelper<ProductHelper>();
int ret = hwInfoConfig->configureHwInfoDrm(&pInHwInfo, &outHwInfo, osInterface); int ret = productHelper.configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(0, ret); EXPECT_EQ(0, ret);
EXPECT_EQ((uint32_t)drm->storedEUVal, outHwInfo.gtSystemInfo.EUCount); EXPECT_EQ((uint32_t)drm->storedEUVal, outHwInfo.gtSystemInfo.EUCount);
EXPECT_EQ((uint32_t)drm->storedSSVal, outHwInfo.gtSystemInfo.SubSliceCount); EXPECT_EQ((uint32_t)drm->storedSSVal, outHwInfo.gtSystemInfo.SubSliceCount);
@@ -28,16 +28,17 @@ EHLTEST_F(HwInfoConfigTestLinuxEhl, GivenEhlThenHwInfoIsCorrect) {
} }
EHLTEST_F(HwInfoConfigTestLinuxEhl, GivenInvalidDeviceIdWhenConfiguringHwInfoThenNegativeOneReturned) { EHLTEST_F(HwInfoConfigTestLinuxEhl, GivenInvalidDeviceIdWhenConfiguringHwInfoThenNegativeOneReturned) {
auto hwInfoConfig = HwInfoConfigHw<IGFX_ELKHARTLAKE>::get();
auto &productHelper = getHelper<ProductHelper>();
drm->failRetTopology = true; drm->failRetTopology = true;
drm->storedRetValForEUVal = -1; drm->storedRetValForEUVal = -1;
auto ret = hwInfoConfig->configureHwInfoDrm(&pInHwInfo, &outHwInfo, osInterface); auto ret = productHelper.configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(-1, ret); EXPECT_EQ(-1, ret);
drm->storedRetValForEUVal = 0; drm->storedRetValForEUVal = 0;
drm->storedRetValForSSVal = -1; drm->storedRetValForSSVal = -1;
ret = hwInfoConfig->configureHwInfoDrm(&pInHwInfo, &outHwInfo, osInterface); ret = productHelper.configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(-1, ret); EXPECT_EQ(-1, ret);
} }

4
shared/test/unit_test/gen11/hw_helper_tests_gen11.cpp
View File

@@ -25,8 +25,8 @@ GEN11TEST_F(HwHelperTestGen11, WhenGettingPitchAlignmentForImageThenCorrectValue
GEN11TEST_F(HwHelperTestGen11, WhenAdjustingDefaultEngineTypeThenEngineTypeIsSet) { GEN11TEST_F(HwHelperTestGen11, WhenAdjustingDefaultEngineTypeThenEngineTypeIsSet) {
auto engineType = hardwareInfo.capabilityTable.defaultEngineType; auto engineType = hardwareInfo.capabilityTable.defaultEngineType;
auto &helper = HwHelper::get(renderCoreFamily); auto &coreHelper = getHelper<CoreHelper>();
helper.adjustDefaultEngineType(&hardwareInfo); coreHelper.adjustDefaultEngineType(&hardwareInfo);
EXPECT_EQ(engineType, hardwareInfo.capabilityTable.defaultEngineType); EXPECT_EQ(engineType, hardwareInfo.capabilityTable.defaultEngineType);
} }

11
shared/test/unit_test/gen11/icllp/linux/hw_info_config_tests_icllp.cpp
View File

@@ -18,8 +18,8 @@ struct HwInfoConfigTestLinuxIcllp : HwInfoConfigTestLinux {
}; };
ICLLPTEST_F(HwInfoConfigTestLinuxIcllp, GivenIcllpThenHwInfoIsCorrect) { ICLLPTEST_F(HwInfoConfigTestLinuxIcllp, GivenIcllpThenHwInfoIsCorrect) {
auto hwInfoConfig = HwInfoConfig::get(productFamily); auto &productHelper = getHelper<ProductHelper>();
int ret = hwInfoConfig->configureHwInfoDrm(&pInHwInfo, &outHwInfo, osInterface); auto ret = productHelper.configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(0, ret); EXPECT_EQ(0, ret);
EXPECT_EQ((uint32_t)drm->storedEUVal, outHwInfo.gtSystemInfo.EUCount); EXPECT_EQ((uint32_t)drm->storedEUVal, outHwInfo.gtSystemInfo.EUCount);
EXPECT_EQ((uint32_t)drm->storedSSVal, outHwInfo.gtSystemInfo.SubSliceCount); EXPECT_EQ((uint32_t)drm->storedSSVal, outHwInfo.gtSystemInfo.SubSliceCount);
@@ -30,16 +30,17 @@ ICLLPTEST_F(HwInfoConfigTestLinuxIcllp, GivenIcllpThenHwInfoIsCorrect) {
} }
ICLLPTEST_F(HwInfoConfigTestLinuxIcllp, GivenInvalidDeviceIdWhenConfiguringHwInfoThenNegativeOneReturned) { ICLLPTEST_F(HwInfoConfigTestLinuxIcllp, GivenInvalidDeviceIdWhenConfiguringHwInfoThenNegativeOneReturned) {
auto hwInfoConfig = HwInfoConfig::get(productFamily);
auto &productHelper = getHelper<ProductHelper>();
drm->failRetTopology = true; drm->failRetTopology = true;
drm->storedRetValForEUVal = -1; drm->storedRetValForEUVal = -1;
auto ret = hwInfoConfig->configureHwInfoDrm(&pInHwInfo, &outHwInfo, osInterface); auto ret = productHelper.configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(-1, ret); EXPECT_EQ(-1, ret);
drm->storedRetValForEUVal = 0; drm->storedRetValForEUVal = 0;
drm->storedRetValForSSVal = -1; drm->storedRetValForSSVal = -1;
ret = hwInfoConfig->configureHwInfoDrm(&pInHwInfo, &outHwInfo, osInterface); ret = productHelper.configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(-1, ret); EXPECT_EQ(-1, ret);
} }

13
shared/test/unit_test/gen11/lkf/linux/hw_info_config_tests_lkf.cpp
View File

@@ -19,8 +19,8 @@ struct HwInfoConfigTestLinuxLkf : HwInfoConfigTestLinux {
}; };
LKFTEST_F(HwInfoConfigTestLinuxLkf, configureHwInfoLkf) { LKFTEST_F(HwInfoConfigTestLinuxLkf, configureHwInfoLkf) {
auto hwInfoConfig = HwInfoConfigHw<IGFX_LAKEFIELD>::get(); auto &productHelper = getHelper<ProductHelper>();
int ret = hwInfoConfig->configureHwInfoDrm(&pInHwInfo, &outHwInfo, osInterface); auto ret = productHelper.configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(0, ret); EXPECT_EQ(0, ret);
EXPECT_EQ((uint32_t)drm->storedEUVal, outHwInfo.gtSystemInfo.EUCount); EXPECT_EQ((uint32_t)drm->storedEUVal, outHwInfo.gtSystemInfo.EUCount);
EXPECT_EQ((uint32_t)drm->storedSSVal, outHwInfo.gtSystemInfo.SubSliceCount); EXPECT_EQ((uint32_t)drm->storedSSVal, outHwInfo.gtSystemInfo.SubSliceCount);
@@ -30,22 +30,23 @@ LKFTEST_F(HwInfoConfigTestLinuxLkf, configureHwInfoLkf) {
} }
LKFTEST_F(HwInfoConfigTestLinuxLkf, negative) { LKFTEST_F(HwInfoConfigTestLinuxLkf, negative) {
auto hwInfoConfig = HwInfoConfigHw<IGFX_LAKEFIELD>::get(); auto &productHelper = getHelper<ProductHelper>();
auto ret = productHelper.configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
drm->failRetTopology = true; drm->failRetTopology = true;
drm->storedRetValForEUVal = -1; drm->storedRetValForEUVal = -1;
auto ret = hwInfoConfig->configureHwInfoDrm(&pInHwInfo, &outHwInfo, osInterface); ret = productHelper.configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(-1, ret); EXPECT_EQ(-1, ret);
drm->storedRetValForEUVal = 0; drm->storedRetValForEUVal = 0;
drm->storedRetValForSSVal = -1; drm->storedRetValForSSVal = -1;
ret = hwInfoConfig->configureHwInfoDrm(&pInHwInfo, &outHwInfo, osInterface); ret = productHelper.configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(-1, ret); EXPECT_EQ(-1, ret);
} }
template <typename T> template <typename T>
class LkfHwInfoTests : public ::testing::Test {}; class LkfHwInfoTests : public ::testing::Test {};
typedef ::testing::Types<LkfHw1x8x8> lkfTestTypes; using lkfTestTypes = ::testing::Types<LkfHw1x8x8>;
TYPED_TEST_CASE(LkfHwInfoTests, lkfTestTypes); TYPED_TEST_CASE(LkfHwInfoTests, lkfTestTypes);
TYPED_TEST(LkfHwInfoTests, gtSetupIsCorrect) { TYPED_TEST(LkfHwInfoTests, gtSetupIsCorrect) {
HardwareInfo hwInfo = *defaultHwInfo; HardwareInfo hwInfo = *defaultHwInfo;

11
shared/test/unit_test/gen12lp/adln/linux/hw_info_config_tests_adln.cpp
View File

@@ -22,8 +22,8 @@ struct HwInfoConfigTestLinuxAdln : HwInfoConfigTestLinux {
}; };
ADLNTEST_F(HwInfoConfigTestLinuxAdln, WhenConfiguringHwInfoThenConfigIsCorrect) { ADLNTEST_F(HwInfoConfigTestLinuxAdln, WhenConfiguringHwInfoThenConfigIsCorrect) {
auto hwInfoConfig = HwInfoConfig::get(productFamily); auto &productHelper = getHelper<ProductHelper>();
int ret = hwInfoConfig->configureHwInfoDrm(&pInHwInfo, &outHwInfo, osInterface); auto ret = productHelper.configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(0, ret); EXPECT_EQ(0, ret);
EXPECT_EQ(static_cast<uint32_t>(drm->storedEUVal), outHwInfo.gtSystemInfo.EUCount); EXPECT_EQ(static_cast<uint32_t>(drm->storedEUVal), outHwInfo.gtSystemInfo.EUCount);
EXPECT_EQ(static_cast<uint32_t>(drm->storedSSVal), outHwInfo.gtSystemInfo.SubSliceCount); EXPECT_EQ(static_cast<uint32_t>(drm->storedSSVal), outHwInfo.gtSystemInfo.SubSliceCount);
@@ -33,16 +33,17 @@ ADLNTEST_F(HwInfoConfigTestLinuxAdln, WhenConfiguringHwInfoThenConfigIsCorrect)
} }
ADLNTEST_F(HwInfoConfigTestLinuxAdln, GivenIncorrectDataWhenConfiguringHwInfoThenErrorIsReturned) { ADLNTEST_F(HwInfoConfigTestLinuxAdln, GivenIncorrectDataWhenConfiguringHwInfoThenErrorIsReturned) {
auto hwInfoConfig = HwInfoConfig::get(productFamily); auto &productHelper = getHelper<ProductHelper>();
drm->failRetTopology = true; drm->failRetTopology = true;
drm->storedRetValForEUVal = -1; drm->storedRetValForEUVal = -1;
auto ret = hwInfoConfig->configureHwInfoDrm(&pInHwInfo, &outHwInfo, osInterface); auto ret = productHelper.configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(-1, ret); EXPECT_EQ(-1, ret);
drm->storedRetValForEUVal = 0; drm->storedRetValForEUVal = 0;
drm->storedRetValForSSVal = -1; drm->storedRetValForSSVal = -1;
ret = hwInfoConfig->configureHwInfoDrm(&pInHwInfo, &outHwInfo, osInterface); ret = productHelper.configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(-1, ret); EXPECT_EQ(-1, ret);
} }

12
shared/test/unit_test/gen12lp/adlp/linux/hw_info_config_tests_adlp.cpp
View File

@@ -23,8 +23,9 @@ struct HwInfoConfigTestLinuxAdlp : HwInfoConfigTestLinux {
}; };
ADLPTEST_F(HwInfoConfigTestLinuxAdlp, WhenConfiguringHwInfoThenInfoIsSetCorrectly) { ADLPTEST_F(HwInfoConfigTestLinuxAdlp, WhenConfiguringHwInfoThenInfoIsSetCorrectly) {
auto hwInfoConfig = HwInfoConfig::get(productFamily); auto &productHelper = getHelper<ProductHelper>();
int ret = hwInfoConfig->configureHwInfoDrm(&pInHwInfo, &outHwInfo, osInterface); auto ret = productHelper.configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(0, ret); EXPECT_EQ(0, ret);
EXPECT_EQ(static_cast<uint32_t>(drm->storedEUVal), outHwInfo.gtSystemInfo.EUCount); EXPECT_EQ(static_cast<uint32_t>(drm->storedEUVal), outHwInfo.gtSystemInfo.EUCount);
EXPECT_EQ(static_cast<uint32_t>(drm->storedSSVal), outHwInfo.gtSystemInfo.SubSliceCount); EXPECT_EQ(static_cast<uint32_t>(drm->storedSSVal), outHwInfo.gtSystemInfo.SubSliceCount);
@@ -34,16 +35,17 @@ ADLPTEST_F(HwInfoConfigTestLinuxAdlp, WhenConfiguringHwInfoThenInfoIsSetCorrectl
} }
ADLPTEST_F(HwInfoConfigTestLinuxAdlp, GivenInvalidDeviceIdWhenConfiguringHwInfoThenErrorIsReturned) { ADLPTEST_F(HwInfoConfigTestLinuxAdlp, GivenInvalidDeviceIdWhenConfiguringHwInfoThenErrorIsReturned) {
auto hwInfoConfig = HwInfoConfig::get(productFamily); auto &productHelper = getHelper<ProductHelper>();
drm->failRetTopology = true; drm->failRetTopology = true;
drm->storedRetValForEUVal = -1; drm->storedRetValForEUVal = -1;
auto ret = hwInfoConfig->configureHwInfoDrm(&pInHwInfo, &outHwInfo, osInterface); auto ret = productHelper.configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(-1, ret); EXPECT_EQ(-1, ret);
drm->storedRetValForEUVal = 0; drm->storedRetValForEUVal = 0;
drm->storedRetValForSSVal = -1; drm->storedRetValForSSVal = -1;
ret = hwInfoConfig->configureHwInfoDrm(&pInHwInfo, &outHwInfo, osInterface); ret = productHelper.configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(-1, ret); EXPECT_EQ(-1, ret);
} }

11
shared/test/unit_test/gen12lp/adls/linux/hw_info_config_tests_adls.cpp
View File

@@ -22,8 +22,9 @@ struct HwInfoConfigTestLinuxAdls : HwInfoConfigTestLinux {
}; };
ADLSTEST_F(HwInfoConfigTestLinuxAdls, WhenConfiguringHwInfoThenConfigIsCorrect) { ADLSTEST_F(HwInfoConfigTestLinuxAdls, WhenConfiguringHwInfoThenConfigIsCorrect) {
auto hwInfoConfig = HwInfoConfig::get(productFamily); auto &productHelper = getHelper<ProductHelper>();
int ret = hwInfoConfig->configureHwInfoDrm(&pInHwInfo, &outHwInfo, osInterface); auto ret = productHelper.configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(0, ret); EXPECT_EQ(0, ret);
EXPECT_EQ(static_cast<uint32_t>(drm->storedEUVal), outHwInfo.gtSystemInfo.EUCount); EXPECT_EQ(static_cast<uint32_t>(drm->storedEUVal), outHwInfo.gtSystemInfo.EUCount);
EXPECT_EQ(static_cast<uint32_t>(drm->storedSSVal), outHwInfo.gtSystemInfo.SubSliceCount); EXPECT_EQ(static_cast<uint32_t>(drm->storedSSVal), outHwInfo.gtSystemInfo.SubSliceCount);
@@ -33,16 +34,16 @@ ADLSTEST_F(HwInfoConfigTestLinuxAdls, WhenConfiguringHwInfoThenConfigIsCorrect)
} }
ADLSTEST_F(HwInfoConfigTestLinuxAdls, GivenIncorrectDataWhenConfiguringHwInfoThenErrorIsReturned) { ADLSTEST_F(HwInfoConfigTestLinuxAdls, GivenIncorrectDataWhenConfiguringHwInfoThenErrorIsReturned) {
auto hwInfoConfig = HwInfoConfig::get(productFamily); auto &productHelper = getHelper<ProductHelper>();
drm->failRetTopology = true; drm->failRetTopology = true;
drm->storedRetValForEUVal = -1; drm->storedRetValForEUVal = -1;
auto ret = hwInfoConfig->configureHwInfoDrm(&pInHwInfo, &outHwInfo, osInterface); auto ret = productHelper.configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(-1, ret); EXPECT_EQ(-1, ret);
drm->storedRetValForEUVal = 0; drm->storedRetValForEUVal = 0;
drm->storedRetValForSSVal = -1; drm->storedRetValForSSVal = -1;
ret = hwInfoConfig->configureHwInfoDrm(&pInHwInfo, &outHwInfo, osInterface); ret = productHelper.configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(-1, ret); EXPECT_EQ(-1, ret);
} }

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

@@ -14,22 +14,22 @@
using HwHelperTestDg1 = HwHelperTest; using HwHelperTestDg1 = HwHelperTest;
DG1TEST_F(HwHelperTestDg1, givenDg1SteppingA0WhenAdjustDefaultEngineTypeCalledThenRcsIsReturned) { DG1TEST_F(HwHelperTestDg1, givenDg1SteppingA0WhenAdjustDefaultEngineTypeCalledThenRcsIsReturned) {
auto &helper = HwHelper::get(renderCoreFamily); auto &coreHelper = getHelper<CoreHelper>();
const auto &hwInfoConfig = *HwInfoConfig::get(productFamily); const auto &productHelper = getHelper<ProductHelper>();
hardwareInfo.featureTable.flags.ftrCCSNode = true; hardwareInfo.featureTable.flags.ftrCCSNode = true;
hardwareInfo.platform.usRevId = hwInfoConfig.getHwRevIdFromStepping(REVISION_A0, hardwareInfo); hardwareInfo.platform.usRevId = productHelper.getHwRevIdFromStepping(REVISION_A0, hardwareInfo);
helper.adjustDefaultEngineType(&hardwareInfo); coreHelper.adjustDefaultEngineType(&hardwareInfo);
EXPECT_EQ(aub_stream::ENGINE_RCS, hardwareInfo.capabilityTable.defaultEngineType); EXPECT_EQ(aub_stream::ENGINE_RCS, hardwareInfo.capabilityTable.defaultEngineType);
} }
DG1TEST_F(HwHelperTestDg1, givenDg1SteppingBWhenAdjustDefaultEngineTypeCalledThenRcsIsReturned) { DG1TEST_F(HwHelperTestDg1, givenDg1SteppingBWhenAdjustDefaultEngineTypeCalledThenRcsIsReturned) {
auto &helper = HwHelper::get(renderCoreFamily); auto &coreHelper = getHelper<CoreHelper>();
const auto &hwInfoConfig = *HwInfoConfig::get(productFamily); const auto &productHelper = getHelper<ProductHelper>();
hardwareInfo.featureTable.flags.ftrCCSNode = true; hardwareInfo.featureTable.flags.ftrCCSNode = true;
hardwareInfo.platform.usRevId = hwInfoConfig.getHwRevIdFromStepping(REVISION_B, hardwareInfo); hardwareInfo.platform.usRevId = productHelper.getHwRevIdFromStepping(REVISION_B, hardwareInfo);
helper.adjustDefaultEngineType(&hardwareInfo); coreHelper.adjustDefaultEngineType(&hardwareInfo);
EXPECT_EQ(aub_stream::ENGINE_RCS, hardwareInfo.capabilityTable.defaultEngineType); EXPECT_EQ(aub_stream::ENGINE_RCS, hardwareInfo.capabilityTable.defaultEngineType);
} }

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

@@ -51,8 +51,8 @@ struct HwInfoConfigTestsLinuxDg1 : HwInfoConfigTestLinux {
}; };
DG1TEST_F(HwInfoConfigTestsLinuxDg1, WhenConfiguringHwInfoThenInfoIsSetCorrectly) { DG1TEST_F(HwInfoConfigTestsLinuxDg1, WhenConfiguringHwInfoThenInfoIsSetCorrectly) {
auto hwInfoConfig = HwInfoConfig::get(productFamily); auto &productHelper = getHelper<ProductHelper>();
int ret = hwInfoConfig->configureHwInfoDrm(&pInHwInfo, &outHwInfo, osInterface); auto ret = productHelper.configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(0, ret); EXPECT_EQ(0, ret);
EXPECT_EQ(static_cast<uint32_t>(drm->storedEUVal), outHwInfo.gtSystemInfo.EUCount); EXPECT_EQ(static_cast<uint32_t>(drm->storedEUVal), outHwInfo.gtSystemInfo.EUCount);
EXPECT_EQ(static_cast<uint32_t>(drm->storedSSVal), outHwInfo.gtSystemInfo.SubSliceCount); EXPECT_EQ(static_cast<uint32_t>(drm->storedSSVal), outHwInfo.gtSystemInfo.SubSliceCount);
@@ -62,16 +62,16 @@ DG1TEST_F(HwInfoConfigTestsLinuxDg1, WhenConfiguringHwInfoThenInfoIsSetCorrectly
} }
DG1TEST_F(HwInfoConfigTestsLinuxDg1, GivenInvalidDeviceIdWhenConfiguringHwInfoThenErrorIsReturned) { DG1TEST_F(HwInfoConfigTestsLinuxDg1, GivenInvalidDeviceIdWhenConfiguringHwInfoThenErrorIsReturned) {
auto hwInfoConfig = HwInfoConfig::get(productFamily);
drm->failRetTopology = true; drm->failRetTopology = true;
drm->storedRetValForEUVal = -1; drm->storedRetValForEUVal = -1;
auto ret = hwInfoConfig->configureHwInfoDrm(&pInHwInfo, &outHwInfo, osInterface); auto &productHelper = getHelper<ProductHelper>();
auto ret = productHelper.configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(-1, ret); EXPECT_EQ(-1, ret);
drm->storedRetValForEUVal = 0; drm->storedRetValForEUVal = 0;
drm->storedRetValForSSVal = -1; drm->storedRetValForSSVal = -1;
ret = hwInfoConfig->configureHwInfoDrm(&pInHwInfo, &outHwInfo, osInterface); ret = productHelper.configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(-1, ret); EXPECT_EQ(-1, ret);
} }

10
shared/test/unit_test/gen12lp/rkl/linux/hw_info_config_tests_rkl.cpp
View File

@@ -22,8 +22,8 @@ struct HwInfoConfigTestLinuxRkl : HwInfoConfigTestLinux {
}; };
RKLTEST_F(HwInfoConfigTestLinuxRkl, WhenConfiguringHwInfoThenConfigIsCorrect) { RKLTEST_F(HwInfoConfigTestLinuxRkl, WhenConfiguringHwInfoThenConfigIsCorrect) {
auto hwInfoConfig = HwInfoConfig::get(productFamily); auto &productHelper = getHelper<ProductHelper>();
int ret = hwInfoConfig->configureHwInfoDrm(&pInHwInfo, &outHwInfo, osInterface); auto ret = productHelper.configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(0, ret); EXPECT_EQ(0, ret);
EXPECT_EQ((uint32_t)drm->storedEUVal, outHwInfo.gtSystemInfo.EUCount); EXPECT_EQ((uint32_t)drm->storedEUVal, outHwInfo.gtSystemInfo.EUCount);
EXPECT_EQ((uint32_t)drm->storedSSVal, outHwInfo.gtSystemInfo.SubSliceCount); EXPECT_EQ((uint32_t)drm->storedSSVal, outHwInfo.gtSystemInfo.SubSliceCount);
@@ -33,16 +33,16 @@ RKLTEST_F(HwInfoConfigTestLinuxRkl, WhenConfiguringHwInfoThenConfigIsCorrect) {
} }
RKLTEST_F(HwInfoConfigTestLinuxRkl, GivenIncorrectDataWhenConfiguringHwInfoThenErrorIsReturned) { RKLTEST_F(HwInfoConfigTestLinuxRkl, GivenIncorrectDataWhenConfiguringHwInfoThenErrorIsReturned) {
auto hwInfoConfig = HwInfoConfig::get(productFamily);
drm->failRetTopology = true; drm->failRetTopology = true;
drm->storedRetValForEUVal = -1; drm->storedRetValForEUVal = -1;
auto ret = hwInfoConfig->configureHwInfoDrm(&pInHwInfo, &outHwInfo, osInterface); auto &productHelper = getHelper<ProductHelper>();
auto ret = productHelper.configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(-1, ret); EXPECT_EQ(-1, ret);
drm->storedRetValForEUVal = 0; drm->storedRetValForEUVal = 0;
drm->storedRetValForSSVal = -1; drm->storedRetValForSSVal = -1;
ret = hwInfoConfig->configureHwInfoDrm(&pInHwInfo, &outHwInfo, osInterface); ret = productHelper.configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(-1, ret); EXPECT_EQ(-1, ret);
} }

22
shared/test/unit_test/gen12lp/rkl/test_hw_helper_rkl.cpp
View File

@@ -14,22 +14,24 @@
using HwHelperTestRkl = HwHelperTest; using HwHelperTestRkl = HwHelperTest;
RKLTEST_F(HwHelperTestRkl, givenRklSteppingA0WhenAdjustDefaultEngineTypeCalledThenRcsIsReturned) { RKLTEST_F(HwHelperTestRkl, givenRklSteppingA0WhenAdjustDefaultEngineTypeCalledThenRcsIsReturned) {
const auto &hwInfoConfig = *HwInfoConfig::get(hardwareInfo.platform.eProductFamily); auto &coreHelper = getHelper<CoreHelper>();
hardwareInfo.featureTable.flags.ftrCCSNode = true; const auto &productHelper = getHelper<ProductHelper>();
hardwareInfo.platform.usRevId = hwInfoConfig.getHwRevIdFromStepping(REVISION_A0, hardwareInfo);
auto &helper = HwHelper::get(renderCoreFamily); hardwareInfo.featureTable.flags.ftrCCSNode = true;
helper.adjustDefaultEngineType(&hardwareInfo); hardwareInfo.platform.usRevId = productHelper.getHwRevIdFromStepping(REVISION_A0, hardwareInfo);
coreHelper.adjustDefaultEngineType(&hardwareInfo);
EXPECT_EQ(aub_stream::ENGINE_RCS, hardwareInfo.capabilityTable.defaultEngineType); EXPECT_EQ(aub_stream::ENGINE_RCS, hardwareInfo.capabilityTable.defaultEngineType);
} }
RKLTEST_F(HwHelperTestRkl, givenRklSteppingBWhenAdjustDefaultEngineTypeCalledThenRcsIsReturned) { RKLTEST_F(HwHelperTestRkl, givenRklSteppingBWhenAdjustDefaultEngineTypeCalledThenRcsIsReturned) {
const auto &hwInfoConfig = *HwInfoConfig::get(hardwareInfo.platform.eProductFamily); auto &coreHelper = getHelper<CoreHelper>();
hardwareInfo.featureTable.flags.ftrCCSNode = true; const auto &productHelper = getHelper<ProductHelper>();
hardwareInfo.platform.usRevId = hwInfoConfig.getHwRevIdFromStepping(REVISION_B, hardwareInfo);
auto &helper = HwHelper::get(renderCoreFamily); hardwareInfo.featureTable.flags.ftrCCSNode = true;
helper.adjustDefaultEngineType(&hardwareInfo); hardwareInfo.platform.usRevId = productHelper.getHwRevIdFromStepping(REVISION_B, hardwareInfo);
coreHelper.adjustDefaultEngineType(&hardwareInfo);
EXPECT_EQ(aub_stream::ENGINE_RCS, hardwareInfo.capabilityTable.defaultEngineType); EXPECT_EQ(aub_stream::ENGINE_RCS, hardwareInfo.capabilityTable.defaultEngineType);
} }

15
shared/test/unit_test/gen12lp/tgllp/linux/hw_info_config_tests_tgllp.cpp
View File

@@ -25,19 +25,19 @@ struct HwInfoConfigTestLinuxTgllp : HwInfoConfigTestLinux {
}; };
TGLLPTEST_F(HwInfoConfigTestLinuxTgllp, GivenTGLLPWhenConfigureHardwareCustomThenMTPIsNotSet) { TGLLPTEST_F(HwInfoConfigTestLinuxTgllp, GivenTGLLPWhenConfigureHardwareCustomThenMTPIsNotSet) {
auto hwInfoConfig = HwInfoConfig::get(productFamily); auto &productHelper = getHelper<ProductHelper>();
pInHwInfo.capabilityTable.defaultPreemptionMode = PreemptionMode::ThreadGroup; pInHwInfo.capabilityTable.defaultPreemptionMode = PreemptionMode::ThreadGroup;
PreemptionHelper::adjustDefaultPreemptionMode(pInHwInfo.capabilityTable, true, true, true); PreemptionHelper::adjustDefaultPreemptionMode(pInHwInfo.capabilityTable, true, true, true);
int ret = hwInfoConfig->configureHwInfoDrm(&pInHwInfo, &outHwInfo, osInterface); auto ret = productHelper.configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(0, ret); EXPECT_EQ(0, ret);
EXPECT_FALSE(outHwInfo.featureTable.flags.ftrGpGpuMidThreadLevelPreempt); EXPECT_FALSE(outHwInfo.featureTable.flags.ftrGpGpuMidThreadLevelPreempt);
} }
TGLLPTEST_F(HwInfoConfigTestLinuxTgllp, configureHwInfo) { TGLLPTEST_F(HwInfoConfigTestLinuxTgllp, configureHwInfo) {
auto hwInfoConfig = HwInfoConfig::get(productFamily); auto &productHelper = getHelper<ProductHelper>();
int ret = hwInfoConfig->configureHwInfoDrm(&pInHwInfo, &outHwInfo, osInterface); auto ret = productHelper.configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(0, ret); EXPECT_EQ(0, ret);
EXPECT_EQ((uint32_t)drm->storedEUVal, outHwInfo.gtSystemInfo.EUCount); EXPECT_EQ((uint32_t)drm->storedEUVal, outHwInfo.gtSystemInfo.EUCount);
EXPECT_EQ((uint32_t)drm->storedSSVal, outHwInfo.gtSystemInfo.SubSliceCount); EXPECT_EQ((uint32_t)drm->storedSSVal, outHwInfo.gtSystemInfo.SubSliceCount);
@@ -47,16 +47,17 @@ TGLLPTEST_F(HwInfoConfigTestLinuxTgllp, configureHwInfo) {
} }
TGLLPTEST_F(HwInfoConfigTestLinuxTgllp, negative) { TGLLPTEST_F(HwInfoConfigTestLinuxTgllp, negative) {
auto hwInfoConfig = HwInfoConfig::get(productFamily);
drm->failRetTopology = true; drm->failRetTopology = true;
drm->storedRetValForEUVal = -1; drm->storedRetValForEUVal = -1;
auto ret = hwInfoConfig->configureHwInfoDrm(&pInHwInfo, &outHwInfo, osInterface); auto &productHelper = getHelper<ProductHelper>();
auto ret = productHelper.configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(-1, ret); EXPECT_EQ(-1, ret);
drm->storedRetValForEUVal = 0; drm->storedRetValForEUVal = 0;
drm->storedRetValForSSVal = -1; drm->storedRetValForSSVal = -1;
ret = hwInfoConfig->configureHwInfoDrm(&pInHwInfo, &outHwInfo, osInterface);
ret = productHelper.configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(-1, ret); EXPECT_EQ(-1, ret);
} }

31
shared/test/unit_test/gen12lp/tgllp/test_hw_helper_tgllp.cpp
View File

@@ -14,33 +14,36 @@
using HwHelperTestGen12Lp = HwHelperTest; using HwHelperTestGen12Lp = HwHelperTest;
TGLLPTEST_F(HwHelperTestGen12Lp, givenTgllpSteppingA0WhenAdjustDefaultEngineTypeCalledThenRcsIsReturned) { TGLLPTEST_F(HwHelperTestGen12Lp, givenTgllpSteppingA0WhenAdjustDefaultEngineTypeCalledThenRcsIsReturned) {
const auto &hwInfoConfig = *HwInfoConfig::get(hardwareInfo.platform.eProductFamily); auto &coreHelper = getHelper<CoreHelper>();
hardwareInfo.featureTable.flags.ftrCCSNode = true; const auto &productHelper = getHelper<ProductHelper>();
hardwareInfo.platform.usRevId = hwInfoConfig.getHwRevIdFromStepping(REVISION_A0, hardwareInfo);
auto &helper = HwHelper::get(renderCoreFamily); hardwareInfo.featureTable.flags.ftrCCSNode = true;
helper.adjustDefaultEngineType(&hardwareInfo); hardwareInfo.platform.usRevId = productHelper.getHwRevIdFromStepping(REVISION_A0, hardwareInfo);
coreHelper.adjustDefaultEngineType(&hardwareInfo);
EXPECT_EQ(aub_stream::ENGINE_RCS, hardwareInfo.capabilityTable.defaultEngineType); EXPECT_EQ(aub_stream::ENGINE_RCS, hardwareInfo.capabilityTable.defaultEngineType);
} }
TGLLPTEST_F(HwHelperTestGen12Lp, givenTgllpSteppingBWhenAdjustDefaultEngineTypeCalledThenRcsIsReturned) { TGLLPTEST_F(HwHelperTestGen12Lp, givenTgllpSteppingBWhenAdjustDefaultEngineTypeCalledThenRcsIsReturned) {
const auto &hwInfoConfig = *HwInfoConfig::get(hardwareInfo.platform.eProductFamily); auto &coreHelper = getHelper<CoreHelper>();
hardwareInfo.featureTable.flags.ftrCCSNode = true; const auto &productHelper = getHelper<ProductHelper>();
hardwareInfo.platform.usRevId = hwInfoConfig.getHwRevIdFromStepping(REVISION_A1, hardwareInfo);
auto &helper = HwHelper::get(renderCoreFamily); hardwareInfo.featureTable.flags.ftrCCSNode = true;
helper.adjustDefaultEngineType(&hardwareInfo); hardwareInfo.platform.usRevId = productHelper.getHwRevIdFromStepping(REVISION_A1, hardwareInfo);
coreHelper.adjustDefaultEngineType(&hardwareInfo);
EXPECT_EQ(aub_stream::ENGINE_RCS, hardwareInfo.capabilityTable.defaultEngineType); EXPECT_EQ(aub_stream::ENGINE_RCS, hardwareInfo.capabilityTable.defaultEngineType);
} }
TGLLPTEST_F(HwHelperTestGen12Lp, givenTgllWhenWaForDefaultEngineIsNotAppliedThenCcsIsReturned) { TGLLPTEST_F(HwHelperTestGen12Lp, givenTgllWhenWaForDefaultEngineIsNotAppliedThenCcsIsReturned) {
const auto &hwInfoConfig = *HwInfoConfig::get(hardwareInfo.platform.eProductFamily); auto &coreHelper = getHelper<CoreHelper>();
const auto &productHelper = getHelper<ProductHelper>();
hardwareInfo.featureTable.flags.ftrCCSNode = true; hardwareInfo.featureTable.flags.ftrCCSNode = true;
hardwareInfo.platform.usRevId = hwInfoConfig.getHwRevIdFromStepping(REVISION_A0, hardwareInfo); hardwareInfo.platform.usRevId = productHelper.getHwRevIdFromStepping(REVISION_A0, hardwareInfo);
hardwareInfo.platform.eProductFamily = IGFX_UNKNOWN; hardwareInfo.platform.eProductFamily = IGFX_UNKNOWN;
auto &helper = HwHelper::get(renderCoreFamily); coreHelper.adjustDefaultEngineType(&hardwareInfo);
helper.adjustDefaultEngineType(&hardwareInfo);
EXPECT_EQ(aub_stream::ENGINE_RCS, hardwareInfo.capabilityTable.defaultEngineType); EXPECT_EQ(aub_stream::ENGINE_RCS, hardwareInfo.capabilityTable.defaultEngineType);
} }

25
shared/test/unit_test/gen8/bdw/linux/hw_info_config_tests_bdw.cpp
View File

@@ -17,9 +17,9 @@ struct HwInfoConfigTestLinuxBdw : HwInfoConfigTestLinux {
}; };
BDWTEST_F(HwInfoConfigTestLinuxBdw, WhenConfiguringHwInfoThenInformationIsCorrect) { BDWTEST_F(HwInfoConfigTestLinuxBdw, WhenConfiguringHwInfoThenInformationIsCorrect) {
auto hwInfoConfig = HwInfoConfig::get(productFamily);
drm->storedSSVal = 3; drm->storedSSVal = 3;
int ret = hwInfoConfig->configureHwInfoDrm(&pInHwInfo, &outHwInfo, osInterface); auto &productHelper = getHelper<ProductHelper>();
auto ret = productHelper.configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(0, ret); EXPECT_EQ(0, ret);
EXPECT_EQ((uint32_t)drm->storedEUVal, outHwInfo.gtSystemInfo.EUCount); EXPECT_EQ((uint32_t)drm->storedEUVal, outHwInfo.gtSystemInfo.EUCount);
EXPECT_EQ((uint32_t)drm->storedSSVal, outHwInfo.gtSystemInfo.SubSliceCount); EXPECT_EQ((uint32_t)drm->storedSSVal, outHwInfo.gtSystemInfo.SubSliceCount);
@@ -28,7 +28,7 @@ BDWTEST_F(HwInfoConfigTestLinuxBdw, WhenConfiguringHwInfoThenInformationIsCorrec
pInHwInfo.platform.usDeviceID = 0x1602; pInHwInfo.platform.usDeviceID = 0x1602;
ret = hwInfoConfig->configureHwInfoDrm(&pInHwInfo, &outHwInfo, osInterface); ret = productHelper.configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(0, ret); EXPECT_EQ(0, ret);
EXPECT_EQ((uint32_t)drm->storedEUVal, outHwInfo.gtSystemInfo.EUCount); EXPECT_EQ((uint32_t)drm->storedEUVal, outHwInfo.gtSystemInfo.EUCount);
EXPECT_EQ((uint32_t)drm->storedSSVal, outHwInfo.gtSystemInfo.SubSliceCount); EXPECT_EQ((uint32_t)drm->storedSSVal, outHwInfo.gtSystemInfo.SubSliceCount);
@@ -37,7 +37,7 @@ BDWTEST_F(HwInfoConfigTestLinuxBdw, WhenConfiguringHwInfoThenInformationIsCorrec
pInHwInfo.platform.usDeviceID = 0x1626; pInHwInfo.platform.usDeviceID = 0x1626;
drm->storedSSVal = 6; drm->storedSSVal = 6;
ret = hwInfoConfig->configureHwInfoDrm(&pInHwInfo, &outHwInfo, osInterface); ret = productHelper.configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(0, ret); EXPECT_EQ(0, ret);
EXPECT_EQ((uint32_t)drm->storedEUVal, outHwInfo.gtSystemInfo.EUCount); EXPECT_EQ((uint32_t)drm->storedEUVal, outHwInfo.gtSystemInfo.EUCount);
EXPECT_EQ((uint32_t)drm->storedSSVal, outHwInfo.gtSystemInfo.SubSliceCount); EXPECT_EQ((uint32_t)drm->storedSSVal, outHwInfo.gtSystemInfo.SubSliceCount);
@@ -48,36 +48,35 @@ BDWTEST_F(HwInfoConfigTestLinuxBdw, WhenConfiguringHwInfoThenInformationIsCorrec
BDWTEST_F(HwInfoConfigTestLinuxBdw, GivenFailedIoctlEuCountWhenConfiguringHwInfoThenErrorIsReturned) { BDWTEST_F(HwInfoConfigTestLinuxBdw, GivenFailedIoctlEuCountWhenConfiguringHwInfoThenErrorIsReturned) {
drm->failRetTopology = true; drm->failRetTopology = true;
drm->storedRetValForEUVal = -4; drm->storedRetValForEUVal = -4;
auto hwInfoConfig = HwInfoConfig::get(productFamily); auto &productHelper = getHelper<ProductHelper>();
int ret = hwInfoConfig->configureHwInfoDrm(&pInHwInfo, &outHwInfo, osInterface); auto ret = productHelper.configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(-4, ret); EXPECT_EQ(-4, ret);
} }
BDWTEST_F(HwInfoConfigTestLinuxBdw, GivenFailedIoctlSsCountWhenConfiguringHwInfoThenErrorIsReturned) { BDWTEST_F(HwInfoConfigTestLinuxBdw, GivenFailedIoctlSsCountWhenConfiguringHwInfoThenErrorIsReturned) {
drm->failRetTopology = true; drm->failRetTopology = true;
drm->storedRetValForSSVal = -5; drm->storedRetValForSSVal = -5;
auto hwInfoConfig = HwInfoConfig::get(productFamily); auto &productHelper = getHelper<ProductHelper>();
int ret = hwInfoConfig->configureHwInfoDrm(&pInHwInfo, &outHwInfo, osInterface); auto ret = productHelper.configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(-5, ret); EXPECT_EQ(-5, ret);
} }
BDWTEST_F(HwInfoConfigTestLinuxBdw, WhenConfiguringHwInfoThenEdramInformationIsCorrect) { BDWTEST_F(HwInfoConfigTestLinuxBdw, WhenConfiguringHwInfoThenEdramInformationIsCorrect) {
auto hwInfoConfig = HwInfoConfig::get(productFamily); auto &productHelper = getHelper<ProductHelper>();
auto ret = productHelper.configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
int ret = hwInfoConfig->configureHwInfoDrm(&pInHwInfo, &outHwInfo, osInterface);
EXPECT_EQ(0, ret); EXPECT_EQ(0, ret);
EXPECT_EQ_VAL(0u, outHwInfo.gtSystemInfo.EdramSizeInKb); EXPECT_EQ_VAL(0u, outHwInfo.gtSystemInfo.EdramSizeInKb);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrEDram); EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrEDram);
pInHwInfo.platform.usDeviceID = 0x1622; pInHwInfo.platform.usDeviceID = 0x1622;
ret = hwInfoConfig->configureHwInfoDrm(&pInHwInfo, &outHwInfo, osInterface); ret = productHelper.configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(0, ret); EXPECT_EQ(0, ret);
EXPECT_EQ_VAL((128u * 1024u), outHwInfo.gtSystemInfo.EdramSizeInKb); EXPECT_EQ_VAL((128u * 1024u), outHwInfo.gtSystemInfo.EdramSizeInKb);
EXPECT_EQ(1u, outHwInfo.featureTable.flags.ftrEDram); EXPECT_EQ(1u, outHwInfo.featureTable.flags.ftrEDram);
pInHwInfo.platform.usDeviceID = 0x162A; pInHwInfo.platform.usDeviceID = 0x162A;
ret = hwInfoConfig->configureHwInfoDrm(&pInHwInfo, &outHwInfo, osInterface); ret = productHelper.configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(0, ret); EXPECT_EQ(0, ret);
EXPECT_EQ_VAL((128u * 1024u), outHwInfo.gtSystemInfo.EdramSizeInKb); EXPECT_EQ_VAL((128u * 1024u), outHwInfo.gtSystemInfo.EdramSizeInKb);
EXPECT_EQ(1u, outHwInfo.featureTable.flags.ftrEDram); EXPECT_EQ(1u, outHwInfo.featureTable.flags.ftrEDram);

4
shared/test/unit_test/gen8/hw_helper_tests_gen8.cpp
View File

@@ -28,8 +28,8 @@ GEN8TEST_F(HwHelperTestGen8, WhenGettingPitchAlignmentForImageThenCorrectValueIs
GEN8TEST_F(HwHelperTestGen8, WhenAdjustingDefaultEngineTypeThenEngineTypeIsSet) { GEN8TEST_F(HwHelperTestGen8, WhenAdjustingDefaultEngineTypeThenEngineTypeIsSet) {
auto engineType = hardwareInfo.capabilityTable.defaultEngineType; auto engineType = hardwareInfo.capabilityTable.defaultEngineType;
auto &helper = HwHelper::get(renderCoreFamily); auto &coreHelper = getHelper<CoreHelper>();
helper.adjustDefaultEngineType(&hardwareInfo); coreHelper.adjustDefaultEngineType(&hardwareInfo);
EXPECT_EQ(engineType, hardwareInfo.capabilityTable.defaultEngineType); EXPECT_EQ(engineType, hardwareInfo.capabilityTable.defaultEngineType);
} }

2
shared/test/unit_test/gen9/bxt/linux/CMakeLists.txt
View File

@@ -6,6 +6,6 @@
if(UNIX) if(UNIX)
target_sources(neo_shared_tests PRIVATE target_sources(neo_shared_tests PRIVATE
${CMAKE_CURRENT_SOURCE_DIR}/hw_info_config_tests.cpp ${CMAKE_CURRENT_SOURCE_DIR}/hw_info_config_tests_bxt.cpp
) )
endif() endif()

36
shared/test/unit_test/gen9/bxt/linux/hw_info_config_tests.cpp → shared/test/unit_test/gen9/bxt/linux/hw_info_config_tests_bxt.cpp
View File

@@ -22,8 +22,8 @@ struct HwInfoConfigTestLinuxBxt : HwInfoConfigTestLinux {
}; };
BXTTEST_F(HwInfoConfigTestLinuxBxt, WhenConfiguringHwInfoThenConfigIsCorrect) { BXTTEST_F(HwInfoConfigTestLinuxBxt, WhenConfiguringHwInfoThenConfigIsCorrect) {
auto hwInfoConfig = HwInfoConfig::get(productFamily); auto &productHelper = getHelper<ProductHelper>();
int ret = hwInfoConfig->configureHwInfoDrm(&pInHwInfo, &outHwInfo, osInterface); auto ret = productHelper.configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(0, ret); EXPECT_EQ(0, ret);
EXPECT_EQ((uint32_t)drm->storedEUVal, outHwInfo.gtSystemInfo.EUCount); EXPECT_EQ((uint32_t)drm->storedEUVal, outHwInfo.gtSystemInfo.EUCount);
EXPECT_EQ((uint32_t)drm->storedSSVal, outHwInfo.gtSystemInfo.SubSliceCount); EXPECT_EQ((uint32_t)drm->storedSSVal, outHwInfo.gtSystemInfo.SubSliceCount);
@@ -32,12 +32,12 @@ BXTTEST_F(HwInfoConfigTestLinuxBxt, WhenConfiguringHwInfoThenConfigIsCorrect) {
EXPECT_EQ((outHwInfo.gtSystemInfo.EUCount - outHwInfo.gtSystemInfo.EuCountPerPoolMin), outHwInfo.gtSystemInfo.EuCountPerPoolMax); EXPECT_EQ((outHwInfo.gtSystemInfo.EUCount - outHwInfo.gtSystemInfo.EuCountPerPoolMin), outHwInfo.gtSystemInfo.EuCountPerPoolMax);
EXPECT_EQ(aub_stream::ENGINE_RCS, outHwInfo.capabilityTable.defaultEngineType); EXPECT_EQ(aub_stream::ENGINE_RCS, outHwInfo.capabilityTable.defaultEngineType);
//constant sysInfo/ftr flags // constant sysInfo/ftr flags
EXPECT_TRUE(outHwInfo.gtSystemInfo.VEBoxInfo.IsValid); EXPECT_TRUE(outHwInfo.gtSystemInfo.VEBoxInfo.IsValid);
pInHwInfo.platform.usDeviceID = 0x5A85; pInHwInfo.platform.usDeviceID = 0x5A85;
drm->storedMinEUinPool = 6; drm->storedMinEUinPool = 6;
ret = hwInfoConfig->configureHwInfoDrm(&pInHwInfo, &outHwInfo, osInterface); ret = productHelper.configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(0, ret); EXPECT_EQ(0, ret);
EXPECT_EQ((uint32_t)drm->storedEUVal, outHwInfo.gtSystemInfo.EUCount); EXPECT_EQ((uint32_t)drm->storedEUVal, outHwInfo.gtSystemInfo.EUCount);
EXPECT_EQ((uint32_t)drm->storedSSVal, outHwInfo.gtSystemInfo.SubSliceCount); EXPECT_EQ((uint32_t)drm->storedSSVal, outHwInfo.gtSystemInfo.SubSliceCount);
@@ -48,7 +48,7 @@ BXTTEST_F(HwInfoConfigTestLinuxBxt, WhenConfiguringHwInfoThenConfigIsCorrect) {
pInHwInfo.platform.usDeviceID = 0x5A85; pInHwInfo.platform.usDeviceID = 0x5A85;
drm->storedMinEUinPool = 9; drm->storedMinEUinPool = 9;
ret = hwInfoConfig->configureHwInfoDrm(&pInHwInfo, &outHwInfo, osInterface); ret = productHelper.configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(0, ret); EXPECT_EQ(0, ret);
EXPECT_EQ((uint32_t)drm->storedEUVal, outHwInfo.gtSystemInfo.EUCount); EXPECT_EQ((uint32_t)drm->storedEUVal, outHwInfo.gtSystemInfo.EUCount);
EXPECT_EQ((uint32_t)drm->storedSSVal, outHwInfo.gtSystemInfo.SubSliceCount); EXPECT_EQ((uint32_t)drm->storedSSVal, outHwInfo.gtSystemInfo.SubSliceCount);
@@ -69,15 +69,16 @@ BXTTEST_F(HwInfoConfigTestLinuxBxt, WhenConfiguringHwInfoThenConfigIsCorrect) {
BXTTEST_F(HwInfoConfigTestLinuxBxt, GivenFailedIoctlEuCountWhenConfiguringHwInfoThenErrorIsReturned) { BXTTEST_F(HwInfoConfigTestLinuxBxt, GivenFailedIoctlEuCountWhenConfiguringHwInfoThenErrorIsReturned) {
drm->failRetTopology = true; drm->failRetTopology = true;
drm->storedRetValForEUVal = -4; drm->storedRetValForEUVal = -4;
auto hwInfoConfig = HwInfoConfig::get(productFamily); auto &productHelper = getHelper<ProductHelper>();
int ret = hwInfoConfig->configureHwInfoDrm(&pInHwInfo, &outHwInfo, osInterface); auto ret = productHelper.configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(-4, ret); EXPECT_EQ(-4, ret);
} }
BXTTEST_F(HwInfoConfigTestLinuxBxt, GivenFailingEnabledPoolWhenConfiguringHwInfoThenZeroIsReturned) { BXTTEST_F(HwInfoConfigTestLinuxBxt, GivenFailingEnabledPoolWhenConfiguringHwInfoThenZeroIsReturned) {
drm->storedRetValForPooledEU = -1; drm->storedRetValForPooledEU = -1;
auto hwInfoConfig = HwInfoConfig::get(productFamily); auto &productHelper = getHelper<ProductHelper>();
int ret = hwInfoConfig->configureHwInfoDrm(&pInHwInfo, &outHwInfo, osInterface); auto ret = productHelper.configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(0, ret); EXPECT_EQ(0, ret);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrPooledEuEnabled); EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrPooledEuEnabled);
@@ -87,8 +88,8 @@ BXTTEST_F(HwInfoConfigTestLinuxBxt, GivenFailingEnabledPoolWhenConfiguringHwInfo
BXTTEST_F(HwInfoConfigTestLinuxBxt, GivenDisabledEnabledPoolWhenConfiguringHwInfoThenZeroIsReturned) { BXTTEST_F(HwInfoConfigTestLinuxBxt, GivenDisabledEnabledPoolWhenConfiguringHwInfoThenZeroIsReturned) {
drm->storedHasPooledEU = 0; drm->storedHasPooledEU = 0;
auto hwInfoConfig = HwInfoConfig::get(productFamily); auto &productHelper = getHelper<ProductHelper>();
int ret = hwInfoConfig->configureHwInfoDrm(&pInHwInfo, &outHwInfo, osInterface); int ret = productHelper.configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(0, ret); EXPECT_EQ(0, ret);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrPooledEuEnabled); EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrPooledEuEnabled);
@@ -100,8 +101,8 @@ BXTTEST_F(HwInfoConfigTestLinuxBxt, GivenFailingMinEuInPoolWhenConfiguringHwInfo
drm->storedRetValForMinEUinPool = -1; drm->storedRetValForMinEUinPool = -1;
drm->storedSSVal = 3; drm->storedSSVal = 3;
auto hwInfoConfig = HwInfoConfig::get(productFamily); auto &productHelper = getHelper<ProductHelper>();
int ret = hwInfoConfig->configureHwInfoDrm(&pInHwInfo, &outHwInfo, osInterface); auto ret = productHelper.configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(0, ret); EXPECT_EQ(0, ret);
EXPECT_EQ(1u, outHwInfo.featureTable.flags.ftrPooledEuEnabled); EXPECT_EQ(1u, outHwInfo.featureTable.flags.ftrPooledEuEnabled);
@@ -109,7 +110,7 @@ BXTTEST_F(HwInfoConfigTestLinuxBxt, GivenFailingMinEuInPoolWhenConfiguringHwInfo
EXPECT_EQ((outHwInfo.gtSystemInfo.EUCount - outHwInfo.gtSystemInfo.EuCountPerPoolMin), outHwInfo.gtSystemInfo.EuCountPerPoolMax); EXPECT_EQ((outHwInfo.gtSystemInfo.EUCount - outHwInfo.gtSystemInfo.EuCountPerPoolMin), outHwInfo.gtSystemInfo.EuCountPerPoolMax);
drm->storedSSVal = 2; drm->storedSSVal = 2;
ret = hwInfoConfig->configureHwInfoDrm(&pInHwInfo, &outHwInfo, osInterface); ret = productHelper.configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(0, ret); EXPECT_EQ(0, ret);
EXPECT_EQ(1u, outHwInfo.featureTable.flags.ftrPooledEuEnabled); EXPECT_EQ(1u, outHwInfo.featureTable.flags.ftrPooledEuEnabled);
@@ -121,8 +122,8 @@ BXTTEST_F(HwInfoConfigTestLinuxBxt, GivenInvalidMinEuInPoolWhenConfiguringHwInfo
drm->storedMinEUinPool = 4; drm->storedMinEUinPool = 4;
drm->storedSSVal = 3; drm->storedSSVal = 3;
auto hwInfoConfig = HwInfoConfig::get(productFamily); auto &productHelper = getHelper<ProductHelper>();
int ret = hwInfoConfig->configureHwInfoDrm(&pInHwInfo, &outHwInfo, osInterface); auto ret = productHelper.configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(0, ret); EXPECT_EQ(0, ret);
EXPECT_EQ(1u, outHwInfo.featureTable.flags.ftrPooledEuEnabled); EXPECT_EQ(1u, outHwInfo.featureTable.flags.ftrPooledEuEnabled);
@@ -130,7 +131,8 @@ BXTTEST_F(HwInfoConfigTestLinuxBxt, GivenInvalidMinEuInPoolWhenConfiguringHwInfo
EXPECT_EQ((outHwInfo.gtSystemInfo.EUCount - outHwInfo.gtSystemInfo.EuCountPerPoolMin), outHwInfo.gtSystemInfo.EuCountPerPoolMax); EXPECT_EQ((outHwInfo.gtSystemInfo.EUCount - outHwInfo.gtSystemInfo.EuCountPerPoolMin), outHwInfo.gtSystemInfo.EuCountPerPoolMax);
drm->storedSSVal = 2; drm->storedSSVal = 2;
ret = hwInfoConfig->configureHwInfoDrm(&pInHwInfo, &outHwInfo, osInterface);
ret = productHelper.configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(0, ret); EXPECT_EQ(0, ret);
EXPECT_EQ(1u, outHwInfo.featureTable.flags.ftrPooledEuEnabled); EXPECT_EQ(1u, outHwInfo.featureTable.flags.ftrPooledEuEnabled);

27
shared/test/unit_test/gen9/cfl/linux/hw_info_config_tests_cfl.cpp
View File

@@ -18,21 +18,21 @@ struct HwInfoConfigTestLinuxCfl : HwInfoConfigTestLinux {
}; };
CFLTEST_F(HwInfoConfigTestLinuxCfl, WhenConfiguringHwInfoThenInformationIsCorrect) { CFLTEST_F(HwInfoConfigTestLinuxCfl, WhenConfiguringHwInfoThenInformationIsCorrect) {
auto hwInfoConfig = HwInfoConfig::get(productFamily); auto &productHelper = getHelper<ProductHelper>();
int ret = hwInfoConfig->configureHwInfoDrm(&pInHwInfo, &outHwInfo, osInterface); auto ret = productHelper.configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(0, ret); EXPECT_EQ(0, ret);
EXPECT_EQ((uint32_t)drm->storedEUVal, outHwInfo.gtSystemInfo.EUCount); EXPECT_EQ((uint32_t)drm->storedEUVal, outHwInfo.gtSystemInfo.EUCount);
EXPECT_EQ((uint32_t)drm->storedSSVal, outHwInfo.gtSystemInfo.SubSliceCount); EXPECT_EQ((uint32_t)drm->storedSSVal, outHwInfo.gtSystemInfo.SubSliceCount);
EXPECT_EQ(aub_stream::ENGINE_RCS, outHwInfo.capabilityTable.defaultEngineType); EXPECT_EQ(aub_stream::ENGINE_RCS, outHwInfo.capabilityTable.defaultEngineType);
//constant sysInfo/ftr flags // constant sysInfo/ftr flags
EXPECT_EQ(1u, outHwInfo.gtSystemInfo.VEBoxInfo.Instances.Bits.VEBox0Enabled); EXPECT_EQ(1u, outHwInfo.gtSystemInfo.VEBoxInfo.Instances.Bits.VEBox0Enabled);
EXPECT_TRUE(outHwInfo.gtSystemInfo.VEBoxInfo.IsValid); EXPECT_TRUE(outHwInfo.gtSystemInfo.VEBoxInfo.IsValid);
pInHwInfo.platform.usDeviceID = 0x3E90; pInHwInfo.platform.usDeviceID = 0x3E90;
drm->storedSSVal = 3; drm->storedSSVal = 3;
ret = hwInfoConfig->configureHwInfoDrm(&pInHwInfo, &outHwInfo, osInterface); ret = productHelper.configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(0, ret); EXPECT_EQ(0, ret);
EXPECT_EQ((uint32_t)drm->storedEUVal, outHwInfo.gtSystemInfo.EUCount); EXPECT_EQ((uint32_t)drm->storedEUVal, outHwInfo.gtSystemInfo.EUCount);
EXPECT_EQ((uint32_t)drm->storedSSVal, outHwInfo.gtSystemInfo.SubSliceCount); EXPECT_EQ((uint32_t)drm->storedSSVal, outHwInfo.gtSystemInfo.SubSliceCount);
@@ -42,7 +42,7 @@ CFLTEST_F(HwInfoConfigTestLinuxCfl, WhenConfiguringHwInfoThenInformationIsCorrec
pInHwInfo.platform.usDeviceID = 0x3EA5; pInHwInfo.platform.usDeviceID = 0x3EA5;
drm->storedSSVal = 6; drm->storedSSVal = 6;
ret = hwInfoConfig->configureHwInfoDrm(&pInHwInfo, &outHwInfo, osInterface); ret = productHelper.configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(0, ret); EXPECT_EQ(0, ret);
EXPECT_EQ((uint32_t)drm->storedEUVal, outHwInfo.gtSystemInfo.EUCount); EXPECT_EQ((uint32_t)drm->storedEUVal, outHwInfo.gtSystemInfo.EUCount);
EXPECT_EQ((uint32_t)drm->storedSSVal, outHwInfo.gtSystemInfo.SubSliceCount); EXPECT_EQ((uint32_t)drm->storedSSVal, outHwInfo.gtSystemInfo.SubSliceCount);
@@ -63,36 +63,35 @@ CFLTEST_F(HwInfoConfigTestLinuxCfl, WhenConfiguringHwInfoThenInformationIsCorrec
CFLTEST_F(HwInfoConfigTestLinuxCfl, GivenFailedIoctlEuCountWhenConfiguringHwInfoThenErrorIsReturned) { CFLTEST_F(HwInfoConfigTestLinuxCfl, GivenFailedIoctlEuCountWhenConfiguringHwInfoThenErrorIsReturned) {
drm->storedRetValForEUVal = -4; drm->storedRetValForEUVal = -4;
drm->failRetTopology = true; drm->failRetTopology = true;
auto hwInfoConfig = HwInfoConfig::get(productFamily); auto &productHelper = getHelper<ProductHelper>();
int ret = hwInfoConfig->configureHwInfoDrm(&pInHwInfo, &outHwInfo, osInterface); auto ret = productHelper.configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(-4, ret); EXPECT_EQ(-4, ret);
} }
CFLTEST_F(HwInfoConfigTestLinuxCfl, GivenFailedIoctlSsCountWhenConfiguringHwInfoThenErrorIsReturned) { CFLTEST_F(HwInfoConfigTestLinuxCfl, GivenFailedIoctlSsCountWhenConfiguringHwInfoThenErrorIsReturned) {
drm->storedRetValForSSVal = -5; drm->storedRetValForSSVal = -5;
drm->failRetTopology = true; drm->failRetTopology = true;
auto hwInfoConfig = HwInfoConfig::get(productFamily); auto &productHelper = getHelper<ProductHelper>();
int ret = hwInfoConfig->configureHwInfoDrm(&pInHwInfo, &outHwInfo, osInterface); auto ret = productHelper.configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(-5, ret); EXPECT_EQ(-5, ret);
} }
CFLTEST_F(HwInfoConfigTestLinuxCfl, WhenConfiguringHwInfoThenEdramInformationIsCorrect) { CFLTEST_F(HwInfoConfigTestLinuxCfl, WhenConfiguringHwInfoThenEdramInformationIsCorrect) {
auto hwInfoConfig = HwInfoConfig::get(productFamily); auto &productHelper = getHelper<ProductHelper>();
auto ret = productHelper.configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
int ret = hwInfoConfig->configureHwInfoDrm(&pInHwInfo, &outHwInfo, osInterface);
EXPECT_EQ(0, ret); EXPECT_EQ(0, ret);
EXPECT_EQ_VAL(0u, outHwInfo.gtSystemInfo.EdramSizeInKb); EXPECT_EQ_VAL(0u, outHwInfo.gtSystemInfo.EdramSizeInKb);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrEDram); EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrEDram);
pInHwInfo.platform.usDeviceID = 0x3EA8; pInHwInfo.platform.usDeviceID = 0x3EA8;
ret = hwInfoConfig->configureHwInfoDrm(&pInHwInfo, &outHwInfo, osInterface); ret = productHelper.configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(0, ret); EXPECT_EQ(0, ret);
EXPECT_EQ_VAL((64u * 1024u), outHwInfo.gtSystemInfo.EdramSizeInKb); EXPECT_EQ_VAL((64u * 1024u), outHwInfo.gtSystemInfo.EdramSizeInKb);
EXPECT_EQ(1u, outHwInfo.featureTable.flags.ftrEDram); EXPECT_EQ(1u, outHwInfo.featureTable.flags.ftrEDram);
pInHwInfo.platform.usDeviceID = 0x3EA6; pInHwInfo.platform.usDeviceID = 0x3EA6;
ret = hwInfoConfig->configureHwInfoDrm(&pInHwInfo, &outHwInfo, osInterface); ret = productHelper.configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(0, ret); EXPECT_EQ(0, ret);
EXPECT_EQ_VAL((64u * 1024u), outHwInfo.gtSystemInfo.EdramSizeInKb); EXPECT_EQ_VAL((64u * 1024u), outHwInfo.gtSystemInfo.EdramSizeInKb);
EXPECT_EQ(1u, outHwInfo.featureTable.flags.ftrEDram); EXPECT_EQ(1u, outHwInfo.featureTable.flags.ftrEDram);

40
shared/test/unit_test/gen9/glk/linux/hw_info_config_tests_glk.cpp
View File

@@ -21,22 +21,22 @@ struct HwInfoConfigTestLinuxGlk : HwInfoConfigTestLinux {
}; };
GLKTEST_F(HwInfoConfigTestLinuxGlk, WhenConfiguringHwInfoThenInformationIsCorrect) { GLKTEST_F(HwInfoConfigTestLinuxGlk, WhenConfiguringHwInfoThenInformationIsCorrect) {
auto hwInfoConfig = HwInfoConfig::get(productFamily); auto &productHelper = getHelper<ProductHelper>();
int ret = hwInfoConfig->configureHwInfoDrm(&pInHwInfo, &outHwInfo, osInterface); auto ret = productHelper.configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(0, ret); EXPECT_EQ(0, ret);
EXPECT_EQ((uint32_t)drm->storedEUVal, outHwInfo.gtSystemInfo.EUCount); EXPECT_EQ((uint32_t)drm->storedEUVal, outHwInfo.gtSystemInfo.EUCount);
EXPECT_EQ((uint32_t)drm->storedSSVal, outHwInfo.gtSystemInfo.SubSliceCount); EXPECT_EQ((uint32_t)drm->storedSSVal, outHwInfo.gtSystemInfo.SubSliceCount);
EXPECT_EQ(aub_stream::ENGINE_RCS, outHwInfo.capabilityTable.defaultEngineType); EXPECT_EQ(aub_stream::ENGINE_RCS, outHwInfo.capabilityTable.defaultEngineType);
//constant sysInfo/ftr flags // constant sysInfo/ftr flags
EXPECT_EQ(1u, outHwInfo.gtSystemInfo.VEBoxInfo.Instances.Bits.VEBox0Enabled); EXPECT_EQ(1u, outHwInfo.gtSystemInfo.VEBoxInfo.Instances.Bits.VEBox0Enabled);
EXPECT_TRUE(outHwInfo.gtSystemInfo.VEBoxInfo.IsValid); EXPECT_TRUE(outHwInfo.gtSystemInfo.VEBoxInfo.IsValid);
pInHwInfo.platform.usDeviceID = 0x3184; pInHwInfo.platform.usDeviceID = 0x3184;
drm->storedMinEUinPool = 6; drm->storedMinEUinPool = 6;
ret = hwInfoConfig->configureHwInfoDrm(&pInHwInfo, &outHwInfo, osInterface); ret = productHelper.configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(0, ret); EXPECT_EQ(0, ret);
EXPECT_EQ((uint32_t)drm->storedEUVal, outHwInfo.gtSystemInfo.EUCount); EXPECT_EQ((uint32_t)drm->storedEUVal, outHwInfo.gtSystemInfo.EUCount);
EXPECT_EQ((uint32_t)drm->storedSSVal, outHwInfo.gtSystemInfo.SubSliceCount); EXPECT_EQ((uint32_t)drm->storedSSVal, outHwInfo.gtSystemInfo.SubSliceCount);
@@ -48,7 +48,7 @@ GLKTEST_F(HwInfoConfigTestLinuxGlk, WhenConfiguringHwInfoThenInformationIsCorrec
pInHwInfo.platform.usDeviceID = 0x3185; pInHwInfo.platform.usDeviceID = 0x3185;
drm->storedMinEUinPool = 9; drm->storedMinEUinPool = 9;
ret = hwInfoConfig->configureHwInfoDrm(&pInHwInfo, &outHwInfo, osInterface); ret = productHelper.configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(0, ret); EXPECT_EQ(0, ret);
EXPECT_EQ((uint32_t)drm->storedEUVal, outHwInfo.gtSystemInfo.EUCount); EXPECT_EQ((uint32_t)drm->storedEUVal, outHwInfo.gtSystemInfo.EUCount);
EXPECT_EQ((uint32_t)drm->storedSSVal, outHwInfo.gtSystemInfo.SubSliceCount); EXPECT_EQ((uint32_t)drm->storedSSVal, outHwInfo.gtSystemInfo.SubSliceCount);
@@ -69,23 +69,23 @@ GLKTEST_F(HwInfoConfigTestLinuxGlk, WhenConfiguringHwInfoThenInformationIsCorrec
} }
GLKTEST_F(HwInfoConfigTestLinuxGlk, GivenInvalidInputWhenConfiguringHwInfoThenErrorIsReturned) { GLKTEST_F(HwInfoConfigTestLinuxGlk, GivenInvalidInputWhenConfiguringHwInfoThenErrorIsReturned) {
auto hwInfoConfig = HwInfoConfig::get(productFamily);
drm->failRetTopology = true; drm->failRetTopology = true;
drm->storedRetValForEUVal = -1; drm->storedRetValForEUVal = -1;
auto ret = hwInfoConfig->configureHwInfoDrm(&pInHwInfo, &outHwInfo, osInterface); auto &productHelper = getHelper<ProductHelper>();
auto ret = productHelper.configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(-1, ret); EXPECT_EQ(-1, ret);
drm->storedRetValForEUVal = 0; drm->storedRetValForEUVal = 0;
drm->storedRetValForSSVal = -1; drm->storedRetValForSSVal = -1;
ret = hwInfoConfig->configureHwInfoDrm(&pInHwInfo, &outHwInfo, osInterface); ret = productHelper.configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(-1, ret); EXPECT_EQ(-1, ret);
} }
GLKTEST_F(HwInfoConfigTestLinuxGlk, GivenFailingEnabledPoolWhenConfiguringHwInfoThenZeroIsSet) { GLKTEST_F(HwInfoConfigTestLinuxGlk, GivenFailingEnabledPoolWhenConfiguringHwInfoThenZeroIsSet) {
drm->storedRetValForPooledEU = -1; drm->storedRetValForPooledEU = -1;
auto hwInfoConfig = HwInfoConfig::get(productFamily); auto &productHelper = getHelper<ProductHelper>();
int ret = hwInfoConfig->configureHwInfoDrm(&pInHwInfo, &outHwInfo, osInterface); auto ret = productHelper.configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(0, ret); EXPECT_EQ(0, ret);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrPooledEuEnabled); EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrPooledEuEnabled);
@@ -95,8 +95,8 @@ GLKTEST_F(HwInfoConfigTestLinuxGlk, GivenFailingEnabledPoolWhenConfiguringHwInfo
GLKTEST_F(HwInfoConfigTestLinuxGlk, GivenDisabledEnabledPoolWhenConfiguringHwInfoThenZeroIsSet) { GLKTEST_F(HwInfoConfigTestLinuxGlk, GivenDisabledEnabledPoolWhenConfiguringHwInfoThenZeroIsSet) {
drm->storedHasPooledEU = 0; drm->storedHasPooledEU = 0;
auto hwInfoConfig = HwInfoConfig::get(productFamily); auto &productHelper = getHelper<ProductHelper>();
int ret = hwInfoConfig->configureHwInfoDrm(&pInHwInfo, &outHwInfo, osInterface); auto ret = productHelper.configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(0, ret); EXPECT_EQ(0, ret);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrPooledEuEnabled); EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrPooledEuEnabled);
@@ -108,8 +108,8 @@ GLKTEST_F(HwInfoConfigTestLinuxGlk, GivenFailingMinEuInPoolWhenConfiguringHwInfo
drm->storedRetValForMinEUinPool = -1; drm->storedRetValForMinEUinPool = -1;
drm->storedSSVal = 3; drm->storedSSVal = 3;
auto hwInfoConfig = HwInfoConfig::get(productFamily); auto &productHelper = getHelper<ProductHelper>();
int ret = hwInfoConfig->configureHwInfoDrm(&pInHwInfo, &outHwInfo, osInterface); auto ret = productHelper.configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(0, ret); EXPECT_EQ(0, ret);
EXPECT_EQ(1u, outHwInfo.featureTable.flags.ftrPooledEuEnabled); EXPECT_EQ(1u, outHwInfo.featureTable.flags.ftrPooledEuEnabled);
@@ -117,7 +117,7 @@ GLKTEST_F(HwInfoConfigTestLinuxGlk, GivenFailingMinEuInPoolWhenConfiguringHwInfo
EXPECT_EQ((outHwInfo.gtSystemInfo.EUCount - outHwInfo.gtSystemInfo.EuCountPerPoolMin), outHwInfo.gtSystemInfo.EuCountPerPoolMax); EXPECT_EQ((outHwInfo.gtSystemInfo.EUCount - outHwInfo.gtSystemInfo.EuCountPerPoolMin), outHwInfo.gtSystemInfo.EuCountPerPoolMax);
drm->storedSSVal = 2; drm->storedSSVal = 2;
ret = hwInfoConfig->configureHwInfoDrm(&pInHwInfo, &outHwInfo, osInterface); ret = productHelper.configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(0, ret); EXPECT_EQ(0, ret);
EXPECT_EQ(1u, outHwInfo.featureTable.flags.ftrPooledEuEnabled); EXPECT_EQ(1u, outHwInfo.featureTable.flags.ftrPooledEuEnabled);
@@ -129,8 +129,8 @@ GLKTEST_F(HwInfoConfigTestLinuxGlk, GivenInvalidMinEuInPoolWhenConfiguringHwInfo
drm->storedMinEUinPool = 4; drm->storedMinEUinPool = 4;
drm->storedSSVal = 3; drm->storedSSVal = 3;
auto hwInfoConfig = HwInfoConfig::get(productFamily); auto &productHelper = getHelper<ProductHelper>();
int ret = hwInfoConfig->configureHwInfoDrm(&pInHwInfo, &outHwInfo, osInterface); auto ret = productHelper.configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(0, ret); EXPECT_EQ(0, ret);
EXPECT_EQ(1u, outHwInfo.featureTable.flags.ftrPooledEuEnabled); EXPECT_EQ(1u, outHwInfo.featureTable.flags.ftrPooledEuEnabled);
@@ -138,7 +138,7 @@ GLKTEST_F(HwInfoConfigTestLinuxGlk, GivenInvalidMinEuInPoolWhenConfiguringHwInfo
EXPECT_EQ((outHwInfo.gtSystemInfo.EUCount - outHwInfo.gtSystemInfo.EuCountPerPoolMin), outHwInfo.gtSystemInfo.EuCountPerPoolMax); EXPECT_EQ((outHwInfo.gtSystemInfo.EUCount - outHwInfo.gtSystemInfo.EuCountPerPoolMin), outHwInfo.gtSystemInfo.EuCountPerPoolMax);
drm->storedSSVal = 2; drm->storedSSVal = 2;
ret = hwInfoConfig->configureHwInfoDrm(&pInHwInfo, &outHwInfo, osInterface); ret = productHelper.configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(0, ret); EXPECT_EQ(0, ret);
EXPECT_EQ(1u, outHwInfo.featureTable.flags.ftrPooledEuEnabled); EXPECT_EQ(1u, outHwInfo.featureTable.flags.ftrPooledEuEnabled);
@@ -147,10 +147,10 @@ GLKTEST_F(HwInfoConfigTestLinuxGlk, GivenInvalidMinEuInPoolWhenConfiguringHwInfo
} }
GLKTEST_F(HwInfoConfigTestLinuxGlk, GivenWaFlagsWhenConfiguringHwInfoThenInformationIsCorrect) { GLKTEST_F(HwInfoConfigTestLinuxGlk, GivenWaFlagsWhenConfiguringHwInfoThenInformationIsCorrect) {
auto hwInfoConfig = HwInfoConfig::get(productFamily);
pInHwInfo.platform.usRevId = 0; pInHwInfo.platform.usRevId = 0;
int ret = hwInfoConfig->configureHwInfoDrm(&pInHwInfo, &outHwInfo, osInterface); auto &productHelper = getHelper<ProductHelper>();
auto ret = productHelper.configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(0, ret); EXPECT_EQ(0, ret);
} }

4
shared/test/unit_test/gen9/hw_helper_tests_gen9.cpp
View File

@@ -30,8 +30,8 @@ GEN9TEST_F(HwHelperTestGen9, WhenGettingPitchAlignmentForImageThenCorrectValueIs
GEN9TEST_F(HwHelperTestGen9, WhenAdjustingDefaultEngineTypeThenEngineTypeIsSet) { GEN9TEST_F(HwHelperTestGen9, WhenAdjustingDefaultEngineTypeThenEngineTypeIsSet) {
auto engineType = hardwareInfo.capabilityTable.defaultEngineType; auto engineType = hardwareInfo.capabilityTable.defaultEngineType;
auto &helper = HwHelper::get(renderCoreFamily); auto &coreHelper = getHelper<CoreHelper>();
helper.adjustDefaultEngineType(&hardwareInfo); coreHelper.adjustDefaultEngineType(&hardwareInfo);
EXPECT_EQ(engineType, hardwareInfo.capabilityTable.defaultEngineType); EXPECT_EQ(engineType, hardwareInfo.capabilityTable.defaultEngineType);
} }

38
shared/test/unit_test/gen9/kbl/linux/hw_info_config_tests_kbl.cpp
View File

@@ -18,27 +18,27 @@ struct HwInfoConfigTestLinuxKbl : HwInfoConfigTestLinux {
}; };
KBLTEST_F(HwInfoConfigTestLinuxKbl, WhenConfiguringHwInfoThenInformationIsCorrect) { KBLTEST_F(HwInfoConfigTestLinuxKbl, WhenConfiguringHwInfoThenInformationIsCorrect) {
auto hwInfoConfig = HwInfoConfig::get(productFamily); auto &productHelper = getHelper<ProductHelper>();
int ret = hwInfoConfig->configureHwInfoDrm(&pInHwInfo, &outHwInfo, osInterface); auto ret = productHelper.configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(0, ret); EXPECT_EQ(0, ret);
EXPECT_EQ((uint32_t)drm->storedEUVal, outHwInfo.gtSystemInfo.EUCount); EXPECT_EQ((uint32_t)drm->storedEUVal, outHwInfo.gtSystemInfo.EUCount);
EXPECT_EQ((uint32_t)drm->storedSSVal, outHwInfo.gtSystemInfo.SubSliceCount); EXPECT_EQ((uint32_t)drm->storedSSVal, outHwInfo.gtSystemInfo.SubSliceCount);
EXPECT_EQ(aub_stream::ENGINE_RCS, outHwInfo.capabilityTable.defaultEngineType); EXPECT_EQ(aub_stream::ENGINE_RCS, outHwInfo.capabilityTable.defaultEngineType);
//constant sysInfo/ftr flags // constant sysInfo/ftr flags
EXPECT_EQ(1u, outHwInfo.gtSystemInfo.VEBoxInfo.Instances.Bits.VEBox0Enabled); EXPECT_EQ(1u, outHwInfo.gtSystemInfo.VEBoxInfo.Instances.Bits.VEBox0Enabled);
EXPECT_TRUE(outHwInfo.gtSystemInfo.VEBoxInfo.IsValid); EXPECT_TRUE(outHwInfo.gtSystemInfo.VEBoxInfo.IsValid);
drm->storedSSVal = 3; drm->storedSSVal = 3;
ret = hwInfoConfig->configureHwInfoDrm(&pInHwInfo, &outHwInfo, osInterface); ret = productHelper.configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(0, ret); EXPECT_EQ(0, ret);
EXPECT_EQ((uint32_t)drm->storedEUVal, outHwInfo.gtSystemInfo.EUCount); EXPECT_EQ((uint32_t)drm->storedEUVal, outHwInfo.gtSystemInfo.EUCount);
EXPECT_EQ((uint32_t)drm->storedSSVal, outHwInfo.gtSystemInfo.SubSliceCount); EXPECT_EQ((uint32_t)drm->storedSSVal, outHwInfo.gtSystemInfo.SubSliceCount);
EXPECT_EQ(1u, outHwInfo.gtSystemInfo.SliceCount); EXPECT_EQ(1u, outHwInfo.gtSystemInfo.SliceCount);
EXPECT_EQ(aub_stream::ENGINE_RCS, outHwInfo.capabilityTable.defaultEngineType); EXPECT_EQ(aub_stream::ENGINE_RCS, outHwInfo.capabilityTable.defaultEngineType);
ret = hwInfoConfig->configureHwInfoDrm(&pInHwInfo, &outHwInfo, osInterface); ret = productHelper.configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(0, ret); EXPECT_EQ(0, ret);
EXPECT_EQ((uint32_t)drm->storedEUVal, outHwInfo.gtSystemInfo.EUCount); EXPECT_EQ((uint32_t)drm->storedEUVal, outHwInfo.gtSystemInfo.EUCount);
EXPECT_EQ((uint32_t)drm->storedSSVal, outHwInfo.gtSystemInfo.SubSliceCount); EXPECT_EQ((uint32_t)drm->storedSSVal, outHwInfo.gtSystemInfo.SubSliceCount);
@@ -46,7 +46,7 @@ KBLTEST_F(HwInfoConfigTestLinuxKbl, WhenConfiguringHwInfoThenInformationIsCorrec
drm->storedSSVal = 6; drm->storedSSVal = 6;
ret = hwInfoConfig->configureHwInfoDrm(&pInHwInfo, &outHwInfo, osInterface); ret = productHelper.configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(0, ret); EXPECT_EQ(0, ret);
EXPECT_EQ((uint32_t)drm->storedEUVal, outHwInfo.gtSystemInfo.EUCount); EXPECT_EQ((uint32_t)drm->storedEUVal, outHwInfo.gtSystemInfo.EUCount);
EXPECT_EQ((uint32_t)drm->storedSSVal, outHwInfo.gtSystemInfo.SubSliceCount); EXPECT_EQ((uint32_t)drm->storedSSVal, outHwInfo.gtSystemInfo.SubSliceCount);
@@ -55,7 +55,7 @@ KBLTEST_F(HwInfoConfigTestLinuxKbl, WhenConfiguringHwInfoThenInformationIsCorrec
drm->storedSSVal = 6; drm->storedSSVal = 6;
ret = hwInfoConfig->configureHwInfoDrm(&pInHwInfo, &outHwInfo, osInterface); ret = productHelper.configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(0, ret); EXPECT_EQ(0, ret);
EXPECT_EQ((uint32_t)drm->storedEUVal, outHwInfo.gtSystemInfo.EUCount); EXPECT_EQ((uint32_t)drm->storedEUVal, outHwInfo.gtSystemInfo.EUCount);
EXPECT_EQ((uint32_t)drm->storedSSVal, outHwInfo.gtSystemInfo.SubSliceCount); EXPECT_EQ((uint32_t)drm->storedSSVal, outHwInfo.gtSystemInfo.SubSliceCount);
@@ -76,56 +76,56 @@ KBLTEST_F(HwInfoConfigTestLinuxKbl, WhenConfiguringHwInfoThenInformationIsCorrec
KBLTEST_F(HwInfoConfigTestLinuxKbl, GivenFailedIoctlEuCountWhenConfiguringHwInfoThenErrorIsReturned) { KBLTEST_F(HwInfoConfigTestLinuxKbl, GivenFailedIoctlEuCountWhenConfiguringHwInfoThenErrorIsReturned) {
drm->failRetTopology = true; drm->failRetTopology = true;
drm->storedRetValForEUVal = -4; drm->storedRetValForEUVal = -4;
auto hwInfoConfig = HwInfoConfig::get(productFamily); auto &productHelper = getHelper<ProductHelper>();
int ret = hwInfoConfig->configureHwInfoDrm(&pInHwInfo, &outHwInfo, osInterface); int ret = productHelper.configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(-4, ret); EXPECT_EQ(-4, ret);
} }
KBLTEST_F(HwInfoConfigTestLinuxKbl, GivenFailedIoctlSsCountWhenConfiguringHwInfoThenErrorIsReturned) { KBLTEST_F(HwInfoConfigTestLinuxKbl, GivenFailedIoctlSsCountWhenConfiguringHwInfoThenErrorIsReturned) {
drm->failRetTopology = true; drm->failRetTopology = true;
drm->storedRetValForSSVal = -5; drm->storedRetValForSSVal = -5;
auto hwInfoConfig = HwInfoConfig::get(productFamily); auto &productHelper = getHelper<ProductHelper>();
int ret = hwInfoConfig->configureHwInfoDrm(&pInHwInfo, &outHwInfo, osInterface); int ret = productHelper.configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(-5, ret); EXPECT_EQ(-5, ret);
} }
KBLTEST_F(HwInfoConfigTestLinuxKbl, GivenWaFlagsWhenConfiguringHwInfoThenInformationIsCorrect) { KBLTEST_F(HwInfoConfigTestLinuxKbl, GivenWaFlagsWhenConfiguringHwInfoThenInformationIsCorrect) {
auto hwInfoConfig = HwInfoConfig::get(productFamily); auto &productHelper = getHelper<ProductHelper>();
outHwInfo.platform.usRevId = 0; outHwInfo.platform.usRevId = 0;
int ret = hwInfoConfig->configureHwInfoDrm(&pInHwInfo, &outHwInfo, osInterface); int ret = productHelper.configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(0, ret); EXPECT_EQ(0, ret);
pInHwInfo.platform.usRevId = 7; pInHwInfo.platform.usRevId = 7;
ret = hwInfoConfig->configureHwInfoDrm(&pInHwInfo, &outHwInfo, osInterface); ret = productHelper.configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(0, ret); EXPECT_EQ(0, ret);
EXPECT_EQ(0u, outHwInfo.workaroundTable.flags.waDisableLSQCROPERFforOCL); EXPECT_EQ(0u, outHwInfo.workaroundTable.flags.waDisableLSQCROPERFforOCL);
EXPECT_EQ(0u, outHwInfo.workaroundTable.flags.waEncryptedEdramOnlyPartials); EXPECT_EQ(0u, outHwInfo.workaroundTable.flags.waEncryptedEdramOnlyPartials);
pInHwInfo.platform.usRevId = 9; pInHwInfo.platform.usRevId = 9;
ret = hwInfoConfig->configureHwInfoDrm(&pInHwInfo, &outHwInfo, osInterface); ret = productHelper.configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(0, ret); EXPECT_EQ(0, ret);
EXPECT_EQ(0u, outHwInfo.workaroundTable.flags.waDisableLSQCROPERFforOCL); EXPECT_EQ(0u, outHwInfo.workaroundTable.flags.waDisableLSQCROPERFforOCL);
EXPECT_EQ(0u, outHwInfo.workaroundTable.flags.waEncryptedEdramOnlyPartials); EXPECT_EQ(0u, outHwInfo.workaroundTable.flags.waEncryptedEdramOnlyPartials);
} }
KBLTEST_F(HwInfoConfigTestLinuxKbl, WhenConfiguringHwInfoThenEdramInformationIsCorrect) { KBLTEST_F(HwInfoConfigTestLinuxKbl, WhenConfiguringHwInfoThenEdramInformationIsCorrect) {
auto hwInfoConfig = HwInfoConfig::get(productFamily); auto &productHelper = getHelper<ProductHelper>();
int ret = hwInfoConfig->configureHwInfoDrm(&pInHwInfo, &outHwInfo, osInterface); int ret = productHelper.configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(0, ret); EXPECT_EQ(0, ret);
EXPECT_EQ_VAL(0u, outHwInfo.gtSystemInfo.EdramSizeInKb); EXPECT_EQ_VAL(0u, outHwInfo.gtSystemInfo.EdramSizeInKb);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrEDram); EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrEDram);
pInHwInfo.platform.usDeviceID = 0x5927; pInHwInfo.platform.usDeviceID = 0x5927;
ret = hwInfoConfig->configureHwInfoDrm(&pInHwInfo, &outHwInfo, osInterface); ret = productHelper.configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(0, ret); EXPECT_EQ(0, ret);
EXPECT_EQ_VAL((64u * 1024u), outHwInfo.gtSystemInfo.EdramSizeInKb); EXPECT_EQ_VAL((64u * 1024u), outHwInfo.gtSystemInfo.EdramSizeInKb);
EXPECT_EQ(1u, outHwInfo.featureTable.flags.ftrEDram); EXPECT_EQ(1u, outHwInfo.featureTable.flags.ftrEDram);
pInHwInfo.platform.usDeviceID = 0x5926; pInHwInfo.platform.usDeviceID = 0x5926;
ret = hwInfoConfig->configureHwInfoDrm(&pInHwInfo, &outHwInfo, osInterface); ret = productHelper.configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(0, ret); EXPECT_EQ(0, ret);
EXPECT_EQ_VAL((64u * 1024u), outHwInfo.gtSystemInfo.EdramSizeInKb); EXPECT_EQ_VAL((64u * 1024u), outHwInfo.gtSystemInfo.EdramSizeInKb);
EXPECT_EQ(1u, outHwInfo.featureTable.flags.ftrEDram); EXPECT_EQ(1u, outHwInfo.featureTable.flags.ftrEDram);

46
shared/test/unit_test/gen9/skl/linux/hw_info_config_tests_skl.cpp
View File

@@ -17,14 +17,14 @@ struct HwInfoConfigTestLinuxSkl : HwInfoConfigTestLinux {
}; };
SKLTEST_F(HwInfoConfigTestLinuxSkl, WhenConfiguringHwInfoThenInformationIsCorrect) { SKLTEST_F(HwInfoConfigTestLinuxSkl, WhenConfiguringHwInfoThenInformationIsCorrect) {
auto hwInfoConfig = HwInfoConfig::get(productFamily); auto &productHelper = getHelper<ProductHelper>();
int ret = hwInfoConfig->configureHwInfoDrm(&pInHwInfo, &outHwInfo, osInterface); int ret = productHelper.configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(0, ret); EXPECT_EQ(0, ret);
EXPECT_EQ((uint32_t)drm->storedEUVal, outHwInfo.gtSystemInfo.EUCount); EXPECT_EQ((uint32_t)drm->storedEUVal, outHwInfo.gtSystemInfo.EUCount);
EXPECT_EQ((uint32_t)drm->storedSSVal, outHwInfo.gtSystemInfo.SubSliceCount); EXPECT_EQ((uint32_t)drm->storedSSVal, outHwInfo.gtSystemInfo.SubSliceCount);
EXPECT_EQ(aub_stream::ENGINE_RCS, outHwInfo.capabilityTable.defaultEngineType); EXPECT_EQ(aub_stream::ENGINE_RCS, outHwInfo.capabilityTable.defaultEngineType);
//constant sysInfo/ftr flags // constant sysInfo/ftr flags
EXPECT_EQ(1u, outHwInfo.gtSystemInfo.VEBoxInfo.Instances.Bits.VEBox0Enabled); EXPECT_EQ(1u, outHwInfo.gtSystemInfo.VEBoxInfo.Instances.Bits.VEBox0Enabled);
EXPECT_EQ(1u, outHwInfo.gtSystemInfo.VDBoxInfo.Instances.Bits.VDBox0Enabled); EXPECT_EQ(1u, outHwInfo.gtSystemInfo.VDBoxInfo.Instances.Bits.VDBox0Enabled);
EXPECT_TRUE(outHwInfo.gtSystemInfo.VEBoxInfo.IsValid); EXPECT_TRUE(outHwInfo.gtSystemInfo.VEBoxInfo.IsValid);
@@ -33,7 +33,7 @@ SKLTEST_F(HwInfoConfigTestLinuxSkl, WhenConfiguringHwInfoThenInformationIsCorrec
pInHwInfo.platform.usDeviceID = 0x1902; pInHwInfo.platform.usDeviceID = 0x1902;
drm->storedSSVal = 3; drm->storedSSVal = 3;
ret = hwInfoConfig->configureHwInfoDrm(&pInHwInfo, &outHwInfo, osInterface); ret = productHelper.configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(0, ret); EXPECT_EQ(0, ret);
EXPECT_EQ((uint32_t)drm->storedEUVal, outHwInfo.gtSystemInfo.EUCount); EXPECT_EQ((uint32_t)drm->storedEUVal, outHwInfo.gtSystemInfo.EUCount);
EXPECT_EQ((uint32_t)drm->storedSSVal, outHwInfo.gtSystemInfo.SubSliceCount); EXPECT_EQ((uint32_t)drm->storedSSVal, outHwInfo.gtSystemInfo.SubSliceCount);
@@ -42,7 +42,7 @@ SKLTEST_F(HwInfoConfigTestLinuxSkl, WhenConfiguringHwInfoThenInformationIsCorrec
pInHwInfo.platform.usDeviceID = 0x1917; pInHwInfo.platform.usDeviceID = 0x1917;
ret = hwInfoConfig->configureHwInfoDrm(&pInHwInfo, &outHwInfo, osInterface); ret = productHelper.configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(0, ret); EXPECT_EQ(0, ret);
EXPECT_EQ((uint32_t)drm->storedEUVal, outHwInfo.gtSystemInfo.EUCount); EXPECT_EQ((uint32_t)drm->storedEUVal, outHwInfo.gtSystemInfo.EUCount);
EXPECT_EQ((uint32_t)drm->storedSSVal, outHwInfo.gtSystemInfo.SubSliceCount); EXPECT_EQ((uint32_t)drm->storedSSVal, outHwInfo.gtSystemInfo.SubSliceCount);
@@ -50,7 +50,7 @@ SKLTEST_F(HwInfoConfigTestLinuxSkl, WhenConfiguringHwInfoThenInformationIsCorrec
pInHwInfo.platform.usDeviceID = 0x0903; pInHwInfo.platform.usDeviceID = 0x0903;
ret = hwInfoConfig->configureHwInfoDrm(&pInHwInfo, &outHwInfo, osInterface); ret = productHelper.configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(0, ret); EXPECT_EQ(0, ret);
EXPECT_EQ((uint32_t)drm->storedEUVal, outHwInfo.gtSystemInfo.EUCount); EXPECT_EQ((uint32_t)drm->storedEUVal, outHwInfo.gtSystemInfo.EUCount);
EXPECT_EQ((uint32_t)drm->storedSSVal, outHwInfo.gtSystemInfo.SubSliceCount); EXPECT_EQ((uint32_t)drm->storedSSVal, outHwInfo.gtSystemInfo.SubSliceCount);
@@ -59,7 +59,7 @@ SKLTEST_F(HwInfoConfigTestLinuxSkl, WhenConfiguringHwInfoThenInformationIsCorrec
pInHwInfo.platform.usDeviceID = 0x0903; pInHwInfo.platform.usDeviceID = 0x0903;
drm->storedSSVal = 6; drm->storedSSVal = 6;
ret = hwInfoConfig->configureHwInfoDrm(&pInHwInfo, &outHwInfo, osInterface); ret = productHelper.configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(0, ret); EXPECT_EQ(0, ret);
EXPECT_EQ((uint32_t)drm->storedEUVal, outHwInfo.gtSystemInfo.EUCount); EXPECT_EQ((uint32_t)drm->storedEUVal, outHwInfo.gtSystemInfo.EUCount);
EXPECT_EQ((uint32_t)drm->storedSSVal, outHwInfo.gtSystemInfo.SubSliceCount); EXPECT_EQ((uint32_t)drm->storedSSVal, outHwInfo.gtSystemInfo.SubSliceCount);
@@ -80,40 +80,40 @@ SKLTEST_F(HwInfoConfigTestLinuxSkl, WhenConfiguringHwInfoThenInformationIsCorrec
SKLTEST_F(HwInfoConfigTestLinuxSkl, GivenFailedIoctlEuCountWhenConfiguringHwInfoThenErrorIsReturned) { SKLTEST_F(HwInfoConfigTestLinuxSkl, GivenFailedIoctlEuCountWhenConfiguringHwInfoThenErrorIsReturned) {
drm->storedRetValForEUVal = -4; drm->storedRetValForEUVal = -4;
drm->failRetTopology = true; drm->failRetTopology = true;
auto hwInfoConfig = HwInfoConfig::get(productFamily); auto &productHelper = getHelper<ProductHelper>();
int ret = hwInfoConfig->configureHwInfoDrm(&pInHwInfo, &outHwInfo, osInterface); int ret = productHelper.configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(-4, ret); EXPECT_EQ(-4, ret);
} }
SKLTEST_F(HwInfoConfigTestLinuxSkl, GivenFailedIoctlSsCountWhenConfiguringHwInfoThenErrorIsReturned) { SKLTEST_F(HwInfoConfigTestLinuxSkl, GivenFailedIoctlSsCountWhenConfiguringHwInfoThenErrorIsReturned) {
drm->storedRetValForSSVal = -5; drm->storedRetValForSSVal = -5;
drm->failRetTopology = true; drm->failRetTopology = true;
auto hwInfoConfig = HwInfoConfig::get(productFamily); auto &productHelper = getHelper<ProductHelper>();
int ret = hwInfoConfig->configureHwInfoDrm(&pInHwInfo, &outHwInfo, osInterface); int ret = productHelper.configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(-5, ret); EXPECT_EQ(-5, ret);
} }
SKLTEST_F(HwInfoConfigTestLinuxSkl, GivenWaFlagsWhenConfiguringHwInfoThenInformationIsCorrect) { SKLTEST_F(HwInfoConfigTestLinuxSkl, GivenWaFlagsWhenConfiguringHwInfoThenInformationIsCorrect) {
auto hwInfoConfig = HwInfoConfig::get(productFamily); auto &productHelper = getHelper<ProductHelper>();
pInHwInfo.platform.usRevId = 1; pInHwInfo.platform.usRevId = 1;
int ret = hwInfoConfig->configureHwInfoDrm(&pInHwInfo, &outHwInfo, osInterface); int ret = productHelper.configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(0, ret); EXPECT_EQ(0, ret);
pInHwInfo.platform.usRevId = 0; pInHwInfo.platform.usRevId = 0;
ret = hwInfoConfig->configureHwInfoDrm(&pInHwInfo, &outHwInfo, osInterface); ret = productHelper.configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(0, ret); EXPECT_EQ(0, ret);
EXPECT_EQ(0u, outHwInfo.workaroundTable.flags.waCompressedResourceRequiresConstVA21); EXPECT_EQ(0u, outHwInfo.workaroundTable.flags.waCompressedResourceRequiresConstVA21);
pInHwInfo.platform.usRevId = 5; pInHwInfo.platform.usRevId = 5;
ret = hwInfoConfig->configureHwInfoDrm(&pInHwInfo, &outHwInfo, osInterface); ret = productHelper.configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(0, ret); EXPECT_EQ(0, ret);
EXPECT_EQ(0u, outHwInfo.workaroundTable.flags.waCompressedResourceRequiresConstVA21); EXPECT_EQ(0u, outHwInfo.workaroundTable.flags.waCompressedResourceRequiresConstVA21);
EXPECT_EQ(0u, outHwInfo.workaroundTable.flags.waModifyVFEStateAfterGPGPUPreemption); EXPECT_EQ(0u, outHwInfo.workaroundTable.flags.waModifyVFEStateAfterGPGPUPreemption);
EXPECT_EQ(0u, outHwInfo.workaroundTable.flags.waDisablePerCtxtPreemptionGranularityControl); EXPECT_EQ(0u, outHwInfo.workaroundTable.flags.waDisablePerCtxtPreemptionGranularityControl);
pInHwInfo.platform.usRevId = 6; pInHwInfo.platform.usRevId = 6;
ret = hwInfoConfig->configureHwInfoDrm(&pInHwInfo, &outHwInfo, osInterface); ret = productHelper.configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(0, ret); EXPECT_EQ(0, ret);
EXPECT_EQ(0u, outHwInfo.workaroundTable.flags.waCompressedResourceRequiresConstVA21); EXPECT_EQ(0u, outHwInfo.workaroundTable.flags.waCompressedResourceRequiresConstVA21);
EXPECT_EQ(0u, outHwInfo.workaroundTable.flags.waModifyVFEStateAfterGPGPUPreemption); EXPECT_EQ(0u, outHwInfo.workaroundTable.flags.waModifyVFEStateAfterGPGPUPreemption);
@@ -122,41 +122,41 @@ SKLTEST_F(HwInfoConfigTestLinuxSkl, GivenWaFlagsWhenConfiguringHwInfoThenInforma
} }
SKLTEST_F(HwInfoConfigTestLinuxSkl, WhenConfiguringHwInfoThenEdramInformationIsCorrect) { SKLTEST_F(HwInfoConfigTestLinuxSkl, WhenConfiguringHwInfoThenEdramInformationIsCorrect) {
auto hwInfoConfig = HwInfoConfig::get(productFamily); auto &productHelper = getHelper<ProductHelper>();
int ret = hwInfoConfig->configureHwInfoDrm(&pInHwInfo, &outHwInfo, osInterface); int ret = productHelper.configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(0, ret); EXPECT_EQ(0, ret);
EXPECT_EQ_VAL(0u, outHwInfo.gtSystemInfo.EdramSizeInKb); EXPECT_EQ_VAL(0u, outHwInfo.gtSystemInfo.EdramSizeInKb);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrEDram); EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrEDram);
pInHwInfo.platform.usDeviceID = 0x1926; pInHwInfo.platform.usDeviceID = 0x1926;
ret = hwInfoConfig->configureHwInfoDrm(&pInHwInfo, &outHwInfo, osInterface); ret = productHelper.configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(0, ret); EXPECT_EQ(0, ret);
EXPECT_EQ_VAL((64u * 1024u), outHwInfo.gtSystemInfo.EdramSizeInKb); EXPECT_EQ_VAL((64u * 1024u), outHwInfo.gtSystemInfo.EdramSizeInKb);
EXPECT_EQ(1u, outHwInfo.featureTable.flags.ftrEDram); EXPECT_EQ(1u, outHwInfo.featureTable.flags.ftrEDram);
pInHwInfo.platform.usDeviceID = 0x1927; pInHwInfo.platform.usDeviceID = 0x1927;
ret = hwInfoConfig->configureHwInfoDrm(&pInHwInfo, &outHwInfo, osInterface); ret = productHelper.configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(0, ret); EXPECT_EQ(0, ret);
EXPECT_EQ_VAL((64u * 1024u), outHwInfo.gtSystemInfo.EdramSizeInKb); EXPECT_EQ_VAL((64u * 1024u), outHwInfo.gtSystemInfo.EdramSizeInKb);
EXPECT_EQ(1u, outHwInfo.featureTable.flags.ftrEDram); EXPECT_EQ(1u, outHwInfo.featureTable.flags.ftrEDram);
pInHwInfo.platform.usDeviceID = 0x192D; pInHwInfo.platform.usDeviceID = 0x192D;
ret = hwInfoConfig->configureHwInfoDrm(&pInHwInfo, &outHwInfo, osInterface); ret = productHelper.configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(0, ret); EXPECT_EQ(0, ret);
EXPECT_EQ_VAL((64u * 1024u), outHwInfo.gtSystemInfo.EdramSizeInKb); EXPECT_EQ_VAL((64u * 1024u), outHwInfo.gtSystemInfo.EdramSizeInKb);
EXPECT_EQ(1u, outHwInfo.featureTable.flags.ftrEDram); EXPECT_EQ(1u, outHwInfo.featureTable.flags.ftrEDram);
pInHwInfo.platform.usDeviceID = 0x193B; pInHwInfo.platform.usDeviceID = 0x193B;
ret = hwInfoConfig->configureHwInfoDrm(&pInHwInfo, &outHwInfo, osInterface); ret = productHelper.configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(0, ret); EXPECT_EQ(0, ret);
EXPECT_EQ_VAL((128u * 1024u), outHwInfo.gtSystemInfo.EdramSizeInKb); EXPECT_EQ_VAL((128u * 1024u), outHwInfo.gtSystemInfo.EdramSizeInKb);
EXPECT_EQ(1u, outHwInfo.featureTable.flags.ftrEDram); EXPECT_EQ(1u, outHwInfo.featureTable.flags.ftrEDram);
pInHwInfo.platform.usDeviceID = 0x193D; pInHwInfo.platform.usDeviceID = 0x193D;
ret = hwInfoConfig->configureHwInfoDrm(&pInHwInfo, &outHwInfo, osInterface); ret = productHelper.configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(0, ret); EXPECT_EQ(0, ret);
EXPECT_EQ_VAL((128u * 1024u), outHwInfo.gtSystemInfo.EdramSizeInKb); EXPECT_EQ_VAL((128u * 1024u), outHwInfo.gtSystemInfo.EdramSizeInKb);
EXPECT_EQ(1u, outHwInfo.featureTable.flags.ftrEDram); EXPECT_EQ(1u, outHwInfo.featureTable.flags.ftrEDram);

4
shared/test/unit_test/helpers/hw_helper_tests.cpp
View File

@@ -815,8 +815,8 @@ HWCMDTEST_F(IGFX_GEN8_CORE, HwHelperTest, givenVariousCachesRequestThenCorrectMo
} }
HWTEST_F(HwHelperTest, whenQueryingMaxNumSamplersThenReturnSixteen) { HWTEST_F(HwHelperTest, whenQueryingMaxNumSamplersThenReturnSixteen) {
auto &helper = HwHelper::get(renderCoreFamily); auto &coreHelper = getHelper<CoreHelper>();
EXPECT_EQ(16u, helper.getMaxNumSamplers()); EXPECT_EQ(16u, coreHelper.getMaxNumSamplers());
} }
HWTEST_F(HwHelperTest, givenDebugVariableSetWhenAskingForAuxTranslationModeThenReturnCorrectValue) { HWTEST_F(HwHelperTest, givenDebugVariableSetWhenAskingForAuxTranslationModeThenReturnCorrectValue) {

4
shared/test/unit_test/helpers/hw_helper_tests_pvc_and_later.cpp
View File

@@ -37,8 +37,8 @@ HWTEST2_F(HwHelperTestPvcAndLater, givenVariousCachesRequestsThenProperMocsIndex
HWTEST2_F(HwHelperTestPvcAndLater, givenRenderEngineWhenRemapCalledThenUseCccs, IsAtLeastXeHpcCore) { HWTEST2_F(HwHelperTestPvcAndLater, givenRenderEngineWhenRemapCalledThenUseCccs, IsAtLeastXeHpcCore) {
hardwareInfo.featureTable.flags.ftrCCSNode = false; hardwareInfo.featureTable.flags.ftrCCSNode = false;
auto &helper = HwHelper::get(renderCoreFamily); auto &coreHelper = getHelper<CoreHelper>();
helper.adjustDefaultEngineType(&hardwareInfo); coreHelper.adjustDefaultEngineType(&hardwareInfo);
EXPECT_EQ(aub_stream::EngineType::ENGINE_CCCS, EngineHelpers::remapEngineTypeToHwSpecific(aub_stream::EngineType::ENGINE_RCS, hardwareInfo)); EXPECT_EQ(aub_stream::EngineType::ENGINE_CCCS, EngineHelpers::remapEngineTypeToHwSpecific(aub_stream::EngineType::ENGINE_RCS, hardwareInfo));
EXPECT_EQ(aub_stream::EngineType::ENGINE_CCCS, EngineHelpers::remapEngineTypeToHwSpecific(aub_stream::EngineType::ENGINE_CCCS, hardwareInfo)); EXPECT_EQ(aub_stream::EngineType::ENGINE_CCCS, EngineHelpers::remapEngineTypeToHwSpecific(aub_stream::EngineType::ENGINE_CCCS, hardwareInfo));

7
shared/test/unit_test/os_interface/linux/drm_query_tests.cpp
View File

@@ -26,7 +26,8 @@ HWTEST2_F(HwConfigTopologyQuery, WhenGettingTopologyFailsThenSetMaxValuesBasedOn
auto drm = new DrmMock(*executionEnvironment->rootDeviceEnvironments[0]); auto drm = new DrmMock(*executionEnvironment->rootDeviceEnvironments[0]);
auto osInterface = std::make_unique<OSInterface>(); executionEnvironment->rootDeviceEnvironments[0]->osInterface = std::make_unique<OSInterface>();
auto osInterface = executionEnvironment->rootDeviceEnvironments[0]->osInterface.get();
osInterface->setDriverModel(std::unique_ptr<Drm>(drm)); osInterface->setDriverModel(std::unique_ptr<Drm>(drm));
drm->failRetTopology = true; drm->failRetTopology = true;
@@ -38,8 +39,8 @@ HWTEST2_F(HwConfigTopologyQuery, WhenGettingTopologyFailsThenSetMaxValuesBasedOn
hwInfo.gtSystemInfo.MaxSubSlicesSupported = 0; hwInfo.gtSystemInfo.MaxSubSlicesSupported = 0;
hwInfo.gtSystemInfo.MaxEuPerSubSlice = 6; hwInfo.gtSystemInfo.MaxEuPerSubSlice = 6;
auto hwConfig = HwInfoConfigHw<productFamily>::get(); auto &productHelper = executionEnvironment->rootDeviceEnvironments[0]->getHelper<ProductHelper>();
int ret = hwConfig->configureHwInfoDrm(&hwInfo, &outHwInfo, osInterface.get()); int ret = productHelper.configureHwInfoDrm(&hwInfo, &outHwInfo, *executionEnvironment->rootDeviceEnvironments[0].get());
EXPECT_NE(-1, ret); EXPECT_NE(-1, ret);
EXPECT_EQ(6u, outHwInfo.gtSystemInfo.MaxEuPerSubSlice); EXPECT_EQ(6u, outHwInfo.gtSystemInfo.MaxEuPerSubSlice);

73
shared/test/unit_test/os_interface/linux/hw_info_config_linux_tests.cpp
View File

@@ -36,7 +36,7 @@ struct HwInfoConfigTestLinuxDummy : HwInfoConfigTestLinux {
}; };
TEST_F(HwInfoConfigTestLinuxDummy, GivenDummyConfigWhenConfiguringHwInfoThenSucceeds) { TEST_F(HwInfoConfigTestLinuxDummy, GivenDummyConfigWhenConfiguringHwInfoThenSucceeds) {
int ret = hwConfig.configureHwInfoDrm(&pInHwInfo, &outHwInfo, osInterface); int ret = hwConfig.configureHwInfoDrm(&pInHwInfo, &outHwInfo, *executionEnvironment->rootDeviceEnvironments[0].get());
EXPECT_EQ(0, ret); EXPECT_EQ(0, ret);
} }
@@ -58,19 +58,19 @@ HWTEST2_F(HwInfoConfigTestLinuxDummy, givenUnsupportedChipsetUniqueUUIDWhenGetti
TEST_F(HwInfoConfigTestLinuxDummy, GivenDummyConfigThenEdramIsDetected) { TEST_F(HwInfoConfigTestLinuxDummy, GivenDummyConfigThenEdramIsDetected) {
hwConfig.use128MbEdram = true; hwConfig.use128MbEdram = true;
int ret = hwConfig.configureHwInfoDrm(&pInHwInfo, &outHwInfo, osInterface); int ret = hwConfig.configureHwInfoDrm(&pInHwInfo, &outHwInfo, *executionEnvironment->rootDeviceEnvironments[0].get());
EXPECT_EQ(0, ret); EXPECT_EQ(0, ret);
EXPECT_EQ(1u, outHwInfo.featureTable.flags.ftrEDram); EXPECT_EQ(1u, outHwInfo.featureTable.flags.ftrEDram);
} }
TEST_F(HwInfoConfigTestLinuxDummy, givenEnabledPlatformCoherencyWhenConfiguringHwInfoThenIgnoreAndSetAsDisabled) { TEST_F(HwInfoConfigTestLinuxDummy, givenEnabledPlatformCoherencyWhenConfiguringHwInfoThenIgnoreAndSetAsDisabled) {
int ret = hwConfig.configureHwInfoDrm(&pInHwInfo, &outHwInfo, osInterface); int ret = hwConfig.configureHwInfoDrm(&pInHwInfo, &outHwInfo, *executionEnvironment->rootDeviceEnvironments[0].get());
EXPECT_EQ(0, ret); EXPECT_EQ(0, ret);
EXPECT_FALSE(outHwInfo.capabilityTable.ftrSupportsCoherency); EXPECT_FALSE(outHwInfo.capabilityTable.ftrSupportsCoherency);
} }
TEST_F(HwInfoConfigTestLinuxDummy, givenDisabledPlatformCoherencyWhenConfiguringHwInfoThenSetValidCapability) { TEST_F(HwInfoConfigTestLinuxDummy, givenDisabledPlatformCoherencyWhenConfiguringHwInfoThenSetValidCapability) {
int ret = hwConfig.configureHwInfoDrm(&pInHwInfo, &outHwInfo, osInterface); int ret = hwConfig.configureHwInfoDrm(&pInHwInfo, &outHwInfo, *executionEnvironment->rootDeviceEnvironments[0].get());
EXPECT_EQ(0, ret); EXPECT_EQ(0, ret);
EXPECT_FALSE(outHwInfo.capabilityTable.ftrSupportsCoherency); EXPECT_FALSE(outHwInfo.capabilityTable.ftrSupportsCoherency);
} }
@@ -79,7 +79,7 @@ TEST_F(HwInfoConfigTestLinuxDummy, GivenFailGetEuCountWhenConfiguringHwInfoThenF
drm->storedRetValForEUVal = -4; drm->storedRetValForEUVal = -4;
drm->failRetTopology = true; drm->failRetTopology = true;
int ret = hwConfig.configureHwInfoDrm(&pInHwInfo, &outHwInfo, osInterface); int ret = hwConfig.configureHwInfoDrm(&pInHwInfo, &outHwInfo, *executionEnvironment->rootDeviceEnvironments[0].get());
EXPECT_EQ(-4, ret); EXPECT_EQ(-4, ret);
} }
@@ -87,14 +87,14 @@ TEST_F(HwInfoConfigTestLinuxDummy, GivenFailGetSsCountWhenConfiguringHwInfoThenF
drm->storedRetValForSSVal = -5; drm->storedRetValForSSVal = -5;
drm->failRetTopology = true; drm->failRetTopology = true;
int ret = hwConfig.configureHwInfoDrm(&pInHwInfo, &outHwInfo, osInterface); int ret = hwConfig.configureHwInfoDrm(&pInHwInfo, &outHwInfo, *executionEnvironment->rootDeviceEnvironments[0].get());
EXPECT_EQ(-5, ret); EXPECT_EQ(-5, ret);
} }
TEST_F(HwInfoConfigTestLinuxDummy, whenFailGettingTopologyThenFallbackToEuCountIoctl) { TEST_F(HwInfoConfigTestLinuxDummy, whenFailGettingTopologyThenFallbackToEuCountIoctl) {
drm->failRetTopology = true; drm->failRetTopology = true;
int ret = hwConfig.configureHwInfoDrm(&pInHwInfo, &outHwInfo, osInterface); int ret = hwConfig.configureHwInfoDrm(&pInHwInfo, &outHwInfo, *executionEnvironment->rootDeviceEnvironments[0].get());
EXPECT_NE(-1, ret); EXPECT_NE(-1, ret);
} }
@@ -137,19 +137,19 @@ TEST_F(HwInfoConfigTestLinuxDummy, givenInvalidTopologyDataWhenConfiguringThenRe
TEST_F(HwInfoConfigTestLinuxDummy, GivenFailingCustomConfigWhenConfiguringHwInfoThenFails) { TEST_F(HwInfoConfigTestLinuxDummy, GivenFailingCustomConfigWhenConfiguringHwInfoThenFails) {
hwConfig.failOnConfigureHardwareCustom = true; hwConfig.failOnConfigureHardwareCustom = true;
int ret = hwConfig.configureHwInfoDrm(&pInHwInfo, &outHwInfo, osInterface); int ret = hwConfig.configureHwInfoDrm(&pInHwInfo, &outHwInfo, *executionEnvironment->rootDeviceEnvironments[0].get());
EXPECT_EQ(-1, ret); EXPECT_EQ(-1, ret);
} }
TEST_F(HwInfoConfigTestLinuxDummy, whenConfigureHwInfoIsCalledThenAreNonPersistentContextsSupportedReturnsTrue) { TEST_F(HwInfoConfigTestLinuxDummy, whenConfigureHwInfoIsCalledThenAreNonPersistentContextsSupportedReturnsTrue) {
int ret = hwConfig.configureHwInfoDrm(&pInHwInfo, &outHwInfo, osInterface); int ret = hwConfig.configureHwInfoDrm(&pInHwInfo, &outHwInfo, *executionEnvironment->rootDeviceEnvironments[0].get());
EXPECT_EQ(0, ret); EXPECT_EQ(0, ret);
EXPECT_TRUE(drm->areNonPersistentContextsSupported()); EXPECT_TRUE(drm->areNonPersistentContextsSupported());
} }
TEST_F(HwInfoConfigTestLinuxDummy, whenConfigureHwInfoIsCalledAndPersitentContextIsUnsupportedThenAreNonPersistentContextsSupportedReturnsFalse) { TEST_F(HwInfoConfigTestLinuxDummy, whenConfigureHwInfoIsCalledAndPersitentContextIsUnsupportedThenAreNonPersistentContextsSupportedReturnsFalse) {
drm->storedPersistentContextsSupport = 0; drm->storedPersistentContextsSupport = 0;
int ret = hwConfig.configureHwInfoDrm(&pInHwInfo, &outHwInfo, osInterface); int ret = hwConfig.configureHwInfoDrm(&pInHwInfo, &outHwInfo, *executionEnvironment->rootDeviceEnvironments[0].get());
EXPECT_EQ(0, ret); EXPECT_EQ(0, ret);
EXPECT_FALSE(drm->areNonPersistentContextsSupported()); EXPECT_FALSE(drm->areNonPersistentContextsSupported());
} }
@@ -165,7 +165,7 @@ HWTEST_F(HwInfoConfigTestLinuxDummy, GivenPreemptionDrmEnabledMidThreadOnWhenCon
UnitTestHelper<FamilyType>::setExtraMidThreadPreemptionFlag(pInHwInfo, true); UnitTestHelper<FamilyType>::setExtraMidThreadPreemptionFlag(pInHwInfo, true);
int ret = hwConfig.configureHwInfoDrm(&pInHwInfo, &outHwInfo, osInterface); int ret = hwConfig.configureHwInfoDrm(&pInHwInfo, &outHwInfo, *executionEnvironment->rootDeviceEnvironments[0].get());
EXPECT_EQ(0, ret); EXPECT_EQ(0, ret);
EXPECT_EQ(PreemptionMode::MidThread, outHwInfo.capabilityTable.defaultPreemptionMode); EXPECT_EQ(PreemptionMode::MidThread, outHwInfo.capabilityTable.defaultPreemptionMode);
EXPECT_TRUE(drm->isPreemptionSupported()); EXPECT_TRUE(drm->isPreemptionSupported());
@@ -178,7 +178,7 @@ TEST_F(HwInfoConfigTestLinuxDummy, GivenPreemptionDrmEnabledThreadGroupOnWhenCon
I915_SCHEDULER_CAP_PRIORITY | I915_SCHEDULER_CAP_PRIORITY |
I915_SCHEDULER_CAP_PREEMPTION; I915_SCHEDULER_CAP_PREEMPTION;
hwConfig.enableThreadGroupPreemption = true; hwConfig.enableThreadGroupPreemption = true;
int ret = hwConfig.configureHwInfoDrm(&pInHwInfo, &outHwInfo, osInterface); int ret = hwConfig.configureHwInfoDrm(&pInHwInfo, &outHwInfo, *executionEnvironment->rootDeviceEnvironments[0].get());
EXPECT_EQ(0, ret); EXPECT_EQ(0, ret);
EXPECT_EQ(PreemptionMode::ThreadGroup, outHwInfo.capabilityTable.defaultPreemptionMode); EXPECT_EQ(PreemptionMode::ThreadGroup, outHwInfo.capabilityTable.defaultPreemptionMode);
EXPECT_TRUE(drm->isPreemptionSupported()); EXPECT_TRUE(drm->isPreemptionSupported());
@@ -189,7 +189,7 @@ TEST_F(HwInfoConfigTestLinuxDummy, givenDebugFlagSetWhenConfiguringHwInfoThenPri
DebugManager.flags.PrintIoctlEntries.set(true); DebugManager.flags.PrintIoctlEntries.set(true);
testing::internal::CaptureStdout(); // start capturing testing::internal::CaptureStdout(); // start capturing
int ret = hwConfig.configureHwInfoDrm(&pInHwInfo, &outHwInfo, osInterface); int ret = hwConfig.configureHwInfoDrm(&pInHwInfo, &outHwInfo, *executionEnvironment->rootDeviceEnvironments[0].get());
EXPECT_EQ(0, ret); EXPECT_EQ(0, ret);
std::array<std::string, 1> expectedStrings = {{"DRM_IOCTL_I915_GETPARAM: param: I915_PARAM_HAS_SCHEDULER, output value: 7, retCode: 0" std::array<std::string, 1> expectedStrings = {{"DRM_IOCTL_I915_GETPARAM: param: I915_PARAM_HAS_SCHEDULER, output value: 7, retCode: 0"
@@ -212,7 +212,7 @@ TEST_F(HwInfoConfigTestLinuxDummy, GivenPreemptionDrmEnabledMidBatchOnWhenConfig
I915_SCHEDULER_CAP_PRIORITY | I915_SCHEDULER_CAP_PRIORITY |
I915_SCHEDULER_CAP_PREEMPTION; I915_SCHEDULER_CAP_PREEMPTION;
hwConfig.enableMidBatchPreemption = true; hwConfig.enableMidBatchPreemption = true;
int ret = hwConfig.configureHwInfoDrm(&pInHwInfo, &outHwInfo, osInterface); int ret = hwConfig.configureHwInfoDrm(&pInHwInfo, &outHwInfo, *executionEnvironment->rootDeviceEnvironments[0].get());
EXPECT_EQ(0, ret); EXPECT_EQ(0, ret);
EXPECT_EQ(PreemptionMode::MidBatch, outHwInfo.capabilityTable.defaultPreemptionMode); EXPECT_EQ(PreemptionMode::MidBatch, outHwInfo.capabilityTable.defaultPreemptionMode);
EXPECT_TRUE(drm->isPreemptionSupported()); EXPECT_TRUE(drm->isPreemptionSupported());
@@ -224,7 +224,7 @@ TEST_F(HwInfoConfigTestLinuxDummy, WhenConfiguringHwInfoThenPreemptionIsSupporte
I915_SCHEDULER_CAP_ENABLED | I915_SCHEDULER_CAP_ENABLED |
I915_SCHEDULER_CAP_PRIORITY | I915_SCHEDULER_CAP_PRIORITY |
I915_SCHEDULER_CAP_PREEMPTION; I915_SCHEDULER_CAP_PREEMPTION;
int ret = hwConfig.configureHwInfoDrm(&pInHwInfo, &outHwInfo, osInterface); int ret = hwConfig.configureHwInfoDrm(&pInHwInfo, &outHwInfo, *executionEnvironment->rootDeviceEnvironments[0].get());
EXPECT_EQ(0, ret); EXPECT_EQ(0, ret);
EXPECT_EQ(PreemptionMode::Disabled, outHwInfo.capabilityTable.defaultPreemptionMode); EXPECT_EQ(PreemptionMode::Disabled, outHwInfo.capabilityTable.defaultPreemptionMode);
EXPECT_TRUE(drm->isPreemptionSupported()); EXPECT_TRUE(drm->isPreemptionSupported());
@@ -236,7 +236,7 @@ TEST_F(HwInfoConfigTestLinuxDummy, GivenPreemptionDrmDisabledAllPreemptionWhenCo
hwConfig.enableMidThreadPreemption = true; hwConfig.enableMidThreadPreemption = true;
hwConfig.enableMidBatchPreemption = true; hwConfig.enableMidBatchPreemption = true;
hwConfig.enableThreadGroupPreemption = true; hwConfig.enableThreadGroupPreemption = true;
int ret = hwConfig.configureHwInfoDrm(&pInHwInfo, &outHwInfo, osInterface); int ret = hwConfig.configureHwInfoDrm(&pInHwInfo, &outHwInfo, *executionEnvironment->rootDeviceEnvironments[0].get());
hwConfig.enableMidThreadPreemption = true; hwConfig.enableMidThreadPreemption = true;
EXPECT_EQ(0, ret); EXPECT_EQ(0, ret);
EXPECT_EQ(PreemptionMode::Disabled, outHwInfo.capabilityTable.defaultPreemptionMode); EXPECT_EQ(PreemptionMode::Disabled, outHwInfo.capabilityTable.defaultPreemptionMode);
@@ -252,7 +252,7 @@ TEST_F(HwInfoConfigTestLinuxDummy, GivenPreemptionDrmEnabledAllPreemptionDriverT
hwConfig.enableMidBatchPreemption = true; hwConfig.enableMidBatchPreemption = true;
hwConfig.enableThreadGroupPreemption = true; hwConfig.enableThreadGroupPreemption = true;
hwConfig.enableMidThreadPreemption = true; hwConfig.enableMidThreadPreemption = true;
int ret = hwConfig.configureHwInfoDrm(&pInHwInfo, &outHwInfo, osInterface); int ret = hwConfig.configureHwInfoDrm(&pInHwInfo, &outHwInfo, *executionEnvironment->rootDeviceEnvironments[0].get());
EXPECT_EQ(0, ret); EXPECT_EQ(0, ret);
EXPECT_EQ(PreemptionMode::ThreadGroup, outHwInfo.capabilityTable.defaultPreemptionMode); EXPECT_EQ(PreemptionMode::ThreadGroup, outHwInfo.capabilityTable.defaultPreemptionMode);
EXPECT_TRUE(drm->isPreemptionSupported()); EXPECT_TRUE(drm->isPreemptionSupported());
@@ -267,7 +267,7 @@ TEST_F(HwInfoConfigTestLinuxDummy, GivenPreemptionDrmEnabledAllPreemptionDriverM
hwConfig.enableMidBatchPreemption = true; hwConfig.enableMidBatchPreemption = true;
hwConfig.enableThreadGroupPreemption = true; hwConfig.enableThreadGroupPreemption = true;
hwConfig.enableMidThreadPreemption = true; hwConfig.enableMidThreadPreemption = true;
int ret = hwConfig.configureHwInfoDrm(&pInHwInfo, &outHwInfo, osInterface); int ret = hwConfig.configureHwInfoDrm(&pInHwInfo, &outHwInfo, *executionEnvironment->rootDeviceEnvironments[0].get());
EXPECT_EQ(0, ret); EXPECT_EQ(0, ret);
EXPECT_EQ(PreemptionMode::MidBatch, outHwInfo.capabilityTable.defaultPreemptionMode); EXPECT_EQ(PreemptionMode::MidBatch, outHwInfo.capabilityTable.defaultPreemptionMode);
EXPECT_TRUE(drm->isPreemptionSupported()); EXPECT_TRUE(drm->isPreemptionSupported());
@@ -282,7 +282,7 @@ TEST_F(HwInfoConfigTestLinuxDummy, GivenConfigPreemptionDrmEnabledAllPreemptionD
hwConfig.enableMidBatchPreemption = true; hwConfig.enableMidBatchPreemption = true;
hwConfig.enableThreadGroupPreemption = true; hwConfig.enableThreadGroupPreemption = true;
hwConfig.enableMidThreadPreemption = true; hwConfig.enableMidThreadPreemption = true;
int ret = hwConfig.configureHwInfoDrm(&pInHwInfo, &outHwInfo, osInterface); int ret = hwConfig.configureHwInfoDrm(&pInHwInfo, &outHwInfo, *executionEnvironment->rootDeviceEnvironments[0].get());
EXPECT_EQ(0, ret); EXPECT_EQ(0, ret);
EXPECT_EQ(PreemptionMode::Disabled, outHwInfo.capabilityTable.defaultPreemptionMode); EXPECT_EQ(PreemptionMode::Disabled, outHwInfo.capabilityTable.defaultPreemptionMode);
EXPECT_TRUE(drm->isPreemptionSupported()); EXPECT_TRUE(drm->isPreemptionSupported());
@@ -291,7 +291,7 @@ TEST_F(HwInfoConfigTestLinuxDummy, GivenConfigPreemptionDrmEnabledAllPreemptionD
TEST_F(HwInfoConfigTestLinuxDummy, givenPlatformEnabledFtrCompressionWhenInitializingThenFlagsAreSet) { TEST_F(HwInfoConfigTestLinuxDummy, givenPlatformEnabledFtrCompressionWhenInitializingThenFlagsAreSet) {
pInHwInfo.capabilityTable.ftrRenderCompressedImages = true; pInHwInfo.capabilityTable.ftrRenderCompressedImages = true;
pInHwInfo.capabilityTable.ftrRenderCompressedBuffers = true; pInHwInfo.capabilityTable.ftrRenderCompressedBuffers = true;
int ret = hwConfig.configureHwInfoDrm(&pInHwInfo, &outHwInfo, osInterface); int ret = hwConfig.configureHwInfoDrm(&pInHwInfo, &outHwInfo, *executionEnvironment->rootDeviceEnvironments[0].get());
EXPECT_EQ(0, ret); EXPECT_EQ(0, ret);
EXPECT_TRUE(outHwInfo.capabilityTable.ftrRenderCompressedImages); EXPECT_TRUE(outHwInfo.capabilityTable.ftrRenderCompressedImages);
EXPECT_TRUE(outHwInfo.capabilityTable.ftrRenderCompressedBuffers); EXPECT_TRUE(outHwInfo.capabilityTable.ftrRenderCompressedBuffers);
@@ -299,7 +299,7 @@ TEST_F(HwInfoConfigTestLinuxDummy, givenPlatformEnabledFtrCompressionWhenInitial
TEST_F(HwInfoConfigTestLinuxDummy, givenPointerToHwInfoWhenConfigureHwInfoCalledThenRequiedSurfaceSizeIsSettedProperly) { TEST_F(HwInfoConfigTestLinuxDummy, givenPointerToHwInfoWhenConfigureHwInfoCalledThenRequiedSurfaceSizeIsSettedProperly) {
EXPECT_EQ(MemoryConstants::pageSize, pInHwInfo.capabilityTable.requiredPreemptionSurfaceSize); EXPECT_EQ(MemoryConstants::pageSize, pInHwInfo.capabilityTable.requiredPreemptionSurfaceSize);
int ret = hwConfig.configureHwInfoDrm(&pInHwInfo, &outHwInfo, osInterface); int ret = hwConfig.configureHwInfoDrm(&pInHwInfo, &outHwInfo, *executionEnvironment->rootDeviceEnvironments[0].get());
EXPECT_EQ(0, ret); EXPECT_EQ(0, ret);
auto expectedSize = static_cast<size_t>(outHwInfo.gtSystemInfo.CsrSizeInMb * MemoryConstants::megaByte); auto expectedSize = static_cast<size_t>(outHwInfo.gtSystemInfo.CsrSizeInMb * MemoryConstants::megaByte);
HwHelper::get(outHwInfo.platform.eRenderCoreFamily).adjustPreemptionSurfaceSize(expectedSize); HwHelper::get(outHwInfo.platform.eRenderCoreFamily).adjustPreemptionSurfaceSize(expectedSize);
@@ -310,38 +310,38 @@ TEST_F(HwInfoConfigTestLinuxDummy, givenInstrumentationForHardwareIsEnabledOrDis
int ret; int ret;
pInHwInfo.capabilityTable.instrumentationEnabled = false; pInHwInfo.capabilityTable.instrumentationEnabled = false;
ret = hwConfig.configureHwInfoDrm(&pInHwInfo, &outHwInfo, osInterface); ret = hwConfig.configureHwInfoDrm(&pInHwInfo, &outHwInfo, *executionEnvironment->rootDeviceEnvironments[0].get());
ASSERT_EQ(0, ret); ASSERT_EQ(0, ret);
EXPECT_FALSE(outHwInfo.capabilityTable.instrumentationEnabled); EXPECT_FALSE(outHwInfo.capabilityTable.instrumentationEnabled);
pInHwInfo.capabilityTable.instrumentationEnabled = true; pInHwInfo.capabilityTable.instrumentationEnabled = true;
ret = hwConfig.configureHwInfoDrm(&pInHwInfo, &outHwInfo, osInterface); ret = hwConfig.configureHwInfoDrm(&pInHwInfo, &outHwInfo, *executionEnvironment->rootDeviceEnvironments[0].get());
ASSERT_EQ(0, ret); ASSERT_EQ(0, ret);
EXPECT_TRUE(outHwInfo.capabilityTable.instrumentationEnabled); EXPECT_TRUE(outHwInfo.capabilityTable.instrumentationEnabled);
} }
TEST_F(HwInfoConfigTestLinuxDummy, givenGttSizeReturnedWhenInitializingHwInfoThenSetSvmFtr) { TEST_F(HwInfoConfigTestLinuxDummy, givenGttSizeReturnedWhenInitializingHwInfoThenSetSvmFtr) {
drm->storedGTTSize = MemoryConstants::max64BitAppAddress; drm->storedGTTSize = MemoryConstants::max64BitAppAddress;
int ret = hwConfig.configureHwInfoDrm(&pInHwInfo, &outHwInfo, osInterface); int ret = hwConfig.configureHwInfoDrm(&pInHwInfo, &outHwInfo, *executionEnvironment->rootDeviceEnvironments[0].get());
EXPECT_EQ(0, ret); EXPECT_EQ(0, ret);
EXPECT_FALSE(outHwInfo.capabilityTable.ftrSvm); EXPECT_FALSE(outHwInfo.capabilityTable.ftrSvm);
drm->storedGTTSize = MemoryConstants::max64BitAppAddress + 1; drm->storedGTTSize = MemoryConstants::max64BitAppAddress + 1;
ret = hwConfig.configureHwInfoDrm(&pInHwInfo, &outHwInfo, osInterface); ret = hwConfig.configureHwInfoDrm(&pInHwInfo, &outHwInfo, *executionEnvironment->rootDeviceEnvironments[0].get());
EXPECT_EQ(0, ret); EXPECT_EQ(0, ret);
EXPECT_TRUE(outHwInfo.capabilityTable.ftrSvm); EXPECT_TRUE(outHwInfo.capabilityTable.ftrSvm);
} }
TEST_F(HwInfoConfigTestLinuxDummy, givenGttSizeReturnedWhenInitializingHwInfoThenSetGpuAddressSpace) { TEST_F(HwInfoConfigTestLinuxDummy, givenGttSizeReturnedWhenInitializingHwInfoThenSetGpuAddressSpace) {
drm->storedGTTSize = maxNBitValue(40) + 1; drm->storedGTTSize = maxNBitValue(40) + 1;
int ret = hwConfig.configureHwInfoDrm(&pInHwInfo, &outHwInfo, osInterface); int ret = hwConfig.configureHwInfoDrm(&pInHwInfo, &outHwInfo, *executionEnvironment->rootDeviceEnvironments[0].get());
EXPECT_EQ(0, ret); EXPECT_EQ(0, ret);
EXPECT_EQ(drm->storedGTTSize - 1, outHwInfo.capabilityTable.gpuAddressSpace); EXPECT_EQ(drm->storedGTTSize - 1, outHwInfo.capabilityTable.gpuAddressSpace);
} }
TEST_F(HwInfoConfigTestLinuxDummy, givenFailingGttSizeIoctlWhenInitializingHwInfoThenSetDefaultValues) { TEST_F(HwInfoConfigTestLinuxDummy, givenFailingGttSizeIoctlWhenInitializingHwInfoThenSetDefaultValues) {
drm->storedRetValForGetGttSize = -1; drm->storedRetValForGetGttSize = -1;
int ret = hwConfig.configureHwInfoDrm(&pInHwInfo, &outHwInfo, osInterface); int ret = hwConfig.configureHwInfoDrm(&pInHwInfo, &outHwInfo, *executionEnvironment->rootDeviceEnvironments[0].get());
EXPECT_EQ(0, ret); EXPECT_EQ(0, ret);
EXPECT_TRUE(outHwInfo.capabilityTable.ftrSvm); EXPECT_TRUE(outHwInfo.capabilityTable.ftrSvm);
@@ -357,20 +357,20 @@ HWTEST2_F(HwConfigLinux, GivenDifferentValuesFromTopologyQueryWhenConfiguringHwI
*executionEnvironment->rootDeviceEnvironments[0]->getMutableHardwareInfo() = *NEO::defaultHwInfo.get(); *executionEnvironment->rootDeviceEnvironments[0]->getMutableHardwareInfo() = *NEO::defaultHwInfo.get();
auto drm = new DrmMock(*executionEnvironment->rootDeviceEnvironments[0]); auto drm = new DrmMock(*executionEnvironment->rootDeviceEnvironments[0]);
executionEnvironment->rootDeviceEnvironments[0]->osInterface = std::make_unique<OSInterface>();
auto osInterface = std::make_unique<OSInterface>(); auto osInterface = executionEnvironment->rootDeviceEnvironments[0]->osInterface.get();
osInterface->setDriverModel(std::unique_ptr<DriverModel>(drm)); osInterface->setDriverModel(std::unique_ptr<DriverModel>(drm));
auto hwInfo = *executionEnvironment->rootDeviceEnvironments[0]->getHardwareInfo(); auto hwInfo = *executionEnvironment->rootDeviceEnvironments[0]->getHardwareInfo();
HardwareInfo outHwInfo; HardwareInfo outHwInfo;
auto hwConfig = HwInfoConfigHw<productFamily>::get(); auto &productHelper = executionEnvironment->rootDeviceEnvironments[0]->getHelper<ProductHelper>();
hwInfo.gtSystemInfo.MaxSubSlicesSupported = drm->storedSSVal * 2; hwInfo.gtSystemInfo.MaxSubSlicesSupported = drm->storedSSVal * 2;
hwInfo.gtSystemInfo.MaxDualSubSlicesSupported = drm->storedSSVal * 2; hwInfo.gtSystemInfo.MaxDualSubSlicesSupported = drm->storedSSVal * 2;
hwInfo.gtSystemInfo.MaxEuPerSubSlice = 16; hwInfo.gtSystemInfo.MaxEuPerSubSlice = 16;
hwInfo.gtSystemInfo.MaxSlicesSupported = drm->storedSVal * 4; hwInfo.gtSystemInfo.MaxSlicesSupported = drm->storedSVal * 4;
int ret = hwConfig->configureHwInfoDrm(&hwInfo, &outHwInfo, osInterface.get()); int ret = productHelper.configureHwInfoDrm(&hwInfo, &outHwInfo, *executionEnvironment->rootDeviceEnvironments[0].get());
EXPECT_EQ(0, ret); EXPECT_EQ(0, ret);
EXPECT_EQ(static_cast<uint32_t>(drm->storedSSVal * 2), outHwInfo.gtSystemInfo.MaxSubSlicesSupported); EXPECT_EQ(static_cast<uint32_t>(drm->storedSSVal * 2), outHwInfo.gtSystemInfo.MaxSubSlicesSupported);
@@ -387,7 +387,7 @@ HWTEST2_F(HwConfigLinux, GivenDifferentValuesFromTopologyQueryWhenConfiguringHwI
hwInfo.gtSystemInfo.MaxEuPerSubSlice = 6; hwInfo.gtSystemInfo.MaxEuPerSubSlice = 6;
hwInfo.gtSystemInfo.MaxSlicesSupported = drm->storedSVal / 2; hwInfo.gtSystemInfo.MaxSlicesSupported = drm->storedSVal / 2;
ret = hwConfig->configureHwInfoDrm(&hwInfo, &outHwInfo, osInterface.get()); ret = productHelper.configureHwInfoDrm(&hwInfo, &outHwInfo, *executionEnvironment->rootDeviceEnvironments[0].get());
EXPECT_EQ(0, ret); EXPECT_EQ(0, ret);
EXPECT_EQ(12u, outHwInfo.gtSystemInfo.MaxSubSlicesSupported); EXPECT_EQ(12u, outHwInfo.gtSystemInfo.MaxSubSlicesSupported);
@@ -398,7 +398,7 @@ HWTEST2_F(HwConfigLinux, GivenDifferentValuesFromTopologyQueryWhenConfiguringHwI
hwInfo.gtSystemInfo.MaxEuPerSubSlice = 0; hwInfo.gtSystemInfo.MaxEuPerSubSlice = 0;
ret = hwConfig->configureHwInfoDrm(&hwInfo, &outHwInfo, osInterface.get()); ret = productHelper.configureHwInfoDrm(&hwInfo, &outHwInfo, *executionEnvironment->rootDeviceEnvironments[0].get());
EXPECT_EQ(0, ret); EXPECT_EQ(0, ret);
EXPECT_EQ(8u, outHwInfo.gtSystemInfo.MaxEuPerSubSlice); EXPECT_EQ(8u, outHwInfo.gtSystemInfo.MaxEuPerSubSlice);
} }
@@ -409,18 +409,19 @@ HWTEST2_F(HwConfigLinux, givenSliceCountWhenConfigureHwInfoDrmThenProperInitiali
*executionEnvironment->rootDeviceEnvironments[0]->getMutableHardwareInfo() = *NEO::defaultHwInfo.get(); *executionEnvironment->rootDeviceEnvironments[0]->getMutableHardwareInfo() = *NEO::defaultHwInfo.get();
auto drm = new DrmMock(*executionEnvironment->rootDeviceEnvironments[0]); auto drm = new DrmMock(*executionEnvironment->rootDeviceEnvironments[0]);
executionEnvironment->rootDeviceEnvironments[0]->osInterface = std::make_unique<OSInterface>();
auto osInterface = std::make_unique<OSInterface>(); auto osInterface = executionEnvironment->rootDeviceEnvironments[0]->osInterface.get();
osInterface->setDriverModel(std::unique_ptr<DriverModel>(drm)); osInterface->setDriverModel(std::unique_ptr<DriverModel>(drm));
auto hwInfo = *executionEnvironment->rootDeviceEnvironments[0]->getHardwareInfo(); auto hwInfo = *executionEnvironment->rootDeviceEnvironments[0]->getHardwareInfo();
HardwareInfo outHwInfo; HardwareInfo outHwInfo;
auto hwConfig = HwInfoConfigHw<productFamily>::get(); auto &productHelper = executionEnvironment->rootDeviceEnvironments[0]->getHelper<ProductHelper>();
uint32_t sliceCount = 4; uint32_t sliceCount = 4;
drm->storedSVal = sliceCount; drm->storedSVal = sliceCount;
hwInfo.gtSystemInfo.SliceCount = sliceCount; hwInfo.gtSystemInfo.SliceCount = sliceCount;
int ret = hwConfig->configureHwInfoDrm(&hwInfo, &outHwInfo, osInterface.get()); int ret = productHelper.configureHwInfoDrm(&hwInfo, &outHwInfo, *executionEnvironment->rootDeviceEnvironments[0].get());
EXPECT_EQ(0, ret); EXPECT_EQ(0, ret);
for (uint32_t i = 0; i < sliceCount; i++) { for (uint32_t i = 0; i < sliceCount; i++) {

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

@@ -36,8 +36,9 @@ struct HwInfoConfigTestLinux : public HwInfoConfigTest {
executionEnvironment->prepareRootDeviceEnvironments(1); executionEnvironment->prepareRootDeviceEnvironments(1);
executionEnvironment->rootDeviceEnvironments[0]->setHwInfo(defaultHwInfo.get()); executionEnvironment->rootDeviceEnvironments[0]->setHwInfo(defaultHwInfo.get());
osInterface = new OSInterface();
drm = new DrmMock(*executionEnvironment->rootDeviceEnvironments[0]); drm = new DrmMock(*executionEnvironment->rootDeviceEnvironments[0]);
executionEnvironment->rootDeviceEnvironments[0]->osInterface.reset(new OSInterface());
osInterface = executionEnvironment->rootDeviceEnvironments[0]->osInterface.get();
osInterface->setDriverModel(std::unique_ptr<DriverModel>(drm)); osInterface->setDriverModel(std::unique_ptr<DriverModel>(drm));
drm->storedEUVal = pInHwInfo.gtSystemInfo.EUCount; drm->storedEUVal = pInHwInfo.gtSystemInfo.EUCount;
@@ -50,8 +51,6 @@ struct HwInfoConfigTestLinux : public HwInfoConfigTest {
void TearDown() override { void TearDown() override {
CpuInfo::cpuidexFunc = rt_cpuidex_func; CpuInfo::cpuidexFunc = rt_cpuidex_func;
delete osInterface;
HwInfoConfigTest::TearDown(); HwInfoConfigTest::TearDown();
} }
@@ -61,6 +60,10 @@ struct HwInfoConfigTestLinux : public HwInfoConfigTest {
return helper; return helper;
} }
RootDeviceEnvironment &getRootDeviceEnvironment() {
return *executionEnvironment->rootDeviceEnvironments[0].get();
}
OSInterface *osInterface; OSInterface *osInterface;
std::unique_ptr<ExecutionEnvironment> executionEnvironment; std::unique_ptr<ExecutionEnvironment> executionEnvironment;
DrmMock *drm; DrmMock *drm;

17
shared/test/unit_test/os_interface/windows/hw_info_config_win_tests.cpp
View File

@@ -49,14 +49,15 @@ template ProductHelper &HwInfoConfigTestWindows::getHelper() const;
template CoreHelper &HwInfoConfigTestWindows::getHelper() const; template CoreHelper &HwInfoConfigTestWindows::getHelper() const;
TEST_F(HwInfoConfigTestWindows, givenCorrectParametersWhenConfiguringHwInfoThenReturnSuccess) { TEST_F(HwInfoConfigTestWindows, givenCorrectParametersWhenConfiguringHwInfoThenReturnSuccess) {
int ret = hwConfig.configureHwInfoWddm(&pInHwInfo, &outHwInfo, osInterface.get());
int ret = hwConfig.configureHwInfoWddm(&pInHwInfo, &outHwInfo, *rootDeviceEnvironment.get());
EXPECT_EQ(0, ret); EXPECT_EQ(0, ret);
} }
TEST_F(HwInfoConfigTestWindows, givenCorrectParametersWhenConfiguringHwInfoThenSetFtrSvmCorrectly) { TEST_F(HwInfoConfigTestWindows, givenCorrectParametersWhenConfiguringHwInfoThenSetFtrSvmCorrectly) {
auto ftrSvm = outHwInfo.featureTable.flags.ftrSVM; auto ftrSvm = outHwInfo.featureTable.flags.ftrSVM;
int ret = hwConfig.configureHwInfoWddm(&pInHwInfo, &outHwInfo, osInterface.get()); int ret = hwConfig.configureHwInfoWddm(&pInHwInfo, &outHwInfo, *rootDeviceEnvironment.get());
ASSERT_EQ(0, ret); ASSERT_EQ(0, ret);
EXPECT_EQ(outHwInfo.capabilityTable.ftrSvm, ftrSvm); EXPECT_EQ(outHwInfo.capabilityTable.ftrSvm, ftrSvm);
@@ -66,29 +67,29 @@ TEST_F(HwInfoConfigTestWindows, givenInstrumentationForHardwareIsEnabledOrDisabl
int ret; int ret;
outHwInfo.capabilityTable.instrumentationEnabled = false; outHwInfo.capabilityTable.instrumentationEnabled = false;
ret = hwConfig.configureHwInfoWddm(&pInHwInfo, &outHwInfo, osInterface.get()); ret = hwConfig.configureHwInfoWddm(&pInHwInfo, &outHwInfo, *rootDeviceEnvironment.get());
ASSERT_EQ(0, ret); ASSERT_EQ(0, ret);
EXPECT_FALSE(outHwInfo.capabilityTable.instrumentationEnabled); EXPECT_FALSE(outHwInfo.capabilityTable.instrumentationEnabled);
outHwInfo.capabilityTable.instrumentationEnabled = true; outHwInfo.capabilityTable.instrumentationEnabled = true;
ret = hwConfig.configureHwInfoWddm(&pInHwInfo, &outHwInfo, osInterface.get()); ret = hwConfig.configureHwInfoWddm(&pInHwInfo, &outHwInfo, *rootDeviceEnvironment.get());
ASSERT_EQ(0, ret); ASSERT_EQ(0, ret);
EXPECT_TRUE(outHwInfo.capabilityTable.instrumentationEnabled); EXPECT_TRUE(outHwInfo.capabilityTable.instrumentationEnabled);
} }
HWTEST_F(HwInfoConfigTestWindows, givenFtrIaCoherencyFlagWhenConfiguringHwInfoThenSetCoherencySupportCorrectly) { HWTEST_F(HwInfoConfigTestWindows, givenFtrIaCoherencyFlagWhenConfiguringHwInfoThenSetCoherencySupportCorrectly) {
HardwareInfo initialHwInfo = *defaultHwInfo; HardwareInfo initialHwInfo = *defaultHwInfo;
auto hwInfoConfig = HwInfoConfig::get(initialHwInfo.platform.eProductFamily); auto &productHelper = rootDeviceEnvironment->getHelper<ProductHelper>();
bool initialCoherencyStatus = false; bool initialCoherencyStatus = false;
hwInfoConfig->setCapabilityCoherencyFlag(outHwInfo, initialCoherencyStatus); productHelper.setCapabilityCoherencyFlag(outHwInfo, initialCoherencyStatus);
initialHwInfo.featureTable.flags.ftrL3IACoherency = false; initialHwInfo.featureTable.flags.ftrL3IACoherency = false;
hwInfoConfig->configureHwInfoWddm(&initialHwInfo, &outHwInfo, osInterface.get()); productHelper.configureHwInfoWddm(&initialHwInfo, &outHwInfo, *rootDeviceEnvironment.get());
EXPECT_FALSE(outHwInfo.capabilityTable.ftrSupportsCoherency); EXPECT_FALSE(outHwInfo.capabilityTable.ftrSupportsCoherency);
initialHwInfo.featureTable.flags.ftrL3IACoherency = true; initialHwInfo.featureTable.flags.ftrL3IACoherency = true;
hwInfoConfig->configureHwInfoWddm(&initialHwInfo, &outHwInfo, osInterface.get()); productHelper.configureHwInfoWddm(&initialHwInfo, &outHwInfo, *rootDeviceEnvironment.get());
EXPECT_EQ(initialCoherencyStatus, outHwInfo.capabilityTable.ftrSupportsCoherency); EXPECT_EQ(initialCoherencyStatus, outHwInfo.capabilityTable.ftrSupportsCoherency);
} }

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

@@ -24,7 +24,7 @@ struct HwInfoConfigTestLinuxXeHp : HwInfoConfigTestLinux {
XEHPTEST_F(HwInfoConfigTestLinuxXeHp, WhenConfiguringHwInfoThenZeroIsReturned) { XEHPTEST_F(HwInfoConfigTestLinuxXeHp, WhenConfiguringHwInfoThenZeroIsReturned) {
auto &productHelper = getHelper<ProductHelper>(); auto &productHelper = getHelper<ProductHelper>();
int ret = productHelper.configureHwInfoDrm(&pInHwInfo, &outHwInfo, osInterface); auto ret = productHelper.configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(0, ret); EXPECT_EQ(0, ret);
} }

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

@@ -29,8 +29,8 @@ struct HwInfoConfigTestLinuxPvc : HwInfoConfigTestLinux {
}; };
PVCTEST_F(HwInfoConfigTestLinuxPvc, WhenConfiguringHwInfoThenZeroIsReturned) { PVCTEST_F(HwInfoConfigTestLinuxPvc, WhenConfiguringHwInfoThenZeroIsReturned) {
auto hwInfoConfig = HwInfoConfig::get(productFamily); auto &productHelper = getHelper<ProductHelper>();
int ret = hwInfoConfig->configureHwInfoDrm(&pInHwInfo, &outHwInfo, osInterface); auto ret = productHelper.configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(0, ret); EXPECT_EQ(0, ret);
} }

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

@@ -109,17 +109,18 @@ DG2TEST_F(HwInfoConfigTestDg2, givenG12DevIdWhenIsDisableOverdispatchAvailableCa
DG2TEST_F(HwInfoConfigTestDg2, whenAdjustingDefaultEngineTypeThenSelectEngineTypeBasedOnRevisionId) { DG2TEST_F(HwInfoConfigTestDg2, whenAdjustingDefaultEngineTypeThenSelectEngineTypeBasedOnRevisionId) {
auto hardwareInfo = *defaultHwInfo; auto hardwareInfo = *defaultHwInfo;
hardwareInfo.featureTable.flags.ftrCCSNode = true; hardwareInfo.featureTable.flags.ftrCCSNode = true;
auto &hwHelper = HwHelper::get(renderCoreFamily);
const auto &hwInfoConfig = *HwInfoConfig::get(productFamily); auto &coreHelper = getHelper<CoreHelper>();
auto &productHelper = getHelper<ProductHelper>();
hardwareInfo.capabilityTable.defaultEngineType = defaultHwInfo->capabilityTable.defaultEngineType; hardwareInfo.capabilityTable.defaultEngineType = defaultHwInfo->capabilityTable.defaultEngineType;
hardwareInfo.platform.usRevId = hwInfoConfig.getHwRevIdFromStepping(REVISION_A0, hardwareInfo); hardwareInfo.platform.usRevId = productHelper.getHwRevIdFromStepping(REVISION_A0, hardwareInfo);
hwHelper.adjustDefaultEngineType(&hardwareInfo); coreHelper.adjustDefaultEngineType(&hardwareInfo);
EXPECT_EQ(aub_stream::ENGINE_RCS, hardwareInfo.capabilityTable.defaultEngineType); EXPECT_EQ(aub_stream::ENGINE_RCS, hardwareInfo.capabilityTable.defaultEngineType);
hardwareInfo.capabilityTable.defaultEngineType = defaultHwInfo->capabilityTable.defaultEngineType; hardwareInfo.capabilityTable.defaultEngineType = defaultHwInfo->capabilityTable.defaultEngineType;
hardwareInfo.platform.usRevId = hwInfoConfig.getHwRevIdFromStepping(REVISION_B, hardwareInfo); hardwareInfo.platform.usRevId = productHelper.getHwRevIdFromStepping(REVISION_B, hardwareInfo);
hwHelper.adjustDefaultEngineType(&hardwareInfo); coreHelper.adjustDefaultEngineType(&hardwareInfo);
EXPECT_EQ(aub_stream::ENGINE_CCS, hardwareInfo.capabilityTable.defaultEngineType); EXPECT_EQ(aub_stream::ENGINE_CCS, hardwareInfo.capabilityTable.defaultEngineType);
} }

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

@@ -23,8 +23,8 @@ struct HwInfoConfigTestLinuxDg2 : HwInfoConfigTestLinux {
}; };
DG2TEST_F(HwInfoConfigTestLinuxDg2, WhenConfiguringHwInfoThenZeroIsReturned) { DG2TEST_F(HwInfoConfigTestLinuxDg2, WhenConfiguringHwInfoThenZeroIsReturned) {
auto hwInfoConfig = HwInfoConfig::get(productFamily); auto &productHelper = getHelper<ProductHelper>();
int ret = hwInfoConfig->configureHwInfoDrm(&pInHwInfo, &outHwInfo, osInterface); auto ret = productHelper.configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(0, ret); EXPECT_EQ(0, ret);
} }