Media/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2025-09-15 13:01:45 +08:00
Code Issues Packages Projects Releases Wiki Activity

Do not provide -cl-feature option to the compiler

Browse Source 
Signed-off-by: Filip Hazubski <filip.hazubski@intel.com>
This commit is contained in:
Filip Hazubski
2020-11-16 16:56:33 +00:00
committed by Compute-Runtime-Automation
parent 2ef52ff39c
commit 59b74a8ea3
12 changed files with 48 additions and 95 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
opencl/source/cl_device/cl_device.cpp
View File

@ -32,7 +32,6 @@ ClDevice::ClDevice(Device &device, Platform *platform) : device(device), platfor
OpenClCFeaturesContainer emptyOpenClCFeatures;
compilerExtensions = convertEnabledExtensionsToCompilerInternalOptions(deviceInfo.deviceExtensions, emptyOpenClCFeatures);
compilerExtensionsWithFeatures = convertEnabledExtensionsToCompilerInternalOptions(deviceInfo.deviceExtensions, deviceInfo.openclCFeatures);
compilerFeatures = convertEnabledOclCFeaturesToCompilerInternalOptions(deviceInfo.openclCFeatures);
auto numAvailableDevices = device.getNumAvailableDevices();
if (numAvailableDevices > 1) {
@ -184,9 +183,6 @@ const std::string &ClDevice::peekCompilerExtensions() const {
const std::string &ClDevice::peekCompilerExtensionsWithFeatures() const {
return compilerExtensionsWithFeatures;
}
const std::string &ClDevice::peekCompilerFeatures() const {
return compilerFeatures;
}
DeviceBitfield ClDevice::getDeviceBitfield() const {
return device.getDeviceBitfield();
}

2
opencl/source/cl_device/cl_device.h
View File

@ -118,7 +118,6 @@ class ClDevice : public BaseObject<_cl_device_id> {
ClDevice *getDeviceById(uint32_t deviceId);
const std::string &peekCompilerExtensions() const;
const std::string &peekCompilerExtensionsWithFeatures() const;
const std::string &peekCompilerFeatures() const;
std::unique_ptr<SyncBufferHandler> syncBufferHandler;
DeviceBitfield getDeviceBitfield() const;
bool isDeviceEnqueueSupported() const;
@ -149,7 +148,6 @@ class ClDevice : public BaseObject<_cl_device_id> {
std::vector<unsigned int> simultaneousInterops = {0};
std::string compilerExtensions;
std::string compilerExtensionsWithFeatures;
std::string compilerFeatures;
};
} // namespace NEO

14
opencl/source/platform/extensions.cpp
View File

@ -163,18 +163,4 @@ std::string convertEnabledExtensionsToCompilerInternalOptions(const char *enable
return extensionsList;
}
std::string convertEnabledOclCFeaturesToCompilerInternalOptions(OpenClCFeaturesContainer &openclCFeatures) {
UNRECOVERABLE_IF(openclCFeatures.empty());
std::string featuresList;
featuresList.reserve(500);
featuresList = " -cl-feature=";
for (auto &feature : openclCFeatures) {
featuresList.append("+");
featuresList.append(feature.name);
featuresList.append(",");
}
featuresList[featuresList.size() - 1] = ' ';
return featuresList;
}
} // namespace NEO

1
opencl/source/platform/extensions.h
View File

@ -24,6 +24,5 @@ std::string getExtensionsList(const HardwareInfo &hwInfo);
void getOpenclCFeaturesList(const HardwareInfo &hwInfo, OpenClCFeaturesContainer &openclCFeatures);
std::string convertEnabledExtensionsToCompilerInternalOptions(const char *deviceExtensions,
OpenClCFeaturesContainer &openclCFeatures);
std::string convertEnabledOclCFeaturesToCompilerInternalOptions(OpenClCFeaturesContainer &openclCFeatures);
} // namespace NEO

8
opencl/source/program/build.cpp
View File

@ -109,13 +109,9 @@ cl_int Program::build(
}
if (requiresOpenClCFeatures(options)) {
auto compilerExtensionsWithFeaturesOptions = defaultClDevice->peekCompilerExtensionsWithFeatures();
CompilerOptions::concatenateAppend(internalOptions, compilerExtensionsWithFeaturesOptions);
auto compilerFeaturesOptions = defaultClDevice->peekCompilerFeatures();
CompilerOptions::concatenateAppend(internalOptions, compilerFeaturesOptions);
CompilerOptions::concatenateAppend(internalOptions, defaultClDevice->peekCompilerExtensionsWithFeatures());
} else {
auto compilerExtensionsOptions = defaultClDevice->peekCompilerExtensions();
CompilerOptions::concatenateAppend(internalOptions, compilerExtensionsOptions);
CompilerOptions::concatenateAppend(internalOptions, defaultClDevice->peekCompilerExtensions());
}
inputArgs.apiOptions = ArrayRef<const char>(options.c_str(), options.length());

1
opencl/source/program/compile.cpp
View File

@ -118,7 +118,6 @@ cl_int Program::compile(
// set parameters for compilation
if (requiresOpenClCFeatures(options)) {
CompilerOptions::concatenateAppend(internalOptions, defaultClDevice->peekCompilerExtensionsWithFeatures());
CompilerOptions::concatenateAppend(internalOptions, defaultClDevice->peekCompilerFeatures());
} else {
CompilerOptions::concatenateAppend(internalOptions, defaultClDevice->peekCompilerExtensions());
}

13
opencl/test/unit_test/device/device_caps_tests.cpp
View File

@ -1051,19 +1051,6 @@ TEST_F(DeviceGetCapsTest, givenFp64SupportForcedWhenCheckingFp64SupportThenFp64I
}
}
TEST(DeviceGetCaps, WhenPeekingCompilerFeaturesThenCompilerFeaturesAreReturned) {
UltClDeviceFactory deviceFactory{1, 0};
auto pClDevice = deviceFactory.rootDevices[0];
EXPECT_EQ(&pClDevice->compilerFeatures, &pClDevice->peekCompilerFeatures());
}
TEST(DeviceGetCaps, WhenCheckingCompilerFeaturesThenValueIsCorrect) {
UltClDeviceFactory deviceFactory{1, 0};
auto pClDevice = deviceFactory.rootDevices[0];
auto expectedCompilerFeatures = convertEnabledOclCFeaturesToCompilerInternalOptions(pClDevice->deviceInfo.openclCFeatures);
EXPECT_STREQ(expectedCompilerFeatures.c_str(), pClDevice->compilerFeatures.c_str());
}
TEST(DeviceGetCaps, WhenPeekingCompilerExtensionsThenCompilerExtensionsAreReturned) {
UltClDeviceFactory deviceFactory{1, 0};
auto pClDevice = deviceFactory.rootDevices[0];

1
opencl/test/unit_test/mocks/mock_cl_device.h
View File

@ -29,7 +29,6 @@ class MockClDevice : public ClDevice {
using ClDevice::ClDevice;
using ClDevice::compilerExtensions;
using ClDevice::compilerExtensionsWithFeatures;
using ClDevice::compilerFeatures;
using ClDevice::deviceExtensions;
using ClDevice::deviceInfo;
using ClDevice::driverInfo;

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

@ -277,8 +277,7 @@ TEST_F(OfflineCompilerTests, givenClStd30OptionWhenCompilingSourceThenCorrectExt
OpenClCFeaturesContainer openclCFeatures;
getOpenclCFeaturesList(DEFAULT_PLATFORM::hwInfo, openclCFeatures);
for (auto &feature : openclCFeatures) {
auto expectedRegex = std::string{feature.name} + ".*" + std::string{feature.name};
EXPECT_THAT(internalOptions, ::testing::ContainsRegex(expectedRegex));
EXPECT_THAT(internalOptions, ::testing::HasSubstr(std::string{feature.name}));
}
}
TEST_F(OfflineCompilerTests, GoodBuildTest) {

39
opencl/test/unit_test/platform/platform_tests.cpp
View File

@ -208,15 +208,11 @@ TEST(PlatformTestSimple, WhenConvertingCustomOclCFeaturesToCompilerInternalOptio
cl_name_version feature;
strcpy_s(feature.name, CL_NAME_VERSION_MAX_NAME_SIZE, "custom_feature");
customOpenclCFeatures.push_back(feature);
auto compilerOption = convertEnabledOclCFeaturesToCompilerInternalOptions(customOpenclCFeatures);
EXPECT_STREQ(" -cl-feature=+custom_feature ", compilerOption.c_str());
compilerOption = convertEnabledExtensionsToCompilerInternalOptions("", customOpenclCFeatures);
auto compilerOption = convertEnabledExtensionsToCompilerInternalOptions("", customOpenclCFeatures);
EXPECT_STREQ(" -cl-ext=-all,+cl_khr_3d_image_writes,+custom_feature ", compilerOption.c_str());
strcpy_s(feature.name, CL_NAME_VERSION_MAX_NAME_SIZE, "other_extra_feature");
customOpenclCFeatures.push_back(feature);
compilerOption = convertEnabledOclCFeaturesToCompilerInternalOptions(customOpenclCFeatures);
EXPECT_STREQ(" -cl-feature=+custom_feature,+other_extra_feature ", compilerOption.c_str());
compilerOption = convertEnabledExtensionsToCompilerInternalOptions("", customOpenclCFeatures);
EXPECT_STREQ(" -cl-ext=-all,+cl_khr_3d_image_writes,+custom_feature,+other_extra_feature ", compilerOption.c_str());
}
@ -225,32 +221,17 @@ TEST(PlatformTestSimple, WhenConvertingOclCFeaturesToCompilerInternalOptionsThen
UltClDeviceFactory deviceFactory{1, 0};
auto pClDevice = deviceFactory.rootDevices[0];
{
std::string expectedCompilerOption = " -cl-feature=";
for (auto &openclCFeature : pClDevice->deviceInfo.openclCFeatures) {
expectedCompilerOption += "+";
expectedCompilerOption += openclCFeature.name;
expectedCompilerOption += ",";
}
expectedCompilerOption.erase(expectedCompilerOption.size() - 1, 1);
expectedCompilerOption += " ";
auto compilerOption = convertEnabledOclCFeaturesToCompilerInternalOptions(pClDevice->deviceInfo.openclCFeatures);
EXPECT_STREQ(expectedCompilerOption.c_str(), compilerOption.c_str());
std::string expectedCompilerOption = " -cl-ext=-all,+cl_khr_3d_image_writes,";
for (auto &openclCFeature : pClDevice->deviceInfo.openclCFeatures) {
expectedCompilerOption += "+";
expectedCompilerOption += openclCFeature.name;
expectedCompilerOption += ",";
}
{
std::string expectedCompilerOption = " -cl-ext=-all,+cl_khr_3d_image_writes,";
for (auto &openclCFeature : pClDevice->deviceInfo.openclCFeatures) {
expectedCompilerOption += "+";
expectedCompilerOption += openclCFeature.name;
expectedCompilerOption += ",";
}
expectedCompilerOption.erase(expectedCompilerOption.size() - 1, 1);
expectedCompilerOption += " ";
expectedCompilerOption.erase(expectedCompilerOption.size() - 1, 1);
expectedCompilerOption += " ";
auto compilerOption = convertEnabledExtensionsToCompilerInternalOptions("", pClDevice->deviceInfo.openclCFeatures);
EXPECT_STREQ(expectedCompilerOption.c_str(), compilerOption.c_str());
}
auto compilerOption = convertEnabledExtensionsToCompilerInternalOptions("", pClDevice->deviceInfo.openclCFeatures);
EXPECT_STREQ(expectedCompilerOption.c_str(), compilerOption.c_str());
}
namespace NEO {

55
opencl/test/unit_test/program/program_tests.cpp
View File

@ -783,19 +783,22 @@ TEST_P(ProgramFromSourceTest, CreateWithSource_Build_Options_Duplicate) {
EXPECT_EQ(CL_SUCCESS, retVal);
}
TEST_P(ProgramFromSourceTest, WhenBuildingProgramThenFeaturesOptionIsNotAdded) {
TEST_P(ProgramFromSourceTest, WhenBuildingProgramThenFeaturesAreNotAdded) {
auto cip = new MockCompilerInterfaceCaptureBuildOptions();
auto pClDevice = pContext->getDevice(0);
pClDevice->getExecutionEnvironment()->rootDeviceEnvironments[pClDevice->getRootDeviceIndex()]->compilerInterface.reset(cip);
auto featuresOption = static_cast<ClDevice *>(devices[0])->peekCompilerFeatures();
auto extensionsOption = static_cast<ClDevice *>(devices[0])->peekCompilerExtensions();
auto extensionsWithFeaturesOption = static_cast<ClDevice *>(devices[0])->peekCompilerExtensionsWithFeatures();
EXPECT_THAT(cip->buildInternalOptions, testing::Not(testing::HasSubstr(extensionsOption)));
EXPECT_THAT(cip->buildInternalOptions, testing::Not(testing::HasSubstr(extensionsWithFeaturesOption)));
retVal = pProgram->build(pProgram->getDevices(), nullptr, false);
EXPECT_THAT(cip->buildInternalOptions, testing::Not(testing::HasSubstr(featuresOption)));
EXPECT_THAT(cip->buildInternalOptions, testing::HasSubstr(extensionsOption));
EXPECT_THAT(cip->buildInternalOptions, testing::Not(testing::HasSubstr(extensionsWithFeaturesOption)));
}
TEST_P(ProgramFromSourceTest, WhenBuildingProgramWithOpenClC30ThenFeaturesOptionIsAdded) {
auto featuresOption = static_cast<ClDevice *>(devices[0])->peekCompilerFeatures();
TEST_P(ProgramFromSourceTest, WhenBuildingProgramWithOpenClC30ThenFeaturesAreAdded) {
auto cip = new MockCompilerInterfaceCaptureBuildOptions();
auto pClDevice = pContext->getDevice(0);
pClDevice->getExecutionEnvironment()->rootDeviceEnvironments[pClDevice->getRootDeviceIndex()]->compilerInterface.reset(cip);
@ -805,13 +808,19 @@ TEST_P(ProgramFromSourceTest, WhenBuildingProgramWithOpenClC30ThenFeaturesOption
MockProgram::initInternalOptionsCalled = 0;
auto extensionsOption = static_cast<ClDevice *>(devices[0])->peekCompilerExtensions();
auto extensionsWithFeaturesOption = static_cast<ClDevice *>(devices[0])->peekCompilerExtensionsWithFeatures();
EXPECT_THAT(cip->buildInternalOptions, testing::Not(testing::HasSubstr(extensionsOption)));
EXPECT_THAT(cip->buildInternalOptions, testing::Not(testing::HasSubstr(extensionsWithFeaturesOption)));
retVal = pProgram->build(pProgram->getDevices(), "-cl-std=CL3.0", false);
EXPECT_EQ(CL_SUCCESS, retVal);
EXPECT_THAT(cip->buildInternalOptions, testing::HasSubstr(featuresOption));
EXPECT_THAT(cip->buildInternalOptions, testing::Not(testing::HasSubstr(extensionsOption)));
EXPECT_THAT(cip->buildInternalOptions, testing::HasSubstr(extensionsWithFeaturesOption));
EXPECT_EQ(1, MockProgram::initInternalOptionsCalled);
}
TEST_P(ProgramFromSourceTest, WhenBuildingProgramWithOpenClC30ThenFeaturesOptionIsAddedOnlyOnce) {
TEST_P(ProgramFromSourceTest, WhenBuildingProgramWithOpenClC30ThenFeaturesAreAddedOnlyOnce) {
auto cip = new MockCompilerInterfaceCaptureBuildOptions();
auto pClDevice = pContext->getDevice(0);
pClDevice->getExecutionEnvironment()->rootDeviceEnvironments[pClDevice->getRootDeviceIndex()]->compilerInterface.reset(cip);
@ -824,30 +833,33 @@ TEST_P(ProgramFromSourceTest, WhenBuildingProgramWithOpenClC30ThenFeaturesOption
retVal = pProgram->build(pProgram->getDevices(), "-cl-std=CL3.0", false);
EXPECT_EQ(CL_SUCCESS, retVal);
auto expectedFeaturesOption = static_cast<ClDevice *>(devices[0])->peekCompilerFeatures();
auto extensionsWithFeaturesOption = pClDevice->peekCompilerExtensionsWithFeatures();
auto &internalOptions = cip->buildInternalOptions;
auto pos = internalOptions.find(expectedFeaturesOption);
auto pos = internalOptions.find(extensionsWithFeaturesOption);
EXPECT_NE(std::string::npos, pos);
pos = internalOptions.find(expectedFeaturesOption, pos + 1);
pos = internalOptions.find(extensionsWithFeaturesOption, pos + 1);
EXPECT_EQ(std::string::npos, pos);
}
TEST_P(ProgramFromSourceTest, WhenCompilingProgramThenFeaturesOptionIsNotAdded) {
TEST_P(ProgramFromSourceTest, WhenCompilingProgramThenFeaturesAreNotAdded) {
auto pCompilerInterface = new MockCompilerInterfaceCaptureBuildOptions();
auto pClDevice = static_cast<ClDevice *>(devices[0]);
pClDevice->getExecutionEnvironment()->rootDeviceEnvironments[pClDevice->getRootDeviceIndex()]->compilerInterface.reset(pCompilerInterface);
auto featuresOption = pClDevice->peekCompilerFeatures();
EXPECT_THAT(pCompilerInterface->buildInternalOptions, testing::Not(testing::HasSubstr(featuresOption)));
auto extensionsOption = pClDevice->peekCompilerExtensions();
auto extensionsWithFeaturesOption = pClDevice->peekCompilerExtensionsWithFeatures();
EXPECT_THAT(pCompilerInterface->buildInternalOptions, testing::Not(testing::HasSubstr(extensionsOption)));
EXPECT_THAT(pCompilerInterface->buildInternalOptions, testing::Not(testing::HasSubstr(extensionsWithFeaturesOption)));
MockProgram::initInternalOptionsCalled = 0;
retVal = pProgram->compile(pProgram->getDevices(), nullptr, 0, nullptr, nullptr);
EXPECT_EQ(CL_SUCCESS, retVal);
EXPECT_THAT(pCompilerInterface->buildInternalOptions, testing::Not(testing::HasSubstr(featuresOption)));
EXPECT_THAT(pCompilerInterface->buildInternalOptions, testing::HasSubstr(extensionsOption));
EXPECT_THAT(pCompilerInterface->buildInternalOptions, testing::Not(testing::HasSubstr(extensionsWithFeaturesOption)));
EXPECT_EQ(1, MockProgram::initInternalOptionsCalled);
}
TEST_P(ProgramFromSourceTest, WhenCompilingProgramWithOpenClC30ThenFeaturesOptionIsAdded) {
TEST_P(ProgramFromSourceTest, WhenCompilingProgramWithOpenClC30ThenFeaturesAreAdded) {
auto pCompilerInterface = new MockCompilerInterfaceCaptureBuildOptions();
auto pClDevice = pContext->getDevice(0);
pClDevice->getExecutionEnvironment()->rootDeviceEnvironments[pClDevice->getRootDeviceIndex()]->compilerInterface.reset(pCompilerInterface);
@ -855,12 +867,15 @@ TEST_P(ProgramFromSourceTest, WhenCompilingProgramWithOpenClC30ThenFeaturesOptio
pProgram->sourceCode = "__kernel mock() {}";
pProgram->createdFrom = Program::CreatedFrom::SOURCE;
auto featuresOption = pClDevice->peekCompilerFeatures();
EXPECT_THAT(pCompilerInterface->buildInternalOptions, testing::Not(testing::HasSubstr(featuresOption)));
auto extensionsOption = pClDevice->peekCompilerExtensions();
auto extensionsWithFeaturesOption = pClDevice->peekCompilerExtensionsWithFeatures();
EXPECT_THAT(pCompilerInterface->buildInternalOptions, testing::Not(testing::HasSubstr(extensionsOption)));
EXPECT_THAT(pCompilerInterface->buildInternalOptions, testing::Not(testing::HasSubstr(extensionsWithFeaturesOption)));
retVal = pProgram->compile(pProgram->getDevices(), "-cl-std=CL3.0", 0, nullptr, nullptr);
EXPECT_EQ(CL_SUCCESS, retVal);
EXPECT_THAT(pCompilerInterface->buildInternalOptions, testing::HasSubstr(featuresOption));
EXPECT_THAT(pCompilerInterface->buildInternalOptions, testing::Not(testing::HasSubstr(extensionsOption)));
EXPECT_THAT(pCompilerInterface->buildInternalOptions, testing::HasSubstr(extensionsWithFeaturesOption));
}
class Callback {
@ -3046,4 +3061,4 @@ TEST(BuildProgramTest, givenMultiDeviceProgramWhenBuildingThenStoreAndProcessBin
retVal = clReleaseProgram(pProgram);
EXPECT_EQ(CL_SUCCESS, retVal);
}
}

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

@ -593,9 +593,7 @@ int OfflineCompiler::parseCommandLine(size_t numArgs, const std::vector<std::str
OpenClCFeaturesContainer openclCFeatures;
getOpenclCFeaturesList(hwInfo, openclCFeatures);
auto compilerExtensions = convertEnabledExtensionsToCompilerInternalOptions(extensionsList.c_str(), openclCFeatures);
auto compilerFeatures = convertEnabledOclCFeaturesToCompilerInternalOptions(openclCFeatures);
CompilerOptions::concatenateAppend(internalOptions, compilerExtensions);
CompilerOptions::concatenateAppend(internalOptions, compilerFeatures);
} else {
OpenClCFeaturesContainer emptyOpenClCFeatures;
auto compilerExtensions = convertEnabledExtensionsToCompilerInternalOptions(extensionsList.c_str(), emptyOpenClCFeatures);