2026 年 11 月 13 日
作者: Fatima Fall
讨论(0)
- L
- T
- F
- R
- AI 生成的摘要:GLM-5.3 NVFP4 是一个拥有 7530 亿参数、每个 token 激活 400 亿参数的量化混合专家模型,约需 464 GB 显存,超过单块 GB300 GPU 的 252 GB HBM3e。两台通过 ConnectX-8 RDMA 互联的 NVIDIA DGX Station 采用张量并行(TP=2)通过一个 OpenAI 兼容端点对外服务该模型,每块 GPU 持有并计算约一半的权重。vLLM 在两台 Station 上启动分布式服务,启用多 token
AI 生成的摘要
- GLM-5.3 NVFP4,这是一个拥有 7530 亿参数、每个 token 激活 400 亿参数的量化混合专家模型,约需 464 GB 显存,超过单块 GB300 GPU 的 252 GB HBM3e。
- 两台通过 ConnectX-8 RDMA 互联的 NVIDIA DGX Station 采用张量并行(TP=2)通过一个 OpenAI 兼容端点对外服务该模型,每块 GPU 持有并计算约一半的权重。
- vLLM 在两台 Station 上启动分布式服务,支持多 token 预测、FP8 KV-cache 存储和前缀缓存,从而在并发负载下最大化吞吐量。
- AIPerf 在 SPEED-Bench Coding 数据集上的基准测试显示,并发数为 16 时整体输出吞吐量达到峰值 607.8 tokens/s,随后在并发数为 32 时降至 385.0 tokens/s,平均请求延迟为 453.5 秒。
后续步骤
- 请遵循 连接两台 DGX Station 操作手册 ,以便在部署前连接并验证硬件。
- 查看 NVIDIA 本地 AI 方案仓库 以获取最新推荐配置。
- 使用以下方式连接应用: vLLM 服务文档 并重新运行 AIPerf,使用自定义提示词,以找出该工作负载的最优并发数。
在本地运行前沿规模的模型意味着要将其全部权重保留在 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 操作手册.
本文介绍如何用 vLLM 在两台 NVIDIA DGX Station 上本地部署 GLM-5.3、发送请求,并测量其在并发负载下的表现。张量并行(TP=2)将模型的张量拆分到两块 GB300 GPU 上。两台 Station 共同计算每个请求,由 Station A 通过一个 OpenAI 兼容 API 返回答案。完成之后,你将获得一个可用的端点,以及它在负载下行为的基线。

前提条件
- 两台运行 Linux 的 GB300 DGX Station,已通过 连接两台 DGX Station 操作手册,包括其在两条链路上的 GPU 显存 RDMA 测试。
- 两台 Station 上均使用相同的 Linux 用户名配置 SSH 和 sudo 访问权限。Docker 和 NVIDIA Container Toolkit 已随 DGX Station 软件栈允许对容器镜像仓库、Hugging Face 和软件包仓库的出站访问。
- 每台 Station 上至少需要 464 GB 的可用磁盘空间,用于存放其检查点副本,此外还需为 vLLM 容器镜像和临时文件留出空间。
- 接受 NVIDIA 开放模型协议以及原始的 GLM-5.3 许可条款,这些条款列在 模型卡。SPEED-Bench 受 NVIDIA 评估数据集许可协议.
- 一个 Hugging Face 账户和读取访问令牌,并具有访问受限的 cais/hle 数据集:登录,打开其页面,并选择 同意并访问仓库第 5 步从该数据集下载 SPEED-Bench 提示词。
配套视频演示了相同的工作流程。
第 1 步:准备两台 Station
本教程使用另一台计算机(例如你的笔记本电脑)来管理两台 Station。首先从该计算机分别打开到每台 Station 的 SSH 会话。或者,也可以直接在每台 Station 的本地终端上操作。本步骤中的每条命令都要在两台 Station 上执行,除非该命令以“On A.”开头。
两个 Station 以不同角色运行相同的容器和检查点: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 安装后配置步骤:将你的用户添加到 docker 组, sudo usermod -aG docker "$USER",运行 exit,然后重新连接并重新运行 docker version。 docker 组授予 root 级权限。 |
|---|
该 ibdev2netdev 输出会列出两条直连轨道, cx8r0 以及 cx8r1。选择一个用于服务流量,例如 cx8r1并在每台 Station 上为其记录两项信息:
- 其 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.
两台 Station 上的轨道名称和设备相同;只有 IPv4 地址不同。
接下来,创建 ~/glm53.env 在每台 Station 上。该文件存储后续命令要使用的值:
nano ~/glm53.env
粘贴以下代码块,并将每个占位符(保留引号)替换为你记录的值。例如,使用 上的默认地址时,Station A 的文件开头如下所示。Station B 的文件除 外完全相同: 由你的主目录构建,第 2 步会通过 SSH 将检查点复制到 Station B 上的相同路径。注意:后续步骤以 开头来加载这些值。每当你打开新的 SSH 会话时,请重新运行此命令。在两台 Station 上,加载这些值并检查存储、连通性和基线内存:这些检查 <...> 占位符(保留引号),并填入你记录的值。
RANK="<NODE_RANK>" # RANK="0" on Station A, RANK="1" on Station B
HEAD_IP="<STATION_A_IPV4_ADDRESS>" # IPv4 address you noted on Station A; same in both files
WORKER_IP="<STATION_B_IPV4_ADDRESS>" # IPv4 address you noted on Station B; same in both files
RAIL_IFACE="<RAIL_NAME>" # Rail you picked, for example cx8r1; same in both files
RAIL_HCA="<RDMA_DEVICE>" # RDMA device you noted, for example mlx5_1; same in both files
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 将检查点复制到 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 上,Xorg 可能会同时出现在两块 GPU 上,占用几 MiB。
提示: 注意 “ 所显示的 GPU 内存使用量 nvidia-smi;第 4 步会将其与已加载的模型进行比较。 |
|---|
第 2 步通过 SSH 将检查点从 A 复制到 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 针对相同的权重运行相同的软件。首先在两台 Station 上拉取固定版本的镜像:
docker pull "$IMG" &&
docker image inspect "$IMG" --format '{{.Architecture}} {{.RepoDigests}}'
拉取可能需要几分钟。匹配的 arm64 摘要意味着两个 rank 运行相同的软件。
在 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 意味着两台 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 的本地 AI 配方仓库.
安全提示: --host 0.0.0.0 , --network host 会在每个 Station A 接口(包括管理接口)上暴露未认证的 API。请将该端口通过防火墙限制为仅允许预期客户端访问,并在扩大访问范围之前添加身份验证和 TLS。 |
|---|
在两台 Station 上,分别创建一个名为 ~/launch-glm53.sh:
nano ~/launch-glm53.sh
该脚本启用了多 token 预测(MTP),这是一种推测解码形式:模型的 MTP 层在每一步起草四个 token,vLLM 用完整模型验证后再接受它们,因此每一步可以生成多个 token。收益取决于草稿被接受的频率,而这会因提示词而异。
与 16 位存储相比,FP8 KV-cache 存储可将缓存内存减半,从而为更多 token 留出空间。前缀缓存已启用,以避免重新处理服务器已经见过的提示词前缀。粘贴下面的脚本;它会检查你的配置,为所选 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
# Use NCCL 2.30.7 from the image: older versions can deadlock
# cross-node CUDA graph replays over 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 的 worker 会等待 A 加入,随后每个 Station 从本地存储加载各自负责的那部分权重、准备内核并捕获 CUDA 图。这一过程需要数分钟。
在 A 上,跟踪日志以查看服务何时就绪(--since (隐藏此前运行的输出):
docker logs --follow --since "$(docker inspect \
--format '{{.State.StartedAt}}' "$CONTAINER")" "$CONTAINER"
当日志显示 Application startup complete,按 Ctrl+C 停止跟踪;服务会继续运行。
此时,一个模型横跨两台机器。两块 GPU 都不持有完整副本,也都无法单独响应请求:每个 token 都需要两个 rank 通过 RoCE 链路交换部分结果。
剩余的 GPU 显存用于存放 KV 缓存,它保存着进行中请求的上下文。启动日志会报告其 容量 (GPU KV 缓存大小)。所有进行中的请求共享它,因此更长的提示词或更多用户需要更多缓存。如果缓存耗尽,请降低 --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,同一个区块会显示已加载的内存:
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 的权重,约为检查点的一半,这证实模型被拆分到两个 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 上限。该请求设置了 reasoning_effort ,在 GLM-5.3 中也接受 和 ,这能让它在回答前进行更长时间的推理,代价是延迟增加。由于启动器启用了工具调用(),使用 OpenAI 工具 API 的智能体框架可以调用同一个端点。 low , chat_template_kwargs. 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 个 Coding 对话,这是一组为评估推测解码而构建的真实提示词,因此 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(), "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 为并发数。部分对话在更高并发下会被发送多次。
基准测试请求使用模型的默认推理强度(最大)和 8,192 token 的输出上限;响应可能在达到上限前就结束。完整扫描可能需要数小时。
两小时的请求超时时间为长响应留出了余地, --server-metrics 收集用于衡量 MTP 接受率的服务器计数器,并且 --export-level raw 会保留每个响应以供检查。
如需快速测试,请在 A 上运行下面的代码块,此时两个容器都在运行,且没有其他 API 流量。该测试在启用前缀缓存的情况下检验 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"} # Quick run: C1 and C8.
# Optional full benchmark: follow the reproduction instructions below.
# Step 3: --max-num-seqs 16 -> export CONCURRENCIES="1 8 16"
# Step 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 将指标、原始响应和日志保存在 results 目录中。预热请求不计入所报告的指标。
可选:复现表 2在 ~/launch-glm53.sh 从两台 Station 上的步骤 3 开始,保留 --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 测试块。
要在不使用前缀缓存的情况下进行测试,请将 --enable-prefix-caching , --no-enable-prefix-caching 在两台 Station 上的步骤 3 脚本中,然后按上述方式重新创建容器。性能可能与表 2 不同。
图 2 比较了在实测请求下的整体输出吞吐量与平均每用户吞吐量。Token 计数包含推理过程。

下表 2 展示了当更多请求共享该服务时,吞吐量和延迟如何变化。
| 配置的 并发数 | 整体吞吐量 (tok/s) | 平均请求延迟 (秒) | 平均 TTFT (毫秒) | 平均每 token 延迟 (毫秒/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. 启用前缀缓存、每步四个 MTP 草稿 token 并使用 FP8 KV 缓存的 SPEED-Bench Coding 结果。延迟指标为所测请求的平均值;预热不计入。TTFT 衡量首个 token 的时间,其中可能包含推理
整体吞吐量在 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,且其中没有 vLLM 进程 nvidia-smi;检查点、容器和结果都保留在磁盘上。要恢复运行,请执行 docker start "$CONTAINER" 在 B 上,然后在 A 上,并重复步骤 4 的检查。
排查常见阻塞问题
- 缺少变量或 SSH 失败:
source ~/glm53.env重新连接后;验证 A 到 B 的密钥认证以及 B 的指纹。 - SPEED-Bench 准备过程因受限数据集错误而失败:请使用同一账户登录 Hugging Face,打开 cais/hle 页面,选择“同意并访问仓库”,然后重新运行准备工作。 同意并访问仓库,然后重新运行准备工作。
- 启动或 RDMA 检查失败:检查
docker logs "$CONTAINER"在两个节点上;验证检查点和 GID,并重新运行 playbook 的验证(脚本 07)。 - CUDA 显存不足:降低
--max-model-len或并发数,然后重新测试。
让端点投入使用
现在,你有一个7530亿参数的模型,在两台NVIDIA DGX Station上通过一个本地API运行,所有模型权重都驻留在GPU内存中。这为那些在托管端点上难以完成的工作打开了大门:对敏感或专有数据运行推理、在本地原型化智能体,以及无需按token付费即可迭代提示词。
使用 vLLM 服务文档连接你自己的应用,然后用你的提示词重新运行 AIPerf,以找到适合你工作负载的并发数。一个前沿规模的模型现在已准备就绪,就在你的桌面上即可构建。讨论 (0) 标签:智能体 AI / 生成式 AI | 边缘计算 | 网络 / 通信 | 通用 | Blackwell | DGX | 中级技术 | 教程 | DGX Station | 推理性能 | LLM 基准测试 | LLM | 本地 AI | vLLM 关于作者 关于 Fatim vLLM 服务文档,然后用你的提示词重新运行 AIPerf,以找到适合你工作负载的并发数。一个前沿规模的模型现在已准备就绪,就在你的桌面上即可构建。
讨论 (0)标签
智能体 AI / 生成式 AI | 边缘计算 | 网络 / 通信 | 通用 | Blackwell | DGX | 中级技术 | 教程 | DGX Station | 推理性能 | LLM 基准测试 | LLM | 本地 AI | vLLM关于作者
关于 Fatima Fall
Fatima Fall 是一名技术营销工程师,对一切与 AI 相关的事物都有浓厚兴趣。她曾就读于霍华德大学,并在那里获得了应用数学学士学位。 查看 Fatima Fall 的所有文章