之前在写 GPU Execution Model 的时候,我对 SM、Warp、Block 这些概念已经有了基本的理解。但最近碰到一个场景让我停下来想了一会儿:我们有两个独立的推理服务共享同一张 A100,各自的 GPU 利用率都不高,直觉上 GPU 应该有很多空闲的执行资源。
于是我想——能不能让两个进程的 Kernel 同时跑起来?
一个看起来理所当然的事情#
A100 有 108 个 SM。假设 Process A 启动了一个只有 20 Blocks 的 Kernel——哪怕每个 Block 占一个 SM,也只用了不到五分之一的执行资源。这时候 Process B 也想提交一个 20 Blocks 的 Kernel。
在 CPU 上,这根本不是问题。两个进程各自跑各自的,OS Scheduler 把它们分到不同的核心上就行了。
但 GPU 不一样。我实际试下来发现,默认情况下两个进程的 Kernel 并不能像我想的那样自然地同时执行。这让我去翻了 CUDA 的 Context 和 Stream 机制,然后就碰到了 MPS。
CUDA Context 与 Stream:两个不同层级的东西#
要理解为什么两个进程不能直接并发,得先搞清楚 CUDA 程序访问 GPU 的层级结构。
CUDA Context 是一个程序访问 GPU 时的执行与资源管理上下文。它管理着与 GPU 相关的地址空间、执行状态、已分配的内存等资源。通常,不同的 CUDA 进程会有独立的 Context。
CUDA Stream 是 Context 内部的命令序列。同一个 Stream 中的操作按提交顺序执行;不同 Streams 的命令,在依赖关系和硬件资源允许时,可以并发执行。
层级关系大致是这样的:
关键区分在于:
同一个 Context 内,不同 Streams 的 Kernel 可以通过 GPU 的 Concurrent Scheduling 同时执行。这是 CUDA 本身就支持的能力——只要 SM 有空余,不同 Stream 的 Kernel 可以共享执行资源。
不同 Context 之间,默认的调度方式是 Time-Sliced Scheduling。GPU 在不同 Context 的工作之间交替分配执行时间,而不是让它们同时占用 SM。
需要说明:Time-Slicing 不意味着必须等 Context A 的整个 Kernel 执行完才切换到 Context B。GPU 可以在更细的粒度上做切换。但无论怎么切换,它和同 Context 内多 Stream 的并发执行是不同的机制——后者允许不同 Stream 的 Kernel 同时占用不同的 SM,而 Time-Slicing 在某个时间片内只有一个 Context 的工作在执行。
MPS 改变了什么#
MPS 全称 Multi-Process Service。它的核心思想:允许多个独立 CUDA 进程的 GPU 工作并发利用同一块 GPU 的执行资源。
在 Volta 架构及之后的 GPU 上,MPS 的实现方式是:每个 Client 进程保留自己独立的 GPU 地址空间,但它们的 Kernel 可以被同时调度到 GPU 的不同 SM 上执行——类似于同一个 Context 内多个 Streams 的并发效果,但跨越了进程边界。
MPS 的运行架构包含三个角色:MPS Control Daemon 管理整个 MPS 的生命周期;MPS Server 是实际的 GPU Context 持有者,负责汇聚和调度来自多个 Client 的 GPU 工作;Client 就是普通的 CUDA 应用程序,它们连接到 MPS Server 后可以透明地提交 Kernel,不需要修改任何代码。
几个容易误解的地方:
- MPS 不会把两个不同进程的 CUDA Grid 合并成一个。
- MPS 不会增加 GPU 的硬件算力或 HBM 带宽。
- MPS 不保证所有 Client 的工作都能同时执行,也不保证使用 MPS 一定能提速。
它改变的是不同 Context 之间的调度方式——从 Time-Sliced 变成可以 Concurrent Execution。
既然有 CUDA Streams,为什么还需要 MPS#
这是我想了最久的问题。
先看一个不需要 MPS 的场景。如果我自己写一个 CUDA 程序,内部有多个相互独立的计算任务,我可以把它们放到不同的 Non-blocking Streams 里。同一个 Context,不同 Streams,GPU Scheduler 自然会尝试并发执行。这种情况下,一切都在掌控之中。
但现实中很多情况不是这样。
想象一个具体的场景:一台机器上同时跑着 python train.py 和 python inference.py。这两个程序生命周期独立,各自有自己的 CUDA Context,可能用不同版本的 PyTorch,由不同的团队维护,分别有独立的部署和故障处理逻辑。
它们各自内部可以用多个 CUDA Streams。但这解决不了跨进程的问题——两个独立的 Context,默认就是 Time-Sliced。
如果不用 MPS,想让两个独立进程的 GPU 工作并发,理论上可以把所有工作统一提交给一个 GPU Worker Process。但这意味着:
- 架构重构——两个独立应用要变成一个应用的子模块。
- IPC 和任务调度——需要设计工作提交、结果回传的通信机制。
- 生命周期耦合——Worker 挂了,所有应用都受影响。
- 多团队协调——框架版本、依赖、发布节奏都要对齐。
MPS 的价值在于:不需要改变应用的进程架构,就能让多个独立 CUDA 应用共享 GPU 的并发执行能力。
这就是 Streams 和 MPS 的本质区别——Streams 解决的是一个应用内部的并发;MPS 解决的是多个独立应用之间的并发。
| 维度 | 多 Streams(同 Context) | MPS(跨 Context) |
|---|---|---|
| 适用范围 | 同一进程内部 | 多个独立进程 |
| 是否需要代码修改 | 需要显式创建 Stream | 对应用透明 |
| 并发机制 | GPU Concurrent Scheduling | MPS Server 汇聚调度 |
| 地址空间 | 共享 | 各 Client 独立(Volta+) |
| 故障隔离 | 同进程,无隔离 | 进程级别隔离 |
用 A100 实际测一下#
以上都是机制层面的理解。接下来用真实实验看看 MPS 到底能带来多少差异。
实验环境:NVIDIA A100-SXM4-40GB(108 SM),CUDA 12.0,Driver 575.57.08。使用自定义 CUDA C++ Benchmark,CPU Wall Clock 和 CUDA Events 计时。这些是探索性实验,不是严格的性能评测,没有用 Nsight 采集逐 Kernel 的硬件时间线。
Compute + Compute#
两个独立进程,各执行 20 Blocks × 256 Threads × 10 次 Kernel Launch,每个 Thread 内做大量 FMA 运算。
| 配置 | Paired Makespan |
|---|---|
| MPS OFF | 494.878 ms |
| MPS ON | 211.942 ms |
约 2.33 倍的 Makespan 加速。
这个结果符合预期:单个 20 Blocks 的 Grid 远没有填满 108 个 SM。MPS 让两个进程的 Kernel 有机会同时占用不同的 SM,所以总完成时间显著下降。
但需要注意——不能把这个结果简单理解为 MPS 提升了单个 Kernel 的 FMA 算力。20 Blocks 也不等于严格占用 20 个 SM。这是一个 Small-Grid、Compute-Heavy 的合成负载,不是所有 Compute-Bound Kernel 都会获得 2.33 倍加速。
Memory + Memory#
两个进程各自执行 Memory-Bound Kernel(大量 Global Memory 读写)。
| 配置 | Paired Makespan | 聚合有效带宽 |
|---|---|---|
| MPS OFF | 158.674 ms | ~1.015 TB/s |
| MPS ON | 117.377 ms | ~1.372 TB/s |
初看 MPS ON 带宽更高。但单 Process、单 Stream 的测试结果是这样的:
| Streams | 聚合有效带宽 |
|---|---|
| 1 | 1365.431 GB/s |
| 2 | 1374.132 GB/s |
| 4 | 1372.411 GB/s |
单进程单 Stream 就已经达到约 1.36 TB/s。增加 Streams 没有带来有意义的吞吐提升——说明这个 Kernel 本身已经能较好地利用 HBM 带宽。
所以 MPS ON 的 1.372 TB/s 并不是"MPS 创造了更多带宽",而是 MPS 让两个进程更有效地共享了已有的执行资源。MPS OFF 的额外耗时,可能与跨 Context 的调度开销有关,但仅凭现有数据不能把差异完全归因于 Context Switch Overhead。
MPS 能提高多进程场景下的资源利用效率,但不会提高 GPU 的硬件带宽上限。
另外需要说明:这里的"有效带宽"是 Algorithmic Bandwidth(用传输数据量除以 Wall Clock 时间),不等于用硬件计数器测到的真实 HBM DRAM Throughput。
Long Kernel + Short Kernel#
这个实验验证 MPS 对延迟敏感型短任务的影响。Long Kernel(54 Blocks,~500 万次循环/Thread,GPU Event 区间约 122–144 ms)模拟后台计算任务;Short Kernel(20 Blocks,50000 次循环/Thread)模拟延迟敏感的短任务。
Long Kernel 的 GPU 代码发出启动信号后,Short Process 才提交短任务。
| 执行方式 | Short Host Time |
|---|---|
| Short 单独运行 | 1.928 ms |
| 同 Context / 双 Streams | 1.500 ms |
| 双 Context / MPS OFF | 5.070 ms |
| 双 Context / MPS ON | 1.497 ms |
同 Context 双 Streams:Short Kernel 延迟很低,因为两个 Kernel 可以并发执行。
双 Context、MPS OFF:Short Kernel 延迟明显上升——它需要等待 Context 调度切换。
双 Context、MPS ON:延迟恢复到接近双 Streams 的水平。
这个结果支持了之前的机制解释:MPS 让不同 Context 的 Kernel 有机会并发,从而减少了短任务的等待时间。
但必须严谨地说明这个实验的局限:这只有单次测量,没有统计置信区间;Long Kernel 的实际 GPU 时间(~122–144 ms)和最初的校准目标有偏差;Host Time 不等于完整的端到端延迟;没有逐 Kernel 的 GPU Timeline 数据。所以这个约 3.39 倍的延迟差异是一次观察,不是所有场景下的稳定收益。
ATP:限制上限,不是固定分配#
MPS 提供了一个控制旋钮:CUDA_MPS_ACTIVE_THREAD_PERCENTAGE(ATP)。它限制每个 MPS Client 能使用的执行资源上限。
在 A100 上实测:
| Client ATP | Context 可见 SM 数 |
|---|---|
| 30% | 32 |
| 70% | 74 |
这个数字是通过 cudaDevAttrMultiProcessorCount 查到的——设置了 ATP 之后,Client 看到的可用 SM 数量变少了。
但这里有个容易踩的坑:ATP 是资源的可用量上限(ceiling),不是资源的固定预留(reservation)。
用一个 CPU 侧的类比:ATP 更像 Cgroup 的 CPU Limit(你最多能用这么多),而不是 CPU Reservation(给你留着这么多)。设置 ATP=30% 并不意味着有 32 个 SM 被物理地、独占地分配给了这个 Client。其他 Client 的工作仍然可能使用这些 SM。
更重要的是,ATP 只约束执行资源(SM / Thread Slots)。HBM、L2 Cache、Memory Fabric 这些资源仍然被所有 Client 共享竞争。ATP 不是 QoS 保证,不能替代真正的硬件隔离。
MPS 和 MIG:共享与隔离的取舍#
MPS 解决的是多进程并发共享 GPU 的问题,但它没有提供强隔离。如果需要更强的资源隔离和性能可预测性,NVIDIA 在 A100 等 GPU 上提供了 MIG(Multi-Instance GPU)。
MPS 偏向提高利用率:多个 Client 共享 GPU 的 SM、HBM、Cache 等资源,能并发执行,但一个 Client 的突发负载可能影响另一个。适合彼此信任、对性能干扰有容忍度的工作负载。
MIG 偏向隔离:把 GPU 的部分硬件资源(计算、内存、带宽)划分成独立的实例,每个实例之间有硬件级别的隔离。代价是分区后每个实例的资源总量变小,灵活性也受限于预定义的 Profile。
| 维度 | MPS | MIG |
|---|---|---|
| 目标 | 多进程并发共享 | 硬件级资源隔离 |
| SM 资源 | 共享,ATP 控制上限 | 物理划分到各实例 |
| HBM | 共享竞争 | 独立 Memory Partition |
| 性能干扰 | 存在 | 实例间大幅减少 |
| 灵活性 | 动态,Client 随时接入 | 需要预先配置 Profile |
| 适用 GPU | Volta+ | A100、H100 等支持 MIG 的 GPU |
需要注意:MIG 也不能消除所有形式的干扰(比如 PCIe 带宽仍然是共享的),但它比 MPS 提供了明显更强的隔离保证。
什么时候值得开 MPS#
回到工程判断。
场景一:单个程序内部有多个可并行的 GPU 任务。 直接用 CUDA Streams。你已经控制了整个 Context,Stream 层面的并发是最自然、最高效的方式。
场景二:多个独立 GPU 应用共享一张卡,单个应用没有打满 GPU。 考虑 MPS。尤其是 Small-Grid 的 Kernel、或者计算和访存互补的工作负载混合在一起时,MPS 能显著减少资源闲置。
场景三:多租户、需要可预测的性能隔离。 MPS 和 ATP 不够。应该考虑 MIG、专卡分配,或者更严格的调度策略。
几个提醒:
- MPS 不是所有 GPU 利用率问题的默认答案。如果单个应用已经把相关资源打满(比如 HBM 带宽已经饱和),MPS 不会带来吞吐收益,甚至可能引入竞争。
- 不能简单把
nvidia-smi的 GPU Utilization 数值提高当作所有业务都变快的证据。 - 对在线推理服务,必须同时关注 Throughput 和 Tail Latency。
- MPS Server 是一个额外的运行时依赖。需要考虑它的启动、故障恢复,以及一个 Client 崩溃是否会影响其他 Client。
写在最后#
串起来看,这篇想说清楚的核心其实就一句话:
CUDA Streams 解决一个应用内部的 GPU 并发;MPS 让多个原本独立的 CUDA 应用,在不改变进程架构的前提下,共享 GPU 的并发执行能力。
更深一层:MPS 不创造额外的计算能力或 HBM 带宽,它改变的是不同 CUDA Context 的工作共同利用 GPU 的方式。
几个值得记住的点:
- 同 Context 的多 Streams 可以并发执行,但这解决不了跨进程的调度边界。
- 不同 Context 默认是 Time-Sliced,MPS 把它变成 Concurrent Execution。
- MPS 对 Small-Grid、资源互补的多进程负载效果最明显。
- ATP 是上限约束,不是资源预留,更不是性能隔离。
- 需要强隔离时,MIG 比 MPS 更合适,但灵活性要让步。
参考资料#
- NVIDIA. Multi-Process Service Architecture.
- NVIDIA. When to Use MPS.
- NVIDIA. MPS Environment Variables.
- NVIDIA. CUDA C++ Programming Guide — CUDA Streams.
- NVIDIA. A100 GPU Architecture Whitepaper.
- GPU Execution Model:为什么大量 Warps 能隐藏内存延迟?
- GPU 的数据存在哪?——从 HBM 到片上存储的存储层级
- 从 FLOPs 到 Latency:GPU 推理性能到底由什么决定?
- 从参数量到 Peak Memory:模型显存到底应该怎么算?