深度学习 on huluhuluu

MNN Backend 介绍

Thu, 26 Feb 2026 23:00:00 +0800

MNN 介绍

本文将介绍MNN框架的后端支持，并介绍后端有关的核心代码与功能。

MNN 介绍
- 1. 后端

1. 后端

MNN是阿里巴巴开源的高效轻量级深度学习推理框架，提供了较为全面的后端支持。主要包括:

架构/精度	类型	Normal	FP16	BF16	Int8
CPU	Native	B	C	B	B
CPU	x86/x64-SSE4.1	A	C	C	A
CPU	x86/x64-AVX2	S	C	C	A
CPU	x86/x64-AVX512	S	C	C	S
CPU	ARMv7a	S	S（ARMv8.2）	C	S
CPU	ARMv8	S	S（ARMv8.2）	S（ARMv8.6）	S
GPU	OpenCL	A	S	C	S
GPU	Vulkan	A	A	C	A
GPU	Metal	A	S	C	S
GPU	CUDA	A	S	C	A
NPU	CoreML	A	C	C	C
NPU	HIAI	A	C	C	C
NPU	NNAPI	B	B	C	B
NPU	QNN	C	B	C	C

S（Support and work well）：深度优化，推荐使用
A（Support and work well）：支持良好，可以使用
B（Support but has bug or not optimized）：支持但有bug或未优化，不推荐使用
C（Not Support）：不支持

1.1 CPU后端系列

1.1.1 x86/x64-SSE4.1后端

技术背景： SSE4.1（Streaming SIMD Extensions 4.1）是Intel在2007年推出的SIMD指令集扩展，提供了47条新指令，主要用于加速多媒体和浮点运算。

适用设备：一般是较老CPU

Intel Core系列处理器（2008年后）
AMD处理器（部分支持）
服务器和桌面PC
部分笔记本电脑

技术特点：

128位SIMD寄存器
支持打包整数和浮点运算
提供点积、混合、提取和插入操作

1.1.2 x86/x64-AVX2后端

技术背景： AVX2（Advanced Vector Extensions 2）是Intel在2013年推出的256位SIMD指令集，是AVX的增强版本，提供了更宽的向量寄存器和更多的指令。

适用设备：主流CPU

Intel Haswell架构及以后的处理器
AMD Excavator架构及以后的处理器
现代服务器和高性能工作站
游戏PC和高端笔记本

1.1.3 x86/x64-AVX512后端

技术背景： AVX512是Intel最新的512位SIMD指令集，首次出现在Xeon Phi处理器中，后来扩展到Xeon和Core系列。

适用设备：主流高性能CPU

Intel Xeon Scalable处理器
Intel Core i7/i9高端处理器（部分型号）
高性能计算服务器
AI训练和推理专用硬件

1.1.4 ARMv7a后端

技术背景： ARMv7-A是ARM公司的32位架构，广泛应用于早期智能手机和嵌入式设备。支持NEON SIMD指令集。

适用设备：一般是比较老旧的移动端CPU

早期Android手机（2010-2015年）
Raspberry Pi 2
部分嵌入式开发板
工业控制设备

1.1.5 ARMv8后端

技术背景： ARMv8-A是ARM的64位架构，是现代移动设备的主流架构，提供了更强的性能和更大的内存寻址空间。

适用设备：当前主流的移动端CPU

现代智能手机（iPhone 5s以后，Android旗舰机）
平板电脑
ARM服务器（如AWS Graviton）
Apple M系列芯片设备
Raspberry Pi 3/4

1.2 GPU后端系列

1.2.1 OpenCL后端

技术背景： OpenCL（Open Computing Language）是Khronos Group制定的开放标准，用于异构计算平台的并行编程。

适用设备：除专用的GPU后端外，主流的GPU后端

支持OpenCL的GPU（NVIDIA、AMD、Intel）
部分移动GPU（Adreno、Mali、PowerVR）
FPGA设备
DSP处理器

1.2.2 Vulkan后端

技术背景： Vulkan是Khronos Group开发的低开销、跨平台的3D图形和计算API，提供了更直接的GPU控制。

适用设备：大部分GPU支持的后端

现代GPU（NVIDIA GTX 900系列以后）
AMD GCN架构GPU
Intel集成显卡（部分支持）
Android设备（API 24+）

1.2.3 Metal后端

技术背景： Metal是Apple开发的低级图形和计算API，专为Apple设备优化，提供了接近硬件的性能。

适用设备：ios设备的GPU后端

iPhone iPad Mac等

1.2.4 CUDA后端

技术背景： CUDA（Compute Unified Device Architecture）是NVIDIA开发的并行计算平台和编程模型，专为NVIDIA GPU设计。

适用设备：NVIDIA GPU的专用后端

NVIDIA GeForce系列GPU
NVIDIA Quadro专业卡
NVIDIA Tesla计算卡
NVIDIA Jetson嵌入式平台

1.2.5 OpenGL后端

技术背景：OpenGL（Open Graphics Library）是一个图形渲染 API 标准，可以利用 GPU 并行计算能力处理非图形任务

适用设备：大部分GPU支持的后端

支持OpenCL的GPU（NVIDIA等）
部分移动GPU（Adreno等）

1.3 专用加速器

1.3.1 CoreML后端

技术背景： Core ML是Apple的机器学习框架，能够利用Apple设备的Neural Engine进行AI推理加速。

适用设备：当前主流的apple ai加速器

iPhone（A11芯片以后，支持Neural Engine）
iPad Pro（A12芯片等）
Mac（M1芯片等）

1.3.2 HIAI后端

技术背景： HIAI（Huawei Intelligent Acceleration Infrastructure）是华为开发的AI加速平台，利用华为麒麟芯片的NPU。

适用设备：当前主流的华为 ai加速器

华为/荣耀手机（麒麟970以后）
华为平板电脑
华为笔记本电脑（部分型号）

1.3.3 NNAPI后端

技术背景： NNAPI（Neural Networks API）是Google在Android 8.1中引入的API，为Android设备提供统一的AI加速接口。

适用设备：在 Android 15 中已弃用。在专用供应商驱动程序的Android设备运行，缺乏时运行在 CPU 上

Android 8.1+设备

1.3.4 QNN后端

技术背景： QNN（Qualcomm Neural Network SDK）是高通开发的AI推理SDK，专为高通Snapdragon平台优化。

适用设备：主流的高通芯片NPU后端

搭载Snapdragon处理器的设备
支持Hexagon DSP的设备
高通AI开发套件

1.3.5 NeuroPilot 后端

技术背景： NeuroPilot SDK是联发科自研的专用 AI 加速硬件单元SDK，集成于天玑（Dimensity）系列 SoC 中。主要通过 NNAPI 间接调用 APU 硬件加速

适用设备：主流的天玑芯片APU后端

搭载天玑系列处理器的设备
支持 NeuroPilot SDK 且 Android 10+（API 29+）的联发科平台设备

1.4 后端相关目录结构

MNN的后端实现集中在source/backend/目录中：

source/backend/
├── cpu/          # CPU通用后端
|    └───x86_x64
|    		└─── avx/          # x86 AVX2优化
|    		└─── avx512/       # x86 AVX512优化
|    		└─── avxfma/       # x86 AVXfma 支持Fused Multiply-Add
|	 		└─── sse/          # x86 SSE优化
|    └─── arm
|    		└───arm32		   # 32为arm指令支持 如ARMv7-A后端
|    		└───arm64		   # 64为arm指令支持
├── arm82/        # ARMv8.2 支持
|    └─── asm
|    		└───arm32		   # 32为arm指令兼容
|    		└───arm64		   # 64为arm指令支持
├── nnapi/        # NNAPI后端
├── metal/        # Metal后端（iOS/macOS）
├── opencl/       # OpenCL后端
├── opengl/       # OpenGL后端
├── vulkan/       # Vulkan后端
├── cuda/         # CUDA后端
├── tensorrt
├── coreml/       # CoreML后端
├── hiai/         # HIAI后端
└── qnn/          # QNN后端
└── neuropilot/   # neuropilot后端

相应的后端需要设置指定的编译宏，例如-DMNN_OPENCL=true表示启用OPENCL后端支持，但是具体调用需要在程序中设置，例如MNN-LLM需要设置… 具体见后续的代码梳理

1.4.1 后端文件说明

MNN 的后端系统由以下几个核心类组成，大致执行顺序如下：

// 1. 创建 下面的关系只表示时间上的顺序依赖关系 如Backend需要调用Runtime创建
Runtime (运行时, 各类后端继承Runtime, 如class CPURuntime : public Runtime)
  ↓ 创建
Backend (后端, 各类后端继承Backend, 如class CPUBackend : public Backend)
  ↓ 创建
Execution (执行器, 大部分算子实现是通过继承Execution实现,如:class CPUAttention : public Execution;
			小部分为汇编优化过的代码, 如source/backend/cpu/x86_x64/avx512/_AVX512_MNNGemmFloatUnit16x8.S)
			
// 2. 重新计算输出形状 在/workspace/code/MNN/source/shape/SizeComputer.hpp内完成 

// 3. 根据输入长度变化 执行的resize操作 下面的关系只表示时间上的顺序依赖关系
Backend::onResizeBegin (resize的准备阶段)
  ↓
Execution::onResize (算子的resize)
  ↓
Backend::onResizeEnd (resize的收尾阶段)

// 4. 执行算子  下面的关系只表示时间上的顺序依赖关系
Backend::onExecuteBegin (execute的准备阶段)
  ↓
Execution::onExecute (算子的execute)
  ↓
Backend::onExecuteEnd (execute的收尾阶段)

1.4.1.1 Runtime - 运行时抽象层

位置：source/core/Backend.hpp

Runtime 是硬件运行时的抽象层，负责管理整个后端的生命周期和资源配置。

核心职责：

创建 Backend 实例
管理线程池和内存分配器
提供垃圾回收机制
支持异步执行和并发控制

关键接口：

class Runtime : public NonCopyable {
public:
    // 创建 Backend
    virtual Backend* onCreate(const BackendConfig* config, Backend* origin) const = 0;
    // 重置运行时配置
    virtual void onReset(int numberThread, const BackendConfig* config, bool full);
    
    // 垃圾回收
    virtual void onGabageCollect(int level) = 0;
    // 获取内存使用量
    virtual float onGetMemoryInMB();
	
    // 主要是cpuruntime使用 cpu后端实现了线程池(source/backend/cpu/ThreadPool.hpp)
    virtual void onConcurrencyBegin() const = 0;
    virtual void onConcurrencyEnd() const = 0;
	
    // 执行优化, mnn以算子图形式运行 下面是不同的运行方式
    enum CompilerType {
        Compiler_Geometry = 0, // 部分执行几何计算，分解形变算子，但不分解 BatchMatMul / Gather 等算子
        Compiler_Origin = 1, // 直接使用原始算子，不进行分解
        Compiler_Loop = 2, // 完全执行几何计算，仅此模式下，可以在算子不支持时自动回退到CPU计算
    };
private:    
    // 记录运行时信息 如kvcacheSizeLimit cpuIds等
    RuntimeHint mHint;
};

1.4.1.2 Backend - 后端抽象基类

位置：source/core/Backend.hpp

Backend 是所有硬件后端的基类，定义了后端必须实现的接口。

核心职责：

管理内存分配和释放
创建 Execution
处理张量缓冲区操作
支持多种存储策略

存储类型枚举：

enum StorageType {
    STATIC,           // 不可重用内存，分配后立即释放
    DYNAMIC,          // 可重用内存，优先重用已有内存
    DYNAMIC_SEPERATE, // 不可重用内存，但延迟释放
    DYNAMIC_IN_EXECUTION // 执行时动态分配
};

关键接口：

class Backend : public NonCopyable {
public:
    // 创建 Execution 
    virtual Execution* onCreate(const std::vector<Tensor*>& inputs,
                                const std::vector<Tensor*>& outputs,
                                const MNN::Op* op) = 0;

    // 执行算子Resize 的开始/结束的一些准备/收尾工作
    virtual void onResizeBegin();
    virtual ErrorCode onResizeEnd() = 0;
    // 执行算子execute 的开始/结束的一些准备/收尾工作
    // 例如OpenCLBackend中 
    virtual void onExecuteBegin() const = 0;
    virtual void onExecuteEnd() const = 0;

    // 内存管理
    virtual MemObj* onAcquire(const Tensor* tensor, StorageType storageType) = 0;
    virtual bool onClearBuffer() = 0;
    virtual void onCopyBuffer(const Tensor* srcTensor, const Tensor* dstTensor) const = 0;
    
    // 把数据映射到指定后端 / 从指定后端映射回数据
    virtual void* onMapTensor(Tensor::MapType mtype, Tensor::DimensionType dtype, const Tensor* srcTensor);
    virtual bool onUnmapTensor(Tensor::MapType mtype, Tensor::DimensionType dtype, const Tensor* dstTensor, void* mapPtr);
    
    // 利用backend后端传递指针, llm中主要传递kvmeta(kv cache有关信息)
    void setMetaPtr(void* ptr);

private:
    // 枚举类 记录执行后端 如cpu opencl为: MNN_FORWARD_CPU MNN_FORWARD_OPENCL
    const MNNForwardType mType;
};

1.4.1.3 Execution - 执行器抽象基类

位置：source/core/Execution.hpp

Execution 是算子执行的抽象基类，每个算子都有对应的 Execution 实现。

核心职责：

响应输入输出张量的形状变化
执行算子计算
支持克隆和共享权重

关键接口：

class Execution : public NonCopyable {
public:
    // 根据输入seq_len长度变化 调整执行时用到的值
    virtual ErrorCode onResize(const std::vector<Tensor*>& inputs,
                               const std::vector<Tensor*>& outputs);

    // 执行计算
    virtual ErrorCode onExecute(const std::vector<Tensor*>& inputs,
                                const std::vector<Tensor*>& outputs) = 0;

    // 克隆执行器 这在llm推理中很有用 例如prefill和decode之间的seq_len输入长度不一样 就会触发克隆 mnn默认保存不同输入长度的计算图
    // 这里通常不克隆权重, 权重在Op* op中 这里会通过指针引用
    virtual bool onClone(Backend* bn, const Op* op, Execution** dst);

    // 获取后端 例如在CPUAttention中利用这里获取kvmeta信息(mMeta = (KVMeta*)(backend->getMetaPtr());)
    Backend* backend() const;
};

1.4.2 后端调用设置

除了后端架构中的 Runtime、Backend、Execution 等核心类，MNN中还有部分特定基础算子的优化代码，例如source/backend/cpu/x86_x64/avx512/_AVX512_MNNGemmFloatUnit16x8.S 等，前者是汇编代码，后者是opencl的代码。

这里指的算子一般都是底层支持的基础算子，会在更上层的算子中被调用，例如CPUAttention中会调用core->Int8GemmKernel;以使用int8矩阵乘算子

1.4.2.1 Core Function

下面以CPU的后端在实例化过程中调用的不同后端的指令集为例说明，在source/backend/cpu/compute/CommonOptFunction.h中定义了CoreFunctions

struct CoreFunctions {
    // CPU 特性标志
    bool supportFp16arith = false;  // 支持 FP16 算术运算
    bool supportSDot = false;       // 支持 ARM S-Dot 指令
    bool supportI8mm = false;       // 支持 ARM I8MM 指令
    bool supportSME2 = false;       // 支持 ARM SME2 指令
    int  smeCoreNumber = 0;         // SME2 核心数量

    // 矩阵乘法相关函数
    void(*MNNGetMatMulPackMode)(int* eP, int *lP, int* hP);
    void(*MNNPackC4ForMatMul_A)(float* destOrigin, float const** sourceGroup,
                                 const int32_t* info, const int32_t* el);
    void(*MNNPackForMatMul_B)(float* dest, const float* source,
                              size_t h, size_t kernelsize, size_t ic, bool transpose);
    void(*MNNPackedMatMul)(float* C, const float* A, const float* B,
                           const size_t* parameter, const float* postParameters,
                           const float* bias, const float* k, const float* b);
    void(*MNNPackedMatMulRemain)(float* C, const float* A, const float* B,
                                 size_t eSize, const size_t* parameter,
                                 const float* postParameters, const float* bias,
                                 const float* k, const float* b);
    // 激活函数
    void(*MNNReluInt8)(int8_t* dst, const int8_t* src, size_t size, ssize_t zeroPoint);
    void(*MNNHardSwish)(float* dst, const float* src, size_t size);
    void(*MNNGelu)(float* dst, const float* src, size_t size, float* parameters);
    const float *beta, float epsilon, size_t size, bool RMSNorm);

    // 其他函数...
};

MNN 使用全局单例 gCoreFunction 来存储当前平台的最优函数实现，在程序启动时会选择各个函数的最优实现代码

// 在source/backend/cpu/CPUBackend.cpp 中创建runtime时 会进入到不同指令集的初始化注册过程
{
#ifdef MNN_SUPPORT_BF16
extern void registerBF16Backend();
#endif
#ifdef ENABLE_ARMV82
extern void registerArm82RuntimeCreator();
#endif
void registerCPURuntimeCreator() {
    MNNCoreFunctionInit();
    CPUBackend::initCreatorMap();
    registerCPUOps();
#ifdef MNN_SUPPORT_BF16
    registerBF16Backend();
#endif
#ifdef MNN_USE_ARMV82
    registerArm82RuntimeCreator();
#endif
    // TODO: Merge _initCoreFunction MNNFunctionInit and cpuinfo_arm_init
    MNNInsertExtraRuntimeCreator(MNN_FORWARD_CPU, new CPURuntimeCreator);
}

// 下面以armv82的初始化为例 在Arm82Functions::init()中
Arm82Functions::init(){
    
    // 部分特殊优化的底层代码
    FUNC_PTR_ASSIGN(gInstance->MNNPackC4ForMatMul_A, Arm82MNNPackForMatMul_A);
    /* 在声明中 这个代码是外部导入的, 路径位置source/backend/arm82/asm/arm64/Arm82MNNPackForMatMul_A.S
    extern "C" {
    // (UP_DIV(l,8), e, 8) -> (UP_DIV(e,eP), l, eP)
        void Arm82MNNPackForMatMul_A(float* destOrigin, float const** sourceGroup, const int32_t* info, const int32_t* el);
    }
    */
    
    // 其它代码...
}

在cpu后端使用时通过调用后端的core function执行底层算子，如

// source/backend/cpu/CPUAttention.cpp
ErrorCode CPUAttention::onExecute(const std::vector<Tensor*>& inputs, const std::vector<Tensor*>& outputs) {
    auto gcore  = static_cast<CPUBackend *>(backend())->functions();
    auto core   = static_cast<CPUBackend*>(backend())->int8Functions();
    // 其它代码...
 	
    // 调用后端的core functions终端矩阵乘法
    gcore->MNNPackedMatMul(...);
    
    // 其它代码...
}

其它后端的底层代码调用可能不同，如opencl后端的.cl代码source/backend/opencl/execution/cl/attention_buf.cl等通过运行时加载 Kernel 源码方式使用。

MNN 核心类介绍

Thu, 26 Feb 2026 23:00:00 +0800

MNN 介绍

MNN框架作为一个高性能的深度学习推理引擎，核心设计围绕着几个关键的抽象类展开。其中，Varp，Expr，Op等类是整个框架的基石，它们不仅定义了数据的表示方式，还构建了计算图的基本结构。本文将深入分析这些核心类的设计理念、实现细节以及它们之间的相互关系。

MNN 介绍
- 1. MNN核心类

1. MNN核心类

MNN 中的核心类主要包括：

类名	职责
`VARP`	智能指针包装的 Variable，表示表达式中的变量节点
`Variable`	表达式图中的变量节点，持有张量数据或计算信息
`Expr`	表达式边，表示一个计算操作以及输入节点和输出节点
`Tensor`	张量数据容器，存储实际的多维数据
`Op`	算子描述符，定义计算的类型和参数、模型权重等
`Pipeline`	计算流水线，TODO:
`Session`	执行会话，推理数据的持有者, TODO
`Interpreter`	解释器, 模型数据的持有者
`Executor`	执行器， TODO
`ExecutorScope`	执行器作用域， TODO

1.1 类之间关系

**逻辑依赖关系： **VARP和Expr是MNN计算图格式的核心，分别表示计算图的节点和边，Op类是整个计算图的核心，表示计算图的边Expr的计算操作。关系图如下：

VARP (Variable Ptr)
    ↓ 指向
Variable
    ↓ 包含
Expr ──→ Op (操作描述)
    ↓
Tensor (存储数据)

每个边Expr都有属性std::vector<VARP> mInputs;指示输入来自的节点; 每个VARP节点有属性EXPRP mFrom; // typedef std::shared_ptr<Expr> EXPRP;指示输入的边，同时VARP的节点的Tensor数据也存放在入边mFrom中，数据读取和写入在Variable::readMap和Variable::writeMap中，需要转换成对应数据格式的指针进行读取/写入。一个简单的计算图可以如下：

Expr (mFrom) -> Tensor x(data)        Expr (mFrom) -> Tensor y(data) 
         	│									    │
         	│									    │
         VARP x                    				  VARP y
            ↓                        	  		    ↓
            └────────────────────┬──────────────────┘
                                 │
                				 │ Expr -------> Op(Add)
	                             │   └─--------> Tensor z
	                             ↓
	             			  VARP z

执行依赖关系： MNN的计算图有两种模式，Defer(延迟计算)模式或Eager(立即计算)模式：Defer模式下，调用表达式相关API不直接计算，而是搭建模型，在需要获取输出值时才执行；Eager模式下，直接进行计算，对应地无法搭建模型。下面以Eager模式为例，梳理MNN中表达式计算顺序，更具体的代码分析见readmap详解:

用户定义VARP计算代码 // 如：VARP x = _Input({2, 3});VARP y = _Input({2, 3});VARP z = _Add(x, y);
    ↓
varp->readmap()  // 触发计算
    ↓
ExecutorScope::Current()->computeInfo() //计算节点信息  ─→ SizeComputer::computeOutputSize() // 动态计算中间节点/输出的形状
    ↓
ExecutorScope::Current()->makeCache() // 计算缓存, 可复用, 按数据依赖顺序准备中间节点的Tensor 以及Session会话的计算信息
    ↓
Executor::ComputeCache::compute() // 按数据依赖顺序执行计算缓存中: 算子的resize和执行。 算子执行会从计算缓存的mSession进入下一步
    ↓
Session::run() // 这里继续进入Session::mPipelines的执行
    ↓
Pipeline::execute() // 这里执行execution->onExecute 进入算子的后端执行
    ↓
后端执行计算	// 计算结果存在tensor中 最后从readmap读取为指针
    ↓
获得指针

这当中主要配置的信息是在ExecutorScope::Current()->makeCache()中配置Session，后续的执行大多依赖Session的数据

1.2 VARP类

VARP本质是 Variable 的智能指针包装类，利用Variable指针的地址重载了比较运算符，核心代码如下：

// express/Expr.cpp
class MNN_PUBLIC VARP {
public:
    // 构造函数
    VARP();
    VARP(std::shared_ptr<Variable> c);
    VARP(Variable* c);
    
    // 获取内部 Variable 变量
    Variable* get() const;
    
    // 重载运算符
    bool operator==(const VARP& var) const = 0;
    bool operator<(const VARP& var) const = 0;
    bool operator<=(const VARP& var) const = 0;
	
    // ... 其它代码  

    // 类型标记
    enum InputType {
        INPUT = 0,      // 输入变量
        CONSTANT = 1,   // 常量变量
        TRAINABLE = 2   // 可训练变量
    };
    // 固定变量类型
    bool fix(InputType type) const;
    // 设置数据格式
    void setOrder(Dimensionformat format); // enum Dimensionformat { NHWC, NC4HW4, NCHW };
    
private:
    std::shared_ptr<Variable> mContent;
};

1.2.1 Variable 类

描述算子图的一个节点，主要刻画了对节点和数据的部分操作，核心代码如下：

// express/Expr.cpp
class MNN_PUBLIC Variable {
public:
    // 获取节点名称
    const std::string& name() const;
    void setName(const std::string& name);
    
    // 获取数据信息
    const Info* getInfo();
	struct Info {
        Dimensionformat order;  // 数据格式（NCHW/NHWC/NC4HW4）
        INTS dim;              // 维度
        halide_type_t type;    // 数据类型
        size_t size;           // 元素总数
        void syncSize();       // 同步大小
    };
    
    // 设置和获取(输入边 以及 数据是“输入边”的第几个输出Tensor)
	void setExpr(EXPRP expr, int index);
    std::pair<EXPRP, int> expr() const;
    
    // 获取 Tensor
    const Tensor* getTensor() const;
    
    // 调整大小
    bool resize(INTS dims);
    
    // 读取/保存节点到文件
	static std::vector<VARP> load(const char* fileName);
    static void save(const std::vector<VARP>& vars, NetT* dest);
    
    // 获得数据的指针映射
    template <typename T>
    const T* readMap();
    template <typename T>
    T* writeMap();
};

1.2.2 readMap详解

接下来详细解释readMap是怎么执行的，TODO

1.3 Expr类

Expr表示计算图的边，核心属性包括边的输入(VARP) 输出(Tensor) 以及计算算子(Op)，这里的输出是Tensor格式，被输出节点VARP通过边引用，核心代码如下:

// express/Expr.cpp
class MNN_PUBLIC Expr {
public:
    struct Inside;
    enum MemoryType {
        COPY,
        MOVE,
        REF
    };
    // 多种构造函数 使用各种信息构造Expr类
    static EXPRP create(Tensor* tensor, bool own = false);
    static EXPRP create(Variable::Info&& info, const void* ptr, VARP::InputType type, MemoryType copy = COPY);
    static EXPRP create(const OpT* op, std::vector<VARP> inputs, int outputSize = 1);
    static EXPRP create(std::shared_ptr<BufferStorage> extra, std::vector<VARP>&& inputs, int outputSize = 1);
    static EXPRP create(std::unique_ptr<OpT>&& op, std::vector<VARP> inputs, int outputSize = 1);
    
    // 获取/设置节点信息
    const Op* get() const;
    const std::vector<VARP>& inputs() const = 0;
    int outputSize() const = 0;
    void setName(const std::string& name);
    const std::string& name() const = 0;
    const std::string& outputName(int index);
    static void replace(EXPRP oldExpr, EXPRP newExpr);
    VARP::InputType inputType() const;
    
    // 判断当前操作依赖的输入节点 以及输入节点往前依赖的所有节点的信息是否正确, 过程中会推导节点的shape
    bool requireInfo();
    
    // 遍历，过程中会调用用户传入的 回调函数
    void visitOutputs(const std::function<bool(EXPRP, int)>& visit);
    static void visit(EXPRP expr, const std::function<bool(EXPRP)>& before, const std::function<bool(EXPRP)>& after);
   

private:
    const Op* mOp;				// 表示的计算算子
    std::vector<VARP> mInputs;	// 输入节点
	
    // 节点信息
    VARP::InputType mType;
    std::string mName;
    std::vector<std::string> mOutputNames;
    // 其中inside记录了很多更多有关边的信息
    std::shared_ptr<Inside> mInside = nullptr;
    struct Expr::Inside {
		// 构造 析构函数
        Inside(int outputSize);
        Inside(Tensor* tensor, bool own = false);
        ~ Inside();
        
        std::vector<Variable::Info> mOutputInfos;	// 输出tensor的信息 与tensor一一对应
        std::vector<Tensor*> mOutputTensors;	// 边对应的输出tensor	
        
        std::shared_ptr<Executor::ComputeCache> mCache; // 计算cache缓存 在1.1 类之间关系提到 通过cache 
        int mCacheOffset = 0;	// 用来索引tensor
        
        // 标记位
        Executor::Requirement mReq;	
        bool mInfoDirty = true;
        bool mContentDirty = true;
        bool mOwnTensor = true;
        
        Tensor* mHostTensor = nullptr;			// 设备内存（GPU/NPU）中的tensor
        std::shared_ptr<Backend> mHoldBackend;	// 持有数据的后端
    };
};

1.3.1 requireInfo 详解

TODO:

1.4 Tensor类

张量数据类，包括数据指针，数据格式，数据维度等信息，所有属性存储在下面两个结构体对象中，

// include/MNN/Tensor.hpp
class MNN_PUBLIC Tensor{
// 其它代码
private:
    halide_buffer_t mBuffer;
    struct InsideDescribe* mDescribe;
};

1.4.1 数据格式

MNN支持常见的数据格式，其中N C H W分别表示批次大小通道数高度宽度。这个格式是对图片格式的兼容，在大模型推理中输入embedding的shape是(batch_size, seq_len, hidden_size)，依次是输入、序列长度和隐藏层大小，不需要太关注这个NCHW，（大模型推理过程中的shape变化可以参考这篇介绍）。

// include/MNN/Tensor.hpp
// 维度类型
    enum DimensionType {
        TENSORFLOW,  // TensorFlow 格式：NHWC
        CAFFE,       // Caffe 格式：NCHW
        CAFFE_C4     // Caffe 格式：NC4HW4（4通道对齐）
    };

值得一提的是 MNN默认只支持1条数据输入，输入embedding维度是(seq_len, hidden_size)，但是除了Attention算子的大部分算子都做了batch维度的适配，对MNN中大模型推理感兴趣可以看这篇介绍。

我尝试在MNN框架上做了Chunk prefill，把不同输入请求合并在seq_len维度上，并在Attention算子中展开:传送门

1.4.2 底层数据格式

从更底层出发，这个数据格式信息由下面结构体存储，对应Tensor类的halide_buffer_t mBuffer属性，其中存储了数据的指针、数据类型、数据维度等信息，核心代码如下：

// include/MNN/HalideRuntime.h
/**
 * The raw representation of an image passed around by generated
 * Halide code. It includes some stuff to track whether the image is
 * not actually in main memory, but instead on a device (like a
 * GPU). For a more convenient C++ wrapper, use Halide::Buffer<T>. */
typedef struct halide_buffer_t {
    /** A device-handle for e.g. GPU memory used to back this buffer. */
    uint64_t device; // 设备句柄

    /** The interface used to interpret the above handle. */
    const struct halide_device_interface_t *device_interface; // 接口指针

    /** A pointer to the start of the data in main memory. In terms of
     * the Halide coordinate system, this is the address of the min
     * coordinates (defined below). */
    uint8_t* host; // 指针 指向数据

    /** flags with various meanings. */
    uint64_t flags;	

    /** The type of each buffer element. */
    struct halide_type_t type;	// 数据类型

    /** The dimensionality of the buffer. */
    int32_t dimensions;	// 数据维度，如[batch_size, seq_len, hidden_size]大小的Tensor数据就是2维

    /** The shape of the buffer. Halide does not own this array - you
     * must manage the memory for it yourself. */
    halide_dimension_t *dim; // 数据各维度的数值, 如如[batch_size, seq_len, hidden_size]大小的Tensor数据 dim[0]就表示batch_size维度的信息

    /** Pads the buffer up to a multiple of 8 bytes */
    void *padding; // 用来对齐内存
} halide_buffer_t;

其中的数据类型halide_type_t type通过数据占比特数和数据的性质判断数据的类型，例如code = halide_type_float并且bits = 16表示半精度浮点数。核心代码如下：

// include/MNN/HalideRuntime.h
/** A runtime tag for a type in the halide type system. Can be ints,
 * unsigned ints, or floats of various bit-widths (the 'bits'
 * field). Can also be vectors of the same (by setting the 'lanes'
 * field to something larger than one). This struct should be
 * exactly 32-bits in size. */
struct halide_type_t {
    /** The basic type code: signed integer, unsigned integer, or floating point. */
    
    // 这个code表示数据的性质 见本代码块最下方结构体，例如 halide_type_int = 0, 表示 signed integers 有符号整型
#ifndef _MSC_VER
    HALIDE_ATTRIBUTE_ALIGN(1) halide_type_code_t code; // halide_type_code_t
#else
    HALIDE_ATTRIBUTE_ALIGN(1) uint8_t code; // halide_type_code_t
#endif

    /** The number of bits of precision of a single scalar value of this type. */
    HALIDE_ATTRIBUTE_ALIGN(1) uint8_t bits;	// 数据占用比特数

    /** How many elements in a vector. This is 1 for scalar types. */
    HALIDE_ATTRIBUTE_ALIGN(2) uint16_t lanes; // 一次处理的数据宽度 用于SIMD

    // 构造函数
#ifdef __cplusplus
    /** Construct a runtime representation of a Halide type from:
     * code: The fundamental type from an enum.
     * bits: The bit size of one element.
     * lanes: The number of vector elements in the type. */
    HALIDE_ALWAYS_INLINE halide_type_t(halide_type_code_t code, uint8_t bits, uint16_t lanes = 1)
        : code(code), bits(bits), lanes(lanes) {
    }
    /** Default constructor is required e.g. to declare halide_trace_event
     * instances. */
    HALIDE_ALWAYS_INLINE halide_type_t() : code((halide_type_code_t)0), bits(0), lanes(0) {}

    // 重载了对比函数
    /** Compare two types for equality. */
    HALIDE_ALWAYS_INLINE bool operator==(const halide_type_t &other) const {
        return (code == other.code &&
                bits == other.bits &&
                lanes == other.lanes);
    }
    HALIDE_ALWAYS_INLINE bool operator!=(const halide_type_t &other) const {
        return !(*this == other);
    }
    
	// 单个数据占据的内存字节数, 按8bit向上对齐
    /** Size in bytes for a single element, even if width is not 1, of this type. */
    HALIDE_ALWAYS_INLINE int bytes() const { return (bits + 7) / 8; }
#endif
};


typedef enum halide_type_code_t
{
    halide_type_int = 0,   //!< signed integers
    halide_type_uint = 1,  //!< unsigned integers
    halide_type_float = 2, //!< IEEE floating point numbers
    halide_type_handle = 3, //!< opaque pointer type (void *)
    halide_type_bfloat = 4  //!< floating point numbers in the bfloat format
} halide_type_code_t;

这里数据维度信息halide_dimension_t *dim 包含该维度的元素个数(extend)和在该维度移动一步时内存地址的偏移量信息(stride，通常在TensorUtils::setLinearLayout中利用extend计算stride)。核心代码如下：

// include/MNN/HalideRuntime.h
typedef struct halide_dimension_t { 
    // extend: 该维度的元素个数
    // stride: 在该维度移动一步时内存地址的偏移量信息
    int32_t min, extent, stride;

    // Per-dimension flags. None are defined yet (This is reserved for future use).
    uint32_t flags;

#ifdef __cplusplus
    HALIDE_ALWAYS_INLINE halide_dimension_t() : min(0), extent(0), stride(0), flags(0) {}
    HALIDE_ALWAYS_INLINE halide_dimension_t(int32_t m, int32_t e, int32_t s, uint32_t f = 0) :
        min(m), extent(e), stride(s), flags(f) {}

    HALIDE_ALWAYS_INLINE bool operator==(const halide_dimension_t &other) const {
        return (min == other.min) &&
            (extent == other.extent) &&
            (stride == other.stride) &&
            (flags == other.flags);
    }

    HALIDE_ALWAYS_INLINE bool operator!=(const halide_dimension_t &other) const {
        return !(*this == other);
    }
#endif
} halide_dimension_t;

1.4.2 核心接口

Tensor类的核心接口包括设置/获取数据信息、把数据映射到执行设备、调整大小等，MNN文档有详细介绍, 需要用到时可以自己查看，比较常用的调试接口是打印数据和打印形状，这里打印数据中有根据数据底层的bits和code信息自动转换成对应数据类型的指针进行打印的转化。

// include/MNN/Tensor.hpp
class MNN_PUBLIC Tensor {
public:
    /**
        * @brief print tensor data. for DEBUG use only.
        */
    void print() const;

    /**
        *@brief print tensor shape
        */
    void printShape() const;
}

1.5 Op类

Op 是算子的描述类，定义了神经网络中各种操作的类型和参数。MNN 使用内存高效的FlatBuffers库来序列化/反序列化来表示Op等信息，核心结构体是OpT，在需要修改算子信息时通常使用该结构体，通常代码中使用的就是该结构体，核心代码如下：

// schema/current/MNN_generated.h
   struct OpT : public flatbuffers::NativeTable {
     std::vector<int32_t> inputIndexes;      // 输入张量索引列表
     OpParameterUnion main;                   // 算子参数（联合体）
     std::string name;                        // 算子名称
     std::vector<int32_t> outputIndexes;     // 输出张量索引列表
     OpType type;                             // 算子类型枚举
     MNN_DATA_FORMAT defaultDimentionFormat; // 默认数据格式（NHWC/NCHW等）
     std::string externalPath;               // 外部权重路径
   };

这里OpType 是一个枚举类型，用于表示不同的算子类型，例如 Conv2D, Add, Relu 等。MNN 中定义了多个算子类型，每个类型对应一个具体的算子实现，部分代码如下：

// schema/current/MNN_generated.h
enum OpType {
    OpType_AbsVal = 0,
    OpType_QuantizedAdd = 1,
    OpType_ArgMax = 2,
    OpType_AsString = 3,
    OpType_InstanceNorm = 4,
    // ...
};

继续往底层是flatbuffers::Table的数据接口，提供了获取输入索引、算子类型等信息的接口，可以通过unpack操作转换为上层的OpT结构体，主要在读取、解析、构建算子的Execution时用到Op结构体，核心代码如下：

struct Op FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef OpT NativeTableType;
  static const flatbuffers::TypeTable *MiniReflectTypeTable() {
    return OpTypeTable();
  }
  // 获取输入索引列表
  const flatbuffers::Vector<int32_t> *inputIndexes() const {
    return GetPointer<const flatbuffers::Vector<int32_t> *>(4);
  }
  // 获取参数类型
  OpParameter main_type() const {
    return static_cast<OpParameter>(GetField<uint8_t>(6, 0));
  }
  // 获取指针
  const void *main() const {
    return GetPointer<const void *>(8);
  }
  
  // 通过一堆main_as_XXX函数根据算子类型转换成对应的参数结构体指针，例如main_as_ArgMax算子就转换成ArgMax结构体指针
  template<typename T> const T *main_as() const;
  const QuantizedAdd *main_as_QuantizedAdd() const {
    return main_type() == OpParameter_QuantizedAdd ? static_cast<const QuantizedAdd *>(main()) : nullptr;
  }
  const ArgMax *main_as_ArgMax() const {
    return main_type() == OpParameter_ArgMax ? static_cast<const ArgMax *>(main()) : nullptr;
  }
  // ... 其它代码

  // 通过FlatBuffers进行序列化和反序列化
  OpT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  void UnPackTo(OpT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  static flatbuffers::Offset<Op> Pack(flatbuffers::FlatBufferBuilder &_fbb, const OpT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};

接下来各个算子都有一个自己的参数解析类，通过判断main_type()的参数类型来转换成对应的参数结构体指针，例如main_as_ArgMax()函数会判断参数类型是否是ArgMax，如果是就转换成ArgMax结构体指针，这里OpParameter是一个枚举类型，用于表示不同的算子参数类型，例如 QuantizedAdd, ArgMax, InstanceNorm 等，部分代码如下：

// schema/current/MNN_generated.h
enum OpParameter {
  OpParameter_NONE = 0,
  OpParameter_QuantizedAdd = 1,
  OpParameter_ArgMax = 2,
  // ... 其它代码 
};

以ArgMax为例，算子可以通过main_as_XXX转换成对应算子读取时使用的底层Flatbuffer结构体，可以继续通过UnPack函数转换成修改/写入时用到的ArgMaxT结构体，核心代码如下：

// schema/current/CaffeOp_generated.h
struct ArgMax FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef ArgMaxT NativeTableType;
  static const flatbuffers::TypeTable *MiniReflectTypeTable() {
    return ArgMaxTypeTable();
  }
  // 获取各种算子的参数
  int32_t outMaxVal() const {
    return GetField<int32_t>(4, 0);
  }
  int32_t topK() const {
    return GetField<int32_t>(6, 0);
  }
  int32_t axis() const {
    return GetField<int32_t>(8, 0);
  }
  int32_t softmaxThreshold() const {
    return GetField<int32_t>(10, 0);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<int32_t>(verifier, 4) &&
           VerifyField<int32_t>(verifier, 6) &&
           VerifyField<int32_t>(verifier, 8) &&
           VerifyField<int32_t>(verifier, 10) &&
           verifier.EndTable();
  }
  // 序列化和反序列化
  ArgMaxT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  void UnPackTo(ArgMaxT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  static flatbuffers::Offset<ArgMax> Pack(flatbuffers::FlatBufferBuilder &_fbb, const ArgMaxT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};

反序列化后的ArgMaxT结构体就是我们平时上层使用的算子参数结构体，属性包含了算子参数的具体数值，例如outMaxVal, topK, axis, softmaxThreshold等，核心代码如下：

struct ArgMaxT : public flatbuffers::NativeTable {
  typedef ArgMax TableType;
  int32_t outMaxVal;
  int32_t topK;
  int32_t axis;
  int32_t softmaxThreshold;
  ArgMaxT()
      : outMaxVal(0),
        topK(0),
        axis(0),
        softmaxThreshold(0) {
  }
};

从Op类再往上层就是后端算子的具体实现，通过继承Execution类实现，该类解释可见后端介绍，例如：

// source/backend/cpu/CPUArgMax.hpp
class CPUArgMax : public Execution {
public:
    enum ArgMinOrMax {
        ARGMIN,
        ARGMAX
    };
    CPUArgMax(Backend *backend, ArgMinOrMax mode, int topk, int outMaxVal, int softmaxThreshold, int axis);
    virtual ~CPUArgMax() = default;
    virtual ErrorCode onResize(const std::vector<Tensor *> &inputs, const std::vector<Tensor *> &outputs) override;
    virtual ErrorCode onExecute(const std::vector<Tensor *> &inputs, const std::vector<Tensor *> &outputs) override;

private:
    Tensor mInputBuffer;
    Tensor mOutputBuffer;
    int mTopk;
    int mOutMaxVal;
    int mSoftmaxThreshold;
    int mAxis;
    int mNum;
    int mDim;
    int mKeyExtent;
    bool mFromNHWC;
    ArgMinOrMax mMode;
};

在构造不同后端的算子实现时，会把Op结构体中的参数传入到成员变量中，例如：topK, outMaxVal, softmaxThreshold, axis等，后续在执行时就可以直接使用这些参数进行计算了，核心代码如下：

// source/backend/cpu/CPUArgMax.cpp
class CPUArgMaxCreator : public CPUBackend::Creator {
public:
    virtual Execution *onCreate(const std::vector<Tensor *> &inputs, const std::vector<Tensor *> &outputs,
                                const MNN::Op *op, Backend *backend) const {
        auto argMax = op->main_as_ArgMax();
        if (op->type() == OpType_ArgMin) {
            return new CPUArgMax(backend, CPUArgMax::ArgMinOrMax::ARGMIN,
                    argMax->topK(), argMax->outMaxVal(), argMax->softmaxThreshold(), argMax->axis());
        } else {
            return new CPUArgMax(backend, CPUArgMax::ArgMinOrMax::ARGMAX,
                    argMax->topK(), argMax->outMaxVal(), argMax->softmaxThreshold(), argMax->axis());
        }
    }
};

总结一下：读取算子时通常用Op结构体，修改/写入时用OpT结构体。阅读代码时可以查看带T的结构体名称，例如ArgMaxT、ConvolutionT，便于阅读。

MNN中会把常见的线性层转换为卷积Convolution算子，常用算子UnaryOp和BinaryOp分别表示一元和二元算子。

常用接口：可以使用EnumNameXXX方式获取OpType、OpParameter等枚举类型的字符串名称，便于调试，例如：

// schema/current/MNN_generated.h
inline const char *EnumNameOpType(OpType e);
inline const char *EnumNameOpParameter(OpParameter e);

// schema/current/TensorflowOp_generated.h
inline const char *EnumNameBinaryOpOperation(BinaryOpOperation e);

这里的获取都是从一个静态数组中取值实现的，例如二元操作的各个名称存储在静态数组中，并且通过EnumNameBinaryOpOperation函数根据枚举值获取对应的名称字符串，核心代码如下：

// schema/current/TensorflowOp_generated.h
inline const char * const *EnumNamesBinaryOpOperation() {
  static const char * const names[] = {
    "ADD",
    "SUB",
    "MUL",
    "DIV",
    "MAX_TEMP",
    "MIN_TEMP",
    "POW",
    "REALDIV",
    "MINIMUM",
    "MAXIMUM",
    "GREATER",
    "GREATER_EQUAL",
    "LESS",
    "FLOORDIV",
    "SquaredDifference",
    "EQUAL",
    "LESS_EQUAL",
    "FLOORMOD",
    "",
    "MOD",
    "ATAN2",
    "LOGICALOR",
    "NOTEQUAL",
    "BITWISE_AND",
    "BITWISE_OR",
    "BITWISE_XOR",
    "LOGICALXOR",
    "LEFTSHIFT",
    "RIGHTSHIFT",
    nullptr
  };
  return names;
}
inline const char *EnumNameBinaryOpOperation(BinaryOpOperation e) {
  if (e < BinaryOpOperation_ADD || e > BinaryOpOperation_RIGHTSHIFT) return "";
  const size_t index = static_cast<int>(e);
  return EnumNamesBinaryOpOperation()[index];
}

1.5.1 GEMM转卷积算子的理解

MNN中会把常见的线性层转换为$1\times1$的卷积Convolution算子，

TODO:

1.6 Pipeline类

TODO:

1.7 Session类

TODO:

深度学习 on huluhuluu

MNN Backend 介绍

MNN 介绍

1. 后端

1.1 CPU后端系列

1.1.1 x86/x64-SSE4.1后端

1.1.2 x86/x64-AVX2后端

1.1.3 x86/x64-AVX512后端

1.1.4 ARMv7a后端

1.1.5 ARMv8后端

1.2 GPU后端系列

1.2.1 OpenCL后端

1.2.2 Vulkan后端

1.2.3 Metal后端

1.2.4 CUDA后端

1.2.5 OpenGL后端

1.3 专用加速器

1.3.1 CoreML后端

1.3.2 HIAI后端

1.3.3 NNAPI后端

1.3.4 QNN后端

1.3.5 NeuroPilot 后端

1.4 后端相关目录结构

1.4.1 后端文件说明

1.4.1.1 Runtime - 运行时抽象层

1.4.1.2 Backend - 后端抽象基类

1.4.1.3 Execution - 执行器抽象基类

1.4.2 后端调用设置

1.4.2.1 Core Function

MNN 核心类介绍

MNN 介绍

1. MNN核心类

1.1 类之间关系

1.2 VARP类

1.2.1 Variable 类

1.2.2 readMap详解

1.3 Expr类

1.3.1 requireInfo 详解

1.4 Tensor类

1.4.1 数据格式

1.4.2 底层数据格式

1.4.2 核心接口

1.5 Op类

1.5.1 GEMM转卷积算子的理解

1.6 Pipeline类

1.7 Session类

1.8 Executor & ExecutorScope类