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

fix: correct setting hw info in drm flow

Browse Source 
firstly, setup hw info using product specific functions
secondly, query system info from GuC to setup max values
then, query memory info
then, query engine info as it depends on memory info
then, query topology as it depends on engine info

Related-To: NEO-12073
Signed-off-by: Mateusz Jablonski <mateusz.jablonski@intel.com>
This commit is contained in:
Mateusz Jablonski
2024-07-24 16:19:00 +00:00
committed by Compute-Runtime-Automation
parent ebcbbcf8fe
commit 0cdfa882eb
28 changed files with 85 additions and 846 deletions
Download Patch File Download Diff File Expand all files Collapse all files

31
shared/test/unit_test/gen11/ehl/linux/product_helper_tests_ehl.cpp
View File

@@ -13,35 +13,6 @@
using namespace NEO;
struct EhlProductHelperLinux : ProductHelperTestLinux {
void SetUp() override {
ProductHelperTestLinux::SetUp();
drm->storedSSVal = 8;
}
};
EHLTEST_F(EhlProductHelperLinux, GivenEhlThenHwInfoIsCorrect) {
int ret = productHelper->configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(0, ret);
EXPECT_EQ((uint32_t)drm->storedEUVal, outHwInfo.gtSystemInfo.EUCount);
EXPECT_EQ((uint32_t)drm->storedSSVal, outHwInfo.gtSystemInfo.SubSliceCount);
EXPECT_EQ(1u, outHwInfo.gtSystemInfo.SliceCount);
}
EHLTEST_F(EhlProductHelperLinux, GivenInvalidDeviceIdWhenConfiguringHwInfoThenNegativeOneReturned) {
drm->failRetTopology = true;
drm->storedRetValForEUVal = -1;
auto ret = productHelper->configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(-1, ret);
drm->storedRetValForEUVal = 0;
drm->storedRetValForSSVal = -1;
ret = productHelper->configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(-1, ret);
}
template <typename T>
class EhlHwInfoTests : public ::testing::Test {};
TEST(EhlHwInfoTests, WhenGtIsSetupThenGtSystemInfoIsCorrect) {
@@ -66,5 +37,5 @@ TEST(EhlHwInfoTests, WhenGtIsSetupThenGtSystemInfoIsCorrect) {
EXPECT_GT(gtSystemInfo.DualSubSliceCount, 0u);
EXPECT_GT_VAL(gtSystemInfo.L3CacheSizeInKb, 0u);
EXPECT_EQ(gtSystemInfo.CsrSizeInMb, 8u);
EXPECT_FALSE(gtSystemInfo.IsDynamicallyPopulated);
EXPECT_TRUE(gtSystemInfo.IsDynamicallyPopulated);
}

33
shared/test/unit_test/gen11/icllp/linux/product_helper_tests_icllp.cpp
View File

@@ -14,37 +14,6 @@
using namespace NEO;
struct IcllpProductHelperLinux : ProductHelperTestLinux {
void SetUp() override {
ProductHelperTestLinux::SetUp();
}
};
ICLLPTEST_F(IcllpProductHelperLinux, GivenIcllpThenHwInfoIsCorrect) {
auto ret = productHelper->configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(0, ret);
EXPECT_EQ((uint32_t)drm->storedEUVal, outHwInfo.gtSystemInfo.EUCount);
EXPECT_EQ((uint32_t)drm->storedSSVal, outHwInfo.gtSystemInfo.SubSliceCount);
EXPECT_EQ(1u, outHwInfo.gtSystemInfo.SliceCount);
EXPECT_EQ(aub_stream::ENGINE_RCS, outHwInfo.capabilityTable.defaultEngineType);
EXPECT_FALSE(outHwInfo.featureTable.flags.ftrTileY);
}
ICLLPTEST_F(IcllpProductHelperLinux, GivenInvalidDeviceIdWhenConfiguringHwInfoThenNegativeOneReturned) {
drm->failRetTopology = true;
drm->storedRetValForEUVal = -1;
auto ret = productHelper->configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(-1, ret);
drm->storedRetValForEUVal = 0;
drm->storedRetValForSSVal = -1;
ret = productHelper->configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(-1, ret);
}
template <typename T>
class IcllpHwInfoTests : public ::testing::Test {};
typedef ::testing::Types<IcllpHw1x8x8, IcllpHw1x4x8, IcllpHw1x6x8> icllpTestTypes;
@@ -69,5 +38,5 @@ TYPED_TEST(IcllpHwInfoTests, WhenGettingSystemInfoThenParamsAreValid) {
EXPECT_GT(gtSystemInfo.DualSubSliceCount, 0u);
EXPECT_GT_VAL(gtSystemInfo.L3CacheSizeInKb, 0u);
EXPECT_EQ(gtSystemInfo.CsrSizeInMb, 5u);
EXPECT_FALSE(gtSystemInfo.IsDynamicallyPopulated);
EXPECT_TRUE(gtSystemInfo.IsDynamicallyPopulated);
}

36
shared/test/unit_test/gen11/lkf/linux/product_helper_tests_lkf.cpp
View File

@@ -13,40 +13,6 @@
using namespace NEO;
struct LkfProductHelperLinux : ProductHelperTestLinux {
void SetUp() override {
ProductHelperTestLinux::SetUp();
drm->storedSSVal = 8;
}
};
LKFTEST_F(LkfProductHelperLinux, GivenLkfThenHwInfoIsCorrect) {
auto ret = productHelper->configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(0, ret);
EXPECT_EQ((uint32_t)drm->storedEUVal, outHwInfo.gtSystemInfo.EUCount);
EXPECT_EQ((uint32_t)drm->storedSSVal, outHwInfo.gtSystemInfo.SubSliceCount);
EXPECT_EQ(1u, outHwInfo.gtSystemInfo.SliceCount);
EXPECT_FALSE(outHwInfo.featureTable.flags.ftrTileY);
}
LKFTEST_F(LkfProductHelperLinux, GivenInvalidDeviceIdWhenConfiguringHwInfoThenNegativeOneReturned) {
auto ret = productHelper->configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
drm->failRetTopology = true;
drm->storedRetValForEUVal = -1;
ret = productHelper->configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(-1, ret);
drm->storedRetValForEUVal = 0;
drm->storedRetValForSSVal = -1;
ret = productHelper->configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(-1, ret);
}
template <typename T>
class LkfHwInfoTests : public ::testing::Test {};
using lkfTestTypes = ::testing::Types<LkfHw1x8x8>;
@@ -73,5 +39,5 @@ TYPED_TEST(LkfHwInfoTests, WhenGtIsSetupThenGtSystemInfoIsCorrect) {
EXPECT_GT(gtSystemInfo.DualSubSliceCount, 0u);
EXPECT_GT_VAL(gtSystemInfo.L3CacheSizeInKb, 0u);
EXPECT_EQ(gtSystemInfo.CsrSizeInMb, 8u);
EXPECT_FALSE(gtSystemInfo.IsDynamicallyPopulated);
EXPECT_TRUE(gtSystemInfo.IsDynamicallyPopulated);
}

39
shared/test/unit_test/gen12lp/adln/linux/product_helper_tests_adln.cpp
View File

@@ -5,50 +5,17 @@
*
*/
#include "shared/source/execution_environment/execution_environment.h"
#include "shared/source/execution_environment/root_device_environment.h"
#include "shared/source/gen12lp/hw_cmds_adln.h"
#include "shared/source/gen12lp/hw_info_gen12lp.h"
#include "shared/source/os_interface/os_interface.h"
#include "shared/test/common/helpers/gtest_helpers.h"
#include "shared/test/common/libult/linux/drm_mock.h"
#include "shared/test/common/test_macros/header/per_product_test_definitions.h"
#include "shared/test/unit_test/os_interface/linux/product_helper_linux_tests.h"
using namespace NEO;
struct AdlnProductHelperLinux : ProductHelperTestLinux {
void SetUp() override {
ProductHelperTestLinux::SetUp();
drm = new DrmMock(*executionEnvironment->rootDeviceEnvironments[0]);
osInterface->setDriverModel(std::unique_ptr<DriverModel>(drm));
}
};
ADLNTEST_F(AdlnProductHelperLinux, WhenConfiguringHwInfoThenConfigIsCorrect) {
auto ret = productHelper->configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(0, ret);
EXPECT_EQ(static_cast<uint32_t>(drm->storedEUVal), outHwInfo.gtSystemInfo.EUCount);
EXPECT_EQ(static_cast<uint32_t>(drm->storedSSVal), outHwInfo.gtSystemInfo.SubSliceCount);
EXPECT_EQ(1u, outHwInfo.gtSystemInfo.SliceCount);
EXPECT_FALSE(outHwInfo.featureTable.flags.ftrTileY);
}
ADLNTEST_F(AdlnProductHelperLinux, GivenIncorrectDataWhenConfiguringHwInfoThenErrorIsReturned) {
drm->failRetTopology = true;
drm->storedRetValForEUVal = -1;
auto ret = productHelper->configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(-1, ret);
drm->storedRetValForEUVal = 0;
drm->storedRetValForSSVal = -1;
ret = productHelper->configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(-1, ret);
}
using AdlnHwInfoLinux = ::testing::Test;
ADLNTEST_F(AdlnHwInfoLinux, WhenSettingUpHwInfoThenConfigIsCorrect) {
@@ -73,7 +40,7 @@ ADLNTEST_F(AdlnHwInfoLinux, WhenSettingUpHwInfoThenConfigIsCorrect) {
EXPECT_GT(gtSystemInfo.DualSubSliceCount, 0u);
EXPECT_GT_VAL(gtSystemInfo.L3CacheSizeInKb, 0u);
EXPECT_EQ(gtSystemInfo.CsrSizeInMb, 8u);
EXPECT_FALSE(gtSystemInfo.IsDynamicallyPopulated);
EXPECT_TRUE(gtSystemInfo.IsDynamicallyPopulated);
EXPECT_GT(gtSystemInfo.DualSubSliceCount, 0u);
EXPECT_GT(gtSystemInfo.MaxDualSubSlicesSupported, 0u);
}

49
shared/test/unit_test/gen12lp/adlp/linux/product_helper_tests_adlp.cpp
View File

@@ -13,46 +13,11 @@
#include "shared/test/common/helpers/gtest_helpers.h"
#include "shared/test/common/libult/linux/drm_mock.h"
#include "shared/test/common/test_macros/header/per_product_test_definitions.h"
#include "shared/test/unit_test/os_interface/linux/product_helper_linux_tests.h"
using namespace NEO;
struct AdlpProductHelperLinux : ProductHelperTestLinux {
void SetUp() override {
ProductHelperTestLinux::SetUp();
drm = new DrmMock(*executionEnvironment->rootDeviceEnvironments[0]);
osInterface->setDriverModel(std::unique_ptr<DriverModel>(drm));
}
};
ADLPTEST_F(AdlpProductHelperLinux, WhenConfiguringHwInfoThenInfoIsSetCorrectly) {
auto ret = productHelper->configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(0, ret);
EXPECT_EQ(static_cast<uint32_t>(drm->storedEUVal), outHwInfo.gtSystemInfo.EUCount);
EXPECT_EQ(static_cast<uint32_t>(drm->storedSSVal), outHwInfo.gtSystemInfo.SubSliceCount);
EXPECT_EQ(1u, outHwInfo.gtSystemInfo.SliceCount);
EXPECT_FALSE(outHwInfo.featureTable.flags.ftrTileY);
}
ADLPTEST_F(AdlpProductHelperLinux, GivenInvalidDeviceIdWhenConfiguringHwInfoThenErrorIsReturned) {
drm->failRetTopology = true;
drm->storedRetValForEUVal = -1;
auto ret = productHelper->configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(-1, ret);
drm->storedRetValForEUVal = 0;
drm->storedRetValForSSVal = -1;
ret = productHelper->configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(-1, ret);
}
ADLPTEST_F(AdlpProductHelperLinux, givenAdlpConfigWhenSetupHardwareInfoBaseThenGtSystemInfoIsCorrect) {
using AdlpHwInfoLinux = ::testing::Test;
ADLPTEST_F(AdlpHwInfoLinux, givenAdlpConfigWhenSetupHardwareInfoBaseThenGtSystemInfoIsCorrect) {
HardwareInfo hwInfo = *defaultHwInfo;
GT_SYSTEM_INFO &gtSystemInfo = hwInfo.gtSystemInfo;
ADLP::setupHardwareInfoBase(&hwInfo, false, nullptr);
@@ -60,19 +25,13 @@ ADLPTEST_F(AdlpProductHelperLinux, givenAdlpConfigWhenSetupHardwareInfoBaseThenG
EXPECT_EQ(64u, gtSystemInfo.TotalPsThreadsWindowerRange);
EXPECT_EQ(8u, gtSystemInfo.CsrSizeInMb);
EXPECT_FALSE(gtSystemInfo.IsL3HashModeEnabled);
EXPECT_FALSE(gtSystemInfo.IsDynamicallyPopulated);
}
template <typename T>
using AdlpHwInfoLinux = ::testing::Test;
using adlpConfigTestTypes = ::testing::Types<AdlpHwConfig>;
TYPED_TEST_SUITE(AdlpHwInfoLinux, adlpConfigTestTypes);
TYPED_TEST(AdlpHwInfoLinux, givenSliceCountZeroWhenSetupHardwareInfoThenNotZeroValuesSetInGtSystemInfo) {
ADLPTEST_F(AdlpHwInfoLinux, givenSliceCountZeroWhenSetupHardwareInfoThenNotZeroValuesSetInGtSystemInfo) {
HardwareInfo hwInfo = *defaultHwInfo;
hwInfo.gtSystemInfo = {0};
TypeParam::setupHardwareInfo(&hwInfo, false, nullptr);
AdlpHwConfig::setupHardwareInfo(&hwInfo, false, nullptr);
EXPECT_NE(0u, hwInfo.gtSystemInfo.SliceCount);
EXPECT_NE(0u, hwInfo.gtSystemInfo.SubSliceCount);

36
shared/test/unit_test/gen12lp/adls/linux/product_helper_tests_adls.cpp
View File

@@ -15,40 +15,6 @@
using namespace NEO;
struct AdlsProductHelperLinux : ProductHelperTestLinux {
void SetUp() override {
ProductHelperTestLinux::SetUp();
drm = new DrmMock(*executionEnvironment->rootDeviceEnvironments[0]);
osInterface->setDriverModel(std::unique_ptr<DriverModel>(drm));
}
};
ADLSTEST_F(AdlsProductHelperLinux, WhenConfiguringHwInfoThenConfigIsCorrect) {
auto ret = productHelper->configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(0, ret);
EXPECT_EQ(static_cast<uint32_t>(drm->storedEUVal), outHwInfo.gtSystemInfo.EUCount);
EXPECT_EQ(static_cast<uint32_t>(drm->storedSSVal), outHwInfo.gtSystemInfo.SubSliceCount);
EXPECT_EQ(1u, outHwInfo.gtSystemInfo.SliceCount);
EXPECT_FALSE(outHwInfo.featureTable.flags.ftrTileY);
}
ADLSTEST_F(AdlsProductHelperLinux, GivenIncorrectDataWhenConfiguringHwInfoThenErrorIsReturned) {
drm->failRetTopology = true;
drm->storedRetValForEUVal = -1;
auto ret = productHelper->configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(-1, ret);
drm->storedRetValForEUVal = 0;
drm->storedRetValForSSVal = -1;
ret = productHelper->configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(-1, ret);
}
using AdlsHwInfoLinux = ::testing::Test;
ADLSTEST_F(AdlsHwInfoLinux, WhenSettingUpHwInfoThenConfigIsCorrect) {
@@ -73,7 +39,7 @@ ADLSTEST_F(AdlsHwInfoLinux, WhenSettingUpHwInfoThenConfigIsCorrect) {
EXPECT_GT(gtSystemInfo.DualSubSliceCount, 0u);
EXPECT_GT_VAL(gtSystemInfo.L3CacheSizeInKb, 0u);
EXPECT_EQ(gtSystemInfo.CsrSizeInMb, 8u);
EXPECT_FALSE(gtSystemInfo.IsDynamicallyPopulated);
EXPECT_TRUE(gtSystemInfo.IsDynamicallyPopulated);
EXPECT_GT(gtSystemInfo.DualSubSliceCount, 0u);
EXPECT_GT(gtSystemInfo.MaxDualSubSlicesSupported, 0u);
}

25
shared/test/unit_test/gen12lp/dg1/linux/product_helper_tests_dg1.cpp
View File

@@ -48,29 +48,6 @@ DG1TEST_F(Dg1ProductHelperLinux, GivenDG1WhenConfigureHardwareCustomThenKmdNotif
EXPECT_EQ(300ll, hardwareInfo.capabilityTable.kmdNotifyProperties.delayKmdNotifyMicroseconds);
}
DG1TEST_F(Dg1ProductHelperLinux, WhenConfiguringHwInfoThenInfoIsSetCorrectly) {
auto ret = productHelper->configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(0, ret);
EXPECT_EQ(static_cast<uint32_t>(drm->storedEUVal), outHwInfo.gtSystemInfo.EUCount);
EXPECT_EQ(static_cast<uint32_t>(drm->storedSSVal), outHwInfo.gtSystemInfo.SubSliceCount);
EXPECT_EQ(1u, outHwInfo.gtSystemInfo.SliceCount);
EXPECT_FALSE(outHwInfo.featureTable.flags.ftrTileY);
}
DG1TEST_F(Dg1ProductHelperLinux, GivenInvalidDeviceIdWhenConfiguringHwInfoThenErrorIsReturned) {
drm->failRetTopology = true;
drm->storedRetValForEUVal = -1;
auto ret = productHelper->configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(-1, ret);
drm->storedRetValForEUVal = 0;
drm->storedRetValForSSVal = -1;
ret = productHelper->configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(-1, ret);
}
template <typename T>
class Dg1HwInfoLinux : public ::testing::Test {};
using dg1TestTypes = ::testing::Types<Dg1HwConfig>;
@@ -94,7 +71,7 @@ TYPED_TEST(Dg1HwInfoLinux, WhenGtIsSetupThenGtSystemInfoIsCorrect) {
EXPECT_GT(gtSystemInfo.SubSliceCount, 0u);
EXPECT_GT_VAL(gtSystemInfo.L3CacheSizeInKb, 0u);
EXPECT_EQ(gtSystemInfo.CsrSizeInMb, 8u);
EXPECT_FALSE(gtSystemInfo.IsDynamicallyPopulated);
EXPECT_TRUE(gtSystemInfo.IsDynamicallyPopulated);
EXPECT_GT(gtSystemInfo.DualSubSliceCount, 0u);
EXPECT_GT(gtSystemInfo.MaxDualSubSlicesSupported, 0u);
}

39
shared/test/unit_test/gen12lp/rkl/linux/product_helper_tests_rkl.cpp
View File

@@ -5,50 +5,17 @@
*
*/
#include "shared/source/execution_environment/execution_environment.h"
#include "shared/source/execution_environment/root_device_environment.h"
#include "shared/source/gen12lp/hw_cmds_rkl.h"
#include "shared/source/gen12lp/hw_info_gen12lp.h"
#include "shared/source/os_interface/os_interface.h"
#include "shared/test/common/helpers/gtest_helpers.h"
#include "shared/test/common/libult/linux/drm_mock.h"
#include "shared/test/common/test_macros/header/per_product_test_definitions.h"
#include "shared/test/unit_test/os_interface/linux/product_helper_linux_tests.h"
using namespace NEO;
struct RklProductHelperLinux : ProductHelperTestLinux {
void SetUp() override {
ProductHelperTestLinux::SetUp();
drm = new DrmMock(*executionEnvironment->rootDeviceEnvironments[0]);
osInterface->setDriverModel(std::unique_ptr<DriverModel>(drm));
}
};
RKLTEST_F(RklProductHelperLinux, WhenConfiguringHwInfoThenConfigIsCorrect) {
auto ret = productHelper->configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(0, ret);
EXPECT_EQ((uint32_t)drm->storedEUVal, outHwInfo.gtSystemInfo.EUCount);
EXPECT_EQ((uint32_t)drm->storedSSVal, outHwInfo.gtSystemInfo.SubSliceCount);
EXPECT_EQ(1u, outHwInfo.gtSystemInfo.SliceCount);
EXPECT_FALSE(outHwInfo.featureTable.flags.ftrTileY);
}
RKLTEST_F(RklProductHelperLinux, GivenIncorrectDataWhenConfiguringHwInfoThenErrorIsReturned) {
drm->failRetTopology = true;
drm->storedRetValForEUVal = -1;
auto ret = productHelper->configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(-1, ret);
drm->storedRetValForEUVal = 0;
drm->storedRetValForSSVal = -1;
ret = productHelper->configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(-1, ret);
}
using RklHwInfoLinux = ::testing::Test;
RKLTEST_F(RklHwInfoLinux, WhenSettingUpHwInfoThenConfigIsCorrect) {
@@ -73,7 +40,7 @@ RKLTEST_F(RklHwInfoLinux, WhenSettingUpHwInfoThenConfigIsCorrect) {
EXPECT_GT(gtSystemInfo.DualSubSliceCount, 0u);
EXPECT_GT_VAL(gtSystemInfo.L3CacheSizeInKb, 0u);
EXPECT_EQ(gtSystemInfo.CsrSizeInMb, 8u);
EXPECT_FALSE(gtSystemInfo.IsDynamicallyPopulated);
EXPECT_TRUE(gtSystemInfo.IsDynamicallyPopulated);
EXPECT_GT(gtSystemInfo.DualSubSliceCount, 0u);
EXPECT_GT(gtSystemInfo.MaxDualSubSlicesSupported, 0u);
}

28
shared/test/unit_test/gen12lp/tgllp/linux/product_helper_tests_tgllp.cpp
View File

@@ -38,32 +38,6 @@ TGLLPTEST_F(TgllpProductHelperLinux, GivenTGLLPWhenConfigureHardwareCustomThenMT
EXPECT_FALSE(outHwInfo.featureTable.flags.ftrGpGpuMidThreadLevelPreempt);
}
TGLLPTEST_F(TgllpProductHelperLinux, WhenConfiguringHwInfoThenInfoIsSetCorrectly) {
auto ret = productHelper->configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(0, ret);
EXPECT_EQ((uint32_t)drm->storedEUVal, outHwInfo.gtSystemInfo.EUCount);
EXPECT_EQ((uint32_t)drm->storedSSVal, outHwInfo.gtSystemInfo.SubSliceCount);
EXPECT_EQ(1u, outHwInfo.gtSystemInfo.SliceCount);
EXPECT_FALSE(outHwInfo.featureTable.flags.ftrTileY);
}
TGLLPTEST_F(TgllpProductHelperLinux, GivenInvalidDeviceIdWhenConfiguringHwInfoThenErrorIsReturned) {
drm->failRetTopology = true;
drm->storedRetValForEUVal = -1;
auto ret = productHelper->configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(-1, ret);
drm->storedRetValForEUVal = 0;
drm->storedRetValForSSVal = -1;
ret = productHelper->configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(-1, ret);
}
template <typename T>
class TgllpHwInfoLinux : public ::testing::Test {};
typedef ::testing::Types<TgllpHw1x6x16> tgllpTestTypes;
@@ -89,7 +63,7 @@ TYPED_TEST(TgllpHwInfoLinux, gtSetupIsCorrect) {
EXPECT_GT(gtSystemInfo.DualSubSliceCount, 0u);
EXPECT_GT_VAL(gtSystemInfo.L3CacheSizeInKb, 0u);
EXPECT_EQ(gtSystemInfo.CsrSizeInMb, 8u);
EXPECT_FALSE(gtSystemInfo.IsDynamicallyPopulated);
EXPECT_TRUE(gtSystemInfo.IsDynamicallyPopulated);
EXPECT_GT(gtSystemInfo.DualSubSliceCount, 0u);
EXPECT_GT(gtSystemInfo.MaxDualSubSlicesSupported, 0u);
}

74
shared/test/unit_test/gen8/bdw/linux/product_helper_tests_bdw.cpp
View File

@@ -13,78 +13,6 @@
using namespace NEO;
struct BdwProductHelperLinux : ProductHelperTestLinux {
void SetUp() override {
ProductHelperTestLinux::SetUp();
}
};
BDWTEST_F(BdwProductHelperLinux, WhenConfiguringHwInfoThenInformationIsCorrect) {
drm->storedSSVal = 3;
auto ret = productHelper->configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(0, ret);
EXPECT_EQ((uint32_t)drm->storedEUVal, outHwInfo.gtSystemInfo.EUCount);
EXPECT_EQ((uint32_t)drm->storedSSVal, outHwInfo.gtSystemInfo.SubSliceCount);
EXPECT_EQ(1u, outHwInfo.gtSystemInfo.SliceCount);
EXPECT_EQ(aub_stream::ENGINE_RCS, outHwInfo.capabilityTable.defaultEngineType);
pInHwInfo.platform.usDeviceID = 0x1602;
ret = productHelper->configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(0, ret);
EXPECT_EQ((uint32_t)drm->storedEUVal, outHwInfo.gtSystemInfo.EUCount);
EXPECT_EQ((uint32_t)drm->storedSSVal, outHwInfo.gtSystemInfo.SubSliceCount);
EXPECT_EQ(aub_stream::ENGINE_RCS, outHwInfo.capabilityTable.defaultEngineType);
pInHwInfo.platform.usDeviceID = 0x1626;
drm->storedSSVal = 6;
ret = productHelper->configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(0, ret);
EXPECT_EQ((uint32_t)drm->storedEUVal, outHwInfo.gtSystemInfo.EUCount);
EXPECT_EQ((uint32_t)drm->storedSSVal, outHwInfo.gtSystemInfo.SubSliceCount);
EXPECT_EQ(2u, outHwInfo.gtSystemInfo.SliceCount);
EXPECT_EQ(aub_stream::ENGINE_RCS, outHwInfo.capabilityTable.defaultEngineType);
}
BDWTEST_F(BdwProductHelperLinux, GivenFailedIoctlEuCountWhenConfiguringHwInfoThenErrorIsReturned) {
drm->failRetTopology = true;
drm->storedRetValForEUVal = -4;
auto ret = productHelper->configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(-4, ret);
}
BDWTEST_F(BdwProductHelperLinux, GivenFailedIoctlSsCountWhenConfiguringHwInfoThenErrorIsReturned) {
drm->failRetTopology = true;
drm->storedRetValForSSVal = -5;
auto ret = productHelper->configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(-5, ret);
}
BDWTEST_F(BdwProductHelperLinux, WhenConfiguringHwInfoThenEdramInformationIsCorrect) {
auto ret = productHelper->configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(0, ret);
EXPECT_EQ_VAL(0u, outHwInfo.gtSystemInfo.EdramSizeInKb);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrEDram);
pInHwInfo.platform.usDeviceID = 0x1622;
ret = productHelper->configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(0, ret);
EXPECT_EQ_VAL((128u * 1024u), outHwInfo.gtSystemInfo.EdramSizeInKb);
EXPECT_EQ(1u, outHwInfo.featureTable.flags.ftrEDram);
pInHwInfo.platform.usDeviceID = 0x162A;
ret = productHelper->configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(0, ret);
EXPECT_EQ_VAL((128u * 1024u), outHwInfo.gtSystemInfo.EdramSizeInKb);
EXPECT_EQ(1u, outHwInfo.featureTable.flags.ftrEDram);
}
template <typename T>
class BdwHwInfoTests : public ::testing::Test {
};
@@ -111,5 +39,5 @@ TYPED_TEST(BdwHwInfoTests, WhenGtIsSetupThenGtSystemInfoIsCorrect) {
EXPECT_GT(gtSystemInfo.DualSubSliceCount, 0u);
EXPECT_GT_VAL(gtSystemInfo.L3CacheSizeInKb, 0u);
EXPECT_EQ(gtSystemInfo.CsrSizeInMb, 8u);
EXPECT_FALSE(gtSystemInfo.IsDynamicallyPopulated);
EXPECT_TRUE(gtSystemInfo.IsDynamicallyPopulated);
}

71
shared/test/unit_test/gen9/bxt/linux/product_helper_tests_bxt.cpp
View File

@@ -27,11 +27,8 @@ struct BxtProductHelperLinux : ProductHelperTestLinux {
BXTTEST_F(BxtProductHelperLinux, WhenConfiguringHwInfoThenConfigIsCorrect) {
auto ret = productHelper->configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(0, ret);
EXPECT_EQ((uint32_t)drm->storedEUVal, outHwInfo.gtSystemInfo.EUCount);
EXPECT_EQ((uint32_t)drm->storedSSVal, outHwInfo.gtSystemInfo.SubSliceCount);
EXPECT_EQ((unsigned int)drm->storedHasPooledEU, outHwInfo.featureTable.flags.ftrPooledEuEnabled);
EXPECT_EQ((uint32_t)drm->storedMinEUinPool, outHwInfo.gtSystemInfo.EuCountPerPoolMin);
EXPECT_EQ((outHwInfo.gtSystemInfo.EUCount - outHwInfo.gtSystemInfo.EuCountPerPoolMin), outHwInfo.gtSystemInfo.EuCountPerPoolMax);
EXPECT_EQ(aub_stream::ENGINE_RCS, outHwInfo.capabilityTable.defaultEngineType);
// constant sysInfo/ftr flags
@@ -41,19 +38,14 @@ BXTTEST_F(BxtProductHelperLinux, WhenConfiguringHwInfoThenConfigIsCorrect) {
drm->storedMinEUinPool = 6;
ret = productHelper->configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(0, ret);
EXPECT_EQ((uint32_t)drm->storedEUVal, outHwInfo.gtSystemInfo.EUCount);
EXPECT_EQ((uint32_t)drm->storedSSVal, outHwInfo.gtSystemInfo.SubSliceCount);
EXPECT_EQ((unsigned int)drm->storedHasPooledEU, outHwInfo.featureTable.flags.ftrPooledEuEnabled);
EXPECT_EQ((uint32_t)drm->storedMinEUinPool, outHwInfo.gtSystemInfo.EuCountPerPoolMin);
EXPECT_EQ((outHwInfo.gtSystemInfo.EUCount - outHwInfo.gtSystemInfo.EuCountPerPoolMin), outHwInfo.gtSystemInfo.EuCountPerPoolMax);
EXPECT_EQ(aub_stream::ENGINE_RCS, outHwInfo.capabilityTable.defaultEngineType);
pInHwInfo.platform.usDeviceID = 0x5A85;
drm->storedMinEUinPool = 9;
ret = productHelper->configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(0, ret);
EXPECT_EQ((uint32_t)drm->storedEUVal, outHwInfo.gtSystemInfo.EUCount);
EXPECT_EQ((uint32_t)drm->storedSSVal, outHwInfo.gtSystemInfo.SubSliceCount);
EXPECT_EQ((unsigned int)drm->storedHasPooledEU, outHwInfo.featureTable.flags.ftrPooledEuEnabled);
EXPECT_EQ((uint32_t)drm->storedMinEUinPool, outHwInfo.gtSystemInfo.EuCountPerPoolMin);
EXPECT_EQ((outHwInfo.gtSystemInfo.EUCount - outHwInfo.gtSystemInfo.EuCountPerPoolMin), outHwInfo.gtSystemInfo.EuCountPerPoolMax);
@@ -68,26 +60,6 @@ BXTTEST_F(BxtProductHelperLinux, WhenConfiguringHwInfoThenConfigIsCorrect) {
EXPECT_EQ(200000, outKmdNotifyProperties.delayQuickKmdSleepForSporadicWaitsMicroseconds);
}
BXTTEST_F(BxtProductHelperLinux, GivenFailedIoctlEuCountWhenConfiguringHwInfoThenErrorIsReturned) {
drm->failRetTopology = true;
drm->storedRetValForEUVal = -4;
auto ret = productHelper->configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(-4, ret);
}
BXTTEST_F(BxtProductHelperLinux, GivenFailingEnabledPoolWhenConfiguringHwInfoThenZeroIsReturned) {
drm->storedRetValForPooledEU = -1;
auto ret = productHelper->configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(0, ret);
EXPECT_EQ(0u, outHwInfo.featureTable.flags.ftrPooledEuEnabled);
EXPECT_EQ(0u, outHwInfo.gtSystemInfo.EuCountPerPoolMin);
EXPECT_EQ(0u, outHwInfo.gtSystemInfo.EuCountPerPoolMax);
}
BXTTEST_F(BxtProductHelperLinux, GivenDisabledEnabledPoolWhenConfiguringHwInfoThenZeroIsReturned) {
drm->storedHasPooledEU = 0;
@@ -99,47 +71,6 @@ BXTTEST_F(BxtProductHelperLinux, GivenDisabledEnabledPoolWhenConfiguringHwInfoTh
EXPECT_EQ(0u, outHwInfo.gtSystemInfo.EuCountPerPoolMax);
}
BXTTEST_F(BxtProductHelperLinux, GivenFailingMinEuInPoolWhenConfiguringHwInfoThenZeroIsReturned) {
drm->storedRetValForMinEUinPool = -1;
drm->storedSSVal = 3;
auto ret = productHelper->configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(0, ret);
EXPECT_EQ(1u, outHwInfo.featureTable.flags.ftrPooledEuEnabled);
EXPECT_EQ(9u, outHwInfo.gtSystemInfo.EuCountPerPoolMin);
EXPECT_EQ((outHwInfo.gtSystemInfo.EUCount - outHwInfo.gtSystemInfo.EuCountPerPoolMin), outHwInfo.gtSystemInfo.EuCountPerPoolMax);
drm->storedSSVal = 2;
ret = productHelper->configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(0, ret);
EXPECT_EQ(1u, outHwInfo.featureTable.flags.ftrPooledEuEnabled);
EXPECT_EQ(3u, outHwInfo.gtSystemInfo.EuCountPerPoolMin);
EXPECT_EQ((outHwInfo.gtSystemInfo.EUCount - outHwInfo.gtSystemInfo.EuCountPerPoolMin), outHwInfo.gtSystemInfo.EuCountPerPoolMax);
}
BXTTEST_F(BxtProductHelperLinux, GivenInvalidMinEuInPoolWhenConfiguringHwInfoThenZeroIsReturned) {
drm->storedMinEUinPool = 4;
drm->storedSSVal = 3;
auto ret = productHelper->configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(0, ret);
EXPECT_EQ(1u, outHwInfo.featureTable.flags.ftrPooledEuEnabled);
EXPECT_EQ(9u, outHwInfo.gtSystemInfo.EuCountPerPoolMin);
EXPECT_EQ((outHwInfo.gtSystemInfo.EUCount - outHwInfo.gtSystemInfo.EuCountPerPoolMin), outHwInfo.gtSystemInfo.EuCountPerPoolMax);
drm->storedSSVal = 2;
ret = productHelper->configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(0, ret);
EXPECT_EQ(1u, outHwInfo.featureTable.flags.ftrPooledEuEnabled);
EXPECT_EQ(3u, outHwInfo.gtSystemInfo.EuCountPerPoolMin);
EXPECT_EQ((outHwInfo.gtSystemInfo.EUCount - outHwInfo.gtSystemInfo.EuCountPerPoolMin), outHwInfo.gtSystemInfo.EuCountPerPoolMax);
}
template <typename T>
class BxtHwInfoTests : public ::testing::Test {
};
@@ -163,5 +94,5 @@ TYPED_TEST(BxtHwInfoTests, WhenConfiguringHwInfoThenConfigIsCorrect) {
EXPECT_GT(gtSystemInfo.SubSliceCount, 0u);
EXPECT_GT_VAL(gtSystemInfo.L3CacheSizeInKb, 0u);
EXPECT_EQ(gtSystemInfo.CsrSizeInMb, 8u);
EXPECT_FALSE(gtSystemInfo.IsDynamicallyPopulated);
EXPECT_TRUE(gtSystemInfo.IsDynamicallyPopulated);
}

28
shared/test/unit_test/gen9/cfl/linux/product_helper_tests_cfl.cpp
View File

@@ -24,8 +24,6 @@ CFLTEST_F(CflProductHelperLinux, WhenConfiguringHwInfoThenInformationIsCorrect)
auto ret = productHelper->configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(0, ret);
EXPECT_EQ((uint32_t)drm->storedEUVal, outHwInfo.gtSystemInfo.EUCount);
EXPECT_EQ((uint32_t)drm->storedSSVal, outHwInfo.gtSystemInfo.SubSliceCount);
EXPECT_EQ(aub_stream::ENGINE_RCS, outHwInfo.capabilityTable.defaultEngineType);
// constant sysInfo/ftr flags
@@ -33,23 +31,15 @@ CFLTEST_F(CflProductHelperLinux, WhenConfiguringHwInfoThenInformationIsCorrect)
EXPECT_TRUE(outHwInfo.gtSystemInfo.VEBoxInfo.IsValid);
pInHwInfo.platform.usDeviceID = 0x3E90;
drm->storedSSVal = 3;
ret = productHelper->configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(0, ret);
EXPECT_EQ((uint32_t)drm->storedEUVal, outHwInfo.gtSystemInfo.EUCount);
EXPECT_EQ((uint32_t)drm->storedSSVal, outHwInfo.gtSystemInfo.SubSliceCount);
EXPECT_EQ(1u, outHwInfo.gtSystemInfo.SliceCount);
EXPECT_EQ(aub_stream::ENGINE_RCS, outHwInfo.capabilityTable.defaultEngineType);
pInHwInfo.platform.usDeviceID = 0x3EA5;
drm->storedSSVal = 6;
ret = productHelper->configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(0, ret);
EXPECT_EQ((uint32_t)drm->storedEUVal, outHwInfo.gtSystemInfo.EUCount);
EXPECT_EQ((uint32_t)drm->storedSSVal, outHwInfo.gtSystemInfo.SubSliceCount);
EXPECT_EQ(2u, outHwInfo.gtSystemInfo.SliceCount);
EXPECT_EQ(aub_stream::ENGINE_RCS, outHwInfo.capabilityTable.defaultEngineType);
auto &outKmdNotifyProperties = outHwInfo.capabilityTable.kmdNotifyProperties;
@@ -63,22 +53,6 @@ CFLTEST_F(CflProductHelperLinux, WhenConfiguringHwInfoThenInformationIsCorrect)
EXPECT_EQ(0, outKmdNotifyProperties.delayQuickKmdSleepForDirectSubmissionMicroseconds);
}
CFLTEST_F(CflProductHelperLinux, GivenFailedIoctlEuCountWhenConfiguringHwInfoThenErrorIsReturned) {
drm->storedRetValForEUVal = -4;
drm->failRetTopology = true;
auto ret = productHelper->configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(-4, ret);
}
CFLTEST_F(CflProductHelperLinux, GivenFailedIoctlSsCountWhenConfiguringHwInfoThenErrorIsReturned) {
drm->storedRetValForSSVal = -5;
drm->failRetTopology = true;
auto ret = productHelper->configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(-5, ret);
}
CFLTEST_F(CflProductHelperLinux, WhenConfiguringHwInfoThenEdramInformationIsCorrect) {
auto ret = productHelper->configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
@@ -126,5 +100,5 @@ TYPED_TEST(CflHwInfoTests, WhenGtIsSetupThenGtSystemInfoIsCorrect) {
EXPECT_GT(gtSystemInfo.DualSubSliceCount, 0u);
EXPECT_GT_VAL(gtSystemInfo.L3CacheSizeInKb, 0u);
EXPECT_EQ(gtSystemInfo.CsrSizeInMb, 8u);
EXPECT_FALSE(gtSystemInfo.IsDynamicallyPopulated);
EXPECT_TRUE(gtSystemInfo.IsDynamicallyPopulated);
}

62
shared/test/unit_test/gen9/glk/linux/product_helper_tests_glk.cpp
View File

@@ -70,20 +70,6 @@ GLKTEST_F(GlkProductHelperLinux, WhenConfiguringHwInfoThenInformationIsCorrect)
EXPECT_EQ(0, outKmdNotifyProperties.delayQuickKmdSleepForDirectSubmissionMicroseconds);
}
GLKTEST_F(GlkProductHelperLinux, GivenInvalidInputWhenConfiguringHwInfoThenErrorIsReturned) {
drm->failRetTopology = true;
drm->storedRetValForEUVal = -1;
auto ret = productHelper->configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(-1, ret);
drm->storedRetValForEUVal = 0;
drm->storedRetValForSSVal = -1;
ret = productHelper->configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(-1, ret);
}
GLKTEST_F(GlkProductHelperLinux, GivenFailingEnabledPoolWhenConfiguringHwInfoThenZeroIsSet) {
drm->storedRetValForPooledEU = -1;
@@ -106,52 +92,6 @@ GLKTEST_F(GlkProductHelperLinux, GivenDisabledEnabledPoolWhenConfiguringHwInfoTh
EXPECT_EQ(0u, outHwInfo.gtSystemInfo.EuCountPerPoolMax);
}
GLKTEST_F(GlkProductHelperLinux, GivenFailingMinEuInPoolWhenConfiguringHwInfoThenCorrectValueSet) {
drm->storedRetValForMinEUinPool = -1;
drm->storedSSVal = 3;
auto ret = productHelper->configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(0, ret);
EXPECT_EQ(1u, outHwInfo.featureTable.flags.ftrPooledEuEnabled);
EXPECT_EQ(9u, outHwInfo.gtSystemInfo.EuCountPerPoolMin);
EXPECT_EQ((outHwInfo.gtSystemInfo.EUCount - outHwInfo.gtSystemInfo.EuCountPerPoolMin), outHwInfo.gtSystemInfo.EuCountPerPoolMax);
drm->storedSSVal = 2;
ret = productHelper->configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(0, ret);
EXPECT_EQ(1u, outHwInfo.featureTable.flags.ftrPooledEuEnabled);
EXPECT_EQ(3u, outHwInfo.gtSystemInfo.EuCountPerPoolMin);
EXPECT_EQ((outHwInfo.gtSystemInfo.EUCount - outHwInfo.gtSystemInfo.EuCountPerPoolMin), outHwInfo.gtSystemInfo.EuCountPerPoolMax);
}
GLKTEST_F(GlkProductHelperLinux, GivenInvalidMinEuInPoolWhenConfiguringHwInfoThenCorrectValueSet) {
drm->storedMinEUinPool = 4;
drm->storedSSVal = 3;
auto ret = productHelper->configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(0, ret);
EXPECT_EQ(1u, outHwInfo.featureTable.flags.ftrPooledEuEnabled);
EXPECT_EQ(9u, outHwInfo.gtSystemInfo.EuCountPerPoolMin);
EXPECT_EQ((outHwInfo.gtSystemInfo.EUCount - outHwInfo.gtSystemInfo.EuCountPerPoolMin), outHwInfo.gtSystemInfo.EuCountPerPoolMax);
drm->storedSSVal = 2;
ret = productHelper->configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(0, ret);
EXPECT_EQ(1u, outHwInfo.featureTable.flags.ftrPooledEuEnabled);
EXPECT_EQ(3u, outHwInfo.gtSystemInfo.EuCountPerPoolMin);
EXPECT_EQ((outHwInfo.gtSystemInfo.EUCount - outHwInfo.gtSystemInfo.EuCountPerPoolMin), outHwInfo.gtSystemInfo.EuCountPerPoolMax);
}
GLKTEST_F(GlkProductHelperLinux, GivenWaFlagsWhenConfiguringHwInfoThenInformationIsCorrect) {
pInHwInfo.platform.usRevId = 0;
auto ret = productHelper->configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(0, ret);
}
template <typename T>
class GlkHwInfoTests : public ::testing::Test {
};
@@ -178,5 +118,5 @@ TYPED_TEST(GlkHwInfoTests, WhenGtIsSetupThenGtSystemInfoIsCorrect) {
EXPECT_GT(gtSystemInfo.DualSubSliceCount, 0u);
EXPECT_GT_VAL(gtSystemInfo.L3CacheSizeInKb, 0u);
EXPECT_EQ(gtSystemInfo.CsrSizeInMb, 8u);
EXPECT_FALSE(gtSystemInfo.IsDynamicallyPopulated);
EXPECT_TRUE(gtSystemInfo.IsDynamicallyPopulated);
}

26
shared/test/unit_test/gen9/kbl/linux/product_helper_tests_kbl.cpp
View File

@@ -51,18 +51,10 @@ KBLTEST_F(KblProductHelperLinux, WhenConfiguringHwInfoThenInformationIsCorrect)
ret = productHelper->configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(0, ret);
EXPECT_EQ((uint32_t)drm->storedEUVal, outHwInfo.gtSystemInfo.EUCount);
EXPECT_EQ((uint32_t)drm->storedSSVal, outHwInfo.gtSystemInfo.SubSliceCount);
EXPECT_EQ(2u, outHwInfo.gtSystemInfo.SliceCount);
EXPECT_EQ(aub_stream::ENGINE_RCS, outHwInfo.capabilityTable.defaultEngineType);
drm->storedSSVal = 6;
ret = productHelper->configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(0, ret);
EXPECT_EQ((uint32_t)drm->storedEUVal, outHwInfo.gtSystemInfo.EUCount);
EXPECT_EQ((uint32_t)drm->storedSSVal, outHwInfo.gtSystemInfo.SubSliceCount);
EXPECT_EQ(2u, outHwInfo.gtSystemInfo.SliceCount);
EXPECT_EQ(aub_stream::ENGINE_RCS, outHwInfo.capabilityTable.defaultEngineType);
auto &outKmdNotifyProperties = outHwInfo.capabilityTable.kmdNotifyProperties;
@@ -76,22 +68,6 @@ KBLTEST_F(KblProductHelperLinux, WhenConfiguringHwInfoThenInformationIsCorrect)
EXPECT_EQ(0, outKmdNotifyProperties.delayQuickKmdSleepForDirectSubmissionMicroseconds);
}
KBLTEST_F(KblProductHelperLinux, GivenFailedIoctlEuCountWhenConfiguringHwInfoThenErrorIsReturned) {
drm->failRetTopology = true;
drm->storedRetValForEUVal = -4;
int ret = productHelper->configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(-4, ret);
}
KBLTEST_F(KblProductHelperLinux, GivenFailedIoctlSsCountWhenConfiguringHwInfoThenErrorIsReturned) {
drm->failRetTopology = true;
drm->storedRetValForSSVal = -5;
int ret = productHelper->configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(-5, ret);
}
KBLTEST_F(KblProductHelperLinux, GivenWaFlagsWhenConfiguringHwInfoThenInformationIsCorrect) {
outHwInfo.platform.usRevId = 0;
@@ -158,5 +134,5 @@ TYPED_TEST(KblHwInfoTests, WhenGtIsSetupThenGtSystemInfoIsCorrect) {
EXPECT_GT(gtSystemInfo.DualSubSliceCount, 0u);
EXPECT_GT_VAL(gtSystemInfo.L3CacheSizeInKb, 0u);
EXPECT_EQ(gtSystemInfo.CsrSizeInMb, 8u);
EXPECT_FALSE(gtSystemInfo.IsDynamicallyPopulated);
EXPECT_TRUE(gtSystemInfo.IsDynamicallyPopulated);
}

32
shared/test/unit_test/gen9/skl/linux/product_helper_tests_skl.cpp
View File

@@ -22,8 +22,6 @@ struct SklProductHelperLinux : ProductHelperTestLinux {
SKLTEST_F(SklProductHelperLinux, WhenConfiguringHwInfoThenInformationIsCorrect) {
int ret = productHelper->configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(0, ret);
EXPECT_EQ((uint32_t)drm->storedEUVal, outHwInfo.gtSystemInfo.EUCount);
EXPECT_EQ((uint32_t)drm->storedSSVal, outHwInfo.gtSystemInfo.SubSliceCount);
EXPECT_EQ(aub_stream::ENGINE_RCS, outHwInfo.capabilityTable.defaultEngineType);
// constant sysInfo/ftr flags
@@ -34,38 +32,26 @@ SKLTEST_F(SklProductHelperLinux, WhenConfiguringHwInfoThenInformationIsCorrect)
pInHwInfo.platform.usDeviceID = 0x1902;
drm->storedSSVal = 3;
ret = productHelper->configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(0, ret);
EXPECT_EQ((uint32_t)drm->storedEUVal, outHwInfo.gtSystemInfo.EUCount);
EXPECT_EQ((uint32_t)drm->storedSSVal, outHwInfo.gtSystemInfo.SubSliceCount);
EXPECT_EQ(1u, outHwInfo.gtSystemInfo.SliceCount);
EXPECT_EQ(aub_stream::ENGINE_RCS, outHwInfo.capabilityTable.defaultEngineType);
pInHwInfo.platform.usDeviceID = 0x1917;
ret = productHelper->configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(0, ret);
EXPECT_EQ((uint32_t)drm->storedEUVal, outHwInfo.gtSystemInfo.EUCount);
EXPECT_EQ((uint32_t)drm->storedSSVal, outHwInfo.gtSystemInfo.SubSliceCount);
EXPECT_EQ(aub_stream::ENGINE_RCS, outHwInfo.capabilityTable.defaultEngineType);
pInHwInfo.platform.usDeviceID = 0x0903;
ret = productHelper->configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(0, ret);
EXPECT_EQ((uint32_t)drm->storedEUVal, outHwInfo.gtSystemInfo.EUCount);
EXPECT_EQ((uint32_t)drm->storedSSVal, outHwInfo.gtSystemInfo.SubSliceCount);
EXPECT_EQ(aub_stream::ENGINE_RCS, outHwInfo.capabilityTable.defaultEngineType);
pInHwInfo.platform.usDeviceID = 0x0903;
drm->storedSSVal = 6;
ret = productHelper->configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(0, ret);
EXPECT_EQ((uint32_t)drm->storedEUVal, outHwInfo.gtSystemInfo.EUCount);
EXPECT_EQ((uint32_t)drm->storedSSVal, outHwInfo.gtSystemInfo.SubSliceCount);
EXPECT_EQ(1u, outHwInfo.gtSystemInfo.SliceCount);
EXPECT_EQ(aub_stream::ENGINE_RCS, outHwInfo.capabilityTable.defaultEngineType);
auto &outKmdNotifyProperties = outHwInfo.capabilityTable.kmdNotifyProperties;
@@ -79,22 +65,6 @@ SKLTEST_F(SklProductHelperLinux, WhenConfiguringHwInfoThenInformationIsCorrect)
EXPECT_EQ(0, outKmdNotifyProperties.delayQuickKmdSleepForDirectSubmissionMicroseconds);
}
SKLTEST_F(SklProductHelperLinux, GivenFailedIoctlEuCountWhenConfiguringHwInfoThenErrorIsReturned) {
drm->storedRetValForEUVal = -4;
drm->failRetTopology = true;
int ret = productHelper->configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(-4, ret);
}
SKLTEST_F(SklProductHelperLinux, GivenFailedIoctlSsCountWhenConfiguringHwInfoThenErrorIsReturned) {
drm->storedRetValForSSVal = -5;
drm->failRetTopology = true;
int ret = productHelper->configureHwInfoDrm(&pInHwInfo, &outHwInfo, getRootDeviceEnvironment());
EXPECT_EQ(-5, ret);
}
SKLTEST_F(SklProductHelperLinux, GivenWaFlagsWhenConfiguringHwInfoThenInformationIsCorrect) {
pInHwInfo.platform.usRevId = 1;
@@ -188,7 +158,7 @@ TYPED_TEST(SklHwInfoTests, WhenGtIsSetupThenGtSystemInfoIsCorrect) {
EXPECT_GT(gtSystemInfo.DualSubSliceCount, 0u);
EXPECT_GT_VAL(gtSystemInfo.L3CacheSizeInKb, 0u);
EXPECT_EQ(gtSystemInfo.CsrSizeInMb, 8u);
EXPECT_FALSE(gtSystemInfo.IsDynamicallyPopulated);
EXPECT_TRUE(gtSystemInfo.IsDynamicallyPopulated);
}
TYPED_TEST(SklHwInfoTests, givenGTSystemInfoTypeWhenConfigureHardwareCustomThenSliceCountDontChange) {

37
shared/test/unit_test/os_interface/linux/device_factory_tests_linux.cpp
View File

@@ -22,43 +22,6 @@ namespace NEO {
extern std::map<std::string, std::vector<std::string>> directoryFilesMap;
};
TEST_F(DeviceFactoryLinuxTest, WhenPreparingDeviceEnvironmentsThenInitializedCorrectly) {
const HardwareInfo *refHwinfo = defaultHwInfo.get();
pDrm->storedEUVal = 16;
pDrm->storedSSVal = 8;
bool success = DeviceFactory::prepareDeviceEnvironments(executionEnvironment);
auto hwInfo = executionEnvironment.rootDeviceEnvironments[0]->getHardwareInfo();
EXPECT_TRUE(success);
EXPECT_NE(hwInfo, nullptr);
EXPECT_EQ(refHwinfo->platform.eDisplayCoreFamily, hwInfo->platform.eDisplayCoreFamily);
EXPECT_EQ((int)hwInfo->gtSystemInfo.EUCount, 16);
EXPECT_EQ((int)hwInfo->gtSystemInfo.SubSliceCount, 8);
EXPECT_EQ((int)hwInfo->gtSystemInfo.DualSubSliceCount, 8);
}
TEST_F(DeviceFactoryLinuxTest, givenSomeDisabledSSAndEUWhenPrepareDeviceEnvironmentsThenCorrectObtainEUCntSSCnt) {
const HardwareInfo *refHwinfo = defaultHwInfo.get();
pDrm->storedEUVal = 144;
pDrm->storedSSVal = 12;
pDrm->storedSVal = 2;
pDrm->disableSomeTopology = true;
bool success = DeviceFactory::prepareDeviceEnvironments(executionEnvironment);
auto hwInfo = executionEnvironment.rootDeviceEnvironments[0]->getHardwareInfo();
EXPECT_TRUE(success);
EXPECT_NE(hwInfo, nullptr);
EXPECT_EQ(refHwinfo->platform.eDisplayCoreFamily, hwInfo->platform.eDisplayCoreFamily);
EXPECT_EQ((int)hwInfo->gtSystemInfo.SliceCount, 1);
EXPECT_EQ((int)hwInfo->gtSystemInfo.SubSliceCount, 2);
EXPECT_EQ((int)hwInfo->gtSystemInfo.DualSubSliceCount, 2);
EXPECT_EQ((int)hwInfo->gtSystemInfo.EUCount, 12);
}
TEST_F(DeviceFactoryLinuxTest, givenGetDeviceCallWhenItIsDoneThenOsInterfaceIsAllocatedAndItContainDrm) {
bool success = DeviceFactory::prepareDeviceEnvironments(executionEnvironment);
EXPECT_TRUE(success);

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

@@ -19,38 +19,6 @@
using namespace NEO;
using HwConfigTopologyQuery = ::testing::Test;
HWTEST2_F(HwConfigTopologyQuery, WhenGettingTopologyFailsThenSetMaxValuesBasedOnSubsliceIoctlQuery, MatchAny) {
auto executionEnvironment = std::make_unique<MockExecutionEnvironment>();
auto drm = new DrmMock(*executionEnvironment->rootDeviceEnvironments[0]);
executionEnvironment->rootDeviceEnvironments[0]->osInterface = std::make_unique<OSInterface>();
auto osInterface = executionEnvironment->rootDeviceEnvironments[0]->osInterface.get();
osInterface->setDriverModel(std::unique_ptr<Drm>(drm));
drm->failRetTopology = true;
auto hwInfo = *executionEnvironment->rootDeviceEnvironments[0]->getHardwareInfo();
HardwareInfo outHwInfo;
hwInfo.gtSystemInfo.MaxSlicesSupported = 0;
hwInfo.gtSystemInfo.MaxSubSlicesSupported = 0;
hwInfo.gtSystemInfo.MaxEuPerSubSlice = 6;
auto &productHelper = executionEnvironment->rootDeviceEnvironments[0]->getHelper<ProductHelper>();
int ret = productHelper.configureHwInfoDrm(&hwInfo, &outHwInfo, *executionEnvironment->rootDeviceEnvironments[0].get());
EXPECT_NE(-1, ret);
EXPECT_EQ(6u, outHwInfo.gtSystemInfo.MaxEuPerSubSlice);
EXPECT_EQ(outHwInfo.gtSystemInfo.SubSliceCount, outHwInfo.gtSystemInfo.MaxSubSlicesSupported);
EXPECT_EQ(hwInfo.gtSystemInfo.SliceCount, outHwInfo.gtSystemInfo.MaxSlicesSupported);
EXPECT_EQ(static_cast<uint32_t>(drm->storedEUVal), outHwInfo.gtSystemInfo.EUCount);
EXPECT_EQ(static_cast<uint32_t>(drm->storedSSVal), outHwInfo.gtSystemInfo.SubSliceCount);
}
TEST(DrmQueryTest, WhenCallingIsDebugAttachAvailableThenReturnValueIsFalse) {
auto executionEnvironment = std::make_unique<MockExecutionEnvironment>();
DrmMock drm{*executionEnvironment->rootDeviceEnvironments[0]};

2
shared/test/unit_test/os_interface/linux/drm_query_topology_prelim_tests.cpp
View File

@@ -26,7 +26,7 @@ TEST(DrmQueryTopologyTest, givenDrmWhenQueryTopologyCalledThenPassNoFlags) {
DrmQueryMock drm{*executionEnvironment->rootDeviceEnvironments[0]};
DrmQueryTopologyData topologyData = {};
drm.engineInfoQueried = true;
EXPECT_TRUE(drm.queryTopology(*drm.context.hwInfo, topologyData));
constexpr uint32_t expectedFlag = 0;

4
shared/test/unit_test/os_interface/linux/drm_query_topology_upstream_tests.cpp
View File

@@ -16,7 +16,7 @@ TEST(DrmQueryTopologyTest, GivenDrmWhenQueryingTopologyInfoCorrectMaxValuesAreSe
DrmMock drm{*executionEnvironment->rootDeviceEnvironments[0]};
DrmQueryTopologyData topologyData = {};
drm.engineInfoQueried = true;
EXPECT_TRUE(drm.queryTopology(*executionEnvironment->rootDeviceEnvironments[0]->getHardwareInfo(), topologyData));
EXPECT_EQ(drm.storedSVal, topologyData.sliceCount);
@@ -33,7 +33,7 @@ TEST(DrmQueryTopologyTest, givenDrmWhenGettingSliceMappingsThenCorrectMappingRet
DrmMock drmMock{*executionEnvironment->rootDeviceEnvironments[0]};
DrmQueryTopologyData topologyData = {};
drmMock.engineInfoQueried = true;
EXPECT_TRUE(drmMock.queryTopology(*executionEnvironment->rootDeviceEnvironments[0]->getHardwareInfo(), topologyData));
auto device0SliceMapping = drmMock.getSliceMappings(0);

9
shared/test/unit_test/os_interface/linux/drm_system_info_tests.cpp
View File

@@ -312,7 +312,6 @@ TEST(DrmSystemInfoTest, givenSetupHardwareInfoWhenQuerySystemInfoSucceedsThenSys
drm.storedSSVal = 1u;
drm.storedEUVal = 1u;
auto expectedMaxSlicesSupported = dummyDeviceBlobData[2];
auto expectedMaxSubslicesSupported = dummyDeviceBlobData[5];
auto expectedMaxEusPerSubsliceSupported = dummyDeviceBlobData[8];
@@ -324,9 +323,6 @@ TEST(DrmSystemInfoTest, givenSetupHardwareInfoWhenQuerySystemInfoSucceedsThenSys
EXPECT_NE(nullptr, drm.getSystemInfo());
const auto &gtSystemInfo = executionEnvironment->rootDeviceEnvironments[0]->getHardwareInfo()->gtSystemInfo;
EXPECT_EQ(expectedMaxSlicesSupported, gtSystemInfo.MaxSlicesSupported);
EXPECT_NE(0u, gtSystemInfo.MaxSlicesSupported);
EXPECT_EQ(expectedMaxSubslicesSupported, gtSystemInfo.MaxSubSlicesSupported);
EXPECT_NE(0u, gtSystemInfo.MaxSubSlicesSupported);
@@ -452,13 +448,14 @@ TEST(DrmSystemInfoTest, givenHardwareInfoWithoutEuCountWhenQuerySystemInfoSuccee
TEST(DrmSystemInfoTest, givenHardwareInfoWithoutEuCountWhenQuerySystemInfoFailsThenFailureIsReturned) {
auto executionEnvironment = std::make_unique<MockExecutionEnvironment>();
executionEnvironment->rootDeviceEnvironments[0]->initGmm();
DrmMockEngine drm(*executionEnvironment->rootDeviceEnvironments[0]);
HardwareInfo &hwInfo = *executionEnvironment->rootDeviceEnvironments[0]->getMutableHardwareInfo();
hwInfo.gtSystemInfo.EUCount = 0u;
hwInfo.gtSystemInfo.SubSliceCount = 2u;
hwInfo.gtSystemInfo.DualSubSliceCount = 2u;
DrmMockEngine drm(*executionEnvironment->rootDeviceEnvironments[0]);
hwInfo.gtSystemInfo.MaxEuPerSubSlice = 0u;
drm.storedEUVal = 0;
drm.failRetTopology = true;

10
shared/test/unit_test/os_interface/linux/drm_tests.cpp
View File

@@ -961,9 +961,13 @@ TEST(DrmQueryTest, GivenDrmWhenSetupHardwareInfoCalledThenCorrectMaxValuesInGtSy
drm.ioctlHelper.reset();
drm.setupHardwareInfo(&device, false);
EXPECT_NE(nullptr, drm.getIoctlHelper());
EXPECT_EQ(NEO::defaultHwInfo->gtSystemInfo.MaxSlicesSupported, hwInfo->gtSystemInfo.MaxSlicesSupported);
EXPECT_EQ(2u, hwInfo->gtSystemInfo.MaxSlicesSupported);
EXPECT_EQ(NEO::defaultHwInfo->gtSystemInfo.MaxSubSlicesSupported, hwInfo->gtSystemInfo.MaxSubSlicesSupported);
EXPECT_EQ(NEO::defaultHwInfo->gtSystemInfo.MaxEuPerSubSlice, hwInfo->gtSystemInfo.MaxEuPerSubSlice);
for (uint32_t i = 0; i < hwInfo->gtSystemInfo.SliceCount; i++) {
EXPECT_TRUE(hwInfo->gtSystemInfo.SliceInfo[i].Enabled);
}
}
TEST(DrmQueryTest, GivenLessAvailableSubSlicesThanMaxSubSlicesWhenQueryingTopologyInfoThenCorrectMaxSubSliceCountIsSet) {
@@ -978,6 +982,7 @@ TEST(DrmQueryTest, GivenLessAvailableSubSlicesThanMaxSubSlicesWhenQueryingTopolo
drm.storedSSVal = drm.storedSVal * 7;
drm.storedEUVal = drm.storedSSVal * 4;
drm.engineInfoQueried = true;
EXPECT_TRUE(drm.queryTopology(*executionEnvironment->rootDeviceEnvironments[0]->getHardwareInfo(), topologyData));
EXPECT_EQ(2, topologyData.sliceCount);
@@ -996,6 +1001,7 @@ TEST(DrmQueryTest, givenDrmWhenGettingTopologyMapThenCorrectMapIsReturned) {
DrmQueryTopologyData topologyData = {};
drmMock.engineInfoQueried = true;
EXPECT_TRUE(drmMock.queryTopology(*executionEnvironment->rootDeviceEnvironments[0]->getHardwareInfo(), topologyData));
auto topologyMap = drmMock.getTopologyMap();
@@ -1018,6 +1024,7 @@ TEST(DrmQueryTest, GivenSingleSliceConfigWhenQueryingTopologyInfoThenSubsliceInd
drm.storedSSVal = drm.storedSVal * 7;
drm.storedEUVal = drm.storedSSVal * 4;
drm.engineInfoQueried = true;
EXPECT_TRUE(drm.queryTopology(*executionEnvironment->rootDeviceEnvironments[0]->getHardwareInfo(), topologyData));
EXPECT_EQ(1, topologyData.sliceCount);
@@ -1050,6 +1057,7 @@ TEST(DrmQueryTest, GivenMultiSliceConfigWhenQueryingTopologyInfoThenSubsliceIndi
drm.storedSSVal = drm.storedSVal * 7;
drm.storedEUVal = drm.storedSSVal * 4;
drm.engineInfoQueried = true;
EXPECT_TRUE(drm.queryTopology(*executionEnvironment->rootDeviceEnvironments[0]->getHardwareInfo(), topologyData));
EXPECT_EQ(2, topologyData.sliceCount);

96
shared/test/unit_test/os_interface/linux/product_helper_linux_tests.cpp
View File

@@ -84,22 +84,6 @@ TEST_F(MockProductHelperTestLinux, givenDisabledPlatformCoherencyWhenConfiguring
EXPECT_FALSE(outHwInfo.capabilityTable.ftrSupportsCoherency);
}
TEST_F(MockProductHelperTestLinux, GivenFailGetEuCountWhenConfiguringHwInfoThenFails) {
drm->storedRetValForEUVal = -4;
drm->failRetTopology = true;
int ret = mockProductHelper->configureHwInfoDrm(&pInHwInfo, &outHwInfo, *executionEnvironment->rootDeviceEnvironments[0].get());
EXPECT_EQ(-4, ret);
}
TEST_F(MockProductHelperTestLinux, GivenFailGetSsCountWhenConfiguringHwInfoThenFails) {
drm->storedRetValForSSVal = -5;
drm->failRetTopology = true;
int ret = mockProductHelper->configureHwInfoDrm(&pInHwInfo, &outHwInfo, *executionEnvironment->rootDeviceEnvironments[0].get());
EXPECT_EQ(-5, ret);
}
TEST_F(MockProductHelperTestLinux, whenFailGettingTopologyThenFallbackToEuCountIoctl) {
drm->failRetTopology = true;
@@ -111,7 +95,7 @@ TEST_F(MockProductHelperTestLinux, givenInvalidTopologyDataWhenConfiguringThenRe
auto storedSVal = drm->storedSVal;
auto storedSSVal = drm->storedSSVal;
auto storedEUVal = drm->storedEUVal;
drm->engineInfoQueried = true;
{
// 0 euCount
drm->storedSVal = storedSVal;
@@ -368,84 +352,6 @@ HWTEST2_F(HwConfigLinux, givenPlatformWithPlatformQuerySupportedWhenItIsCalledTh
EXPECT_TRUE(productHelper.isPlatformQuerySupported());
}
HWTEST2_F(HwConfigLinux, GivenDifferentValuesFromTopologyQueryWhenConfiguringHwInfoThenMaxSlicesSupportedSetToAvailableCountInGtSystemInfo, MatchAny) {
auto executionEnvironment = std::make_unique<ExecutionEnvironment>();
executionEnvironment->prepareRootDeviceEnvironments(1);
executionEnvironment->rootDeviceEnvironments[0]->setHwInfoAndInitHelpers(NEO::defaultHwInfo.get());
auto drm = new DrmMock(*executionEnvironment->rootDeviceEnvironments[0]);
executionEnvironment->rootDeviceEnvironments[0]->osInterface = std::make_unique<OSInterface>();
auto osInterface = executionEnvironment->rootDeviceEnvironments[0]->osInterface.get();
osInterface->setDriverModel(std::unique_ptr<DriverModel>(drm));
auto hwInfo = *executionEnvironment->rootDeviceEnvironments[0]->getHardwareInfo();
HardwareInfo outHwInfo;
auto &productHelper = executionEnvironment->rootDeviceEnvironments[0]->getHelper<ProductHelper>();
hwInfo.gtSystemInfo.MaxSubSlicesSupported = drm->storedSSVal * 2;
hwInfo.gtSystemInfo.MaxDualSubSlicesSupported = drm->storedSSVal * 2;
hwInfo.gtSystemInfo.MaxEuPerSubSlice = 16;
hwInfo.gtSystemInfo.MaxSlicesSupported = drm->storedSVal * 4;
int ret = productHelper.configureHwInfoDrm(&hwInfo, &outHwInfo, *executionEnvironment->rootDeviceEnvironments[0].get());
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.MaxDualSubSlicesSupported);
EXPECT_EQ(16u, outHwInfo.gtSystemInfo.MaxEuPerSubSlice);
EXPECT_EQ(static_cast<uint32_t>(drm->storedSVal), outHwInfo.gtSystemInfo.MaxSlicesSupported);
drm->storedSVal = 3;
drm->storedSSVal = 12;
drm->storedEUVal = 12 * 8;
hwInfo.gtSystemInfo.MaxSubSlicesSupported = drm->storedSSVal / 2;
hwInfo.gtSystemInfo.MaxDualSubSlicesSupported = drm->storedSSVal / 2;
hwInfo.gtSystemInfo.MaxEuPerSubSlice = 6;
hwInfo.gtSystemInfo.MaxSlicesSupported = drm->storedSVal / 2;
ret = productHelper.configureHwInfoDrm(&hwInfo, &outHwInfo, *executionEnvironment->rootDeviceEnvironments[0].get());
EXPECT_EQ(0, ret);
EXPECT_EQ(12u, outHwInfo.gtSystemInfo.MaxSubSlicesSupported);
EXPECT_EQ(6u, outHwInfo.gtSystemInfo.MaxEuPerSubSlice); // MaxEuPerSubslice is preserved
EXPECT_EQ(static_cast<uint32_t>(drm->storedSVal), outHwInfo.gtSystemInfo.MaxSlicesSupported);
EXPECT_EQ(outHwInfo.gtSystemInfo.MaxSubSlicesSupported, outHwInfo.gtSystemInfo.MaxDualSubSlicesSupported);
hwInfo.gtSystemInfo.MaxEuPerSubSlice = 0;
ret = productHelper.configureHwInfoDrm(&hwInfo, &outHwInfo, *executionEnvironment->rootDeviceEnvironments[0].get());
EXPECT_EQ(0, ret);
EXPECT_EQ(8u, outHwInfo.gtSystemInfo.MaxEuPerSubSlice);
}
HWTEST2_F(HwConfigLinux, givenSliceCountWhenConfigureHwInfoDrmThenProperInitializationInSliceInfoEnabled, MatchAny) {
auto executionEnvironment = std::make_unique<ExecutionEnvironment>();
executionEnvironment->prepareRootDeviceEnvironments(1);
executionEnvironment->rootDeviceEnvironments[0]->setHwInfoAndInitHelpers(NEO::defaultHwInfo.get());
auto drm = new DrmMock(*executionEnvironment->rootDeviceEnvironments[0]);
executionEnvironment->rootDeviceEnvironments[0]->osInterface = std::make_unique<OSInterface>();
auto osInterface = executionEnvironment->rootDeviceEnvironments[0]->osInterface.get();
osInterface->setDriverModel(std::unique_ptr<DriverModel>(drm));
auto hwInfo = *executionEnvironment->rootDeviceEnvironments[0]->getHardwareInfo();
HardwareInfo outHwInfo;
auto &productHelper = executionEnvironment->rootDeviceEnvironments[0]->getHelper<ProductHelper>();
uint32_t sliceCount = 4;
drm->storedSVal = sliceCount;
hwInfo.gtSystemInfo.SliceCount = sliceCount;
int ret = productHelper.configureHwInfoDrm(&hwInfo, &outHwInfo, *executionEnvironment->rootDeviceEnvironments[0].get());
EXPECT_EQ(0, ret);
for (uint32_t i = 0; i < sliceCount; i++) {
EXPECT_TRUE(outHwInfo.gtSystemInfo.SliceInfo[i].Enabled);
}
}
HWTEST2_F(ProductHelperTest, givenProductHelperWhenIsPlatformQueryNotSupportedThenReturnFalse, IsAtLeastMtl) {
EXPECT_TRUE(productHelper->isPlatformQuerySupported());

2
shared/test/unit_test/xe2_hpg_core/bmg/linux/product_helper_tests_bmg_linux.cpp
View File

@@ -90,7 +90,7 @@ BMGTEST_F(BmgProductHelperLinux, WhenGtIsSetupThenGtSystemInfoIsCorrect) {
EXPECT_GT(gtSystemInfo.DualSubSliceCount, 0u);
EXPECT_GT_VAL(gtSystemInfo.L3CacheSizeInKb, 0u);
EXPECT_EQ(gtSystemInfo.CsrSizeInMb, 0u);
EXPECT_FALSE(gtSystemInfo.IsDynamicallyPopulated);
EXPECT_TRUE(gtSystemInfo.IsDynamicallyPopulated);
EXPECT_GT(gtSystemInfo.DualSubSliceCount, 0u);
EXPECT_GT(gtSystemInfo.MaxDualSubSlicesSupported, 0u);
}

2
shared/test/unit_test/xe2_hpg_core/lnl/linux/product_helper_tests_lnl_linux.cpp
View File

@@ -90,7 +90,7 @@ LNLTEST_F(LnlHwInfoLinux, WhenGtIsSetupThenGtSystemInfoIsCorrect) {
EXPECT_GT(gtSystemInfo.SubSliceCount, 0u);
EXPECT_GT_VAL(gtSystemInfo.L3CacheSizeInKb, 0u);
EXPECT_EQ(gtSystemInfo.CsrSizeInMb, 0u);
EXPECT_FALSE(gtSystemInfo.IsDynamicallyPopulated);
EXPECT_TRUE(gtSystemInfo.IsDynamicallyPopulated);
EXPECT_GT(gtSystemInfo.DualSubSliceCount, 0u);
EXPECT_GT(gtSystemInfo.MaxDualSubSlicesSupported, 0u);
}

2
shared/test/unit_test/xe_hpg_core/arl/linux/product_helper_tests_arl.cpp
View File

@@ -82,7 +82,7 @@ ARLTEST_F(ArlHwInfoLinux, whenSetupHardwareInfoThenGtSetupIsCorrect) {
EXPECT_GT(gtSystemInfo.SubSliceCount, 0u);
EXPECT_GT(gtSystemInfo.DualSubSliceCount, 0u);
EXPECT_GT_VAL(gtSystemInfo.L3CacheSizeInKb, 0u);
EXPECT_FALSE(gtSystemInfo.IsDynamicallyPopulated);
EXPECT_TRUE(gtSystemInfo.IsDynamicallyPopulated);
EXPECT_GT(gtSystemInfo.MaxDualSubSlicesSupported, 0u);
EXPECT_GT(gtSystemInfo.MaxSlicesSupported, 0u);
EXPECT_GT(gtSystemInfo.MaxSubSlicesSupported, 0u);