MNN 核心类介绍

1
2
3
4
5
6
7

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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

用户定义 `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` 进入算子的后端执行
    ↓
`Execution::onExecute()`	// 按计算图依次执行各算子的后端计算，计算结果存在 `Tensor` 中，最后从 `readMap` 读取为指针
    ↓
获得数据指针

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

// include/MNN/expr/Expr.hpp
class MNN_PUBLIC VARP {
public:
    // 绑定 / 解绑底层 Variable
    VARP();
    VARP(std::shared_ptr<Variable> c);
    VARP(Variable* c);

    // 直接取内部的 Variable 指针
    Variable* get() const;

    enum InputType {
        INPUT = 0,
        CONSTANT = 1,
        TRAINABLE = 2,
    };

    // 标记当前 VARP 的输入类型和维度格式
    bool fix(InputType type) const;
    void setOrder(Dimensionformat format);
    
private:
    std::shared_ptr<Variable> mContent;
};

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

// include/MNN/expr/Expr.hpp
class MNN_PUBLIC Variable {
public:
    // 节点命名，便于调试和导出
    const std::string& name() const;
    void setName(const std::string& name);

    struct Info {
        Dimensionformat order = NHWC;
        INTS dim;
        halide_type_t type;
        size_t size;
        void syncSize();
    };

    // 读取当前节点的 shape / dtype / format 信息
    const Info* getInfo();
    // 建立 Variable 到 Expr 的反向引用
    void setExpr(EXPRP expr,  int index);
    std::pair<EXPRP,  int> expr() const;
    // 返回当前节点关联的 Tensor
    const Tensor* getTensor() const;
    // 仅调整逻辑 shape，不直接触发算子执行
    bool resize(INTS dims);

    // 序列化 / 反序列化相关入口
    static std::vector<VARP> load(const char* fileName);
    static void save(const std::vector<VARP>& vars,  NetT* dest);

    // 直接把底层 Tensor 映射成可读 / 可写指针
    template <typename T>
    const T* readMap();
    template <typename T>
    T* writeMap();
private:
    // 核心类属性 表示入边
    EXPRP mFrom;
    int mFromIndex;
};

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

// express/Expr.cpp
void* Variable::readInternal(bool forShape) {
    if (nullptr == mFrom->get()) {
        // 输入 / 常量 / 可训练参数，直接走已有 Tensor
        return mFrom->inside()->mOutputTensors[0]->buffer().host;
    }
    // 普通 Expr，先补齐 shape 信息
    if (!mFrom->requireInfo()) {
        return nullptr;
    }
    // 没有 cache 时，先把当前子图收敛成一个临时 Session
    auto cache = mFrom->inside()->mCache;
    if (nullptr == cache) {
        ExecutorScope::Current()->makeCache({mFrom}, forShape);
        cache = mFrom->inside()->mCache;
    }
    if (nullptr == cache || NO_ERROR != cache->compute()) {
        return nullptr;
    }
    return cache->mapOutput(mFrom->mInside->mCacheOffset + mFromIndex,
                            mFrom->mInside->mOutputTensors[mFromIndex]);
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

bool Expr::requireInfo() {
    if (!mInside->mInfoDirty) {
        return true;
    }
    if (nullptr == mOp) {
        return !HasUnknownDim(mInside->mOutputInfos[0].dim);
    }
    // 递归补齐所有的输入链节点信息
    for (int i = 0; i < mInputs.size(); ++i) {
        auto inputInfo = mInputs[i]->getInfo();
        if (nullptr == inputInfo) {
            mValid = false;
            return false;
        }
    }
    for (int i = 0; i < mInputs.size(); ++i) {
        if (mInside->mReq.shapeNeedContent[i]) {
            auto ptr = mInputs[i]->readInternal(true);
            if (nullptr == ptr) {
                return false;
            }
        }
    }
    auto res = ExecutorScope::Current()->computeInfo(this);
    if (NO_ERROR == res) {
        mInside->mInfoDirty = false;
    }
    return NO_ERROR == res;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

// express/Executor.cpp
ErrorCode Executor::computeInfo(Expr* expr) {
    auto op = expr->get();
    std::vector<Tensor*> inputTensors(expr->inputs().size());
    for (int i = 0; i < inputTensors.size(); ++i) {
        auto inputExpr = expr->inputs()[i]->expr();
        inputTensors[i] = inputExpr.first->inside()->mOutputTensors[inputExpr.second];
    }
    bool res = SizeComputer::computeOutputSize(op, inputTensors, expr->inside()->mOutputTensors);
    if (!res) {
        return COMPUTE_SIZE_ERROR;
    }
    for (int i = 0; i < expr->outputSize(); ++i) {
        auto tensor = expr->inside()->mOutputTensors[i];
        TensorUtils::setLinearLayout(tensor);
        auto shape = expr->outputInfo(i);
        Utils::copyTensorToInfo(shape, tensor);
    }
    return NO_ERROR;
}

1
2
3
4
5
6

// express/Expr.cpp
auto cache = mFrom->inside()->mCache;
if (nullptr == cache) {
    ExecutorScope::Current()->makeCache({mFrom}, forShape);
    cache = mFrom->inside()->mCache;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

// express/Executor.cpp
void Executor::_makeCache(const std::vector<EXPRP>& expr, bool forceCPU) {
    Schedule::ScheduleInfo scheduleInfo;
    scheduleInfo.pipelineInfo.resize(1);
    auto& pipeline = scheduleInfo.pipelineInfo[0].second;
    // 反向遍历 Expr 子图，构造 pipeline 里的 OpCacheInfo
    while (!dfsStack.empty()) {
        // ...
        Schedule::OpCacheInfo opInfo;
        opInfo.op = expr->get();
        opInfo.inputs.resize(inputs.size());
        opInfo.outputs.resize(expr->outputSize());
        // ...
        pipeline.emplace_back(std::move(opInfo));
    }
    std::shared_ptr<ComputeCache> cahce(new ComputeCache);
    for (auto& iter : dstExpr) {
        iter.first->inside()->mCacheOffset = iter.second;
        iter.first->inside()->mCache = cahce;
    }
    cahce->mSession.reset(new Session(std::move(scheduleInfo), group, std::move(rt)));
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

ErrorCode Executor::ComputeCache::compute() {
    while (!dfsStack.empty()) {
        auto cache = dfsStack.top();
        if (cache->mShapeDirty) {
            auto code = cache->resize();
            if (NO_ERROR != code) {
                return code;
            }
        }
        if (!cache->mContentDirty) {
            // 已有可复用结果，跳过执行
            continue;
        }
        // 输入依赖都满足后，真正执行 Session
        code = cache->mSession->run();
        if (NO_ERROR != code) {
            return code;
        }
        cache->mContentDirty = false;
    }
    return NO_ERROR;
}

1
2
3
4
5
6
7

ErrorCode Executor::ComputeCache::resizeImpl() {
    mShapeDirty = false;
    mSession->setNeedResize();
    mSession->resize();
    mContentDirty = true;
    return NO_ERROR;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

// source/core/Session.cpp
ErrorCode Session::run() const {
    for (auto& iter : mPipelines) {
        auto error = iter->execute();
        if (NO_ERROR != error) {
            return error;
        }
    }
    return NO_ERROR;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

// express/Utils.cpp
void* Executor::ComputeCache::mapOutput(int offset, Tensor* dest) {
    auto tensor = mSession->getTensor(offset);
    if (0 == tensor->deviceId() && TensorUtils::getDescribe(tensor)->quantAttr.get() == nullptr) {
        auto ptr = tensor->host<void>();
        dest->buffer().host = (uint8_t*)ptr;
        return ptr;
    }
    Utils::allocMemoryForHostTensor(dest);
    tensor->copyToHostTensor(dest);
    return dest->host<void>();
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70

Variable::readMap<T>()
# 模板接口，只负责把 readInternal() 返回的 void* 转成 T*
└── Variable::readInternal(forShape = false)
    # readMap 的真正入口；forShape=false 表示这次是为了读取最终数据
    ├── [叶子节点] mFrom->get() == nullptr
    │   # 没有关联 Op，说明是 Input / Const / Trainable 这类已持有 Tensor 的节点
    │   └── 直接返回 mOutputTensors[0]->buffer().host
    │
    ├── Expr::requireInfo()
    │   # 普通算子节点先保证输出 shape / dtype / format 已经推导完成
    │   ├── 递归补齐输入 shape
    │   │   # 当前 Expr 的 shape 依赖所有输入 Variable 的 Info
    │   │   └── input VARP -> Variable::getInfo()
    │   │       └── input Expr -> Expr::requireInfo()
    │   ├── [shape 依赖输入内容]
    │   │   # 部分 shape 算子不只依赖维度，还要先读输入 Tensor 的真实内容
    │   │   └── input VARP -> Variable::readInternal(forShape = true)
    │   └── ExecutorScope::Current()->computeInfo(this)
    │       └── Executor::computeInfo(expr)
    │           └── SizeComputer::computeOutputSize(op, inputs, outputs)
    │               # 进入算子 shape 推导注册表，写回 Expr 输出 Tensor 的形状信息
    │
    ├── [当前 Expr 没有 cache] ExecutorScope::Current()->makeCache({mFrom}, forShape)
    │   # 第一次真正求值时才会把 Expr 子图收敛成可执行缓存
    │   └── Executor::makeCache(outputs, forceCPU)
    │       └── Executor::_makeCache(outputs, forceCPU)
    │           ├── 从目标 Expr 反向 DFS 收集依赖
    │           │   # 只收集本次输出真正依赖的 Expr，已有 cache 的输入会作为边界
    │           ├── 按依赖顺序生成 Schedule::OpCacheInfo
    │           │   # 每个 OpCacheInfo 记录一个 Op、它的输入 Tensor 和输出 Tensor
    │           ├── 填充 Schedule::ScheduleInfo::pipelineInfo
    │           │   # pipelineInfo 后续会被 Session / Pipeline 用来创建 command
    │           ├── 记录目标 Expr 的 mCacheOffset / mCache
    │           │   # mCacheOffset 用于 mapOutput() 时找到目标输出 Tensor
    │           └── new Session(scheduleInfo, group, runtime)
    │               └── 保存到 ComputeCache::mSession
    │                   # ComputeCache 持有临时 Session，后续 resize/run 都靠它
    │
    ├── Executor::ComputeCache::compute()
    │   # cache 已经存在后，从这里开始决定是否 resize、是否重新执行
    │   ├── DFS 检查依赖的 input cache
    │   │   # 保证上游 cache 已经完成，输入内容没有脏状态
    │   ├── [mShapeDirty] ComputeCache::resize()
    │   │   # shape 脏时先重新 resize；resize 后内容也会变脏
    │   │   └── ComputeCache::resizeImpl()
    │   │       ├── Session::setNeedResize()
    │   │       └── Session::resize()
    │   │           ├── Pipeline::encode()
    │   │           │   # 根据 ScheduleInfo 生成 command，并创建算子 Execution
    │   │           │   └── Backend 创建每个 Op 对应的 Execution
    │   │           └── Pipeline::allocMemory()
    │   │               # 为 command 里的 Tensor 分配或复用后端内存
    │   │               └── 为输入、中间结果和输出 Tensor 分配后端内存
    │   └── [mContentDirty] Session::run() / Session::runWithCallBack()
    │       # 内容脏时才真正执行；有 debug callback 时走 runWithCallBack()
    │       └── Pipeline::execute()
    │           # 按 command buffer 顺序执行每个算子
    │           └── cmd.execution->onExecute(...)
    │               └── 具体 Backend Execution 执行算子
    │
    └── Executor::ComputeCache::mapOutput(mCacheOffset + mFromIndex, outputTensor)
        # 从临时 Session 的输出 Tensor 映射回当前 Variable 持有的 Tensor
        ├── host Tensor 且无 quantAttr
        │   # 已经在 CPU host 内存上，可以零拷贝返回指针
        │   └── 直接返回 tensor->host<void>()
        └── 设备 Tensor / 量化 Tensor
            # GPU / NPU 等设备内存或量化 Tensor，需要先复制到 host
            ├── Utils::allocMemoryForHostTensor(dest)
            ├── tensor->copyToHostTensor(dest)
            └── 返回 dest->host<void>()

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

// include/MNN/expr/Expr.hpp
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;
    int outputSize() const;
    // 当前边的名字和输出名
    void setName(const std::string& name);
    const std::string& name() const;
    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; // 核心属性 表示边的操作 如果为空表示当前边的输出VARP节点是常量节点
    std::vector<VARP> mInputs; // 核心属性 表示边的输入节点
    VARP::InputType mType;
    std::string mName;
    std::vector<std::string> mOutputNames;
    std::shared_ptr<Inside> mInside = nullptr; // 包括当前边的输出信息
};

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

// express/Utils.hpp
struct Expr::Inside {
    // 按输出个数初始化内部状态
    Inside(int outputSize);
    // 直接用已有 Tensor 构造 Expr 的内部表示
    Inside(Tensor* tensor, bool own = false);
    // 释放输出 Tensor / Host Tensor 等内部资源
    ~ Inside();
    std::vector<Variable::Info> mOutputInfos;  // 每个输出对应的 shape / dtype / format 描述
    std::vector<Tensor*> mOutputTensors;       // 每个输出真正绑定的 Tensor 指针
    Executor::Requirement mReq;                // 当前 Expr 对输入内容和 shape 的依赖要求
    std::shared_ptr<Executor::ComputeCache> mCache; // 当前 Expr 关联的执行缓存，里面会持有临时 Session
    int mCacheOffset = 0;                      // 当前 Expr 的第一个输出在 cache Tensor 列表中的偏移
    bool mInfoDirty = true;                    // 输出信息是否失效，失效时需要重新做 shape 推导
    bool mContentDirty = true;                 // 输出内容是否失效，失效时需要重新执行算子
    bool mOwnTensor = true;                    // 当前 Inside 是否负责释放 mOutputTensors
    Tensor* mHostTensor = nullptr;             // 设备 Tensor 读回 Host 时使用的临时拷贝 Tensor
    std::shared_ptr<Backend> mHoldBackend;     // 持有输出数据的后端，避免底层资源被提前释放
};

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

// express/Expr.cpp
bool Expr::requireInfo() {
    // 已经计算过就直接返回
    if (!mInside->mInfoDirty) {
        return true;
    }
    // 节点本身已经失效，直接失败
    if (!mValid) {
        return false;
    }
    // 没有算子时，只检查输出维度是否还包含未知值
    if (nullptr == mOp) {
        return !HasUnknownDim(mInside->mOutputInfos[0].dim);
    }
    // 先把所有输入节点的信息补齐
    for (int i = 0; i < mInputs.size(); ++i) {
        auto inputInfo = mInputs[i]->getInfo();
        if (nullptr == inputInfo) {
            mValid = false;
            return false;
        }
    }
    // 某些算子的 shape 推导需要真实输入内容
    for (int i = 0; i < mInputs.size(); ++i) {
        if (mInside->mReq.shapeNeedContent[i]) {
            // 某些算子的 shape 推导依赖输入内容
            if (nullptr == mInputs[i]->readInternal(true)) {
                return false;
            }
        }
    }
    // 交给 Executor 做真正的 shape / info 推导
    auto res = ExecutorScope::Current()->computeInfo(this);
    if (NO_ERROR == res) {
        mInside->mInfoDirty = false;
    } else {
        mValid = false;
    }
    return NO_ERROR == res;
}

1
2
3
4
5
6
7

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

1
2
3
4
5
6
7

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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

// 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] 就是 3 维

    /** 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;

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60

// 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;

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

// 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
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

// 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
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

构造阶段（NativeTable，可修改）

OpT
├── type = OpType_ArgMax                  # 算子类型
├── inputIndexes / outputIndexes / name  # 输入输出索引和算子名
└── main : OpParameterUnion
    ├── type  = OpParameter_ArgMax        # 参数类型标签
    └── value -------> ArgMaxT            # 指向具体参数结构体
                         ├── axis
                         ├── topK
                         ├── outMaxVal
                         └── softmaxThreshold


模型二进制转换过程（FlatBuffers）

OpT
  └── Pack / CreateOp(...)                # 把 NativeTable 打包成 FlatBuffers 二进制
        ↓
   FlatBuffer binary                      # 模型中的实际存储形式
        ↓
flatbuffers::GetRoot<Op>(...)             # 从二进制上取得 Op 只读视图
        ↓
       Op
       ├── type()
       ├── inputIndexes()
       └── main_as_ArgMax()               # 按参数类型取出 ArgMax 只读视图
              ↓
            ArgMax
              └── UnPack()                # 如需修改，再转回 NativeTable
                    ↓
                  ArgMaxT

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

// 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;               // 外部权重路径
};

1
2
3
4
5
6
7
8
9

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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

// schema/current/MNN_generated.h
struct OpParameterUnion {
  OpParameter type; // 参数类型
  void *value;      // 参数值，指向具体的参数结构体，如 QuantizedAddT、ArgMaxT 等

  // 根据参数类型转换成对应的参数结构体指针
  QuantizedAddT *AsQuantizedAdd() {
    return type == OpParameter_QuantizedAdd ?
      reinterpret_cast<QuantizedAddT *>(value) : nullptr;
  }
  const QuantizedAddT *AsQuantizedAdd() const {
    return type == OpParameter_QuantizedAdd ?
      reinterpret_cast<const QuantizedAddT *>(value) : nullptr;
  }
  ArgMaxT *AsArgMax() {
    return type == OpParameter_ArgMax ?
      reinterpret_cast<ArgMaxT *>(value) : nullptr;
  }
  const ArgMaxT *AsArgMax() const {
    return type == OpParameter_ArgMax ?
      reinterpret_cast<const ArgMaxT *>(value) : nullptr;
  }

1
2
3
4
5
6
7

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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

// express/MathOp.cpp
VARP _ArgMax(VARP input, int axis) {
    input = _checkNC4HW4(input);
    std::unique_ptr<OpT> op(new OpT);
    // 设置算子类型和参数
    op->main.type                         = OpParameter_ArgMax;
    op->type                              = OpType_ArgMax;
    // 构造参数结构体并设置参数值
    op->main.value                        = new ArgMaxT;
    op->main.AsArgMax()->axis = axis;
    op->main.AsArgMax()->outMaxVal = 0;
    op->main.AsArgMax()->topK = 0;
    op->main.AsArgMax()->softmaxThreshold = 0;
    return (Variable::create(Expr::create(std::move(op), {input})));
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

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) {
  }
};

1
2

// express/module/Module.cpp:461
auto op = net->oplists()->GetAs<Op>(i);

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

// schema/current/MNN_generated.h
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 函数，根据参数类型转换成对应的参数结构体
  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 在 Op 和 OpT 之间切换
  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);
};

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

// 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();
  }
  // `UnPack`接口可以把反序列化成包含了算子参数的各种属性
  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);
};

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

// 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 {
        // 通过 Op 结构体获取 ArgMax 参数结构体
        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());
            // 上面通过topK()、outMaxVal()、softmaxThreshold()、axis()等接口获取算子的参数值
        } else {
            return new CPUArgMax(backend, CPUArgMax::ArgMinOrMax::ARGMAX,
                    argMax->topK(), argMax->outMaxVal(), argMax->softmaxThreshold(), argMax->axis());
        }
    }
};

1
2
3
4
5
6

// 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);

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

// 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
2
3
4
5
6
7

// source/core/Pipeline.hpp
class Pipeline : public NonCopyable {
public:
    ErrorCode encode(bool supportDebug = false, bool permitCodegen = false);
    ErrorCode allocMemory(bool firstMalloc, bool permitCodegen);
    ErrorCode execute();
};

1
2
3
4
5
6

/** encode :
   1. compute shape for every op's inputs and outputs;
   2. geometry transform;
   3. copy op, inputs and outputs tensor info to mBuffer
*/
ErrorCode encode(bool supportDebug = false, bool permitCodegen = false);

1
2
3
4
5

Session::run()
    ↓
Pipeline::execute()
    ↓
Execution::onExecute()

1
2
3
4
5
6
7
8
9

// source/core/Session.hpp
class MNN_PUBLIC Session {
public:
    ErrorCode run() const;
    ErrorCode runWithCallBack(const TensorCallBackWithInfo& before,
                              const TensorCallBackWithInfo& after,
                              bool sync = false) const;
    ErrorCode resize();
};

1
2
3
4
5
6
7

struct ModeGroup {
    Interpreter::SessionMode inputMode = Interpreter::Session_Input_Inside;
    Interpreter::SessionMode outputMode = Interpreter::Session_Output_Inside;
    Interpreter::SessionMode backendMode = Interpreter::Session_Backend_Fix;
    Interpreter::SessionMode resizeMode = Interpreter::Session_Resize_Direct;
    Interpreter::SessionMode memoryUsageMode = Interpreter::Session_Memory_Collect;
};

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

// source/core/Session.cpp
auto rt         = runtime.first.find(iter.first.info.type)->second.get();
auto cpuRuntime = runtime.second;
iter.first.cache.first.reset(rt->onCreate(iter.first.info.user));

if (iter.first.cache.first->type() == MNN_FORWARD_CPU && (!specialUsage)) {
    iter.first.cache.second = iter.first.cache.first;
} else {
    iter.first.cache.second.reset(cpuRuntime->onCreate(&defaultConfig, origin));
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

// include/MNN/expr/Executor.hpp
class MNN_PUBLIC Executor {
public:
    struct Requirement {
        std::vector<bool> contentNeedContent;
        std::vector<bool> shapeNeedContent;
    };
    Requirement getRequirement(Expr* expr) const;
    ErrorCode computeInfo(Expr* expr);
    void makeCache(const std::vector<EXPRP>& expr, bool forceCPU = false);
};

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

// express/Executor.cpp
bool res = SizeComputer::computeOutputSize(op, inputTensors, expr->inside()->mOutputTensors);
if (!res) {
    return COMPUTE_SIZE_ERROR;
}
for (int i = 0; i < expr->outputSize(); ++i) {
    auto tensor = expr->inside()->mOutputTensors[i];
    TensorUtils::setLinearLayout(tensor);
    auto shape  = expr->outputInfo(i);
    Utils::copyTensorToInfo(shape, tensor);
}

1
2
3
4
5
6
7

// express/Executor.cpp
scheduleInfo.pipelineInfo.resize(1);
auto& pipeline = scheduleInfo.pipelineInfo[0].second;
...
pipeline.emplace_back(std::move(opInfo));
...
cahce->mSession.reset(new Session(std::move(scheduleInfo), group, std::move(rt)));

1
2
3
4
5
6
7
8

// express/ExecutorScope.cpp
const std::shared_ptr<Executor> ExecutorScope::Current() {
    auto exe = _getGlobalScope()->Content();
    if (exe) {
        return exe;
    }
    return Executor::getGlobalExecutor();
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

BackendConfig config;
auto exe = Executor::newExecutor(MNN_FORWARD_CPU, config, 1);
{
    ExecutorScope scope(exe);
    // 这个作用域内，ExecutorScope::Current() 返回 exe
    auto y = _Add(x0, x1);
    y->readMap<float>();
}
// 离开作用域后，自动恢复到上一层 Executor；
// 如果没有上一层，就继续回退到全局 Executor。