辅助接口

获取device个数。该接口在c_graph.h中定义。

uint32_t dev_count;
HIAI_GetDeviceNum(&dev_count);

获取第一个device的id。该接口在c_graph.h中定义。

uint32_t first_dev_id;
HIAI_GetFirstDeviceId(&first_dev_id);

获取GraphID。该接口在c_graph.h中定义。

uint32_t first_graph_id;
HIAI_GetFirstGraphId(&first_graph_id);

获取下一个device的id。该接口在c_graph.h中定义。

uint32_t cur_dev_id = 1;
uint32_t next_dev_id;
HIAI_GetNextDeviceId(cur_dev_id, &next_dev_id);

获取下一个GraphID。该接口在c_graph.h中定义。

uint32_t cur_graph_id = 1;
uint32_t next_graph_id;
HIAI_GetNextGraphId(cur_graph_id, &next_graph_id);

根据engineID查找Engine对象指针。该接口在graph.h中定义。

uint32_t engineID= 1000；
auto graphPtr = Graph::GetInstance(100);
auto enginePtr = graphPtr->GetEngine(engineID);

获取当前graph的id。该接口在graph.h中定义。

获取当前graph在device侧的id。该接口在graph.h中定义。

auto graphPtr = Graph::GetInstance(100);
auto deviceId = graphPtr->GetDeviceID();

获取Engine的GraphId。该接口在engine.h中定义。

uint32_t engineID= 1000；
auto graphPtr = Graph::GetInstance(100);
auto enginePtr = graphPtr->GetEngine(engineID);
auto graphID= enginePtr->GetGraphId();

获取Engine的Queue最大Size。该接口在engine.h中定义。

uint32_t engineID= 1000；
auto graphPtr = Graph::GetInstance(100);
auto enginePtr = graphPtr->GetEngine(engineID);
auto engineQueueSize = enginePtr->GetQueueMaxSize();

获取Engine的某端口号Queue的Size。该接口在engine.h中定义。

uint32_t engineID= 1000；
uint32_t portID = 0；
auto graphPtr = Graph::GetInstance(100);
auto enginePtr = graphPtr->GetEngine(engineID);
auto engineQueueSize = enginePtr->GetQueueCurrentSize(portID);

解析配置文件。Matrix解析配置文件，并将生成的Graph回写到list中，供用户使用。该接口在graph.h中定义。

获取PCIe（Peripheral Component Interconnect Express）的信息。该接口在c_graph.h中定义。

uint32_t devId= 1;
uint32_t bus;
uint32_t dev;
uint32_t func;
HIAI_GetPCIeInfo(devId, &bus, &dev, &func);

获取API版本信息。该接口在c_graph.h中定义。

HIAI_API_VERSION HIAI_GetAPIVersion();

获取OamConfig智能指针，用于获取oam配置信息，包括模型名称、是否打开Dump开关、需要Dump模型中哪些层的算子信息。该接口在engine.h文件中定义。

为用户自定义的数据结构类型提供自动化序列化和反序列化机制。该宏在data_type_reg.h中定义。

• 该接口需要在host和Device端同时注册。
• 因为cereal的限制， 结构体中应避免使用long double类型，为了保证跨平台（如Windows到Linux）运行， 结构体成员尽量使用可移植的类型，如 int32_t等;
• 因为cereal的限制， 结构体中需使用共享指针。

为用户自定义的模板的数据结构类型提供自动化序列化和反序列化机制。该宏在data_type_reg.h中定义。

该接口需要在host和Device端同时注册该类。

为用户自定义的数据类型提供自定义的序列化和反序列化机制。该宏在data_type_reg.h中定义。

即发送时将用户传输的结构体指针转化为结构体buffer和数据buffer，接受数据时，将从框架获取的结构体buffer和数据buffer反转为结构体。

使用场景：

用于从host侧到Device侧快速搬运数据，如果用户需要提升传输性能，必须使用该接口注册函数。

• 该接口用于从host侧到Device侧快速搬运数据使用。
• 如果用户想使用高性能传输接口，必须使用该注册函数注册序列化和反序列化函数。

在数据进行反序列化过程中，数据内存赋值给智能指针时，将本函数注册为删除器。该接口在graph.h中定义。

/***************************************************************************************
 *                      CopyRight (C) Hisilicon Co., Ltd.
 *
 *       Filename:  user_def_datatype.h
 *    Description:  User defined data type
 *
 *        Version:  1.0
 *        Created:  2018-01-08 10:15:18
 *         Author:  
 *
 *       Revision:  initial draft;
 **************************************************************************************/
#ifndef USE_DEF_DATA_TYPE_H_
#define USE_DEF_DATA_TYPE_H_

#ifdef __cplusplus
#include <vector>
#include <map>
#endif

// 用户自定义的数据类型 （C 语言风格）
typedef struct UseDefDataType
{
    int data1;
    float data2;
}UseDefDataTypeT;

#ifdef __cplusplus
// 用户自定义的数据类型 （带模板类型） 
template<typename T1, typename T2, typename T3>
class UseDefTemplateDataType
{
  public:
    std::vector<T1> data_vec_;
    std::map<T2, T3> data_map_;
};
#endif

#endif

/***************************************************************************************
 *                      CopyRight (C) Hisilicon Co., Ltd.
 *
 *       Filename:  use_def_data_type_reg.cpp
 *    Description:  User defined Data Type Register
 *
 *        Version:  1.0
 *        Created:  2018-01-08 10:15:18
 *         Author:  h00384043
 *
 *       Revision:  initial draft;
 **************************************************************************************/

#include "use_def_data_type.h"
#include "hiaiengine/data_type_reg.h"

// 用户自定义的数据类型必须先注册到Matrix，才能作为Engine之间的通信接口正常使用
template<class Archive>
void serialize(Archive& ar, UseDefDataTypeT& data)
{
    ar(data.data1, data.data2);
}

// 注册UseDefDataTypeT
HIAI_REGISTER_DATA_TYPE("UseDefDataTypeT", UseDefDataTypeT)


// 模板类型数据的注册
// 对于模板类型，对于所有需要使用的类型必须都注册
template<class Archive, typename T1, typename T2, typename T3>
void serialize(Archive& ar, UseDefTemplateDataType<T1, T2, T3>& data)
{
    ar(data.data_vec_, data.data_map_);
}

// 注册 UseDefTemplateDataType<int, float>
HIAI_REGISTER_TEMPLATE_DATA_TYPE("UseDefTemplateDataType_uint64_t_float_string", UseDefTemplateDataType, uint64_t, float, std::string);

//... 注册其他类型

// 注册 UseDefTemplateDataType<int, int>
HIAI_REGISTER_TEMPLATE_DATA_TYPE("UseDefTemplateDataType_uint64_t_uint64_t_uint64_t", UseDefTemplateDataType, uint64_t, uint64_t, uint64_t);

// 注册结构体的序列化和反序列化
typedef struct tagST_SC_IMAGE
{
    INT32  iWidth;                  // image width
    INT32  iHeight;                 // image height
    INT32  iWidthStep;              // Size of aligned image row in bytes
    INT32  iChannel;                // channels
    INT32  iDepth;                  // depth in bits
    UINT32 uiTimeStampH;
    UINT32 uiTimeStampL;
    UINT32 iSize;
    UINT64 uiID;
    EN_SC_IMAGE_TYPE eType;          // image type
    ST_SC_IMAGE_ROI *roi;            // Image ROI. If NULL, the whole image is selected
    UINT8*  pucImageData;            // Image data
    UINT64 uiPhyAddr;
}ST_SC_IMAGE;

std::shared_ptr<ST_SC_IMAGE> st_image = std::make_shared<ST_SC_IMAGE>();
st_image->iWidth = 1080;
st_image->iHeight = 1080;
st_image->iChannel = 1;
st_image->iWidthStep = 1080;
st_image->iSize = 1080*1080*3/2 ;
st_image->eType = SC_IMAGE_YUV420SP;
st_image->roi = (ST_SC_IMAGE_ROI*)malloc(sizeof(ST_SC_IMAGE_ROI));
st_image->pucImageData = nullptr;
uint8_t* align_buffer = nullptr;
HIAI_StatusT get_ret =  HIAIMemory::HIAI_DMalloc(st_image->iSize,(void*&)align_buffer,10000);
hiai::EnginePortID engine_id;
engine_id.graph_id = 1;
engine_id.engine_id = 1;
engine_id.port_id = 0;
HIAI_SendData(engine_id, "ST_SC_IMAGE", std::static_pointer_cast<void>(st_image),100000);

void GetStScImageSearPtr(void* inputPtr, std::string& ctrlStr, uint8_t*& dataPtr, uint32_t& dataLen)

{
    // 如果结构体内有除了image之外的多个指针， 则进行拼接
    ST_SC_IMAGE* st_image = (ST_SC_IMAGE*)inputPtr;

    ctrlStr = std::string((char*)inputPtr, sizeof(ST_SC_IMAGE));
    if(nullptr != st_image->roi)
    {
        std::string image_roi_str = std::string((char*)st_image->roi, sizeof(ST_SC_IMAGE_ROI));
        ctrlStr += image_roi_str;
    }

    dataPtr = (UINT8*)st_image->pucImageData;
    dataLen= st_image->iSize;
}

std::shared_ptr<void> GetStScImageDearPtr(const char* ctrlPtr, const uint32_t& ctrlLen, const uint8_t* dataPtr, const uint32_t& dataLen)
{
    ST_SC_IMAGE* st_sc_image = (ST_SC_IMAGE*)ctrlPtr;
    std::shared_ptr<hiai::BatchImagePara<uint8_t>> ImageInfo(new hiai::BatchImagePara<uint8_t>);
    hiai::ImageData<uint8_t> image_data;
    image_data.width = st_sc_image->iWidth;
    image_data.height = st_sc_image->iHeight;
    image_data.channel = st_sc_image->iChannel;
    image_data.width_step = st_sc_image->iWidthStep;
    if (st_sc_image->eType == SC_IMAGE_U8C3PLANAR)
    {
       image_data.size = st_sc_image->iWidth * st_sc_image->iHeight * 3;
       image_data.format = hiai::BGR888;
    }
    else if (SC_IMAGE_U8C3PACKAGE == st_sc_image->eType)
    {
       image_data.size = st_sc_image->iWidth * st_sc_image->iHeight * 3;
       image_data.format = hiai::BGR888;
    }
    else if (st_sc_image->eType == SC_IMAGE_YUV420SP)
    {
       image_data.size = st_sc_image->iSize;//st_sc_image->iWidth * st_sc_image->iHeight * 3 / 2;
       image_data.format = hiai::YUV420SP;
    }
    image_data.data.reset(dataPtr, hiai::Graph::ReleaseDataBuffer);
    ImageInfo->v_img.push_back(image_data);
    ImageInfo->b_info.frame_ID.push_back(0);
    ImageInfo->b_info.batch_size = ImageInfo->b_info.frame_ID.size();

    return std::static_pointer_cast<void>(ImageInfo);
}

HIAI_REGISTER_SERIALIZE_FUNC("ST_SC_IMAGE", ST_SC_IMAGE, GetStScImageSearPtr, GetStScImageDearPtr);

通过Matrix接口申请Host侧或Device侧的内存块，配合高效数据传输使用。该接口在c_graph.h中定义。

若要给Device端分配DVPP使用的内存，您需要参考HIAI_DVPP_DMalloc。

使用场景：

通过Matrix框架，将大数据从Host端搬运到Device端，该接口需要配合宏:HIAI_REGISTER_SERIALIZE_FUNC使用。

例如：需要将1080P或者4K图像发送到Device端，如果需要提升传输性能，则必须通过HIAI_REGISTER_SERIALIZE_FUNC注册结构体转换和反转函数，另外，大数据块内存则通过HIAI_DMalloc接口申请内存，使用该方式，传输性能将得到很大提升。

该接口主要用于Host与Device的搬运大数据的性能问题，如无性能要求或非传输场景，不建议使用本接口。

释放通过HiAI接口申请的内存。该接口在c_graph.h中定义。

使用场景：

当用户通过HIAI_DMalloc申请内存后并且没有调用SendData接口发送数据，必须通过该接口释放内存，如果已经调用SendData接口，则不需要调用该接口释放内存。

用于分配内存， 该接口主要用于分配内存给Device端的DVPP使用。该接口在c_graph.h中定义。调用该接口申请内存后，必须使用HIAI_DVPP_DFree接口释放内存。

// 使用HIAI_DVPP_DMalloc申请内存
uint32_t allocSize = 1000;
char* allocBuffer = (char*)HIAI_DVPP_DMalloc(allocSize);
if (allocBuffer == nullptr) {
    // 分配失败，进行异常处理
}

用于释放内存， 该接口主要用于释放HIAI_DVPP_DMalloc接口分配的内存。该接口在c_graph.h中定义。

通过Matrix接口申请Host侧或Device侧的内存块，配合高效数据传输使用。该接口在ai_memory.h中定义。

若要给Device端分配DVPP使用的内存，您需要参考HIAIMemory::HIAI_DVPP_DMalloc。

使用场景：

通过Matrix框架，将大数据从Host端搬运到Device端，该接口需要配合宏:HIAI_REGISTER_SERIALIZE_FUNC使用。

例如：需要将1080P或者4K图像发送到Device端，如果需要提升传输性能，则必须通过HIAI_REGISTER_SERIALIZE_FUNC注册结构体转换和反转函数，另外，大数据块内存则通过HIAI_DMalloc接口申请内存，使用该方式，传输性能将得到很大提升。

• 该接口主要用于Host与Device的搬运大数据的性能问题，不推荐当做普通的malloc使用。
• 出于性能考虑，该接口会预申请内存，实际占用内存大小与申请内存大小存在一定差异，该接口的运行时间也会存在波动。

释放通过HiAI接口申请的内存。该接口在ai_memory.h中定义。

使用场景：

当用户通过HIAIMemory::HIAI_DMalloc申请内存后并且没有调用SendData接口发送数据，必须通过该接口释放内存，如果已经调用SendData接口，则不需要调用该接口释放内存。

用户可调用该接口判断内存是否是由DMalloc申请。该接口在ai_memory.h中定义。

用于分配内存， 该接口主要用于分配内存给Device端的DVPP使用。该接口在ai_memory.h中定义。调用该接口申请内存后，必须使用HIAIMemory::HIAI_DVPP_DFree接口释放内存。

// 使用HIAI_DVPP_DMalloc申请内存
uint32_t allocSize = 1000;
char* allocBuffer  = nullptr;
HIAI_StatusT ret = hiai::HIAIMemory::HIAI_DVPP_DMalloc(allocSize, (void*&)allocBuffer);
if (ret != HIAI_OK || allocBuffer == nullptr) {
    // 分配失败，进行异常处理
}

用于释放内存， 该接口主要用于释放HIAIMemory::HIAI_DVPP_DMalloc接口分配的内存。该接口在ai_memory.h中定义。

通过HIAI_ENGINE_LOG来根据传入的参数调用不同的HIAI_ENGINE_LOG_IMPL函数。在调用格式化函数时，format中参数的类型与个数必须与实际参数类型一致。日志打印相关的接口在log.h中定义。

调用HIAI_ENGINE_LOG后，系统将日志记录日志文件中，日志文件在Host侧或开发者板的“/var”目录下。Device侧的日志被记录在文件名称以device-id开头的日志文件中，Host侧的日志被记录在文件名称以host-0开头的日志文件中。

MultiTypeQueue构造函数。

往指定队列插入数据。

读取指定队列头部数据（并不从队列中删除）

读取指定队列头部数据，并从队列中删除。

PopAllData读取所有队列头部数据。仅当所有队列头部都有数据时才读取成功，并删除队列头部数据。否则，返回失败但并不删除任何数据。

见调用示例。

用户调用RegisterEventHandle接口订阅感兴趣的事件，当前支持Host-Device断开连接事件，用户订阅该事件，当连接断开时，用户可接收到该事件，并在注册的回调函数中处理断开逻辑（如停掉主程序的等待）。该接口在graph.h中定义。

用户需要定义一个DataRecvInterface类的子类，初始化一个子类的对象，作为数据接收回调函数，传入Graph::SetDataRecvFunctor或Engine::SetDataRecvFunctor。同时，用户需要在子类中重载实现RecvData接口。该接口在data_recv_interface.h中定义。

该接口用于设置公钥，该公钥用于对Device侧Matrix要加载的*.so文件进行数字签名验证。需要在创建Graph之前调用该接口。该接口在graph.h中定义。

数字签名采用的算法为SHA256withRSA，本组件只提供数字签名的验证功能，加签的功能需要由用户自己基于该算法进行对需要的SO进行签名，签名文件在host的存放路径需要与SO在统一目录，并且签名文件的名称为SO名称+“.signature”，比如SO的名称为“libhosttodevice.so”，签名文件的名称应为“libhosttodevice.so.signature”。

如果不调用Graph::SetPublicKeyForSignatureEncryption接口或者调用Graph::SetPublicKeyForSignatureEncryption接口的返回值不是HIAI_OK，则Matrix无法设置公钥，Device侧不会启用签名校验机制，因此无法通过数字签名识别出可能被篡改的*.so文件。

std::string publicKey =
"-----BEGIN RSA PUBLIC KEY-----\n"
"MIIBCAKCAQEAt+kdmu8CdViw2xHlh/JWXOl/0AitDgYGd+9RadULGZmj0tt/UQLv\n"
"EYPZaXC8E0a9e97kqfg/ZHinu04XG5RhXv2J0kwkhuBAeCCllefvrQy5OBRqdLYq\n"
"EZe8wUO0adSMDsLbPL52b+NdO9/zX+MUzvsBzitWJbiH96s4xCiEERX87/uQfr6F\n"
"lHLtrNtooeF2VmxOm3n0yzh4kcSouLgb/O0+v0I+fnR+CTNG95IvzDNOYLWD6ZkL\n"
"c7JyIYFZA0CNx9SlPhqbrfjOV5XSG3g3CW0TopUDfHyhAgZt5vACMpeDDx+89tg2\n"
"RfT4M9DH/qKzkLlOURvsMShRMD6/PwzsPwIBAw==\n"
"-----END RSA PUBLIC KEY-----";
auto ret = Graph::SetPublicKeyForSignatureEncryption(publicKey);