网络/通讯

当一个 GPU 无法满足需求时:借助 vLLM 在两个 NVIDIA DGX 工作站上服务 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 上 HBM3e 的 252 GB。本教程使用两个 DGX 工作站将权重保留在 GPU 显存中,并禁用 CPU 权重卸载。

开始之前,请使用 “Connect Two DGX Stations”手册连接两个工作站。

本文将介绍如何使用 vLLM 在两个 NVIDIA DGX 工作站之间本地提供 GLM-5.3、发送请求以及测量并发负载下的行为。张量并行 (TP = 2) 将模型的张量分割到两个 GB300 GPU 上。两个工作站都会计算每个请求,而工作站 A 则通过一个兼容 OpenAI 的 API 返回答案。最后,您将拥有一个工作端点和一个基准,以便了解其在负载下的表现。

预备知识

  • 两个运行 Linux 的 GB300 DGX Station ,通过 Connect Two DGX Station 手册连接并验证,包括其在两条轨道上的 GPU 内存 RDMA 测试。
  • 使用相同的 Linux 用户名在两个工作站上使用 SSH 和 sudo 访问。Docker 和 NVIDIA Container Toolkit 已预安装 DGX Station 软件堆栈。允许对容器注册表、Hugging Face 和软件包存储库进行出站访问。
  • 每个工作站至少有 464 GB 的可用磁盘空间用于其检查点副本,另外还有空间用于存放 vLLM 容器镜像和临时文件。
  • 接受 NVIDIA 开放模型协议和模型卡上列出的原始 GLM-5.3 许可条款 。SPEED-Bench 受 NVIDIA 评估数据集许可协议 (NVIDIA Evaluation Dataset License Agreement) 的约束。
  • Hugging Face 账户和读取访问 token,可访问门控 cais/hle 数据集:登录并打开其页面,然后选择 Agree (同意) 并访问存储库。第 5 步从此数据集中下载 SPEED-Bench 提示词。

配套视频遵循相同的工作流程。

视频 1. 准备、推理、基准测试和关闭演示

第 1 步:准备两个工作站

本教程使用笔记本电脑等单独的计算机来管理这两个工作站。首先,从计算机为每个工作站打开一个 SSH 会话。或者,您也可以在每个工作站的本地终端上工作。在两个工作站上运行此步骤中的每个命令,除非命令以“On A”开头。

两个工作站以不同的角色运行相同的容器和检查点:工作站 A ( rank 0) 托管 API,而工作站 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 组授予根级权限。

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。

两个工作站的轨道名称和设备相同,只有 IPv4 地址不同。

接下来,在每个工作站上创建 ~/glm53.env 。此文件存储后续命令使用的值:

nano ~/glm53.env

粘贴以下块,并将每个 <...> 占位符替换为您注意到的值,同时保留引号。

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 的文件以如下方式开始。除 RANK="1" 外,Station B 的文件相同:

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 会话时,请再次运行此命令。

在这两个工作站上,加载值并检查存储、连接和基准内存:

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 只需几个 MiB 即可显示在两个 GPU 上。

小贴士: 请注意 nvidia-smi 显示的 GPU 显存使用情况;第 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 步:下载并复制模型

张量并行要求两个秩以相同的权重运行相同的软件。首先,在两个工作站上拉取固定图像:

docker pull "$IMG" &&
docker image inspect "$IMG" --format '{{.Architecture}} {{.RepoDigests}}'

拉取可能需要几分钟时间。匹配 Arm64 摘要意味着两个秩运行相同的软件。

在 A 上,下载固定检查点。在约 464 GB 的情况下,在 1 Gb/s 的速度下大约需要一个小时,在 10 Gb/s 的速度下大约需要 6 分钟:

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 ,为 vLLM 提供 93% 的 GPU 显存。如果您更改了其他标志,则每次更改一个标志,然后再次测试。

有关最新推荐配置,请参阅 NVIDIA 的本地 AI recipe 存储库。

带有 --network host 的 安全说明: --host 0.0.0.0 会在每个 Station A 接口 (包括管理) 上显示未经身份验证的 API。防火墙将端口连接到目标客户端,并在更广泛的访问之前添加身份验证和 TLS。

在这两个工作站上,创建名为 ~/launch-glm53.sh 的文件:

nano ~/launch-glm53.sh

该脚本支持多 token 预测 (MTP) ,这是一种预测性解码形式:模型的 MTP 层每步起草四个 token,vLLM 在接受之前使用完整模型对其进行验证,因此每个步骤都可以生成几个 token。收益取决于草稿的接受频率,而接受频率会随着提示词的变化而改变。

与 16 位存储相比,FP8 KV 缓存存储将缓存内存减半,从而为更多 token 留出空间。启用前缀缓存可避免重新处理服务器已看到的提示词前缀。粘贴以下脚本;它会检查您的配置,找到所选轨道的 RoCE GID 索引,并在容器中启动此工作站的 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 加入,然后每个工作站从本地存储加载其份额的权重、准备核函数并捕获 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 回答问题。接下来,在两个工作站上,检查 rank 是否通过 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 站 B 站
使用 GB300 GPU (GiB) 0.01% 231.35 0.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 限制,而是完成了答案。请求将 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 ) 中获取这些提示:如果您还没有,请打开其页面并选择 Agree (同意) 并访问存储库,然后再继续。然后,在 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 是并发请求。一些对话以更高的并发率发送多次。

基准测试请求使用模型的默认推理工作量 (最大值) 和 8192 个 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 会在结果目录中保存指标、原始响应和日志。热身请求排除在报告的指标之外。

可选:重现表 2 。在 ~/launch-glm53.sh 中的步骤 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 代码块。

要在无前缀缓存的情况下进行测试,请在这两个工作站的“Step 3”脚本中将 --enable-prefix-caching 替换为 --no-enable-prefix-caching ,然后按上述步骤重新创建容器。性能可能不同于表 2.

图 2 比较了测量请求的总体输出吞吐量与每个用户的平均吞吐量。Token 数量包括推理。

下表 2 显示了吞吐量和延迟如何随着更多请求共享服务而变化。

配置 并发 总体吞吐量
( tok/ s)
平均请求延迟
( 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 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 进程;检查点、容器和结果保留在磁盘上。要继续,请在 B 上运行 docker start "$CONTAINER" ,然后在 A 上运行,然后重复执行第 4 步检查。

对常见的拦截器进行故障排除

  • 缺少变量或 SSH 失败:重新连接后 source ~/glm53.env ;验证 A-to-B 密钥身份验证和 B 的指纹。
  • SPEED-Bench 准备工作失败,并出现门控数据集错误:使用同一账户登录 Hugging Face,打开 cais/hle 页面,选择 Agree (同意) 并访问存储库,然后重新运行准备工作。
  • 启动或 RDMA 检查失败:检查两个节点上的 docker logs "$CONTAINER" ;验证检查点和 GID,然后重新运行剧本的验证 (脚本 07) 。
  • CUDA 显存不足:降低 --max-model-len 或并发率,然后重新测试。

让端点发挥作用

现在,有一个 7530 亿参数模型在两个 NVIDIA DGX 工作站的一个本地 API 后面运行,每个权重都在 GPU 显存中。这为托管端点开启了一项难以完成的工作:对敏感数据或专有数据运行推理,在本地创建原型代理,以及在无需按 token 成本的情况下对提示词进行迭代。

使用 vLLM 服务文档连接您自己的应用,然后根据提示重新运行 AIPerf,以找到适合您工作负载的并发。现在,您可以直接在桌面上构建前沿模型。

标签