Linux内核Major Page Fault深度实战：TLB未命中、NUMA迁移与巨页优化的工程交响曲

3.2 PCID / ASID：避免每次 CR3 切换都刷新 TLB

PCID（Process-Context Identifier） 是实现的关键。CR3 的低 12 位存储 PCID（最多 4096 个，受 VMX 限）以避免每在相应 CR3 write 时刷新全部 TLB。Linux 的 PCID 策略分两级：

# 查看 PCID 是否启用
$ dmesg | grep -i pcid
[    0.159952] x86: Booting SMP configuration:
[    0.160016] smpboot: CPU0

# 内核源码：arch/x86/include/asm/tlbflush.h
# CONFIG_HAVE_PCID_CPUFLUSH=y

在 64 位 Linux 中，PCID 模式分两种：

• User PCID（bit 63=0）：每个 mm 一个 PCID，CR3 write 时只刷新当前 PCID 的 non-global 项
• Global Pages（PGL 全局位）：标记内核页面在所有上下文中共享，刷新时不失效

KPTI（Kernel Page Table Isolation，补丁自 Meltdown 漏洞）在用户态和内核态使用不同的页表，每次系统调用/中断触发 CR3 write。若无 PCID，KPTI 会导致每次切换都全部清 TLB，性能损失可达 30%。启用 PCID 后此项开销被基本消除。

3.3 INVPCID：更细粒度的 TLB 刷新

INVPCID（Invalidates TLBs and Paging-Structure Caches）指令支持四种模式：

内核的 tlb_flush_all() 和 tlb_flush_mm_range() 在检测到 CPU 支持 INVPCID 后会优先走它，避免不必要的 CR3 全部刷新。这对使用大地址空间（100GB+）的数据库应用尤其关键——全页表 TLB 条数可能达到数万项。

4. 巨页（Huge Page / THP）：减少 TLB 压力与 Fault 次数

4.1 三次翻译，三重优势

相同工作集使用 4KB 页 vs 2MB THP vs 1GB HugePage 的 TLB 覆盖率差异巨大。以一个 1GB 内存占用的数据库缓冲池为例：

结论是：使用 THP/HugePage 时，TLB 未命中率下降 100-500 倍，Major Fault 的总次数也线性减少。

4.2 THP（Transparent Huge Page）：内核的自动巨页拆分

THP 通过 khugepaged 内核线程将碎片化的 4KB 页面合并为 2MB 页面：

/sys/kernel/mm/transparent_hugepage/enabled = "madvise"  # 推荐：显式启用
/sys/kernel/mm/transparent_hugepage/defrag = "defer+madvice"  # 减少直接 compaction 开销
/sys/kernel/mm/transparent_hugepage/khugepaged/scan_sleep_millisecs = 10000
/sys/kernel/mm/transparent_hugepage/khugepaged/alloc_sleep_millisecs = 60000

问题在于：

• THP 的 defrag 行为会触发大量页面迁移（split_huge_page_to_list）
• 在 NUMA 系统中，TEP 可能试图迁移远程节点上的页面到本地节点，导致性能反而下降
• 内存紧张的容器中，THP 的 2MB 分配更容易触发 OOM（4KB 分页可通过回收部分页面避免）

许多高性能数据库（Redis、PostgreSQL）建议关闭 THP或仅通过 madvise(MADV_HUGEPAGE) 显式启用。

4.3 libhugetlbfs 与显式 HugePage

对延迟敏感的系统（高频交易、电信信令面），预分配 1GB HugePage 是标准做法：

# 在 NUMA 节点 0 预分配 8 个 1GB HugePage
echo 8 > /sys/devices/system/node/node0/hugepages/hugepages-1048576kB/nr_hugepages

# 或通过启动参数（早期初始化，避免碎片化）
hugepagesz=1G hugepages=8 default_hugepagesz=1G

# 预留文件挂载
mount -t hugetlbfs nodev /dev/hugepages1G

# C 代码：显式 mmap 巨页
int fd = open("/dev/hugepages1G/data", O_CREAT|O_RDWR, 0666);
void *ptr = mmap(NULL, size, PROT_READ|PROT_WRITE,
                 MAP_SHARED|MAP_HUGETLB|((30UL << MAP_HUGE_SHIFT)),  // 1GB = 2^30
                 fd, 0);

显式 HugePage 的巨页不会被 swap 掉（不可回收），这是吞吐与延迟的取舍。

5. NUMA（Non-Uniform Memory Access）：远程访问下的延迟黑洞

5.1 NUMA 拓扑与本地化率

多 socket 系统中，每个 socket 有本地内存节点（Node）和远程内存节点。Intel Xeon 的跨节点访问延迟通常是本地节点的 1.5-2 倍；AMD EPYC（Zen 4）由于 chiplet + IOD 架构，这一比例可达 2-3 倍。

# 查看 NUMA 拓扑
$ numactl --hardware
available: 2 nodes (0-1)
node 0 size: 64500 MB
node 0 free: 43000 MB
node 1 size: 64500 MB
node 1 free: 52000 MB
node distances:
node  0   1
  0:  10  16    # 对角线=本地（10），非对角线=远程（16）
  1:  16  10

$ lscpu | grep NUMA
NUMA node(s):          2
NUMA node0 CPU(s):     0-31
NUMA node1 CPU(s):     32-63

First-Touch 策略：Linux 默认的 NUMA 分配策略是 MPOL_DEFAULT（localalloc）。页面在首次被写入的 CPU 的本地节点分配。这意味着：在 Node 0 上启动的线程对某段内存的首次写入，决定了这片内存的物理位置。

如果后续访问来自 Node 1，就会产生远程访问——Major Fault 在远程节点上导致的 TLB shootdown 和 page table walker 延迟更加严重。

5.2 AutoNUMA：内核的运行时均衡机制

Linux 3.8 引入的 AutoNUMA（需开启 CONFIG_AUTONUMA）会在运行时扫描某段内存的访问热度，并将页面迁移到最活跃的 NUMA 节点：

/proc/sys/kernel/numa_balancing = 1        # 全局开关
/proc/sys/kernel/numa_balancing_scan_delay_ms = 1000    # 启动后多久开始扫描
/proc/sys/kernel/numa_balancing_scan_period_min_ms = 1000
/proc/sched_autogroup_enabled                                # 自动分组协助

AutoNUMA 的工作流程：

1. knuma_balanced 内核线程定期标记访问器（通过clear page table accessed bits）
2. 再次访问触发 pte_young() 后被置位，扫描算法收集热度数据
3. 热度不平衡时调用 migrate_misplaced_pages() 将页面从冷节点迁移到热节点

但 AutoNUMA 的扫描开销本身不可忽视——在高负载 OLTP 系统中，每 1000ms 扫描 256MB 范围的 PTE 位，可能会短暂抢占应用 CPU。PostgreSQL 社区建议在 OLTP 负载中关闭 AutoNUMA，改用显式 numa 绑定。

5.3 显式 NUMA 绑定与 mbind

对于已知流量模式的系统，显式绑定比自动均衡更稳定：

// CPU + 内存双绑定
cpu_set_t cpuset;
CPU_ZERO(&cpuset);
CPU_SET(0, &cpuset);
pthread_setaffinity_np(thread, sizeof(cpu_set_t), &cpuset);

unsigned long nodemask = 1UL << 0;  // Node 0
mbind(ptr, size, MPOL_BIND, &tempmask, sizeof(nodemask)*8, MF_MOFUE|MF_MOVE);

MPOL_BIND：严格绑定到指定节点，若节点内存不足则触发 OOM；MPOL_PREFERRED（软策略）：优先使用指定节点，若不足回退到其他节点。Redis 在多 NUMA 节点服务器的最佳实践是：将线程绑定到某 NUMA 节点的 CPU 并同时将内存分配绑定到同一节点，避免跨节点 Flash/持久化 I/O 路径冲突。

6. 生产环境调优：从指标到方案

6.1 指标采集：定位 Major Fault 来源

# 1. 按进程统计 Fault 次数（minor + major）
$ pidstat -r -p ALL 1
Average:      UID       PID    minflt/s  majflt/s  VSZ    RSS 
Average:     1000     12345    2541.00     45.00  8.2g  6.1g

# 2. 用 perf 采样缺页的调用栈
$ perf record -e page-faults -ag -- sleep 10
$ perf report --sort=comm,dso

# 3. bpftrace 实时观测缺页路径
$ bpftrace -e '
kprobe:do_page_fault {
  @comm = comm;
  @start = nsecs;
}
kprobe:do_page_fault /@start/ {
  @lat_us = hist((nsecs - @start) / 1000);
  delete(@start);
}'

# 4. 查看 THP 拆分与 khugepaged 活动
$ grep -E 'thp|khugepaged' /proc/vmstat | head -20
thp_fault_alloc              2360
thp_fault_fallback           1483   # 巨页分配失败次数高 → 内存碎片化
thp_split_page               971
thp_split_page_failed        3

6.2 四种模式的工程方案

方案 A：预读 + 预加载 + mincore——适合启动密集型、后续恒定型负载（搜索引擎、OLAP 查询）。通过 madvise(MADV_WILLNEED) 或 readahead() 系统调用在启动时将文件 page cache 加载到内存，后续访问几乎不会触发 Major Fault。在启动阶段注入：

void preload_file(const char *path) {
    int fd = open(path, O_RDONLY);
    struct stat st;
    fstat(fd, &st);
    void *ptr = mmap(NULL, st.st_size, PROT_READ, MAP_SHARED|MAP_POPULATE, fd, 0);
    madvise(ptr, st.st_size, MADV_WILLNEED | MADV_SEQUENTIAL);
    munmap(ptr, st.st_size);
    close(fd);
}

MAP_POPULATE 标志在 mmap 时即触发全部缺页（相当于预读），MADV_SEQUENTIAL 提示内核增加预读窗口。

方案 B：NUMA 本地化 + mbind 硬绑定——适合多核 NUMA 同构系统。将工作线程按 NUMA 节点分区，所有 I/O 缓冲区和索引结构绑定到本地节点。PostgreSQL 的 numa.opennuma 配置项或自带 pg_numa 扩展库是用于此目的。

# 实时打印每个 Major Fault 的进程、地址、延迟
$ bpftrace -e '
kprobe:do_swap_page {
  @comm = comm;
  @ts[tid] = nsecs;
}
kretprobe:do_swap_page /@ts[tid]/ {
  $dur = (nsecs - @ts[tid]) / 1000;
  if ($dur > 1000) {
    printf("SWAPIN SLOW %s pid=%d %d us\n", @comm, pid, $dur);
  }
  delete(@ts[tid]);
}'

# 下载并编译
$ cat > major_fault_test.c <<'EOF'
#define _GNU_SOURCE
#include <sys/mman.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <fcntl.h>

#define SIZE_GB (1UL * 1024 * 1024 * 1024)
#define PAGE_SIZE 4096

int main() {
    // 1. 用 MAP_POPULATE + MAP_LOCKED 预加载，消除 Major Fault
    void *p = mmap(NULL, SIZE_GB, PROT_READ|PROT_WRITE,
                   MAP_PRIVATE|MAP_ANONYMOUS|MAP_POPULATE|MAP_LOCKED,
                   -1, 0);
    if (p == MAP_FAILED) { perror("mmap"); return 1; }

    // 2. 用 MADV_DONTNEED 丢弃页面（模拟冷启动缺页）
    madvise(p, SIZE_GB, MADV_DONTNEED);

    struct timespec t0, t1;
    clock_gettime(CLOCK_MONOTONIC, &t0);

    // 3. 逐页触发缺页
    for (size_t off = 0; off < SIZE_GB; off += PAGE_SIZE) {
        memset(p + off, 0x42, PAGE_SIZE);
    }

    clock_gettime(CLOCK_MONOTONIC, &t1);
    double dur = (t1.tv_sec - t0.tv_sec) + (t1.tv_nsec - t0.tv_nsec)*1e-9;
    printf("1GB zero-fill: %.2f sec, throughput: %.2f GB/s\n", dur, 1.0/dur);

    munmap(p, SIZE_GB);
    return 0;
}
EOF
$ gcc -O2 -o major_fault_test major_fault_test.c