chore: import upstream snapshot with attribution

docs/cpp/Expr.md

@@ -0,0 +1,952 @@
+# VARP
+```cpp
+class VARP
+```
+
+## 枚举类
+### Dimensionformat
+```cpp
+enum Dimensionformat {
+    NHWC,
+    NC4HW4,
+    NCHW
+};
+```
+
+| value | name |      说明         |
+|:------|:-----|:-----------------|
+| 0 | `NHWC` |  |
+| 1 | `NC4HW4` | |
+| 2 | `NCHW` |  |
+
+### InputType
+```cpp
+enum InputType {
+    INPUT = 0,
+    CONSTANT = 1,
+    TRAINABLE = 2,
+};
+```
+
+| value | name |      说明         |
+|:------|:-----|:-----------------|
+| 0 | `INPUT` | 默认输入变量 |
+| 1 | `CONSTANT` | 常量 |
+| 2 | `TRAINABLE` | 可训练变量 |
+
+## 成员函数
+
+### VARP
+```cpp
+VARP(std::shared_ptr<Variable> c) {
+    mContent = std::move(c);
+};
+```
+调用移动构造函数，将c的对象移动至mContent对象
+
+
+参数：
+- `c` Variable类型变量
+
+返回：`void`
+
+### VARP
+```cpp
+VARP(Variable* c) {
+    mContent.reset(c);
+};
+```
+重置mContent对象中的Variable对象
+
+
+参数：
+- `c` Variable类型变量
+
+返回：`void`
+
+### get
+```cpp
+Variable* get() const  {
+    return mContent.get();
+};
+```
+获取mContent的Variable对象
+
+
+参数：无
+
+返回：Variable对象
+
+### VARP
+```cpp
+VARP(const VARP& var) {
+    mContent = var.mContent;
+};
+```
+把var的content对象赋值给mContent变量
+
+
+参数：
+- `var` 输入变量
+
+返回：`void`
+
+### VARP
+```cpp
+VARP(VARP&& var) {
+    mContent = std::move(var.mContent);
+};
+```
+调用移动构造函数，将var.mContent的对象移动至mContent对象
+
+
+参数：
+- `var` 输入变量
+
+返回：`void`
+
+### operator+
+```cpp
+VARP operator+(VARP var) const;
+```
+VARP类型对象加法计算
+
+
+参数：
+- `var` 输入变量
+
+返回：VARP对象
+
+### operator-
+```cpp
+VARP operator-(VARP var) const;
+```
+VARP类型对象减法计算
+
+
+参数：
+- `var` 输入变量
+
+返回：VARP对象
+
+### operator*
+```cpp
+VARP operator*(VARP var) const;
+```
+VARP类型对象乘法计算
+
+
+参数：
+- `var` 输入变量
+
+返回：VARP对象
+
+### operator/
+```cpp
+VARP operator/(VARP var) const;
+```
+VARP类型对象除法计算
+
+
+参数：
+- `var` 输入变量
+
+返回：VARP对象
+
+### mean
+```cpp
+VARP mean(INTS dims) const;
+```
+计算均值
+
+
+参数：
+- `dims` 一个向量
+
+返回：VARP对象
+
+### sum
+```cpp
+VARP sum(INTS dims) const;
+```
+计算和
+
+
+参数：
+- `dims` 一个向量
+
+返回：VARP对象
+
+### operator==
+```cpp
+bool operator==(const VARP& var) const {
+    return var.mContent == mContent;
+};
+```
+重载相等运算符，判断var.mContent和mContent是否相等
+
+
+参数：
+- `var` 输入变量
+
+返回：true/false
+
+### operator<
+```cpp
+bool operator<(const VARP& var) const {
+    return mContent < var.mContent;
+};
+```
+重载小于运算符，判断mContent是否小于var.mContent
+
+
+参数：
+- `var` 输入变量
+
+返回：true/false
+
+### operator<=
+```cpp
+bool operator<=(const VARP& var) const {
+    return mContent <= var.mContent;
+};
+```
+重载小于等于运算符，判断mContent是否小于等于var.mContent
+
+
+参数：
+- `var` 输入变量
+
+返回：true/false
+
+### operator=
+```cpp
+VARP& operator=(const VARP& var) {
+    mContent = var.mContent;
+    return *this;
+};
+```
+拷贝var.mContent对象到mContent
+
+
+参数：
+- `var` 输入变量
+
+返回：当前对象的拷贝
+
+### operator=
+```cpp
+VARP& operator=(Variable* var) {
+    mContent.reset(var);
+    return *this;
+};
+```
+重置mContent对象中的Variable对象，并拷贝
+
+
+
+参数：
+- `var` 输入变量
+
+返回：当前对象的拷贝
+
+### operator->
+```cpp
+Variable* operator->() const  {
+    return mContent.get();
+};
+```
+获取mContent对象的值
+
+
+参数：无
+
+返回：Variable对象
+
+### fix
+```cpp
+bool fix(InputType type) const;
+```
+朝零方向取整
+
+
+参数：
+- `type` 输入数据类型
+
+返回：true/false
+
+### operator==
+```cpp
+inline bool operator==(Variable* src, VARP dst) {
+    return src == dst.get();
+};
+```
+重载相等运算符，判断src和dst.get()是否相等
+
+
+参数：
+- `src` Variable类型输入变量
+- `dst` VARP类型输入变量
+
+返回：true/false
+
+### operator!=
+```cpp
+inline bool operator!=(Variable* src, VARP dst) {
+    return src != dst.get();
+};
+```
+重载不相等运算符，判断src和dst.get()是否不相等
+
+
+参数：
+- `src` Variable类型输入变量
+- `dst` VARP类型输入变量
+
+返回：true/false
+
+
+# Variable
+```cpp
+class Variable
+```
+## 成员函数
+### name
+```cpp
+const std::string& name() const;
+```
+获取Variable对象的名称
+
+
+参数：无
+
+返回：名称
+
+### setName
+```cpp
+void setName(const std::string& name);
+```
+设置名称
+
+
+参数：
+- `name` 名称
+
+返回：`void` 
+
+### expr
+```cpp
+std::pair<EXPRP, int> expr() const {
+    return std::make_pair(mFrom, mFromIndex);
+};
+```
+创建一个EXPRP对象，需要mFrom作为参数，位置为mFromIndex
+
+
+参数：无
+
+返回：EXPRP对象
+
+### getInfo
+```cpp
+const Info* getInfo();
+```
+获取Variable对象的相关信息
+
+
+参数：无
+
+返回：如果计算信息错误，返回nullptr
+
+### resize
+```cpp
+bool resize(INTS dims);
+```
+调整Variable对象的大小
+
+
+参数：
+- `dims` 一个向量
+
+返回：true/false
+
+### readMap
+```cpp
+template <typename T>
+const T* readMap() {
+    return (const T*)readInternal();
+};
+```
+读取内部信息
+
+
+
+参数：无
+
+返回：信息
+
+### writeMap
+```cpp
+template <typename T>
+T* writeMap() {
+    return (T*)writeInternal();
+};
+```
+写入内部信息
+
+
+参数：无
+
+返回：信息
+
+### input
+```cpp
+bool input(VARP src);
+```
+输入信息
+
+
+参数：
+- `src` 输入变量
+
+返回：true/false
+
+### replace
+```cpp
+static void replace(VARP dst, VARP src);
+```
+替换信息
+
+
+参数：
+- `dst` 输入变量
+- `src` 输入变量
+
+返回：`void`
+
+### create
+```cpp
+static VARP create(EXPRP expr, int index = 0);
+```
+在index位置创建expr对象
+
+
+参数：
+- `expr` 输入变量
+- `index` 位置下标，默认为0
+
+返回：VARP对象
+
+### load
+```cpp
+static std::vector<VARP> load(const char* fileName);
+```
+通过文件名加载对象
+
+
+参数：
+- `fileName` 文件名
+
+返回：VARP对象矩阵
+
+### loadMap
+```cpp
+static std::map<std::string, VARP> loadMap(const char* fileName);
+```
+通过文件名读取模型对象
+
+
+参数：
+- `fileName` 文件名
+
+返回：模型对象
+
+### load
+```cpp
+static std::vector<VARP> load(const uint8_t* buffer, size_t length);
+```
+加载存储的，长度为length的模型对象
+
+
+参数：
+- `buffer` 存储数据
+- `length` 数据长度
+
+返回：模型对象
+
+### loadMap
+```cpp
+static std::map<std::string, VARP> loadMap(const uint8_t* buffer, size_t length);
+```
+读取存储的，长度为length的模型对象
+
+
+参数：
+- `buffer` 存储数据
+- `length` 数据长度 
+
+返回：模型对象
+
+### getInputAndOutput
+```cpp
+static std::pair<std::map<std::string, VARP>, std::map<std::string, VARP>> getInputAndOutput(const std::map<std::string, VARP>& allVariable);
+```
+获取模型输入输出节点
+
+
+参数：
+- `allVariable` 输入变量
+
+返回：模型输入输出节点
+
+### mapToSequence
+```cpp
+static std::vector<VARP> mapToSequence(const std::map<std::string, VARP>& source);
+```
+模型的输出节点及其名称
+
+
+参数：
+- `source` 输入变量
+
+返回：输出节点及其名称
+
+### getExecuteOrder
+```cpp
+static std::vector<EXPRP> getExecuteOrder(const std::vector<VARP>& output);
+```
+获取操作指令
+
+
+参数：
+- `output` 输入变量
+
+返回：指令集
+
+### save
+```cpp
+static void save(const std::vector<VARP>& vars, const char* fileName);
+```
+保存vars到指定位置
+
+
+参数：
+- `vars` 输入变量
+- `fileName` 文件名
+
+返回：`void`
+
+### save
+```cpp
+static std::vector<int8_t> save(const std::vector<VARP>& vars);
+```
+保存vars到默认位置
+
+
+参数：
+- `vars` 输入变量
+
+返回：`void`
+
+### save
+```cpp
+static void save(const std::vector<VARP>& vars, NetT* dest);
+```
+保存vars到dest位置
+
+
+参数：
+- `vars` 输入变量
+- `dest` 目标地址
+
+返回：`void`
+
+### prepareCompute
+```cpp
+static void prepareCompute(const std::vector<VARP>& vars, bool forceCPU = false);
+```
+将几个变量打包在一个管道中进行计算
+
+
+参数：
+- `vars` 输入变量
+- `forceCPU` 是否强制使用CPU，默认为false
+
+返回：`void`
+
+### compute
+```cpp
+static void compute(const std::vector<VARP>& vars, bool forceCPU = false);
+```
+计算变量
+
+
+参数：
+- `vars` 输入变量
+- `forceCPU` 是否强制使用CPU，默认为false
+
+返回：`void`
+
+### linkNumber
+```cpp
+size_t linkNumber() const;
+```
+获取输出信息的size
+
+
+参数：无
+
+返回：size
+
+### toExprs
+```cpp
+const std::vector<WeakEXPRP>& toExprs() const;
+```
+返回模型对象信息
+
+
+参数：无
+
+返回：模型对象信息
+
+### setExpr
+```cpp
+void setExpr(EXPRP expr, int index) {
+    mFrom = expr;
+    mFromIndex = index;
+};
+```
+在index位置设置EXPRP对象
+
+
+参数：无
+
+返回：EXPRP对象
+
+
+# Expr
+```cpp
+class Expr
+```
+
+## 枚举类
+### MemoryType
+```cpp
+enum MemoryType {
+    COPY,
+    MOVE,
+    REF
+};
+```
+
+| value | name |      说明         |
+|:------|:-----|:-----------------|
+| 0 | `COPY` | 拷贝 |
+| 1 | `MOVE` | 移动 |
+| 2 | `REF` | 引用 |
+
+## 成员函数
+### create
+```cpp
+static EXPRP create(Tensor* tensor, bool own = false);
+```
+创建一个包含tensor的EXPRP变量
+
+
+参数：
+- `tensor` 输入变量
+- `own` 默认为false
+
+返回：EXPRP变量
+
+### create
+```cpp
+static EXPRP create(Variable::Info&& info, const void* ptr, VARP::InputType type, MemoryType copy = COPY);
+```
+创建一个包含info对象的EXPRP变量
+
+
+参数：
+- `info` Variable类型输入变量
+- `ptr` 目标对象地址
+- `type` 输入数据类型
+- `copy` 内存拷贝
+
+返回：EXPRP变量
+
+### create
+```cpp
+static EXPRP create(const OpT* op, std::vector<VARP> inputs, int outputSize = 1);
+```
+创建EXPRP变量
+
+
+参数：
+- `op` 输入变量
+- `inputs` 输入变量
+- `outputSize` 输出信息大小，默认为1
+
+返回：EXPRP变量
+
+### create
+```cpp
+static EXPRP create(std::shared_ptr<BufferStorage> extra, std::vector<VARP>&& inputs, int outputSize = 1);
+```
+创建EXPRP变量
+
+
+参数：
+- `extra` 输入变量
+- `inputs` 输入变量
+- `outputSize` 输出信息大小，默认为1
+
+返回：EXPRP变量
+
+### create
+```cpp
+static EXPRP create(std::unique_ptr<OpT>&& op, std::vector<VARP> inputs, int outputSize = 1) {
+    return create(op.get(), inputs, outputSize);
+};
+```
+创建EXPRP变量
+
+
+参数：
+- `op` 输入变量
+- `inputs` 输入变量
+- `outputSize` 输出信息大小，默认为1
+
+返回：EXPRP变量
+
+### setName
+```cpp
+void setName(const std::string& name);
+```
+设置名称
+
+
+参数：
+- `name` 名称
+
+返回：`void`
+
+### get
+```cpp
+const Op* get() const {
+    return mOp;
+};
+```
+获取对象信息
+
+
+参数：无
+
+返回：对象信息
+
+### inputs
+```cpp
+const std::vector<VARP>& inputs() const {
+    return mInputs;
+};
+```
+获取输入节点信息
+
+
+参数：无
+
+返回：输入节点信息
+
+### outputSize
+```cpp
+int outputSize() const {
+    return (int)mOutputNames.size();
+};
+```
+返回输出节点信息大小
+
+
+参数：无
+
+返回：size
+
+### replace
+```cpp
+static void replace(EXPRP oldExpr, EXPRP newExpr);
+```
+用newExpr替换oldExpr
+
+
+参数：
+- `oldExpr` 输入变量，源对象
+- `newExpr` 输入变量，目标对象
+
+返回：`void`
+
+### requireInfo
+```cpp
+bool requireInfo();
+```
+获取需要的信息
+
+
+参数：无 
+
+返回：信息
+
+### visitOutputs
+```cpp
+void visitOutputs(const std::function<bool(EXPRP, int)>& visit);
+```
+访问输出节点的信息
+
+
+参数：
+- `visit` 访问方法
+
+返回：`void`
+
+### visit
+```cpp
+static void visit(EXPRP expr, const std::function<bool(EXPRP)>& before, const std::function<bool(EXPRP)>& after);
+```
+访问某一个范围的信息
+
+
+参数：
+- `expr` 输入变量
+- `before` before指针
+- `after`  after指针
+
+返回：`void`
+
+### outputs
+```cpp
+const std::vector<WeakEXPRP>& outputs() const {
+    return mTo;
+};
+```
+返回输出节点信息
+
+
+参数：无
+
+返回：信息
+
+### ~Expr()
+析构函数
+
+### visited
+```cpp
+bool visited() const {
+    return mVisited;
+};
+```
+是否已经访问过
+
+
+参数：无
+
+返回：true/false
+
+### setVisited
+```cpp
+void setVisited(bool visited) {
+    mVisited = visited;
+};
+```
+设置已经被访问
+
+
+参数：
+- `visited` 是否访问
+
+返回：`void`
+
+### name
+```cpp
+const std::string& name() const {
+    return mName;
+};
+```
+获取名称
+
+
+参数：无
+
+返回：名称
+
+### outputName
+```cpp
+const std::string& outputName(int index) {
+    return mOutputNames[index];
+};
+```
+输出指定index的名称
+
+
+参数：
+- `index` 下标
+
+返回：名称
+
+### inputType
+```cpp
+VARP::InputType inputType() const {return mType;};
+```
+返回当前输入类型
+
+
+参数：无
+
+返回：输入类型
+
+### outputInfo
+```cpp
+Variable::Info* outputInfo(int index) const;
+```
+返回指定下标的输出信息
+
+
+参数：
+- `index` 下标值
+
+返回：输出信息
+
+### extra
+```cpp
+std::shared_ptr<BufferStorage> extra() const {
+    return mStorage;
+};
+```
+返回附加信息
+
+
+参数：无
+
+返回：附加信息
+
+### inside
+```cpp
+std::shared_ptr<Inside> inside() const {
+    return mInside;
+};
+```
+返回内部信息
+
+
+参数：无
+
+返回：内部信息
+
+### valid
+```cpp
+bool valid() const {
+    return mValid;
+};
+```
+是否有效
+
+
+参数：无
+
+返回：true/false

docs/cpp/ImageProcess.md

@@ -0,0 +1,241 @@
+# ImageProcess
+```cpp
+class ImageProcess
+```
+
+## 枚举类
+### ImageFormat
+```cpp
+enum ImageFormat {
+    RGBA     = 0,
+    RGB      = 1,
+    BGR      = 2,
+    GRAY     = 3,
+    BGRA     = 4,
+    YCrCb    = 5,
+    YUV      = 6,
+    HSV      = 7,
+    XYZ      = 8,
+    BGR555   = 9,
+    BGR565   = 10,
+    YUV_NV21 = 11,
+    YUV_NV12 = 12,
+    YUV_I420 = 13,
+    HSV_FULL = 14,
+};
+```
+
+| value | name |      说明         |
+|:------|:-----|:-----------------|
+| 0 |  `RGBA`     |  |
+| 1 |  `RGB`      |  |
+| 2 |  `BGR`      |  |
+| 3 |  `GRAY`     |  |
+| 4 |  `BGRA`     |  |
+| 5 |  `YCrCb`    |  |
+| 6 |  `YUV`      |  |
+| 7 |  `HSV`      |  |
+| 8 |  `XYZ`      |  |
+| 9 |  `BGR555`   |  |
+| 10 | `BGR565`   |  |
+| 11 | `YUV_NV21` |  |
+| 12 | `YUV_NV12` |  |
+| 13 | `YUV_I420` |  |
+| 14 | `HSV_FULL` |  |
+
+
+### Filter
+```cpp
+enum Filter {
+    NEAREST       = 0,
+    BILINEAR      = 1,
+    BICUBIC       = 2,
+};
+```
+
+| value | name |      说明         |
+|:------|:-----|:-----------------|
+| 0 | `NEAREST`  | 最近点 |
+| 1 | `BILINEAR` | 双线性的 |
+| 2 | `BICUBIC`  | 双三次的 |
+
+
+### Wrap
+```cpp
+enum Wrap {
+    CLAMP_TO_EDGE  = 0,
+    ZERO           = 1,
+    REPEAT         = 2
+};
+```
+
+| value | name |      说明         |
+|:------|:-----|:-----------------|
+| 0 | `CLAMP_TO_EDGE` | 固定边缘的 |
+| 1 | `ZERO`          | 零 |
+| 1 | `REPEAT`        | 重复 |
+
+## 成员函数
+
+### create
+```cpp
+static ImageProcess* create(const Config& config, const Tensor* dstTensor = nullptr);
+```
+为给定张量创建给定配置的图像处理
+
+参数：
+- `config` 给定配置
+- `dstTensor` 给定张量，默认为nullptr
+
+返回：图像处理器
+
+### create
+```cpp
+static ImageProcess* create(const ImageFormat sourceFormat = RGBA, const ImageFormat destFormat = RGBA,
+                            const float* means = nullptr, const int meanCount = 0, const float* normals = nullptr,
+                            const int normalCount = 0, const Tensor* dstTensor = nullptr);
+```
+为给定张量创建给定配置的图像处理
+
+参数：
+- `sourceFormat` 源图像格式，默认为RGBA
+- `destFormat` 目的图像格式，默认为RGBA
+- `means` 给定方法，默认为nullptr
+- `meanCount` 给定方法数量，默认为0
+- `normals` 给定常量，默认为nullptr
+- `normalCount` 给定常量数量，默认为0
+- `dstTensor` 给定张量，默认为nullptr
+
+返回：图像处理器
+
+### ~ImageProcess
+析构函数
+
+### destroy
+```cpp
+static void destroy(ImageProcess* imageProcess);
+```
+释放图像资源
+
+参数：
+- `imageProcess` 被释放的图像进程
+
+返回：`void`
+
+### matrix
+```cpp
+inline const Matrix& matrix() const {
+        return mTransform;
+    };
+```
+得到仿射变换矩阵
+
+参数：无
+
+返回：仿射变换矩阵
+
+### setMatrix
+```cpp
+void setMatrix(const Matrix& matrix);
+```
+设置仿射变换矩阵
+
+参数：
+- `matrix` 源仿射变换矩阵
+
+返回：`void`
+
+### convert
+```cpp
+ErrorCode convert(const uint8_t* source, int iw, int ih, int stride, Tensor* dest);
+```
+将源数据转换为给定的张量
+
+参数：
+- `source` 源资源数据
+- `iw` 源资源数据的宽度
+- `ih` 源资源数据的高度
+- `stride` 每行的元素数，100宽RGB包含至少300个元素
+- `dest` 目的张量
+
+返回：结果code
+
+### convert
+```cpp
+ErrorCode convert(const uint8_t* source, int iw, int ih, int stride, void* dest, int ow, int oh, int outputBpp = 0,
+                  int outputStride = 0, halide_type_t type = halide_type_of<float>());
+```
+将源数据转换为给定的张量
+
+参数：
+- `source` 源资源数据
+- `iw` 源资源数据的宽度
+- `ih` 源资源数据的高度
+- `stride` 每行的元素数，100宽RGB包含至少300个元素
+- `dest` 目的张量
+- `ow` 输出宽度
+- `oh` 输出高度
+- `outputBpp` 如果是0，设置为保存和config.destFormat，默认为0
+- `outputStride` 如果为0，设置为ow * outputBpp，默认为0
+- `type` 支持`halide_type_of<uint8_t>`和`halide_type_of<float>`，默认为`halide_type_of<float>`
+
+返回：结果code
+
+### createImageTensor
+```cpp
+template <typename T>
+static Tensor* createImageTensor(int w, int h, int bpp, void* p = nullptr) {
+    return createImageTensor(halide_type_of<T>(), w, h, bpp, p);
+}
+static Tensor* createImageTensor(halide_type_t type, int w, int h, int bpp, void* p = nullptr);
+```
+用给定的数据创建张量
+
+参数：
+- `type` 只支持halide_type_of和halide_type_of
+- `w` 图像宽度
+- `h` 图像高度
+- `bpp` 每像素字节
+- `p` 像素数据指针，默认为nullptr
+
+返回：创建的张量
+
+### setPadding
+```cpp
+void setPadding(uint8_t value) {
+    mPaddingValue = value;
+};
+```
+当wrap=ZERO时设置填充值
+
+参数：
+- `value` 填充值
+
+返回：`void`
+
+### setDraw
+```cpp
+void setDraw();
+```
+设置绘制模式
+
+参数：无
+
+返回：`void`
+
+### draw
+```cpp
+void draw(uint8_t* img, int w, int h, int c, const int* regions, int num, const uint8_t* color);
+```
+绘制img区域的颜色
+
+参数：
+- `img` 要绘制的图像
+- `w` 图像的宽度
+- `h` 图像的高度
+- `c` 图像的通道
+- `regions` 要绘制的区域，大小为[num * 3]包含num x {y, xl, xr}
+- `num` 区域数量
+- `color` 要绘制的颜色
+
+返回：`void`

docs/cpp/Interpreter.md

@@ -0,0 +1,466 @@
+# Interpreter
+```cpp
+class Interpreter
+```
+
+## 枚举类
+### SessionMode
+```cpp
+enum SessionMode {
+    Session_Debug = 0,
+    Session_Release = 1,
+    Session_Input_Inside = 2,
+    Session_Input_User = 3,
+    Session_Output_Inside = 4,
+    Session_Output_User = 5,
+    Session_Resize_Direct = 6,
+    Session_Resize_Defer = 7,
+    Session_Backend_Fix = 8,
+    Session_Backend_Auto = 9,
+};
+```
+
+| value | name |      说明         |
+|:------|:-----|:-----------------|
+| 0 | `Session_Debug` | 可以执行callback函数，并获取Op信息(*默认*) |
+| 1 | `Session_Release` | 不可执行callback函数 |
+| 2 | `Session_Input_Inside` | 输入由session申请(*默认*) |
+| 3 | `Session_Input_User` | 输入由用户申请 |
+| 4 | `Session_Output_Inside` | 输出依赖于session不可单独使用 |
+| 5 | `Session_Output_User` | 输出不依赖于session可单独使用 |
+| 6 | `Session_Resize_Direct` | 在创建Session时执行resize(*默认*) |
+| 7 | `Session_Resize_Defer` | 在创建Session时不执行resize |
+| 8 | `Session_Backend_Fix` | 使用用户指定的后端，后端不支持时回退CPU |
+| 9 | `Session_Backend_Auto` | 根据算子类型自动选择后端 |
+
+### ErrorCode
+```cpp
+enum ErrorCode {
+    NO_ERROR           = 0,
+    OUT_OF_MEMORY      = 1,
+    NOT_SUPPORT        = 2,
+    COMPUTE_SIZE_ERROR = 3,
+    NO_EXECUTION       = 4,
+    INVALID_VALUE      = 5,
+    INPUT_DATA_ERROR = 10,
+    CALL_BACK_STOP   = 11,
+    TENSOR_NOT_SUPPORT = 20,
+    TENSOR_NEED_DIVIDE = 21,
+};
+```
+
+| value | name |      说明         |
+|:------|:-----|:-----------------|
+| 0 | `NO_ERROR` | 没有错误，执行成功  |
+| 1 | `OUT_OF_MEMORY` | 内存不足，无法申请内存 |
+| 2 | `NOT_SUPPORT` | 有不支持的OP |
+| 3 | `COMPUTE_SIZE_ERROR` | 形状计算出错 |
+| 4 | `NO_EXECUTION` | 创建执行时出错 |
+| 10 | `INPUT_DATA_ERROR` | 输入数据出错 |
+| 11 | `CALL_BACK_STOP` | 用户callback函数退出 |
+| 20 | `TENSOR_NOT_SUPPORT` | resize出错 |
+| 21 | `TENSOR_NEED_DIVIDE` | resize出错 |
+
+### SessionInfoCode
+```cpp
+enum SessionInfoCode {
+    MEMORY = 0,
+    FLOPS = 1,
+    BACKENDS = 2,
+    RESIZE_STATUS = 3,
+    ALL
+};
+```
+
+| value | name |      说明         |
+|:-----|:-----|:-----------------|
+| 0 | `MEMORY` | 会话的内存占用大小，MB计算，浮点类型数据 |
+| 1 | `FLOPS` | 会话的计算量，flops，浮点数据类型 |
+| 2 | `BACKENDS` | 会话的后端数目，个数是config数量加1 |
+| 3 | `RESIZE_STATUS` | resize的状态，数据是int类型，0表示就绪，1表示需要分配内存，2表示需要resize |
+|   | `ALL` | 以上所有信息 |
+
+### HintMode
+```cpp
+enum HintMode {
+    MAX_TUNING_NUMBER = 0,
+};
+```
+
+| value | name |      说明         |
+|:-----|:-----|:-----------------|
+| 0 | `MAX_TUNING_NUMBER` | GPU下tuning的最大OP数 |
+
+## 成员函数
+
+### Interpreter
+该构造函数禁止使用，创建对象请使用`createFromFile`
+
+### ~Interpreter
+析构函数
+
+### createFromFile
+```cpp
+static Interpreter* createFromFile(const char* file);
+```
+从文件加载模型，加载`.mnn`模型文件创建一个MNN解释器，返回一个解释器对象
+
+参数：
+- `file` MNN模型所放置的完整文件路径
+
+返回：创建成功则返回创建的解释器对象指针，失败就返回`nullptr`
+
+### createFromBuffer
+```cpp
+static Interpreter* createFromBuffer(const void* buffer, size_t size)
+```
+从内存加载模型，根据指定内存地址与大小，从内存中创建一个计时器对象
+
+参数：
+- `buffer` 模型文件内存中的数据指针
+- `size`  模型文件字节数大小
+
+返回：创建成功则返回创建的解释器对象指针，失败就返回`nullptr`
+
+### destroy
+```cpp
+static void destroy(Interpreter* net);
+```
+释放指定的解释器对象
+
+参数：
+- `net` 需要释放的解释器对象
+
+返回：`void`
+
+### setSessionMode
+```cpp
+void setSessionMode(SessionMode mode);
+```
+设置模型推理时回话的执行模式，参考[SessionMode](./Interpreter.html#sessionmode)
+
+*该函数需在`createSession`前调用*
+
+参数：
+- `mode` 回话的执行模式
+
+返回：`void`
+
+### setCacheFile
+```cpp
+void setCacheFile(const char* cacheFile, size_t keySize = 128);
+```
+设置缓存文件，缓存文件在GPU模式下用来存储Kernel与Op信息；执行该函数，在`runSession`前会从缓存文件中加载信息；在`runSession`后会将相关信息写入缓存文件中
+
+*该函数需在`createSession`前调用*
+
+参数：
+- `cacheFile` 缓存文件名
+- `keySize` 保留参数，现在未使用
+
+返回：`void`
+
+### setExternalFile
+```cpp
+void setExternalFile(const char* file, size_t flag = 128);
+```
+设置额外文件，额外文件是指存储了模型中权重，常量等数据的文件，在创建`Session`时会从该文件中加载权重等数据。
+
+*该函数需在`createSession`前调用*
+
+参数：
+- `file` 额外文件名
+- `flag` 保留参数，现在未使用
+
+返回：`void`
+
+### updateCacheFile
+```cpp
+ErrorCode updateCacheFile(Session *session, int flag = 0);
+```
+更新缓存文件，在最近的一次`resizeSession`中如果修改了缓存信息，就写入到缓存文件中；如果没有修改缓存信息，就什么都不做
+
+*该函数需在`resizeSession`前调用*
+
+参数：
+- `session` 要更新的缓存会话
+- `flag` 保留参数，现在未使用
+
+返回：更新缓存的[错误码](Interpreter.html#errorcode)
+
+### setSessionHint
+```cpp
+void setSessionHint(HintMode mode, int value);
+```
+设置会话的额外执行信息，使用[HintMode](Interpreter.html#hintmode)来描述额外信息的类型
+
+*该函数需在`createSession`前调用*
+
+参数：
+- `mode` 额外信息的类型
+- `value` 额外信息的数值
+
+返回：`void`
+
+### createRuntime
+```cpp
+static RuntimeInfo createRuntime(const std::vector<ScheduleConfig>& configs);
+```
+根据配置创建一个Runtime，默认情况下，在`createSession`时对应create单独一个Runtime。对于串行的一系列模型，可以先单独创建Runtime，然后在各Session创建时传入，使各模型用共享同样的运行时资源（对CPU而言为线程池、内存池，对GPU而言Kernel池等）；`RuntimeInfo`的定义如下：
+```cpp
+typedef std::pair<std::map<MNNForwardType, std::shared_ptr<Runtime>>, std::shared_ptr<Runtime>> RuntimeInfo;
+```
+
+参数：
+- `configs` 调度信息
+
+返回：创建的运行时信息，可以用于创建`Session`
+
+### createSession
+```cpp
+Session* createSession(const ScheduleConfig& config);
+Session* createSession(const ScheduleConfig& config, const RuntimeInfo& runtime);
+```
+根据配置或根据用户指定的运行时信息创建会话`Session`
+- 当仅传入`config`时会根据`config`信息创建`Runtime`
+- 当传入`runtime`时则使用用户传入的`Runtime`
+
+参数：
+- `config` 调度信息
+- `runtime` 执行信息
+
+返回：创建的会话`Session`
+
+### createMultiPathSession
+```cpp
+Session* createMultiPathSession(const std::vector<ScheduleConfig>& configs);
+Session* createMultiPathSession(const std::vector<ScheduleConfig>& configs, const RuntimeInfo& runtime);
+```
+根据多个配置创建多段计算路径的会话
+- 当仅传入`config`时会根据`config`信息创建`Runtime`
+- 当传入`runtime`时则使用用户传入的`Runtime`
+
+参数：
+- `configs` 多个调度信息
+
+返回：创建的会话`Session`
+
+### releaseSession
+```cpp
+bool releaseSession(Session* session);
+```
+释放指定的`Session`
+
+参数：
+- `session` 待释放的`Session`
+
+返回：是否成功释放该`Session`
+
+### resizeSession
+```cpp
+void resizeSession(Session* session);
+void resizeSession(Session* session, int needRelloc);
+```
+为session分配内存，进行推理准备工作；该函数一般配合`resizeTensor`一起调用，修改Tensor输入形状后对应整个推理过程中的内存分配也需要修改
+
+参数：
+- `session` 改变输入形状后需要重新分配内存的Session对象
+- `needRelloc` 是否重新分配内存，如果为0则只进行形状计算不进行内存分配
+
+返回：`void`
+
+### releaseModel
+```cpp
+void releaseModel();
+```
+当不再需要执行`createSession`和`resizeSession`的时候，可以调用此函数释放解释器中持有的模型资源，会释放模型文件大小的内存
+
+参数：
+- `void`
+
+返回：`void`
+
+### getModelBuffer
+```cpp
+std::pair<const void*, size_t> getModelBuffer() const;
+```
+获取模型模型的内存数据指针和内存大小，方便用户存储模型
+
+参数：
+- `void`
+
+返回：内存数据指针和内存大小
+
+### getModelVersion
+```cpp
+const char* getModelVersion() const;
+```
+获取模型的版本信息，以字符串的形式返回
+
+参数：
+- `void`
+
+返回：模型的版本信息，类似：`"2.0.0"`
+
+### updateSessionToModel
+```cpp
+ErrorCode updateSessionToModel(Session* session);
+```
+将`Session`中`Tensor`的数据更新Model中的常量数据
+
+参数：
+- `session` 需要更新的会话
+
+返回：更新数据的[错误码](Interpreter.html#errorcode)
+
+### runSession
+```cpp
+ErrorCode runSession(Session* session) const;
+```
+运行session执行模型推理，返回对应的error code，需要根据错误码来判断后续是否成功执行模型推理
+
+参数：
+- `session` 执行推理的Session对象
+
+返回：执行推理的[错误码](Interpreter.html#errorcode)
+
+### runSessionWithCallBack
+```cpp
+ErrorCode runSessionWithCallBack(const Session* session, const TensorCallBack& before, const TensorCallBack& end, bool sync = false) const;
+```
+该函数本质上与`runSession`一致，但是提供了用户hook函数的接口，在运行session做网络推理，每层推理前前后会执行的`before`和`end`并根据返回值来决定是否继续执行
+
+参数：
+- `session` 执行推理的Session对象
+- `before` 每层推理前执行的回调函数，类型为
+  ```cpp
+  std::function<bool(const std::vector<Tensor*>&, const std::string& /*opName*/)>
+  ```
+- `end` 每层推理后执行的回调函数，类型同上
+- `sync` 是否同步等待执行完成
+
+返回：执行推理的[错误码](Interpreter.html#errorcode)
+
+### runSessionWithCallBackInfo
+```cpp
+ErrorCode runSessionWithCallBackInfo(const Session* session, const TensorCallBackWithInfo& before,
+                                     const TensorCallBackWithInfo& end, bool sync = false) const;
+```
+该函数与`runSessionWithCallBack`相似，但是回调函数中增加了Op的类型和计算量信息，可以用来评估模型的计算量
+
+参数：
+- `session` 执行推理的Session对象
+- `before` 每层推理前执行的回调函数，类型为
+  ```cpp
+  std::function<bool(const std::vector<Tensor*>&, const OperatorInfo*)>
+  ```
+- `end` 每层推理后执行的回调函数，类型同上
+- `sync` 是否同步等待执行完成
+
+返回：执行推理的[错误码](Interpreter.html#errorcode)
+
+### getSessionInput
+```cpp
+Tensor* getSessionInput(const Session* session, const char* name);
+```
+根据`name`返回模型指定会话的输入tensor；如果没有指定tensor名称，则返回第一个输入tensor
+
+参数：
+- `session` 持有推理会话数据的Session对象
+- `name` Tensor的名称
+
+返回：输入Tensor对象
+
+### getSessionOutput
+```cpp
+Tensor* getSessionOutput(const Session* session, const char* name);
+```
+根据`name`返回模型指定会话的输出tensor；如果没有指定tensor名称，则返回第一个输出tensor
+
+参数：
+- `session` 持有推理会话数据的Session对象
+- `name` Tensor的名称
+
+返回：输出Tensor对象
+
+### getSessionInfo
+```cpp
+bool getSessionInfo(const Session* session, SessionInfoCode code, void* ptr);
+```
+根据指定类型获取`Session`的信息
+
+参数：
+- `session` 要获取信息的Session对象
+- `code` 获取的信息类型，使用[SessionInfoCode](Interpreter.html#sessioninfocode)
+- `ptr` 将信息存储在该指针中
+
+返回：是否支持获取`code`类型的信息
+
+### getSessionOutputAll
+```cpp
+const std::map<std::string, Tensor*>& getSessionOutputAll(const Session* session) const;
+```
+返回模型指定会话的所有的输出tensor
+
+参数：
+- `session` 持有推理会话数据的Session对象
+
+返回：所有的输出Tensor的名称和指针
+
+### getSessionInputAll
+```cpp
+const std::map<std::string, Tensor*>& getSessionInputAll(const Session* session) const;
+```
+返回模型指定会话的所有的输入tensor
+
+参数：
+- `session` 持有推理会话数据的Session对象
+
+返回：所有的输入Tensor的名称和指针
+
+### resizeTensor
+```cpp
+void resizeTensor(Tensor* tensor, const std::vector<int>& dims);
+```
+改变tensor形状，并重新分配内存
+
+参数：
+- `tensor` 需要改变形状的Tensor对象，一般为输入tensor
+- `dims` 新的形状
+- `batch,channel,height,width` 新的形状各维度
+
+返回：`void`
+
+### getBackend
+```cpp
+const Backend* getBackend(const Session* session, const Tensor* tensor) const;
+```
+获取指定`tensor`创建时使用的后端`Backend`；可以在代码中使用该函数来判断当前`Session`的推理实际使用什么后端。
+
+参数：
+- `session` tensor相关的会话
+- `tensor` 被创建的tensor
+
+返回：创建指定tensor的后端，可能为`nullptr`
+
+### bizCode
+```cpp
+const char* bizCode() const;
+```
+获取创建该解释器的模型中的`bizCode`
+
+参数：
+- `void`
+
+返回：模型中的`bizCode`
+
+### uuid
+```cpp
+const char* uuid() const;
+```
+获取创建该解释器的模型中的`uuid`
+
+参数：
+- `void`
+
+返回：模型中的`uuid`

docs/cpp/Module.md

@@ -0,0 +1,349 @@
+# Module
+```cpp
+class Module
+```
+
+## 成员函数
+### Tensor
+构造函数
+```cpp
+Module() == default;
+```
+创建一个空Module
+
+参数：无
+
+返回：Module对象
+
+### ~Module
+析构函数
+```cpp
+virtual ~Module() == default;
+```
+
+### onForward
+```cpp
+virtual std::vector<Express::VARP> onForward(const std::vector<Express::VARP>& inputs) = 0;
+```
+模块前向传播,返回多个结果变量
+
+参数：
+- `inputs` 前向传播输入变量
+
+返回：前向传播输出变量
+
+### forward
+```cpp
+Express::VARP forward(Express::VARP input);
+```
+模块前向传播,返回一个结果变量
+
+参数：
+- `input` 前向传播输入变量
+
+返回：前向传播输出变量
+
+### parameters
+```cpp
+std::vector<Express::VARP> parameters() const;
+```
+获取Module的参数
+
+参数：无
+
+返回：Module的参数
+
+### loadParameters
+```cpp
+bool loadParameters(const std::vector<Express::VARP>& parameters);
+```
+加载现有的参数
+
+参数：
+- `parameters` 参数值
+
+返回：是否成功加载参数
+
+### setIsTraining
+```cpp
+void setIsTraining(const bool isTraining);
+```
+设置Module的训练状态
+
+参数：
+- `isTraining` 是否为训练模式
+
+返回：`void`
+
+### getIsTraining
+```cpp
+bool getIsTraining();
+```
+获取_Module的是否为训练模式
+
+参数：无
+
+返回：Module是否为训练模式，是则返回true，不是返回false
+
+### clearCache
+```cpp
+void clearCache();
+```
+清除Module的缓存，并递归清除子模块的缓存
+
+参数：无
+
+返回：`void`
+
+### name
+```cpp
+const std::string& name() const {
+    return mName;
+};
+```
+获取Module的名称
+
+参数：无
+
+返回：Module的名称
+
+### setName
+```cpp
+void setName(std::string name) {
+    mName = std::move(name);
+};
+```
+设置Module的名称
+
+参数：
+- `name` 模块的名称
+
+返回：`void`
+
+### type
+```cpp
+const std::string type() const {
+    return mType;
+};
+```
+获取Module的类型
+
+参数：无
+
+返回：Module的类型
+
+### setType
+```cpp
+void setType(std::string type) {
+    mType = std::move(type);
+};
+```
+设置Module的类型
+
+参数：
+- `type` 模块的类型
+
+返回：`void`
+
+### addParameter
+```cpp
+int addParameter(Express::VARP parameter);
+```
+添加参数
+
+参数：
+- `parameter` 参数值
+
+返回：添加前的参数数量
+
+### setParameter
+```cpp
+void setParameter(Express::VARP parameter, int index);
+```
+设置参数
+
+参数：
+- `type` 参数值
+- `index` 参数的位置索引
+
+返回：`void`
+
+### createEmpty
+```cpp
+static Module* createEmpty(const std::vector<Express::VARP>& parameters);
+```
+根据参数创建一个空的Module对象
+
+参数：
+- `parameters` 参数值
+
+返回：创建的空的Module对象
+
+### load
+```cpp
+static Module* load(const std::vector<std::string>& inputs, const std::vector<std::string>& outputs, const uint8_t* buffer, size_t length, const Config* config = nullptr);
+```
+加载module对象
+
+参数：
+- `inputs` module输入信息
+- `outputs` module输出信息
+- `buffer` 缓冲信息
+- `length` 信息长度
+- `config` 其他配置项
+
+返回：module对象
+
+### load
+```cpp
+static Module* load(const std::vector<std::string>& inputs, const std::vector<std::string>& outputs, const char* fileName, const Config* config = nullptr);
+```
+加载module对象
+
+参数：
+- `inputs` module输入信息
+- `outputs` module输出信息
+- `fileName` 文件名
+- `config` 其他配置项
+
+返回：module对象
+
+### load
+```cpp
+static Module* load(const std::vector<std::string>& inputs, const std::vector<std::string>& outputs, const char* fileName, const std::shared_ptr<MNN::Express::Executor::RuntimeManager> rtMgr, const Config* config = nullptr);
+```
+加载module对象
+
+参数：
+- `inputs` module输入信息
+- `outputs` module输出信息
+- `fileName` 文件名
+- `rtMgr` 运行时资源
+- `config` 其他配置项
+
+返回：module对象
+
+### load
+```cpp
+static Module* load(const std::vector<std::string>& inputs, const std::vector<std::string>& outputs, const uint8_t* buffer, size_t length, const std::shared_ptr<MNN::Express::Executor::RuntimeManager> rtMgr, const Config* config = nullptr);
+```
+加载module对象
+
+参数：
+- `inputs` module输入信息
+- `outputs` module输出信息
+- `buffer` 缓冲信息
+- `length` 信息长度
+- `rtMgr` 运行时资源
+- `config` 其他配置项
+
+返回：module对象
+
+### load
+```cpp
+static Module* extract(std::vector<Express::VARP> inputs, std::vector<Express::VARP> outputs, bool fortrain, const std::map<std::string, SubGraph>& subGraph = {});
+```
+加载module对象
+
+参数：
+- `inputs` module输入信息
+- `outputs` module输出信息
+- `fortrain`
+- `subGraph` 子图
+
+返回：module对象
+
+### clone
+```cpp
+static Module* clone(const Module* module, const bool shareParams = false);
+```
+克隆Module对象
+
+参数：
+- `module` module对象实例
+- `shareParams` 是否共享参数，默认为false
+
+返回：Module对象实例
+
+### getInfo
+```cpp
+const Info* getInfo() const;
+```
+获取Module的信息
+
+参数：无
+
+返回：Module的信息
+
+### CloneContext
+```cpp
+CloneContext() = default;
+```
+克隆Module的内容
+
+参数：无
+
+返回：Module的内容
+
+### CloneContext
+```cpp
+explicit CloneContext(const bool shareParams)
+        : mShareParams(shareParams) {};
+```
+克隆Module的内容
+
+参数：
+- `shareParams` 是否共享参数
+
+返回：Module的内容
+
+### ~CloneContext
+析构函数
+```cpp
+virtual ~CloneContext() = default;
+```
+
+### shareParams
+```cpp
+const bool shareParams() const { return mShareParams; };
+```
+是否共享参数
+
+参数：无
+
+返回：共享返回true，反之则为false
+
+### clone
+```cpp
+virtual Module* clone(CloneContext* ctx) const {
+    return nullptr;
+};
+```
+克隆Module对象
+
+参数：
+- `ctx` 克隆的上下文
+
+返回：Module对象
+
+### registerModel
+```cpp
+void registerModel(const std::vector<std::shared_ptr<Module>>& children);
+```
+注册子模块
+
+参数：
+- `children` 子模块列表
+
+返回：`void`
+
+### destroy
+```cpp
+static void destroy(Module* m);
+```
+销毁Module对象
+
+参数：
+- `m` Module对象
+
+返回：`void`

docs/cpp/Optimizer.md

@@ -0,0 +1,138 @@
+# Optimizer
+```cpp
+class Optimizer
+```
+## 枚举类
+### Device
+```cpp
+enum Device {
+    CPU = 0,
+    GPU = 1,
+    OTHER = 2,
+    AUTO = 3
+};
+```
+
+| value | name |      说明         |
+|:------|:-----|:-----------------|
+| 0 | `CPU` | 中央处理器 |
+| 1 | `GPU` | 图像处理器 |
+| 2 | `OTHER` | 其他 |
+| 3 | `AUTO` | 自定义 |
+
+## 成员函数
+### Optimizer
+构造函数
+```cpp
+Optimizer() = default;
+```
+创建一个空Optimizer
+
+参数：无
+
+返回：Optimizer对象
+
+### ~Optimizer
+析构函数
+```cpp
+virtual ~Optimizer() = default;
+```
+创建一个空Optimizer
+
+参数：无
+
+返回：Optimizer对象
+
+### create
+```cpp
+static std::shared_ptr<Optimizer> create(Config config);
+```
+创建一个Optimizer对象
+
+参数：
+- `config` 配置信息，包括线程、Device和MNNForwardType等信息
+
+返回：Optimizer对象
+
+### onGetParameters
+```cpp
+virtual std::shared_ptr<Parameters> onGetParameters(const std::vector<VARP>& outputs) {
+    return nullptr;
+};
+```
+获取Optimizer对象的参数
+
+参数：
+- `outputs` Optimizer输出信息
+
+返回：Optimizer对象的参数
+
+### onMeasure
+```cpp
+virtual Cost onMeasure(const std::vector<VARP>& outputs, std::shared_ptr<Parameters> parameters = nullptr) = 0;
+```
+返回Cost对象信息，包括compute(计算)和memory(内存)信息，parameters必须与onGetParameters相同
+
+参数：
+- `outputs` Optimizer输出信息
+- `parameters` 与onGetParameters相同
+
+返回：Cost对象信息
+
+### onExecute
+```cpp
+virtual bool onExecute(const std::vector<VARP>& outputs, std::shared_ptr<Parameters> parameters = nullptr) = 0;
+```
+修改输出信息，parameters必须与onGetParameters相同
+
+参数：
+- `outputs` Optimizer输出信息
+- `parameters` 与onGetParameters相同
+
+返回：是否修改输出成功
+
+## Parameters
+```cpp
+class Parameters
+```
+## 成员函数
+
+### Parameters
+```cpp
+Parameters(int n);
+```
+创建一个Parameters对象
+
+参数：
+- `n` 成员个数
+
+返回：Parameters对象
+
+### ~Parameters
+析构函数
+
+### get
+```cpp
+float* get() const {
+    return mValue;
+};
+```
+获取Parameters对象成员数量
+
+参数：无
+
+返回：Parameters对象成员数量
+
+### size
+```cpp
+int size() const {
+    return mSize;
+};
+```
+获取Parameters对象大小
+
+参数：无
+
+返回：Parameters对象大小
+
+

docs/cpp/Tensor.md

@@ -0,0 +1,479 @@
+# Tensor
+```cpp
+class Tensor
+```
+
+## 枚举类
+### DimensionType
+用于创建张量的维度类型
+
+```cpp
+enum DimensionType {
+    TENSORFLOW,
+    CAFFE,
+    CAFFE_C4
+};
+```
+
+| value | name |      说明         |
+|:------|:-----|:-----------------|
+| 0 | `TENSORFLOW` | tensorflow网络类型，数据格式为NHWC |
+| 1 | `CAFFE` | caffe网络类型，数据格式为NCHW |
+| 2 | `CAFFE_C4` | caffe网络类型，数据格式为NC4HW4 |
+
+
+数据处理类型
+### HandleDataType
+```cpp
+enum HandleDataType {
+    HANDLE_NONE        = 0,
+    HANDLE_STRING      = 1
+};
+```
+
+| value | name |      说明         |
+|:------|:-----|:-----------------|
+| 0 | `HANDLE_NONE` | 默认处理类型  |
+| 1 | `HANDLE_STRING` | 字符串处理类型 |
+
+
+### MapType
+张量映射类型：读或写
+
+```cpp
+enum MapType {
+    MAP_TENSOR_WRITE   = 0,
+    MAP_TENSOR_READ    = 1
+};
+```
+
+| value | name |      说明         |
+|:------|:-----|:-----------------|
+| 0 | `MAP_TENSOR_WRITE` | 默认写类型 |
+| 1 | `MAP_TENSOR_READ` | 读类型 |
+
+## 成员函数
+
+### Tensor
+构造函数
+```cpp
+Tensor(int dimSize = 4, DimensionType type = CAFFE);
+```
+创建一个具有维度大小和类型的张量，而不需要为数据获取内存
+
+参数：
+- `dimSize` 尺寸大小，默认为4
+- `type` 张量的维度类型，默认为CAFFE
+
+返回：具有维度大小和类型的张量
+
+### Tensor
+构造函数
+```cpp
+Tensor(const Tensor* tensor, DimensionType type = CAFFE, bool allocMemory = true);
+```
+创建一个与给定张量形状相同的张量
+
+参数：
+- `tensor` 形状提供者
+- `type` 张量的维度类型，默认为CAFFE
+- `allocMemory` 是否为数据获取内存
+
+返回：给定张量形状相同的张量
+
+### ~Tensor
+析构函数
+
+### createDevice
+```cpp
+static Tensor* createDevice(const std::vector<int>& shape, halide_type_t type, DimensionType dimType = TENSORFLOW);
+```
+创建具有形状、数据类型和维度类型的张量，存储数据的内存不会被获取，调用后端的onAcquireBuffer来准备内存
+
+参数：
+- `shape` 张量的形状
+- `type` 数据类型
+- `dimType` 张量的维度类型，默认为TENSORFLOW
+
+返回：具有形状、数据类型和维度类型的张量
+
+### createDevice
+```cpp
+static Tensor* createDevice(const std::vector<int>& shape, DimensionType dimType = TENSORFLOW) {
+    return createDevice(shape, halide_type_of<T>(), dimType);
+};
+```
+创建具有形状和尺寸类型的张量，数据类型用“T”表示，存储数据的内存不会被获取，调用后端的onAcquireBuffer来准备内存
+
+参数：
+- `shape` 张量的形状
+- `dimType` 张量的维度类型，默认为TENSORFLOW
+
+返回：具有形状、数据类型和维度类型的张量
+
+### create
+```cpp
+static Tensor* create(const std::vector<int>& shape, halide_type_t type, void* data = NULL,
+                      DimensionType dimType = TENSORFLOW);
+```
+创建具有形状、数据类型、数据和维度类型的张量
+
+参数：
+- `shape` 张量的形状
+- `type` 数据类型
+- `data` 数据保存
+- `dimType` 张量的维度类型，默认为TENSORFLOW
+
+返回：具有形状、数据类型、数据和维度类型的张量
+
+### create
+```cpp
+static Tensor* create(const std::vector<int>& shape, void* data = NULL, DimensionType dimType = TENSORFLOW) {
+    return create(shape, halide_type_of<T>(), data, dimType);
+};
+```
+创建具有形状、数据和维度类型的张量，数据类型用‘T’表示
+
+参数：
+- `shape` 张量的形状
+- `data` 数据保存
+- `dimType` 张量的维度类型，默认为TENSORFLOW
+
+返回：具有形状、数据类型、数据和维度类型的张量
+
+### clone
+```cpp
+static Tensor* clone(const Tensor* src, bool deepCopy = false);
+```
+拷贝张量
+
+参数：
+- `src` 张量
+- `deepCopy` 是否创建新的内容和复制，目前只支持deepCopy = false
+
+返回：拷贝的张量
+
+### destroy
+```cpp
+static void destroy(Tensor* tensor);
+```
+释放张量
+
+参数：
+- `tensor` 需要释放的张量对象
+
+返回：`void`
+
+### copyFromHostTensor
+```cpp
+bool copyFromHostTensor(const Tensor* hostTensor);
+```
+对于DEVICE张量，从给定的HOST张量拷贝数据
+
+参数：
+- `hostTensor` HOST张量，数据提供者
+
+返回：DEVICE张量为真，HOST张量为假
+
+### copyToHostTensor
+```cpp
+bool copyToHostTensor(Tensor* hostTensor) const;
+```
+对于DEVICE张量，将数据复制到给定的HOST张量
+
+参数：
+- `hostTensor` HOST张量，数据消费者
+
+返回：DEVICE张量为真，HOST张量为假
+
+### createHostTensorFromDevice
+```cpp
+static Tensor* createHostTensorFromDevice(const Tensor* deviceTensor, bool copyData = true);
+```
+从DEVICE张量创建HOST张量，可以复制数据也可以不复制数据
+
+参数：
+- `deviceTensor` DEVICE张量
+- `copyData` 是否复制数据，默认为true
+
+返回：HOST张量
+
+### getDimensionType
+```cpp
+DimensionType getDimensionType() const;
+```
+获取维度类型
+
+参数：无
+
+返回：维度类型
+
+### getHandleDataType
+```cpp
+HandleDataType getHandleDataType() const;
+```
+处理数据类型，当数据类型代码为halide_type_handle时使用
+
+参数：无
+
+返回：处理数据类型
+
+### setType
+```cpp
+void setType(int type);
+```
+设置数据类型
+
+参数：
+- `type` 定义在“Type_generated.h”中的数据类型
+
+返回：`void`
+
+### getType
+```cpp
+inline halide_type_t getType() const {
+    return mBuffer.type;
+};
+```
+获取数据类型
+
+参数：无
+
+返回：数据类型
+
+### host
+```cpp
+template <typename T>
+T* host() const {
+    return (T*)mBuffer.host;
+};
+```
+访问Host内存，数据类型用“T”表示
+
+参数：无
+
+返回：“T”类型的数据点
+
+### deviceId
+```cpp
+uint64_t deviceId() const {
+    return mBuffer.device;
+};
+```
+访问设备内存
+
+参数：无
+
+返回：设备数据ID，ID的含义因后端而异
+
+### dimensions
+```cpp
+int dimensions() const {
+    return mBuffer.dimensions;
+};
+```
+张量维度
+
+参数：无
+
+返回：维度
+
+### shape
+```cpp
+std::vector<int> shape() const;
+```
+得到所有维度的范围
+
+参数：无
+
+返回：维度的程度
+
+### size
+```cpp
+int size() const;
+```
+考虑到重新排序标志，计算存储数据所需的字节数
+
+参数：无
+
+返回：存储数据所需的字节数
+
+### elementSize
+```cpp
+inline int elementSize() const {
+    return size() / mBuffer.type.bytes();
+};
+```
+考虑到重新排序标志，计算存储数据所需的元素数量
+
+参数：无
+
+返回：存储数据所需的元素数量
+
+### width
+```cpp
+inline int width() const {
+    if (getDimensionType() == TENSORFLOW) {
+        return mBuffer.dim[2].extent;
+    }
+    return mBuffer.dim[3].extent;
+};
+```
+张量宽度
+
+参数：无
+
+返回：张量宽度
+
+### height
+```cpp
+inline int height() const {
+    if (getDimensionType() == TENSORFLOW) {
+        return mBuffer.dim[1].extent;
+    }
+    return mBuffer.dim[2].extent;
+};
+```
+张量高度
+
+参数：无
+
+返回：张量高度
+
+### channel
+```cpp
+inline int channel() const {
+    if (getDimensionType() == TENSORFLOW) {
+        return mBuffer.dim[3].extent;
+    }
+    return mBuffer.dim[1].extent;
+};
+```
+张量通道
+
+参数：无
+
+返回：张量通道
+
+### batch
+```cpp
+inline int batch() const {
+    return mBuffer.dim[0].extent;
+};
+```
+张量批量
+
+参数：无
+
+返回：张量批量
+
+### stride
+```cpp
+inline int stride(int index) const {
+    return mBuffer.dim[index].stride;
+};
+```
+返回张量的步幅
+
+参数：
+- `index` 指定维度
+
+返回：张量的步幅
+
+### length
+```cpp
+inline int length(int index) const {
+    return mBuffer.dim[index].extent;
+};
+```
+返回张量的长度
+
+参数：
+- `index` 指定维度
+
+返回：张量的长度
+
+### setStride
+```cpp
+inline void setStride(int index, int stride) {
+    mBuffer.dim[index].stride = stride;
+};
+```
+设置张量的步幅
+
+参数：
+- `index` 指定维度
+- `stride` 步幅
+
+返回：`void`
+
+### setLength
+```cpp
+inline void setLength(int index, int length) {
+    mBuffer.dim[index].extent = length;
+};
+```
+设置张量的长度
+
+参数：
+- `index` 指定维度
+- `stride` 长度
+
+返回：`void`
+
+### print
+```cpp
+void print() const;
+```
+打印张量数据，仅供调试使用
+
+参数：无
+
+返回：`void`
+
+### printShape
+```cpp
+void printShape() const;
+```
+打印张量的形状
+
+参数：无
+
+返回：`void`
+
+### map
+```cpp
+void* map(MapType mtype, DimensionType dtype);
+```
+GPU张量，以获得主机ptr
+
+参数：
+- `mtype` 张量映射类型：读或写
+- `dtype` 张量类型
+
+返回：主机ptr
+
+### unmap
+```cpp
+void unmap(MapType mtype, DimensionType dtype, void* mapPtr);
+```
+GPU张量
+
+参数：
+- `mtype` 张量映射类型：读或写
+- `dtype` 张量类型
+- `mapPtr` 主机ptr
+
+返回：`void`
+
+### wait
+```cpp
+int wait(MapType mtype, bool finish);
+```
+等待直到张量准备好读/写
+
+参数：
+- `mtype` 等待读取或写入
+- `finish` 等待命令刷新或完成
+
+返回：读/写