← 文章 / AI技术
NVIDIA 开发者博客 8天前 · 2026-11-14 09:14:34 · 30 阅读

一台 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 返回结果。读完本文,你将拥有一个可用的服务端点,并了解其在负载下的基准表现。

两台工作站服务单一模型:选定的 RDMA 连接下,每块 GPU 存储并计算模型的一部分。两者的显存保持独立。
图 1. 两台工作站服务单一模型:在选定的 RDMA 连接下,每块 GPU 存储并计算模型的一部分。两者的显存保持独立

前置条件

  • 两台运行 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:准备、推理、基准测试与关机的完整演示

步骤 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 AStation B
GB300 GPU 已用显存 (GiB)0.01 → 231.350.00 → 231.34
表 1. 加载模型前后的 GPU 显存占用,此时没有请求在运行。数值包含权重、KV cache 和运行时缓冲区

在 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)部分。

在并发 1、8、16、32(已开启 prefix caching)下的整体输出吞吐量和平均单用户吞吐量。C1:107.4 和 115.3 tok/s;C8:386.0 和 53.0;C16:607.8 和 42.4;C32:385.0 和 13.0。
图 2. SPEED-Bench Coding 上整体吞吐量与平均单用户吞吐量的对比(已开启 prefix caching)。C1、C8、C16、C32 表示配置的并发数

下方的表 2 展示了并发请求数增多时,吞吐量和延迟的变化情况。

配置并发数整体吞吐量
(tok/s)
平均请求延迟
(s)
平均 TTFT
(ms)
平均 token 间延迟
(ms/token)
1107.449.84479.758.78
8386.0114.17433.7919.01
16607.8136.46482.9023.77
32385.0453.54899.3677.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,找到适合你工作负载的并发数。一个前沿规模的模型,现在就在你的桌面上,随时可以上手开发。

原始来源: NVIDIA 开发者博客

评论 (0)