智能体 AI / 生成式 AI 当一块 GPU 不够用时:用 vLLM 在两台 NVIDIA DGX Station 上部署 GLM-5.3 2026 年 11 月 13 日 作者: Fatima Fall 讨论(0)

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 秒。

后续步骤

由 NVIDIA Nemotron 提供支持。AI 生成的内容可能无法完整概括信息。请核实重要信息。 了解更多

在本地运行前沿规模的模型意味着要将其全部权重保留在 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 返回答案。完成之后,你将获得一个可用的端点,以及它在负载下行为的基线。

Two stations serve one model: each GPU holds and computes part of the model over the selected RDMA connection. Their memories remain distinct.
图 1. 两台 Station 共同服务一个模型:每块 GPU 通过选定的 RDMA 连接持有并计算模型的一部分。两者的内存保持独立

前提条件

  • 两台运行 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. 准备、推理、基准测试与关停的全流程演示

第 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 AStation B
使用的 GB300 GPU(GiB)0.01 → 231.350.00 → 231.34
表 1. 未运行任何请求时,加载模型前后的 GPU 显存。数值包括权重、KV 缓存和运行时缓冲区

在 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 计数包含推理过程。

Overall output throughput and mean per-user throughput at configured concurrency 1, 8, 16, and 32, with prefix caching enabled. C1: 107.4 and 115.3 tok/s; C8: 386.0 and 53.0; C16: 607.8 and 42.4; C32: 385.0 and 13.0.
图 2. 在启用前缀缓存的情况下,SPEED-Bench Coding 上整体输出吞吐量与平均每用户吞吐量的对比。C1、C8、C16 和 C32 表示配置的并发数

下表 2 展示了当更多请求共享该服务时,吞吐量和延迟如何变化。

配置的 并发数整体吞吐量
(tok/s)
平均请求延迟
(秒)
平均 TTFT
(毫秒)
平均每 token 延迟
(毫秒/token)
1107.449.84479.758.78
8386.0114.17433.7919.01
16607.8136.46482.9023.77
32385.0453.54899.3677.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

关于作者

Avatar photo 关于 Fatima Fall
Fatima Fall 是一名技术营销工程师,对一切与 AI 相关的事物都有浓厚兴趣。她曾就读于霍华德大学,并在那里获得了应用数学学士学位。 查看 Fatima Fall 的所有文章

评论