当一块 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 测试,找到最适合你的工作负载的并发配置。一个前沿规模的大模型,如今已经可以在你的办公桌上搭建完成,随时可供构建使用。

NVIDIA