diff --git a/opencl/test/unit_test/offline_compiler/mock/mock_argument_helper.h b/opencl/test/unit_test/offline_compiler/mock/mock_argument_helper.h index 1f1d0bbdb0..22d4547244 100644 --- a/opencl/test/unit_test/offline_compiler/mock/mock_argument_helper.h +++ b/opencl/test/unit_test/offline_compiler/mock/mock_argument_helper.h @@ -8,7 +8,6 @@ #pragma once #include "shared/offline_compiler/source/ocloc_arg_helper.h" -#include "shared/source/helpers/product_config_helper_former.h" #include "shared/source/helpers/string.h" #include @@ -16,10 +15,6 @@ #include #include -int oclocInvokeWithHelper( - OclocArgHelper *argHelper, - unsigned int numArgs, const char *argv[]); - class MockOclocArgHelper : public OclocArgHelper { public: using OclocArgHelper::hasOutput; @@ -46,10 +41,6 @@ class MockOclocArgHelper : public OclocArgHelper { MockOclocArgHelper(FilesMap &filesMap) : OclocArgHelper(0, nullptr, nullptr, nullptr, 0, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr), filesMap(filesMap){}; - void setFormerProductConfigHelper(std::unique_ptr helper) { - formerProductConfigHelper = std::move(helper); - } - void setAllCallBase(bool value) { callBaseFileExists = value; callBaseReadBinaryFile = value; diff --git a/opencl/test/unit_test/offline_compiler/ocloc_api_tests.cpp b/opencl/test/unit_test/offline_compiler/ocloc_api_tests.cpp index 606506fb62..f2c04e7229 100644 --- a/opencl/test/unit_test/offline_compiler/ocloc_api_tests.cpp +++ b/opencl/test/unit_test/offline_compiler/ocloc_api_tests.cpp @@ -29,7 +29,6 @@ #include "environment.h" #include "gtest/gtest.h" #include "hw_cmds_default.h" -#include "mock/mock_argument_helper.h" #include "neo_aot_platforms.h" #include @@ -42,97 +41,13 @@ extern Environment *gEnvironment; using namespace std::string_literals; -Ocloc::SupportedDevicesHelper::SupportedDevicesData createMockFormerData() { - Ocloc::SupportedDevicesHelper::SupportedDevicesData mockFormerData{ - // deviceIpVersions - { - 0x2000000, 0x2400009, 0x2404009, 0x2408009, 0x240c000, 0x2410000, 0x2414000, 0x2418000, 0x241c000, - 0x2c00000, 0x2c04000, 0x2c08000}, - // deviceInfos - { - {0x1001, 0x01, 0x2000000}, - {0x1002, 0x02, 0x2400009}, - {0x1003, 0x03, 0x2404009}, - {0x1004, 0x04, 0x2408009}}, - // acronyms - { - {"bdw", 0x2000000}, - {"skl", 0x2400009}, - {"kbl", 0x2404009}, - {"cfl", 0x2408009}, - {"apl", 0x240c000}, - {"bxt", 0x240c000}, - {"glk", 0x2410000}, - {"whl", 0x2414000}, - {"aml", 0x2418000}, - {"cml", 0x241c000}, - {"icl", 0x2c00000}, - {"lkf", 0x2c04000}, - {"ehl", 0x2c08000}, - }, - // familyGroups - { - {"family8", {0x2000000}}, - {"family9", {0x2400009, 0x2404009, 0x2408009, 0x240c000, 0x2410000, 0x2414000, 0x2418000, 0x241c000}}, - {"family11", {0x2c00000, 0x2c04000, 0x2c08000}}}, - // releaseGroups - { - {"release8", {0x2000000}}, - {"release9", {0x2400009, 0x2404009, 0x2408009, 0x240c000, 0x2410000, 0x2414000, 0x2418000, 0x241c000}}, - {"release11", {0x2c00000, 0x2c04000, 0x2c08000}}}}; - - return mockFormerData; -} - void mockedAbortOclocExecution(int errorCode) { throw std::runtime_error{"mockedAbortOclocExecution() called with error code = " + std::to_string(errorCode)}; } -namespace OclocTestMocks { -int mockOclocInvokeResult = ocloc_error_t::OCLOC_SUCCESS; -} - -int mockOclocInvoke(unsigned int numArgs, const char *argv[], - const uint32_t numSources, const uint8_t **dataSources, const uint64_t *lenSources, const char **nameSources, - const uint32_t numInputHeaders, const uint8_t **dataInputHeaders, const uint64_t *lenInputHeaders, const char **nameInputHeaders, - uint32_t *numOutputs, uint8_t ***dataOutputs, uint64_t **lenOutputs, char ***nameOutputs); - -int mockOclocInvoke(unsigned int numArgs, const char *argv[], - const uint32_t numSources, const uint8_t **dataSources, const uint64_t *lenSources, const char **nameSources, - const uint32_t numInputHeaders, const uint8_t **dataInputHeaders, const uint64_t *lenInputHeaders, const char **nameInputHeaders, - uint32_t *numOutputs, uint8_t ***dataOutputs, uint64_t **lenOutputs, char ***nameOutputs) { - - if (numOutputs && dataOutputs && lenOutputs && nameOutputs) { - numOutputs[0] = 2; - dataOutputs[0] = new uint8_t *[2]; - dataOutputs[0][0] = new uint8_t[1]; - dataOutputs[0][0][0] = 0xa; - dataOutputs[0][1] = new uint8_t[2]; - dataOutputs[0][1][0] = 0x1; - dataOutputs[0][1][1] = 0x4; - lenOutputs[0] = new uint64_t[2]; - lenOutputs[0][0] = 1; - lenOutputs[0][1] = 2; - nameOutputs[0] = new char *[2]; - constexpr char outputName0[] = "out0"; - constexpr char outputName1[] = "out1"; - nameOutputs[0][0] = new char[sizeof(outputName0)]; - nameOutputs[0][1] = new char[sizeof(outputName1)]; - memcpy_s(nameOutputs[0][0], sizeof(outputName0), outputName0, sizeof(outputName0)); - memcpy_s(nameOutputs[0][1], sizeof(outputName1), outputName1, sizeof(outputName1)); - } - - return OclocTestMocks::mockOclocInvokeResult; -} - TEST(OclocApiTests, WhenOclocVersionIsCalledThenCurrentOclocVersionIsReturned) { EXPECT_EQ(ocloc_version_t::OCLOC_VERSION_CURRENT, oclocVersion()); } - -namespace Ocloc { -extern std::string oclocFormerLibName; -} - class OclocApiTest : public ::testing::Test { protected: void SetUp() override { @@ -149,59 +64,9 @@ class OclocApiTest : public ::testing::Test { writeDataToFile(clCopybufferFilename.c_str(), kernelSources); } - // Helper struct to reduce repetition of IoFunctions mocking - struct IoFunctionsMockHelper { - static inline std::vector currentExpectedFiles{"copybuffer.cl"}; - static inline std::string currentKernelSource{"example_kernel(){}"}; - - VariableBackup mockFopen; - VariableBackup mockFclose; - VariableBackup mockFseek; - VariableBackup mockFtell; - VariableBackup mockFread; - - static FILE *mockFopenImpl(const char *filename, const char *mode) { - std::filesystem::path filePath = filename; - std::string fileNameWithExtension = filePath.filename().string(); - auto itr = std::find(currentExpectedFiles.begin(), currentExpectedFiles.end(), fileNameWithExtension); - if (itr != currentExpectedFiles.end()) { - return reinterpret_cast(0x40); - } - return NULL; - } - - static int mockFcloseImpl(FILE *stream) { return 0; } - - static int mockFseekImpl(FILE *stream, long int offset, int origin) { return 0; } - - static long int mockFtellImpl(FILE *stream) { - std::stringstream fileStream(currentKernelSource); - fileStream.seekg(0, std::ios::end); - return static_cast(fileStream.tellg()); - } - - static size_t mockFreadImpl(void *ptr, size_t size, size_t count, FILE *stream) { - std::stringstream fileStream(currentKernelSource); - size_t totalBytes = size * count; - fileStream.read(static_cast(ptr), totalBytes); - return static_cast(fileStream.gcount() / size); - } - - IoFunctionsMockHelper(const std::vector &expectedFiles = {"copybuffer.cl"}, - const std::string &kernelSource = "example_kernel(){}") : mockFopen(&NEO::IoFunctions::fopenPtr, mockFopenImpl), - mockFclose(&NEO::IoFunctions::fclosePtr, mockFcloseImpl), - mockFseek(&NEO::IoFunctions::fseekPtr, mockFseekImpl), - mockFtell(&NEO::IoFunctions::ftellPtr, mockFtellImpl), - mockFread(&NEO::IoFunctions::freadPtr, mockFreadImpl) { - currentExpectedFiles = expectedFiles; - currentKernelSource = kernelSource; - } - }; - const std::string clCopybufferFilename = "some_kernel.cl"; const std::string_view kernelSources = "example_kernel(){}"; }; - TEST_F(OclocApiTest, WhenGoodArgsAreGivenThenSuccessIsReturned) { VariableBackup mockFopen(&NEO::IoFunctions::fopenPtr, [](const char *filename, const char *mode) -> FILE * { std::filesystem::path filePath = filename; @@ -535,7 +400,6 @@ TEST_F(OclocApiTest, WhenGoodFamilyNameIsProvidedThenSuccessIsReturned) { 0, nullptr, nullptr, nullptr, 0, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr); - std::string output = capture.getCapturedStdout(); EXPECT_EQ(retVal, OCLOC_SUCCESS); @@ -694,11 +558,11 @@ TEST_F(OclocApiTest, GivenIncludeHeadersWhenCompilingThenPassesToFclHeadersPacke unsigned int argc = sizeof(argv) / sizeof(const char *); const char *headerA = R"===( - void foo() {} + void foo() {} )==="; const char *headerB = R"===( - void bar() {} + void bar() {} )==="; const char *main = R"===( @@ -1332,386 +1196,6 @@ TEST_F(OclocApiTest, GivenVerboseModeWhenCompilingThenPrintCommandLine) { EXPECT_NE(std::string::npos, output.find("Build succeeded.\n")); } -TEST_F(OclocApiTest, GivenFormerDeviceNamesWhenCompilingThenFormerOclocIsUsedAndSuccessIsReturned) { - IoFunctionsMockHelper mockIoFunctions; - - std::string clFileName(clFiles + "copybuffer.cl"); - MockOclocArgHelper::FilesMap mockArgHelperFilesMap{{clFileName, "example_kernel(){}"}}; - MockOclocArgHelper mockArgHelper{mockArgHelperFilesMap}; - auto formerHelper = std::make_unique(); - - formerHelper->getData() = createMockFormerData(); - mockArgHelper.setFormerProductConfigHelper(std::move(formerHelper)); - - VariableBackup oclocFormerNameBackup{&Ocloc::oclocFormerLibName}; - Ocloc::oclocFormerLibName = "oclocFormer"; - - static auto storedOriginalLoadFunc = NEO::OsLibrary::loadFunc; - - auto selectiveLoadFunc = [](const NEO::OsLibraryCreateProperties &properties) -> NEO::OsLibrary * { - if (properties.libraryName == "oclocFormer") { - if (MockOsLibrary::loadLibraryNewObject) { - auto ptr = MockOsLibrary::loadLibraryNewObject; - MockOsLibrary::loadLibraryNewObject = nullptr; - return ptr; - } - return nullptr; - } - return storedOriginalLoadFunc(properties); - }; - VariableBackup funcBackup{&NEO::OsLibrary::loadFunc, +selectiveLoadFunc}; - - MockOsLibrary::loadLibraryNewObject = new MockOsLibraryCustom(nullptr, true); - auto osLibrary = static_cast(MockOsLibrary::loadLibraryNewObject); - osLibrary->procMap["oclocInvoke"] = reinterpret_cast(mockOclocInvoke); - VariableBackup retCodeBackup{&OclocTestMocks::mockOclocInvokeResult, ocloc_error_t::OCLOC_SUCCESS}; - - std::vector deviceCombinations = { - "8.0.0", - "0x1001", - "33554432", - "bdw", - "bdw,skl,icl", - "bdw:icl", - ":icl"}; - - for (const auto &deviceArg : deviceCombinations) { - const char *argv[] = { - "ocloc", - "-file", - clFileName.c_str(), - "-device", - deviceArg.c_str()}; - unsigned int argc = sizeof(argv) / sizeof(const char *); - - StreamCapture capture; - capture.captureStdout(); - auto retVal = oclocInvokeWithHelper(&mockArgHelper, argc, argv); - std::string output = capture.getCapturedStdout(); - - EXPECT_EQ(retVal, OCLOC_SUCCESS) << "Failed for device: " << deviceArg; - EXPECT_EQ(std::string::npos, output.find("Command was: ocloc -file test_files/copybuffer.cl -device " + deviceArg)) << "Unexpected command output for device: " << deviceArg; - } -} - -TEST_F(OclocApiTest, GivenMixedFormerAndCurrentDeviceNamesWhenCompilingThenCorrectOclocIsUsedAndSuccessIsReturned) { - IoFunctionsMockHelper mockIoFunctions; - - std::string clFileName(clFiles + "copybuffer.cl"); - MockOclocArgHelper::FilesMap mockArgHelperFilesMap{{clFileName, "example_kernel(){}"}}; - MockOclocArgHelper mockArgHelper{mockArgHelperFilesMap}; - auto formerHelper = std::make_unique(); - - formerHelper->getData() = createMockFormerData(); - mockArgHelper.setFormerProductConfigHelper(std::move(formerHelper)); - - auto target = gEnvironment->devicePrefix; - auto product = mockArgHelper.productConfigHelper->getProductConfigFromAcronym(target); - if (product == AOT::UNKNOWN_ISA) { - GTEST_SKIP(); - } - - VariableBackup oclocFormerNameBackup{&Ocloc::oclocFormerLibName}; - Ocloc::oclocFormerLibName = "oclocFormer"; - - static auto storedOriginalLoadFunc = NEO::OsLibrary::loadFunc; - - auto selectiveLoadFunc = [](const NEO::OsLibraryCreateProperties &properties) -> NEO::OsLibrary * { - if (properties.libraryName == "oclocFormer") { - if (MockOsLibrary::loadLibraryNewObject) { - auto ptr = MockOsLibrary::loadLibraryNewObject; - MockOsLibrary::loadLibraryNewObject = nullptr; - return ptr; - } - return nullptr; - } - return storedOriginalLoadFunc(properties); - }; - VariableBackup funcBackup{&NEO::OsLibrary::loadFunc, +selectiveLoadFunc}; - - MockOsLibrary::loadLibraryNewObject = new MockOsLibraryCustom(nullptr, true); - auto osLibrary = static_cast(MockOsLibrary::loadLibraryNewObject); - osLibrary->procMap["oclocInvoke"] = reinterpret_cast(mockOclocInvoke); - VariableBackup retCodeBackup{&OclocTestMocks::mockOclocInvokeResult, ocloc_error_t::OCLOC_SUCCESS}; - - std::vector deviceCombinations = { - "bdw,skl," + std::string(target.c_str()), - "bdw:" + std::string(target.c_str()), - ":" + std::string(target.c_str())}; - - for (const auto &deviceArg : deviceCombinations) { - const char *argv[] = { - "ocloc", - "-file", - clFileName.c_str(), - "-device", - deviceArg.c_str()}; - unsigned int argc = sizeof(argv) / sizeof(const char *); - - StreamCapture capture; - capture.captureStdout(); - auto retVal = oclocInvokeWithHelper(&mockArgHelper, argc, argv); - std::string output = capture.getCapturedStdout(); - - EXPECT_EQ(retVal, OCLOC_SUCCESS) << "Failed for device: " << deviceArg; - EXPECT_EQ(std::string::npos, output.find("Command was: ocloc -file test_files/copybuffer.cl -device " + deviceArg)) << "Unexpected command output for device: " << deviceArg; - } -} - -TEST_F(OclocApiTest, GivenFormerFamilyNamesWhenCompilingThenFormerOclocIsUsedAndSuccessIsReturned) { - IoFunctionsMockHelper mockIoFunctions; - - std::string clFileName(clFiles + "copybuffer.cl"); - MockOclocArgHelper::FilesMap mockArgHelperFilesMap{{clFileName, "example_kernel(){}"}}; - MockOclocArgHelper mockArgHelper{mockArgHelperFilesMap}; - auto formerHelper = std::make_unique(); - - formerHelper->getData() = createMockFormerData(); - mockArgHelper.setFormerProductConfigHelper(std::move(formerHelper)); - - VariableBackup oclocFormerNameBackup{&Ocloc::oclocFormerLibName}; - Ocloc::oclocFormerLibName = "oclocFormer"; - - static auto storedOriginalLoadFunc = NEO::OsLibrary::loadFunc; - - auto selectiveLoadFunc = [](const NEO::OsLibraryCreateProperties &properties) -> NEO::OsLibrary * { - if (properties.libraryName == "oclocFormer") { - if (MockOsLibrary::loadLibraryNewObject) { - auto ptr = MockOsLibrary::loadLibraryNewObject; - MockOsLibrary::loadLibraryNewObject = nullptr; - return ptr; - } - return nullptr; - } - return storedOriginalLoadFunc(properties); - }; - VariableBackup funcBackup{&NEO::OsLibrary::loadFunc, +selectiveLoadFunc}; - - MockOsLibrary::loadLibraryNewObject = new MockOsLibraryCustom(nullptr, true); - auto osLibrary = static_cast(MockOsLibrary::loadLibraryNewObject); - osLibrary->procMap["oclocInvoke"] = reinterpret_cast(mockOclocInvoke); - VariableBackup retCodeBackup{&OclocTestMocks::mockOclocInvokeResult, ocloc_error_t::OCLOC_SUCCESS}; - - std::vector familyCombinations = { - "family8", - "family8,family9,family11", - "family8:family11", - ":family11"}; - - for (const auto &familyArg : familyCombinations) { - const char *argv[] = { - "ocloc", - "-file", - clFileName.c_str(), - "-device", - familyArg.c_str()}; - unsigned int argc = sizeof(argv) / sizeof(const char *); - - StreamCapture capture; - capture.captureStdout(); - auto retVal = oclocInvokeWithHelper(&mockArgHelper, argc, argv); - std::string output = capture.getCapturedStdout(); - - EXPECT_EQ(retVal, OCLOC_SUCCESS) << "Failed for device: " << familyArg; - EXPECT_EQ(std::string::npos, output.find("Command was: ocloc -file test_files/copybuffer.cl -device " + familyArg)) << "Unexpected command output for device: " << familyArg; - } -} - -TEST_F(OclocApiTest, GivenMixedFormerAndCurrentFamilyNamesWhenCompilingThenCorrectOclocIsUsedAndSuccessIsReturned) { - IoFunctionsMockHelper mockIoFunctions; - - std::string clFileName(clFiles + "copybuffer.cl"); - MockOclocArgHelper::FilesMap mockArgHelperFilesMap{{clFileName, "example_kernel(){}"}}; - MockOclocArgHelper mockArgHelper{mockArgHelperFilesMap}; - auto formerHelper = std::make_unique(); - - formerHelper->getData() = createMockFormerData(); - mockArgHelper.setFormerProductConfigHelper(std::move(formerHelper)); - - auto target = gEnvironment->devicePrefix; - auto product = mockArgHelper.productConfigHelper->getProductConfigFromAcronym(target); - if (product == AOT::UNKNOWN_ISA) { - GTEST_SKIP(); - } - - auto &deviceAotInfo = mockArgHelper.productConfigHelper->getDeviceAotInfo(); - auto it = std::find_if(deviceAotInfo.begin(), deviceAotInfo.end(), ProductConfigHelper::findProductConfig(product)); - auto familyAcronym = mockArgHelper.productConfigHelper->getAcronymFromAFamily(it->family); - - VariableBackup oclocFormerNameBackup{&Ocloc::oclocFormerLibName}; - Ocloc::oclocFormerLibName = "oclocFormer"; - - static auto storedOriginalLoadFunc = NEO::OsLibrary::loadFunc; - - auto selectiveLoadFunc = [](const NEO::OsLibraryCreateProperties &properties) -> NEO::OsLibrary * { - if (properties.libraryName == "oclocFormer") { - if (MockOsLibrary::loadLibraryNewObject) { - auto ptr = MockOsLibrary::loadLibraryNewObject; - MockOsLibrary::loadLibraryNewObject = nullptr; - return ptr; - } - return nullptr; - } - return storedOriginalLoadFunc(properties); - }; - VariableBackup funcBackup{&NEO::OsLibrary::loadFunc, +selectiveLoadFunc}; - - MockOsLibrary::loadLibraryNewObject = new MockOsLibraryCustom(nullptr, true); - auto osLibrary = static_cast(MockOsLibrary::loadLibraryNewObject); - osLibrary->procMap["oclocInvoke"] = reinterpret_cast(mockOclocInvoke); - VariableBackup retCodeBackup{&OclocTestMocks::mockOclocInvokeResult, ocloc_error_t::OCLOC_SUCCESS}; - - std::vector familyCombinations = { - "family8,family11," + std::string(familyAcronym.str().c_str()), - "family8:" + std::string(familyAcronym.str().c_str()), - ":" + std::string(familyAcronym.str().c_str())}; - - for (const auto &familyArg : familyCombinations) { - const char *argv[] = { - "ocloc", - "-file", - clFileName.c_str(), - "-device", - familyArg.c_str()}; - unsigned int argc = sizeof(argv) / sizeof(const char *); - - StreamCapture capture; - capture.captureStdout(); - auto retVal = oclocInvokeWithHelper(&mockArgHelper, argc, argv); - std::string output = capture.getCapturedStdout(); - - EXPECT_EQ(retVal, OCLOC_SUCCESS) << "Failed for device: " << familyArg; - EXPECT_EQ(std::string::npos, output.find("Command was: ocloc -file test_files/copybuffer.cl -device " + familyArg)) << "Unexpected command output for device: " << familyArg; - } -} - -TEST_F(OclocApiTest, GivenFormerReleaseNamesWhenCompilingThenFormerOclocIsUsedAndSuccessIsReturned) { - IoFunctionsMockHelper mockIoFunctions; - - std::string clFileName(clFiles + "copybuffer.cl"); - MockOclocArgHelper::FilesMap mockArgHelperFilesMap{{clFileName, "example_kernel(){}"}}; - MockOclocArgHelper mockArgHelper{mockArgHelperFilesMap}; - auto formerHelper = std::make_unique(); - - formerHelper->getData() = createMockFormerData(); - mockArgHelper.setFormerProductConfigHelper(std::move(formerHelper)); - - VariableBackup oclocFormerNameBackup{&Ocloc::oclocFormerLibName}; - Ocloc::oclocFormerLibName = "oclocFormer"; - - static auto storedOriginalLoadFunc = NEO::OsLibrary::loadFunc; - - auto selectiveLoadFunc = [](const NEO::OsLibraryCreateProperties &properties) -> NEO::OsLibrary * { - if (properties.libraryName == "oclocFormer") { - if (MockOsLibrary::loadLibraryNewObject) { - auto ptr = MockOsLibrary::loadLibraryNewObject; - MockOsLibrary::loadLibraryNewObject = nullptr; - return ptr; - } - return nullptr; - } - return storedOriginalLoadFunc(properties); - }; - VariableBackup funcBackup{&NEO::OsLibrary::loadFunc, +selectiveLoadFunc}; - - MockOsLibrary::loadLibraryNewObject = new MockOsLibraryCustom(nullptr, true); - auto osLibrary = static_cast(MockOsLibrary::loadLibraryNewObject); - osLibrary->procMap["oclocInvoke"] = reinterpret_cast(mockOclocInvoke); - VariableBackup retCodeBackup{&OclocTestMocks::mockOclocInvokeResult, ocloc_error_t::OCLOC_SUCCESS}; - - std::vector releaseCombinations = { - "release8", - "release8,release9,release11", - "release8:release11", - ":release11"}; - - for (const auto &releaseArg : releaseCombinations) { - const char *argv[] = { - "ocloc", - "-file", - clFileName.c_str(), - "-device", - releaseArg.c_str()}; - unsigned int argc = sizeof(argv) / sizeof(const char *); - - StreamCapture capture; - capture.captureStdout(); - auto retVal = oclocInvokeWithHelper(&mockArgHelper, argc, argv); - std::string output = capture.getCapturedStdout(); - - EXPECT_EQ(retVal, OCLOC_SUCCESS) << "Failed for device: " << releaseArg; - EXPECT_EQ(std::string::npos, output.find("Command was: ocloc -file test_files/copybuffer.cl -device " + releaseArg)) << "Unexpected command output for device: " << releaseArg; - } -} - -TEST_F(OclocApiTest, GivenMixedFormerAndCurrentReleaseNamesWhenCompilingThenCorrectOclocIsUsedAndSuccessIsReturned) { - IoFunctionsMockHelper mockIoFunctions; - - std::string clFileName(clFiles + "copybuffer.cl"); - MockOclocArgHelper::FilesMap mockArgHelperFilesMap{{clFileName, "example_kernel(){}"}}; - MockOclocArgHelper mockArgHelper{mockArgHelperFilesMap}; - auto formerHelper = std::make_unique(); - - formerHelper->getData() = createMockFormerData(); - mockArgHelper.setFormerProductConfigHelper(std::move(formerHelper)); - - auto target = gEnvironment->devicePrefix; - auto product = mockArgHelper.productConfigHelper->getProductConfigFromAcronym(target); - if (product == AOT::UNKNOWN_ISA) { - GTEST_SKIP(); - } - - auto &deviceAotInfo = mockArgHelper.productConfigHelper->getDeviceAotInfo(); - auto it = std::find_if(deviceAotInfo.begin(), deviceAotInfo.end(), ProductConfigHelper::findProductConfig(product)); - auto releaseAcronym = mockArgHelper.productConfigHelper->getAcronymFromARelease(it->release); - - VariableBackup oclocFormerNameBackup{&Ocloc::oclocFormerLibName}; - Ocloc::oclocFormerLibName = "oclocFormer"; - - static auto storedOriginalLoadFunc = NEO::OsLibrary::loadFunc; - - auto selectiveLoadFunc = [](const NEO::OsLibraryCreateProperties &properties) -> NEO::OsLibrary * { - if (properties.libraryName == "oclocFormer") { - if (MockOsLibrary::loadLibraryNewObject) { - auto ptr = MockOsLibrary::loadLibraryNewObject; - MockOsLibrary::loadLibraryNewObject = nullptr; - return ptr; - } - return nullptr; - } - return storedOriginalLoadFunc(properties); - }; - VariableBackup funcBackup{&NEO::OsLibrary::loadFunc, +selectiveLoadFunc}; - - MockOsLibrary::loadLibraryNewObject = new MockOsLibraryCustom(nullptr, true); - auto osLibrary = static_cast(MockOsLibrary::loadLibraryNewObject); - osLibrary->procMap["oclocInvoke"] = reinterpret_cast(mockOclocInvoke); - VariableBackup retCodeBackup{&OclocTestMocks::mockOclocInvokeResult, ocloc_error_t::OCLOC_SUCCESS}; - - std::vector releaseCombinations = { - "release8,release11," + std::string(releaseAcronym.str().c_str()), - "release8:" + std::string(releaseAcronym.str().c_str()), - ":" + std::string(releaseAcronym.str().c_str())}; - - for (const auto &releaseArg : releaseCombinations) { - const char *argv[] = { - "ocloc", - "-file", - clFileName.c_str(), - "-device", - releaseArg.c_str()}; - unsigned int argc = sizeof(argv) / sizeof(const char *); - - StreamCapture capture; - capture.captureStdout(); - auto retVal = oclocInvokeWithHelper(&mockArgHelper, argc, argv); - std::string output = capture.getCapturedStdout(); - - EXPECT_EQ(retVal, OCLOC_SUCCESS) << "Failed for device: " << releaseArg; - EXPECT_EQ(std::string::npos, output.find("Command was: ocloc -file test_files/copybuffer.cl -device " + releaseArg)) << "Unexpected command output for device: " << releaseArg; - } -} - TEST(InvokeFormerOclocTest, givenEmptyOrInvalidFormerOclocNameWhenInvokeFormerOclocThenNulloptIsReturned) { const char *argv[] = { "ocloc", @@ -1736,6 +1220,10 @@ TEST(InvokeFormerOclocTest, givenEmptyOrInvalidFormerOclocNameWhenInvokeFormerOc EXPECT_FALSE(retVal.has_value()); } +namespace Ocloc { +extern std::string oclocFormerLibName; +} + struct OclocFallbackTests : ::testing::Test { int callOclocForInvalidDevice() { @@ -1801,3 +1289,143 @@ TEST_F(OclocFallbackTests, GivenNoFormerOclocNameWhenInvalidDeviceErrorIsReturne EXPECT_EQ(std::string::npos, capturedStdout.find("Couldn't load former ocloc")); EXPECT_TRUE(capturedStderr.empty()); } + +TEST_F(OclocFallbackTests, GivenInvalidFormerOclocNameWhenInvalidDeviceErrorIsReturnedThenFallbackButWithoutLoadingLib) { + VariableBackup mockFopen(&NEO::IoFunctions::fopenPtr, [](const char *filename, const char *mode) -> FILE * { return NULL; }); + + Ocloc::oclocFormerLibName = "invalidName"; + + auto retVal = callOclocForInvalidDevice(); + + EXPECT_EQ(ocloc_error_t::OCLOC_INVALID_DEVICE, retVal); + EXPECT_NE(std::string::npos, capturedStdout.find("Could not determine device target: invalid_device.\n")); + EXPECT_NE(std::string::npos, capturedStdout.find("Error: Cannot get HW Info for device invalid_device.\n")); + EXPECT_NE(std::string::npos, capturedStdout.find("Command was: ocloc -file kernel.cl -device invalid_device\n")); + + EXPECT_NE(std::string::npos, capturedStdout.find("Couldn't load former ocloc invalidName")); + EXPECT_NE(std::string::npos, capturedStdout.find("Invalid device error, trying to fallback to former ocloc invalidName")); + EXPECT_TRUE(capturedStderr.empty()); +} + +int mockOclocInvokeResult = ocloc_error_t::OCLOC_SUCCESS; + +int mockOclocInvoke(unsigned int numArgs, const char *argv[], + const uint32_t numSources, const uint8_t **dataSources, const uint64_t *lenSources, const char **nameSources, + const uint32_t numInputHeaders, const uint8_t **dataInputHeaders, const uint64_t *lenInputHeaders, const char **nameInputHeaders, + uint32_t *numOutputs, uint8_t ***dataOutputs, uint64_t **lenOutputs, char ***nameOutputs) { + + if (numOutputs && dataOutputs && lenOutputs && nameOutputs) { + numOutputs[0] = 2; + dataOutputs[0] = new uint8_t *[2]; + dataOutputs[0][0] = new uint8_t[1]; + dataOutputs[0][0][0] = 0xa; + dataOutputs[0][1] = new uint8_t[2]; + dataOutputs[0][1][0] = 0x1; + dataOutputs[0][1][1] = 0x4; + lenOutputs[0] = new uint64_t[2]; + lenOutputs[0][0] = 1; + lenOutputs[0][1] = 2; + nameOutputs[0] = new char *[2]; + constexpr char outputName0[] = "out0"; + constexpr char outputName1[] = "out1"; + nameOutputs[0][0] = new char[sizeof(outputName0)]; + nameOutputs[0][1] = new char[sizeof(outputName1)]; + memcpy_s(nameOutputs[0][0], sizeof(outputName0), outputName0, sizeof(outputName0)); + memcpy_s(nameOutputs[0][1], sizeof(outputName1), outputName1, sizeof(outputName1)); + } + + return mockOclocInvokeResult; +} + +TEST_F(OclocFallbackTests, GivenValidFormerOclocNameWhenFormerOclocReturnsSuccessThenSuccessIsPropagatedAndCommandLineIsNotPrinted) { + VariableBackup mockFopen(&NEO::IoFunctions::fopenPtr, [](const char *filename, const char *mode) -> FILE * { return NULL; }); + + Ocloc::oclocFormerLibName = "oclocFormer"; + VariableBackup funcBackup{&NEO::OsLibrary::loadFunc, MockOsLibraryCustom::load}; + MockOsLibrary::loadLibraryNewObject = new MockOsLibraryCustom(nullptr, true); + auto osLibrary = static_cast(MockOsLibrary::loadLibraryNewObject); + + osLibrary->procMap["oclocInvoke"] = reinterpret_cast(mockOclocInvoke); + + VariableBackup retCodeBackup{&mockOclocInvokeResult, ocloc_error_t::OCLOC_SUCCESS}; + auto retVal = callOclocForInvalidDevice(); + + EXPECT_EQ(ocloc_error_t::OCLOC_SUCCESS, retVal); + EXPECT_NE(std::string::npos, capturedStdout.find("Could not determine device target: invalid_device.\n")); + EXPECT_NE(std::string::npos, capturedStdout.find("Error: Cannot get HW Info for device invalid_device.\n")); + EXPECT_NE(std::string::npos, capturedStdout.find("Invalid device error, trying to fallback to former ocloc oclocFormer\n")); + EXPECT_EQ(std::string::npos, capturedStdout.find("Command was: ocloc -file kernel.cl -device invalid_device\n")); + EXPECT_TRUE(capturedStderr.empty()); +} + +TEST_F(OclocFallbackTests, GivenValidFormerOclocNameWhenFormerOclocReturnsErrorThenErrorIsPropagated) { + VariableBackup mockFopen(&NEO::IoFunctions::fopenPtr, [](const char *filename, const char *mode) -> FILE * { return NULL; }); + + Ocloc::oclocFormerLibName = "oclocFormer"; + VariableBackup funcBackup{&NEO::OsLibrary::loadFunc, MockOsLibraryCustom::load}; + for (auto &error : { + ocloc_error_t::OCLOC_OUT_OF_HOST_MEMORY, + ocloc_error_t::OCLOC_BUILD_PROGRAM_FAILURE, + ocloc_error_t::OCLOC_INVALID_DEVICE, + ocloc_error_t::OCLOC_INVALID_PROGRAM, + ocloc_error_t::OCLOC_INVALID_COMMAND_LINE, + ocloc_error_t::OCLOC_INVALID_FILE, + ocloc_error_t::OCLOC_COMPILATION_CRASH}) { + + MockOsLibrary::loadLibraryNewObject = new MockOsLibraryCustom(nullptr, true); + auto osLibrary = static_cast(MockOsLibrary::loadLibraryNewObject); + + osLibrary->procMap["oclocInvoke"] = reinterpret_cast(mockOclocInvoke); + + VariableBackup retCodeBackup{&mockOclocInvokeResult, error}; + + auto retVal = callOclocForInvalidDevice(); + + EXPECT_EQ(error, retVal); + EXPECT_NE(std::string::npos, capturedStdout.find("Could not determine device target: invalid_device.\n")); + EXPECT_NE(std::string::npos, capturedStdout.find("Error: Cannot get HW Info for device invalid_device.\n")); + EXPECT_NE(std::string::npos, capturedStdout.find("Invalid device error, trying to fallback to former ocloc oclocFormer\n")); + EXPECT_NE(std::string::npos, capturedStdout.find("Command was: ocloc -file kernel.cl -device invalid_device\n")); + EXPECT_TRUE(capturedStderr.empty()); + } +} + +TEST_F(OclocFallbackTests, GivenValidFormerOclocNameWhenFormerOclocReturnsOutputsThenOutputIsPropagated) { + VariableBackup mockFopen(&NEO::IoFunctions::fopenPtr, [](const char *filename, const char *mode) -> FILE * { return NULL; }); + + for (auto &expectedRetVal : {ocloc_error_t::OCLOC_SUCCESS, + ocloc_error_t::OCLOC_OUT_OF_HOST_MEMORY, + ocloc_error_t::OCLOC_BUILD_PROGRAM_FAILURE, + ocloc_error_t::OCLOC_INVALID_DEVICE, + ocloc_error_t::OCLOC_INVALID_PROGRAM, + ocloc_error_t::OCLOC_INVALID_COMMAND_LINE, + ocloc_error_t::OCLOC_INVALID_FILE, + ocloc_error_t::OCLOC_COMPILATION_CRASH}) { + + passOutputs = true; + Ocloc::oclocFormerLibName = "oclocFormer"; + VariableBackup funcBackup{&NEO::OsLibrary::loadFunc, MockOsLibraryCustom::load}; + MockOsLibrary::loadLibraryNewObject = new MockOsLibraryCustom(nullptr, true); + auto osLibrary = static_cast(MockOsLibrary::loadLibraryNewObject); + + osLibrary->procMap["oclocInvoke"] = reinterpret_cast(mockOclocInvoke); + + VariableBackup retCodeBackup{&mockOclocInvokeResult, expectedRetVal}; + auto retVal = callOclocForInvalidDevice(); + EXPECT_EQ(expectedRetVal, retVal); + EXPECT_TRUE(capturedStdout.empty()); + EXPECT_TRUE(capturedStderr.empty()); + EXPECT_EQ(2u, numOutputs); + EXPECT_STREQ("out0", nameOutputs[0]); + EXPECT_STREQ("out1", nameOutputs[1]); + EXPECT_EQ(1u, lenOutputs[0]); + EXPECT_EQ(2u, lenOutputs[1]); + + EXPECT_EQ(0xa, dataOutputs[0][0]); + EXPECT_EQ(0x1, dataOutputs[1][0]); + EXPECT_EQ(0x4, dataOutputs[1][1]); + + oclocFreeOutput(&numOutputs, &dataOutputs, &lenOutputs, &nameOutputs); + } + passOutputs = false; +} \ No newline at end of file diff --git a/shared/offline_compiler/source/CMakeLists.txt b/shared/offline_compiler/source/CMakeLists.txt index 13d261ccab..23ce0c9059 100644 --- a/shared/offline_compiler/source/CMakeLists.txt +++ b/shared/offline_compiler/source/CMakeLists.txt @@ -75,8 +75,6 @@ set(CLOC_LIB_SRCS_LIB ${NEO_SHARED_DIRECTORY}/helpers/${BRANCH_DIR_SUFFIX}product_config_helper_extra.cpp ${NEO_SHARED_DIRECTORY}/helpers/product_config_helper.cpp ${NEO_SHARED_DIRECTORY}/helpers/product_config_helper.h - ${NEO_SHARED_DIRECTORY}/helpers/product_config_helper_former.cpp - ${NEO_SHARED_DIRECTORY}/helpers/product_config_helper_former.h ${NEO_SHARED_DIRECTORY}/kernel/${BRANCH_DIR_SUFFIX}kernel_descriptor_ext.cpp ${NEO_SHARED_DIRECTORY}/os_interface/os_library.cpp ${NEO_SHARED_DIRECTORY}/os_interface/os_library.h diff --git a/shared/offline_compiler/source/linux/ocloc_supported_devices_helper_linux.cpp b/shared/offline_compiler/source/linux/ocloc_supported_devices_helper_linux.cpp index 9ca685f7fd..cfeefedb84 100644 --- a/shared/offline_compiler/source/linux/ocloc_supported_devices_helper_linux.cpp +++ b/shared/offline_compiler/source/linux/ocloc_supported_devices_helper_linux.cpp @@ -85,12 +85,7 @@ std::string SupportedDevicesHelper::getDataFromFormerOcloc() const { break; } - // Use formerOclocFree since memory was allocated by former ocloc - auto freeResult = Commands::formerOclocFree(getOclocFormerLibName(), &numOutputs, &dataOutputs, &ouputLengths, &outputNames); - if (!freeResult) { - // Fallback to regular oclocFreeOutput if formerOclocFree fails - oclocFreeOutput(&numOutputs, &dataOutputs, &ouputLengths, &outputNames); - } + oclocFreeOutput(&numOutputs, &dataOutputs, &ouputLengths, &outputNames); return retData; } diff --git a/shared/offline_compiler/source/ocloc_api.cpp b/shared/offline_compiler/source/ocloc_api.cpp index 3d87d91fa1..522c4a0585 100644 --- a/shared/offline_compiler/source/ocloc_api.cpp +++ b/shared/offline_compiler/source/ocloc_api.cpp @@ -12,12 +12,17 @@ #include +extern "C" { using namespace Ocloc; -int oclocInvokeWithHelper( - OclocArgHelper *argHelper, - unsigned int numArgs, const char *argv[]) { - +int oclocInvoke(unsigned int numArgs, const char *argv[], + const uint32_t numSources, const uint8_t **dataSources, const uint64_t *lenSources, const char **nameSources, + const uint32_t numInputHeaders, const uint8_t **dataInputHeaders, const uint64_t *lenInputHeaders, const char **nameInputHeaders, + uint32_t *numOutputs, uint8_t ***dataOutputs, uint64_t **lenOutputs, char ***nameOutputs) { + auto argHelper = std::make_unique( + numSources, dataSources, lenSources, nameSources, + numInputHeaders, dataInputHeaders, lenInputHeaders, nameInputHeaders, + numOutputs, dataOutputs, lenOutputs, nameOutputs); std::vector args(argv, argv + numArgs); try { @@ -28,23 +33,34 @@ int oclocInvokeWithHelper( auto &command = args[1]; int retVal = -0; if (command == CommandNames::disassemble) { - retVal = Commands::disassemble(argHelper, args); + retVal = Commands::disassemble(argHelper.get(), args); } else if (command == CommandNames::assemble) { - retVal = Commands::assemble(argHelper, args); + retVal = Commands::assemble(argHelper.get(), args); } else if (command == CommandNames::multi) { - retVal = Commands::multi(argHelper, args); + retVal = Commands::multi(argHelper.get(), args); } else if (command == CommandNames::validate) { - retVal = Commands::validate(argHelper, args); + retVal = Commands::validate(argHelper.get(), args); } else if (command == CommandNames::query) { - retVal = Commands::query(argHelper, args); + retVal = Commands::query(argHelper.get(), args); } else if (command == CommandNames::ids) { - retVal = Commands::ids(argHelper, args); + retVal = Commands::ids(argHelper.get(), args); } else if (command == CommandNames::link) { - retVal = Commands::link(argHelper, args); + retVal = Commands::link(argHelper.get(), args); } else if (command == CommandNames::concat) { - retVal = Commands::concat(argHelper, args); + retVal = Commands::concat(argHelper.get(), args); } else { - retVal = Commands::compile(argHelper, args); + retVal = Commands::compile(argHelper.get(), args); + } + + if (retVal == ocloc_error_t::OCLOC_INVALID_DEVICE && !getOclocFormerLibName().empty()) { + argHelper->printf("Invalid device error, trying to fallback to former ocloc %s\n", getOclocFormerLibName().c_str()); + auto retValFromFormerOcloc = Commands::invokeFormerOcloc(getOclocFormerLibName(), numArgs, argv, numSources, dataSources, lenSources, nameSources, numInputHeaders, dataInputHeaders, lenInputHeaders, nameInputHeaders, numOutputs, dataOutputs, lenOutputs, nameOutputs); + if (retValFromFormerOcloc) { + retVal = retValFromFormerOcloc.value(); + argHelper->dontSetupOutputs(); + } else { + argHelper->printf("Couldn't load former ocloc %s\n", getOclocFormerLibName().c_str()); + } } if (retVal != OCLOC_SUCCESS) { @@ -60,18 +76,6 @@ int oclocInvokeWithHelper( } } -extern "C" { -int oclocInvoke(unsigned int numArgs, const char *argv[], - const uint32_t numSources, const uint8_t **dataSources, const uint64_t *lenSources, const char **nameSources, - const uint32_t numInputHeaders, const uint8_t **dataInputHeaders, const uint64_t *lenInputHeaders, const char **nameInputHeaders, - uint32_t *numOutputs, uint8_t ***dataOutputs, uint64_t **lenOutputs, char ***nameOutputs) { - auto argHelper = std::make_unique( - numSources, dataSources, lenSources, nameSources, - numInputHeaders, dataInputHeaders, lenInputHeaders, nameInputHeaders, - numOutputs, dataOutputs, lenOutputs, nameOutputs); - return oclocInvokeWithHelper(argHelper.get(), numArgs, argv); -} - int oclocFreeOutput(uint32_t *numOutputs, uint8_t ***dataOutputs, uint64_t **lenOutputs, char ***nameOutputs) { for (uint32_t i = 0; i < *numOutputs; i++) { delete[] (*dataOutputs)[i]; diff --git a/shared/offline_compiler/source/ocloc_arg_helper.cpp b/shared/offline_compiler/source/ocloc_arg_helper.cpp index fa0b4367c1..d7a3382b35 100644 --- a/shared/offline_compiler/source/ocloc_arg_helper.cpp +++ b/shared/offline_compiler/source/ocloc_arg_helper.cpp @@ -68,7 +68,6 @@ OclocArgHelper::OclocArgHelper(const uint32_t numSources, const uint8_t **dataSo } productConfigHelper = std::make_unique(); - formerProductConfigHelper = std::make_unique(); } OclocArgHelper::OclocArgHelper() : OclocArgHelper(0, nullptr, nullptr, nullptr, 0, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr) {} diff --git a/shared/offline_compiler/source/ocloc_arg_helper.h b/shared/offline_compiler/source/ocloc_arg_helper.h index a7b3104ada..97fb243b8d 100644 --- a/shared/offline_compiler/source/ocloc_arg_helper.h +++ b/shared/offline_compiler/source/ocloc_arg_helper.h @@ -21,7 +21,6 @@ constexpr auto *oclocStdoutLogName = "stdout.log"; struct ProductConfigHelper; -struct FormerProductConfigHelper; namespace NEO { class CompilerProductHelper; class ReleaseHelper; @@ -148,5 +147,4 @@ class OclocArgHelper { } std::unique_ptr productConfigHelper; - std::unique_ptr formerProductConfigHelper; }; diff --git a/shared/offline_compiler/source/ocloc_fatbinary.cpp b/shared/offline_compiler/source/ocloc_fatbinary.cpp index 18771f1233..899b14a1da 100644 --- a/shared/offline_compiler/source/ocloc_fatbinary.cpp +++ b/shared/offline_compiler/source/ocloc_fatbinary.cpp @@ -9,7 +9,6 @@ #include "shared/offline_compiler/source/ocloc_api.h" #include "shared/offline_compiler/source/ocloc_arg_helper.h" -#include "shared/offline_compiler/source/ocloc_interface.h" #include "shared/offline_compiler/source/offline_compiler.h" #include "shared/offline_compiler/source/utilities/safety_caller.h" #include "shared/source/compiler_interface/compiler_options.h" @@ -21,7 +20,6 @@ #include "shared/source/helpers/file_io.h" #include "shared/source/helpers/hw_info.h" #include "shared/source/helpers/product_config_helper.h" -#include "shared/source/helpers/product_config_helper_former.h" #include "shared/source/utilities/directory.h" #include "neo_aot_platforms.h" @@ -35,29 +33,22 @@ namespace NEO { -using Position = FormerProductConfigHelper::Position; - bool isSpvOnly(const std::vector &args) { return std::find(args.begin(), args.end(), "-spv_only") != args.end(); } bool requestedFatBinary(ConstStringRef deviceArg, OclocArgHelper *helper) { - auto &prodHelper = *helper->productConfigHelper; - auto &formerProdHelper = *helper->formerProductConfigHelper; auto deviceName = deviceArg.str(); ProductConfigHelper::adjustDeviceName(deviceName); + auto release = helper->productConfigHelper->getReleaseFromDeviceName(deviceName); + auto family = helper->productConfigHelper->getFamilyFromDeviceName(deviceName); - auto release = prodHelper.getReleaseFromDeviceName(deviceName); - auto family = prodHelper.getFamilyFromDeviceName(deviceName); auto retVal = deviceArg.contains("*"); retVal |= deviceArg.contains(":"); retVal |= deviceArg.contains(","); retVal |= family != AOT::UNKNOWN_FAMILY; retVal |= release != AOT::UNKNOWN_RELEASE; - retVal |= formerProdHelper.isSupportedTarget(deviceName); - retVal |= formerProdHelper.isSupportedTarget(deviceName); - return retVal; } @@ -74,8 +65,7 @@ bool requestedFatBinary(const std::vector &args, OclocArgHelper *he template <> void getProductsAcronymsForTarget(std::vector &out, AOT::RELEASE target, OclocArgHelper *argHelper) { - auto &prodHelper = *argHelper->productConfigHelper; - auto &allSuppportedProducts = prodHelper.getDeviceAotInfo(); + auto &allSuppportedProducts = argHelper->productConfigHelper->getDeviceAotInfo(); auto hasDeviceAcronym = std::any_of(allSuppportedProducts.begin(), allSuppportedProducts.end(), ProductConfigHelper::findDeviceAcronymForRelease(target)); for (const auto &device : allSuppportedProducts) { if (device.release == target) { @@ -98,8 +88,7 @@ void getProductsAcronymsForTarget(std::vector template <> void getProductsAcronymsForTarget(std::vector &out, AOT::FAMILY target, OclocArgHelper *argHelper) { - auto &prodHelper = *argHelper->productConfigHelper; - auto &allSuppportedProducts = prodHelper.getDeviceAotInfo(); + auto &allSuppportedProducts = argHelper->productConfigHelper->getDeviceAotInfo(); std::vector releases{}; for (const auto &device : allSuppportedProducts) { if (device.family == target && std::find(releases.begin(), releases.end(), device.release) == releases.end()) { @@ -126,21 +115,9 @@ std::vector getProductsForTargetRange(T targetFrom, T targetTo, std::vector getProductsForRange(unsigned int productFrom, unsigned int productTo, OclocArgHelper *argHelper) { - auto &prodHelper = *argHelper->productConfigHelper; - auto &formerProdHelper = *argHelper->formerProductConfigHelper; std::vector ret = {}; + auto &allSuppportedProducts = argHelper->productConfigHelper->getDeviceAotInfo(); - auto &formerData = formerProdHelper.getData(); - uint32_t ipVersionAdded = 0; - for (const auto &[acronym, ipVersion] : formerData.acronyms) { - auto validAcronym = ipVersion >= productFrom; - validAcronym &= ipVersion <= productTo; - if (validAcronym && ipVersion != ipVersionAdded) { - ret.push_back(acronym.c_str()); - ipVersionAdded = ipVersion; - } - } - auto &allSuppportedProducts = prodHelper.getDeviceAotInfo(); for (const auto &device : allSuppportedProducts) { auto validAcronym = device.aotConfig.value >= productFrom; validAcronym &= device.aotConfig.value <= productTo; @@ -156,347 +133,122 @@ std::vector getProductsForRange(unsigned int productFrom, unsign return ret; } -std::vector getProductsForFamilyClosedRange(const std::string &fromStr, const std::string &toStr, OclocArgHelper *argHelper) { - auto &prodHelper = *argHelper->productConfigHelper; - auto &formerProdHelper = *argHelper->formerProductConfigHelper; +std::vector getProductForClosedRange(ConstStringRef rangeFrom, ConstStringRef rangeTo, OclocArgHelper *argHelper) { + std::vector requestedProducts = {}; + auto rangeToStr = rangeTo.str(); + auto rangeFromStr = rangeFrom.str(); - auto getFamilyConfigWithFallback = [&](const std::string &familyStr, FormerProductConfigHelper::Position pos) { - auto family = prodHelper.getFamilyFromDeviceName(familyStr); - AOT::PRODUCT_CONFIG config = AOT::UNKNOWN_ISA; - if (family != AOT::UNKNOWN_FAMILY) { - config = prodHelper.getLastProductConfigFromFamilyName(family); - } - if (config == AOT::UNKNOWN_ISA) { - config = formerProdHelper.getProductConfigFromFamilyName(familyStr, pos); - } - return config; - }; + ProductConfigHelper::adjustDeviceName(rangeToStr); + ProductConfigHelper::adjustDeviceName(rangeFromStr); + argHelper->productConfigHelper->adjustClosedRangeDeviceLegacyAcronyms(rangeFromStr, rangeToStr); - auto familyFrom = prodHelper.getFamilyFromDeviceName(fromStr); - auto familyTo = prodHelper.getFamilyFromDeviceName(toStr); + auto familyFrom = argHelper->productConfigHelper->getFamilyFromDeviceName(rangeFromStr); + auto familyTo = argHelper->productConfigHelper->getFamilyFromDeviceName(rangeToStr); if (familyFrom != AOT::UNKNOWN_FAMILY && familyTo != AOT::UNKNOWN_FAMILY) { return getProductsForTargetRange(familyFrom, familyTo, argHelper, AOT::FAMILY_MAX); } - AOT::PRODUCT_CONFIG prodConfigFrom = getFamilyConfigWithFallback(fromStr, Position::firstItem); - AOT::PRODUCT_CONFIG prodConfigTo = getFamilyConfigWithFallback(toStr, Position::lastItem); - if (prodConfigFrom != AOT::UNKNOWN_ISA && prodConfigTo != AOT::UNKNOWN_ISA) { - return getProductsForRange(prodConfigFrom, prodConfigTo, argHelper); - } - return {}; -} -std::vector getProductsForReleaseClosedRange(const std::string &fromStr, const std::string &toStr, OclocArgHelper *argHelper) { - auto &prodHelper = *argHelper->productConfigHelper; - auto &formerProdHelper = *argHelper->formerProductConfigHelper; - - auto getReleaseConfigWithFallback = [&](const std::string &releaseStr, FormerProductConfigHelper::Position pos) { - auto release = prodHelper.getReleaseFromDeviceName(releaseStr); - auto config = prodHelper.getLastProductConfigFromReleaseName(release); - if (config == AOT::UNKNOWN_ISA) { - config = formerProdHelper.getProductConfigFromReleaseName(releaseStr, pos); - } - return config; - }; - - auto releaseFrom = prodHelper.getReleaseFromDeviceName(fromStr); - auto releaseTo = prodHelper.getReleaseFromDeviceName(toStr); + auto releaseFrom = argHelper->productConfigHelper->getReleaseFromDeviceName(rangeFromStr); + auto releaseTo = argHelper->productConfigHelper->getReleaseFromDeviceName(rangeToStr); if (releaseFrom != AOT::UNKNOWN_RELEASE && releaseTo != AOT::UNKNOWN_RELEASE) { return getProductsForTargetRange(releaseFrom, releaseTo, argHelper, AOT::RELEASE_MAX); } - AOT::PRODUCT_CONFIG prodConfigFrom = getReleaseConfigWithFallback(fromStr, Position::firstItem); - AOT::PRODUCT_CONFIG prodConfigTo = getReleaseConfigWithFallback(toStr, Position::lastItem); - if (prodConfigFrom != AOT::UNKNOWN_ISA && prodConfigTo != AOT::UNKNOWN_ISA) { - return getProductsForRange(prodConfigFrom, prodConfigTo, argHelper); - } - return {}; -} -std::vector getProductsForProductClosedRange(const std::string &fromStr, const std::string &toStr, OclocArgHelper *argHelper) { - auto &prodHelper = *argHelper->productConfigHelper; - auto &formerProdHelper = *argHelper->formerProductConfigHelper; - - auto getProductConfigWithFallback = [&](const std::string &deviceName) { - auto config = prodHelper.getProductConfigFromDeviceName(deviceName); - if (config == AOT::UNKNOWN_ISA) { - config = formerProdHelper.getProductConfigFromDeviceName(deviceName); - } - return config; - }; - - AOT::PRODUCT_CONFIG prodConfigFrom = getProductConfigWithFallback(fromStr); - AOT::PRODUCT_CONFIG prodConfigTo = getProductConfigWithFallback(toStr); + auto prodConfigFrom = argHelper->productConfigHelper->getProductConfigFromDeviceName(rangeFromStr); + auto prodConfigTo = argHelper->productConfigHelper->getProductConfigFromDeviceName(rangeToStr); if (prodConfigFrom != AOT::UNKNOWN_ISA && prodConfigTo != AOT::UNKNOWN_ISA) { if (prodConfigFrom > prodConfigTo) { std::swap(prodConfigFrom, prodConfigTo); } return getProductsForRange(prodConfigFrom, prodConfigTo, argHelper); } - return {}; -} - -std::vector getProductForClosedRange(ConstStringRef rangeFrom, ConstStringRef rangeTo, OclocArgHelper *argHelper) { - auto rangeFromStr = rangeFrom.str(); - auto rangeToStr = rangeTo.str(); - ProductConfigHelper::adjustDeviceName(rangeFromStr); - ProductConfigHelper::adjustDeviceName(rangeToStr); - - auto familyProducts = getProductsForFamilyClosedRange(rangeFromStr, rangeToStr, argHelper); - if (!familyProducts.empty()) { - return familyProducts; - } - auto releaseProducts = getProductsForReleaseClosedRange(rangeFromStr, rangeToStr, argHelper); - if (!releaseProducts.empty()) { - return releaseProducts; - } - auto productProducts = getProductsForProductClosedRange(rangeFromStr, rangeToStr, argHelper); - if (!productProducts.empty()) { - return productProducts; - } auto target = rangeFromStr + ":" + rangeToStr; argHelper->printf("Failed to parse target : %s.\n", target.c_str()); return {}; } -auto mergeProducts = [](std::vector &dst, std::vector &&src) { - for (auto &elem : src) { - if (std::find(dst.begin(), dst.end(), elem) == dst.end()) { - dst.push_back(std::move(elem)); - } - } -}; +std::vector getProductForOpenRange(ConstStringRef openRange, OclocArgHelper *argHelper, bool rangeTo) { + std::vector requestedProducts = {}; + auto openRangeStr = openRange.str(); + ProductConfigHelper::adjustDeviceName(openRangeStr); -std::vector getProductsForFamilyOpenRange(const std::string &openRangeStr, OclocArgHelper *argHelper, bool rangeTo) { - auto &prodHelper = *argHelper->productConfigHelper; - auto &formerProdHelper = *argHelper->formerProductConfigHelper; - - auto getFamilyConfigWithFallback = [&](const std::string &familyStr, FormerProductConfigHelper::Position pos) { - auto family = prodHelper.getFamilyFromDeviceName(familyStr); - AOT::PRODUCT_CONFIG config = AOT::UNKNOWN_ISA; - if (family != AOT::UNKNOWN_FAMILY) { - config = prodHelper.getLastProductConfigFromFamilyName(family); - } - if (config == AOT::UNKNOWN_ISA) { - config = formerProdHelper.getProductConfigFromFamilyName(familyStr, pos); - } - return config; - }; - - std::vector requestedProducts; - auto family = prodHelper.getFamilyFromDeviceName(openRangeStr); + auto family = argHelper->productConfigHelper->getFamilyFromDeviceName(openRangeStr); if (family != AOT::UNKNOWN_FAMILY) { if (rangeTo) { - auto prodConfigFrom = getFamilyConfigWithFallback(formerProdHelper.getFamilyName(Position::firstItem), Position::firstItem); - auto prodConfigTo = getFamilyConfigWithFallback(formerProdHelper.getFamilyName(Position::lastItem), Position::lastItem); - if (prodConfigFrom != AOT::UNKNOWN_ISA && prodConfigTo != AOT::UNKNOWN_ISA) { - mergeProducts(requestedProducts, getProductsForRange(prodConfigFrom, prodConfigTo, argHelper)); - } - unsigned int familyFrom = AOT::UNKNOWN_FAMILY + 1; - mergeProducts(requestedProducts, getProductsForTargetRange(static_cast(familyFrom), family, argHelper, AOT::FAMILY_MAX)); - return requestedProducts; + unsigned int familyFrom = AOT::UNKNOWN_FAMILY; + ++familyFrom; + return getProductsForTargetRange(static_cast(familyFrom), family, argHelper, AOT::FAMILY_MAX); } else { unsigned int familyTo = AOT::FAMILY_MAX; return getProductsForTargetRange(family, static_cast(familyTo), argHelper, AOT::FAMILY_MAX); } - } else if (formerProdHelper.isFamilyName(openRangeStr)) { - if (rangeTo) { - auto prodConfigFrom = getFamilyConfigWithFallback(formerProdHelper.getFamilyName(Position::firstItem), Position::firstItem); - auto prodConfigTo = getFamilyConfigWithFallback(openRangeStr, Position::lastItem); - if (prodConfigFrom != AOT::UNKNOWN_ISA && prodConfigTo != AOT::UNKNOWN_ISA) { - return getProductsForRange(prodConfigFrom, prodConfigTo, argHelper); - } - } else { - auto prodConfigFrom = getFamilyConfigWithFallback(openRangeStr, Position::firstItem); - auto prodConfigTo = getFamilyConfigWithFallback(formerProdHelper.getFamilyName(Position::lastItem), Position::lastItem); - if (prodConfigFrom != AOT::UNKNOWN_ISA && prodConfigTo != AOT::UNKNOWN_ISA) { - mergeProducts(requestedProducts, getProductsForRange(prodConfigFrom, prodConfigTo, argHelper)); - } - unsigned int familyFrom = AOT::UNKNOWN_FAMILY + 1; - unsigned int familyTo = AOT::FAMILY_MAX; - mergeProducts(requestedProducts, getProductsForTargetRange(static_cast(familyFrom), static_cast(familyTo), argHelper, AOT::FAMILY_MAX)); - return requestedProducts; - } } - return {}; -} -std::vector getProductsForReleaseOpenRange(const std::string &openRangeStr, OclocArgHelper *argHelper, bool rangeTo) { - auto &prodHelper = *argHelper->productConfigHelper; - auto &formerProdHelper = *argHelper->formerProductConfigHelper; - std::vector requestedProducts; - - auto getReleaseConfigWithFallback = [&](const std::string &releaseStr, FormerProductConfigHelper::Position pos) { - auto release = prodHelper.getReleaseFromDeviceName(releaseStr); - auto config = prodHelper.getLastProductConfigFromReleaseName(release); - if (config == AOT::UNKNOWN_ISA) { - config = formerProdHelper.getProductConfigFromReleaseName(releaseStr, pos); - } - return config; - }; - - auto release = prodHelper.getReleaseFromDeviceName(openRangeStr); + auto release = argHelper->productConfigHelper->getReleaseFromDeviceName(openRangeStr); if (release != AOT::UNKNOWN_RELEASE) { if (rangeTo) { - auto prodConfigFrom = getReleaseConfigWithFallback(formerProdHelper.getReleaseName(Position::firstItem), Position::firstItem); - auto prodConfigTo = getReleaseConfigWithFallback(formerProdHelper.getReleaseName(Position::lastItem), Position::lastItem); - if (prodConfigFrom != AOT::UNKNOWN_ISA && prodConfigTo != AOT::UNKNOWN_ISA) { - mergeProducts(requestedProducts, getProductsForRange(prodConfigFrom, prodConfigTo, argHelper)); - } - unsigned int releaseFrom = AOT::UNKNOWN_RELEASE + 1; - mergeProducts(requestedProducts, getProductsForTargetRange(static_cast(releaseFrom), release, argHelper, AOT::RELEASE_MAX)); - return requestedProducts; + unsigned int releaseFrom = AOT::UNKNOWN_FAMILY; + ++releaseFrom; + return getProductsForTargetRange(static_cast(releaseFrom), release, argHelper, AOT::RELEASE_MAX); } else { unsigned int releaseTo = AOT::RELEASE_MAX; return getProductsForTargetRange(release, static_cast(releaseTo), argHelper, AOT::RELEASE_MAX); } - } else if (formerProdHelper.isReleaseName(openRangeStr)) { - if (rangeTo) { - auto prodConfigFrom = getReleaseConfigWithFallback(formerProdHelper.getReleaseName(Position::firstItem), Position::firstItem); - auto prodConfigTo = getReleaseConfigWithFallback(openRangeStr, Position::lastItem); - if (prodConfigFrom != AOT::UNKNOWN_ISA && prodConfigTo != AOT::UNKNOWN_ISA) { - return getProductsForRange(prodConfigFrom, prodConfigTo, argHelper); - } - } else { - auto prodConfigFrom = getReleaseConfigWithFallback(openRangeStr, Position::firstItem); - auto prodConfigTo = getReleaseConfigWithFallback(formerProdHelper.getReleaseName(Position::lastItem), Position::lastItem); - if (prodConfigFrom != AOT::UNKNOWN_ISA && prodConfigTo != AOT::UNKNOWN_ISA) { - mergeProducts(requestedProducts, getProductsForRange(prodConfigFrom, prodConfigTo, argHelper)); - } - unsigned int releaseFrom = AOT::UNKNOWN_RELEASE + 1; - unsigned int releaseTo = AOT::RELEASE_MAX; - mergeProducts(requestedProducts, getProductsForTargetRange(static_cast(releaseFrom), static_cast(releaseTo), argHelper, AOT::RELEASE_MAX)); - return requestedProducts; - } } - return {}; -} -std::vector getProductsForProductOpenRange(const std::string &openRangeStr, OclocArgHelper *argHelper, bool rangeTo) { - auto &prodHelper = *argHelper->productConfigHelper; - auto &formerProdHelper = *argHelper->formerProductConfigHelper; - - auto getProductConfigWithFallback = [&](const std::string &deviceName) { - auto config = prodHelper.getProductConfigFromDeviceName(deviceName); - if (config == AOT::UNKNOWN_ISA) { - config = formerProdHelper.getProductConfigFromDeviceName(deviceName); - } - return config; - }; - - auto product = getProductConfigWithFallback(openRangeStr); + auto product = argHelper->productConfigHelper->getProductConfigFromDeviceName(openRangeStr); if (product != AOT::UNKNOWN_ISA) { if (rangeTo) { - unsigned int productFrom = formerProdHelper.getFirstProductConfig(); - if (productFrom == AOT::UNKNOWN_ISA) { - ++productFrom; - } + unsigned int productFrom = AOT::UNKNOWN_ISA; + ++productFrom; return getProductsForRange(productFrom, static_cast(product), argHelper); } else { - unsigned int productTo = AOT::getConfixMaxPlatform() - 1; + unsigned int productTo = AOT::getConfixMaxPlatform(); + --productTo; return getProductsForRange(product, static_cast(productTo), argHelper); } } - return {}; -} - -std::vector getProductForOpenRange(ConstStringRef openRange, OclocArgHelper *argHelper, bool rangeTo) { - auto openRangeStr = openRange.str(); - ProductConfigHelper::adjustDeviceName(openRangeStr); - - auto familyProducts = getProductsForFamilyOpenRange(openRangeStr, argHelper, rangeTo); - if (!familyProducts.empty()) { - return familyProducts; - } - auto releaseProducts = getProductsForReleaseOpenRange(openRangeStr, argHelper, rangeTo); - if (!releaseProducts.empty()) { - return releaseProducts; - } - auto productProducts = getProductsForProductOpenRange(openRangeStr, argHelper, rangeTo); - if (!productProducts.empty()) { - return productProducts; - } - argHelper->printf("Failed to parse target : %s.\n", openRangeStr.c_str()); return {}; } std::vector getProductForSpecificTarget(const CompilerOptions::TokenizedString &targets, OclocArgHelper *argHelper) { - auto &prodHelper = *argHelper->productConfigHelper; - auto &formerProdHelper = *argHelper->formerProductConfigHelper; std::vector requestedConfigs; - - auto getProductsAcronymsForFamilyWithFallback = [&](const std::string &targetStr) -> bool { - auto family = prodHelper.getFamilyFromDeviceName(targetStr); - if (family != AOT::UNKNOWN_FAMILY) { - getProductsAcronymsForTarget(requestedConfigs, family, argHelper); - return true; - } - if (formerProdHelper.isSupportedTarget(targetStr)) { - mergeProducts(requestedConfigs, formerProdHelper.getProductAcronymsFromFamilyGroup(targetStr)); - return true; - } - return false; - }; - - auto getProductsAcronymsForReleaseWithFallback = [&](const std::string &targetStr) -> bool { - auto release = prodHelper.getReleaseFromDeviceName(targetStr); - if (release != AOT::UNKNOWN_RELEASE) { - getProductsAcronymsForTarget(requestedConfigs, release, argHelper); - return true; - } - if (formerProdHelper.isSupportedTarget(targetStr)) { - mergeProducts(requestedConfigs, formerProdHelper.getProductAcronymsFromReleaseGroup(targetStr)); - return true; - } - return false; - }; - - auto getProductConfigWithFallback = [&](const ConstStringRef &target) -> bool { - auto product = prodHelper.getProductConfigFromAcronym(target.str()); - if (product == AOT::UNKNOWN_ISA) { - product = formerProdHelper.getProductConfigFromDeviceName(target.str()); - } - if (product != AOT::UNKNOWN_ISA) { - mergeProducts(requestedConfigs, std::vector{target}); - return true; - } - return false; - }; - for (const auto &target : targets) { auto targetStr = target.str(); ProductConfigHelper::adjustDeviceName(targetStr); - if (getProductsAcronymsForFamilyWithFallback(targetStr)) { + auto family = argHelper->productConfigHelper->getFamilyFromDeviceName(targetStr); + if (family != AOT::UNKNOWN_FAMILY) { + getProductsAcronymsForTarget(requestedConfigs, family, argHelper); continue; } - if (getProductsAcronymsForReleaseWithFallback(targetStr)) { + auto release = argHelper->productConfigHelper->getReleaseFromDeviceName(targetStr); + if (release != AOT::UNKNOWN_RELEASE) { + getProductsAcronymsForTarget(requestedConfigs, release, argHelper); continue; } - if (getProductConfigWithFallback(target)) { - continue; - } - if (getHwInfoForDeprecatedAcronym(targetStr) != nullptr) { + auto product = argHelper->productConfigHelper->getProductConfigFromDeviceName(targetStr); + if (product != AOT::UNKNOWN_ISA) { requestedConfigs.push_back(target); continue; } - - argHelper->printf("Failed to parse target : %s - invalid device:\n", targetStr.c_str()); + auto legacyAcronymHwInfo = getHwInfoForDeprecatedAcronym(targetStr); + if (nullptr != legacyAcronymHwInfo) { + requestedConfigs.push_back(target); + continue; + } + argHelper->printf("Failed to parse target : %s - invalid device:\n", target.str().c_str()); return {}; } - return requestedConfigs; } std::vector getTargetProductsForFatbinary(ConstStringRef deviceArg, OclocArgHelper *argHelper) { - auto &prodHelper = *argHelper->productConfigHelper; - auto &formerProdHelper = *argHelper->formerProductConfigHelper; std::vector retVal; if (deviceArg == "*") { - retVal = prodHelper.getRepresentativeProductAcronyms(); - auto formerAcronyms = formerProdHelper.getRepresentativeProductAcronyms(); - retVal.insert(retVal.begin(), formerAcronyms.begin(), formerAcronyms.end()); - return retVal; + return argHelper->productConfigHelper->getRepresentativeProductAcronyms(); } else { auto sets = CompilerOptions::tokenize(deviceArg, ','); if (sets[0].contains(":")) { @@ -531,7 +283,6 @@ int getDeviceArgValueIdx(const std::vector &args) { int buildFatBinaryForTarget(int retVal, const std::vector &argsCopy, std::string pointerSize, Ar::ArEncoder &fatbinary, OfflineCompiler *pCompiler, OclocArgHelper *argHelper, const std::string &product) { - auto &prodHelper = *argHelper->productConfigHelper; if (retVal == 0) { retVal = buildWithSafetyGuard(pCompiler); @@ -560,11 +311,10 @@ int buildFatBinaryForTarget(int retVal, const std::vector &argsCopy if (product.find(".") != std::string::npos) { entryName = product; } else { - auto productConfig = prodHelper.getProductConfigFromDeviceName(product); - auto genericIdAcronymIt = std::find_if(AOT::genericIdAcronyms.begin(), AOT::genericIdAcronyms.end(), - [product](const std::pair &genericIdAcronym) { - return product == genericIdAcronym.first; - }); + auto productConfig = argHelper->productConfigHelper->getProductConfigFromDeviceName(product); + auto genericIdAcronymIt = std::find_if(AOT::genericIdAcronyms.begin(), AOT::genericIdAcronyms.end(), [product](const std::pair &genericIdAcronym) { + return product == genericIdAcronym.first; + }); if (AOT::UNKNOWN_ISA != productConfig && genericIdAcronymIt == AOT::genericIdAcronyms.end()) { entryName = ProductConfigHelper::parseMajorMinorRevisionValue(productConfig); } else { @@ -576,74 +326,6 @@ int buildFatBinaryForTarget(int retVal, const std::vector &argsCopy return retVal; } -int buildFatBinaryForFormerTarget(int retVal, const std::vector &argsCopy, std::string pointerSize, Ar::ArEncoder &fatbinary, - OclocArgHelper *argHelper, const std::string &product) { - auto &formerProdHelper = *argHelper->formerProductConfigHelper; - uint32_t numOutputs = 0u; - unsigned char **dataOutputs = nullptr; - uint64_t *lenOutputs = nullptr; - char **nameOutputs = nullptr; - - if (retVal == 0) { - std::vector argvPtrs; - argvPtrs.reserve(argsCopy.size()); - for (const auto &arg : argsCopy) { - argvPtrs.push_back(arg.c_str()); - } - auto retValFormerOcloc = Ocloc::Commands::invokeFormerOcloc(Ocloc::getOclocFormerLibName(), - static_cast(argvPtrs.size()), - argvPtrs.data(), - 0, nullptr, nullptr, nullptr, - 0, nullptr, nullptr, nullptr, - &numOutputs, &dataOutputs, - &lenOutputs, &nameOutputs); - if (retValFormerOcloc) { - retVal = retValFormerOcloc.value(); - argHelper->dontSetupOutputs(); - // Check if the actual return code indicates success - if (retVal == 0) { - argHelper->printf("Build succeeded for : %s.\n", product.c_str()); - } else { - argHelper->printf("Build failed for : %s with error code: %d\n", product.c_str(), retVal); - argHelper->printf("Command was:"); - for (const auto &arg : argsCopy) { - argHelper->printf(" %s", arg.c_str()); - } - argHelper->printf("\n"); - return retVal; - } - } else { - // Former ocloc couldn't be invoked at all - argHelper->printf("Build failed for : %s - could not invoke former ocloc\n", product.c_str()); - return retVal; - } - - for (size_t i = 0; i < numOutputs; ++i) { - std::string name = nameOutputs[i]; - if (name.find(".bin") != std::string::npos) { - const ArrayRef fileData(dataOutputs[i], static_cast(lenOutputs[i])); - - std::string entryName(""); - if (product.find(".") != std::string::npos) { - entryName = product; - } else { - auto productConfig = formerProdHelper.getProductConfigFromAcronym(product); - entryName = ProductConfigHelper::parseMajorMinorRevisionValue(productConfig); - } - fatbinary.appendFileEntry(pointerSize + "." + entryName, fileData); - } - } - } - - // Use formerOclocFree since memory was allocated by former ocloc - auto freeResult = Ocloc::Commands::formerOclocFree(Ocloc::getOclocFormerLibName(), &numOutputs, &dataOutputs, &lenOutputs, &nameOutputs); - if (!freeResult) { - // Fallback to regular oclocFreeOutput if formerOclocFree fails - oclocFreeOutput(&numOutputs, &dataOutputs, &lenOutputs, &nameOutputs); - } - return retVal; -} - int buildFatBinary(const std::vector &args, OclocArgHelper *argHelper) { std::string pointerSizeInBits = (sizeof(void *) == 4) ? "32" : "64"; size_t deviceArgIndex = -1; @@ -711,34 +393,23 @@ int buildFatBinary(const std::vector &args, OclocArgHelper *argHelp argHelper->printf("Warning! -device_options set for non-compiled device: %s\n", deviceAcronym.c_str()); } } - std::string optionsForIr; for (const auto &product : targetProducts) { - int retVal = OCLOC_SUCCESS; + int retVal = 0; argsCopy[deviceArgIndex] = product.str(); - auto &formerProdHelper = *argHelper->formerProductConfigHelper; - auto formerProduct = formerProdHelper.getProductConfigFromDeviceName(product.str().c_str()); - auto formerProductFallback = formerProdHelper.isSupportedProductConfig(formerProduct); - if (formerProductFallback) { - retVal = buildFatBinaryForFormerTarget(retVal, argsCopy, pointerSizeInBits, fatbinary, argHelper, product.str()); - if (retVal) { - return retVal; - } - } else { - std::unique_ptr pCompiler{OfflineCompiler::create(argsCopy.size(), argsCopy, false, retVal, argHelper)}; - if (OCLOC_SUCCESS != retVal) { - argHelper->printf("Error! Couldn't create OfflineCompiler. Exiting.\n"); - return retVal; - } + std::unique_ptr pCompiler{OfflineCompiler::create(argsCopy.size(), argsCopy, false, retVal, argHelper)}; + if (OCLOC_SUCCESS != retVal) { + argHelper->printf("Error! Couldn't create OfflineCompiler. Exiting.\n"); + return retVal; + } - retVal = buildFatBinaryForTarget(retVal, argsCopy, pointerSizeInBits, fatbinary, pCompiler.get(), argHelper, product.str()); - if (retVal) { - return retVal; - } - if (optionsForIr.empty()) { - optionsForIr = pCompiler->getOptions(); - } + retVal = buildFatBinaryForTarget(retVal, argsCopy, pointerSizeInBits, fatbinary, pCompiler.get(), argHelper, product.str()); + if (retVal) { + return retVal; + } + if (optionsForIr.empty()) { + optionsForIr = pCompiler->getOptions(); } } diff --git a/shared/offline_compiler/source/ocloc_interface.cpp b/shared/offline_compiler/source/ocloc_interface.cpp index c1de2e8dd3..51256269a0 100644 --- a/shared/offline_compiler/source/ocloc_interface.cpp +++ b/shared/offline_compiler/source/ocloc_interface.cpp @@ -19,11 +19,8 @@ #include "shared/offline_compiler/source/offline_linker.h" #include "shared/offline_compiler/source/utilities/safety_caller.h" #include "shared/source/device_binary_format/elf/elf_decoder.h" -#include "shared/source/helpers/product_config_helper_former.h" #include "shared/source/os_interface/os_library.h" -#include "neo_aot_platforms.h" - #include namespace Ocloc { @@ -130,23 +127,14 @@ const std::string &getOclocFormerLibName() { return oclocFormerLibName; } namespace Commands { -bool isDeviceArgProvided(const std::vector &args) { - for (size_t argIndex = 0; argIndex + 1 < args.size(); ++argIndex) { - if (ConstStringRef("-device") == args[argIndex]) { - return true; - } - } - return false; -} - int compile(OclocArgHelper *argHelper, const std::vector &args) { std::vector argsCopy(args); - int deviceArgIndex = NEO::getDeviceArgValueIdx(args); if (NEO::requestedFatBinary(args, argHelper)) { bool onlySpirV = NEO::isSpvOnly(args); if (onlySpirV) { + int deviceArgIndex = NEO::getDeviceArgValueIdx(args); UNRECOVERABLE_IF(deviceArgIndex < 0); std::vector targetProducts = NEO::getTargetProductsForFatbinary(ConstStringRef(args[deviceArgIndex]), argHelper); ConstStringRef firstDevice = targetProducts.front(); @@ -157,59 +145,31 @@ int compile(OclocArgHelper *argHelper, const std::vector &args) { } int retVal = OCLOC_SUCCESS; - auto formerProductFallback = false; + std::unique_ptr pCompiler{OfflineCompiler::create(argsCopy.size(), argsCopy, true, retVal, argHelper)}; - if (isDeviceArgProvided(argsCopy)) { - UNRECOVERABLE_IF(deviceArgIndex < 0); - auto &formerProdHelper = *argHelper->formerProductConfigHelper; - auto product = formerProdHelper.getProductConfigFromDeviceName(argsCopy[deviceArgIndex]); - formerProductFallback = formerProdHelper.isSupportedProductConfig(product); - } - - if (formerProductFallback) { - std::vector argvPtrs; - argvPtrs.reserve(argsCopy.size()); - for (const auto &arg : argsCopy) { - argvPtrs.push_back(arg.c_str()); + if (retVal == OCLOC_SUCCESS) { + if (pCompiler->showHelpOnly()) { + return retVal; } - auto retValFormerOcloc = Ocloc::Commands::invokeFormerOcloc(Ocloc::getOclocFormerLibName(), - static_cast(argvPtrs.size()), - argvPtrs.data(), - 0, nullptr, nullptr, nullptr, - 0, nullptr, nullptr, nullptr, - nullptr, nullptr, nullptr, nullptr); - if (retValFormerOcloc) { - retVal = retValFormerOcloc.value(); - argHelper->dontSetupOutputs(); + retVal = buildWithSafetyGuard(pCompiler.get()); + + std::string buildLog = pCompiler->getBuildLog(); + if (buildLog.empty() == false) { + argHelper->printf("%s\n", buildLog.c_str()); + } + + if (retVal == OCLOC_SUCCESS) { + if (!pCompiler->isQuiet()) { + argHelper->printf("Build succeeded.\n"); + } } else { argHelper->printf("Build failed with error code: %d\n", retVal); } - } else { - std::unique_ptr pCompiler{OfflineCompiler::create(argsCopy.size(), argsCopy, true, retVal, argHelper)}; - if (retVal == OCLOC_SUCCESS) { - if (pCompiler->showHelpOnly()) { - return retVal; - } - retVal = buildWithSafetyGuard(pCompiler.get()); - - std::string buildLog = pCompiler->getBuildLog(); - if (buildLog.empty() == false) { - argHelper->printf("%s\n", buildLog.c_str()); - } - - if (retVal == OCLOC_SUCCESS) { - if (!pCompiler->isQuiet()) { - argHelper->printf("Build succeeded.\n"); - } - } else { - argHelper->printf("Build failed with error code: %d\n", retVal); - } - } - if (retVal != OCLOC_SUCCESS) { - printOclocOptionsReadFromFile(*argHelper, pCompiler.get()); - } } + if (retVal != OCLOC_SUCCESS) { + printOclocOptionsReadFromFile(*argHelper, pCompiler.get()); + } return retVal; }; @@ -324,26 +284,5 @@ std::optional invokeFormerOcloc(const std::string &formerOclocName, unsigne return oclocInvokeFunc(numArgs, argv, numSources, dataSources, lenSources, nameSources, numInputHeaders, dataInputHeaders, lenInputHeaders, nameInputHeaders, numOutputs, dataOutputs, lenOutputs, nameOutputs); } -std::optional formerOclocFree(const std::string &formerOclocName, uint32_t *numOutputs, uint8_t ***dataOutputs, uint64_t **lenOutputs, char ***nameOutputs) { - if (formerOclocName.empty()) { - return {}; - } - - std::unique_ptr oclocLib(OsLibrary::loadFunc(formerOclocName)); - - if (!oclocLib) { - return {}; - } - - typedef int (*pOclocFreeOutput)(uint32_t * numOutputs, uint8_t * **dataOutputs, uint64_t * *lenOutputs, char ***nameOutputs); - auto oclocFreeFunc = reinterpret_cast(oclocLib->getProcAddress("oclocFreeOutput")); - - if (!oclocFreeFunc) { - return {}; - } - - return oclocFreeFunc(numOutputs, dataOutputs, lenOutputs, nameOutputs); -} - } // namespace Commands } // namespace Ocloc diff --git a/shared/offline_compiler/source/ocloc_interface.h b/shared/offline_compiler/source/ocloc_interface.h index f295aa53e3..36d3fad167 100644 --- a/shared/offline_compiler/source/ocloc_interface.h +++ b/shared/offline_compiler/source/ocloc_interface.h @@ -47,6 +47,5 @@ std::optional invokeFormerOcloc(const std::string &formerOclocName, unsigne const uint32_t numSources, const uint8_t **dataSources, const uint64_t *lenSources, const char **nameSources, const uint32_t numInputHeaders, const uint8_t **dataInputHeaders, const uint64_t *lenInputHeaders, const char **nameInputHeaders, uint32_t *numOutputs, uint8_t ***dataOutputs, uint64_t **lenOutputs, char ***nameOutputs); -std::optional formerOclocFree(const std::string &formerOclocName, uint32_t *numOutputs, uint8_t ***dataOutputs, uint64_t **lenOutputs, char ***nameOutputs); } // namespace Commands } // namespace Ocloc diff --git a/shared/offline_compiler/source/ocloc_supported_devices_helper.cpp b/shared/offline_compiler/source/ocloc_supported_devices_helper.cpp index 0555360c98..eea5c36551 100644 --- a/shared/offline_compiler/source/ocloc_supported_devices_helper.cpp +++ b/shared/offline_compiler/source/ocloc_supported_devices_helper.cpp @@ -63,18 +63,6 @@ SupportedDevicesHelper::SupportedDevicesData SupportedDevicesHelper::collectSupp return data; } -SupportedDevicesHelper::SupportedDevicesData SupportedDevicesHelper::collectFormerSupportedDevicesData() const { - std::string formerSupportedDevices = getDataFromFormerOcloc(); - SupportedDevicesData formerData; - - if (formerSupportedDevices.empty()) { - return formerData; - } - - auto formerDataDeserialized = deserialize(formerSupportedDevices); - return formerDataDeserialized[getFormerOclocName()]; -} - std::string SupportedDevicesHelper::serialize(std::string_view oclocName, const SupportedDevicesData &data) const { std::ostringstream oss; oss << oclocName << ":\n"; diff --git a/shared/offline_compiler/source/ocloc_supported_devices_helper.h b/shared/offline_compiler/source/ocloc_supported_devices_helper.h index e688793272..07fd2687f8 100644 --- a/shared/offline_compiler/source/ocloc_supported_devices_helper.h +++ b/shared/offline_compiler/source/ocloc_supported_devices_helper.h @@ -57,7 +57,6 @@ class SupportedDevicesHelper { std::string getCurrentOclocOutputFilename() const; SupportedDevicesData collectSupportedDevicesData(const std::vector &enabledDevices) const; - SupportedDevicesData collectFormerSupportedDevicesData() const; std::string serialize(std::string_view oclocName, const SupportedDevicesData &data) const; std::map deserialize(std::string_view yamlString) const; diff --git a/shared/source/helpers/CMakeLists.txt b/shared/source/helpers/CMakeLists.txt index f1b78f7003..163d02dd92 100644 --- a/shared/source/helpers/CMakeLists.txt +++ b/shared/source/helpers/CMakeLists.txt @@ -132,8 +132,6 @@ set(NEO_CORE_HELPERS ${CMAKE_CURRENT_SOURCE_DIR}/${BRANCH_DIR_SUFFIX}product_config_helper_extra.cpp ${CMAKE_CURRENT_SOURCE_DIR}/product_config_helper.cpp ${CMAKE_CURRENT_SOURCE_DIR}/product_config_helper.h - ${CMAKE_CURRENT_SOURCE_DIR}/product_config_helper_former.cpp - ${CMAKE_CURRENT_SOURCE_DIR}/product_config_helper_former.h ${CMAKE_CURRENT_SOURCE_DIR}/ptr_math.h ${CMAKE_CURRENT_SOURCE_DIR}/ray_tracing_helper.h ${CMAKE_CURRENT_SOURCE_DIR}/register_offsets.h diff --git a/shared/source/helpers/compiler_product_helper.h b/shared/source/helpers/compiler_product_helper.h index 7030f85316..46282a1cf5 100644 --- a/shared/source/helpers/compiler_product_helper.h +++ b/shared/source/helpers/compiler_product_helper.h @@ -9,7 +9,6 @@ #include "shared/source/helpers/hw_mapper.h" #include "shared/source/helpers/product_config_helper.h" -#include "shared/source/helpers/product_config_helper_former.h" #include "shared/source/utilities/stackvec.h" #include "neo_igfxfmid.h" diff --git a/shared/source/helpers/product_config_helper.cpp b/shared/source/helpers/product_config_helper.cpp index 480e445c27..0a0e1bc2a7 100644 --- a/shared/source/helpers/product_config_helper.cpp +++ b/shared/source/helpers/product_config_helper.cpp @@ -79,26 +79,6 @@ void ProductConfigHelper::adjustClosedRangeDeviceLegacyAcronyms(std::string &ran } } -AOT::PRODUCT_CONFIG ProductConfigHelper::getLastProductConfigFromFamilyName(AOT::FAMILY family) { - uint32_t lastProduct = AOT::UNKNOWN_ISA; - for (const auto &device : deviceAotInfo) { - if (device.family == family) { - lastProduct = device.aotConfig.value; - } - } - return static_cast(lastProduct); -} - -AOT::PRODUCT_CONFIG ProductConfigHelper::getLastProductConfigFromReleaseName(AOT::RELEASE release) { - uint32_t lastProduct = AOT::UNKNOWN_ISA; - for (const auto &device : deviceAotInfo) { - if (device.release == release) { - lastProduct = device.aotConfig.value; - } - } - return static_cast(lastProduct); -} - NEO::ConstStringRef ProductConfigHelper::getAcronymFromAFamily(AOT::FAMILY family) { for (const auto &[acronym, value] : AOT::familyAcronyms) { if (value == family) { diff --git a/shared/source/helpers/product_config_helper.h b/shared/source/helpers/product_config_helper.h index 6a904ea924..00e28f9d46 100644 --- a/shared/source/helpers/product_config_helper.h +++ b/shared/source/helpers/product_config_helper.h @@ -60,8 +60,6 @@ struct ProductConfigHelper { } static std::vector getDeviceAcronyms(); - AOT::PRODUCT_CONFIG getLastProductConfigFromFamilyName(AOT::FAMILY family); - AOT::PRODUCT_CONFIG getLastProductConfigFromReleaseName(AOT::RELEASE release); static NEO::ConstStringRef getAcronymFromAFamily(AOT::FAMILY family); static NEO::ConstStringRef getAcronymFromARelease(AOT::RELEASE release); static uint32_t getProductConfigFromVersionValue(const std::string &device); diff --git a/shared/source/helpers/product_config_helper_former.cpp b/shared/source/helpers/product_config_helper_former.cpp deleted file mode 100644 index 43067e7460..0000000000 --- a/shared/source/helpers/product_config_helper_former.cpp +++ /dev/null @@ -1,170 +0,0 @@ -/* - * Copyright (C) 2025 Intel Corporation - * - * SPDX-License-Identifier: MIT - * - */ - -#include "shared/source/helpers/product_config_helper_former.h" - -#include "shared/source/helpers/hw_info.h" - -#include "device_ids_configs.h" -#include "hw_cmds.h" -#include "neo_aot_platforms.h" - -FormerProductConfigHelper::FormerProductConfigHelper() - : helper(Ocloc::SupportedDevicesMode::concat, nullptr) { - data = helper.collectFormerSupportedDevicesData(); -} - -Ocloc::SupportedDevicesHelper::SupportedDevicesData &FormerProductConfigHelper::getData() { - return data; -} - -template <> -bool FormerProductConfigHelper::isSupportedTarget(const std::string &target) const { - return std::any_of( - data.familyGroups.begin(), data.familyGroups.end(), - [&](const auto &pair) { return pair.first == target; }); -} - -template <> -bool FormerProductConfigHelper::isSupportedTarget(const std::string &target) const { - return std::any_of( - data.releaseGroups.begin(), data.releaseGroups.end(), - [&](const auto &pair) { return pair.first == target; }); -} - -bool FormerProductConfigHelper::isSupportedProductConfig(uint32_t config) const { - if (config == AOT::UNKNOWN_ISA) { - return false; - } - return std::any_of(data.deviceIpVersions.begin(), data.deviceIpVersions.end(), - [config](uint32_t v) { return v == config; }); -} - -std::vector FormerProductConfigHelper::getProductAcronymsFromFamilyGroup(const std::string &groupName) const { - return getProductAcronymsFromGroup(groupName, data.familyGroups); -} - -std::vector FormerProductConfigHelper::getProductAcronymsFromReleaseGroup(const std::string &groupName) const { - return getProductAcronymsFromGroup(groupName, data.releaseGroups); -} - -AOT::PRODUCT_CONFIG FormerProductConfigHelper::getProductConfigFromDeviceName(const std::string &device) { - uint32_t config = AOT::UNKNOWN_ISA; - char hexPrefixLength = 2; - if (device.find(".") != std::string::npos) { - config = ProductConfigHelper::getProductConfigFromVersionValue(device); - } else if (std::all_of(device.begin(), device.end(), (::isdigit))) { - config = static_cast(std::stoul(device)); - } else if (device.substr(0, hexPrefixLength) == "0x" && std::all_of(device.begin() + hexPrefixLength, device.end(), (::isxdigit))) { - auto deviceId = static_cast(std::stoi(device, 0, 16)); - config = getProductConfigFromDeviceId(deviceId); - } else { - config = getProductConfigFromAcronym(device); - } - return static_cast(config); -} - -AOT::PRODUCT_CONFIG FormerProductConfigHelper::getProductConfigFromAcronym(const std::string &device) { - auto it = std::find_if( - data.acronyms.begin(), data.acronyms.end(), - [&](const auto &pair) { return pair.first == device; }); - if (it != data.acronyms.end()) { - return static_cast(it->second); - } - return AOT::UNKNOWN_ISA; -} - -AOT::PRODUCT_CONFIG FormerProductConfigHelper::getProductConfigFromDeviceId(const uint32_t &deviceId) { - auto it = std::find_if( - data.deviceInfos.begin(), data.deviceInfos.end(), - [&](const auto &deviceInfo) { return deviceInfo.deviceId == deviceId; }); - if (it != data.deviceInfos.end()) { - return static_cast(it->ipVersion); - } - return AOT::UNKNOWN_ISA; -} - -AOT::PRODUCT_CONFIG FormerProductConfigHelper::getFirstProductConfig() { - uint32_t firstProduct = AOT::UNKNOWN_ISA; - if (!data.acronyms.empty()) { - auto &firstProductPair = data.acronyms.front(); - firstProduct = firstProductPair.second; - } - return static_cast(firstProduct); -} - -bool FormerProductConfigHelper::isFamilyName(const std::string &family) { - return std::any_of( - data.familyGroups.begin(), data.familyGroups.end(), - [&family](const auto &pair) { - return pair.first == family; - }); -} - -bool FormerProductConfigHelper::isReleaseName(const std::string &release) { - return std::any_of( - data.releaseGroups.begin(), data.releaseGroups.end(), - [&release](const auto &pair) { - return pair.first == release; - }); -} - -std::string FormerProductConfigHelper::getFamilyName(Position pos) { - if (data.familyGroups.empty()) { - return ""; - } - if (pos == Position::firstItem) { - return data.familyGroups.front().first; - } else { - return data.familyGroups.back().first; - } -} - -std::string FormerProductConfigHelper::getReleaseName(Position pos) { - if (data.releaseGroups.empty()) { - return ""; - } - if (pos == Position::firstItem) { - return data.releaseGroups.front().first; - } else { - return data.releaseGroups.back().first; - } -} - -AOT::PRODUCT_CONFIG FormerProductConfigHelper::getProductConfigFromFamilyName(const std::string &family, Position pos) { - for (const auto &[acronym, value] : data.familyGroups) { - if (acronym == family && !value.empty()) { - if (pos == Position::firstItem) { - return static_cast(value.front()); - } else { - return static_cast(value.back()); - } - } - } - return AOT::UNKNOWN_ISA; -} - -AOT::PRODUCT_CONFIG FormerProductConfigHelper::getProductConfigFromReleaseName(const std::string &release, Position pos) { - for (const auto &[acronym, value] : data.releaseGroups) { - if (acronym == release && !value.empty()) { - if (pos == Position::firstItem) { - return static_cast(value.front()); - } else { - return static_cast(value.back()); - } - } - } - return AOT::UNKNOWN_ISA; -} - -std::vector FormerProductConfigHelper::getRepresentativeProductAcronyms() { - std::vector enabledAcronyms{}; - for (const auto &[acronym, ipVersion] : data.acronyms) { - enabledAcronyms.push_back(acronym.c_str()); - } - return enabledAcronyms; -} diff --git a/shared/source/helpers/product_config_helper_former.h b/shared/source/helpers/product_config_helper_former.h deleted file mode 100644 index 87f18a366b..0000000000 --- a/shared/source/helpers/product_config_helper_former.h +++ /dev/null @@ -1,75 +0,0 @@ -/* - * Copyright (C) 2025 Intel Corporation - * - * SPDX-License-Identifier: MIT - * - */ - -#pragma once - -#include "shared/offline_compiler/source/ocloc_api.h" -#include "shared/offline_compiler/source/ocloc_interface.h" -#include "shared/offline_compiler/source/ocloc_supported_devices_helper.h" -#include "shared/source/helpers/hw_ip_version.h" -#include "shared/source/helpers/product_config_helper.h" -#include "shared/source/utilities/const_stringref.h" - -#include "neo_igfxfmid.h" - -#include -#include -#include -#include - -struct ProductConfigHelper; -struct FormerProductConfigHelper { - public: - enum class Position { firstItem, - lastItem }; - - FormerProductConfigHelper(); - - Ocloc::SupportedDevicesHelper::SupportedDevicesData &getData(); - - template - bool isSupportedTarget(const std::string &target) const; - bool isSupportedProductConfig(uint32_t config) const; - std::vector getProductAcronymsFromFamilyGroup(const std::string &groupName) const; - std::vector getProductAcronymsFromReleaseGroup(const std::string &groupName) const; - AOT::PRODUCT_CONFIG getProductConfigFromDeviceName(const std::string &device); - AOT::PRODUCT_CONFIG getProductConfigFromAcronym(const std::string &device); - AOT::PRODUCT_CONFIG getProductConfigFromDeviceId(const uint32_t &deviceId); - AOT::PRODUCT_CONFIG getFirstProductConfig(); - bool isFamilyName(const std::string &family); - bool isReleaseName(const std::string &release); - std::string getFamilyName(Position pos); - std::string getReleaseName(Position pos); - AOT::PRODUCT_CONFIG getProductConfigFromFamilyName(const std::string &family, Position pos); - AOT::PRODUCT_CONFIG getProductConfigFromReleaseName(const std::string &release, Position pos); - std::vector getRepresentativeProductAcronyms(); - - protected: - template - std::vector getProductAcronymsFromGroup(const std::string &groupName, const GroupT &groups) const; - Ocloc::SupportedDevicesHelper helper; - Ocloc::SupportedDevicesHelper::SupportedDevicesData data; -}; - -template -std::vector FormerProductConfigHelper::getProductAcronymsFromGroup(const std::string &groupName, const GroupT &groups) const { - std::vector enabledAcronyms{}; - for (const auto &[name, ipVersions] : groups) { - if (name == groupName) { - for (const auto &ipVersion : ipVersions) { - auto it = std::find_if(data.acronyms.begin(), data.acronyms.end(), - [&ipVersion](const std::pair &pair) { - return pair.second == ipVersion; - }); - if (it != data.acronyms.end()) { - enabledAcronyms.push_back(it->first); - } - } - } - } - return enabledAcronyms; -}