操作系统 / 系统课时

用实验观察 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 的关键不是“地址变了”,而是共享页数量下降、私有脏页数量上升。

COW 分阶段增长轨迹

RSS 统计“这个进程当前驻留了多少页”,同一物理页可以同时计入父进程和子进程的 RSS,所以把两个进程 RSS 相加会重复计算共享页。Pss 会按共享者数量分摊页面,更适合观察 fork 后的真实物理内存责任。

编写并运行观测程序

下面的完整程序申请 64 MiB 匿名私有映射,先由父进程全部写入,再通过两组管道同步父子进程。子进程依次写一半和全部页面;每个阶段都从包含该映射地址的 smaps VMA 中读取关键指标。

c
#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 合并影响,因此这里用占位符表示。

text
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,然后编译并运行:

bash
cc -O0 -Wall -Wextra -std=c11 cow_trace.c -o cow_trace
./cow_trace

预期输出仍是上面的 7 个阶段;如果命令成功结束,最后一行应是 parent-after-child-write-all,进程退出码为 0。

text
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 先共享物理页,真正的额外物理内存成本在后续写入时逐页产生。

按自己的节奏,确认真正理解。

目录与阅读设置

阅读设置

17

记录一个想法

用实验观察 COW 增长轨迹

0 / 10000 · 笔记保存到账号。未提交的修改会在关闭、离开或刷新后丢失。

登录哪都通