为什么C <stdio.h>文件* fread()比Win32 ReadFile()更快？

Question

使用以下三种技术对读取文件进行比较：

1. C <stdio.h> FILE*
2. Win32 CreateFile()/ReadFile()
3. Win32内存映射

我注意到#1比#2快，#3是最快的。

例如，从最快到最慢的排序，为了处理900 to的测试文件，我得到了以下结果：

Win32内存映射: 821.308 ms C文件(文件*)：1779.83 ms Win32文件(CreateFile)：3649.67 ms

为什么C <stdio.h>技术比Win32 ReadFile()访问快？我希望原始的Win32 API比CRT具有更少的开销。我在这里错过了什么？

下面是可编译的测试C++源代码。

编辑

我用4KB的读缓冲区重复了测试，并使用三个不同的文件(具有相同的内容)来避免可能扭曲性能度量的缓存效果，现在的结果与预期的一样。

例如，对于大约400 MB的文件，结果如下：

1. Win32内存映射：305.908 ms
2. Win32文件(CreateFile)：451.402 ms
3. C文件(文件*)：460.579 ms

////////////////////////////////////////////////////////////////////////////////
// Test file reading using C FILE*, Win32 CreateFile and Win32 memory mapping.
////////////////////////////////////////////////////////////////////////////////


#include <stdio.h>
#include <stdlib.h>
#include <algorithm>
#include <exception>
#include <iostream>
#include <stdexcept>
#include <vector>
#include <Windows.h>


//------------------------------------------------------------------------
//                      Performance (speed) measurement
//------------------------------------------------------------------------

long long counter()
{
    LARGE_INTEGER li;
    QueryPerformanceCounter(&li);
    return li.QuadPart;
}

long long frequency()
{
    LARGE_INTEGER li;
    QueryPerformanceFrequency(&li);
    return li.QuadPart;
}

void print_time(const long long start, const long long finish,
    const char * const s)
{
    std::cout << s << ": " << (finish - start) * 1000.0 / frequency() << " ms\n";
}


//------------------------------------------------------------------------
//                      RAII handle wrappers
//------------------------------------------------------------------------

struct c_file_traits
{
    typedef FILE* type;

    static FILE* invalid_value()
    {
        return nullptr;
    }

    static void close(FILE* f)
    {
        fclose(f);
    }
};

struct win32_file_traits
{
    typedef HANDLE type;

    static HANDLE invalid_value()
    {
        return INVALID_HANDLE_VALUE;
    }

    static void close(HANDLE h)
    {
        CloseHandle(h);
    }
};

struct win32_handle_traits
{
    typedef HANDLE type;

    static HANDLE invalid_value()
    {
        return nullptr;
    }

    static void close(HANDLE h)
    {
        CloseHandle(h);
    }
};

template <typename Traits>
class handle
{
public:
    typedef typename Traits::type type;

    handle()
        : _h(Traits::invalid_value())
    {
    }

    explicit handle(type h)
        : _h(h)
    {
    }

    ~handle()
    {
        close();
    }

    bool valid() const
    {
        return (_h != Traits::invalid_value());
    }

    type get() const
    {
        return _h;
    }

    void close()
    {
        if (valid())
            Traits::close(_h);

        _h = Traits::invalid_value();
    }

    void reset(type h)
    {
        if (h != _h)
        {
            close();
            _h = h;
        }
    }


private: // Ban copy
    handle(const handle&);
    handle& operator=(const handle&);

private:
    type _h;    // wrapped raw handle
};

typedef handle<c_file_traits> c_file_handle;
typedef handle<win32_file_traits> win32_file_handle;
typedef handle<win32_handle_traits> win32_handle;


//------------------------------------------------------------------------
//              File reading tests using various techniques
//------------------------------------------------------------------------

unsigned long long count_char_using_c_file(const std::string& filename, const char ch)
{
    unsigned long long char_count = 0;

#pragma warning(push)
#pragma warning(disable: 4996) // fopen use is OK
    c_file_handle file(fopen(filename.c_str(), "rb"));
#pragma warning(pop)

    if (!file.valid())
        throw std::runtime_error("Can't open file.");

    std::vector<char> read_buffer(4*1024); // 4 KB
    bool has_more_data = true;
    while (has_more_data)
    {
        size_t read_count = fread(read_buffer.data(), 1, read_buffer.size(), file.get());
        for (size_t i = 0; i < read_count; i++)
        {
            if (read_buffer[i] == ch)
                char_count++;
        }

        if (read_count < read_buffer.size())
            has_more_data = false;
    }

    return char_count;
}


unsigned long long count_char_using_win32_file(const std::string& filename, const char ch)
{
    unsigned long long char_count = 0;

    win32_file_handle file(::CreateFileA(
        filename.c_str(),
        GENERIC_READ,
        FILE_SHARE_READ,
        nullptr,
        OPEN_EXISTING,
        FILE_FLAG_SEQUENTIAL_SCAN,
        nullptr
        )
        );
    if (!file.valid())
        throw std::runtime_error("Can't open file.");

    std::vector<char> read_buffer(4*1024); // 4 KB
    bool has_more_data = true;
    while (has_more_data)
    {
        DWORD read_count = 0;
        if (!ReadFile(file.get(), read_buffer.data(), read_buffer.size(), &read_count, nullptr))
            throw std::runtime_error("File read error using ReadFile().");

        for (size_t i = 0; i < read_count; i++)
        {
            if (read_buffer[i] == ch)
                char_count++;
        }

        if (read_count < sizeof(read_buffer))
            has_more_data = false;
    }

    return char_count;
}


// Memory-map a file.
class file_map
{
public:
    explicit file_map(const std::string& filename)
        : _view(nullptr), _length(0)
    {
        _file.reset(::CreateFileA(
            filename.c_str(),
            GENERIC_READ,
            FILE_SHARE_READ,
            nullptr,
            OPEN_EXISTING,
            FILE_ATTRIBUTE_NORMAL,
            nullptr));
        if (!_file.valid())
            return;

        LARGE_INTEGER file_size;
        if (!GetFileSizeEx(_file.get(), &file_size))
            return;

        if (file_size.QuadPart == 0)
            return;

        _mapping.reset(::CreateFileMapping(
            _file.get(), nullptr,
            PAGE_READONLY,
            0,
            0,
            nullptr)
            );
        if (!_mapping.valid())
            return;

        _view = reinterpret_cast<char*>
            (::MapViewOfFile(_mapping.get(), FILE_MAP_READ, 0, 0, 0));
        if (!_view)
            return;

        _length = file_size.QuadPart;
    }

    ~file_map()
    {
        if (_view)
            UnmapViewOfFile(_view);
    }

    bool valid() const
    {
        return (_view != nullptr);
    }

    const char * begin() const
    {
        return _view;
    }

    const char * end() const
    {
        return begin() + length();
    }

    unsigned long long length() const
    {
        return _length;
    }

private:    // ban copy
    file_map(const file_map&);
    file_map& operator=(const file_map&);

private:
    win32_file_handle   _file;
    win32_handle        _mapping;
    char*               _view;
    unsigned long long  _length;    // in bytes
};


unsigned long long count_char_using_memory_mapping(const std::string& filename, const char ch)
{
    unsigned long long char_count = 0;

    file_map view(filename);
    if (!view.valid())
        throw std::runtime_error("Can't create memory-mapping of file.");

    for (auto it = view.begin(); it != view.end(); ++it)
    {
        if (*it == ch)
        {
            char_count++;
        }
    }

    return char_count;
}


template <typename TestFunc>
void run_test(const char * message, TestFunc test, const std::string& filename, const char ch)
{
    const long long start = counter();
    const unsigned long long char_count = test(filename, ch);
    const long long finish = counter();
    print_time(start, finish, message);
    std::cout << "Count of \'" << ch << "\' : " << char_count << "\n\n";
}


int main(int argc, char* argv[])
{
    static const int kExitOk = 0;
    static const int kExitError = 1;

    if (argc != 3)
    {
        std::cerr << argv[0] << " <char> <filename>.\n";
        std::cerr << "Counts occurrences of ASCII character <char>\n";
        std::cerr << "in the <filename> file.\n\n";
        return kExitError;
    }

    const char ch = *(argv[1]);
    const std::string filename = argv[2];

    try
    {
        // Execute tests on THREE different files with the same content,
        // to avoid caching effects.
        // (file names have incremental number suffix).
        run_test("C <stdio.h> file (FILE*)", count_char_using_c_file, filename + "1", ch);
        run_test("Win32 file (CreateFile)", count_char_using_win32_file, filename + "2", ch);
        run_test("Win32 memory mapping", count_char_using_memory_mapping, filename + "3", ch);

        return kExitOk;
    }
    catch (const std::exception& e)
    {
        std::cerr << "\n*** ERROR: " << e.what() << '\n';
        return kExitError;
    }
}

////////////////////////////////////////////////////////////////////////////////

Answer 1

刚在我的机器上运行了一些测试，这些测试表明，增加缓冲区大小实际上可以提高性能：

C <stdio.h> file (FILE*): 1431.93 ms
Bufsize: 0
Count of 'x' : 3161882

Win32 file (CreateFile): 2289.45 ms
Bufsize: 1024
Count of 'x' : 3161882

Win32 file (CreateFile): 1714.5 ms
Bufsize: 2048
Count of 'x' : 3161882

Win32 file (CreateFile): 1479.16 ms
Bufsize: 4096
Count of 'x' : 3161882

Win32 file (CreateFile): 1328.25 ms
Bufsize: 8192
Count of 'x' : 3161882

Win32 file (CreateFile): 1256.1 ms
Bufsize: 16384
Count of 'x' : 3161882

Win32 file (CreateFile): 1223.54 ms
Bufsize: 32768
Count of 'x' : 3161882

Win32 file (CreateFile): 1224.84 ms
Bufsize: 65536
Count of 'x' : 3161882

Win32 file (CreateFile): 1212.4 ms
Bufsize: 131072
Count of 'x' : 3161882

Win32 file (CreateFile): 1238.09 ms
Bufsize: 262144
Count of 'x' : 3161882

Win32 file (CreateFile): 1209.2 ms
Bufsize: 524288
Count of 'x' : 3161882

Win32 file (CreateFile): 1223.67 ms
Bufsize: 1048576
Count of 'x' : 3161882

Win32 file (CreateFile): 1349.98 ms
Bufsize: 2097152
Count of 'x' : 3161882

Win32 memory mapping: 796.281 ms
Bufsize: 0
Count of 'x' : 3161882

Visual 2012调试器中的一些步骤显示，至少在我的计算机上，文件*方法的缓冲区大小为4096字节。(正如其他人已经说过的，除非您正在从控制台阅读，否则它也会调用ReadFile。)

同样有趣的是，大缓冲区稍微减慢了性能。将new操作符移出测试也解决不了这个问题。

首先，内存映射测试对我来说很慢，因为我是在调试模式下运行的。我已经用发布模式编译更新了所有结果。内存映射成为第一个。

Answer 2

我获得的最快的磁盘访问是使用ReadFile。但我特别使用标志打开文件，以满足磁盘访问和缓存的要求。如果你只是逐字使用它，那么这个比较就有点蹩脚了。

您应该阅读更多关于该函数以及CreateFile的内容。您会发现您可以在扇区大小的块中读取数据到扇区对齐内存中。然后你会超过-表现fread。

正如其他人所说，fread正在进行自己的缓冲。您使用ReadFile的缓冲实现仍然需要工作。

看看MSDN。ALl信息在那里。具体而言，在此：

• File buffering
• Caching behaviour

Answer 3

你确定你是在测试吗？

您是如何计算磁盘位置、查找时间、文件缓存等的？

stdio和win32最终会对Windows内核进行相同的调用来打开文件。

mmap做的事情略有不同，因为它可以保留实际读取数据直到它被使用-如果您有固定的文件大小和性能问题，mmap是一个很好的选择。