replica
/
hanchenye-llvm-project
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Extend stat query APIs to explicitly specify if the query is for 

a file or directory, allowing just a stat call if a file descriptor
is not needed.

Doing just 'stat' is faster than 'open/fstat/close'.
This has the effect of cutting down system time for validating the input files of a PCH.

llvm-svn: 169831
This commit is contained in:
Argyrios Kyrtzidis 2012-12-11 07:48:23 +00:00
parent 53c3877f94
commit 3b7793797f
7 changed files with 35 additions and 36 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
clang/include/clang/Basic/FileManager.h
View File

@ -164,7 +164,7 @@ class FileManager : public RefCountedBase<FileManager> {
OwningPtr<FileSystemStatCache> StatCache;
bool getStatValue(const char *Path, struct stat &StatBuf,
int *FileDescriptor);
bool isFile, int *FileDescriptor);
/// Add all ancestors of the given path (pointing to either a file
/// or a directory) as virtual directories.

19
clang/include/clang/Basic/FileSystemStatCache.h
View File

@ -44,13 +44,13 @@ public:
///
/// \returns \c true if the path does not exist or \c false if it exists.
///
/// If FileDescriptor is non-null, then this lookup should only return success
/// for files (not directories). If it is null this lookup should only return
/// If isFile is true, then this lookup should only return success for files
/// (not directories). If it is false this lookup should only return
/// success for directories (not files). On a successful file lookup, the
/// implementation can optionally fill in FileDescriptor with a valid
/// descriptor and the client guarantees that it will close it.
static bool get(const char *Path, struct stat &StatBuf, int *FileDescriptor,
FileSystemStatCache *Cache);
static bool get(const char *Path, struct stat &StatBuf,
bool isFile, int *FileDescriptor, FileSystemStatCache *Cache);
/// \brief Sets the next stat call cache in the chain of stat caches.
@ -69,16 +69,17 @@ public:
protected:
virtual LookupResult getStat(const char *Path, struct stat &StatBuf,
int *FileDescriptor) = 0;
bool isFile, int *FileDescriptor) = 0;
LookupResult statChained(const char *Path, struct stat &StatBuf,
int *FileDescriptor) {
bool isFile, int *FileDescriptor) {
if (FileSystemStatCache *Next = getNextStatCache())
return Next->getStat(Path, StatBuf, FileDescriptor);
return Next->getStat(Path, StatBuf, isFile, FileDescriptor);
// If we hit the end of the list of stat caches to try, just compute and
// return it without a cache.
return get(Path, StatBuf, FileDescriptor, 0) ? CacheMissing : CacheExists;
return get(Path, StatBuf,
isFile, FileDescriptor, 0) ? CacheMissing : CacheExists;
}
};
@ -97,7 +98,7 @@ public:
iterator end() const { return StatCalls.end(); }
virtual LookupResult getStat(const char *Path, struct stat &StatBuf,
int *FileDescriptor);
bool isFile, int *FileDescriptor);
};
} // end namespace clang

20
clang/lib/Basic/FileManager.cpp
View File

@ -311,7 +311,7 @@ const DirectoryEntry *FileManager::getDirectory(StringRef DirName,
// Check to see if the directory exists.
struct stat StatBuf;
if (getStatValue(InterndDirName, StatBuf, 0/*directory lookup*/)) {
if (getStatValue(InterndDirName, StatBuf, false, 0/*directory lookup*/)) {
// There's no real directory at the given path.
if (!CacheFailure)
SeenDirEntries.erase(DirName);
@ -376,7 +376,8 @@ const FileEntry *FileManager::getFile(StringRef Filename, bool openFile,
// Nope, there isn't. Check to see if the file exists.
int FileDescriptor = -1;
struct stat StatBuf;
if (getStatValue(InterndFileName, StatBuf, &FileDescriptor)) {
if (getStatValue(InterndFileName, StatBuf, true,
openFile ? &FileDescriptor : 0)) {
// There's no real file at the given path.
if (!CacheFailure)
SeenFileEntries.erase(Filename);
@ -444,14 +445,9 @@ FileManager::getVirtualFile(StringRef Filename, off_t Size,
"The directory of a virtual file should already be in the cache.");
// Check to see if the file exists. If so, drop the virtual file
int FileDescriptor = -1;
struct stat StatBuf;
const char *InterndFileName = NamedFileEnt.getKeyData();
if (getStatValue(InterndFileName, StatBuf, &FileDescriptor) == 0) {
// If the stat process opened the file, close it to avoid a FD leak.
if (FileDescriptor != -1)
close(FileDescriptor);
if (getStatValue(InterndFileName, StatBuf, true, 0) == 0) {
StatBuf.st_size = Size;
StatBuf.st_mtime = ModificationTime;
UFE = &UniqueRealFiles.getFile(InterndFileName, StatBuf);
@ -564,18 +560,18 @@ getBufferForFile(StringRef Filename, std::string *ErrorStr) {
/// false if it's an existent real file. If FileDescriptor is NULL,
/// do directory look-up instead of file look-up.
bool FileManager::getStatValue(const char *Path, struct stat &StatBuf,
int *FileDescriptor) {
bool isFile, int *FileDescriptor) {
// FIXME: FileSystemOpts shouldn't be passed in here, all paths should be
// absolute!
if (FileSystemOpts.WorkingDir.empty())
return FileSystemStatCache::get(Path, StatBuf, FileDescriptor,
return FileSystemStatCache::get(Path, StatBuf, isFile, FileDescriptor,
StatCache.get());
SmallString<128> FilePath(Path);
FixupRelativePath(FilePath);
return FileSystemStatCache::get(FilePath.c_str(), StatBuf, FileDescriptor,
StatCache.get());
return FileSystemStatCache::get(FilePath.c_str(), StatBuf,
isFile, FileDescriptor, StatCache.get());
}
bool FileManager::getNoncachedStatValue(StringRef Path,

20
clang/lib/Basic/FileSystemStatCache.cpp
View File

@ -34,21 +34,23 @@ void FileSystemStatCache::anchor() { }
/// path, using the cache to accelerate it if possible. This returns true if
/// the path does not exist or false if it exists.
///
/// If FileDescriptor is non-null, then this lookup should only return success
/// for files (not directories). If it is null this lookup should only return
/// If isFile is true, then this lookup should only return success for files
/// (not directories). If it is false this lookup should only return
/// success for directories (not files). On a successful file lookup, the
/// implementation can optionally fill in FileDescriptor with a valid
/// descriptor and the client guarantees that it will close it.
bool FileSystemStatCache::get(const char *Path, struct stat &StatBuf,
int *FileDescriptor, FileSystemStatCache *Cache) {
bool isFile, int *FileDescriptor,
FileSystemStatCache *Cache) {
LookupResult R;
bool isForDir = FileDescriptor == 0;
bool isForDir = !isFile;
// If we have a cache, use it to resolve the stat query.
if (Cache)
R = Cache->getStat(Path, StatBuf, FileDescriptor);
else if (isForDir) {
// If this is a directory and we have no cache, just go to the file system.
R = Cache->getStat(Path, StatBuf, isFile, FileDescriptor);
else if (isForDir || !FileDescriptor) {
// If this is a directory or a file descriptor is not needed and we have
// no cache, just go to the file system.
R = ::stat(Path, &StatBuf) != 0 ? CacheMissing : CacheExists;
} else {
// Otherwise, we have to go to the filesystem. We can always just use
@ -104,8 +106,8 @@ bool FileSystemStatCache::get(const char *Path, struct stat &StatBuf,
MemorizeStatCalls::LookupResult
MemorizeStatCalls::getStat(const char *Path, struct stat &StatBuf,
int *FileDescriptor) {
LookupResult Result = statChained(Path, StatBuf, FileDescriptor);
bool isFile, int *FileDescriptor) {
LookupResult Result = statChained(Path, StatBuf, isFile, FileDescriptor);
// Do not cache failed stats, it is easy to construct common inconsistent
// situations if we do, and they are not important for PCH performance (which

4
clang/lib/Frontend/CacheTokens.cpp
View File

@ -517,8 +517,8 @@ public:
~StatListener() {}
LookupResult getStat(const char *Path, struct stat &StatBuf,
int *FileDescriptor) {
LookupResult Result = statChained(Path, StatBuf, FileDescriptor);
bool isFile, int *FileDescriptor) {
LookupResult Result = statChained(Path, StatBuf, isFile, FileDescriptor);
if (Result == CacheMissing) // Failed 'stat'.
PM.insert(PTHEntryKeyVariant(Path), PTHEntry());

4
clang/lib/Lex/PTHLexer.cpp
View File

@ -679,13 +679,13 @@ public:
~PTHStatCache() {}
LookupResult getStat(const char *Path, struct stat &StatBuf,
int *FileDescriptor) {
bool isFile, int *FileDescriptor) {
// Do the lookup for the file's data in the PTH file.
CacheTy::iterator I = Cache.find(Path);
// If we don't get a hit in the PTH file just forward to 'stat'.
if (I == Cache.end())
return statChained(Path, StatBuf, FileDescriptor);
return statChained(Path, StatBuf, isFile, FileDescriptor);
const PTHStatData &Data = *I;

2
clang/unittests/Basic/FileManagerTest.cpp
View File

@ -51,7 +51,7 @@ public:
// Implement FileSystemStatCache::getStat().
virtual LookupResult getStat(const char *Path, struct stat &StatBuf,
int *FileDescriptor) {
bool isFile, int *FileDescriptor) {
if (StatCalls.count(Path) != 0) {
StatBuf = StatCalls[Path];
return CacheExists;