mirror of
https://github.com/intel/compute-runtime.git
synced 2026-01-03 23:03:02 +08:00
feature: Add process safety to Windows compiler cache
Related-To: NEO-8092 Signed-off-by: Fabian Zwolinski <fabian.zwolinski@intel.com> Co-authored-by: Diedrich, Kamil <kamil.diedrich@intel.com>
This commit is contained in:
Fabian Zwolinski
committed by
Compute-Runtime-Automation
Compute-Runtime-Automation
parent
41914be8c3
commit
10675134e1
@@ -10,6 +10,7 @@
|
||||
#include "shared/test/common/os_interface/windows/mock_sys_calls.h"
|
||||
|
||||
#include <cstdint>
|
||||
#include <vector>
|
||||
|
||||
namespace NEO {
|
||||
|
||||
@@ -23,6 +24,8 @@ unsigned long getNumThreads() {
|
||||
return 1;
|
||||
}
|
||||
|
||||
DWORD getLastErrorResult = 0u;
|
||||
|
||||
BOOL systemPowerStatusRetVal = 1;
|
||||
BYTE systemPowerStatusACLineStatusOverride = 1;
|
||||
const wchar_t *currentLibraryPath = L"";
|
||||
@@ -35,6 +38,45 @@ bool mmapAllowExtendedPointers = false;
|
||||
bool pathExistsMock = false;
|
||||
const char *driverStorePath = nullptr;
|
||||
|
||||
size_t closeHandleCalled = 0u;
|
||||
|
||||
size_t getTempFileNameACalled = 0u;
|
||||
UINT getTempFileNameAResult = 0u;
|
||||
|
||||
size_t lockFileExCalled = 0u;
|
||||
BOOL lockFileExResult = TRUE;
|
||||
|
||||
size_t unlockFileExCalled = 0u;
|
||||
BOOL unlockFileExResult = TRUE;
|
||||
|
||||
size_t createFileACalled = 0u;
|
||||
extern const size_t createFileAResultsCount = 4;
|
||||
HANDLE createFileAResults[createFileAResultsCount] = {nullptr, nullptr, nullptr, nullptr};
|
||||
|
||||
size_t deleteFileACalled = 0u;
|
||||
const size_t deleteFilesCount = 4;
|
||||
std::string deleteFiles[deleteFilesCount];
|
||||
|
||||
bool callBaseReadFileEx = true;
|
||||
BOOL readFileExResult = TRUE;
|
||||
size_t readFileExCalled = 0u;
|
||||
size_t readFileExBufferData = 0u;
|
||||
|
||||
size_t writeFileCalled = 0u;
|
||||
BOOL writeFileResult = true;
|
||||
extern const size_t writeFileBufferSize = 10;
|
||||
char writeFileBuffer[writeFileBufferSize];
|
||||
DWORD writeFileNumberOfBytesWritten = 0u;
|
||||
|
||||
HANDLE findFirstFileAResult = nullptr;
|
||||
|
||||
size_t findNextFileACalled = 0u;
|
||||
extern const size_t findNextFileAFileDataCount = 4;
|
||||
WIN32_FIND_DATAA findNextFileAFileData[findNextFileAFileDataCount];
|
||||
|
||||
size_t getFileAttributesCalled = 0u;
|
||||
DWORD getFileAttributesResult = TRUE;
|
||||
|
||||
bool pathExists(const std::string &path) {
|
||||
return pathExistsMock;
|
||||
}
|
||||
@@ -42,6 +84,10 @@ bool pathExists(const std::string &path) {
|
||||
void exit(int code) {
|
||||
}
|
||||
|
||||
DWORD getLastError() {
|
||||
return getLastErrorResult;
|
||||
}
|
||||
|
||||
HANDLE createEvent(LPSECURITY_ATTRIBUTES lpEventAttributes, BOOL bManualReset, BOOL bInitialState, LPCSTR lpName) {
|
||||
if (mockCreateEventClb) {
|
||||
return mockCreateEventClb(lpEventAttributes, bManualReset, bInitialState, lpName, mockCreateEventClbData);
|
||||
@@ -50,6 +96,7 @@ HANDLE createEvent(LPSECURITY_ATTRIBUTES lpEventAttributes, BOOL bManualReset, B
|
||||
}
|
||||
|
||||
BOOL closeHandle(HANDLE hObject) {
|
||||
closeHandleCalled++;
|
||||
if (mockCloseHandleClb) {
|
||||
return mockCloseHandleClb(hObject, mockCloseHandleClbData);
|
||||
}
|
||||
@@ -60,6 +107,7 @@ BOOL getSystemPowerStatus(LPSYSTEM_POWER_STATUS systemPowerStatusPtr) {
|
||||
systemPowerStatusPtr->ACLineStatus = systemPowerStatusACLineStatusOverride;
|
||||
return systemPowerStatusRetVal;
|
||||
}
|
||||
|
||||
BOOL getModuleHandle(DWORD dwFlags, LPCWSTR lpModuleName, HMODULE *phModule) {
|
||||
constexpr auto expectedFlags = GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS | GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT;
|
||||
if (dwFlags != expectedFlags) {
|
||||
@@ -68,11 +116,100 @@ BOOL getModuleHandle(DWORD dwFlags, LPCWSTR lpModuleName, HMODULE *phModule) {
|
||||
*phModule = handleValue;
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
DWORD getModuleFileName(HMODULE hModule, LPWSTR lpFilename, DWORD nSize) {
|
||||
lstrcpyW(lpFilename, currentLibraryPath);
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
UINT getTempFileNameA(LPCSTR lpPathName, LPCSTR lpPrefixString, UINT uUnique, LPSTR lpTempFileName) {
|
||||
getTempFileNameACalled++;
|
||||
return getTempFileNameAResult;
|
||||
}
|
||||
|
||||
BOOL moveFileExA(LPCSTR lpExistingFileName, LPCSTR lpNewFileName, DWORD dwFlags) {
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
BOOL lockFileEx(HANDLE hFile, DWORD dwFlags, DWORD dwReserved, DWORD nNumberOfBytesToLockLow, DWORD nNumberOfBytesToLockHigh, LPOVERLAPPED lpOverlapped) {
|
||||
lockFileExCalled++;
|
||||
return lockFileExResult;
|
||||
}
|
||||
|
||||
BOOL unlockFileEx(HANDLE hFile, DWORD dwReserved, DWORD nNumberOfBytesToLockLow, DWORD nNumberOfBytesToLockHigh, LPOVERLAPPED lpOverlapped) {
|
||||
unlockFileExCalled++;
|
||||
return unlockFileExResult;
|
||||
}
|
||||
|
||||
BOOL getOverlappedResult(HANDLE hFile, LPOVERLAPPED lpOverlapped, LPDWORD lpNumberOfBytesTransferred, BOOL bWait) {
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
HANDLE createFileA(LPCSTR lpFileName, DWORD dwDesiredAccess, DWORD dwShareMode, LPSECURITY_ATTRIBUTES lpSecurityAttributes, DWORD dwCreationDisposition, DWORD dwFlagsAndAttributes, HANDLE hTemplateFile) {
|
||||
HANDLE retVal = nullptr;
|
||||
|
||||
if (createFileACalled < createFileAResultsCount) {
|
||||
retVal = createFileAResults[createFileACalled];
|
||||
}
|
||||
|
||||
createFileACalled++;
|
||||
return retVal;
|
||||
}
|
||||
|
||||
BOOL deleteFileA(LPCSTR lpFileName) {
|
||||
if (deleteFileACalled < deleteFilesCount) {
|
||||
deleteFiles[deleteFileACalled] = std::string(lpFileName);
|
||||
}
|
||||
deleteFileACalled++;
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
BOOL readFileEx(HANDLE hFile, LPVOID lpBuffer, DWORD nNumberOfBytesToRead, LPOVERLAPPED lpOverlapped, LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine) {
|
||||
readFileExCalled++;
|
||||
if (callBaseReadFileEx) {
|
||||
return ReadFileEx(hFile, lpBuffer, nNumberOfBytesToRead, lpOverlapped, lpCompletionRoutine);
|
||||
}
|
||||
if (lpBuffer) {
|
||||
*static_cast<size_t *>(lpBuffer) = readFileExBufferData;
|
||||
}
|
||||
return readFileExResult;
|
||||
}
|
||||
|
||||
BOOL writeFile(HANDLE hFile, LPCVOID lpBuffer, DWORD nNumberOfBytesToWrite, LPDWORD lpNumberOfBytesWritten, LPOVERLAPPED lpOverlapped) {
|
||||
writeFileCalled++;
|
||||
memcpy_s(writeFileBuffer, writeFileBufferSize, lpBuffer, nNumberOfBytesToWrite);
|
||||
if (lpNumberOfBytesWritten) {
|
||||
*lpNumberOfBytesWritten = writeFileNumberOfBytesWritten;
|
||||
}
|
||||
return writeFileResult;
|
||||
}
|
||||
|
||||
HANDLE findFirstFileA(LPCSTR lpFileName, LPWIN32_FIND_DATAA lpFindFileData) {
|
||||
return findFirstFileAResult;
|
||||
}
|
||||
|
||||
BOOL findNextFileA(HANDLE hFindFile, LPWIN32_FIND_DATAA lpFindFileData) {
|
||||
BOOL retVal = TRUE;
|
||||
|
||||
if (findNextFileACalled < findNextFileAFileDataCount) {
|
||||
*lpFindFileData = findNextFileAFileData[findNextFileACalled];
|
||||
} else {
|
||||
retVal = FALSE;
|
||||
}
|
||||
findNextFileACalled++;
|
||||
|
||||
return retVal;
|
||||
}
|
||||
|
||||
BOOL findClose(HANDLE hFindFile) {
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
DWORD getFileAttributesA(LPCSTR lpFileName) {
|
||||
getFileAttributesCalled++;
|
||||
return getFileAttributesResult;
|
||||
}
|
||||
|
||||
LSTATUS regOpenKeyExA(HKEY hKey, LPCSTR lpSubKey, DWORD ulOptions, REGSAM samDesired, PHKEY phkResult) {
|
||||
if (regOpenKeySuccessCount > 0) {
|
||||
regOpenKeySuccessCount--;
|
||||
|
||||
@@ -875,19 +875,3 @@ TEST(CompilerCacheHelper, GivenNotExistingPathWhenGettingFileSizeThenZeroIsRetur
|
||||
|
||||
EXPECT_EQ(getFileSize("/tmp/file1"), 0u);
|
||||
}
|
||||
|
||||
TEST(CompilerCacheHelper, makePathGivenEmptyRhsThenLhsIsReturned) {
|
||||
EXPECT_STREQ(makePath("", "path").c_str(), "path");
|
||||
}
|
||||
|
||||
TEST(CompilerCacheHelper, makePathGivenEmptyLhsThenRhsIsReturned) {
|
||||
EXPECT_STREQ(makePath("path", "").c_str(), "path");
|
||||
}
|
||||
|
||||
TEST(CompilerCacheHelper, makePathGivenPathWithTrailingSlashThenSlashIsNotAdded) {
|
||||
EXPECT_STREQ(makePath("path/", "test").c_str(), "path/test");
|
||||
}
|
||||
|
||||
TEST(CompilerCacheHelper, makePathGivenPathWithoutTrailingSlashThenSlashIsAdded) {
|
||||
EXPECT_STREQ(makePath("path", "test").c_str(), "path/test");
|
||||
}
|
||||
|
||||
@@ -5,19 +5,767 @@
|
||||
*
|
||||
*/
|
||||
|
||||
#include "shared/source/compiler_interface/compiler_cache.h"
|
||||
#include "shared/source/compiler_interface/os_compiler_cache_helper.h"
|
||||
#include "shared/source/helpers/constants.h"
|
||||
#include "shared/source/helpers/string.h"
|
||||
#include "shared/source/os_interface/windows/sys_calls.h"
|
||||
#include "shared/source/utilities/debug_settings_reader.h"
|
||||
#include "shared/test/common/helpers/debug_manager_state_restore.h"
|
||||
#include "shared/test/common/helpers/gtest_helpers.h"
|
||||
#include "shared/test/common/helpers/variable_backup.h"
|
||||
#include "shared/test/common/test_macros/test.h"
|
||||
|
||||
#include <cstring>
|
||||
#include <string>
|
||||
|
||||
using namespace NEO;
|
||||
namespace NEO {
|
||||
|
||||
class CompilerCacheMockWindows : public CompilerCache {
|
||||
public:
|
||||
CompilerCacheMockWindows(const CompilerCacheConfig &config) : CompilerCache(config) {}
|
||||
using CompilerCache::createUniqueTempFileAndWriteData;
|
||||
using CompilerCache::evictCache;
|
||||
using CompilerCache::lockConfigFileAndReadSize;
|
||||
using CompilerCache::renameTempFileBinaryToProperName;
|
||||
|
||||
bool createUniqueTempFileAndWriteData(char *tmpFilePath, const char *pBinary, size_t binarySize) override {
|
||||
createUniqueTempFileAndWriteDataCalled++;
|
||||
if (callBaseCreateUniqueTempFileAndWriteData) {
|
||||
return CompilerCache::createUniqueTempFileAndWriteData(tmpFilePath, pBinary, binarySize);
|
||||
}
|
||||
createUniqueTempFileAndWriteDataTmpFilePath = tmpFilePath;
|
||||
return createUniqueTempFileAndWriteDataResult;
|
||||
}
|
||||
|
||||
bool callBaseCreateUniqueTempFileAndWriteData = true;
|
||||
size_t createUniqueTempFileAndWriteDataCalled = 0u;
|
||||
bool createUniqueTempFileAndWriteDataResult = true;
|
||||
std::string createUniqueTempFileAndWriteDataTmpFilePath = "";
|
||||
|
||||
bool renameTempFileBinaryToProperName(const std::string &oldName, const std::string &kernelFileHash) override {
|
||||
renameTempFileBinaryToProperNameCalled++;
|
||||
if (callBaseRenameTempFileBinaryToProperName) {
|
||||
CompilerCache::renameTempFileBinaryToProperName(oldName, kernelFileHash);
|
||||
}
|
||||
renameTempFileBinaryToProperNameCacheFilePath = kernelFileHash;
|
||||
return renameTempFileBinaryToProperNameResult;
|
||||
}
|
||||
|
||||
bool callBaseRenameTempFileBinaryToProperName = true;
|
||||
size_t renameTempFileBinaryToProperNameCalled = 0u;
|
||||
bool renameTempFileBinaryToProperNameResult = true;
|
||||
std::string renameTempFileBinaryToProperNameCacheFilePath = "";
|
||||
|
||||
bool evictCache() override {
|
||||
evictCacheCalled++;
|
||||
if (callBaseEvictCache) {
|
||||
return CompilerCache::evictCache();
|
||||
}
|
||||
return evictCacheResult;
|
||||
}
|
||||
|
||||
bool callBaseEvictCache = true;
|
||||
size_t evictCacheCalled = 0u;
|
||||
bool evictCacheResult = true;
|
||||
|
||||
void lockConfigFileAndReadSize(const std::string &configFilePath, HandleType &handle, size_t &directorySize) override {
|
||||
lockConfigFileAndReadSizeCalled++;
|
||||
if (callBaseLockConfigFileAndReadSize) {
|
||||
return CompilerCache::lockConfigFileAndReadSize(configFilePath, handle, directorySize);
|
||||
}
|
||||
handle = lockConfigFileAndReadSizeHandle;
|
||||
}
|
||||
|
||||
bool callBaseLockConfigFileAndReadSize = true;
|
||||
size_t lockConfigFileAndReadSizeCalled = 0u;
|
||||
HandleType lockConfigFileAndReadSizeHandle = INVALID_HANDLE_VALUE;
|
||||
};
|
||||
|
||||
TEST(CompilerCacheHelper, GivenHomeEnvWhenOtherProcessCreatesNeoCompilerCacheFolderThenProperDirectoryIsReturned) {
|
||||
std::unique_ptr<SettingsReader> settingsReader(SettingsReader::createOsReader(false, ""));
|
||||
|
||||
std::string cacheDir = "";
|
||||
EXPECT_FALSE(checkDefaultCacheDirSettings(cacheDir, settingsReader.get()));
|
||||
}
|
||||
}
|
||||
|
||||
namespace SysCalls {
|
||||
extern DWORD getLastErrorResult;
|
||||
|
||||
extern size_t closeHandleCalled;
|
||||
|
||||
extern size_t getTempFileNameACalled;
|
||||
extern UINT getTempFileNameAResult;
|
||||
|
||||
extern size_t lockFileExCalled;
|
||||
extern BOOL lockFileExResult;
|
||||
|
||||
extern size_t unlockFileExCalled;
|
||||
extern BOOL unlockFileExResult;
|
||||
|
||||
extern size_t createFileACalled;
|
||||
extern const size_t createFileAResultsCount;
|
||||
extern HANDLE createFileAResults[];
|
||||
|
||||
extern size_t deleteFileACalled;
|
||||
extern std::string deleteFiles[];
|
||||
|
||||
extern bool callBaseReadFileEx;
|
||||
extern BOOL readFileExResult;
|
||||
extern size_t readFileExCalled;
|
||||
extern size_t readFileExBufferData;
|
||||
|
||||
extern size_t writeFileCalled;
|
||||
extern BOOL writeFileResult;
|
||||
extern const size_t writeFileBufferSize;
|
||||
extern char writeFileBuffer[];
|
||||
extern DWORD writeFileNumberOfBytesWritten;
|
||||
|
||||
extern HANDLE findFirstFileAResult;
|
||||
|
||||
extern size_t findNextFileACalled;
|
||||
extern const size_t findNextFileAFileDataCount;
|
||||
extern WIN32_FIND_DATAA findNextFileAFileData[];
|
||||
|
||||
extern size_t getFileAttributesCalled;
|
||||
extern DWORD getFileAttributesResult;
|
||||
} // namespace SysCalls
|
||||
|
||||
struct CompilerCacheWindowsTest : public ::testing::Test {
|
||||
CompilerCacheWindowsTest()
|
||||
: getLastErrorResultBackup(&SysCalls::getLastErrorResult),
|
||||
closeHandleCalledBackup(&SysCalls::closeHandleCalled),
|
||||
getTempFileNameACalled(&SysCalls::getTempFileNameACalled),
|
||||
getTempFileNameAResult(&SysCalls::getTempFileNameAResult),
|
||||
lockFileExCalledBackup(&SysCalls::lockFileExCalled),
|
||||
lockFileExResultBackup(&SysCalls::lockFileExResult),
|
||||
unlockFileExCalledBackup(&SysCalls::unlockFileExCalled),
|
||||
unlockFileExResultBackup(&SysCalls::unlockFileExResult),
|
||||
createFileACalledBackup(&SysCalls::createFileACalled),
|
||||
deleteFileACalledBackup(&SysCalls::deleteFileACalled),
|
||||
callBaseReadFileExBackup(&SysCalls::callBaseReadFileEx),
|
||||
readFileExResultBackup(&SysCalls::readFileExResult),
|
||||
readFileExCalledBackup(&SysCalls::readFileExCalled),
|
||||
readFileExBufferDataBackup(&SysCalls::readFileExBufferData),
|
||||
writeFileCalledBackup(&SysCalls::writeFileCalled),
|
||||
writeFileResultBackup(&SysCalls::writeFileResult),
|
||||
writeFileNumberOfBytesWrittenBackup(&SysCalls::writeFileNumberOfBytesWritten),
|
||||
findFirstFileAResultBackup(&SysCalls::findFirstFileAResult),
|
||||
findNextFileACalledBackup(&SysCalls::findNextFileACalled),
|
||||
getFileAttributesCalledBackup(&SysCalls::getFileAttributesCalled),
|
||||
getFileAttributesResultBackup(&SysCalls::getFileAttributesResult) {}
|
||||
|
||||
void SetUp() override {
|
||||
SysCalls::closeHandleCalled = 0u;
|
||||
SysCalls::getTempFileNameACalled = 0u;
|
||||
SysCalls::lockFileExCalled = 0u;
|
||||
SysCalls::unlockFileExCalled = 0u;
|
||||
SysCalls::createFileACalled = 0u;
|
||||
SysCalls::deleteFileACalled = 0u;
|
||||
SysCalls::readFileExCalled = 0u;
|
||||
SysCalls::writeFileCalled = 0u;
|
||||
SysCalls::findNextFileACalled = 0u;
|
||||
SysCalls::getFileAttributesCalled = 0u;
|
||||
}
|
||||
|
||||
void TearDown() override {
|
||||
for (size_t i = 0; i < SysCalls::findNextFileAFileDataCount; i++) {
|
||||
memset(&SysCalls::findNextFileAFileData[i], 0, sizeof(SysCalls::findNextFileAFileData[i]));
|
||||
}
|
||||
for (size_t i = 0; i < SysCalls::deleteFileACalled; i++) {
|
||||
SysCalls::deleteFiles[i].~basic_string();
|
||||
}
|
||||
for (size_t i = 0; i < SysCalls::createFileAResultsCount; i++) {
|
||||
SysCalls::createFileAResults[i] = nullptr;
|
||||
}
|
||||
memset(SysCalls::writeFileBuffer, 0, SysCalls::writeFileBufferSize);
|
||||
}
|
||||
|
||||
protected:
|
||||
VariableBackup<DWORD> getLastErrorResultBackup;
|
||||
VariableBackup<size_t> closeHandleCalledBackup;
|
||||
VariableBackup<size_t> getTempFileNameACalled;
|
||||
VariableBackup<UINT> getTempFileNameAResult;
|
||||
VariableBackup<size_t> lockFileExCalledBackup;
|
||||
VariableBackup<BOOL> lockFileExResultBackup;
|
||||
VariableBackup<size_t> unlockFileExCalledBackup;
|
||||
VariableBackup<BOOL> unlockFileExResultBackup;
|
||||
VariableBackup<size_t> createFileACalledBackup;
|
||||
VariableBackup<size_t> deleteFileACalledBackup;
|
||||
VariableBackup<bool> callBaseReadFileExBackup;
|
||||
VariableBackup<BOOL> readFileExResultBackup;
|
||||
VariableBackup<size_t> readFileExCalledBackup;
|
||||
VariableBackup<size_t> readFileExBufferDataBackup;
|
||||
VariableBackup<size_t> writeFileCalledBackup;
|
||||
VariableBackup<BOOL> writeFileResultBackup;
|
||||
VariableBackup<DWORD> writeFileNumberOfBytesWrittenBackup;
|
||||
VariableBackup<HANDLE> findFirstFileAResultBackup;
|
||||
VariableBackup<size_t> findNextFileACalledBackup;
|
||||
VariableBackup<size_t> getFileAttributesCalledBackup;
|
||||
VariableBackup<DWORD> getFileAttributesResultBackup;
|
||||
};
|
||||
|
||||
TEST_F(CompilerCacheWindowsTest, GivenCompilerCacheWithOneMegabyteWhenEvictCacheIsCalledThenDeleteTwoOldestFiles) {
|
||||
WIN32_FIND_DATAA filesData[4];
|
||||
DWORD cacheFileSize = (MemoryConstants::megaByte / 6) + 10;
|
||||
|
||||
filesData[0].ftLastAccessTime.dwLowDateTime = 6u;
|
||||
filesData[1].ftLastAccessTime.dwLowDateTime = 4u;
|
||||
filesData[2].ftLastAccessTime.dwLowDateTime = 8u;
|
||||
filesData[3].ftLastAccessTime.dwLowDateTime = 2u;
|
||||
|
||||
for (size_t i = 0; i < 4; i++) {
|
||||
snprintf(filesData[i].cFileName, MAX_PATH, "file_%zu.cl_cache", i);
|
||||
filesData[i].nFileSizeHigh = 0;
|
||||
filesData[i].nFileSizeLow = cacheFileSize;
|
||||
filesData[i].ftLastAccessTime.dwHighDateTime = 0;
|
||||
|
||||
SysCalls::findNextFileAFileData[i] = filesData[i];
|
||||
}
|
||||
|
||||
SysCalls::findFirstFileAResult = reinterpret_cast<HANDLE>(0x1234);
|
||||
const size_t cacheSize = MemoryConstants::megaByte - 2u;
|
||||
CompilerCacheMockWindows cache({true, ".cl_cache", "somePath\\cl_cache", cacheSize});
|
||||
auto &deletedFiles = SysCalls::deleteFiles;
|
||||
auto result = cache.evictCache();
|
||||
|
||||
EXPECT_TRUE(result);
|
||||
EXPECT_EQ(2u, SysCalls::deleteFileACalled);
|
||||
EXPECT_EQ(0, strcmp(deletedFiles[0].c_str(), "somePath\\cl_cache\\file_3.cl_cache"));
|
||||
EXPECT_EQ(0, strcmp(deletedFiles[1].c_str(), "somePath\\cl_cache\\file_1.cl_cache"));
|
||||
}
|
||||
|
||||
TEST_F(CompilerCacheWindowsTest, givenEvictCacheWhenFileSearchFailedThenDebugMessageWithErrorIsPrinted) {
|
||||
DebugManagerStateRestore restore;
|
||||
NEO::DebugManager.flags.PrintDebugMessages.set(1);
|
||||
|
||||
SysCalls::findFirstFileAResult = INVALID_HANDLE_VALUE;
|
||||
const size_t cacheSize = MemoryConstants::megaByte - 2u;
|
||||
CompilerCacheMockWindows cache({true, ".cl_cache", "somePath\\cl_cache", cacheSize});
|
||||
|
||||
::testing::internal::CaptureStderr();
|
||||
cache.evictCache();
|
||||
auto capturedStderr = ::testing::internal::GetCapturedStderr();
|
||||
|
||||
std::string expectedStderrSubstr("[Cache failure]: File search failed! error code:");
|
||||
EXPECT_TRUE(hasSubstr(capturedStderr, expectedStderrSubstr));
|
||||
EXPECT_EQ(0u, SysCalls::deleteFileACalled);
|
||||
}
|
||||
|
||||
TEST_F(CompilerCacheWindowsTest, givenLockConfigFileAndReadSizeWhenOpenExistingConfigThenConfigFileIsLockedAndRead) {
|
||||
const size_t readCacheDirSize = 840 * MemoryConstants::kiloByte;
|
||||
SysCalls::createFileAResults[0] = reinterpret_cast<HANDLE>(0x1234);
|
||||
SysCalls::lockFileExResult = TRUE;
|
||||
|
||||
SysCalls::callBaseReadFileEx = false;
|
||||
SysCalls::readFileExResult = TRUE;
|
||||
SysCalls::readFileExBufferData = readCacheDirSize;
|
||||
|
||||
const size_t cacheSize = MemoryConstants::megaByte - 2u;
|
||||
CompilerCacheMockWindows cache({true, ".cl_cache", "somePath\\cl_cache", cacheSize});
|
||||
|
||||
HANDLE configFileHandle = nullptr;
|
||||
size_t directorySize = 0u;
|
||||
cache.lockConfigFileAndReadSize("somePath\\cl_cache\\config.file", configFileHandle, directorySize);
|
||||
|
||||
EXPECT_EQ(1u, SysCalls::createFileACalled);
|
||||
EXPECT_EQ(1u, SysCalls::lockFileExCalled);
|
||||
|
||||
EXPECT_EQ(1u, SysCalls::readFileExCalled);
|
||||
EXPECT_EQ(readCacheDirSize, directorySize);
|
||||
|
||||
EXPECT_EQ(0u, SysCalls::unlockFileExCalled);
|
||||
EXPECT_EQ(0u, SysCalls::closeHandleCalled);
|
||||
}
|
||||
|
||||
TEST_F(CompilerCacheWindowsTest, givenLockConfigFileAndReadSizeWhenOpenExistingConfigWhenLockFailsThenErrorIsPrintedAndFunctionExits) {
|
||||
DebugManagerStateRestore restore;
|
||||
NEO::DebugManager.flags.PrintDebugMessages.set(1);
|
||||
|
||||
SysCalls::createFileAResults[0] = reinterpret_cast<HANDLE>(0x1234);
|
||||
SysCalls::lockFileExResult = FALSE;
|
||||
|
||||
SysCalls::callBaseReadFileEx = false;
|
||||
SysCalls::readFileExResult = TRUE;
|
||||
|
||||
const size_t cacheSize = MemoryConstants::megaByte - 2u;
|
||||
CompilerCacheMockWindows cache({true, ".cl_cache", "somePath\\cl_cache", cacheSize});
|
||||
|
||||
HANDLE configFileHandle = nullptr;
|
||||
size_t directorySize = 0u;
|
||||
|
||||
::testing::internal::CaptureStderr();
|
||||
cache.lockConfigFileAndReadSize("somePath\\cl_cache\\config.file", configFileHandle, directorySize);
|
||||
auto capturedStderr = ::testing::internal::GetCapturedStderr();
|
||||
|
||||
std::string expectedStderrSubstr("[Cache failure]: Lock config file failed! error code:");
|
||||
EXPECT_TRUE(hasSubstr(capturedStderr, expectedStderrSubstr));
|
||||
|
||||
EXPECT_EQ(1u, SysCalls::createFileACalled);
|
||||
EXPECT_EQ(1u, SysCalls::lockFileExCalled);
|
||||
|
||||
EXPECT_EQ(0u, SysCalls::readFileExCalled);
|
||||
|
||||
EXPECT_EQ(0u, SysCalls::unlockFileExCalled);
|
||||
EXPECT_EQ(0u, SysCalls::closeHandleCalled);
|
||||
}
|
||||
|
||||
TEST_F(CompilerCacheWindowsTest, givenLockConfigFileAndReadSizeWhenOpenExistingConfigWhenReadFileFailsThenErrorIsPrintedAndFileIsUnlockedAndClosed) {
|
||||
DebugManagerStateRestore restore;
|
||||
NEO::DebugManager.flags.PrintDebugMessages.set(1);
|
||||
|
||||
SysCalls::createFileAResults[0] = reinterpret_cast<HANDLE>(0x1234);
|
||||
SysCalls::lockFileExResult = TRUE;
|
||||
|
||||
SysCalls::callBaseReadFileEx = false;
|
||||
SysCalls::readFileExResult = FALSE;
|
||||
|
||||
const size_t cacheSize = MemoryConstants::megaByte - 2u;
|
||||
CompilerCacheMockWindows cache({true, ".cl_cache", "somePath\\cl_cache", cacheSize});
|
||||
|
||||
HANDLE configFileHandle = nullptr;
|
||||
size_t directorySize = 0u;
|
||||
|
||||
::testing::internal::CaptureStderr();
|
||||
cache.lockConfigFileAndReadSize("somePath\\cl_cache\\config.file", configFileHandle, directorySize);
|
||||
auto capturedStderr = ::testing::internal::GetCapturedStderr();
|
||||
|
||||
std::string expectedStderrSubstr("[Cache failure]: Read config failed! error code:");
|
||||
EXPECT_TRUE(hasSubstr(capturedStderr, expectedStderrSubstr));
|
||||
|
||||
EXPECT_EQ(1u, SysCalls::createFileACalled);
|
||||
EXPECT_EQ(1u, SysCalls::lockFileExCalled);
|
||||
|
||||
EXPECT_EQ(1u, SysCalls::readFileExCalled);
|
||||
|
||||
EXPECT_EQ(1u, SysCalls::unlockFileExCalled);
|
||||
EXPECT_EQ(1u, SysCalls::closeHandleCalled);
|
||||
}
|
||||
|
||||
TEST_F(CompilerCacheWindowsTest, givenLockConfigFileAndReadSizeWhenOpenExistingConfigFailsThenCreateNewConfigFileAndCountDirectorySize) {
|
||||
const size_t readCacheDirSize = 840 * MemoryConstants::kiloByte;
|
||||
SysCalls::createFileAResults[0] = INVALID_HANDLE_VALUE;
|
||||
SysCalls::createFileAResults[1] = reinterpret_cast<HANDLE>(0x1234);
|
||||
SysCalls::lockFileExResult = TRUE;
|
||||
|
||||
SysCalls::callBaseReadFileEx = false;
|
||||
SysCalls::readFileExResult = TRUE;
|
||||
SysCalls::readFileExBufferData = readCacheDirSize;
|
||||
|
||||
WIN32_FIND_DATAA filesData[4];
|
||||
DWORD cacheFileSize = (MemoryConstants::megaByte / 6) + 10;
|
||||
|
||||
filesData[0].ftLastAccessTime.dwLowDateTime = 6u;
|
||||
filesData[1].ftLastAccessTime.dwLowDateTime = 4u;
|
||||
filesData[2].ftLastAccessTime.dwLowDateTime = 8u;
|
||||
filesData[3].ftLastAccessTime.dwLowDateTime = 2u;
|
||||
|
||||
for (size_t i = 0; i < 4; i++) {
|
||||
snprintf(filesData[i].cFileName, MAX_PATH, "file_%zu.cl_cache", i);
|
||||
filesData[i].nFileSizeHigh = 0;
|
||||
filesData[i].nFileSizeLow = cacheFileSize;
|
||||
filesData[i].ftLastAccessTime.dwHighDateTime = 0;
|
||||
|
||||
SysCalls::findNextFileAFileData[i] = filesData[i];
|
||||
}
|
||||
const size_t expectedDirectorySize = 4 * cacheFileSize;
|
||||
|
||||
const size_t cacheSize = MemoryConstants::megaByte - 2u;
|
||||
CompilerCacheMockWindows cache({true, ".cl_cache", "somePath\\cl_cache", cacheSize});
|
||||
|
||||
HANDLE configFileHandle = nullptr;
|
||||
size_t directorySize = 0u;
|
||||
cache.lockConfigFileAndReadSize("somePath\\cl_cache\\config.file", configFileHandle, directorySize);
|
||||
|
||||
EXPECT_EQ(2u, SysCalls::createFileACalled);
|
||||
EXPECT_EQ(1u, SysCalls::lockFileExCalled);
|
||||
|
||||
EXPECT_EQ(expectedDirectorySize, directorySize);
|
||||
|
||||
EXPECT_EQ(0u, SysCalls::readFileExCalled);
|
||||
EXPECT_EQ(0u, SysCalls::unlockFileExCalled);
|
||||
EXPECT_EQ(0u, SysCalls::closeHandleCalled);
|
||||
}
|
||||
|
||||
TEST_F(CompilerCacheWindowsTest, givenCreateUniqueTempFileAndWriteDataWhenCreateAndWriteTempFileSucceedsThenBinaryIsWritten) {
|
||||
SysCalls::getTempFileNameAResult = 6u;
|
||||
SysCalls::createFileAResults[0] = reinterpret_cast<HANDLE>(0x1234);
|
||||
SysCalls::writeFileResult = TRUE;
|
||||
|
||||
const size_t cacheSize = MemoryConstants::megaByte - 2u;
|
||||
CompilerCacheMockWindows cache({true, ".cl_cache", "somePath\\cl_cache", cacheSize});
|
||||
|
||||
const char *binary = "12345";
|
||||
SysCalls::writeFileNumberOfBytesWritten = static_cast<DWORD>(strlen(binary));
|
||||
cache.createUniqueTempFileAndWriteData("somePath\\cl_cache\\TMP.XXXXXX", binary, strlen(binary));
|
||||
|
||||
EXPECT_EQ(0, strcmp(SysCalls::writeFileBuffer, binary));
|
||||
EXPECT_EQ(1u, SysCalls::getTempFileNameACalled);
|
||||
EXPECT_EQ(1u, SysCalls::createFileACalled);
|
||||
EXPECT_EQ(1u, SysCalls::writeFileCalled);
|
||||
EXPECT_EQ(1u, SysCalls::closeHandleCalled);
|
||||
}
|
||||
|
||||
TEST_F(CompilerCacheWindowsTest, givenCreateUniqueTempFileAndWriteDataWhenGetTempFileNameFailsThenErrorIsPrinted) {
|
||||
DebugManagerStateRestore restore;
|
||||
NEO::DebugManager.flags.PrintDebugMessages.set(1);
|
||||
|
||||
SysCalls::getTempFileNameAResult = 0u;
|
||||
|
||||
const size_t cacheSize = MemoryConstants::megaByte - 2u;
|
||||
CompilerCacheMockWindows cache({true, ".cl_cache", "somePath\\cl_cache", cacheSize});
|
||||
|
||||
const char *binary = "12345";
|
||||
::testing::internal::CaptureStderr();
|
||||
cache.createUniqueTempFileAndWriteData("somePath\\cl_cache\\TMP.XXXXXX", binary, strlen(binary));
|
||||
auto capturedStderr = ::testing::internal::GetCapturedStderr();
|
||||
|
||||
std::string expectedStderrSubstr("[Cache failure]: Creating temporary file name failed! error code:");
|
||||
EXPECT_TRUE(hasSubstr(capturedStderr, expectedStderrSubstr));
|
||||
EXPECT_EQ(1u, SysCalls::getTempFileNameACalled);
|
||||
EXPECT_EQ(0u, SysCalls::createFileACalled);
|
||||
EXPECT_EQ(0u, SysCalls::writeFileCalled);
|
||||
EXPECT_EQ(0u, SysCalls::closeHandleCalled);
|
||||
}
|
||||
|
||||
TEST_F(CompilerCacheWindowsTest, givenCreateUniqueTempFileAndWriteDataWhenCreateFileFailsThenErrorIsPrinted) {
|
||||
DebugManagerStateRestore restore;
|
||||
NEO::DebugManager.flags.PrintDebugMessages.set(1);
|
||||
|
||||
SysCalls::getTempFileNameAResult = 6u;
|
||||
SysCalls::createFileAResults[0] = INVALID_HANDLE_VALUE;
|
||||
|
||||
const size_t cacheSize = MemoryConstants::megaByte - 2u;
|
||||
CompilerCacheMockWindows cache({true, ".cl_cache", "somePath\\cl_cache", cacheSize});
|
||||
|
||||
const char *binary = "12345";
|
||||
::testing::internal::CaptureStderr();
|
||||
cache.createUniqueTempFileAndWriteData("somePath\\cl_cache\\TMP.XXXXXX", binary, strlen(binary));
|
||||
auto capturedStderr = ::testing::internal::GetCapturedStderr();
|
||||
|
||||
std::string expectedStderrSubstr("[Cache failure]: Creating temporary file failed! error code:");
|
||||
EXPECT_TRUE(hasSubstr(capturedStderr, expectedStderrSubstr));
|
||||
EXPECT_EQ(1u, SysCalls::getTempFileNameACalled);
|
||||
EXPECT_EQ(1u, SysCalls::createFileACalled);
|
||||
EXPECT_EQ(0u, SysCalls::writeFileCalled);
|
||||
EXPECT_EQ(0u, SysCalls::closeHandleCalled);
|
||||
}
|
||||
|
||||
TEST_F(CompilerCacheWindowsTest, givenCreateUniqueTempFileAndWriteDataWhenWriteFileFailsThenErrorIsPrinted) {
|
||||
DebugManagerStateRestore restore;
|
||||
NEO::DebugManager.flags.PrintDebugMessages.set(1);
|
||||
|
||||
SysCalls::getTempFileNameAResult = 6u;
|
||||
SysCalls::createFileAResults[0] = reinterpret_cast<HANDLE>(0x1234);
|
||||
SysCalls::writeFileResult = FALSE;
|
||||
|
||||
const size_t cacheSize = MemoryConstants::megaByte - 2u;
|
||||
CompilerCacheMockWindows cache({true, ".cl_cache", "somePath\\cl_cache", cacheSize});
|
||||
|
||||
const char *binary = "12345";
|
||||
::testing::internal::CaptureStderr();
|
||||
cache.createUniqueTempFileAndWriteData("somePath\\cl_cache\\TMP.XXXXXX", binary, strlen(binary));
|
||||
auto capturedStderr = ::testing::internal::GetCapturedStderr();
|
||||
|
||||
std::string expectedStderrSubstr("[Cache failure]: Writing to temporary file failed! error code:");
|
||||
EXPECT_TRUE(hasSubstr(capturedStderr, expectedStderrSubstr));
|
||||
EXPECT_EQ(1u, SysCalls::getTempFileNameACalled);
|
||||
EXPECT_EQ(1u, SysCalls::createFileACalled);
|
||||
EXPECT_EQ(1u, SysCalls::writeFileCalled);
|
||||
EXPECT_EQ(1u, SysCalls::closeHandleCalled);
|
||||
}
|
||||
|
||||
TEST_F(CompilerCacheWindowsTest, givenCreateUniqueTempFileAndWriteDataWhenWriteFileBytesWrittenMismatchesThenErrorIsPrinted) {
|
||||
DebugManagerStateRestore restore;
|
||||
NEO::DebugManager.flags.PrintDebugMessages.set(1);
|
||||
|
||||
SysCalls::getTempFileNameAResult = 6u;
|
||||
SysCalls::createFileAResults[0] = reinterpret_cast<HANDLE>(0x1234);
|
||||
SysCalls::writeFileResult = TRUE;
|
||||
|
||||
const size_t cacheSize = MemoryConstants::megaByte - 2u;
|
||||
CompilerCacheMockWindows cache({true, ".cl_cache", "somePath\\cl_cache", cacheSize});
|
||||
|
||||
const char *binary = "12345";
|
||||
SysCalls::writeFileNumberOfBytesWritten = static_cast<DWORD>(strlen(binary)) - 1;
|
||||
::testing::internal::CaptureStderr();
|
||||
cache.createUniqueTempFileAndWriteData("somePath\\cl_cache\\TMP.XXXXXX", binary, strlen(binary));
|
||||
auto capturedStderr = ::testing::internal::GetCapturedStderr();
|
||||
|
||||
std::stringstream expectedStderrSubstr;
|
||||
expectedStderrSubstr << "[Cache failure]: Writing to temporary file failed! Incorrect number of bytes written: ";
|
||||
expectedStderrSubstr << SysCalls::writeFileNumberOfBytesWritten << " vs " << strlen(binary);
|
||||
|
||||
EXPECT_TRUE(hasSubstr(capturedStderr, expectedStderrSubstr.str()));
|
||||
EXPECT_EQ(1u, SysCalls::getTempFileNameACalled);
|
||||
EXPECT_EQ(1u, SysCalls::createFileACalled);
|
||||
EXPECT_EQ(1u, SysCalls::writeFileCalled);
|
||||
EXPECT_EQ(1u, SysCalls::closeHandleCalled);
|
||||
}
|
||||
|
||||
TEST_F(CompilerCacheWindowsTest, givenEmptyBinaryAndOrBinarySizeWhenCacheBinaryThenEarlyReturnFalse) {
|
||||
const size_t cacheSize = MemoryConstants::megaByte - 2u;
|
||||
CompilerCacheMockWindows cache({true, ".cl_cache", "somePath\\cl_cache", cacheSize});
|
||||
|
||||
const std::string kernelFileHash = "7e3291364d8df42";
|
||||
auto result = cache.cacheBinary(kernelFileHash, nullptr, 10);
|
||||
EXPECT_FALSE(result);
|
||||
|
||||
result = cache.cacheBinary(kernelFileHash, "123456", 0);
|
||||
EXPECT_FALSE(result);
|
||||
|
||||
result = cache.cacheBinary(kernelFileHash, nullptr, 0);
|
||||
EXPECT_FALSE(result);
|
||||
}
|
||||
|
||||
TEST_F(CompilerCacheWindowsTest, givenCacheBinaryWhenAllStepsSuccessThenReturnTrue) {
|
||||
SysCalls::getFileAttributesResult = INVALID_FILE_ATTRIBUTES;
|
||||
|
||||
const size_t cacheSize = MemoryConstants::megaByte - 2u;
|
||||
CompilerCacheMockWindows cache({true, ".cl_cache", "somePath\\cl_cache", cacheSize});
|
||||
|
||||
cache.callBaseLockConfigFileAndReadSize = false;
|
||||
cache.lockConfigFileAndReadSizeHandle = reinterpret_cast<HANDLE>(0x1234);
|
||||
|
||||
cache.callBaseEvictCache = false;
|
||||
cache.evictCacheResult = true;
|
||||
|
||||
cache.callBaseCreateUniqueTempFileAndWriteData = false;
|
||||
cache.createUniqueTempFileAndWriteDataResult = true;
|
||||
|
||||
cache.callBaseRenameTempFileBinaryToProperName = false;
|
||||
cache.renameTempFileBinaryToProperNameResult = true;
|
||||
|
||||
const std::string kernelFileHash = "7e3291364d8df42";
|
||||
const char *binary = "123456";
|
||||
const size_t binarySize = strlen(binary);
|
||||
SysCalls::writeFileNumberOfBytesWritten = static_cast<DWORD>(sizeof(size_t));
|
||||
auto result = cache.cacheBinary(kernelFileHash, binary, binarySize);
|
||||
|
||||
EXPECT_TRUE(result);
|
||||
EXPECT_EQ(1u, cache.lockConfigFileAndReadSizeCalled);
|
||||
EXPECT_EQ(1u, SysCalls::getFileAttributesCalled);
|
||||
EXPECT_EQ(1u, cache.createUniqueTempFileAndWriteDataCalled);
|
||||
EXPECT_EQ(1u, cache.renameTempFileBinaryToProperNameCalled);
|
||||
EXPECT_EQ(1u, SysCalls::writeFileCalled);
|
||||
EXPECT_EQ(0, strcmp(cache.createUniqueTempFileAndWriteDataTmpFilePath.c_str(), "somePath\\cl_cache\\cl_cache.XXXXXX"));
|
||||
EXPECT_EQ(0, strcmp(cache.renameTempFileBinaryToProperNameCacheFilePath.c_str(), "somePath\\cl_cache\\7e3291364d8df42.cl_cache"));
|
||||
}
|
||||
|
||||
TEST_F(CompilerCacheWindowsTest, givenCacheBinaryWhenCacheAlreadyExistsThenDoNotCreateCacheAndReturnTrue) {
|
||||
SysCalls::getFileAttributesResult = INVALID_FILE_ATTRIBUTES - 1;
|
||||
SysCalls::getLastErrorResult = ERROR_FILE_NOT_FOUND + 1;
|
||||
|
||||
const size_t cacheSize = MemoryConstants::megaByte - 2u;
|
||||
CompilerCacheMockWindows cache({true, ".cl_cache", "somePath\\cl_cache", cacheSize});
|
||||
|
||||
cache.callBaseLockConfigFileAndReadSize = false;
|
||||
cache.lockConfigFileAndReadSizeHandle = reinterpret_cast<HANDLE>(0x1234);
|
||||
|
||||
const std::string kernelFileHash = "7e3291364d8df42";
|
||||
const char *binary = "123456";
|
||||
const size_t binarySize = strlen(binary);
|
||||
auto result = cache.cacheBinary(kernelFileHash, binary, binarySize);
|
||||
|
||||
EXPECT_TRUE(result);
|
||||
EXPECT_EQ(1u, SysCalls::unlockFileExCalled);
|
||||
EXPECT_EQ(1u, SysCalls::closeHandleCalled);
|
||||
EXPECT_EQ(1u, cache.lockConfigFileAndReadSizeCalled);
|
||||
EXPECT_EQ(1u, SysCalls::getFileAttributesCalled);
|
||||
EXPECT_EQ(0u, cache.createUniqueTempFileAndWriteDataCalled);
|
||||
EXPECT_EQ(0u, cache.renameTempFileBinaryToProperNameCalled);
|
||||
EXPECT_EQ(0u, SysCalls::writeFileCalled);
|
||||
}
|
||||
|
||||
TEST_F(CompilerCacheWindowsTest, givenCacheBinaryWhenWriteToConfigFileFailsThenErrorIsPrinted) {
|
||||
DebugManagerStateRestore restore;
|
||||
NEO::DebugManager.flags.PrintDebugMessages.set(1);
|
||||
|
||||
SysCalls::getFileAttributesResult = INVALID_FILE_ATTRIBUTES;
|
||||
SysCalls::writeFileResult = FALSE;
|
||||
|
||||
const size_t cacheSize = MemoryConstants::megaByte - 2u;
|
||||
CompilerCacheMockWindows cache({true, ".cl_cache", "somePath\\cl_cache", cacheSize});
|
||||
|
||||
cache.callBaseLockConfigFileAndReadSize = false;
|
||||
cache.lockConfigFileAndReadSizeHandle = reinterpret_cast<HANDLE>(0x1234);
|
||||
|
||||
cache.callBaseEvictCache = false;
|
||||
cache.evictCacheResult = true;
|
||||
|
||||
cache.callBaseCreateUniqueTempFileAndWriteData = false;
|
||||
cache.createUniqueTempFileAndWriteDataResult = true;
|
||||
|
||||
cache.callBaseRenameTempFileBinaryToProperName = false;
|
||||
cache.renameTempFileBinaryToProperNameResult = true;
|
||||
|
||||
const std::string kernelFileHash = "7e3291364d8df42";
|
||||
const char *binary = "123456";
|
||||
const size_t binarySize = strlen(binary);
|
||||
SysCalls::writeFileNumberOfBytesWritten = static_cast<DWORD>(sizeof(size_t));
|
||||
|
||||
::testing::internal::CaptureStderr();
|
||||
auto result = cache.cacheBinary(kernelFileHash, binary, binarySize);
|
||||
auto capturedStderr = ::testing::internal::GetCapturedStderr();
|
||||
|
||||
std::string expectedStderrSubstr("[Cache failure]: Writing to config file failed! error code:");
|
||||
|
||||
EXPECT_TRUE(result);
|
||||
EXPECT_TRUE(hasSubstr(capturedStderr, expectedStderrSubstr));
|
||||
EXPECT_EQ(1u, cache.lockConfigFileAndReadSizeCalled);
|
||||
EXPECT_EQ(1u, SysCalls::getFileAttributesCalled);
|
||||
EXPECT_EQ(1u, cache.createUniqueTempFileAndWriteDataCalled);
|
||||
EXPECT_EQ(1u, cache.renameTempFileBinaryToProperNameCalled);
|
||||
EXPECT_EQ(1u, SysCalls::writeFileCalled);
|
||||
}
|
||||
|
||||
TEST_F(CompilerCacheWindowsTest, givenCacheBinaryWhenWriteFileBytesWrittenMismatchesThenErrorIsPrinted) {
|
||||
DebugManagerStateRestore restore;
|
||||
NEO::DebugManager.flags.PrintDebugMessages.set(1);
|
||||
|
||||
SysCalls::getFileAttributesResult = INVALID_FILE_ATTRIBUTES;
|
||||
|
||||
const size_t cacheSize = MemoryConstants::megaByte - 2u;
|
||||
CompilerCacheMockWindows cache({true, ".cl_cache", "somePath\\cl_cache", cacheSize});
|
||||
|
||||
cache.callBaseLockConfigFileAndReadSize = false;
|
||||
cache.lockConfigFileAndReadSizeHandle = reinterpret_cast<HANDLE>(0x1234);
|
||||
|
||||
cache.callBaseEvictCache = false;
|
||||
cache.evictCacheResult = true;
|
||||
|
||||
cache.callBaseCreateUniqueTempFileAndWriteData = false;
|
||||
cache.createUniqueTempFileAndWriteDataResult = true;
|
||||
|
||||
cache.callBaseRenameTempFileBinaryToProperName = false;
|
||||
cache.renameTempFileBinaryToProperNameResult = true;
|
||||
|
||||
const std::string kernelFileHash = "7e3291364d8df42";
|
||||
const char *binary = "123456";
|
||||
const size_t binarySize = strlen(binary);
|
||||
SysCalls::writeFileNumberOfBytesWritten = static_cast<DWORD>(sizeof(size_t)) - 1;
|
||||
|
||||
::testing::internal::CaptureStderr();
|
||||
auto result = cache.cacheBinary(kernelFileHash, binary, binarySize);
|
||||
auto capturedStderr = ::testing::internal::GetCapturedStderr();
|
||||
|
||||
std::stringstream expectedStderrSubstr;
|
||||
expectedStderrSubstr << "[Cache failure]: Writing to config file failed! Incorrect number of bytes written: ";
|
||||
expectedStderrSubstr << SysCalls::writeFileNumberOfBytesWritten << " vs " << static_cast<DWORD>(sizeof(size_t));
|
||||
|
||||
EXPECT_TRUE(result);
|
||||
EXPECT_TRUE(hasSubstr(capturedStderr, expectedStderrSubstr.str()));
|
||||
EXPECT_EQ(1u, cache.lockConfigFileAndReadSizeCalled);
|
||||
EXPECT_EQ(1u, SysCalls::getFileAttributesCalled);
|
||||
EXPECT_EQ(1u, cache.createUniqueTempFileAndWriteDataCalled);
|
||||
EXPECT_EQ(1u, cache.renameTempFileBinaryToProperNameCalled);
|
||||
EXPECT_EQ(1u, SysCalls::writeFileCalled);
|
||||
}
|
||||
|
||||
TEST_F(CompilerCacheWindowsTest, givenCacheBinaryWhenLockConfigFileAndReadSizeFailsThenEarlyReturnFalse) {
|
||||
const size_t cacheSize = MemoryConstants::megaByte - 2u;
|
||||
CompilerCacheMockWindows cache({true, ".cl_cache", "somePath\\cl_cache", cacheSize});
|
||||
|
||||
cache.callBaseLockConfigFileAndReadSize = false;
|
||||
cache.lockConfigFileAndReadSizeHandle = INVALID_HANDLE_VALUE;
|
||||
|
||||
const std::string kernelFileHash = "7e3291364d8df42";
|
||||
const char *binary = "123456";
|
||||
const size_t binarySize = strlen(binary);
|
||||
auto result = cache.cacheBinary(kernelFileHash, binary, binarySize);
|
||||
|
||||
EXPECT_FALSE(result);
|
||||
}
|
||||
|
||||
TEST_F(CompilerCacheWindowsTest, givenCacheBinaryWhenEvictCacheFailsThenReturnFalse) {
|
||||
SysCalls::getFileAttributesResult = INVALID_FILE_ATTRIBUTES;
|
||||
|
||||
const size_t cacheSize = 3u;
|
||||
CompilerCacheMockWindows cache({true, ".cl_cache", "somePath\\cl_cache", cacheSize});
|
||||
|
||||
cache.callBaseLockConfigFileAndReadSize = false;
|
||||
cache.lockConfigFileAndReadSizeHandle = reinterpret_cast<HANDLE>(0x1234);
|
||||
|
||||
cache.callBaseEvictCache = false;
|
||||
cache.evictCacheResult = false;
|
||||
|
||||
const std::string kernelFileHash = "7e3291364d8df42";
|
||||
const char *binary = "123456";
|
||||
const size_t binarySize = strlen(binary);
|
||||
auto result = cache.cacheBinary(kernelFileHash, binary, binarySize);
|
||||
|
||||
EXPECT_FALSE(result);
|
||||
EXPECT_EQ(1u, SysCalls::unlockFileExCalled);
|
||||
EXPECT_EQ(1u, SysCalls::closeHandleCalled);
|
||||
EXPECT_EQ(1u, cache.lockConfigFileAndReadSizeCalled);
|
||||
EXPECT_EQ(1u, SysCalls::getFileAttributesCalled);
|
||||
EXPECT_EQ(0u, cache.createUniqueTempFileAndWriteDataCalled);
|
||||
EXPECT_EQ(0u, cache.renameTempFileBinaryToProperNameCalled);
|
||||
EXPECT_EQ(0u, SysCalls::writeFileCalled);
|
||||
}
|
||||
|
||||
TEST_F(CompilerCacheWindowsTest, givenCacheBinaryWhenCreateUniqueTempFileAndWriteDataFailsThenReturnFalse) {
|
||||
SysCalls::getFileAttributesResult = INVALID_FILE_ATTRIBUTES;
|
||||
|
||||
const size_t cacheSize = MemoryConstants::megaByte - 2u;
|
||||
CompilerCacheMockWindows cache({true, ".cl_cache", "somePath\\cl_cache", cacheSize});
|
||||
|
||||
cache.callBaseLockConfigFileAndReadSize = false;
|
||||
cache.lockConfigFileAndReadSizeHandle = reinterpret_cast<HANDLE>(0x1234);
|
||||
|
||||
cache.callBaseEvictCache = false;
|
||||
cache.evictCacheResult = true;
|
||||
|
||||
cache.callBaseCreateUniqueTempFileAndWriteData = false;
|
||||
cache.createUniqueTempFileAndWriteDataResult = false;
|
||||
|
||||
const std::string kernelFileHash = "7e3291364d8df42";
|
||||
const char *binary = "123456";
|
||||
const size_t binarySize = strlen(binary);
|
||||
auto result = cache.cacheBinary(kernelFileHash, binary, binarySize);
|
||||
|
||||
EXPECT_FALSE(result);
|
||||
EXPECT_EQ(1u, SysCalls::unlockFileExCalled);
|
||||
EXPECT_EQ(1u, SysCalls::closeHandleCalled);
|
||||
EXPECT_EQ(1u, cache.lockConfigFileAndReadSizeCalled);
|
||||
EXPECT_EQ(1u, SysCalls::getFileAttributesCalled);
|
||||
EXPECT_EQ(1u, cache.createUniqueTempFileAndWriteDataCalled);
|
||||
EXPECT_EQ(0u, cache.renameTempFileBinaryToProperNameCalled);
|
||||
EXPECT_EQ(0u, SysCalls::writeFileCalled);
|
||||
}
|
||||
|
||||
TEST_F(CompilerCacheWindowsTest, givenCacheBinaryWhenRenameTempFileBinaryToProperNameFailsThenReturnFalse) {
|
||||
SysCalls::getFileAttributesResult = INVALID_FILE_ATTRIBUTES;
|
||||
|
||||
const size_t cacheSize = MemoryConstants::megaByte - 2u;
|
||||
CompilerCacheMockWindows cache({true, ".cl_cache", "somePath\\cl_cache", cacheSize});
|
||||
|
||||
cache.callBaseLockConfigFileAndReadSize = false;
|
||||
cache.lockConfigFileAndReadSizeHandle = reinterpret_cast<HANDLE>(0x1234);
|
||||
|
||||
cache.callBaseEvictCache = false;
|
||||
cache.evictCacheResult = true;
|
||||
|
||||
cache.callBaseCreateUniqueTempFileAndWriteData = false;
|
||||
cache.createUniqueTempFileAndWriteDataResult = true;
|
||||
|
||||
cache.callBaseRenameTempFileBinaryToProperName = false;
|
||||
cache.renameTempFileBinaryToProperNameResult = false;
|
||||
|
||||
const std::string kernelFileHash = "7e3291364d8df42";
|
||||
const char *binary = "123456";
|
||||
const size_t binarySize = strlen(binary);
|
||||
auto result = cache.cacheBinary(kernelFileHash, binary, binarySize);
|
||||
|
||||
EXPECT_FALSE(result);
|
||||
EXPECT_EQ(1u, SysCalls::unlockFileExCalled);
|
||||
EXPECT_EQ(1u, SysCalls::closeHandleCalled);
|
||||
EXPECT_EQ(1u, cache.lockConfigFileAndReadSizeCalled);
|
||||
EXPECT_EQ(1u, SysCalls::getFileAttributesCalled);
|
||||
EXPECT_EQ(1u, cache.createUniqueTempFileAndWriteDataCalled);
|
||||
EXPECT_EQ(1u, cache.renameTempFileBinaryToProperNameCalled);
|
||||
EXPECT_EQ(1u, SysCalls::deleteFileACalled);
|
||||
EXPECT_EQ(0u, SysCalls::writeFileCalled);
|
||||
}
|
||||
|
||||
} // namespace NEO
|
||||
|
||||
@@ -37,6 +37,7 @@ target_sources(neo_shared_tests PRIVATE
|
||||
${CMAKE_CURRENT_SOURCE_DIR}/kernel_helpers_tests.cpp
|
||||
${CMAKE_CURRENT_SOURCE_DIR}/matcher_tests.cpp
|
||||
${CMAKE_CURRENT_SOURCE_DIR}/memory_management_tests.cpp
|
||||
${CMAKE_CURRENT_SOURCE_DIR}/path_tests.cpp
|
||||
${CMAKE_CURRENT_SOURCE_DIR}/product_config_helper_tests.cpp
|
||||
${CMAKE_CURRENT_SOURCE_DIR}/product_config_helper_tests.h
|
||||
${CMAKE_CURRENT_SOURCE_DIR}/ptr_math_tests.cpp
|
||||
|
||||
45
shared/test/unit_test/helpers/path_tests.cpp
Normal file
45
shared/test/unit_test/helpers/path_tests.cpp
Normal file
@@ -0,0 +1,45 @@
|
||||
/*
|
||||
* Copyright (C) 2023 Intel Corporation
|
||||
*
|
||||
* SPDX-License-Identifier: MIT
|
||||
*
|
||||
*/
|
||||
|
||||
#include "shared/source/helpers/path.h"
|
||||
|
||||
#include "gtest/gtest.h"
|
||||
#include "os_inc.h"
|
||||
|
||||
#include <string>
|
||||
|
||||
using namespace NEO;
|
||||
|
||||
TEST(PathTests, givenOnlyRhsWhenJoinPathThenOnlyRhsIsReturned) {
|
||||
const std::string lhs = "";
|
||||
const std::string rhs = "folder/file.txt";
|
||||
const std::string result = joinPath(lhs, rhs);
|
||||
EXPECT_EQ(rhs, result);
|
||||
}
|
||||
|
||||
TEST(PathTests, givenOnlyLhsWhenJoinPathThenOnlyLhsIsReturned) {
|
||||
const std::string lhs = "folder";
|
||||
const std::string rhs = "";
|
||||
const std::string result = joinPath(lhs, rhs);
|
||||
EXPECT_EQ(lhs, result);
|
||||
}
|
||||
|
||||
TEST(PathTests, givenLhsEndingWithPathSeparatorAndNonEmptyRhsWhenJoinPathThenLhsAndRhsAreJoined) {
|
||||
const std::string lhs = std::string("folder") + PATH_SEPARATOR;
|
||||
const std::string rhs = "file.txt";
|
||||
const std::string expected = lhs + rhs;
|
||||
const std::string result = joinPath(lhs, rhs);
|
||||
EXPECT_EQ(expected, result);
|
||||
}
|
||||
|
||||
TEST(PathTests, givenLhsNotEndingWithPathSeparatorAndNonEmptyRhsWhenJoinPathThenPathSeparatorIsAppendedBetweenLhsAndRhs) {
|
||||
const std::string lhs = "folder";
|
||||
const std::string rhs = "file.txt";
|
||||
const std::string expected = std::string("folder") + PATH_SEPARATOR + std::string("file.txt");
|
||||
const std::string result = joinPath(lhs, rhs);
|
||||
EXPECT_EQ(expected, result);
|
||||
}
|
||||
Reference in New Issue
Block a user