为什么使用istreambuf迭代器读取文件会因重复执行而变得更快？

Question

I was looking for a way to read a whole file into a string. I found a few techniques on the internet, and decided to put two of them to the test, but the results were strange.

I'm using Visual Studio Community 2019 (Version 16.0.3) on a Windows 10 laptop. The length of the file "my_text.txt" is 2,235,259 characters and it's 2.183 MB in size.

Here is the complete code:

#include <chrono>
#include <fstream>
#include <iostream>
#include <string>

// first technique
void read_string_1(std::ifstream& fstr, std::string& result)
{
    fstr.seekg(0, std::ios::end);
    size_t length = fstr.tellg();
    fstr.seekg(0);
    result = std::string(length + 1, '\0');
    fstr.read(&result[0], length);
}

// second technique
void read_string_2(std::ifstream& fstr, std::string& result)
{
    result = std::string( (std::istreambuf_iterator<char>(fstr)), (std::istreambuf_iterator<char>()) );
}

int main()
{
    std::ifstream ifile{ "my_text.txt", std::ios_base::binary };
    if (!ifile)
        throw std::runtime_error("Error!");

    std::string content;

    for (int i = 0; i < 10; ++i)
    {
        std::chrono::high_resolution_clock::time_point p1 = std::chrono::high_resolution_clock::now();
        read_string_1(ifile, content);
        std::chrono::high_resolution_clock::time_point p2 = std::chrono::high_resolution_clock::now();
        auto duration1 = std::chrono::duration_cast<std::chrono::microseconds>(p2 - p1).count();
        std::cout << "M1:" << duration1 << std::endl;
    }

    for (int i = 0; i < 10; ++i)
    {
        std::chrono::high_resolution_clock::time_point p3 = std::chrono::high_resolution_clock::now();
        read_string_2(ifile, content);
        std::chrono::high_resolution_clock::time_point p4 = std::chrono::high_resolution_clock::now();
        auto duration2 = std::chrono::duration_cast<std::chrono::microseconds>(p4 - p3).count();
        std::cout << "M2:" << duration2 << std::endl;
    }

    return 0;
}

And here are the results:

Case 1: call read_string_1() first, then call read_string_2().

M1:7389
M1:8821
M1:6303
M1:6725
M1:5951
M1:8097
M1:5651
M1:6156
M1:6110
M1:5848
M2:827
M2:15
M2:15
M2:15
M2:14
M2:13
M2:14
M2:13
M2:14
M2:14

Case 2: call read_string_2() first, then read_string_1().

M1:940311
M1:352
M1:16
M1:13
M1:15
M1:15
M1:13
M1:13
M1:14
M1:14
M2:4668
M2:4761
M2:4881
M2:7446
M2:5050
M2:5572
M2:5255
M2:5108
M2:5234
M2:5072

Of course the results differ each time, but they follow a general pattern. As you can see, read_string_1() is pretty consistent, but the execution times of read_string_2() are puzzling. Why, in both cases, it gets faster with repeated execution? Why, in case 2, it takes so long to execute in the first run? What's happening in the background? Am I doing something wrong? And in the end, which function is faster, read_string_1() or read_string_2()?

Answer 1

Execution becomes faster because of caching.

With seeking, it takes time going through the file. So while some things are cached, the difference is not so big. With direct read, the file content itself can be cached. So reading it again is just a pointer to cached memory.

How long it takes on first try depends on what's in the cache and on the operation itself.