一文搞懂ONNX-Runtime综述&使用&源码分析（持续更新）

最新推荐文章于 2025-02-13 09:16:28 发布

奇华智能

最新推荐文章于 2025-02-13 09:16:28 发布

阅读量2.2k

点赞数 3

文章标签：人工智能深度学习 AI

原文链接：https://zhuanlan.zhihu.com/p/655086894

版权

一：综述

onnx-runtime的结构如下：

整体来看，这是个异构模型运行框架，先将原始onnx模型做硬件无关的图优化后，获取当前支持的硬件对应的算子库，然后将模型切分为多个sub-model，最后在下发到各个硬件平台上执行，onnx称之为：并行&分布式的runtime，当前onnx-runtime对模型计算仅提供同步模式，不支持异步模式

ORT： onnx-runtime的简称

graph transformer：onnx-runtime对图优化的抽象

EP：execution provider： onnx对各个硬件平台的算子库+运行时的抽象，提供对应硬件上的：内存管理+算子库；可以仅实现onnx算计集合的部分算子，但是onnx-runtime 默认的execution provider（CPU）是支持所有onnx算子；onnx-runtime提供标准的tensor定义，但是各个execution provider可以提供自己不同的定义，但是需要execution provider提供标准tensor向自定义tensor的转换接口；可以添加新的EP和Op实现

每个inference-session的run接口，可以多线程调用，因此要求每个kernel的compute接口是支持并发的（即无状态的）

兼容性：ORT支持后向兼容，即新的ORT可以运行老版本的onnx模型

多平台支持： win（CPU+GPU）、linux（CPU+GPU）、mac、ios、Android

二：应用

2.1 安装

# linux + cuda 11.6 + python
# onnxruntime --- cpu
# onnxruntime-gpt --- cuda&tensorrt&cpu
# onnxruntime-gpu 包含onnxruntime的功能，二者在只能二选一，不能同时存在
pip install onnx -i https://pypi.tuna.tsinghua.edu.cn/simple
pip install onnxruntime -i https://pypi.tuna.tsinghua.edu.cn/simple
pip install onnxruntime-gpu -i https://pypi.tuna.tsinghua.edu.cn/simple

2.n: 性能优化

三：源码分析

3.1 综述

ORT 头文件分析

onnx-runtime\include\onnxruntime\core\common
onnx-runtime\include\onnxruntime\core\eager
onnx-runtime\include\onnxruntime\core\framework
onnx-runtime\include\onnxruntime\core\graph
onnx-runtime\include\onnxruntime\core\optimizer
onnx-runtime\include\onnxruntime\core\platform
onnx-runtime\include\onnxruntime\core\providers
onnx-runtime\include\onnxruntime\core\session

3.1.1 common

onnx_runtime\onnx-runtime\include\onnxruntime\core\common\basic_types.h
/** A computed hash value. */
using HashValue = uint64_t; // 使用uint64来表示hash值

onnx_runtime\onnx-runtime\include\onnxruntime\core\common\exceptions.h
// ORT 异常定义：如未实现的算子{NotImplementedException}，运行时异常等
class NotImplementedException : public std::logic_error
class TypeMismatchException : public std::logic_error
class OnnxRuntimeException : public std::exception

onnx_runtime\onnx-runtime\include\onnxruntime\core\common\narrow.h
// 对gsl::narrow的包装，禁用异常时，也可以使用，用于做溢出检查

3.1.2 framework

onnx_runtime\onnx-runtime\include\onnxruntime\core\framework\alloc_kind.h ---- 内存分配类型
1. 模型的输入tensor：由用户分配
2. 模型的输出tensor：由runtime分配，runtime将权限转移给用户： ---- 这个比较奇怪
3. weight：静态内存，分配一次，多次使用

onnx_runtime\onnx-runtime\include\onnxruntime\core\framework\allocator.h ---- 内存分配释放
1. 提供Alloc/Free接口，由底层硬件如：cpu、gpu负责实现

onnx_runtime\onnx-runtime\include\onnxruntime\core\framework\execution_provider.h --- EP抽象接口，各个EP负责实现
1. 提供数据格式转换：如：NCHW--->NHWC： GetDataTransfer
2. 提供算子查找接口：基于Node来查找该EP支持该算子的信息，方便FMK来创建对应EP上的kernel
virtual const KernelCreateInfo* LookUpKernel(const Node& node) const = 0;
3. 提供获取kernel注册的接口
GetKernelRegistry()

onnx_runtime\onnx-runtime\include\onnxruntime\core\framework\kernel_registry.h --- 各EP的kernel注册接口，负责向算子库注册

onnx_runtime\onnx-runtime\include\onnxruntime\core\framework\op_kernel_context.h --- kernel的运行环境信息

onnx_runtime\onnx-runtime\include\onnxruntime\core\framework\op_node_proto_helper.h -- 获取proto定义的op的信息助手

onnx_runtime\onnx-runtime\include\onnxruntime\core\framework\ort_value.h --- ORT中tensor/sparer_tensor等的封装

onnx_runtime\onnx-runtime\include\onnxruntime\core\framework\ortdevice.h --- device的定义：CUDA/CPU/HIP/CANN

framework主要提供：内存管理（Alloc/Free）+ tensor定义 + op_kernel注册 + EP接口定义等功能

3.1.3 graph

onnx_runtime\onnx-runtime\include\onnxruntime\core\graph\constants.h --- 一些常用常量定义
constexpr const char* kOnnxDomainAlias = "ai.onnx";
constexpr const char* kMLDomain = "ai.onnx.ml";

// 各种EP
constexpr const char* kCpuExecutionProvider = "CPUExecutionProvider";
constexpr const char* kCudaExecutionProvider = "CUDAExecutionProvider";
constexpr const char* kDnnlExecutionProvider = "DnnlExecutionProvider";
constexpr const char* kOpenVINOExecutionProvider = "OpenVINOExecutionProvider";

onnx_runtime\onnx-runtime\include\onnxruntime\core\graph\graph.h ---- graph、node/edge： 图、边、节点的定义和操作
--- 计算图的定义
class Graph ：
// 0. 图标识：通过name来唯一标识

const std::string& Name()
void SetName(const std::string& name);
const std::string& Description() 
void SetDescription(const std::string& description);
// 1. 支持图嵌套，当前graph是sub-graph的话，则拥有parentgraph
bool IsSubgraph() 
Graph* ParentGraph()

// 2. 支持修改/增加/查询graph中的node的weight数据，将name相同的tensor用新的new_initializer替换掉
      一般在图融合中会用到，比如conv+bn融合时
   common::Status ReplaceInitializedTensor(ONNX_NAMESPACE::TensorProto new_initializer);
  /** Add an initializer tensor to the Graph. */
  void AddInitializedTensor(const ONNX_NAMESPACE::TensorProto& tensor_proto);
  /** Remove the initializer tensor with the provided name from the Graph. */
  void RemoveInitializedTensor(const std::string& tensor_name);
  /** Check if a given name is an initializer tensor's name in this graph. */
  bool IsInitializedTensor(const std::string& name) const;
  bool GetInitializedTensor(const std::string& tensor_name, const ONNX_NAMESPACE::TensorProto*& value) const;

// 3. 获取graph的输入输出tensor，输入tensor分两种，常量和非常量：非常量为tensor，常量为initializer
std::vector<const NodeArg*>& GetInputs() // 输入为tensor
std::vector<const NodeArg*>& GetInputsIncludingInitializers() // 输入为const tensor
std::vector<const NodeArg*>& GetOutputs()

// 4. 对graph中的nodes提供操作：增删改查
const Node* GetNode(NodeIndex node_index) // 依据index来获取node
 GraphNodes& Nodes() // 获取所有nodes
int MaxNodeIndex() // 获取graph中node的最大索引
int NumberOfNodes() // 获取graph中node的数量
NodeArg* GetNodeArg(const std::string& name) // 依据node-name来获取node
Node& AddNode(const Node& other); // 提供了各种方法来增加node
bool RemoveNode(NodeIndex node_index); // 删除
void AddEdge(NodeIndex src_node_index, NodeIndex dst_node_index, int src_arg_index, int dst_arg_index);
void RemoveEdge(NodeIndex src_node_index, NodeIndex dst_node_index, int src_arg_index, int dst_arg_index);
 bool AddControlEdge(NodeIndex src_node_index, NodeIndex dst_node_index); // 控制流算子会用到，控制边和普通的边分开

// 5. 对graph进行拓补排序
  void KahnsTopologicalSort(const std::function<void(const Node*)>& enter,
                            const std::function<bool(const Node*, const Node*)>& comp) const;

//  6. 将sub-graph作为一个node的存在，内嵌到当前graph中
  Node& BeginFuseSubGraph(const IndexedSubGraph& sub_graph, const std::string& fused_node_name);

  void FinalizeFuseSubGraph(const IndexedSubGraph& sub_graph, Node& fused_node);

// 7. graph 和 graph-proto的互操作
  const ONNX_NAMESPACE::GraphProto& ToGraphProto();
  ONNX_NAMESPACE::GraphProto ToGraphProto() const;

// 8. node 和 op之间的操作
bool SetOpSchemaFromRegistryForNode(Node& node); // 为node设置op-schema

// 9. graph和model之间的操作
Model& GetModel() // 获取graph所属的model

// 10. graph的构造
  Graph(Graph& parent_graph, const Node& parent_node, ONNX_NAMESPACE::GraphProto& subgraph_proto);
  Graph(const Model& owning_model, // 所属的model
        IOnnxRuntimeOpSchemaCollectionPtr schema_registry,
        ONNX_NAMESPACE::GraphProto& subgraph_proto,
        const std::unordered_map<std::string, int>& domain_version_map,
        const logging::Logger& logger,
        bool strict_shape_type_inference);

//  11. 图的解析
  /**
  Resolve this Graph to ensure it is completely valid, fully initialized, and able to be executed.
  1. Run through all validation rules.
    a. Node name and node output's names should be unique.
    b. Attribute match between node and op definition.
    c. Input/Output match between node and op definition.
    d. Graph is acyclic and sort nodes in topological order.
  2. Check & Setup inner nodes' dependency.
  3. Cleanup function definition lists.
  Note: the weights for training can't be cleaned during resolve.
  @returns common::Status with success or error information.
  */
  common::Status Resolve(const ResolveOptions& options);

  common::Status Resolve() {
    ResolveOptions default_options;
    return Resolve(default_options);
  }

graph的关键在于：图构建和图排序，以及图修改（删除或者增加Node或者修改Node）

3.1.4 optimizer

ORT将优化分为不同的等级，各种优化归属于不能的优化等级下

enum class TransformerLevel : int {
  Default = 0,  // required transformers only
  Level1,       // basic optimizations
  Level2,       // extended optimizations
  Level3,       // layout optimizations
  // The max level should always be same as the last level.
  MaxLevel = Level3
};

图优化图融合相关操作

onnx_runtime\onnx-runtime\include\onnxruntime\core\optimizer\graph_transformer.h
Status Apply(Graph& graph, bool& modified, const logging::Logger& logger) const; // 图融合的入口

onnx_runtime\onnx-runtime\include\onnxruntime\core\optimizer\rewrite_rule.h ---- 子图重写规则 --- 算子融合

3.1.4.1 RewriteRule

实现局部的graph改写，例如：算子融合、无效算子删除等，主要为两个步骤：

步骤0：确定触发规则的算子：

  std::vector<std::string> TargetOpTypes() const noexcept override {
    return {"Cast"}; // 可以是一个，多个算子。 如果是这些算子，才会触发该规则
  }

步骤一：规则匹配：核心就是子图匹配、参数匹配、属性匹配等，算子融合的原理和步骤都是一样的

virtual bool SatisfyCondition(const Graph& graph, const Node& node, const logging::Logger& logger) const = 0;
1. 在该接口中设置匹配的规则，比如：conv+bn子图匹配
2. 该接口会被图优化框架调用
3. graph --- 为整个计算图，node为当前的节点

步骤二：进行改写

virtual common::Status Apply(Graph& graph, Node& node, RewriteRuleEffect& rule_effect, const logging::Logger& logger) const = 0;
};

上层框架调用方式：

  common::Status CheckConditionAndApply(Graph& graph, Node& node, RewriteRuleEffect& rule_effect, const logging::Logger& logger) const {
    return SatisfyCondition(graph, node, logger) ? Apply(graph, node, rule_effect, logger) : Status::OK();
  }

重写后对graph的影响：更新op参数、修改op、删除op

  enum class RewriteRuleEffect : uint8_t {
    kNone,                // The rewrite rule has not modified the graph.
    kUpdatedCurrentNode,  // The rewrite rule updated (but did not remove) the node on which it was triggered.
    kRemovedCurrentNode,  // The rewrite rule removed the node on which it was triggered.
    kModifiedRestOfGraph  // The rewrite rule modified nodes other than the one it was triggered on.
  };

类关系：

class RuleBasedGraphTransformer : public GraphTransformer
Status RuleBasedGraphTransformer::ApplyRulesOnNode(Graph& graph, Node& node,
                                                   gsl::span<const std::reference_wrapper<const RewriteRule>> rules,
                                                   RuleEffect& rule_effect, const logging::Logger& logger) const {
  for (const RewriteRule& rule : rules) { // 遍历多个子图融合规则，所以，这里也涉及到一个融合顺序先后的问题
    ORT_RETURN_IF_ERROR(rule.CheckConditionAndApply(graph, node, rule_effect, logger));
    // If the current node was removed as a result of a rule, stop rule application for that node.
    if (rule_effect == RuleEffect::kRemovedCurrentNode) {
      break;
    }
  }
  return Status::OK();
}

上层调用：

onnx_runtime\onnx-runtime\onnxruntime\core\optimizer\graph_transformer_utils.cc
InlinedVector<std::unique_ptr<GraphTransformer>> GenerateTransformers(
    TransformerLevel level,
    const SessionOptions& session_options,
    const IExecutionProvider& cpu_execution_provider, /*required by constant folding*/
    const InlinedHashSet<std::string>& rules_and_transformers_to_disable) {
     // level=0时，会添加 rewiterule的算子融合相关
      auto rule_transformer = GenerateRuleBasedGraphTransformer(level, rules_and_transformers_to_disable, {});
      if (rule_transformer != nullptr) {
        transformers.emplace_back(std::move(rule_transformer));
      }
}

Status RuleBasedGraphTransformer::ApplyImpl(Graph& graph, bool& modified, int graph_level, const logging::Logger& logger) const {
  GraphViewer graph_viewer(graph);
  auto& order = graph_viewer.GetNodesInTopologicalOrder(); // 先拓扑排序后的graph

  for (NodeIndex i : order) {
    auto* node = graph.GetNode(i); // 按照计算图算子执行顺序进行遍历
    // A node might not be found as it might have already been deleted from one of the rules.
    if (!node) {
      continue;
    }

    // Initialize the effect of rules on this node to denote that the graph has not yet been modified
    // by the rule application on the current node.
    auto rule_effect = RuleEffect::kNone;
    
   // 查看当前op的融合规则适用于哪些设备，涉及到异构场景下的融合了
    if (!graph_utils::IsSupportedProvider(*node, GetCompatibleExecutionProviders())) {
      continue;
    }

    // First apply rewrite rules that are registered for the op type of the current node; then apply rules that are
    // registered to be applied regardless of the op type; then recursively apply rules to subgraphs (if any).
    // Stop further rule application for the current node, if the node gets removed by a rule.
    const InlinedVector<std::reference_wrapper<const RewriteRule>>* rules = nullptr;

    rules = GetRewriteRulesForOpType(node->OpType()); // 按照op_type来获取和该op相关的一系列融合规则
    if (rules) {
      ORT_RETURN_IF_ERROR(ApplyRulesOnNode(graph, *node, *rules, rule_effect, logger));
    }

    if (rule_effect != RuleEffect::kRemovedCurrentNode) {
      rules = GetAnyOpRewriteRules();
      if (rules) {
        ORT_RETURN_IF_ERROR(ApplyRulesOnNode(graph, *node, *rules, rule_effect, logger));
      }
    }

    // Update the modified field of the rule-based transformer.
    if (rule_effect != RuleEffect::kNone) {
      modified = true;
    }

    if (rule_effect != RuleEffect::kRemovedCurrentNode) {
      ORT_RETURN_IF_ERROR(Recurse(*node, modified, graph_level, logger));
    }
  }

  return Status::OK();
}

常见的一些RewriteRule优化

: onnxruntime\core\optimizer\conv_bn_fusion.h


1. conv + bn ---> conv
class ConvBNFusion : public RewriteRule
 
2. 算子消除类：EliminateXXX
如果cast算子的src.dtype == dst.dtype，则删除cast算子
class CastElimination : public RewriteRule
class EliminateDropout : public RewriteRule ： infer网络删除dropout算子
class ExpandElimination : public RewriteRule ： 如果expand的算子的输入和输出的shape相同，则删除expand
class EliminateIdentity : public RewriteRule ： identity算子删除
class NoopElimination : public RewriteRule： 加减乘除中没有意义的计算：x+0, 0+x, x-0, x*1, 1*x and x/1


3. conv + mul ---> conv
class ConvMulFusion : public RewriteRule

3.1.4.2 GraphTransformer

3.1.4.2.1 综述

所有graph优化的基类，整个融合过程如下：

整个过程如下：
1. 匹配子图
2. 从子图中提取参数，构建fusion-op
3. 修改graph，将融合后的算子添加到graph中，将融合掉的算子从graph中剔除

整体逻辑还是和其他infer框架的融合逻辑保持一致

ORT中graphtransformer调用流程如下：

InferenceSession::Initialize() // 在session  init过程中，执行graph-transformers
	InferenceSession::AddPredefinedTransformers
		GenerateTransformers
			case TransformerLevel::Level1:
				GenerateRuleBasedGraphTransformer
					GenerateRewriteRules
						case TransformerLevel::Level1:
							EliminateIdentity
							CastElimination
							ConvAddFusion
							......
				ConstantSharing
				CommonSubexpressionElimination
				ConstantFolding
				....
			case TransformerLevel::Level2:
				GemmActivationFusion
				MatMulIntegerToFloatFusion
				ConvActivationFusion
				....
			case TransformerLevel::Level3:
				NchwcTransformer
				NhwcTransformer

3.1.4.2.2 重要接口

// 基类定义
class GraphTransformer {
 public:
  // 构造函数：name --- 自定义一个name
  GraphTransformer(const std::string& name,
                   const InlinedHashSet<std::string_view>& compatible_execution_providers = {}) noexcept
      : name_(name), compatible_provider_types_(compatible_execution_providers) {
  }

  // 对graph执行transformer
Status Apply(Graph& graph, bool& modified, const logging::Logger& logger) const;

3.1.4.2.3 案例

案例一：Fuse Add + Gelu to BiasGelu or FastGelu
onnxruntime\core\optimizer\bias_gelu_fusion.h
class BiasGeluFusion : public GraphTransformer {
 public:
  BiasGeluFusion(const InlinedHashSet<std::string_view>& compatible_execution_providers = {}) noexcept
      : GraphTransformer("BiasGeluFusion", compatible_execution_providers) { // 构造函数，定义了融合的名字
  }
  // 复写
  Status ApplyImpl(Graph& graph, bool& modified, int graph_level, const logging::Logger& logger) const override;
};

Status BiasGeluFusion::ApplyImpl(Graph& graph, bool& modified, int graph_level, const logging::Logger& logger) const {
  GraphViewer graph_viewer(graph);
   // 1. 获取graph 拓扑排序后的算子列表
  const auto& node_topology_list = graph_viewer.GetNodesInTopologicalOrder();
  
//  2. 对graph做遍历
  for (auto node_index : node_topology_list) {
    auto* node_ptr = graph.GetNode(node_index);
    if (nullptr == node_ptr)
      continue;  // node was removed

    auto& node = *node_ptr;
    
    // 子图处理
    ORT_RETURN_IF_ERROR(Recurse(node, modified, graph_level, logger));
    // 3. 判断当时是否是Add算子，且Add算子的输出边只有一个，即Add算子只有一个输出
    if (!graph_utils::IsSupportedOptypeVersionAndDomain(node, "Add", {7, 13, 14}) ||
        !graph_utils::IsSupportedProvider(node, GetCompatibleExecutionProviders()) ||
        !optimizer_utils::CheckOutputEdges(graph, node, 1)) {
      continue;
    }

    InlinedVector<NodeArg*> gelu_input;
   // 4. 获取当前Add算子的两个输入tensor的shape
    const TensorShapeProto* input1_shape = node.MutableInputDefs()[0]->Shape();
    const TensorShapeProto* input2_shape = node.MutableInputDefs()[1]->Shape();
    // 5. 仅支持2D及以上的Add输入
    if (input1_shape == nullptr ||
        input2_shape == nullptr ||
        input1_shape->dim_size() < 1 ||
        input2_shape->dim_size() < 1) {
      continue;
    }
    // 6. 要求Add算子的两个输入的shape的最后的维度相等, 例如：[3,5] and [4,5] 就支持， [3,4] and [3,3] 就不支持
    if (input1_shape->dim(input1_shape->dim_size() - 1) != input2_shape->dim(input2_shape->dim_size() - 1)) {
      continue;
    }
   // 7. 将Add算子的输入shape参数填给gelu算子
    if (input1_shape->dim_size() == 1) {
      gelu_input.push_back(node.MutableInputDefs()[1]);
      gelu_input.push_back(node.MutableInputDefs()[0]);
    } else if (input2_shape->dim_size() == 1) {
      gelu_input.push_back(node.MutableInputDefs()[0]);
      gelu_input.push_back(node.MutableInputDefs()[1]);
    } else {
      continue;
    }
    // 8. 如果Add算子是graph中的最后一个算子，则不支持fusion
    auto next_node_itr = node.OutputNodesBegin();
    if (next_node_itr == node.OutputNodesEnd()) {
      continue;
    }
    
  //  9. Add算子的下一个算子是否是Gelu或FastGelu
    const Node& next_node = (*next_node_itr);
    if (!(graph_utils::IsSupportedOptypeVersionAndDomain(next_node, "Gelu", {1}, kMSDomain) ||
          graph_utils::IsSupportedOptypeVersionAndDomain(next_node, "FastGelu", {1}, kMSDomain)) ||
        next_node.GetExecutionProviderType() != node.GetExecutionProviderType()) {
      continue;
    }

    bool is_fast_gelu = next_node.OpType().compare("FastGelu") == 0;
    if (is_fast_gelu && next_node.InputDefs().size() > 1) {
      continue;
    }
    // 10. gelu算子是否是graph的最后一个算子，好多融合框架都有这个要求：即待融合的sub-graph不能是graph最后一个部分
   // 即： Add +Gelu如果是graph的最后部分，则不支持fusion
    if (graph.NodeProducesGraphOutput(node)) {
      continue;
    }

    Node& add_node = node;
    // 11. 直接将Add的下一个算子转为Gelu算子
    Node& gelu_node = const_cast<Node&>(next_node);
    std::string op_type = "BiasGelu";
    if (is_fast_gelu) op_type = "FastGelu";
    
    // 12. 将Add + Gelu融合后的算子添加到graph中
    Node& gelu_add_fusion_node = graph.AddNode(graph.GenerateNodeName(op_type),
                                               op_type,
                                               "fused Add and Gelu",
                                               gelu_input,
                                               {},
                                               {},
                                               kMSDomain);

    // Assign provider to this new node. Provider should be same as the provider for old node.
    gelu_add_fusion_node.SetExecutionProviderType(gelu_node.GetExecutionProviderType());

    // move output definitions and edges from gelu_node to gelu_add_fusion_node
    // delete add_node and gelu_node.
   // 13. 删除Add和gelu算子，保留融合后的Gelu算子
    graph_utils::FinalizeNodeFusion(graph, {add_node, gelu_node}, gelu_add_fusion_node);

    modified = true;
  }

  return Status::OK();
}

常见的一些GraphTransformer：

onnxruntime\core\optimizer\bias_gelu_fusion.h

1. Fuse Add + Gelu to BiasGelu or FastGelu
class BiasGeluFusion : public GraphTransformer

其他

onnxruntime\core\optimizer\compute_optimizer: 训练相关的优化

3.1.5 platform

提供不同平台下的线程、文件、so/dll加载、计时器相关、日志等操作

windows + Android + linux + max等

os等平台差异接口封装
onnx_runtime\onnx-runtime\include\onnxruntime\core\platform\ort_mutex.h --- 线程锁
onnx_runtime\onnx-runtime\include\onnxruntime\core\platform\threadpool.h --- 线程池

3.1.6 session

ORT使用session来抽象和管理整个推理过程

session的对外接口
onnx_runtime\onnx-runtime\include\onnxruntime\core\session\onnxruntime_cxx_api.h

inference_session 分析

inference_session 是onnx-runtime承载模型推理的总入口

onnx_runtime\onnx-runtime\onnxruntime\core\session\inference_session.h
// 简单用法流程如下：
 * Sample simple usage:
 *  CPUExecutionProviderInfo epi;
 *  ProviderOption po{"CPUExecutionProvider", epi};
 *  SessionOptions so(vector<ProviderOption>{po});
 *  string log_id = "Foo";
 *  auto logging_manager = std::make_unique<LoggingManager>
                (std::unique_ptr<ISink>{new CLogSink{}},
                                  static_cast<Severity>(lm_info.default_warning_level),
                                  false,
                                  LoggingManager::InstanceType::Default,
                                  &log_id)
 *  Environment::Create(std::move(logging_manager), env) // 1. 创建env
 *  InferenceSession session_object{so,env}; // 2. 创建session对象
 *  common::Status status = session_object.Load(MODEL_URI); // 3. 使用session，做模型加载（onnx or ort 模型）
 *  common::Status status = session_object.Initialize();   // 4. session初始化，包括内存分配、图优化等操作
 *
 *  NameMLValMap feeds;
 *  feeds.insert({}); // 5. 通过模型的input节点的name和输入数据来构造tensor，作为整个模型推理的输入数据
 *  ...
 *  std::vector<std::string> output_names;
 *  output_names.insert(...); // 6. 模型的输出节点的名称，这个指定输出节点的name的方式，可以使得仅适用部分模型做推理
 *  ...
 *  std::vector<OrtValue> fetches;
 *  common::Status status = session_object.Run(run_options, feeds, output_names, &fetches); // 7. 执行推理，同步接口，结果存储在fetchs中
 *  process the output here...  // 8. 对模型的计算结果进行后处理---->业务逻辑部分

(1): inference-session的构造函数分析

  // 有多个构造函数，主要参数如下：session-option和env以及model的加载路径
  explicit InferenceSession(const SessionOptions& session_options,
                            const Environment& session_env);

  explicit InferenceSession(const SessionOptions& session_options,
                            const Environment& session_env,
                            onnxruntime::concurrency::ThreadPool* external_intra_op_thread_pool, // 这两个线程池是用于干什么？
                            onnxruntime::concurrency::ThreadPool* external_inter_op_thread_pool);

  InferenceSession(const SessionOptions& session_options,
                   const Environment& session_env,
                   const std::string& model_uri);

// 上述构造函数都会调用Model::Load做模型加载和 ConstructorCommon做线程池初始化等
void InferenceSession::ConstructorCommon(const SessionOptions& session_options,
                                         const Environment& session_env)
{
   FinalizeSessionOptions // 进行session-option的构建，来源于模型或者InferenceSession的和构造参数：session_options
   InitLogger(logging_manager_); // 初始化log
   // 默认配置下，会创建线程池
   concurrency::CreateThreadPool(&Env::Default(), to, concurrency::ThreadPoolType::INTRA_OP);
   // 如果session-option中为并行计算模式，则会创建并行计算的线程池
   concurrency::CreateThreadPool(&Env::Default(), to, concurrency::ThreadPoolType::INTER_OP);
}

static Status FinalizeSessionOptions(const SessionOptions& user_provided_session_options,
                                     const ONNX_NAMESPACE::ModelProto& model_proto,
                                     bool is_model_proto_parsed,
                                     /*out*/ SessionOptions& finalized_session_options) {
const Env& env_instance = Env::Default(); // 过去当前平台或者系统下的环境信息：windows或者Linux等
  // 获取环境变量的配置配置信息：该环境配置信息表示是否从model中获取session-option
  const std::string load_config_from_model_env_var_value =
      env_instance.GetEnvironmentVar(inference_session_utils::kOrtLoadConfigFromModelEnvVar);
// 如果是从模型中获取session-option
    auto status = config_parser.ParseOrtConfigJsonInModelProto(model_proto);
    if (!status.IsOK()) {
      return status;
    }
    status = config_parser.ParseSessionOptionsFromModelProto(constructed_session_options);
    if (!status.IsOK()) {
      return status;
    }
}

可以看出，构造函数中依据session-option完成了各种运行环境的初始化工作：核心是模型加载和线程池的创建

（2）：load

// 模型加载接口，支持从文件路径、内存进行加载， 没找到unload接口（待定分析）
common::Status Load(const std::string& model_uri);

common::Status Load(const void* model_data, int model_data_len);

// 内部接口，用于将onnx模型保存为ort模型（flatbuffer格式）
common::Status SaveToOrtFormat(const PathString& filepath) const;

模型加载就是通过protobuf或者flatbuffer的接口将onnx或者ort模型反序列化为计算图对象，供ort来使用

（3）：initialize

// inference-session 初始化接口
common::Status Initialize();

//  1. 先获取 graph
onnxruntime::Graph& graph = model_->MainGraph();

// 2. 如果没有cpu计算库，则创建并拉起cpu计算库，其他的依据用户通过inference-session接口传递的PE来从lib库中的PE中获取
      CPUExecutionProviderInfo epi{session_options_.enable_cpu_mem_arena};
      auto p_cpu_exec_provider = std::make_unique<CPUExecutionProvider>(epi);

// 3. 遍历每个EP，获取每个EP的内存管理接口
    for (auto& ep : execution_providers_) {
      auto tuning_ctx = ep->GetTuningContext();
      if (nullptr != tuning_ctx) {
        tuning_ctx->RegisterAllocatorsView(&session_state_->GetAllocators());
      }
    }
// 4. 获取每个EP的算子注册map
kernel_registry_manager_.RegisterKernels(execution_providers_)
// 5. 如果加载的是onnx模型，则需要添加一些预处理的transformers
  AddPredefinedTransformers--->GenerateTransformers ----> RewriteRule等pass
// 5.1. 进行图优化（GenerateTransformers 中注册的pass）
TransformGraph(graph, saving_ort_format))

// 6. 如果加载的是ort模型
// 6.1 会依据支持的EP，对算子进行异构划分，比如：x算子仅支持在cpu上运行，则将其划分到cpu上，y算子划分到cuda上
//     通过查询EP注册的算子情况，来进行图切分，切分为运行在不同设备上的子图，供后续执行调用
PartitionOrtFormatModel
// 6.2. 在线推理时的图优化
ApplyOrtFormatModelRuntimeOptimizations(graph, *session_logger_, session_options_, optimizers_to_disable_, cpu_ep)

// 7. 如果配置了保存ort格式的模型，就保存，ort模型是经过图优化和异构划分的模型
SaveToOrtFormat(session_options_.optimized_model_filepath)

核心逻辑就是：将各个PE拉起来，做图优化，并保存ort模型，为后续run接口做准备工作

（4）：模型推理接口

// 接口定义和tf的session接口定义类似 
 [[nodiscard]] common::Status Run(const RunOptions& run_options, gsl::span<const std::string> feed_names,
                                   gsl::span<const OrtValue> feeds, gsl::span<const std::string> output_names,
                                   std::vector<OrtValue>* p_fetches,
                                   const std::vector<OrtDevice>* p_fetches_device_info = nullptr);

  [[nodiscard]] common::Status Run(const RunOptions& run_options,
                                   gsl::span<const char* const> feed_names,
                                   gsl::span<const OrtValue* const> feeds,
                                   gsl::span<const char* const> fetch_names,
                                   gsl::span<OrtValue*> fetches);
 // 支持异构推理吗？
  [[nodiscard]] common::Status RunAsync(const RunOptions* run_options, 
                                        gsl::span<const char* const> feed_names,
                                        gsl::span<const OrtValue* const> feeds,
                                        gsl::span<const char* const> fetch_names,
                                        gsl::span<OrtValue*> fetches,
                                        RunAsyncCallbackFn callback,
                                        void* user_data = nullptr);


// 1. 对模型的输入输出做校验
      ORT_RETURN_IF_ERROR_SESSIONID_(ValidateInputs(feed_names, feeds));
      ORT_RETURN_IF_ERROR_SESSIONID_(ValidateOutputs(output_names, p_fetches));

// 2. 通知各个EP启动计算
      for (auto& xp : execution_providers_) {
        // call OnRunStart and add to exec_providers_to_stop if successful
        auto start_func = [&xp, &exec_providers_to_stop]() {
          auto status = xp->OnRunStart();
          if (status.IsOK())
            exec_providers_to_stop.push_back(xp.get());

          return status;
        };

        ORT_CHECK_AND_SET_RETVAL(start_func());
      }
// 3. 进行计算图推理
        retval = utils::ExecuteGraph(*session_state_, feeds_fetches_manager, feeds, *p_fetches,
                                     session_options_.execution_mode,
                                     run_options,）

（5）：信息获取接口

// 获取模型metedata，onnx中关于model的metadata定义，如version等
std::pair<common::Status, const ModelMetadata*> GetModelMetadata() const;

// 获取模型输入输出op的信息：如name、shape、dtype
std::pair<common::Status, const InputDefList*> GetModelInputs() const;
std::pair<common::Status, const OutputDefList*> GetModelOutputs() const;

// 获取注册EP类型：cpu 、 cuda等
const std::vector<std::string>& GetRegisteredProviderTypes() const;

（6）：其他

// 模型输入输出校验

  [[nodiscard]] common::Status ValidateInputs(gsl::span<const std::string> feed_names,
                                              gsl::span<const OrtValue> feeds) const;

  [[nodiscard]] common::Status ValidateOutputs(gsl::span<const std::string> output_names,
                                               const std::vector<OrtValue>* p_fetches) const;

// profiling 相关
void StartProfiling(const logging::Logger* logger_ptr);
std::string EndProfiling();
const profiling::Profiler& GetProfiling() const;

（7）： SessionOptions

作为session运行的配置参数：SessionOptions

onnx_runtime\onnx-runtime\onnxruntime\core\framework\session_options.h

// 计算图的执行方式
enum class ExecutionOrder {
  DEFAULT = 0,        // default topological sort  --- 默认的topo排序方式，即从前往后逐个算子执行
  PRIORITY_BASED = 1  // priority-based topological sort ---- 优先级排序的执行方式， ？？？？
};

// 模型执行的优先级： 多模型并发执行场景，按照优先级进行执行
enum class ExecutionPriority : int {
  GLOBAL_HIGHT = -100,
  LOCAL_HIGH = -10,
  DEFAULT = 0,
  LOCAL_LOW = 10,
  GLOBAL_LOW = 100
};

// session的配置： 涵盖了是否并发执行op、图优化级别、是否内存复用、是否开启profiling等
struct SessionOptions {
  ExecutionMode execution_mode = ExecutionMode::ORT_SEQUENTIAL;

  // set the execution order of the graph
  ExecutionOrder execution_order = ExecutionOrder::DEFAULT;

  // enable profiling for this session.
  bool enable_profiling = false;

  // enable the memory pattern optimization.
  // The idea is if the input shapes are the same, we could trace the internal memory allocation
  // and generate a memory pattern for future request. So next time we could just do one allocation
  // with a big chunk for all the internal memory allocation.
  // See class 'OrtValuePatternPlanner'.
  bool enable_mem_pattern = true;

  // Enable memory resue in memory planning. Allows to reuse tensor buffer between tensors if they are of
  // the same size. The issue with this is it can lead to memory being held for longer than needed and
  // can impact peak memory consumption.
  bool enable_mem_reuse = true; // 这个内存复用的机制待分析

  // enable the memory arena on CPU
  // Arena may pre-allocate memory for future usage.
  // set this option to false if you don't want it.
  bool enable_cpu_mem_arena = true;

  // set graph optimization level --- 图优化级别
  TransformerLevel graph_optimization_level = TransformerLevel::Level3;

  // controls the size of the thread pool used to parallelize the execution of tasks within individual nodes (ops)
  OrtThreadPoolParams intra_op_param;

  // controls the size of the thread pool used to parallelize the execution of nodes (ops)
  // configuring this makes sense only when you're using parallel executor
  OrtThreadPoolParams inter_op_param;

  // By default the session uses its own set of threadpools, unless this is set to false.
  // Use this in conjunction with the CreateEnvWithGlobalThreadPools API.
  bool use_per_session_threads = true;
  bool thread_pool_allow_spinning = true;

};

四：EP分析

ORT中的EP分为两大类：1. 算子由ORT负责实现，如CPU/CUDA 2. 算子由第三方库实现，如：TensorRT/CoreML/SNPE等。 ORT是如何组织者两种不同类型的EP的呢？ ORT的fmk又是如何调用不同的EP的呢？ onnx模型，是如何对接到SPNE/CoreML/TensorRT等框架上的呢？ORT的内存等是如何和SNPE/CoreML对接的呢？ORT是如何做到元框架（SPNE/CoreML等）之上的框架的呢？ ORT是否支持真正的异构（如SNPE和CPU算子库异构）？

--- ORT对接CoreML和tensorRT是采用在线编译的方式对接的，即将onnx模型加载后的graph传递给coreml和tensorrt，有它们完成计算。

4.1 EP综述

# EP 基类定义与核心接口
onnx-runtime\include\onnxruntime\core\framework\execution_provider.h
#  所有EP的基类
class IExecutionProvider：
// 1. 构造函数： type --- EP类型， device--- EP运行的设备
IExecutionProvider(const std::string& type, OrtDevice device, bool use_metadef_id_creator = false)

// 2. cpu 和 EP之间的数据拷贝
std::unique_ptr<onnxruntime::IDataTransfer> GetDataTransfer()

// 3. 内置类，通过Node的op_type查找当前EP支持该算子的kernel
 class IKernelLookup {
   public:
    /**
     * Given `node`, try to find a matching kernel for this EP.
     * The return value is non-null if and only if a matching kernel was found.
     */
    virtual const KernelCreateInfo* LookUpKernel(const Node& node) const = 0;
  };

// 4. 每个EP都有一个kernel注册器，进行kernel注册（向所属的EP）
virtual std::shared_ptr<KernelRegistry> GetKernelRegistry() 

// 5. 同步接口，等待EP执行完成
virtual common::Status Sync()

// 6. 还有一些其他接口，但不是所有的接口都被每个EP支持，EP选择性的支持部分接口，部分接口是和特定的EP相关的，比如CUDA

ORT主要支持的后端算子库：

acl： arm compute library:是ARM公司发布的开源工程,提供arm平台的硬件加速库

armnn: Arm机构开源的基于arm嵌入式设备的inference框架，在Arm Cortex-A CPUs、Arm Mali GPUs、Arm Machine Learning processor都可以达到很高的加速效果

rknpu : RKNPU(Rockchip Neural Processing Unit)是瑞芯微(Rockchip)的AI芯片

cann: 华为NPU

coreml： 苹果

snpe ： 高通

tensorrt/cuda： NVIDIA

rocm ： AMD

xnnpack： Google开源的用于浮点的计算库
qnnpack： Google开源的用于量化的计算库

4.2 CPU_EP

CPU_EP的类关系

// 类继承 ：core\providers\cpu\cpu_execution_provider.h
IExecutionProvider
	CPUExecutionProvider:
	    // 重载了基类的三个接口
		GetKernelRegistry // 算子注册到CPU_EP
		GetDataTransfer
		CreatePreferredAllocators // CPU_EP的内存分配接口
                     CPUAllocator // 承载了CPU上的内存分配和管理

CPU_EP比较特殊，是由inference-session主动拉起来的，而不是由EP主动向ORT注册的

// infer-session 拉起 CPU_EP
InferenceSession::Initialize():
    CPUExecutionProviderInfo epi{session_options_.enable_cpu_mem_arena};
    auto p_cpu_exec_provider = std::make_unique<CPUExecutionProvider>(epi);
    RegisterExecutionProvider(std::move(p_cpu_exec_provider))

CPU_EP的算子注册流程：

CPUExecutionProvider::GetKernelRegistry():
	RegisterCPUKernels
		RegisterOnnxOperatorKernels： onnx算子在cpu上的实现注册
			涵盖每个算子支持onnx版本、数据类型等
                           BuildKernelCreateInfo<ONNX_OPERATOR_KERNEL_CLASS_NAME(kCpuExecutionProvider, kOnnxDomain, 6, Elu)>,
                           BuildKernelCreateInfo<ONNX_OPERATOR_KERNEL_CLASS_NAME(kCpuExecutionProvider, kOnnxDomain, 6, HardSigmoid)>,
                           BuildKernelCreateInfo<ONNX_OPERATOR_VERSIONED_KERNEL_CLASS_NAME(kCpuExecutionProvider, kOnnxDomain, 6, 15, LeakyRelu)>,
                           BuildKernelCreateInfo<ONNX_OPERATOR_VERSIONED_TYPED_KERNEL_CLASS_NAME(kCpuExecutionProvider, kOnnxDomain, 6, 12, float, Relu)>,
                           BuildKernelCreateInfo<ONNX_OPERATOR_VERSIONED_TYPED_KERNEL_CLASS_NAME(kCpuExecutionProvider, kOnnxDomain, 6, 12, double, Relu)>,
		RegisterFp16Kernels ： fp16的算子库，需要特定的实现
		RegisterOnnxMLOperatorKernels
		RegisterCpuContribKernels
		RegisterCpuTrainingKernels

CPU_EP算子实现流程

//  Op辅助类【1】：从模型中的算子的proto中提取算子的输入输出、attr等信息供算子计算使用
class ProtoHelperNodeContext {
 public:
  explicit ProtoHelperNodeContext(const onnxruntime::Node& node) : node_(node) {}
  ProtoHelperNodeContext() = delete;

  const ONNX_NAMESPACE::AttributeProto* getAttribute(const std::string& name) const;
  size_t getNumInputs() const;
  const ONNX_NAMESPACE::TypeProto* getInputType(size_t index) const;
  size_t getNumOutputs() const;
  const ONNX_NAMESPACE::TypeProto* getOutputType(size_t index) const;

 private:
  const onnxruntime::Node& node_;
};

//  Op辅助类【2】：OpKernelInfo ：封装了op_proto信息、所属PE信息、内存分配信息，为OpKernel计算提供所有的环境信息

class OpKernelInfo : public OpNodeProtoHelper<ProtoHelperNodeContext> {
 public:
  explicit OpKernelInfo(const onnxruntime::Node& node,
                        const KernelDef& kernel_def,
                        const IExecutionProvider& execution_provider,
                        const std::unordered_map<int, OrtValue>& constant_initialized_tensors,
                        const OrtValueNameIdxMap& mlvalue_name_idx_map,
                        const DataTransferManager& data_transfer_mgr,
                        const AllocatorMap& allocators = {});

class OpKernelInfo : public OpNodeProtoHelper<ProtoHelperNodeContext>

// 【重点】算子基类： OpKernel分析
// onnx-runtime\include\onnxruntime\core\framework\op_kernel.h
class OpKernel {
// 1. 构造函数
explicit OpKernel(const OpKernelInfo& info) ：
// 2. 算子计算接口：OpKernelContext为入参，包含了算子输入输出tensor等信息
virtual Status Compute(_Inout_ OpKernelContext* context)

以random算子为例：

onnxruntime\core\providers\cpu\generator\random.h
// 1. 算子定义&实现
class RandomNormal final : public OpKernel：
// 2. 在算子构建过程中，将算子计算过程需要的信息都提取出来，算子构建属于模型加载过程
  RandomNormal(const OpKernelInfo& info) : OpKernel(info) {
    ORT_ENFORCE(info.GetAttr<float>("mean", &mean_).IsOK());
    ORT_ENFORCE(info.GetAttr<float>("scale", &scale_).IsOK());

    // read optional seed attribute and generate if not provided
    float seed = 0.f;
    if (info.GetAttr<float>("seed", &seed).IsOK()) {
      generator_ = std::default_random_engine{gsl::narrow_cast<uint32_t>(seed)};
    } else {
      // node index is added to the global seed to avoid two nodes generating the same sequence of random data
      generator_ = std::default_random_engine{gsl::narrow_cast<uint32_t>(utils::GetRandomSeed() + info.node().Index())};
    }

    int64_t dtype;
    ORT_ENFORCE(info.GetAttr<int64_t>("dtype", &dtype).IsOK());
    dtype_ = static_cast<ONNX_NAMESPACE::TensorProto::DataType>(dtype);
    ORT_ENFORCE(ONNX_NAMESPACE::TensorProto::DataType_IsValid(dtype_) && dtype_ != ONNX_NAMESPACE::TensorProto::UNDEFINED,
                "Invalid dtype of ", dtype_);

    TensorShapeVector shape;
    ORT_ENFORCE(info.GetAttrs("shape", shape).IsOK());
    shape_ = TensorShape(shape);
  }

// 3. 在compute接口中实现计算过程，计算过程输入inference-session的run过程，即计算过程：
Status RandomNormal::Compute(OpKernelContext* ctx) const {
  Tensor& Y = *ctx->Output(0, shape_);

  std::lock_guard<onnxruntime::OrtMutex> l(generator_mutex_);
  auto status = RandomNormalCompute(mean_, scale_, generator_, dtype_, Y);

  return status;
}

// 4. 向CPU_PE注册，在CPU_PE的算子注册接口中添加需要注册的算子
Status RegisterOnnxOperatorKernels(KernelRegistry& kernel_registry)：
BuildKernelCreateInfo<ONNX_OPERATOR_KERNEL_CLASS_NAME(kCpuExecutionProvider, kOnnxDomain, 1, RandomNormal)>,

以conv为例

// 按照数据类型来实例化conv算子
template <typename T>
class Conv : public OpKernel {
 public:
  Conv(const OpKernelInfo& info) : OpKernel(info), conv_attrs_(info) {
  }
  Status Compute(OpKernelContext* context) const override;
 private:
  ConvAttributes conv_attrs_; // 在构造的过程中，将conv的kernel/stride等attr信息从OpKernelInfo中提取出来，放在ConvAttributes 中
};

template <typename T>
Status Conv<T>::Compute(OpKernelContext* context)：
// 1. 做数据预处理，比如计算output.shape的大小，从ConvAttributes 中获取pad/kernel等信息。看起来是支持动态shape的
// 2. 动态申请workspace
// 3. 进行计算，不同的shape场景，调用不同的kernel，例如：im2col、gemm，这些算子都是调用不同CPU平台优化后的实现
//    算子实现位于：onnxruntime\core\util\math_cpu.cc 和 onnxruntime\core\mlas\inc\mlas.h： 高性能计算的位于mlas库下面
//    针对ARM/X84等不同的CPU（32/64位）都有高性能实现
  math::Im2col<T, StorageOrder::NCHW>()
  math::Gemm<T>

CPU_PE整体而言，就是一个算子库的抽象，不过仅仅是算子库，并不包含PE独属的图优化的部分（即硬件相关的优化），另外由于支持动态shape，workspace的申请在每次推理时都会进行

另外CPU_PE的高性能算子库实现位于：

1. onnx_runtime\onnx-runtime\onnxruntime\core\mlas : 针对各种CPU优化的conv/gemm等算子
2. onnx_runtime\onnx-runtime\onnxruntime\contrib_ops\cpu ： 部分CPU算子实现

4.3 CUDA_EP

4.4 SNPE_EP

SNPE支持将onnx模型转为DLC模型，然后基于SNPE直接做推理，感觉此处再通过ORT调用SNPE接口，意义不是很大；

当前通过ORT 对接到SNPE的流程为：

1. 将snpe的DLC格式的模型转换为onnx模型，其中将整个dlc模型封装到一个"snpe"自定义的算子中
（该算子在ort中自定义：），具体可以参考：
onnx_runtime_example\onnxruntime-inference-examples\c_cxx\Snpe_EP\README.md
    import onnx
    from onnx import helper
    from onnx import TensorProto

    with open('./dlc/inception_v3_quantized.dlc','rb') as file:
        file_content = file.read()

    input1 = helper.make_tensor_value_info('input:0', TensorProto.FLOAT, [1, 299, 299, 3])
    output1 = helper.make_tensor_value_info('InceptionV3/Predictions/Reshape_1:0', TensorProto.FLOAT, [1, 1001])
    // 将整个dlc模型封装到snpe的算子中
    snpe_node = helper.make_node('Snpe', name='Inception v3', inputs=['input:0'], outputs=['InceptionV3/Predictions/Reshape_1:0'], DLC=file_content, snpe_version='1.61.0', target_device='DSP', notes='quantized dlc model.', domain='com.microsoft')

    graph_def = helper.make_graph([snpe_node], 'Inception_v3', [input1], [output1])
    model_def = helper.make_model(graph_def, producer_name='tesorflow', opset_imports=[helper.make_opsetid('', 13)])
    onnx.save(model_def, 'snpe_inception_v3.onnx')
2. 然后使用ort的接口来做推理，EP设置为snpe

ORT中snpe的对接：

onnx_runtime\onnx-runtime\onnxruntime\core\providers\snpe

总体而言，将onnx模型转为dlc模型，然后再将dlc模型包装为onnx模型，再通过ort来做推理。.........

4.5 CANN_EP

四：总结

onnx-runtime可以加载onnx或者ort格式的模型

--- onnx 模型，即原始的onnx模型，为protobuf格式存储

--- ort模型，onnx-runtime将onnx模型经过图优化等保存下来的模型，采用flatbuffer，性能更好，体积更小

整体而言，onnx-runtime为了支持多设备多平台，做了很多复杂的事情，整体的推理软件栈的思路还是一致的；flatbuffer也是替代protobuf的一种很好的方式

五：附录

1. ORT源码编译

# 环境信息： linux、torch、ORT cpu版本编译安装
# 0. 环境准备
conda create -n onnx_test python=3.9
pip install torch -i https://mirrors.aliyun.com/pypi/simple/
pip install onnx -i https://mirrors.aliyun.com/pypi/simple/
# 1. 代码下载
git clone https://gitee.com/mirrors/onnx-runtime.git
git submodule sync
git submodule update --init --recursive # 网络问题，该命令可能需要执行多次

# 2. 编译： linux+torch+cpu
# 安装cmake
conda install cmake
cmake --veriosn  #  查看cmake是否安装成功

# ORT要求gcc>8.0，本环境为7.x，进行升级
conda config --add channels conda-forge
conda install gcc or conda install gcc=8.3 # 一个是最新版本，一个是指定版本
gcc --version

# 四种编译模式：--config Debug, Release, RelWithDebInfo and MinSizeRel
# 默认编译后会跑所有的用例，如果不想跑，加上： --build 或者 --update --build
# --parallel 是指启动多线程编译，会加速编译
# --build_shared_lib 是指将ORT编译为so
# --build_wheel 是指编译为python的安装包

./build.sh --config Debug --build_shared_lib --parallel --compile_no_warning_as_error --skip_submodule_sync

# 编译一个dubug模式的ORT的python版本包，这样可以用python接口来跑onnx模型，也可以在c++代码中添加日志打印，跟踪ort流程，或者使用pdb+gdb
# 编译过程中，会从github下载一堆第三方依赖，可能会失败，多次重复执行即可
./build.sh --config Release --enable_pybind --build_wheel

# 
ORT的编译脚本：build.sh 最终是通过这个python脚本来完成的，具体编译可以分析这个脚本即可
onnx_runtime\onnx-runtime\tools\ci_build\build.py