// 简单但有问题的方案
int simpleSave() {
    // 遍历所有数据并写入磁盘
    foreach(key in database) {
        writeKeyToDisk(key, value);
    }
    fsync();  // 强制刷新到磁盘
}

// 看似可行但仍有问题的方案
void asyncSave() {
    // 在后台线程中保存数据
    pthread_create(&thread, NULL, saveInBackground, database);
}

int rdbSaveBackground() {
    pid_t childpid;
    
    if ((childpid = fork()) == 0) {
        // 子进程：专门负责持久化
        // 看到的是 fork 时刻的数据快照
        rdbSave("dump.rdb");
        exit(0);
    } else {
        // 父进程：继续处理客户端请求
        // 不会被持久化操作阻塞
        return REDIS_OK;
    }
}

父进程虚拟内存空间 ←→ 共享物理内存页面 ←→ 子进程虚拟内存空间
        (2GB 视图)           (2GB 实际)          (2GB 视图)

// 假设父进程修改了一个 key
redis_set("user:1001", "updated_value");

父进程新页面 ←→ 新复制的页面 (4KB)
子进程原页面 ←→ 原始共享页面 (4KB)
其他未修改的页面仍然共享

void sendChildInfoGeneric(childInfoType info_type, size_t keys, double progress, char *pname) {
    // 获取当前 COW 使用量
    cow = zmalloc_get_private_dirty(-1);
    
    // 记录监控日志
    serverLog(LL_VERBOSE, "Fork CoW for %s: current %zu MB, peak %zu MB",
              pname, cow>>20, peak_cow>>20);
}

// Redis 数据结构示例
typedef struct zset {
    dict *dict;          // Hash 表：随机分布
    zskiplist *zsl;      // Skip List：节点分散
} zset;

typedef struct zskiplistNode {
    sds ele;                    // 字符串：可能在不同页面
    struct zskiplistNode *backward;  // 指针：指向其他页面
    struct zskiplistLevel {
        struct zskiplistNode *forward;  // 更多跨页面引用
    } level[];
} zskiplistNode;

修改 key1 → 触发 COW → 复制 4KB 页面 → 内存增加 4KB
修改 key2 → 触发 COW → 复制 4KB 页面 → 内存增加 4KB
...
修改 1000 个分散的 key → 约 500 个不同页面 → 总增加 ~2MB

修改 key1 → 触发 COW → 复制 2MB 页面 → 内存增加 2MB
修改 key2 → 触发 COW → 复制 2MB 页面 → 内存增加 2MB
...
修改 1000 个分散的 key → 约 800 个不同大页面 → 总增加 ~1.6GB

// 一个 Hash 操作可能涉及多个页面
HSET user:1001 name "Alice"

int rdbSaveBackground(int req, char *filename, rdbSaveInfo *rsi, int rdbflags) {
    pid_t childpid;
    
    if (hasActiveChildProcess()) return C_ERR;  // 确保只有一个子进程
    
    if ((childpid = redisFork(CHILD_TYPE_RDB)) == 0) {
        // 子进程执行 RDB 保存
        redisSetProcTitle("redis-rdb-bgsave");
        retval = rdbSave(req, filename, rsi, rdbflags);
        exitFromChild((retval == C_OK) ? 0 : 1, 0);
    }
    // 父进程继续处理客户端请求
    return C_OK;
}

int rewriteAppendOnlyFileBackground(void) {
    if (hasActiveChildProcess()) return C_ERR;  // 同样确保单子进程
    
    if ((childpid = redisFork(CHILD_TYPE_AOF)) == 0) {
        // 子进程重写 AOF
        redisSetProcTitle("redis-aof-rewrite");
        rewriteAppendOnlyFile(tmpfile);
        exitFromChild(0, 0);
    }
    return C_OK;
}

// 每次 COW 需要：
1. 分配 2MB 连续物理内存
2. 复制 2MB 数据
3. 更新页表映射
4. 刷新 TLB 缓存

// 在持久化过程中，这个函数会被频繁调用
sendChildInfoGeneric(CHILD_INFO_TYPE_CURRENT_INFO, keys, progress, "RDB") {

    // ....
    /* When called to report current info, we need to throttle down CoW updates as they
 * can be very expensive. To do that, we measure the time it takes to get a reading
 * and schedule the next reading to happen not before time*CHILD_COW_COST_FACTOR
 * passes. */
    cow = zmalloc_get_private_dirty(-1);
    // ....
}

size_t zmalloc_get_private_dirty(long pid) {
    FILE *fp = fopen("/proc/self/smaps", "r");  // 系统调用
    while(fgets(line, sizeof(line), fp) != NULL) {  // 逐行解析
        if (strncmp(line, "Private_Dirty:", 14) == 0) {
            // THP 环境下，smaps 文件更大更复杂
        }
    }
    fclose(fp);
}

#define CHILD_COW_DUTY_CYCLE 100

// 如果上次检测耗时 1ms，下次至少等待 100ms
if (now - cow_updated > cow_update_cost * CHILD_COW_DUTY_CYCLE) {
    // 这说明 COW 检测本身开销很大
}

// 每次 COW 检测涉及的系统调用：
open("/proc/self/smaps", O_RDONLY)  // 系统调用 1
read(fd, buffer, size)              // 系统调用 2 (多次)
close(fd)                           // 系统调用 3

# 临时禁用
echo never > /sys/kernel/mm/transparent_hugepage/enabled

# 永久禁用（添加到 /etc/rc.local 或系统启动脚本）
echo 'echo never > /sys/kernel/mm/transparent_hugepage/enabled' >> /etc/rc.local

cat /sys/kernel/mm/transparent_hugepage/enabled
# 应该显示：always madvise [never]

disable-thp yes  # Redis 7.0+ 支持

redis-cli info memory | grep cow

current_cow_peak:0
current_cow_size:0
current_cow_size_age:0
rdb_last_cow_size:0
aof_last_cow_size:0
module_fork_last_cow_size:0

Redis 实例内存：2GB
预留 COW 内存：2GB  
系统预留内存：1GB
总计需要内存：5GB

THP 启用 → 2MB 大页面 → COW 开销增大 → 内存消耗翻倍 
    ↓
延迟峰值 → 系统资源竞争 → 监控开销增加 → 整体性能下降