C++ 内存模型 - 夜羽的小作坊

写 AI Infra 或者 CUDA kernel 的时候，内存管理是绕不开的话题。GPU 显存贵、CPU 内存带宽有限，一个不对齐的访问就能让性能掉一半。这篇文章从 CPU 侧的内存模型出发，搞清楚栈和堆在底层到底是怎么运作的，再聊聊内存对齐为什么重要，最后演示如何在 C++ 里追踪每一笔内存分配。

程序的内存全貌#

一个运行中的进程，地址空间大致长这样（64-bit Linux 为例，地址从低到高）：

1
高地址
2
┌─────────────────────────────┐
3
│         Stack               │  ← 向下增长，局部变量、函数调用帧
4
├─────────────────────────────┤
5
│          ...                │  （大片未映射区域）
6
├─────────────────────────────┤
7
│         Heap                │  ← 向上增长，malloc/new 分配
8
├─────────────────────────────┤
9
│   BSS Segment               │  未初始化全局/静态变量（全零）
10
├─────────────────────────────┤
11
│   Data Segment              │  已初始化全局/静态变量
12
├─────────────────────────────┤
13
│   Text Segment              │  可执行代码（只读）
14
低地址

栈和堆从两端向中间增长，中间是一大片未映射的虚拟地址。两者碰头了就是栈溢出或堆耗尽——当然在 64-bit 地址空间里，理论上有 128 TB 可以用，一般不会真的碰。

栈（Stack）#

分配的本质：一条指令#

栈分配快到令人发指，原因很简单：分配就是移动栈指针。

在 x86-64 里，栈指针是 RSP 寄存器。函数进入时，编译器知道这个函数需要多少栈空间，于是直接一条指令搞定：

1
sub rsp, 32    ; 在栈上"分配"32字节，就这么简单

函数返回时：

1
add rsp, 32    ; "释放"栈内存，同样一条指令

没有系统调用，没有链表遍历，没有锁，CPU 就是在做一次整数加减法。这就是栈分配快的根本原因。

函数调用时发生了什么#

调用一个函数，CPU 会：

把返回地址压栈（call 指令隐含的操作）
保存调用者的帧指针（rbp）
移动 rsp 分配局部变量空间
执行函数体

函数返回时逆序恢复，整个过程在纳秒级别完成。

1
#include <iostream>
2

3
void foo() {
4
    int a = 1;   // 栈上，&a 就在当前帧里
5
    int b = 2;   // 紧挨着 a
6
    std::cout << "a @ " << &a << "\n";
7
    std::cout << "b @ " << &b << "\n";
8
    // 差值通常是 4（或者因对齐是 8）
9
}
10

11
int main() {
12
    foo();
13
    return 0;
14
}

你会看到 a 和 b 的地址非常接近，而且都比 main 的局部变量地址更低（栈向下增长）。

栈的限制#

栈大小通常只有 8 MB（Linux 默认，可以用 ulimit -s 查看或修改）。这意味着：

不要在栈上分配大数组（int arr[1000000] 直接栈溢出）
递归层数过深也会溢出
大对象请放到堆上

生命周期由作用域决定：出了花括号，栈帧弹出，那块内存就”消失”了（实际上只是 RSP 移回去了，数据还在，只是随时可能被覆盖）。返回局部变量的指针是经典的 UB，别这样做。

堆（Heap）#

分配的代价#

new 或 malloc 从堆分配内存，代价比栈高得多：

找空闲块：堆内存管理器（glibc 的 ptmalloc、jemalloc 等）需要在空闲列表（free list）或 buddy system 中找到一个足够大的块
处理碎片：如果找到的块太大，需要切割，把剩余部分放回空闲列表
可能触发系统调用：堆内存不足时，需要调用 brk() 或 mmap() 向操作系统申请更多内存
更新元数据：堆管理器要记录这块内存的大小、状态等信息（通常藏在分配块头部的几个字节里）
线程安全：多线程环境下需要加锁（或使用 per-thread arena 等优化）

相比栈的一条 sub rsp 指令，堆分配的开销可能是它的 几十倍甚至几百倍。

1
#include <iostream>
2
#include <chrono>
3

4
int main() {
5
    const int N = 1'000'000;
6

7
    // 测试堆分配
8
    auto t1 = std::chrono::high_resolution_clock::now();
9
    for (int i = 0; i < N; ++i) {
10
        int* p = new int(i);
11
        delete p;
12
    }
13
    auto t2 = std::chrono::high_resolution_clock::now();
14

15
    // 测试栈"分配"（编译器可能优化掉，仅作对比思路）
16
    auto t3 = std::chrono::high_resolution_clock::now();
17
    for (int i = 0; i < N; ++i) {
18
        int x = i;           // 栈上，函数内循环通常直接用寄存器
19
        (void)x;
20
    }
21
    auto t4 = std::chrono::high_resolution_clock::now();
22

23
    auto heap_ns = std::chrono::duration_cast<std::chrono::nanoseconds>(t2 - t1).count();
24
    auto stack_ns = std::chrono::duration_cast<std::chrono::nanoseconds>(t4 - t3).count();
25

26
    std::cout << "堆分配（百万次）: " << heap_ns / 1000 << " μs\n";
27
    std::cout << "栈变量（百万次）: " << stack_ns / 1000 << " μs\n";
28
    return 0;
29
}

堆的优势#

堆分配慢，但它提供了栈不具备的能力：

生命周期完全可控：什么时候 delete 你说了算
容量大：可以分配几 GB 的内存（受物理内存和虚拟地址空间限制）
运行时决定大小：new int[n]，n 可以是运行时变量

内存对齐（Memory Alignment）#

CPU 读内存的基本单元#

现代 CPU 不是一个字节一个字节地读内存，而是以 word 为单位（通常 8 字节，即 64 位）。想象内存是一排格子，每格 8 字节，CPU 每次抓一格。

如果一个 int（4 字节）恰好跨了两格的边界：

1
字节地址:  0  1  2  3  4  5  6  7 | 8  9 10 11 12 13 14 15
2
            [        格0          ] [        格1          ]
3
                              [  int 跨边界了！  ]
4
                             ^6                 ^9

CPU 就必须读两次，然后拼接，性能白白损失。更糟的是，某些架构（如早期 ARM、SPARC）直接触发硬件异常（bus error）。

编译器的解决方案：Padding#

编译器会自动在结构体成员之间插入填充字节（padding），确保每个成员都对齐到其自然对齐边界：

类型	大小	对齐要求（`alignof`）
`char`	1	1
`short`	2	2
`int`	4	4
`float`	4	4
`double`	8	8
指针（64-bit）	8	8

规则是：成员的起始地址必须是其 alignof 的整数倍，而 结构体整体的大小必须是最大成员对齐要求的整数倍。

演示：字段顺序大不同#

1
#include <iostream>
2

3
struct Bad {
4
    char  a;    // 1 字节，offset 0
5
    // padding: 7 字节（为了让 b 对齐到 8）
6
    double b;   // 8 字节，offset 8
7
    char  c;    // 1 字节，offset 16
8
    // padding: 3 字节（为了让 d 对齐到 4）
9
    int   d;    // 4 字节，offset 20
10
    // padding: 4 字节（结构体大小需是 8 的倍数）
11
};              // sizeof(Bad) = 32
12

13
struct Good {
14
    double b;   // 8 字节，offset 0
15
    int    d;   // 4 字节，offset 8
16
    char   a;   // 1 字节，offset 12
17
    char   c;   // 1 字节，offset 13
18
    // padding: 2 字节（结构体大小需是 8 的倍数）
19
};              // sizeof(Good) = 16
20

21
int main() {
22
    std::cout << "sizeof(Bad)  = " << sizeof(Bad)  << "\n";  // 32
23
    std::cout << "sizeof(Good) = " << sizeof(Good) << "\n";  // 16
24

25
    std::cout << "\nBad 各成员 offset:\n";
26
    Bad bobj{};
27
    std::cout << "  a: " << (char*)&bobj.a - (char*)&bobj << "\n";  // 0
28
    std::cout << "  b: " << (char*)&bobj.b - (char*)&bobj << "\n";  // 8
29
    std::cout << "  c: " << (char*)&bobj.c - (char*)&bobj << "\n";  // 16
30
    std::cout << "  d: " << (char*)&bobj.d - (char*)&bobj << "\n";  // 20
31

32
    std::cout << "\nGood 各成员 offset:\n";
33
    Good gobj{};
34
    std::cout << "  b: " << (char*)&gobj.b - (char*)&gobj << "\n";  // 0
35
    std::cout << "  d: " << (char*)&gobj.d - (char*)&gobj << "\n";  // 8
36
    std::cout << "  a: " << (char*)&gobj.a - (char*)&gobj << "\n";  // 12
37
    std::cout << "  c: " << (char*)&gobj.c - (char*)&gobj << "\n";  // 13
38

39
    return 0;
40
}

输出：

1
sizeof(Bad)  = 32
2
sizeof(Good) = 16
3

4
Bad 各成员 offset:
5
  a: 0
6
  b: 8
7
  c: 16
8
  d: 20
9

10
Good 各成员 offset:
11
  b: 0
12
  d: 8
13
  a: 12
14
  c: 13

同样的四个成员，换个顺序，结构体从 32 字节缩到 16 字节。大原则：按对齐要求从大到小排列成员。 存一百万个这样的结构体，差了 16 MB，cache 命中率差距显著。

`attribute((packed))` 与 `alignas`#

如果你真的需要消除 padding（比如解析网络协议包、读取二进制文件），可以用：

1
struct __attribute__((packed)) NetworkHeader {
2
    uint8_t  version;
3
    uint16_t length;
4
    uint32_t checksum;
5
};
6
// sizeof = 7，没有 padding

代价：每次访问未对齐的成员，CPU 都要多做一次读取和拼接，性能下降。在某些 RISC 架构上甚至直接崩溃（bus error）。用之前想清楚。

反过来，如果需要强制更高的对齐（比如 SIMD 需要 32 字节对齐），用 C++11 的 alignas：

1
struct alignas(32) SimdFriendly {
2
    float data[8];  // 256-bit AVX 向量，需要 32 字节对齐
3
};
4

5
static_assert(alignof(SimdFriendly) == 32);

追踪内存分配#

调试内存泄漏和性能问题时，了解程序到底做了多少次堆分配非常有用。C++ 允许重载全局 operator new 和 operator delete，我们可以借此插入追踪逻辑。

1
#include <iostream>
2
#include <cstdlib>
3

4
// 简单的分配追踪器
5
struct AllocStats {
6
    size_t total_allocated = 0;
7
    size_t total_freed = 0;
8
    size_t alloc_count = 0;
9
    size_t free_count = 0;
10
};
11

12
static AllocStats g_stats;
13
static bool g_tracking = false;  // 防止追踪器自身的分配被计入
14

15
void* operator new(size_t size) {
16
    if (g_tracking) {
17
        g_stats.total_allocated += size;
18
        ++g_stats.alloc_count;
19
        std::cout << "[ALLOC] " << size << " bytes (累计 "
20
                  << g_stats.alloc_count << " 次, "
21
                  << g_stats.total_allocated << " 字节)\n";
22
    }
23
    return std::malloc(size);
24
}
25

26
void operator delete(void* ptr) noexcept {
27
    if (g_tracking) {
28
        ++g_stats.free_count;
29
    }
30
    std::free(ptr);
31
}
32

33
void operator delete(void* ptr, size_t size) noexcept {
34
    if (g_tracking) {
35
        g_stats.total_freed += size;
36
        ++g_stats.free_count;
37
    }
38
    std::free(ptr);
39
}
40

41
int main() {
42
    g_tracking = true;
43

44
    std::cout << "=== 分配一个 int ===\n";
45
    int* p1 = new int(42);
46

47
    std::cout << "\n=== 分配一个 double 数组 ===\n";
48
    double* p2 = new double[10];
49

50
    std::cout << "\n=== std::string 内部分配 ===\n";
51
    std::string s = "Hello, memory model!";  // 短字符串可能走 SSO，不触发堆分配
52

53
    std::cout << "\n=== 统计 ===\n";
54
    std::cout << "总分配次数: " << g_stats.alloc_count << "\n";
55
    std::cout << "总分配字节: " << g_stats.total_allocated << "\n";
56

57
    delete p1;
58
    delete[] p2;
59

60
    std::cout << "总释放次数: " << g_stats.free_count << "\n";
61
    std::cout << "泄漏检测: "
62
              << (g_stats.alloc_count == g_stats.free_count ? "无泄漏" : "有泄漏！")
63
              << "\n";
64

65
    g_tracking = false;
66
    return 0;
67
}

典型输出：

1
=== 分配一个 int ===
2
[ALLOC] 4 bytes (累计 1 次, 4 字节)
3

4
=== 分配一个 double 数组 ===
5
[ALLOC] 80 bytes (累计 2 次, 84 字节)
6

7
=== std::string 内部分配 ===
8
（短字符串 SSO，无堆分配）
9

10
=== 统计 ===
11
总分配次数: 2
12
总分配字节: 84
13
总释放次数: 2
14
泄漏检测: 无泄漏

这个技巧在做性能调优时非常好用：某个看似无害的函数调用了多少次 new？std::vector 在 push_back 时扩容了几次？一目了然。

TIP
生产环境里推荐用 Valgrind（Linux）、AddressSanitizer（-fsanitize=address）或者 Heaptrack，功能更完整，无需修改代码。

CUDA / GPU 侧的内存对齐（AI Infra 视角）#

GPU 的内存体系和 CPU 类似，但对齐的重要性更上一个量级。

GPU 的栈与堆#

每个 CUDA thread 有自己的私有栈，用于存放局部变量和函数调用帧（存在寄存器文件里，溢出时放 local memory）。全局内存（cudaMalloc 分配）就是 GPU 的”堆”，访问延迟约 200-800 个时钟周期，比 L1 cache 慢两个数量级。

Coalesced Access：GPU 对齐的核心#

GPU 的内存控制器以 32 字节或 128 字节的事务（transaction）为单位读取全局内存。一个 warp（32 个 thread）同时发出内存请求时，硬件会尝试把这些请求合并成尽量少的事务——这就是 coalesced memory access。

如果 warp 里的 32 个 thread 访问连续对齐的内存，只需要 1 次事务：

1
thread 0 → addr 0
2
thread 1 → addr 4
3
thread 2 → addr 8
4
...
5
thread 31 → addr 124
6
→ 1 次 128 字节事务，完美 coalesced

如果访问是跳跃的（stride access）或者起始地址未对齐，就可能退化成 32 次独立事务，带宽利用率从 100% 掉到 3%。

1
// 好的访问模式：AoS → SoA
2
// 差（Array of Structs）:
3
struct Particle { float x, y, z, w; };
4
__global__ void bad_kernel(Particle* p, int n) {
5
    int i = blockIdx.x * blockDim.x + threadIdx.x;
6
    // thread 0 访问 p[0].x，thread 1 访问 p[1].x
7
    // 地址间隔 16 字节（sizeof(Particle)），不连续
8
    float val = p[i].x;
9
}
10

11
// 好（Struct of Arrays）:
12
struct Particles { float* x; float* y; float* z; float* w; };
13
__global__ void good_kernel(Particles p, int n) {
14
    int i = blockIdx.x * blockDim.x + threadIdx.x;
15
    // thread 0 访问 p.x[0]，thread 1 访问 p.x[1]
16
    // 地址连续，完美 coalesced
17
    float val = p.x[i];
18
}

cudaMalloc 保证返回的地址至少 256 字节对齐，所以堆分配本身没问题。需要注意的是自定义结构体的内存布局和数组起始地址的对齐。

CUDA 提供了 __align__ 关键字（类似 CPU 的 alignas）来强制对齐，配合向量类型（float4、int2 等）能最大化内存访问效率：

1
// 用 float4 一次读 16 字节，减少内存事务次数
2
__global__ void vectorized_kernel(float4* data, int n) {
3
    int i = blockIdx.x * blockDim.x + threadIdx.x;
4
    if (i < n / 4) {
5
        float4 v = data[i];  // 一次 16 字节读取，4 个 float
6
        v.x *= 2.0f;
7
        v.y *= 2.0f;
8
        v.z *= 2.0f;
9
        v.w *= 2.0f;
10
        data[i] = v;
11
    }
12
}

小结#

	栈	堆
分配速度	极快（一条指令）	较慢（找空闲块、可能系统调用）
容量	小（~8 MB）	大（~GB 级）
生命周期	由作用域决定	手动管理（RAII / 智能指针）
碎片问题	无	有（长期运行后）
适合场景	小对象、短生命周期	大对象、动态大小、跨作用域

内存对齐的核心原则：

按对齐要求从大到小排列结构体成员，节省空间
用 sizeof 和 offsetof 验证你的假设
__attribute__((packed)) 消除 padding，但有性能代价
CUDA 里优先用 SoA 布局和向量类型，确保 coalesced access

分配追踪：

开发阶段重载 operator new/delete 快速定位热点
生产/测试阶段用 Valgrind、AddressSanitizer、Heaptrack

理解这些底层机制，写出来的代码不只是”能跑”，而是真的快。

程序的内存全貌#

栈（Stack）#

分配的本质：一条指令#

函数调用时发生了什么#

栈的限制#

堆（Heap）#

分配的代价#

堆的优势#

内存对齐（Memory Alignment）#

CPU 读内存的基本单元#

编译器的解决方案：Padding#

演示：字段顺序大不同#

__attribute__((packed)) 与 alignas#

追踪内存分配#

CUDA / GPU 侧的内存对齐（AI Infra 视角）#

GPU 的栈与堆#

Coalesced Access：GPU 对齐的核心#

小结#

`attribute((packed))` 与 `alignas`#