Add support for dumping cl_cache to specified directory

kcencele · Compute-Runtime-Automation · commit 3e800d55e6f2 · 2018-11-29T13:59:26.000+01:00
Change-Id: I782ff17d0d4b17d3d26db543eb7ae222f75ff8a1
diff --git a/runtime/compiler_interface/binary_cache.cpp b/runtime/compiler_interface/binary_cache.cpp
@@ -14,6 +14,8 @@
 #include <runtime/helpers/hw_info.h>
 #include <runtime/os_interface/os_inc_base.h>
 #include <runtime/program/program.h>
+#include <runtime/utilities/debug_settings_reader.h>
+#include "os_inc.h"
 
 #include <cstring>
 #include <string>
@@ -23,7 +25,6 @@
 
 namespace OCLRT {
 std::mutex BinaryCache::cacheAccessMtx;
-
 const std::string BinaryCache::getCachedFileName(const HardwareInfo &hwInfo, const ArrayRef<const char> input,
                                                  const ArrayRef<const char> options, const ArrayRef<const char> internalOptions) {
     Hash hash;
@@ -51,18 +52,22 @@ const std::string BinaryCache::getCachedFileName(const HardwareInfo &hwInfo, con
     return stream.str();
 }
 
+BinaryCache::BinaryCache() {
+    std::unique_ptr<SettingsReader> settingsReader(SettingsReader::createOsReader(CL_CACHE_LOCATION));
+    clCacheLocation = settingsReader->getSetting(settingsReader->appSpecificLocation("cl_cache_dir"), static_cast<std::string>(CL_CACHE_LOCATION));
+};
+
+BinaryCache::~BinaryCache(){};
+
 bool BinaryCache::cacheBinary(const std::string kernelFileHash, const char *pBinary, uint32_t binarySize) {
     if (pBinary == nullptr || binarySize == 0) {
         return false;
     }
-
-    std::string hashFilePath = CL_CACHE_LOCATION;
-    hashFilePath.append(Os::fileSeparator);
-    hashFilePath.append(kernelFileHash + ".cl_cache");
+    std::string filePath = clCacheLocation + PATH_SEPARATOR + kernelFileHash + ".cl_cache";
 
     std::lock_guard<std::mutex> lock(cacheAccessMtx);
     if (writeDataToFile(
-            hashFilePath.c_str(),
+            filePath.c_str(),
             pBinary,
             binarySize) == 0) {
         return false;
@@ -75,13 +80,11 @@ bool BinaryCache::loadCachedBinary(const std::string kernelFileHash, Program &pr
     void *pBinary = nullptr;
     size_t binarySize = 0;
 
-    std::string hashFilePath = CL_CACHE_LOCATION;
-    hashFilePath.append(Os::fileSeparator);
-    hashFilePath.append(kernelFileHash + ".cl_cache");
+    std::string filePath = clCacheLocation + PATH_SEPARATOR + kernelFileHash + ".cl_cache";
 
     {
         std::lock_guard<std::mutex> lock(cacheAccessMtx);
-        binarySize = loadDataFromFile(hashFilePath.c_str(), pBinary);
+        binarySize = loadDataFromFile(filePath.c_str(), pBinary);
     }
 
     if ((pBinary == nullptr) || (binarySize == 0)) {
diff --git a/runtime/compiler_interface/binary_cache.h b/runtime/compiler_interface/binary_cache.h
@@ -11,25 +11,23 @@
 #include <cstring>
 #include <string>
 #include <mutex>
-
 #include "runtime/utilities/arrayref.h"
 
 namespace OCLRT {
-
 struct HardwareInfo;
 class Program;
+
 class BinaryCache {
   public:
     static const std::string getCachedFileName(const HardwareInfo &hwInfo, ArrayRef<const char> input,
                                                ArrayRef<const char> options, ArrayRef<const char> internalOptions);
-
-    virtual ~BinaryCache(){};
-
+    BinaryCache();
+    virtual ~BinaryCache();
     virtual bool cacheBinary(const std::string kernelFileHash, const char *pBinary, uint32_t binarySize);
     virtual bool loadCachedBinary(const std::string kernelFileHash, Program &program);
 
   protected:
     static std::mutex cacheAccessMtx;
+    std::string clCacheLocation;
 };
-
 } // namespace OCLRT
diff --git a/runtime/os_interface/debug_settings_manager.cpp b/runtime/os_interface/debug_settings_manager.cpp
@@ -41,7 +41,7 @@ DebugSettingsManager<DebugLevel>::DebugSettingsManager() {
     }
 
     std::remove(logFileName.c_str());
-}
+} // namespace OCLRT
 
 template <DebugFunctionalityLevel DebugLevel>
 void DebugSettingsManager<DebugLevel>::writeToFile(std::string filename, const char *str, size_t length, std::ios_base::openmode mode) {
diff --git a/runtime/os_interface/linux/debug_env_reader.cpp b/runtime/os_interface/linux/debug_env_reader.cpp
@@ -13,6 +13,13 @@ SettingsReader *SettingsReader::createOsReader(bool userScope) {
     return new EnvironmentVariableReader;
 }
 
+SettingsReader *SettingsReader::createOsReader(const std::string &regKey) {
+    return new EnvironmentVariableReader;
+}
+const char *EnvironmentVariableReader::appSpecificLocation(const std::string &name) {
+    return name.c_str();
+}
+
 bool EnvironmentVariableReader::getSetting(const char *settingName, bool defaultValue) {
     return getSetting(settingName, static_cast<int32_t>(defaultValue)) ? true : false;
 }
diff --git a/runtime/os_interface/windows/debug_registry_reader.cpp b/runtime/os_interface/windows/debug_registry_reader.cpp
@@ -16,6 +16,22 @@ namespace OCLRT {
 SettingsReader *SettingsReader::createOsReader(bool userScope) {
     return new RegistryReader(userScope);
 }
+SettingsReader *SettingsReader::createOsReader(const std::string &regKey) {
+    return new RegistryReader(regKey);
+}
+void RegistryReader::setUpProcessName() {
+    char buff[MAX_PATH];
+    GetModuleFileNameA(nullptr, buff, MAX_PATH);
+    if (GetLastError() == ERROR_INSUFFICIENT_BUFFER) {
+        processName = "";
+    }
+    processName.assign(buff);
+}
+const char *RegistryReader::appSpecificLocation(const std::string &name) {
+    if (processName.length() > 0)
+        return processName.c_str();
+    return name.c_str();
+}
 
 bool RegistryReader::getSetting(const char *settingName, bool defaultValue) {
     return getSetting(settingName, static_cast<int32_t>(defaultValue)) ? true : false;
@@ -27,7 +43,7 @@ int32_t RegistryReader::getSetting(const char *settingName, int32_t defaultValue
     DWORD success = ERROR_SUCCESS;
 
     success = RegOpenKeyExA(igdrclHkeyType,
-                            igdrclRegKey.c_str(),
+                            registryReadRootKey.c_str(),
                             0,
                             KEY_READ,
                             &Key);
@@ -52,11 +68,10 @@ int32_t RegistryReader::getSetting(const char *settingName, int32_t defaultValue
 std::string RegistryReader::getSetting(const char *settingName, const std::string &value) {
     HKEY Key;
     DWORD success = ERROR_SUCCESS;
-    bool retFlag = false;
     std::string keyValue = value;
 
     success = RegOpenKeyExA(igdrclHkeyType,
-                            igdrclRegKey.c_str(),
+                            registryReadRootKey.c_str(),
                             0,
                             KEY_READ,
                             &Key);
@@ -80,10 +95,8 @@ std::string RegistryReader::getSetting(const char *settingName, const std::strin
                                        &regType,
                                        (LPBYTE)regData,
                                        &regSize);
-
             keyValue.assign(regData);
             delete[] regData;
-            retFlag = true;
         } else if (success == ERROR_SUCCESS && regType == REG_BINARY) {
             std::unique_ptr<wchar_t[]> regData(new wchar_t[regSize]);
             success = RegQueryValueExA(Key,
@@ -99,11 +112,11 @@ std::string RegistryReader::getSetting(const char *settingName, const std::strin
             wcstombs_s(&charsConverted, convertedData.get(), regSize, regData.get(), regSize);
 
             keyValue.assign(convertedData.get());
-            retFlag = true;
         }
 
         RegCloseKey(Key);
     }
     return keyValue;
 }
+
 }; // namespace OCLRT
diff --git a/runtime/os_interface/windows/registry_reader.h b/runtime/os_interface/windows/registry_reader.h
@@ -8,7 +8,7 @@
 #pragma once
 
 #include "runtime/utilities/debug_settings_reader.h"
-
+#include "os_inc.h"
 #include <string>
 #include <stdint.h>
 #include <Windows.h>
@@ -21,13 +21,18 @@ class RegistryReader : public SettingsReader {
     std::string getSetting(const char *settingName, const std::string &value) override;
     RegistryReader(bool userScope) {
         igdrclHkeyType = userScope ? HKEY_CURRENT_USER : HKEY_LOCAL_MACHINE;
+        setUpProcessName();
     }
     RegistryReader(std::string regKey) {
-        igdrclRegKey = regKey;
+        registryReadRootKey.append(std::string(1, PATH_SEPARATOR)).append(regKey);
+        setUpProcessName();
     }
+    const char *appSpecificLocation(const std::string &name) override;
 
   protected:
     HKEY igdrclHkeyType = HKEY_LOCAL_MACHINE;
-    std::string igdrclRegKey = "Software\\Intel\\IGFX\\OCL";
+    std::string registryReadRootKey = "Software\\Intel\\IGFX\\OCL";
+    void setUpProcessName();
+    std::string processName;
 };
 } // namespace OCLRT
diff --git a/runtime/os_interface/windows/windows_wrapper.h b/runtime/os_interface/windows/windows_wrapper.h
@@ -14,3 +14,19 @@
 // There is a conflict with max/min defined as macro in windows headers with std::max/std::min
 #undef min
 #undef max
+#undef RegOpenKeyExA
+#undef RegQueryValueExA
+#pragma warning(disable : 4273)
+LSTATUS APIENTRY RegOpenKeyExA(
+    HKEY hKey,
+    LPCSTR lpSubKey,
+    DWORD ulOptions,
+    REGSAM samDesired,
+    PHKEY phkResult);
+LSTATUS APIENTRY RegQueryValueExA(
+    HKEY hKey,
+    LPCSTR lpValueName,
+    LPDWORD lpReserved,
+    LPDWORD lpType,
+    LPBYTE lpData,
+    LPDWORD lpcbData);
diff --git a/runtime/utilities/debug_file_reader.cpp b/runtime/utilities/debug_file_reader.cpp
@@ -82,4 +82,8 @@ std::string SettingsFileReader::getSetting(const char *settingName, const std::s
 
     return returnValue;
 }
+
+const char *SettingsFileReader::appSpecificLocation(const std::string &name) {
+    return name.c_str();
+}
 }; // namespace OCLRT
diff --git a/runtime/utilities/debug_file_reader.h b/runtime/utilities/debug_file_reader.h
@@ -24,9 +24,10 @@ class SettingsFileReader : public SettingsReader {
     int32_t getSetting(const char *settingName, int32_t defaultValue) override;
     bool getSetting(const char *settingName, bool defaultValue) override;
     std::string getSetting(const char *settingName, const std::string &value) override;
+    const char *appSpecificLocation(const std::string &name) override;
 
   protected:
     std::map<std::string, int32_t> settingValueMap;
     std::map<std::string, std::string> settingStringMap;
 };
-}; // namespace OCLRT
+}; // namespace OCLRT
diff --git a/runtime/utilities/debug_settings_reader.h b/runtime/utilities/debug_settings_reader.h
@@ -23,11 +23,12 @@ class SettingsReader {
         return createOsReader(false);
     }
     static SettingsReader *createOsReader(bool userScope);
+    static SettingsReader *createOsReader(const std::string &regKey);
     static SettingsReader *createFileReader();
     virtual int32_t getSetting(const char *settingName, int32_t defaultValue) = 0;
     virtual bool getSetting(const char *settingName, bool defaultValue) = 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;
 };
 }; // namespace OCLRT
diff --git a/runtime/utilities/linux/debug_env_reader.h b/runtime/utilities/linux/debug_env_reader.h
@@ -17,5 +17,6 @@ class EnvironmentVariableReader : public SettingsReader {
     int32_t getSetting(const char *settingName, int32_t defaultValue) override;
     bool getSetting(const char *settingName, bool defaultValue) override;
     std::string getSetting(const char *settingName, const std::string &value) override;
+    const char *appSpecificLocation(const std::string &name) override;
 };
 } // namespace OCLRT
diff --git a/unit_tests/helpers/debug_manager_state_restore.h b/unit_tests/helpers/debug_manager_state_restore.h
@@ -49,7 +49,11 @@ class RegistryReaderMock : public SettingsReader {
     bool getSetting(const char *settingName, bool defaultValue) override {
         return true;
     }
+
     std::string getSetting(const char *settingName, const std::string &value) override {
         return "";
     }
+    const char *appSpecificLocation(const std::string &name) override {
+        return name.c_str();
+    }
 };
diff --git a/unit_tests/os_interface/linux/debug_env_reader.cpp b/unit_tests/os_interface/linux/debug_env_reader.cpp
@@ -6,6 +6,7 @@
  */
 
 #include "test.h"
+#include <memory>
 #include "runtime/utilities/linux/debug_env_reader.h"
 
 namespace OCLRT {
@@ -68,4 +69,15 @@ TEST_F(DebugEnvReaderTests, CheckBoolEnvVariable) {
     ret = evr->getSetting("TestingVariable", defaultValue);
     EXPECT_EQ(defaultValue, ret);
 }
+
+TEST_F(DebugEnvReaderTests, appSpecificLacationReturnClCacheLocation) {
+    std::string appSpecific;
+    appSpecific = "cl_cache_dir";
+    EXPECT_EQ(appSpecific, evr->appSpecificLocation(appSpecific));
+}
+
+TEST_F(DebugEnvReaderTests, givenEnvironmentVariableReaderWhenCreateOsReaderWithStringThenNotNullPointer) {
+    std::unique_ptr<SettingsReader> evr(SettingsReader::createOsReader(""));
+    EXPECT_NE(nullptr, evr);
+}
 } // namespace OCLRT
diff --git a/unit_tests/os_interface/windows/CMakeLists.txt b/unit_tests/os_interface/windows/CMakeLists.txt
@@ -38,6 +38,7 @@ set(IGDRCL_SRCS_tests_os_interface_windows
   ${CMAKE_CURRENT_SOURCE_DIR}/wddm_memory_manager_allocate_in_device_pool_tests.inl
   ${CMAKE_CURRENT_SOURCE_DIR}/wddm_preemption_tests.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/wddm_residency_controller_tests.cpp
+  ${CMAKE_CURRENT_SOURCE_DIR}/mock_registry_reader.cpp
 )
 if(WIN32)
   file(GLOB IGDRCL_SRC_tests_wddm_interface "${CMAKE_CURRENT_SOURCE_DIR}/wddm2[0-9]_tests\.cpp")
diff --git a/unit_tests/os_interface/windows/driver_info_tests.cpp b/unit_tests/os_interface/windows/driver_info_tests.cpp
@@ -69,7 +69,6 @@ class RegistryReaderMock : public SettingsReader {
   public:
     std::string nameString;
     std::string versionString;
-
     std::string getSetting(const char *settingName, const std::string &value) {
         std::string key(settingName);
         if (key == "HardwareInformation.AdapterString") {
@@ -82,6 +81,7 @@ class RegistryReaderMock : public SettingsReader {
 
     bool getSetting(const char *settingName, bool defaultValue) { return defaultValue; };
     int32_t getSetting(const char *settingName, int32_t defaultValue) { return defaultValue; };
+    const char *appSpecificLocation(const std::string &name) { return name.c_str(); };
 
     bool properNameKey = false;
     bool properVersionKey = false;
diff --git a/unit_tests/os_interface/windows/mock_registry_reader.cpp b/unit_tests/os_interface/windows/mock_registry_reader.cpp
@@ -0,0 +1,27 @@
+/*
+ * Copyright (C) 2017-2018 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#include "windows_wrapper.h"
+
+LSTATUS APIENTRY RegOpenKeyExA(
+    HKEY hKey,
+    LPCSTR lpSubKey,
+    DWORD ulOptions,
+    REGSAM samDesired,
+    PHKEY phkResult) {
+    return ERROR_FILE_NOT_FOUND;
+};
+
+LSTATUS APIENTRY RegQueryValueExA(
+    HKEY hKey,
+    LPCSTR lpValueName,
+    LPDWORD lpReserved,
+    LPDWORD lpType,
+    LPBYTE lpData,
+    LPDWORD lpcbData) {
+    return ERROR_FILE_NOT_FOUND;
+};
diff --git a/unit_tests/os_interface/windows/registry_reader_tests.cpp b/unit_tests/os_interface/windows/registry_reader_tests.cpp
diff --git a/unit_tests/utilities/debug_file_reader_tests.inl b/unit_tests/utilities/debug_file_reader_tests.inl
diff --git a/unit_tests/utilities/debug_settings_reader_tests.cpp b/unit_tests/utilities/debug_settings_reader_tests.cpp

Original file line number	Diff line number	Diff line change
`@@ -41,7 +41,7 @@ DebugSettingsManager<DebugLevel>::DebugSettingsManager() {`
`41`	`41`	`}`
`42`	`42`
`43`	`43`	`std::remove(logFileName.c_str());`
`44`		`-}`
	`44`	`+} // namespace OCLRT`
`45`	`45`
`46`	`46`	`template <DebugFunctionalityLevel DebugLevel>`
`47`	`47`	`void DebugSettingsManager<DebugLevel>::writeToFile(std::string filename, const char *str, size_t length, std::ios_base::openmode mode) {`
Original file line number	Diff line number	Diff line change
`@@ -13,6 +13,13 @@ SettingsReader *SettingsReader::createOsReader(bool userScope) {`
`13`	`13`	`return new EnvironmentVariableReader;`
`14`	`14`	`}`
`15`	`15`
	`16`	`+SettingsReader *SettingsReader::createOsReader(const std::string &regKey) {`
	`17`	`+ return new EnvironmentVariableReader;`
	`18`	`+}`
	`19`	`+const char *EnvironmentVariableReader::appSpecificLocation(const std::string &name) {`
	`20`	`+ return name.c_str();`
	`21`	`+}`
	`22`	`+`
`16`	`23`	`bool EnvironmentVariableReader::getSetting(const char *settingName, bool defaultValue) {`
`17`	`24`	`return getSetting(settingName, static_cast<int32_t>(defaultValue)) ? true : false;`
`18`	`25`	`}`
Original file line number	Diff line number	Diff line change
`@@ -82,4 +82,8 @@ std::string SettingsFileReader::getSetting(const char *settingName, const std::s`
`82`	`82`
`83`	`83`	`return returnValue;`
`84`	`84`	`}`
	`85`	`+`
	`86`	`+const char *SettingsFileReader::appSpecificLocation(const std::string &name) {`
	`87`	`+ return name.c_str();`
	`88`	`+}`
`85`	`89`	`}; // namespace OCLRT`