From d49190f4ae761ef94539892be6cf13ffa007dee5 Mon Sep 17 00:00:00 2001 From: John Falkowski Date: Sun, 20 Aug 2023 04:31:48 +0000 Subject: [PATCH] feature: Add debug/release variables prefixes Add debug/release variables with prefixes for Level Zero, OpenCL and NEO Resolves: NEO-6357 Signed-off-by: John Falkowski --- .../source/helpers/api_specific_config_l0.cpp | 17 + .../helpers/api_specific_config_ocl.cpp | 18 + .../windows/driver_info_tests.cpp | 6 + .../debug_settings/debug_settings_manager.cpp | 62 ++- .../debug_settings/debug_settings_manager.h | 16 + shared/source/helpers/api_specific_config.h | 8 +- .../source/os_interface/debug_env_reader.cpp | 60 +++ shared/source/os_interface/debug_env_reader.h | 4 + .../windows/debug_registry_reader.cpp | 94 ++++- .../windows/debug_registry_reader.h | 9 + shared/source/utilities/debug_file_reader.cpp | 55 +++ shared/source/utilities/debug_file_reader.h | 6 + .../utilities/debug_settings_reader.cpp | 15 +- .../source/utilities/debug_settings_reader.h | 7 + .../test/common/test_files/neo_string.config | 6 + .../debug_settings_manager_tests.cpp | 177 ++++++++- .../os_interface/linux/debug_env_reader.cpp | 363 ++++++++++++++++++ .../windows/registry_reader_tests.cpp | 273 +++++++++++++ .../windows/registry_reader_tests.h | 6 + .../windows/wddm_windows_tests.cpp | 6 + shared/test/unit_test/ult_specific_config.cpp | 25 ++ .../utilities/debug_file_reader_tests.inl | 51 +++ .../utilities/debug_settings_reader_tests.cpp | 64 +-- 23 files changed, 1289 insertions(+), 59 deletions(-) create mode 100644 shared/test/common/test_files/neo_string.config diff --git a/level_zero/core/source/helpers/api_specific_config_l0.cpp b/level_zero/core/source/helpers/api_specific_config_l0.cpp index c6fc2dddc6..8555421160 100644 --- a/level_zero/core/source/helpers/api_specific_config_l0.cpp +++ b/level_zero/core/source/helpers/api_specific_config_l0.cpp @@ -10,7 +10,12 @@ #include "level_zero/core/source/compiler_interface/l0_reg_path.h" +#include +#include + namespace NEO { +std::vector validL0Prefixes; +std::vector validL0PrefixTypes; bool ApiSpecificConfig::isStatelessCompressionSupported() { return false; } @@ -51,4 +56,16 @@ const char *ApiSpecificConfig::getRegistryPath() { return L0::registryPath; } +void ApiSpecificConfig::initPrefixes() { + validL0Prefixes = {"NEO_L0_", "NEO_", ""}; + validL0PrefixTypes = {DebugVarPrefix::Neo_L0, DebugVarPrefix::Neo, DebugVarPrefix::None}; +} + +const std::vector &ApiSpecificConfig::getPrefixStrings() { + return validL0Prefixes; +} + +const std::vector &ApiSpecificConfig::getPrefixTypes() { + return validL0PrefixTypes; +} } // namespace NEO diff --git a/opencl/source/helpers/api_specific_config_ocl.cpp b/opencl/source/helpers/api_specific_config_ocl.cpp index b433927902..17563a6d23 100644 --- a/opencl/source/helpers/api_specific_config_ocl.cpp +++ b/opencl/source/helpers/api_specific_config_ocl.cpp @@ -10,7 +10,12 @@ #include "opencl/source/os_interface/ocl_reg_path.h" +#include +#include + namespace NEO { +std::vector validClPrefixes; +std::vector validClPrefixTypes; bool ApiSpecificConfig::isStatelessCompressionSupported() { return true; } @@ -50,4 +55,17 @@ uint64_t ApiSpecificConfig::getReducedMaxAllocSize(uint64_t maxAllocSize) { const char *ApiSpecificConfig::getRegistryPath() { return oclRegPath; } + +void ApiSpecificConfig::initPrefixes() { + validClPrefixes = {"NEO_OCL_", "NEO_", ""}; + validClPrefixTypes = {DebugVarPrefix::Neo_Ocl, DebugVarPrefix::Neo, DebugVarPrefix::None}; +} + +const std::vector &ApiSpecificConfig::getPrefixStrings() { + return validClPrefixes; +} + +const std::vector &ApiSpecificConfig::getPrefixTypes() { + return validClPrefixTypes; +} } // namespace NEO diff --git a/opencl/test/unit_test/os_interface/windows/driver_info_tests.cpp b/opencl/test/unit_test/os_interface/windows/driver_info_tests.cpp index c3bf45ffd2..4dfccd9de7 100644 --- a/opencl/test/unit_test/os_interface/windows/driver_info_tests.cpp +++ b/opencl/test/unit_test/os_interface/windows/driver_info_tests.cpp @@ -6,6 +6,7 @@ */ #include "shared/source/command_stream/preemption.h" +#include "shared/source/debug_settings/debug_settings_manager.h" #include "shared/source/execution_environment/execution_environment.h" #include "shared/source/execution_environment/root_device_environment.h" #include "shared/source/os_interface/os_interface.h" @@ -110,6 +111,8 @@ class MockRegistryReader : public SettingsReader { public: std::string nameString; std::string versionString; + std::string getSetting(const char *settingName, const std::string &value, DebugVarPrefix &type) override { return ""; }; + std::string getSetting(const char *settingName, const std::string &value) override { std::string key(settingName); if (key == "HardwareInformation.AdapterString") { @@ -131,8 +134,11 @@ class MockRegistryReader : public SettingsReader { return value; } + bool getSetting(const char *settingName, bool defaultValue, DebugVarPrefix &type) override { return defaultValue; }; bool getSetting(const char *settingName, bool defaultValue) override { return defaultValue; }; + int64_t getSetting(const char *settingName, int64_t defaultValue, DebugVarPrefix &type) override { return defaultValue; }; int64_t getSetting(const char *settingName, int64_t defaultValue) override { return defaultValue; }; + int32_t getSetting(const char *settingName, int32_t defaultValue, DebugVarPrefix &type) override { return defaultValue; }; int32_t getSetting(const char *settingName, int32_t defaultValue) override { return defaultValue; }; const char *appSpecificLocation(const std::string &name) override { return name.c_str(); }; diff --git a/shared/source/debug_settings/debug_settings_manager.cpp b/shared/source/debug_settings/debug_settings_manager.cpp index 4bd7d00dde..e2f6fb1abe 100644 --- a/shared/source/debug_settings/debug_settings_manager.cpp +++ b/shared/source/debug_settings/debug_settings_manager.cpp @@ -9,9 +9,11 @@ #include "shared/source/debug_settings/debug_variables_helper.h" #include "shared/source/debug_settings/definitions/translate_debug_settings.h" +#include "shared/source/helpers/api_specific_config.h" #include "shared/source/helpers/debug_helpers.h" #include "shared/source/helpers/string.h" #include "shared/source/utilities/debug_settings_reader_creator.h" +#include "shared/source/utilities/io_functions.h" #include "shared/source/utilities/logger.h" #include @@ -33,6 +35,7 @@ static std::string toString(const T &arg) { template DebugSettingsManager::DebugSettingsManager(const char *registryPath) { readerImpl = SettingsReaderCreator::create(std::string(registryPath)); + ApiSpecificConfig::initPrefixes(); injectSettingsFromReader(); dumpFlags(); translateDebugSettings(flags); @@ -57,6 +60,18 @@ void DebugSettingsManager::getHardwareInfoOverride(std::string &hwIn } } +static const char *convPrefixToString(DebugVarPrefix prefix) { + if (prefix == DebugVarPrefix::Neo) { + return "NEO_"; + } else if (prefix == DebugVarPrefix::Neo_L0) { + return "NEO_L0_"; + } else if (prefix == DebugVarPrefix::Neo_Ocl) { + return "NEO_OCL_"; + } else { + return ""; + } +} + template template void DebugSettingsManager::dumpNonDefaultFlag(const char *variableName, const DataType &variableValue, const DataType &defaultValue, std::ostringstream &ostring) { @@ -74,18 +89,31 @@ void DebugSettingsManager::getStringWithFlags(std::string &allFlags, std::ostringstream changedFlagsStream; changedFlagsStream.str(""); -#define DECLARE_DEBUG_VARIABLE(dataType, variableName, defaultValue, description) \ - allFlagsStream << getNonReleaseKeyName(#variableName) << " = " << flags.variableName.get() << '\n'; \ - dumpNonDefaultFlag(getNonReleaseKeyName(#variableName), flags.variableName.get(), defaultValue, changedFlagsStream); - +#define DECLARE_DEBUG_VARIABLE(dataType, variableName, defaultValue, description) \ + { \ + char neoFinal[MAX_NEO_KEY_LENGTH]; \ + const char *prefix = convPrefixToString(flags.variableName.getPrefixType()); \ + strcpy_s(neoFinal, strlen(prefix) + 1, prefix); \ + strcpy_s(neoFinal + strlen(prefix), strlen(#variableName) + 1, #variableName); \ + const char *neoKey = neoFinal; \ + allFlagsStream << getNonReleaseKeyName(neoKey) << " = " << flags.variableName.get() << '\n'; \ + dumpNonDefaultFlag(getNonReleaseKeyName(neoKey), flags.variableName.get(), defaultValue, changedFlagsStream); \ + } if (registryReadAvailable() || isDebugKeysReadEnabled()) { #include "debug_variables.inl" } #undef DECLARE_DEBUG_VARIABLE -#define DECLARE_DEBUG_VARIABLE(dataType, variableName, defaultValue, description) \ - allFlagsStream << #variableName << " = " << flags.variableName.get() << '\n'; \ - dumpNonDefaultFlag(#variableName, flags.variableName.get(), defaultValue, changedFlagsStream); +#define DECLARE_DEBUG_VARIABLE(dataType, variableName, defaultValue, description) \ + { \ + char neoFinal[MAX_NEO_KEY_LENGTH]; \ + const char *prefix = convPrefixToString(flags.variableName.getPrefixType()); \ + strcpy_s(neoFinal, strlen(prefix) + 1, prefix); \ + strcpy_s(neoFinal + strlen(prefix), strlen(#variableName) + 1, #variableName); \ + const char *neoKey = neoFinal; \ + allFlagsStream << neoKey << " = " << flags.variableName.get() << '\n'; \ + dumpNonDefaultFlag(neoKey, flags.variableName.get(), defaultValue, changedFlagsStream); \ + } #include "release_variables.inl" #undef DECLARE_DEBUG_VARIABLE @@ -114,10 +142,12 @@ void DebugSettingsManager::dumpFlags() const { template void DebugSettingsManager::injectSettingsFromReader() { #undef DECLARE_DEBUG_VARIABLE -#define DECLARE_DEBUG_VARIABLE(dataType, variableName, defaultValue, description) \ - { \ - dataType tempData = readerImpl->getSetting(getNonReleaseKeyName(#variableName), flags.variableName.get()); \ - flags.variableName.set(tempData); \ +#define DECLARE_DEBUG_VARIABLE(dataType, variableName, defaultValue, description) \ + { \ + DebugVarPrefix type; \ + dataType tempData = readerImpl->getSetting(getNonReleaseKeyName(#variableName), flags.variableName.get(), type); \ + flags.variableName.setPrefixType(type); \ + flags.variableName.set(tempData); \ } if (registryReadAvailable() || isDebugKeysReadEnabled()) { @@ -125,10 +155,12 @@ void DebugSettingsManager::injectSettingsFromReader() { } #undef DECLARE_DEBUG_VARIABLE -#define DECLARE_DEBUG_VARIABLE(dataType, variableName, defaultValue, description) \ - { \ - dataType tempData = readerImpl->getSetting(#variableName, flags.variableName.get()); \ - flags.variableName.set(tempData); \ +#define DECLARE_DEBUG_VARIABLE(dataType, variableName, defaultValue, description) \ + { \ + DebugVarPrefix type; \ + dataType tempData = readerImpl->getSetting(#variableName, flags.variableName.get(), type); \ + flags.variableName.setPrefixType(type); \ + flags.variableName.set(tempData); \ } #include "release_variables.inl" #undef DECLARE_DEBUG_VARIABLE diff --git a/shared/source/debug_settings/debug_settings_manager.h b/shared/source/debug_settings/debug_settings_manager.h index d45a931c29..5146141e28 100644 --- a/shared/source/debug_settings/debug_settings_manager.h +++ b/shared/source/debug_settings/debug_settings_manager.h @@ -59,6 +59,13 @@ void logDebugString(std::string_view debugString); class SettingsReader; +enum class DebugVarPrefix : uint8_t { + None = 1, + Neo = 2, + Neo_L0 = 3, + Neo_Ocl = 4 +}; + template struct DebugVarBase { DebugVarBase(const T &defaultValue) : value(defaultValue), defaultValue(defaultValue) {} @@ -76,10 +83,17 @@ struct DebugVarBase { this->set(data); } } + void setPrefixType(DebugVarPrefix data) { + prefixType = std::move(data); + } + DebugVarPrefix getPrefixType() const { + return prefixType; + } private: T value; T defaultValue; + DebugVarPrefix prefixType = DebugVarPrefix::None; }; struct DebugVariables { // NOLINT(clang-analyzer-optin.performance.Padding) @@ -158,6 +172,8 @@ class DebugSettingsManager { extern DebugSettingsManager DebugManager; +#define MAX_NEO_KEY_LENGTH 256 + #define PRINT_DEBUGGER_LOG_TO_FILE(...) \ NEO::DebugManager.logLazyEvaluateArgs([&] { \ char temp[4000]; \ diff --git a/shared/source/helpers/api_specific_config.h b/shared/source/helpers/api_specific_config.h index 41c4789eed..7e951f1b97 100644 --- a/shared/source/helpers/api_specific_config.h +++ b/shared/source/helpers/api_specific_config.h @@ -6,10 +6,14 @@ */ #pragma once +#include "shared/source/debug_settings/debug_settings_manager.h" + #include #include +#include namespace NEO { + struct ApiSpecificConfig { enum ApiType { OCL, L0 }; @@ -22,7 +26,9 @@ struct ApiSpecificConfig { static std::string getName(); static uint64_t getReducedMaxAllocSize(uint64_t maxAllocSize); static const char *getRegistryPath(); - + static void initPrefixes(); + static const std::vector &getPrefixStrings(); + static const std::vector &getPrefixTypes(); static std::string getAubPrefixForSpecificApi() { return (getName() + "_"); } diff --git a/shared/source/os_interface/debug_env_reader.cpp b/shared/source/os_interface/debug_env_reader.cpp index 5acb3d2f2d..6f66ecd6b4 100644 --- a/shared/source/os_interface/debug_env_reader.cpp +++ b/shared/source/os_interface/debug_env_reader.cpp @@ -7,22 +7,57 @@ #include "shared/source/os_interface/debug_env_reader.h" +#include "shared/source/helpers/api_specific_config.h" #include "shared/source/utilities/io_functions.h" +#include + namespace NEO { const char *EnvironmentVariableReader::appSpecificLocation(const std::string &name) { return name.c_str(); } +bool EnvironmentVariableReader::getSetting(const char *settingName, bool defaultValue, DebugVarPrefix &type) { + return getSetting(settingName, static_cast(defaultValue), type) ? true : false; +} + bool EnvironmentVariableReader::getSetting(const char *settingName, bool defaultValue) { return getSetting(settingName, static_cast(defaultValue)) ? true : false; } +int32_t EnvironmentVariableReader::getSetting(const char *settingName, int32_t defaultValue, DebugVarPrefix &type) { + return static_cast(getSetting(settingName, static_cast(defaultValue), type)); +} + int32_t EnvironmentVariableReader::getSetting(const char *settingName, int32_t defaultValue) { return static_cast(getSetting(settingName, static_cast(defaultValue))); } +int64_t EnvironmentVariableReader::getSetting(const char *settingName, int64_t defaultValue, DebugVarPrefix &type) { + int64_t value = defaultValue; + char *envValue; + + const std::vector prefixString = ApiSpecificConfig::getPrefixStrings(); + const std::vector prefixType = ApiSpecificConfig::getPrefixTypes(); + char neoFinal[MAX_NEO_KEY_LENGTH]; + uint32_t i = 0; + + for (const auto &prefix : prefixString) { + strcpy_s(neoFinal, strlen(prefix) + 1, prefix); + strcpy_s(neoFinal + strlen(prefix), strlen(settingName) + 1, settingName); + envValue = IoFunctions::getenvPtr(neoFinal); + if (envValue) { + value = atoll(envValue); + type = prefixType[i]; + return value; + } + i++; + } + type = DebugVarPrefix::None; + return value; +} + int64_t EnvironmentVariableReader::getSetting(const char *settingName, int64_t defaultValue) { int64_t value = defaultValue; char *envValue; @@ -34,6 +69,31 @@ int64_t EnvironmentVariableReader::getSetting(const char *settingName, int64_t d return value; } +std::string EnvironmentVariableReader::getSetting(const char *settingName, const std::string &value, DebugVarPrefix &type) { + char *envValue; + std::string keyValue; + keyValue.assign(value); + + const std::vector prefixString = ApiSpecificConfig::getPrefixStrings(); + const std::vector prefixType = ApiSpecificConfig::getPrefixTypes(); + + char neoFinal[MAX_NEO_KEY_LENGTH]; + uint32_t i = 0; + for (const auto &prefix : prefixString) { + strcpy_s(neoFinal, strlen(prefix) + 1, prefix); + strcpy_s(neoFinal + strlen(prefix), strlen(settingName) + 1, settingName); + envValue = IoFunctions::getenvPtr(neoFinal); + if (envValue) { + keyValue.assign(envValue); + type = prefixType[i]; + return keyValue; + } + i++; + } + type = DebugVarPrefix::None; + return keyValue; +} + std::string EnvironmentVariableReader::getSetting(const char *settingName, const std::string &value) { char *envValue; std::string keyValue; diff --git a/shared/source/os_interface/debug_env_reader.h b/shared/source/os_interface/debug_env_reader.h index d1812708ec..27e2ce9ab1 100644 --- a/shared/source/os_interface/debug_env_reader.h +++ b/shared/source/os_interface/debug_env_reader.h @@ -14,9 +14,13 @@ namespace NEO { class EnvironmentVariableReader : public SettingsReader { public: + int32_t getSetting(const char *settingName, int32_t defaultValue, DebugVarPrefix &type) override; int32_t getSetting(const char *settingName, int32_t defaultValue) override; + int64_t getSetting(const char *settingName, int64_t defaultValue, DebugVarPrefix &type) override; int64_t getSetting(const char *settingName, int64_t defaultValue) override; + bool getSetting(const char *settingName, bool defaultValue, DebugVarPrefix &type) override; bool getSetting(const char *settingName, bool defaultValue) override; + std::string getSetting(const char *settingName, const std::string &value, DebugVarPrefix &type) override; std::string getSetting(const char *settingName, const std::string &value) override; const char *appSpecificLocation(const std::string &name) override; }; diff --git a/shared/source/os_interface/windows/debug_registry_reader.cpp b/shared/source/os_interface/windows/debug_registry_reader.cpp index 1d9753ab5d..3469eac0ca 100644 --- a/shared/source/os_interface/windows/debug_registry_reader.cpp +++ b/shared/source/os_interface/windows/debug_registry_reader.cpp @@ -8,6 +8,7 @@ #include "shared/source/os_interface/windows/debug_registry_reader.h" #include "shared/source/debug_settings/debug_settings_manager.h" +#include "shared/source/helpers/api_specific_config.h" #include "shared/source/os_interface/windows/sys_calls.h" #include "shared/source/os_interface/windows/windows_wrapper.h" #include "shared/source/utilities/debug_settings_reader.h" @@ -43,19 +44,26 @@ const char *RegistryReader::appSpecificLocation(const std::string &name) { return name.c_str(); } +bool RegistryReader::getSetting(const char *settingName, bool defaultValue, DebugVarPrefix &type) { + return getSetting(settingName, static_cast(defaultValue), type) ? true : false; +} + bool RegistryReader::getSetting(const char *settingName, bool defaultValue) { return getSetting(settingName, static_cast(defaultValue)) ? true : false; } +int32_t RegistryReader::getSetting(const char *settingName, int32_t defaultValue, DebugVarPrefix &type) { + return static_cast(getSetting(settingName, static_cast(defaultValue), type)); +} + int32_t RegistryReader::getSetting(const char *settingName, int32_t defaultValue) { return static_cast(getSetting(settingName, static_cast(defaultValue))); } -int64_t RegistryReader::getSetting(const char *settingName, int64_t defaultValue) { +bool RegistryReader::getSettingIntCommon(const char *settingName, int64_t &value) { HKEY Key{}; - int64_t value = defaultValue; DWORD success = ERROR_SUCCESS; - bool readSettingFromEnv = true; + bool retVal = false; success = SysCalls::regOpenKeyExA(hkeyType, registryReadRootKey.c_str(), @@ -75,11 +83,44 @@ int64_t RegistryReader::getSetting(const char *settingName, int64_t defaultValue &size); if (ERROR_SUCCESS == success) { value = regData; - readSettingFromEnv = false; + retVal = true; } RegCloseKey(Key); } - if (readSettingFromEnv) { + return retVal; +} + +int64_t RegistryReader::getSetting(const char *settingName, int64_t defaultValue, DebugVarPrefix &type) { + int64_t value = defaultValue; + + if (!(getSettingIntCommon(settingName, value))) { + char *envValue; + + const std::vector prefixString = ApiSpecificConfig::getPrefixStrings(); + const std::vector prefixType = ApiSpecificConfig::getPrefixTypes(); + + char neoFinal[MAX_NEO_KEY_LENGTH]; + uint32_t i = 0; + for (const auto &prefix : prefixString) { + strcpy_s(neoFinal, strlen(prefix) + 1, prefix); + strcpy_s(neoFinal + strlen(prefix), strlen(settingName) + 1, settingName); + envValue = getenv(neoFinal); + if (envValue) { + value = atoll(envValue); + type = prefixType[i]; + return value; + } + i++; + } + } + type = DebugVarPrefix::None; + return value; +} + +int64_t RegistryReader::getSetting(const char *settingName, int64_t defaultValue) { + int64_t value = defaultValue; + + if (!(getSettingIntCommon(settingName, value))) { const char *envValue = getenv(settingName); if (envValue) { value = atoll(envValue); @@ -89,11 +130,10 @@ int64_t RegistryReader::getSetting(const char *settingName, int64_t defaultValue return value; } -std::string RegistryReader::getSetting(const char *settingName, const std::string &value) { +bool RegistryReader::getSettingStringCommon(const char *settingName, std::string &keyValue) { HKEY Key{}; DWORD success = ERROR_SUCCESS; - std::string keyValue = value; - bool readSettingFromEnv = true; + bool retVal = false; success = SysCalls::regOpenKeyExA(hkeyType, registryReadRootKey.c_str(), @@ -121,7 +161,7 @@ std::string RegistryReader::getSetting(const char *settingName, const std::strin ®Size); if (success == ERROR_SUCCESS) { keyValue.assign(regData.get()); - readSettingFromEnv = false; + retVal = true; } } else if (regType == REG_BINARY) { size_t charCount = regSize / sizeof(wchar_t); @@ -140,14 +180,46 @@ std::string RegistryReader::getSetting(const char *settingName, const std::strin convertedData.get()[charCount] = 0; keyValue.assign(convertedData.get()); - readSettingFromEnv = false; + retVal = true; } } } RegCloseKey(Key); } + return retVal; +} - if (readSettingFromEnv) { +std::string RegistryReader::getSetting(const char *settingName, const std::string &value, DebugVarPrefix &type) { + std::string keyValue = value; + + if (!(getSettingStringCommon(settingName, keyValue))) { + char *envValue; + + const std::vector prefixString = ApiSpecificConfig::getPrefixStrings(); + const std::vector prefixType = ApiSpecificConfig::getPrefixTypes(); + + char neoFinal[MAX_NEO_KEY_LENGTH]; + uint32_t i = 0; + for (const auto &prefix : prefixString) { + strcpy_s(neoFinal, strlen(prefix) + 1, prefix); + strcpy_s(neoFinal + strlen(prefix), strlen(settingName) + 1, settingName); + envValue = strcmp(processName.c_str(), neoFinal) ? getenv(neoFinal) : getenv("cl_cache_dir"); + if (envValue) { + keyValue.assign(envValue); + type = prefixType[i]; + return keyValue; + } + i++; + } + } + type = DebugVarPrefix::None; + return keyValue; +} + +std::string RegistryReader::getSetting(const char *settingName, const std::string &value) { + std::string keyValue = value; + + if (!(getSettingStringCommon(settingName, keyValue))) { const char *envValue = strcmp(processName.c_str(), settingName) ? getenv(settingName) : getenv("cl_cache_dir"); if (envValue) { keyValue.assign(envValue); diff --git a/shared/source/os_interface/windows/debug_registry_reader.h b/shared/source/os_interface/windows/debug_registry_reader.h index 8f3706e9e4..ae7a62fa51 100644 --- a/shared/source/os_interface/windows/debug_registry_reader.h +++ b/shared/source/os_interface/windows/debug_registry_reader.h @@ -15,13 +15,22 @@ #include namespace NEO { + +enum class DebugVarPrefix : uint8_t; + class RegistryReader : public SettingsReader { public: RegistryReader() = delete; RegistryReader(bool userScope, const std::string ®Key); + bool getSettingIntCommon(const char *settingName, int64_t &value); + bool getSettingStringCommon(const char *settingName, std::string &keyValue); + int32_t getSetting(const char *settingName, int32_t defaultValue, DebugVarPrefix &type) override; int32_t getSetting(const char *settingName, int32_t defaultValue) override; + int64_t getSetting(const char *settingName, int64_t defaultValue, DebugVarPrefix &type) override; int64_t getSetting(const char *settingName, int64_t defaultValue) override; + bool getSetting(const char *settingName, bool defaultValue, DebugVarPrefix &type) override; bool getSetting(const char *settingName, bool defaultValue) override; + std::string getSetting(const char *settingName, const std::string &value, DebugVarPrefix &type) override; std::string getSetting(const char *settingName, const std::string &value) override; const char *appSpecificLocation(const std::string &name) override; diff --git a/shared/source/utilities/debug_file_reader.cpp b/shared/source/utilities/debug_file_reader.cpp index a1ad2e592c..9e8e8f24c8 100644 --- a/shared/source/utilities/debug_file_reader.cpp +++ b/shared/source/utilities/debug_file_reader.cpp @@ -7,6 +7,7 @@ #include "shared/source/utilities/debug_file_reader.h" +#include "shared/source/helpers/api_specific_config.h" #include "shared/source/helpers/debug_helpers.h" #include @@ -30,10 +31,37 @@ SettingsFileReader::~SettingsFileReader() { settingStringMap.clear(); } +int32_t SettingsFileReader::getSetting(const char *settingName, int32_t defaultValue, DebugVarPrefix &type) { + return static_cast(getSetting(settingName, static_cast(defaultValue), type)); +} + int32_t SettingsFileReader::getSetting(const char *settingName, int32_t defaultValue) { return static_cast(getSetting(settingName, static_cast(defaultValue))); } +int64_t SettingsFileReader::getSetting(const char *settingName, int64_t defaultValue, DebugVarPrefix &type) { + int64_t value = defaultValue; + + const std::vector prefixString = ApiSpecificConfig::getPrefixStrings(); + const std::vector prefixType = ApiSpecificConfig::getPrefixTypes(); + + char neoFinal[MAX_NEO_KEY_LENGTH]; + uint32_t i = 0; + for (const auto &prefix : prefixString) { + strcpy_s(neoFinal, strlen(prefix) + 1, prefix); + strcpy_s(neoFinal + strlen(prefix), strlen(settingName) + 1, settingName); + std::map::iterator it = settingStringMap.find(std::string(neoFinal)); + if (it != settingStringMap.end()) { + value = strtoll(it->second.c_str(), nullptr, 0); + type = prefixType[i]; + return value; + } + i++; + } + type = DebugVarPrefix::None; + return value; +} + int64_t SettingsFileReader::getSetting(const char *settingName, int64_t defaultValue) { int64_t value = defaultValue; @@ -45,10 +73,37 @@ int64_t SettingsFileReader::getSetting(const char *settingName, int64_t defaultV return value; } +bool SettingsFileReader::getSetting(const char *settingName, bool defaultValue, DebugVarPrefix &type) { + return getSetting(settingName, static_cast(defaultValue), type) ? true : false; +} + bool SettingsFileReader::getSetting(const char *settingName, bool defaultValue) { return getSetting(settingName, static_cast(defaultValue)) ? true : false; } +std::string SettingsFileReader::getSetting(const char *settingName, const std::string &value, DebugVarPrefix &type) { + std::string returnValue = value; + + const std::vector prefixString = ApiSpecificConfig::getPrefixStrings(); + const std::vector prefixType = ApiSpecificConfig::getPrefixTypes(); + + char neoFinal[MAX_NEO_KEY_LENGTH]; + uint32_t i = 0; + for (const auto &prefix : prefixString) { + strcpy_s(neoFinal, strlen(prefix) + 1, prefix); + strcpy_s(neoFinal + strlen(prefix), strlen(settingName) + 1, settingName); + std::map::iterator it = settingStringMap.find(std::string(neoFinal)); + if (it != settingStringMap.end()) { + returnValue = it->second; + type = prefixType[i]; + return returnValue; + } + i++; + } + type = DebugVarPrefix::None; + return returnValue; +} + std::string SettingsFileReader::getSetting(const char *settingName, const std::string &value) { std::string returnValue = value; std::map::iterator it = settingStringMap.find(std::string(settingName)); diff --git a/shared/source/utilities/debug_file_reader.h b/shared/source/utilities/debug_file_reader.h index 7f8fee0af5..62bec06fff 100644 --- a/shared/source/utilities/debug_file_reader.h +++ b/shared/source/utilities/debug_file_reader.h @@ -15,13 +15,19 @@ namespace NEO { +enum class DebugVarPrefix : uint8_t; + class SettingsFileReader : public SettingsReader { public: SettingsFileReader(const char *filePath); ~SettingsFileReader() override; + int32_t getSetting(const char *settingName, int32_t defaultValue, DebugVarPrefix &type) override; int32_t getSetting(const char *settingName, int32_t defaultValue) override; + int64_t getSetting(const char *settingName, int64_t defaultValue, DebugVarPrefix &type) override; int64_t getSetting(const char *settingName, int64_t defaultValue) override; + bool getSetting(const char *settingName, bool defaultValue, DebugVarPrefix &type) override; bool getSetting(const char *settingName, bool defaultValue) override; + std::string getSetting(const char *settingName, const std::string &value, DebugVarPrefix &type) override; std::string getSetting(const char *settingName, const std::string &value) override; const char *appSpecificLocation(const std::string &name) override; diff --git a/shared/source/utilities/debug_settings_reader.cpp b/shared/source/utilities/debug_settings_reader.cpp index c387a4becc..c971ff83f0 100644 --- a/shared/source/utilities/debug_settings_reader.cpp +++ b/shared/source/utilities/debug_settings_reader.cpp @@ -10,17 +10,24 @@ #include "shared/source/utilities/debug_file_reader.h" #include +#include namespace NEO { const char *SettingsReader::settingsFileName = "igdrcl.config"; +const char *SettingsReader::neoSettingsFileName = "neo.config"; SettingsReader *SettingsReader::createFileReader() { std::ifstream settingsFile; - settingsFile.open(settingsFileName); - if (settingsFile.is_open()) { - settingsFile.close(); - return new SettingsFileReader(settingsFileName); + std::vector fileName; + fileName.push_back(settingsFileName); + fileName.push_back(neoSettingsFileName); + for (const auto &file : fileName) { + settingsFile.open(file); + if (settingsFile.is_open()) { + settingsFile.close(); + return new SettingsFileReader(file); + } } return nullptr; } diff --git a/shared/source/utilities/debug_settings_reader.h b/shared/source/utilities/debug_settings_reader.h index 1bbe31639a..6e4ba4a6d5 100644 --- a/shared/source/utilities/debug_settings_reader.h +++ b/shared/source/utilities/debug_settings_reader.h @@ -11,6 +11,8 @@ namespace NEO { +enum class DebugVarPrefix : uint8_t; + class SettingsReader { public: virtual ~SettingsReader() = default; @@ -23,12 +25,17 @@ class SettingsReader { } static SettingsReader *createOsReader(bool userScope, const std::string ®Key); static SettingsReader *createFileReader(); + virtual int32_t getSetting(const char *settingName, int32_t defaultValue, DebugVarPrefix &type) = 0; virtual int32_t getSetting(const char *settingName, int32_t defaultValue) = 0; + virtual int64_t getSetting(const char *settingName, int64_t defaultValue, DebugVarPrefix &type) = 0; virtual int64_t getSetting(const char *settingName, int64_t defaultValue) = 0; + virtual bool getSetting(const char *settingName, bool defaultValue, DebugVarPrefix &type) = 0; virtual bool getSetting(const char *settingName, bool defaultValue) = 0; + virtual std::string getSetting(const char *settingName, const std::string &value, DebugVarPrefix &type) = 0; virtual std::string getSetting(const char *settingName, const std::string &value) = 0; virtual const char *appSpecificLocation(const std::string &name) = 0; static const char *settingsFileName; + static const char *neoSettingsFileName; MOCKABLE_VIRTUAL char *getenv(const char *settingName); }; }; // namespace NEO diff --git a/shared/test/common/test_files/neo_string.config b/shared/test/common/test_files/neo_string.config new file mode 100644 index 0000000000..969128ea92 --- /dev/null +++ b/shared/test/common/test_files/neo_string.config @@ -0,0 +1,6 @@ +StringTestKey = IncorrectValue +IntTestKey = 888 +IntTestKeyHex = 0xFACE +NEO_StringTestKey = TestValue +NEO_IntTestKey = 123 +NEO_IntTestKeyHex = 0xABCD \ No newline at end of file diff --git a/shared/test/unit_test/debug_settings/debug_settings_manager_tests.cpp b/shared/test/unit_test/debug_settings/debug_settings_manager_tests.cpp index 8f50f4c495..241866c4da 100644 --- a/shared/test/unit_test/debug_settings/debug_settings_manager_tests.cpp +++ b/shared/test/unit_test/debug_settings/debug_settings_manager_tests.cpp @@ -5,6 +5,7 @@ * */ +#include "shared/source/helpers/api_specific_config.h" #include "shared/source/memory_manager/graphics_allocation.h" #include "shared/source/memory_manager/memory_manager.h" #include "shared/source/utilities/debug_file_reader.h" @@ -21,6 +22,10 @@ #include #include +namespace NEO { +extern ApiSpecificConfig::ApiType apiTypeForUlts; +} // namespace NEO + TEST(DebugSettingsManager, WhenDebugManagerIsCreatedThenInjectFcnIsNull) { FullyEnabledTestDebugManager debugManager; @@ -114,13 +119,19 @@ TEST(DebugSettingsManager, givenReaderImplInDebugManagerWhenSettingDifferentRead EXPECT_EQ(readerImpl2, debugManager.getReaderImpl()); } -TEST(DebugSettingsManager, givenPrintDebugSettingsEnabledWhenCallingDumpFlagsThenFlagsAreWrittenToDumpFile) { +TEST(DebugSettingsManager, givenPrintDebugSettingsEnabledWithNoPrefixWhenCallingDumpFlagsThenFlagsAreWrittenToDumpFile) { testing::internal::CaptureStdout(); FullyEnabledTestDebugManager debugManager; + + VariableBackup backup(&apiTypeForUlts, ApiSpecificConfig::L0); debugManager.flags.PrintDebugSettings.set(true); + debugManager.flags.PrintDebugSettings.setPrefixType(DebugVarPrefix::None); debugManager.flags.LoopAtDriverInit.set(true); + debugManager.flags.LoopAtDriverInit.setPrefixType(DebugVarPrefix::None); debugManager.flags.Enable64kbpages.set(1); + debugManager.flags.Enable64kbpages.setPrefixType(DebugVarPrefix::None); debugManager.flags.TbxServer.set("192.168.0.1"); + debugManager.flags.TbxServer.setPrefixType(DebugVarPrefix::None); // Clear dump files and generate new std::remove(FullyEnabledTestDebugManager::settingsDumpFileName); @@ -128,11 +139,15 @@ TEST(DebugSettingsManager, givenPrintDebugSettingsEnabledWhenCallingDumpFlagsThe // Validate allSettingsDumpFile SettingsFileReader allSettingsReader{FullyEnabledTestDebugManager::settingsDumpFileName}; -#define DECLARE_DEBUG_VARIABLE(dataType, varName, defaultValue, description) \ - EXPECT_EQ(debugManager.flags.varName.get(), allSettingsReader.getSetting(#varName, defaultValue)); +#define DECLARE_DEBUG_VARIABLE(dataType, varName, defaultValue, description) \ + { \ + DebugVarPrefix type; \ + EXPECT_EQ(debugManager.flags.varName.get(), allSettingsReader.getSetting(#varName, defaultValue, type)); \ + } #include "debug_variables.inl" #undef DECLARE_DEBUG_VARIABLE + std::remove(FullyEnabledTestDebugManager::settingsDumpFileName); std::string output = testing::internal::GetCapturedStdout(); ASSERT_NE(0u, output.size()); @@ -143,6 +158,162 @@ TEST(DebugSettingsManager, givenPrintDebugSettingsEnabledWhenCallingDumpFlagsThe EXPECT_NE(std::string::npos, output.find("Non-default value of debug variable: Enable64kbpages = 1")); } +TEST(DebugSettingsManager, givenPrintDebugSettingsEnabledWithNeoPrefixWhenCallingDumpFlagsThenFlagsAreWrittenToDumpFile) { + testing::internal::CaptureStdout(); + FullyEnabledTestDebugManager debugManager; + + VariableBackup backup(&apiTypeForUlts, ApiSpecificConfig::L0); + debugManager.flags.PrintDebugSettings.set(true); + debugManager.flags.PrintDebugSettings.setPrefixType(DebugVarPrefix::Neo); + debugManager.flags.LoopAtDriverInit.set(true); + debugManager.flags.LoopAtDriverInit.setPrefixType(DebugVarPrefix::Neo); + debugManager.flags.Enable64kbpages.set(1); + debugManager.flags.Enable64kbpages.setPrefixType(DebugVarPrefix::Neo); + debugManager.flags.TbxServer.set("192.168.0.1"); + debugManager.flags.TbxServer.setPrefixType(DebugVarPrefix::Neo); + + // Clear dump files and generate new + std::remove(FullyEnabledTestDebugManager::settingsDumpFileName); + debugManager.dumpFlags(); + + // Validate allSettingsDumpFile + SettingsFileReader allSettingsReader{FullyEnabledTestDebugManager::settingsDumpFileName}; +#define DECLARE_DEBUG_VARIABLE(dataType, varName, defaultValue, description) \ + { \ + DebugVarPrefix type; \ + EXPECT_EQ(debugManager.flags.varName.get(), allSettingsReader.getSetting(#varName, defaultValue, type)); \ + } + +#include "debug_variables.inl" +#undef DECLARE_DEBUG_VARIABLE + + std::remove(FullyEnabledTestDebugManager::settingsDumpFileName); + std::string output = testing::internal::GetCapturedStdout(); + ASSERT_NE(0u, output.size()); + + EXPECT_NE(std::string::npos, output.find("Non-default value of debug variable: NEO_TbxServer = 192.168.0.1")); + EXPECT_NE(std::string::npos, output.find("Non-default value of debug variable: NEO_LoopAtDriverInit = 1")); + EXPECT_NE(std::string::npos, output.find("Non-default value of debug variable: NEO_PrintDebugSettings = 1")); + EXPECT_NE(std::string::npos, output.find("Non-default value of debug variable: NEO_Enable64kbpages = 1")); +} + +TEST(DebugSettingsManager, givenPrintDebugSettingsEnabledWithLevelZeroPrefixWhenCallingDumpFlagsThenFlagsAreWrittenToDumpFile) { + testing::internal::CaptureStdout(); + FullyEnabledTestDebugManager debugManager; + + VariableBackup backup(&apiTypeForUlts, ApiSpecificConfig::L0); + debugManager.flags.PrintDebugSettings.set(true); + debugManager.flags.PrintDebugSettings.setPrefixType(DebugVarPrefix::Neo_L0); + debugManager.flags.LoopAtDriverInit.set(true); + debugManager.flags.LoopAtDriverInit.setPrefixType(DebugVarPrefix::Neo_L0); + debugManager.flags.Enable64kbpages.set(1); + debugManager.flags.Enable64kbpages.setPrefixType(DebugVarPrefix::Neo_L0); + debugManager.flags.TbxServer.set("192.168.0.1"); + debugManager.flags.TbxServer.setPrefixType(DebugVarPrefix::Neo_L0); + + // Clear dump files and generate new + std::remove(FullyEnabledTestDebugManager::settingsDumpFileName); + debugManager.dumpFlags(); + + // Validate allSettingsDumpFile + SettingsFileReader allSettingsReader{FullyEnabledTestDebugManager::settingsDumpFileName}; +#define DECLARE_DEBUG_VARIABLE(dataType, varName, defaultValue, description) \ + { \ + DebugVarPrefix type; \ + EXPECT_EQ(debugManager.flags.varName.get(), allSettingsReader.getSetting(#varName, defaultValue, type)); \ + } + +#include "debug_variables.inl" +#undef DECLARE_DEBUG_VARIABLE + + std::remove(FullyEnabledTestDebugManager::settingsDumpFileName); + std::string output = testing::internal::GetCapturedStdout(); + ASSERT_NE(0u, output.size()); + + EXPECT_NE(std::string::npos, output.find("Non-default value of debug variable: NEO_L0_TbxServer = 192.168.0.1")); + EXPECT_NE(std::string::npos, output.find("Non-default value of debug variable: NEO_L0_LoopAtDriverInit = 1")); + EXPECT_NE(std::string::npos, output.find("Non-default value of debug variable: NEO_L0_PrintDebugSettings = 1")); + EXPECT_NE(std::string::npos, output.find("Non-default value of debug variable: NEO_L0_Enable64kbpages = 1")); +} + +TEST(DebugSettingsManager, givenPrintDebugSettingsEnabledWithOclPrefixWhenCallingDumpFlagsThenFlagsAreWrittenToDumpFile) { + testing::internal::CaptureStdout(); + FullyEnabledTestDebugManager debugManager; + + VariableBackup backup(&apiTypeForUlts, ApiSpecificConfig::OCL); + debugManager.flags.PrintDebugSettings.set(true); + debugManager.flags.PrintDebugSettings.setPrefixType(DebugVarPrefix::Neo_Ocl); + debugManager.flags.LoopAtDriverInit.set(true); + debugManager.flags.LoopAtDriverInit.setPrefixType(DebugVarPrefix::Neo_Ocl); + debugManager.flags.Enable64kbpages.set(1); + debugManager.flags.Enable64kbpages.setPrefixType(DebugVarPrefix::Neo_Ocl); + debugManager.flags.TbxServer.set("192.168.0.1"); + debugManager.flags.TbxServer.setPrefixType(DebugVarPrefix::Neo_Ocl); + + // Clear dump files and generate new + std::remove(FullyEnabledTestDebugManager::settingsDumpFileName); + debugManager.dumpFlags(); + + // Validate allSettingsDumpFile + SettingsFileReader allSettingsReader{FullyEnabledTestDebugManager::settingsDumpFileName}; +#define DECLARE_DEBUG_VARIABLE(dataType, varName, defaultValue, description) \ + { \ + DebugVarPrefix type; \ + EXPECT_EQ(debugManager.flags.varName.get(), allSettingsReader.getSetting(#varName, defaultValue, type)); \ + } + +#include "debug_variables.inl" +#undef DECLARE_DEBUG_VARIABLE + + std::remove(FullyEnabledTestDebugManager::settingsDumpFileName); + std::string output = testing::internal::GetCapturedStdout(); + ASSERT_NE(0u, output.size()); + + EXPECT_NE(std::string::npos, output.find("Non-default value of debug variable: NEO_OCL_TbxServer = 192.168.0.1")); + EXPECT_NE(std::string::npos, output.find("Non-default value of debug variable: NEO_OCL_LoopAtDriverInit = 1")); + EXPECT_NE(std::string::npos, output.find("Non-default value of debug variable: NEO_OCL_PrintDebugSettings = 1")); + EXPECT_NE(std::string::npos, output.find("Non-default value of debug variable: NEO_OCL_Enable64kbpages = 1")); +} + +TEST(DebugSettingsManager, givenPrintDebugSettingsEnabledWithMixedPrefixWhenCallingDumpFlagsThenFlagsAreWrittenToDumpFile) { + testing::internal::CaptureStdout(); + FullyEnabledTestDebugManager debugManager; + + VariableBackup backup(&apiTypeForUlts, ApiSpecificConfig::L0); + debugManager.flags.PrintDebugSettings.set(true); + debugManager.flags.PrintDebugSettings.setPrefixType(DebugVarPrefix::Neo_L0); + debugManager.flags.LoopAtDriverInit.set(true); + debugManager.flags.LoopAtDriverInit.setPrefixType(DebugVarPrefix::Neo); + debugManager.flags.Enable64kbpages.set(1); + debugManager.flags.Enable64kbpages.setPrefixType(DebugVarPrefix::None); + debugManager.flags.TbxServer.set("192.168.0.1"); + debugManager.flags.TbxServer.setPrefixType(DebugVarPrefix::Neo_L0); + + // Clear dump files and generate new + std::remove(FullyEnabledTestDebugManager::settingsDumpFileName); + debugManager.dumpFlags(); + + // Validate allSettingsDumpFile + SettingsFileReader allSettingsReader{FullyEnabledTestDebugManager::settingsDumpFileName}; +#define DECLARE_DEBUG_VARIABLE(dataType, varName, defaultValue, description) \ + { \ + DebugVarPrefix type; \ + EXPECT_EQ(debugManager.flags.varName.get(), allSettingsReader.getSetting(#varName, defaultValue, type)); \ + } + +#include "debug_variables.inl" +#undef DECLARE_DEBUG_VARIABLE + + std::remove(FullyEnabledTestDebugManager::settingsDumpFileName); + std::string output = testing::internal::GetCapturedStdout(); + ASSERT_NE(0u, output.size()); + + EXPECT_NE(std::string::npos, output.find("Non-default value of debug variable: NEO_L0_TbxServer = 192.168.0.1")); + EXPECT_NE(std::string::npos, output.find("Non-default value of debug variable: NEO_LoopAtDriverInit = 1")); + EXPECT_NE(std::string::npos, output.find("Non-default value of debug variable: NEO_L0_PrintDebugSettings = 1")); + EXPECT_NE(std::string::npos, output.find("Non-default value of debug variable: Enable64kbpages = 1")); +} + TEST(DebugSettingsManager, givenPrintDebugSettingsEnabledOnDisabledDebugManagerWhenCallingDumpFlagsThenFlagsAreNotWrittenToDumpFile) { testing::internal::CaptureStdout(); FullyDisabledTestDebugManager debugManager; diff --git a/shared/test/unit_test/os_interface/linux/debug_env_reader.cpp b/shared/test/unit_test/os_interface/linux/debug_env_reader.cpp index af1edc8f3b..37bfa93d9a 100644 --- a/shared/test/unit_test/os_interface/linux/debug_env_reader.cpp +++ b/shared/test/unit_test/os_interface/linux/debug_env_reader.cpp @@ -7,6 +7,7 @@ #include "shared/source/os_interface/debug_env_reader.h" +#include "shared/source/helpers/api_specific_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" @@ -16,6 +17,8 @@ namespace NEO { +extern ApiSpecificConfig::ApiType apiTypeForUlts; + class DebugEnvReaderTests : public ::testing::Test { public: void SetUp() override { @@ -65,6 +68,366 @@ TEST_F(DebugEnvReaderTests, GivenSetVariableThenSetValueIsReturned) { } } +TEST_F(DebugEnvReaderTests, GivenSetVariableWithNoPrefixThenSetValueIsReturned) { + int32_t ret; + std::string retString; + std::string defaultString = "Default Value"; + std::string setString = "Expected Value"; + const char *testingVariableName = "TestingVariable"; + const char *testingVariableValue = "1234"; + bool defaultBoolValue = true; + VariableBackup backup(&apiTypeForUlts, ApiSpecificConfig::L0); + { + VariableBackup mockGetenvCalledBackup(&IoFunctions::mockGetenvCalled, 0); + std::unordered_map mockableEnvs = {{testingVariableName, testingVariableValue}}; + VariableBackup *> mockableEnvValuesBackup(&IoFunctions::mockableEnvValues, &mockableEnvs); + DebugVarPrefix type = DebugVarPrefix::None; + + ret = evr->getSetting(testingVariableName, 1, type); + EXPECT_EQ(3u, IoFunctions::mockGetenvCalled); + EXPECT_EQ(DebugVarPrefix::None, type); + EXPECT_EQ(1234, ret); + } + { + VariableBackup mockGetenvCalledBackup(&IoFunctions::mockGetenvCalled, 0); + std::unordered_map mockableEnvs = {{testingVariableName, setString.c_str()}}; + VariableBackup *> mockableEnvValuesBackup(&IoFunctions::mockableEnvValues, &mockableEnvs); + DebugVarPrefix type = DebugVarPrefix::None; + + retString = evr->getSetting("TestingVariable", defaultString, type); + EXPECT_EQ(3u, IoFunctions::mockGetenvCalled); + EXPECT_EQ(DebugVarPrefix::None, type); + EXPECT_EQ(0, retString.compare(setString)); + } + { + VariableBackup mockGetenvCalledBackup(&IoFunctions::mockGetenvCalled, 0); + std::unordered_map mockableEnvs = {{testingVariableName, "0"}}; + VariableBackup *> mockableEnvValuesBackup(&IoFunctions::mockableEnvValues, &mockableEnvs); + DebugVarPrefix type = DebugVarPrefix::None; + + ret = evr->getSetting(testingVariableName, defaultBoolValue, type); + EXPECT_EQ(3u, IoFunctions::mockGetenvCalled); + EXPECT_EQ(DebugVarPrefix::None, type); + EXPECT_EQ(0, ret); + } +} + +TEST_F(DebugEnvReaderTests, GivenSetVariableWithNeoPrefixThenSetValueIsReturned) { + int32_t ret; + std::string retString; + std::string defaultString = "Default Value"; + std::string setString = "Expected Value"; + const char *testingVariableName = "TestingVariable"; + const char *neoTestingVariableName = "NEO_TestingVariable"; + const char *testingVariableValue = "1234"; + bool defaultBoolValue = true; + VariableBackup backup(&apiTypeForUlts, ApiSpecificConfig::L0); + { + VariableBackup mockGetenvCalledBackup(&IoFunctions::mockGetenvCalled, 0); + std::unordered_map mockableEnvs = {{neoTestingVariableName, testingVariableValue}}; + VariableBackup *> mockableEnvValuesBackup(&IoFunctions::mockableEnvValues, &mockableEnvs); + DebugVarPrefix type = DebugVarPrefix::None; + + ret = evr->getSetting(testingVariableName, 1, type); + EXPECT_EQ(2u, IoFunctions::mockGetenvCalled); + EXPECT_EQ(DebugVarPrefix::Neo, type); + EXPECT_EQ(1234, ret); + } + { + VariableBackup mockGetenvCalledBackup(&IoFunctions::mockGetenvCalled, 0); + std::unordered_map mockableEnvs = {{neoTestingVariableName, setString.c_str()}}; + VariableBackup *> mockableEnvValuesBackup(&IoFunctions::mockableEnvValues, &mockableEnvs); + DebugVarPrefix type = DebugVarPrefix::None; + + retString = evr->getSetting("TestingVariable", defaultString, type); + EXPECT_EQ(2u, IoFunctions::mockGetenvCalled); + EXPECT_EQ(DebugVarPrefix::Neo, type); + EXPECT_EQ(0, retString.compare(setString)); + } + { + VariableBackup mockGetenvCalledBackup(&IoFunctions::mockGetenvCalled, 0); + std::unordered_map mockableEnvs = {{neoTestingVariableName, "0"}}; + VariableBackup *> mockableEnvValuesBackup(&IoFunctions::mockableEnvValues, &mockableEnvs); + DebugVarPrefix type = DebugVarPrefix::None; + + ret = evr->getSetting(testingVariableName, defaultBoolValue, type); + EXPECT_EQ(2u, IoFunctions::mockGetenvCalled); + EXPECT_EQ(DebugVarPrefix::Neo, type); + EXPECT_EQ(0, ret); + } +} + +TEST_F(DebugEnvReaderTests, GivenSetVariableWithOclPrefixThenSetValueIsReturned) { + int32_t ret; + std::string retString; + std::string defaultString = "Default Value"; + std::string setString = "Expected Value"; + const char *testingVariableName = "TestingVariable"; + const char *oclTestingVariableName = "NEO_OCL_TestingVariable"; + const char *testingVariableValue = "1234"; + bool defaultBoolValue = true; + VariableBackup backup(&apiTypeForUlts, ApiSpecificConfig::OCL); + { + VariableBackup mockGetenvCalledBackup(&IoFunctions::mockGetenvCalled, 0); + std::unordered_map mockableEnvs = {{oclTestingVariableName, testingVariableValue}}; + VariableBackup *> mockableEnvValuesBackup(&IoFunctions::mockableEnvValues, &mockableEnvs); + DebugVarPrefix type = DebugVarPrefix::None; + + ret = evr->getSetting(testingVariableName, 1, type); + EXPECT_EQ(1u, IoFunctions::mockGetenvCalled); + EXPECT_EQ(DebugVarPrefix::Neo_Ocl, type); + EXPECT_EQ(1234, ret); + } + { + VariableBackup mockGetenvCalledBackup(&IoFunctions::mockGetenvCalled, 0); + std::unordered_map mockableEnvs = {{oclTestingVariableName, setString.c_str()}}; + VariableBackup *> mockableEnvValuesBackup(&IoFunctions::mockableEnvValues, &mockableEnvs); + DebugVarPrefix type = DebugVarPrefix::None; + + retString = evr->getSetting("TestingVariable", defaultString, type); + EXPECT_EQ(1u, IoFunctions::mockGetenvCalled); + EXPECT_EQ(DebugVarPrefix::Neo_Ocl, type); + EXPECT_EQ(0, retString.compare(setString)); + } + { + VariableBackup mockGetenvCalledBackup(&IoFunctions::mockGetenvCalled, 0); + std::unordered_map mockableEnvs = {{oclTestingVariableName, "0"}}; + VariableBackup *> mockableEnvValuesBackup(&IoFunctions::mockableEnvValues, &mockableEnvs); + DebugVarPrefix type = DebugVarPrefix::None; + + ret = evr->getSetting(testingVariableName, defaultBoolValue, type); + EXPECT_EQ(1u, IoFunctions::mockGetenvCalled); + EXPECT_EQ(DebugVarPrefix::Neo_Ocl, type); + EXPECT_EQ(0, ret); + } +} + +TEST_F(DebugEnvReaderTests, GivenSetVariableWithL0PrefixThenSetValueIsReturned) { + int32_t ret; + std::string retString; + std::string defaultString = "Default Value"; + std::string setString = "Expected Value"; + const char *testingVariableName = "TestingVariable"; + const char *lzeroTestingVariableName = "NEO_L0_TestingVariable"; + const char *testingVariableValue = "1234"; + bool defaultBoolValue = true; + VariableBackup backup(&apiTypeForUlts, ApiSpecificConfig::L0); + { + VariableBackup mockGetenvCalledBackup(&IoFunctions::mockGetenvCalled, 0); + std::unordered_map mockableEnvs = {{lzeroTestingVariableName, testingVariableValue}}; + VariableBackup *> mockableEnvValuesBackup(&IoFunctions::mockableEnvValues, &mockableEnvs); + DebugVarPrefix type = DebugVarPrefix::None; + ret = evr->getSetting(testingVariableName, 1, type); + EXPECT_EQ(1u, IoFunctions::mockGetenvCalled); + EXPECT_EQ(DebugVarPrefix::Neo_L0, type); + EXPECT_EQ(1234, ret); + } + { + VariableBackup mockGetenvCalledBackup(&IoFunctions::mockGetenvCalled, 0); + std::unordered_map mockableEnvs = {{lzeroTestingVariableName, setString.c_str()}}; + VariableBackup *> mockableEnvValuesBackup(&IoFunctions::mockableEnvValues, &mockableEnvs); + DebugVarPrefix type = DebugVarPrefix::None; + + retString = evr->getSetting("TestingVariable", defaultString, type); + EXPECT_EQ(1u, IoFunctions::mockGetenvCalled); + EXPECT_EQ(DebugVarPrefix::Neo_L0, type); + EXPECT_EQ(0, retString.compare(setString)); + } + { + VariableBackup mockGetenvCalledBackup(&IoFunctions::mockGetenvCalled, 0); + std::unordered_map mockableEnvs = {{lzeroTestingVariableName, "0"}}; + VariableBackup *> mockableEnvValuesBackup(&IoFunctions::mockableEnvValues, &mockableEnvs); + DebugVarPrefix type = DebugVarPrefix::None; + + ret = evr->getSetting(testingVariableName, defaultBoolValue, type); + EXPECT_EQ(1u, IoFunctions::mockGetenvCalled); + EXPECT_EQ(DebugVarPrefix::Neo_L0, type); + EXPECT_EQ(0, ret); + } +} + +TEST_F(DebugEnvReaderTests, GivenSetVariableWithL0MultiplePrefixesThenHighestPrioritySetValueIsReturned) { + int32_t ret; + std::string retString; + std::string defaultString = "Default Value"; + std::string setString = "Expected Value"; + const char *testingVariableName = "TestingVariable"; + const char *neoTestingVariableName = "NEO_TestingVariable"; + const char *lzeroTestingVariableName = "NEO_L0_TestingVariable"; + const char *testingVariableValue = "1234"; + VariableBackup backup(&apiTypeForUlts, ApiSpecificConfig::L0); + { + VariableBackup mockGetenvCalledBackup(&IoFunctions::mockGetenvCalled, 0); + std::unordered_map mockableEnvs = {{testingVariableName, "1"}, + {neoTestingVariableName, "2"}, + {lzeroTestingVariableName, testingVariableValue}}; + VariableBackup *> mockableEnvValuesBackup(&IoFunctions::mockableEnvValues, &mockableEnvs); + DebugVarPrefix type = DebugVarPrefix::None; + ret = evr->getSetting(testingVariableName, 1, type); + EXPECT_EQ(1u, IoFunctions::mockGetenvCalled); + EXPECT_EQ(DebugVarPrefix::Neo_L0, type); + EXPECT_EQ(1234, ret); + } + { + VariableBackup mockGetenvCalledBackup(&IoFunctions::mockGetenvCalled, 0); + std::unordered_map mockableEnvs = {{testingVariableName, "1"}, + {neoTestingVariableName, "2"}}; + VariableBackup *> mockableEnvValuesBackup(&IoFunctions::mockableEnvValues, &mockableEnvs); + DebugVarPrefix type = DebugVarPrefix::None; + ret = evr->getSetting(testingVariableName, 1, type); + EXPECT_EQ(2u, IoFunctions::mockGetenvCalled); + EXPECT_EQ(DebugVarPrefix::Neo, type); + EXPECT_EQ(2, ret); + } + { + VariableBackup mockGetenvCalledBackup(&IoFunctions::mockGetenvCalled, 0); + std::unordered_map mockableEnvs = {{testingVariableName, "Default None"}, + {neoTestingVariableName, "Default Neo"}, + {lzeroTestingVariableName, setString.c_str()}}; + VariableBackup *> mockableEnvValuesBackup(&IoFunctions::mockableEnvValues, &mockableEnvs); + DebugVarPrefix type = DebugVarPrefix::None; + + retString = evr->getSetting("TestingVariable", defaultString, type); + EXPECT_EQ(1u, IoFunctions::mockGetenvCalled); + EXPECT_EQ(DebugVarPrefix::Neo_L0, type); + EXPECT_EQ(0, retString.compare(setString)); + } + { + VariableBackup mockGetenvCalledBackup(&IoFunctions::mockGetenvCalled, 0); + std::unordered_map mockableEnvs = {{testingVariableName, "Default None"}, + {neoTestingVariableName, "Default Neo"}}; + VariableBackup *> mockableEnvValuesBackup(&IoFunctions::mockableEnvValues, &mockableEnvs); + DebugVarPrefix type = DebugVarPrefix::None; + + retString = evr->getSetting("TestingVariable", defaultString, type); + EXPECT_EQ(2u, IoFunctions::mockGetenvCalled); + EXPECT_EQ(DebugVarPrefix::Neo, type); + EXPECT_EQ(0, retString.compare("Default Neo")); + } +} + +TEST_F(DebugEnvReaderTests, GivenSetVariableWithOclMultipPrefixesThenHighestPrioritySetValueIsReturned) { + int32_t ret; + std::string retString; + std::string defaultString = "Default Value"; + std::string setString = "Expected Value"; + const char *testingVariableName = "TestingVariable"; + const char *neoTestingVariableName = "NEO_TestingVariable"; + const char *oclTestingVariableName = "NEO_OCL_TestingVariable"; + const char *testingVariableValue = "1234"; + VariableBackup backup(&apiTypeForUlts, ApiSpecificConfig::OCL); + { + VariableBackup mockGetenvCalledBackup(&IoFunctions::mockGetenvCalled, 0); + std::unordered_map mockableEnvs = {{testingVariableName, "1"}, + {neoTestingVariableName, "2"}, + {oclTestingVariableName, testingVariableValue}}; + VariableBackup *> mockableEnvValuesBackup(&IoFunctions::mockableEnvValues, &mockableEnvs); + DebugVarPrefix type = DebugVarPrefix::None; + ret = evr->getSetting(testingVariableName, 1, type); + EXPECT_EQ(1u, IoFunctions::mockGetenvCalled); + EXPECT_EQ(DebugVarPrefix::Neo_Ocl, type); + EXPECT_EQ(1234, ret); + } + { + VariableBackup mockGetenvCalledBackup(&IoFunctions::mockGetenvCalled, 0); + std::unordered_map mockableEnvs = {{testingVariableName, "1"}, + {neoTestingVariableName, "2"}}; + VariableBackup *> mockableEnvValuesBackup(&IoFunctions::mockableEnvValues, &mockableEnvs); + DebugVarPrefix type = DebugVarPrefix::None; + ret = evr->getSetting(testingVariableName, 1, type); + EXPECT_EQ(2u, IoFunctions::mockGetenvCalled); + EXPECT_EQ(DebugVarPrefix::Neo, type); + EXPECT_EQ(2, ret); + } + { + VariableBackup mockGetenvCalledBackup(&IoFunctions::mockGetenvCalled, 0); + std::unordered_map mockableEnvs = {{testingVariableName, "Default None"}, + {neoTestingVariableName, "Default Neo"}, + {oclTestingVariableName, setString.c_str()}}; + VariableBackup *> mockableEnvValuesBackup(&IoFunctions::mockableEnvValues, &mockableEnvs); + DebugVarPrefix type = DebugVarPrefix::None; + + retString = evr->getSetting("TestingVariable", defaultString, type); + EXPECT_EQ(1u, IoFunctions::mockGetenvCalled); + EXPECT_EQ(DebugVarPrefix::Neo_Ocl, type); + EXPECT_EQ(0, retString.compare(setString)); + } + { + VariableBackup mockGetenvCalledBackup(&IoFunctions::mockGetenvCalled, 0); + std::unordered_map mockableEnvs = {{testingVariableName, "Default None"}, + {neoTestingVariableName, "Default Neo"}}; + VariableBackup *> mockableEnvValuesBackup(&IoFunctions::mockableEnvValues, &mockableEnvs); + DebugVarPrefix type = DebugVarPrefix::None; + + retString = evr->getSetting("TestingVariable", defaultString, type); + EXPECT_EQ(2u, IoFunctions::mockGetenvCalled); + EXPECT_EQ(DebugVarPrefix::Neo, type); + EXPECT_EQ(0, retString.compare("Default Neo")); + } +} + +TEST_F(DebugEnvReaderTests, GivenSetVariableWithBothOclAndL0PrefixCorrectDriverValueReturned) { + int32_t ret; + std::string retString; + std::string defaultString = "Default Value"; + std::string setString = "Expected Value"; + const char *testingVariableName = "TestingVariable"; + const char *lzeroTestingVariableName = "NEO_L0_TestingVariable"; + const char *oclTestingVariableName = "NEO_OCL_TestingVariable"; + const char *testingVariableValue = "1234"; + + { + VariableBackup backup(&apiTypeForUlts, ApiSpecificConfig::OCL); + VariableBackup mockGetenvCalledBackup(&IoFunctions::mockGetenvCalled, 0); + std::unordered_map mockableEnvs = {{lzeroTestingVariableName, "5678"}, + {oclTestingVariableName, testingVariableValue}}; + VariableBackup *> mockableEnvValuesBackup(&IoFunctions::mockableEnvValues, &mockableEnvs); + DebugVarPrefix type = DebugVarPrefix::None; + ret = evr->getSetting(testingVariableName, 1, type); + EXPECT_EQ(1u, IoFunctions::mockGetenvCalled); + EXPECT_EQ(DebugVarPrefix::Neo_Ocl, type); + EXPECT_EQ(1234, ret); + } + { + VariableBackup backup(&apiTypeForUlts, ApiSpecificConfig::L0); + VariableBackup mockGetenvCalledBackup(&IoFunctions::mockGetenvCalled, 0); + std::unordered_map mockableEnvs = {{lzeroTestingVariableName, "5678"}, + {oclTestingVariableName, testingVariableValue}}; + VariableBackup *> mockableEnvValuesBackup(&IoFunctions::mockableEnvValues, &mockableEnvs); + DebugVarPrefix type = DebugVarPrefix::None; + ret = evr->getSetting(testingVariableName, 1, type); + EXPECT_EQ(1u, IoFunctions::mockGetenvCalled); + EXPECT_EQ(DebugVarPrefix::Neo_L0, type); + EXPECT_EQ(5678, ret); + } + { + VariableBackup backup(&apiTypeForUlts, ApiSpecificConfig::OCL); + VariableBackup mockGetenvCalledBackup(&IoFunctions::mockGetenvCalled, 0); + std::unordered_map mockableEnvs = {{lzeroTestingVariableName, "Default Level Zero"}, + {oclTestingVariableName, setString.c_str()}}; + VariableBackup *> mockableEnvValuesBackup(&IoFunctions::mockableEnvValues, &mockableEnvs); + DebugVarPrefix type = DebugVarPrefix::None; + + retString = evr->getSetting("TestingVariable", defaultString, type); + EXPECT_EQ(1u, IoFunctions::mockGetenvCalled); + EXPECT_EQ(DebugVarPrefix::Neo_Ocl, type); + EXPECT_EQ(0, retString.compare(setString)); + } + { + VariableBackup backup(&apiTypeForUlts, ApiSpecificConfig::L0); + VariableBackup mockGetenvCalledBackup(&IoFunctions::mockGetenvCalled, 0); + std::unordered_map mockableEnvs = {{lzeroTestingVariableName, "Default Level Zero"}, + {oclTestingVariableName, setString.c_str()}}; + VariableBackup *> mockableEnvValuesBackup(&IoFunctions::mockableEnvValues, &mockableEnvs); + DebugVarPrefix type = DebugVarPrefix::None; + + retString = evr->getSetting("TestingVariable", defaultString, type); + EXPECT_EQ(1u, IoFunctions::mockGetenvCalled); + EXPECT_EQ(DebugVarPrefix::Neo_L0, type); + EXPECT_EQ(0, retString.compare("Default Level Zero")); + } +} + TEST_F(DebugEnvReaderTests, givenMaxInt64AsEnvWhenGetSettingThenProperValueIsReturned) { const char *testingVariableName = "TestingVariable"; const char *testingVariableValue = "9223372036854775807"; diff --git a/shared/test/unit_test/os_interface/windows/registry_reader_tests.cpp b/shared/test/unit_test/os_interface/windows/registry_reader_tests.cpp index eb93164755..03b1919a85 100644 --- a/shared/test/unit_test/os_interface/windows/registry_reader_tests.cpp +++ b/shared/test/unit_test/os_interface/windows/registry_reader_tests.cpp @@ -13,6 +13,8 @@ namespace NEO { +enum class DebugVarPrefix : uint8_t; + using RegistryReaderTest = ::testing::Test; namespace SysCalls { @@ -50,6 +52,15 @@ TEST_F(RegistryReaderTest, givenRegistryReaderWhenRegKeyNotExistThenReturnDefaul EXPECT_EQ(value, registryReader.getSetting("", value)); } +TEST_F(RegistryReaderTest, givenRegistryReaderWhenRegKeyNotExistThenReturnDefaultValuePrefix) { + std::string regKey = "notExistPath"; + std::string value = "defaultValue"; + TestedRegistryReader registryReader(regKey); + + DebugVarPrefix type = DebugVarPrefix::None; + EXPECT_EQ(value, registryReader.getSetting("", value, type)); +} + TEST_F(RegistryReaderTest, givenRegistryReaderWhenItIsCreatedWithRegKeySpecifiedThenRegKeyIsInitializedAccordingly) { std::string regKey = "Software\\Intel\\IGFX\\OCL\\regKey"; TestedRegistryReader registryReader(regKey); @@ -63,6 +74,24 @@ TEST_F(RegistryReaderTest, givenRegistryReaderWhenEnvironmentVariableExistsThenR EXPECT_EQ("TestedEnvironmentVariableValue", registryReader.getSetting(envVar, value)); } +TEST_F(RegistryReaderTest, givenRegistryReaderWhenEnvironmentVariableExistsThenReturnCorrectValuePrefix) { + char *envVar = "TestedEnvironmentVariable"; + std::string value = "defaultValue"; + TestedRegistryReader registryReader(""); + DebugVarPrefix type = DebugVarPrefix::None; + EXPECT_EQ("TestedEnvironmentVariableValue", registryReader.getSetting(envVar, value, type)); + EXPECT_EQ(DebugVarPrefix::None, type); +} + +TEST_F(RegistryReaderTest, givenRegistryReaderWhenPrefixedEnvironmentVariableExistsThenReturnCorrectValue) { + char *envVar = "TestedEnvironmentVariableWithPrefix"; + std::string value = "defaultValue"; + TestedRegistryReader registryReader(""); + DebugVarPrefix type = DebugVarPrefix::None; + EXPECT_EQ("TestedEnvironmentVariableValueWithPrefix", registryReader.getSetting(envVar, value, type)); + EXPECT_EQ(DebugVarPrefix::Neo, type); +} + TEST_F(RegistryReaderTest, givenRegistryReaderWhenEnvironmentIntVariableExistsThenReturnCorrectValue) { char *envVar = "TestedEnvironmentIntVariable"; int32_t value = -1; @@ -70,6 +99,24 @@ TEST_F(RegistryReaderTest, givenRegistryReaderWhenEnvironmentIntVariableExistsTh EXPECT_EQ(1234, registryReader.getSetting(envVar, value)); } +TEST_F(RegistryReaderTest, givenRegistryReaderWhenEnvironmentIntVariableExistsThenReturnCorrectValuePrefix) { + char *envVar = "TestedEnvironmentIntVariable"; + int32_t value = -1; + TestedRegistryReader registryReader(""); + DebugVarPrefix type = DebugVarPrefix::None; + EXPECT_EQ(1234, registryReader.getSetting(envVar, value, type)); + EXPECT_EQ(DebugVarPrefix::None, type); +} + +TEST_F(RegistryReaderTest, givenRegistryReaderWhenPrefixedEnvironmentIntVariableExistsThenReturnCorrectValue) { + char *envVar = "TestedEnvironmentIntVariableWithPrefix"; + int32_t value = -1; + TestedRegistryReader registryReader(""); + DebugVarPrefix type = DebugVarPrefix::None; + EXPECT_EQ(5678, registryReader.getSetting(envVar, value, type)); + EXPECT_EQ(DebugVarPrefix::Neo, type); +} + TEST_F(RegistryReaderTest, givenRegistryReaderWhenEnvironmentInt64VariableExistsThenReturnCorrectValue) { const char *envVar = "TestedEnvironmentInt64Variable"; int64_t expectedValue = 9223372036854775807; @@ -78,6 +125,26 @@ TEST_F(RegistryReaderTest, givenRegistryReaderWhenEnvironmentInt64VariableExists EXPECT_EQ(expectedValue, registryReader.getSetting(envVar, defaultValue)); } +TEST_F(RegistryReaderTest, givenRegistryReaderWhenEnvironmentInt64VariableExistsThenReturnCorrectValuePrefix) { + const char *envVar = "TestedEnvironmentInt64Variable"; + int64_t expectedValue = 9223372036854775807; + int64_t defaultValue = 0; + TestedRegistryReader registryReader(""); + DebugVarPrefix type = DebugVarPrefix::None; + EXPECT_EQ(expectedValue, registryReader.getSetting(envVar, defaultValue, type)); + EXPECT_EQ(DebugVarPrefix::None, type); +} + +TEST_F(RegistryReaderTest, givenRegistryReaderWhenPrefixedEnvironmentInt64VariableExistsThenReturnCorrectValue) { + const char *envVar = "TestedEnvironmentInt64VariableWithPrefix"; + int64_t expectedValue = 9223372036854775806; + int64_t defaultValue = 0; + TestedRegistryReader registryReader(""); + DebugVarPrefix type = DebugVarPrefix::None; + EXPECT_EQ(expectedValue, registryReader.getSetting(envVar, defaultValue, type)); + EXPECT_EQ(DebugVarPrefix::Neo, type); +} + struct DebugReaderWithRegistryAndEnvTest : ::testing::Test { VariableBackup openRegCountBackup{&SysCalls::regOpenKeySuccessCount}; VariableBackup queryRegCountBackup{&SysCalls::regQueryValueSuccessCount}; @@ -91,6 +158,15 @@ TEST_F(DebugReaderWithRegistryAndEnvTest, givenIntDebugKeyWhenReadFromRegistrySu EXPECT_EQ(1u, registryReader.getSetting("settingSourceInt", 0)); } +TEST_F(DebugReaderWithRegistryAndEnvTest, givenIntDebugKeyWhenReadFromRegistrySucceedsThenReturnObtainedValuePrefix) { + SysCalls::regOpenKeySuccessCount = 1u; + SysCalls::regQueryValueSuccessCount = 1u; + + DebugVarPrefix type = DebugVarPrefix::None; + EXPECT_EQ(1u, registryReader.getSetting("settingSourceInt", 0, type)); + EXPECT_EQ(DebugVarPrefix::None, type); +} + TEST_F(DebugReaderWithRegistryAndEnvTest, givenInt64DebugKeyWhenReadFromRegistrySucceedsThenReturnObtainedValue) { SysCalls::regOpenKeySuccessCount = 1u; SysCalls::regQueryValueSuccessCount = 1u; @@ -98,6 +174,15 @@ TEST_F(DebugReaderWithRegistryAndEnvTest, givenInt64DebugKeyWhenReadFromRegistry EXPECT_EQ(0xeeeeeeee, registryReader.getSetting("settingSourceInt64", 0)); } +TEST_F(DebugReaderWithRegistryAndEnvTest, givenInt64DebugKeyWhenReadFromRegistrySucceedsThenReturnObtainedValuePrefix) { + SysCalls::regOpenKeySuccessCount = 1u; + SysCalls::regQueryValueSuccessCount = 1u; + + DebugVarPrefix type = DebugVarPrefix::None; + EXPECT_EQ(0xeeeeeeee, registryReader.getSetting("settingSourceInt64", 0, type)); + EXPECT_EQ(DebugVarPrefix::None, type); +} + TEST_F(DebugReaderWithRegistryAndEnvTest, givenIntDebugKeyWhenQueryValueFailsThenObtainValueFromEnv) { SysCalls::regOpenKeySuccessCount = 1u; SysCalls::regQueryValueSuccessCount = 0u; @@ -105,6 +190,15 @@ TEST_F(DebugReaderWithRegistryAndEnvTest, givenIntDebugKeyWhenQueryValueFailsThe EXPECT_EQ(2u, registryReader.getSetting("settingSourceInt", 0)); } +TEST_F(DebugReaderWithRegistryAndEnvTest, givenIntDebugKeyWhenQueryValueFailsThenObtainValueFromEnvPrefix) { + SysCalls::regOpenKeySuccessCount = 1u; + SysCalls::regQueryValueSuccessCount = 0u; + + DebugVarPrefix type = DebugVarPrefix::None; + EXPECT_EQ(2u, registryReader.getSetting("settingSourceInt", 0, type)); + EXPECT_EQ(DebugVarPrefix::None, type); +} + TEST_F(DebugReaderWithRegistryAndEnvTest, givenIntDebugKeyWhenOpenKeyFailsThenObtainValueFromEnv) { SysCalls::regOpenKeySuccessCount = 0u; SysCalls::regQueryValueSuccessCount = 0u; @@ -112,6 +206,15 @@ TEST_F(DebugReaderWithRegistryAndEnvTest, givenIntDebugKeyWhenOpenKeyFailsThenOb EXPECT_EQ(2u, registryReader.getSetting("settingSourceInt", 0)); } +TEST_F(DebugReaderWithRegistryAndEnvTest, givenIntDebugKeyWhenOpenKeyFailsThenObtainValueFromEnvPrefix) { + SysCalls::regOpenKeySuccessCount = 0u; + SysCalls::regQueryValueSuccessCount = 0u; + + DebugVarPrefix type = DebugVarPrefix::None; + EXPECT_EQ(2u, registryReader.getSetting("settingSourceInt", 0, type)); + EXPECT_EQ(DebugVarPrefix::None, type); +} + TEST_F(DebugReaderWithRegistryAndEnvTest, givenStringDebugKeyWhenReadFromRegistrySucceedsThenReturnObtainedValue) { std::string defaultValue("default"); SysCalls::regOpenKeySuccessCount = 1u; @@ -120,6 +223,16 @@ TEST_F(DebugReaderWithRegistryAndEnvTest, givenStringDebugKeyWhenReadFromRegistr EXPECT_STREQ("registry", registryReader.getSetting("settingSourceString", defaultValue).c_str()); } +TEST_F(DebugReaderWithRegistryAndEnvTest, givenStringDebugKeyWhenReadFromRegistrySucceedsThenReturnObtainedValuePrefix) { + std::string defaultValue("default"); + SysCalls::regOpenKeySuccessCount = 1u; + SysCalls::regQueryValueSuccessCount = 2u; + + DebugVarPrefix type = DebugVarPrefix::None; + EXPECT_STREQ("registry", registryReader.getSetting("settingSourceString", defaultValue, type).c_str()); + EXPECT_EQ(DebugVarPrefix::None, type); +} + TEST_F(DebugReaderWithRegistryAndEnvTest, givenStringDebugKeyWhenQueryValueFailsThenObtainValueFromEnv) { std::string defaultValue("default"); SysCalls::regOpenKeySuccessCount = 1u; @@ -133,6 +246,22 @@ TEST_F(DebugReaderWithRegistryAndEnvTest, givenStringDebugKeyWhenQueryValueFails EXPECT_STREQ("environment", registryReader.getSetting("settingSourceString", defaultValue).c_str()); } +TEST_F(DebugReaderWithRegistryAndEnvTest, givenStringDebugKeyWhenQueryValueFailsThenObtainValueFromEnvPrefix) { + std::string defaultValue("default"); + SysCalls::regOpenKeySuccessCount = 1u; + SysCalls::regQueryValueSuccessCount = 0u; + + DebugVarPrefix type = DebugVarPrefix::None; + EXPECT_STREQ("environment", registryReader.getSetting("settingSourceString", defaultValue, type).c_str()); + EXPECT_EQ(DebugVarPrefix::None, type); + + SysCalls::regOpenKeySuccessCount = 1u; + SysCalls::regQueryValueSuccessCount = 1u; + + EXPECT_STREQ("environment", registryReader.getSetting("settingSourceString", defaultValue, type).c_str()); + EXPECT_EQ(DebugVarPrefix::None, type); +} + TEST_F(DebugReaderWithRegistryAndEnvTest, givenStringDebugKeyWhenOpenKeyFailsThenObtainValueFromEnv) { std::string defaultValue("default"); SysCalls::regOpenKeySuccessCount = 0u; @@ -141,6 +270,16 @@ TEST_F(DebugReaderWithRegistryAndEnvTest, givenStringDebugKeyWhenOpenKeyFailsThe EXPECT_STREQ("environment", registryReader.getSetting("settingSourceString", defaultValue).c_str()); } +TEST_F(DebugReaderWithRegistryAndEnvTest, givenStringDebugKeyWhenOpenKeyFailsThenObtainValueFromEnvPrefix) { + std::string defaultValue("default"); + SysCalls::regOpenKeySuccessCount = 0u; + SysCalls::regQueryValueSuccessCount = 0u; + + DebugVarPrefix type = DebugVarPrefix::None; + EXPECT_STREQ("environment", registryReader.getSetting("settingSourceString", defaultValue, type).c_str()); + EXPECT_EQ(DebugVarPrefix::None, type); +} + TEST_F(DebugReaderWithRegistryAndEnvTest, givenBinaryDebugKeyWhenReadFromRegistrySucceedsThenReturnObtainedValue) { std::string defaultValue("default"); SysCalls::regOpenKeySuccessCount = 1u; @@ -148,6 +287,17 @@ TEST_F(DebugReaderWithRegistryAndEnvTest, givenBinaryDebugKeyWhenReadFromRegistr EXPECT_STREQ("registry", registryReader.getSetting("settingSourceBinary", defaultValue).c_str()); } + +TEST_F(DebugReaderWithRegistryAndEnvTest, givenBinaryDebugKeyWhenReadFromRegistrySucceedsThenReturnObtainedValuePrefix) { + std::string defaultValue("default"); + SysCalls::regOpenKeySuccessCount = 1u; + SysCalls::regQueryValueSuccessCount = 2u; + + DebugVarPrefix type = DebugVarPrefix::None; + EXPECT_STREQ("registry", registryReader.getSetting("settingSourceBinary", defaultValue, type).c_str()); + EXPECT_EQ(DebugVarPrefix::None, type); +} + TEST_F(DebugReaderWithRegistryAndEnvTest, givenBinaryDebugKeyOnlyInRegistryWhenReadFromRegistryFailsThenReturnDefaultValue) { std::string defaultValue("default"); SysCalls::regOpenKeySuccessCount = 1u; @@ -166,6 +316,28 @@ TEST_F(DebugReaderWithRegistryAndEnvTest, givenBinaryDebugKeyOnlyInRegistryWhenR EXPECT_STREQ("default", registryReader.getSetting("settingSourceBinary", defaultValue).c_str()); } +TEST_F(DebugReaderWithRegistryAndEnvTest, givenBinaryDebugKeyOnlyInRegistryWhenReadFromRegistryFailsThenReturnDefaultValuePrefix) { + std::string defaultValue("default"); + SysCalls::regOpenKeySuccessCount = 1u; + SysCalls::regQueryValueSuccessCount = 1u; + + DebugVarPrefix type = DebugVarPrefix::None; + EXPECT_STREQ("default", registryReader.getSetting("settingSourceBinary", defaultValue, type).c_str()); + EXPECT_EQ(DebugVarPrefix::None, type); + + SysCalls::regOpenKeySuccessCount = 1u; + SysCalls::regQueryValueSuccessCount = 0u; + + EXPECT_STREQ("default", registryReader.getSetting("settingSourceBinary", defaultValue, type).c_str()); + EXPECT_EQ(DebugVarPrefix::None, type); + + SysCalls::regOpenKeySuccessCount = 0u; + SysCalls::regQueryValueSuccessCount = 0u; + + EXPECT_STREQ("default", registryReader.getSetting("settingSourceBinary", defaultValue, type).c_str()); + EXPECT_EQ(DebugVarPrefix::None, type); +} + TEST_F(RegistryReaderTest, givenRegistryKeyPresentWhenValueIsZeroThenExpectBooleanFalse) { std::string regKey = "notExistPath"; std::string keyName = "boolRegistryKey"; @@ -180,6 +352,22 @@ TEST_F(RegistryReaderTest, givenRegistryKeyPresentWhenValueIsZeroThenExpectBoole EXPECT_FALSE(value); } +TEST_F(RegistryReaderTest, givenRegistryKeyPresentWhenValueIsZeroThenExpectBooleanFalsePrefix) { + std::string regKey = "notExistPath"; + std::string keyName = "boolRegistryKey"; + + bool defaultValue = false; + SysCalls::regOpenKeySuccessCount = 1; + SysCalls::regQueryValueSuccessCount = 1; + SysCalls::regQueryValueExpectedData = 0ull; + + TestedRegistryReader registryReader(regKey); + DebugVarPrefix type = DebugVarPrefix::None; + bool value = registryReader.getSetting(keyName.c_str(), defaultValue, type); + EXPECT_FALSE(value); + EXPECT_EQ(DebugVarPrefix::None, type); +} + TEST_F(RegistryReaderTest, givenRegistryKeyNotPresentWhenDefaulValueIsFalseOrTrueThenExpectReturnIsMatchingFalseOrTrue) { std::string regKey = "notExistPath"; std::string keyName = "boolRegistryKey"; @@ -202,6 +390,31 @@ TEST_F(RegistryReaderTest, givenRegistryKeyNotPresentWhenDefaulValueIsFalseOrTru EXPECT_TRUE(value); } +TEST_F(RegistryReaderTest, givenRegistryKeyNotPresentWhenDefaulValueIsFalseOrTrueThenExpectReturnIsMatchingFalseOrTruePrefix) { + std::string regKey = "notExistPath"; + std::string keyName = "boolRegistryKey"; + + bool defaultValue = false; + SysCalls::regOpenKeySuccessCount = 1; + SysCalls::regQueryValueSuccessCount = 0; + SysCalls::regQueryValueExpectedData = 1ull; + + TestedRegistryReader registryReader(regKey); + DebugVarPrefix type = DebugVarPrefix::None; + bool value = registryReader.getSetting(keyName.c_str(), defaultValue, type); + EXPECT_FALSE(value); + EXPECT_EQ(DebugVarPrefix::None, type); + + defaultValue = true; + SysCalls::regOpenKeySuccessCount = 1; + SysCalls::regQueryValueSuccessCount = 0; + SysCalls::regQueryValueExpectedData = 0ull; + + value = registryReader.getSetting(keyName.c_str(), defaultValue, type); + EXPECT_TRUE(value); + EXPECT_EQ(DebugVarPrefix::None, type); +} + TEST_F(RegistryReaderTest, givenRegistryKeyPresentWhenValueIsNonZeroInHigherDwordThenExpectBooleanFalse) { std::string regKey = "notExistPath"; std::string keyName = "boolRegistryKey"; @@ -216,6 +429,22 @@ TEST_F(RegistryReaderTest, givenRegistryKeyPresentWhenValueIsNonZeroInHigherDwor EXPECT_FALSE(value); } +TEST_F(RegistryReaderTest, givenRegistryKeyPresentWhenValueIsNonZeroInHigherDwordThenExpectBooleanFalsePrefix) { + std::string regKey = "notExistPath"; + std::string keyName = "boolRegistryKey"; + + bool defaultValue = true; + SysCalls::regOpenKeySuccessCount = 1; + SysCalls::regQueryValueSuccessCount = 1; + SysCalls::regQueryValueExpectedData = 1ull << 32; + + TestedRegistryReader registryReader(regKey); + DebugVarPrefix type = DebugVarPrefix::None; + bool value = registryReader.getSetting(keyName.c_str(), defaultValue, type); + EXPECT_FALSE(value); + EXPECT_EQ(DebugVarPrefix::None, type); +} + TEST_F(RegistryReaderTest, givenRegistryKeyPresentWhenValueIsNonZeroInLowerDwordThenExpectBooleanTrue) { std::string regKey = "notExistPath"; std::string keyName = "boolRegistryKey"; @@ -230,6 +459,22 @@ TEST_F(RegistryReaderTest, givenRegistryKeyPresentWhenValueIsNonZeroInLowerDword EXPECT_TRUE(value); } +TEST_F(RegistryReaderTest, givenRegistryKeyPresentWhenValueIsNonZeroInLowerDwordThenExpectBooleanTruePrefix) { + std::string regKey = "notExistPath"; + std::string keyName = "boolRegistryKey"; + + bool defaultValue = false; + SysCalls::regOpenKeySuccessCount = 1; + SysCalls::regQueryValueSuccessCount = 1; + SysCalls::regQueryValueExpectedData = 1ull; + + TestedRegistryReader registryReader(regKey); + DebugVarPrefix type = DebugVarPrefix::None; + bool value = registryReader.getSetting(keyName.c_str(), defaultValue, type); + EXPECT_TRUE(value); + EXPECT_EQ(DebugVarPrefix::None, type); +} + TEST_F(RegistryReaderTest, givenRegistryKeyPresentWhenValueIsNonZeroInBothDwordsThenExpectBooleanTrue) { std::string regKey = "notExistPath"; std::string keyName = "boolRegistryKey"; @@ -244,6 +489,23 @@ TEST_F(RegistryReaderTest, givenRegistryKeyPresentWhenValueIsNonZeroInBothDwords EXPECT_TRUE(value); } +TEST_F(RegistryReaderTest, givenRegistryKeyPresentWhenValueIsNonZeroInBothDwordsThenExpectBooleanTruePrefix) { + std::string regKey = "notExistPath"; + std::string keyName = "boolRegistryKey"; + + bool defaultValue = false; + SysCalls::regOpenKeySuccessCount = 1; + SysCalls::regQueryValueSuccessCount = 1; + SysCalls::regQueryValueExpectedData = 1ull | (1ull << 32); + + TestedRegistryReader registryReader(regKey); + + DebugVarPrefix type = DebugVarPrefix::None; + bool value = registryReader.getSetting(keyName.c_str(), defaultValue, type); + EXPECT_TRUE(value); + EXPECT_EQ(DebugVarPrefix::None, type); +} + TEST_F(DebugReaderWithRegistryAndEnvTest, givenSetProcessNameWhenReadFromEnvironmentVariableThenReturnClCacheDir) { SysCalls::regOpenKeySuccessCount = 0u; SysCalls::regQueryValueSuccessCount = 0u; @@ -252,4 +514,15 @@ TEST_F(DebugReaderWithRegistryAndEnvTest, givenSetProcessNameWhenReadFromEnviron 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 \ No newline at end of file diff --git a/shared/test/unit_test/os_interface/windows/registry_reader_tests.h b/shared/test/unit_test/os_interface/windows/registry_reader_tests.h index 53f07aa79c..63c4090417 100644 --- a/shared/test/unit_test/os_interface/windows/registry_reader_tests.h +++ b/shared/test/unit_test/os_interface/windows/registry_reader_tests.h @@ -24,10 +24,16 @@ class TestedRegistryReader : public RegistryReader { char *getenv(const char *envVar) override { if (strcmp(envVar, "TestedEnvironmentVariable") == 0) { return "TestedEnvironmentVariableValue"; + } else if (strcmp(envVar, "NEO_TestedEnvironmentVariableWithPrefix") == 0) { + return "TestedEnvironmentVariableValueWithPrefix"; } else if (strcmp(envVar, "TestedEnvironmentIntVariable") == 0) { return "1234"; + } else if (strcmp(envVar, "NEO_TestedEnvironmentIntVariableWithPrefix") == 0) { + return "5678"; } else if (strcmp(envVar, "TestedEnvironmentInt64Variable") == 0) { return "9223372036854775807"; + } else if (strcmp(envVar, "NEO_TestedEnvironmentInt64VariableWithPrefix") == 0) { + return "9223372036854775806"; } else if (strcmp(envVar, "settingSourceString") == 0) { return "environment"; } else if (strcmp(envVar, "settingSourceInt") == 0) { diff --git a/shared/test/unit_test/os_interface/windows/wddm_windows_tests.cpp b/shared/test/unit_test/os_interface/windows/wddm_windows_tests.cpp index 9e4cec629b..1b6f6dd40a 100644 --- a/shared/test/unit_test/os_interface/windows/wddm_windows_tests.cpp +++ b/shared/test/unit_test/os_interface/windows/wddm_windows_tests.cpp @@ -5,6 +5,7 @@ * */ +#include "shared/source/debug_settings/debug_settings_manager.h" #include "shared/source/gmm_helper/gmm_helper.h" #include "shared/source/os_interface/windows/driver_info_windows.h" #include "shared/source/os_interface/windows/dxgi_wrapper.h" @@ -224,6 +225,8 @@ TEST_F(Wddm20WithMockGdiDllTests, whenSetDeviceInfoSucceedsThenDeviceCallbacksAr class MockRegistryReaderWithDriverStorePath : public SettingsReader { public: MockRegistryReaderWithDriverStorePath(const char *driverStorePathArg) : driverStorePath(driverStorePathArg){}; + std::string getSetting(const char *settingName, const std::string &value, DebugVarPrefix &type) override { return ""; }; + std::string getSetting(const char *settingName, const std::string &value) override { std::string key(settingName); if (key == "DriverStorePathForComputeRuntime") { @@ -234,8 +237,11 @@ class MockRegistryReaderWithDriverStorePath : public SettingsReader { return value; } + bool getSetting(const char *settingName, bool defaultValue, DebugVarPrefix &type) override { return defaultValue; }; bool getSetting(const char *settingName, bool defaultValue) override { return defaultValue; }; + int64_t getSetting(const char *settingName, int64_t defaultValue, DebugVarPrefix &type) override { return defaultValue; }; int64_t getSetting(const char *settingName, int64_t defaultValue) override { return defaultValue; }; + int32_t getSetting(const char *settingName, int32_t defaultValue, DebugVarPrefix &type) override { return defaultValue; }; int32_t getSetting(const char *settingName, int32_t defaultValue) override { return defaultValue; }; const char *appSpecificLocation(const std::string &name) override { return name.c_str(); }; diff --git a/shared/test/unit_test/ult_specific_config.cpp b/shared/test/unit_test/ult_specific_config.cpp index faec1879db..0098f60867 100644 --- a/shared/test/unit_test/ult_specific_config.cpp +++ b/shared/test/unit_test/ult_specific_config.cpp @@ -23,6 +23,13 @@ namespace NEO { namespace ImplicitScaling { bool apiSupport = false; } // namespace ImplicitScaling + +const char *neoMockSettingsFileName = "neo_mock.config"; +std::vector validUltL0Prefixes = {"NEO_L0_", "NEO_", ""}; +std::vector validUltL0PrefixTypes = {DebugVarPrefix::Neo_L0, DebugVarPrefix::Neo, DebugVarPrefix::None}; +std::vector validUltOclPrefixes = {"NEO_OCL_", "NEO_", ""}; +std::vector validUltOclPrefixTypes = {DebugVarPrefix::Neo_Ocl, DebugVarPrefix::Neo, DebugVarPrefix::None}; + bool CompressionSelector::preferCompressedAllocation(const AllocationProperties &properties) { return false; } @@ -78,6 +85,24 @@ const char *ApiSpecificConfig::getRegistryPath() { return ""; } +void ApiSpecificConfig::initPrefixes() { +} + +const std::vector &ApiSpecificConfig::getPrefixStrings() { + if (apiTypeForUlts == ApiSpecificConfig::L0) { + return validUltL0Prefixes; + } else { + return validUltOclPrefixes; + } +} + +const std::vector &ApiSpecificConfig::getPrefixTypes() { + if (apiTypeForUlts == ApiSpecificConfig::L0) { + return validUltL0PrefixTypes; + } else { + return validUltOclPrefixTypes; + } +} } // namespace NEO using namespace NEO; diff --git a/shared/test/unit_test/utilities/debug_file_reader_tests.inl b/shared/test/unit_test/utilities/debug_file_reader_tests.inl index a782f36b30..e653755409 100644 --- a/shared/test/unit_test/utilities/debug_file_reader_tests.inl +++ b/shared/test/unit_test/utilities/debug_file_reader_tests.inl @@ -5,9 +5,12 @@ * */ +#include "shared/source/debug_settings/debug_settings_manager.h" +#include "shared/source/helpers/api_specific_config.h" #include "shared/source/helpers/file_io.h" #include "shared/source/utilities/debug_file_reader.h" #include "shared/test/common/helpers/test_files.h" +#include "shared/test/common/helpers/variable_backup.h" #include "shared/test/common/test_macros/test.h" #include "gtest/gtest.h" @@ -15,6 +18,10 @@ #include #include +namespace NEO { +extern ApiSpecificConfig::ApiType apiTypeForUlts; +} // namespace NEO + using namespace NEO; class TestSettingsFileReader : public SettingsFileReader { @@ -44,6 +51,10 @@ class TestSettingsFileReader : public SettingsFileReader { static const std::string getStringTestPath() { return clFiles + "igdrcl_string.config"; } + + static const std::string getNeoStringTestPath() { + return clFiles + "neo_string.config"; + } }; TEST(SettingsFileReader, GivenFilesDoesNotExistWhenCreatingFileReaderThenCreationSucceeds) { @@ -264,3 +275,43 @@ TEST(SettingsFileReader, givenNoKeyOrNoValueWhenGetSettingThenExceptionIsNotThro EXPECT_EQ(0u, reader->getStringSettingsCount()); } } + +TEST(SettingsFileReader, givenPrefixFileReadCorrectValueReturned) { + auto reader = std::make_unique(TestSettingsFileReader::getStringTestPath().c_str()); + ASSERT_NE(nullptr, reader.get()); + VariableBackup backup(&apiTypeForUlts, ApiSpecificConfig::OCL); + DebugVarPrefix type = DebugVarPrefix::None; + int32_t retValue = 0; + int32_t returnedIntValue = reader->getSetting("IntTestKey", retValue, type); + EXPECT_EQ(DebugVarPrefix::None, type); + EXPECT_EQ(123, returnedIntValue); + + int32_t returnedIntValueHex = reader->getSetting("IntTestKeyHex", 0, type); + EXPECT_EQ(DebugVarPrefix::None, type); + EXPECT_EQ(0xABCD, returnedIntValueHex); + + std::string retValueString = ""; + std::string returnedStringValue = reader->getSetting("StringTestKey", retValueString, type); + EXPECT_EQ(DebugVarPrefix::None, type); + EXPECT_STREQ(returnedStringValue.c_str(), "TestValue"); + + auto neo_reader = std::make_unique(TestSettingsFileReader::getNeoStringTestPath().c_str()); + ASSERT_NE(nullptr, neo_reader.get()); + + retValue = 0; + returnedIntValue = 0; + returnedIntValue = neo_reader->getSetting("IntTestKey", retValue, type); + EXPECT_EQ(DebugVarPrefix::Neo, type); + EXPECT_EQ(123, returnedIntValue); + + returnedIntValueHex = 0; + returnedIntValueHex = neo_reader->getSetting("IntTestKeyHex", 0, type); + EXPECT_EQ(DebugVarPrefix::Neo, type); + EXPECT_EQ(0xABCD, returnedIntValueHex); + + retValueString = ""; + returnedStringValue = ""; + returnedStringValue = neo_reader->getSetting("StringTestKey", retValueString, type); + EXPECT_EQ(DebugVarPrefix::Neo, type); + EXPECT_STREQ(returnedStringValue.c_str(), "TestValue"); +} diff --git a/shared/test/unit_test/utilities/debug_settings_reader_tests.cpp b/shared/test/unit_test/utilities/debug_settings_reader_tests.cpp index 85fdadb610..45fd0a6d9e 100644 --- a/shared/test/unit_test/utilities/debug_settings_reader_tests.cpp +++ b/shared/test/unit_test/utilities/debug_settings_reader_tests.cpp @@ -8,6 +8,7 @@ #include "shared/source/debug_settings/debug_settings_manager.h" #include "shared/source/helpers/api_specific_config.h" #include "shared/source/helpers/file_io.h" +#include "shared/source/utilities/debug_file_reader.h" #include "shared/source/utilities/debug_settings_reader.h" #include "shared/test/common/test_macros/test.h" @@ -20,23 +21,29 @@ using namespace NEO; class MockSettingsReader : public SettingsReader { public: + std::string getSetting(const char *settingName, const std::string &value, DebugVarPrefix &type) override { + return value; + } std::string getSetting(const char *settingName, const std::string &value) override { return value; } + bool getSetting(const char *settingName, bool defaultValue, DebugVarPrefix &type) override { return defaultValue; }; bool getSetting(const char *settingName, bool defaultValue) override { return defaultValue; }; + int64_t getSetting(const char *settingName, int64_t defaultValue, DebugVarPrefix &type) override { return defaultValue; }; int64_t getSetting(const char *settingName, int64_t defaultValue) override { return defaultValue; }; + int32_t getSetting(const char *settingName, int32_t defaultValue, DebugVarPrefix &type) override { return defaultValue; }; int32_t getSetting(const char *settingName, int32_t defaultValue) override { return defaultValue; }; const char *appSpecificLocation(const std::string &name) override { return name.c_str(); }; }; TEST(SettingsReader, WhenCreatingSettingsReaderThenReaderIsCreated) { - SettingsReader *reader = SettingsReader::create(ApiSpecificConfig::getRegistryPath()); - EXPECT_NE(nullptr, reader); - delete reader; + auto reader = std::unique_ptr(SettingsReader::create(ApiSpecificConfig::getRegistryPath())); + EXPECT_NE(nullptr, reader.get()); } TEST(SettingsReader, GivenNoSettingsFileWhenCreatingSettingsReaderThenOsReaderIsCreated) { - remove(SettingsReader::settingsFileName); + ASSERT_FALSE(fileExists(SettingsReader::settingsFileName)); + auto fileReader = std::unique_ptr(SettingsReader::createFileReader()); EXPECT_EQ(nullptr, fileReader.get()); @@ -45,11 +52,11 @@ TEST(SettingsReader, GivenNoSettingsFileWhenCreatingSettingsReaderThenOsReaderIs } TEST(SettingsReader, GivenSettingsFileExistsWhenCreatingSettingsReaderThenReaderIsCreated) { - bool settingsFileExists = fileExists(SettingsReader::settingsFileName); - if (!settingsFileExists) { - const char data[] = "ProductFamilyOverride = test"; - writeDataToFile(SettingsReader::settingsFileName, &data, sizeof(data)); - } + ASSERT_FALSE(fileExists(SettingsReader::settingsFileName)); + + const char data[] = "ProductFamilyOverride = test"; + writeDataToFile(SettingsReader::settingsFileName, &data, sizeof(data)); + auto reader = std::unique_ptr(SettingsReader::create(ApiSpecificConfig::getRegistryPath())); EXPECT_NE(nullptr, reader.get()); std::string defaultValue("unk"); @@ -59,30 +66,37 @@ TEST(SettingsReader, GivenSettingsFileExistsWhenCreatingSettingsReaderThenReader } TEST(SettingsReader, WhenCreatingFileReaderThenReaderIsCreated) { - bool settingsFileExists = fileExists(SettingsReader::settingsFileName); - if (!settingsFileExists) { - char data = 0; - writeDataToFile(SettingsReader::settingsFileName, &data, 0); - } - SettingsReader *reader = SettingsReader::createFileReader(); - EXPECT_NE(nullptr, reader); + ASSERT_FALSE(fileExists(SettingsReader::settingsFileName)); + char data = 0; + writeDataToFile(SettingsReader::settingsFileName, &data, 0); - if (!settingsFileExists) { - remove(SettingsReader::settingsFileName); - } - delete reader; + auto reader = std::unique_ptr(SettingsReader::createFileReader()); + EXPECT_NE(nullptr, reader.get()); + + std::remove(SettingsReader::settingsFileName); +} + +TEST(SettingsReader, WhenCreatingFileReaderUseNeoFileIfNoDefault) { + ASSERT_FALSE(fileExists(SettingsReader::settingsFileName)); + ASSERT_FALSE(fileExists(SettingsReader::neoSettingsFileName)); + char data = 0; + writeDataToFile(SettingsReader::neoSettingsFileName, &data, 0); + + auto reader = std::unique_ptr(SettingsReader::createFileReader()); + EXPECT_NE(nullptr, reader.get()); + + std::remove(SettingsReader::neoSettingsFileName); } TEST(SettingsReader, WhenCreatingOsReaderThenReaderIsCreated) { - SettingsReader *reader = SettingsReader::createOsReader(false, ApiSpecificConfig::getRegistryPath()); - EXPECT_NE(nullptr, reader); - delete reader; + auto reader = std::unique_ptr(SettingsReader::createOsReader(false, ApiSpecificConfig::getRegistryPath())); + EXPECT_NE(nullptr, reader.get()); } TEST(SettingsReader, GivenRegKeyWhenCreatingOsReaderThenReaderIsCreated) { std::string regKey = ApiSpecificConfig::getRegistryPath(); - std::unique_ptr reader(SettingsReader::createOsReader(false, regKey)); - EXPECT_NE(nullptr, reader); + auto reader = std::unique_ptr(SettingsReader::createOsReader(false, regKey)); + EXPECT_NE(nullptr, reader.get()); } TEST(SettingsReader, GivenTrueWhenPrintingDebugStringThenPrintsToOutput) {