双卡部署大模型：TP、PP、DP 和 Layer Split 到底有什么区别？

Mon, 24 Aug 2026 10:00:00 +0800

📚 双 RTX 5060 Ti 部署 Qwen3.8 系列 · 2/6

💡 导读：

模型单卡放不下以后，“再加一张 GPU”并不是完整答案。Layer Split、Pipeline Parallel、Tensor Parallel 和 Data Parallel 看起来都是多卡推理，实际解决的却是容量、单实例加速和并发吞吐三个不同问题。

上一篇先把显存问题算清楚了：双 16GB 能不能跑 27B，首先取决于权重能不能装下，以及装完以后还剩多少运行空间。

但模型单卡放不下以后，“加一张 GPU”并不是一个完整答案。

多卡部署至少有几种完全不同的思路：

Layer Split
Pipeline Parallel（PP）
Tensor Parallel（TP）
Data Parallel（DP）

它们表面上都是“多张 GPU 跑一个模型服务”，实际解决的问题却不一样。

先记住一个最简单的结论：

Layer Split / PP
主要解决：模型装不下

TP
主要解决：模型装不下 + 单个模型实例的计算并行

DP
主要解决：并发吞吐

下面继续以这套硬件为例：

2 × RTX 5060 Ti 16GB + Qwen3.8-27B

1. Layer Split：最直观的多卡切法

假设模型有 64 层。

最简单的办法就是按层拆：

GPU0
Layer 0 ~ 31
      ↓
GPU1
Layer 32 ~ 63

原本一张 16GB GPU 放不下整个模型，现在变成：

GPU0 放一部分权重。
GPU1 放另一部分权重。

两张卡的容量都被利用起来了。

llama.cpp 的多 GPU layer split，可以先把它理解成这一类思路。

它最大的优势是灵活。

如果两张卡容量甚至不一样，例如：

GPU0：16GB
GPU1：12GB

就可以让 GPU0 多放一些层，GPU1 少放一些。

对于消费级硬件、GGUF、混合显存容量，这种模型放置方式非常实用。

Layer Split 的问题

一颗 token 在 Decode 时仍然要依次经过整套模型：

Token
 ↓
GPU0 上的前半模型
 ↓
GPU1 上的后半模型
 ↓
输出

GPU0 没完成前面的层，GPU1 后面的层就拿不到对应的 Activation。

所以它首先解决的是：

Capacity Scaling——容量扩展。

而不是自动获得：

2× Single-stream Decode Performance。

这也是整个系列里一个很重要的区分：

模型成功分到两张卡，不等于两张卡会同时为同一层工作。

2. Pipeline Parallel：也是按层切，但它是一套执行策略

Pipeline Parallel，简称 PP。

双卡 PP2 可以画成：

Stage 0              Stage 1

GPU0                 GPU1
Layer 0~31   ─────→  Layer 32~63

从模型切分上看，它和 Layer Split 很像：

不同层位于不同 GPU。

但 PP 不只是“把哪些层放哪张卡”的问题。

推理框架还会显式管理：

Pipeline Stage
Stage 间通信
Micro Batch
Pipeline Scheduling
分布式 Runtime

所以我更倾向于这样区分：

Layer Split 更像模型放置方式；PP 是完整的并行执行策略。

PP 能不能让单请求快一倍？

对于单条请求、单 token Decode，通常不能这么理解。

因为它仍然有：

GPU0 Stage
↓
GPU1 Stage

这样的前后依赖。

但当 Batch 或并发增加后，可以让不同请求处于不同 Stage：

时间 T1
GPU0：请求 A
GPU1：空闲

时间 T2
GPU0：请求 B
GPU1：请求 A

时间 T3
GPU0：请求 C
GPU1：请求 B

这时候 Pipeline 才真正“流动”起来。

因此 PP 对吞吐和多请求调度的价值，通常比对单流 Decode 延迟更明显。

3. TP：不是切 Layer，而是切 Layer 里面的矩阵

Tensor Parallel，简称 TP。

它和前面两种方式最大的区别是：

两张 GPU 会同时参与同一层的计算。

例如：

              Layer N

        ┌───────────────┐
        │               │
        ↓               ↓
      GPU0            GPU1
   Matrix Part 0   Matrix Part 1
        │               │
        └──────┬────────┘
               ↓
          通信 / 聚合
               ↓
            Layer N+1

假设一个 Linear 是：

Y = XW

可以把 W 切开：

W0 → GPU0
W1 → GPU1

两张卡同时计算：

GPU0：X × W0
GPU1：X × W1

然后再通过 Collective 把结果组合成下一步需要的形式。

在 TP2 下，从第一层到最后一层，两张 GPU 都会持续参与。

为什么 TP 更可能让双卡的单流 Decode 变快？

RTX 5060 Ti 16GB 单卡显存带宽约：

448 GB/s

Layer Split 时，一颗 token 更接近：

GPU0 读前半权重并计算
↓
GPU1 读后半权重并计算

而 TP2 更接近：

GPU0 读取这一层的一部分权重
+
GPU1 读取这一层的另一部分权重

同时进行

于是两张卡的：

显存带宽
计算单元
Tensor Core

都有机会同时参与同一个 Layer。

这也是为什么 TP 是这几种方案里，最值得拿来讨论单个模型实例加速的一种。

但 TP 不是免费的。

每层的局部结果需要通过：

AllReduce
AllGather
ReduceScatter
NCCL
PCIe / P2P

等方式交换或聚合。

所以 TP 的收益实际上是一笔账：

并行计算节省的时间
-
跨卡通信时间
-
同步与调度开销
=
最终 Scaling

到这里先不展开通信量。

因为第三篇就专门回答一个最容易凭直觉判断错的问题：

没有 NVLink、甚至没有 CUDA P2P 的消费级双卡，TP 到底还值不值得？

4. TP 和 PP 最本质的区别

可以直接看图。

PP2

GPU0
Layer 0
Layer 1
...
Layer 31
   ↓
GPU1
Layer 32
Layer 33
...
Layer 63

每个 Layer 基本只属于一个 Stage。

TP2

Layer 0  → GPU0 + GPU1
Layer 1  → GPU0 + GPU1
Layer 2  → GPU0 + GPU1
...
Layer 63 → GPU0 + GPU1

每一层，两张卡都参与。

所以最简单的一句话就是：

PP 是切 Layer，TP 是切 Layer 里面的矩阵。

这也是理解二者单流性能差异的关键。

Layer Split 和 PP 为什么看起来那么像？

因为从外面看，它们都可能是：

前半模型 → GPU0
后半模型 → GPU1

区别更像是关注点不同。

Layer Split

重点是：

权重怎么放。

典型问题是：

这张卡放多少层？
那张卡放多少层？

Pipeline Parallel

重点是：

模型如何被划成 Stage，并按 Pipeline 方式运行。

它会进一步涉及 Stage、Micro Batch 和调度。

所以二者虽然都按层切，但不能完全当成同一个概念。

5. DP：根本不是用来解决单模型显存的

Data Parallel，简称 DP。

最简单的 DP2：

GPU0
完整模型
→ 请求 A

GPU1
完整模型
→ 请求 B

两张 GPU 各放一份完整模型。

所以如果一个模型本身需要：

23GB VRAM

而单张 5060 Ti 只有：

16GB

单纯开 DP2 没有帮助。

它不会把：

16 + 16

变成一个 32GB 的模型实例。

因为每个 DP Replica 都需要自己完整的一份权重。

DP 解决的是并发吞吐

假设单个 Replica 能稳定处理一批请求。

DP2 相当于：

GPU0：Replica A
GPU1：Replica B

两张卡可以独立服务不同请求。

因此 DP 的核心目标是：

Throughput Scaling。

而不是：

Single Request Speed。

请求 A 不会因为 DP2 就自动从 30 token/s 变成 60 token/s。

但服务可以同时让另一个 Replica 去处理请求 B。

这和 TP 的目标明显不同。

6. TP、PP、DP 可以组合

真实的大规模部署往往不会只使用一种并行方式。

例如 8 张 GPU 可以做：

TP4 × DP2

也就是：

GPU0~3
→ TP4
→ Replica 1

GPU4~7
→ TP4
→ Replica 2

这里：

TP4
负责一个模型实例内部的并行

DP2
负责复制两个服务实例扩展并发

也可以做：

TP2 + PP2

四张 GPU：

Stage 0
GPU0 + GPU1
TP2

↓

Stage 1
GPU2 + GPU3
TP2

也就是层之间用 PP，层内部用 TP。

所以 TP、PP、DP 并不是互斥选项，它们是在不同维度切模型和请求。

7. 一个表看懂四种方式

方式	怎么切	扩展单实例显存	单请求加速潜力	并发扩展
Layer Split	按层放到不同 GPU	✅	较弱	一般
PP	按 Stage 分模型	✅	有限	✅
TP	每层内部切矩阵	✅	✅	间接
DP	复制完整模型	❌	❌	✅✅

如果换成实际问题：

模型单卡放不下怎么办？

优先看：

Layer Split / PP / TP

想提高单请求 Decode 速度？

优先研究：

TP

模型单卡已经能放下，只想扩大并发？

优先考虑：

DP

模型特别大，单一 TP 或 PP 都不够？

就会进入：

TP + PP

这样的组合。

8. 为什么消费级双卡特别值得测试 TP？

数据中心 GPU 的多卡环境往往拥有：

NVLink
NVSwitch
高带宽 GPU 互联

消费级 GPU 的现实则经常是：

PCIe
没有 NVLink
P2P 甚至可能不可用

这就出现了一个很自然的担心：

TP 每层都要同步，PCIe 这么慢，是不是直接把双卡并行收益吃光？

但这里不能只拿：

GPU 本地显存带宽：几百 GB/s，而 GPU 间通信：个位数或十几 GB/s。

直接下结论。

因为 TP 的收益来自两张卡同时处理自己的权重分片，而跨卡同步的也不是“把几十 GB 模型权重来回传”。

到底通信量有多大、为什么没有 P2P 也还能跑出不错的 Scaling，必须结合实际模型 hidden size、Collective 次数和实测带宽一起算。

这就是下一篇的主题。

9. 双 5060 Ti，我会怎么选？

如果模型单卡能放下：

单用户 / 单请求
→ 单卡就可能够用

大量并发
→ DP 才开始有意义

如果模型单卡放不下，又是 llama.cpp / GGUF、希望兼容不同显存容量和 CPU + GPU：

Layer Split

通常很自然。

如果使用 vLLM，希望一个模型实例同时利用两张 GPU 的计算与显存带宽：

TP2

更值得优先测试。

如果 TP 不适合当前模型、并行维度受限，或者通信条件实在太差：

PP

则可以回到容量优先的方向。

10. 结论

多 GPU 推理不能简单理解成：

多一张卡
=
多一倍性能

不同并行方式解决的是不同问题：

Layer Split：按层分权重，重点解决容量。

PP：按 Stage 分模型，重点解决超大模型和 Pipeline 吞吐。

TP：切分每一层内部的矩阵，重点解决单实例模型并行和计算性能。

DP：复制完整模型，重点解决多 Replica 并发吞吐。

其中最值得先记住的一句话还是：

PP 是切 Layer，TP 是切 Layer 里面的计算，DP 是复制整个模型。

对于双 RTX 5060 Ti，真正有意思的问题也从这里开始：

TP2 确实能让两张 GPU 同时工作，但消费级显卡又没有 NVLink。PCIe 通信到底会损失多少性能？

下一篇直接用实测回答：

《两张 RTX 5060 Ti 为什么没有两倍推理速度？显存带宽、PCIe 与 P2P》

系列导航： ← 上一篇：2× RTX 5060 Ti 16GB 能跑 27B 大模型吗？先把显存算清楚 · 下一篇：两张 RTX 5060 Ti 为什么没有两倍推理速度？显存带宽、PCIe 与 P2P →

Pipeline Parallel on Jiangwan's Blog