C++ 多线程与 OpenMP
多核不会自动让普通串行 C++ 变快。必须把可独立工作拆开，并处理共享数据、同步、粒度与负载均衡。
1. std::thread：显式线程
cpp
#include <thread>
#include <vector>
void scale(float* x, std::size_t begin, std::size_t end, float k) {
for (std::size_t i = begin; i < end; ++i) x[i] *= k;
}
std::thread a(scale, data, 0, n / 2, 2.0f);
std::thread b(scale, data, n / 2, n, 2.0f);
a.join();
b.join();join() 等待线程结束，也建立必要的同步关系。真实程序更常用线程池，避免为大量小任务频繁创建线程。
2. 数据竞争不是普通逻辑错误
两个线程并发访问同一内存位置，至少一个是写，并且缺少同步，就构成 data race；在 C++ 内存模型中通常导致未定义行为。
cpp
// wrong: shared counter++ from multiple threads
// choices: mutex, atomic, thread-local partial result + reduction互斥锁保护复合不变量；原子适合可由原子操作表达的共享状态；局部结果最后归约往往扩展性更好。原子不等于“整段算法线程安全”。
3. OpenMP：用指令描述并行区域
cpp
double sum = 0.0;
#pragma omp parallel for reduction(+:sum)
for (int i = 0; i < n; ++i) {
sum += a[i];
}典型编译参数：GCC/Clang 使用 -fopenmp，MSVC 使用相应 OpenMP 选项。是否支持某个 OpenMP 版本取决于编译器与运行时。
关键概念：
parallel创建线程团队；for将循环迭代分配给线程；reduction为线程建立局部值并在末尾合并；private/firstprivate控制变量副本；critical、atomic、barrier提供不同同步语义；task更适合不规则任务图，而不只是规则循环。
4. 调度策略
| 策略 | 适合 | 代价 |
|---|---|---|
static | 每次迭代成本接近 | 调度开销低，负载不均时可能闲置 |
dynamic | 迭代成本差异大 | 负载更均衡，调度开销更高 |
guided | 开始大块、随后缩小 | 在开销与均衡之间折中 |
不要看到不均衡就机械改 dynamic；先测量每项工作差异和任务粒度。
5. 常见性能陷阱
- 临界区放进热循环，线程大部分时间等待；
- 多线程写同一 Cache line 的不同变量，产生伪共享；
- 任务过小，调度成本高于计算；
- 首次触碰内存与线程所在 NUMA 节点不匹配；
- 嵌套并行导致线程过量，反而频繁切换；
- 只比较墙钟时间一次，没有固定输入与线程数。
深入原理与工程实践
前面的内容负责建立统一心智模型；下面把同一主题继续拆到执行过程、代码、性能代价与工程判断。
<!-- migrated-deep-dive:start -->
完整迁入：原 OpenMP 与 SIMD 全文
CPU 并行编程——OpenMP 与 SIMD 向量化 / CPU Parallel Programming with OpenMP and SIMD
📅 创建时间：2026-06-02 🏷️ 标签：#CPU #OpenMP #SIMD #AVX512 #并行化 #向量化 📚 前置知识：[[01-computer-architecture-basics]]（CPU 架构） 📚 相关知识：[[04-cuda-programming-model]]（CUDA 编程，对比学习） [[09-heterogeneous-computing]]（异构计算）
先抓住直觉
CPU 也有两种“同时做”：OpenMP 把不同任务交给多个 CPU 核心，SIMD 让一个核心用一条指令处理多个数据。前者像增加工人，后者像让每个工人一次端多盘菜。
- 必须理解：线程级并行与数据级并行的区别；数据竞争；并行归约。
- 用到再查：pragma 子句、AVX Intrinsics 和编译器参数。
- 读完能回答：为什么 CPU 数据预处理会让 GPU 空等？OpenMP 和 SIMD 能否叠加？
场景：GPU 在训练，CPU 也不能闲着
┌─────────────────────────────────────────────────────────────┐
│ │
│ 深度学习训练不只是 GPU 的工作： │
│ │
│ GPU 负责： │
│ - 前向传播（矩阵乘法） │
│ - 反向传播（梯度计算） │
│ │
│ CPU 负责： │
│ - 数据加载：从 SSD/HDD 读取训练数据 │
│ - 数据预处理：数据增强、归一化、Tokenization │
│ - 分布式协调：多卡梯度同步的控制逻辑 │
│ - 日志记录、Checkpoint 保存 │
│ │
│ 如果 CPU 处理太慢，会拖慢整个训练流程！ │
│ 本章学习如何用 OpenMP + SIMD 加速 CPU 端计算。 │
│ │
└─────────────────────────────────────────────────────────────┘第1节：OpenMP——几行代码实现多核并行
什么是 OpenMP？
┌─────────────────────────────────────────────────────────────┐
│ OpenMP 是什么？ │
├─────────────────────────────────────────────────────────────┤
│ │
│ OpenMP = Open Multi-Processing │
│ 一套编译器指令（#pragma omp），告诉编译器如何并行化 │
│ │
│ 对比 CUDA： │
│ CUDA：需要学习新的编程模型（kernel、grid、block） │
│ OpenMP：在现有 C++ 代码上加几行 #pragma │
│ │
│ 本质： │
│ 自动把 for 循环分配到多个 CPU 核心 │
│ 编译器生成线程创建/管理代码，程序员只需加指令 │
│ │
└─────────────────────────────────────────────────────────────┘最简单的例子
cpp
// C++ 单线程版本
#include <vector>
float sum = 0.0f;
for (int i = 0; i < 1000000; i++) {
sum += data[i];
}cpp
// OpenMP 并行版本（只加了一行）
#include <vector>
#include <omp.h> // OpenMP 头文件
float sum = 0.0f;
#pragma omp parallel for
for (int i = 0; i < 1000000; i++) {
sum += data[i]; // ⚠️ 问题：多线程同时写 sum，需要归约
}并行归约（Reduction）
cpp
// ❌ 错误：多线程同时写 sum，竞态条件（race condition）
#pragma omp parallel for
for (int i = 0; i < 1000000; i++) {
sum += data[i]; // 多个线程同时读-改-写同一个变量
}
// ✅ 正确：使用 reduction 子句
#pragma omp parallel for reduction(+:sum)
for (int i = 0; i < 1000000; i++) {
sum += data[i];
}
// reduction(+:sum) 的含义：
// 1. 每个线程有自己的 sum 副本（初始化为 0）
// 2. 每个线程累加到自己的 sum
// 3. 最后把所有线程的 sum 加起来常用 OpenMP 子句
┌─────────────────────────────────────────────────────────────┐
│ OpenMP 常用子句 │
├─────────────────────────────────────────────────────────────┤
│ │
│ #pragma omp parallel for [子句...] │
│ │
│ 常用子句： │
│ - reduction(op:list) 归约操作 │
│ - schedule(kind, chunk) 循环调度策略 │
│ - num_threads(n) 指定线程数 │
│ - collapse(n) 把 n 层循环合并为一维并行 │
│ - nowait 去掉隐式 barrier（同步） │
│ │
│ schedule 子句： │
│ - static: 循环均匀分块（编译时确定） │
│ - dynamic: 动态分块（运行时按需分配） │
│ - guided: 动态递减块大小 │
│ - runtime: 由 OMP_SCHEDULE 环境变量决定 │
│ │
└─────────────────────────────────────────────────────────────┘矩阵乘法的 OpenMP 版本
cpp
// OpenMP 矩阵乘法
void matrix_mul_openmp(float* C, float* A, float* B,
int M, int N, int K) {
#pragma omp parallel for collapse(2)
for (int i = 0; i < M; i++) {
for (int j = 0; j < N; j++) {
float sum = 0.0f;
for (int k = 0; k < K; k++) {
sum += A[i * K + k] * B[k * N + j];
}
C[i * N + j] = sum;
}
}
}
// collapse(2) 把两层循环合并为一个 2D 循环
// 原来：M 个外层迭代
// 合并后：M × N 个迭代，并行度更高线程数控制
cpp
// 方式1：运行时函数
omp_set_num_threads(16); // 设置后续 parallel 的线程数
// 方式2：环境变量
// export OMP_NUM_THREADS=16
// 方式3：子句
#pragma omp parallel for num_threads(8)
// 方式4：系统自动（推荐）
// 不设置，让 OpenMP 自动选择 = CPU 核心数第2节：SIMD 向量化——一条指令处理多个数据
SIMD 原理
┌─────────────────────────────────────────────────────────────┐
│ SIMD：单指令多数据 │
├─────────────────────────────────────────────────────────────┤
│ │
│ 标量计算（一次处理一个数）： │
│ CPU: [ALU] → result │
│ 执行 4 次：4 × 4 周期 = 16 周期 │
│ │
│ SIMD 计算（一次处理 8 个 float）： │
│ CPU: [ALU][ALU][ALU][ALU][ALU][ALU][ALU][ALU] │
│ → 一次执行 8 个结果，1 个周期完成 │
│ │
│ AVX-512 = 512 位 = 16 × 32-bit float = 16 个 float │
│ SSE = 128 位 = 4 × 32-bit float │
│ NEON = ARM 的 SIMD = 128 位 │
│ │
└─────────────────────────────────────────────────────────────┘手动 SIMD（Intrinsics）
cpp
// 使用 AVX-512 intrinsics（Intel/AMD x86）
#include <immintrin.h>
void vector_add_avx512(float* a, float* b, float* c, int N) {
// 一次处理 16 个 float（16 × 32-bit = 512-bit）
for (int i = 0; i < N; i += 16) {
// __m512 = 512-bit 寄存器（16 个 float）
__m512 va = _mm512_loadu_ps(&a[i]); // 加载 16 个 float
__m512 vb = _mm512_loadu_ps(&b[i]);
__m512 vc = _mm512_add_ps(va, vb); // 16 个加法并行执行
_mm512_storeu_ps(&c[i], vc); // 存储结果
}
}
// 常用 intrinsics：
// _mm512_loadu_ps / _mm512_storeu_ps 加载/存储
// _mm512_add_ps / _mm512_sub_ps 加减
// _mm512_mul_ps / _mm512_div_ps 乘除
// _mm512_fmadd_ps 融合乘加（a*b+c）
// _mm512_set1_ps 创建常数向量融合乘加（FMA）——矩阵乘法的关键
cpp
// 普通计算：2 次操作
c[i] = a[i] * b[i] + c[i];
// 编译后可能需要 2 条指令
// FMA：1 次操作（乘加融合）
// c[i] = a[i] * b[i] + c[i]
__m512 va = _mm512_loadu_ps(&a[i]);
__m512 vb = _mm512_loadu_ps(&b[i]);
__m512 vc = _mm512_loadu_ps(&c[i]);
vc = _mm512_fmadd_ps(va, vb, vc); // vc = va * vb + vc
_mm512_storeu_ps(&c[i], vc);
// FMA 优点：
// 1. 减少指令数（性能提升）
// 2. 减少舍入误差（一次运算 vs 两次）OpenMP 自动向量化
cpp
// 编译器自动 SIMD 化（GCC/Clang 需要 -O3 -march=native）
#pragma omp parallel for simd
for (int i = 0; i < N; i++) {
c[i] = a[i] + b[i];
}
// simd 子句告诉编译器：循环可以安全地向量化
// 编译器会自动选择 SIMD 宽度和指令第3节：OpenMP + SIMD 组合使用
完整的数据预处理流水线
cpp
// 场景：图像数据增强（CPU 端）
struct ImageBatch {
float* data; // [batch][channel][height][width]
int batch_size;
int channels;
int height;
int width;
};
// 数据归一化：减去均值，除以标准差
void normalize_batch(float* data, int N,
const float* mean, const float* std,
float* output) {
#pragma omp parallel for schedule(static)
for (int i = 0; i < N; i++) {
#pragma omp simd
for (int c = 0; c < 3; c++) {
output[i * 3 + c] =
(data[i * 3 + c] - mean[c]) / std[c];
}
}
}
// 关键：omp parallel for + omp simd
// - parallel for：多核并行（16 核 = 16 倍）
// - simd：单核内向量并行（16 float/次 = 16 倍）
// - 总计：16 × 16 = 256 倍加速！实际性能数据
┌─────────────────────────────────────────────────────────────┐
│ 性能测试对比（Intel Xeon 8380） │
├─────────────────────────────────────────────────────────────┤
│ │
│ 测试：1000 张 224×224×3 图像归一化 │
│ │
│ 单线程（无 SIMD） 5000 ms │
│ 单线程（AVX-512） 600 ms 8x 加速 │
│ 16 核（无 SIMD） 320 ms 16x 加速 │
│ 16 核 + AVX-512 40 ms 125x 加速！ │
│ │
│ OpenMP（多核）+ SIMD（向量化）= 双重加速 │
│ │
└─────────────────────────────────────────────────────────────┘第4节：与 CUDA 的对比
┌─────────────────────────────────────────────────────────────┐
│ OpenMP vs CUDA │
├─────────────────────────────────────────────────────────────┤
│ │
│ OpenMP：CPU 多核并行 │
│ - 核心数：8-64 核 │
│ - 内存：共享内存（无需拷贝） │
│ - 编程：加 #pragma 即可 │
│ - 适用：数据预处理、IO 密集任务 │
│ │
│ CUDA：GPU 大规模并行 │
│ - 核心数：上千核 │
│ - 内存：独立显存（需要拷贝） │
│ - 编程：学习新的编程模型 │
│ - 适用：计算密集任务（矩阵乘法、卷积） │
│ │
│ 组合使用： │
│ CPU：数据加载 + 预处理（OpenMP+SIMD 加速） │
│ GPU：模型训练（CUDA 加速） │
│ 两者通过 PCIe 传输数据 │
│ │
└─────────────────────────────────────────────────────────────┘"AI 可查 vs 必须理解"清单
AI 可查：
✅ AVX-512 intrinsics 的具体函数（_mm512_loadu_ps 等）
✅ OpenMP schedule 的具体参数选择
✅ OpenMP 和 SIMD 组合的最佳实践参数
必须理解：
🔴 OpenMP #pragma omp parallel for 的工作原理（自动创建线程池）
🔴 reduction 子句：解决多线程写同一变量的竞态条件
🔴 SIMD = 单指令多数据 = 一次处理多个数据
🔴 AVX-512 = 512 位 = 16 个 float 并行
🔴 OpenMP（多核）+ SIMD（向量化）= 双重加速叠加学习状态：🟡 开始学习
完整迁入：原 CPU 并行全文
CPU 并行：多线程、SIMD、Cache 一致性与 NUMA / CPU Parallelism with Threads, SIMD, Cache Coherence, and NUMA
📅 创建时间：2026-07-20 🏷️ 标签：#CPU #多线程 #SIMD #NUMA #OpenMP 📚 前置知识：[[02-processor-architecture]] 📚 相关知识：[[/02-systems-and-performance/02-computer-architecture-and-hardware/07-openmp-simd]] [[/01-cpp/06-concurrency/04-concurrency]]
1. CPU 并行的三个层次
text
线程级并行：多个核心执行不同线程
数据级并行：一条 SIMD 指令处理多个元素
任务级并行：不同任务组成流水线或任务图例如矩阵运算可以把行分给多个线程，每个线程内部再使用 AVX 指令一次计算多个浮点数。
2. 线程并行
线程创建不是免费的
创建和销毁线程涉及系统调用、栈空间和调度，因此工程中通常使用线程池。
text
任务提交 → 工作队列 → 固定数量工作线程 → 执行结果线程数量并非越多越好：
- 计算密集型任务通常接近物理核心数
- I/O 密集型任务可以更多
- 使用 SMT 时需要实际测量
- 第三方数学库可能已经创建线程，避免嵌套过度并行
OpenMP 示例
cpp
#pragma omp parallel for
for (int i = 0; i < n; ++i) {
output[i] = compute(input[i]);
}OpenMP 适合逐步并行化规则循环，但仍需检查数据竞争和任务粒度。
3. SIMD 向量化
标量加法一次处理一个元素：
text
a0+b0 → c0256 位 AVX 指令可以一次处理 8 个 FP32：
text
[a0..a7] + [b0..b7] → [c0..c7]编译器自动向量化偏爱：
- 连续内存访问
- 简单、固定次数的循环
- 迭代之间没有依赖
- 容易证明指针不重叠
- 分支较少
不利示例
cpp
for (int i = 1; i < n; ++i) {
a[i] = a[i - 1] * 0.5f; // 当前迭代依赖前一次结果
}这是循环携带依赖，不能直接并行执行各次迭代。
4. 数据竞争与同步
cpp
counter++; // 读取、加一、写回，并非不可分割操作多个线程同时修改会导致结果丢失。常用保护方式：
- Mutex：保护复杂临界区
- Atomic：保护简单原子状态
- Reduction：每个线程局部计算，最后合并
- 消息传递：避免共享可变状态
并行归约通常优于每次循环都锁住全局变量。
5. 伪共享
即使线程修改不同变量，只要变量位于同一个 Cache Line，也可能互相使缓存失效。
cpp
struct Counters {
long a; // 线程 A 修改
long b; // 线程 B 修改，但可能与 a 在同一 Cache Line
};常见处理方法：
- 对高频写入的线程局部变量进行 Cache Line 对齐
- 每线程维护局部统计值
- 降低共享写入频率
伪共享不会造成结果错误，但会造成严重性能下降。
6. NUMA：内存也有远近
多路服务器中，每颗 CPU 插槽通常连接自己的本地内存。
text
CPU 0 ─ 本地内存 0
│
互联总线
│
CPU 1 ─ 本地内存 1CPU 0 访问内存 1 的延迟更高、带宽可能更低，这就是非统一内存访问 NUMA。
NUMA 优化原则
- First Touch：由实际使用数据的线程首次初始化数据
- 线程绑定：避免线程在不同 NUMA 节点之间迁移
- 数据分区：让线程主要访问本地内存
- 测量远程访问比例，而不是凭感觉绑定
7. CPU 并行适用场景
CPU 更适合：
- 分支复杂、任务差异大的计算
- 数据规模较小、要求低延迟的计算
- 图遍历、搜索、编译、数据库执行
- 操作系统和 I/O 协调
- GPU kernel 前后的数据准备与控制
GPU 更适合并不意味着 CPU 不重要。多数异构应用都依赖 CPU 组织整个执行流程。
章节检查清单
- 循环迭代是否相互独立？
- 任务粒度是否显著大于调度成本？
- 是否存在共享写入和伪共享？
- 编译器是否成功向量化？
- 线程和数据是否跨越 NUMA 节点？
- 数学库是否已经在内部并行？
下一篇：[[04-memory-hierarchy]] <!-- migrated-deep-dive:end -->
面试速答
OpenMP 是处理器吗？ 不是。它是一套共享内存并行编程接口，由编译器指令、运行时库和环境变量共同实现。
什么时候用 std::thread，什么时候用 OpenMP？ 需要长期线程、精细生命周期和自定义同步时偏向 C++ 并发设施；规则循环和科学计算快速并行化时 OpenMP 更直接。
单核能运行多线程吗？ 能并发运行，但 CPU 密集线程通常通过时间片交替，不会获得真正多核并行吞吐。
自测
volatile能否修复 data race？- 为什么 reduction 常比每次加锁好？
- 线程数为何不应盲目超过逻辑 CPU 数量？
答案：不能；它把频繁共享更新变成局部累积和少量合并；过量线程会增加切换、竞争和缓存压力，除非等待型工作另有理由。