C++ 高性能推理引擎实战：用 ONNX Runtime 把模型推理延迟压到 10ms 以下

C++ 高性能推理引擎实战：用 ONNX Runtime 把模型推理延迟压到 10ms 以下

前言

最近在做一个实时风控系统，需要对每笔交易做 AI 模型推理。业务要求单次推理延迟必须控制在 15ms 以内。

第一版直接用 Python + FastAPI 跑，延迟 80ms。换成 C++ ONNX Runtime 之后，压到了 8ms。

这篇文章记录整个优化过程。不讲废话，直接上数据。

一、为什么选 ONNX Runtime

1.1 推理框架对比

先看数据。同一个 BERT-base 模型，相同硬件（Intel Xeon 8375C，32核），不同框架的推理延迟：

ONNX Runtime C++ 版本的性能已经非常接近 TensorRT，但部署复杂度低很多。对于大多数场景，这就是最优解。

1.2 架构总览

graph TD A[模型训练 PyTorch] --> B[导出 ONNX 格式] B --> C[ONNX Runtime C++ 加载] C --> D{推理优化} D --> E[图优化 Graph Optimization] D --> F[算子融合 Operator Fusion] D --> G[内存预分配 Memory Arena] D --> H[线程池配置 Thread Pool] E --> I[生产部署] F --> I G --> I H --> I I --> J["延迟 < 10ms ✅"]

二、快速上手

2.1 环境准备

# 下载 ONNX Runtime C++ 预编译包（Linux x64） wget https://github.com/microsoft/onnxruntime/releases/download/v1.18.0/onnxruntime-linux-x64-1.18.0.tgz tar -xzf onnxruntime-linux-x64-1.18.0.tgz # CMakeLists.txt 中链接 # find_package(onnxruntime REQUIRED) # target_link_libraries(你的目标 onnxruntime)

2.2 最小可运行示例

#include <onnxruntime_cxx_api.h> #include <iostream> #include <vector> #include <chrono> int main() { // 创建运行环境 Ort::Env env(ORT_LOGGING_LEVEL_WARNING, "风控推理引擎"); Ort::SessionOptions session_options; // 核心优化：开启图优化 session_options.SetGraphOptimizationLevel(GraphOptimizationLevel::ORT_ENABLE_ALL); // 加载模型 Ort::Session session(env, "风控模型.onnx", session_options); // 准备输入数据（模拟一笔交易的特征向量） std::vector<float> input_data(128, 0.5f); // 128维特征 std::vector<int64_t> input_shape = {1, 128}; // 创建输入张量 auto memory_info = Ort::MemoryInfo::CreateCpu(OrtArenaAllocator, OrtMemTypeDefault); Ort::Value input_tensor = Ort::Value::CreateTensor<float>( memory_info, input_data.data(), input_data.size(), input_shape.data(), input_shape.size() ); // 执行推理并计时 const char* input_names[] = {"输入特征"}; const char* output_names[] = {"风险概率"}; auto start = std::chrono::high_resolution_clock::now(); auto output = session.Run( Ort::RunOptions{nullptr}, input_names, &input_tensor, 1, output_names, 1 ); auto end = std::chrono::high_resolution_clock::now(); // 输出结果 float* result = output[0].GetTensorMutableData<float>(); auto duration = std::chrono::duration_cast<std::chrono::microseconds>(end - start); std::cout << "风险概率: " << result[0] << std::endl; std::cout << "推理延迟: " << duration.count() / 1000.0 << "ms" << std::endl; return 0; }

跑一下，大概 15ms 左右。还不够。继续压。

三、核心优化：从 15ms 压到 8ms

3.1 优化一：线程池精调

默认情况下，ONNX Runtime 会用所有 CPU 核心。但核心数越多不代表越快——线程切换和缓存失效会拖后腿。

// 关键：线程数不是越多越好 // 实测数据： // 32线程 -> 15ms（默认） // 16线程 -> 12ms // 8线程 -> 9ms（最优） // 4线程 -> 11ms // 2线程 -> 18ms session_options.SetIntraOpNumThreads(8); // 算子内并行线程数 session_options.SetInterOpNumThreads(1); // 算子间并行线程数 // 💡 经验法则：IntraOp 线程数设为 物理核心数 / 4 // 原因：避免超线程带来的缓存竞争

⚠️踩坑提醒：SetInterOpNumThreads设成 1 就好。多了反而引入调度开销。除非你的模型有大量可并行的独立子图，否则别动这个参数。

3.2 优化二：内存分配策略

每次推理都 malloc/free？太慢了。用 Arena 预分配。

// 启用内存 Arena（预分配内存池） session_options.EnableMemPattern(); // 记忆内存使用模式 session_options.EnableCpuMemArena(); // 启用 CPU 内存 Arena // Arena 的工作原理： // 第一次推理时记录所有内存分配模式 // 后续推理直接从预分配池中获取 // 省掉了反复 malloc/free 的系统调用开销 // 实测：这一项就省了 2ms

3.3 优化三：图优化 + 算子融合

// 最高级别图优化（包含算子融合） session_options.SetGraphOptimizationLevel( GraphOptimizationLevel::ORT_ENABLE_ALL ); // 可选：将优化后的模型保存到磁盘 // 下次启动时直接加载优化后的版本，跳过优化过程 session_options.SetOptimizedModelFilePath("风控模型_优化版.onnx");

💡ORT_ENABLE_ALL 具体做了什么：

1. 常量折叠：把编译期能算出来的东西提前算好
2. 冗余节点消除：去掉不影响输出的中间节点
3. 算子融合：比如 Conv + BN + ReLU 合成一个算子，减少内存拷贝
4. 布局优化：自动选择对 CPU 缓存最友好的数据布局

3.4 完整的生产级配置

#include <onnxruntime_cxx_api.h> #include <vector> #include <chrono> #include <iostream> #include <stdexcept> class 推理引擎 { public: 推理引擎(const std::string& 模型路径, int 线程数 = 8) { // 初始化环境 env_ = std::make_unique<Ort::Env>( ORT_LOGGING_LEVEL_WARNING, "风控推理" ); // 配置会话参数 Ort::SessionOptions options; options.SetIntraOpNumThreads(线程数); options.SetInterOpNumThreads(1); options.SetGraphOptimizationLevel( GraphOptimizationLevel::ORT_ENABLE_ALL ); options.EnableMemPattern(); options.EnableCpuMemArena(); // 设置执行模式为顺序执行（减少调度开销） options.SetExecutionMode(ExecutionMode::ORT_SEQUENTIAL); // 加载模型 session_ = std::make_unique<Ort::Session>( *env_, 模型路径.c_str(), options ); // 预分配内存信息 memory_info_ = Ort::MemoryInfo::CreateCpu( OrtArenaAllocator, OrtMemTypeDefault ); // 预热：跑几次让 Arena 记住内存模式 预热(5); } float 推理(const std::vector<float>& 特征) { if (特征.size() != 128) { throw std::invalid_argument("特征维度必须为128"); } // 创建输入张量（零拷贝，直接引用外部数据） std::vector<int64_t> shape = {1, 128}; Ort::Value input = Ort::Value::CreateTensor<float>( memory_info_, const_cast<float*>(特征.data()), 特征.size(), shape.data(), shape.size() ); // 执行推理 const char* input_names[] = {"features"}; const char* output_names[] = {"probability"}; auto output = session_->Run( Ort::RunOptions{nullptr}, input_names, &input, 1, output_names, 1 ); return output[0].GetTensorMutableData<float>()[0]; } private: void 预热(int 次数) { std::vector<float> dummy(128, 0.0f); for (int i = 0; i < 次数; ++i) { 推理(dummy); } } std::unique_ptr<Ort::Env> env_; std::unique_ptr<Ort::Session> session_; Ort::MemoryInfo memory_info_{nullptr}; }; int main() { try { 推理引擎 engine("风控模型.onnx", 8); // 模拟 1000 次推理，统计延迟 std::vector<double> latencies; std::vector<float> 测试特征(128, 0.5f); for (int i = 0; i < 1000; ++i) { auto start = std::chrono::high_resolution_clock::now(); float result = engine.推理(测试特征); auto end = std::chrono::high_resolution_clock::now(); double ms = std::chrono::duration_cast<std::chrono::microseconds>( end - start ).count() / 1000.0; latencies.push_back(ms); } // 计算统计数据 std::sort(latencies.begin(), latencies.end()); double avg = 0; for (auto l : latencies) avg += l; avg /= latencies.size(); std::cout << "平均延迟: " << avg << "ms" << std::endl; std::cout << "P50 延迟: " << latencies[499] << "ms" << std::endl; std::cout << "P99 延迟: " << latencies[989] << "ms" << std::endl; std::cout << "最大延迟: " << latencies.back() << "ms" << std::endl; } catch (const std::exception& e) { std::cerr << "推理失败: " << e.what() << std::endl; return 1; } return 0; }

四、性能对比结果

优化前后的数据对比：

每一毫秒都有出处。别跟我说"差不多就行"。

五、避坑指南

5.1 模型导出的坑

⚠️ PyTorch 导出 ONNX 时，dynamic_axes别忘了设。否则 batch size 会被固死。

# Python 侧导出（这步别省） import torch model = torch.load("风控模型.pth") model.eval() dummy_input = torch.randn(1, 128) torch.onnx.export( model, dummy_input, "风控模型.onnx", input_names=["features"], output_names=["probability"], dynamic_axes={ "features": {0: "batch_size"}, # batch 维度动态 "probability": {0: "batch_size"} }, opset_version=17 # 用最新的 opset，算子融合效果更好 )

5.2 线程亲和性

在 NUMA 架构服务器上，线程跨 NUMA 节点调度会导致延迟剧烈抖动。

# 绑定到 NUMA node 0 的前 8 个核心 numactl --cpunodebind=0 --membind=0 ./推理服务 # 或者在代码中用 pthread_setaffinity_np 手动绑核

5.3 批量推理

如果场景允许攒批，延迟换吞吐很划算：

六、总结

三个核心优化点：

1. 线程数精调：不是越多越好，物理核心数 / 4 是个好起点
2. 内存 Arena：预分配干掉 malloc/free 的系统调用
3. 图优化全开：算子融合 + 常量折叠 + 布局优化

从 Python 的 80ms 到 C++ 的 8ms，10 倍提升。每一毫秒，都是真金白银。