TencentOS Server 昆仑芯 P800 部署实践

目前，TencentOS Server 已实现对昆仑芯 GPU 驱动的深度适配和原生支持，为使用昆仑芯 GPU 用户提供了昆仑芯基础运行环境库（XRE）安装包，并支持对 XDR 部分的直接编译。XRE 提供了完整的运行时环境，包括内核级驱动、系统管理工具（xpu-smi）及计算运行库，可与上层 AI 框架无缝衔接。
﻿
本文档将指导如何在 TencentOS Server 上快速完成昆仑芯 P800 驱动（XRE）的安装部署，并无缝运行上层 AI 模型与应用。
基础环境要求及说明
支持 TencentOS 内核版本：系统及内核要求参见下表，仅支持该表中系统及内核版本。OS 镜像预装了 TencentOS Server 3.1 (TK4) 及对应内核，购买实例时选择公共镜像中的 TencentOS Server 3.1 即可。
注意：
升级操作系统内核风险较高，可能会导致系统不稳定或出现兼容性问题。在操作内核升级前，请充分了解升级可能出现的问题，建议同步备份重要数据并谨慎操作。
如果您的实例高于支持的内核版本，请联系相关社区，TencentOS 团队与昆仑芯官方将尽快完善支持。
CPU 架构
操作系统
支持内核版本
x86_64
TencentOS Server 3.1 (TK4)
5.4.119-19.0009.56
支持的 GPU 设备：昆仑芯 P800 OAM
驱动软件版本：XRE 5.0.21.47（推荐）、XDR 1.1.0.4
其他要求：
PCIe 需要支持 Gen5 X16。
MMIO 资源满足 GPU 板卡资源需求，BIOS 中 MMIO High Granularity Size 参数应设置为 1024G。
服务器电源满足整机最大工作负载（TDP 400W）。
单个 PCIe 槽位满足 GPU 单卡的供电需求。
环境检查
本文部署实践方案，主要以二进制形式安装驱动包，请通过以下命令确认系统环境符合要求，匹配软硬件系统。检查 CPU 架构、操作系统版本和内核版本满足基础环境要求。若存在任何一项不匹配，请参见 基础环境要求及说明 升级软硬件系统。
# 检查 CPU 架构
uname -m
 
# 检查操作系统版本
lsb_release -a
 
# 检查内核版本
uname -r
# 如内核版本不满足需求，请先升级至指定内核并设置成默认启动内核
# TencentOS Server 3.1 (TK4) 推荐内核版本：5.4.119
dnf install kernel-5.4.119
 
# 检查昆仑芯 GPU 设备是否识别（昆仑芯 PCI vendor ID 为 1d22）
lspci -d 1d22:
﻿
# 检查 IB 网卡状态（多卡训练/推理场景需确认网卡正常）
ibdev2netdev
安装昆仑芯 XRE 驱动
检查网卡 OFED 驱动
驱动安装过程中会自动安装 peermem 组件，该组件安装依赖 OFED。因此需在安装 XRE 前检查主机已安装 5.8-2.0.3 版本的 OFED：
# 若下面路径存在，说明 OFED 已安装
ll /usr/src/ofa_kernel
﻿
# 查看 OFED 版本
ofed_info -s
安装 XRE 驱动包
安装驱动及依赖包。请预先下载 XRE 驱动安装包，并将安装包上传至您的服务器。XRE（昆仑芯基础运行环境库）包含内核级驱动、运行时库及管理工具 xpu-smi：
# 下载 XRE 驱动安装包
wget https://aicompute-1251001002.cos.ap-shanghai.myqcloud.com/kunlunxin/xre-Linux_x86_64-5.0.21.47.run
sudo chmod +x xre-Linux-x86_64-5.0.21.47.run
﻿
# 如果原来已安装过 XRE，先卸载旧版本
sudo bash xre-Linux-x86_64-5.0.21.47.run --uninstall
sudo reboot  # 通过软重启清理缓存
﻿
# 安装驱动（如遇选择信息直接回车选择 default，或增加 -q 静默安装）
sudo bash xre-Linux-x86_64-5.0.21.47.run
﻿
# 检查驱动版本号
cat /proc/kunlun/version
裸金属 ACS 关闭配置（可选）
裸金属机器（HCCPK1 或 HCCPK1s）需关闭 ACS（Access Control Services），虚拟机（HCCPK1t）跳过此步骤。
# 检查 ACS 状态，若全部输出为以下内容则跳过配置
/usr/local/qcloud/set-acs-hsmp/acsctl_online.sh s | grep -i acsctl
﻿
# 预期输出：所有行均显示 SrcValid- TransBlk- ReqRedir- CmpltRedir- UpstreamFwd- EgressCtrl- DirectTrans-
# 若检查失败，执行以下配置
cp -a acsctl_online.sh /usr/local/qcloud/set-acs-hsmp/acsctl_online.sh
chmod +x /usr/local/qcloud/set-acs-hsmp/acsctl_online.sh
/usr/local/qcloud/set-acs-hsmp/acsctl_online.sh d
XPU 设备检查
# 查看 XPU 状态
xpu-smi
﻿
# 查看 XPU 互联拓扑
xpu-smi topo -m
安装 XDR 驱动（可选）
XDR 是昆仑芯软件栈中的可编译部分，提供驱动源码的直接编译能力。如需自定义编译驱动或适配特殊内核版本，可安装 XDR。常规部署场景下，XRE 安装包已满足使用需求，无需单独安装 XDR。
下载 XDR 产出包并编译安装，执行以下命令进行编译安装，注意不同系统中查找内核头文件时的操作差异：
# 下载 XDR 产出包
wget https://klx-sdk-release-public.su.bcebos.com/xccl/release/xdr_copy-x86_64/1.1.0.4/xdr_copy-x86_64_1.1.0.4.tar.gz
﻿
# 解压并进入目录
tar zvxf xdr_copy-x86_64_1.1.0.4.tar.gz
cd xdr_copy-x86_64_1.1.0.4
﻿
# 安装编译依赖
sudo yum install kernel-devel-$(uname -r)
﻿
# 编译（TencentOS Server 3.1 / CentOS 发行版）
KERNELDIR=/usr/src/kernels/$(uname -r) ./build.sh
﻿
# 安装
sudo rmmod xdr  # 如果之前装过其他版本的 xdr
sudo ./install.sh
注意：
TencentOS Server 3.1 (TK4) 内核版本为 5.4.119-19.0009.56，编译 XDR 前需确保已安装匹配的 kernel-devel 包，其他内核下可能报编译错误。
在无法对系统和内核版本进行修改的环境下，需重点关注 BIOS 的高级配置选项。其中，MMIO High Granularity Size 参数应设置为 1024G。部分 BIOS 系统中，该参数可能显示为"MMIO 限制"，此时其值需大于 40BIT。鉴于不同服务器厂商的 BIOS 配置选项存在差异，关于具体 BIOS 配置选项的推荐设置，建议咨询服务器厂商以获取准确信息。
配置路径示例：Advanced -> Socket config -> Uncore config -> configuration
检查 XDR 驱动状态
安装完成后，执行以下命令检查 XDR 驱动状态：
# 检查驱动信息是否正常
lsmod | grep xdr
﻿
# 查看 XPU 信息，n 个 XPU 应该看到 n 行输出
cat /proc/xdr/map_xpus
﻿
# 查看版本
cat /proc/xdr/version
﻿
# 检查设备是否存在
ls /dev/xdrdrv
﻿
# 不应该有返回值
dmesg -T | grep 'XDR disabled'
AI 框架安装与验证
拉取 AI 镜像
昆仑芯 P800 推荐使用腾讯云容器镜像，该镜像预装有昆仑芯基础运行环境库（XRE）、PyTorch（xPytorch）及 vLLM 推理框架，可直接用于训练和推理任务：
# 拉取昆仑芯 P800 容器镜像
docker pull ccr.ccs.tencentyun.com/taco/taco-train:kunlun_torch2.0.1-ubuntu20-04-py3.8-v1.0
说明：
TencentOS Server 3.1 (TK4) 默认 Python 版本为 3.8，容器镜像内已预装对应 Python 环境。如需自定义 Python 版本，请在容器内安装。
启动容器
在容器中运行 AI 框架及大模型需要使用宿主机 GPU 能力，需将昆仑芯 XPU 设备直通至容器。推荐使用如下 Docker Run 方式：
# 定义容器名称和镜像
export XAV_IMAGE=ccr.ccs.tencentyun.com/taco/taco-train:kunlun_torch2.0.1-ubuntu20-04-py3.8-v1.0
export XAV_CONTAINER=test
﻿
# 启动容器（需要 privileged 模式映射 XPU 设备）
docker run -itd --privileged --net=host \\
    --security-opt seccomp=unconfined \\
    --name ${XAV_CONTAINER} \\
    --shm-size 256g \\
    ${XAV_IMAGE} \\
    bash
注意：
昆仑芯 P800 容器需使用 --privileged 模式运行，以确保 XPU 设备完整映射。
共享内存建议设置为 256g（--shm-size 256g），以满足大模型训练/推理的内存需求。
如需挂载数据盘（模型权重等），可通过 -v 参数映射，如 -v /ssd1:/ssd1。
进入容器后，检查昆仑芯 XPU 设备是否正常识别：
xpu-smi
验证 PyTorch 及 vLLM 环境
容器内已预装 PyTorch（xPytorch）和 vLLM 推理框架。进入容器后，执行基础环境检查：
# 检查 PyTorch 版本及 XPU 可用性
python3 -c "import torch; print('PyTorch version:', torch.__version__); print('XPU available:', torch.xpu.is_available()); print('XPU device count:', torch.xpu.device_count())"
﻿
# 检查 vLLM 是否可用
python3 -c "import vllm; print('vLLM version:', vllm.__version__)"
预期输出示例：
# PyTorch 版本信息
PyTorch version: 2.0.1
XPU available: True
XPU device count: 8
﻿
# vLLM 版本信息
vLLM version: 0.7.x
运行大模型推理（以 SGLang + MiniMax-M3 为例）
昆仑芯 P800 支持通过 SGLang 框架进行大模型推理部署。以下示例以 MiniMax-M3 模型为例，展示如何拉取镜像、下载模型权重、启动推理服务并进行性能测试。
拉取推理镜像
# 下载 SGLang P800 镜像
wget -c https://klx-public.bj.bcebos.com/Group_A/docker/sglang-p800-pd-disagg-0510_20260703_474.tar
﻿
# 加载镜像
docker load < sglang-p800-pd-disagg-0510_20260703_474.tar
下载模型权重
# 下载 MiniMax-M3 INT4 模型权重
wget https://klx-public.bj.bcebos.com/Group_A/models/MiniMax-M3-int4.tar
﻿
# 下载 EAGLE3 草稿模型权重（用于投机解码加速）
wget https://klx-public.bj.bcebos.com/Group_A/models/MiniMax-M3-EAGLE3.tar
启动推理容器
# 定义容器名称和镜像
CONTAINER_NAME="sglang_0703_474"
DOCKER_IMAGE="iregistry.baidu-int.com/xpu/sglang-p800-pd-disagg-0510:20260703_474"
﻿
# 配置 XPU 设备映射（按实际卡数调整 XPU_NUM）
XPU_NUM=8
DOCKER_DEVICE_CONFIG=""
for ((idx=0; idx<=$XPU_NUM-1; idx++)); do
    DOCKER_DEVICE_CONFIG+=" --device=/dev/xpu${idx}:/dev/xpu${idx}"
done
DOCKER_DEVICE_CONFIG+=" --device=/dev/xpuctrl:/dev/xpuctrl"
﻿
# 启动容器
docker run -itd \\
    ${DOCKER_DEVICE_CONFIG} \\
    --privileged \\
    --net=host \\
    --cap-add=SYS_PTRACE --security-opt seccomp=unconfined \\
    --tmpfs /dev/shm:rw,nosuid,nodev,exec,size=32g \\
    -v ${PWD}:/work \\
    -v /ssd1:/ssd1 \\
    -v /ssd2:/ssd2 \\
    -v /ssd1:/data1 \\
    --name ${CONTAINER_NAME} \\
    -w /work \\
    ${DOCKER_IMAGE} /bin/bash
启动推理服务
#!/bin/bash
set -x
pkill -9 -f "sglang.launch_server|sglang serve" || true
sleep 2
﻿
# 模型路径和端口
MODEL_DIR=${model_dir:-/data1/models/MiniMax-M3-int4}
DRAFT_MODEL_DIR=${draft_model_dir:-/data1/models/MiniMax-M3-EAGLE3}
PORT=30000
﻿
# ===== 上下文配置（按场景选择档位） =====
# CONTEXT_LEVEL=0: 512K 长上下文，低并发
# CONTEXT_LEVEL=1: 128K 均衡档
# CONTEXT_LEVEL=2: 32K 短上下文，高并发/高吞吐
CONTEXT_LEVEL=${CONTEXT_LEVEL:-0}
PAGE_SIZE=${page_size:-128}
﻿
case "${CONTEXT_LEVEL}" in
0)
    # 512K 长上下文，低并发：优先单请求长度
    CONTEXT_LENGTH=${context_length:-524288}
    MAX_TOTAL_TOKENS=${max_total_tokens:-720896}
    MAX_RUNNING_REQUESTS=${max_running_requests:-24}
    CUDA_GRAPH_MAX_BS=${cuda_graph_max_bs:-24}
    CHUNKED_PREFILL_SIZE=${chunked_prefill_size:-4096}
    MEM_FRACTION_STATIC=${mem_fraction_static:-0.88}
    PIECEWISE_CUDA_GRAPH_MAX_TOKENS=${piecewise_cuda_graph_max_tokens:-512}
    PIECEWISE_CUDA_GRAPH_TOKENS=${piecewise_cuda_graph_tokens:-"4 8 16 32 64 128 192 256 384 512"}
    ;;
1)
    # 128K 均衡：中等并发与吞吐
    CONTEXT_LENGTH=${context_length:-262144}
    MAX_TOTAL_TOKENS=${max_total_tokens:-720896}
    MAX_RUNNING_REQUESTS=${max_running_requests:-64}
    CUDA_GRAPH_MAX_BS=${cuda_graph_max_bs:-64}
    CHUNKED_PREFILL_SIZE=${chunked_prefill_size:-4096}
    MEM_FRACTION_STATIC=${mem_fraction_static:-0.88}
    PIECEWISE_CUDA_GRAPH_MAX_TOKENS=${piecewise_cuda_graph_max_tokens:-4096}
    PIECEWISE_CUDA_GRAPH_TOKENS=${piecewise_cuda_graph_tokens:-"4 8 16 32 64 128 192 256 384 512 768 1024 1536 2048 3072 4096"}
    ;;
2)
    # 32K 短上下文，高并发/高吞吐
    CONTEXT_LENGTH=${context_length:-32768}
    MAX_TOTAL_TOKENS=${max_total_tokens:-786432}
    MAX_RUNNING_REQUESTS=${max_running_requests:-128}
    CUDA_GRAPH_MAX_BS=${cuda_graph_max_bs:-128}
    CHUNKED_PREFILL_SIZE=${chunked_prefill_size:-4096}
    MEM_FRACTION_STATIC=${mem_fraction_static:-0.9}
    PIECEWISE_CUDA_GRAPH_MAX_TOKENS=${piecewise_cuda_graph_max_tokens:-4096}
    PIECEWISE_CUDA_GRAPH_TOKENS=${piecewise_cuda_graph_tokens:-"4 8 16 32 64 128 192 256 384 512 768 1024 1536 2048 3072 4096"}
    ;;
*)
    echo "Invalid CONTEXT_LEVEL=${CONTEXT_LEVEL}. Valid values: 0(512K), 1(128K), 2(32K)."
    exit 1
    ;;
esac
﻿
nohup sglang serve \\
    --host 0.0.0.0 --port ${PORT}  \\
    --model-path "$MODEL_DIR"  \\
    --tp-size 8  \\
    --ep-size 8  \\
    --trust-remote-code  \\
    --attention-backend kunlun  \\
    --mm-attention-backend fa3  \\
    --tool-call-parser minimax-m3-nom  \\
    --reasoning-parser minimax-m3  \\
    --disable-overlap-schedule  \\
    --disable-custom-all-reduce  \\
    --disable-shared-experts-fusion  \\
    --kv-cache-dtype float16  \\
    --dtype float16  \\
    --speculative-algorithm EAGLE3  \\
    --speculative-draft-model-path "$DRAFT_MODEL_DIR"  \\
    --speculative-num-steps 3  \\
    --speculative-eagle-topk 1  \\
    --chunked-prefill-size "$CHUNKED_PREFILL_SIZE"  \\
    --context-length "$CONTEXT_LENGTH"  \\
    --page-size "$PAGE_SIZE"  \\
    --mem-fraction-static "$MEM_FRACTION_STATIC"  \\
    --max-total-tokens "$MAX_TOTAL_TOKENS"  \\
    --max-running-requests "$MAX_RUNNING_REQUESTS"  \\
    --cuda-graph-max-bs "$CUDA_GRAPH_MAX_BS"  \\
    --enforce-piecewise-cuda-graph  \\
    --piecewise-cuda-graph-max-tokens "$PIECEWISE_CUDA_GRAPH_MAX_TOKENS"  \\
    --piecewise-cuda-graph-tokens $PIECEWISE_CUDA_GRAPH_TOKENS  \\
    --watchdog-timeout 3000000 >log_$(date +"%Y%m%d").log 2>&1 &
说明：
上下文分档说明：512K 档优先单请求长度，适合长文本场景；128K 档均衡并发与吞吐，适合通用场景；32K 档牺牲上下文长度换取最大并发吞吐，适合短文本高并发场景。
--tp-size 8 和 --ep-size 8 表示使用 8 卡张量并行和专家并行，需根据实际卡数调整。
EAGLE3 投机解码可显著降低推理延迟，需配合草稿模型使用。
若启动时出现 OOM，可适当降低 MEM_FRACTION_STATIC 值或减小 CONTEXT_LENGTH。
验证服务与性能测试
# curl 对话测试
curl -X POST "http://localhost:30000/v1/chat/completions" \\
    -H "Content-Type: application/json" \\
    -d '{
           "model": "/data1/models/MiniMax-M3-int4",
           "messages": [
               {"role": "user", "content": "给我推荐一个新疆的旅游路线?"}
           ],
           "max_tokens": 32768,
           "top_p": 0.6,
           "temperature": 0.6,
           "top_k": 20,
           "repetition_penalty": 1.05
         }'
﻿
# 性能压测（需先确保服务已正常启动）
curl -X POST "http://0.0.0.0:30000/flush_cache"
﻿
python3 -m sglang.bench_serving \\
    --host 0.0.0.0 \\
    --port 30000 \\
    --backend sglang \\
    --max-concurrency 4 \\
    --num-prompts 64 \\
    --dataset-name generated-shared-prefix \\
    --random-range-ratio 1 \\
    --gsp-num-groups 4 \\
    --gsp-prompts-per-group 16 \\
    --gsp-system-prompt-len 54000 \\
    --gsp-question-len 15000 \\
    --gsp-output-len 500 \\
    --request-rate 1 \\
    --tokenizer /data1/models/MiniMax-M3-int4
运行大模型推理（以 vLLM + DeepSeek-R1 为例）
昆仑芯 P800 同时支持通过 vLLM 框架进行大模型推理部署。以下示例以 DeepSeek-R1 INT8 模型为例，展示如何下载模型权重、启动 vLLM 推理服务并进行性能测试。适用于双机多卡部署场景（tp=4, 2 机共 16 卡，data-parallel 模式）。
下载模型权重
# 下载 DeepSeek-R1 INT8 模型权重（vLLM 格式）
wget -c https://haihub-model-bj-1251001002.cos.ap-beijing.myqcloud.com/kunlun/DeepSeek-R1-Channel-INT8-vllm.tar
﻿
# 下载 DeepSeek-R1 INT8 草稿模型权重（用于 MTP 投机解码加速）
wget -c https://haihub-model-bj-1251001002.cos.ap-beijing.myqcloud.com/kunlun/DeepSeek-R1-INT8-NextN-vllm.tar
启动 vLLM 推理服务
在第一个主节点的容器内执行如下命令（双机部署，TP_SIZE=4，每机 8 卡）：
#!/bin/bash
﻿
# 模型路径（需修改为实际路径）
MODEL=${MODEL:-/data1/models/DeepSeek-R1-Channel-INT8-vllm}
DRAFT_MODEL_PATH=${DRAFT_MODEL_PATH:-/data1/models/DeepSeek-R1-INT8-NextN-vllm}
﻿
# 主节点 IP（子节点需复用此 IP）
DECODER_IP=${DECODER_IP:-22.0.0.3}
IFNAME=${IFNAME:-eth0}
﻿
# 推理参数
TP_SIZE=${TP_SIZE:-4}
MAX_NUM_SEQS=${MAX_NUM_SEQS:-64}
SPEC_TOKEN_NUM=${SPEC_TOKEN_NUM:-3}  # MTP 投机解码 token 数
﻿
# 网络与通信配置
export BKCL_RDMA_NICS=${BKCL_RDMA_NICS:-bond0,bond1,bond2,bond3,bond4,bond5,bond6,bond7}
export GLOO_SOCKET_IFNAME=${IFNAME}
export BKCL_SOCKET_IFNAME=${IFNAME}
export BKCL_ENABLE_XDR=1
export BKCL_USE_RDMA=1
export BKCL_INFERENCE=1  # 开启推理优化
﻿
# xPytorch 相关
export XMLIR_FORCE_USE_XPU_GRAPH=1
export PYTORCH_NO_XPU_MEMORY_CACHING=0
﻿
# 大算子优化
export ENABLE_VLLM_FUSED_QKV_SPLIT_NORM_ROPE=1
export ENABLE_VLLM_FAST_SWIGLU=1
export MOE_ACC_LEVEL=2
﻿
# vLLM 相关
export VLLM_USE_V1=1
export VLLM_ALL2ALL_BACKEND="deepep_low_latency"
export ENABLE_VLLM_XPU_CPU_BINDING=all
export ENABLE_SP=1
﻿
# Data Parallel 配置
NNODES=${NNODES:-2}
DP_SIZE=$((NNODES * 8 / TP_SIZE))
DPL_SIZE=$((8 / TP_SIZE))
﻿
# MTP 投机解码参数
mtp_params=()
if [[ $SPEC_TOKEN_NUM -gt 0 ]]; then
  mtp_params+=(--speculative-config "{\\"model\\": \\"${DRAFT_MODEL_PATH}\\", \\"enable_chunked_prefill\\": false, \\"num_speculative_tokens\\": ${SPEC_TOKEN_NUM}, \\"method\\": \\"deepseek_mtp\\", \\"draft_tensor_parallel_size\\": ${TP_SIZE}}")
fi
﻿
# CUDA Graph capture sizes
capture_sizes=""
for i in $(seq 1 "${MAX_NUM_SEQS}"); do
    value=$((i * (SPEC_TOKEN_NUM + 1)))
    if [ "${i}" -eq 1 ]; then
        capture_sizes+="$value"
    else
        capture_sizes+=", $value"
    fi
done
﻿
HOST_IP=$(hostname -I | awk '{print $1}')
export VLLM_HOST_IP=${HOST_IP}
export NIXL_MOONCAKE_IP_ADDR=${HOST_IP}
﻿
# 启动 vLLM serve（主节点）
nohup vllm serve "${MODEL}" \\
  --data-parallel-address "${DECODER_IP}" \\
  --port 38200 \\
  --gpu-memory-utilization 0.8 \\
  --trust-remote-code \\
  --served-model-name base_model \\
  --enable-expert-parallel \\
  --tensor-parallel-size ${TP_SIZE} \\
  --data-parallel-size ${DP_SIZE} \\
  --data-parallel-size-local ${DPL_SIZE} \\
  --data-parallel-rpc-port 38799 \\
  --block_size 128 \\
  --max_num_seqs ${MAX_NUM_SEQS} \\
  --max_model_len 72000 \\
  --max-num-batched-tokens 4096 \\
  --dtype bfloat16 \\
  --expert-placement-strategy round_robin \\
  --enable-prefix-caching \\
  --no-enable-chunked-prefill \\
  --compilation_config '{"level": 0, "cudagraph_capture_sizes': '["'$capture_sizes'"]''}' \\
  "${mtp_params[@]}" \\
  --api-server-count=4 >log_$(date +"%Y-%m-%d-%H:%M:%S").log 2>&1 &
在第二个副节点的容器内执行如下命令（添加 --headless 和 --data-parallel-start-rank 参数）：
# 副节点与主节点配置基本一致，区别如下：
# 1. DECODER_IP 复用主节点 IP
# 2. 添加 --headless 参数
# 3. 添加 --data-parallel-start-rank 参数
﻿
DP_START_RANK=${DP_START_RANK:-2}  # D1-3 -> 2 4 6
﻿
nohup vllm serve "${MODEL}" \\
  --data-parallel-address "${DECODER_IP}" \\
  --port 38200 \\
  --gpu-memory-utilization 0.8 \\
  --trust-remote-code \\
  --served-model-name base_model \\
  --enable-expert-parallel \\
  --tensor-parallel-size ${TP_SIZE} \\
  --data-parallel-size ${DP_SIZE} \\
  --data-parallel-size-local ${DPL_SIZE} \\
  --data-parallel-start-rank "${DP_START_RANK}" \\
  --data-parallel-rpc-port 38799 \\
  --block_size 128 \\
  --max_num_seqs ${MAX_NUM_SEQS} \\
  --max_model_len 72000 \\
  --max-num-batched-tokens 4096 \\
  --dtype bfloat16 \\
  --expert-placement-strategy round_robin \\
  --enable-prefix-caching \\
  --no-enable-chunked-prefill \\
  --compilation_config '{"level": 0, "cudagraph_capture_sizes': '["'$capture_sizes'"]''}' \\
  "${mtp_params[@]}" \\
  --headless >log_$(date +"%Y-%m-%d-%H:%M:%S").log 2>&1 &
说明：
双机部署时，主节点和副节点需使用相同的模型路径、TP_SIZE 和通信配置。
--tensor-parallel-size 4 表示每机使用 4 卡张量并行，16 卡双机通过 data-parallel 模式协同。
MTP（Multi-Token Prediction）投机解码可显著降低首 token 延迟，需配合草稿模型使用。
若启动时出现 OOM，可适当降低 --gpu-memory-utilization 值或减小 --max_model_len。
验证服务与性能测试
# 对话测试
curl -X POST "http://localhost:38200/v1/chat/completions" \\
    -H "Content-Type: application/json" \\
    -d '{
           "model": "base_model",
           "messages": [
               {"role": "user", "content": "请介绍一下深度学习的基本概念。"}
           ],
           "max_tokens": 1024,
           "temperature": 0.7
         }'
﻿
# vLLM bench 性能压测
for workers in 32 64 128 256; do
    concurrency_multiplier=8
    if [ $workers -gt 128 ]; then
        concurrency_multiplier=4
    fi
    vllm bench serve \\
        --backend vllm \\
        --model /data1/models/DeepSeek-R1-Channel-INT8-vllm \\
        --served-model-name base_model \\
        --dataset-name random \\
        --random-input-len 1005 \\
        --random-output-len 635 \\
        --num-prompts $((workers*concurrency_multiplier)) \\
        --max-concurrency $workers \\
        --host 0.0.0.0 \\
        --port 38200 \\
        --ignore-eos
done
﻿
附录
附录一：软件包清单
昆仑芯 P800 在 TencentOS 上的驱动软件包清单：
分类
版本
安装方式
XRE（基础运行环境库）
5.0.21.47（推荐）/ 5.0.21.43（兼容）
.run 安装包（sudo bash xre-Linux-x86_64-5.0.21.47.run）
XDR（可编译驱动）
1.1.0.4
源码编译安装
OFED（网卡驱动）
5.8-2.0.3
OS 镜像预装
说明：
XRE 是昆仑芯基础运行环境库，以 .run 安装包形式提供，包含内核级驱动、运行时库及管理工具 xpu-smi。推荐版本 5.0.21.47，兼容版本 5.0.21.43。
XDR 是驱动的可编译部分，支持直接编译安装，适用于自定义内核适配场景。下载地址：https://klx-sdk-release-public.su.bcebos.com/xccl/release/xdr_copy-x86_64/1.1.0.4/xdr_copy-x86_64_1.1.0.4.tar.gz。
OFED 驱动由 TencentOS 镜像预装，多卡训练/推理场景下 peermem 组件依赖 OFED，安装 XRE 前需确认 OFED 状态。
﻿
附录二：昆仑芯 P800 及软件栈架构介绍
P800 OAM 是基于昆仑芯 P800 芯片设计的一款 AI 加速模组，依据 OCP OAM 标准设计，兼容 OAI（Open Accelerator Infrastructure）标准，是一款面向大语言模型场景的高性能人工智能训练产品，同时支持推理场景。P800 OAM 支持 PCIe 5.0，支持 FP16、FP32、INT8 等多种计算精度，显存容量 96G，TDP（最大热设计功耗）400W。
昆仑芯 SDK 提供从底层驱动环境到上层模型转换等全栈的软件工具：
XRE（XPU Runtime Environment）：昆仑芯基础运行环境库，包含内核驱动（kmd）、用户态运行时库及系统管理工具 xpu-smi，以 .run 安装包形式分发。
XDR：驱动的可编译部分，支持源码直接编译，用于适配特殊内核版本或自定义配置。
XDNN：昆仑芯深度学习计算库，提供高性能算子加速。
XBLAS：昆仑芯基础线性代数库，提供 BLAS 运算加速。
XTDK：昆仑芯模型转换工具套件，支持模型量化、格式转换等。
XCCL（XPU Collective Communication Library）：昆仑芯集合通信库，支持多卡训练时的卡间通信。
XHPC：昆仑芯高性能计算库，提供 BLAS、FFT 等数学运算加速。
昆仑芯 SDK 兼容 PyTorch、DeepSpeed 等主流 AI 框架，确保模型迁移无需改动代码且性能无损。
﻿
附录三：昆仑芯 P800 硬件规格
项目
规格
芯片型号
昆仑芯 P800
卡形态
OAM（Open Accelerator Module）
适配 CPU
Intel x86_64
接口
PCIe Gen5 X16
计算精度
FP16、FP32、INT8
显存容量
96G
TDP（最大热设计功耗）
400W
驱动软件
XRE 5.0.21.47（推荐）+ XDR 1.1.0.4
适配系统
TencentOS Server 3.1 (TK4)（内核 5.4.119-19.0009.56）
AI 框架
PyTorch（xPytorch）、vLLM、SGLang
推理框架支持的模型
MiniMax-M3、DeepSeek、Qwen 系列等
CPU 架构	操作系统	支持内核版本
x86_64	TencentOS Server 3.1 (TK4)	5.4.119-19.0009.56
分类	版本	安装方式
XRE（基础运行环境库）	5.0.21.47（推荐）/ 5.0.21.43（兼容）	`.run` 安装包（`sudo bash xre-Linux-x86_64-5.0.21.47.run`）
XDR（可编译驱动）	1.1.0.4	源码编译安装
OFED（网卡驱动）	5.8-2.0.3	OS 镜像预装
项目	规格
芯片型号	昆仑芯 P800
卡形态	OAM（Open Accelerator Module）
适配 CPU	Intel x86_64
接口	PCIe Gen5 X16
计算精度	FP16、FP32、INT8
显存容量	96G
TDP（最大热设计功耗）	400W
驱动软件	XRE 5.0.21.47（推荐）+ XDR 1.1.0.4
适配系统	TencentOS Server 3.1 (TK4)（内核 5.4.119-19.0009.56）
AI 框架	PyTorch（xPytorch）、vLLM、SGLang
推理框架支持的模型	MiniMax-M3、DeepSeek、Qwen 系列等
昆仑芯 P800 部署实践

本页目录：

基础环境要求及说明

环境检查

安装昆仑芯 XRE 驱动

检查网卡 OFED 驱动

安装 XRE 驱动包

裸金属 ACS 关闭配置（可选）

XPU 设备检查

安装 XDR 驱动（可选）

检查 XDR 驱动状态

AI 框架安装与验证

拉取 AI 镜像

启动容器

验证 PyTorch 及 vLLM 环境

运行大模型推理（以 SGLang + MiniMax-M3 为例）

拉取推理镜像

下载模型权重

启动推理容器

启动推理服务

验证服务与性能测试

运行大模型推理（以 vLLM + DeepSeek-R1 为例）

下载模型权重

启动 vLLM 推理服务

验证服务与性能测试

附录

附录一：软件包清单

附录二：昆仑芯 P800 及软件栈架构介绍

附录三：昆仑芯 P800 硬件规格
