Question

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

4624996948753406865 10214715013130414417

4305027007407867230 4569406367070518418

10817905656952544704 3697712211731468838 ... ...

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

我在C ++中的代码：

void process_data(string str)
{
    vector<string> arr;
    boost::split(arr, str, boost::is_any_of(" \n"));
    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 ++比较陌生。当我运行此代码时，我遇到了这些问题。

由于以字节为单位读取文件，有时块的最后一行对应于原始文件中未完成的行（＆＃34; 4624996948753406865 10214＆＃34;而不是实际的字符串＆＃34; 4624996948753406865 10214715013130414417＆＃34;主文件。）
此代码运行速度非常慢。在具有6GB RAM的64位Intel Core i7 920系统中运行一个块操作需要大约6秒。是否有任何可用于改善运行时的优化技术？
是否有必要包括＆＃34; \ n＆＃34;以及提升分割功能中的空白字符？

我已经阅读了有关C ++中mmap文件的内容，但我不确定它是否是正确的方法。如果是，请附上一些链接。

Answer 1

我重新设计了这个来进行流式传输，而不是阻止。

更简单的方法是：

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

如果您大致了解预期的值，预先使用std::vector::reserve可以进一步加快速度。

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

How to parse space-separated floats in C++ quickly? 显示了这些方法，其中包含浮点数的基准。

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

当使用4.5GiB ^[1]的样本输入文件时，程序将在9秒内运行^[2]：

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 * byte = 1.5 gibibytes。所以当你读了一个45 GB的文件，你需要一个估计15GiB的RAM来存储向量（假设在重新分配时没有碎片）： 45GiB解析在10分45秒内完成：

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 非常快

用于基准测试的完整代码

#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\n";
    else 
        std::cerr << "Parse failed at #" << std::distance(mmap.const_data(), f) << " around '" << std::string(f,f+50) << "'\n";

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

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

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

^[1]

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

Answer 2

我只能猜测瓶颈在于：

string str(memblock);

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

您应该逐行阅读文件，如下所述：

的 Read file line by line

为了对程序进行概要分析，您可以在每行之间打印clock（），如下所述：

的 Easily measure elapsed time

Answer 3

你可以将文件内存映射到内存中，但这将取决于平台（在unix上将是mmap on windows CreateFileMapping / MapViewIntoFile）;如果在32位系统中，如果没有足够大的虚拟内存块（64位系统不会出现这个问题），你可能会遇到问题。

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

Answer 4

在Linux上，使用C <stdio.h>而不是C ++流可能有助于提高性能（因为C ++流构建在FILE - s之上）。您可以使用readline(3)或fgets(3)或fscanf(3)。您可以使用setbuffer(3)等设置更大的缓冲区（例如64K字节或256K字节）...但我猜您的（改进的）程序将受I / O限制，而不受CPU限制。然后你可以玩posix_fadvise(2)

您可以考虑使用内存映射mmap(2)＆amp; madvise(2)（另请参阅fopen(3)的m模式）。另请参阅readahead(2)

最后，如果您的算法允许，您可以csplit较小的文件中的文件，并在并行过程中处理每个文件。

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

我在C ++中的代码：

4 个答案:

用于基准测试的完整代码