intel/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2025-12-18 13:54:58 +08:00
Code Issues Packages Projects Releases Wiki Activity

fix(ocloc): correct ocloc name in supported devices query

Browse Source 
previous approach was to version ocloc library but it was deprecated
right now there will be 2 known libraries:
- libocloc.so - for mainstream
- libocloc-legacy1.so for legacy platforms

Related-To: NEO-12273, NEO-9630
Signed-off-by: Mateusz Jablonski <mateusz.jablonski@intel.com>
This commit is contained in:
Mateusz Jablonski
2024-08-14 09:07:50 +00:00
committed by Compute-Runtime-Automation
parent b063c3c62b
commit 922edfd68d
10 changed files with 100 additions and 104 deletions
Download Patch File Download Diff File Expand all files Collapse all files

23
opencl/test/unit_test/offline_compiler/linux/ocloc_supported_devices_helper_linux_tests.cpp
View File

@@ -23,7 +23,7 @@ using namespace NEO;
struct SupportedDevicesHelperLinuxTest : public ::testing::Test {
void SetUp() override {
mockHelper.getOclocCurrentVersionMockResult = "";
mockHelper.getCurrentOclocNameMockResult = "";
oclocCurrentLibName.shrink_to_fit();
oclocFormerLibName.shrink_to_fit();
}
@@ -36,28 +36,27 @@ struct SupportedDevicesHelperLinuxTest : public ::testing::Test {
MockSupportedDevicesHelper mockHelper = MockSupportedDevicesHelper(SupportedDevicesMode::concat, nullptr);
};
TEST_F(SupportedDevicesHelperLinuxTest, GivenVariousOclocLibraryNamesWhenExtractingOclocVersionThenEmptyStringIsReturned) {
TEST_F(SupportedDevicesHelperLinuxTest, GivenVariousOclocLibraryNamesWhenExtractingOclocNameThenCorrectStringIsReturned) {
{
// Valid Ocloc lib names
EXPECT_EQ(mockHelper.extractOclocVersion("libocloc-2.0.1.so"), "ocloc-2.0.1");
EXPECT_EQ(mockHelper.extractOclocVersion("libocloc-2.0.so"), "ocloc-2.0");
EXPECT_EQ(mockHelper.extractOclocName("libocloc.so"), "ocloc");
EXPECT_EQ(mockHelper.extractOclocName("libocloc-legacy1.so"), "ocloc-legacy1");
}
{
// Invalid Ocloc lib names
EXPECT_EQ(mockHelper.extractOclocVersion("libocloc2.0.so"), "ocloc");
EXPECT_EQ(mockHelper.extractOclocVersion("libocloc-2.0"), "ocloc");
EXPECT_EQ(mockHelper.extractOclocVersion(""), "ocloc");
EXPECT_EQ(mockHelper.extractOclocVersion("libocloc.so"), "ocloc");
EXPECT_EQ(mockHelper.extractOclocName("ocloc2.so"), "ocloc");
EXPECT_EQ(mockHelper.extractOclocName(""), "ocloc");
EXPECT_EQ(mockHelper.extractOclocName("libocloc2"), "ocloc");
}
}
TEST_F(SupportedDevicesHelperLinuxTest, GivenSupportedDevicesHelperWhenGetOclocCurrentVersionThenReturnCorrectValue) {
TEST_F(SupportedDevicesHelperLinuxTest, GivenSupportedDevicesHelperWhenGetCurrentOclocNameThenReturnCorrectValue) {
VariableBackup<std::string> oclocNameBackup(&oclocCurrentLibName, "libocloc-current.so");
EXPECT_EQ("ocloc-current", mockHelper.getOclocCurrentVersion());
EXPECT_EQ("ocloc-current", mockHelper.getCurrentOclocName());
}
TEST_F(SupportedDevicesHelperLinuxTest, GivenSupportedDevicesHelperWhenGetOclocFormerVersionThenReturnCorrectValue) {
TEST_F(SupportedDevicesHelperLinuxTest, GivenSupportedDevicesHelperWhenGetFormerOclocNameThenReturnCorrectValue) {
VariableBackup<std::string> oclocNameBackup(&oclocFormerLibName, "libocloc-former.so");
EXPECT_EQ("ocloc-former", mockHelper.getOclocFormerVersion());
EXPECT_EQ("ocloc-former", mockHelper.getFormerOclocName());
}

20
opencl/test/unit_test/offline_compiler/mock/mock_ocloc_supported_devices_helper.h
View File

@@ -18,16 +18,16 @@ using namespace Ocloc;
class MockSupportedDevicesHelper : public SupportedDevicesHelper {
public:
using SupportedDevicesHelper::extractOclocVersion;
using SupportedDevicesHelper::getOclocCurrentVersion;
using SupportedDevicesHelper::getOclocFormerVersion;
using SupportedDevicesHelper::mergeOclocVersionData;
using SupportedDevicesHelper::extractOclocName;
using SupportedDevicesHelper::getCurrentOclocName;
using SupportedDevicesHelper::getFormerOclocName;
using SupportedDevicesHelper::mergeOclocData;
public:
MockSupportedDevicesHelper(SupportedDevicesMode mode, ProductConfigHelper *productConfigHelper)
: SupportedDevicesHelper(mode, productConfigHelper) {}
std::string getDataFromFormerOclocVersion() const override {
std::string getDataFromFormerOcloc() const override {
if (getDataFromFormerOclocVersionEmptyResult) {
return "";
}
@@ -53,16 +53,16 @@ class MockSupportedDevicesHelper : public SupportedDevicesHelper {
)";
}
std::string getOclocCurrentVersion() const override {
if (!getOclocCurrentVersionMockResult.empty()) {
return getOclocCurrentVersionMockResult;
std::string getCurrentOclocName() const override {
if (!getCurrentOclocNameMockResult.empty()) {
return getCurrentOclocNameMockResult;
}
return SupportedDevicesHelper::getOclocCurrentVersion();
return SupportedDevicesHelper::getCurrentOclocName();
}
public:
bool getDataFromFormerOclocVersionEmptyResult = false;
std::string getOclocCurrentVersionMockResult = "ocloc-current";
std::string getCurrentOclocNameMockResult = "ocloc-current";
};
} // namespace NEO

28
opencl/test/unit_test/offline_compiler/ocloc_supported_devices_helper_tests.cpp
View File

@@ -370,7 +370,7 @@ TEST_F(SupportedDevicesHelperTest, WhenSerializingDeserializingAndSerializingAga
}
}
TEST_F(SupportedDevicesHelperTest, WhenMergingOclocVersionDataThenAllDataIsCombinedCorrectly) {
TEST_F(SupportedDevicesHelperTest, WhenMergingOclocDataThenAllDataIsCombinedCorrectly) {
SupportedDevicesMode mode = SupportedDevicesMode::merge;
MockSupportedDevicesHelper supportedDevicesHelper(mode, argHelper->productConfigHelper.get());
@@ -397,7 +397,7 @@ TEST_F(SupportedDevicesHelperTest, WhenMergingOclocVersionDataThenAllDataIsCombi
versionDataMap["ocloc-1.0"] = data1;
versionDataMap["ocloc-2.0"] = data2;
auto mergedData = supportedDevicesHelper.mergeOclocVersionData(versionDataMap);
auto mergedData = supportedDevicesHelper.mergeOclocData(versionDataMap);
ASSERT_EQ(mergedData.deviceIpVersions.size(), 3u);
EXPECT_TRUE(std::is_sorted(mergedData.deviceIpVersions.begin(), mergedData.deviceIpVersions.end()));
@@ -448,13 +448,13 @@ TEST_F(SupportedDevicesHelperTest, WhenMergingOclocVersionDataThenAllDataIsCombi
EXPECT_EQ(mergedData.releaseGroups[3].second, std::vector<uint32_t>({0x2000001}));
}
TEST_F(SupportedDevicesHelperTest, WhenConcatAndSerializeWithFormerVersionDataThenResultIsCorrect) {
TEST_F(SupportedDevicesHelperTest, WhenConcatAndSerializeWithFormerDataThenResultIsCorrect) {
SupportedDevicesMode mode = SupportedDevicesMode::concat;
MockSupportedDevicesHelper supportedDevicesHelper(mode, argHelper->productConfigHelper.get());
auto currentVersionData = supportedDevicesHelper.collectSupportedDevicesData(enabledDevices);
auto currentData = supportedDevicesHelper.collectSupportedDevicesData(enabledDevices);
std::string concatResult = supportedDevicesHelper.concatAndSerializeWithFormerVersionData(currentVersionData);
std::string concatResult = supportedDevicesHelper.concatAndSerializeWithFormerData(currentData);
auto family1 = argHelper->productConfigHelper->getAcronymFromAFamily(mockDevices[0].family);
auto family2 = argHelper->productConfigHelper->getAcronymFromAFamily(mockDevices[1].family);
@@ -516,14 +516,14 @@ ocloc-former:
EXPECT_EQ(concatResult, expectedYaml);
}
TEST_F(SupportedDevicesHelperTest, GivenEmptyFormerVersionDataWhenConcatAndSerializeWithFormerVersionDataThenResultIsCorrect) {
TEST_F(SupportedDevicesHelperTest, GivenEmptyFormerDataWhenConcatAndSerializeWithFormerDataThenResultIsCorrect) {
SupportedDevicesMode mode = SupportedDevicesMode::concat;
MockSupportedDevicesHelper supportedDevicesHelper(mode, argHelper->productConfigHelper.get());
supportedDevicesHelper.getDataFromFormerOclocVersionEmptyResult = true;
auto currentVersionData = supportedDevicesHelper.collectSupportedDevicesData(enabledDevices);
auto currentData = supportedDevicesHelper.collectSupportedDevicesData(enabledDevices);
std::string concatResult = supportedDevicesHelper.concatAndSerializeWithFormerVersionData(currentVersionData);
std::string concatResult = supportedDevicesHelper.concatAndSerializeWithFormerData(currentData);
auto family1 = argHelper->productConfigHelper->getAcronymFromAFamily(mockDevices[0].family);
auto family2 = argHelper->productConfigHelper->getAcronymFromAFamily(mockDevices[1].family);
@@ -566,13 +566,13 @@ TEST_F(SupportedDevicesHelperTest, GivenEmptyFormerVersionDataWhenConcatAndSeria
EXPECT_EQ(concatResult, expectedYaml);
}
TEST_F(SupportedDevicesHelperTest, WhenMergeAndSerializeWithFormerVersionDataThenBothVersionsAreCorrectlyMerged) {
TEST_F(SupportedDevicesHelperTest, WhenMergeAndSerializeWithFormerDataThenBothVersionsAreCorrectlyMerged) {
SupportedDevicesMode mode = SupportedDevicesMode::merge;
MockSupportedDevicesHelper supportedDevicesHelper(mode, argHelper->productConfigHelper.get());
supportedDevicesHelper.getDataFromFormerOclocVersionEmptyResult = false;
auto currentVersionData = supportedDevicesHelper.collectSupportedDevicesData(enabledDevices);
std::string mergeResult = supportedDevicesHelper.mergeAndSerializeWithFormerVersionData(currentVersionData);
auto currentData = supportedDevicesHelper.collectSupportedDevicesData(enabledDevices);
std::string mergeResult = supportedDevicesHelper.mergeAndSerializeWithFormerData(currentData);
auto deserializedResult = supportedDevicesHelper.deserialize(mergeResult);
ASSERT_EQ(deserializedResult.size(), 1u);
@@ -643,13 +643,13 @@ TEST_F(SupportedDevicesHelperTest, WhenMergeAndSerializeWithFormerVersionDataThe
}
}
TEST_F(SupportedDevicesHelperTest, GivenEmptyFormerVersionDataWhenMergeAndSerializeWithFormerVersionDataThenOnlyCurrentVersionIsPresent) {
TEST_F(SupportedDevicesHelperTest, GivenEmptyFormerDataWhenMergeAndSerializeWithFormerDataThenOnlyCurrentVersionIsPresent) {
SupportedDevicesMode mode = SupportedDevicesMode::merge;
MockSupportedDevicesHelper supportedDevicesHelper(mode, argHelper->productConfigHelper.get());
supportedDevicesHelper.getDataFromFormerOclocVersionEmptyResult = true;
auto currentVersionData = supportedDevicesHelper.collectSupportedDevicesData(enabledDevices);
std::string mergeResult = supportedDevicesHelper.mergeAndSerializeWithFormerVersionData(currentVersionData);
auto currentData = supportedDevicesHelper.collectSupportedDevicesData(enabledDevices);
std::string mergeResult = supportedDevicesHelper.mergeAndSerializeWithFormerData(currentData);
auto family1 = argHelper->productConfigHelper->getAcronymFromAFamily(mockDevices[0].family);
auto family2 = argHelper->productConfigHelper->getAcronymFromAFamily(mockDevices[1].family);

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

@@ -1042,7 +1042,7 @@ TEST_F(OfflineCompilerTests, WhenQueryingSupportedDevicesThenNonEmptyOutputFileI
EXPECT_EQ(OCLOC_SUCCESS, retVal);
Ocloc::SupportedDevicesHelper supportedDevicesHelper(mode, oclocArgHelperWithoutInput->productConfigHelper.get());
std::string expectedFileName = supportedDevicesHelper.getOclocCurrentVersionOutputFilename();
std::string expectedFileName = supportedDevicesHelper.getCurrentOclocOutputFilename();
EXPECT_NE(oclocArgHelperWithoutInput->filesMap.find(expectedFileName), oclocArgHelperWithoutInput->filesMap.end());

30
opencl/test/unit_test/offline_compiler/windows/ocloc_supported_devices_helper_windows_tests.cpp
View File

@@ -11,11 +11,11 @@
#include "gtest/gtest.h"
namespace NEO {
using namespace NEO;
struct SupportedDevicesHelperWindowsTest : public ::testing::Test {
void SetUp() override {
mockHelper.getOclocCurrentVersionMockResult = "";
mockHelper.getCurrentOclocNameMockResult = "";
}
void TearDown() override {
@@ -24,25 +24,23 @@ struct SupportedDevicesHelperWindowsTest : public ::testing::Test {
MockSupportedDevicesHelper mockHelper = MockSupportedDevicesHelper(SupportedDevicesMode::concat, nullptr);
};
TEST_F(SupportedDevicesHelperWindowsTest, GivenVariousOclocLibraryNamesWhenExtractingOclocVersionThenEmptyStringIsReturned) {
EXPECT_EQ(mockHelper.extractOclocVersion("libocloc-2.0.1.so"), "");
EXPECT_EQ(mockHelper.extractOclocVersion("libocloc-2.0.so"), "");
EXPECT_EQ(mockHelper.extractOclocVersion("libocloc2.0.so"), "");
EXPECT_EQ(mockHelper.extractOclocVersion("libocloc-2.0"), "");
EXPECT_EQ(mockHelper.extractOclocVersion("libocloc.so"), "");
TEST_F(SupportedDevicesHelperWindowsTest, GivenVariousOclocLibraryNamesWhenExtractingOclocNameThenEmptyStringIsReturned) {
EXPECT_EQ(mockHelper.extractOclocName("libocloc-2.0.1.so"), "");
EXPECT_EQ(mockHelper.extractOclocName("libocloc-2.0.so"), "");
EXPECT_EQ(mockHelper.extractOclocName("libocloc2.0.so"), "");
EXPECT_EQ(mockHelper.extractOclocName("libocloc-2.0"), "");
EXPECT_EQ(mockHelper.extractOclocName("libocloc.so"), "");
}
TEST_F(SupportedDevicesHelperWindowsTest, GivenSupportedDevicesHelperWhenGetOclocCurrentVersionThenReturnCorrectValue) {
EXPECT_EQ("ocloc", mockHelper.getOclocCurrentVersion());
TEST_F(SupportedDevicesHelperWindowsTest, GivenSupportedDevicesHelperWhenGetCurrentOclocNameThenReturnCorrectValue) {
EXPECT_EQ("ocloc", mockHelper.getCurrentOclocName());
}
TEST_F(SupportedDevicesHelperWindowsTest, GivenSupportedDevicesHelperWhenGetOclocFormerVersionThenReturnCorrectValue) {
EXPECT_EQ("", mockHelper.getOclocFormerVersion());
TEST_F(SupportedDevicesHelperWindowsTest, GivenSupportedDevicesHelperWhenGetFormerOclocNameThenReturnCorrectValue) {
EXPECT_EQ("", mockHelper.getFormerOclocName());
}
TEST_F(SupportedDevicesHelperWindowsTest, GivenSupportedDevicesHelperWhenGetDataFromFormerOclocVersionThenReturnEmptyData) {
TEST_F(SupportedDevicesHelperWindowsTest, GivenSupportedDevicesHelperWhenGetDataFromFormerOclocThenReturnEmptyData) {
SupportedDevicesHelper helper(SupportedDevicesMode::concat, nullptr);
EXPECT_EQ("", helper.getDataFromFormerOclocVersion());
EXPECT_EQ("", helper.getDataFromFormerOcloc());
}
} // namespace NEO

25
shared/offline_compiler/source/linux/ocloc_supported_devices_helper_linux.cpp
View File

@@ -19,25 +19,24 @@ std::string SupportedDevicesHelper::getOutputFilenameSuffix(SupportedDevicesMode
return "_supported_devices_" + toStr(mode) + fileExtension.data();
}
std::string SupportedDevicesHelper::getOclocCurrentVersionOutputFilename() const {
return getOclocCurrentVersion() + getOutputFilenameSuffix(mode);
std::string SupportedDevicesHelper::getCurrentOclocOutputFilename() const {
return getCurrentOclocName() + getOutputFilenameSuffix(mode);
}
std::string SupportedDevicesHelper::getOclocCurrentVersion() const {
return extractOclocVersion(getOclocCurrentLibName());
std::string SupportedDevicesHelper::getCurrentOclocName() const {
return extractOclocName(getOclocCurrentLibName());
}
std::string SupportedDevicesHelper::getOclocFormerVersion() const {
return extractOclocVersion(getOclocFormerLibName());
}
std::string SupportedDevicesHelper::extractOclocVersion(std::string_view oclocLibNameWithVersion) const {
// libocloc-2.0.so -> ocloc-2.0
std::string_view view(oclocLibNameWithVersion);
auto start = view.find("ocloc-");
std::string SupportedDevicesHelper::extractOclocName(std::string_view oclocLibName) const {
// libocloc.so -> ocloc
// libocloc-legacy1.so -> ocloc-legacy1
std::string_view view(oclocLibName);
constexpr char prefix[] = "lib";
auto start = view.find(prefix);
if (start == std::string_view::npos) {
return "ocloc";
}
start += strlen(prefix);
auto end = view.find(".so", start);
if (end == std::string_view::npos) {
@@ -47,7 +46,7 @@ std::string SupportedDevicesHelper::extractOclocVersion(std::string_view oclocLi
return std::string(view.substr(start, end - start));
}
std::string SupportedDevicesHelper::getDataFromFormerOclocVersion() const {
std::string SupportedDevicesHelper::getDataFromFormerOcloc() const {
std::string retData;
const char *argv[] = {"ocloc", "query", "SUPPORTED_DEVICES", "-concat"};

38
shared/offline_compiler/source/ocloc_supported_devices_helper.cpp
View File

@@ -8,9 +8,9 @@
#include "shared/offline_compiler/source/ocloc_supported_devices_helper.h"
#include "shared/offline_compiler/source/ocloc_api.h"
#include "shared/offline_compiler/source/ocloc_interface.h"
#include "shared/source/device_binary_format/yaml/yaml_parser.h"
#include "shared/source/helpers/product_config_helper.h"
#include "shared/source/os_interface/os_library.h"
#include <cstring>
#include <memory>
@@ -63,9 +63,9 @@ SupportedDevicesHelper::SupportedDevicesData SupportedDevicesHelper::collectSupp
return data;
}
std::string SupportedDevicesHelper::serialize(std::string_view oclocVersion, const SupportedDevicesData &data) const {
std::string SupportedDevicesHelper::serialize(std::string_view oclocName, const SupportedDevicesData &data) const {
std::ostringstream oss;
oss << oclocVersion << ":\n";
oss << oclocName << ":\n";
// DeviceIpVersions
oss << " " << SupportedDevicesYamlConstants::deviceIpVersions << ":\n";
@@ -204,30 +204,30 @@ std::map<std::string, SupportedDevicesHelper::SupportedDevicesData> SupportedDev
return result;
}
std::string SupportedDevicesHelper::mergeAndSerializeWithFormerVersionData(const SupportedDevicesData &currentVersionData) const {
std::string formerVersionSupportedDevices = getDataFromFormerOclocVersion();
std::string SupportedDevicesHelper::mergeAndSerializeWithFormerData(const SupportedDevicesData &currentData) const {
std::string formerSupportedDevices = getDataFromFormerOcloc();
if (formerVersionSupportedDevices.empty()) {
return serialize(getOclocCurrentVersion(), currentVersionData);
if (formerSupportedDevices.empty()) {
return serialize(getCurrentOclocName(), currentData);
}
auto formerVerDeserialized = deserialize(formerVersionSupportedDevices);
formerVerDeserialized[getOclocCurrentVersion()] = currentVersionData;
auto formerDataDeserialized = deserialize(formerSupportedDevices);
formerDataDeserialized[getCurrentOclocName()] = currentData;
auto mergedData = mergeOclocVersionData(formerVerDeserialized);
auto mergedData = mergeOclocData(formerDataDeserialized);
return serialize("ocloc", mergedData);
}
std::string SupportedDevicesHelper::concatAndSerializeWithFormerVersionData(const SupportedDevicesData &currentVersionData) const {
std::string output = serialize(getOclocCurrentVersion(), currentVersionData);
std::string formerVersionSupportedDevices = getDataFromFormerOclocVersion();
if (!formerVersionSupportedDevices.empty()) {
output += "\n" + formerVersionSupportedDevices;
std::string SupportedDevicesHelper::concatAndSerializeWithFormerData(const SupportedDevicesData &currentData) const {
std::string output = serialize(getCurrentOclocName(), currentData);
std::string formerSupportedDevices = getDataFromFormerOcloc();
if (!formerSupportedDevices.empty()) {
output += "\n" + formerSupportedDevices;
}
return output;
}
SupportedDevicesHelper::SupportedDevicesData SupportedDevicesHelper::mergeOclocVersionData(const std::map<std::string, SupportedDevicesData> &versionDataMap) const {
SupportedDevicesHelper::SupportedDevicesData SupportedDevicesHelper::mergeOclocData(const std::map<std::string, SupportedDevicesData> &nameDataMap) const {
struct DeviceInfoComparator {
bool operator()(const DeviceInfo &lhs, const DeviceInfo &rhs) const {
return std::tie(lhs.deviceId, lhs.revisionId, lhs.ipVersion) <
@@ -242,7 +242,7 @@ SupportedDevicesHelper::SupportedDevicesData SupportedDevicesHelper::mergeOclocV
std::map<std::string, std::set<uint32_t>> uniqueFamilyGroups;
std::map<std::string, std::set<uint32_t>> uniqueReleaseGroups;
for (const auto &[version, data] : versionDataMap) {
for (const auto &[name, data] : nameDataMap) {
uniqueIpVersions.insert(data.deviceIpVersions.begin(), data.deviceIpVersions.end());
for (const auto &deviceInfo : data.deviceInfos) {
uniqueDeviceInfos.insert(deviceInfo);
@@ -294,4 +294,8 @@ SupportedDevicesHelper::SupportedDevicesData SupportedDevicesHelper::mergeOclocV
return mergedData;
}
std::string SupportedDevicesHelper::getFormerOclocName() const {
return extractOclocName(getOclocFormerLibName());
}
} // namespace Ocloc

18
shared/offline_compiler/source/ocloc_supported_devices_helper.h
View File

@@ -55,22 +55,22 @@ class SupportedDevicesHelper {
SupportedDevicesHelper(SupportedDevicesMode mode, ProductConfigHelper *productConfigHelper)
: mode(mode), productConfigHelper(productConfigHelper) {}
std::string getOclocCurrentVersionOutputFilename() const;
std::string getCurrentOclocOutputFilename() const;
SupportedDevicesData collectSupportedDevicesData(const std::vector<DeviceAotInfo> &enabledDevices) const;
std::string serialize(std::string_view oclocVersion, const SupportedDevicesData &data) const;
std::string serialize(std::string_view oclocName, const SupportedDevicesData &data) const;
std::map<std::string, SupportedDevicesData> deserialize(std::string_view yamlString) const;
std::string mergeAndSerializeWithFormerVersionData(const SupportedDevicesData &currentVersionData) const;
std::string concatAndSerializeWithFormerVersionData(const SupportedDevicesData &currentVersionData) const;
std::string mergeAndSerializeWithFormerData(const SupportedDevicesData &currentData) const;
std::string concatAndSerializeWithFormerData(const SupportedDevicesData &currentData) const;
MOCKABLE_VIRTUAL std::string getDataFromFormerOclocVersion() const;
MOCKABLE_VIRTUAL std::string getDataFromFormerOcloc() const;
protected:
MOCKABLE_VIRTUAL std::string getOclocCurrentVersion() const;
std::string getOclocFormerVersion() const;
std::string extractOclocVersion(std::string_view oclocLibNameWithVersion) const;
SupportedDevicesData mergeOclocVersionData(const std::map<std::string, SupportedDevicesData> &versionDataMap) const;
MOCKABLE_VIRTUAL std::string getCurrentOclocName() const;
std::string getFormerOclocName() const;
std::string extractOclocName(std::string_view oclocLibFileName) const;
SupportedDevicesData mergeOclocData(const std::map<std::string, SupportedDevicesData> &nameDataMap) const;
std::string getOutputFilenameSuffix([[maybe_unused]] SupportedDevicesMode mode) const;
private:

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

@@ -472,12 +472,12 @@ int OfflineCompiler::querySupportedDevices(Ocloc::SupportedDevicesMode mode, Ocl
std::string output;
if (mode == Ocloc::SupportedDevicesMode::merge) {
output = supportedDevicesHelper.mergeAndSerializeWithFormerVersionData(supportedDevicesData);
output = supportedDevicesHelper.mergeAndSerializeWithFormerData(supportedDevicesData);
} else {
output = supportedDevicesHelper.concatAndSerializeWithFormerVersionData(supportedDevicesData);
output = supportedDevicesHelper.concatAndSerializeWithFormerData(supportedDevicesData);
}
helper->saveOutput(supportedDevicesHelper.getOclocCurrentVersionOutputFilename(), output.data(), output.size());
helper->saveOutput(supportedDevicesHelper.getCurrentOclocOutputFilename(), output.data(), output.size());
return 0;
}

14
shared/offline_compiler/source/windows/ocloc_supported_devices_helper_windows.cpp
View File

@@ -17,23 +17,19 @@ std::string SupportedDevicesHelper::getOutputFilenameSuffix(SupportedDevicesMode
return std::string("_supported_devices") + fileExtension.data();
}
std::string SupportedDevicesHelper::getOclocCurrentVersionOutputFilename() const {
return getOclocCurrentVersion() + getOutputFilenameSuffix(SupportedDevicesMode::unknown);
std::string SupportedDevicesHelper::getCurrentOclocOutputFilename() const {
return getCurrentOclocName() + getOutputFilenameSuffix(SupportedDevicesMode::unknown);
}
std::string SupportedDevicesHelper::getOclocCurrentVersion() const {
std::string SupportedDevicesHelper::getCurrentOclocName() const {
return "ocloc";
}
std::string SupportedDevicesHelper::getOclocFormerVersion() const {
std::string SupportedDevicesHelper::extractOclocName(std::string_view oclocLibName) const {
return "";
}
std::string SupportedDevicesHelper::extractOclocVersion(std::string_view oclocLibNameWithVersion) const {
return "";
}
std::string SupportedDevicesHelper::getDataFromFormerOclocVersion() const {
std::string SupportedDevicesHelper::getDataFromFormerOcloc() const {
return "";
}
} // namespace Ocloc