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

背景

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

fwrite : 应用程序 -> fwrite(Buffered IO) -> File System -> Page Cache -> Block IO Layer -> Device & Disk etc.
mmap : 应用程序 -> mmap -> Page Cache -> Block IO Layer -> Device & Disk etc.
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; // 4KBvoid 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;
}

这个 demo 分别测试了 fwrite、mmap 和 DirectIO 的性能，其中 fwrite 和 mmap 都是直接写入文件，而 DirectIO 则需要使用 heap_buffer 作为内存中转。
在测试 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 4096int 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` 标志以启用 DirectIOfd = 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系统为什么要这样设计呢？