对比fwrite、mmap、DirectIO 的内存、性能开销,剖析 Page Cache

2024-01-09 20:14:37

背景

如上图所示:应用程序写文件有三种形式。

  1. fwrite : 应用程序 -> fwrite(Buffered IO) -> File System -> Page Cache -> Block IO Layer -> Device & Disk etc.
  2. mmap : 应用程序 -> mmap -> Page Cache ->?Block IO Layer -> Device & Disk etc.
  3. Direct IO :?应用程序 ->?Block IO Layer -> Device & Disk etc.

Direct IO优点:使用Direct I/O时,数据直接在应用程序和存储设备之间传输,绕过了操作系统的缓存机制。这样可以提高数据传输的效率

Direct IO缺点:其中一个限制是,Direct I/O要求数据缓冲区必须对齐到存储设备的块大小,否则会导致性能下降或者出现错误。

为了解决这个问题,通常需要使用一块内存作为中转缓冲区,将应用程序的数据先复制到中转缓冲区中,然后再使用Direct I/O将数据从中转缓冲区传输到存储设备。这样可以保证数据缓冲区对齐,并且可以避免在应用程序和存储设备之间频繁地复制数据。

这块中转缓冲区通常被称为“heap”,因为它是从堆内存中分配的。在使用Direct I/O时,heap的大小通常需要根据存储设备的块大小和应用程序的需求来确定。

测试用例

#include <iostream>
#include <fstream>
#include <chrono>
#include <cstring>
#include <sys/mman.h>
#include <fcntl.h>
#include <unistd.h>

using namespace std;

const int FILE_SIZE = 1024 * 1024 * 1024; // 1GB
const int BLOCK_SIZE = 4096; // 4KB

void test_fwrite() {
    ofstream ofs("test_fwrite.bin", ios::binary);
    char* buffer = new char[BLOCK_SIZE];
    auto start = chrono::high_resolution_clock::now();
    for (int i = 0; i < FILE_SIZE / BLOCK_SIZE; i++) {
        ofs.write(buffer, BLOCK_SIZE);
    }
    auto end = chrono::high_resolution_clock::now();
    cout << "fwrite time: " << chrono::duration_cast<chrono::milliseconds>(end - start).count() << "ms" << endl;
    delete[] buffer;
}

void test_mmap() {
    int fd = open("test_mmap.bin", O_RDWR | O_CREAT, 0666);
    ftruncate(fd, FILE_SIZE);
    char* buffer = (char*) mmap(NULL, FILE_SIZE, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
    auto start = chrono::high_resolution_clock::now();
    memset(buffer, 0, FILE_SIZE);
    auto end = chrono::high_resolution_clock::now();
    cout << "mmap time: " << chrono::duration_cast<chrono::milliseconds>(end - start).count() << "ms" << endl;
    munmap(buffer, FILE_SIZE);
    close(fd);
}

void test_directio() {
    int fd = open("test_directio.bin", O_RDWR | O_CREAT | O_DIRECT, 0666);
    char* buffer = new char[BLOCK_SIZE];
    char* heap_buffer = new char[FILE_SIZE];
    auto start = chrono::high_resolution_clock::now();
    for (int i = 0; i < FILE_SIZE / BLOCK_SIZE; i++) {
        write(fd, buffer, BLOCK_SIZE);
    }
    auto end = chrono::high_resolution_clock::now();
    cout << "directIO time: " << chrono::duration_cast<chrono::milliseconds>(end - start).count() << "ms" << endl;
    delete[] buffer;
    delete[] heap_buffer;
    close(fd);
}

int main() {

    test_fwrite();
    test_mmap();
    test_directio();
    
    return 0;
}
  1. 这个 demo 分别测试了 fwrite、mmap 和 DirectIO 的性能,其中 fwrite 和 mmap 都是直接写入文件,而 DirectIO 则需要使用 heap_buffer 作为内存中转。
  2. 在测试 DirectIO 时,我们使用了 O_DIRECT 标志来打开文件,这会禁用文件系统缓存,从而确保数据直接从内存写入磁盘。但是,由于 DirectIO 要求内存对齐,因此我们需要使用 heap_buffer 来确保内存对齐。这个 heap_buffer 的大小与文件大小相同。

运行这个 demo,我们可以得到以下输出:

wj@wj:~/WORK/Learning/Learning/DirectIO$ ./test.out 
fwrite time: 649ms
mmap time: 267ms
directIO time: 1191ms
wj@wj:~/WORK/Learning/Learning/DirectIO$

实验结论

从输出可以看出,mmap 的性能远远优于 fwrite,而 DirectIO 的性能比?fwrite 差一些。

这表明,mmap 可以映射文件到内存中,从而避免了数据的复制,因此性能更高。

而 DirectIO 需要使用 heap_buffer 作为内存中转,因此存在一定的内存开销,目前来看这个开销还是非常大的,不能忽略不计。

DirectIO的内存开销

DirectIO 的内存开销主要取决于两个因素:每个请求的大小和并发请求数量。由于 DirectIO 使用 heap_buffer 作为内存中转,因此每个请求都需要分配一定大小的内存。并且,由于 DirectIO 是异步的,因此在高并发情况下,可能会有大量的请求同时进行,从而导致内存开销增加。

具体来说,假设每个请求的大小为 `request_size`,并发请求数量为 `concurrency`,则 DirectIO 的内存开销可以估算为: ``` memory_overhead = request_size * concurrency ```

例如,如果每个请求的大小为 4KB,同时有 1000 个请求在进行,则 DirectIO 的内存开销大约为 4MB。

需要注意的是,这只是一个粗略的估算,实际的内存开销可能会受到其他因素的影响,例如操作系统的内存管理策略、硬件配置等。

实验demo

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

#define BUF_SIZE 4096

int main(int argc, char *argv[]) {
    int fd;
    char *buf;
    struct stat st;
    off_t offset = 0;
    ssize_t nread;

    if (argc != 2) {
        fprintf(stderr, "Usage: %s <file>\n", argv[0]);
        exit(EXIT_FAILURE);
    }

    //使用 `open` 函数打开一个文件,并指定 `O_DIRECT` 标志以启用 DirectIO
    fd = open(argv[1], O_RDONLY | O_DIRECT);
    if (fd == -1) {
        perror("open");
        exit(EXIT_FAILURE);
    }

    //使用 `fstat` 函数获取文件的信息,包括块大小
    if (fstat(fd, &st) == -1) {
        perror("fstat");
        exit(EXIT_FAILURE);
    }

    //使用 `aligned_alloc` 函数分配一个对齐到块大小的缓冲区
    buf = (char*)aligned_alloc(st.st_blksize, BUF_SIZE);
    if (buf == NULL) {
        perror("aligned_alloc");
        exit(EXIT_FAILURE);
    }

    //使用 `pread` 函数读取文件,并在读取过程中计算内存开销
    while ((nread = pread(fd, buf, BUF_SIZE, offset)) > 0) {
        offset += nread;
    }

    if (nread == -1) {
        perror("pread");
        exit(EXIT_FAILURE);
    }

    printf("offset : %ld\n",offset);

    free(buf);
    close(fd);

    return 0;
}

wj@wj:~/WORK/Learning/Learning/DirectIO$ g++ directIO.cpp -o directIO.out
wj@wj:~/WORK/Learning/Learning/DirectIO$ ./directIO.out test_mmap.bin
offset : 1073741824
wj@wj:~/WORK/Learning/Learning/DirectIO$ 

注意,该程序只是一个简单的示例,实际的内存开销可能会更复杂,需要根据具体情况进行测试和分析。

fwrite?和?mmap 都需要经过 Page Cache,再到 Block IO Layer,那么Linux系统为什么要这样设计呢?

什么是Page Cache?

思考一个问题:Page Cache 到底是属于内核空间还是属于用户空间呢?

参考:如何用数据观测Page Cache?_如何查看page cache-CSDN博客

文章来源:https://blog.csdn.net/weixin_42136255/article/details/135476984
本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。