一台 GPU 不够用:用 vLLM 跨两台 NVIDIA DGX Station 部署 GLM-5.3
在本地部署前沿级大模型要求将所有权重驻留在 GPU 显存中,而最新模型已无法单卡容纳。通过 ConnectX-8 RDMA 连接两台 NVIDIA DGX 工作站,即可通过单一端点服务同一个模型,利用张量并行将模型权重与计算任务分摊到两块 GPU 上。
NVIDIA 发布的 GLM-5.3 NVFP4 模型是 Z.ai 混合专家(MoE)架构的量化版本,总参数量达 7530 亿,每个 token 激活 400 亿参数。虽然稀疏激活机制降低了计算量,但由于每个 token 可能被路由至不同专家,全部模型权重仍必须保持可用。该模型检查点体积约为 464 GB,超过了单块 GB300 GPU 252 GB 的 HBM3e 显存容量。本教程使用两台 DGX 工作站将权重完整载入 GPU 显存,并禁用 CPU 权重卸载功能。
开始前,请先按照《连接两台 DGX 工作站操作指南》完成两台设备的互联。
本文演示如何在两台 NVIDIA DGX 工作站上利用 vLLM 本地部署 GLM-5.3 模型,发送测试请求,并测量其在并发负载下的表现。张量并行(TP=2)将模型张量拆分至两块 GB300 GPU。两台工作站协同处理每个请求,最终由工作站 A 通过统一的 OpenAI 兼容 API 返回结果。读完本文,你将拥有一个可用的服务端点,并了解其在负载下的基准表现。
前置条件
- 两台运行 Linux 系统的 GB300 DGX 工作站,已按照《连接两台 DGX 工作站操作指南》完成连接与验证,包括在双链路(rails)上执行的 GPU 显存 RDMA 测试。
- 两台 Station 都要有相同的 Linux 用户名,并能使用 SSH 和 sudo。Docker 和 NVIDIA Container Toolkit 已随 DGX Station 软件栈预装。需允许访问容器镜像仓库、Hugging Face 和软件包仓库的外网连接。
- 每台 Station 至少有 464 GB 的空闲磁盘空间,用于存放 checkpoint 副本,另外还要为 vLLM 容器镜像和临时文件留出空间。
- 需接受 NVIDIA Open Model Agreement 以及 GLM-5.3 原始许可条款(见模型页面)。SPEED-Bench 则受 NVIDIA Evaluation Dataset License Agreement 约束。
- 需要一个 Hugging Face 账号和只读访问令牌,并能访问受限的 cais/hle 数据集:登录后打开该数据集页面,选择 Agree and access repository。第 5 步将从该数据集下载 SPEED-Bench 提示词。
配套视频的流程与本文相同。
步骤 1:准备两台 Station
本教程使用另一台电脑(比如你的笔记本)来管理两台 Station。先在这台电脑上分别与两台 Station 建立 SSH 会话;也可以直接在每台 Station 的本地终端操作。本步骤中的所有命令都要在两台 Station 上执行,除非命令前标注了“On A”。
两台 Station 运行相同的容器和 checkpoint,但角色不同:Station A(rank 0)负责提供 API,Station B(rank 1)只作为 worker 运行,不启动 API 服务。
首先,确认 Docker 可用,并收集稍后会用到的网络信息:
docker version ibdev2netdev ip -br addr
注: 如果 docker version 的输出中没有 Server 部分,说明客户端无法连接到 Docker 守护进程。如果错误显示 permission denied,请按照Docker 安装后配置指南操作:使用 sudo usermod -aG docker "$USER" 将当前用户加入 docker 组,执行 exit 退出,重新连接后再运行 docker version。docker 组拥有 root 级别权限。 |
|---|
ibdev2netdev 的输出列出了两条直连网线 cx8r0 和 cx8r1。选定其中一条用于承载流量(例如 cx8r1),并在每台工作站上记下它的两项信息:
- 其 RDMA 设备名:查看
ibdev2netdev输出中以该网线名结尾的那一行。例如在mlx5_1 port 1 ==> cx8r1 (Up)中,设备名为mlx5_1。 - 其 IPv4 地址:查看
ip -br addr输出中以该网线名开头的那一行。例如在cx8r1 UP 192.168.101.1/24中,地址为192.168.101.1。
两台工作站上的网线名和设备名相同,仅 IPv4 地址不同。
接下来,在每台工作站上创建 ~/glm53.env 文件,用于存储后续命令所需的变量:
nano ~/glm53.env
粘贴以下内容,并将每个 <...> 占位符替换为你刚才记下的值,注意保留引号。
RANK="<NODE_RANK>" # Station A 上填 RANK="0",Station B 上填 RANK="1"
HEAD_IP="<STATION_A_IPV4_ADDRESS>" # Station A 的 IPv4 地址;两个文件里保持一致
WORKER_IP="<STATION_B_IPV4_ADDRESS>" # Station B 的 IPv4 地址;两个文件里保持一致
RAIL_IFACE="<RAIL_NAME>" # 选定的 rail,例如 cx8r1;两个文件里保持一致
RAIL_HCA="<RDMA_DEVICE>" # 记录的 RDMA 设备,例如 mlx5_1;两个文件里保持一致
IMG=vllm/vllm-openai:v0.30.0-aarch64
IMG+=@sha256:4864d46625cbc3307623e29ac742030655e27249feba7b97ec925ce4cc4dfb56
MODEL_REPO=nvidia/GLM-5.3-NVFP4
MODEL_REV=e3b8f9f2fad29727dfa95e766c5cac18ea1414bf
MODEL_HOST="$HOME/models/GLM-5.3-NVFP4"
CONTAINER=glm53-full
PORT=8000
if [ "$RANK" = 0 ]; then
NODE_IP=$HEAD_IP; PEER_IP=$WORKER_IP
else
NODE_IP=$WORKER_IP; PEER_IP=$HEAD_IP
fi
GPU_UUID=$(nvidia-smi --query-gpu=uuid,name --format=csv,noheader |
awk -F, '$2 ~ /GB300/ {gsub(/ /,"",$1); print $1; exit}')
比如使用默认地址和 cx8r1,Station A 的文件开头如下。Station B 的文件与之相同,只是 RANK="1":
RANK="0"
HEAD_IP="192.168.101.1"
WORKER_IP="192.168.101.2"
RAIL_IFACE="cx8r1"
RAIL_HCA="mlx5_1"
MODEL_HOST 基于你的主目录生成,第 2 步会通过 SSH 把 checkpoint 复制到 Station B 上的相同路径。
注意:后面的步骤都会先执行 source ~/glm53.env 来加载这些变量。每次新开 SSH 会话时都要重新执行这条命令。 |
|---|
在两台 Station 上加载变量,并检查存储、连通性和基线显存:
source ~/glm53.env
mkdir -p "$MODEL_HOST" && df -h "$MODEL_HOST"
ethtool "$RAIL_IFACE"
ip link show dev "$RAIL_IFACE"
ping -I "$RAIL_IFACE" -M do -s 8972 -c 3 "$PEER_IP"
timedatectl show -p NTPSynchronized --value
nvidia-smi
这些检查能在问题演变成 NCCL 超时之前,提前发现布线和地址配置上的错误。预期结果是链路速率 400000Mb/s、MTU 9000、巨型帧 ping 成功、时间已同步。nvidia-smi 应显示 GB300 上没有计算进程。在配有显示 GPU 的 Station 上,两块 GPU 可能都会出现占用几 MiB 的 Xorg 进程,这是正常的。
提示:关注 nvidia-smi 显示的 GPU 内存使用情况,第 4 步会将该数值与已加载模型进行比对。 |
|---|
第 2 步通过 SSH 从 A 机复制 checkpoint 到 B 机,因此 A 机需具备对 B 机的免密登录权限。在 A 机上创建一个不带密码短语的密钥(具体操作参见SSH 密钥),在核实 B 机的主机指纹后,将公钥复制到 B 机,并验证登录状态:
ssh-keygen -t ed25519
ssh-copy-id "$WORKER_IP"
ssh -o BatchMode=yes "$WORKER_IP" hostname
第 2 步:下载并复制模型
张量并行要求两个 rank 针对相同的权重运行相同的软件。首先,在两台机器上拉取固定的镜像版本:
docker pull "$IMG" &&
docker image inspect "$IMG" --format '{{.Architecture}} {{.RepoDigests}}'
拉取过程可能需要几分钟。若两者的 arm64 digest 一致,说明两个 rank 运行的是完全相同的软件。
在 A 机上下载固定的 checkpoint。由于体积约为 464 GB,在 1 Gb/s 带宽下需耗时约一小时,而在 10 Gb/s 带宽下仅需约六分钟:
mkdir -p "$MODEL_HOST"
docker run --rm --network host -v "$MODEL_HOST:/model" \
--entrypoint bash "$IMG" -lc \
"exec hf download '$MODEL_REPO' --revision '$MODEL_REV' --local-dir /model"
当 hf download 输出 Downloaded 后,将文件复制到 B 机。在 A 机上执行:
ssh "$WORKER_IP" "mkdir -p '$MODEL_HOST'" &&
rsync -aH --info=progress2 --exclude '.cache/' \
"$MODEL_HOST/" "$WORKER_IP:$MODEL_HOST/"
每块磁盘都保留完整的 checkpoint;vLLM 在加载时会跨 GPU 对权重进行分区,不再进行额外的量化处理。
在 A 机上比对两份拷贝(校验过程通过 SSH 读取 B 机的文件列表),然后验证 checkpoint:
(
set -euo pipefail
L=$(find "$MODEL_HOST" -path '*/.cache' -prune -o \
-type f -printf '%P %s\n' | LC_ALL=C sort | sha256sum)
R=$(ssh "$WORKER_IP" "set -o pipefail; find '$MODEL_HOST' \
-path '*/.cache' -prune -o -type f -printf '%P %s\\n' | \
LC_ALL=C sort | sha256sum")
test "$L" = "$R"
test "$(find "$MODEL_HOST" -maxdepth 1 \
-name 'model-*-of-00050.safetensors' | wc -l)" = 50
python3 -c "import json; c=json.load(open('$MODEL_HOST/config.json')); \
assert c['architectures']==['GlmMoeDsaForCausalLM']; \
assert c['quantization_config']['quant_algo']=='MIXED_PRECISION'"
echo MODEL_READY
)
MODEL_READY 表示两台 Station 上的文件名、大小和目录布局完全一致。MIXED_PRECISION 属于预期结果:NVFP4 量化只作用于 MoE 模块的线性层权重和激活值,而非所有张量。
第 3 步:启动分布式服务
这一步会把两台机器整合成一个服务:同一份启动脚本在两台 Station 上运行,读取 ~/glm53.env,并在各自机器上启动一个 vLLM rank。如果要改动配置,最关键的两个参数是:--max-model-len 98304,即上下文长度上限(以 token 计,包含输入和输出);以及 --gpu-memory-utilization 0.93,即让 vLLM 使用 93% 的 GPU 显存。其他参数如果要调整,请一次只改一个并重新测试。
最新的推荐配置可参考 NVIDIA 的 Local AI 配方仓库。
安全提示:--host 0.0.0.0 配合 --network host 会把未经身份验证的 API 暴露在 Station A 的所有网络接口上,包括管理接口。请用防火墙限制端口访问范围,并在对外提供更广泛访问之前加上身份验证和 TLS。 |
|---|
在两台 Station 上分别创建名为 ~/launch-glm53.sh 的文件:
nano ~/launch-glm53.sh
该脚本会启用多 token 预测(MTP),这是一种投机解码方式:模型的 MTP 层每步草拟 4 个 token,vLLM 再用完整模型验证后决定是否采纳,因此每一步可以产出多个 token。实际收益取决于草拟 token 的采纳率,而采纳率会随提示词的不同而变化。
相比 16 位存储,FP8 KV 缓存可将缓存内存减半,从而腾出空间容纳更多 token。同时开启前缀缓存,避免重复处理服务端已经识别过的 prompt 前缀。粘贴下方脚本,它会校验配置、找到所选 rail 对应的 RoCE GID 索引,并在容器内启动本台 Station 的 vLLM rank:
set -euo pipefail
source "$HOME/glm53.env"
case "$RANK" in 0|1) ;; *) echo "Invalid RANK" >&2; exit 1;; esac
test -n "$GPU_UUID"
test -f "$MODEL_HOST/config.json"
GID_INDEX=$(/usr/sbin/show_gids 2>/dev/null |
awk -v d="$RAIL_HCA" -v ip="$NODE_IP" \
'$1==d && $5==ip && $6=="v2" {g=$3} END {if(g!="") print g}')
test -n "$GID_INDEX"
HEADLESS=
if [ "$RANK" = 1 ]; then HEADLESS=--headless; fi
SPEC_CONFIG='{"method":"mtp","num_speculative_tokens":4}'
KERNEL_CONFIG='{"enable_flashinfer_autotune":false,"moe_backend":"flashinfer_cutlass"}'
COMPILE_CONFIG='{"cudagraph_mode":"FULL_DECODE_ONLY","cudagraph_capture_sizes":[5,10,20,40,80],"pass_config":{"fuse_allreduce_rms":false}}'
docker run -d --name "$CONTAINER" \
--gpus device="$GPU_UUID" --network host --ipc host --shm-size 32g \
--device /dev/infiniband --cap-add IPC_LOCK \
--ulimit memlock=-1 --ulimit stack=67108864 \
-v "$MODEL_HOST:/model:ro" \
-e RANK="$RANK" -e HEADLESS="$HEADLESS" \
-e MASTER_ADDR="$HEAD_IP" -e MODEL_REPO="$MODEL_REPO" -e PORT="$PORT" \
-e SPEC_CONFIG="$SPEC_CONFIG" -e KERNEL_CONFIG="$KERNEL_CONFIG" \
-e COMPILE_CONFIG="$COMPILE_CONFIG" \
-e NCCL_CUMEM_ENABLE=1 -e NCCL_IB_HCA="$RAIL_HCA" \
-e NCCL_IB_GID_INDEX="$GID_INDEX" \
-e NCCL_IB_TIMEOUT=22 -e NCCL_IB_RETRY_CNT=7 \
-e VLLM_ALLREDUCE_USE_FLASHINFER=0 -e VLLM_ALLREDUCE_USE_SYMM_MEM=0 \
-e NCCL_SOCKET_IFNAME="$RAIL_IFACE" -e GLOO_SOCKET_IFNAME="$RAIL_IFACE" \
-e NCCL_NET_GDR_LEVEL=5 -e NCCL_DEBUG=INFO -e NCCL_DEBUG_SUBSYS=INIT,NET \
-e NCCL_DEBUG_FILE='/tmp/nccl_%h_%p.log' -e VLLM_HOST_IP="$NODE_IP" \
-e VLLM_EXECUTE_MODEL_TIMEOUT_SECONDS=1800 \
-e PYTORCH_CUDA_ALLOC_CONF=expandable_segments:True \
-e VLLM_ALLOW_LONG_MAX_MODEL_LEN=1 -e FLASHINFER_DISABLE_VERSION_CHECK=1 \
--entrypoint bash "$IMG" -lc '
set -euo pipefail
# 使用镜像自带的 NCCL 2.30.7:旧版本在通过 RoCE 进行
# 跨节点 CUDA graph 重放时可能死锁(vLLM issue #52504)。
export VLLM_NCCL_SO_PATH=$(python3 -c "import nvidia.nccl,os;
print(os.path.join(list(nvidia.nccl.__path__)[0], \"lib\", \"libnccl.so.2\"))")
test -f "$VLLM_NCCL_SO_PATH"
EXTRA=()
if [ -n "$HEADLESS" ]; then EXTRA+=("$HEADLESS"); fi
exec vllm serve /model --served-model-name "$MODEL_REPO" \
--host 0.0.0.0 --port "$PORT" \
--nnodes 2 --node-rank "$RANK" --master-addr "$MASTER_ADDR" \
--master-port 29501 --tensor-parallel-size 2 \
--speculative-config "$SPEC_CONFIG" \
--max-model-len 98304 --max-num-batched-tokens 8192 \
--block-size 128 --max-num-seqs 16 \
--trust-remote-code --disable-custom-all-reduce \
--kv-cache-dtype fp8 --enable-prefix-caching \
--gpu-memory-utilization 0.93 \
--enable-prompt-tokens-details \
--kernel-config "$KERNEL_CONFIG" --compilation-config "$COMPILE_CONFIG" \
--distributed-timeout-seconds 1800 \
--enable-auto-tool-choice --tool-call-parser glm47 --reasoning-parser glm47 \
"${EXTRA[@]}"
'
先在 B 上运行脚本,再在 A 上运行:
bash ~/launch-glm53.sh
每条命令都会打印一个容器 ID 并立即返回,此时服务尚未就绪。B 的 worker 会等待 A 加入,然后两台 Station 各自从本地存储加载自己那部分权重、准备 kernel 并捕获 CUDA graph。这一步需要几分钟。
在 A 上跟踪日志,观察服务何时就绪(--since 会隐藏之前运行的输出):
docker logs --follow --since "$(docker inspect \
--format '{{.State.StartedAt}}' "$CONTAINER")" "$CONTAINER"
当日志出现 Application startup complete 时,按 Ctrl+C 停止跟踪即可,服务仍在继续运行。
至此,一个模型横跨两台机器。任何一块 GPU 都不持有完整副本,任何一台都无法单独响应请求:每个 token 的生成都需要两个 rank 通过 RoCE 网络交换部分计算结果。
剩余的 GPU 显存用于 KV cache,存放进行中请求的上下文。启动日志会报告其容量(GPU KV cache size)。所有进行中的请求共享这份缓存,因此提示词越长或用户越多,占用的空间就越大。如果空间不足,可以调低 --max-model-len,或减少并发请求数。
第 4 步:验证服务并发送请求
在 A 上检查 API(127.0.0.1 即 A 本机):
docker exec "$CONTAINER" curl -fsS --max-time 10 \
"http://127.0.0.1:$PORT/health" >/dev/null && echo HEALTH_OK
输出 HEALTH_OK 说明 Station A 已正常响应。接下来在两台 Station 上确认各 rank 是通过 GPU RDMA 通信,而不是退回到 TCP socket。该检查会读取启动器通过 NCCL_DEBUG=INFO 写出的 NCCL 日志,同一段命令还会显示已加载的显存:
docker exec "$CONTAINER" bash -lc '
set -euo pipefail
files=(/tmp/nccl_*.log)
test -e "${files[0]}"
grep -hE "NET/IB.*GDRDMA|GPU Direct RDMA Enabled" "${files[@]}" >/dev/null
grep -hF "$NCCL_IB_HCA" "${files[@]}" >/dev/null
if grep -hE "NET/Socket|NCCL WARN|NCCL ERROR" "${files[@]}"; then
exit 1
fi
echo RDMA_CHECK_OK
'
nvidia-smi
RDMA_CHECK_OK 表示检查通过,没有任何告警。在 nvidia-smi 中,A 显示的是 VLLM::Worker_TP0 进程,B 显示的是 VLLM::Worker_TP1,每张 GPU 对应一个 rank。启动日志显示每张 GPU 加载了约 218 GiB 的权重,大约是 checkpoint 的一半,说明模型确实被切分到了两张 GPU 上。
| 测量项 | Station A | Station B |
|---|---|---|
| GB300 GPU 已用显存 (GiB) | 0.01 → 231.35 | 0.00 → 231.34 |
在 A 上通过 OpenAI 兼容 API 发送一个对话请求:
docker exec "$CONTAINER" curl -fsS --max-time 120 \
"http://127.0.0.1:$PORT/v1/chat/completions" \
-H 'Content-Type: application/json' \
-d '{"model":"nvidia/GLM-5.3-NVFP4",
"messages":[{"role":"user","content":"Quarterly units sold: Q1 = 120; Q2 = 180; Q3 = 150. Summarize the trend in one sentence and calculate the percentage change from Q1 to Q2."}],
"temperature":0,"max_tokens":4096,
"chat_template_kwargs":{"reasoning_effort":"low"}}' |
python3 -c 'import json,sys; c=json.load(sys.stdin)["choices"][0];
print(c["message"]["content"]); print("finish_reason:",c["finish_reason"])'
返回结果应该类似这样:
**Trend:** Units sold rose sharply in Q2 before partially declining in Q3, remaining above the Q1 level.
**Q1 → Q2 percentage change:** (180 - 120) / 120 × 100 = **50% increase**
finish_reason: stop
finish_reason: stop 表示模型完整生成了回答,而不是因为达到 token 上限被截断。请求在 chat_template_kwargs 中把 reasoning_effort 设成了 low。GLM-5.3 还支持 high 和 max,可以让模型在回答前进行更长时间的推理,代价是延迟增加。由于启动命令开启了工具调用(--enable-auto-tool-choice),使用 OpenAI tools API 的 agent 框架也可以直接调用同一个端点。
Step 5. 并发测试与释放资源
AIPerf 是 NVIDIA 推出的推理端点基准测试工具,用于测量吞吐量和延迟。把它装进服务容器可能会改变 vLLM 的依赖,所以在 A 上单独用一个虚拟环境来安装:
sudo apt update &&
sudo apt install -y python3.12-venv python3.12-dev build-essential &&
python3.12 -m venv "$HOME/.venvs/aiperf-0.12.0" &&
"$HOME/.venvs/aiperf-0.12.0/bin/pip" install 'aiperf==0.12.0' &&
"$HOME/.venvs/aiperf-0.12.0/bin/pip" check
安装结束时应该看到 No broken requirements found。
AIPerf 可以发送合成 prompt,也可以重放现有数据集。本教程使用 SPEED-Bench 中的 80 段 Coding 对话——这是专为评估投机解码而构建的真实 prompt 集合——从而让 MTP 的测试基于真实文本。SPEED-Bench 的准备脚本会从多个 Hugging Face 数据集拉取 prompt,其中包括需要授权的 cais/hle:如果还没有操作过,请先打开该数据集页面,点击 Agree and access repository,然后继续。接着在 A 上登录 Hugging Face:
"$HOME/.venvs/aiperf-0.12.0/bin/hf" auth login
然后下载并准备数据集,详细步骤参见 AIPerf 官方指南:
SPEED_BENCH_DIR="$HOME/datasets/speed-bench"
mkdir -p "$SPEED_BENCH_DIR"
curl -fLsS https://raw.githubusercontent.com/NVIDIA-NeMo/Skills/refs/heads/main/nemo_skills/dataset/speed-bench/prepare.py | \
"$HOME/.venvs/aiperf-0.12.0/bin/python" - --config qualitative --output_dir "$SPEED_BENCH_DIR"
在 A 上检查数据集和服务。当输出 BENCHMARK_READY 后再继续:
(
set -euo pipefail
source ~/glm53.env
curl -fsS "http://$HEAD_IP:$PORT/health" >/dev/null
"$HOME/.venvs/aiperf-0.12.0/bin/python" - <<'PY_CHECK'
import json
from pathlib import Path
root = Path.home()
path = root / "datasets/speed-bench/qualitative.jsonl"
assert path.exists(), "Dataset missing: rerun the SPEED-Bench preparation"
rows = [json.loads(line) for line in path.read_text().splitlines() if line.strip()]
coding = [row for row in rows if row["category"] == "coding"]
assert len(coding) == 80, "Expected 80 Coding conversations"
assert sum(len(row["messages"]) for row in coding) == 89
assert all("FULL BENCHMARK DATA SHOULD BE FETCHED" not in message["content"]
for row in coding for message in row["messages"])
print("BENCHMARK_READY: dataset has 80 Coding conversations, 89 turns in total.")
PY_CHECK
)
完整的测试扫描覆盖并发数 1、8、16 和 32。每个级别下,AIPerf 先发送 3×C 个预热请求,再测量 10×C 个请求,其中 C 为并发数。在高并发下,部分对话会被发送多次。
基准测试请求使用模型默认的推理强度(max),输出上限为 8192 个 token;回复可以在达到上限之前结束。完整扫描可能需要数小时。
请求超时设为两小时,为长回复留出余量;--server-metrics 用于采集服务端计数器,以测量 MTP 接受率;--export-level raw 会保留每条回复以便检查。
如果想快速测试,可以在 A 上运行下面的代码块,前提是两个容器都在运行,且没有其他 API 流量。它会在开启 prefix caching 的情况下测试 C1 和 C8,与下文表 2 中的参考测量条件一致。
(
set -euo pipefail
source ~/glm53.env
CODING_DATASET="$HOME/datasets/speed-bench/qualitative.jsonl"
test -f "$CODING_DATASET"
export CONCURRENCIES=${CONCURRENCIES:-"1 8"} # 快速跑:C1 和 C8。
# 可选的完整基准测试:按照下面的复现步骤操作。
# 步骤 3:--max-num-seqs 16 -> export CONCURRENCIES="1 8 16"
# 步骤 3:--max-num-seqs 32 -> export CONCURRENCIES=32
RUN_DIR="$HOME/aiperf-results/blog-coding-$(date +%Y%m%d-%H%M%S)"
for C in $CONCURRENCIES; do
ART="$RUN_DIR/c$C"
env -u HF_HUB_OFFLINE -u TRANSFORMERS_OFFLINE \
"$HOME/.venvs/aiperf-0.12.0/bin/aiperf" profile \
-m "$MODEL_REPO" --url "http://$HEAD_IP:$PORT" \
--endpoint-type chat --streaming --tokenizer "$MODEL_HOST" \
--custom-dataset-type speed_bench_coding --input-file "$CODING_DATASET" \
--request-count "$((10 * C))" --warmup-request-count "$((3 * C))" \
--osl 8192 \
--use-server-token-count --concurrency "$C" --random-seed 42 \
--request-timeout-seconds 7200 \
--server-metrics "http://$HEAD_IP:$PORT/metrics" \
--export-level raw --artifact-dir "$ART"
printf "Results: %s\n" "$ART"
done
printf "Results directory: %s\n" "$RUN_DIR"
)
AIPerf 会把指标、原始响应和日志保存到结果目录中。预热请求不计入报告的指标。
可选:复现表 2。在两台 Station 上,修改步骤 3 生成的 ~/launch-glm53.sh:保留 --enable-prefix-caching,并按上面注释中对应的分组把 --max-num-seqs 设为 16 或 32。每组测试前,先在 A 上停止并删除当前容器,再到 B 上操作(用 docker stop --timeout 60 "$CONTAINER",接着 docker rm "$CONTAINER")。在 B 上用 bash ~/launch-glm53.sh 重新运行更新后的脚本,然后是 A,并等待 Application startup complete 出现。在 A 上执行注释中对应的 export CONCURRENCIES 命令,然后重新运行上面这段 AIPerf 脚本。
如果要在不开启 prefix caching 的情况下测试,把两台 Station 上步骤 3 脚本中的 --enable-prefix-caching 替换为 --no-enable-prefix-caching,然后按上述方式重建容器。性能表现可能与表 2 不同。
图 2 将所有测量请求的整体输出吞吐量与单用户平均吞吐量进行了对比。Token 计数包含推理(reasoning)部分。
下方的表 2 展示了并发请求数增多时,吞吐量和延迟的变化情况。
| 配置并发数 | 整体吞吐量 (tok/s) | 平均请求延迟 (s) | 平均 TTFT (ms) | 平均 token 间延迟 (ms/token) |
| 1 | 107.4 | 49.84 | 479.75 | 8.78 |
| 8 | 386.0 | 114.17 | 433.79 | 19.01 |
| 16 | 607.8 | 136.46 | 482.90 | 23.77 |
| 32 | 385.0 | 453.54 | 899.36 | 77.90 |
表 2. SPEED-Bench Coding 测试结果(已开启 prefix caching,每步 4 个 MTP 草稿 token,使用 FP8 KV cache)。延迟指标为实测请求的均值,不含预热。TTFT 指首个 token(可能是推理内容)的生成时间
整体吞吐量在 C16 时达到峰值 607.8 tok/s,到 C32 时降至 385.0 tok/s,此时平均请求延迟为 453.5 s。并发数升高还会拉低平均单用户吞吐量:从 C1 时的 115.3 tok/s 降到 C32 时的 13.0 tok/s。
所有请求完成后,先在 A 机上停止 vLLM 容器,再在 B 机上操作:
docker stop --timeout 60 "$CONTAINER"
docker inspect --format \
'Status={{.State.Status}} Running={{.State.Running}}' "$CONTAINER"
nvidia-smi
此时状态应显示 Status=exited Running=false,且 nvidia-smi 中没有 vLLM 进程;checkpoint、容器和结果都保留在磁盘上。要恢复时,先在 B 上执行 docker start "$CONTAINER",再到 A 上执行,然后重复第 4 步的检查。
排查常见问题
- 变量丢失或 SSH 连接失败:重新连接后执行
source ~/glm53.env;确认 A 到 B 的密钥认证正常,并核对 B 的指纹。 - SPEED-Bench 准备阶段报 gated 数据集错误:用同一账号登录 Hugging Face,打开 cais/hle 页面,点击 Agree and access repository,然后重新运行准备步骤。
- 启动或 RDMA 检查失败:在两个节点上查看
docker logs "$CONTAINER";确认 checkpoint 和 GID 无误,并重新运行 playbook 的验证脚本(脚本 07)。 - CUDA out of memory:调低
--max-model-len或并发数,然后重新测试。
让端点真正用起来
现在,一个 7530 亿参数的模型已在两台 NVIDIA DGX Station 上运行,对外暴露为一个本地 API,所有权重都在 GPU 显存中。这意味着你可以做一些托管端点很难做到的事:在敏感或专有数据上跑推理、在本地快速原型化 agent、随意迭代 prompt 而不用按 token 计费。
参考 vLLM serving 文档 接入你自己的应用,再用你的实际 prompt 重跑 AIPerf,找到适合你工作负载的并发数。一个前沿规模的模型,现在就在你的桌面上,随时可以上手开发。