模型管家接口（C++语言）

初始化接口，主要完成模型加载。

设置模型管理回调函数。

如果不调用此接口或调用此接口时listener设置为nullptr，表示Process接口为同步调用，否则为异步。

计算接口。单模型推理时，process的缓冲队列长度限制为2048。推理队列长度超过2048，将返回失败。

创建输出的Tensor列表。

如果用户使用该接口来创建tensor，该接口返回的内存首地址满足512对齐要求。建议用户使用AITensorFactory::CreateTensor接口来创建tensor，详见AITensorFactory::CreateTensor。

创建输入的Tensor列表。

如果用户使用该接口来创建tensor，该接口返回的内存首地址满足512对齐要求。建议用户使用AITensorFactory::CreateTensor接口来创建tensor，详见AITensorFactory::CreateTensor。

是否可以预分配输出内存。

相关函数：

AIStatus AIModelManager::CreateOutputTensor(const std::vector<std::shared_ptr<IAITensor>> &in_data, std::vector<std::shared_ptr<IAITensor>> &out_data);

获取已加载模型的输入输出尺寸。

input_tensor
{
name = "data"                 #输入层的name
data_type = 0                 #预留数据类型，暂时不用
size = 20                     #内存大小，单位字节
format = 0                    #预留Tensor排布格式，暂时不用
dims = {1,3,224,224}
}
output_tensor
{
name =  "output_0_prob_0"     #输出Tensor的name，格式为：output_{数字}_{输出节点name}_{输出节点输出索引}
data_type = 0                 #预留数据类型，暂时不用
size = 20                     #内存大小，单位字节
format = 0                    #预留Tensor排布格式，暂时不用
dims = {1,1000,1,1}
}

根据模型名字查询模型使用内存大小。

设置tensor数据地址。

创建模型tensor。该接口在ai_tensor.h中定义。

AIPP（AI Preprocessing）用于在AI Core上完成图像预处理，包括改变图像尺寸（Crop裁剪或Padding补边）、色域转换（转换图像格式）、减均值/乘系数（改变图像像素）。

对于动态AIPP，模型转换时仅设置AIPP模式为动态，每次模型推理前需要在推理Engine的代码中设置动态AIPP参数值，然后在模型推理时可使用不同的AIPP参数。在推理Engine的代码中设置动态AIPP参数值，就需要调用本章提供的AIPP配置相关接口，这部分接口在ai_tensor.h中定义。

/**
* @file mngr_sample.h
*
* Copyright(c)<2018>, <Huawei Technologies Co.,Ltd>
*
* @version 1.0
*
* @date 2018-4-25
*/
#include <stdio.h>
#include <string>
#include <vector>
#include <iostream>
#include <fstream>
#include <assert.h>
#include "hiaiengine/ai_model_manager.h"
using namespace std;
using namespace hiai;
// 图片数据路径
static const std::string IMAGE_FILE_PATH = "/data/input_zebra.bin";
static const char* MODEL_PATH = "/data/ResNet.davincimodel";
static const char* MODEL_NAME = "resnet18";
/*
*** brief：读取输入数据
*/
char* ReadBinFile(const char *file_name, uint32_t *fileSize)
{
    std::filebuf *pbuf;
    std::ifstream filestr;
    size_t size;
    filestr.open(file_name, std::ios::binary);
    if (!filestr)
    {
        return nullptr;
    }
    pbuf = filestr.rdbuf();
    size = pbuf->pubseekoff(0, std::ios::end, std::ios::in);
    pbuf->pubseekpos(0, std::ios::in);
    char * buffer = (char*)malloc(size);
    if (nullptr == buffer)
    {
        return nullptr;
    }
    pbuf->sgetn(buffer, size);
    *fileSize = size;
    filestr.close();
    return buffer;
}
int main(int argc, char* argv[])
{
    vector<shared_ptr<IAITensor>> model_input;
    vector<shared_ptr<IAITensor>> model_output;
    AIModelManager model_mngr;
    AIModelDescription model_desc;
    AIConfig config;
    AIContext context;
    model_desc.set_path(MODEL_PATH);
    model_desc.set_name(MODEL_NAME);
    model_desc.set_type(0);
    vector<AIModelDescription> model_descs;
    model_descs.push_back(model_desc);
    // AIModelManager Init
    AIStatus ret = model_mngr.Init(config, model_descs);
    if (SUCCESS != ret)
    {
        printf("AIModelManager Init failed. ret = %d\n", ret);
        return -1;
    }
    // 输入tensor
    // 输入tensor会在读取图片数据后重新设置，这里的作用只是初始化
    AITensorDescription tensor_desc = AINeuralNetworkBuffer::GetDescription();
    shared_ptr<IAITensor> input_tensor = AITensorFactory::GetInstance()->CreateTensor(tensor_desc);
    if (nullptr == input_tensor)
    {
        printf("Create input_tensor failed.\n");
        return -1;
    }
    // 读取图片数据
    uint32_t image_data_size = 0;
    float* image_data = (float*)ReadBinFile(IMAGE_FILE_PATH.c_str(), &image_data_size);
    if (nullptr == image_data)
    {
        printf("ReadBinFile failed bin file path= %s \n", IMAGE_FILE_PATH.c_str());
        return -1;
    }
    // 将图片数据地址指针及长度，设置给input_simple_tensor
    shared_ptr<AISimpleTensor> input_simple_tensor = static_pointer_cast<AISimpleTensor>(input_tensor);
    input_simple_tensor->SetBuffer((void*)image_data, image_data_size);
    model_input.push_back(input_tensor);
    // 创建输出tensor
    if(model_mngr.IsPreAllocateOutputMem())
    {
        ret = model_mngr.CreateOutputTensor(model_input, model_output);
        if (SUCCESS != ret)
        {
            printf("CreateOutputTensor failed.ret = %d\n", ret);
            delete image_data;
            return -1;
        }
    }
    else
    {
        // 用户创建tensor
        ret = model_mngr.GetModelIOTensorDim(MODEL_NAME, input_tensor_dims, output_tensor_dims);
        std::vector<TensorDimension> input_tensor_dims;
        std::vector<TensorDimension> output_tensor_dims;
        for(TensorDimension & dims : output_tensor_dims)
        {
            shared_ptr<IAITensor> output_tensor = AITensorFactory::GetInstance()->CreateTensor(tensor_desc);
            shared_ptr<AISimpleTensor> output_simple_tensor = static_pointer_cast<AISimpleTensor>(output_tensor);
            output_simple_tensor->setBuffer((void*) new char[dims.size], dims.size);
            model_output.push_back(output_tensor)
        }
    }

    bool dynamic_aipp_flag = true;
    if (dynamic_aipp_flag) 
    {
        const int batch_number = 2;
        AITensorDescription desc = AippDynamicParaTensor::GetDescription(std::to_string(batch_number));
        shared_ptr<IAITensor> tensor = AITensorFactory::GetInstance()->CreateTensor(desc);
        shared_ptr<AippDynamicParaTensor> aipp_params_tensor = static_pointer_cast<AippDynamicParaTensor>(tensor);
        //设置模型的原始输入的类型。
        aipp_params_tensor->SetInputFormat(hiai::YUV420SP_U8);
        //设置色域矩阵参数值
        aipp_params_tensor->SetCscParams(hiai::YUV420SP_U8, hiai::MODEL_BGR888_U8, hiai::JPEG);
        //设置原始图片的宽和高信息
        aipp_params_tensor->SetSrcImageSize(256, 224);
        //如果有多batch的情况下，为每个batch设置AIPP参数。
        for (int i = 0; i < batch_number; i++) {
            //设置抠图参数值
            aipp_params_tensor->SetCropParams(true, 0, 0, 200, 200, i);
            //设置Padding参数值
            aipp_params_tensor->SetPaddingParams(true, 12, 12, 12, 12, i);
            //设置DTC通道均值参数
            aipp_params_tensor->SetDtcPixelMean(104, 117, 123, 0, i);
            //设置DTC通道方差或（max-min）的倒数
            aipp_params_tensor->SetPixelVarReci(1.0, 1.0, 1.0, 1.0, i);
        }
		
	model_mngr.SetInputDynamicAIPP(model_input, aipp_params_tensor);
    }

    // 启动模型推理
    printf("Start process.\n");
    ret = model_mngr.Process(context, model_input, model_output, 0);
    if (SUCCESS != ret)
    {
        printf("Process failed.ret = %d\n", ret);
        return -1;
    }
    // 因未设置监听器，所以模型推理为同步调用，可直接取出模型推理输出数据
    shared_ptr<AISimpleTensor> result_tensor = static_pointer_cast<AISimpleTensor>(model_output[0]);
    printf("Get Result, buffsize is %d",result_tensor->GetSize());
    for(TensorDimension & dims : output_tensor_dims)
    {
    }
    printf("predict ok.\n");
    return 0;
}

AIConfig中配置项描述，详细实现参考ai_type.proto。

message AIConfigItem
{
    string name = 1;   // 配置项名称
    string value = 2;  // 配置项值
    repeated AIConfigItem sub_items = 3;  // 配置子项
};

调用模型管家Init接口时作为入参，详细实现参考ai_types.proto。

message AIConfig
{
    repeated AIConfigItem items = 1; // 配置项列表
};

tensor参数描述，详细实现参考ai_types.proto。

message AITensorParaDescription
{
    string name = 1;   // 参数名称
    string type = 2;   // 参数类型
    string value = 3;  // 参数值
    string desc = 4;   // 参数描述
    repeated AITensorParaDescription sub_paras = 5; // 子参数列表
};

tensor描述，主要用于描述模型的输入输出信息，详细实现参考ai_types.proto。

// Tensor描述
message AITensorDescription
{
    string name = 1;   // Tensor名称
    string type = 2;   // Tensor类型
    repeated string compatible_type = 3; // 指定可以兼容的所有父类类型
    repeated AITensorParaDescription paras = 4; // 参数列表
};

tensor描述列表，主要用于描述模型的输入输出信息列表，详细实现参考ai_types.proto。

message AITensorDescriptionList
{
    repeated AITensorDescription tensor_descs = 1; // tensor列表
}

调用Init接口时作为输入，用于描述模型，详细实现参考ai_types.proto。

messAIPPDynaage AIModelDescription
{
    string name = 1;  // 模型名称，支持大小写字母、数字、下划线和点(.)
    int32 type = 2;   // 模型类型，当前仅支持 DAVINCI_OFFLINE_MODEL类型，值为0
                      // 模型管家已新增模型解析能力，因此该字段不设置亦无碍，为了保持向前兼容，特此保留--2018/11/24
    string version = 3;  // 模型版本
    int32 size = 4;  // 模型大小
    string path = 5;  // 模型路径，支持大小写字母、数字、下划线
    repeated string sub_path = 6;  // 辅助模型路径，用于模型文件为多个的情况，比如caffe在线模型
                                  // 为了向前兼容，我们没有对path字段做修改（修改为repeated），而是新增了sub_path字段
    string key = 7;  // 模型秘钥
    repeated string sub_key = 8; // 辅助模型秘钥，用于模型秘钥为多个的情况，比如caffe在线模型
                                 // 为了向前兼容，我们没有对key字段做修改（修改为repeated），而是新增了sub_key字段
    enum Frequency   
    {
        UNSET   =0;   
        LOW     =1;   
        MEDIUM  =2;  
        HIGH    =3;   
    }
    Frequency frequency = 9;
    enum DeviceType  
    {
        NPU  = 0;   
        IPU  = 1;   
        MLU  = 2;   
        CPU  = 3;
        NONE = 255;
    }
    DeviceType device_type = 10;
    enum Framework  
    {
        OFFLINE    =0;
        CAFFE      =1;
        TENSORFLOW =2;
    }
    Framework framework = 11;
    bytes data = 100;  // 模型数据
    repeated AITensorDescription inputs = 12;  // 输入Tensor描述
    repeated AITensorDescription outputs = 13; // 输出Tensor描述
};

NN（neural network） Node描述，主要用于描述NN Node需要的模型、输入tensor、输出tensor等，详细实现参考ai_types.proto。

message AINNNodeDescription
{
    string name = 1;  // NNNode名称
    string desc = 2;  // NNNode描述
    bool isPreAllocateOutputMem = 3;  // 是否预分配输出内存
    AIConfig config = 4; // 配置参数
    repeated AIModelDescription model_list = 5; // nnnode需要的模型列表
    repeated AITensorDescription inputs = 6;   // 输入Tensor描述
    repeated AITensorDescription outputs = 7;  // 输出Tensor描述
    bool need_verify = 8; // 串联时是否需要校验Tensor匹配
    repeated string ignored_check_aitensor = 9; // 指定在串联时不与Inputs的Tensor做匹配校验的Tensor列表
};

NN（neural network） Node描述列表，主要用于描述NN Node需要的模型、输入tensor、输出tensor等，详细实现参考ai_types.proto。

message AINNNodeDescriptionList
{
    repeated AINNNodeDescription nnnode_descs = 1; // nnnode列表
}

API描述，主要用于描述API的名称、输入tensor、输出tensor等，详细实现请参考ai_types.proto。

message AIAPIDescription
{
    string name = 1;  // API名称
    string desc = 2;  // API描述
    bool isPreAllocateOutputMem = 3;  // 是否预分配输出内存
    AIConfig config = 4; // 配置参数
    repeated AITensorDescription inputs = 5;   // 输入Tensor描述
    repeated AITensorDescription outputs = 6;  // 输出Tensor描述
    bool need_verify = 7; // 串联时是否需要校验Tensor匹配
    repeated string ignored_check_aitensor = 8; // 指定在串联时不与Inputs的Tensor做匹配校验的Tensor列表
};

API描述列表，主要用于描述API的名称、输入tensor、输出tensor等，详细实现请参考ai_types.proto。

message AIAPIDescriptionList
{
    repeated AIAPIDescription api_descs = 1; // API列表
}

该类型在ai_types.proto中定义。

//AI Operation描述
message AIOPDescription
{
    enum OP_Type
    {
        AI_API = 0;
        AI_NNNODE = 1;
    }

    OP_Type type = 1;
    AINNNodeDescription nnnode_desc = 2;
    AIAPIDescription api_desc = 3;
};

该类型在ai_types.proto中定义。

//AI Operation描述列表
message AIOPDescriptionList
{
    repeated AIOPDescription op_descs = 1; //  AI Operation列表
}

该类型在ai_types.proto中定义。

message NodeDesc
{
   string name=1; // IAINNNode或ALG_API 名字
   AIConfig config=2;  //IAINNNode或ALG_API 需要的初始化参数
   repeated  AIModelDescription mode_desc=3; //IAINNNode 需要的初始化参数
}

该类型在ai_types.proto中定义。

message EngineDesc
{
    enum RunSide
    {
        DEVICE=0;
        HOST=1;
    }
    enum EngineType
    {
        NORMAL=0;
        SOURCE=1;
        DEST=2;
    }
    uint32 id =1;   //Engine ID (节点)
    EngineType type=2; 
    string name =3; //Engine 节点名字
    repeated string so_name=4; //需要的所有动态库so文件名列表
    RunSide side=5; //部署在Host侧还是Device侧
    int32 priority=6; //节点优先级
    uint32 instance_cnt=7; //实例个数（相当于线程个数）
    repeated uint32 next_node_id=8; //下一个节点列表
    bool user_input_cb=9;   //IDE 可以忽略
    bool user_output_cb=10; //IDE 可以忽略
    repeated NodeDesc oper=11; //HIAIEngine Node 列表
}

该类型在ai_types.proto中定义。

message GraphInitDesc
{
    int32 priority=1; //Graph 整个进程的优先级
}

该类型在ai_types.proto中定义。

message GeneralFileBuffer
{
    bytes raw_data = 1;
    string file_name = 2;
}

/*
    * 描述Tensor尺寸
    */
    struct TensorDimension
    {
        uint32_t n;  //批量大小Batch
        uint32_t c;  //特征图通道Channels
        uint32_t h;  //特征图高度Height
        uint32_t w;  //特征图宽度Width
        uint32_t data_type;
        uint32_t size;
        std::string  name;
    };

• 若执行模型转换时，未配置AIPP（AI Preprocessing，用于在AI Core上完成图像预处理）相关参数，则通过AIModelManager::GetModelIOTensorDim接口获取到的模型输入/输出尺寸的信息如下：
  • n、c、h、w就是转换前模型的n、c、h、w。
  • data_type枚举值的定义如下：

    enum DataType
    {
    DT_UNDEFINED = 0; // Used to indicate a DataType field has not been set.
    DT_FLOAT = 1; // float type，数据大小为4字节
    DT_FLOAT16 = 2; // fp16 type，数据大小为2字节
    DT_INT8 = 3; // int8 type，数据大小为1字节
    DT_UINT8 = 4; // uint8 type，数据大小为1字节
    DT_INT16 = 5; // int16 type，数据大小为2字节
    DT_UINT16 = 6; // uint16 type，数据大小为2字节
    DT_INT32 = 7; // int32 type，数据大小为4字节
    DT_INT64 = 8; // int64 type，数据大小为8字节
    DT_UINT32 = 9; // unsigned int32，数据大小为4字节
    DT_UINT64 = 10; // unsigned int64，数据大小为8字节
    DT_BOOL = 11; // bool type，数据大小为1字节
    DT_DOUBLE = 12; // double type，数据大小为8字节
    }

  • size=n*c*h*w*各类型数据的字节数
• 若执行模型转换时，配置AIPP相关参数，则通过AIModelManager::GetModelIOTensorDim接口获取到的模型输入/输出尺寸的信息如下：
  • n、c、h、w依然是转换前模型的n、c、h、w，并不是在AIPP处配置的h（对应src_image_size_h参数）、w（对应src_image_size_w参数）。
  • data_type值固定为3，表示DT_INT8类型。
  • size的值为AIPP处理后的图片数据的大小，不同输入格式对应的size不同，具体见表10-1。
    表10-1 size公式

    input_format	size
    YUV400_U8	n * src_image_size_w * src_image_size_h
    YUV420SP_U8	n * src_image_size_w * src_image_size_h * 1.5
    XRGB8888_U8	n * src_image_size_w * src_image_size_h * 4
    RGB888_U8	n * src_image_size_w * src_image_size_h * 3

关于模型转换或AIPP的说明，请参见《模型转换指导》。

异步调用Process时需要配置IAIListener，用于模型执行结束后，回调通知，具体实现如下。该类在ai_nn_node.h中定义。

/*
* 异步回调接口，由调用方实现
*/
class IAIListener
{
public:
    virtual ~IAIListener(){}
    /*
    * @brief 异步回调接口
    * @param [in] context 运行时上下文信息，包含nnnode运行时的一些可变参数配置
    * @param [in] result 执行结束时任务状态
    * @param [in] out_data 执行结束时的输出数据
    */
    virtual void OnProcessDone(const AIContext &context, int result,-
        const std::vector<std::shared_ptr<IAITensor>> &out_data) = 0;
    / *
      * @brief 服务死亡回调接口，当客户端到服务端挂死时，通知应用
      */
    virtual void OnServiceDied() {};
};

Porcess函数时使用IAITensor作为模型的输入输出。该类在ai_tensor.h中定义。

/**
* Tensor，用于表示输入输出的数据
*/
class IAITensor
{
public:
    IAITensor() {}
    virtual ~IAITensor() {};
    /*
     * @brief 通过AITensorDescription设置参数
     * @param [in] tensor_desc tensor描述
     * @return true: init成功
     * @return false: init失败，失败的可能原因比如tensor_desc与当前tensor不符
    */
    virtual bool Init(const AITensorDescription &tensor_desc) = 0;
   /*
    * @brief 获取类型名称
    */
    virtual const char* const GetTypeName() = 0;
    /*
    * @brief  获取序列化后字节长度
    */
    virtual uint32_t ByteSizeLong() = 0;
    virtual void SetBufferAttr(void *data, int32_t size, bool isowner, bool is_support_mem_share) = 0;

    virtual bool IsSupportZerocpy() = 0;

#if defined( __ANDROID__) || defined(ANDROID)
        /*
        * @brief 序列化到buffer，用于数据跨进程交互
        * @param [in] buffer 序列化输出的内存区域地址，由调用方分配
        * @param [in] size 输出内存区域的大小
        * @return SUCCESS: 成功
        *         FAILED: 失败，如果该Tensor不支持跨进程，则不需要实现此接口，直接返回失败
        */
        virtual AIStatus SerializeTo(void* buffer, const uint32_t size) = 0;

        /*
        * @brief 从buffer反序列化回tensor，用于数据跨进程交互
        * @param [in] buffer 输入的内存区域地址
        * @param [in] size 输入内存区域的大小
        * @return SUCCESS: 成功
        *         FAILED: 失败，如果该Tensor不支持跨进程，则不需要实现此接口，直接返回失败
        */
        virtual AIStatus DeserializeFrom(const void* buffer, const uint32_t size) = 0;
#endif
};

ALG的API注册工厂类。该类在ai_alg_api.h中定义。

    class AIAlgAPIFactory
    {
    public:
        static AIAlgAPIFactory* GetInstance();

        /*
        * @brief 获取API
        * @param [in] name api名称
        * @return API原型指针
        */
        AI_ALG_API GetAPI(const std::string &name);

        /*
        * @brief 注册API
        * @param [in] desc api描述
        * @param [in] func api定义
        * @return SUCCESS 成功
        * @return 其他    失败
        */
        AIStatus RegisterAPI(const AIAPIDescription &desc, AI_ALG_API func);

        /*
        * @brief 获取所有API描述
        * @param [in] api_desc_list api描述列表
        */
        void GetAllAPIDescription(AIAPIDescriptionList &api_desc_list);

        /*
        * @brief 卸载注册API
        * @param [in] api_desc api描述
        */
        AIStatus UnRegisterApi(const AIAPIDescription &api_desc);

        /*
        * @brief 获取API描述
        * @param [in] name api名称
        * @param [in] api_desc api描述
        * @return SUCCESS 成功
        * @return 其他    失败
        */
        AIStatus GetAPIDescription(const std::string &name, AIAPIDescription &api_desc);

    private:
        std::map<std::string, AI_ALG_API> func_map_;
        std::map<std::string, AIAPIDescription> desc_map_;
        std::mutex api_reg_lock_;
    };

对AIAlgAPIFactory工厂类的注册封装。该类在ai_alg_api.h中定义。

    class AIAlgAPIRegisterar
    {
    public:
        AIAlgAPIRegisterar(const AIAPIDescription &desc, AI_ALG_API func)
        {
            AIAlgAPIFactory::GetInstance()->RegisterAPI(desc, func);
            api_desc_ = desc;
        }

        ~AIAlgAPIRegisterar()
        {
            AIAlgAPIFactory::GetInstance()->UnRegisterApi(api_desc_);
        }
    private:
        AIAPIDescription api_desc_;
    };

API注册宏，在API实现中使用。该宏在ai_alg_api.h中定义。

#define REGISTER_ALG_API_UNIQUE(desc, ctr, func) \
    AIAlgAPIRegisterar g_##ctr##_api_registerar(desc, func)

对REGISTER_ALG_API_UNIQUE的封装宏。该宏在ai_alg_api.h中定义。

#define REGISTER_ALG_API(name, desc, func) \
    REGISTER_ALG_API_UNIQUE(desc, name, func)

模型管理类。该类在ai_model_manager.h中定义。

    class AIModelManager : public IAINNNode
    {
    public:
        AIModelManager();

       /*
        * @brief 设置动态batch接口，用户不需要调用该接口。
        * @param [in] inputDim 模型输入尺寸
        * @param [in] input 输入数据
        * @param [out] inputIndex 需要设置动态batch输入的序号, 从0开始
        * @param [in] batchNumber 动态batch数
        * @return SUCCESS 成功
        * @return 其他 失败
        */
        AIStatus SetInputDynamicBatch(const vector<TensorDimension>& inputDim, std::vector <std::shared_ptr <IAITensor> > &input,
            uint32_t inputIndex, uint32_t batchNumber);

       /*
        * @brief 是否可以预分配输出内存，该接口由业务NNNode实现，默认值为true.
        */
        virtual bool IsPreAllocateOutputMem() override;
        
       /*
        * @brief 获取AINNNodeDescription对象.
        */
        static AINNNodeDescription GetDescription();

        /*
        * @brief 获取已加载模型的输入输出尺寸
        * @param [in] model_name 模型名字
        * @param [out] input_tensor 模型输入尺寸
        * @param [out] output_tensor 模型输出尺寸
        * @return SUCCESS 成功
        * @return 其他 失败
        */
        AIStatus GetModelIOTensorDim(const std::string& model_name,
            std::vector<TensorDimension>& input_tensor, std::vector<TensorDimension>& output_tensor);

        /*
        * @brief 设置线程推理请求ID
        * @param [in] request_id 模型名字
        * @return 无
        */
        static void SetRequestId(uint64_t request_id);

        ~AIModelManager();

#ifdef __LITE__
        /*
        * @brief 闲置超时调用，释放资源。实现时调用的是UnloadModels。
        */
        virtual AIStatus IdleRelease();
        /*
        * @brief 超时后恢复，包含打开设备，加载模型等。实现时调用的是LoadModels。
        */
        virtual AIStatus IdleResume();
#endif // __LITE__

    private:
        AIModelManagerImpl* impl_;
    };

解析一个模型文件，获取模型信息。该接口在ai_model_parser.h中定义。

       /**
        * @ingroup hiai
        * @brief 解析一个模型文件,获取模型信息
        * @param [in] model_path 模型文件路径
        * @param [in] key 模型解密秘钥
        * @param [out] model_desc 模型信息
        * @return Status 运行结果
        */

        hiai::AIStatus getModelInfo(const std::string & model_path, 
            const std::string & key, AIModelDescription & model_desc);

NN Node接口，业务提供方实现。IAINNNode类在ai_nn_node.h中定义。

    class IAINNNode
    {
    public:
        virtual  ~IAINNNode(){}
        /*
        * @brief 初始化接口，业务在该接口中实现模型加载或其他初始化动作
        * @param [in] model_desc 模型信息，如果不需要模型，则传入空的vector
        * @param [in] config 配置参数
        * @return SUCCESS 成功
        * @return 其他    失败
        */
        virtual AIStatus Init(const AIConfig &config, 
            const std::vector<AIModelDescription> &model_descs = {}) = 0;

        /*
        * @brief 设置监听
        * @parm [in] 如果listener设置为nullptr，表示process接口为同步调用,否则为异步
        * @return SUCCESS 成功
        * @return 其他    失败
        */
        virtual AIStatus SetListener(std::shared_ptr<IAIListener> listener) = 0;

        /*
        * @brief 计算接口
        * @param [in] context 运行时上下文信息，包含nnnode运行时的一些可变参数配置
        * @param [in] in_data 输入数据
        * @param [out] out_data 输出数据
        * @param [in] timeout 超时时间，同步调用时无效
        * @return SUCCESS 成功
        * @return 其他    失败
        */
        virtual AIStatus Process(AIContext &context, 
            const std::vector<std::shared_ptr<IAITensor>> &in_data, 
            std::vector<std::shared_ptr<IAITensor>> &out_data, uint32_t timeout) = 0;

        /*
        * @brief 创建输出的Tensor列表
        * @param [in] in_data 输入tensor列表，计算输出时可能使用
        * @param [out] out_data 输出的tensor列表
        * @return SUCCESS 成功
        * @return 其他    失败
        */
        virtual AIStatus CreateOutputTensor(
            const std::vector<std::shared_ptr<IAITensor>> &in_data, 
            std::vector<std::shared_ptr<IAITensor>> &out_data) { (void)in_data;(void)out_data;return SUCCESS; }

        /*
        * @brief 是否可以预分配输出内存，该接口由业务NNNode实现，默认值为true.
        */
        virtual bool IsPreAllocateOutputMem() { return true; }

        /*
        * @brief 判断nnnode是否有效
        */
        virtual AIStatus IsValid() { return SUCCESS; }

        /*
        * @brief 查询node 支持的同步方式
        * @return BOTH    支持同步异步
        * @return ASYNC   仅支持异步
        * @return SYNC    仅支持同步
        */
        virtual AI_NODE_EXEC_MODE GetSupportedExecMode() { return AI_NODE_EXEC_MODE::BOTH; }

#ifdef __LITE__
        /*
        * @brief nnnode闲置超时，需要释放的资源，由用户自定义实现，适用于lite场景。如果使用了modelmanger，需要在实现该函数时调用相应modelmanager释放资源的方法IdleRelease
        */
        virtual AIStatus IdleRelease() { return SUCCESS; }
        /*
        * @brief nnnode超时后恢复，包含打开设备，加载模型等，由用户自定义实现，适用于lite场景。如果使用了modelmanger，需要在实现该函数时调用相应modelmanager的方法IdleResume
        */
        virtual AIStatus IdleResume() { return SUCCESS; }
        /*
        * @brief 设置最大闲置时间，如果超过该时间则自动销毁释放资源，未设置情况下，默认60s
        *        业务构造函数中调用
        *        在AIServiceBase中实现
        * @param [in] time 最大闲置时间，单位ms
        */
        virtual void SetMaxIdleTime(const int32_t time) { (void)time;}
#endif // __LITE__  
       
       /*
        * @brief 获取业务最大使用内存
        * @return 业务最大使用内存大小
        */
        virtual uint32_t GetMaxUsedMemory() { return 0; }
    };

支持业务引擎自注册，提供创建NN Node接口，提供已注册NN Node描述信息查询（按名称查询以及查询全部）。AINNNodeFactory类在ai_nn_node.h中定义。

    class AINNNodeFactory
    {
    public:
        static AINNNodeFactory* GetInstance();

        /*
        * @brief 根据nnnode name创建NNNode
        * @param [in] name nnnode名称
        * @return std::shared_ptr<IAINNNode> name对应的NNNode对象指针，如果返回nullptr，表示找不到对应的nnnode
        */
        std::shared_ptr<IAINNNode> CreateNNNode(const std::string &name);

        /*
        * @brief 获取所有已注册nnnode的描述信息
        * @param [out] nnnode_desc 所有已注册的nnnode描述信息
        * @return SUCCESS 成功
        * @return 其他    失败
        */
        void GetAllNNNodeDescription(AINNNodeDescriptionList &nnnode_desc);

        /*
        * @brief 根据nnnode name获取nnnode的描述信息
        * @param [in] name nnnode名称
        * @param [out] engin_desc nnnode描述信息
        * @return SUCCESS 成功
        * @return 其他    失败
        */
        AIStatus GetNNNodeDescription(const std::string &name, AINNNodeDescription &engin_desc);

        /*
        * @brief 注册NNNode创建函数
        * @param [in] nnnode_desc nnnode描述信息
        * @param [in] create_func nnnode创建函数
        * @return SUCCESS 成功
        * @return 其他    失败
        */
        AIStatus RegisterNNNodeCreator(const AINNNodeDescription &nnnode_desc, 
            AINNNODE_CREATE_FUN create_func);
        AIStatus RegisterNNNodeCreator(const string nnnode_str, 
            AINNNODE_CREATE_FUN create_func);

        /*
        * @brief 注销NNNode
        * @param [in] name nnnode名称
        * @return SUCCESS 成功
        */
        AIStatus UnRegisterNNNode(const AINNNodeDescription &nnnode_desc);
        AIStatus UnRegisterNNNode(const string nnnode_str);

    private:
        std::map<std::string, AINNNODE_CREATE_FUN> create_func_map_;
        std::map<std::string, AINNNodeDescription> nnnode_desc_map_;
        std::mutex  map_lock_;
    };

NN Node注册类。AINNNodeRegisterar类在ai_nn_node.h中定义。

    class AINNNodeRegisterar
    {
    public:
        AINNNodeRegisterar(const AINNNodeDescription &nnnode_desc, AINNNODE_CREATE_FUN create_func)
        {
            AINNNodeFactory::GetInstance()->RegisterNNNodeCreator(nnnode_desc, create_func);
            nnnode_desc_ = nnnode_desc;
            nnnode_str_.erase(nnnode_str_.begin(),nnnode_str_.end());
        }

        ~AINNNodeRegisterar(){
                AINNNodeFactory::GetInstance()->UnRegisterNNNode(nnnode_desc_);
        }
    private:
        AINNNodeDescription nnnode_desc_;
        string nnnode_str_;
    };

NN Node注册宏。

   /*
    * @brief NNNode 注册宏，业务NNNode在实现类中使用
    * 直接使用 REGISTER_ENGINE(desc, clazz)
    * @param [in] desc nnnode描述信息对象
    * @param [in] clazz nnnode类名
    */
#define REGISTER_NN_NODE(desc, name) \
    std::shared_ptr<IAINNNode> NNNode_##name##_Creator() \
    { \
        return std::make_shared<name>(); \
    } \
    AINNNodeRegisterar g_nnnode_##name##_creator(desc,NNNode_##name##_Creator)

获取Tensor字节大小。该接口在ai_tensor.h中定义。

extern uint32_t AITensorGetBytes(int32_t data_type);

Tensor工厂类，用来创建Tensor。AITensorFactory类在ai_tensor.h中定义。

    class AITensorFactory
    {
    public:
        static AITensorFactory* GetInstance();

        /*
        * @brief 通过参数创建Tensor，包含分配内存
        * @param [in] tensor_desc 包含Tensor参数的描述信息
        * @return shared_ptr<IAITensor> 创建完成的Tensor指针，如果创建失败，则返回nullptr
        */
        std::shared_ptr<IAITensor> CreateTensor(const AITensorDescription &tensor_desc);

        /*
        * @brief 通过type创建Tensor，不分配内存，非预分配情况下使用
        * @param [in] type Tensor注册时的类型
        * @return shared_ptr<IAITensor> 创建完成的Tensor指针，如果创建失败，则返回nullptr
        */
        std::shared_ptr<IAITensor> CreateTensor(const std::string &type);
     
       
#if defined( __ANDROID__) || defined(ANDROID)
        /*
        * @brief 通过参数、buffer创建Tensor，内容从buffer反序列化得到
        * @param [in] tensor_desc 包含Tensor参数的描述信息
        * @param [in] buffer 已存在的数据缓存
        * @param [in] size buffer的大小
        * @return shared_ptr<IAITensor> 创建完成的Tensor指针，如果创建失败，则返回nullptr
        */
        std::shared_ptr<IAITensor> CreateTensor(const AITensorDescription &tensor_desc,
            const void *buffer, const int32_t size);
#else
        std::shared_ptr<IAITensor> CreateTensor(const AITensorDescription &tensor_desc,
            void *buffer, int32_t size);
#endif
    
        /*
        * @brief 注册Tensor
        * @param [in] tensor_desc tensor描述
        * @param [in] create_func tensor创建函数
        */
        AIStatus RegisterTensor(const AITensorDescription &tensor_desc,
            CREATE_TENSOR_FUN create_func);
        AIStatus RegisterTensor(const string tensor_str, CREATE_TENSOR_FUN create_func)
        {
            // 加锁，防止多线程并发
            AITensorDescription tensor_desc;
            tensor_desc.set_type(tensor_str);
            return RegisterTensor(tensor_desc, create_func);
        }

       /*
        * @brief 卸载注册Tensor
        * @param [in] tensor_desc tensor描述
        */
        AIStatus UnRegisterTensor(const AITensorDescription &tensor_desc);
        AIStatus UnRegisterTensor(const string tensor_str)
        {
            AITensorDescription tensor_desc;
            tensor_desc.set_type(tensor_str);
            return UnRegisterTensor(tensor_desc);
        }

        /*
        * @brief 获取所有的Tensor列表
        * @param [out] tensor_desc_list 输出Tensor描述列表
        */
        void GetAllTensorDescription(AITensorDescriptionList &tensor_desc_list);

        /*
        * @brief 获取tensor描述
        */
        AIStatus GetTensorDescription(const std::string& tensor_type_name,
            AITensorDescription &tensor_desc);

    private:
        std::map<std::string, AITensorDescription> tensor_desc_map_;
        std::map<std::string, CREATE_TENSOR_FUN> create_func_map_;
        std::mutex tensor_reg_lock_;
    };

Tensor注册宏。该宏在ai_tensor.h中定义。

#define REGISTER_TENSOR_CREATER_UNIQUE(desc, name, func) \
    AITensorRegisterar g_##name##_tensor_registerar(desc, func)

对Tensor注册宏的封装宏。该宏在ai_tensor.h中定义。

#define REGISTER_TENSOR_CREATER(name, desc,func) \
        REGISTER_TENSOR_CREATER_UNIQUE(desc, name, func)

简单类型的数据Tensor。该类在ai_tensor.h中定义。

   class AISimpleTensor : public IAITensor
   {
    public:
        AISimpleTensor();

        ~AISimpleTensor();

        /*
        * @brief 获取类型名称
        */
        virtual const char* const GetTypeName() override;

       /*获取数据地址*/
        void* GetBuffer();

        /*
        @brief 设置数据地址
        @param [in] data 数据指针
        @param [in] size 大小
        @param [in] isown 是否在tensor生命周期结束后，由tensor释放data地址内存
        */
        void SetBuffer(void *data, const int32_t size, bool isown=false);

        /*
        @brief 获取数据占用空间大小
        */
        uint32_t GetSize();

        /*
        @brief 分配数据空间
        */
        void* MallocDataBuffer(uint32_t size);

        /*
        * @brief  获取序列化后字节长度
        */
        virtual uint32_t ByteSizeLong() override;

        /*
        * @brief 通过AITensorDescription设置参数
        * @param [in] tensor_desc tensor描述
        * @return true: init成功
        * @return false: init失败，失败的可能原因比如tensor_desc与当前tensor不符
        */
        virtual bool Init(const AITensorDescription &tensor_desc) override;

#if defined( __ANDROID__) || defined(ANDROID)
        /*
        * @brief 序列化到buffer，用于数据跨进程交互
        * @param [in] buffer 序列化输出的内存区域地址，由调用方分配
        * @param [in] size 输出内存区域的大小
        * @return SUCCESS: 成功
        *         FAILED: 失败，如果该Tensor不支持跨进程，则不需要实现此接口，直接返回失败
        */
        virtual AIStatus SerializeTo(void* buffer, const uint32_t size) override;

        /*
        * @brief 从buffer反序列化回tensor，用于数据跨进程交互
        * @param [in] buffer 输入的内存区域地址
        * @param [in] size 输入内存区域的大小
        * @return SUCCESS: 成功
        *         FAILED: 失败，如果该Tensor不支持跨进程，则不需要实现此接口，直接返回失败
        */
        virtual AIStatus DeserializeFrom(const void* buffer, const uint32_t size) override;
#endif

        /*
        @brief 构建tensor描述
        */
        static AITensorDescription BuildDescription(const std::string& size = "");

        /*
        @brief 根据描述创建tensor
        */
        static std::shared_ptr<IAITensor> CreateTensor(const AITensorDescription& tensor_desc);

        bool IsSupportZerocpy();
        /*
        @brief 设置数据地址
        @param [in] data 数据指针
        @param [in] size 大小
        @param [in] isown 是否在tensor生命周期结束后，由tensor释放data地址内存
        @param [in] is_data_support_mem_share_ 是否在tensor生命周期结束后，由tensor释放data地址内存
        */
        void SetBufferAttr(void *data, int32_t size, bool isowner, bool is_support_mem_share) override;

    private:
        void* data_;
        uint32_t size_;
        bool isowner_ ;

        static std::string type_name_;
    }

NN通用Buffer定义。该类在ai_tensor.h中定义。

    class AINeuralNetworkBuffer : public AISimpleTensor
    {
    public:
        AINeuralNetworkBuffer()
        {
            data_type_ = 0;
            number_    = 1;
            channel_   = 1;
            height_    = 1;
            width_     = 1;
            name_      = "";
        };
     
        ~AINeuralNetworkBuffer() {};
        /*
        * @brief 获取类型名称
        */
        const char* const GetTypeName();

        /*
        @brief 获取size字节大小
        */
        uint32_t ByteSizeLong();

        /*
        @brief 初始化
        @param [in] tensor_desc tensor描述
        */
        bool Init(const AITensorDescription &tensor_desc);
        
#if defined( __ANDROID__) || defined(ANDROID)
        /*
        * @brief 序列化到buffer，用于数据跨进程交互
        * @param [in] buffer 序列化输出的内存区域地址，由调用方分配
        * @param [in] size 输出内存区域的大小
        * @return SUCCESS: 成功
        *         FAILED: 失败，如果该Tensor不支持跨进程，则不需要实现此接口，直接返回失败
        */
        AIStatus SerializeTo(void* buffer, uint32_t size_);

        /*
        * @brief 从buffer反序列化回tensor，用于数据跨进程交互
        * @param [in] buffer 输入的内存区域地址
        * @param [in] size 输入内存区域的大小
        * @return SUCCESS: 成功
        *         FAILED: 失败，如果该Tensor不支持跨进程，则不需要实现此接口，直接返回失败
        */
        AIStatus DeserializeFrom(const void* buffer, uint32_t size_);
#endif
        /*
        * @brief 获取描述信息
        */
        static AITensorDescription GetDescription(
            const std::string &size = "0",const std::string &data_type="0",
            const std::string &number="0", const std::string &channel="0",
            const std::string &height="0", const std::string &width="0");

        /*
        @brief 创建tensor
        */
        static std::shared_ptr<IAITensor> CreateTensor(const AITensorDescription& tensor_desc);

        /*
        @brief 获取number数量
        */
        int32_t GetNumber();

        /*
        @brief 设置number
        */
        void SetNumber(int32_t number);

        /*
        @brief 获取channel数量
        */
        int32_t GetChannel();

        /*
        @brief 设置channel
        */
        void SetChannel(int32_t channel);

        /*
        @brief 获取height
        */
        int32_t GetHeight();

        /*
        @brief 设置height
        */
        void SetHeight(int32_t height);

        /*
        @brief 获取width
        */
        int32_t GetWidth();

        /*
        @brief 设置width
        */
        void SetWidth(int32_t width);

        /*
        @brief 获取数据类型
        */
        int32_t GetData_type();

        /*
        @brief 设置数据类型
        */
        void SetData_type(int32_t data_type);

        /*
        @brief 获取数据类型
        */
        const std::string& GetName() const;

        /*
        @brief 设置数据类型
        */
        void SetName(const std::string& value);

    private:
        int32_t data_type_;
        int32_t number_;
        int32_t channel_;
        int32_t height_;
        int32_t width_;
        std::string name_;
    };

图像的通用Buffer定义。该类在ai_tensor.h中定义。

    class AIImageBuffer : public AISimpleTensor
    {
    public:
        AIImageBuffer()
        {
            format_ = JPEG;
            width_  = 0;
            height_ = 0;
        };

        /*
        * @brief 获取类型名称
        */
        const char* const GetTypeName();

        /*
        @brief 获取size字节大小
        */
        uint32_t ByteSizeLong();

        /*
        @brief 初始化
        @param [in] tensor_desc tensor描述
        */
        bool Init(const AITensorDescription &tensor_desc);

#if defined( __ANDROID__) || defined(ANDROID)
        /*
        * @brief 序列化到buffer，用于数据跨进程交互
        * @param [in] buffer 序列化输出的内存区域地址，由调用方分配
        * @param [in] size 输出内存区域的大小
        * @return SUCCESS: 成功
        *         FAILED: 失败，如果该Tensor不支持跨进程，则不需要实现此接口，直接返回失败
        */
        AIStatus SerializeTo(void* buffer, uint32_t size_);

        /*
        * @brief 从buffer反序列化回tensor，用于数据跨进程交互
        * @param [in] buffer 输入的内存区域地址
        * @param [in] size 输入内存区域的大小
        * @return SUCCESS: 成功
        *         FAILED: 失败，如果该Tensor不支持跨进程，则不需要实现此接口，直接返回失败
        */
        AIStatus DeserializeFrom(const void* buffer, uint32_t size_);
#endif
        /*
        * @brief 获取描述信息
        */
        static AITensorDescription GetDescription(
            const std::string &size = "0",const std::string &height="0",
            const std::string &width="0", const std::string format="JPEG");

        /*
        @brief 创建tensor
        */
        static std::shared_ptr<IAITensor> CreateTensor(const AITensorDescription& tensor_desc);

        /*
        @brief 获取图像格式
        */
        ImageFormat GetFormat();
        /*
        @brief 设置图像格式
        */
        void SetFormat(ImageFormat format);

        /*
        @brief 获取height
        */
        int32_t GetHeight();

        /*
        @brief 设置height
        */
        void SetHeight(int32_t height);

        /*
        @brief 获取width
        */
        int32_t GetWidth();

        /*
        @brief 设置width
        */
        void SetWidth(int32_t width);
    private:
        ImageFormat format_;
        int32_t width_;
        int32_t height_;
    };

HiAI的日志类。该类在log.h中定义。

      class HIAILog {
      public:
        /**
        * @ingroup hiaiengine
        * @brief 获取HIAILog指针
        */
        HIAI_LIB_INTERNAL static HIAILog* GetInstance();

        /**
        * @ingroup hiaiengine
        * @brief : 是否初始化
        * @return : 是否初始化 true 是
        */
        HIAI_LIB_INTERNAL bool IsInit() { return isInitFlag; }

        /**
        * @ingroup hiaiengine
        * @brief 获取log输出级别
        * @return :log输出级别
        */
        HIAI_LIB_INTERNAL uint32_t HIAIGetCurLogLevel();

        /**
        * @ingroup hiaiengine
        * @brief 判断该条log是否需要输出
        * @param [in]errorCode:消息的错误码
        * @return 是否能被输出
        */
        HIAI_LIB_INTERNAL bool HIAILogOutputEnable(const uint32_t errorCode);

        /**
        * @ingroup hiaiengine
        * @brief log对应的级别名称
        * @param [in]logLevel:宏定义的log级别
        */
        HIAI_LIB_INTERNAL std::string HIAILevelName(const uint32_t logLevel);

        /**
        * @ingroup hiaiengine
        * @brief 输出log
        * @param [in]moudleID:enum定义的组件id,
        * @param [in]logLevel:宏定义的log级别,
        * @param [in]strLog:输出的日志内容
        */
        HIAI_LIB_INTERNAL void HIAISaveLog(const int32_t moudleID,
            const uint32_t logLevel, const char* strLog);
      protected:
        /**
        * @ingroup hiaiengine
        * @brief HIAILog构造函数
        */
        HIAI_LIB_INTERNAL HIAILog();
        HIAI_LIB_INTERNAL ~HIAILog() {}
      private:
        /**
        * @ingroup hiaiengine
        * @brief HIAILog初始化函数
        */
        HIAI_LIB_INTERNAL void Init();
        HIAI_LIB_INTERNAL HIAILog(const HIAILog&) = delete;
        HIAI_LIB_INTERNAL HIAILog(HIAILog&&) = delete;
        HIAI_LIB_INTERNAL HIAILog& operator=(const HIAILog&) = delete;
        HIAI_LIB_INTERNAL HIAILog& operator=(HIAILog&&) = delete;
      private:
        HIAI_LIB_INTERNAL static std::mutex mutexHandle;
        uint32_t outputLogLevel;
        std::map<uint32_t, std::string> levelName;
        std::map<std::string, uint32_t> levelNum;
        static bool isInitFlag;
    };

日志封装宏，对HIAI_ENGINE_LOG_IMPL宏进行封装。该宏在log.h中定义。

#define HIAI_ENGINE_LOG(...) \
    HIAI_ENGINE_LOG_IMPL(__FUNCTION__, __FILE__, __LINE__, ##__VA_ARGS__)