补充专题 on Dorkytiger 的小屋

内存分配器

Mon, 01 Jan 0001 00:00:00 +0000

好的，我们从第一个盲区开始补齐：内存分配器（Memory Allocator）。

这是无锁编程中最容易被忽视的"隐藏杀手"。你精心设计了一个无锁队列，所有 CAS 操作都完美，结果发现性能还是上不去——很可能是 new 和 delete 在背后拖了后腿。

1. 问题：`malloc` 是个"全局锁"

当我们调用 new / delete（底层是 malloc / free）时，背后是一个全局堆管理器在干活。

[线程A] new 对象 → 进入 malloc()
                    │
                    ▼
              [全局堆锁] ← 线程A 拿到锁，开始分配内存
                    │
[线程B] new 对象 → 进入 malloc() → 等待全局堆锁 → 阻塞！
[线程C] new 对象 → 进入 malloc() → 等待全局堆锁 → 阻塞！

硬件视角：

全局堆锁本质上是一个 Mutex（或自旋锁），多个线程争抢时会产生缓存行乒乓（MESI RFO）。
每次 malloc/free 都可能触发系统调用（brk / mmap），陷入内核态。
频繁分配/释放时，锁开销可能超过业务逻辑本身。

结论：无锁数据结构本身很快，但 malloc 的全局锁会让你的多线程程序退化成串行执行。

2. 解决方案：Per-CPU / Per-Thread 内存池

核心思想：让每个线程/核心拥有自己独立的内存池，分配时无需加锁。

NUMA（非统一内存访问）

Mon, 01 Jan 0001 00:00:00 +0000

这是多插槽服务器（如双路 Xeon、AMD EPYC、ARM 服务器）上最容易被忽视的性能杀手。你在单颗桌面 CPU 上跑得飞快的程序，搬到多插槽服务器上可能性能直接腰斩——十有八九是 NUMA 在作祟。

1. 什么是 NUMA？（物理拓扑视角）

在传统的 UMA（Uniform Memory Access，统一内存访问） 架构中，所有 CPU 核心通过同一条总线（或同一个内存控制器）访问所有物理内存，延迟一致。

在 NUMA 架构中，每个 CPU 插槽（Socket）拥有自己独立的内存控制器和本地内存。CPU 插槽之间通过高速互联（如 Intel UPI、AMD Infinity Fabric）连接。

+-----------------------------------------------------------+
|                    NUMA 双插槽服务器                        |
+-----------------------------------------------------------+
|  Socket 0 (CPU 0)          |  Socket 1 (CPU 1)            |
|  +-------------------+     |  +-------------------+        |
|  | 核心 0-7          |     |  | 核心 8-15         |        |
|  | L1/L2/L3 缓存     |     |  | L1/L2/L3 缓存     |        |
|  +-------------------+     |  +-------------------+        |
|  | 内存控制器 (MC0)  |     |  | 内存控制器 (MC1)  |        |
|  +--------+----------+     |  +--------+----------+        |
|           |                |           |                   |
|  +--------v----------+     |  +--------v----------+        |
|  | 本地内存 (Node 0) |     |  | 本地内存 (Node 1) |        |
|  | 延迟: ~80ns       |     |  | 延迟: ~80ns       |        |
|  +-------------------+     |  +-------------------+        |
|           |                |           |                   |
|           +----[UPI 互联]---+-----------+                   |
|               跨插槽访问延迟: ~160ns (2倍!)                  |
+-----------------------------------------------------------+

核心事实：

无锁编程的 ABA 问题实战解法

Mon, 01 Jan 0001 00:00:00 +0000

这是无锁编程中最隐蔽、最难调试的陷阱——比内存分配器更"邪门"，因为它在单线程下完全不存在，只有在多线程高并发下才会随机触发，导致数据损坏或程序崩溃。

1. ABA 问题的本质（硬件视角回顾）

我们之前讲过 ABA 问题的硬件根源，现在从实战角度重新审视：

// 场景：无锁栈的 pop 操作（有 ABA 漏洞）
std::atomic<Node*> head{nullptr};

bool pop(Node*& result) {
    Node* old_head = head.load(std::memory_order_acquire);
    Node* new_head;
    do {
        if (!old_head) return false;
        new_head = old_head->next;  // ← 读取 old_head 的 next
    } while (!head.compare_exchange_weak(old_head, new_head,
              std::memory_order_release, std::memory_order_relaxed));
    
    result = old_head;  // ← 此时 old_head 可能已经被其他线程释放！
    return true;
}

ABA 攻击时序：

[时刻 T1] 线程A 读取 head = 节点X (地址 0x1000)
[时刻 T2] 线程B 弹出节点X → head = 节点Y
[时刻 T3] 线程B 释放节点X（delete / free）
[时刻 T4] 线程B 分配新节点Z，恰好复用地址 0x1000
[时刻 T5] 线程B push 节点Z → head = 0x1000
[时刻 T6] 线程A 执行 CAS：当前 head (0x1000) == 期望值 (0x1000) → ✅ 成功！
          new_head = old_head->next = 0x1000->next (此时是节点Z的next)
          head = new_head（可能是垃圾地址）

结果：head 指向了完全无关的地址，数据结构被破坏。

CPU 指令级优化（SIMD / 预取）

Mon, 01 Jan 0001 00:00:00 +0000

这是从**“算法对”到“代码跑得快”的最后一公里。你之前学的都是宏观架构**（缓存、内存、调度），而 SIMD 和预取是微观指令级的优化——让 CPU 的每个流水线周期都塞满有用的工作。

1. SIMD（单指令多数据流）：一条指令干一堆活

什么是 SIMD？

SIMD（Single Instruction, Multiple Data）是 CPU 的并行处理扩展，允许一条指令同时对多个数据执行相同的操作。

标量（Scalar）：一条指令处理一个数据
+--------+     +--------+
| ADD R1 | --> |  A + B  |  (1 次操作)
+--------+     +--------+

SIMD（向量化）：一条指令处理 N 个数据
+--------+     +--------+--------+--------+--------+
| ADD ZMM | --> | A1+B1  | A2+B2  | A3+B3  | A4+B4  |  (4 次操作，1 条指令)
+--------+     +--------+--------+--------+--------+

硬件实现（x86 / ARM 的 SIMD 单元）

架构	指令集	寄存器宽度	同时处理数据量（单精度浮点）
x86 (Intel/AMD)	SSE	128-bit	4 个 float
x86 (Intel/AMD)	AVX2	256-bit	8 个 float
x86 (Intel/AMD)	AVX-512	512-bit	16 个 float
ARM (手机/服务器)	NEON	128-bit	4 个 float
ARM (服务器)	SVE2	可变（最高 2048-bit）	可变

硬件结构：

性能测量方法论

Mon, 01 Jan 0001 00:00:00 +0000

这是把前面所有理论落地到实践的工具箱。没有测量，你的一切优化都是盲人摸象——你以为快了，实际上可能更慢了；你以为瓶颈在 A，实际上在 B。

我们不讲空话，直接上**硬件性能计数器（PMC）和火焰图（Flamegraph）**这两把“屠龙刀”。

1. 性能测量的核心工具：硬件性能计数器（PMC）

PMC（Performance Monitoring Counters） 是 CPU 内部的硬件计数器，可以精确记录各种微架构事件，如：

Cache Miss（L1/L2/L3 未命中次数）
TLB Miss（地址翻译未命中次数）
分支预测失败（Branch Misprediction）
CPU 周期数（Cycles）
指令执行数（Instructions）
内存带宽（Memory Bandwidth）

这些计数器是纯硬件的，不依赖操作系统采样，几乎没有性能开销（<1%）。

硬件实现

[CPU 核心]
    │
    ├── 执行单元（ALU）
    │   └── 计数器：指令执行数、周期数
    │
    ├── 缓存系统（L1/L2/L3）
    │   └── 计数器：Cache Miss、Cache Hit、缓存行传输
    │
    ├── MMU / TLB
    │   └── 计数器：TLB Miss
    │
    └── 分支预测器
        └── 计数器：分支预测成功/失败

2. Linux `perf`：最强大的硬件性能分析工具

perf 是 Linux 内核自带的性能分析工具，封装了 CPU 的 PMC，可以精确测量程序的硬件行为。

补充专题 on Dorkytiger 的小屋

内存分配器

1. 问题：malloc 是个"全局锁"

2. 解决方案：Per-CPU / Per-Thread 内存池

NUMA（非统一内存访问）

1. 什么是 NUMA？（物理拓扑视角）

无锁编程的 ABA 问题实战解法

1. ABA 问题的本质（硬件视角回顾）

CPU 指令级优化（SIMD / 预取）

1. SIMD（单指令多数据流）：一条指令干一堆活

什么是 SIMD？

硬件实现（x86 / ARM 的 SIMD 单元）

性能测量方法论

1. 性能测量的核心工具：硬件性能计数器（PMC）

硬件实现

2. Linux perf：最强大的硬件性能分析工具

1. 问题：`malloc` 是个"全局锁"

2. Linux `perf`：最强大的硬件性能分析工具