foreman
02cf1c13a0
ECR #304775 - Preparation for kernel caching feature force line ending on files to one style. Precheckin does not capture this failure as it converts all text files to linux format so that both linux and windows can compile the code during precheckin. Affected files ... ... //depot/stg/opencl/drivers/opencl/compiler/lib/backends/common/cache.cpp#4 edit ... //depot/stg/opencl/drivers/opencl/compiler/lib/backends/common/cache.hpp#4 edit
130 wiersze
4.5 KiB
C++
130 wiersze
4.5 KiB
C++
#ifndef AMD_KERNEL_CACHE_H_
|
|
#define AMD_KERNEL_CACHE_H_
|
|
#include <string>
|
|
#include <sstream>
|
|
#include <fstream>
|
|
#include <iostream>
|
|
#include <cstdio>
|
|
#ifdef __linux__
|
|
#include <unistd.h>
|
|
#include <fcntl.h>
|
|
#include <pwd.h>
|
|
#include <sys/file.h>
|
|
#include <sys/stat.h>
|
|
#include <sys/types.h>
|
|
#include <dirent.h>
|
|
#include <errno.h>
|
|
#include <alloca.h>
|
|
#else
|
|
#include <windows.h>
|
|
#include <shlobj.h>
|
|
#include <Lmcons.h>
|
|
#include <aclapi.h>
|
|
#include <filesystem>
|
|
#endif
|
|
#include "os/os.hpp"
|
|
#include "utils/options.hpp"
|
|
#include "../../../sc/Interface/SCLib_Ver.h"
|
|
#if _WIN32
|
|
#define CloseFile CloseHandle
|
|
#define FileHandle HANDLE
|
|
#else
|
|
#define CloseFile close
|
|
#define FileHandle int
|
|
#endif
|
|
typedef struct _KernelCacheData {
|
|
char *data;
|
|
size_t dataSize;
|
|
} KernelCacheData;
|
|
// Specialize std::hash
|
|
struct HashType {
|
|
std::string data;
|
|
std::string buildOption;
|
|
};
|
|
namespace std {
|
|
template<>
|
|
struct hash<HashType> {
|
|
public:
|
|
size_t operator()(const HashType &v) const
|
|
{
|
|
size_t h1 = std::hash<std::string>()(v.data);
|
|
size_t h2 = std::hash<std::string>()(v.buildOption);
|
|
return h1 ^ ( h2 << 1 );
|
|
}
|
|
};
|
|
}
|
|
typedef struct _KernelCacheFileHeader {
|
|
char AMD[4]; // 'AMD\0'
|
|
size_t buildOptSize;
|
|
size_t dstSize;
|
|
} KernelCacheFileHeader;
|
|
/* Kernel Cache File Contents (listed in order) */
|
|
// BUild options in text format
|
|
// Src data size
|
|
// Src data
|
|
// Dest data
|
|
class KernelCache {
|
|
private:
|
|
// TODO: the default cache size (512MB) might be changed later
|
|
static const unsigned int DEFAULT_CACHE_SIZE = 512 * 1024 * 1024;
|
|
unsigned int version;
|
|
unsigned int cacheSize;
|
|
std::string rootPath;
|
|
std::string indexName;
|
|
std::string errorMsg;
|
|
// Set the root path for the cache
|
|
bool setRootPath(const std::string &chipName);
|
|
// Wipe the cache folder structure
|
|
bool wipeCacheFolders();
|
|
// Setup cache tree structure
|
|
bool setUpCacheFolders();
|
|
// Get the cache version and size from the index file
|
|
bool getCacheInfo();
|
|
// Set the cache version and size in the index file
|
|
bool setCacheInfo(unsigned int newVersion, unsigned int newSize);
|
|
// Compute hash value for chunks of data
|
|
unsigned int computeHash(const KernelCacheData *data, const std::string &buildOpts);
|
|
// Computes hash and file name from given data
|
|
void makeFileName(const KernelCacheData *data, const std::string &buildOpts, std::string &pathToFile);
|
|
// Finds path to a file from a given hash value
|
|
void getFilePathFromHash(unsigned int hash, std::string &pathToFile);
|
|
#if _WIN32
|
|
// Get Sid of account
|
|
std::unique_ptr<SID> getSid(TCHAR *userName);
|
|
#endif
|
|
// Return detailed error message as string
|
|
std::string getLastErrorMsg();
|
|
// Read contents in cacheFile
|
|
bool readFile(FileHandle cacheFile, void *buffer, ssize_t size);
|
|
// Write data to a file
|
|
bool writeFile(FileHandle cacheFile, const void *buffer, ssize_t sizeToWriten);
|
|
bool writeFile(const std::string &fileName, const void *data, size_t size, bool appendable);
|
|
// Set file to only owner accessible
|
|
bool setAccessPermission(const std::string &fileName, bool isFile = false);
|
|
// Set up cache file structure
|
|
bool cacheInit(unsigned int compilerVersion, const std::string &chipName);
|
|
// Get cache entry corresponding to srcData, if it exists
|
|
bool getCacheEntry_helper(const KernelCacheData *srcData, const std::string &buildOpts,
|
|
std::string &dstData);
|
|
// Control kernel cache test
|
|
bool internalKCacheTestSwitch();
|
|
// Verify whether the file includes the right kernel cache file header
|
|
bool verifyKernelCacheFileHeader(KernelCacheFileHeader &H, const std::string &buildOpts);
|
|
// Remove partially written file
|
|
void removePartiallyWrittenFile(const std::string &fileName);
|
|
// Log error message and close the file
|
|
void logErrorCloseFile(const std::string &errorMsg, const FileHandle file);
|
|
public:
|
|
KernelCache() : version(0), cacheSize(0) { rootPath.clear(); indexName.clear(); errorMsg.clear(); }
|
|
// Make cache entry corresponding to srcData, dstData, buildOpts and kernelName
|
|
bool makeCacheEntry(bool isCacheReady, const KernelCacheData *srcData,
|
|
const std::string &buildOpts, const std::string &dstData);
|
|
// Wrapper function for getCacheEntry
|
|
bool getCacheEntry(bool &isCacheReady, const std::string &deviceName, amd::option::Options *opts,
|
|
const KernelCacheData *srcData, const std::string &buildOpts,
|
|
std::string &dstData, const std::string &msg);
|
|
// Log caching error messages for debugging the cache and/or detecting collisions
|
|
void appendLogToFile(std::string extraMsg = "");
|
|
};
|
|
#endif // AMD_KERNEL_CACHE_H_
|