当一块 GPU 不够用:用 vLLM 在两台 NVIDIA DGX Station 上部署 GLM-5.3
要在本地运行前沿规模的模型,需要将其全部权重保留在 GPU 显存中,而目前最大的模型已经无法装进一台机器。通过 ConnectX-8 RDMA 连接的两台 NVIDIA DGX Station 可以通过单一接入点为同一个模型提供服务,张量并行技术会将模型权重和计算过程拆分到两块 GPU 上。
NVIDIA GLM-5.3 NVFP4 模型是 Z.ai 混合专家(MoE)模型的量化版本,拥有 7530 亿参数,每个 Token 激活 400 亿参数。稀疏激活机制降低了计算量,但由于每个 Token 都可能被路由到不同的专家网络,所有模型权重仍需保持可用状态。该检查点文件大小约为 464 GB,超过单块 GB300 GPU 252 GB 的 HBM3e 显存容量。本教程使用两台 DGX Station 将权重保留在 GPU 显存中,并关闭 CPU 权重卸载功能。
开始之前,请参照《连接两台 DGX Station》操作指南完成两台机器的连接。
本文将介绍如何在两台 NVIDIA DGX Station 上通过 vLLM 本地部署 GLM-5.3,发送请求,并测量其在并发负载下的表现。张量并行(TP=2)会将模型张量拆分到两块 GB300 GPU 上。两台机器都会参与每个请求的计算,而 Station A 通过一个兼容 OpenAI 的 API 返回答案。完成本文操作后,你将获得一个可用的服务端点,以及该端点在负载下表现的基准数据。
前提条件
两台运行 Linux 系统的 GB300 DGX Station,已通过《连接两台 DGX Station》操作指南完成连接和验证,包括在两条链路上进行的 GPU 显存 RDMA 测试。
两台机器均可通过 SSH 和 sudo 权限访问,且使用相同的 Linux 用户名。Docker 和 NVIDIA Container Toolkit 已预装在 DGX Station 软件栈中。需允许访问容器镜像仓库、Hugging Face 以及软件包仓库的出站流量。
每台机器至少有 464 GB 的空闲磁盘空间用于存放各自的检查点副本,并额外预留空间存放 vLLM 容器镜像和临时文件。
需同意 NVIDIA 开放模型协议以及模型卡中列出的原始 GLM-5.3 许可条款。SPEED-Bench 遵循 NVIDIA 评估数据集许可协议。
需拥有 Hugging Face 账户及读取权限的访问令牌,并获得受限数据集 cais/hle 的访问权限:登录后打开该数据集页面,选择"同意并访问仓库"。第 5 步将从该数据集下载 SPEED-Bench 的提示词。
配套视频遵循相同的操作流程。
第 1 步:准备两台机器
本教程使用一台独立的计算机(例如笔记本电脑)来管理两台 Station。首先从该计算机分别对两台 Station 建立 SSH 会话,也可以在每台 Station 上使用本地终端操作。本步骤中除标注"在 A 上"的命令外,其余命令均需在两台机器上执行。
两台机器运行相同的容器和检查点,但角色不同:Station A(rank 0)承载 API 服务,Station B(rank 1)仅运行工作节点,不提供 API 服务。
首先,检查 Docker 访问权限并收集后续需要用到的网络参数:
docker version
ibdev2netdev
ip -br addr
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="<节点编号>" # Station A 上设为 "0",Station B 上设为 "1"
HEAD_IP="<STATION_A的IPV4地址>" # 在 Station A 上记录的 IPv4 地址;两个文件中相同
WORKER_IP="<STATION_B的IPV4地址>" # 在 Station B 上记录的 IPv4 地址;两个文件中相同
RAIL_IFACE="<链路名称>" # 你选择的链路,例如 cx8r1;两个文件中相同
RAIL_HCA="<RDMA设备>" # 你记录的 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, ' ~ /GB300/ {gsub(/ /,"",); print ; 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 将检查点复制到 Station B 的相同路径下。
在两台机器上,加载这些变量并检查存储、网络连通性和基础显存状态:
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 的机器上,Xorg 可能会在两块 GPU 上各占用少量显存(几 MiB)。
第 2 步需要将检查点从 A 复制到 B(通过 SSH),因此 A 需要具备对 B 的免密登录权限。在 A 上,创建一个无密码的密钥(详见 SSH 密钥相关说明),在核验 B 的主机指纹后将公钥复制到 B,然后确认登录:
ssh-keygen -t ed25519
ssh-copy-id "$WORKER_IP"
ssh -o BatchMode=yes "$WORKER_IP" hostname
第 2 步:下载并复制模型
张量并行要求两个节点运行相同的软件、针对相同的权重。首先在两台机器上拉取锁定版本的镜像:
docker pull "$IMG" && docker image inspect "$IMG" --format '{{.Architecture}} {{.RepoDigests}}'
该拉取过程可能需要数分钟。两台机器的 arm64 摘要值一致,说明两个节点运行的是完全相同的软件。
在 A 上下载锁定版本的检查点。该文件大小约为 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/"
每块磁盘保存完整的检查点文件;vLLM 会在加载时将权重拆分到各 GPU 上,不会进行额外的量化处理。
在 A 上,比对两份副本(该检查通过 SSH 读取 B 的文件列表),然后验证检查点文件:
(
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 表示两台机器保存了相同的文件名和文件大小,且布局符合预期。出现 MIXED_PRECISION 是正常现象:NVFP4 量化只针对 MoE 模块中的线性层权重和激活值,并非应用于所有张量。
第 3 步:启动分布式服务
这一步会将两台机器变成一个服务:同一份启动脚本会在两台机器上运行,读取 ~/glm53.env 文件,并在每台机器上各启动一个 vLLM 节点。如果你需要调整脚本,最重要的两个参数是:--max-model-len 98304(上下文长度上限,以 Token 计,包含输入和输出),以及 --gpu-memory-utilization 0.93(将 93% 的显存分配给 vLLM)。如需修改其他参数,请一次只改一项并重新测试。
关于最新的推荐配置,请参阅 NVIDIA 的 Local AI 配置库。
在两台机器上,创建名为 ~/launch-glm53.sh 的文件:
nano ~/launch-glm53.sh
该脚本启用了多 Token 预测(MTP),这是一种推测解码技术:模型的 MTP 层每一步会起草 4 个 Token,vLLM 会用完整模型对这些草稿进行验证后才予以接受,因此每一步可能产生多个 Token。实际收益取决于草稿被接受的比例,这会随提示词的不同而变化。
FP8 格式的 KV 缓存相比 16 位存储可将缓存显存占用减半,从而为更多 Token 留出空间。脚本还启用了前缀缓存功能,以避免重复处理服务器已经处理过的提示词前缀。粘贴以下脚本内容;该脚本会检查配置,查找所选链路对应的 RoCE GID 索引,并在容器中启动本机的 vLLM 节点:
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" \
'==d && ==ip && =="v2" {g=} 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
# 使用镜像中 2.30.7 版本的 NCCL:旧版本在跨节点 CUDA 图重放时
# 可能通过 RoCE 出现死锁问题(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 的工作节点会等待 A 加入,随后两台机器各自从本地存储加载自己负责的那部分权重,准备内核并捕获 CUDA 图。这一过程需要数分钟。
在 A 上,跟踪日志以查看服务何时就绪(--since 参数用于隐藏此前运行留下的旧日志):
docker logs --follow --since "$(docker inspect \
--format '{{.State.StartedAt}}' "$CONTAINER")" "$CONTAINER"
当日志显示 Application startup complete 时,按 Ctrl+C 停止跟踪;服务本身会继续运行。
此时,一个模型已经横跨两台机器运行。两块 GPU 都没有保存完整的模型副本,单独一块也无法独立应答请求:每生成一个 Token,都需要两个节点通过 RoCE 链路交换中间计算结果。
剩余的显存容量用于存储 KV 缓存,该缓存保存着正在处理请求的上下文信息。启动日志会报告其容量大小(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 已正常响应。接下来,在两台机器上检查两个节点是否通过 GPU RDMA 通信,而非回退至 TCP 套接字。该检查会读取启动脚本通过 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 对应一个节点。启动日志报告每块 GPU 约加载了 218 GiB 的权重,大约是检查点总大小的一半,这证实了模型确实被拆分到两块 GPU 上运行。
在 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"])'
返回结果大致如下:
趋势:销量在 Q2 大幅上升,随后在 Q3 有所回落,但仍高于 Q1 水平。
Q1 到 Q2 的百分比变化:(180 - 120) / 120 × 100 = 增长 50%
finish_reason: stop
finish_reason: stop 表示模型已正常完成回答,而非因达到 Token 上限而被截断。该请求在 chat_template_kwargs 中将 reasoning_effort 设为 low。GLM-5.3 还支持 high 和 max 选项,这两个选项会让模型在回答前进行更长时间的推理,但会增加响应延迟。由于启动脚本启用了工具调用功能(--enable-auto-tool-choice),使用 OpenAI 工具 API 的智能体框架也可以调用该服务端点。
第 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 可以发送合成提示词,也可以回放现有数据集。本教程使用 SPEED-Bench 中的 80 条编程类对话——这是一组为评估推测解码而构建的真实提示词集合,因此 MTP 的效果测试基于真实文本。SPEED-Bench 的准备脚本会从多个 Hugging Face 数据集(包括受限数据集 cais/hle)中获取这些提示词:如果你尚未授权,请打开该数据集页面并选择"同意并访问仓库"后再继续。然后在 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(), "数据集缺失:请重新运行 SPEED-Bench 准备步骤"
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, "应有 80 条编程类对话"
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: 数据集包含 80 条编程类对话,共 89 轮对话。")
PY_CHECK
)
完整的测试序列涵盖并发数 1、8、16 和 32。在每个并发级别下,AIPerf 会先发送 3×C 个预热请求,然后测量 10×C 个请求,其中 C 代表并发数。在较高并发级别下,部分对话会被重复发送多次。
基准测试请求使用模型默认的推理强度(max)并设置 8192 个 Token 的输出上限;实际响应可能在未达到上限前就已完成。完整的测试序列可能需要耗费数小时。
两小时的请求超时设置为长响应预留了充足时间,--server-metrics 参数用于收集服务器计数指标以衡量 MTP 的接受率,--export-level raw 参数会保留每条响应内容以供检查。
若想进行快速测试,可在两个容器均已运行、且无其他 API 流量的情况下,在 A 上运行以下代码块。该代码块会测试启用前缀缓存情况下的 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 "结果目录:%s\n" "$ART"
done
printf "总结果目录:%s\n" "$RUN_DIR"
)
AIPerf 会将各项指标、原始响应及日志保存在结果目录中。预热请求不计入最终报告的指标统计。
可选操作:复现表 2 的数据。在两台机器上,回到第 3 步的 ~/launch-glm53.sh 脚本,保留 --enable-prefix-caching 参数,并按照上方注释将 --max-num-seqs 设为 16 或 32(对应不同的测试组)。在切换每组测试前,先在 A 上停止并删除当前容器,再对 B 执行同样操作(依次执行 docker stop --timeout 60 "$CONTAINER" 和 docker rm "$CONTAINER")。然后先在 B 上、再在 A 上用 bash ~/launch-glm53.sh 重新启动更新后的脚本,并等待日志显示 Application startup complete。在 A 上,按照上方注释运行对应的 export CONCURRENCIES 命令,然后重新运行 AIPerf 测试代码块。
若想在不启用前缀缓存的情况下测试,可在两台机器的第 3 步脚本中将 --enable-prefix-caching 替换为 --no-enable-prefix-caching,然后按上述方法重建容器。测试结果可能与表 2 有所不同。
图 2 对比了各并发级别下测得请求的整体输出吞吐量与人均吞吐量。Token 计数包含推理过程产生的 Token。
下方表 2 展示了随着请求数增加、多个请求共享服务时,吞吐量和延迟的变化情况。
整体吞吐量在 C16 并发下达到峰值,为 607.8 tok/s。在 C32 并发下降至 385.0 tok/s,此时平均请求延迟为 453.5 秒。并发数升高也会降低人均吞吐量,从 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 进程;检查点文件、容器及测试结果都会保留在磁盘上。如需恢复服务,先在 B 上执行 docker start "$CONTAINER",再在 A 上执行,然后重复第 4 步的检查流程。
常见问题排查
变量缺失或 SSH 连接失败:重新连接后执行 source ~/glm53.env;核实 A 到 B 的密钥认证是否正常,以及 B 的主机指纹是否匹配。
SPEED-Bench 准备过程因受限数据集报错:使用同一账户登录 Hugging Face,打开 cais/hle 数据集页面,选择"同意并访问仓库",然后重新运行准备脚本。
启动失败或 RDMA 检查失败:在两个节点上查看 docker logs "$CONTAINER" 日志;核实检查点文件和 GID 配置,并重新运行连接指南中的验证脚本(脚本 07)。
CUDA 显存不足:降低 --max-model-len 参数值或并发数,然后重新测试。
让服务端点真正发挥作用
至此,你已经成功在两台 NVIDIA DGX Station 上搭建起一个拥有 7530 亿参数的模型,并通过单一本地 API 对外提供服务,所有权重均保留在 GPU 显存中。这为许多在托管服务端点上难以完成的工作打开了大门:对敏感或专有数据进行推理计算、在本地原型开发智能体,以及在不产生按 Token 计费成本的情况下迭代优化提示词。
你可以参照 vLLM 服务文档将自己的应用程序接入该服务端点,然后使用你自己的提示词重新运行 AIPerf 测试,找到最适合你的工作负载的并发配置。一个前沿规模的大模型,如今已经可以在你的办公桌上搭建完成,随时可供构建使用。
