Media
/
compute-runtime
mirror of https://github.com/intel/compute-runtime.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

fix: remove compiler cache legacy implementation 

Related-To: NEO-10679

Signed-off-by: Weronika Kapusta <weronika.kapusta@intel.com>
This commit is contained in:
Weronika Kapusta 2024-05-06 16:20:13 +00:00 committed by Compute-Runtime-Automation
parent e2a3c21e1c
commit d6c16c1640
20 changed files with 26 additions and 154 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
CMakeLists.txt
View File

@ -613,7 +613,6 @@ endif()
# Miscs options
option(IGDRCL_GCOV "generate gcov report" OFF)
set(CL_CACHE_LOCATION "cl_cache" CACHE STRING "OpenCL program binary cache location")
option(NEO_SHOW_VERBOSE_ULT_RESULTS "Use the default/verbose test output" OFF)

1
cmake/run_aub_test_target.cmake
View File

@ -60,7 +60,6 @@ if(NOT NEO_SKIP_OCL_UNIT_TESTS OR NOT NEO_SKIP_L0_UNIT_TESTS)
COMMAND ${CMAKE_COMMAND} -E remove_directory ${TargetDir}/${product}_aub/${revision_id}
COMMAND ${CMAKE_COMMAND} -E make_directory ${TargetDir}/${product}_aub/${revision_id}
COMMAND ${CMAKE_COMMAND} -E make_directory ${TargetDir}/${product}_aub/${revision_id}/aub_out
COMMAND ${CMAKE_COMMAND} -E make_directory ${TargetDir}/${product}_aub/${revision_id}/cl_cache
)
endif()

2
cmake/run_ult_target.cmake
View File

@ -60,8 +60,6 @@ if(NOT NEO_SKIP_OCL_UNIT_TESTS)
POST_BUILD
COMMAND WORKING_DIRECTORY ${TargetDir}
COMMAND echo Running igdrcl_tests ${target} ${slices}x${subslices}x${eu_per_ss} in ${TargetDir}
COMMAND ${CMAKE_COMMAND} -E remove_directory ${outputdir}/cl_cache
COMMAND ${CMAKE_COMMAND} -E make_directory ${outputdir}/cl_cache
COMMAND echo Cmd line: ${GTEST_ENV} ${NEO_RUN_INTERCEPTOR_LIST} $<TARGET_FILE:igdrcl_tests> --product ${product} --slices ${slices} --subslices ${subslices} --eu_per_ss ${eu_per_ss} ${GTEST_EXCEPTION_OPTIONS} --gtest_repeat=${GTEST_REPEAT} ${GTEST_SHUFFLE} ${GTEST_OUTPUT} ${NEO_TESTS_LISTENER_OPTION} ${GTEST_FILTER_OPTION} --rev_id ${revision_id}
COMMAND ${GTEST_ENV} ${NEO_RUN_INTERCEPTOR_LIST} $<TARGET_FILE:igdrcl_tests> --product ${product} --slices ${slices} --subslices ${subslices} --eu_per_ss ${eu_per_ss} ${GTEST_EXCEPTION_OPTIONS} --gtest_repeat=${GTEST_REPEAT} ${GTEST_SHUFFLE} ${GTEST_OUTPUT} ${NEO_TESTS_LISTENER_OPTION} ${GTEST_FILTER_OPTION} --rev_id ${revision_id}
)

1
config.h.in
View File

@ -8,7 +8,6 @@
#ifndef CONFIG_H
#define CONFIG_H
#cmakedefine CL_CACHE_LOCATION "${CL_CACHE_LOCATION}"
#cmakedefine NEO_ARCH "${NEO_ARCH}"
#endif /* CONFIG_H */

8
level_zero/core/source/helpers/api_specific_config_l0.cpp
View File

@ -78,14 +78,6 @@ bool ApiSpecificConfig::isSharedAllocPrefetchEnabled() {
(NEO::debugManager.flags.EnableBOChunkingPrefetch.get() && ((NEO::debugManager.flags.EnableBOChunking.get()) != -1) && ((NEO::debugManager.flags.EnableBOChunking.get()) & 0x1)));
}
std::string ApiSpecificConfig::compilerCacheDir() {
return "l0_cache_dir";
}
std::string ApiSpecificConfig::compilerCacheLocation() {
return "l0_cache";
}
std::string ApiSpecificConfig::compilerCacheFileExtension() {
return ".l0_cache";
}

8
level_zero/core/test/unit_tests/sources/helper/api_specific_config_l0_tests.cpp
View File

@ -79,14 +79,6 @@ TEST(ImplicitScalingApiTests, givenLevelZeroApiUsedThenSupportEnabled) {
EXPECT_TRUE(ImplicitScaling::apiSupport);
}
TEST(ApiSpecificConfigL0Tests, WhenGettingCompilerCacheDirThenReturnProperDirString) {
EXPECT_EQ(0, strcmp("l0_cache_dir", ApiSpecificConfig::compilerCacheDir().c_str()));
}
TEST(ApiSpecificConfigL0Tests, WhenGettingCompilerCacheLocationThenReturnProperLocationString) {
EXPECT_EQ(0, strcmp("l0_cache", ApiSpecificConfig::compilerCacheLocation().c_str()));
}
TEST(ApiSpecificConfigL0Tests, WhenGettingCompilerCacheFileExtensionThenReturnProperFileExtensionString) {
EXPECT_EQ(0, strcmp(".l0_cache", ApiSpecificConfig::compilerCacheFileExtension().c_str()));
}

4
opencl/doc/FAQ.md
View File

@ -40,10 +40,6 @@ See the enabling [guide](cl_intel_va_api_media_sharing.md).
## Feature: cl_cache
Originally, compute-runtime had an experimental cache implementation, which was replaced
in Q2'23 with a more robust approach. Legacy solution is now considered deprecated and the
old experimental controls explained below will be removed by EOY 2023.
### What is cl_cache?
This is a mechanism to cache binary representations of OpenCL kernels provided in text form by

8
opencl/source/helpers/api_specific_config_ocl.cpp
View File

@ -69,14 +69,6 @@ const StackVec<DebugVarPrefix, 4> &ApiSpecificConfig::getPrefixTypes() {
return validClPrefixTypes;
}
std::string ApiSpecificConfig::compilerCacheDir() {
return "cl_cache_dir";
}
std::string ApiSpecificConfig::compilerCacheLocation() {
return "cl_cache";
}
std::string ApiSpecificConfig::compilerCacheFileExtension() {
return ".cl_cache";
}

8
opencl/test/unit_test/helpers/api_specific_config_ocl_tests.cpp
View File

@ -71,14 +71,6 @@ TEST(ApiSpecificConfigOclTests, givenEnableStatelessCompressionWhenProvidingPrin
EXPECT_TRUE(NEO::CompressionSelector::preferCompressedAllocation(properties));
}
TEST(ApiSpecificConfigOclTests, WhenGettingCompilerCacheDirThenReturnProperDirString) {
EXPECT_EQ(0, strcmp("cl_cache_dir", ApiSpecificConfig::compilerCacheDir().c_str()));
}
TEST(ApiSpecificConfigOclTests, WhenGettingCompilerCacheLocationThenReturnProperLocationString) {
EXPECT_EQ(0, strcmp("cl_cache", ApiSpecificConfig::compilerCacheLocation().c_str()));
}
TEST(ApiSpecificConfigOclTests, WhenGettingCompilerCacheFileExtensionThenReturnProperFileExtensionString) {
EXPECT_EQ(0, strcmp(".cl_cache", ApiSpecificConfig::compilerCacheFileExtension().c_str()));
}

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

@ -12,5 +12,5 @@ TEST(CompilerCache, GivenDefaultCacheConfigThenValuesAreProperlyPopulated) {
auto cacheConfig = NEO::getDefaultCompilerCacheConfig();
EXPECT_STREQ("ocloc_cache", cacheConfig.cacheDir.c_str());
EXPECT_STREQ(".ocloc_cache", cacheConfig.cacheFileExtension.c_str());
EXPECT_TRUE(cacheConfig.enabled);
EXPECT_FALSE(cacheConfig.enabled);
}

2
programmers-guide/COMPILER_CACHE.md
View File

@ -13,7 +13,7 @@ SPDX-License-Identifier: MIT
- [Implementation](#Implementation)
- [Key Features](#Key-Features)
- [Debug Keys](#Debug-Keys)
- [Potential Problems and Limitations](#Potential-Problems-and-Limitations)
- [Potential Issues and Limitations](#Potential-Issues-and-Limitations)
# Introduction

2
shared/source/compiler_interface/compiler_cache.h
View File

@ -20,7 +20,7 @@ namespace NEO {
struct HardwareInfo;
struct CompilerCacheConfig {
bool enabled = true;
bool enabled = false;
std::string cacheFileExtension;
std::string cacheDir;
size_t cacheSize = 0;

19
shared/source/compiler_interface/default_cache_config.cpp
View File

@ -53,25 +53,12 @@ CompilerCacheConfig getDefaultCompilerCacheConfig() {
ret.cacheSize = std::numeric_limits<size_t>::max();
}
if (ret.enabled) {
PRINT_DEBUG_STRING(NEO::debugManager.flags.PrintDebugMessages.get(), stdout, "NEO_CACHE_PERSISTENT is enabled. Cache is located in: %s\n\n",
ret.cacheDir.c_str());
}
PRINT_DEBUG_STRING(NEO::debugManager.flags.PrintDebugMessages.get(), stdout, "NEO_CACHE_PERSISTENT is enabled. Cache is located in: %s\n\n",
ret.cacheDir.c_str());
return ret;
}
ret.cacheDir = envReader.getSetting(ApiSpecificConfig::compilerCacheDir().c_str(), ApiSpecificConfig::compilerCacheLocation());
if (NEO::SysCalls::pathExists(ret.cacheDir)) {
ret.enabled = true;
ret.cacheSize = static_cast<size_t>(neoCacheMaxSizeDefault);
ret.cacheFileExtension = ApiSpecificConfig::compilerCacheFileExtension();
} else {
ret.enabled = false;
ret.cacheSize = 0u;
ret.cacheFileExtension = ApiSpecificConfig::compilerCacheFileExtension();
}
return ret;
}

4
shared/source/os_interface/windows/debug_registry_reader.cpp
View File

@ -197,7 +197,7 @@ std::string RegistryReader::getSetting(const char *settingName, const std::strin
for (const auto &prefix : prefixString) {
std::string neoKey = prefix;
neoKey += settingName;
envValue = strcmp(processName.c_str(), neoKey.c_str()) ? IoFunctions::getenvPtr(neoKey.c_str()) : IoFunctions::getenvPtr("cl_cache_dir");
envValue = IoFunctions::getenvPtr(neoKey.c_str());
if (envValue) {
keyValue.assign(envValue);
type = prefixType[i];
@ -214,7 +214,7 @@ std::string RegistryReader::getSetting(const char *settingName, const std::strin
std::string keyValue = value;
if (!(getSettingStringCommon(settingName, keyValue))) {
const char *envValue = strcmp(processName.c_str(), settingName) ? IoFunctions::getenvPtr(settingName) : IoFunctions::getenvPtr("cl_cache_dir");
const char *envValue = IoFunctions::getenvPtr(settingName);
if (envValue) {
keyValue.assign(envValue);
}

1
shared/test/unit_test/compiler_interface/compiler_cache_tests.cpp
View File

@ -445,6 +445,7 @@ TEST(CompilerInterfaceCachedTests, givenKernelWithoutIncludesAndBinaryInCacheWhe
std::unique_ptr<CompilerCacheMock> cache(new CompilerCacheMock());
cache->loadResult = true;
cache->config.enabled = true;
auto compilerInterface = std::unique_ptr<CompilerInterface>(CompilerInterface::createInstance(std::move(cache), true));
TranslationOutput translationOutput;
inputArgs.allowCaching = true;

50
shared/test/unit_test/compiler_interface/linux/default_cl_cache_config_tests.cpp
View File

@ -21,47 +21,6 @@ namespace SysCalls {
extern bool pathExistsMock;
}
namespace LegacyPathWorksIfNewEnvIsSetToDisabled {
bool pathExistsMock(const std::string &path) {
if (path.find(ApiSpecificConfig::compilerCacheLocation().c_str()) != path.npos)
return true;
return false;
}
} // namespace LegacyPathWorksIfNewEnvIsSetToDisabled
TEST(ClCacheDefaultConfigLinuxTest, GivenDefaultClCacheConfigWithPathExistsAndNewEnvSetToDisabledThenValuesAreProperlyPopulated) {
std::unordered_map<std::string, std::string> mockableEnvs;
mockableEnvs["NEO_CACHE_PERSISTENT"] = "0";
VariableBackup<std::unordered_map<std::string, std::string> *> mockableEnvValuesBackup(&NEO::IoFunctions::mockableEnvValues, &mockableEnvs);
VariableBackup<decltype(NEO::SysCalls::sysCallsPathExists)> pathExistsBackup(&NEO::SysCalls::sysCallsPathExists, LegacyPathWorksIfNewEnvIsSetToDisabled::pathExistsMock);
auto cacheConfig = NEO::getDefaultCompilerCacheConfig();
EXPECT_STREQ(ApiSpecificConfig::compilerCacheLocation().c_str(), cacheConfig.cacheDir.c_str());
EXPECT_STREQ(ApiSpecificConfig::compilerCacheFileExtension().c_str(), cacheConfig.cacheFileExtension.c_str());
EXPECT_TRUE(cacheConfig.enabled);
}
namespace NewEnvIsDisabledAndLegacyPathDoesNotExist {
bool pathExistsMock(const std::string &path) {
return false;
}
} // namespace NewEnvIsDisabledAndLegacyPathDoesNotExist
TEST(ClCacheDefaultConfigLinuxTest, GivenDefaultClCacheConfigWithNotExistingPathAndNewEnvSetToDisabledThenValuesAreProperlyPopulated) {
std::unordered_map<std::string, std::string> mockableEnvs;
mockableEnvs["NEO_CACHE_PERSISTENT"] = "0";
VariableBackup<std::unordered_map<std::string, std::string> *> mockableEnvValuesBackup(&NEO::IoFunctions::mockableEnvValues, &mockableEnvs);
VariableBackup<decltype(NEO::SysCalls::sysCallsPathExists)> pathExistsBackup(&NEO::SysCalls::sysCallsPathExists, NewEnvIsDisabledAndLegacyPathDoesNotExist::pathExistsMock);
auto cacheConfig = NEO::getDefaultCompilerCacheConfig();
EXPECT_STREQ(ApiSpecificConfig::compilerCacheLocation().c_str(), cacheConfig.cacheDir.c_str());
EXPECT_STREQ(ApiSpecificConfig::compilerCacheFileExtension().c_str(), cacheConfig.cacheFileExtension.c_str());
EXPECT_FALSE(cacheConfig.enabled);
}
namespace AllVariablesCorrectlySet {
bool pathExistsMock(const std::string &path) {
if (path.find("ult/directory/") != path.npos)
@ -365,4 +324,13 @@ TEST(ClCacheDefaultConfigLinuxTest, GivenXdgEnvWhenOtherProcessCreatesNeoCompile
EXPECT_EQ(cacheConfig.cacheDir, "xdg/directory/neo_compiler_cache");
EXPECT_TRUE(XdgPathIsSetAndOtherProcessCreatesPath::mkdirCalled);
}
TEST(ClCacheDefaultConfigLinuxTest, GivenNeoCachePersistentSetToZeroWhenGetDefaultCompilerCacheConfigThenCacheIsDisabled) {
std::unordered_map<std::string, std::string> mockableEnvs;
mockableEnvs["NEO_CACHE_PERSISTENT"] = "0";
auto cacheConfig = NEO::getDefaultCompilerCacheConfig();
EXPECT_FALSE(cacheConfig.enabled);
}
} // namespace NEO

32
shared/test/unit_test/compiler_interface/windows/default_cl_cache_config_tests.cpp
View File

@ -62,30 +62,6 @@ struct ClCacheDefaultConfigWindowsTest : public ::testing::Test {
VariableBackup<BOOL> createDirectoryAResultBackup;
};
TEST_F(ClCacheDefaultConfigWindowsTest, GivenDefaultClCacheConfigWithPathExistsThenValuesAreProperlyPopulated) {
mockableEnvs["NEO_CACHE_PERSISTENT"] = "0";
bool pathExistsMock = true;
VariableBackup<bool> pathExistsMockBackup(&NEO::SysCalls::pathExistsMock, pathExistsMock);
auto cacheConfig = NEO::getDefaultCompilerCacheConfig();
EXPECT_STREQ(ApiSpecificConfig::compilerCacheLocation().c_str(), cacheConfig.cacheDir.c_str());
EXPECT_STREQ(ApiSpecificConfig::compilerCacheFileExtension().c_str(), cacheConfig.cacheFileExtension.c_str());
EXPECT_TRUE(cacheConfig.enabled);
}
TEST_F(ClCacheDefaultConfigWindowsTest, GivenDefaultClCacheConfigWithNonExistingPathThenValuesAreProperlyPopulated) {
mockableEnvs["NEO_CACHE_PERSISTENT"] = "0";
bool pathExistsMock = false;
VariableBackup<bool> pathExistsMockBackup(&NEO::SysCalls::pathExistsMock, pathExistsMock);
auto cacheConfig = NEO::getDefaultCompilerCacheConfig();
EXPECT_STREQ(ApiSpecificConfig::compilerCacheLocation().c_str(), cacheConfig.cacheDir.c_str());
EXPECT_STREQ(ApiSpecificConfig::compilerCacheFileExtension().c_str(), cacheConfig.cacheFileExtension.c_str());
EXPECT_FALSE(cacheConfig.enabled);
}
TEST_F(ClCacheDefaultConfigWindowsTest, GivenAllEnvVarWhenProperlySetThenCorrectConfigIsReturned) {
mockableEnvs["NEO_CACHE_PERSISTENT"] = "1";
mockableEnvs["NEO_CACHE_MAX_SIZE"] = "22";
@ -289,4 +265,12 @@ TEST_F(ClCacheDefaultConfigWindowsTest, GivenCachePathExistsAndNoEnvVarsSetWhenG
EXPECT_EQ(cacheConfig.cacheDir, expectedCacheDirPath);
}
TEST_F(ClCacheDefaultConfigWindowsTest, GivenNeoCachePersistentSetToZeroWhenGetDefaultCompilerCacheConfigThenCacheIsDisabled) {
mockableEnvs["NEO_CACHE_PERSISTENT"] = "0";
auto cacheConfig = NEO::getDefaultCompilerCacheConfig();
EXPECT_FALSE(cacheConfig.enabled);
}
} // namespace NEO

6
shared/test/unit_test/os_interface/debug_env_reader_tests.cpp
View File

@ -483,12 +483,6 @@ TEST_F(DebugEnvReaderTests, GivenBoolEnvVariableWhenGettingThenCorrectValueIsRet
}
}
TEST_F(DebugEnvReaderTests, WhenSettingAppSpecificLocationThenLocationIsReturned) {
std::string appSpecific;
appSpecific = "cl_cache_dir";
EXPECT_EQ(appSpecific, environmentVariableReader->appSpecificLocation(appSpecific));
}
TEST_F(DebugEnvReaderTests, givenEnvironmentVariableReaderWhenCreateOsReaderWithStringThenNotNullPointer) {
std::unique_ptr<SettingsReader> settingsReader(SettingsReader::createOsReader(false, ""));
EXPECT_NE(nullptr, settingsReader);

20
shared/test/unit_test/os_interface/windows/registry_reader_tests.cpp
View File

@ -507,24 +507,4 @@ TEST_F(RegistryReaderTest, givenRegistryKeyPresentWhenValueIsNonZeroInBothDwords
EXPECT_TRUE(value);
EXPECT_EQ(DebugVarPrefix::none, type);
}
TEST_F(DebugReaderWithRegistryAndEnvTest, givenSetProcessNameWhenReadFromEnvironmentVariableThenReturnClCacheDir) {
SysCalls::regOpenKeySuccessCount = 0u;
SysCalls::regQueryValueSuccessCount = 0u;
registryReader.processName = "processName";
std::string defaultCacheDir = "";
std::string cacheDir = registryReader.getSetting("processName", defaultCacheDir);
EXPECT_STREQ("./tested_cl_cache_dir", cacheDir.c_str());
}
TEST_F(DebugReaderWithRegistryAndEnvTest, givenSetProcessNameWhenReadFromEnvironmentVariableThenReturnClCacheDirPrefix) {
SysCalls::regOpenKeySuccessCount = 0u;
SysCalls::regQueryValueSuccessCount = 0u;
registryReader.processName = "processName";
std::string defaultCacheDir = "";
DebugVarPrefix type = DebugVarPrefix::none;
std::string cacheDir2 = registryReader.getSetting("processName", defaultCacheDir, type);
EXPECT_STREQ("./tested_cl_cache_dir", cacheDir2.c_str());
EXPECT_EQ(DebugVarPrefix::none, type);
}
} // namespace NEO

1
shared/test/unit_test/os_interface/windows/registry_reader_tests.h
View File

@ -38,7 +38,6 @@ class TestedRegistryReader : public RegistryReader {
IoFunctions::mockableEnvValues->insert({"settingSourceString", "environment"});
IoFunctions::mockableEnvValues->insert({"settingSourceInt", "2"});
IoFunctions::mockableEnvValues->insert({"processName", "processName"});
IoFunctions::mockableEnvValues->insert({"cl_cache_dir", "./tested_cl_cache_dir"});
}
const char *getRegKey() const {
return registryReadRootKey.c_str();