Media
/
compute-runtime
mirror of https://github.com/intel/compute-runtime.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Unify definition of hardware ip version 

Signed-off-by: Mateusz Jablonski <mateusz.jablonski@intel.com>
This commit is contained in:
Mateusz Jablonski 2022-12-06 15:59:36 +00:00 committed by Compute-Runtime-Automation
parent 103f522f18
commit 23fd280334
26 changed files with 101 additions and 96 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
level_zero/core/test/unit_tests/sources/module/test_module.cpp
View File

@ -2277,8 +2277,8 @@ HWTEST_F(ModuleTranslationUnitTest, WhenCreatingFromNativeBinaryThenSetsUpPacked
PatchTokensTestData::ValidEmptyProgram programTokens;
const auto &hwInfoConfig = *NEO::HwInfoConfig::get(productFamily);
NEO::HardwareInfo hwInfo = *NEO::defaultHwInfo;
AheadOfTimeConfig aotConfig = {0};
aotConfig.ProductConfig = hwInfoConfig.getProductConfigFromHwInfo(hwInfo);
HardwareIpVersion aotConfig = {0};
aotConfig.value = hwInfoConfig.getProductConfigFromHwInfo(hwInfo);
NEO::Ar::ArEncoder encoder;
std::string requiredProduct = NEO::hardwarePrefix[productFamily];
@ -2293,7 +2293,7 @@ HWTEST_F(ModuleTranslationUnitTest, WhenCreatingFromNativeBinaryThenSetsUpPacked
NEO::TargetDevice target;
target.coreFamily = static_cast<GFXCORE_FAMILY>(programTokens.header->Device);
target.aotConfig.ProductConfig = hwInfoConfig.getProductConfigFromHwInfo(hwInfo);
target.aotConfig.value = hwInfoConfig.getProductConfigFromHwInfo(hwInfo);
target.stepping = programTokens.header->SteppingId;
target.maxPointerSizeInBytes = programTokens.header->GPUPointerSizeInBytes;

6
opencl/test/unit_test/offline_compiler/ocloc_arg_helper_tests.cpp
View File

@ -29,7 +29,7 @@ TEST_F(OclocArgHelperTests, givenProductOrAotConfigWhenParseMajorMinorRevisionVa
}
for (const auto &device : enabledDeviceConfigs) {
auto productConfig = static_cast<AOT::PRODUCT_CONFIG>(device.aotConfig.ProductConfig);
auto productConfig = static_cast<AOT::PRODUCT_CONFIG>(device.aotConfig.value);
auto configStr0 = ProductConfigHelper::parseMajorMinorRevisionValue(productConfig);
auto configStr1 = ProductConfigHelper::parseMajorMinorRevisionValue(device.aotConfig);
EXPECT_STREQ(configStr0.c_str(), configStr1.c_str());
@ -56,7 +56,7 @@ TEST_F(OclocArgHelperTests, givenProductConfigAcronymWhenCheckAllEnabledThenCorr
EXPECT_TRUE(acronymFound);
device.acronyms.clear();
device.aotConfig.ProductConfig = AOT::UNKNOWN_ISA;
device.aotConfig.value = AOT::UNKNOWN_ISA;
enabledAcronyms = argHelper->getEnabledProductAcronyms();
acronymFound = std::any_of(enabledAcronyms.begin(), enabledAcronyms.end(), findAcronym(acronym));
@ -214,4 +214,4 @@ TEST_F(OclocArgHelperTests, givenEnabledProductAcronymsWithoutDashesWhenCheckIfI
}
EXPECT_TRUE(argHelper->isProductConfig(acronymCopy));
}
}
}

2
opencl/test/unit_test/offline_compiler/ocloc_fatbinary_tests.cpp
View File

@ -191,7 +191,7 @@ TEST(OclocFatBinaryRequestedFatBinary, givenDeviceArgToFatBinaryWhenConfigIsNotF
auto aotConfig = allEnabledDeviceConfigs[0].aotConfig;
std::stringstream majorString;
majorString << aotConfig.ProductConfigID.Major;
majorString << aotConfig.architecture;
auto major = majorString.str();
auto aotValue0 = argHelper->productConfigHelper->getProductConfigForVersionValue(major);

4
opencl/test/unit_test/offline_compiler/ocloc_product_config_tests.cpp
View File

@ -16,9 +16,9 @@ TEST_P(OclocProductConfigTests, GivenProductConfigValuesWhenInitHardwareInfoThen
auto &allSupportedConfigs = mockOfflineCompiler->argHelper->productConfigHelper->getDeviceAotInfo();
for (const auto &deviceConfig : allSupportedConfigs) {
if (aotConfig.ProductConfig == deviceConfig.aotConfig.ProductConfig) {
if (aotConfig.value == deviceConfig.aotConfig.value) {
deviceId = deviceConfig.deviceIds->front();
revId = deviceConfig.aotConfig.ProductConfigID.Revision;
revId = deviceConfig.aotConfig.revision;
break;
}
}

4
opencl/test/unit_test/offline_compiler/ocloc_product_config_tests.h
View File

@ -12,11 +12,11 @@
namespace NEO {
struct OclocProductConfigTests : public ::testing::TestWithParam<std::tuple<AOT::PRODUCT_CONFIG, PRODUCT_FAMILY>> {
void SetUp() override {
std::tie(aotConfig.ProductConfig, productFamily) = GetParam();
std::tie(aotConfig.value, productFamily) = GetParam();
mockOfflineCompiler = std::make_unique<MockOfflineCompiler>();
}
AheadOfTimeConfig aotConfig;
HardwareIpVersion aotConfig;
PRODUCT_FAMILY productFamily;
std::unique_ptr<MockOfflineCompiler> mockOfflineCompiler;
};

4
opencl/test/unit_test/offline_compiler/offline_compiler_tests.cpp
View File

@ -534,7 +534,7 @@ TEST_F(MockOfflineCompilerTests, givenProductConfigValueAndRevisionIdWhenInitHwI
auto config = AOT::UNKNOWN_ISA;
for (const auto &deviceMapConfig : allEnabledDeviceConfigs) {
if (productFamily == deviceMapConfig.hwInfo->platform.eProductFamily) {
config = static_cast<AOT::PRODUCT_CONFIG>(deviceMapConfig.aotConfig.ProductConfig);
config = static_cast<AOT::PRODUCT_CONFIG>(deviceMapConfig.aotConfig.value);
break;
}
}
@ -809,7 +809,7 @@ TEST_F(OfflineCompilerTests, givenProductAcronymWhenIdsCommandIsInvokeThenSucces
std::vector<std::string> expected{};
auto product = ProductConfigHelper::getProductConfigForAcronym(productAcronym.str());
for (const auto &device : supportedDevicesConfigs) {
if (device.aotConfig.ProductConfig == product) {
if (device.aotConfig.value == product) {
auto config = ProductConfigHelper::parseMajorMinorRevisionValue(device.aotConfig);
expected.push_back(config);
}

2
shared/offline_compiler/source/ocloc_arg_helper.cpp
View File

@ -164,7 +164,7 @@ bool OclocArgHelper::getHwInfoForProductConfig(uint32_t productConfig, NEO::Hard
const auto &deviceAotMap = productConfigHelper->getDeviceAotInfo();
for (auto &deviceConfig : deviceAotMap) {
if (deviceConfig.aotConfig.ProductConfig == productConfig) {
if (deviceConfig.aotConfig.value == productConfig) {
hwInfo = *deviceConfig.hwInfo;
if (hwInfoConfig) {
setHwInfoValuesFromConfig(hwInfoConfig, hwInfo);

4
shared/offline_compiler/source/ocloc_fatbinary.cpp
View File

@ -86,8 +86,8 @@ void getProductsForRange(unsigned int productFrom, unsigned int productTo, std::
auto &allSuppportedProducts = argHelper->productConfigHelper->getDeviceAotInfo();
for (const auto &device : allSuppportedProducts) {
auto validAcronym = device.aotConfig.ProductConfig >= productFrom;
validAcronym &= device.aotConfig.ProductConfig <= productTo;
auto validAcronym = device.aotConfig.value >= productFrom;
validAcronym &= device.aotConfig.value <= productTo;
validAcronym &= !device.acronyms.empty();
if (validAcronym) {
out.push_back(device.acronyms.front());

2
shared/offline_compiler/source/offline_compiler.cpp
View File

@ -170,7 +170,7 @@ int OfflineCompiler::queryAcronymIds(size_t numArgs, const std::vector<std::stri
} else if (helper->productConfigHelper->isProductConfig(queryAcronym)) {
auto product = ProductConfigHelper::getProductConfigForAcronym(queryAcronym);
for (const auto &device : enabledDevices) {
if (device.aotConfig.ProductConfig == product) {
if (device.aotConfig.value == product) {
matchedVersions.push_back(ProductConfigHelper::parseMajorMinorRevisionValue(device.aotConfig));
}
}

2
shared/source/device_binary_format/device_binary_formats.cpp
View File

@ -26,7 +26,7 @@ TargetDevice targetDeviceFromHwInfo(const HardwareInfo &hwInfo) {
targetDevice.coreFamily = hwInfo.platform.eRenderCoreFamily;
targetDevice.productFamily = hwInfo.platform.eProductFamily;
targetDevice.aotConfig.ProductConfig = hwInfoConfig.getProductConfigFromHwInfo(hwInfo);
targetDevice.aotConfig.value = hwInfoConfig.getProductConfigFromHwInfo(hwInfo);
targetDevice.stepping = hwInfo.platform.usRevId;
targetDevice.maxPointerSizeInBytes = sizeof(uintptr_t);
targetDevice.grfSize = hwInfo.capabilityTable.grfSize;

2
shared/source/device_binary_format/device_binary_formats.h
View File

@ -57,7 +57,7 @@ inline const char *asString(DecodeError err) {
struct TargetDevice {
GFXCORE_FAMILY coreFamily = IGFX_UNKNOWN_CORE;
PRODUCT_FAMILY productFamily = IGFX_UNKNOWN;
AheadOfTimeConfig aotConfig = {0};
HardwareIpVersion aotConfig = {0};
uint32_t stepping = 0U;
uint32_t maxPointerSizeInBytes = 4U;
uint32_t grfSize = 32U;

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

@ -79,6 +79,7 @@ set(NEO_CORE_HELPERS
${CMAKE_CURRENT_SOURCE_DIR}/hw_helper_tgllp_and_later.inl
${CMAKE_CURRENT_SOURCE_DIR}/hw_info.cpp
${CMAKE_CURRENT_SOURCE_DIR}/hw_info.h
${CMAKE_CURRENT_SOURCE_DIR}/hw_ip_version.h
${CMAKE_CURRENT_SOURCE_DIR}/hw_walk_order.h
${CMAKE_CURRENT_SOURCE_DIR}/kernel_helpers.cpp
${CMAKE_CURRENT_SOURCE_DIR}/kernel_helpers.h

4
shared/source/helpers/compiler_aot_config_bdw_and_later.inl
View File

@ -10,8 +10,8 @@
namespace NEO {
template <PRODUCT_FAMILY gfxProduct>
void CompilerProductHelperHw<gfxProduct>::setProductConfigForHwInfo(HardwareInfo &hwInfo, AheadOfTimeConfig config) const {
hwInfo.platform.usRevId = config.ProductConfigID.Revision;
void CompilerProductHelperHw<gfxProduct>::setProductConfigForHwInfo(HardwareInfo &hwInfo, HardwareIpVersion config) const {
hwInfo.platform.usRevId = config.revision;
}
} // namespace NEO

4
shared/source/helpers/compiler_hw_info_config.h
View File

@ -28,7 +28,7 @@ class CompilerProductHelper {
virtual bool isForceEmuInt32DivRemSPRequired() const = 0;
virtual bool isStatelessToStatefulBufferOffsetSupported() const = 0;
virtual bool isForceToStatelessRequired() const = 0;
virtual void setProductConfigForHwInfo(HardwareInfo &hwInfo, AheadOfTimeConfig config) const = 0;
virtual void setProductConfigForHwInfo(HardwareInfo &hwInfo, HardwareIpVersion config) const = 0;
virtual const char *getCachingPolicyOptions(bool isDebuggerActive) const = 0;
};
@ -44,7 +44,7 @@ class CompilerProductHelperHw : public CompilerProductHelper {
bool isForceEmuInt32DivRemSPRequired() const override;
bool isStatelessToStatefulBufferOffsetSupported() const override;
bool isForceToStatelessRequired() const override;
void setProductConfigForHwInfo(HardwareInfo &hwInfo, AheadOfTimeConfig config) const override;
void setProductConfigForHwInfo(HardwareInfo &hwInfo, HardwareIpVersion config) const override;
const char *getCachingPolicyOptions(bool isDebuggerActive) const override;
protected:

10
shared/source/helpers/hw_info.h
View File

@ -7,6 +7,7 @@
#pragma once
#include "shared/source/direct_submission/direct_submission_properties.h"
#include "shared/source/helpers/hw_ip_version.h"
#include "shared/source/helpers/kmd_notify_properties.h"
#include "gtsysinfo.h"
@ -133,15 +134,6 @@ inline bool operator==(const RuntimeCapabilityTable &lhs, const RuntimeCapabilit
return result;
}
struct HardwareIpVersion {
uint8_t architecture{};
uint8_t release{};
uint8_t revision{};
protected:
uint8_t reserved[5]{};
};
struct HardwareInfo {
HardwareInfo() = default;
HardwareInfo(const PLATFORM *platform, const FeatureTable *featureTable, const WorkaroundTable *workaroundTable,

24
shared/source/helpers/hw_ip_version.h Normal file
View File

@ -0,0 +1,24 @@
/*
* Copyright (C) 2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#pragma once
#include <cstdint>
namespace NEO {
struct HardwareIpVersion {
union {
uint32_t value;
struct
{
uint32_t revision : 6;
uint32_t reserved : 8;
uint32_t release : 8;
uint32_t architecture : 10;
};
};
};
} // namespace NEO

20
shared/source/helpers/product_config_helper.cpp
View File

@ -21,7 +21,7 @@ ProductConfigHelper::ProductConfigHelper() : deviceAotInfo({
}
bool ProductConfigHelper::compareConfigs(DeviceAotInfo deviceAotInfo0, DeviceAotInfo deviceAotInfo1) {
return deviceAotInfo0.aotConfig.ProductConfig < deviceAotInfo1.aotConfig.ProductConfig;
return deviceAotInfo0.aotConfig.value < deviceAotInfo1.aotConfig.value;
}
std::vector<DeviceAotInfo> &ProductConfigHelper::getDeviceAotInfo() {
@ -181,15 +181,15 @@ std::vector<NEO::ConstStringRef> ProductConfigHelper::getDeprecatedAcronyms() {
return deprecatedAcronyms;
}
std::string ProductConfigHelper::parseMajorMinorRevisionValue(AheadOfTimeConfig config) {
std::string ProductConfigHelper::parseMajorMinorRevisionValue(NEO::HardwareIpVersion config) {
std::stringstream stringConfig;
stringConfig << config.ProductConfigID.Major << "." << config.ProductConfigID.Minor << "." << config.ProductConfigID.Revision;
stringConfig << config.architecture << "." << config.release << "." << config.revision;
return stringConfig.str();
}
std::string ProductConfigHelper::parseMajorMinorValue(AheadOfTimeConfig config) {
std::string ProductConfigHelper::parseMajorMinorValue(NEO::HardwareIpVersion config) {
std::stringstream stringConfig;
stringConfig << config.ProductConfigID.Major << "." << config.ProductConfigID.Minor;
stringConfig << config.architecture << "." << config.release;
return stringConfig.str();
}
@ -229,10 +229,10 @@ AOT::PRODUCT_CONFIG ProductConfigHelper::getProductConfigForVersionValue(const s
return AOT::UNKNOWN_ISA;
}
AheadOfTimeConfig product = {0};
product.ProductConfigID.Major = major;
product.ProductConfigID.Minor = minor;
product.ProductConfigID.Revision = revision;
NEO::HardwareIpVersion product = {0};
product.architecture = major;
product.release = minor;
product.revision = revision;
return static_cast<AOT::PRODUCT_CONFIG>(product.ProductConfig);
return static_cast<AOT::PRODUCT_CONFIG>(product.value);
}

28
shared/source/helpers/product_config_helper.h
View File

@ -7,6 +7,7 @@
#pragma once
#include "shared/source/helpers/hw_ip_version.h"
#include "shared/source/utilities/const_stringref.h"
#include "igfxfmid.h"
@ -26,21 +27,8 @@ namespace NEO {
struct HardwareInfo;
} // namespace NEO
struct AheadOfTimeConfig {
union {
uint32_t ProductConfig;
struct
{
uint32_t Revision : 6;
uint32_t Reserved : 8;
uint32_t Minor : 8;
uint32_t Major : 10;
} ProductConfigID;
};
};
struct DeviceAotInfo {
AheadOfTimeConfig aotConfig = {};
NEO::HardwareIpVersion aotConfig{};
const NEO::HardwareInfo *hwInfo = nullptr;
const std::vector<unsigned short> *deviceIds = nullptr;
AOT::FAMILY family = {};
@ -48,7 +36,7 @@ struct DeviceAotInfo {
std::vector<NEO::ConstStringRef> acronyms{};
bool operator==(const DeviceAotInfo &rhs) {
return aotConfig.ProductConfig == rhs.aotConfig.ProductConfig && family == rhs.family && release == rhs.release && hwInfo == rhs.hwInfo;
return aotConfig.value == rhs.aotConfig.value && family == rhs.family && release == rhs.release && hwInfo == rhs.hwInfo;
}
};
@ -59,13 +47,13 @@ struct ProductConfigHelper {
MismatchedValue = -1,
};
static void adjustDeviceName(std::string &device);
static std::string parseMajorMinorValue(AheadOfTimeConfig config);
static std::string parseMajorMinorRevisionValue(AheadOfTimeConfig config);
static std::string parseMajorMinorValue(NEO::HardwareIpVersion config);
static std::string parseMajorMinorRevisionValue(NEO::HardwareIpVersion config);
static int parseProductConfigFromString(const std::string &device, size_t begin, size_t end);
inline static std::string parseMajorMinorRevisionValue(AOT::PRODUCT_CONFIG config) {
std::stringstream stringConfig;
AheadOfTimeConfig aotConfig = {0};
aotConfig.ProductConfig = config;
NEO::HardwareIpVersion aotConfig = {0};
aotConfig.value = config;
return parseMajorMinorRevisionValue(aotConfig);
}
@ -107,7 +95,7 @@ struct ProductConfigHelper {
template <typename EqComparableT>
static auto findProductConfig(const EqComparableT &lhs) {
return [&lhs](const auto &rhs) { return lhs == rhs.aotConfig.ProductConfig; };
return [&lhs](const auto &rhs) { return lhs == rhs.aotConfig.value; };
}
void initialize();

4
shared/source/helpers/product_config_helper_extra.cpp
View File

@ -14,7 +14,7 @@
void ProductConfigHelper::initialize() {
for (auto &device : deviceAotInfo) {
for (const auto &[acronym, value] : AOT::deviceAcronyms) {
if (value == device.aotConfig.ProductConfig) {
if (value == device.aotConfig.value) {
device.acronyms.push_back(NEO::ConstStringRef(acronym));
}
}
@ -26,4 +26,4 @@ AOT::PRODUCT_CONFIG ProductConfigHelper::getProductConfigForAcronym(const std::s
if (it == AOT::deviceAcronyms.end())
return AOT::UNKNOWN_ISA;
return it->second;
}
}

30
shared/test/unit_test/device_binary_format/device_binary_format_ar_tests.cpp
View File

@ -60,8 +60,8 @@ TEST(UnpackSingleDeviceBinaryAr, WhenBinaryWithProductConfigIsFoundThenChooseItA
PatchTokensTestData::ValidEmptyProgram programTokens;
const auto &hwInfoConfig = *NEO::HwInfoConfig::get(productFamily);
NEO::HardwareInfo hwInfo = *NEO::defaultHwInfo;
AheadOfTimeConfig aotConfig = {0};
aotConfig.ProductConfig = hwInfoConfig.getProductConfigFromHwInfo(hwInfo);
NEO::HardwareIpVersion aotConfig = {0};
aotConfig.value = hwInfoConfig.getProductConfigFromHwInfo(hwInfo);
NEO::Ar::ArEncoder encoder;
std::string requiredProduct = NEO::hardwarePrefix[productFamily];
@ -101,8 +101,8 @@ TEST(UnpackSingleDeviceBinaryAr, WhenBinaryWithProductConfigIsFoundThenPackedTar
PatchTokensTestData::ValidEmptyProgram programTokens;
const auto &hwInfoConfig = *NEO::HwInfoConfig::get(productFamily);
NEO::HardwareInfo hwInfo = *NEO::defaultHwInfo;
AheadOfTimeConfig aotConfig = {0};
aotConfig.ProductConfig = hwInfoConfig.getProductConfigFromHwInfo(hwInfo);
NEO::HardwareIpVersion aotConfig = {0};
aotConfig.value = hwInfoConfig.getProductConfigFromHwInfo(hwInfo);
NEO::Ar::ArEncoder encoder;
std::string requiredProduct = NEO::hardwarePrefix[productFamily];
@ -132,8 +132,8 @@ TEST(UnpackSingleDeviceBinaryAr, WhenMultipleBinariesMatchedThenChooseBestMatch)
PatchTokensTestData::ValidEmptyProgram programTokens;
const auto &hwInfoConfig = *NEO::HwInfoConfig::get(productFamily);
NEO::HardwareInfo hwInfo = *NEO::defaultHwInfo;
AheadOfTimeConfig aotConfig = {0};
aotConfig.ProductConfig = hwInfoConfig.getProductConfigFromHwInfo(hwInfo);
NEO::HardwareIpVersion aotConfig = {0};
aotConfig.value = hwInfoConfig.getProductConfigFromHwInfo(hwInfo);
NEO::Ar::ArEncoder encoder;
std::string requiredProduct = NEO::hardwarePrefix[productFamily];
@ -148,7 +148,7 @@ TEST(UnpackSingleDeviceBinaryAr, WhenMultipleBinariesMatchedThenChooseBestMatch)
NEO::TargetDevice target;
target.coreFamily = static_cast<GFXCORE_FAMILY>(programTokens.header->Device);
target.aotConfig.ProductConfig = hwInfoConfig.getProductConfigFromHwInfo(hwInfo);
target.aotConfig.value = hwInfoConfig.getProductConfigFromHwInfo(hwInfo);
target.stepping = programTokens.header->SteppingId;
target.maxPointerSizeInBytes = programTokens.header->GPUPointerSizeInBytes;
@ -241,8 +241,8 @@ TEST(UnpackSingleDeviceBinaryAr, WhenFailedToUnpackMatchWithProductConfigThenTry
const auto &hwInfoConfig = *NEO::HwInfoConfig::get(productFamily);
NEO::HardwareInfo hwInfo = *NEO::defaultHwInfo;
AheadOfTimeConfig aotConfig = {0};
aotConfig.ProductConfig = hwInfoConfig.getProductConfigFromHwInfo(hwInfo);
NEO::HardwareIpVersion aotConfig = {0};
aotConfig.value = hwInfoConfig.getProductConfigFromHwInfo(hwInfo);
std::string requiredProductConfig = ProductConfigHelper::parseMajorMinorRevisionValue(aotConfig);
@ -259,7 +259,7 @@ TEST(UnpackSingleDeviceBinaryAr, WhenFailedToUnpackMatchWithProductConfigThenTry
NEO::TargetDevice target;
target.coreFamily = static_cast<GFXCORE_FAMILY>(programTokens.header->Device);
target.aotConfig.ProductConfig = hwInfoConfig.getProductConfigFromHwInfo(hwInfo);
target.aotConfig.value = hwInfoConfig.getProductConfigFromHwInfo(hwInfo);
target.stepping = programTokens.header->SteppingId;
target.maxPointerSizeInBytes = programTokens.header->GPUPointerSizeInBytes;
@ -349,8 +349,8 @@ TEST(UnpackSingleDeviceBinaryAr, WhenDeviceBinaryNotMatchedButIrWithProductConfi
PatchTokensTestData::ValidEmptyProgram programTokens;
const auto &hwInfoConfig = *NEO::HwInfoConfig::get(productFamily);
NEO::HardwareInfo hwInfo = *NEO::defaultHwInfo;
AheadOfTimeConfig aotConfig = {0};
aotConfig.ProductConfig = hwInfoConfig.getProductConfigFromHwInfo(hwInfo);
NEO::HardwareIpVersion aotConfig = {0};
aotConfig.value = hwInfoConfig.getProductConfigFromHwInfo(hwInfo);
std::string requiredProductConfig = ProductConfigHelper::parseMajorMinorRevisionValue(aotConfig);
std::string requiredProduct = NEO::hardwarePrefix[productFamily];
@ -369,7 +369,7 @@ TEST(UnpackSingleDeviceBinaryAr, WhenDeviceBinaryNotMatchedButIrWithProductConfi
target.coreFamily = static_cast<GFXCORE_FAMILY>(programTokens.header->Device);
target.stepping = programTokens.header->SteppingId;
target.maxPointerSizeInBytes = programTokens.header->GPUPointerSizeInBytes;
target.aotConfig.ProductConfig = hwInfoConfig.getProductConfigFromHwInfo(hwInfo);
target.aotConfig.value = hwInfoConfig.getProductConfigFromHwInfo(hwInfo);
auto arData = encoder.encode();
std::string unpackErrors;
@ -573,8 +573,8 @@ TEST(UnpackSingleDeviceBinaryAr, WhenCouldNotFindBinaryWithRightPointerSizeThenU
const auto &hwInfoConfig = *NEO::HwInfoConfig::get(productFamily);
NEO::HardwareInfo hwInfo = *NEO::defaultHwInfo;
AheadOfTimeConfig aotConfig = {0};
aotConfig.ProductConfig = hwInfoConfig.getProductConfigFromHwInfo(hwInfo);
NEO::HardwareIpVersion aotConfig = {0};
aotConfig.value = hwInfoConfig.getProductConfigFromHwInfo(hwInfo);
std::string requiredProductConfig = ProductConfigHelper::parseMajorMinorRevisionValue(aotConfig);
std::string requiredProduct = NEO::hardwarePrefix[productFamily];

2
shared/test/unit_test/fixtures/product_config_fixture.h
View File

@ -39,7 +39,7 @@ struct ProductConfigHwInfoTests : public ProductConfigTest<::testing::TestWithPa
}
}
PRODUCT_FAMILY prod = IGFX_UNKNOWN;
const AheadOfTimeConfig invalidConfig = {CommonConstants::invalidRevisionID};
const HardwareIpVersion invalidConfig = {CommonConstants::invalidRevisionID};
};
using ProductConfigTests = ProductConfigTest<::testing::Test>;

6
shared/test/unit_test/helpers/compiler_hw_info_config_tests.cpp
View File

@ -49,10 +49,10 @@ HWTEST2_F(CompilerProductHelperFixture, givenAotConfigWhenSetHwInfoRevisionIdThe
auto hwInfo = *defaultHwInfo;
auto &productHelper = getHelper<ProductHelper>();
auto productConfig = productHelper.getProductConfigFromHwInfo(*defaultHwInfo);
AheadOfTimeConfig aotConfig = {0};
aotConfig.ProductConfig = productConfig;
HardwareIpVersion aotConfig = {0};
aotConfig.value = productConfig;
CompilerProductHelper::get(hwInfo.platform.eProductFamily)->setProductConfigForHwInfo(hwInfo, aotConfig);
EXPECT_EQ(hwInfo.platform.usRevId, aotConfig.ProductConfigID.Revision);
EXPECT_EQ(hwInfo.platform.usRevId, aotConfig.revision);
}
HWTEST2_F(CompilerProductHelperFixture, givenAtMostXeHPWhenGetCachingPolicyOptionsThenReturnNullptr, IsAtMostXeHpCore) {

8
shared/test/unit_test/helpers/product_config_helper_tests.cpp
View File

@ -241,7 +241,7 @@ TEST_F(AotDeviceInfoTests, givenProductOrAotConfigWhenParseMajorMinorRevisionVal
}
for (const auto &device : enabledDeviceConfigs) {
auto productConfig = static_cast<AOT::PRODUCT_CONFIG>(device.aotConfig.ProductConfig);
auto productConfig = static_cast<AOT::PRODUCT_CONFIG>(device.aotConfig.value);
auto configStr0 = ProductConfigHelper::parseMajorMinorRevisionValue(productConfig);
auto configStr1 = ProductConfigHelper::parseMajorMinorRevisionValue(device.aotConfig);
EXPECT_STREQ(configStr0.c_str(), configStr1.c_str());
@ -268,7 +268,7 @@ TEST_F(AotDeviceInfoTests, givenProductConfigAcronymWhenCheckAllEnabledThenCorre
EXPECT_TRUE(acronymFound);
device.acronyms.clear();
device.aotConfig.ProductConfig = AOT::UNKNOWN_ISA;
device.aotConfig.value = AOT::UNKNOWN_ISA;
enabledAcronyms = productConfigHelper->getAllProductAcronyms();
acronymFound = std::any_of(enabledAcronyms.begin(), enabledAcronyms.end(), findAcronym(acronym));
@ -425,7 +425,7 @@ TEST_F(AotDeviceInfoTests, givenNotFullConfigWhenGetProductConfigThenUnknownIsaI
}
auto aotConfig = allEnabledDeviceConfigs[0].aotConfig;
std::stringstream majorString;
majorString << aotConfig.ProductConfigID.Major;
majorString << aotConfig.architecture;
auto major = majorString.str();
auto aotValue0 = ProductConfigHelper::getProductConfigForVersionValue(major);
@ -481,7 +481,7 @@ TEST_F(AotDeviceInfoTests, givenProductConfigWhenGetDeviceAotInfoThenCorrectValu
DeviceAotInfo aotInfo{};
for (auto &product : enabledProducts) {
auto productConfig = static_cast<AOT::PRODUCT_CONFIG>(product.aotConfig.ProductConfig);
auto productConfig = static_cast<AOT::PRODUCT_CONFIG>(product.aotConfig.value);
EXPECT_TRUE(productConfigHelper->getDeviceAotInfoForProductConfig(productConfig, aotInfo));
EXPECT_TRUE(aotInfo == product);
}

6
shared/test/unit_test/xe_hpc_core/pvc/device_binary_format_ar_tests_pvc.cpp
View File

@ -28,9 +28,9 @@ PVCTEST_F(PvcUnpackSingleDeviceBinaryAr, WhenFailedToUnpackMatchWithPvcProductCo
PatchTokensTestData::ValidEmptyProgram programTokens;
PatchTokensTestData::ValidEmptyProgram programTokensWrongTokenVersion;
AheadOfTimeConfig aotConfig0{}, aotConfig1{};
aotConfig0.ProductConfig = AOT::PVC_XL_A0;
aotConfig1.ProductConfig = AOT::PVC_XL_A0P;
NEO::HardwareIpVersion aotConfig0{}, aotConfig1{};
aotConfig0.value = AOT::PVC_XL_A0;
aotConfig1.value = AOT::PVC_XL_A0P;
std::string requiredProductConfig = ProductConfigHelper::parseMajorMinorRevisionValue(aotConfig0);
std::string anotherProductConfig = ProductConfigHelper::parseMajorMinorRevisionValue(aotConfig1);

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

@ -74,10 +74,10 @@ PVCTEST_F(PvcProductHelperLinux, givenProductHelperWhenAskedIfPatIndexProgrammin
PVCTEST_F(PvcProductHelperLinux, givenAotConfigWhenSetHwInfoRevisionIdForPvcThenCorrectValueIsSet) {
for (const auto &config : AOT_PVC::productConfigs) {
AheadOfTimeConfig aotConfig = {0};
aotConfig.ProductConfig = config;
HardwareIpVersion aotConfig = {0};
aotConfig.value = config;
CompilerProductHelper::get(pInHwInfo.platform.eProductFamily)->setProductConfigForHwInfo(pInHwInfo, aotConfig);
EXPECT_EQ(pInHwInfo.platform.usRevId, aotConfig.ProductConfigID.Revision);
EXPECT_EQ(pInHwInfo.platform.usRevId, aotConfig.revision);
}
}

6
shared/test/unit_test/xe_hpg_core/dg2/device_binary_format_ar_tests_dg2.cpp
View File

@ -28,9 +28,9 @@ DG2TEST_F(Dg2UnpackSingleDeviceBinaryAr, WhenFailedToUnpackMatchWithDg2ProductCo
PatchTokensTestData::ValidEmptyProgram programTokens;
PatchTokensTestData::ValidEmptyProgram programTokensWrongTokenVersion;
AheadOfTimeConfig aotConfig0{}, aotConfig1{};
aotConfig0.ProductConfig = AOT::DG2_G10_A0;
aotConfig1.ProductConfig = AOT::DG2_G10_B0;
NEO::HardwareIpVersion aotConfig0{}, aotConfig1{};
aotConfig0.value = AOT::DG2_G10_A0;
aotConfig1.value = AOT::DG2_G10_B0;
std::string requiredProductConfig = ProductConfigHelper::parseMajorMinorRevisionValue(aotConfig0);
std::string anotherProductConfig = ProductConfigHelper::parseMajorMinorRevisionValue(aotConfig1);