Add options when building the program

Report "-ocl-version=300" when OCL 3.0 is enabled.
Report "-cl-feature=" with list of supported features.

Related-To: NEO-4368

Change-Id: I9aee559ed53541a0f0c1a2a004926d9d29a53d94
Signed-off-by: Filip Hazubski <filip.hazubski@intel.com>

opencl/source/cl_device/cl_device.cpp

@@ -30,6 +30,7 @@ ClDevice::ClDevice(Device &device, Platform *platform) : device(device), platfor
     driverInfo.reset(DriverInfo::create(&device.getHardwareInfo(), osInterface));
     initializeCaps();
     compilerExtensions = convertEnabledExtensionsToCompilerInternalOptions(deviceInfo.deviceExtensions);
+    compilerFeatures = convertEnabledOclCFeaturesToCompilerInternalOptions(deviceInfo.openclCFeatures);
 
     auto numAvailableDevices = device.getNumAvailableDevices();
     if (numAvailableDevices > 1) {
@@ -172,6 +173,9 @@ void ClDeviceVector::toDeviceIDs(std::vector<cl_device_id> &devIDs) {
 const std::string &ClDevice::peekCompilerExtensions() const {
     return compilerExtensions;
 }
+const std::string &ClDevice::peekCompilerFeatures() const {
+    return compilerFeatures;
+}
 DeviceBitfield ClDevice::getDeviceBitfield() const {
     return device.getDeviceBitfield();
 }

opencl/source/cl_device/cl_device.h

@@ -116,6 +116,7 @@ class ClDevice : public BaseObject<_cl_device_id> {
     const DeviceInfo &getSharedDeviceInfo() const;
     ClDevice *getDeviceById(uint32_t deviceId);
     const std::string &peekCompilerExtensions() const;
+    const std::string &peekCompilerFeatures() const;
     std::unique_ptr<SyncBufferHandler> syncBufferHandler;
     DeviceBitfield getDeviceBitfield() const;
     bool isDeviceEnqueueSupported() const;
@@ -125,7 +126,6 @@ class ClDevice : public BaseObject<_cl_device_id> {
     void initializeCaps();
     void initializeExtensionsWithVersion();
     void initializeOpenclCAllVersions();
-    void initializeOpenclCFeatures();
     void initializeOsSpecificCaps();
     void setupFp64Flags();
 
@@ -145,6 +145,7 @@ class ClDevice : public BaseObject<_cl_device_id> {
 
     std::vector<unsigned int> simultaneousInterops = {0};
     std::string compilerExtensions;
+    std::string compilerFeatures;
 };
 
 } // namespace NEO

opencl/source/cl_device/cl_device_caps.cpp

@@ -392,7 +392,7 @@ void ClDevice::initializeCaps() {
     }
 
     initializeOsSpecificCaps();
-    initializeOpenclCFeatures();
+    getOpenclCFeaturesList(hwInfo, deviceInfo.openclCFeatures);
 }
 
 void ClDevice::initializeExtensionsWithVersion() {
@@ -430,56 +430,4 @@ void ClDevice::initializeOpenclCAllVersions() {
     }
 }
 
-void ClDevice::initializeOpenclCFeatures() {
-    auto &hwInfo = getHardwareInfo();
-    cl_name_version openClCFeature;
-    openClCFeature.version = CL_MAKE_VERSION(3, 0, 0);
-
-    strcpy_s(openClCFeature.name, CL_NAME_VERSION_MAX_NAME_SIZE, "__opencl_c_atomic_order_acq_rel");
-    deviceInfo.openclCFeatures.push_back(openClCFeature);
-
-    if (hwInfo.capabilityTable.supportsImages) {
-        strcpy_s(openClCFeature.name, CL_NAME_VERSION_MAX_NAME_SIZE, "__opencl_c_3d_image_writes");
-        deviceInfo.openclCFeatures.push_back(openClCFeature);
-    }
-
-    if (hwInfo.capabilityTable.supportsOcl21Features) {
-        strcpy_s(openClCFeature.name, CL_NAME_VERSION_MAX_NAME_SIZE, "__opencl_c_atomic_order_seq_cst");
-        deviceInfo.openclCFeatures.push_back(openClCFeature);
-
-        strcpy_s(openClCFeature.name, CL_NAME_VERSION_MAX_NAME_SIZE, "__opencl_c_atomic_scope_all_devices");
-        deviceInfo.openclCFeatures.push_back(openClCFeature);
-
-        strcpy_s(openClCFeature.name, CL_NAME_VERSION_MAX_NAME_SIZE, "__opencl_c_atomic_scope_device");
-        deviceInfo.openclCFeatures.push_back(openClCFeature);
-
-        strcpy_s(openClCFeature.name, CL_NAME_VERSION_MAX_NAME_SIZE, "__opencl_c_generic_address_space");
-        deviceInfo.openclCFeatures.push_back(openClCFeature);
-
-        strcpy_s(openClCFeature.name, CL_NAME_VERSION_MAX_NAME_SIZE, "__opencl_c_program_scope_global_variables");
-        deviceInfo.openclCFeatures.push_back(openClCFeature);
-
-        strcpy_s(openClCFeature.name, CL_NAME_VERSION_MAX_NAME_SIZE, "__opencl_c_read_write_images");
-        deviceInfo.openclCFeatures.push_back(openClCFeature);
-
-        strcpy_s(openClCFeature.name, CL_NAME_VERSION_MAX_NAME_SIZE, "__opencl_c_work_group_collective_functions");
-        deviceInfo.openclCFeatures.push_back(openClCFeature);
-
-        if (hwInfo.capabilityTable.supportsIndependentForwardProgress) {
-            strcpy_s(openClCFeature.name, CL_NAME_VERSION_MAX_NAME_SIZE, "__opencl_c_subgroups");
-            deviceInfo.openclCFeatures.push_back(openClCFeature);
-        }
-    }
-
-    if (hwInfo.capabilityTable.supportsDeviceEnqueue) {
-        strcpy_s(openClCFeature.name, CL_NAME_VERSION_MAX_NAME_SIZE, "__opencl_c_device_enqueue");
-        deviceInfo.openclCFeatures.push_back(openClCFeature);
-    }
-
-    if (hwInfo.capabilityTable.supportsPipes) {
-        strcpy_s(openClCFeature.name, CL_NAME_VERSION_MAX_NAME_SIZE, "__opencl_c_pipes");
-        deviceInfo.openclCFeatures.push_back(openClCFeature);
-    }
-}
-
 } // namespace NEO

opencl/source/platform/extensions.cpp

@@ -8,6 +8,7 @@
 #include "opencl/source/platform/extensions.h"
 
 #include "shared/source/helpers/hw_info.h"
+#include "shared/source/helpers/string.h"
 
 #include <string>
 
@@ -71,6 +72,57 @@ std::string getExtensionsList(const HardwareInfo &hwInfo) {
     return allExtensionsList;
 }
 
+void getOpenclCFeaturesList(const HardwareInfo &hwInfo, StackVec<cl_name_version, 12> &openclCFeatures) {
+    cl_name_version openClCFeature;
+    openClCFeature.version = CL_MAKE_VERSION(3, 0, 0);
+
+    strcpy_s(openClCFeature.name, CL_NAME_VERSION_MAX_NAME_SIZE, "__opencl_c_atomic_order_acq_rel");
+    openclCFeatures.push_back(openClCFeature);
+
+    if (hwInfo.capabilityTable.supportsImages) {
+        strcpy_s(openClCFeature.name, CL_NAME_VERSION_MAX_NAME_SIZE, "__opencl_c_3d_image_writes");
+        openclCFeatures.push_back(openClCFeature);
+    }
+
+    if (hwInfo.capabilityTable.supportsOcl21Features) {
+        strcpy_s(openClCFeature.name, CL_NAME_VERSION_MAX_NAME_SIZE, "__opencl_c_atomic_order_seq_cst");
+        openclCFeatures.push_back(openClCFeature);
+
+        strcpy_s(openClCFeature.name, CL_NAME_VERSION_MAX_NAME_SIZE, "__opencl_c_atomic_scope_all_devices");
+        openclCFeatures.push_back(openClCFeature);
+
+        strcpy_s(openClCFeature.name, CL_NAME_VERSION_MAX_NAME_SIZE, "__opencl_c_atomic_scope_device");
+        openclCFeatures.push_back(openClCFeature);
+
+        strcpy_s(openClCFeature.name, CL_NAME_VERSION_MAX_NAME_SIZE, "__opencl_c_generic_address_space");
+        openclCFeatures.push_back(openClCFeature);
+
+        strcpy_s(openClCFeature.name, CL_NAME_VERSION_MAX_NAME_SIZE, "__opencl_c_program_scope_global_variables");
+        openclCFeatures.push_back(openClCFeature);
+
+        strcpy_s(openClCFeature.name, CL_NAME_VERSION_MAX_NAME_SIZE, "__opencl_c_read_write_images");
+        openclCFeatures.push_back(openClCFeature);
+
+        strcpy_s(openClCFeature.name, CL_NAME_VERSION_MAX_NAME_SIZE, "__opencl_c_work_group_collective_functions");
+        openclCFeatures.push_back(openClCFeature);
+
+        if (hwInfo.capabilityTable.supportsIndependentForwardProgress) {
+            strcpy_s(openClCFeature.name, CL_NAME_VERSION_MAX_NAME_SIZE, "__opencl_c_subgroups");
+            openclCFeatures.push_back(openClCFeature);
+        }
+    }
+
+    if (hwInfo.capabilityTable.supportsDeviceEnqueue) {
+        strcpy_s(openClCFeature.name, CL_NAME_VERSION_MAX_NAME_SIZE, "__opencl_c_device_enqueue");
+        openclCFeatures.push_back(openClCFeature);
+    }
+
+    if (hwInfo.capabilityTable.supportsPipes) {
+        strcpy_s(openClCFeature.name, CL_NAME_VERSION_MAX_NAME_SIZE, "__opencl_c_pipes");
+        openclCFeatures.push_back(openClCFeature);
+    }
+}
+
 std::string removeLastSpace(std::string &processedString) {
     if (processedString.size() > 0) {
         if (*processedString.rbegin() == ' ') {
@@ -93,4 +145,18 @@ std::string convertEnabledExtensionsToCompilerInternalOptions(const char *enable
     return extensionsList;
 }
 
+std::string convertEnabledOclCFeaturesToCompilerInternalOptions(StackVec<cl_name_version, 12> &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

opencl/source/platform/extensions.h

@@ -8,6 +8,9 @@
 #pragma once
 
 #include "shared/source/helpers/hw_info.h"
+#include "shared/source/utilities/stackvec.h"
+
+#include "CL/cl.h"
 
 #include <string>
 
@@ -18,7 +21,9 @@ constexpr const char *const sharingFormatQuery = "cl_intel_sharing_format_query
 extern const char *deviceExtensionsList;
 
 std::string getExtensionsList(const HardwareInfo &hwInfo);
+void getOpenclCFeaturesList(const HardwareInfo &hwInfo, StackVec<cl_name_version, 12> &openclCFeatures);
 std::string removeLastSpace(std::string &s);
 std::string convertEnabledExtensionsToCompilerInternalOptions(const char *deviceExtensions);
+std::string convertEnabledOclCFeaturesToCompilerInternalOptions(StackVec<cl_name_version, 12> &openclCFeatures);
 
 } // namespace NEO

opencl/source/program/build.cpp

@@ -105,6 +105,10 @@ cl_int Program::build(
             if (internalOptions.find(compilerExtensionsOptions) == std::string::npos) {
                 CompilerOptions::concatenateAppend(internalOptions, compilerExtensionsOptions);
             }
+            auto compilerFeaturesOptions = clDevice->peekCompilerFeatures();
+            if (internalOptions.find(compilerFeaturesOptions) == std::string::npos) {
+                CompilerOptions::concatenateAppend(internalOptions, compilerFeaturesOptions);
+            }
 
             inputArgs.apiOptions = ArrayRef<const char>(options.c_str(), options.length());
             inputArgs.internalOptions = ArrayRef<const char>(internalOptions.c_str(), internalOptions.length());

opencl/source/program/compile.cpp

@@ -133,6 +133,8 @@ cl_int Program::compile(
         UNRECOVERABLE_IF(clDevice == nullptr);
         auto compilerExtensionsOptions = clDevice->peekCompilerExtensions();
         CompilerOptions::concatenateAppend(internalOptions, compilerExtensionsOptions);
+        auto compilerFeaturesOptions = clDevice->peekCompilerFeatures();
+        CompilerOptions::concatenateAppend(internalOptions, compilerFeaturesOptions);
 
         if (isKernelDebugEnabled()) {
             std::string filename;

opencl/source/program/program.cpp

@@ -63,8 +63,10 @@ Program::Program(ExecutionEnvironment &executionEnvironment, Context *context, b
     bool force32BitAddressess = false;
 
     if (pClDevice) {
-        auto areOcl21FeaturesEnabled = pClDevice->areOcl21FeaturesEnabled();
+        auto enabledClVersion = pClDevice->getEnabledClVersion();
-        if (areOcl21FeaturesEnabled) {
+        if (enabledClVersion == 30) {
+            internalOptions = "-ocl-version=300 ";
+        } else if (enabledClVersion == 21) {
             internalOptions = "-ocl-version=210 ";
         } else {
             internalOptions = "-ocl-version=120 ";

opencl/test/unit_test/device/device_caps_tests.cpp

@@ -13,6 +13,7 @@
 #include "shared/test/unit_test/mocks/mock_device.h"
 
 #include "opencl/source/memory_manager/os_agnostic_memory_manager.h"
+#include "opencl/source/platform/extensions.h"
 #include "opencl/test/unit_test/helpers/hw_helper_tests.h"
 #include "opencl/test/unit_test/mocks/mock_builtins.h"
 #include "opencl/test/unit_test/mocks/mock_execution_environment.h"
@@ -1029,6 +1030,19 @@ TEST(DeviceGetCaps, givenDeviceThatDoesHaveFp64WhenDbgFlagDisablesFp64ThenDontRe
     EXPECT_NE(notExpectedSingleFp, actualSingleFp);
 }
 
+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, givenOclVersionLessThan21WhenCapsAreCreatedThenDeviceReportsNoSupportedIlVersions) {
     DebugManagerStateRestore dbgRestorer;
     {

opencl/test/unit_test/mocks/mock_cl_device.h

@@ -25,6 +25,7 @@ extern CommandStreamReceiver *createCommandStream(ExecutionEnvironment &executio
 class MockClDevice : public ClDevice {
   public:
     using ClDevice::ClDevice;
+    using ClDevice::compilerFeatures;
     using ClDevice::deviceExtensions;
     using ClDevice::deviceInfo;
     using ClDevice::driverInfo;

opencl/test/unit_test/offline_compiler/offline_compiler_tests.cpp

@@ -13,6 +13,7 @@
 #include "shared/source/helpers/hw_info.h"
 #include "shared/test/unit_test/helpers/debug_manager_state_restore.h"
 
+#include "opencl/source/platform/extensions.h"
 #include "opencl/test/unit_test/mocks/mock_compilers.h"
 
 #include "compiler_options.h"
@@ -247,6 +248,11 @@ TEST_F(OfflineCompilerTests, TestExtensions) {
     mockOfflineCompiler->parseCommandLine(argv.size(), argv);
     std::string internalOptions = mockOfflineCompiler->internalOptions;
     EXPECT_THAT(internalOptions, ::testing::HasSubstr(std::string("cl_khr_3d_image_writes")));
+
+    StackVec<cl_name_version, 12> openclCFeatures;
+    getOpenclCFeaturesList(DEFAULT_PLATFORM::hwInfo, openclCFeatures);
+    auto expectedFeaturesOption = convertEnabledOclCFeaturesToCompilerInternalOptions(openclCFeatures);
+    EXPECT_THAT(internalOptions, ::testing::HasSubstr(expectedFeaturesOption));
 }
 TEST_F(OfflineCompilerTests, GoodBuildTest) {
     std::vector<std::string> argv = {

opencl/test/unit_test/platform/platform_tests.cpp

@@ -7,6 +7,7 @@
 
 #include "shared/source/device/device.h"
 #include "shared/source/helpers/hw_info.h"
+#include "shared/source/helpers/string.h"
 #include "shared/source/os_interface/device_factory.h"
 #include "shared/test/unit_test/helpers/debug_manager_state_restore.h"
 #include "shared/test/unit_test/helpers/ult_hw_config.h"
@@ -19,10 +20,12 @@
 #include "opencl/test/unit_test/fixtures/mock_aub_center_fixture.h"
 #include "opencl/test/unit_test/fixtures/platform_fixture.h"
 #include "opencl/test/unit_test/mocks/mock_builtins.h"
+#include "opencl/test/unit_test/mocks/mock_cl_device.h"
 #include "opencl/test/unit_test/mocks/mock_csr.h"
 #include "opencl/test/unit_test/mocks/mock_execution_environment.h"
 #include "opencl/test/unit_test/mocks/mock_platform.h"
 #include "opencl/test/unit_test/mocks/mock_source_level_debugger.h"
+#include "opencl/test/unit_test/mocks/ult_cl_device_factory.h"
 
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
@@ -197,6 +200,38 @@ TEST(PlatformTestSimple, givenNotCsrHwTypeWhenPlatformIsInitializedThenInitAubCe
     EXPECT_TRUE(rootDeviceEnvironment->initAubCenterCalled);
 }
 
+TEST(PlatformTestSimple, WhenConvertingCustomOclCFeaturesToCompilerInternalOptionsThenResultIsCorrect) {
+    StackVec<cl_name_version, 12> customOpenclCFeatures;
+
+    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());
+
+    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());
+}
+
+TEST(PlatformTestSimple, WhenConvertingOclCFeaturesToCompilerInternalOptionsThenResultIsCorrect) {
+    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());
+}
+
 namespace NEO {
 extern CommandStreamReceiverCreateFunc commandStreamReceiverFactory[IGFX_MAX_CORE];
 }

opencl/test/unit_test/program/program_tests.cpp

@@ -863,6 +863,42 @@ TEST_P(ProgramFromSourceTest, CreateWithSource_Build_Options_Duplicate) {
     EXPECT_EQ(CL_SUCCESS, retVal);
 }
 
+TEST_P(ProgramFromSourceTest, WhenBuildingProgramThenFeaturesOptionIsAdded) {
+    auto featuresOption = static_cast<ClDevice *>(devices[0])->peekCompilerFeatures();
+    EXPECT_THAT(pProgram->getInternalOptions(), testing::Not(testing::HasSubstr(featuresOption)));
+
+    retVal = pProgram->build(1, devices, nullptr, nullptr, nullptr, false);
+    EXPECT_EQ(CL_SUCCESS, retVal);
+    EXPECT_THAT(pProgram->getInternalOptions(), testing::HasSubstr(featuresOption));
+}
+
+TEST_P(ProgramFromSourceTest, WhenBuildingProgramThenFeaturesOptionIsAddedOnlyOnce) {
+    retVal = pProgram->build(1, devices, nullptr, nullptr, nullptr, false);
+    EXPECT_EQ(CL_SUCCESS, retVal);
+    retVal = pProgram->build(1, devices, nullptr, nullptr, nullptr, false);
+    EXPECT_EQ(CL_SUCCESS, retVal);
+
+    auto expectedFeaturesOption = static_cast<ClDevice *>(devices[0])->peekCompilerFeatures();
+    auto &internalOptions = pProgram->getInternalOptions();
+    auto pos = internalOptions.find(expectedFeaturesOption);
+    EXPECT_NE(std::string::npos, pos);
+
+    pos = internalOptions.find(expectedFeaturesOption, pos + 1);
+    EXPECT_EQ(std::string::npos, pos);
+}
+
+TEST_P(ProgramFromSourceTest, WhenCompilingProgramThenFeaturesOptionIsAdded) {
+    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)));
+
+    retVal = pProgram->compile(1, devices, nullptr, 0, nullptr, nullptr, nullptr, nullptr);
+    EXPECT_EQ(CL_SUCCESS, retVal);
+    EXPECT_THAT(pCompilerInterface->buildInternalOptions, testing::HasSubstr(featuresOption));
+}
+
 class Callback {
   public:
     Callback() {
@@ -1617,17 +1653,27 @@ TEST_F(ProgramTests, WhenProgramIsCreatedThenCorrectOclVersionIsInOptions) {
     DebugManager.flags.DisableStatelessToStatefulOptimization.set(false);
 
     MockProgram program(*pDevice->getExecutionEnvironment(), pContext, false, pDevice);
-    if (pClDevice->areOcl21FeaturesEnabled()) {
+    if (pClDevice->getEnabledClVersion() == 30) {
+        EXPECT_TRUE(CompilerOptions::contains(program.getInternalOptions(), "-ocl-version=300")) << program.getInternalOptions();
+    } else if (pClDevice->getEnabledClVersion() == 21) {
         EXPECT_TRUE(CompilerOptions::contains(program.getInternalOptions(), "-ocl-version=210")) << program.getInternalOptions();
     } else {
         EXPECT_TRUE(CompilerOptions::contains(program.getInternalOptions(), "-ocl-version=120")) << program.getInternalOptions();
     }
 }
 
-TEST_F(ProgramTests, GivenOcl21FeaturesEnabledWhenProgramIsCreatedThenOcl21IsInOptions) {
+TEST_F(ProgramTests, GivenForcedClVersionWhenProgramIsCreatedThenCorrectOclOptionIsPresent) {
-    pClDevice->ocl21FeaturesEnabled = true;
+    std::pair<unsigned int, std::string> testedValues[] = {
-    MockProgram program(*pDevice->getExecutionEnvironment(), pContext, false, pDevice);
+        {0, "-ocl-version=120"},
-    EXPECT_TRUE(CompilerOptions::contains(program.getInternalOptions(), "-ocl-version=210"));
+        {12, "-ocl-version=120"},
+        {21, "-ocl-version=210"},
+        {30, "-ocl-version=300"}};
+
+    for (auto &testedValue : testedValues) {
+        pClDevice->enabledClVersion = testedValue.first;
+        MockProgram program{*pDevice->getExecutionEnvironment(), pContext, false, pDevice};
+        EXPECT_TRUE(CompilerOptions::contains(program.getInternalOptions(), testedValue.second));
+    }
 }
 
 TEST_F(ProgramTests, GivenStatelessToStatefulIsDisabledWhenProgramIsCreatedThenGreaterThan4gbBuffersRequiredOptionIsSet) {
@@ -1635,13 +1681,7 @@ TEST_F(ProgramTests, GivenStatelessToStatefulIsDisabledWhenProgramIsCreatedThenG
     DebugManager.flags.DisableStatelessToStatefulOptimization.set(true);
 
     MockProgram program(*pDevice->getExecutionEnvironment(), pContext, false, pDevice);
-    if (pClDevice->areOcl21FeaturesEnabled()) {
+    EXPECT_TRUE(CompilerOptions::contains(program.getInternalOptions(), NEO::CompilerOptions::greaterThan4gbBuffersRequired));
-        EXPECT_TRUE(CompilerOptions::contains(program.getInternalOptions(), "-ocl-version=210")) << program.getInternalOptions();
-        EXPECT_TRUE(CompilerOptions::contains(program.getInternalOptions(), NEO::CompilerOptions::greaterThan4gbBuffersRequired));
-    } else {
-        EXPECT_TRUE(CompilerOptions::contains(program.getInternalOptions(), "-ocl-version=120")) << program.getInternalOptions();
-        EXPECT_TRUE(CompilerOptions::contains(program.getInternalOptions(), NEO::CompilerOptions::greaterThan4gbBuffersRequired));
-    }
 }
 
 TEST_F(ProgramTests, WhenCreatingProgramThenBindlessIsEnabledOnlyIfDebugFlagIsEnabled) {
@@ -1695,11 +1735,6 @@ TEST_F(ProgramTests, GivenForce32BitAddressessWhenProgramIsCreatedThenGreaterTha
     if (pDevice) {
         const_cast<DeviceInfo *>(&pDevice->getDeviceInfo())->force32BitAddressess = true;
         MockProgram program(*pDevice->getExecutionEnvironment(), pContext, false, pDevice);
-        if (pClDevice->areOcl21FeaturesEnabled()) {
-            EXPECT_TRUE(CompilerOptions::contains(program.getInternalOptions(), "-ocl-version=210")) << program.getInternalOptions();
-        } else {
-            EXPECT_TRUE(CompilerOptions::contains(program.getInternalOptions(), "-ocl-version=120")) << program.getInternalOptions();
-        }
         if (pDevice->areSharedSystemAllocationsAllowed()) {
             EXPECT_TRUE(CompilerOptions::contains(program.getInternalOptions(), CompilerOptions::greaterThan4gbBuffersRequired)) << program.getInternalOptions();
         } else {

shared/offline_compiler/source/CMakeLists.txt

@@ -10,21 +10,27 @@ set(OCLOC_NAME "ocloc")
 set(OCLOC_FOLDER_NAME "offline_compiler")
 
 set(CLOC_LIB_SRCS_LIB
+  ${NEO_SHARED_DIRECTORY}/compiler_interface/compiler_options/compiler_options_base.cpp
+  ${NEO_SHARED_DIRECTORY}/compiler_interface/create_main.cpp
   ${NEO_SHARED_DIRECTORY}/device_binary_format/ar/ar.h
-  ${NEO_SHARED_DIRECTORY}/device_binary_format/ar/ar_decoder.h
   ${NEO_SHARED_DIRECTORY}/device_binary_format/ar/ar_decoder.cpp
-  ${NEO_SHARED_DIRECTORY}/device_binary_format/ar/ar_encoder.h
+  ${NEO_SHARED_DIRECTORY}/device_binary_format/ar/ar_decoder.h
   ${NEO_SHARED_DIRECTORY}/device_binary_format/ar/ar_encoder.cpp
+  ${NEO_SHARED_DIRECTORY}/device_binary_format/ar/ar_encoder.h
   ${NEO_SHARED_DIRECTORY}/device_binary_format/elf/elf.h
-  ${NEO_SHARED_DIRECTORY}/device_binary_format/elf/elf_decoder.h
   ${NEO_SHARED_DIRECTORY}/device_binary_format/elf/elf_decoder.cpp
-  ${NEO_SHARED_DIRECTORY}/device_binary_format/elf/elf_encoder.h
+  ${NEO_SHARED_DIRECTORY}/device_binary_format/elf/elf_decoder.h
   ${NEO_SHARED_DIRECTORY}/device_binary_format/elf/elf_encoder.cpp
+  ${NEO_SHARED_DIRECTORY}/device_binary_format/elf/elf_encoder.h
   ${NEO_SHARED_DIRECTORY}/device_binary_format/elf/ocl_elf.h
   ${NEO_SHARED_DIRECTORY}/helpers/abort.cpp
   ${NEO_SHARED_DIRECTORY}/helpers/debug_helpers.cpp
   ${NEO_SHARED_DIRECTORY}/helpers/file_io.cpp
+  ${NEO_SHARED_DIRECTORY}/helpers/hw_info.cpp
+  ${NEO_SHARED_DIRECTORY}/helpers/hw_info.h
   ${NEO_SHARED_DIRECTORY}/os_interface/os_library.h
+  ${NEO_SOURCE_DIR}/opencl/source/platform/extensions.cpp
+  ${NEO_SOURCE_DIR}/opencl/source/platform/extensions.h
   ${OCLOC_DIRECTORY}/source/decoder/binary_decoder.cpp
   ${OCLOC_DIRECTORY}/source/decoder/binary_decoder.h
   ${OCLOC_DIRECTORY}/source/decoder/binary_encoder.cpp
@@ -33,24 +39,19 @@ set(CLOC_LIB_SRCS_LIB
   ${OCLOC_DIRECTORY}/source/decoder/helper.h
   ${OCLOC_DIRECTORY}/source/decoder/iga_wrapper.h
   ${OCLOC_DIRECTORY}/source/decoder/translate_platform_base.h
-  ${OCLOC_DIRECTORY}/source/ocloc_api.cpp
+  ${OCLOC_DIRECTORY}/source/${BRANCH_DIR_SUFFIX}/extra_settings.cpp
-  ${OCLOC_DIRECTORY}/source/ocloc_api.h
-  ${OCLOC_DIRECTORY}/source/ocloc_arg_helper.h
-  ${OCLOC_DIRECTORY}/source/ocloc_arg_helper.cpp
-  ${OCLOC_DIRECTORY}/source/ocloc_fatbinary.cpp
-  ${OCLOC_DIRECTORY}/source/ocloc_fatbinary.h
-  ${OCLOC_DIRECTORY}/source/offline_compiler_helper.cpp
-  ${OCLOC_DIRECTORY}/source/offline_compiler.cpp
-  ${OCLOC_DIRECTORY}/source/offline_compiler.h
   ${OCLOC_DIRECTORY}/source/multi_command.cpp
   ${OCLOC_DIRECTORY}/source/multi_command.h
+  ${OCLOC_DIRECTORY}/source/ocloc_api.cpp
+  ${OCLOC_DIRECTORY}/source/ocloc_api.h
+  ${OCLOC_DIRECTORY}/source/ocloc_arg_helper.cpp
+  ${OCLOC_DIRECTORY}/source/ocloc_arg_helper.h
+  ${OCLOC_DIRECTORY}/source/ocloc_fatbinary.cpp
+  ${OCLOC_DIRECTORY}/source/ocloc_fatbinary.h
+  ${OCLOC_DIRECTORY}/source/offline_compiler.cpp
+  ${OCLOC_DIRECTORY}/source/offline_compiler.h
+  ${OCLOC_DIRECTORY}/source/offline_compiler_helper.cpp
   ${OCLOC_DIRECTORY}/source/offline_compiler_options.cpp
-  ${OCLOC_DIRECTORY}/source/${BRANCH_DIR_SUFFIX}/extra_settings.cpp
-  ${NEO_SHARED_DIRECTORY}/compiler_interface/compiler_options/compiler_options_base.cpp
-  ${NEO_SHARED_DIRECTORY}/compiler_interface/create_main.cpp
-  ${NEO_SHARED_DIRECTORY}/helpers/hw_info.cpp
-  ${NEO_SOURCE_DIR}/opencl/source/platform/extensions.cpp
-  ${NEO_SOURCE_DIR}/opencl/source/platform/extensions.h
 )
 
 if(${IGA_HEADERS_AVAILABLE})

shared/offline_compiler/source/offline_compiler.cpp

@@ -527,6 +527,10 @@ int OfflineCompiler::parseCommandLine(size_t numArgs, const std::vector<std::str
             } else {
                 std::string extensionsList = getExtensionsList(*hwInfo);
                 CompilerOptions::concatenateAppend(internalOptions, convertEnabledExtensionsToCompilerInternalOptions(extensionsList.c_str()));
+
+                StackVec<cl_name_version, 12> openclCFeatures;
+                getOpenclCFeaturesList(*hwInfo, openclCFeatures);
+                CompilerOptions::concatenateAppend(internalOptions, convertEnabledOclCFeaturesToCompilerInternalOptions(openclCFeatures));
             }
         }
     }