Media/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2025-09-10 12:53:42 +08:00
Code Issues Packages Projects Releases Wiki Activity

Use device ID from ProductConfigHelper

Browse Source 
This commit switches the device ID logic from the deprecated
to the new one, so that if the user passes a hex value to the -device
parameter, ocloc will use the new implementation in the product config
helper.

Signed-off-by: Daria Hinz <daria.hinz@intel.com>
Related-To: NEO-7487
This commit is contained in:
Daria Hinz
2022-11-07 14:22:31 +01:00
committed by Compute-Runtime-Automation
parent a30cc94708
commit 60a8bcb3d7
10 changed files with 121 additions and 95 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
opencl/test/unit_test/offline_compiler/mock/mock_argument_helper.h
View File

@ -19,7 +19,6 @@
class MockOclocArgHelper : public OclocArgHelper {
public:
using OclocArgHelper::deviceProductTable;
using OclocArgHelper::hasOutput;
using OclocArgHelper::headers;
using OclocArgHelper::inputs;

23
opencl/test/unit_test/offline_compiler/ocloc_validator_tests.cpp
View File

@ -102,26 +102,3 @@ TEST(OclocValidate, WhenErrorsEmitedThenRedirectsThemToStdout) {
EXPECT_EQ(static_cast<int>(NEO::DecodeError::InvalidBinary), res) << oclocStdout;
EXPECT_NE(nullptr, strstr(oclocStdout.c_str(), "Validator detected errors :\nNEO::Yaml : Could not parse line : [1] : [kernels ] <-- parser position on error. Reason : Vector data type expects to have at least one value starting with -")) << oclocStdout;
}
TEST(OclocValidate, givenDeviceProductTableEveryProductMatchesProperPattern) {
MockOclocArgHelper::FilesMap files{{"src.gen", "01234567"}};
MockOclocArgHelper argHelper{files};
ASSERT_GE(argHelper.deviceProductTable.size(), 1u);
std::vector<std::string> genPatterns;
for (int j = 0; j < IGFX_MAX_PRODUCT; j++) {
if (NEO::hardwarePrefix[j] == nullptr)
continue;
genPatterns.push_back(NEO::hardwarePrefix[j]);
}
ASSERT_GE(genPatterns.size(), 1u);
if (argHelper.deviceProductTable.size() == 1 && argHelper.deviceProductTable[0].deviceId == 0) {
auto &deviceProductTable = const_cast<std::vector<DeviceProduct> &>(argHelper.deviceProductTable);
deviceProductTable[0].product = genPatterns[0];
deviceProductTable[0].deviceId = 0x123;
deviceProductTable.push_back(DeviceProduct{0, ""});
}
for (int i = 0; argHelper.deviceProductTable[i].deviceId != 0; i++) {
auto res = std::find(genPatterns.begin(), genPatterns.end(), argHelper.returnProductNameForDevice(argHelper.deviceProductTable[i].deviceId));
EXPECT_NE(res, genPatterns.end());
}
}

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

@ -1031,13 +1031,14 @@ TEST_F(OfflineCompilerTests, GivenArgsWhenOfflineCompilerIsCreatedThenSuccessIsR
}
TEST_F(OfflineCompilerTests, givenDeviceIdHexValueWhenInitHwInfoThenItHasCorrectlySetValues) {
auto deviceId = oclocArgHelperWithoutInput->deviceProductTable[0].deviceId;
if (oclocArgHelperWithoutInput->deviceProductTable.size() == 1 && deviceId == 0) {
auto deviceAotInfo = oclocArgHelperWithoutInput->productConfigHelper->getDeviceAotInfo();
if (deviceAotInfo.empty()) {
GTEST_SKIP();
}
MockOfflineCompiler mockOfflineCompiler;
std::stringstream deviceString, productString;
auto deviceId = deviceAotInfo[0].deviceIds->front();
deviceString << "0x" << std::hex << deviceId;
mockOfflineCompiler.argHelper->getPrinterRef() = MessagePrinter{true};
@ -1046,15 +1047,17 @@ TEST_F(OfflineCompilerTests, givenDeviceIdHexValueWhenInitHwInfoThenItHasCorrect
}
TEST_F(OfflineCompilerTests, givenProperDeviceIdHexAsDeviceArgumentThenSuccessIsReturned) {
auto deviceId = oclocArgHelperWithoutInput->deviceProductTable[0].deviceId;
if (oclocArgHelperWithoutInput->deviceProductTable.size() == 1 && deviceId == 0) {
auto deviceAotInfo = oclocArgHelperWithoutInput->productConfigHelper->getDeviceAotInfo();
if (deviceAotInfo.empty()) {
GTEST_SKIP();
}
std::stringstream deviceString, productString;
AOT::PRODUCT_CONFIG config = static_cast<AOT::PRODUCT_CONFIG>(deviceAotInfo[0].aotConfig.ProductConfig);
auto deviceId = deviceAotInfo[0].deviceIds->front();
productString << oclocArgHelperWithoutInput->productConfigHelper->getAcronymForProductConfig(config);
deviceString << "0x" << std::hex << deviceId;
productString << oclocArgHelperWithoutInput->deviceProductTable[0].product;
std::vector<std::string> argv = {
"ocloc",
@ -1092,7 +1095,7 @@ TEST_F(OfflineCompilerTests, givenIncorrectDeviceIdHexThenInvalidDeviceIsReturne
auto output = testing::internal::GetCapturedStdout();
EXPECT_EQ(nullptr, pOfflineCompiler);
EXPECT_STREQ(output.c_str(), "Could not determine target based on device id: 0x0\nError: Cannot get HW Info for device 0x0.\n");
EXPECT_STREQ(output.c_str(), "Could not determine device target: 0x0\nError: Cannot get HW Info for device 0x0.\n");
EXPECT_EQ(CL_INVALID_DEVICE, retVal);
}
@ -2301,7 +2304,7 @@ TEST(OfflineCompilerTest, GivenUnsupportedDeviceConfigWhenInitHardwareInfoThenIn
EXPECT_EQ(retVal, OclocErrorCode::INVALID_DEVICE);
auto output = testing::internal::GetCapturedStdout();
resString << "Could not determine target based on product config: " << deviceName << "\n";
resString << "Could not determine device target: " << deviceName << "\n";
EXPECT_STREQ(output.c_str(), resString.str().c_str());
}

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

@ -58,13 +58,7 @@ OclocArgHelper::OclocArgHelper(const uint32_t numSources, const uint8_t **dataSo
uint64_t **lenOutputs, char ***nameOutputs)
: numOutputs(numOutputs), nameOutputs(nameOutputs),
dataOutputs(dataOutputs), lenOutputs(lenOutputs), hasOutput(numOutputs != nullptr),
messagePrinter(hasOutput), deviceProductTable({
#define NAMEDDEVICE(devId, product, ignored_devName) {devId, NEO::hardwarePrefix[NEO::product::hwInfo.platform.eProductFamily]},
#define DEVICE(devId, product) {devId, NEO::hardwarePrefix[NEO::product::hwInfo.platform.eProductFamily]},
#include "devices.inl"
#undef DEVICE
#undef NAMEDDEVICE
{0u, std::string("")}}) {
messagePrinter(hasOutput) {
for (uint32_t i = 0; i < numSources; ++i) {
inputs.push_back(Source(dataSources[i], static_cast<size_t>(lenSources[i]), nameSources[i]));
}
@ -199,25 +193,4 @@ void OclocArgHelper::saveOutput(const std::string &filename, const std::ostream
std::ofstream file(filename);
file << ss.str();
}
}
bool OclocArgHelper::setAcronymForDeviceId(std::string &device) {
auto product = returnProductNameForDevice(std::stoi(device, 0, 16));
if (!product.empty()) {
printf("Auto-detected target based on %s device id: %s\n", device.c_str(), product.c_str());
} else {
printf("Could not determine target based on device id: %s\n", device.c_str());
return false;
}
device = std::move(product);
return true;
}
std::string OclocArgHelper::returnProductNameForDevice(unsigned short deviceId) {
for (int i = 0; deviceProductTable[i].deviceId != 0; i++) {
if (deviceProductTable[i].deviceId == deviceId) {
return deviceProductTable[i].product;
}
}
return "";
}

8
shared/offline_compiler/source/ocloc_arg_helper.h
View File

@ -41,11 +41,6 @@ struct Output {
Output(const std::string &name, const void *data, const size_t &size);
};
struct DeviceProduct {
unsigned short deviceId;
std::string product;
};
class OclocArgHelper {
protected:
std::vector<Source> inputs, headers;
@ -56,7 +51,6 @@ class OclocArgHelper {
uint64_t **lenOutputs = nullptr;
bool hasOutput = false;
MessagePrinter messagePrinter;
const std::vector<DeviceProduct> deviceProductTable;
void moveOutputs();
Source *findSourceFile(const std::string &filename);
bool sourceFileExists(const std::string &filename) const;
@ -77,7 +71,6 @@ class OclocArgHelper {
virtual ~OclocArgHelper();
MOCKABLE_VIRTUAL bool fileExists(const std::string &filename) const;
bool getHwInfoForProductConfig(uint32_t productConfig, NEO::HardwareInfo &hwInfo, uint64_t hwInfoConfig);
bool setAcronymForDeviceId(std::string &device);
std::vector<std::string> headersToVectorOfStrings();
MOCKABLE_VIRTUAL void readFileToVectorOfStrings(const std::string &filename, std::vector<std::string> &lines);
MOCKABLE_VIRTUAL std::vector<char> readBinaryFile(const std::string &filename);
@ -135,6 +128,5 @@ class OclocArgHelper {
return os.str();
}
std::string returnProductNameForDevice(unsigned short deviceId);
std::unique_ptr<ProductConfigHelper> productConfigHelper;
};

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

@ -435,7 +435,7 @@ void OfflineCompiler::setFamilyType() {
familyNameWithType.append(hwInfo.capabilityTable.platformType);
}
int OfflineCompiler::initHardwareInfoForDeprecatedAcronyms(std::string deviceName, int deviceId) {
int OfflineCompiler::initHardwareInfoForDeprecatedAcronyms(std::string deviceName) {
std::vector<PRODUCT_FAMILY> allSupportedProduct{ALL_SUPPORTED_PRODUCT_FAMILIES};
std::transform(deviceName.begin(), deviceName.end(), deviceName.begin(), ::tolower);
@ -445,9 +445,6 @@ int OfflineCompiler::initHardwareInfoForDeprecatedAcronyms(std::string deviceNam
if (revisionId != -1) {
hwInfo.platform.usRevId = revisionId;
}
if (deviceId != -1) {
hwInfo.platform.usDeviceID = deviceId;
}
uint64_t config = hwInfoConfig ? hwInfoConfig : defaultHardwareInfoConfigTable[hwInfo.platform.eProductFamily];
setHwInfoValuesFromConfig(config, hwInfo);
hardwareInfoBaseSetup[hwInfo.platform.eProductFamily](&hwInfo, true);
@ -459,31 +456,44 @@ int OfflineCompiler::initHardwareInfoForDeprecatedAcronyms(std::string deviceNam
return INVALID_DEVICE;
}
bool OfflineCompiler::isArgumentDeviceId(const std::string &argument) const {
const char hexPrefixLength = 2;
return argument.substr(0, hexPrefixLength) == "0x" && std::all_of(argument.begin() + hexPrefixLength, argument.end(), (::isxdigit));
}
int OfflineCompiler::initHardwareInfoForProductConfig(std::string deviceName) {
AOT::PRODUCT_CONFIG productConfig = AOT::UNKNOWN_ISA;
ProductConfigHelper::adjustDeviceName(deviceName);
int deviceId = -1;
if (deviceName.find(".") != std::string::npos) {
productConfig = argHelper->productConfigHelper->getProductConfigForVersionValue(deviceName);
if (productConfig == AOT::UNKNOWN_ISA) {
argHelper->printf("Could not determine device target: %s\n", deviceName.c_str());
}
} else if (isArgumentDeviceId(deviceName)) {
deviceId = std::stoi(deviceName, 0, 16);
productConfig = argHelper->productConfigHelper->getProductConfigForDeviceId(deviceId);
} else if (argHelper->productConfigHelper->isProductConfig(deviceName)) {
productConfig = ProductConfigHelper::getProductConfigForAcronym(deviceName);
} else {
return INVALID_DEVICE;
}
if (productConfig != AOT::UNKNOWN_ISA) {
if (argHelper->getHwInfoForProductConfig(productConfig, hwInfo, hwInfoConfig)) {
if (revisionId != -1) {
hwInfo.platform.usRevId = revisionId;
}
deviceConfig = productConfig;
setFamilyType();
return SUCCESS;
if (argHelper->getHwInfoForProductConfig(productConfig, hwInfo, hwInfoConfig)) {
if (revisionId != -1) {
hwInfo.platform.usRevId = revisionId;
}
argHelper->printf("Could not determine target based on product config: %s\n", deviceName.c_str());
if (deviceId != -1) {
auto product = argHelper->productConfigHelper->getAcronymForProductConfig(productConfig);
argHelper->printf("Auto-detected target based on %s device id: %s\n", deviceName.c_str(), product.c_str());
hwInfo.platform.usDeviceID = deviceId;
}
deviceConfig = productConfig;
setFamilyType();
return SUCCESS;
} else {
argHelper->printf("Could not determine device target: %s\n", deviceName.c_str());
return INVALID_DEVICE;
}
return INVALID_DEVICE;
}
int OfflineCompiler::initHardwareInfo(std::string deviceName) {
@ -492,21 +502,12 @@ int OfflineCompiler::initHardwareInfo(std::string deviceName) {
return retVal;
}
const char hexPrefix = 2;
int deviceId = -1;
retVal = initHardwareInfoForProductConfig(deviceName);
if (retVal == SUCCESS) {
return retVal;
}
if (deviceName.substr(0, hexPrefix) == "0x" && std::all_of(deviceName.begin() + hexPrefix, deviceName.end(), (::isxdigit))) {
deviceId = std::stoi(deviceName, 0, 16);
if (!argHelper->setAcronymForDeviceId(deviceName)) {
return retVal;
}
}
retVal = initHardwareInfoForDeprecatedAcronyms(deviceName, deviceId);
retVal = initHardwareInfoForDeprecatedAcronyms(deviceName);
return retVal;
}

3
shared/offline_compiler/source/offline_compiler.h
View File

@ -101,7 +101,8 @@ All supported acronyms: %s.
void setFamilyType();
int initHardwareInfo(std::string deviceName);
int initHardwareInfoForProductConfig(std::string deviceName);
int initHardwareInfoForDeprecatedAcronyms(std::string deviceName, int deviceId);
int initHardwareInfoForDeprecatedAcronyms(std::string deviceName);
bool isArgumentDeviceId(const std::string &argument) const;
std::string getStringWithinDelimiters(const std::string &src);
int initialize(size_t numArgs, const std::vector<std::string> &allArgs, bool dumpFiles);

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

@ -92,6 +92,23 @@ AOT::PRODUCT_CONFIG ProductConfigHelper::getProductConfigForAcronym(const std::s
return it->second;
}
const std::string ProductConfigHelper::getAcronymForProductConfig(AOT::PRODUCT_CONFIG config) const {
auto it = std::find_if(deviceAotInfo.begin(), deviceAotInfo.end(), findProductConfig(config));
if (it == deviceAotInfo.end()) {
return {};
}
return it->acronyms.empty() ? parseMajorMinorRevisionValue(it->aotConfig) : it->acronyms.front().str();
}
AOT::PRODUCT_CONFIG ProductConfigHelper::getProductConfigForDeviceId(unsigned short deviceId) const {
for (const auto &device : deviceAotInfo) {
if (std::find(device.deviceIds->begin(), device.deviceIds->end(), deviceId) != device.deviceIds->end()) {
return static_cast<AOT::PRODUCT_CONFIG>(device.aotConfig.ProductConfig);
}
}
return AOT::UNKNOWN_ISA;
}
bool ProductConfigHelper::isRelease(const std::string &device) {
auto release = getReleaseForAcronym(device);
if (release == AOT::UNKNOWN_RELEASE) {

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

@ -106,12 +106,15 @@ struct ProductConfigHelper {
bool isProductConfig(const std::string &device);
bool getDeviceAotInfoForProductConfig(AOT::PRODUCT_CONFIG config, DeviceAotInfo &out) const;
std::vector<DeviceAotInfo> &getDeviceAotInfo();
std::vector<NEO::ConstStringRef> getRepresentativeProductAcronyms();
std::vector<NEO::ConstStringRef> getReleasesAcronyms();
std::vector<NEO::ConstStringRef> getFamiliesAcronyms();
std::vector<NEO::ConstStringRef> getDeprecatedAcronyms();
std::vector<NEO::ConstStringRef> getAllProductAcronyms();
AOT::PRODUCT_CONFIG getProductConfigForDeviceId(unsigned short deviceId) const;
const std::string getAcronymForProductConfig(AOT::PRODUCT_CONFIG config) const;
protected:
std::vector<DeviceAotInfo> deviceAotInfo;

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

@ -505,3 +505,63 @@ TEST_F(AotDeviceInfoTests, givenUnknownIsaWhenGetDeviceAotInfoThenFalseIsReturne
EXPECT_FALSE(productConfigHelper->getDeviceAotInfoForProductConfig(AOT::UNKNOWN_ISA, aotInfo));
EXPECT_TRUE(aotInfo == emptyInfo);
}
TEST_F(AotDeviceInfoTests, givenDeviceIdWhenSearchForProductConfigAndAcronymThenCorrectResultsAreReturned) {
auto deviceAot = productConfigHelper->getDeviceAotInfo();
if (deviceAot.empty()) {
GTEST_SKIP();
}
for (const auto &device : deviceAot) {
for (const auto &deviceId : *device.deviceIds) {
auto config = productConfigHelper->getProductConfigForDeviceId(deviceId);
EXPECT_NE(config, AOT::UNKNOWN_ISA);
auto name = productConfigHelper->getAcronymForProductConfig(config);
EXPECT_FALSE(name.empty());
}
}
}
TEST_F(AotDeviceInfoTests, givenDeviceIdWhenThereAreNoAcronymsThenMajorMinorRevisionIsReturned) {
auto &deviceAot = productConfigHelper->getDeviceAotInfo();
if (deviceAot.empty()) {
GTEST_SKIP();
}
for (auto &device : deviceAot) {
for (const auto &deviceId : *device.deviceIds) {
auto config = productConfigHelper->getProductConfigForDeviceId(deviceId);
EXPECT_NE(config, AOT::UNKNOWN_ISA);
device.acronyms.clear();
auto name = productConfigHelper->getAcronymForProductConfig(config);
auto expected = productConfigHelper->parseMajorMinorRevisionValue(config);
EXPECT_STREQ(name.c_str(), expected.c_str());
}
}
}
TEST_F(AotDeviceInfoTests, givenInvalidDeviceIdWhenSearchForProductConfigAndAcronymThenUnknownIsaIsReturned) {
auto config = productConfigHelper->getProductConfigForDeviceId(0x0);
EXPECT_EQ(config, AOT::UNKNOWN_ISA);
auto name = productConfigHelper->getAcronymForProductConfig(config);
EXPECT_TRUE(name.empty());
}
TEST_F(AotDeviceInfoTests, givenDeviceIdsFromDevicesFileWhenGetProductConfigThenValueIsExpectedToBeFound) {
std::vector<unsigned short> deviceIds{
#define NAMEDDEVICE(devId, ignored_product, ignored_devName) devId,
#define DEVICE(devId, ignored_product) devId,
#include "devices.inl"
#undef DEVICE
#undef NAMEDDEVICE
};
if (deviceIds.empty()) {
GTEST_SKIP();
}
for (const auto &deviceId : deviceIds) {
EXPECT_NE(productConfigHelper->getProductConfigForDeviceId(deviceId), AOT::UNKNOWN_ISA);
}
}