↓ Skip to main content
  1. Posts/

NVIDIA MPS:既然有 CUDA Streams,为什么还需要跨进程并发?

·4621 words·10 mins
Note: This article is available in Chinese only. 本文暂无英文版本。 View original

之前在写 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 的命令,在依赖关系和硬件资源允许时,可以并发执行。

层级关系大致是这样的:

CUDA 执行层级:Process -> Context -> Streams -> Kernels

关键区分在于:

同一个 Context 内,不同 Streams 的 Kernel 可以通过 GPU 的 Concurrent Scheduling 同时执行。这是 CUDA 本身就支持的能力——只要 SM 有空余,不同 Stream 的 Kernel 可以共享执行资源。

不同 Context 之间,默认的调度方式是 Time-Sliced Scheduling。GPU 在不同 Context 的工作之间交替分配执行时间,而不是让它们同时占用 SM。

默认 Time-Slicing 与 MPS Concurrent Execution 对比

需要说明: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 架构:Daemon / Server / Client

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 自然会尝试并发执行。这种情况下,一切都在掌控之中。

场景对比:单进程多 Stream vs 多进程独立 Context

但现实中很多情况不是这样。

想象一个具体的场景:一台机器上同时跑着 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 SchedulingMPS 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 OFF494.878 ms
MPS ON211.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 OFF158.674 ms~1.015 TB/s
MPS ON117.377 ms~1.372 TB/s

初看 MPS ON 带宽更高。但单 Process、单 Stream 的测试结果是这样的:

Streams聚合有效带宽
11365.431 GB/s
21374.132 GB/s
41372.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 才提交短任务。

实验 C:Long Kernel 运行中提交 Short Kernel
执行方式Short Host Time
Short 单独运行1.928 ms
同 Context / 双 Streams1.500 ms
双 Context / MPS OFF5.070 ms
双 Context / MPS ON1.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 ATPContext 可见 SM 数
30%32
70%74

这个数字是通过 cudaDevAttrMultiProcessorCount 查到的——设置了 ATP 之后,Client 看到的可用 SM 数量变少了。

ATP:资源上限不等于资源预留

但这里有个容易踩的坑: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。

维度MPSMIG
目标多进程并发共享硬件级资源隔离
SM 资源共享,ATP 控制上限物理划分到各实例
HBM共享竞争独立 Memory Partition
性能干扰存在实例间大幅减少
灵活性动态,Client 随时接入需要预先配置 Profile
适用 GPUVolta+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 更合适,但灵活性要让步。

参考资料
#

Related

Numerical Stability in ML Systems:从浮点误差到 GPU 计算

起因:H20 上 FP64 只有 1 TFLOPS,但计算要的是双精度 # 写这篇笔记的直接原因是一块 H20。业务里有一块对数值精度敏感的计算,需要接近 FP64 的结果,但 H20 的 FP64 算力只有 1 TFLOPS。对照同一张卡的其他规格,这个数字有多别扭很直观:FP32 是 44 TFLOPS,FP16/BF16 Tensor Core 是 148 TFLOPS,FP8 是 296 TFLOPS,FP64 只有 1——不到 FP32 的四十分之一,而满血的 H100 上 FP64 是 34 TFLOPS。

从 Register Tiling 到 Cache Tiling:理解高性能计算中的 Data Reuse

最近在看 CMU 15-442 的 Hardware Acceleration。课件翻到 Register Tiling,一个 2×3 output tile 的例子。我盯着那页 slide 看了一会儿——Register Tiling 这个词不陌生,但要我说清楚它和 Cache Tiling 的区别,以及它们到底在优化什么,我发现自己的理解一直停在"把矩阵切成小块"这个表面。

从 Dense FFN 到 MoE:Router、Token Dispatch 与 Grouped GEMM

·5127 words·11 mins
上一篇 MoE 笔记把架构家族理了一遍——稀疏、稠密、Soft MoE,gate 在前还是在后,决定了算力形态和适用场景。 但那篇有一段伪代码一直让我不太舒服: 1for prob, idx in zip(topk_probs.unbind(1), topk_idx.unbind(1)): 2 out += prob.unsqueeze(1) * self.experts[idx](x) 逻辑上没问题。但想象一下真实场景:一个 batch 有几千个 token,每个 token 选 2 个 expert,就是上万个 token-expert 计算任务。用 Python for loop 逐个调 expert 的 forward,GPU 利用率会低得离谱。

深入理解 PyTorch DDP:为什么更少的通信,不一定意味着更快的训练?

起因 # 上一篇讨论完 Checkpointing 和 Offloading 之后,结尾留了一句:单卡优化的代价已经不可接受时,下一步自然是考虑让多张 GPU 分担训练状态。 于是我开始看 DDP(DistributedDataParallel)。一开始觉得 DDP 的核心思想很直白——每张卡各算各的梯度,然后 All-Reduce 同步一下,用平均梯度更新参数。看起来最朴素的做法就是把所有梯度打包成一个大 tensor 做一次 All-Reduce,简单干净。