From cddec0f78bf84024bc5fb785e2374bfe346573e5 Mon Sep 17 00:00:00 2001 From: Artur Harasimiuk Date: Thu, 13 Jun 2024 14:24:55 +0000 Subject: [PATCH] feature(ocloc): read cl_cache configuration from env variables Related-To: NEO-7785 Signed-off-by: Artur Harasimiuk --- .../default_cache_config_tests.cpp | 48 +++++++++++++++ .../source/default_cache_config.cpp | 60 ++++++++++++++++++- .../source/offline_compiler.cpp | 7 ++- 3 files changed, 111 insertions(+), 4 deletions(-) diff --git a/opencl/test/unit_test/offline_compiler/default_cache_config_tests.cpp b/opencl/test/unit_test/offline_compiler/default_cache_config_tests.cpp index 982142ea65..f34ea599b0 100644 --- a/opencl/test/unit_test/offline_compiler/default_cache_config_tests.cpp +++ b/opencl/test/unit_test/offline_compiler/default_cache_config_tests.cpp @@ -6,11 +6,59 @@ */ #include "shared/source/compiler_interface/default_cache_config.h" +#include "shared/test/common/helpers/variable_backup.h" +#include "shared/test/common/mocks/mock_io_functions.h" #include "shared/test/common/test_macros/test.h" +std::unordered_map mockableEnvValues; + +char *mockGetenv(const char *name) noexcept { + std::cout << "getenv( " << name << " ).2" << std::endl; + if (mockableEnvValues.find(name) != mockableEnvValues.end()) { + return const_cast(mockableEnvValues.find(name)->second.c_str()); + } + return nullptr; +}; + +using getenvMockFuncPtr = char *(*)(const char *); + TEST(CompilerCache, GivenDefaultCacheConfigThenValuesAreProperlyPopulated) { + VariableBackup getenvBkp((getenvMockFuncPtr *)(&NEO::IoFunctions::getenvPtr), &mockGetenv); + auto cacheConfig = NEO::getDefaultCompilerCacheConfig(); EXPECT_STREQ("ocloc_cache", cacheConfig.cacheDir.c_str()); EXPECT_STREQ(".ocloc_cache", cacheConfig.cacheFileExtension.c_str()); + EXPECT_EQ(0u, cacheConfig.cacheSize); + EXPECT_FALSE(cacheConfig.enabled); +} + +TEST(CompilerCache, GivenEnvVariableWhenDefaultConfigIsCreatedThenValuesAreProperlyPopulated) { + std::unordered_map mockableEnvs; + mockableEnvs["NEO_CACHE_PERSISTENT"] = "1"; + mockableEnvs["NEO_CACHE_MAX_SIZE"] = "1024"; + mockableEnvs["NEO_CACHE_DIR"] = "ult/directory/"; + + VariableBackup mockableEnvValuesBackup(&mockableEnvValues, mockableEnvs); + VariableBackup getenvBkp((getenvMockFuncPtr *)(&NEO::IoFunctions::getenvPtr), &mockGetenv); + + auto cacheConfig = NEO::getDefaultCompilerCacheConfig(); + EXPECT_STREQ("ult/directory/", cacheConfig.cacheDir.c_str()); + EXPECT_STREQ(".ocloc_cache", cacheConfig.cacheFileExtension.c_str()); + EXPECT_EQ(1024u, cacheConfig.cacheSize); + EXPECT_TRUE(cacheConfig.enabled); + + mockableEnvValues["NEO_CACHE_MAX_SIZE"] = "0"; + cacheConfig = NEO::getDefaultCompilerCacheConfig(); + EXPECT_STREQ("ult/directory/", cacheConfig.cacheDir.c_str()); + EXPECT_STREQ(".ocloc_cache", cacheConfig.cacheFileExtension.c_str()); + EXPECT_EQ(std::numeric_limits::max(), cacheConfig.cacheSize); + EXPECT_TRUE(cacheConfig.enabled); + + mockableEnvValues["NEO_CACHE_MAX_SIZE"] = "1048576"; + mockableEnvValues.erase("NEO_CACHE_DIR"); + cacheConfig = NEO::getDefaultCompilerCacheConfig(); + EXPECT_STREQ("", cacheConfig.cacheDir.c_str()); + EXPECT_STREQ("", cacheConfig.cacheFileExtension.c_str()); + EXPECT_EQ(0u, cacheConfig.cacheSize); EXPECT_FALSE(cacheConfig.enabled); } diff --git a/shared/offline_compiler/source/default_cache_config.cpp b/shared/offline_compiler/source/default_cache_config.cpp index 5d566e9424..5fa6078a30 100644 --- a/shared/offline_compiler/source/default_cache_config.cpp +++ b/shared/offline_compiler/source/default_cache_config.cpp @@ -1,5 +1,5 @@ /* - * Copyright (C) 2022 Intel Corporation + * Copyright (C) 2022-2024 Intel Corporation * * SPDX-License-Identifier: MIT * @@ -7,11 +7,69 @@ #include "shared/source/compiler_interface/default_cache_config.h" +#include "shared/source/os_interface/sys_calls_common.h" +#include "shared/source/utilities/io_functions.h" + namespace NEO { + +const std::string neoCachePersistent = "NEO_CACHE_PERSISTENT"; +const std::string neoCacheMaxSize = "NEO_CACHE_MAX_SIZE"; +const std::string neoCacheDir = "NEO_CACHE_DIR"; + +const int64_t neoCacheMaxSizeDefault = static_cast(1 * 1024 * 1024 * 1024); // 1 Gigabyte + +int64_t getSetting(const char *settingName, int64_t defaultValue) { + int64_t value = defaultValue; + char *envValue; + + envValue = IoFunctions::getenvPtr(settingName); + if (envValue) { + value = atoll(envValue); + return value; + } + + return value; +} + +std::string getSetting(const char *settingName, const std::string &value) { + char *envValue; + std::string keyValue; + keyValue.assign(value); + + envValue = IoFunctions::getenvPtr(settingName); + if (envValue) { + keyValue.assign(envValue); + } + return keyValue; +} + CompilerCacheConfig getDefaultCompilerCacheConfig() { CompilerCacheConfig ret; + int64_t compilerCacheDefaultEnabled = 0; + + if (NEO::getSetting(neoCachePersistent.c_str(), compilerCacheDefaultEnabled) != 0) { + ret.enabled = true; + std::string emptyString = ""; + ret.cacheDir = NEO::getSetting(neoCacheDir.c_str(), emptyString); + + if (ret.cacheDir.empty()) { + ret.enabled = false; + return ret; + } + + ret.cacheFileExtension = ".ocloc_cache"; + ret.cacheSize = static_cast(NEO::getSetting(neoCacheMaxSize.c_str(), neoCacheMaxSizeDefault)); + + if (ret.cacheSize == 0u) { + ret.cacheSize = std::numeric_limits::max(); + } + + return ret; + } + ret.cacheDir = "ocloc_cache"; ret.cacheFileExtension = ".ocloc_cache"; + return ret; } } // namespace NEO diff --git a/shared/offline_compiler/source/offline_compiler.cpp b/shared/offline_compiler/source/offline_compiler.cpp index 13f1878c4e..c91e4d094f 100644 --- a/shared/offline_compiler/source/offline_compiler.cpp +++ b/shared/offline_compiler/source/offline_compiler.cpp @@ -935,10 +935,11 @@ int OfflineCompiler::initialize(size_t numArgs, const std::vector & } parseDebugSettings(); - auto cacheConfig = NEO::getDefaultCompilerCacheConfig(); - cacheDir = cacheConfig.cacheDir; if (allowCaching) { - cacheConfig.cacheDir = cacheDir; + auto cacheConfig = NEO::getDefaultCompilerCacheConfig(); + if (cacheConfig.cacheDir.empty() && !cacheDir.empty()) { + cacheConfig.cacheDir = cacheDir; + } cache = std::make_unique(cacheConfig); createDir(cacheConfig.cacheDir); }