IT-Swarm.Net

用c ++快速读取文本文件

我目前正在用c ++编写一个程序,其中包括阅读大量的大文本文件。每行有~400.000行,极端情况下每行有4000或更多字符。仅供测试,我使用ifstream和cplusplus.com提供的实现读取其中一个文件。花了大约60秒,这太长了。现在我想知道,有没有一种直接的方法来提高阅读速度?

编辑:我使用的代码或多或少是这样的:

string tmpString;
ifstream txtFile(path);
if(txtFile.is_open())
{
    while(txtFile.good())
    {
        m_numLines++;
        getline(txtFile, tmpString);
    }
    txtFile.close();
}

编辑2:我读的文件只有82 MB大。我主要说它可以达到4000,因为我认为可能有必要知道为了做缓冲。.

编辑3:谢谢大家的答案,但考虑到我的问题似乎没有太大的改进空间。我必须使用readline,因为我想计算行数。将ifstream实例化为二进制文件也不会使读取速度更快。我将尝试尽可能地并行化它,至少应该起作用。.

编辑4:显然我可以做一些事情。非常感谢你花了这么多时间,我非常感激! =)

54
Arne

更新: 请务必检查初始答案下面的(令人惊讶的)更新


内存映射文件很好用1

#include <boost/iostreams/device/mapped_file.hpp> // for mmap
#include <algorithm>  // for std::find
#include <iostream>   // for std::cout
#include <cstring>

int main()
{
    boost::iostreams::mapped_file mmap("input.txt", boost::iostreams::mapped_file::readonly);
    auto f = mmap.const_data();
    auto l = f + mmap.size();

    uintmax_t m_numLines = 0;
    while (f && f!=l)
        if ((f = static_cast<const char*>(memchr(f, '\n', l-f))))
            m_numLines++, f++;

    std::cout << "m_numLines = " << m_numLines << "\n";
}

这应该很快。.

更新

如果它可以帮助你测试这种方法,这里是一个版本直接使用mmap而不是使用Boost: 在Coliru上看它

#include <algorithm>
#include <iostream>
#include <cstring>

// for mmap:
#include <sys/mman.h>
#include <sys/stat.h>
#include <fcntl.h>

const char* map_file(const char* fname, size_t& length);

int main()
{
    size_t length;
    auto f = map_file("test.cpp", length);
    auto l = f + length;

    uintmax_t m_numLines = 0;
    while (f && f!=l)
        if ((f = static_cast<const char*>(memchr(f, '\n', l-f))))
            m_numLines++, f++;

    std::cout << "m_numLines = " << m_numLines << "\n";
}

void handle_error(const char* msg) {
    perror(msg); 
    exit(255);
}

const char* map_file(const char* fname, size_t& length)
{
    int fd = open(fname, O_RDONLY);
    if (fd == -1)
        handle_error("open");

    // obtain file size
    struct stat sb;
    if (fstat(fd, &sb) == -1)
        handle_error("fstat");

    length = sb.st_size;

    const char* addr = static_cast<const char*>(mmap(NULL, length, PROT_READ, MAP_PRIVATE, fd, 0u));
    if (addr == MAP_FAILED)
        handle_error("mmap");

    // TODO close fd at some point in time, call munmap(...)
    return addr;
}

更新

我可以通过查看GNU coreutils wc的来源找到最后一点性能。令我惊讶的是使用以下(大大简化的)代码改编自wc在大约84%的时间内运行采用上面的内存映射文件:

static uintmax_t wc(char const *fname)
{
    static const auto BUFFER_SIZE = 16*1024;
    int fd = open(fname, O_RDONLY);
    if(fd == -1)
        handle_error("open");

    /* Advise the kernel of our access pattern.  */
    posix_fadvise(fd, 0, 0, 1);  // FDADVICE_SEQUENTIAL

    char buf[BUFFER_SIZE + 1];
    uintmax_t lines = 0;

    while(size_t bytes_read = read(fd, buf, BUFFER_SIZE))
    {
        if(bytes_read == (size_t)-1)
            handle_error("read failed");
        if (!bytes_read)
            break;

        for(char *p = buf; (p = (char*) memchr(p, '\n', (buf + bytes_read) - p)); ++p)
            ++lines;
    }

    return lines;
}

1 见例如这里的基准: 如何快速解析C++中空格分隔的浮点数?

68
sehe

快速,可靠且价格合理的云托管

注册并在30天内获得$50奖金!

4000 * 400,000 = 1.6 GB如果您的硬盘驱动器不是SSD,您可能会获得~100 MB/s的顺序读取。这只是I/O中的16秒。.

既然你没有详细说明你使用的特定代码或者你需要如何解析这些文件(你需要逐行读取它,系统有很多RAM你能读完整个吗?将文件放入一个大的RAM缓冲区,然后解析它?)你几乎无法加速这个过程。.

在按顺序读取文件时,内存映射文件不会提供任何性能改进。也许手动解析新行的大块而不是使用“getline”将提供改进。.

_ edit _ 做了一些学习(谢谢@sehe)。这是我可能会使用的内存映射解决方案。.

#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/mman.h>
#include <sys/stat.h>
#include <errno.h>

int main() {
    char* fName = "big.txt";
    //
    struct stat sb;
    long cntr = 0;
    int fd, lineLen;
    char *data;
    char *line;
    // map the file
    fd = open(fName, O_RDONLY);
    fstat(fd, &sb);
    //// int pageSize;
    //// pageSize = getpagesize();
    //// data = mmap((caddr_t)0, pageSize, PROT_READ, MAP_PRIVATE, fd, pageSize);
    data = mmap((caddr_t)0, sb.st_size, PROT_READ, MAP_PRIVATE, fd, 0);
    line = data;
    // get lines
    while(cntr < sb.st_size) {
        lineLen = 0;
        line = data;
        // find the next line
        while(*data != '\n' && cntr < sb.st_size) {
            data++;
            cntr++;
            lineLen++;
        }
        /***** PROCESS LINE *****/
        // ... processLine(line, lineLen);
    }
    return 0;
}
9
Louis Ricci

Neil Kirk,遗憾的是我无法回复你的评论(信誉不足),但我对ifstream进行了性能测试,并且逐行读取文本文件的性能完全相同。.

std::stringstream stream;
std::string line;
while(std::getline(stream, line)) {
}

在106MB文件上需要1426ms。.

std::ifstream stream;
std::string line;
while(ifstream.good()) {
    getline(stream, line);
}

这在同一个文件上需要1433ms。.

以下代码更快:

const int MAX_LENGTH = 524288;
char* line = new char[MAX_LENGTH];
while (iStream.getline(line, MAX_LENGTH) && strlen(line) > 0) {
}

这在同一个文件上需要884ms。这只是有点棘手,因为您必须设置缓冲区的最大大小(即输入文件中每行的最大长度)。.

3
user2434119

你必须同时阅读所有文件吗? (例如,在您的申请开始时)

如果这样做,请考虑并行化操作。.

无论哪种方式,考虑使用二进制流,或者对于数据块使用unbffered read 。.

2
utnapistim

使用Random file access或使用binary mode。顺序,这很大但仍取决于你正在阅读什么。.

1
Shumail Mohyuddin

作为竞争性编程背景的人,我可以告诉你:至少对于像整数解析这样的简单事情,C中的主要成本是锁定文件流(默认情况下是为多线程完成的)。请改用unlocked_stdio版本(fgetc_unlocked()fread_unlocked())。对于C++,常见的知识是使用std::ios::sync_with_stdio(false)但我不知道它是否与unlocked_stdio一样快。.

这里参考我的标准整数解析代码。这是一个 很多 比scanf更快,正如我所说,主要是因为没有锁定流。对我而言,它与我之前使用的最好的手工编码mmap或自定义缓冲版本一样快,没有疯狂的维护债务。.

int readint(void)
{
        int n, c;
        n = getchar_unlocked() - '0';
        while ((c = getchar_unlocked()) > ' ')
                n = 10*n + c-'0';
        return n;
}

(注意:只有在任意两个整数之间只有一个非数字字符时才能使用此选项)。.

如果可能的话,当然要避免内存分配......

1
Jo So