Linux服务器下C++高效实现1.2TB大文件反转拼接方案问询

我有一个工具生成了10个总大小约1.2TB的大文件，每个文件均为序列化的size_t值向量。该工具需要将所有文件的内容反转后，拼接成一个超级大文件ct_file。我已通过半外部模式实现该功能，但因输入数据量过大导致操作系统缓存不堪重负，运行速度极慢。

以下是我的C++实现代码（简化版）：

size_t BUFFER_SIZE = 1024*1024*8/sizeof(size_t); //8MB for the buffer
size_t buffer[BUFF_SIZE]={0};

std::ofstream res(ct_file, std::ios::out | std::binary);

for(size_t i=0; i<10;i++){
    std::string file = list_of_files[i]; 
    std::ifstream tmp_i_file(file, std::ifstream::binary);

    tmp_i_file.seekg(0, std::ifstream::end);
    len = tmp_i_file.tellg()/sizeof(size_t); // number of size_t values in the current file
    tmp_i_file.seekg (0, std::ifstream::beg);

    if(len>0){
        rem=len;
        to_read = std::min<size_t>(BUFF_SIZE, len);

        while(true){//read the data in the file from right to left
            tmp_i_file.seekg( (rem - to_read) * sizeof(size_t));
            tmp_i_file.read((char *)buffer, sizeof(size_t)*to_read);
            assert(tmp_i_file.good());

            //invert data
            start =0;end=to_read-1;
            while(start<end){
                std::swap(buffer[start++], buffer[end--]);
            }

            res.write((char *)buffer, sizeof(size_t)*to_read);
            assert(res.good());

            rem -= tmp_i_file.gcount()/sizeof(size_t);
            to_read = std::min<size_t>(BUFF_SIZE, rem);
            if(to_read == 0) break;
        }
        tmp_i_file.close();
    }
}

上述代码可实现需求，但在处理海量数据时速度极慢，在配备700GB内存的机器上会完全填满页缓存甚至交换空间。我了解可使用内存映射文件（mmap）或O_DIRECT来优化性能，但网上对此存在诸多争议：若访问模式为顺序型，mmap无法提升性能；O_DIRECT也无法保证一定加速。由于我的代码访问模式近乎顺序（输入文件反向读取，输出文件顺序写入），因此对使用这些方案存在疑虑。现询问：2023年在Linux服务器上处理TB级输入时，该如何高效实现此任务？

针对Linux服务器上TB级数据的反向拼接需求，以下是几个经过验证的优化方向：

1. 用O_DIRECT绕过系统缓存，避免页缓存污染 #

你的核心问题是大量文件读取填满系统页缓存，导致后续IO请求变慢甚至触发交换。O_DIRECT可以直接绕过页缓存，让应用程序直接与磁盘设备交互，避免占用宝贵的内存资源。

实现要点： #

• 替换C++标准库fstream为POSIX的open/read/write接口，标准库默认不支持O_DIRECT，部分编译器扩展兼容性差。
• 满足O_DIRECT的对齐要求：缓冲区地址、读写大小、文件偏移量必须是磁盘扇区大小的整数倍（通常是512字节或4KB）。你的8MB缓冲区刚好是4KB的整数倍，只需确保文件偏移量计算正确。
• 读取逻辑保持反向顺序，每次读取指定数量的size_t，反转缓冲区后写入输出文件。

示例片段：

int out_fd = open(ct_file.c_str(), O_WRONLY | O_CREAT | O_TRUNC | O_DIRECT, 0644);
assert(out_fd != -1);

for(size_t i=0; i<10;i++){
    const std::string& file = list_of_files[i];
    int in_fd = open(file.c_str(), O_RDONLY | O_DIRECT, 0644);
    assert(in_fd != -1);

    off_t file_size = lseek(in_fd, 0, SEEK_END);
    size_t len = file_size / sizeof(size_t);
    if(len == 0){
        close(in_fd);
        continue;
    }

    size_t rem = len;
    size_t to_read = std::min<size_t>(BUFFER_SIZE, len);
    // 用posix_memalign确保缓冲区对齐
    size_t* buffer;
    int ret = posix_memalign((void**)&buffer, 4096, sizeof(size_t)*BUFFER_SIZE);
    assert(ret == 0);

    while(rem > 0){
        off_t offset = (rem - to_read) * sizeof(size_t);
        lseek(in_fd, offset, SEEK_SET);
        ssize_t bytes_read = read(in_fd, buffer, sizeof(size_t)*to_read);
        assert(bytes_read == sizeof(size_t)*to_read);

        // 反转缓冲区
        size_t start = 0, end = to_read - 1;
        while(start < end){
            std::swap(buffer[start++], buffer[end--]);
        }

        ssize_t bytes_written = write(out_fd, buffer, sizeof(size_t)*to_read);
        assert(bytes_written == sizeof(size_t)*to_read);

        rem -= to_read;
        to_read = std::min<size_t>(BUFFER_SIZE, rem);
    }

    free(buffer);
    close(in_fd);
}
close(out_fd);

2. 利用mmap减少系统调用，配合MADV_DONTNEED避免缓存污染 #

虽然mmap在顺序读取时优势不明显，但反向读取时可以避免频繁的seek操作，直接通过指针访问内存映射区域，减少系统调用开销。同时用madvise告诉内核不要缓存已读取的页面，避免占用内存。

实现要点： #

• 将每个输入文件映射到内存，从映射区域末尾开始，每次取BUFFER_SIZE个size_t拷贝到缓冲区，反转后写入输出文件。
• 使用madvise(mapped, file_size, MADV_DONTNEED)让内核释放已处理的页面，避免页缓存堆积。
• 输出文件可选择O_DIRECT或标准库接口，避免写入数据占用缓存。

示例片段：

std::ofstream res(ct_file, std::ios::out | std::binary);
assert(res.is_open());

for(size_t i=0; i<10;i++){
    const std::string& file = list_of_files[i];
    int fd = open(file.c_str(), O_RDONLY);
    assert(fd != -1);

    off_t file_size = lseek(fd, 0, SEEK_END);
    size_t len = file_size / sizeof(size_t);
    if(len == 0){
        close(fd);
        continue;
    }

    size_t* mapped = (size_t*)mmap(nullptr, file_size, PROT_READ, MAP_PRIVATE, fd, 0);
    assert(mapped != MAP_FAILED);

    // 告诉内核不需要缓存这些页面
    madvise(mapped, file_size, MADV_DONTNEED);

    size_t rem = len;
    size_t to_read = std::min<size_t>(BUFFER_SIZE, len);
    size_t* buffer = new size_t[BUFFER_SIZE];

    while(rem > 0){
        size_t start_idx = rem - to_read;
        memcpy(buffer, mapped + start_idx, sizeof(size_t)*to_read);

        // 反转缓冲区
        size_t s = 0, e = to_read -1;
        while(s < e){
            std::swap(buffer[s++], buffer[e--]);
        }

        res.write((char*)buffer, sizeof(size_t)*to_read);
        assert(res.good());

        rem -= to_read;
        to_read = std::min<size_t>(BUFFER_SIZE, rem);
    }

    delete[] buffer;
    munmap(mapped, file_size);
    close(fd);
}
res.close();

3. 并行化处理提升吞吐量 #

如果服务器有多核CPU和多磁盘，可以并行处理多个输入文件：

• 使用线程池，每个线程负责一个文件的反向读取和预处理。
• 确保输出顺序：要么协调线程按原文件顺序写入最终文件，要么每个线程先将处理后的数据写入临时文件，最后按顺序合并临时文件。
• 并行场景下O_DIRECT优势更突出，不会因多线程IO操作导致页缓存竞争。

4. 其他优化细节 #

• 调整缓冲区大小：8MB缓冲区偏小，建议改为64MB或128MB（根据磁盘IO性能调整，过大缓冲区会增加内存占用）。
• 禁用交换分区：700GB内存足够处理1.2TB数据，临时关闭交换可避免交换导致的性能骤降：sudo swapoff -a。
• 使用原生IO接口：避免C++标准库fstream的额外缓存，减少页缓存和用户缓存的双重占用。
• 优化磁盘调度器：将磁盘调度器设置为deadline或noop，适合顺序IO场景：echo deadline | sudo tee /sys/block/sdX/queue/scheduler（替换sdX为目标磁盘）。

内容的提问来源于stack exchange，提问作者AAA