Linux 内核虚拟内存管理是现代操作系统的核心支柱之一。它通过为每个进程提供独立的虚拟地址空间,实现了进程隔离、内存超配(overcommit)、按需调页(demand paging)和内存映射文件等关键能力。本文将深入剖析 Linux 内核虚拟内存子系统的完整架构,从页表管理、VMA(Virtual Memory Area)区域组织、Page Fault 处理路径,到反向映射(reverse mapping)、KSM 页面合并以及大页(Huge Pages)机制,全面揭示内核如何高效地管理虚拟地址到物理地址的映射。

一、虚拟内存架构总览

Linux 采用多级页表(Multi-level Page Table)实现虚拟地址到物理地址的转换。以 x86_64 架构为例,使用 4 级页表(PGD→PUD→PMD→PTE),虚拟地址空间划分为用户态(0x0000_0000_0000_0000 ~ 0x0000_7FFF_FFFF_FFFF)和内核态(0xFFFF_8000_0000_0000 ~ 0xFFFF_FFFF_FFFF_FFFF)。

// 四级页表地址翻译过程(x86_64, 4KB 页)
// Virtual Address (48-bit effective):
// | PGD index (9) | PUD index (9) | PMD index (9) | PTE index (9) | Offset (12) |
//
// 翻译过程:
// 1. CR3 寄存器 → PGD 基址
// 2. PGD[pgd_index] → PUD 基址
// 3. PUD[pud_index] → PMD 基址
// 4. PMD[pmd_index] → PTE 基址
// 5. PTE[pte_index] → Physical Page Frame
// 6. Page Frame + offset = 物理地址

TLB(Translation Lookaside Buffer)作为页表缓存,存储最近使用的虚拟→物理映射。x86_64 通常有 L1 DTLB(64 项, 4KB 页)、L2 TLB(512 项+)和 STLB(共享 TLB)。当发生 Page Miss(TLB 未命中)时,硬件 Page Table Walker 自动遍历页表填充 TLB。

二、VMA(Virtual Memory Area)管理

2.1 mm_struct 与 VMAs 组织

每个进程的内存管理由 struct mm_struct 描述,其中 VMAs 通过红黑树和双向链表两种结构组织,兼顾范围查询和遍历性能:

// 关键数据结构(简化)
struct mm_struct {
    struct rb_root              mm_rb;          // VMA 红黑树根(按起始地址排序)
    struct vm_area_struct      *mmap;          // VMA 链表头
    atomic_t                    mm_users;       // 用户引用计数
    atomic_t                    mm_count;       // 主引用计数
    unsigned long               start_code;     // 代码段起始
    unsigned long               end_code;       // 代码段结束
    unsigned long               start_data;     // 数据段起始
    unsigned long               end_data;       // 数据段结束
    unsigned long               start_brk;      // 堆起始
    unsigned long               brk;            // 堆当前顶部
    unsigned long               start_stack;    // 栈起始
    unsigned long               rss;            // 驻留页面计数
    unsigned long               total_vm;      // 总虚拟页面数
    pgd_t                      *pgd;            // 全局页目录基址
    rwlock_t                    page_table_lock;// 页表锁
};

struct vm_area_struct {
    unsigned long        vm_start;       // 区域起始地址
    unsigned long        vm_end;         // 区域结束(不包含)
    struct mm_struct    *vm_mm;          // 所属 mm_struct
    pgprot_t            vm_page_prot;    // 访问权限
    unsigned long        vm_flags;       // 标志 (READ/WRITE/EXEC/SHARED)
    struct rb_node       vm_rb;          // 红黑树节点
    const struct vm_operations_struct *vm_ops;  // 操作函数表
    unsigned long        vm_pgoff;       // 文件映射时的页偏移
    struct file         *vm_file;        // 映射的文件(如有)
};

2.2 典型进程内存布局

// x86_64 Linux 进程典型内存布局(从高地址到低地址):
//
// 0xFFFF_FFFF_FFFF_FFFF ┐
//                       │  内核空间 (128TB)
// 0xFFFF_8000_0000_0000 ┘
// 0x0000_7FFF_FFFF_FFFF ┐
//                       │  栈 (Stack) — 向下增长
//                       │  ↓
//                       │  随机偏移 (ASLR)
//                       │
//                       │  mmap 区域(共享库/文件映射)
//                       │  ↓(Linux 默认栈向 mmap 区增长方向相反)
//                       │
//                       │  堆 (Heap) — brk 向上增长
//                       │  ↑
//                       │  BSS 段
//                       │  Data 段
//                       │  Text 段 (代码段)
// 0x0000_0000_0040_0000 ┘ (典型 ELF 加载地址)

2.3 VMA 查找与合并

内核在每次 VMA 操作时通过 find_vma() 在红黑树中查找包含给定地址的 VMA。如果新映射区域与现有 VMA 相邻且属性相同,内核会自动合并它们,减少 VMA 节点数量:

// VMA 合并判断逻辑
struct vm_area_struct *vma = find_vma(mm, addr);
if (vma && vma->vm_start <= addr + len) {
    // 存在重叠或相邻
    if (vma->vm_flags == flags &&
        vma->vm_pgoff + ((vma->vm_end - vma->vm_start) >> PAGE_SHIFT) == pgoff &&
        !is_merge_constraint_violated()) {
        // 可以合并,扩展现有 VMA
        vma->vm_end = addr + len;
        return vma;
    }
}

三、Page Fault 处理机制

3.1 Page Fault 类型

CPU 在虚拟地址翻译失败时触发 Page Fault(异常 #14),Linux 内核根据具体情况分为三类:

  • Minor Page Fault(次缺页):页面在物理内存中但未建立页表映射(如共享库首次访问、写时复制后)。无需磁盘 I/O,仅需修改页表项。
  • Major Page Fault(主缺页):页面不在物理内存中,需从磁盘(swap/file)加载。涉及 I/O 操作,延迟高(毫秒级)。
  • Invalid/Protection Fault(无效/保护缺页):访问未映射区域(如 NULL 指针解引用)或违反权限(写只读页,触发 COW)。导致 SIGSEGV 或 COW 分裂。

3.2 缺页处理主路径

x86_64 架构下,Page Fault 的处理入口是 do_page_fault()(已整合到 exc_page_fault()),核心调用链如下:

// Page Fault 处理流程(简化)
exc_page_fault (arch/x86/mm/fault.c)
  └── __do_page_fault()
       ├── 1. 获取故障地址 (CR2 寄存器)
       ├── 2. 查找 VMA (find_vma)
       │    ├── VMA 不存在 → SIGSEGV (SEGV_MAPERR)
       │    ├── 权限不匹配 → SIGSEGV (SEGV_ACCERR)
       │    └── VMA 有效 ↓
       ├── 3. handle_mm_fault()
       │    ├── handle_pte_fault()   — PTE 级处理
       │    │    ├── do_anonymous_page() — 匿名页首次访问
       │    │    ├── do_fault()          — 文件映射缺页
       │    │    │    ├── do_read_fault()  — 读文件 (filemap_fault)
       │    │    │    ├── do_cow_fault()   — 写时复制
       │    │    │    └── do_shared_fault()— 共享文件写
       │    │    └── do_swap_page()        — 从 swap 换入
       │    ├── do_huge_pmd_anonymous_page() — 大页匿名映射
       │    └── __handle_mm_fault (PMD/PUD 级)
       └── 返回 (若成功,CPU 自动重试故障指令)

3.3 需求分页(Demand Paging)

Linux 使用延迟分配策略:当进程调用 mmap() 申请大块内存时,内核仅创建 VMA 而不分配物理页面。实际物理页面分配推迟到首次访问时通过 Page Fault 完成:

// do_anonymous_page: 匿名页首次访问处理
static vm_fault_t do_anonymous_page(struct vm_fault *vmf) {
    // 1. 检查是否允许延迟分配(vma->vm_flags & VM_PFNMAP?)
    // 2. 分配一个物理页面 (alloc_zeroed_user_highpage_movable)
    // 3. 建立 PTE 映射 (mk_pte + set_pte_at)
    // 4. 更新 RSS 计数器
    // 5. 返回 FAULT_FLAG_WRITE 以允许后续写入
    
    page = alloc_zeroed_user_highpage_movable(vma, vmf->address);
    if (!page) return VM_FAULT_OOM;  // 内存不足
    
    // 填入页表
    vmf->pte = pte_offset_map_lock(vma->vm_mm, vmf->pmd, vmf->address, &ptl);
    entry = mk_pte(page, vma->vm_page_prot);
    set_pte_at(vma->vm_mm, vmf->address, vmf->pte, entry);
    
    return 0;  // 成功
}

3.4 写时复制(Copy-on-Write)

当 fork() 创建子进程时,Linux 不会立即复制父进程的物理页面。父子共享同一组物理页,但页表项被标记为只读。任何一方尝试写入时触发 COW Fault,内核才真正复制页面:

// COW 分裂流程:
// 1. fork() → copy_mm() → dup_mm()
//    - 复制 mm_struct 和所有 VMA
//    - 父子共享页面,PTE 设为只读 (vma->vm_flags &= ~VM_WRITE)
//
// 2. 任一进程尝试写入共享页 → do_wp_page()
//    - 检查 page->_refcount:
//      - refcount == 1 → 无其他持有者,直接标记可写
//      - refcount > 1 → 需要复制:
//        a. 分配新物理页面
//        b. 复制内容 (copy_user_highpage)
//        c. 建立新 PTE 映射 (可写)
//        d. 旧页面 refcount--

// do_wp_page 核心逻辑
static vm_fault_t do_wp_page(struct vm_fault *vmf) {
    page = vmf->page;
    if (page_count(page) == 1) {
        // 独占页面,直接升级写权限
        entry = pte_mkwrite(ppo_mkdirty(vmf->orig_pte));
        set_pte_at_notify(mm, vmf->address, vmf->pte, entry);
        return 0;
    }
    // 多持有者 → 复制新页面
    new_page = alloc_page_vma(GFP_HIGHUSER_MOVABLE, vma, vmf->address);
    copy_user_highpage(new_page, page, vmf->address, vma);
    __SetPageUptodate(new_page);
    set_pte_at_notify(mm, vmf->address, vmf->pte,
                      mk_pte(new_page, vma->vm_page_prot));
    return 0;
}

四、反向映射(Reverse Mapping, RMAP)

4.1 为什么需要 RMAP

页表(PTE)是正向映射:虚拟地址→物理地址。但当内核需要回收或换出一个物理页面时,必须知道哪些进程的页表项指向它,才能全部失效(unmap)并更新。这就是反向映射的作用。

4.2 匿名页 RMAP(anon_vma)

匿名页通过 anon_vma 链表维护所有映射到该页的 VMA 实例:

// 匿名页 RMAP 结构 (简化)
struct anon_vma {
    struct anon_vma *root;       // 根 anon_vma(fork 时合并)
    atomic_t         refcount;   // 引用计数
    unsigneddegree  degree;     // VMA 嵌套层级
    struct rb_root   rb_root;    // interval tree(区间树,用于高效查找)
};

struct anon_vma_chain {
    struct vm_area_struct *vma;          // 指向的 VMA
    struct anon_vma      *anon_vma;      // 所属的 anon_vma
    struct list_head      same_vma;      // 链入 VMA 的 anon_vma_chain 列表
    struct list_head      rb;            // 按区间排序的红黑树节点
};

// 遍历同页面所有映射项
static void unmap_anon_vma(struct page *page) {
    struct anon_vma *anon_vma = page_anon_vma(page);
    struct anon_vma_chain *avc;
    pgoff_t pgoff = page->index;
    
    // 遍历所有 avc,对每个 VMA 调用 teardown
    anon_vma_interval_tree_foreach(avc, &anon_vma->rb_root, pgoff, pgoff) {
        struct mm_struct *mm = avc->vma->vm_mm;
        unsigned long address = vma_address(page, avc->vma);
        // 取消映射
        pte_get_and_clear_full(mm, address, pte, 0);
    }
}

4.3 文件页 RMAP(address_space)

文件映射(file-backed)页面的反向映射通过 address_space 的优先搜索树(priority search tree, PST)实现。由于文件页可能被数千个进程共享(如共享库的代码段),PST 支持高效的多索引查询:

// 文件映射 RMAP 结构
struct address_space {
    struct inode        *host;          // 关联 inode
    struct radix_tree_root  page_tree;  // 页面缓存的 radix tree
    struct rb_root       i_mmap;        // 优先搜索树(PST 根)
    struct rw_semaphore  i_mmap_rwsem;  // 读写信号锁
    // ...
};

// 取消文件页的所有映射
static void truncate_inode_pages_range(struct address_space *mapping,
                                       loff_t loff, loff_t end) {
    // 在 i_mmap 优先搜索树中查找所有区间包含 [loff, end] 的 VMA
    // 对每个 VMA 执行 zap_page_range 取消 PTE 映射
    // 从 page tree 中移除 page
}

五、Swap 与页面回收

5.1 LRU 页面回收算法

Linux 使用双链表 LRU(Least Recently Used)实现页面回收。每个内存区域(zone)维护 Active/Inactive 两个文件页和匿名页链表,共四个 LRU 链表:

// LRU 链表定义(每个 NUMA node × zone)
enum lru_list {
    LRU_INACTIVE_ANON = 0,  // 非活跃匿名页(置换首选)
    LRU_ACTIVE_ANON,        // 活跃匿名页
    LRU_INACTIVE_FILE,      // 非活跃文件页
    LRU_ACTIVE_FILE,        // 活跃文件页
    NR_LRU_LISTS
};

// kswapd 页面回收流程:
// 1. kswapd 在 free_pages_low 时唤醒
// 2. balance_pgdat() 遍历所有 zone
// 3. shrink_node() → shrink_mem_cgroup_node()
// 4. shrink_list() 优先回收 Inactive File(成本最低,直接丢弃)
// 5. Inactive File 不足 → 回收 Inactive Anonymous(需写入 swap)
// 6. 页面访问时通过 page_check_references() 将页提升到 Active

// 引用检查决定升降级
static enum page_references page_check_references(struct page *page, struct scan_control *sc) {
    referenced = page_referenced(page, 1, sc->target_mem_cgroup, &vm_flags);
    if (referenced && page_is_file_cache(page))
        return PAGEREF_ACTIVATE;   // 文件页活跃 → 升到 Active
    if (referenced && !page_is_file_cache(page))
        return PAGEREF_ACTIVATE;   // 匿名页活跃 → 升到 Active
    return PAGEREF_KEEP;           // 保持当前状态
}

5.2 Swap Slab 与换入换出

当页面需要被换出到 swap 时,内核通过 swap_entry_t 编码 swap 设备 ID 和页面偏移,填入 PTE。再次访问时触发 Page Fault,内核识别 PTE 类型后从 swap 读入:

// 换出流程 (shrink_page_list)
// 1. 从 Inactive 链表摘取页面
// 2. 对匿名页: add_to_swap() → 获取 swap slot → 写入磁盘 → swap_entry_t 填入 PTE
// 3. 对文件页: 若 dirty,写回磁盘后释放;若 clean,直接丢弃

// 换入流程 (do_swap_page)
// 1. PTE 中的 swap_entry_t 解析为 swap device + offset
// 2. 查找 swap cache(可能被其他进程已换入)
// 3. 若未缓存,从磁盘读取页面(read_swap_cache_async)
// 4. 建立 PTE 物理映射

// 性能数据:
// - SSD swap 换入: 0.05~0.1ms (4KB 页)
// - HDD swap 换入: 5~10ms
// - 匿名页 Minor Fault: ~0.5us(无 I/O)
// - 文件 Major Fault 换入 SSD: ~50us

六、大页(Huge Pages / THP)

6.1 透明大页(Transparent Huge Pages)

Linux 内核支持 2MB 甚至 1GB 的大页(x86_64),以减少 TLB 未命中和页表开销。THP(Transparent Huge Pages)允许内核自动将普通页面合并为大页:

// THP 合并不意图(简化伪代码)
// 1. khugepaged 内核线程周期性扫描进程内存
// 2. 对满足条件的匿名 VMA:
//    - 区域 >= 2MB
//    - VM_NOHUGEPAGE 未设置
//    - 连续 512 个 4KB 页面都在 Active/Inactive 链表中
// 3. 分配 2MB 大页(需连续物理内存)
// 4. 合并 512 个 PTE 为一个 PMD 大页映射
// 5. 释放 512 个 4KB 页

// PMD 级大页映射(2MB PMD):
// VA: | PGD | PMD (21-bit offset!) |
// PMD entry 的 PS (Page Size) bit = 1 表示 2MB 大页
// 跳过 PTE 层,直接用 PMD entry 的 PFN + 21-bit offset

// 配置 THP 模式:
// /sys/kernel/mm/transparent_hugepage/enabled
//   [always] madvise never
// always = 全局启用
// madvise = 仅对 madvise(MADV_HUGEPAGE) 区域启用
// never  = 禁用

6.2 hugetlb 静态大页

静态大页通过启动参数 hugepages= 预留内存(必须连续物理池),适用于 DPDK/数据库等场景:

// 静态大页配置
// GRUB: hugepagesz=2M hugepages=1024 default_hugepagesz=2M

// 程序使用静态大页:
// 1. 挂载 hugetlbfs: mount -t hugetlbfs nodev /dev/hugepages
// 2. 创建文件并 mmap:
fd = open("/dev/hugepages/my_pool", O_CREAT | O_RDWR, 0755);
ptr = mmap(NULL, 2 * 1024 * 1024, PROT_READ | PROT_WRITE,
           MAP_SHARED | MAP_HUGETLB, fd, 0);

// 优势: 页面不会被换出,TLB 命中率极高(一页 2MB TLB 覆盖)
// 代价: 预留过多导致其他任务可用内存减少

七、KSM(Kernel Same-page Merging)

Kernel Same-page Merging 允许内核扫描已注册的红黑树中的页面,识别重复页面并合并:

// KSM 工作流程:
// 1. 用户通过 madvise(addr, len, MADV_MERGEABLE) 注册区域
// 2. ksmd 内核线程周期性扫描
// 3. 对每个页面:
//    a. 计算 checksum(若 checksum 未变,跳过)
//    b. 在 KSM 红黑树中查找相同 checksum 的页面
//    c. 内容比较(memcmp)
//    d. 若相同:合并两个 VMA 到同一物理页(设置为只读 COW)
//    e. 释放被合并的孤立页面

// KSM 的场景:
// - KVM 虚拟机:相同 OS/APP 的虚拟机之间节省 50-70% 内存
// - 容器平台:相同基础镜像的容器间合并
// - 代价:ksmd 的 CPU 开销,扫描延迟

// 监控:
// /sys/kernel/mm/ksm/pages_shared    — 已合并页面数
// /sys/kernel/mm/ksm/pages_sharing   — 共享合并页的虚拟页数
// /sys/kernel/mm/ksm/pages_unshared  — 检查后发现不相同的页面

八、内存压力与直接回收(Direct Reclaim)

当进程自身在分配内存时遇到 low watermark,会触发直接回收(Direct Reclaim):

// 直接回收路径
// alloc_pages(GFP_KERNEL)
//   → alloc_pages_node()
//     → __alloc_pages_nodemask()
//       → __alloc_pages_slowpath()  (快速路径失败)
//         → __alloc_pages_direct_reclaim()
//           → try_to_free_pages()
//             → throttle_direct_reclaim()  (等待 kswapd)
//             → shrink_zones()
//             → 清理 slab (shrink_slab)

// 直接回收性能影响:
// - 分配者被阻塞(非异步)
// - 回收到 low watermark 才停止
// - 在高 I/O 压力下可能阻塞数百毫秒
// - OOM Killer 在回收无效后触发

// OOM Killer 评分 (oom_badness):
// oom_score = (total_vm / total_ram) * 1000 + oom_score_adj
// - 占用内存越多 → 分越高
// - 运行时间越长 → 分数打折(* (运行时间 / 半衰期))
// - root 进程 → 分数 * 3%
// - oom_score_adj 范围: -1000 (禁用) 到 +1000 (优先杀)

九、mmap 与零拷贝内存映射

9.1 mmap 系统调用

mmap() 将文件或设备映射到进程地址空间,允许进程通过内存读写操作与文件交互:

// mmap 典型使用场景
// 1. 文件映射(共享)
void *addr = mmap(NULL, file_size, PROT_READ | PROT_WRITE,
                  MAP_SHARED, fd, 0);
// 修改内存即写回文件(通过 page cache)
memcpy(addr, data, len);
msync(addr, len, MS_SYNC);  // 刷回磁盘

// 2. 匿名大页分配
void *addr = mmap(NULL, size, PROT_READ | PROT_WRITE,
                  MAP_PRIVATE | MAP_ANONYMOUS | MAP_HUGETLB,
                  -1, 0);

// 3. 私有文件映射 (Copy-on-Write)
void *addr = mmap(NULL, file_size, PROT_READ | PROT_WRITE,
                  MAP_PRIVATE, fd, 0);
// 写入时复制页面,修改不写回文件

// 性能优势:
// - 避免 read()/write() 的用户态-内核态数据拷贝
// - 利用内核 page cache,自动缓存管理
// - 支持随机访问(lseek 开销低)
// - 多个进程共享同一文件映射

9.2 MAP_POPULATE 与 MADVISE

对于希望避免 Minor Fault 的场景,可使用 MAP_POPULATE 预分配物理页面,或通过 madvise() 提供访问模式提示:

// 预分配(等同于提前触发所有 Page Fault)
void *addr = mmap(NULL, size, PROT_READ | PROT_WRITE,
                  MAP_PRIVATE | MAP_ANONYMOUS | MAP_POPULATE, -1, 0);

// madvise 提示(不阻塞,仅调整内核策略)
madvise(addr, size, MADV_SEQUENTIAL);  // 顺序访问: 激进预读
madvise(addr, size, MADV_RANDOM);      // 随机访问: 禁用预读
madvise(addr, size, MADV_DONTNEED);    // 释放物理页面(下次重读)
madvise(addr, size, MADV_HUGEPAGE);    // 启用 THP
madvise(addr, size, MADV_DONTFORK);    // fork 时不复制

十、性能监控与调优

10.1 Page Fault 监控工具

# perf stat 统计缺页
perf stat -e page-faults,minor-faults,major-faults -p $PID

# /proc/PID/smaps_rollup 查看详细 VMA 统计
cat /proc/$$/smaps_rollup | head -30
# Rss:               1234 kB  (常驻物理内存)
# Pss:               1000 kB  (按比例分摊)
# Shared_Clean:       200 kB
# Private_Dirty:      500 kB  (写时复制的存储)
# Referenced:        1100 kB  (最近访问过)

# vmstat 查看系统级缺页率
vmstat 1
# 列: si(so)=swap in/out, bi(bo)=block in/out
#    in=中断, cs=上下文切换

# sar -B 报告 paging 统计
sar -B 1
# pgpgin/s pgpgout/s fault/s majflt/s pgfree/s pgscank/s pgscand/s

10.2 减少 Major Fault 的最佳实践

  • 增加 file cache 热页驻留:调整 vm.min_free_kbytes、vm.swappiness(降低值避免换出缓存页)
  • 预读优化:使用 MAP_POPULATE 或 posix_fadvise() 提前加载大文件
  • 大页加速 TLB 密集场景:数据库/Redis 等建议使用 THP 或 hugetlb
  • numactl 绑核:避免跨 NUMA 节点内存访问,numactl --cpunodebind=0 --membind=0 ./app
  • 禁用 swap 对延迟敏感场景:vm.swappiness=1 或 mlockall(MCL_CURRENT | MCL_FUTURE)

10.3 TLB Shootdown 注意事项

当一个进程 munmap() 或修改页表权限时,其他 CPU 上可能缓存了旧的 TLB 条目。此时内核发送 IPI(Inter-Processor Interrupt)请求这些 CPU 执行 TLB 失效,这被称为 TLB Shootdown:

// TLB Shootdown 代价
// - 单次 IPI 延迟: ~2-10us(若目标 CPU 空闲)
// - unmap 大量页面后可能发送多个 IPI
// - 64 核系统全局 TLB 失效开销可达 100us+
// - 优化: lazy TLB mode (mm_cpumask 跟踪)
//   → 借助 context_tracking 延迟失效到下次进入内核

// 最佳实践:
// - 避免高频 mmap/munmap 小区域(用内存池替代)
// - 大映射优于小映射(减少 TLB 操作频次)
// - 使用 mlock 锁定的页面不被换出(仍可能 TLB shootdown)

十一、实战案例:高并发内存池的 Page Fault 优化

某高并发交易系统在使用 glibc malloc 时遇到启动延迟高的问题,分析发现原因是大量 Minor Fault:

// 原始问题: 新进程启动时 100MB*8 线程 Minor Fault
// perf stat: 8000+ page-faults, 延迟 500ms

// 优化方案: mmap + MAP_POPULATE 预分配大内存池
class MemoryPool {
    void* pool_;
    size_t size_;
    
public:
    MemoryPool(size_t size) : size_(size) {
        // 一次性申请大块,MAP_POPULATE 预填所有页面
        pool_ = mmap(nullptr, size_, PROT_READ | PROT_WRITE,
                     MAP_PRIVATE | MAP_ANONYMOUS | MAP_POPULATE,
                     -1, 0);
        if (pool_ == MAP_FAILED) {
            // 备用方案: madvise MADV_WILLNEED(内核异步预读)
            madvise(pool_, size_, MADV_WILLNEED);
        }
    }
    
    void* allocate(size_t n) {
        // 从预分配池中分割,不触发新的 mmap
        void* ptr = static_cast<char*>(pool_) + offset_;
        offset_ += n;
        return ptr;
    }
    
    ~MemoryPool() {
        munmap(pool_, size_);
    }
};

// 效果:
// - Minor Fault 数: 8000+ → 0 (启动时)
// - 启动延迟: 500ms → 50ms
// - MAP_POPULATE 开销约 80ms(一次性),远小于分散 Fault 的 450ms
// - TLB 效率提升(连续访问,TLB 覆盖率高)

十二、总结

Linux 内核虚拟内存管理是整个操作系统的核心子系统。它通过多级页表、VMA 组织、需求分页、写时复制、反向映射、LRU 回收、透明大页等机制,在安全性、隔离性和性能之间取得了精妙的平衡。

关键要点总结:

  1. 延迟分配:mmap 只创建 VMA,物理页面在首次访问(Page Fault)时分配
  2. COW 优化 fork:父子进程共享页面,写入时才复制
  3. RMAP 支持回收:通过 anon_vma(匿名页)和 address_space(文件页)快速找到所有持有者
  4. LRU 链表分级:Active/Inactive × File/Anonymous 四链表,回收时优先丢弃文件页缓存
  5. THP 大页加速:khugepaged 自动合并 4KB → 2MB 大页,减少 TLB Miss
  6. 性能调优指标:Major Fault 是关键指标,反映 cache 命中率;减少 Major Fault 就是要增加文件缓存驻留

深入理解虚拟内存机制,是诊断系统性能问题(抖动、OOM、TLB Miss)和开发高性能程序(内存池、预读、大页利用)的基础。

点赞(0) 打赏

评论列表 共有 0 条评论

暂无评论
立即
投稿

微信公众账号

微信扫一扫加关注

发表
评论
返回
顶部