【CPU方式加载推理模型】xinferece vllm 跑emb 性能和vllm serve 原生相比，【并发1】要低

[ZhikaiGuo960110]

System Info / 系統信息

xinference 1.15.0
vllm 0.11
ubuntu 20.04

Running Xinference with Docker? / 是否使用 Docker 运行 Xinfernece？

• docker / docker
• pip install / 通过 pip install 安装
• installation from source / 从源码安装

Version info / 版本信息

已知在1.15.0 上，vllm emb 已知支持了聚合组batch 逻辑和异步优化处理
#4197
具体见

The command used to start Xinference / 用以启动 xinference 的命令

xinf 启动Qwen3-Embedding-0.6B, cpu 方式, tp1

想对比，vllm 方式
vllm serve /weights/Qwen3-Embed-0.6B --trust-remote-code --tensor-parallel-size 1 --max-model-len 6553 --enforce-eager --served-model-name qwen3_emb --port 8008 --task embed --enable-log-requests

Reproduction / 复现过程

import requests
import time

定义请求参数

开始计时

for i in range(50000):
start_time = time.time()
response = requests.post(
"http://localhost:8008/v1/embeddings", # Embedding 端点
json={
"model": "qwen3-emb", # 替换为你的 Embedding 模型 UID（如 'bge-m3'）
"input": "A man is eating pasta." # 支持字符串或字符串列表
}
)
# 结束计时
end_time = time.time()
total_time = end_time - start_time

print(f"{i} 请求耗时: {total_time:.3f} 秒")
# print("Emb 结果:", response.json())

测试代码，查看每个请求处理耗时。
vllm serve 原生每个请求差不多 0.078s

Expected behavior / 期待表现

两边耗时接近，性能尽可能持平。

[ZhikaiGuo960110]

可以看到，xinf 虽然也是32 cores 活跃，但是CPU each core 利用率不算太高。

导致每个请求单一耗时较大。

[ZhikaiGuo960110]

对比来看，vllm serve 原生的话，CPU 每个core 几乎打满了，所以导致性能目前有差异。

[qinxuye]

是不是还是要 bind 下 cpu core？

[ZhikaiGuo960110]

我也在研究看看，但我感觉xinf cpu 也是bind core 了，只是感觉core利用率上不去导致的性能问题

[ZhikaiGuo960110]

高并发下【比如128并发下， 都是短文本输入】，xinf-cpu cores 是活跃的，auto batching 也把算力打满，现在就是低并发下，cores 不活跃。

[ZhikaiGuo960110]

目前有一个新进展，如果单纯用LLM.embed 去调用CPU, 然后加载模型推理，CPU core 是能打满的，并且数据和vllm serve 基本上能对齐，可能率低但是差距不会太大。怀疑可能是xoscar 或者哪里组件有阻塞请求现象。 具体还得再排查。 测试启动方式如下： `import os

os.environ["VLLM_TARGET_DEVICE"] = "cpu"

from fastapi import FastAPI, HTTPException

from vllm import LLM
import uvicorn
import traceback

app = FastAPI()
llm = None

========== 新增：CPU绑核配置 ==========

def bind_cpu_cores(core_ids):
"""
绑定进程到指定CPU核心
:param core_ids: 核心列表，如 [0,1,2,3] 或 [0]
"""
try:
# 方式1：os.sched_setaffinity（Linux/macOS）
os.sched_setaffinity(0, core_ids) # 0表示当前进程
print(f"✅ 成功绑定CPU核心: {core_ids}")

    # 验证绑定结果
    current_cores = os.sched_getaffinity(0)
    print(f"🔍 当前进程绑定的核心: {sorted(list(current_cores))}")
except AttributeError:
    # 方式2：psutil兼容（Windows/Linux/macOS）
    process = psutil.Process(os.getpid())
    process.cpu_affinity(core_ids)
    print(f"✅ (psutil) 成功绑定CPU核心: {core_ids}")
except Exception as e:
    print(f"⚠️ 绑核失败: {e}")

os.environ["OMP_NUM_THREADS"] = "8"
CPU_CORES_TO_BIND = [0,1,2,3,4,5,6,7,8]
bind_cpu_cores(CPU_CORES_TO_BIND)

def extract_embedding(output):
"""从输出中提取嵌入向量，尝试多种可能的属性"""
# 尝试方式1: output.outputs.embedding
if hasattr(output, 'outputs') and hasattr(output.outputs, 'embedding'):
print("output.outputs.embedding")
return output.outputs.embedding

# 尝试方式2: output.outputs.data
if hasattr(output, 'outputs') and hasattr(output.outputs, 'data'):
    print(f"outputs:{output}, {type(output)} ")
    print("output.outputs.data")
    return output.outputs.data

# 尝试方式3: output.outputs (直接是列表)
if hasattr(output, 'outputs') and isinstance(output.outputs, list):
    print("output.outputs")
    return output.outputs

# 尝试方式4: output.embedding
if hasattr(output, 'embedding'):
    print("embedding")
    return output.embedding

# 尝试方式5: output.data
if hasattr(output, 'data'):
    print("data")
    return output.data

# 尝试方式6: output 本身就是嵌入
if isinstance(output, list):
    print("list")
    return output

# 如果都不行，打印结构帮助调试
print(f"无法提取嵌入，输出类型: {type(output)}")
print(f"输出属性: {dir(output)}")
print(f"{output}")
if hasattr(output, 'outputs'):
    print(f"outputs 类型: {type(output.outputs)}")
    print(f"outputs 属性: {dir(output.outputs)}")

raise ValueError(f"无法从输出中提取嵌入向量，输出类型: {type(output)}")

@app.on_event("startup")
async def startup_event():
global llm
print("正在初始化 vLLM CPU 引擎 (v0.11.1.dev)...")
try:
llm = LLM(
model="/embedding_weights/Qwen3-Embed-0.6B",
task="embed",
trust_remote_code=True,
tensor_parallel_size=1,
max_model_len=8192,
enforce_eager=True,
)
print("vLLM 引擎初始化完成!")

    # 测试编码
    #test_output = llm.embed(["测试"], pooling_task="embed")
    test_output = llm.embed(["hello"])
    test_embedding = extract_embedding(test_output[0])
    
    print(f"测试编码成功! 向量维度: {len(test_embedding)}")
    
except Exception as e:
    print(f"初始化失败: {e}")
    print(traceback.format_exc())
    raise

@app.post("/v1/embeddings")
async def create_embedding(data: dict):
global llm

if llm is None:
    raise HTTPException(status_code=503, detail="模型未加载")

try:
    inputs = data.get("input", "")
    if isinstance(inputs, str):
        inputs = [inputs]
    
    # 调用 encode，传递 pooling_task
    #outputs = llm.embed(inputs, pooling_task="embed")
    outputs = llm.embed(["hello"])
    # 提取嵌入向量
    embeddings = [extract_embedding(output) for output in outputs]
    
    return {
        "data": [{"embedding": emb, "index": i} for i, emb in enumerate(embeddings)],
        "model": "qwen3_emb"
    }
except Exception as e:
    print(f"编码错误: {e}")
    print(traceback.format_exc())
    raise HTTPException(status_code=500, detail=str(e))

@app.get("/health")
async def health_check():
return {"status": "healthy", "model_loaded": llm is not None}

if name == 'main':
uvicorn.run(app, host="0.0.0.0", port=8088)
`

[ZhikaiGuo960110]

qwen3_vllm_embed.py

[ZhikaiGuo960110]

目前出现了一个奇怪现象。就是

这个函数会耗时更慢，但是进到具体接口里面，耗时和vllm serve 能对齐，消失的0.2s 不知道在哪里

[ZhikaiGuo960110]

问题出现在装饰器cache clean, 导致开销大。 如果低并发注释调这部分，cpu core 是能打满的，和vllm serve 基本上持平，会稍微低一点，但差异不算太大。

。这个地方要改一下

[ZhikaiGuo960110]

rerank 同理。这个地方社区要关注一下。