From 5a4a2ab8ab59a4c4433598c79666898d7dc7c344 Mon Sep 17 00:00:00 2001
From: "Diedrich, Kamil" <kamil.diedrich@intel.com>
Date: Tue, 9 May 2023 00:39:55 +0200
Subject: [PATCH] feature: Add new environment variables for compiler cache

This patch add new environment variables to control compiler cache.
Works as follow: If persistent cache is set driver check if NEO_CACHE_DIR
is set. If not then driver checks XDG_CACHE_HOME - If exists
then driver create neo_compiler_cache folder, if
not then driver checks HOME directory. If each NEO_CACHE_DIR,
XDG_CACHE_HOME and HOME are not set then compiler cache is disabled.
Current support is for Linux only.

Signed-off-by: Diedrich, Kamil <kamil.diedrich@intel.com>

Related-To: NEO-4262
---
 opencl/doc/FAQ.md                             |  62 +-
 .../default_cache_config.cpp                  |  42 +-
 .../compiler_interface/CMakeLists.txt         |   6 +-
 .../linux/default_cl_cache_config_tests.cpp   | 213 +++++
 .../source/compiler_interface/CMakeLists.txt  |   3 +
 .../linux/os_compiler_cache_helper.cpp        |  57 ++
 .../os_compiler_cache_helper.h                |  14 +
 .../windows/os_compiler_cache_helper.cpp      |  14 +
 shared/source/os_interface/linux/sys_calls.h  |   1 +
 .../os_interface/linux/sys_calls_linux.cpp    |   4 +
 .../linux/sys_calls_linux_ult.cpp             |  14 +
 .../os_interface/linux/sys_calls_linux_ult.h  |   2 +
 .../compiler_interface/CMakeLists.txt         |  11 +-
 .../compiler_cache_tests.cpp                  | 570 -------------
 .../linux/compiler_cache_tests_linux.cpp      | 806 ++++++++++++++++++
 .../windows/compiler_cache_tests_windows.cpp  |  23 +
 16 files changed, 1257 insertions(+), 585 deletions(-)
 create mode 100644 opencl/test/unit_test/compiler_interface/linux/default_cl_cache_config_tests.cpp
 create mode 100644 shared/source/compiler_interface/linux/os_compiler_cache_helper.cpp
 create mode 100644 shared/source/compiler_interface/os_compiler_cache_helper.h
 create mode 100644 shared/source/compiler_interface/windows/os_compiler_cache_helper.cpp
 create mode 100644 shared/test/unit_test/compiler_interface/linux/compiler_cache_tests_linux.cpp
 create mode 100644 shared/test/unit_test/compiler_interface/windows/compiler_cache_tests_windows.cpp

diff --git a/opencl/doc/FAQ.md b/opencl/doc/FAQ.md
index 99d84e1b5f..8f381e5f67 100644
--- a/opencl/doc/FAQ.md
+++ b/opencl/doc/FAQ.md
@@ -1,6 +1,6 @@
 <!---
 
-Copyright (C) 2020-2021 Intel Corporation
+Copyright (C) 2020-2023 Intel Corporation
 
 SPDX-License-Identifier: MIT
 
@@ -40,29 +40,67 @@ See the enabling [guide](cl_intel_va_api_media_sharing.md).
 
 ## Feature: cl_cache
 
+Originally, compute-runtime had an experimental cache implementation, which was replaced
+in Q2'23 with a more robust approach. Legacy solution is now considered deprecated and the
+old experimental controls explained below will be removed by EOY 2023.
+
 ### What is cl_cache?
 
 This is a mechanism to cache binary representations of OpenCL kernels provided in text form by
 the application. By storing the binary representations, compiling is required only the first time,
 which improves performance.
 
-### How can cl_cache be enabled?
+### Linux
+
+#### Official instructions
+
+##### Environment flags (Linux only)
+
+NEO_PERSISTENT_CACHE - integer value to enable (1)/disable (0) on-disk binary cache. When enabled 
+                       Neo will try to cache and reuse compiled binaries. Default is off.
+
+NEO_CACHE_DIR        - path to persistent cache directory. Default values are $XDG_CACHE_HOME/neo_compiler_cache
+                       if $XDG_CACHE_HOME is set, $HOME/neo_compiler_cache otherwise. If none of environment
+                       variables are set then on-disk cache is disabled.
+
+NEO_CACHE_MAX_SIZE   - Cache eviction is triggered once total size of cached binaries exceeds the value in
+                       bytes (default is 1GB). Set to 0 to disable size-based cache eviction.
+
+##### How cl_cache works (Linux implementation)
+
+When persistent cache is enabled at first occurance driver create config.file which contains amount directory
+size and is also entry point to caching mechanism.
+
+Each write to disk has following steps:
+1. lock config.file (advisor lock)
+2. create temporary file
+3. write content to file
+4. rename temporary file to proper hash name
+
+Reads are unblocked
+
+Eviction mechanism is working as follow:
+1. lock config.file (advisor lock)
+2. scandir will gather all entries created by the driver
+3. stat all files and check last usage time
+4. sort files
+5. remove least recently used files with 1/3 amount size
+
+#### Legacy approach
 
 In the working directory, manually create *cl_cache* directory.
 The driver will use this directory to store the binary representations of the compiled kernels.
 Note: This will work on all supported OSes.
 
-### Configuring cl_cache location
+##### Configuring cl_cache location
 
 Cached kernels can be stored in a different directory than the default one.
 This is useful when the application is installed into a directory
 for which the user doesn't have permissions.
 
-#### Linux configuration
-
 Set the environment variable named `cl_cache_dir` to new location of cl_cache directory.
 
-#### Example:
+##### Example:
 
 If the application's directory is `/home/user/Document`, by default cl_cache will be stored in
  `/home/user/Document/cl_cache`. If the new path should be `/home/user/Desktop/cl_cache_place`,
@@ -74,14 +112,20 @@ export cl_cache_dir=/home/user/Desktop/cl_cache_place
 Subsequent application runs with passed source code and `cl_cache_dir` environment variable set will
 reuse previously cached kernel binaries instead of compiling kernels from source.
 
-#### Windows configuration
+### Windows
+
+#### Official instructions (implementation pending)
+
+#### Legacy approach
+
+##### Windows configuration
 
 To set the new location of cl_cache directory - in the registry `HKEY_LOCAL_MACHINE\SOFTWARE\Intel\IGFX\OCL`:
 1. add key `cl_cache_dir`
 1. add string value named <path_to_app> to `cl_cache_dir` key
 1. set data of added value to desired location of cl_cache
 
-#### Example:
+##### Example:
 
 If application is located in `C:\Program Files\application\app.exe`,
 by default cl_cache will be stored in `C:\Program Files\application\cl_cache`.
@@ -98,7 +142,7 @@ Neo will look for string value (REG_SZ) `C:\Program Files\application\app.exe`
 in key `HKEY_LOCAL_MACHINE\SOFTWARE\Intel\IGFX\OCL\cl_cache_dir`.
 Data of this string value will be used as new cl_cache dump directory for this specific application.
 
-### What are the known limitations of cl_cache?
+##### What are the known limitations of cl_cache for Windows?
 
 1. Not thread safe.
 (Workaround: Make sure your clBuildProgram calls are executed in thread safe fashion.)
diff --git a/opencl/source/compiler_interface/default_cache_config.cpp b/opencl/source/compiler_interface/default_cache_config.cpp
index 962de6e8d8..e13b2a345f 100644
--- a/opencl/source/compiler_interface/default_cache_config.cpp
+++ b/opencl/source/compiler_interface/default_cache_config.cpp
@@ -7,6 +7,7 @@
 
 #include "shared/source/compiler_interface/default_cache_config.h"
 
+#include "shared/source/compiler_interface/os_compiler_cache_helper.h"
 #include "shared/source/helpers/constants.h"
 #include "shared/source/os_interface/sys_calls_common.h"
 #include "shared/source/utilities/debug_settings_reader.h"
@@ -19,13 +20,46 @@
 #include <string>
 
 namespace NEO {
+std::string NeoCachePersistent = "NEO_CACHE_PERSISTENT";
+std::string NeoCacheMaxSize = "NEO_CACHE_MAX_SIZE";
+std::string NeoCacheDir = "NEO_CACHE_DIR";
+std::string ClCacheDir = "cl_cache_dir";
+
 CompilerCacheConfig getDefaultCompilerCacheConfig() {
     CompilerCacheConfig ret;
 
-    std::string keyName = oclRegPath;
-    keyName += "cl_cache_dir";
-    std::unique_ptr<SettingsReader> settingsReader(SettingsReader::createOsReader(false, keyName));
-    ret.cacheDir = settingsReader->getSetting(settingsReader->appSpecificLocation(keyName), static_cast<std::string>(CL_CACHE_LOCATION));
+    std::unique_ptr<SettingsReader> settingsReader(SettingsReader::createOsReader(false, oclRegPath));
+
+    auto cachePersistentKey = oclRegPath + NeoCachePersistent;
+
+    if (settingsReader->getSetting(settingsReader->appSpecificLocation(cachePersistentKey), 0l) != 0) {
+        ret.enabled = true;
+        std::string emptyString = "";
+        ret.cacheDir = settingsReader->getSetting(settingsReader->appSpecificLocation(NeoCacheDir), emptyString);
+
+        if (ret.cacheDir.empty()) {
+            if (!checkDefaultCacheDirSettings(ret.cacheDir, settingsReader.get())) {
+                ret.enabled = false;
+                return ret;
+            }
+        } else {
+            if (!NEO::SysCalls::pathExists(ret.cacheDir)) {
+                ret.cacheDir = "";
+                ret.enabled = false;
+                return ret;
+            }
+        }
+
+        ret.cacheSize = static_cast<size_t>(settingsReader->getSetting(settingsReader->appSpecificLocation(NeoCacheMaxSize), static_cast<int64_t>(MemoryConstants::gigaByte)));
+
+        if (ret.cacheSize == 0u) {
+            ret.cacheSize = std::numeric_limits<size_t>::max();
+        }
+
+        return ret;
+    }
+
+    ret.cacheDir = settingsReader->getSetting(settingsReader->appSpecificLocation(ClCacheDir), static_cast<std::string>(CL_CACHE_LOCATION));
 
     if (NEO::SysCalls::pathExists(ret.cacheDir)) {
         ret.enabled = true;
diff --git a/opencl/test/unit_test/compiler_interface/CMakeLists.txt b/opencl/test/unit_test/compiler_interface/CMakeLists.txt
index 729d266a98..ba445daa83 100644
--- a/opencl/test/unit_test/compiler_interface/CMakeLists.txt
+++ b/opencl/test/unit_test/compiler_interface/CMakeLists.txt
@@ -1,5 +1,5 @@
 #
-# Copyright (C) 2018-2021 Intel Corporation
+# Copyright (C) 2018-2023 Intel Corporation
 #
 # SPDX-License-Identifier: MIT
 #
@@ -11,3 +11,7 @@ set(IGDRCL_SRCS_tests_compiler_interface
 )
 
 target_sources(igdrcl_tests PRIVATE ${IGDRCL_SRCS_tests_compiler_interface})
+
+if(NOT WIN32)
+  target_sources(igdrcl_tests PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/linux/default_cl_cache_config_tests.cpp)
+endif()
diff --git a/opencl/test/unit_test/compiler_interface/linux/default_cl_cache_config_tests.cpp b/opencl/test/unit_test/compiler_interface/linux/default_cl_cache_config_tests.cpp
new file mode 100644
index 0000000000..e37507bb08
--- /dev/null
+++ b/opencl/test/unit_test/compiler_interface/linux/default_cl_cache_config_tests.cpp
@@ -0,0 +1,213 @@
+/*
+ * Copyright (C) 2023 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#include "shared/source/compiler_interface/default_cache_config.h"
+#include "shared/source/os_interface/sys_calls_common.h"
+#include "shared/source/utilities/io_functions.h"
+#include "shared/test/common/helpers/variable_backup.h"
+#include "shared/test/common/mocks/mock_io_functions.h"
+#include "shared/test/common/os_interface/linux/sys_calls_linux_ult.h"
+#include "shared/test/common/test_macros/test.h"
+
+namespace NEO {
+
+namespace SysCalls {
+extern bool pathExistsMock;
+}
+
+namespace AllVariablesCorrectlySet {
+bool pathExistsMock(const std::string &path) {
+    if (path.find("ult/directory/") != path.npos)
+        return true;
+
+    return false;
+}
+} // namespace AllVariablesCorrectlySet
+
+TEST(CompilerCache, GivenAllEnvVarWhenProperlySetThenProperConfigIsReturned) {
+    std::unordered_map<std::string, std::string> mockableEnvs;
+    mockableEnvs["NEO_CACHE_PERSISTENT"] = "1";
+    mockableEnvs["NEO_CACHE_MAX_SIZE"] = "22";
+    mockableEnvs["NEO_CACHE_DIR"] = "ult/directory/";
+
+    VariableBackup<std::unordered_map<std::string, std::string> *> mockableEnvValuesBackup(&NEO::IoFunctions::mockableEnvValues, &mockableEnvs);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsPathExists)> pathExistsBackup(&NEO::SysCalls::sysCallsPathExists, AllVariablesCorrectlySet::pathExistsMock);
+
+    auto cacheConfig = getDefaultCompilerCacheConfig();
+
+    EXPECT_TRUE(cacheConfig.enabled);
+    EXPECT_EQ(cacheConfig.cacheSize, 22u);
+    EXPECT_EQ(cacheConfig.cacheDir, "ult/directory/");
+}
+
+namespace NonExistingPathIsSet {
+bool pathExistsMock(const std::string &path) {
+    return false;
+}
+} // namespace NonExistingPathIsSet
+
+TEST(CompilerCache, GivenNonExistingPathWhenGetCompilerCacheConfigThenConfigWithDisabledCacheIsReturned) {
+    std::unordered_map<std::string, std::string> mockableEnvs;
+    mockableEnvs["NEO_CACHE_PERSISTENT"] = "1";
+    mockableEnvs["NEO_CACHE_MAX_SIZE"] = "22";
+    mockableEnvs["NEO_CACHE_DIR"] = "ult/directory/";
+
+    VariableBackup<std::unordered_map<std::string, std::string> *> mockableEnvValuesBackup(&NEO::IoFunctions::mockableEnvValues, &mockableEnvs);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsPathExists)> pathExistsBackup(&NEO::SysCalls::sysCallsPathExists, NonExistingPathIsSet::pathExistsMock);
+
+    auto cacheConfig = getDefaultCompilerCacheConfig();
+
+    EXPECT_FALSE(cacheConfig.enabled);
+    EXPECT_TRUE(cacheConfig.cacheDir.empty());
+}
+
+namespace XDGEnvPathIsSet {
+bool pathExistsMock(const std::string &path) {
+    if (path.find("xdg/directory/neo_compiler_cache") != path.npos) {
+        return true;
+    }
+    if (path.find("xdg/directory/") != path.npos) {
+        return true;
+    }
+    return false;
+}
+} // namespace XDGEnvPathIsSet
+
+TEST(CompilerCache, GivenXdgCachePathSetWhenGetCompilerCacheConfigThenConfigWithEnabledCacheIsReturned) {
+    std::unordered_map<std::string, std::string> mockableEnvs;
+    mockableEnvs["NEO_CACHE_PERSISTENT"] = "1";
+    mockableEnvs["NEO_CACHE_MAX_SIZE"] = "22";
+    mockableEnvs["XDG_CACHE_HOME"] = "xdg/directory/";
+
+    VariableBackup<std::unordered_map<std::string, std::string> *> mockableEnvValuesBackup(&NEO::IoFunctions::mockableEnvValues, &mockableEnvs);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsPathExists)> pathExistsBackup(&NEO::SysCalls::sysCallsPathExists, XDGEnvPathIsSet::pathExistsMock);
+
+    auto cacheConfig = getDefaultCompilerCacheConfig();
+
+    EXPECT_TRUE(cacheConfig.enabled);
+    EXPECT_EQ(cacheConfig.cacheSize, 22u);
+    EXPECT_EQ(cacheConfig.cacheDir, "xdg/directory/neo_compiler_cache");
+}
+
+namespace HomeEnvPathIsSet {
+bool pathExistsMock(const std::string &path) {
+    if (path.find("home/directory/.cache/neo_compiler_cache") != path.npos) {
+        return true;
+    }
+    if (path.find("home/directory/.cache/") != path.npos) {
+        return true;
+    }
+    return false;
+}
+} // namespace HomeEnvPathIsSet
+
+TEST(CompilerCache, GivenHomeCachePathSetWhenGetCompilerCacheConfigThenConfigWithEnabledCacheIsReturned) {
+    std::unordered_map<std::string, std::string> mockableEnvs;
+    mockableEnvs["NEO_CACHE_PERSISTENT"] = "1";
+    mockableEnvs["NEO_CACHE_MAX_SIZE"] = "22";
+    mockableEnvs["HOME"] = "home/directory/";
+
+    VariableBackup<std::unordered_map<std::string, std::string> *> mockableEnvValuesBackup(&NEO::IoFunctions::mockableEnvValues, &mockableEnvs);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsPathExists)> pathExistsBackup(&NEO::SysCalls::sysCallsPathExists, HomeEnvPathIsSet::pathExistsMock);
+
+    auto cacheConfig = getDefaultCompilerCacheConfig();
+
+    EXPECT_TRUE(cacheConfig.enabled);
+    EXPECT_EQ(cacheConfig.cacheSize, 22u);
+    EXPECT_EQ(cacheConfig.cacheDir, "home/directory/.cache/neo_compiler_cache");
+}
+
+TEST(CompilerCache, GivenCacheMaxSizeSetTo0WhenGetDefaultConfigThenCacheSizeIsSetToMaxSize) {
+    std::unordered_map<std::string, std::string> mockableEnvs;
+    mockableEnvs["NEO_CACHE_PERSISTENT"] = "1";
+    mockableEnvs["NEO_CACHE_MAX_SIZE"] = "0";
+    mockableEnvs["NEO_CACHE_DIR"] = "ult/directory/";
+
+    VariableBackup<std::unordered_map<std::string, std::string> *> mockableEnvValuesBackup(&NEO::IoFunctions::mockableEnvValues, &mockableEnvs);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsPathExists)> pathExistsBackup(&NEO::SysCalls::sysCallsPathExists, AllVariablesCorrectlySet::pathExistsMock);
+
+    auto cacheConfig = getDefaultCompilerCacheConfig();
+
+    EXPECT_TRUE(cacheConfig.enabled);
+    EXPECT_EQ(cacheConfig.cacheSize, std::numeric_limits<size_t>::max());
+    EXPECT_EQ(cacheConfig.cacheDir, "ult/directory/");
+}
+
+namespace XdgPathIsSetAndNeedToCreate {
+bool pathExistsMock(const std::string &path) {
+    if (path.find("xdg/directory/neo_compiler_cache") != path.npos) {
+        return false;
+    }
+    if (path.find("xdg/directory/") != path.npos) {
+        return true;
+    }
+    return false;
+}
+int mkdirMock(const std::string &dir) {
+    return 0;
+}
+} // namespace XdgPathIsSetAndNeedToCreate
+
+TEST(CompilerCache, GivenXdgEnvWhenNeoCompilerCacheNotExistsThenCreateNeoCompilerCacheFolder) {
+    std::unordered_map<std::string, std::string> mockableEnvs;
+    mockableEnvs["NEO_CACHE_PERSISTENT"] = "1";
+    mockableEnvs["NEO_CACHE_MAX_SIZE"] = "22";
+    mockableEnvs["XDG_CACHE_HOME"] = "xdg/directory/";
+
+    VariableBackup<std::unordered_map<std::string, std::string> *> mockableEnvValuesBackup(&NEO::IoFunctions::mockableEnvValues, &mockableEnvs);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsPathExists)> pathExistsBackup(&NEO::SysCalls::sysCallsPathExists, XdgPathIsSetAndNeedToCreate::pathExistsMock);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsMkdir)> mkdirBackup(&NEO::SysCalls::sysCallsMkdir, XdgPathIsSetAndNeedToCreate::mkdirMock);
+
+    auto cacheConfig = getDefaultCompilerCacheConfig();
+
+    EXPECT_TRUE(cacheConfig.enabled);
+    EXPECT_EQ(cacheConfig.cacheSize, 22u);
+    EXPECT_EQ(cacheConfig.cacheDir, "xdg/directory/neo_compiler_cache");
+}
+
+namespace XdgPathIsSetAndOtherProcessCreatesPath {
+bool mkdirCalled = false;
+
+bool pathExistsMock(const std::string &path) {
+    if (path.find("xdg/directory/neo_compiler_cache") != path.npos) {
+        return false;
+    }
+    if (path.find("xdg/directory/") != path.npos) {
+        return true;
+    }
+    return false;
+}
+int mkdirMock(const std::string &dir) {
+    if (dir.find("xdg/directory/neo_compiler_cache") != dir.npos) {
+        mkdirCalled = true;
+        errno = EEXIST;
+        return -1;
+    }
+    return 0;
+}
+} // namespace XdgPathIsSetAndOtherProcessCreatesPath
+
+TEST(CompilerCache, GivenXdgEnvWhenOtherProcessCreatesNeoCompilerCacheFolderThenProperConfigIsReturned) {
+    std::unordered_map<std::string, std::string> mockableEnvs;
+    mockableEnvs["NEO_CACHE_PERSISTENT"] = "1";
+    mockableEnvs["NEO_CACHE_MAX_SIZE"] = "22";
+    mockableEnvs["XDG_CACHE_HOME"] = "xdg/directory/";
+    bool mkdirCalledTemp = false;
+
+    VariableBackup<std::unordered_map<std::string, std::string> *> mockableEnvValuesBackup(&NEO::IoFunctions::mockableEnvValues, &mockableEnvs);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsPathExists)> pathExistsBackup(&NEO::SysCalls::sysCallsPathExists, XdgPathIsSetAndOtherProcessCreatesPath::pathExistsMock);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsMkdir)> mkdirBackup(&NEO::SysCalls::sysCallsMkdir, XdgPathIsSetAndOtherProcessCreatesPath::mkdirMock);
+    VariableBackup<bool> mkdirCalledBackup(&XdgPathIsSetAndOtherProcessCreatesPath::mkdirCalled, mkdirCalledTemp);
+
+    auto cacheConfig = getDefaultCompilerCacheConfig();
+
+    EXPECT_TRUE(cacheConfig.enabled);
+    EXPECT_EQ(cacheConfig.cacheSize, 22u);
+    EXPECT_EQ(cacheConfig.cacheDir, "xdg/directory/neo_compiler_cache");
+    EXPECT_TRUE(XdgPathIsSetAndOtherProcessCreatesPath::mkdirCalled);
+}
+} // namespace NEO
diff --git a/shared/source/compiler_interface/CMakeLists.txt b/shared/source/compiler_interface/CMakeLists.txt
index 173502e7a6..dd1749f464 100644
--- a/shared/source/compiler_interface/CMakeLists.txt
+++ b/shared/source/compiler_interface/CMakeLists.txt
@@ -23,16 +23,19 @@ set(NEO_CORE_COMPILER_INTERFACE
     ${CMAKE_CURRENT_SOURCE_DIR}/intermediate_representations.h
     ${CMAKE_CURRENT_SOURCE_DIR}/linker.h
     ${CMAKE_CURRENT_SOURCE_DIR}/linker.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/os_compiler_cache_helper.h
     ${CMAKE_CURRENT_SOURCE_DIR}/tokenized_string.h
 )
 
 if(WIN32)
   list(APPEND NEO_CORE_COMPILER_INTERFACE
        ${CMAKE_CURRENT_SOURCE_DIR}/windows/compiler_cache_windows.cpp
+       ${CMAKE_CURRENT_SOURCE_DIR}/windows/os_compiler_cache_helper.cpp
   )
 else()
   list(APPEND NEO_CORE_COMPILER_INTERFACE
        ${CMAKE_CURRENT_SOURCE_DIR}/linux/compiler_cache_linux.cpp
+       ${CMAKE_CURRENT_SOURCE_DIR}/linux/os_compiler_cache_helper.cpp
   )
 endif()
 
diff --git a/shared/source/compiler_interface/linux/os_compiler_cache_helper.cpp b/shared/source/compiler_interface/linux/os_compiler_cache_helper.cpp
new file mode 100644
index 0000000000..fa45ec3f91
--- /dev/null
+++ b/shared/source/compiler_interface/linux/os_compiler_cache_helper.cpp
@@ -0,0 +1,57 @@
+/*
+ * Copyright (C) 2023 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#include "shared/source/compiler_interface/os_compiler_cache_helper.h"
+
+#include "shared/source/os_interface/linux/sys_calls.h"
+#include "shared/source/utilities/debug_settings_reader.h"
+
+namespace NEO {
+bool createCompilerCachePath(std::string &cacheDir) {
+    if (NEO::SysCalls::pathExists(cacheDir)) {
+        if (NEO::SysCalls::pathExists(cacheDir + "neo_compiler_cache")) {
+            cacheDir = cacheDir + "neo_compiler_cache";
+            return true;
+        }
+
+        if (NEO::SysCalls::mkdir(cacheDir + "neo_compiler_cache") == 0) {
+            cacheDir = cacheDir + "neo_compiler_cache";
+            return true;
+        } else {
+            if (errno == EEXIST) {
+                cacheDir = cacheDir + "neo_compiler_cache";
+                return true;
+            }
+        }
+    }
+
+    cacheDir = "";
+    return false;
+}
+
+bool checkDefaultCacheDirSettings(std::string &cacheDir, SettingsReader *reader) {
+    std::string emptyString = "";
+    cacheDir = reader->getSetting(reader->appSpecificLocation("XDG_CACHE_HOME"), emptyString);
+
+    if (cacheDir.empty()) {
+        cacheDir = reader->getSetting(reader->appSpecificLocation("HOME"), emptyString);
+        if (cacheDir.empty()) {
+            return false;
+        }
+
+        cacheDir = cacheDir + ".cache/";
+
+        return createCompilerCachePath(cacheDir);
+    }
+
+    if (NEO::SysCalls::pathExists(cacheDir)) {
+        return createCompilerCachePath(cacheDir);
+    }
+
+    return false;
+}
+} // namespace NEO
\ No newline at end of file
diff --git a/shared/source/compiler_interface/os_compiler_cache_helper.h b/shared/source/compiler_interface/os_compiler_cache_helper.h
new file mode 100644
index 0000000000..d29a2952af
--- /dev/null
+++ b/shared/source/compiler_interface/os_compiler_cache_helper.h
@@ -0,0 +1,14 @@
+/*
+ * Copyright (C) 2023 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#pragma once
+#include <string>
+
+namespace NEO {
+class SettingsReader;
+bool checkDefaultCacheDirSettings(std::string &cacheDir, SettingsReader *reader);
+} // namespace NEO
\ No newline at end of file
diff --git a/shared/source/compiler_interface/windows/os_compiler_cache_helper.cpp b/shared/source/compiler_interface/windows/os_compiler_cache_helper.cpp
new file mode 100644
index 0000000000..a8c1fc3675
--- /dev/null
+++ b/shared/source/compiler_interface/windows/os_compiler_cache_helper.cpp
@@ -0,0 +1,14 @@
+/*
+ * Copyright (C) 2023 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#include "shared/source/compiler_interface/os_compiler_cache_helper.h"
+
+namespace NEO {
+bool checkDefaultCacheDirSettings(std::string &cacheDir, SettingsReader *reader) {
+    return false;
+}
+} // namespace NEO
\ No newline at end of file
diff --git a/shared/source/os_interface/linux/sys_calls.h b/shared/source/os_interface/linux/sys_calls.h
index 9f8987452c..a5c238418f 100644
--- a/shared/source/os_interface/linux/sys_calls.h
+++ b/shared/source/os_interface/linux/sys_calls.h
@@ -17,6 +17,7 @@
 namespace NEO {
 namespace SysCalls {
 int close(int fileDescriptor);
+int mkdir(const std::string &path);
 int open(const char *file, int flags);
 int openWithMode(const char *file, int flags, int mode);
 void *dlopen(const char *filename, int flag);
diff --git a/shared/source/os_interface/linux/sys_calls_linux.cpp b/shared/source/os_interface/linux/sys_calls_linux.cpp
index 3523186173..4ab967409a 100644
--- a/shared/source/os_interface/linux/sys_calls_linux.cpp
+++ b/shared/source/os_interface/linux/sys_calls_linux.cpp
@@ -51,6 +51,10 @@ unsigned long getNumThreads() {
     return taskStat.st_nlink - 2;
 }
 
+int mkdir(const std::string &path) {
+    return ::mkdir(path.c_str(), S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH);
+}
+
 int close(int fileDescriptor) {
     return ::close(fileDescriptor);
 }
diff --git a/shared/test/common/os_interface/linux/sys_calls_linux_ult.cpp b/shared/test/common/os_interface/linux/sys_calls_linux_ult.cpp
index 49036d5c60..bf3fe41a79 100644
--- a/shared/test/common/os_interface/linux/sys_calls_linux_ult.cpp
+++ b/shared/test/common/os_interface/linux/sys_calls_linux_ult.cpp
@@ -89,8 +89,22 @@ int (*sysCallsScandir)(const char *dirp,
 int (*sysCallsUnlink)(const std::string &pathname) = nullptr;
 int (*sysCallsStat)(const std::string &filePath, struct stat *statbuf) = nullptr;
 int (*sysCallsMkstemp)(char *fileName) = nullptr;
+int (*sysCallsMkdir)(const std::string &dir) = nullptr;
+bool (*sysCallsPathExists)(const std::string &path) = nullptr;
+
+int mkdir(const std::string &path) {
+    if (sysCallsMkdir != nullptr) {
+        return sysCallsMkdir(path);
+    }
+
+    return 0;
+}
 
 bool pathExists(const std::string &path) {
+    if (sysCallsPathExists != nullptr) {
+        return sysCallsPathExists(path);
+    }
+
     return pathExistsMock;
 }
 
diff --git a/shared/test/common/os_interface/linux/sys_calls_linux_ult.h b/shared/test/common/os_interface/linux/sys_calls_linux_ult.h
index efbf1467c5..f30d425abe 100644
--- a/shared/test/common/os_interface/linux/sys_calls_linux_ult.h
+++ b/shared/test/common/os_interface/linux/sys_calls_linux_ult.h
@@ -16,6 +16,7 @@
 namespace NEO {
 namespace SysCalls {
 
+extern int (*sysCallsMkdir)(const std::string &dir);
 extern int (*sysCallsOpen)(const char *pathname, int flags);
 extern int (*sysCallsOpenWithMode)(const char *pathname, int flags, int mode);
 extern ssize_t (*sysCallsPread)(int fd, void *buf, size_t count, off_t offset);
@@ -38,6 +39,7 @@ extern int (*sysCallsScandir)(const char *dirp,
 extern int (*sysCallsUnlink)(const std::string &pathname);
 extern int (*sysCallsStat)(const std::string &filePath, struct stat *statbuf);
 extern int (*sysCallsMkstemp)(char *fileName);
+extern bool (*sysCallsPathExists)(const std::string &path);
 
 extern int flockRetVal;
 extern int closeFuncRetVal;
diff --git a/shared/test/unit_test/compiler_interface/CMakeLists.txt b/shared/test/unit_test/compiler_interface/CMakeLists.txt
index 630d438028..57e6c77cff 100644
--- a/shared/test/unit_test/compiler_interface/CMakeLists.txt
+++ b/shared/test/unit_test/compiler_interface/CMakeLists.txt
@@ -1,5 +1,5 @@
 #
-# Copyright (C) 2019-2022 Intel Corporation
+# Copyright (C) 2019-2023 Intel Corporation
 #
 # SPDX-License-Identifier: MIT
 #
@@ -14,3 +14,12 @@ target_sources(neo_shared_tests PRIVATE
                ${CMAKE_CURRENT_SOURCE_DIR}/linker_tests.cpp
 )
 
+if(WIN32)
+  target_sources(neo_shared_tests PRIVATE
+                 ${CMAKE_CURRENT_SOURCE_DIR}/windows/compiler_cache_tests_windows.cpp
+  )
+else()
+  target_sources(neo_shared_tests PRIVATE
+                 ${CMAKE_CURRENT_SOURCE_DIR}/linux/compiler_cache_tests_linux.cpp
+  )
+endif()
\ No newline at end of file
diff --git a/shared/test/unit_test/compiler_interface/compiler_cache_tests.cpp b/shared/test/unit_test/compiler_interface/compiler_cache_tests.cpp
index 0ccb848325..800e48f8f3 100644
--- a/shared/test/unit_test/compiler_interface/compiler_cache_tests.cpp
+++ b/shared/test/unit_test/compiler_interface/compiler_cache_tests.cpp
@@ -418,573 +418,3 @@ TEST(CompilerInterfaceCachedTests, givenKernelWithIncludesAndBinaryInCacheWhenCo
 
     gEnvironment->fclPopDebugVars();
 }
-
-#ifndef _WIN32
-
-#include "shared/test/common/os_interface/linux/sys_calls_linux_ult.h"
-
-class CompilerCacheMockLinux : public CompilerCache {
-  public:
-    CompilerCacheMockLinux(const CompilerCacheConfig &config) : CompilerCache(config) {}
-    using CompilerCache::createUniqueTempFileAndWriteData;
-    using CompilerCache::evictCache;
-    using CompilerCache::lockConfigFileAndReadSize;
-    using CompilerCache::renameTempFileBinaryToProperName;
-};
-
-namespace EvictCachePass {
-decltype(NEO::SysCalls::sysCallsScandir) mockScandir = [](const char *dirp,
-                                                          struct dirent ***namelist,
-                                                          int (*filter)(const struct dirent *),
-                                                          int (*compar)(const struct dirent **,
-                                                                        const struct dirent **)) -> int {
-    struct dirent **v = (struct dirent **)malloc(6 * (sizeof(struct dirent *)));
-
-    v[0] = (struct dirent *)malloc(sizeof(struct dirent));
-
-    memcpy_s(v[0]->d_name, sizeof(v[0]->d_name), "file1.cl_cache", sizeof("file1.cl_cache"));
-
-    v[1] = (struct dirent *)malloc(sizeof(struct dirent));
-
-    memcpy_s(v[1]->d_name, sizeof(v[1]->d_name), "file2.cl_cache", sizeof("file2.cl_cache"));
-
-    v[2] = (struct dirent *)malloc(sizeof(struct dirent));
-
-    memcpy_s(v[2]->d_name, sizeof(v[2]->d_name), "file3.cl_cache", sizeof("file3.cl_cache"));
-
-    v[3] = (struct dirent *)malloc(sizeof(struct dirent));
-
-    memcpy_s(v[3]->d_name, sizeof(v[3]->d_name), "file4.cl_cache", sizeof("file4.cl_cache"));
-
-    v[4] = (struct dirent *)malloc(sizeof(struct dirent));
-
-    memcpy_s(v[4]->d_name, sizeof(v[4]->d_name), "file5.cl_cache", sizeof("file5.cl_cache"));
-
-    v[5] = (struct dirent *)malloc(sizeof(struct dirent));
-
-    memcpy_s(v[5]->d_name, sizeof(v[5]->d_name), "file6.cl_cache", sizeof("file6.cl_cache"));
-
-    *namelist = v;
-    return 6;
-};
-
-decltype(NEO::SysCalls::sysCallsStat) mockStat = [](const std::string &filePath, struct stat *statbuf) -> int {
-    if (filePath.find("file1") != filePath.npos) {
-        statbuf->st_atime = 3;
-    }
-    if (filePath.find("file2") != filePath.npos) {
-        statbuf->st_atime = 6;
-    }
-    if (filePath.find("file3") != filePath.npos) {
-        statbuf->st_atime = 1;
-    }
-    if (filePath.find("file4") != filePath.npos) {
-        statbuf->st_atime = 2;
-    }
-    if (filePath.find("file5") != filePath.npos) {
-        statbuf->st_atime = 4;
-    }
-    if (filePath.find("file6") != filePath.npos) {
-        statbuf->st_atime = 5;
-    }
-    statbuf->st_size = (MemoryConstants::megaByte / 6) + 10;
-
-    return 0;
-};
-
-std::vector<std::string> *unlinkFiles;
-
-decltype(NEO::SysCalls::sysCallsUnlink) mockUnlink = [](const std::string &pathname) -> int {
-    unlinkFiles->push_back(pathname);
-
-    return 0;
-};
-} // namespace EvictCachePass
-
-TEST(CompilerCacheTests, GivenCompilerCacheWithOneMegabyteWhenEvictCacheIsCalledThenUnlinkTwoOldestFiles) {
-    std::vector<std::string> unlinkLocalFiles;
-    EvictCachePass::unlinkFiles = &unlinkLocalFiles;
-
-    VariableBackup<decltype(NEO::SysCalls::sysCallsScandir)> scandirBackup(&NEO::SysCalls::sysCallsScandir, EvictCachePass::mockScandir);
-    VariableBackup<decltype(NEO::SysCalls::sysCallsStat)> statBackup(&NEO::SysCalls::sysCallsStat, EvictCachePass::mockStat);
-    VariableBackup<decltype(NEO::SysCalls::sysCallsUnlink)> unlinkBackup(&NEO::SysCalls::sysCallsUnlink, EvictCachePass::mockUnlink);
-
-    CompilerCacheMockLinux cache({true, ".cl_cache", "/home/cl_cache/", MemoryConstants::megaByte - 2u});
-
-    EXPECT_TRUE(cache.evictCache());
-
-    EXPECT_EQ(unlinkLocalFiles.size(), 2u);
-
-    EXPECT_NE(unlinkLocalFiles[0].find("file3"), unlinkLocalFiles[0].npos);
-    EXPECT_NE(unlinkLocalFiles[1].find("file4"), unlinkLocalFiles[1].npos);
-}
-
-TEST(CompilerCacheTests, GivenCompilerCacheWithWhenScandirFailThenEvictCacheFail) {
-    CompilerCacheMockLinux cache({true, ".cl_cache", "/home/cl_cache/", MemoryConstants::megaByte});
-    VariableBackup<decltype(NEO::SysCalls::sysCallsScandir)> scandirBackup(&NEO::SysCalls::sysCallsScandir, [](const char *dirp, struct dirent ***namelist, int (*filter)(const struct dirent *), int (*compar)(const struct dirent **, const struct dirent **)) -> int { return -1; });
-
-    EXPECT_FALSE(cache.evictCache());
-}
-
-namespace CreateUniqueTempFilePass {
-decltype(NEO::SysCalls::sysCallsMkstemp) mockMkstemp = [](char *fileName) -> int {
-    memcpy_s(&fileName[22], 20, "123456", sizeof("123456"));
-    return 1;
-};
-
-decltype(NEO::SysCalls::sysCallsPwrite) mockPwrite = [](int fd, const void *buf, size_t count, off_t offset) -> ssize_t {
-    return count;
-};
-} // namespace CreateUniqueTempFilePass
-
-TEST(CompilerCacheTests, GivenCompilerCacheWhenCreateUniqueTempFileAndWriteDataThenFileIsCreatedAndDataAreWritten) {
-    VariableBackup<decltype(NEO::SysCalls::sysCallsMkstemp)> mkstempBackup(&NEO::SysCalls::sysCallsMkstemp, CreateUniqueTempFilePass::mockMkstemp);
-    VariableBackup<decltype(NEO::SysCalls::sysCallsPwrite)> pwriteBackup(&NEO::SysCalls::sysCallsPwrite, CreateUniqueTempFilePass::mockPwrite);
-
-    CompilerCacheMockLinux cache({true, ".cl_cache", "/home/cl_cache/", MemoryConstants::megaByte - 2u});
-
-    char x[256] = "/home/cl_cache/mytemp.XXXXXX";
-    char compare[256] = "/home/cl_cache/mytemp.123456";
-    EXPECT_TRUE(cache.createUniqueTempFileAndWriteData(x, "1", 1));
-
-    EXPECT_EQ(0, memcmp(x, compare, 28));
-}
-
-namespace CreateUniqueTempFileFail1 {
-decltype(NEO::SysCalls::sysCallsMkstemp) mockMkstemp = [](char *fileName) -> int {
-    return -1;
-};
-} // namespace CreateUniqueTempFileFail1
-
-TEST(CompilerCacheTests, GivenCompilerCacheWithCreateUniqueTempFileAndWriteDataWhenMkstempFailThenFalseIsReturned) {
-    VariableBackup<decltype(NEO::SysCalls::sysCallsMkstemp)> mkstempBackup(&NEO::SysCalls::sysCallsMkstemp, CreateUniqueTempFileFail1::mockMkstemp);
-    CompilerCacheMockLinux cache({true, ".cl_cache", "/home/cl_cache/", MemoryConstants::megaByte - 2u});
-
-    char x[256] = "/home/cl_cache/mytemp.XXXXXX";
-    EXPECT_FALSE(cache.createUniqueTempFileAndWriteData(x, "1", 1));
-}
-
-namespace CreateUniqueTempFileFail2 {
-decltype(NEO::SysCalls::sysCallsMkstemp) mockMkstemp = [](char *fileName) -> int {
-    memcpy_s(&fileName[22], 20, "123456", sizeof("123456"));
-    return 1;
-};
-
-decltype(NEO::SysCalls::sysCallsPwrite) mockPwrite = [](int fd, const void *buf, size_t count, off_t offset) -> ssize_t {
-    return -1;
-};
-} // namespace CreateUniqueTempFileFail2
-
-TEST(CompilerCacheTests, GivenCompilerCacheWithCreateUniqueTempFileAndWriteDataWhenPwriteFailThenFalseIsReturnedAndCleanupIsMade) {
-    std::vector<std::string> unlinkLocalFiles;
-    EvictCachePass::unlinkFiles = &unlinkLocalFiles;
-
-    VariableBackup<decltype(NEO::SysCalls::sysCallsUnlink)> unlinkBackup(&NEO::SysCalls::sysCallsUnlink, EvictCachePass::mockUnlink);
-    VariableBackup<decltype(NEO::SysCalls::sysCallsMkstemp)> mkstempBackup(&NEO::SysCalls::sysCallsMkstemp, CreateUniqueTempFileFail2::mockMkstemp);
-    VariableBackup<decltype(NEO::SysCalls::sysCallsPwrite)> pwriteBackup(&NEO::SysCalls::sysCallsPwrite, CreateUniqueTempFileFail2::mockPwrite);
-
-    CompilerCacheMockLinux cache({true, ".cl_cache", "/home/cl_cache/", MemoryConstants::megaByte - 2u});
-
-    char x[256] = "/home/cl_cache/mytemp.XXXXXX";
-    EXPECT_FALSE(cache.createUniqueTempFileAndWriteData(x, "1", 1));
-    EXPECT_EQ(NEO::SysCalls::closeFuncArgPassed, 1);
-    EXPECT_EQ(0, memcmp(x, unlinkLocalFiles[0].c_str(), 28));
-}
-
-TEST(CompilerCacheTests, GivenCompilerCacheWithCreateUniqueTempFileAndWriteDataWhenCloseFailThenFalseIsReturned) {
-    int closeRetVal = -1;
-    VariableBackup<decltype(NEO::SysCalls::sysCallsMkstemp)> mkstempBackup(&NEO::SysCalls::sysCallsMkstemp, CreateUniqueTempFilePass::mockMkstemp);
-    VariableBackup<decltype(NEO::SysCalls::sysCallsPwrite)> pwriteBackup(&NEO::SysCalls::sysCallsPwrite, CreateUniqueTempFilePass::mockPwrite);
-    VariableBackup<decltype(NEO::SysCalls::closeFuncRetVal)> closeBackup(&NEO::SysCalls::closeFuncRetVal, closeRetVal);
-
-    CompilerCacheMockLinux cache({true, ".cl_cache", "/home/cl_cache/", MemoryConstants::megaByte - 2u});
-
-    char x[256] = "/home/cl_cache/mytemp.XXXXXX";
-    EXPECT_FALSE(cache.createUniqueTempFileAndWriteData(x, "1", 1));
-}
-
-TEST(CompilerCacheTests, GivenCompilerCacheWhenRenameFailThenFalseIsReturned) {
-    int unlinkTemp = 0;
-    VariableBackup<decltype(NEO::SysCalls::unlinkCalled)> unlinkBackup(&NEO::SysCalls::unlinkCalled, unlinkTemp);
-    VariableBackup<decltype(NEO::SysCalls::sysCallsRename)> renameBackup(&NEO::SysCalls::sysCallsRename, [](const char *currName, const char *dstName) -> int { return -1; });
-
-    CompilerCacheMockLinux cache({true, ".cl_cache", "/home/cl_cache/", MemoryConstants::megaByte});
-
-    EXPECT_FALSE(cache.renameTempFileBinaryToProperName("src", "dst"));
-    EXPECT_EQ(NEO::SysCalls::unlinkCalled, 1);
-}
-
-TEST(CompilerCacheTests, GivenCompilerCacheWhenRenameThenTrueIsReturned) {
-    VariableBackup<decltype(NEO::SysCalls::sysCallsRename)> renameBackup(&NEO::SysCalls::sysCallsRename, [](const char *currName, const char *dstName) -> int { return 0; });
-
-    CompilerCacheMockLinux cache({true, ".cl_cache", "/home/cl_cache/", MemoryConstants::megaByte});
-
-    EXPECT_TRUE(cache.renameTempFileBinaryToProperName("src", "dst"));
-}
-
-TEST(CompilerCacheTests, GivenCompilerCacheWhenConfigFileIsInacessibleThenFdIsSetToNegativeNumber) {
-    CompilerCacheMockLinux cache({true, ".cl_cache", "/home/cl_cache/", MemoryConstants::megaByte});
-
-    VariableBackup<decltype(NEO::SysCalls::sysCallsOpen)> openBackup(&NEO::SysCalls::sysCallsOpen, [](const char *pathname, int flags) -> int { errno = EACCES;  return -1; });
-
-    int configFileDescriptor = 0;
-    size_t directory = 0;
-
-    cache.lockConfigFileAndReadSize("config.file", configFileDescriptor, directory);
-
-    EXPECT_EQ(configFileDescriptor, -1);
-}
-
-TEST(CompilerCacheTests, GivenCompilerCacheWhenCannotLockConfigFileThenFdIsSetToNegativeNumber) {
-    CompilerCacheMockLinux cache({true, ".cl_cache", "/home/cl_cache/", MemoryConstants::megaByte});
-    int flockRetVal = -1;
-
-    VariableBackup<decltype(NEO::SysCalls::flockRetVal)> flockBackup(&NEO::SysCalls::flockRetVal, flockRetVal);
-
-    int configFileDescriptor = 0;
-    size_t directory = 0;
-
-    cache.lockConfigFileAndReadSize("config.file", configFileDescriptor, directory);
-
-    EXPECT_EQ(configFileDescriptor, -1);
-}
-
-#include <fcntl.h>
-
-namespace LockConfigFileAndReadSize {
-int openWithMode(const char *file, int flags, int mode) {
-
-    if (flags == (O_CREAT | O_EXCL | O_RDWR)) {
-        return 1;
-    }
-
-    errno = 2;
-    return -1;
-}
-
-int open(const char *file, int flags) {
-    errno = 2;
-    return -1;
-}
-} // namespace LockConfigFileAndReadSize
-
-TEST(CompilerCacheTests, GivenCompilerCacheWhenScandirFailInLockConfigFileThenFdIsSetToNegativeNumber) {
-    CompilerCacheMockLinux cache({true, ".cl_cache", "/home/cl_cache/", MemoryConstants::megaByte});
-
-    VariableBackup<decltype(NEO::SysCalls::sysCallsScandir)> scandirBackup(&NEO::SysCalls::sysCallsScandir, [](const char *dirp, struct dirent ***namelist, int (*filter)(const struct dirent *), int (*compar)(const struct dirent **, const struct dirent **)) -> int { return -1; });
-    VariableBackup<decltype(NEO::SysCalls::sysCallsOpenWithMode)> openWithModeBackup(&NEO::SysCalls::sysCallsOpenWithMode, LockConfigFileAndReadSize::openWithMode);
-    VariableBackup<decltype(NEO::SysCalls::sysCallsOpen)> openBackup(&NEO::SysCalls::sysCallsOpen, LockConfigFileAndReadSize::open);
-
-    int configFileDescriptor = 0;
-    size_t directory = 0;
-
-    cache.lockConfigFileAndReadSize("config.file", configFileDescriptor, directory);
-
-    EXPECT_EQ(configFileDescriptor, -1);
-}
-
-namespace lockConfigFileAndReadSizeMocks {
-decltype(NEO::SysCalls::sysCallsScandir) mockScandir = [](const char *dirp,
-                                                          struct dirent ***namelist,
-                                                          int (*filter)(const struct dirent *),
-                                                          int (*compar)(const struct dirent **,
-                                                                        const struct dirent **)) -> int {
-    struct dirent **v = (struct dirent **)malloc(4 * (sizeof(struct dirent *)));
-
-    v[0] = (struct dirent *)malloc(sizeof(struct dirent));
-
-    memcpy_s(v[0]->d_name, sizeof(v[0]->d_name), "file1.cl_cache", sizeof("file1.cl_cache"));
-
-    v[1] = (struct dirent *)malloc(sizeof(struct dirent));
-
-    memcpy_s(v[1]->d_name, sizeof(v[1]->d_name), "file2.cl_cache", sizeof("file2.cl_cache"));
-
-    v[2] = (struct dirent *)malloc(sizeof(struct dirent));
-
-    memcpy_s(v[2]->d_name, sizeof(v[2]->d_name), "file3.cl_cache", sizeof("file3.cl_cache"));
-
-    v[3] = (struct dirent *)malloc(sizeof(struct dirent));
-
-    memcpy_s(v[3]->d_name, sizeof(v[3]->d_name), "file4.cl_cache", sizeof("file4.cl_cache"));
-
-    *namelist = v;
-    return 4;
-};
-
-decltype(NEO::SysCalls::sysCallsStat) mockStat = [](const std::string &filePath, struct stat *statbuf) -> int {
-    if (filePath.find("file1") != filePath.npos) {
-        statbuf->st_atime = 3;
-    }
-    if (filePath.find("file2") != filePath.npos) {
-        statbuf->st_atime = 6;
-    }
-    if (filePath.find("file3") != filePath.npos) {
-        statbuf->st_atime = 1;
-    }
-    if (filePath.find("file4") != filePath.npos) {
-        statbuf->st_atime = 2;
-    }
-
-    statbuf->st_size = (MemoryConstants::megaByte / 4);
-
-    return 0;
-};
-} // namespace lockConfigFileAndReadSizeMocks
-
-TEST(CompilerCacheTests, GivenCompilerCacheWhenLockConfigFileWithFileCreationThenFdIsSetProperSizeIsSetAndScandirIsCalled) {
-    CompilerCacheMockLinux cache({true, ".cl_cache", "/home/cl_cache/", MemoryConstants::megaByte});
-    int scandirCalledTemp = 0;
-
-    VariableBackup<decltype(NEO::SysCalls::scandirCalled)> scandirCalledBackup(&NEO::SysCalls::scandirCalled, scandirCalledTemp);
-    VariableBackup<decltype(NEO::SysCalls::sysCallsScandir)> scandirBackup(&NEO::SysCalls::sysCallsScandir, lockConfigFileAndReadSizeMocks::mockScandir);
-    VariableBackup<decltype(NEO::SysCalls::sysCallsStat)> statBackup(&NEO::SysCalls::sysCallsStat, lockConfigFileAndReadSizeMocks::mockStat);
-    VariableBackup<decltype(NEO::SysCalls::sysCallsOpenWithMode)> openWithModeBackup(&NEO::SysCalls::sysCallsOpenWithMode, LockConfigFileAndReadSize::openWithMode);
-    VariableBackup<decltype(NEO::SysCalls::sysCallsOpen)> openBackup(&NEO::SysCalls::sysCallsOpen, LockConfigFileAndReadSize::open);
-
-    int configFileDescriptor = 0;
-    size_t directory = 0;
-
-    cache.lockConfigFileAndReadSize("config.file", configFileDescriptor, directory);
-
-    EXPECT_EQ(configFileDescriptor, 1);
-    EXPECT_EQ(NEO::SysCalls::scandirCalled, 1);
-    EXPECT_EQ(directory, MemoryConstants::megaByte);
-}
-
-namespace LockConfigFileAndConfigFileIsCreatedInMeantime {
-int openCalledTimes = 0;
-int openWithMode(const char *file, int flags, int mode) {
-
-    if (flags == (O_CREAT | O_EXCL | O_RDWR)) {
-        return -1;
-    }
-
-    return 0;
-}
-
-int open(const char *file, int flags) {
-    if (openCalledTimes == 0) {
-        openCalledTimes++;
-        errno = 2;
-        return -1;
-    }
-
-    return 1;
-}
-
-size_t configSize = MemoryConstants::megaByte;
-ssize_t pread(int fd, void *buf, size_t count, off_t offset) {
-    memcpy(buf, &configSize, sizeof(configSize));
-    return 0;
-}
-} // namespace LockConfigFileAndConfigFileIsCreatedInMeantime
-
-TEST(CompilerCacheTests, GivenCompilerCacheWhenLockConfigFileAndOtherProcessCreateInMeanTimeThenFdIsSetProperSizeIsSetAndScandirIsNotCalled) {
-    CompilerCacheMockLinux cache({true, ".cl_cache", "/home/cl_cache/", MemoryConstants::megaByte});
-    int openCalledTimes = 0;
-    int scandirCalledTimes = 0;
-
-    VariableBackup<decltype(NEO::SysCalls::scandirCalled)> scandirCalledBackup(&NEO::SysCalls::scandirCalled, scandirCalledTimes);
-    VariableBackup<decltype(LockConfigFileAndConfigFileIsCreatedInMeantime::openCalledTimes)> openCalledBackup(&LockConfigFileAndConfigFileIsCreatedInMeantime::openCalledTimes, openCalledTimes);
-    VariableBackup<decltype(NEO::SysCalls::sysCallsPread)> preadBackup(&NEO::SysCalls::sysCallsPread, LockConfigFileAndConfigFileIsCreatedInMeantime::pread);
-    VariableBackup<decltype(NEO::SysCalls::sysCallsOpenWithMode)> openWithModeBackup(&NEO::SysCalls::sysCallsOpenWithMode, LockConfigFileAndConfigFileIsCreatedInMeantime::openWithMode);
-    VariableBackup<decltype(NEO::SysCalls::sysCallsOpen)> openBackup(&NEO::SysCalls::sysCallsOpen, LockConfigFileAndConfigFileIsCreatedInMeantime::open);
-
-    int configFileDescriptor = 0;
-    size_t directory = 0;
-
-    cache.lockConfigFileAndReadSize("config.file", configFileDescriptor, directory);
-
-    EXPECT_EQ(configFileDescriptor, 1);
-    EXPECT_EQ(NEO::SysCalls::scandirCalled, 0);
-    EXPECT_EQ(directory, LockConfigFileAndConfigFileIsCreatedInMeantime::configSize);
-}
-
-TEST(CompilerCacheTests, GivenCompilerCacheWhenLockConfigFileThenFdIsSetProperSizeIsSetAndScandirIsNotCalled) {
-    CompilerCacheMockLinux cache({true, ".cl_cache", "/home/cl_cache/", MemoryConstants::megaByte});
-    int scandirCalledTimes = 0;
-
-    VariableBackup<decltype(NEO::SysCalls::scandirCalled)> scandirCalledBackup(&NEO::SysCalls::scandirCalled, scandirCalledTimes);
-    VariableBackup<decltype(NEO::SysCalls::sysCallsPread)> preadBackup(&NEO::SysCalls::sysCallsPread, LockConfigFileAndConfigFileIsCreatedInMeantime::pread);
-
-    int configFileDescriptor = 0;
-    size_t directory = 0;
-
-    cache.lockConfigFileAndReadSize("config.file", configFileDescriptor, directory);
-
-    EXPECT_EQ(configFileDescriptor, NEO::SysCalls::fakeFileDescriptor);
-    EXPECT_EQ(NEO::SysCalls::scandirCalled, 0);
-    EXPECT_EQ(directory, LockConfigFileAndConfigFileIsCreatedInMeantime::configSize);
-}
-
-class CompilerCacheFailingLokcConfigFileAndReadSizeLinux : public CompilerCache {
-  public:
-    CompilerCacheFailingLokcConfigFileAndReadSizeLinux(const CompilerCacheConfig &config) : CompilerCache(config) {}
-    using CompilerCache::createUniqueTempFileAndWriteData;
-    using CompilerCache::evictCache;
-    using CompilerCache::lockConfigFileAndReadSize;
-    using CompilerCache::renameTempFileBinaryToProperName;
-
-    void lockConfigFileAndReadSize(const std::string &configFilePath, int &fd, size_t &directorySize) override {
-        fd = -1;
-        return;
-    }
-};
-
-TEST(CompilerCacheTests, GivenCompilerCacheWhenLockConfigFileFailThenCacheBinaryReturnsFalse) {
-    CompilerCacheFailingLokcConfigFileAndReadSizeLinux cache({true, ".cl_cache", "/home/cl_cache/", MemoryConstants::megaByte});
-
-    EXPECT_FALSE(cache.cacheBinary("config.file", "1", 1));
-}
-
-class CompilerCacheLinuxReturnTrueIfAnotherProcessCreateCacheFile : public CompilerCache {
-  public:
-    CompilerCacheLinuxReturnTrueIfAnotherProcessCreateCacheFile(const CompilerCacheConfig &config) : CompilerCache(config) {}
-    using CompilerCache::createUniqueTempFileAndWriteData;
-    using CompilerCache::evictCache;
-    using CompilerCache::lockConfigFileAndReadSize;
-    using CompilerCache::renameTempFileBinaryToProperName;
-
-    void lockConfigFileAndReadSize(const std::string &configFilePath, int &fd, size_t &directorySize) override {
-        fd = 1;
-        return;
-    }
-};
-
-TEST(CompilerCacheTests, GivenCompilerCacheWhenFileAlreadyExistsThenCacheBinaryReturnsTrue) {
-    VariableBackup<decltype(NEO::SysCalls::sysCallsStat)> statBackup(&NEO::SysCalls::sysCallsStat, [](const std::string &filePath, struct stat *statbuf) -> int { return 0; });
-
-    CompilerCacheLinuxReturnTrueIfAnotherProcessCreateCacheFile cache({true, ".cl_cache", "/home/cl_cache/", MemoryConstants::megaByte});
-
-    EXPECT_TRUE(cache.cacheBinary("config.file", "1", 1));
-}
-
-class CompilerCacheLinuxReturnFalseOnCacheBinaryIfEvictFailed : public CompilerCache {
-  public:
-    CompilerCacheLinuxReturnFalseOnCacheBinaryIfEvictFailed(const CompilerCacheConfig &config) : CompilerCache(config) {}
-    using CompilerCache::createUniqueTempFileAndWriteData;
-    using CompilerCache::evictCache;
-    using CompilerCache::lockConfigFileAndReadSize;
-    using CompilerCache::renameTempFileBinaryToProperName;
-
-    void lockConfigFileAndReadSize(const std::string &configFilePath, int &fd, size_t &directorySize) override {
-        directorySize = MemoryConstants::megaByte;
-        fd = 1;
-        return;
-    }
-
-    bool evictCache() override {
-        return false;
-    }
-};
-
-TEST(CompilerCacheTests, GivenCompilerCacheWhenEvictCacheFailThenCacheBinaryReturnsFalse) {
-    VariableBackup<decltype(NEO::SysCalls::sysCallsStat)> statBackup(&NEO::SysCalls::sysCallsStat, [](const std::string &filePath, struct stat *statbuf) -> int { return -1; });
-
-    CompilerCacheLinuxReturnFalseOnCacheBinaryIfEvictFailed cache({true, ".cl_cache", "/home/cl_cache/", MemoryConstants::megaByte});
-
-    EXPECT_FALSE(cache.cacheBinary("config.file", "1", 1));
-}
-
-class CompilerCacheLinuxReturnFalseOnCacheBinaryIfCreateUniqueFileFailed : public CompilerCache {
-  public:
-    CompilerCacheLinuxReturnFalseOnCacheBinaryIfCreateUniqueFileFailed(const CompilerCacheConfig &config) : CompilerCache(config) {}
-    using CompilerCache::createUniqueTempFileAndWriteData;
-    using CompilerCache::evictCache;
-    using CompilerCache::lockConfigFileAndReadSize;
-    using CompilerCache::renameTempFileBinaryToProperName;
-
-    void lockConfigFileAndReadSize(const std::string &configFilePath, int &fd, size_t &directorySize) override {
-        directorySize = MemoryConstants::megaByte;
-        fd = 1;
-        return;
-    }
-
-    bool evictCache() override {
-        return true;
-    }
-
-    bool createUniqueTempFileAndWriteData(char *tmpFilePathTemplate, const char *pBinary, size_t binarySize) override {
-        return false;
-    }
-};
-
-TEST(CompilerCacheTests, GivenCompilerCacheWhenCreateUniqueFileFailThenCacheBinaryReturnsFalse) {
-    VariableBackup<decltype(NEO::SysCalls::sysCallsStat)> statBackup(&NEO::SysCalls::sysCallsStat, [](const std::string &filePath, struct stat *statbuf) -> int { return -1; });
-
-    CompilerCacheLinuxReturnFalseOnCacheBinaryIfCreateUniqueFileFailed cache({true, ".cl_cache", "/home/cl_cache/", MemoryConstants::megaByte});
-
-    EXPECT_FALSE(cache.cacheBinary("config.file", "1", 1));
-}
-
-class CompilerCacheLinuxReturnFalseOnCacheBinaryIfRenameFileFailed : public CompilerCache {
-  public:
-    CompilerCacheLinuxReturnFalseOnCacheBinaryIfRenameFileFailed(const CompilerCacheConfig &config) : CompilerCache(config) {}
-    using CompilerCache::createUniqueTempFileAndWriteData;
-    using CompilerCache::evictCache;
-    using CompilerCache::lockConfigFileAndReadSize;
-    using CompilerCache::renameTempFileBinaryToProperName;
-
-    void lockConfigFileAndReadSize(const std::string &configFilePath, int &fd, size_t &directorySize) override {
-        directorySize = MemoryConstants::megaByte;
-        fd = 1;
-        return;
-    }
-
-    bool evictCache() override {
-        return true;
-    }
-
-    bool createUniqueTempFileAndWriteData(char *tmpFilePathTemplate, const char *pBinary, size_t binarySize) override {
-        return true;
-    }
-
-    bool renameTempFileBinaryToProperName(const std::string &oldName, const std::string &kernelFileHash) override {
-        return false;
-    }
-};
-
-TEST(CompilerCacheTests, GivenCompilerCacheWhenRenameFileFailThenCacheBinaryReturnsFalse) {
-    VariableBackup<decltype(NEO::SysCalls::sysCallsStat)> statBackup(&NEO::SysCalls::sysCallsStat, [](const std::string &filePath, struct stat *statbuf) -> int { return -1; });
-
-    CompilerCacheLinuxReturnFalseOnCacheBinaryIfRenameFileFailed cache({true, ".cl_cache", "/home/cl_cache/", MemoryConstants::megaByte});
-
-    EXPECT_FALSE(cache.cacheBinary("config.file", "1", 1));
-}
-
-class CompilerCacheLinuxReturnTrueOnCacheBinary : public CompilerCache {
-  public:
-    CompilerCacheLinuxReturnTrueOnCacheBinary(const CompilerCacheConfig &config) : CompilerCache(config) {}
-    using CompilerCache::createUniqueTempFileAndWriteData;
-    using CompilerCache::evictCache;
-    using CompilerCache::lockConfigFileAndReadSize;
-    using CompilerCache::renameTempFileBinaryToProperName;
-
-    void lockConfigFileAndReadSize(const std::string &configFilePath, int &fd, size_t &directorySize) override {
-        directorySize = MemoryConstants::megaByte;
-        fd = 1;
-        return;
-    }
-
-    bool evictCache() override {
-        return true;
-    }
-
-    bool createUniqueTempFileAndWriteData(char *tmpFilePathTemplate, const char *pBinary, size_t binarySize) override {
-        return true;
-    }
-
-    bool renameTempFileBinaryToProperName(const std::string &oldName, const std::string &kernelFileHash) override {
-        return true;
-    }
-};
-
-TEST(CompilerCacheTests, GivenCompilerCacheWhenAllFunctionsSuccedThenCacheBinaryReturnsTrue) {
-    VariableBackup<decltype(NEO::SysCalls::sysCallsStat)> statBackup(&NEO::SysCalls::sysCallsStat, [](const std::string &filePath, struct stat *statbuf) -> int { return 0; });
-
-    CompilerCacheLinuxReturnTrueOnCacheBinary cache({true, ".cl_cache", "/home/cl_cache/", MemoryConstants::megaByte});
-
-    EXPECT_TRUE(cache.cacheBinary("config.file", "1", 1));
-}
-
-#endif // !_WIN32
diff --git a/shared/test/unit_test/compiler_interface/linux/compiler_cache_tests_linux.cpp b/shared/test/unit_test/compiler_interface/linux/compiler_cache_tests_linux.cpp
new file mode 100644
index 0000000000..619b061e93
--- /dev/null
+++ b/shared/test/unit_test/compiler_interface/linux/compiler_cache_tests_linux.cpp
@@ -0,0 +1,806 @@
+/*
+ * Copyright (C) 2019-2023 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#include "shared/source/compiler_interface/compiler_cache.h"
+#include "shared/source/compiler_interface/compiler_interface.h"
+#include "shared/source/compiler_interface/default_cache_config.h"
+#include "shared/source/compiler_interface/os_compiler_cache_helper.h"
+#include "shared/source/helpers/aligned_memory.h"
+#include "shared/source/helpers/hash.h"
+#include "shared/source/helpers/hw_info.h"
+#include "shared/source/helpers/string.h"
+#include "shared/source/utilities/debug_settings_reader.h"
+#include "shared/source/utilities/io_functions.h"
+#include "shared/test/common/helpers/debug_manager_state_restore.h"
+#include "shared/test/common/helpers/default_hw_info.h"
+#include "shared/test/common/libult/global_environment.h"
+#include "shared/test/common/mocks/mock_compiler_cache.h"
+#include "shared/test/common/mocks/mock_device.h"
+#include "shared/test/common/mocks/mock_io_functions.h"
+#include "shared/test/common/os_interface/linux/sys_calls_linux_ult.h"
+#include "shared/test/common/test_macros/test.h"
+
+#include "os_inc.h"
+
+#include <array>
+#include <list>
+#include <memory>
+
+using namespace NEO;
+
+class CompilerCacheMockLinux : public CompilerCache {
+  public:
+    CompilerCacheMockLinux(const CompilerCacheConfig &config) : CompilerCache(config) {}
+    using CompilerCache::createUniqueTempFileAndWriteData;
+    using CompilerCache::evictCache;
+    using CompilerCache::lockConfigFileAndReadSize;
+    using CompilerCache::renameTempFileBinaryToProperName;
+};
+
+namespace EvictCachePass {
+decltype(NEO::SysCalls::sysCallsScandir) mockScandir = [](const char *dirp,
+                                                          struct dirent ***namelist,
+                                                          int (*filter)(const struct dirent *),
+                                                          int (*compar)(const struct dirent **,
+                                                                        const struct dirent **)) -> int {
+    struct dirent **v = (struct dirent **)malloc(6 * (sizeof(struct dirent *)));
+
+    v[0] = (struct dirent *)malloc(sizeof(struct dirent));
+
+    memcpy_s(v[0]->d_name, sizeof(v[0]->d_name), "file1.cl_cache", sizeof("file1.cl_cache"));
+
+    v[1] = (struct dirent *)malloc(sizeof(struct dirent));
+
+    memcpy_s(v[1]->d_name, sizeof(v[1]->d_name), "file2.cl_cache", sizeof("file2.cl_cache"));
+
+    v[2] = (struct dirent *)malloc(sizeof(struct dirent));
+
+    memcpy_s(v[2]->d_name, sizeof(v[2]->d_name), "file3.cl_cache", sizeof("file3.cl_cache"));
+
+    v[3] = (struct dirent *)malloc(sizeof(struct dirent));
+
+    memcpy_s(v[3]->d_name, sizeof(v[3]->d_name), "file4.cl_cache", sizeof("file4.cl_cache"));
+
+    v[4] = (struct dirent *)malloc(sizeof(struct dirent));
+
+    memcpy_s(v[4]->d_name, sizeof(v[4]->d_name), "file5.cl_cache", sizeof("file5.cl_cache"));
+
+    v[5] = (struct dirent *)malloc(sizeof(struct dirent));
+
+    memcpy_s(v[5]->d_name, sizeof(v[5]->d_name), "file6.cl_cache", sizeof("file6.cl_cache"));
+
+    *namelist = v;
+    return 6;
+};
+
+decltype(NEO::SysCalls::sysCallsStat) mockStat = [](const std::string &filePath, struct stat *statbuf) -> int {
+    if (filePath.find("file1") != filePath.npos) {
+        statbuf->st_atime = 3;
+    }
+    if (filePath.find("file2") != filePath.npos) {
+        statbuf->st_atime = 6;
+    }
+    if (filePath.find("file3") != filePath.npos) {
+        statbuf->st_atime = 1;
+    }
+    if (filePath.find("file4") != filePath.npos) {
+        statbuf->st_atime = 2;
+    }
+    if (filePath.find("file5") != filePath.npos) {
+        statbuf->st_atime = 4;
+    }
+    if (filePath.find("file6") != filePath.npos) {
+        statbuf->st_atime = 5;
+    }
+    statbuf->st_size = (MemoryConstants::megaByte / 6) + 10;
+
+    return 0;
+};
+
+std::vector<std::string> *unlinkFiles;
+
+decltype(NEO::SysCalls::sysCallsUnlink) mockUnlink = [](const std::string &pathname) -> int {
+    unlinkFiles->push_back(pathname);
+
+    return 0;
+};
+} // namespace EvictCachePass
+
+TEST(CompilerCacheTests, GivenCompilerCacheWithOneMegabyteWhenEvictCacheIsCalledThenUnlinkTwoOldestFiles) {
+    std::vector<std::string> unlinkLocalFiles;
+    EvictCachePass::unlinkFiles = &unlinkLocalFiles;
+
+    VariableBackup<decltype(NEO::SysCalls::sysCallsScandir)> scandirBackup(&NEO::SysCalls::sysCallsScandir, EvictCachePass::mockScandir);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsStat)> statBackup(&NEO::SysCalls::sysCallsStat, EvictCachePass::mockStat);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsUnlink)> unlinkBackup(&NEO::SysCalls::sysCallsUnlink, EvictCachePass::mockUnlink);
+
+    CompilerCacheMockLinux cache({true, ".cl_cache", "/home/cl_cache/", MemoryConstants::megaByte - 2u});
+
+    EXPECT_TRUE(cache.evictCache());
+
+    EXPECT_EQ(unlinkLocalFiles.size(), 2u);
+
+    EXPECT_NE(unlinkLocalFiles[0].find("file3"), unlinkLocalFiles[0].npos);
+    EXPECT_NE(unlinkLocalFiles[1].find("file4"), unlinkLocalFiles[1].npos);
+}
+
+TEST(CompilerCacheTests, GivenCompilerCacheWithWhenScandirFailThenEvictCacheFail) {
+    CompilerCacheMockLinux cache({true, ".cl_cache", "/home/cl_cache/", MemoryConstants::megaByte});
+    VariableBackup<decltype(NEO::SysCalls::sysCallsScandir)> scandirBackup(&NEO::SysCalls::sysCallsScandir, [](const char *dirp, struct dirent ***namelist, int (*filter)(const struct dirent *), int (*compar)(const struct dirent **, const struct dirent **)) -> int { return -1; });
+
+    EXPECT_FALSE(cache.evictCache());
+}
+
+namespace CreateUniqueTempFilePass {
+decltype(NEO::SysCalls::sysCallsMkstemp) mockMkstemp = [](char *fileName) -> int {
+    memcpy_s(&fileName[22], 20, "123456", sizeof("123456"));
+    return 1;
+};
+
+decltype(NEO::SysCalls::sysCallsPwrite) mockPwrite = [](int fd, const void *buf, size_t count, off_t offset) -> ssize_t {
+    return count;
+};
+} // namespace CreateUniqueTempFilePass
+
+TEST(CompilerCacheTests, GivenCompilerCacheWhenCreateUniqueTempFileAndWriteDataThenFileIsCreatedAndDataAreWritten) {
+    VariableBackup<decltype(NEO::SysCalls::sysCallsMkstemp)> mkstempBackup(&NEO::SysCalls::sysCallsMkstemp, CreateUniqueTempFilePass::mockMkstemp);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsPwrite)> pwriteBackup(&NEO::SysCalls::sysCallsPwrite, CreateUniqueTempFilePass::mockPwrite);
+
+    CompilerCacheMockLinux cache({true, ".cl_cache", "/home/cl_cache/", MemoryConstants::megaByte - 2u});
+
+    char x[256] = "/home/cl_cache/mytemp.XXXXXX";
+    char compare[256] = "/home/cl_cache/mytemp.123456";
+    EXPECT_TRUE(cache.createUniqueTempFileAndWriteData(x, "1", 1));
+
+    EXPECT_EQ(0, memcmp(x, compare, 28));
+}
+
+namespace CreateUniqueTempFileFail1 {
+decltype(NEO::SysCalls::sysCallsMkstemp) mockMkstemp = [](char *fileName) -> int {
+    return -1;
+};
+} // namespace CreateUniqueTempFileFail1
+
+TEST(CompilerCacheTests, GivenCompilerCacheWithCreateUniqueTempFileAndWriteDataWhenMkstempFailThenFalseIsReturned) {
+    VariableBackup<decltype(NEO::SysCalls::sysCallsMkstemp)> mkstempBackup(&NEO::SysCalls::sysCallsMkstemp, CreateUniqueTempFileFail1::mockMkstemp);
+    CompilerCacheMockLinux cache({true, ".cl_cache", "/home/cl_cache/", MemoryConstants::megaByte - 2u});
+
+    char x[256] = "/home/cl_cache/mytemp.XXXXXX";
+    EXPECT_FALSE(cache.createUniqueTempFileAndWriteData(x, "1", 1));
+}
+
+namespace CreateUniqueTempFileFail2 {
+decltype(NEO::SysCalls::sysCallsMkstemp) mockMkstemp = [](char *fileName) -> int {
+    memcpy_s(&fileName[22], 20, "123456", sizeof("123456"));
+    return 1;
+};
+
+decltype(NEO::SysCalls::sysCallsPwrite) mockPwrite = [](int fd, const void *buf, size_t count, off_t offset) -> ssize_t {
+    return -1;
+};
+} // namespace CreateUniqueTempFileFail2
+
+TEST(CompilerCacheTests, GivenCompilerCacheWithCreateUniqueTempFileAndWriteDataWhenPwriteFailThenFalseIsReturnedAndCleanupIsMade) {
+    std::vector<std::string> unlinkLocalFiles;
+    EvictCachePass::unlinkFiles = &unlinkLocalFiles;
+
+    VariableBackup<decltype(NEO::SysCalls::sysCallsUnlink)> unlinkBackup(&NEO::SysCalls::sysCallsUnlink, EvictCachePass::mockUnlink);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsMkstemp)> mkstempBackup(&NEO::SysCalls::sysCallsMkstemp, CreateUniqueTempFileFail2::mockMkstemp);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsPwrite)> pwriteBackup(&NEO::SysCalls::sysCallsPwrite, CreateUniqueTempFileFail2::mockPwrite);
+
+    CompilerCacheMockLinux cache({true, ".cl_cache", "/home/cl_cache/", MemoryConstants::megaByte - 2u});
+
+    char x[256] = "/home/cl_cache/mytemp.XXXXXX";
+    EXPECT_FALSE(cache.createUniqueTempFileAndWriteData(x, "1", 1));
+    EXPECT_EQ(NEO::SysCalls::closeFuncArgPassed, 1);
+    EXPECT_EQ(0, memcmp(x, unlinkLocalFiles[0].c_str(), 28));
+}
+
+TEST(CompilerCacheTests, GivenCompilerCacheWithCreateUniqueTempFileAndWriteDataWhenCloseFailThenFalseIsReturned) {
+    int closeRetVal = -1;
+    VariableBackup<decltype(NEO::SysCalls::sysCallsMkstemp)> mkstempBackup(&NEO::SysCalls::sysCallsMkstemp, CreateUniqueTempFilePass::mockMkstemp);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsPwrite)> pwriteBackup(&NEO::SysCalls::sysCallsPwrite, CreateUniqueTempFilePass::mockPwrite);
+    VariableBackup<decltype(NEO::SysCalls::closeFuncRetVal)> closeBackup(&NEO::SysCalls::closeFuncRetVal, closeRetVal);
+
+    CompilerCacheMockLinux cache({true, ".cl_cache", "/home/cl_cache/", MemoryConstants::megaByte - 2u});
+
+    char x[256] = "/home/cl_cache/mytemp.XXXXXX";
+    EXPECT_FALSE(cache.createUniqueTempFileAndWriteData(x, "1", 1));
+}
+
+TEST(CompilerCacheTests, GivenCompilerCacheWhenRenameFailThenFalseIsReturned) {
+    int unlinkTemp = 0;
+    VariableBackup<decltype(NEO::SysCalls::unlinkCalled)> unlinkBackup(&NEO::SysCalls::unlinkCalled, unlinkTemp);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsRename)> renameBackup(&NEO::SysCalls::sysCallsRename, [](const char *currName, const char *dstName) -> int { return -1; });
+
+    CompilerCacheMockLinux cache({true, ".cl_cache", "/home/cl_cache/", MemoryConstants::megaByte});
+
+    EXPECT_FALSE(cache.renameTempFileBinaryToProperName("src", "dst"));
+    EXPECT_EQ(NEO::SysCalls::unlinkCalled, 1);
+}
+
+TEST(CompilerCacheTests, GivenCompilerCacheWhenRenameThenTrueIsReturned) {
+    VariableBackup<decltype(NEO::SysCalls::sysCallsRename)> renameBackup(&NEO::SysCalls::sysCallsRename, [](const char *currName, const char *dstName) -> int { return 0; });
+
+    CompilerCacheMockLinux cache({true, ".cl_cache", "/home/cl_cache/", MemoryConstants::megaByte});
+
+    EXPECT_TRUE(cache.renameTempFileBinaryToProperName("src", "dst"));
+}
+
+TEST(CompilerCacheTests, GivenCompilerCacheWhenConfigFileIsInacessibleThenFdIsSetToNegativeNumber) {
+    CompilerCacheMockLinux cache({true, ".cl_cache", "/home/cl_cache/", MemoryConstants::megaByte});
+
+    VariableBackup<decltype(NEO::SysCalls::sysCallsOpen)> openBackup(&NEO::SysCalls::sysCallsOpen, [](const char *pathname, int flags) -> int { errno = EACCES;  return -1; });
+
+    int configFileDescriptor = 0;
+    size_t directory = 0;
+
+    cache.lockConfigFileAndReadSize("config.file", configFileDescriptor, directory);
+
+    EXPECT_EQ(configFileDescriptor, -1);
+}
+
+TEST(CompilerCacheTests, GivenCompilerCacheWhenCannotLockConfigFileThenFdIsSetToNegativeNumber) {
+    CompilerCacheMockLinux cache({true, ".cl_cache", "/home/cl_cache/", MemoryConstants::megaByte});
+    int flockRetVal = -1;
+
+    VariableBackup<decltype(NEO::SysCalls::flockRetVal)> flockBackup(&NEO::SysCalls::flockRetVal, flockRetVal);
+
+    int configFileDescriptor = 0;
+    size_t directory = 0;
+
+    cache.lockConfigFileAndReadSize("config.file", configFileDescriptor, directory);
+
+    EXPECT_EQ(configFileDescriptor, -1);
+}
+
+#include <fcntl.h>
+
+namespace LockConfigFileAndReadSize {
+int openWithMode(const char *file, int flags, int mode) {
+
+    if (flags == (O_CREAT | O_EXCL | O_RDWR)) {
+        return 1;
+    }
+
+    errno = 2;
+    return -1;
+}
+
+int open(const char *file, int flags) {
+    errno = 2;
+    return -1;
+}
+} // namespace LockConfigFileAndReadSize
+
+TEST(CompilerCacheTests, GivenCompilerCacheWhenScandirFailInLockConfigFileThenFdIsSetToNegativeNumber) {
+    CompilerCacheMockLinux cache({true, ".cl_cache", "/home/cl_cache/", MemoryConstants::megaByte});
+
+    VariableBackup<decltype(NEO::SysCalls::sysCallsScandir)> scandirBackup(&NEO::SysCalls::sysCallsScandir, [](const char *dirp, struct dirent ***namelist, int (*filter)(const struct dirent *), int (*compar)(const struct dirent **, const struct dirent **)) -> int { return -1; });
+    VariableBackup<decltype(NEO::SysCalls::sysCallsOpenWithMode)> openWithModeBackup(&NEO::SysCalls::sysCallsOpenWithMode, LockConfigFileAndReadSize::openWithMode);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsOpen)> openBackup(&NEO::SysCalls::sysCallsOpen, LockConfigFileAndReadSize::open);
+
+    int configFileDescriptor = 0;
+    size_t directory = 0;
+
+    cache.lockConfigFileAndReadSize("config.file", configFileDescriptor, directory);
+
+    EXPECT_EQ(configFileDescriptor, -1);
+}
+
+namespace lockConfigFileAndReadSizeMocks {
+decltype(NEO::SysCalls::sysCallsScandir) mockScandir = [](const char *dirp,
+                                                          struct dirent ***namelist,
+                                                          int (*filter)(const struct dirent *),
+                                                          int (*compar)(const struct dirent **,
+                                                                        const struct dirent **)) -> int {
+    struct dirent **v = (struct dirent **)malloc(4 * (sizeof(struct dirent *)));
+
+    v[0] = (struct dirent *)malloc(sizeof(struct dirent));
+
+    memcpy_s(v[0]->d_name, sizeof(v[0]->d_name), "file1.cl_cache", sizeof("file1.cl_cache"));
+
+    v[1] = (struct dirent *)malloc(sizeof(struct dirent));
+
+    memcpy_s(v[1]->d_name, sizeof(v[1]->d_name), "file2.cl_cache", sizeof("file2.cl_cache"));
+
+    v[2] = (struct dirent *)malloc(sizeof(struct dirent));
+
+    memcpy_s(v[2]->d_name, sizeof(v[2]->d_name), "file3.cl_cache", sizeof("file3.cl_cache"));
+
+    v[3] = (struct dirent *)malloc(sizeof(struct dirent));
+
+    memcpy_s(v[3]->d_name, sizeof(v[3]->d_name), "file4.cl_cache", sizeof("file4.cl_cache"));
+
+    *namelist = v;
+    return 4;
+};
+
+decltype(NEO::SysCalls::sysCallsStat) mockStat = [](const std::string &filePath, struct stat *statbuf) -> int {
+    if (filePath.find("file1") != filePath.npos) {
+        statbuf->st_atime = 3;
+    }
+    if (filePath.find("file2") != filePath.npos) {
+        statbuf->st_atime = 6;
+    }
+    if (filePath.find("file3") != filePath.npos) {
+        statbuf->st_atime = 1;
+    }
+    if (filePath.find("file4") != filePath.npos) {
+        statbuf->st_atime = 2;
+    }
+
+    statbuf->st_size = (MemoryConstants::megaByte / 4);
+
+    return 0;
+};
+} // namespace lockConfigFileAndReadSizeMocks
+
+TEST(CompilerCacheTests, GivenCompilerCacheWhenLockConfigFileWithFileCreationThenFdIsSetProperSizeIsSetAndScandirIsCalled) {
+    CompilerCacheMockLinux cache({true, ".cl_cache", "/home/cl_cache/", MemoryConstants::megaByte});
+    int scandirCalledTemp = 0;
+
+    VariableBackup<decltype(NEO::SysCalls::scandirCalled)> scandirCalledBackup(&NEO::SysCalls::scandirCalled, scandirCalledTemp);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsScandir)> scandirBackup(&NEO::SysCalls::sysCallsScandir, lockConfigFileAndReadSizeMocks::mockScandir);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsStat)> statBackup(&NEO::SysCalls::sysCallsStat, lockConfigFileAndReadSizeMocks::mockStat);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsOpenWithMode)> openWithModeBackup(&NEO::SysCalls::sysCallsOpenWithMode, LockConfigFileAndReadSize::openWithMode);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsOpen)> openBackup(&NEO::SysCalls::sysCallsOpen, LockConfigFileAndReadSize::open);
+
+    int configFileDescriptor = 0;
+    size_t directory = 0;
+
+    cache.lockConfigFileAndReadSize("config.file", configFileDescriptor, directory);
+
+    EXPECT_EQ(configFileDescriptor, 1);
+    EXPECT_EQ(NEO::SysCalls::scandirCalled, 1);
+    EXPECT_EQ(directory, MemoryConstants::megaByte);
+}
+
+namespace LockConfigFileAndConfigFileIsCreatedInMeantime {
+int openCalledTimes = 0;
+int openWithMode(const char *file, int flags, int mode) {
+
+    if (flags == (O_CREAT | O_EXCL | O_RDWR)) {
+        return -1;
+    }
+
+    return 0;
+}
+
+int open(const char *file, int flags) {
+    if (openCalledTimes == 0) {
+        openCalledTimes++;
+        errno = 2;
+        return -1;
+    }
+
+    return 1;
+}
+
+size_t configSize = MemoryConstants::megaByte;
+ssize_t pread(int fd, void *buf, size_t count, off_t offset) {
+    memcpy(buf, &configSize, sizeof(configSize));
+    return 0;
+}
+} // namespace LockConfigFileAndConfigFileIsCreatedInMeantime
+
+TEST(CompilerCacheTests, GivenCompilerCacheWhenLockConfigFileAndOtherProcessCreateInMeanTimeThenFdIsSetProperSizeIsSetAndScandirIsNotCalled) {
+    CompilerCacheMockLinux cache({true, ".cl_cache", "/home/cl_cache/", MemoryConstants::megaByte});
+    int openCalledTimes = 0;
+    int scandirCalledTimes = 0;
+
+    VariableBackup<decltype(NEO::SysCalls::scandirCalled)> scandirCalledBackup(&NEO::SysCalls::scandirCalled, scandirCalledTimes);
+    VariableBackup<decltype(LockConfigFileAndConfigFileIsCreatedInMeantime::openCalledTimes)> openCalledBackup(&LockConfigFileAndConfigFileIsCreatedInMeantime::openCalledTimes, openCalledTimes);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsPread)> preadBackup(&NEO::SysCalls::sysCallsPread, LockConfigFileAndConfigFileIsCreatedInMeantime::pread);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsOpenWithMode)> openWithModeBackup(&NEO::SysCalls::sysCallsOpenWithMode, LockConfigFileAndConfigFileIsCreatedInMeantime::openWithMode);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsOpen)> openBackup(&NEO::SysCalls::sysCallsOpen, LockConfigFileAndConfigFileIsCreatedInMeantime::open);
+
+    int configFileDescriptor = 0;
+    size_t directory = 0;
+
+    cache.lockConfigFileAndReadSize("config.file", configFileDescriptor, directory);
+
+    EXPECT_EQ(configFileDescriptor, 1);
+    EXPECT_EQ(NEO::SysCalls::scandirCalled, 0);
+    EXPECT_EQ(directory, LockConfigFileAndConfigFileIsCreatedInMeantime::configSize);
+}
+
+TEST(CompilerCacheTests, GivenCompilerCacheWhenLockConfigFileThenFdIsSetProperSizeIsSetAndScandirIsNotCalled) {
+    CompilerCacheMockLinux cache({true, ".cl_cache", "/home/cl_cache/", MemoryConstants::megaByte});
+    int scandirCalledTimes = 0;
+
+    VariableBackup<decltype(NEO::SysCalls::scandirCalled)> scandirCalledBackup(&NEO::SysCalls::scandirCalled, scandirCalledTimes);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsPread)> preadBackup(&NEO::SysCalls::sysCallsPread, LockConfigFileAndConfigFileIsCreatedInMeantime::pread);
+
+    int configFileDescriptor = 0;
+    size_t directory = 0;
+
+    cache.lockConfigFileAndReadSize("config.file", configFileDescriptor, directory);
+
+    EXPECT_EQ(configFileDescriptor, NEO::SysCalls::fakeFileDescriptor);
+    EXPECT_EQ(NEO::SysCalls::scandirCalled, 0);
+    EXPECT_EQ(directory, LockConfigFileAndConfigFileIsCreatedInMeantime::configSize);
+}
+
+class CompilerCacheFailingLokcConfigFileAndReadSizeLinux : public CompilerCache {
+  public:
+    CompilerCacheFailingLokcConfigFileAndReadSizeLinux(const CompilerCacheConfig &config) : CompilerCache(config) {}
+    using CompilerCache::createUniqueTempFileAndWriteData;
+    using CompilerCache::evictCache;
+    using CompilerCache::lockConfigFileAndReadSize;
+    using CompilerCache::renameTempFileBinaryToProperName;
+
+    void lockConfigFileAndReadSize(const std::string &configFilePath, int &fd, size_t &directorySize) override {
+        fd = -1;
+        return;
+    }
+};
+
+TEST(CompilerCacheTests, GivenCompilerCacheWhenLockConfigFileFailThenCacheBinaryReturnsFalse) {
+    CompilerCacheFailingLokcConfigFileAndReadSizeLinux cache({true, ".cl_cache", "/home/cl_cache/", MemoryConstants::megaByte});
+
+    EXPECT_FALSE(cache.cacheBinary("config.file", "1", 1));
+}
+
+class CompilerCacheLinuxReturnTrueIfAnotherProcessCreateCacheFile : public CompilerCache {
+  public:
+    CompilerCacheLinuxReturnTrueIfAnotherProcessCreateCacheFile(const CompilerCacheConfig &config) : CompilerCache(config) {}
+    using CompilerCache::createUniqueTempFileAndWriteData;
+    using CompilerCache::evictCache;
+    using CompilerCache::lockConfigFileAndReadSize;
+    using CompilerCache::renameTempFileBinaryToProperName;
+
+    void lockConfigFileAndReadSize(const std::string &configFilePath, int &fd, size_t &directorySize) override {
+        fd = 1;
+        return;
+    }
+};
+
+TEST(CompilerCacheTests, GivenCompilerCacheWhenFileAlreadyExistsThenCacheBinaryReturnsTrue) {
+    VariableBackup<decltype(NEO::SysCalls::sysCallsStat)> statBackup(&NEO::SysCalls::sysCallsStat, [](const std::string &filePath, struct stat *statbuf) -> int { return 0; });
+
+    CompilerCacheLinuxReturnTrueIfAnotherProcessCreateCacheFile cache({true, ".cl_cache", "/home/cl_cache/", MemoryConstants::megaByte});
+
+    EXPECT_TRUE(cache.cacheBinary("config.file", "1", 1));
+}
+
+class CompilerCacheLinuxReturnFalseOnCacheBinaryIfEvictFailed : public CompilerCache {
+  public:
+    CompilerCacheLinuxReturnFalseOnCacheBinaryIfEvictFailed(const CompilerCacheConfig &config) : CompilerCache(config) {}
+    using CompilerCache::createUniqueTempFileAndWriteData;
+    using CompilerCache::evictCache;
+    using CompilerCache::lockConfigFileAndReadSize;
+    using CompilerCache::renameTempFileBinaryToProperName;
+
+    void lockConfigFileAndReadSize(const std::string &configFilePath, int &fd, size_t &directorySize) override {
+        directorySize = MemoryConstants::megaByte;
+        fd = 1;
+        return;
+    }
+
+    bool evictCache() override {
+        return false;
+    }
+};
+
+TEST(CompilerCacheTests, GivenCompilerCacheWhenEvictCacheFailThenCacheBinaryReturnsFalse) {
+    VariableBackup<decltype(NEO::SysCalls::sysCallsStat)> statBackup(&NEO::SysCalls::sysCallsStat, [](const std::string &filePath, struct stat *statbuf) -> int { return -1; });
+
+    CompilerCacheLinuxReturnFalseOnCacheBinaryIfEvictFailed cache({true, ".cl_cache", "/home/cl_cache/", MemoryConstants::megaByte});
+
+    EXPECT_FALSE(cache.cacheBinary("config.file", "1", 1));
+}
+
+class CompilerCacheLinuxReturnFalseOnCacheBinaryIfCreateUniqueFileFailed : public CompilerCache {
+  public:
+    CompilerCacheLinuxReturnFalseOnCacheBinaryIfCreateUniqueFileFailed(const CompilerCacheConfig &config) : CompilerCache(config) {}
+    using CompilerCache::createUniqueTempFileAndWriteData;
+    using CompilerCache::evictCache;
+    using CompilerCache::lockConfigFileAndReadSize;
+    using CompilerCache::renameTempFileBinaryToProperName;
+
+    void lockConfigFileAndReadSize(const std::string &configFilePath, int &fd, size_t &directorySize) override {
+        directorySize = MemoryConstants::megaByte;
+        fd = 1;
+        return;
+    }
+
+    bool evictCache() override {
+        return true;
+    }
+
+    bool createUniqueTempFileAndWriteData(char *tmpFilePathTemplate, const char *pBinary, size_t binarySize) override {
+        return false;
+    }
+};
+
+TEST(CompilerCacheTests, GivenCompilerCacheWhenCreateUniqueFileFailThenCacheBinaryReturnsFalse) {
+    VariableBackup<decltype(NEO::SysCalls::sysCallsStat)> statBackup(&NEO::SysCalls::sysCallsStat, [](const std::string &filePath, struct stat *statbuf) -> int { return -1; });
+
+    CompilerCacheLinuxReturnFalseOnCacheBinaryIfCreateUniqueFileFailed cache({true, ".cl_cache", "/home/cl_cache/", MemoryConstants::megaByte});
+
+    EXPECT_FALSE(cache.cacheBinary("config.file", "1", 1));
+}
+
+class CompilerCacheLinuxReturnFalseOnCacheBinaryIfRenameFileFailed : public CompilerCache {
+  public:
+    CompilerCacheLinuxReturnFalseOnCacheBinaryIfRenameFileFailed(const CompilerCacheConfig &config) : CompilerCache(config) {}
+    using CompilerCache::createUniqueTempFileAndWriteData;
+    using CompilerCache::evictCache;
+    using CompilerCache::lockConfigFileAndReadSize;
+    using CompilerCache::renameTempFileBinaryToProperName;
+
+    void lockConfigFileAndReadSize(const std::string &configFilePath, int &fd, size_t &directorySize) override {
+        directorySize = MemoryConstants::megaByte;
+        fd = 1;
+        return;
+    }
+
+    bool evictCache() override {
+        return true;
+    }
+
+    bool createUniqueTempFileAndWriteData(char *tmpFilePathTemplate, const char *pBinary, size_t binarySize) override {
+        return true;
+    }
+
+    bool renameTempFileBinaryToProperName(const std::string &oldName, const std::string &kernelFileHash) override {
+        return false;
+    }
+};
+
+TEST(CompilerCacheTests, GivenCompilerCacheWhenRenameFileFailThenCacheBinaryReturnsFalse) {
+    VariableBackup<decltype(NEO::SysCalls::sysCallsStat)> statBackup(&NEO::SysCalls::sysCallsStat, [](const std::string &filePath, struct stat *statbuf) -> int { return -1; });
+
+    CompilerCacheLinuxReturnFalseOnCacheBinaryIfRenameFileFailed cache({true, ".cl_cache", "/home/cl_cache/", MemoryConstants::megaByte});
+
+    EXPECT_FALSE(cache.cacheBinary("config.file", "1", 1));
+}
+
+class CompilerCacheLinuxReturnTrueOnCacheBinary : public CompilerCache {
+  public:
+    CompilerCacheLinuxReturnTrueOnCacheBinary(const CompilerCacheConfig &config) : CompilerCache(config) {}
+    using CompilerCache::createUniqueTempFileAndWriteData;
+    using CompilerCache::evictCache;
+    using CompilerCache::lockConfigFileAndReadSize;
+    using CompilerCache::renameTempFileBinaryToProperName;
+
+    void lockConfigFileAndReadSize(const std::string &configFilePath, int &fd, size_t &directorySize) override {
+        directorySize = MemoryConstants::megaByte;
+        fd = 1;
+        return;
+    }
+
+    bool evictCache() override {
+        return true;
+    }
+
+    bool createUniqueTempFileAndWriteData(char *tmpFilePathTemplate, const char *pBinary, size_t binarySize) override {
+        return true;
+    }
+
+    bool renameTempFileBinaryToProperName(const std::string &oldName, const std::string &kernelFileHash) override {
+        return true;
+    }
+};
+
+TEST(CompilerCacheTests, GivenCompilerCacheWhenAllFunctionsSuccedThenCacheBinaryReturnsTrue) {
+    VariableBackup<decltype(NEO::SysCalls::sysCallsStat)> statBackup(&NEO::SysCalls::sysCallsStat, [](const std::string &filePath, struct stat *statbuf) -> int { return 0; });
+
+    CompilerCacheLinuxReturnTrueOnCacheBinary cache({true, ".cl_cache", "/home/cl_cache/", MemoryConstants::megaByte});
+
+    EXPECT_TRUE(cache.cacheBinary("config.file", "1", 1));
+}
+
+namespace NonExistingPathIsSet {
+bool pathExistsMock(const std::string &path) {
+    return false;
+}
+} // namespace NonExistingPathIsSet
+
+TEST(CompilerCacheHelper, GivenNonExistingPathWhenCheckDefaultCacheDirSettingsThenFalseIsReturned) {
+    std::unique_ptr<SettingsReader> settingsReader(SettingsReader::createOsReader(false, ""));
+
+    std::unordered_map<std::string, std::string> mockableEnvs;
+    mockableEnvs["NEO_CACHE_DIR"] = "ult/directory/";
+
+    VariableBackup<std::unordered_map<std::string, std::string> *> mockableEnvValuesBackup(&NEO::IoFunctions::mockableEnvValues, &mockableEnvs);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsPathExists)> pathExistsBackup(&NEO::SysCalls::sysCallsPathExists, NonExistingPathIsSet::pathExistsMock);
+
+    std::string cacheDir = "";
+    EXPECT_FALSE(checkDefaultCacheDirSettings(cacheDir, settingsReader.get()));
+}
+
+namespace XDGEnvPathIsSet {
+bool pathExistsMock(const std::string &path) {
+    if (path.find("xdg/directory/neo_compiler_cache") != path.npos) {
+        return true;
+    }
+    if (path.find("xdg/directory/") != path.npos) {
+        return true;
+    }
+    return false;
+}
+} // namespace XDGEnvPathIsSet
+
+TEST(CompilerCacheHelper, GivenXdgCachePathSetWhenCheckDefaultCacheDirSettingsThenProperPathIsReturned) {
+    std::unique_ptr<SettingsReader> settingsReader(SettingsReader::createOsReader(false, ""));
+
+    std::unordered_map<std::string, std::string> mockableEnvs;
+    mockableEnvs["XDG_CACHE_HOME"] = "xdg/directory/";
+
+    VariableBackup<std::unordered_map<std::string, std::string> *> mockableEnvValuesBackup(&NEO::IoFunctions::mockableEnvValues, &mockableEnvs);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsPathExists)> pathExistsBackup(&NEO::SysCalls::sysCallsPathExists, XDGEnvPathIsSet::pathExistsMock);
+
+    std::string cacheDir = "";
+
+    EXPECT_TRUE(checkDefaultCacheDirSettings(cacheDir, settingsReader.get()));
+    EXPECT_EQ(cacheDir, "xdg/directory/neo_compiler_cache");
+}
+
+namespace HomeEnvPathIsSet {
+bool pathExistsMock(const std::string &path) {
+    if (path.find("home/directory/.cache/neo_compiler_cache") != path.npos) {
+        return true;
+    }
+    if (path.find("home/directory/.cache/") != path.npos) {
+        return true;
+    }
+    return false;
+}
+} // namespace HomeEnvPathIsSet
+
+TEST(CompilerCacheHelper, GivenHomeCachePathSetWhenCheckDefaultCacheDirSettingsThenProperDirectoryIsSet) {
+    std::unique_ptr<SettingsReader> settingsReader(SettingsReader::createOsReader(false, ""));
+
+    std::unordered_map<std::string, std::string> mockableEnvs;
+    mockableEnvs["HOME"] = "home/directory/";
+
+    VariableBackup<std::unordered_map<std::string, std::string> *> mockableEnvValuesBackup(&NEO::IoFunctions::mockableEnvValues, &mockableEnvs);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsPathExists)> pathExistsBackup(&NEO::SysCalls::sysCallsPathExists, HomeEnvPathIsSet::pathExistsMock);
+
+    std::string cacheDir = "";
+    EXPECT_TRUE(checkDefaultCacheDirSettings(cacheDir, settingsReader.get()));
+    EXPECT_EQ(cacheDir, "home/directory/.cache/neo_compiler_cache");
+}
+
+namespace XdgPathIsSetAndOtherProcessCreatesPath {
+bool mkdirCalled = false;
+
+bool pathExistsMock(const std::string &path) {
+    if (path.find("xdg/directory/neo_compiler_cache") != path.npos) {
+        return false;
+    }
+    if (path.find("xdg/directory/") != path.npos) {
+        return true;
+    }
+    return false;
+}
+int mkdirMock(const std::string &dir) {
+    if (dir.find("xdg/directory/neo_compiler_cache") != dir.npos) {
+        mkdirCalled = true;
+        errno = EEXIST;
+        return -1;
+    }
+    return 0;
+}
+} // namespace XdgPathIsSetAndOtherProcessCreatesPath
+
+TEST(CompilerCacheHelper, GivenXdgEnvWhenOtherProcessCreatesNeoCompilerCacheFolderThenProperDirectoryIsReturned) {
+    std::unique_ptr<SettingsReader> settingsReader(SettingsReader::createOsReader(false, ""));
+    std::unordered_map<std::string, std::string> mockableEnvs;
+    mockableEnvs["XDG_CACHE_HOME"] = "xdg/directory/";
+    bool mkdirCalledTemp = false;
+
+    VariableBackup<std::unordered_map<std::string, std::string> *> mockableEnvValuesBackup(&NEO::IoFunctions::mockableEnvValues, &mockableEnvs);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsPathExists)> pathExistsBackup(&NEO::SysCalls::sysCallsPathExists, XdgPathIsSetAndOtherProcessCreatesPath::pathExistsMock);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsMkdir)> mkdirBackup(&NEO::SysCalls::sysCallsMkdir, XdgPathIsSetAndOtherProcessCreatesPath::mkdirMock);
+    VariableBackup<bool> mkdirCalledBackup(&XdgPathIsSetAndOtherProcessCreatesPath::mkdirCalled, mkdirCalledTemp);
+
+    std::string cacheDir = "";
+    EXPECT_TRUE(checkDefaultCacheDirSettings(cacheDir, settingsReader.get()));
+    EXPECT_EQ(cacheDir, "xdg/directory/neo_compiler_cache");
+    EXPECT_TRUE(XdgPathIsSetAndOtherProcessCreatesPath::mkdirCalled);
+}
+
+namespace XdgPathIsSetAndNeedToCreate {
+bool pathExistsMock(const std::string &path) {
+    if (path.find("xdg/directory/neo_compiler_cache") != path.npos) {
+        return false;
+    }
+    if (path.find("xdg/directory/") != path.npos) {
+        return true;
+    }
+    return false;
+}
+int mkdirMock(const std::string &dir) {
+    return 0;
+}
+} // namespace XdgPathIsSetAndNeedToCreate
+
+TEST(CompilerCacheHelper, GivenXdgEnvWhenNeoCompilerCacheNotExistsThenCreateNeoCompilerCacheFolder) {
+    std::unique_ptr<SettingsReader> settingsReader(SettingsReader::createOsReader(false, ""));
+    std::unordered_map<std::string, std::string> mockableEnvs;
+    mockableEnvs["XDG_CACHE_HOME"] = "xdg/directory/";
+
+    VariableBackup<std::unordered_map<std::string, std::string> *> mockableEnvValuesBackup(&NEO::IoFunctions::mockableEnvValues, &mockableEnvs);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsPathExists)> pathExistsBackup(&NEO::SysCalls::sysCallsPathExists, XdgPathIsSetAndNeedToCreate::pathExistsMock);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsMkdir)> mkdirBackup(&NEO::SysCalls::sysCallsMkdir, XdgPathIsSetAndNeedToCreate::mkdirMock);
+
+    std::string cacheDir = "";
+    EXPECT_TRUE(checkDefaultCacheDirSettings(cacheDir, settingsReader.get()));
+    EXPECT_EQ(cacheDir, "xdg/directory/neo_compiler_cache");
+}
+
+namespace HomePathIsSetAndNeedToCreate {
+bool pathExistsMock(const std::string &path) {
+    if (path.find("home/directory/.cache/neo_compiler_cache") != path.npos) {
+        return false;
+    }
+    if (path.find("home/directory/.cache/") != path.npos) {
+        return true;
+    }
+    return false;
+}
+int mkdirMock(const std::string &dir) {
+    return 0;
+}
+} // namespace HomePathIsSetAndNeedToCreate
+
+TEST(CompilerCacheHelper, GivenHomeCachePathSetWhenCheckDefaultCacheDirSettingsThenProperDirectoryIsCreated) {
+    std::unique_ptr<SettingsReader> settingsReader(SettingsReader::createOsReader(false, ""));
+
+    std::unordered_map<std::string, std::string> mockableEnvs;
+    mockableEnvs["HOME"] = "home/directory/";
+
+    VariableBackup<std::unordered_map<std::string, std::string> *> mockableEnvValuesBackup(&NEO::IoFunctions::mockableEnvValues, &mockableEnvs);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsPathExists)> pathExistsBackup(&NEO::SysCalls::sysCallsPathExists, HomePathIsSetAndNeedToCreate::pathExistsMock);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsMkdir)> mkdirBackup(&NEO::SysCalls::sysCallsMkdir, HomePathIsSetAndNeedToCreate::mkdirMock);
+
+    std::string cacheDir = "";
+    EXPECT_TRUE(checkDefaultCacheDirSettings(cacheDir, settingsReader.get()));
+    EXPECT_EQ(cacheDir, "home/directory/.cache/neo_compiler_cache");
+}
+
+namespace HomePathIsSetAndOtherProcessCreatesPath {
+bool mkdirCalled = false;
+
+bool pathExistsMock(const std::string &path) {
+    if (path.find("home/directory/.cache/neo_compiler_cache") != path.npos) {
+        return false;
+    }
+    if (path.find("home/directory/.cache/") != path.npos) {
+        return true;
+    }
+    return false;
+}
+int mkdirMock(const std::string &dir) {
+    if (dir.find("home/directory/.cache/neo_compiler_cache") != dir.npos) {
+        mkdirCalled = true;
+        errno = EEXIST;
+        return -1;
+    }
+    return 0;
+}
+} // namespace HomePathIsSetAndOtherProcessCreatesPath
+
+TEST(CompilerCacheHelper, GivenHomeEnvWhenOtherProcessCreatesNeoCompilerCacheFolderThenProperDirectoryIsReturned) {
+    std::unique_ptr<SettingsReader> settingsReader(SettingsReader::createOsReader(false, ""));
+    std::unordered_map<std::string, std::string> mockableEnvs;
+    mockableEnvs["HOME"] = "home/directory/";
+    bool mkdirCalledTemp = false;
+
+    VariableBackup<std::unordered_map<std::string, std::string> *> mockableEnvValuesBackup(&NEO::IoFunctions::mockableEnvValues, &mockableEnvs);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsPathExists)> pathExistsBackup(&NEO::SysCalls::sysCallsPathExists, HomePathIsSetAndOtherProcessCreatesPath::pathExistsMock);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsMkdir)> mkdirBackup(&NEO::SysCalls::sysCallsMkdir, HomePathIsSetAndOtherProcessCreatesPath::mkdirMock);
+    VariableBackup<bool> mkdirCalledBackup(&HomePathIsSetAndOtherProcessCreatesPath::mkdirCalled, mkdirCalledTemp);
+
+    std::string cacheDir = "";
+    EXPECT_TRUE(checkDefaultCacheDirSettings(cacheDir, settingsReader.get()));
+    EXPECT_EQ(cacheDir, "home/directory/.cache/neo_compiler_cache");
+    EXPECT_TRUE(HomePathIsSetAndOtherProcessCreatesPath::mkdirCalled);
+}
diff --git a/shared/test/unit_test/compiler_interface/windows/compiler_cache_tests_windows.cpp b/shared/test/unit_test/compiler_interface/windows/compiler_cache_tests_windows.cpp
new file mode 100644
index 0000000000..1dc5e24ba4
--- /dev/null
+++ b/shared/test/unit_test/compiler_interface/windows/compiler_cache_tests_windows.cpp
@@ -0,0 +1,23 @@
+/*
+ * Copyright (C) 2019-2023 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#include "shared/source/compiler_interface/os_compiler_cache_helper.h"
+#include "shared/source/helpers/string.h"
+#include "shared/source/utilities/debug_settings_reader.h"
+#include "shared/test/common/helpers/debug_manager_state_restore.h"
+#include "shared/test/common/test_macros/test.h"
+
+#include <string>
+
+using namespace NEO;
+
+TEST(CompilerCacheHelper, GivenHomeEnvWhenOtherProcessCreatesNeoCompilerCacheFolderThenProperDirectoryIsReturned) {
+    std::unique_ptr<SettingsReader> settingsReader(SettingsReader::createOsReader(false, ""));
+
+    std::string cacheDir = "";
+    EXPECT_FALSE(checkDefaultCacheDirSettings(cacheDir, settingsReader.get()));
+}
\ No newline at end of file