FILE_FLAG_IO_BUFFERING slows down synchronous read operation - c++

Question

Reading a set of files with no buffering(skipping the file cache) using the flag FILE_FLAG_IO_BUFFERING should be faster than the normal reading(without using this flag). The reason for that to be faster is that 'no buffering' mechanism will skip the system file cache and will directly read into application's buffer.
The application is run in cold environment (after disk defragmentation, machine restart) so that the system file cache is not cached with the concerned files before the run.
This is from msdn documentation on these APIs and flags.
However, I experience a totally different performance behavior. I read a set of files synchronously one after the other, after the file handles have been created using the FILE_FLAG_IO_BUFFERING flag. The time it takes to read the set of files is 29 sec. Where as, if I had read normally without using this flag (again in the cold run of the application when file cache does not hold the concerned files), the time it takes is around 24 secs.
Details:
Total number of files: 1939
Total file size(sum of all): 57 MB
With FLAG_IO_NO_BUFFERING: 29 secs (time taken to read)
Without FLAG_IO_NO_BUFFERING: 24 secs (time taken to read)
Here is the code that implements the read:
DWORD ReadFiles(std::vector<std::string> &filePathNameVectorRef)
{
long totalBytesRead = 0;
for(all file in filePathNameVectorRef)
totalBytesRead += Read_Synchronous(file);
return totalBytesRead;
}
DWORD Read_Synchronous(const char * filePathName)
{
DWORD accessMode = GENERIC_READ;
DWORD shareMode = 0;
DWORD createDisposition = OPEN_EXISTING;
DWORD flags = FILE_FLAG_NO_BUFFERING;
HANDLE handle = INVALID_HANDLE_VALUE;
DWORD fileSize;
DWORD bytesRead = 0;
DWORD bytesToRead = 0;
LARGE_INTEGER li;
char * buffer;
BOOL success = false;
handle = CreateFile(filePathName, accessMode, shareMode, NULL, createDisposition, flags, NULL);
if(handle == INVALID_HANDLE_VALUE)
return 0;
GetFileSizeEx(handle, &li);
fileSize = (DWORD)li.QuadPart;
bytesToRead = (fileSize/g_bytesPerPhysicalSector)*g_bytesPerPhysicalSector;
buffer = static_cast<char *>(VirtualAlloc(0, bytesToRead, MEM_COMMIT, PAGE_READWRITE));
if(buffer == NULL)
goto RETURN;
success = ReadFile(handle, buffer, bytesToRead, &bytesRead, NULL);
if(!success){
fprintf(stdout, "\n Error occured: %d", GetLastError());
return 0;
}
free(buffer);
RETURN:
CloseHandle(handle);
return bytesRead;
}
Please share your thoughts on the reason you think this code is running slower than when the FILE_FLAG_NO_BUFFERING is not used. Thanks.

Answer 1

I expect that what you are measuring is the time to open and close the files. There are rather a lot of files. You should be able to read 57MB from a disk in around one second. So the overhead would appear to be the file opening rather than the reading. You should try again with fewer, but larger, files. Create, say, 20 100MB files and read those. It looks like, on your system at least, that it is slower to open files with FILE_FLAG_NO_BUFFERING than without.
In any case, don't expect FILE_FLAG_NO_BUFFERING to speed things up. The time spent copying from the file handle's buffer to your buffer is trivial in comparison to pulling the data off the disk.