7

我有一个 ASCII 文件，其中每一行都包含可变长度的记录。例如

Record-1:15 characters
Record-2:200 characters
Record-3:500 characters
...
...
Record-n: X characters

由于文件大小约为 10GB，我想分块读取记录。一旦读取，我需要转换它们，将它们以二进制格式写入另一个文件。

所以，为了阅读，我的第一反应是创建一个 char 数组，例如

FILE *stream; 
char buffer[104857600]; //100 MB char array
fread(buffer, sizeof(buffer), 104857600, stream);
  1. 假设 linux 将发出一个系统调用并获取整个 100MB 是否正确？
  2. 由于记录由换行符分隔，因此我在缓冲区中逐个字符地搜索换行符并重建每个记录。

我的问题是，这是我应该如何分块读取，还是有更好的替代方法来分块读取数据并重构每条记录？是否有另一种方法可以在一次调用中从 ASCII 文件中读取 x 条可变大小的行？

接下来在写入期间，我也会这样做。我有一个写入字符缓冲区，我将其传递给 fwrite 以在一次调用中写入一整套记录。

fwrite(buffer, sizeof(buffer), 104857600, stream);

更新：如果我 setbuf（流，缓冲区），其中缓冲区是我的 100MB 字符缓冲区，fgets 会从缓冲区返回还是导致磁盘 IO？

4

3 回答 3

6

  1. 是的，fread将立即获取整个内容。（假设它是一个普通文件。）但它不会读取 105 MB，除非文件本身是 105 MB，如果你不检查返回值，你就无法知道实际读取了多少数据，或者是否有是一个错误。

  2. 使用fgets（见man fgets）代替fread。这将为您搜索换行符。

    char linebuf[1000];
FILE *file = ...;
while (fgets(linebuf, sizeof(linebuf), file) {
    // decode one line
}

  3. 你的代码有问题。

    char buffer[104857600]; // too big

    如果您尝试在堆栈上分配一个大缓冲区（105 MB 肯定很大），那么它将失败并且您的程序将崩溃。如果你需要一个那么大的缓冲区，你将不得不在堆上分配它malloc或类似的。我当然会将单个函数的堆栈使用量最多保持在几十 KB，尽管在大多数股票 Linux 系统上你可能会使用几 MB。

作为替代方案，您可以只mmap将整个文件放入内存。在大多数情况下，这不会提高或降低性能，但更容易使用。

int r, fdes;
struct stat st;
void *ptr;
size_t sz;

fdes = open(filename, O_RDONLY);
if (fdes < 0) abort();
r = fstat(fdes, &st);
if (r) abort();
if (st.st_size > (size_t) -1) abort(); // too big to map
sz = st.st_size;
ptr = mmap(NULL, sz, PROT_READ, MAP_SHARED, fdes, 0);
if (ptr == MAP_FAILED) abort();
close(fdes); // file no longer needed

// now, ptr has the data, sz has the data length
// you can use ordinary string functions

使用的好处mmap是你的程序不会耗尽内存。在 64 位系统上，您可以将整个文件同时放入您的地址空间（即使是 10 GB 的文件），系统会在您的程序访问内存时自动读取新的块。旧的块将被自动丢弃，并在您的程序再次需要它们时重新读取。

这是浏览大文件的好方法。

于 2012-05-10T03:53:09.360 回答
2

如果可以，您可能会发现mmaping 文件将是最简单的。mmap将文件的（一部分）映射到内存中，因此整个文件基本上可以作为字节数组进行访问。在您的情况下，您可能无法一次映射整个文件，它看起来像：

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


/* ... */

struct stat stat_buf;
long pagesz = sysconf(_SC_PAGESIZE);
int fd = fileno(stream);
off_t line_start = 0;
char *file_chunk = NULL;
char *input_line;
off_t cur_off = 0;
off_t map_offset = 0;
/* map 16M plus pagesize to ensure any record <= 16M will always fit in the mapped area */
size_t map_size = 16*1024*1024+pagesz;
if (map_offset + map_size > stat_buf.st_size) {
  map_size = stat_buf.st_size - map_offset;
}
fstat(fd, &stat_buf);
/* map the first chunk of the file */
file_chunk = mmap(NULL, map_size, PROT_READ, MAP_SHARED, fd, map_offset);
// until we reach the end of the file
while (cur_off < stat_buf.st_size) {
  /* check if we're about to read outside the current chunk */
  if (!(cur_off-map_offset < map_size)) {
    // destroy the previous mapping
    munmap(file_chunk, map_size);
    // round down to the page before line_start
    map_offset = (line_start/pagesz)*pagesz;
    // limit mapped region to size of file
    if (map_offset + map_size > stat_buf.st_size) {
      map_size = stat_buf.st_size - map_offset;
    }
    // map the next chunk
    file_chunk = mmap(NULL, map_size, PROT_READ, MAP_SHARED, fd, map_offset);
    // adjust the line start for the new mapping
    input_line = &file_chunk[line_start-map_offset];
  }
  if (file_chunk[cur_off-map_offset] == '\n') {
    // found a new line, process the current line
    process_line(input_line, cur_off-line_start);
    // set up for the next one
    line_start = cur_off+1;
    input_line = &file_chunk[line_start-map_offset];
  }
  cur_off++;
}

最复杂的是避免制作太大的映射。您也许可以使用映射整个文件

char *file_data = mmap(NULL, stat_buf.st_size, PROT_READ, MAP_SHARED, fd, 0);
于 2012-05-10T04:38:16.697 回答
0

我的意见是fgets(buff)用于自动检测新行。

然后strlen(buff)用于计算缓冲区大小，

if( (total+strlen(buff)) > 104857600 )

然后写入新块..

但是块的大小几乎不会是 104857600 字节。

CMIIW

于 2012-05-10T03:53:41.120 回答