L0: GRF mode debug flags support

Signed-off-by: Dunajski, Bartosz <bartosz.dunajski@intel.com>

level_zero/core/source/module/module_imp.cpp

@@ -743,6 +743,8 @@ void ModuleImp::createBuildOptions(const char *pBuildFlags, std::string &apiOpti
         moveBuildOption(internalBuildOptions, apiOptions, NEO::CompilerOptions::allowZebin, NEO::CompilerOptions::allowZebin);
         moveBuildOption(internalBuildOptions, apiOptions, NEO::CompilerOptions::largeGrf, BuildOptions::optLargeRegisterFile);
 
+        NEO::CompilerOptions::applyAdditionalOptions(internalBuildOptions);
+
         moveOptLevelOption(apiOptions, apiOptions);
         moveProfileFlagsOption(apiOptions, apiOptions);
         this->libraryExportRequired = moveBuildOption(apiOptions, apiOptions, BuildOptions::enableLibraryCompile, BuildOptions::enableLibraryCompile);

level_zero/core/test/unit_tests/sources/module/test_module_2.cpp

@@ -270,5 +270,61 @@ TEST_F(ModuleOnlineCompiled, GivenKernelThenCorrectAttributesAreReturned) {
     free(attributes);
 }
 
+TEST_F(ModuleTests, givenLargeGrfFlagSetWhenCreatingModuleThenOverrideInternalFlags) {
+    DebugManagerStateRestore restorer;
+    DebugManager.flags.ForceLargeGrfCompilationMode.set(true);
+
+    auto pMockCompilerInterface = new MockCompilerInterface;
+    auto &rootDeviceEnvironment = this->neoDevice->executionEnvironment->rootDeviceEnvironments[this->neoDevice->getRootDeviceIndex()];
+    rootDeviceEnvironment->compilerInterface.reset(pMockCompilerInterface);
+
+    auto zebinData = std::make_unique<ZebinTestData::ZebinWithL0TestCommonModule>(device->getHwInfo());
+    const auto &src = zebinData->storage;
+
+    ze_module_desc_t moduleDesc = {};
+    moduleDesc.format = ZE_MODULE_FORMAT_IL_SPIRV;
+    moduleDesc.pInputModule = src.data();
+    moduleDesc.inputSize = src.size();
+
+    auto mockTranslationUnit = new MockModuleTranslationUnit(device);
+    Module module(device, nullptr, ModuleType::User);
+
+    module.translationUnit.reset(mockTranslationUnit);
+
+    bool success = module.initialize(&moduleDesc, neoDevice);
+    EXPECT_TRUE(success);
+
+    EXPECT_NE(pMockCompilerInterface->inputInternalOptions.find("-cl-intel-256-GRF-per-thread"), std::string::npos);
+    EXPECT_EQ(pMockCompilerInterface->inputInternalOptions.find("-cl-intel-128-GRF-per-thread"), std::string::npos);
+}
+
+TEST_F(ModuleTests, givenDefaultGrfFlagSetWhenCreatingModuleThenOverrideInternalFlags) {
+    DebugManagerStateRestore restorer;
+    DebugManager.flags.ForceDefaultGrfCompilationMode.set(true);
+
+    auto pMockCompilerInterface = new MockCompilerInterface;
+    auto &rootDeviceEnvironment = this->neoDevice->executionEnvironment->rootDeviceEnvironments[this->neoDevice->getRootDeviceIndex()];
+    rootDeviceEnvironment->compilerInterface.reset(pMockCompilerInterface);
+
+    auto zebinData = std::make_unique<ZebinTestData::ZebinWithL0TestCommonModule>(device->getHwInfo());
+    const auto &src = zebinData->storage;
+
+    ze_module_desc_t moduleDesc = {};
+    moduleDesc.format = ZE_MODULE_FORMAT_IL_SPIRV;
+    moduleDesc.pInputModule = src.data();
+    moduleDesc.inputSize = src.size();
+
+    auto mockTranslationUnit = new MockModuleTranslationUnit(device);
+    Module module(device, nullptr, ModuleType::User);
+
+    module.translationUnit.reset(mockTranslationUnit);
+
+    bool success = module.initialize(&moduleDesc, neoDevice);
+    EXPECT_TRUE(success);
+
+    EXPECT_EQ(pMockCompilerInterface->inputInternalOptions.find("-cl-intel-256-GRF-per-thread"), std::string::npos);
+    EXPECT_NE(pMockCompilerInterface->inputInternalOptions.find("-cl-intel-128-GRF-per-thread"), std::string::npos);
+}
+
 } // namespace ult
 } // namespace L0

opencl/source/program/build.cpp

@@ -65,7 +65,7 @@ cl_int Program::build(
 
             const bool shouldSuppressRebuildWarning{CompilerOptions::extract(CompilerOptions::noRecompiledFromIr, options)};
             extractInternalOptions(options, internalOptions);
-            applyAdditionalOptions(internalOptions);
+            CompilerOptions::applyAdditionalOptions(internalOptions);
 
             CompilerInterface *pCompilerInterface = defaultDevice.getCompilerInterface();
             if (!pCompilerInterface) {

opencl/source/program/program.cpp

@@ -498,25 +498,6 @@ void Program::prependFilePathToOptions(const std::string &filename) {
     }
 }
 
-void Program::applyAdditionalOptions(std::string &internalOptions) {
-    size_t pos;
-    if (DebugManager.flags.ForceLargeGrfCompilationMode.get()) {
-        pos = internalOptions.find(CompilerOptions::largeGrf.data());
-        if (pos == std::string::npos) {
-            CompilerOptions::concatenateAppend(internalOptions, CompilerOptions::largeGrf);
-        }
-    } else if (DebugManager.flags.ForceDefaultGrfCompilationMode.get()) {
-        pos = internalOptions.find(CompilerOptions::defaultGrf.data());
-        if (pos == std::string::npos) {
-            CompilerOptions::concatenateAppend(internalOptions, CompilerOptions::defaultGrf.data());
-        }
-        pos = internalOptions.find(CompilerOptions::largeGrf.data());
-        if (pos != std::string::npos) {
-            internalOptions.erase(pos, CompilerOptions::largeGrf.size());
-        }
-    }
-}
-
 const std::vector<ConstStringRef> Program::internalOptionsToExtract = {CompilerOptions::gtpinRera,
                                                                        CompilerOptions::defaultGrf,
                                                                        CompilerOptions::largeGrf,

opencl/source/program/program.h

@@ -305,7 +305,6 @@ class Program : public BaseObject<_cl_program> {
     void extractInternalOptions(const std::string &options, std::string &internalOptions);
     MOCKABLE_VIRTUAL bool isFlagOption(ConstStringRef option);
     MOCKABLE_VIRTUAL bool isOptionValueValid(ConstStringRef option, ConstStringRef value);
-    MOCKABLE_VIRTUAL void applyAdditionalOptions(std::string &internalOptions);
 
     MOCKABLE_VIRTUAL bool appendKernelDebugOptions(ClDevice &clDevice, std::string &internalOptions);
     void notifyDebuggerWithSourceCode(ClDevice &clDevice, std::string &filename);

opencl/test/unit_test/mocks/mock_program.h

@@ -28,7 +28,6 @@ ClDeviceVector toClDeviceVector(ClDevice &clDevice);
 class MockProgram : public Program {
   public:
     using Program::allowNonUniform;
-    using Program::applyAdditionalOptions;
     using Program::areSpecializationConstantsInitialized;
     using Program::buildInfos;
     using Program::context;

opencl/test/unit_test/program/program_tests.cpp

@@ -2693,23 +2693,6 @@ TEST_F(ProgramTests, GivenInjectInternalBuildOptionsWhenCompilingBuiltInProgramT
     EXPECT_FALSE(CompilerOptions::contains(cip->buildInternalOptions, "-abc")) << cip->buildInternalOptions;
 }
 
-class AdditionalOptionsMockProgram : public MockProgram {
-  public:
-    using MockProgram::MockProgram;
-    void applyAdditionalOptions(std::string &internalOptions) override {
-        applyAdditionalOptionsCalled++;
-        MockProgram::applyAdditionalOptions(internalOptions);
-    }
-    uint32_t applyAdditionalOptionsCalled = 0;
-};
-
-TEST_F(ProgramTests, givenProgramWhenBuiltThenAdditionalOptionsAreApplied) {
-    AdditionalOptionsMockProgram program(toClDeviceVector(*pClDevice));
-
-    program.build(program.getDevices(), nullptr, false);
-    EXPECT_EQ(1u, program.applyAdditionalOptionsCalled);
-}
-
 TEST(CreateProgramFromBinaryTests, givenBinaryProgramBuiltInWhenKernelRebulildIsForcedThenDeviceBinaryIsNotUsed) {
     DebugManagerStateRestore dbgRestorer;
     DebugManager.flags.RebuildPrecompiledKernels.set(true);
@@ -3368,11 +3351,11 @@ TEST(ProgramInternalOptionsTests, givenProgramWhenForceLargeGrfCompilationModeIs
     MockProgram program(toClDeviceVector(device));
     auto internalOptions = program.getInternalOptions();
     EXPECT_FALSE(CompilerOptions::contains(internalOptions, CompilerOptions::largeGrf)) << internalOptions;
-    program.applyAdditionalOptions(internalOptions);
+    CompilerOptions::applyAdditionalOptions(internalOptions);
     EXPECT_TRUE(CompilerOptions::contains(internalOptions, CompilerOptions::largeGrf)) << internalOptions;
 
     size_t internalOptionsSize = internalOptions.size();
-    program.applyAdditionalOptions(internalOptions);
+    CompilerOptions::applyAdditionalOptions(internalOptions);
     EXPECT_EQ(internalOptionsSize, internalOptions.size());
 }
 
@@ -3384,11 +3367,11 @@ TEST(ProgramInternalOptionsTests, givenProgramWhenForceDefaultGrfCompilationMode
     MockProgram program(toClDeviceVector(device));
     auto internalOptions = program.getInternalOptions();
     EXPECT_FALSE(CompilerOptions::contains(internalOptions, CompilerOptions::defaultGrf)) << internalOptions;
-    program.applyAdditionalOptions(internalOptions);
+    CompilerOptions::applyAdditionalOptions(internalOptions);
     EXPECT_TRUE(CompilerOptions::contains(internalOptions, CompilerOptions::defaultGrf)) << internalOptions;
 
     size_t internalOptionsSize = internalOptions.size();
-    program.applyAdditionalOptions(internalOptions);
+    CompilerOptions::applyAdditionalOptions(internalOptions);
     EXPECT_EQ(internalOptionsSize, internalOptions.size());
 }
 
@@ -3403,11 +3386,11 @@ TEST(ProgramInternalOptionsTests, givenProgramWhenForceDefaultGrfCompilationMode
     EXPECT_FALSE(CompilerOptions::contains(internalOptions, CompilerOptions::defaultGrf)) << internalOptions;
     EXPECT_TRUE(CompilerOptions::contains(internalOptions, CompilerOptions::largeGrf)) << internalOptions;
 
-    program.applyAdditionalOptions(internalOptions);
+    CompilerOptions::applyAdditionalOptions(internalOptions);
     EXPECT_TRUE(CompilerOptions::contains(internalOptions, CompilerOptions::defaultGrf)) << internalOptions;
     EXPECT_FALSE(CompilerOptions::contains(internalOptions, CompilerOptions::largeGrf)) << internalOptions;
 
     size_t internalOptionsSize = internalOptions.size();
-    program.applyAdditionalOptions(internalOptions);
+    CompilerOptions::applyAdditionalOptions(internalOptions);
     EXPECT_EQ(internalOptionsSize, internalOptions.size());
 }

shared/source/compiler_interface/compiler_options.cpp

@@ -7,6 +7,8 @@
 
 #include "shared/source/compiler_interface/compiler_options.h"
 
+#include "shared/source/debug_settings/debug_settings_manager.h"
+
 #include <cstring>
 
 namespace NEO {
@@ -50,5 +52,24 @@ TokenizedString tokenize(ConstStringRef src, char sperator) {
     return ret;
 };
 
+void applyAdditionalOptions(std::string &internalOptions) {
+    size_t pos;
+    if (DebugManager.flags.ForceLargeGrfCompilationMode.get()) {
+        pos = internalOptions.find(CompilerOptions::largeGrf.data());
+        if (pos == std::string::npos) {
+            CompilerOptions::concatenateAppend(internalOptions, CompilerOptions::largeGrf);
+        }
+    } else if (DebugManager.flags.ForceDefaultGrfCompilationMode.get()) {
+        pos = internalOptions.find(CompilerOptions::defaultGrf.data());
+        if (pos == std::string::npos) {
+            CompilerOptions::concatenateAppend(internalOptions, CompilerOptions::defaultGrf.data());
+        }
+        pos = internalOptions.find(CompilerOptions::largeGrf.data());
+        if (pos != std::string::npos) {
+            internalOptions.erase(pos, CompilerOptions::largeGrf.size());
+        }
+    }
+}
+
 } // namespace CompilerOptions
 } // namespace NEO

shared/source/compiler_interface/compiler_options.h

@@ -179,5 +179,7 @@ bool contains(const std::string &options, ConstStringRef optionToFind);
 
 using TokenizedString = StackVec<ConstStringRef, 32>;
 TokenizedString tokenize(ConstStringRef src, char sperator = ' ');
+
+void applyAdditionalOptions(std::string &internalOptions);
 } // namespace CompilerOptions
 } // namespace NEO