[3/N] compiler interface refactor - cache

Change-Id: Iac1f36f7f505b100e65c2b44dff7f1689f99bfe5

Author: jchodor

core/compiler_interface/CMakeLists.txt

@@ -6,6 +6,8 @@
 
 set(NEO_COMPILER_INTERFACE
   ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
+  ${CMAKE_CURRENT_SOURCE_DIR}/compiler_cache.h
+  ${CMAKE_CURRENT_SOURCE_DIR}/compiler_cache.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/linker.h
   ${CMAKE_CURRENT_SOURCE_DIR}/linker.cpp
 )

runtime/compiler_interface/binary_cache.cpp renamed to core/compiler_interface/compiler_cache.cpp

@@ -5,15 +5,13 @@
  *
  */
 
-#include "runtime/compiler_interface/binary_cache.h"
+#include "core/compiler_interface/compiler_cache.h"
 
 #include "core/helpers/aligned_memory.h"
 #include "core/helpers/file_io.h"
 #include "core/helpers/hash.h"
 #include "core/utilities/debug_settings_reader.h"
 #include "runtime/helpers/hw_info.h"
-#include "runtime/os_interface/ocl_reg_path.h"
-#include "runtime/os_interface/os_inc_base.h"
 
 #include "config.h"
 #include "os_inc.h"
@@ -25,9 +23,9 @@
 #include <string>
 
 namespace NEO {
-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) {
+std::mutex CompilerCache::cacheAccessMtx;
+const std::string CompilerCache::getCachedFileName(const HardwareInfo &hwInfo, const ArrayRef<const char> input,
+                                                   const ArrayRef<const char> options, const ArrayRef<const char> internalOptions) {
     Hash hash;
 
     hash.update("----", 4);
@@ -53,26 +51,20 @@ const std::string BinaryCache::getCachedFileName(const HardwareInfo &hwInfo, con
     return stream.str();
 }
 
-BinaryCache::BinaryCache() {
-    std::string keyName = oclRegPath;
-    keyName += "cl_cache_dir";
-    std::unique_ptr<SettingsReader> settingsReader(SettingsReader::createOsReader(false, keyName));
-    clCacheLocation = settingsReader->getSetting(settingsReader->appSpecificLocation(keyName), static_cast<std::string>(CL_CACHE_LOCATION));
-};
+CompilerCache::CompilerCache(const CompilerCacheConfig &cacheConfig)
+    : config(cacheConfig){};
 
-BinaryCache::~BinaryCache(){};
-
-bool BinaryCache::cacheBinary(const std::string kernelFileHash, const char *pBinary, uint32_t binarySize) {
+bool CompilerCache::cacheBinary(const std::string kernelFileHash, const char *pBinary, uint32_t binarySize) {
     if (pBinary == nullptr || binarySize == 0) {
         return false;
     }
-    std::string filePath = clCacheLocation + PATH_SEPARATOR + kernelFileHash + ".cl_cache";
+    std::string filePath = config.cacheDir + PATH_SEPARATOR + kernelFileHash + config.cacheFileExtension;
     std::lock_guard<std::mutex> lock(cacheAccessMtx);
     return 0 != writeDataToFile(filePath.c_str(), pBinary, binarySize);
 }
 
-std::unique_ptr<char[]> BinaryCache::loadCachedBinary(const std::string kernelFileHash, size_t &cachedBinarySize) {
-    std::string filePath = clCacheLocation + PATH_SEPARATOR + kernelFileHash + ".cl_cache";
+std::unique_ptr<char[]> CompilerCache::loadCachedBinary(const std::string kernelFileHash, size_t &cachedBinarySize) {
+    std::string filePath = config.cacheDir + PATH_SEPARATOR + kernelFileHash + config.cacheFileExtension;
 
     std::lock_guard<std::mutex> lock(cacheAccessMtx);
     return loadDataFromFile(filePath.c_str(), cachedBinarySize);

core/compiler_interface/compiler_cache.h

@@ -0,0 +1,47 @@
+/*
+ * Copyright (C) 2017-2019 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#pragma once
+
+#include "core/utilities/arrayref.h"
+
+#include <cstdint>
+#include <cstring>
+#include <memory>
+#include <mutex>
+#include <string>
+
+namespace NEO {
+struct HardwareInfo;
+
+struct CompilerCacheConfig {
+    bool enabled = true;
+    std::string cacheFileExtension;
+    std::string cacheDir;
+};
+
+class CompilerCache {
+  public:
+    static const std::string getCachedFileName(const HardwareInfo &hwInfo, ArrayRef<const char> input,
+                                               ArrayRef<const char> options, ArrayRef<const char> internalOptions);
+
+    CompilerCache(const CompilerCacheConfig &config);
+    virtual ~CompilerCache() = default;
+
+    CompilerCache(const CompilerCache &) = delete;
+    CompilerCache(CompilerCache &&) = delete;
+    CompilerCache &operator=(const CompilerCache &) = delete;
+    CompilerCache &operator=(CompilerCache &&) = delete;
+
+    MOCKABLE_VIRTUAL bool cacheBinary(const std::string kernelFileHash, const char *pBinary, uint32_t binarySize);
+    MOCKABLE_VIRTUAL std::unique_ptr<char[]> loadCachedBinary(const std::string kernelFileHash, size_t &cachedBinarySize);
+
+  protected:
+    static std::mutex cacheAccessMtx;
+    CompilerCacheConfig config;
+};
+} // namespace NEO

core/unit_tests/compiler_interface/CMakeLists.txt

@@ -6,8 +6,9 @@
 
 set(NEO_CORE_COMPILER_INTERFACE_TESTS
   ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
+  ${CMAKE_CURRENT_SOURCE_DIR}/compiler_cache_tests.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/linker_mock.h
   ${CMAKE_CURRENT_SOURCE_DIR}/linker_tests.cpp
 )
 
-set_property(GLOBAL PROPERTY NEO_CORE_COMPILER_INTERFACE_TESTS ${NEO_CORE_COMPILER_INTERFACE_TESTS})
+set_property(GLOBAL PROPERTY NEO_CORE_COMPILER_INTERFACE_TESTS ${NEO_CORE_COMPILER_INTERFACE_TESTS})