Media/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2025-09-10 12:53:42 +08:00
Code Issues Packages Projects Releases Wiki Activity

Ocloc: Add -s to options string for non-spirv input with -g option passed

Browse Source 
Automatically add "-s" (source path) option if -g flag is present.
This applies only to non-spirv input.
- Due to conflict, do not automatically append source path when
CMC compiler is used.
- Minor code refactor: use defined compiler options instead of local
strings; wrap filename in quotes (in case of space-separated filename
string).

Related-To: NEO-7285
Signed-off-by: Kacper Nowak kacper.nowak@intel.com
This commit is contained in:
Kacper Nowak
2022-09-09 18:44:06 +00:00
committed by Compute-Runtime-Automation
parent 66f5af0fec
commit 65f7ff2027
6 changed files with 136 additions and 5 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
opencl/source/program/program.cpp
View File

@ -491,10 +491,10 @@ cl_int Program::processInputDevices(ClDeviceVector *&deviceVectorPtr, cl_uint nu
}
void Program::prependFilePathToOptions(const std::string &filename) {
ConstStringRef cmcOption = "-cmc";
if (!filename.empty() && options.compare(0, cmcOption.size(), cmcOption.data())) {
auto isCMCOptionUsed = CompilerOptions::contains(options, CompilerOptions::useCMCompiler);
if (!filename.empty() && false == isCMCOptionUsed) {
// Add "-s" flag first so it will be ignored by clang in case the options already have this flag set.
options = std::string("-s ") + filename + " " + options;
options = CompilerOptions::generateSourcePath.str() + " " + CompilerOptions::wrapInQuotes(filename) + " " + options;
}
}

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

@ -1244,6 +1244,123 @@ TEST_F(OfflineCompilerTests, givenDebugOptionThenInternalOptionShouldContainKern
EXPECT_TRUE(hasSubstr(internalOptions, "-cl-kernel-debug-enable"));
}
TEST_F(OfflineCompilerTests, givenDebugOptionAndNonSpirvInputThenOptionsShouldContainDashSOptionAppendedAutomatically) {
auto mockOfflineCompiler = std::unique_ptr<MockOfflineCompiler>(new MockOfflineCompiler());
mockOfflineCompiler->uniqueHelper->callBaseFileExists = false;
mockOfflineCompiler->uniqueHelper->callBaseLoadDataFromFile = false;
mockOfflineCompiler->uniqueHelper->filesMap["some_input.cl"] = "";
std::vector<std::string> argv = {
"ocloc",
"-q",
"-options",
"-g",
"-file",
"some_input.cl",
"-device",
gEnvironment->devicePrefix.c_str()};
mockOfflineCompiler->initialize(argv.size(), argv);
const auto &options = mockOfflineCompiler->options;
std::string appendedOption{"-s \"some_input.cl\""};
EXPECT_TRUE(hasSubstr(options, appendedOption));
}
TEST_F(OfflineCompilerTests, givenDebugOptionAndNonSpirvInputWhenFilenameIsSeparatedWithSpacesThenAppendedSourcePathIsSetCorrectly) {
auto mockOfflineCompiler = std::unique_ptr<MockOfflineCompiler>(new MockOfflineCompiler());
mockOfflineCompiler->uniqueHelper->callBaseFileExists = false;
mockOfflineCompiler->uniqueHelper->callBaseLoadDataFromFile = false;
mockOfflineCompiler->uniqueHelper->filesMap["filename with spaces.cl"] = "";
std::vector<std::string> argv = {
"ocloc",
"-q",
"-options",
"-g",
"-file",
"filename with spaces.cl",
"-device",
gEnvironment->devicePrefix.c_str()};
const auto result = mockOfflineCompiler->initialize(argv.size(), argv);
EXPECT_EQ(OclocErrorCode::SUCCESS, result);
const auto &options = mockOfflineCompiler->options;
std::string appendedOption{"-s \"filename with spaces.cl\""};
EXPECT_TRUE(hasSubstr(options, appendedOption));
}
TEST_F(OfflineCompilerTests, givenDebugOptionAndSpirvInputThenDoNotAppendDashSOptionAutomatically) {
auto mockOfflineCompiler = std::unique_ptr<MockOfflineCompiler>(new MockOfflineCompiler());
mockOfflineCompiler->uniqueHelper->callBaseFileExists = false;
mockOfflineCompiler->uniqueHelper->callBaseLoadDataFromFile = false;
mockOfflineCompiler->uniqueHelper->filesMap["some_input.spirv"] = "";
std::vector<std::string> argvSpirvInput = {
"ocloc",
"-q",
"-spirv_input",
"-options",
"-g",
"-file",
"some_input.spirv",
"-device",
gEnvironment->devicePrefix.c_str()};
mockOfflineCompiler->initialize(argvSpirvInput.size(), argvSpirvInput);
const auto &options = mockOfflineCompiler->options;
std::string notAppendedOption{"-s \"some_input.spirv\""};
EXPECT_FALSE(hasSubstr(options, notAppendedOption));
}
TEST_F(OfflineCompilerTests, givenDebugOptionWhenCompilerIsCMCThenDoNotAppendDashSOptionAutomatically) {
auto mockOfflineCompiler = std::unique_ptr<MockOfflineCompiler>(new MockOfflineCompiler());
mockOfflineCompiler->uniqueHelper->callBaseFileExists = false;
mockOfflineCompiler->uniqueHelper->callBaseLoadDataFromFile = false;
mockOfflineCompiler->uniqueHelper->filesMap["some_input.cl"] = "";
std::vector<std::string> argvSpirvInput = {
"ocloc",
"-q",
"-options",
"-g -cmc",
"-file",
"some_input.cl",
"-device",
gEnvironment->devicePrefix.c_str()};
mockOfflineCompiler->initialize(argvSpirvInput.size(), argvSpirvInput);
const auto &options = mockOfflineCompiler->options;
std::string notAppendedOption{"-s \"some_input.spirv\""};
EXPECT_FALSE(hasSubstr(options, notAppendedOption));
}
TEST_F(OfflineCompilerTests, givenDebugOptionAndDashSOptionPassedManuallyThenDoNotAppendDashSOptionAutomatically) {
auto mockOfflineCompiler = std::unique_ptr<MockOfflineCompiler>(new MockOfflineCompiler());
mockOfflineCompiler->uniqueHelper->callBaseFileExists = false;
mockOfflineCompiler->uniqueHelper->callBaseLoadDataFromFile = false;
mockOfflineCompiler->uniqueHelper->filesMap["some_input.cl"] = "";
std::vector<std::string> argvDashSPassed = {
"ocloc",
"-q",
"-options",
"-g -s \"mockPath/some_input.cl\"",
"-file",
"some_input.cl",
"-device",
gEnvironment->devicePrefix.c_str()};
mockOfflineCompiler->initialize(argvDashSPassed.size(), argvDashSPassed);
const auto &options = mockOfflineCompiler->options;
std::string appendedOption{"-s"};
auto occurrences = 0u;
size_t pos = 0u;
while ((pos = options.find(appendedOption, pos)) != std::string::npos) {
occurrences++;
pos++;
}
EXPECT_EQ(1u, occurrences);
}
TEST_F(OfflineCompilerTests, givenDashGInBiggerOptionStringWhenInitializingThenInternalOptionsShouldNotContainKernelDebugEnable) {
std::vector<std::string> argv = {

4
opencl/test/unit_test/program/program_with_kernel_debug_tests.cpp
View File

@ -141,7 +141,7 @@ TEST_F(ProgramWithKernelDebuggingTest, givenEnabledKernelDebugWhenProgramIsCompi
cl_int retVal = pProgram->compile(pProgram->getDevices(), nullptr,
0, nullptr, nullptr);
EXPECT_EQ(CL_SUCCESS, retVal);
EXPECT_TRUE(startsWith(pProgram->getOptions(), "-s debugFileName"));
EXPECT_TRUE(startsWith(pProgram->getOptions(), "-s \"debugFileName\""));
}
TEST_F(ProgramWithKernelDebuggingTest, givenEnabledKernelDebugWhenProgramIsCompiledWithCmCOptionThenDashSFilenameIsNotPrepended) {
@ -194,7 +194,7 @@ TEST_F(ProgramWithKernelDebuggingTest, givenEnabledKernelDebugWhenProgramIsBuilt
cl_int retVal = pProgram->build(pProgram->getDevices(), nullptr, false);
EXPECT_EQ(CL_SUCCESS, retVal);
EXPECT_TRUE(startsWith(pProgram->getOptions(), "-s debugFileName"));
EXPECT_TRUE(startsWith(pProgram->getOptions(), "-s \"debugFileName\""));
}
TEST_F(ProgramWithKernelDebuggingTest, givenEnabledKernelDebugWhenProgramIsBuiltWithCmCOptionThenDashSFilenameIsNotPrepended) {

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

@ -616,6 +616,12 @@ int OfflineCompiler::initialize(size_t numArgs, const std::vector<std::string> &
if (hwInfo.platform.eRenderCoreFamily >= IGFX_GEN9_CORE) {
internalOptions = CompilerOptions::concatenate(internalOptions, CompilerOptions::debugKernelEnable);
}
if (false == inputFileSpirV && false == CompilerOptions::contains(options, CompilerOptions::generateSourcePath) && false == CompilerOptions::contains(options, CompilerOptions::useCMCompiler)) {
auto sourcePathStringOption = CompilerOptions::generateSourcePath.str();
sourcePathStringOption.append(" ");
sourcePathStringOption.append(CompilerOptions::wrapInQuotes(inputFile));
options = CompilerOptions::concatenate(options, sourcePathStringOption);
}
}
if (deviceName.empty()) {

5
shared/source/compiler_interface/compiler_options.cpp
View File

@ -32,6 +32,11 @@ bool contains(const std::string &options, ConstStringRef optionToFind) {
return contains(options.c_str(), optionToFind);
}
std::string wrapInQuotes(const std::string &stringToWrap) {
std::string quoteEscape{"\""};
return std::string{quoteEscape + stringToWrap + quoteEscape};
}
TokenizedString tokenize(ConstStringRef src, char sperator) {
TokenizedString ret;
const char *it = src.begin();

3
shared/source/compiler_interface/compiler_options.h
View File

@ -29,6 +29,7 @@ constexpr ConstStringRef fastRelaxedMath = "-cl-fast-relaxed-math";
constexpr ConstStringRef preserveVec3Type = "-fpreserve-vec3-type";
constexpr ConstStringRef createLibrary = "-create-library";
constexpr ConstStringRef generateDebugInfo = "-g";
constexpr ConstStringRef generateSourcePath = "-s";
constexpr ConstStringRef bindlessMode = "-cl-intel-use-bindless-mode -cl-intel-use-bindless-advanced-mode";
constexpr ConstStringRef uniformWorkgroupSize = "-cl-uniform-work-group-size";
constexpr ConstStringRef forceEmuInt32DivRem = "-cl-intel-force-emu-int32divrem";
@ -42,6 +43,7 @@ constexpr ConstStringRef noRecompiledFromIr = "-Wno-recompiled-from-ir";
constexpr ConstStringRef defaultGrf = "-cl-intel-128-GRF-per-thread";
constexpr ConstStringRef largeGrf = "-cl-intel-256-GRF-per-thread";
constexpr ConstStringRef numThreadsPerEu = "-cl-intel-reqd-eu-thread-count";
constexpr ConstStringRef useCMCompiler = "-cmc";
constexpr size_t nullterminateSize = 1U;
constexpr size_t spaceSeparatorSize = 1U;
@ -177,6 +179,7 @@ bool contains(const char *options, ConstStringRef optionToFind);
bool contains(const std::string &options, ConstStringRef optionToFind);
std::string wrapInQuotes(const std::string &stringToWrap);
using TokenizedString = StackVec<ConstStringRef, 32>;
TokenizedString tokenize(ConstStringRef src, char sperator = ' ');