评分并提供意见反馈 :
华为采用机器翻译与人工审校相结合的方式将此文档翻译成不同语言，希望能帮助您更容易理解此文档的内容。 请注意：即使是最好的机器翻译，其准确度也不及专业翻译人员的水平。 华为对于翻译的准确性不承担任何责任，并建议您参考英文文档（已提供链接）。
附录
后续版本会删除的接口
后续版本会删除的接口，用户无需调用，调用后无法保证后续兼容性。
低功耗接口（C++语言）
PowerState::SubscribePowerStateEvent
用户注册低功耗回调函数。该接口在power_state.h中定义。
函数格式
HIAI_StatusT SubscribePowerStateEvent(PowerStateNotifyCallbackT notifyCallback)
参数说明
参数 |
说明 |
取值范围 |
|---|---|---|
notifyCallback |
用户希望注册的回调函数。 |
- |
返回值
返回的部分错误码请参见“错误码示例”中的“错误码”列。
错误码示例
序号 |
错误码 |
错误码描述 |
|---|---|---|
1 |
HIAI_OK |
running ok |
2 |
HIAI_POWER_STATE_CALLBACK_ERROR |
App callback function is nullptr |
PowerState::UnsubscribePowerStateEvent
用户注销先前注册的低功耗回调函数。该接口在power_state.h中定义。
函数格式
HIAI_StatusT UnsubscribePowerStateEvent(PowerStateNotifyCallbackT notifyCallback)
参数说明
参数 |
说明 |
取值范围 |
|---|---|---|
notifyCallback |
用户希望注销的回调函数 |
- |
返回值
返回的部分错误码请参见“错误码示例”中的“错误码”列。
错误码示例
序号 |
错误码 |
错误码描述 |
|---|---|---|
1 |
HIAI_OK |
running ok |
2 |
HIAI_POWER_STATE_CALLBACK_ERROR |
App callback function is nullptr |
数据类型
枚举：PowerState::DEVICE_POWER_STATE
enum DEVICE_POWER_STATE {
DEVICE_POWER_STATE_S0 = 0, // 系统进入S0，设备可用，唤醒APP
DEVICE_POWER_STATE_SUSPEND, // 系统即将进入S3/S4，APP释放通道、内存等资源
DEVICE_POWER_STATE_D0, // NPU设备进入D0，设备可用，唤醒APP（matrix业务无需处理）
DEVICE_POWER_STATE_D3, // NPU设备即将进入D3，APP停止与device侧通信（matrix业务无需处理）
DEVICE_POWER_STATE_ENABLE, // NPU设备驱动安装/启用, NPU可用
DEVICE_POWER_STATE_DISABLE, // NPU设备驱动卸载/禁用, NPU不可用
DEVICE_POWER_STATE_MAX // 状态最大个数，并不代表实际状态
};
Matrix数据类型
Protobuffer数据类型
关于Protobuffer的使用，请参见https://developers.google.com/protocol-buffers/docs/reference/proto3-spec。
Matrix用到的数据类型Protobuffer格式：
ai_types.proto
syntax = "proto3";IAITensor
package hiai;
// Tensor参数描述
message AITensorParaDescription
{
string name = 1; // 参数名称
string type = 2; // 参数类型
string value = 3; // 参数值
string desc = 4; // 参数描述
repeated AITensorParaDescription sub_paras = 5; // 子参数列表
};
// Tensor描述
message AITensorDescription
{
string name = 1; // Tensor名称
string type = 2; // Tensor类型
repeated string compatible_type = 3; // 指定可以兼容的所有父类类型
repeated AITensorParaDescription paras = 4; // 参数列表
};
// Tensor描述列表
message AITensorDescriptionList
{
repeated AITensorDescription tensor_descs = 1; // tensor列表
}
// 通用配置项
// 如果存在sub_items，则当前节点为父节点，value值无效
message AIConfigItem
{
string name = 1; // 配置项名称
string value = 2; // 配置项值，此处配置模型文件所在的路径时，包含文件名（名称中只允许有数字、字母、下划线和点号），可以将参数值配置为单个模型文件的路径（如：./test_data/model/resnet18.om）；也可以将模型文件打包成tar包后，将参数值配置为tar包所在的路径（如：./test_data/model/resnet18.tar）。若存在多个AIConfigItem，在配置tar包路径时，不允许在同一个目录下同时存在名称相同但格式不同的文件，例如./test_data/model/test、./test_data/model/test.tar。创建Graph接口包含Graph::CreateGraph或HIAI_CreateGraph。
repeated AIConfigItem sub_items = 3; // 配置子项
};
// nnnode/api运行时配置参数
message AIConfig
{
repeated AIConfigItem items = 1; // 配置项列表
};
// 模型描述
message AIModelDescription
{
string name = 1; // 模型名称
int32 type = 2; // 模型类型，当前仅支持DAVINCI_OFFLINE_MODEL类型，值为0
string version = 3; // 模型版本
int32 size = 4; // 模型大小
string path = 5; // 模型路径
string key = 8; // 模型秘钥
bytes data = 100; // 模型数据
repeated AITensorDescription inputs = 6; // 输入Tensor描述
repeated AITensorDescription outputs = 7; // 输出Tensor描述
};
// NNNode描述
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列表
};
// NNNode描述列表
message AINNNodeDescriptionList
{
repeated AINNNodeDescription nnnode_descs = 1; // NNNode列表
}
// API描述
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描述列表
message AIAPIDescriptionList
{
repeated AIAPIDescription api_descs = 1; // API列表
}
// 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 Operation 描述列表
message AIOPDescriptionList
{
repeated AIOPDescription op_descs = 1; // AI Operation列表
}
// IDE传给Matrix的接口
message NodeDesc
{
string name=1; // IAINNNode或ALG_API 名字
AIConfig config=2; //IAINNNode或ALG_API 需要的初始化参数
repeated AIModelDescription mode_desc=3; //IAINNNode 需要的初始化参数
}
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; //Matrix Node 列表
}
message GraphInitDesc
{
int32 priority=1; //Graph 整个进程的优先级
//Runside side = 2; //当前假定Graph 配置在host侧，不可配置
}
message GeneralFileBuffer
{
bytes raw_data = 1;
string file_name = 2;
}
graph_config.proto
syntax = "proto3";
import "ai_types.proto";
package hiai;
message DumpDef
{
bytes model_name = 1; //模型名称
bytes is_dump_all = 2; //是否打开Dump开关，用于Dump模型中每层算子的信息
repeated bytes layer = 3; //需要Dump模型中哪些层的算子信息
}
message OAMConfigDef
{
repeated DumpDef dump_list = 1;
bytes dump_path = 2; //dump文件存放的路径
}
message EngineConfig
{
enum RunSide
{
DEVICE=0; //运行在DEVICE侧
HOST=1; //运行在host侧
}
uint32 id =1; //Engine ID (节点)
string engine_name =2; //Engine 节点名字
repeated string so_name=3; //需要拷贝的所有动态库so文件名列表，会先按照用户配置的顺序先进行加载，加载失败再按照其他的加载顺序进行尝试加载
RunSide side=4; //部署在host侧还是Device侧
uint32 thread_num = 5;//线程数量。多路解码时，则该参数值推荐设置为1，如果thread_num值大于1，则线程之间的解码无法保证顺序。
uint32 thread_priority = 6;//线程优先级
uint32 queue_size = 7;//队列大小
AIConfig ai_config = 8; //Aiconfig配置文件
repeated AIModelDescription ai_model = 9; //AIModelDescription
repeated string internal_so_name=10; //不需要拷贝的所有动态库so文件名列表
uint32 wait_inputdata_max_time = 12; //当前已经收到数据后等待下一个数据的最大超时时间，单位为毫秒
uint32 holdModelFileFlag = 13; //是否保留本engine的模型文件，0不保留（默认为0），非0保留
OAMConfigDef oam_config = 14; // OAM Config配置
bool is_repeat_timeout_flag = 15; //engine未收到数据是否重复做超时处理，0不重复，1重复。例如多路数据分析时，数据量较大的情况下，建议将该参数值设置为1，做重复超时处理。与wait_inputdata_max_time参数配合使用，如果is_repeat_timeout_flag设置为0，则通过wait_inputdata_max_time参数设置单次超时时长；如果is_repeat_timeout_flag设置为1，则通过wait_inputdata_max_time参数设置周期超时时长。
}
message ConnectConfig
{
uint32 src_engine_id=1; //发送端的EngineID
uint32 src_port_id = 2; //发送端的PortID
uint32 target_graph_id=3; //接收端的GraphID
uint32 target_engine_id=4; //接收端的PortID
uint32 target_port_id=5; //接收端的PortID
bool receive_memory_without_dvpp=6; //参数默认值为0，表示Deivce上运行的目标Engine的接收内存需要满足DVPP的内存要求；若将参数值配置为1，表示Device上运行的目标Engine的接收内存无限制。参数的生效场景及使用场景请参见“关于receive_memory_without_dvpp参数的说明”。
}
message GraphConfig
{
uint32 graph_id = 1; //GraphID
int32 priority = 2; //优先级
string device_id = 3;//设备id配置，例如"0"
repeated EngineConfig engines = 3; //所有的engine。多路解码时推荐配置多个Engine，一个Engine对应一个线程，如果一个Engine对应多个线程，解码时无法保证顺序。
repeated ConnectConfig connects = 4; //连接方式
}
message GraphConfigList
{
repeated GraphConfig graphs = 1; //单个Graph的配置参数
}
message ProfileConfig
{
string matrix_profiling = 1; //Matrix的性能统计开关，“on”为开
string ome_profiling = 2; //OME的性能统计开关，“on”为开
string cce_profiling =3; //CCE的性能统计开关，“on”为开
string runtime_profiling = 4; //RUNTIME的性能统计开关，“on”为开
string PROFILER_TARGET = 5; //透传Profiling的参数
string PROFILER_JOBCTX = 6;
string src_path = 7;
string dest_path = 8;
string runtime_config = 9;
string RTS_PATH = 10;
string profiler_jobctx_path = 11;
string profiler_target_path = 12;
}
message GraphUpdateConfig
{
GraphConfig updataGraphConfig = 1;
repeated uint32 del_engine_ids = 2;
repeated ConnectConfig del_connects = 3;
}
关于receive_memory_without_dvpp参数的说明：
- 生效场景：使用HIAI_DMalloc接口申请内存，同时使用HIAI_REGISTER_SERIALIZE_FUNC宏对自定义数据类型进行序列化/反序列化时，配置文件中的该参数才生效。
- 使用场景：
当前，在DVPP中：
- 对VPC、JPEGE、JPEGD、PNGD功能的输入内存有限制，保持receive_memory_without_dvpp参数的默认值（默认值为0），不用配置，内存满足DVPP的要求；
- 对VDEC、VENC功能的输入内存无限制，可将receive_memory_without_dvpp参数配置为1，使用普通内存，提高系统普通内存的使用率，减少“满足DVPP要求的内存”的占用；也可以不配置receive_memory_without_dvpp参数（默认值为0）。
- 配置方法有两种：
- 在Graph配置文件中，在connects属性下，将所有在Device上运行的目标Engine的receive_memory_without_dvpp参数配置为1。
- 在Graph配置文件中，将所有connects属性下的receive_memory_without_dvpp参数都配置为1，因为在Host上运行的目标Engine即使配置了该参数也无影响。
Matrix已经注册的数据结构
Matrix中传输的数据结构需要先进行注册，以下数据结构Matrix已经进行了注册，可直接使用。
namespace hiai {
// message name <<<<<<=================>>>>>>> message type
// name:"BatchInfo" type:BatchInfo
// name:"FrameInfo" type:FrameInfo
// name:"IMAGEFORMAT" type:IMAGEFORMAT
// name:"Angle" type:Angle
// name:"Point2D" type:Point2D
// name:"Point3D" type:Point3D
// name:"ROICube" type:ROICube
// name:"RLECode" type:RLECode
// name:"IDTreeNode" type:IDTreeNode
// name:"IDTreePara" type:IDTreePara
// name:"BatchIDTreePara" type:BatchIDTreePara
// name:"RetrievalResult" type:RetrievalResult
// name:"RetrievalResultTopN" type:RetrievalResultTopN
// name:"RetrievalResultPara" type:RetrievalResultPara
// name:"RawDataBuffer" type:RawDataBuffer
// name:"BatchRawDataBuffer" type:BatchRawDataBuffer
// name:"string" type:string
// name:"vector_uint8_t" type:vector<uint8_t>
// name:"vector_float" type:vector<float>
// name:"ImageData_uint8_t" type:ImageData<uint8_t>
// name:"ImageData_float" type:ImageData<float>
// name:"ImagePara_uint8_t" type:ImagePara<uint8_t>
// name:"ImagePara_float" type:ImagePara<float>
// name:"BatchImagePara_uint8_t" type:BatchImagePara<uint8_t>
// name:"BatchImagePara_float" type:BatchImagePara<float>
// name:"Line_uint8_t" type:Line<uint8_t>
// name:"Line_float" type:Line<float>
// name:"Rectangle_uint8_t" type:Rectangle<uint8_t>
// name:"Rectangle_float" type:Rectangle<float>
// name:"Polygon_uint8_t" type:Polygon<uint8_t>
// name:"Polygon_float" type:Polygon<float>
// name:"MaskMatrix_uint8_t" type:MaskMatrix<uint8_t>
// name:"MaskMatrix_float" type:MaskMatrix<float>
// name:"ObjectLocation_uint8_t_uint8_t" type:ObjectLocation<uint8_t, uint8_t>
// name:"ObjectLocation_float_float" type:ObjectLocation<float, uint8_t>
// name:"DetectedObjectPara_uint8_t_uint8_t" type:DetectedObjectPara<uint8_t, uint8_t>
// name:"DetectedObjectPara_float_float" type:DetectedObjectPara<float, float>
// name:"BatchDetectedObjectPara_uint8_t_uint8_t" type:BatchDetectedObjectPara<uint8_t,uint8_t>
// name:"BatchDetectedObjectPara_float_float" type:BatchDetectedObjectPara<float,float>
// name:"BatchDetectedObjectPara_Rectangle_Point2D_int32_t" type:BatchDetectedObjectPara<Rectangle<Point2D>, int32_t>
// name:"BatchDetectedObjectPara_Rectangle_Point2D_float" type:BatchDetectedObjectPara<Rectangle<Point2D>, float>
// name:"RegionImage_uint8_t" type:RegionImage<uint8_t>
// name:"RegionImage_float" type:RegionImage<float>
// name:"RegionImagePara_uint8_t" type:RegionImagePara<uint8_t>
// name:"RegionImagePara_float" type:RegionImagePara<float>
// name:"BatchRegionImagePara_uint8_t" type:BatchRegionImagePara<uint8_t>
// name:"BatchRegionImagePara_float" type:BatchRegionImagePara<float>
// name:"Attribute_uint8_t" type:Attribute<uint8_t>
// name:"Attribute_float" type:Attribute<float>
// name:"AttributeTopN_uint8_t" type:AttributeTopN<uint8_t>
// name:"AttributeTopN_float" type:AttributeTopN<float>
// name:"AttributeVec_uint8_t" type:AttributeVec<uint8_t>
// name:"AttributeVec_float" type:AttributeVec<float>
// name:"AttributeResultPara_uint8_t" type: AttributeVec<uint8_t>
// name:"AttributeResultPara_float" type:AttributeVec<float>
// name:"BatchAttributeResultPara_uint8_t" type:AttributeVec<uint8_t>
// name:"BatchAttributeResultPara_float" type:AttributeVec<float>
// name:"Feature_uint8_t" type:AttributeVec<uint8_t>
// name:"Feature_float" type:AttributeVec<float>
// name:"FeatureList_uint8_t" type:FeatureList<uint8_t>
// name:"FeatureList_float" type:FeatureList<float>
// name:"FeatureVec_uint8_t" type:FeatureVec<uint8_t>
// name:"FeatureVec_float" type:FeatureVec<float>
// name:"FeatureResultPara_uint8_t" type:FeatureResultPara<uint8_t>
// name:"FeatureResultPara_float" type:FeatureResultPara<float>
// name:"BatchFeatureResultPara_uint8_t" type:BatchFeatureResultPara<uint8_t>
// name:"BatchFeatureResultPara_float" type:BatchFeatureResultPara<float>
// name:"FeatureRecord_uint8_t" type:FeatureRecord<uint8_t>
// name:"FeatureRecord_float" type:FeatureRecord<float>
// name:"RetrievalSet_uint8_t_uint8_t" type:RetrievalSet<uint8_t, uint8_t>
// name:"RetrievalSet_float_float" type:RetrievalSet<float, float>
// name:"EvaluationResult_uint8_t" type:EvaluationResult<uint8_t>
// name:"EvaluationResult_float" type:EvaluationResult<float>
// name:"EvaluationResultVec_uint8_t" type:EvaluationResultVec<uint8_t>
// name:"EvaluationResultVec_float" type:EvaluationResultVec<float>
// name:"EvaluationResultPara_uint8_t" type:EvaluationResultPara<uint8_t>
// name:"EvaluationResultPara_float" type:EvaluationResultPara<float>
// name:"BatchEvaluationResultPara_uint8_t" type:BatchEvaluationResultPara<uint8_t>
// name:"BatchEvaluationResultPara_float" type:BatchEvaluationResultPara<float>
// name:"Classification_uint8_t" type:Classification<uint8_t>
// name:"Classification_float" type:Classification<float>
// name:"ClassificationTopN_uint8_t" type:ClassificationTopN<uint8_t>
// name:"ClassificationTopN_float" type:ClassificationTopN<float>
// name:"ClassificationVec_uint8_t" type:ClassificationVec<uint8_t>
// name:"ClassificationVec_float" type:ClassificationVec<float>
// name:"ClassificationResultPara_uint8_t" type:ClassificationResultPara<uint8_t>
// name:"ClassificationResultPara_float" type:ClassificationResultPara<float>
// name:"BatchClassificationResultPara_uint8_t" type:BatchClassificationResultPara<uint8_t>
// name:"BatchClassificationResultPara_float" type:BatchClassificationResultPara<float>
//////////////////////////////////////////////////////
/////////////// batch信息 ////////////////////
//////////////////////////////////////////////////////
struct BatchInfo {
bool is_first = false; // 是否为第一个batch
bool is_last = false; // 是否为最后一个batch
uint32_t batch_size = 0; // 当前batch的实际大小
uint32_t max_batch_size = 0; // batch预设大小（最大容量）
uint32_t batch_ID = 0; // 当前batch ID号
uint32_t channel_ID = 0; // 处理当前batch的通道ID号
uint32_t processor_stream_ID = 0; // 处理器计算流ID号
std::vector<uint32_t> frame_ID; // batch中图像帧ID号
std::vector<uint32_t> source_ID; // batch中图像源ID号
std::vector<uint64_t> timestamp; // batch中图像的时间戳
};
template<class Archive>
void serialize(Archive& ar, BatchInfo& data) {
ar(data.is_first, data.is_last, data.batch_size,
data.max_batch_size, data.batch_ID, data.channel_ID,
data.processor_stream_ID, data.frame_ID, data.source_ID,
data.timestamp);
}
//////////////////////////////////////////////////////
/////////////// frame信息 ////////////////////
//////////////////////////////////////////////////////
struct FrameInfo {
bool is_first = false; // 是否为第一个frame
bool is_last = false; // 是否为最后一个frame
uint32_t channel_ID = 0; // 处理当前frame的通道ID号
uint32_t processor_stream_ID = 0; // 处理器计算流ID号
uint32_t frame_ID = 0; // 图像帧ID号
uint32_t source_ID = 0; // 图像源ID号
uint64_t timestamp = 0; // 图像的时间戳
};
template<class Archive>
void serialize(Archive& ar, FrameInfo& data) {
ar(data.is_first, data.is_last, data.channel_ID,
data.processor_stream_ID, data.frame_ID, data.source_ID,
data.timestamp);
}
//////////////////////////////////////////////////////
////////////////// 1. image tensor ///////////////////
//////////////////////////////////////////////////////
// 图像格式
enum IMAGEFORMAT {
RGB565, // Red 15:11, Green 10:5, Blue 4:0
BGR565, // Blue 15:11, Green 10:5, Red 4:0
RGB888, // Red 24:16, Green 15:8, Blue 7:0
BGR888, // Blue 24:16, Green 15:8, Red 7:0
BGRA8888, // Blue 31:24, Green 23:16, Red 15:8, Alpha 7:0
ARGB8888, // Alpha 31:24, Red 23:16, Green 15:8, Blue 7:0
RGBX8888,
XRGB8888,
YUV420Planar, // I420
YVU420Planar, // YV12
YUV420SP, // NV12
YVU420SP, // NV21
YUV420Packed, // YUV420 Interleaved
YVU420Packed, // YVU420 Interleaved
YUV422Planar, // Three arrays Y,U,V.
YVU422Planar,
YUYVPacked, // 422 packed per payload in planar slices
YVYUPacked, // 422 packed
UYVYPacket, // 422 packed
VYUYPacket, // 422 packed
YUV422SP, // 422 packed
YVU422SP,
YUV444Interleaved, // Each pixel contains equal parts YUV
Y8,
Y16,
RAW
};
enum OBJECTTYPE {
OT_VEHICLE,
OT_HUMAN,
OT_NON_MOTOR,
OT_FACE,
OT_FACE_BODY,
OT_PLATE
};
template<class T> // T: uint8_t float
struct ImageData {
IMAGEFORMAT format; // 图像格式
uint32_t width = 0; // 图像宽
uint32_t height = 0; // 图像高
uint32_t channel = 0; // 图像通道数
uint32_t depth = 0; // 位深
uint32_t height_step = 0; // 对齐高度
uint32_t width_step = 0; // 对齐宽度
uint32_t size = 0; // 数据大小（Byte）
std::shared_ptr<T> data; // 数据指针
};
template<class Archive, class T>
void serialize(Archive& ar, ImageData<T>& data) {
ar(data.format, data.width, data.height, data.channel,
data.depth, data.height_step, data.width_step, data.size);
if (data.size > 0 && data.data.get() == nullptr) {
data.data.reset(new(std::nothrow) T[data.size]);
}
ar(cereal::binary_data(data.data.get(), data.size * sizeof(T)));
}
// 参数
template<class T>
struct ImagePara {
FrameInfo f_info; // frame信息
ImageData<T> img; // 图像
};
template<class Archive, class T>
void serialize(Archive& ar, ImagePara<T>& data) {
ar(data.f_info, data.img);
}
// 参数
template<class T>
struct BatchImagePara {
BatchInfo b_info; // batch信息
std::vector<ImageData<T> > v_img; // batch中的图像
};
template<class Archive, class T>
void serialize(Archive& ar, BatchImagePara<T>& data) {
ar(data.b_info, data.v_img);
}
// 角度
typedef struct {
float x;
float y;
float z;
}Angle;
template<class Archive>
void serialize(Archive& ar, Angle& data) {
ar(data.x, data.y, data.z);
}
// 2D点
struct Point2D {
int32_t x;
int32_t y;
};
template<class Archive>
void serialize(Archive& ar, Point2D& data) {
ar(data.x, data.y);
}
//////////////////////////////////////////////////////
/////////////// ROI信息 ////////////////////
//////////////////////////////////////////////////////
struct RoiPolygon {
uint32_t uiPtNum; //多边形顶点数
std::vector<Point2D> astPts; //多个检索结果（TopN）
};
template<class Archive>
void serialize(Archive &ar, RoiPolygon &data) {
ar(data.uiPtNum, data.astPts);
}
struct ArgsRoiPolygon {
RoiPolygon stRoiPolygon; // 配置项Roi
uint32_t iMinFace; // 最小人脸26*26
uint32_t iMaxFace; // 最大人脸300*300
uint32_t imgWidth; // 视频帧图像宽
uint32_t imgHeight; // 视频帧图像高
};
template<class Archive>
void serialize(Archive &ar, ArgsRoiPolygon &data) {
ar(data.stRoiPolygon, data.iMinFace, data.iMaxFace, data.imgWidth, data.imgHeight, data.iMinFace);
}
// 3D点
struct Point3D {
int32_t x;
int32_t y;
int32_t z;
};
template<class Archive>
void serialize(Archive& ar, Point3D& data) {
ar(data.x, data.y, data.z);
}
// 2D或3D空间上的线
template<class T> // T: Point2D Point3D
struct Line {
T start;
T end;
};
template<class Archive, class T>
void serialize(Archive& ar, Line<T>& data) {
ar(data.start, data.end);
}
// 2D或3D空间上的矩形平面
template<class T> // T: Point2D Point3D
struct Rectangle {
T anchor_lt;
T anchor_rb;
};
template<class Archive, class T>
void serialize(Archive& ar, Rectangle<T>& data) {
ar(data.anchor_lt, data.anchor_rb);
}
// 2D或3D空间上的多边形平面
template<class T> // T: Point2D Point3D
struct Polygon {
std::vector<T> anchors;
};
template<class Archive, class T>
void serialize(Archive& ar, Polygon<T>& data) {
ar(data.anchors);
}
// 立方体
struct ROICube {
Point3D anchor;
uint32_t length;
uint32_t width;
uint32_t height;
};
template<class Archive>
void serialize(Archive& ar, ROICube& data) {
ar(data.anchor, data.length, data.width, data.height);
}
// 掩膜矩阵
template<class T> // T: int32_t float etc.
struct MaskMatrix {
uint32_t cols;
uint32_t rows;
std::shared_ptr<T> data;
};
template<class Archive, class T>
void serialize(Archive& ar, MaskMatrix<T>& data) {
ar(data.cols, data.rows);
if (data.cols*data.rows > 0 && data.data.get() == nullptr) {
data.data.reset(new(std::nothrow) T[data.cols*data.rows]);
}
ar(cereal::binary_data(data.data.get(),
data.cols * data.rows * sizeof(T)));
}
// RLE编码
struct RLECode {
uint32_t len;
uint32_t cols;
uint32_t rows;
std::shared_ptr<uint32_t> data;
};
template<class Archive>
void serialize(Archive& ar, RLECode& data) {
ar(data.len, data.cols, data.rows);
if (data.len > 0 && data.data.get() == nullptr) {
data.data.reset(new(std::nothrow) uint32_t[data.len]);
}
ar(cereal::binary_data(data.data.get(),
data.len * sizeof(uint32_t)));
}
template<class T1, class T2> // T1: Point2D Rectangle RLECode etc.
struct ObjectLocation { // T2: int8_t float etc.
std::vector<uint32_t> v_obj_id;
std::vector<T1> range; // 目标范围描述
std::vector<Angle> angle; // 角度信息
std::vector<T2> confidence; // 置信度
std::vector<uint32_t> label; // 目标类型标签
};
template<class Archive, class T1, class T2>
void serialize(Archive& ar, ObjectLocation<T1, T2>& data) {
ar(data.v_obj_id, data.range, data.angle,
data.confidence, data.label);
}
// 参数
template<class T1, class T2>
struct DetectedObjectPara {
FrameInfo f_info; // frame信息
ObjectLocation<T1, T2> location; // 多个目标位置
};
template<class Archive, class T1, class T2>
void serialize(Archive& ar, DetectedObjectPara<T1, T2>& data) {
ar(data.f_info, data.location);
}
// 参数
template<class T1, class T2>
struct BatchDetectedObjectPara {
// batch信息
BatchInfo b_info;
// 对应每帧图像的多个目标位置
std::vector<ObjectLocation<T1, T2> > v_location;
};
template<class Archive, class T1, class T2>
void serialize(Archive& ar, BatchDetectedObjectPara<T1, T2>& data) {
ar(data.b_info, data.v_location);
}
///////////////////////////////////////////////////////
/////////////// 3. region image tensor ////////////////
///////////////////////////////////////////////////////
template<class T>
struct RegionImage {
std::vector<ImageData<T> > region;
std::vector<uint32_t> v_obj_id;
};
template<class Archive, class T>
void serialize(Archive& ar, RegionImage<T>& data) {
ar(data.v_obj_id, data.region);
}
// 参数
template<class T>
struct RegionImagePara {
FrameInfo f_info; // frame信息
RegionImage<T> region; // 每帧对应的小图
};
template<class Archive, class T>
void serialize(Archive& ar, RegionImagePara<T>& data) {
ar(data.f_info, data.region);
}
// 参数
template<class T>
struct BatchRegionImagePara {
// batch信息
BatchInfo b_info;
// 每帧图像若干region image，用一个指向Image数组的指针来引用
std::vector<RegionImage<T>> v_region;
};
template<class Archive, class T>
void serialize(Archive& ar, BatchRegionImagePara<T>& data) {
ar(data.b_info, data.v_region);
}
// 递归ID树节点
struct IDTreeNode {
std::vector<uint32_t> nodeID; // 节点上的ID值
std::vector<bool> is_leaf; // 是否为叶子节点
std::vector<IDTreeNode> node; // 子节点结构指针
};
template <class Archive>
void serialize(Archive& ar, IDTreeNode& data) {
ar(data.nodeID, data.is_leaf, data.node);
}
// 参数
struct IDTreePara {
FrameInfo f_info; // frame信息
IDTreeNode tree; // 图像中的ID Tree
};
template <class Archive>
void serialize(Archive& ar, IDTreePara& data) {
ar(data.f_info, data.tree);
}
// 参数
struct BatchIDTreePara {
BatchInfo b_info; // batch信息
std::vector<IDTreeNode> v_tree; // 每帧图像中的ID Tree
};
template <class Archive>
void serialize(Archive& ar, BatchIDTreePara& data) {
ar(data.b_info, data.v_tree);
}
template<class T>
struct Attribute {
std::string attr_value;
T score;
};
template <class Archive, class T>
void serialize(Archive& ar, Attribute<T>& data) {
ar(data.attr_value, data.score);
}
template<class T>
struct AttributeTopN {
uint32_t obj_ID;
std::map<std::string, std::vector<Attribute<T>> > attr_map;
};
template <class Archive, class T>
void serialize(Archive& ar, AttributeTopN<T>& data) {
ar(data.obj_ID, data.attr_map);
}
template<class T>
struct AttributeVec {
std::vector<AttributeTopN<T>> obj_attr;
};
template <class Archive, class T>
void serialize(Archive& ar, AttributeVec<T>& data) {
ar(data.obj_attr);
}
// ²ÎÊý
template<class T>
struct AttributeResultPara {
FrameInfo f_info;
AttributeVec<T> attr;
};
template <class Archive, class T>
void serialize(Archive& ar, AttributeResultPara<T>& data) {
ar(data.f_info, data.attr);
}
// ²ÎÊý
template<class T>
struct BatchAttributeResultPara {
BatchInfo b_info;
std::vector<AttributeVec<T>> v_attr;
};
template <class Archive, class T>
void serialize(Archive& ar, BatchAttributeResultPara<T>& data) {
ar(data.b_info, data.v_attr);
}
template<class T>
struct Feature {
int32_t len; // 特征向量长度
std::shared_ptr<T> feature; // 特征向量指针
};
template<class Archive, class T>
void serialize(Archive& ar, Feature<T>& data) {
ar(data.len);
if (data.len > 0 && data.feature.get() == nullptr) {
data.feature.reset(new(std::nothrow) T[data.len]);
}
ar(cereal::binary_data(data.feature.get(), data.len * sizeof(T)));
}
template<class T>
struct FeatureList {
uint32_t obj_ID; // 目标ID
std::vector<Feature<T>> feature_list; // 目标的多个特征
};
template<class Archive, class T>
void serialize(Archive& ar, FeatureList<T>& data) {
ar(data.obj_ID, data.feature_list);
}
template<class T>
struct FeatureVec {
std::vector<FeatureList<T>> obj_feature; // 多个目标的属性
};
template<class Archive, class T>
void serialize(Archive& ar, FeatureVec<T>& data) {
ar(data.obj_feature);
}
// 参数
template<class T>
struct FeatureResultPara {
FrameInfo f_info; // frame信息
FeatureVec<T> feature; // 图像的多个目标的特征
};
template<class Archive, class T>
void serialize(Archive& ar, FeatureResultPara<T>& data) {
ar(data.f_info, data.feature);
}
// 参数
template<class T>
struct BatchFeatureResultPara {
// batch信息
BatchInfo b_info;
// 对应每帧图像的多个目标的特征
std::vector<FeatureVec<T>> v_feature;
};
template<class Archive, class T>
void serialize(Archive& ar, BatchFeatureResultPara<T>& data) {
ar(data.b_info, data.v_feature);
}
template<class T>
struct FeatureRecord {
uint32_t ID; // 特征图ID
uint32_t len; // 特征向量长度
std::shared_ptr<T> feature; // 特征向量指针
};
template<class Archive, class T>
void serialize(Archive& ar, FeatureRecord<T>& data) {
ar(data.ID, data.len);
if (data.len > 0 && data.feature.get() == nullptr) {
data.feature.reset(new(std::nothrow) T[data.len]);
}
ar(cereal::binary_data(data.feature.get(), data.len * sizeof(T)));
}
template<class T1, class T2>
struct RetrievalSet {
uint32_t TopN; // TopN结果设置
T1 threshold; // 相似度阈值
std::vector<FeatureRecord<T2>> record; // 特征集合中所有的记录
};
template<class Archive, class T1, class T2>
void serialize(Archive& ar, RetrievalSet<T1, T2>& data) {
ar(data.TopN, data.threshold, data.record);
}
// 参数
template<class T1, class T2>
struct RetrievalSetPara {
RetrievalSet<T1, T2> set; // 参数和特征集合
};
template<class Archive, class T1, class T2>
void serialize(Archive& ar, RetrievalSetPara<T1, T2>& data) {
ar(data.set);
}
struct RetrievalResult {
uint32_t ID; // 特征图ID
float similarity; // 相似度
};
template<class Archive>
void serialize(Archive& ar, RetrievalResult& data) {
ar(data.ID, data.similarity);
}
struct RetrievalResultTopN {
std::vector<RetrievalResult> result_list; // 多个检索结果（TopN）
};
template<class Archive>
void serialize(Archive& ar, RetrievalResultTopN& data) {
ar(data.result_list);
}
// 参数
struct RetrievalResultPara {
FrameInfo f_info; // frame信息
RetrievalResultTopN result; // 检索结果
};
template<class Archive>
void serialize(Archive& ar, RetrievalResultPara& data) {
ar(data.f_info, data.result);
}
// 参数
struct BatchRetrievalResultPara {
// batch信息
BatchInfo b_info;
// 对应每帧图像的检索结果
std::vector<RetrievalResultTopN> v_result;
};
template<class Archive>
void serialize(Archive& ar, BatchRetrievalResultPara& data) {
ar(data.b_info, data.v_result);
}
template<class T>
struct EvaluationResult {
uint32_t obj_ID; // 目标ID
std::string description; // 描述
T score; // 评价分数
};
template <class Archive, class T>
void serialize(Archive& ar, EvaluationResult<T>& data) {
ar(data.obj_ID, data.description, data.score);
}
template<class T>
struct EvaluationResultVec {
std::vector<EvaluationResult<T>> result; // 多个目标的评价结果
};
template <class Archive, class T>
void serialize(Archive& ar, EvaluationResultVec<T>& data) {
ar(data.result);
}
// 参数
template<class T>
struct EvaluationResultPara {
FrameInfo f_info; // frame信息
EvaluationResultVec<T> result; // 评价结果
};
template <class Archive, class T>
void serialize(Archive& ar, EvaluationResultPara<T>& data) {
ar(data.f_info, data.result);
}
// 参数
template<class T>
struct BatchEvaluationResultPara {
// batch信息
BatchInfo b_info;
// 对应每帧图像的评价结果
std::vector<EvaluationResultVec<T>> v_result;
};
template <class Archive, class T>
void serialize(Archive& ar, BatchEvaluationResultPara<T>& data) {
ar(data.b_info, data.v_result);
}
template<class T>
struct Classification {
std::string class_value; // 类别取值
T score; // 置信度
};
template<class Archive, class T>
void serialize(Archive& ar, Classification<T>& data) {
ar(data.class_value, data.score);
}
template<class T>
struct ClassificationTopN {
uint32_t obj_ID; // 目标ID
std::vector<Classification<T>> class_result; // 分类结果（TopN）
};
template<class Archive, class T>
void serialize(Archive& ar, ClassificationTopN<T>& data) {
ar(data.obj_ID, data.class_result);
}
template<class T>
struct ClassificationVec {
std::vector<ClassificationTopN<T>> class_list; // 多个目标的分类
};
template<class Archive, class T>
void serialize(Archive& ar, ClassificationVec<T>& data) {
ar(data.class_list);
}
// 参数
template<class T>
struct ClassificationResultPara {
FrameInfo f_info; // frame信息
ClassificationVec<T> classification; // 多个目标的分类
};
template<class Archive, class T>
void serialize(Archive& ar, ClassificationResultPara<T>& data) {
ar(data.f_info, data.classification);
}
// 参数
template<class T>
struct BatchClassificationResultPara {
// batch信息
BatchInfo b_info;
// 对应每帧图像的多个目标的分类
std::vector<ClassificationVec<T>> v_class;
};
template<class Archive, class T>
void serialize(Archive& ar, BatchClassificationResultPara<T>& data) {
ar(data.b_info, data.v_class);
}
struct RawDataBuffer {
uint32_t len_of_byte; // size length
std::shared_ptr<uint8_t> data; // 一块buffer，可转为用户自定义类型
};
template<class Archive>
void serialize(Archive& ar, RawDataBuffer& data) {
ar(data.len_of_byte);
if (data.len_of_byte > 0 && data.data.get() == nullptr) {
data.data.reset(new(std::nothrow) uint8_t[data.len_of_byte]);
}
ar(cereal::binary_data(data.data.get(), data.len_of_byte *
sizeof(uint8_t)));
}
// common raw databuffer struct
struct BatchRawDataBuffer {
BatchInfo b_info; // batch info
std::vector<RawDataBuffer> v_info;
};
template<class Archive>
void serialize(Archive& ar, BatchRawDataBuffer& data) {
ar(data.b_info, data.v_info);
}
template<typename T> const char* TypeName(void);
#define REGISTER_TYPE_DEFINITION(type) \
template<> inline const char* TypeName<type>(void) { return #type; }
REGISTER_TYPE_DEFINITION(int8_t);
REGISTER_TYPE_DEFINITION(uint8_t);
REGISTER_TYPE_DEFINITION(int16_t);
REGISTER_TYPE_DEFINITION(uint16_t);
REGISTER_TYPE_DEFINITION(int32_t);
REGISTER_TYPE_DEFINITION(uint32_t);
REGISTER_TYPE_DEFINITION(int64_t);
REGISTER_TYPE_DEFINITION(uint64_t);
REGISTER_TYPE_DEFINITION(float);
REGISTER_TYPE_DEFINITION(double);
REGISTER_TYPE_DEFINITION(Point2D);
REGISTER_TYPE_DEFINITION(Point3D);
REGISTER_TYPE_DEFINITION(Line<Point2D>);
REGISTER_TYPE_DEFINITION(Line<Point3D>);
REGISTER_TYPE_DEFINITION(Rectangle<Point2D>);
REGISTER_TYPE_DEFINITION(Rectangle<Point3D>);
REGISTER_TYPE_DEFINITION(Polygon<Point2D>);
REGISTER_TYPE_DEFINITION(Polygon<Point3D>);
REGISTER_TYPE_DEFINITION(ROICube);
REGISTER_TYPE_DEFINITION(MaskMatrix<int8_t>);
REGISTER_TYPE_DEFINITION(MaskMatrix<int32_t>);
REGISTER_TYPE_DEFINITION(MaskMatrix<float>);
REGISTER_TYPE_DEFINITION(RLECode);
REGISTER_TYPE_DEFINITION(RoiPolygon);
REGISTER_TYPE_DEFINITION(ArgsRoiPolygon);
}
示例
编排配置示例
Graph创建配置文件（graph.prototxt）为proto格式，其示例如下（该示例同时创建两个Graph，每个Graph创建多个Engine并配置映射关系）。
如果用户想要传送文件，必须满足下列条件，否则系统会默认传递的是字符串或数字：
- Linux环境下，文件要包含相对路径或者绝对路径，例如：“/home/1.txt”或者“../test/2.txt”。注意如果字符串中使用了"\"或"/"符号可能会被误判为文件，请避免使用。
- Windows环境下，文件要包含相对路径或者绝对路径，例如：“c:\1.txt”，或者“..\test\2.txt”。注意如果字符串中使用了\"或"/"符号可能会被误判为文件，请避免使用
graphs {
graph_id: 100
device_id: "0"
priority: 1
engines {
id: 1000
engine_name: "SrcEngine"
side: HOST
thread_num: 1
}
engines {
id: 1001
engine_name: "HelloWorldEngine"
so_name: "./libhelloworld.so"
side: DEVICE
thread_num: 1
}
engines {
id: 1002
engine_name: "DestEngine"
side: HOST
thread_num: 1
}
connects {
src_engine_id: 1000
src_port_id: 0
target_engine_id: 1001
target_port_id: 0
}
connects {
src_engine_id: 1001
src_port_id: 0
target_engine_id: 1002
target_port_id: 0
}
}
graphs {
graph_id: 200
device_id: "1"
priority: 1
engines {
id: 1000
engine_name: "SrcEngine"
side: HOST
thread_num: 1
}
engines {
id: 1001
engine_name: "HelloWorldEngine"
internal_so_name: "/lib64/libhelloworld.so"
side: DEVICE
thread_num: 1
}
engines {
id: 1002
engine_name: "DestEngine"
side: HOST
thread_num: 1
}
connects {
src_engine_id: 1000
src_port_id: 0
target_engine_id: 1001
target_port_id: 0
}
connects {
src_engine_id: 1001
src_port_id: 0
target_engine_id: 1002
target_port_id: 0
}
}
性能优化传输示例
(1)使用性能优化方案传输数据，必须对要传输的数据进行手动序列化和反序列化：
// 注：序列化函数在发送端使用，反序列化在接收端使用，所以这个注册函数最好在接收端和发送端都注册一遍；
结构体
typedef struct
{
uint32_t frameId;
uint8_t bufferId;
uint8_t* image_data;
uint8_t image_size;
}TEST_STR;
// 序列化TEST_STR结构体，该函数只需要调动注册函数进行注册，参数说明：
// 输入：inputPtr，TEST_STR结构体指针
// 输出：ctrlStr，控制信息地址
imageData，数据信息指针
imageLen，数据信息大小
void GetTestStrSearPtr(void* inputPtr, std::string& ctrlStr, uint8_t*& imageData, uint32_t& imageLen)
{
// 获取结构体buffer
TEST_STR* test_str = (TEST_STR*)inputPtr;
ctrlStr = std::string((char*)inputPtr, sizeof(TEST_STR));
// 获取数据信息，直接将结构体的数据指针赋值传递
imageData = (uint8_t*)test_str->image_data;
imageLen = test_str->image_size;
}
// 反序列化结构体，回传回来的将是结构体buffer和数据块buffer
// 输入：ctrlPtr，控制信息地址
ctrlLen，控制信息大小
imageData，数据信息指针
imageLen，数据信息大小
// 输出：std::shared_ptr<void>，指向结构体的智能指针
std::shared_ptr<void> GetTestStrDearPtr(const char* ctrlPtr, const uint32_t& ctrlLen,const uint8_t* imageData, const uint32_t& imageLen)
{
// 获取结构体
TEST_STR* test_str = (TEST_STR*)ctrlPtr;
// 获取传输过来的大内存数据
// 注：大内存数据最好赋值给智能指针，并注册删除器，如果不是使用智能指针或者没有注册删除器，则需要在释放该内存时手动调用hiai::Graph::ReleaseDataBuffer(void* ptr);
std::shared_ptr<TEST_STR<uint8_t>> shared_data = std::make_shared<TEST_STR<uint8_t>>();
shared_data->frameId = test_str->frame_ID;
shared_data->bufferId= test_str->bufferId;
shared_data->image_size = imageLen;
shared_data->image_data.reset(imageData, hiai::Graph::ReleaseDataBuffer);
// 返回智能指针给到Device端Engine使用
return std::static_pointer_cast<void>(shared_data);
}
// 注册序列化反序列化函数
HIAI_REGISTER_SERIALIZE_FUNC("TEST_STR", TEST_STR, GetTestStrSearPtr, GetTestStrDearPtr);
(2) 在发送数据时，需要使用注册的数据类型，另外配合使用HIAI_DMalloc分配数据内存，可以使性能更优
注：在从host侧向Device侧搬运数据时，使用HIAI_DMalloc方式将很大的提供传输效率，建议优先使用HIAI_DMalloc，该内存接口目前支持0 – (256M Bytes - 96 Bytes)的数据大小，如果数据超出该范围，则需要使用malloc接口进行分配；
// 使用Dmalloc接口申请数据内存，10000为时延，为10000毫秒，表示如果内存不足，等待10000毫秒；
HIAI_StatusT get_ret = HIAIMemory::HIAI_DMalloc(width*align_height*3/2,(void*&)align_buffer, 10000);
// 发送数据，调用该接口后无需调用HIAI_Dfree接口，10000为时延
graph->SendData(engine_id_0, "TEST_STR", std::static_pointer_cast<void>(align_buffer), 10000);
