1
虚拟地址：[页号][页内偏移]
2
              ↓
3
页表查找 → 物理页帧号
4
              ↓
5
物理地址：[物理页帧号][页内偏移]

1
1. 读取 CR3 寄存器 → PML4 表基址
2
2. 用 PML4 索引查 PML4 表 → PDPT 表基址    （内存访问 1）
3
3. 用 PDPT 索引查 PDPT 表 → PD 表基址      （内存访问 2）
4
4. 用 PD 索引查 PD 表 → PT 表基址           （内存访问 3）
5
5. 用 PT 索引查 PT 表 → 物理页帧号          （内存访问 4）
6
6. 物理页帧号 + 偏移 → 物理地址

1
# 方式 1：透明大页（Transparent Huge Pages, THP）
2
# 自动将 4KB 页合并为 2MB 大页
3
cat /sys/kernel/mm/transparent_hugepage/enabled
4
# [always] madvise never
5

6
# 启用 THP
7
echo always > /sys/kernel/mm/transparent_hugepage/enabled
8

9
# 方式 2：hugetlbfs（预留大页）
10
# 预留 1024 个 2MB 大页 = 2GB
11
echo 1024 > /proc/sys/vm/nr_hugepages
12

13
# 查看大页状态
14
cat /proc/meminfo | grep Huge
15
# HugePages_Total:    1024
16
# HugePages_Free:      512
17
# Hugepagesize:       2048 kB

1
# 查看 CPU 是否支持 PCID
2
cat /proc/cpuinfo | grep pcid
3

4
# Linux 4.14+ 默认启用 PCID（如果硬件支持）
5
# 效果：上下文切换时不再刷新整个 TLB

1
// 测量 TLB 刷新的影响
2
#include <stdio.h>
3
#include <time.h>
4
#include <sys/mman.h>
5

6
#define SIZE (256 * 1024 * 1024)  // 256MB
7

8
int main() {
9
    char *pages[65536];  // 65536 个 4KB 页
10

11
    // 分配并访问所有页（填充 TLB）
12
    for (int i = 0; i < 65536; i++) {
13
        pages[i] = mmap(NULL, 4096, PROT_READ|PROT_WRITE,
14
                        MAP_PRIVATE|MAP_ANONYMOUS, -1, 0);
15
        pages[i][0] = 1;  // 触发页表填充
16
    }
17

18
    // 测量访问时间（TLB 热状态）
19
    clock_t start = clock();
20
    for (int i = 0; i < 65536; i++) {
21
        pages[i][0]++;
22
    }
23
    clock_t end = clock();
24
    printf("TLB 热状态: %.3f 秒\n", (double)(end - start) / CLOCKS_PER_SEC);
25

26
    // 触发 TLB 刷新（修改页保护）
27
    for (int i = 0; i < 65536; i++) {
28
        mprotect(pages[i], 4096, PROT_READ);
29
    }
30

31
    // 测量访问时间（TLB 冷状态）
32
    start = clock();
33
    for (int i = 0; i < 65536; i++) {
34
        pages[i][0]++;  // TLB 未命中
35
    }
36
    end = clock();
37
    printf("TLB 冷状态: %.3f 秒\n", (double)(end - start) / CLOCKS_PER_SEC);
38

39
    return 0;
40
}

1
虚拟地址 → TLB 查找 → 物理地址 → 缓存查找 → 数据

1
虚拟地址：[索引位][标签位][偏移]
2
              ↓           ↓
3
        缓存索引（虚拟）  TLB 查找 → 物理标签
4
              ↓                    ↓
5
        缓存行查找 ←──── 标签比较

1
#include <stdio.h>
2
#include <stdlib.h>
3
#include <time.h>
4

5
int main() {
6
    printf("步长(页数)  每次访问延迟(ns)\n");
7
    for (int stride_pages = 1; stride_pages <= 4096; stride_pages *= 2) {
8
        int total_pages = stride_pages * 64;
9
        int *pages = malloc(total_pages * sizeof(int));
10
        for (int i = 0; i < total_pages; i++) pages[i] = (i + stride_pages) % total_pages;
11

12
        clock_t start = clock();
13
        int idx = 0;
14
        for (int i = 0; i < 10000000; i++) idx = pages[idx];
15
        clock_t end = clock();
16

17
        double ns = (double)(end - start) / CLOCKS_PER_SEC * 1e9 / 10000000;
18
        printf("%8d     %.1f\n", stride_pages, ns);
19
        free(pages);
20
    }
21
    return 0;
22
}
23
// 延迟在 TLB 容量边界处跳跃

1
# 使用 perf 测量 TLB 未命中
2
perf stat -e dTLB-loads,dTLB-load-misses,iTLB-loads,iTLB-load-misses ./your_program
3

4
# 对比 4KB 页和 2MB 大页
5
# 4KB 页
6
./your_program  # 默认
7

8
# 2MB 大页（需要程序支持）
9
HUGETLB_MORECORE=yes ./your_program

1
# 查看 TLB 配置
2
lscpu | grep -i tlb
3

4
# 查看页大小
5
getconf PAGESIZE
6
# 4096
7

8
# 查看大页信息
9
cat /proc/meminfo | grep -i huge
10

11
# 查看进程的页表大小
12
cat /proc/$(pidof your_program)/status | grep VmPTE

1
4 级页表（48 位虚拟地址）：
2
┌────────┬────────┬────────┬────────┬──────────────┐
3
│ 保留    │ PML4   │ PDPT   │ PD     │ PT           │ 页内偏移      │
4
│ 16位    │ 9位    │ 9位    │ 9位    │ 9位          │ 12位          │
5
└────────┴────────┴────────┴────────┴──────────────┘
6
 63-48     47-39   38-30   29-21   20-12         11-0
7

8
5 级页表（57 位虚拟地址，LA57）：
9
┌────────┬────────┬────────┬────────┬────────┬──────────────┐
10
│ 保留    │ PML5   │ PML4   │ PDPT   │ PD     │ PT     │ 偏移 │
11
│ 7位     │ 9位    │ 9位    │ 9位    │ 9位    │ 9位    │ 12位 │
12
└────────┴────────┴────────┴────────┴────────┴──────────────┘
13
 63-57     56-48   47-39   38-30   29-21   20-12   11-0

1
// 测量 TLB 未命中的影响
2
#include <stdio.h>
3
#include <stdlib.h>
4
#include <time.h>
5

6
#define SIZE_MB 256
7
#define PAGE_SIZE 4096
8

9
int main() {
10
    int pages = SIZE_MB * 1024 / PAGE_SIZE;
11
    char *buf = malloc(SIZE_MB * 1024 * 1024);
12

13
    // 顺序访问（TLB 友好）
14
    clock_t start = clock();
15
    long long sum = 0;
16
    for (int i = 0; i < SIZE_MB * 1024 * 1024; i += PAGE_SIZE) {
17
        sum += buf[i];  // 每页只访问 1 字节
18
    }
19
    clock_t end = clock();
20
    printf("顺序访问(每页1字节): %.3f 秒\n",
21
           (double)(end - start) / CLOCKS_PER_SEC);
22

23
    // 随机跳页访问（TLB 不友好）
24
    int *order = malloc(pages * sizeof(int));
25
    for (int i = 0; i < pages; i++) order[i] = i;
26
    // shuffle order...
27
    start = clock();
28
    sum = 0;
29
    for (int i = 0; i < pages; i++) {
30
        sum += buf[order[i] * PAGE_SIZE];  // 随机页访问
31
    }
32
    end = clock();
33
    printf("随机页访问: %.3f 秒\n",
34
           (double)(end - start) / CLOCKS_PER_SEC);
35

36
    free(buf);
37
    free(order);
38
    return 0;
39
}

1
# ===== 透明大页（THP）=====
2
# 查看当前状态
3
cat /sys/kernel/mm/transparent_hugepage/enabled
4
# always [madvise] never
5

6
# 启用 THP
7
echo always | sudo tee /sys/kernel/mm/transparent_hugepage/enabled
8

9
# 在代码中使用 madvise 请求大页
10
# madvise(ptr, size, MADV_HUGEPAGE);
11

12
# ===== 静态大页（hugetlbfs）=====
13
# 预留 1024 个 2MB 大页 = 2GB
14
echo 1024 | sudo tee /proc/sys/vm/nr_hugepages
15

16
# 查看大页状态
17
cat /proc/meminfo | grep Huge
18
# HugePages_Total:    1024
19
# HugePages_Free:     1024
20
# HugePages_Rsvd:      0
21
# Hugepagesize:       2048 kB
22

23
# 挂载 hugetlbfs
24
sudo mount -t hugetlbfs nodev /mnt/hugepages
25

26
# ===== 1GB 大页 =====
27
# 预留 4 个 1GB 大页（需要启动参数）
28
# 在 /etc/default/grub 添加:
29
# default_hugepagesz=1G hugepagesz=1G hugepages=4
30
sudo update-grub && sudo reboot
31

32
# 查看可用大页大小
33
cat /proc/meminfo | grep Hugepages