CPU、GPU 并行加速

情景：为了模型训练，我需要生成数据集，状态-控制 时间轨迹。但是由于动辄十万条轨迹，数据生成实在是太慢了。

什么是并行计算？

Serial Computing 串行计算

传统上，软件是为 串行计算 编写的：问题被分解为一系列离散的指令，指令一个接一个顺序地在单个处理器上执行，任何时刻只能执行一条指令。

Parallel Computing 并行计算

从最简单的意义上讲，并行计算 是指 同时使用多个计算资源来解决计算问题：一个问题被分解为可以并行解决的离散部分，每个部分进一步分解为一系列指令，采用一种整体控制/协调机制，使得 每个部分的指令在不同的处理器上同时执行。

• 计算问题 应具备以下能力：

  • 能够分解 为可以同时解决的离散工作单元；
  • 在任何时刻可以执行多个程序指令；
  • 使用多个计算资源比使用单个计算资源所需时间更短。

• 计算资源 通常是：

  • 一台具有 多个处理器/核心 的单台计算机
  • 通过网络连接的任意数量的此类计算机

Parallel Computers 并行计算机

几乎所有独立的计算机 在硬件层面上都是并行的：多个功能单元（L1 缓存、L2 缓存、分支、预取、解码、浮点运算、图形处理（GPU）、整数等），多个执行单元/核心，多个硬件线程。

比如，IBM BG/Q 计算芯片，拥有 18 个核心（PU）和 16 个 L2 缓存单元（L2），

网络 将多个独立计算机（节点）连接起来，以形成更大的 并行计算机集群。

CPU 并行 —— 进程与线程

• 进程（Process） 是 程序的执行实例，可以理解为程序在操作系统中运行起来后的一个“容器”。每个进程都有独立的内存空间、代码段、数据段等，进程是系统资源分配的最小单位。

  📌 举个例子：打开一个 Word 文档，就相当于启动了一个 Word 的进程。如果你再开一个 Word 文档，就是另一个进程。

• 线程（Thread） 是进程中的执行单元，是 程序执行的最小单位。一个进程可以有多个线程，这些线程 共享该进程的资源（内存、文件等）。线程是 CPU 调度的最小单位。

  📌 举个例子：在 Word 进程里，可能一个线程负责文字输入，另一个线程负责拼写检查，还有一个负责保存自动备份。

打开一个 终端窗口，操作系统会启动一个 bash 或 zsh 的进程，让你输入命令。你再打开一个终端，就又启动了另一个 bash/zsh 进程。这两个终端互相独立，各有各的进程 ID（PID），互不影响。

# 在终端1中
echo $$  # 查看当前终端进程的 PID，比如显示 3456# 在终端2中
echo $$  # 再打开一个终端，显示的 PID 是另一个，比如 3980

行为	是不是一个新进程？	说明
打开一个终端窗口	✅	启动了一个 shell 进程
再打开另一个终端窗口	✅	又是另一个独立的进程
在终端中运行一个程序	✅	shell 创建的子进程（子进程）
在终端中运行多个线程程序	❌ 线程不算新进程	同一进程内的多个线程

执行线程是操作系统可以独立管理的最小指令。

• 在串行区域中只有一个线程存在。
• 在并行区域中，利用 CPU 的核心启动多个线程。

多进程系统拥有超过两个进程，而多线程是一种允许单个进程拥有多个线程的程序执行技术。

场景	推荐方式	原因
CPU 密集型	多进程	避开 GIL，真正多核并行
I/O 密集型	多线程	GIL 会释放，线程够灵活

• 单进程单线程：一只狗在一个狗盆上吃狗粮。
• 单进程多线程：多只狗在同一个狗盆一起吃狗粮。
• 多进程单线程：多只狗每只狗在自己的狗盆吃狗粮。

🤔 CPU 密集型任务用多进程

在 Python 中，有个特殊机制叫 GIL（Global Interpreter Lock，全局解释器锁）：

• GIL 保证同一时间只有一个线程在执行 Python 字节码（哪怕你开了多个线程）。
• 所以，在 CPU 密集型任务中，多线程反而没法真正并行使用多核 CPU！

GIL 实际上是 Python 表示 “请一次只使用一个线程！” 的方式。

• 它是一个互斥锁（互斥排他锁），用于 保护对 Python 对象的访问，确保 Python 内存管理的线程安全。
• 它的初衷是简化内存管理（尤其是垃圾回收），但代价就是多线程无法并行执行 CPU 密集任务。

GIL 退出历史舞台了吗？ 还没有，但已经在路上了。主流的 CPython（Python 的“官方”实现）中，GIL 仍然存在。Python 3.12 和之前的版本都还在用它。Python 官方正在推进 「无 GIL 的 Python」 ！PEP 703 已被正式接受。

import threadingdef sum_numbers(start, end):total = sum(range(start, end + 1))print(f"Sum from {start} to {end}: {total}")threads = [threading.Thread(target=sum_numbers, args=(1, 5)),threading.Thread(target=sum_numbers, args=(6, 10)),threading.Thread(target=sum_numbers, args=(11, 15)),threading.Thread(target=sum_numbers, args=(16, 20))
]for t in threads:t.start()for t in threads:t.join()

• 你以为会发生什么：四个 CPU 核心同时进行计算。
• 实际上发生什么：一个线程在运行，而 GIL 说：“耐心，其他人！”导致……顺序执行。

多进程 的优势：

• 每个进程有独立的 Python 解释器和内存空间，不受 GIL 限制。
• 能真正做到 多核并行，大大提高计算效率。

📌 举个例子：你有 8 核 CPU，要同时跑 8 个复杂数学运算，多线程其实只用到了一个核，而多进程能用满 8 个核。

🤔 I/O 密集型任务用多线程

• 当线程发起 I/O 操作时，比如等网络响应，线程会被挂起。
• 此时 GIL 会被释放，其他线程可以跑！

这时候多线程的好处就体现出来了：

• 即使线程被挂起，其他线程仍然能跑
• 多线程创建、切换开销比进程小，资源占用更少
• 对于等待型操作（比如爬虫、文件读写），线程够用了

📌 举个例子：你写一个爬虫，要请求 1000 个网页，每个网页都要等 1 秒。如果你用多线程，就可以同时去“等网页”，等完就立马处理，而不是一个等完再等一个。

GIL 对于 I/O 密集型任务，如下载猫视频或读取关于猫品种的 JSON 文件，工作得相当好。当一个线程正在等待网络响应或磁盘 I/O 时，GIL 允许另一个线程介入，让你的程序看起来忙碌而高效。

import threading
import timedef fetch_data(name):print(f"Fetching data for {name}...")time.sleep(2)  # Simulates I/O delayprint(f"Done fetching data for {name}!")threads = [threading.Thread(target=fetch_data, args=("Cats",)),threading.Thread(target=fetch_data, args=("Dogs",)),threading.Thread(target=fetch_data, args=("Birds",))
]for t in threads:t.start()for t in threads:t.join()

GPU 并行加速

CPU VS GPU

CPU，通常被称为计算机的“大脑”，是执行通用计算任务的核心单元。CPU 按顺序处理任务，遵循包括获取、解码、执行和存储数据的指令周期。这种逐步的方法可以实现高精度和可靠性，使 CPU 非常适合单线程任务，如数据库查询、代码编译和复杂模拟。

GPU 是一种专门化的处理器，针对并行处理或同时处理多个信息块的任务进行了优化。GPU 最初是为了处理视频游戏和视觉应用中的图像渲染而开发的，但其 并行处理大量数据的能力，使它们对于高性能计算和人工智能开发至关重要。

与专注于精度和顺序的 CPU 不同，GPU 将大问题分解成小任务，并行处理，并汇总结果。这种架构使得 GPU 在需要对大量数据集应用相同指令的操作中表现出色。

下图展示了 CPU 和 GPU 之间硬件架构的主要差异。各种功能的晶体管数量通过不同阴影区域的相对大小进行抽象表示。在图中，绿色代表计算；黄色是指令处理；紫色是 L1 缓存；蓝色是高级缓存，橙色是内存（DRAM，实际上应该比缓存大数千倍）。

• 与 GPU 相比，CPU 可以处理更复杂的流程。
• CPU 的算术逻辑单元或浮点单元数量没有 GPU 多（大致指上面的小绿框），但 CPU 核心中的 ALU 和 FPU 在单个方面更为强大。
• CPU 的缓存内存比 GPU 多。
• 最后一点是，GPU 的设计主要是为了处理可以显著并行化的工作负载。这在图中通过每行只有一个黄色控制框来表示，对应着那些小绿计算框。

GPU 永远不能完全取代 CPU：GPU 通过允许在应用程序中 并行运行重复的计算，同时主程序继续在 CPU 上运行，从而补充 CPU 架构。CPU 可以被视为整个系统的任务大师，协调广泛的通用计算任务，而 GPU 则执行更窄范围的更专业化的任务（通常是数学任务）。利用并行计算的力量，GPU 可以在相同的时间内完成比 CPU 更多的工作。

属性	CPU	GPU
核心数	少（通常 4～16 个）	多（上千个小核心）
优势	单线程性能强，适合逻辑控制	批量数据处理快，适合并行计算
典型任务	系统任务、流程控制	图像处理、矩阵运算、模型训练

对于「大量相同维度的线性系统仿真＋PID 控制」场景，

情况	推荐方案	原因
轨迹数目较少（比如几十条以内），每条轨迹时间步又不多	CPU 多进程／多线程	启动和调度进程／线程开销小，BLAS 矩阵乘已经多线程优化得很好
轨迹数目非常多（几百、几千乃至更多），且希望一次性批量仿真	GPU 加速	能把每条轨迹的矩阵运算合并成大块批量运算，GPU 核心利用率高

• 如果只是生成 10～50 条轨迹，多进程（ProcessPoolExecutor） 匹配机器核数就能跑满 CPU，通常比把小批量矩阵拷 GPU 要快。
• 当要生成上百、上千条轨迹时，把它们 batch 在一起，就可以用一次大规模的矩阵乘 A·X + B·U，用 GPU 上千核心并行，吞吐量会远超多进程。

单卡 GPU 加速的关键技巧

1. 所有数据转到 GPU 上处理

🚫 别在每一步都把数据来回 GPU ⇄ CPU 拷贝！

# 错误：每步拷来拷去，慢得要命
for t in range(T):X_cpu = X.cuda()X_next = model(X_cpu)X = X_next.cpu()

✅ 正确：一次拷到 GPU 上，之后全在 GPU 内部完成

X = X.cuda()
U = U.cuda()
for t in range(T):X, Y = step(X, U)  # 只用 GPU tensor 运算

2. 使用批处理结构

让 GPU 干“千人一面”的活，而不是“循环一个个轨迹”。

# X: [N, 172], U: [N, 13]
X_dot = X @ A.T + U @ B.T  # N 条轨迹一次完成

相比于：

# 慢！CPU for 循环 + 每条轨迹做一遍
for i in range(N):X[i] = A @ X[i] + B @ U[i]