操作系统 / 系统课时
用实验观察 COW 增长轨迹
用实验观察 COW 增长轨迹
COW(Copy-on-Write)最容易被误解为“fork 会立刻复制一份内存”。本实验用匿名映射制造 64 MiB 已驻留页,再让子进程分阶段写入,并从 /proc/self/smaps 读取同一 VMA 的 Shared_Dirty、Private_Dirty 与 Pss,直接观察共享页如何逐步变成私有页。
学习目标
- 用一个可运行的
fork实验复现 COW 从共享到复制的变化。 - 能从
smaps的Pss、Shared_Dirty、Private_Dirty判断页面是否仍被父子进程共享。 - 能解释为什么 RSS 看起来几乎不变,但系统实际物理内存占用仍会随着写入增长。
实验要观察什么
父进程先把匿名映射逐页写入,使它真实分配物理页;随后 fork 只复制页表,父子进程仍指向同一批物理页。子进程每写一个仍共享的页,内核才为写入方建立私有副本,因此 COW 的关键不是“地址变了”,而是共享页数量下降、私有脏页数量上升。

RSS 统计“这个进程当前驻留了多少页”,同一物理页可以同时计入父进程和子进程的 RSS,所以把两个进程 RSS 相加会重复计算共享页。Pss 会按共享者数量分摊页面,更适合观察 fork 后的真实物理内存责任。
编写并运行观测程序
下面的完整程序申请 64 MiB 匿名私有映射,先由父进程全部写入,再通过两组管道同步父子进程。子进程依次写一半和全部页面;每个阶段都从包含该映射地址的 smaps VMA 中读取关键指标。
#define _GNU_SOURCE
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/mman.h>
#include <sys/wait.h>
#include <unistd.h>
#define REGION_SIZE (64UL * 1024 * 1024)
static void die(const char *msg) {
perror(msg);
exit(EXIT_FAILURE);
}
static void sync_write(int fd, char token) {
if (write(fd, &token, 1) != 1) {
die("write");
}
}
static void sync_read(int fd) {
char token;
if (read(fd, &token, 1) != 1) {
die("read");
}
}
static void report(const char *label, void *ptr) {
FILE *fp = fopen("/proc/self/smaps", "r");
if (fp == NULL) {
die("fopen smaps");
}
char line[512];
unsigned long start = 0, end = 0;
int in_target = 0;
long size = -1, rss = -1, pss = -1;
long shared_dirty = -1, private_dirty = -1;
while (fgets(line, sizeof line, fp) != NULL) {
if (sscanf(line, "%lx-%lx", &start, &end) == 2) {
if (in_target) {
break;
}
uintptr_t addr = (uintptr_t)ptr;
in_target = addr >= start && addr < end;
continue;
}
if (!in_target) {
continue;
}
sscanf(line, "Size: %ld kB", &size);
sscanf(line, "Rss: %ld kB", &rss);
sscanf(line, "Pss: %ld kB", &pss);
sscanf(line, "Shared_Dirty: %ld kB", &shared_dirty);
sscanf(line, "Private_Dirty: %ld kB", &private_dirty);
}
fclose(fp);
printf("%-31s pid=%ld Size=%ld Rss=%ld Pss=%ld Shared_Dirty=%ld Private_Dirty=%ld kB\n",
label, (long)getpid(), size, rss, pss, shared_dirty, private_dirty);
fflush(stdout);
}
int main(void) {
long page_size = sysconf(_SC_PAGESIZE);
if (page_size <= 0) {
die("sysconf");
}
unsigned char *region = mmap(NULL, REGION_SIZE,
PROT_READ | PROT_WRITE,
MAP_PRIVATE | MAP_ANONYMOUS,
-1, 0);
if (region == MAP_FAILED) {
die("mmap");
}
for (size_t off = 0; off < REGION_SIZE; off += (size_t)page_size) {
region[off] = 1;
}
report("parent-before-fork", region);
int parent_to_child[2];
int child_to_parent[2];
if (pipe(parent_to_child) != 0 || pipe(child_to_parent) != 0) {
die("pipe");
}
pid_t pid = fork();
if (pid < 0) {
die("fork");
}
if (pid == 0) {
close(parent_to_child[1]);
close(child_to_parent[0]);
report("child-after-fork", region);
sync_write(child_to_parent[1], 'R');
sync_read(parent_to_child[0]);
for (size_t off = 0; off < REGION_SIZE / 2; off += (size_t)page_size) {
region[off]++;
}
report("child-after-write-half", region);
sync_write(child_to_parent[1], 'H');
sync_read(parent_to_child[0]);
for (size_t off = REGION_SIZE / 2; off < REGION_SIZE; off += (size_t)page_size) {
region[off]++;
}
report("child-after-write-all", region);
sync_write(child_to_parent[1], 'A');
sync_read(parent_to_child[0]);
_exit(EXIT_SUCCESS);
}
close(parent_to_child[0]);
close(child_to_parent[1]);
sync_read(child_to_parent[0]);
report("parent-after-fork", region);
sync_write(parent_to_child[1], '1');
sync_read(child_to_parent[0]);
report("parent-after-child-write-half", region);
sync_write(parent_to_child[1], '2');
sync_read(child_to_parent[0]);
report("parent-after-child-write-all", region);
sync_write(parent_to_child[1], '3');
if (waitpid(pid, NULL, 0) < 0) {
die("waitpid");
}
munmap(region, REGION_SIZE);
return 0;
}预期结果(编译运行后)会出现 7 个阶段标签;数值会受页大小、内核版本和 VMA 合并影响,因此这里用占位符表示。
parent-before-fork pid=<PID> Size=<KB> Rss=<KB> Pss=<KB> Shared_Dirty=<SMALL_KB> Private_Dirty=<ABOUT_65536_KB> kB
child-after-fork pid=<PID> Size=<KB> Rss=<KB> Pss=<ABOUT_HALF_KB> Shared_Dirty=<ABOUT_65536_KB> Private_Dirty=<SMALL_KB> kB
parent-after-fork pid=<PID> Size=<KB> Rss=<KB> Pss=<ABOUT_HALF_KB> Shared_Dirty=<ABOUT_65536_KB> Private_Dirty=<SMALL_KB> kB
child-after-write-half pid=<PID> Size=<KB> Rss=<KB> Pss=<KB> Shared_Dirty=<ABOUT_32768_KB> Private_Dirty=<ABOUT_32768_KB> kB
parent-after-child-write-half pid=<PID> Size=<KB> Rss=<KB> Pss=<KB> Shared_Dirty=<ABOUT_32768_KB> Private_Dirty=<ABOUT_32768_KB> kB
child-after-write-all pid=<PID> Size=<KB> Rss=<KB> Pss=<KB> Shared_Dirty=<SMALL_KB> Private_Dirty=<ABOUT_65536_KB> kB
parent-after-child-write-all pid=<PID> Size=<KB> Rss=<KB> Pss=<KB> Shared_Dirty=<SMALL_KB> Private_Dirty=<ABOUT_65536_KB> kB把程序保存为 cow_trace.c,然后编译并运行:
cc -O0 -Wall -Wextra -std=c11 cow_trace.c -o cow_trace
./cow_trace预期输出仍是上面的 7 个阶段;如果命令成功结束,最后一行应是 parent-after-child-write-all,进程退出码为 0。
parent-after-child-write-all pid=<PID> Size=<KB> Rss=<KB> Pss=<KB> Shared_Dirty=<SMALL_KB> Private_Dirty=<ABOUT_65536_KB> kB怎么读增长轨迹
fork 之后,父子进程的 RSS 都可能接近 64 MiB,但这并不代表系统立即多用了 128 MiB:共享页同时出现在两个进程的 RSS 中,而 PSS 会把这些页按共享者分摊。此时应看到 Shared_Dirty 较高、Private_Dirty 较低。
子进程写前一半页面后,约一半共享页触发 COW。父进程没有写数据,但对应页面也从“双方共享”变成“父进程独占旧页”,所以父子双方的 Private_Dirty 都会上升。继续写完后一半,共享脏页趋近于零,两边都拥有各自的 64 MiB 私有副本。
结果不符合预期时
如果变化不是整齐的 32 MiB 和 64 MiB,先检查内核是否启用了透明大页、VMA 是否与相邻匿名区域合并,以及系统页大小是否为常见的 4 KiB。实验关心的是趋势:共享脏页持续下降、私有脏页持续上升,而单个进程 RSS 变化不大。
读取 /proc/<PID>/smaps 还可能受权限限制;应以目标进程同一用户运行实验,必要时检查系统的 ptrace 与 /proc 挂载限制。只要阶段变化方向一致,就已经验证了 COW 的核心行为:fork 先共享物理页,真正的额外物理内存成本在后续写入时逐页产生。