关于linux：在C ++中有效地读取非常大的文本文件


Efficiently reading a very large text file in C++

我有一个非常大的文本文件(45GB)。文本文件的每一行包含两个以空格分隔的64位无符号整数，如下所示。

4624996948753406865 102147150113130414417

4305027007407867230 45694063670518418

10817905656952544704 3697712211731468838……

我想读取文件并对数字执行一些操作。

C++中的我的代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
void process_data(string str)
{
    vector<string> arr;
    boost::split(arr, str, boost::is_any_of("
"));
    do_some_operation(arr);
}

int main()
{
    unsigned long long int read_bytes = 45 * 1024 *1024;
    const char* fname ="input.txt";
    ifstream fin(fname, ios::in);
    char* memblock;

    while(!fin.eof())
    {
        memblock = new char[read_bytes];
        fin.read(memblock, read_bytes);
        string str(memblock);
        process_data(str);
        delete [] memblock;
    }
    return 0;
}

我对C++是比较新的。当我运行此代码时，我将面临这些问题。

  • 由于以字节读取文件，有时块的最后一行对应于原始文件中的未完成行("462496948753406865 10214"而不是主文件的实际字符串"462496948753406865 102147115013130414417")。

  • 这个代码运行非常慢。在一个64bit Intel Core i7 920系统中运行一个块操作大约需要6sec的内存。有没有什么优化技术可以用来改进运行时？

  • 是否需要在boost split函数中包含"和空白字符？

    • 我已经阅读了关于MMAP文件的C++，但是我不确定它是否是正确的方法。如果是，请附加一些链接。

    相关讨论

    我会重新设计这个来扮演流媒体的角色，而不是在一个块上。

    更简单的方法是：

    1
    2
    std::ifstream ifs("input.txt");
    std::vector<uint64_t> parsed(std::istream_iterator<uint64_t>(ifs), {});

    如果您大致知道预期值的数量，那么使用前面的std::vector::reserve可以进一步加快速度。

    或者，您可以使用内存映射文件并迭代字符序列。

    • 如何快速解析C++中的空间分离浮点？显示了这些带有浮动基准的方法。

    更新i修改了上述程序，将uint32_t解析为向量。

    当使用4.5gib[1]的示例输入文件时，程序将在9秒内运行[2]：

    1
    2
    3
    4
    5
    6
    7
    sehe@desktop:/tmp$ make -B && sudo chrt -f 99 /usr/bin/time -f"%E elapsed, %c context switches" ./test smaller.txt
    g++ -std=c++0x -Wall -pedantic -g -O2 -march=native test.cpp -o test -lboost_system -lboost_iostreams -ltcmalloc
    parse success
    trailing unparsed: '
    '
    data.size():   402653184
    0:08.96 elapsed, 6 context switches

    当然，它至少分配402653184*4*字节=1.5千兆字节。所以什么时候如果您读取一个45 GB的文件，则需要估计的15 GiB RAM才能存储向量(假设在重新分配时没有碎片)：45gib分析10分钟45秒后完成：

    1
    2
    3
    4
    5
    6
    7
    8
    make && sudo chrt -f 99 /usr/bin/time -f"%E elapsed, %c context switches" ./test 45gib_uint32s.txt
    make: Nothing to be done for `all'.
    tcmalloc: large alloc 17570324480 bytes == 0x2cb6000 @  0x7ffe6b81dd9c 0x7ffe6b83dae9 0x401320 0x7ffe6af4cec5 0x40176f (nil)
    Parse success
    Trailing unparsed: 1 characters
    Data.size():   4026531840
    Time taken by parsing: 644.64s
    10:45.96 elapsed, 42 context switches

    相比之下，运行wc -l 45gib_uint32s.txt只需要大约12分钟(尽管没有实时优先级调度)。wc的速度非常快。

    用于基准的完整代码

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    #include <boost/spirit/include/qi.hpp>
    #include <boost/iostreams/device/mapped_file.hpp>
    #include <chrono>

    namespace qi = boost::spirit::qi;

    typedef std::vector<uint32_t> data_t;

    using hrclock = std::chrono::high_resolution_clock;

    int main(int argc, char** argv) {
        if (argc<2) return 255;
        data_t data;
        data.reserve(4392580288);   // for the  45 GiB file benchmark
        // data.reserve(402653284); // for the 4.5 GiB file benchmark

        boost::iostreams::mapped_file mmap(argv[1], boost::iostreams::mapped_file::readonly);
        auto f = mmap.const_data();
        auto l = f + mmap.size();

        using namespace qi;

        auto start_parse = hrclock::now();
        bool ok = phrase_parse(f,l,int_parser<uint32_t, 10>() % eol, blank, data);
        auto stop_time = hrclock::now();

        if (ok)  
            std::cout <<"Parse success
    "    ;
        else
            std::cerr <<"Parse failed at #" << std::distance(mmap.const_data(), f) <<" around '" << std::string(f,f+50) <<"'
    "    ;

        if (f!=l)
            std::cerr <<"Trailing unparsed:" << std::distance(f,l) <<" characters
    "    ;

        std::cout <<"Data.size():  " << data.size() <<"
    "    ;
        std::cout <<"Time taken by parsing:" << std::chrono::duration_cast<std::chrono::milliseconds>(stop_time-start_parse).count() / 1000.0 <<"s
    "    ;
    }

    [1]用od -t u4 /dev/urandom -A none -v -w4 | pv | dd bs=1M count=$((9*1024/2)) iflag=fullblock > smaller.txt生成

    [2]显然，这是在Linux上缓存在缓冲区缓存中的文件-大文件没有这样的好处

    相关讨论

    我只能猜测瓶颈在：

    1
    string str(memblock);

    -因为您在内存中分配了一个45MB长的段。

    您应该一行一行地读取文件，如下所述：

    • 逐行读取文件

    为了分析您的程序，您可以在每行之间打印clock()，如中所述：

    • 轻松测量经过的时间
    相关讨论

    在Linux上，使用C EDCOX1 5来代替C++流可能有助于性能(因为C++流是在EDCOX1，6，-s)之上构建的。您可以使用readline(3)或fgets(3)或fscanf(3)。您可以使用set buffer(3)等设置更大的缓冲区(例如64kbytes或256kbytes)。但我想您的(改进的)程序将是I/O绑定的，而不是CPU绑定的。然后你可以玩posix_fadvise(2)

    您可以考虑使用内存映射mmap(2)和madvise(2)(另请参见fopen(3)的m模式)。另见预读(2)

    最后，如果您的算法允许，您可以将文件分成更小的部分，并并行处理每个部分。

    您可以将文件内存映射到内存中，但这取决于平台(在Unix上，Windows CreateFileMapping/MapViewIntoFile上的mmap)；但是，如果在32位系统中，如果没有足够大的虚拟内存块，则可能会出现问题(64位系统不会出现该问题)。

    内存映射应该比从磁盘逐块读取数据更快。

    相关讨论