leon/ss928_framework
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
446c6cd638
ss928_framework/svp/common/sample_common_svp_npu_model.c
Your Name 9e9bb7036c first commit
2024-12-16 13:31:45 +08:00

1130 lines
47 KiB
C
Executable File
Raw Blame History

/*
Copyright (c), 2001-2022, Shenshu Tech. Co., Ltd.
*/
#include "sample_common_svp_npu_model.h"
#include <limits.h>
#include "svp_acl_rt.h"
#include "svp_acl_ext.h"
#include "libapi_common_svp.h"
static struct_svp_npu_model_info g_svp_npu_model[MACRO_SVP_NPU_MAX_MODEL_NUM] = {0};
static td_s32 sample_svp_npu_get_model_base_info(td_u32 model_index)
{
svp_acl_error ret;
g_svp_npu_model[model_index].input_num = svp_acl_mdl_get_num_inputs(g_svp_npu_model[model_index].model_desc);
macro_svp_check_exps_return(g_svp_npu_model[model_index].input_num < MACRO_SVP_NPU_EXTRA_INPUT_NUM + 1,
TD_FAILURE, ENUM_SVP_ERR_LEVEL_ERROR, "get input num failed!\n");
g_svp_npu_model[model_index].output_num = svp_acl_mdl_get_num_outputs(g_svp_npu_model[model_index].model_desc);
macro_svp_check_exps_return(g_svp_npu_model[model_index].output_num < 1,
TD_FAILURE, ENUM_SVP_ERR_LEVEL_ERROR, "get output num failed!\n");
ret = svp_acl_mdl_get_input_index_by_name(g_svp_npu_model[model_index].model_desc,
SVP_ACL_DYNAMIC_TENSOR_NAME, &g_svp_npu_model[model_index].dynamic_batch_idx);
macro_svp_check_exps_return(ret != SVP_ACL_SUCCESS, TD_FAILURE, ENUM_SVP_ERR_LEVEL_ERROR,
"get dynamic batch idx failed, model id is %u, error code is %d!\n", model_index, ret);
return TD_SUCCESS;
}
static td_s32 sample_svp_npu_get_line_num_and_line_byte_num(const struct_svp_npu_task_info *task, td_u32 idx,
td_bool is_input, td_u32 *total_line_num, td_u32 *line_byte_num)
{
td_s32 ret;
td_u32 i;
svp_acl_mdl_io_dims dims;
svp_acl_data_type data_type;
size_t data_size;
if (is_input == TD_TRUE) {
ret = svp_acl_mdl_get_input_dims(g_svp_npu_model[task->cfg.model_idx].model_desc, idx, &dims);
} else {
ret = svp_acl_mdl_get_output_dims(g_svp_npu_model[task->cfg.model_idx].model_desc, idx, &dims);
}
macro_svp_check_exps_return(ret != TD_SUCCESS, TD_FAILURE, ENUM_SVP_ERR_LEVEL_ERROR,
"get %u-th input/output dims failed!\n", idx);
if (is_input == TD_TRUE) {
data_type = svp_acl_mdl_get_input_data_type(g_svp_npu_model[task->cfg.model_idx].model_desc, idx);
} else {
data_type = svp_acl_mdl_get_output_data_type(g_svp_npu_model[task->cfg.model_idx].model_desc, idx);
}
macro_svp_check_exps_return(ret != TD_SUCCESS, TD_FAILURE, ENUM_SVP_ERR_LEVEL_ERROR,
"get %u-th input/output data type failed!\n", idx);
data_size = svp_acl_data_type_size(data_type);
macro_svp_check_exps_return(data_size == 0, TD_FAILURE, ENUM_SVP_ERR_LEVEL_ERROR, "get data size failed!\n");
*line_byte_num = dims.dims[dims.dim_count - 1] *
((data_size + MACRO_SVP_NPU_BYTE_BIT_NUM - 1) / MACRO_SVP_NPU_BYTE_BIT_NUM);
*total_line_num = 1;
for (i = 0; i < dims.dim_count - 1; i++) {
*total_line_num *= dims.dims[i];
}
/* lstm xt line num */
if ((task->cfg.total_t != 0) && (idx == 0)) {
macro_svp_check_exps_return(task->cfg.total_t > dims.dims[0], TD_FAILURE, ENUM_SVP_ERR_LEVEL_ERROR,
"total t(%u) can't be greater than max total t(%ld)!\n", task->cfg.total_t, dims.dims[0]);
*total_line_num /= dims.dims[0];
*total_line_num *= task->cfg.total_t;
}
return TD_SUCCESS;
}
static td_s32 sample_svp_check_task_cfg(const struct_svp_npu_task_info *task)
{
macro_svp_check_exps_return(task == TD_NULL, TD_FAILURE, ENUM_SVP_ERR_LEVEL_ERROR, "task is NULL!\n");
macro_svp_check_exps_return(task->cfg.max_batch_num == 0, TD_FAILURE, ENUM_SVP_ERR_LEVEL_ERROR,
"max_batch_num(%u) is 0!\n", task->cfg.max_batch_num);
macro_svp_check_exps_return(task->cfg.dynamic_batch_num == 0, TD_FAILURE, ENUM_SVP_ERR_LEVEL_ERROR,
"dynamic_batch_num(%u) is 0!\n", task->cfg.dynamic_batch_num);
macro_svp_check_exps_return(task->cfg.total_t != 0 && task->cfg.dynamic_batch_num != 1, TD_FAILURE,
ENUM_SVP_ERR_LEVEL_ERROR, "dynamic_batch_num(%u) should be 1 when total_t(%u) is not 0!\n",
task->cfg.dynamic_batch_num, task->cfg.total_t);
macro_svp_check_exps_return((task->cfg.is_cached != TD_TRUE && task->cfg.is_cached != TD_FALSE), TD_FAILURE,
ENUM_SVP_ERR_LEVEL_ERROR, "is_cached(%u) should be [%u, %u]!\n", task->cfg.is_cached, TD_FALSE, TD_TRUE);
macro_svp_check_exps_return(task->cfg.model_idx >= MACRO_SVP_NPU_MAX_MODEL_NUM, TD_FAILURE,
ENUM_SVP_ERR_LEVEL_ERROR, "model_idx(%u) should be less than %u!\n",
task->cfg.model_idx, MACRO_SVP_NPU_MAX_MODEL_NUM);
macro_svp_check_exps_return(g_svp_npu_model[task->cfg.model_idx].model_desc == TD_NULL, TD_FAILURE,
ENUM_SVP_ERR_LEVEL_ERROR, "%u-th model_desc is NULL!\n", task->cfg.model_idx);
return TD_SUCCESS;
}
td_s32 sample_common_svp_npu_get_input_data(const td_char *src[], td_u32 file_num,
const struct_svp_npu_task_info *task)
{
td_s32 ret;
td_u32 i, line, total_line_num, line_byte_num;
td_char path[PATH_MAX] = { 0 };
size_t stride, size, input_num;
FILE *fp = TD_NULL;
td_void *data = TD_NULL;
svp_acl_data_buffer *data_buffer = TD_NULL;
if (sample_svp_check_task_cfg(task) != TD_SUCCESS) {
macro_svp_trace_err("check task cfg failed!\n");
return TD_FAILURE;
}
macro_svp_check_exps_return(src == TD_NULL, TD_FAILURE, ENUM_SVP_ERR_LEVEL_ERROR, "src is NULL!\n");
input_num = g_svp_npu_model[task->cfg.model_idx].input_num - MACRO_SVP_NPU_EXTRA_INPUT_NUM;
macro_svp_check_exps_return(input_num != file_num, TD_FAILURE, ENUM_SVP_ERR_LEVEL_ERROR,
"input file num(%u) should be equal to %lu!\n", file_num, input_num);
for (i = 0; i < file_num; i++) {
macro_svp_check_exps_return(realpath(src[i], path) == TD_NULL, TD_FAILURE, ENUM_SVP_ERR_LEVEL_ERROR,
"Invalid file!\n");
fp = fopen(path, "rb");
macro_svp_check_exps_return(fp == TD_NULL, TD_FAILURE, ENUM_SVP_ERR_LEVEL_ERROR, "open file failed!\n");
ret = sample_svp_npu_get_line_num_and_line_byte_num(task, i, TD_TRUE, &total_line_num, &line_byte_num);
macro_svp_check_exps_goto(ret != TD_SUCCESS, end, ENUM_SVP_ERR_LEVEL_ERROR, "get line num failed!\n");
data_buffer = svp_acl_mdl_get_dataset_buffer(task->input_dataset, i);
macro_svp_check_exps_goto(data_buffer == TD_NULL, end, ENUM_SVP_ERR_LEVEL_ERROR, "get data buffer NULL!\n");
data = svp_acl_get_data_buffer_addr(data_buffer);
macro_svp_check_exps_goto(data == TD_NULL, end, ENUM_SVP_ERR_LEVEL_ERROR, "get data addr NULL!\n");
stride = svp_acl_get_data_buffer_stride(data_buffer);
macro_svp_check_exps_goto(stride == 0, end, ENUM_SVP_ERR_LEVEL_ERROR, "get data stride failed!\n");
size = svp_acl_get_data_buffer_size(data_buffer);
macro_svp_check_exps_goto(size < (td_u64)task->cfg.dynamic_batch_num * total_line_num * stride, end,
ENUM_SVP_ERR_LEVEL_ERROR, "%u-th data buffer size(%lu) is less than needed(%llu)!\n",
i, size, (td_u64)task->cfg.dynamic_batch_num * total_line_num * stride);
for (line = 0; line < task->cfg.dynamic_batch_num * total_line_num; line++) {
ret = fread(data + line * stride, line_byte_num, 1, fp);
macro_svp_check_exps_goto(ret != 1, end, ENUM_SVP_ERR_LEVEL_ERROR, "Read file failed!\n");
}
if (task->cfg.is_cached == TD_TRUE) {
(td_void)svp_acl_rt_mem_flush(data, task->cfg.dynamic_batch_num * total_line_num * stride);
}
(td_void)fclose(fp);
}
return TD_SUCCESS;
end:
if (fp != TD_NULL) {
(td_void)fclose(fp);
}
return TD_FAILURE;
}
static td_s32 sample_svp_npu_read_model(const td_char *model_path, td_u32 model_index, td_bool is_cached)
{
FILE *fp = TD_NULL;
td_s32 ret;
/* Get model file size */
fp = fopen(model_path, "rb");
macro_svp_check_exps_return(fp == TD_NULL, TD_FAILURE, ENUM_SVP_ERR_LEVEL_ERROR,
"open model file failed, model file is %s!\n", model_path);
ret = fseek(fp, 0L, SEEK_END);
macro_svp_check_exps_goto(ret == -1, end_0, ENUM_SVP_ERR_LEVEL_ERROR, "fseek failed!\n");
g_svp_npu_model[model_index].model_mem_size = ftell(fp);
macro_svp_check_exps_goto(g_svp_npu_model[model_index].model_mem_size <= 0, end_0,
ENUM_SVP_ERR_LEVEL_ERROR, "ftell failed!\n");
ret = fseek(fp, 0L, SEEK_SET);
macro_svp_check_exps_goto(ret == -1, end_0, ENUM_SVP_ERR_LEVEL_ERROR, "fseek failed!\n");
/* malloc model file mem */
if (is_cached == TD_TRUE) {
ret = svp_acl_rt_malloc_cached(&g_svp_npu_model[model_index].model_mem_ptr,
g_svp_npu_model[model_index].model_mem_size, SVP_ACL_MEM_MALLOC_NORMAL_ONLY);
} else {
ret = svp_acl_rt_malloc(&g_svp_npu_model[model_index].model_mem_ptr,
g_svp_npu_model[model_index].model_mem_size, SVP_ACL_MEM_MALLOC_NORMAL_ONLY);
}
macro_svp_check_exps_goto(ret != SVP_ACL_SUCCESS, end_0, ENUM_SVP_ERR_LEVEL_ERROR,
"malloc mem failed, erroe code %d!\n", ret);
ret = fread(g_svp_npu_model[model_index].model_mem_ptr, g_svp_npu_model[model_index].model_mem_size, 1, fp);
macro_svp_check_exps_goto(ret != 1, end_1, ENUM_SVP_ERR_LEVEL_ERROR, "read model file failed!\n");
if (is_cached == TD_TRUE) {
ret = svp_acl_rt_mem_flush(g_svp_npu_model[model_index].model_mem_ptr,
g_svp_npu_model[model_index].model_mem_size);
macro_svp_check_exps_goto(ret != SVP_ACL_SUCCESS, end_1, ENUM_SVP_ERR_LEVEL_ERROR,
"flush mem failed!, error code is %d\n", ret);
}
(td_void)fclose(fp);
return TD_SUCCESS;
end_1:
(td_void)svp_acl_rt_free(g_svp_npu_model[model_index].model_mem_ptr);
end_0:
(td_void)fclose(fp);
return TD_FAILURE;
}
static td_s32 sample_svp_npu_create_desc(td_u32 model_index)
{
svp_acl_error ret;
g_svp_npu_model[model_index].model_desc = svp_acl_mdl_create_desc();
macro_svp_check_exps_return(g_svp_npu_model[model_index].model_desc == TD_NULL, TD_FAILURE,
ENUM_SVP_ERR_LEVEL_ERROR, "create model description failed!\n");
ret = svp_acl_mdl_get_desc(g_svp_npu_model[model_index].model_desc, g_svp_npu_model[model_index].model_id);
macro_svp_check_exps_return(ret != SVP_ACL_SUCCESS, TD_FAILURE,
ENUM_SVP_ERR_LEVEL_ERROR, "get model description failed, error code is %d!\n", ret);
macro_svp_trace_info("create model description success!\n");
return TD_SUCCESS;
}
td_s32 sample_common_svp_npu_load_model(const td_char *model_path, td_u32 model_index, td_bool is_cached)
{
td_s32 ret;
macro_svp_check_exps_return(g_svp_npu_model[model_index].is_load_flag == TD_TRUE, TD_FAILURE,
ENUM_SVP_ERR_LEVEL_ERROR, "%u-th node has already loaded a model!\n", model_index);
ret = sample_svp_npu_read_model(model_path, model_index, is_cached);
macro_svp_check_exps_return(ret != SVP_ACL_SUCCESS, TD_FAILURE,
ENUM_SVP_ERR_LEVEL_ERROR, "query model failed, model file is %s!\n", model_path);
ret = svp_acl_mdl_load_from_mem(g_svp_npu_model[model_index].model_mem_ptr,
g_svp_npu_model[model_index].model_mem_size, &g_svp_npu_model[model_index].model_id);
macro_svp_check_exps_goto(ret != SVP_ACL_SUCCESS, end_0,
ENUM_SVP_ERR_LEVEL_ERROR, "load model from mem failed, error code is %d!\n", ret);
ret = sample_svp_npu_create_desc(model_index);
macro_svp_check_exps_goto(ret != SVP_ACL_SUCCESS, end_0,
ENUM_SVP_ERR_LEVEL_ERROR, "create desc failed, model file is %s!\n", model_path);
ret = sample_svp_npu_get_model_base_info(model_index);
macro_svp_check_exps_goto(ret != SVP_ACL_SUCCESS, end_1,
ENUM_SVP_ERR_LEVEL_ERROR, "get model base info failed, model file is %s!\n", model_path);
macro_svp_trace_info("load mem_size:%lu, id:%d!\n", g_svp_npu_model[model_index].model_mem_size,
g_svp_npu_model[model_index].model_id);
g_svp_npu_model[model_index].is_load_flag = TD_TRUE;
macro_svp_trace_info("load model %s success!\n", model_path);
return TD_SUCCESS;
end_1:
(td_void)svp_acl_mdl_destroy_desc(g_svp_npu_model[model_index].model_desc);
g_svp_npu_model[model_index].model_desc = TD_NULL;
end_0:
(td_void)svp_acl_rt_free(g_svp_npu_model[model_index].model_mem_ptr);
g_svp_npu_model[model_index].model_mem_ptr = TD_NULL;
g_svp_npu_model[model_index].model_mem_size = 0;
return TD_FAILURE;
}
td_void sample_common_svp_npu_unload_model(td_u32 model_index)
{
svp_acl_error ret;
macro_svp_check_exps_return_void(g_svp_npu_model[model_index].is_load_flag != TD_TRUE,
ENUM_SVP_ERR_LEVEL_ERROR, "%u-th node has not loaded a model!\n", model_index);
ret = svp_acl_mdl_unload(g_svp_npu_model[model_index].model_id);
if (ret != SVP_ACL_SUCCESS) {
macro_svp_trace_err("unload model failed, model_id is %u, error code is %d!\n",
g_svp_npu_model[model_index].model_id, ret);
}
if (g_svp_npu_model[model_index].model_desc != TD_NULL) {
(td_void)svp_acl_mdl_destroy_desc(g_svp_npu_model[model_index].model_desc);
g_svp_npu_model[model_index].model_desc = TD_NULL;
}
if (g_svp_npu_model[model_index].model_mem_ptr != TD_NULL) {
(td_void)svp_acl_rt_free(g_svp_npu_model[model_index].model_mem_ptr);
g_svp_npu_model[model_index].model_mem_ptr = TD_NULL;
g_svp_npu_model[model_index].model_mem_size = 0;
}
g_svp_npu_model[model_index].is_load_flag = TD_FALSE;
macro_svp_trace_info("unload model SUCCESS, model id is %u!\n", g_svp_npu_model[model_index].model_id);
}
static td_s32 sample_svp_npu_malloc_mem(td_void **buffer, td_u32 buffer_size, td_bool is_cached)
{
svp_acl_error ret;
if (is_cached == TD_TRUE) {
ret = svp_acl_rt_malloc_cached(buffer, buffer_size, SVP_ACL_MEM_MALLOC_NORMAL_ONLY);
} else {
ret = svp_acl_rt_malloc(buffer, buffer_size, SVP_ACL_MEM_MALLOC_NORMAL_ONLY);
}
macro_svp_check_exps_return(ret != SVP_ACL_SUCCESS, TD_FAILURE, ENUM_SVP_ERR_LEVEL_ERROR,
"can't malloc buffer, size is %u, error code is %d!\n", buffer_size, ret);
(td_void)memset_s(*buffer, buffer_size, 0, buffer_size);
if (is_cached == TD_TRUE) {
(td_void)svp_acl_rt_mem_flush(*buffer, buffer_size);
}
return ret;
}
static td_void sample_svp_npu_destroy_data_buffer(svp_acl_data_buffer *input_data)
{
td_void *data = svp_acl_get_data_buffer_addr(input_data);
(td_void)svp_acl_rt_free(data);
(td_void)svp_acl_destroy_data_buffer(input_data);
}
static svp_acl_data_buffer *sample_common_svp_npu_create_input_data_buffer(struct_svp_npu_task_info *task, td_u32 idx)
{
size_t buffer_size, stride;
td_void *input_buffer = TD_NULL;
svp_acl_data_buffer *input_data = TD_NULL;
stride = svp_acl_mdl_get_input_default_stride(g_svp_npu_model[task->cfg.model_idx].model_desc, idx);
macro_svp_check_exps_return(stride == 0, input_data, ENUM_SVP_ERR_LEVEL_ERROR,
"get %u-th input stride failed!\n", idx);
buffer_size = svp_acl_mdl_get_input_size_by_index(g_svp_npu_model[task->cfg.model_idx].model_desc, idx) *
(td_u64)task->cfg.max_batch_num;
macro_svp_check_exps_return((buffer_size == 0 || buffer_size > MACRO_SVP_NPU_MAX_MEM_SIZE), input_data,
ENUM_SVP_ERR_LEVEL_ERROR, "buffer_size(%lu) can't be 0 and should be less than %u!\n",
buffer_size, MACRO_SVP_NPU_MAX_MEM_SIZE);
if (sample_svp_npu_malloc_mem(&input_buffer, (td_u32)buffer_size, task->cfg.is_cached) != TD_SUCCESS) {
macro_svp_trace_err("%u-th input malloc mem failed!\n", idx);
return input_data;
}
input_data = svp_acl_create_data_buffer(input_buffer, buffer_size, stride);
if (input_data == TD_NULL) {
macro_svp_trace_err("can't create %u-th input data buffer!\n", idx);
(td_void)svp_acl_rt_free(input_buffer);
return input_data;
}
if (idx == g_svp_npu_model[task->cfg.model_idx].input_num - MACRO_SVP_NPU_EXTRA_INPUT_NUM) {
task->task_buf_ptr = input_buffer;
task->task_buf_size = buffer_size;
task->task_buf_stride = stride;
} else if (idx == g_svp_npu_model[task->cfg.model_idx].input_num - 1) {
task->work_buf_ptr = input_buffer;
task->work_buf_size = buffer_size;
task->work_buf_stride = stride;
}
return input_data;
}
static svp_acl_data_buffer *sample_common_svp_npu_create_output_data_buffer(const struct_svp_npu_task_info *task,
td_u32 idx)
{
size_t buffer_size, stride;
td_void *output_buffer = TD_NULL;
svp_acl_data_buffer *output_data = TD_NULL;
stride = svp_acl_mdl_get_output_default_stride(g_svp_npu_model[task->cfg.model_idx].model_desc, idx);
macro_svp_check_exps_return(stride == 0, output_data, ENUM_SVP_ERR_LEVEL_ERROR,
"get %u-th output stride failed!\n", idx);
buffer_size = svp_acl_mdl_get_output_size_by_index(g_svp_npu_model[task->cfg.model_idx].model_desc, idx) *
(td_u64)task->cfg.max_batch_num;
macro_svp_check_exps_return((buffer_size == 0 || buffer_size > MACRO_SVP_NPU_MAX_MEM_SIZE), output_data,
ENUM_SVP_ERR_LEVEL_ERROR, "buffer_size(%lu) can't be 0 and should be less than %u!\n",
buffer_size, MACRO_SVP_NPU_MAX_MEM_SIZE);
if (sample_svp_npu_malloc_mem(&output_buffer, buffer_size, task->cfg.is_cached) != TD_SUCCESS) {
macro_svp_trace_err("%u-th output malloc mem failed!\n", idx);
return output_data;
}
output_data = svp_acl_create_data_buffer(output_buffer, buffer_size, stride);
if (output_data == TD_NULL) {
macro_svp_trace_err("can't create %u-th output data buffer!\n", idx);
(td_void)svp_acl_rt_free(output_buffer);
return output_data;
}
return output_data;
}
td_s32 sample_common_svp_npu_create_input(struct_svp_npu_task_info *task)
{
svp_acl_error ret;
td_u32 i;
svp_acl_data_buffer *input_data = TD_NULL;
if (sample_svp_check_task_cfg(task) != TD_SUCCESS) {
macro_svp_trace_err("check task cfg failed!\n");
return TD_FAILURE;
}
task->input_dataset = svp_acl_mdl_create_dataset();
macro_svp_check_exps_return(task->input_dataset == TD_NULL, TD_FAILURE, ENUM_SVP_ERR_LEVEL_ERROR,
"create input dataset failed!\n");
for (i = 0; i < g_svp_npu_model[task->cfg.model_idx].input_num - MACRO_SVP_NPU_EXTRA_INPUT_NUM; i++) {
input_data = sample_common_svp_npu_create_input_data_buffer(task, i);
if (input_data == TD_NULL) {
macro_svp_trace_err("create %u-th input data buffer failed!\n", i);
(td_void)sample_common_svp_npu_destroy_input(task);
return TD_FAILURE;
}
ret = svp_acl_mdl_add_dataset_buffer(task->input_dataset, input_data);
if (ret != SVP_ACL_SUCCESS) {
macro_svp_trace_err("add %u-th input data buffer failed!\n", i);
(td_void)sample_svp_npu_destroy_data_buffer(input_data);
(td_void)sample_common_svp_npu_destroy_input(task);
return TD_FAILURE;
}
}
return TD_SUCCESS;
}
td_s32 sample_common_svp_npu_create_output(struct_svp_npu_task_info *task)
{
svp_acl_error ret;
td_u32 i;
svp_acl_data_buffer *output_data = TD_NULL;
if (sample_svp_check_task_cfg(task) != TD_SUCCESS) {
macro_svp_trace_err("check task cfg failed!\n");
return TD_FAILURE;
}
task->output_dataset = svp_acl_mdl_create_dataset();
macro_svp_check_exps_return(task->input_dataset == TD_NULL, TD_FAILURE, ENUM_SVP_ERR_LEVEL_ERROR,
"create output dataset failed!\n");
for (i = 0; i < g_svp_npu_model[task->cfg.model_idx].output_num; i++) {
output_data = sample_common_svp_npu_create_output_data_buffer(task, i);
if (output_data == TD_NULL) {
macro_svp_trace_err("create %u-th output data buffer failed!\n", i);
(td_void)sample_common_svp_npu_destroy_input(task);
return TD_FAILURE;
}
ret = svp_acl_mdl_add_dataset_buffer(task->output_dataset, output_data);
if (ret != SVP_ACL_SUCCESS) {
macro_svp_trace_err("add %u-th output data buffer failed!\n", i);
(td_void)sample_svp_npu_destroy_data_buffer(output_data);
(td_void)sample_common_svp_npu_destroy_output(task);
return TD_FAILURE;
}
}
return TD_SUCCESS;
}
td_void sample_common_svp_npu_destroy_input(struct_svp_npu_task_info *task)
{
td_u32 i;
size_t input_num;
svp_acl_data_buffer *data_buffer = TD_NULL;
td_void *data = TD_NULL;
if (sample_svp_check_task_cfg(task) != TD_SUCCESS) {
macro_svp_trace_err("check task cfg failed!\n");
return;
}
if (task->input_dataset == TD_NULL) {
return;
}
input_num = svp_acl_mdl_get_dataset_num_buffers(task->input_dataset);
for (i = 0; i < input_num; i++) {
data_buffer = svp_acl_mdl_get_dataset_buffer(task->input_dataset, i);
if (i < g_svp_npu_model[task->cfg.model_idx].input_num - MACRO_SVP_NPU_EXTRA_INPUT_NUM) {
data = svp_acl_get_data_buffer_addr(data_buffer);
(td_void)svp_acl_rt_free(data);
}
(td_void)svp_acl_destroy_data_buffer(data_buffer);
}
(td_void)svp_acl_mdl_destroy_dataset(task->input_dataset);
task->input_dataset = TD_NULL;
}
td_void sample_common_svp_npu_destroy_output(struct_svp_npu_task_info *task)
{
td_u32 i;
size_t output_num;
svp_acl_data_buffer *data_buffer = TD_NULL;
td_void *data = TD_NULL;
if (sample_svp_check_task_cfg(task) != TD_SUCCESS) {
macro_svp_trace_err("check task cfg failed!\n");
return;
}
if (task->output_dataset == TD_NULL) {
return;
}
output_num = svp_acl_mdl_get_dataset_num_buffers(task->output_dataset);
for (i = 0; i < output_num; i++) {
data_buffer = svp_acl_mdl_get_dataset_buffer(task->output_dataset, i);
data = svp_acl_get_data_buffer_addr(data_buffer);
(td_void)svp_acl_rt_free(data);
(td_void)svp_acl_destroy_data_buffer(data_buffer);
}
(td_void)svp_acl_mdl_destroy_dataset(task->output_dataset);
task->output_dataset = TD_NULL;
}
td_void sample_common_svp_npu_destroy_task_buf(struct_svp_npu_task_info *task)
{
if (sample_svp_check_task_cfg(task) != TD_SUCCESS) {
macro_svp_trace_err("check task cfg failed!\n");
return;
}
if (task->task_buf_ptr == TD_NULL) {
return;
}
(td_void)svp_acl_rt_free(task->task_buf_ptr);
task->task_buf_ptr = TD_NULL;
task->task_buf_stride = 0;
task->task_buf_size = 0;
}
td_void sample_common_svp_npu_destroy_work_buf(struct_svp_npu_task_info *task)
{
if (sample_svp_check_task_cfg(task) != TD_SUCCESS) {
macro_svp_trace_err("check task cfg failed!\n");
return;
}
if (task->work_buf_ptr == TD_NULL) {
return;
}
(td_void)svp_acl_rt_free(task->work_buf_ptr);
task->work_buf_ptr = TD_NULL;
task->work_buf_stride = 0;
task->work_buf_size = 0;
}
td_s32 sample_common_svp_npu_create_task_buf(struct_svp_npu_task_info *task)
{
size_t num;
svp_acl_data_buffer *task_buf = TD_NULL;
svp_acl_error ret;
if (sample_svp_check_task_cfg(task) != TD_SUCCESS) {
macro_svp_trace_err("check task cfg failed!\n");
return TD_FAILURE;
}
macro_svp_check_exps_return(task->input_dataset == TD_NULL, TD_FAILURE, ENUM_SVP_ERR_LEVEL_ERROR,
"input_dataset is NULL!\n");
num = svp_acl_mdl_get_dataset_num_buffers(task->input_dataset);
macro_svp_check_exps_return(num != g_svp_npu_model[task->cfg.model_idx].input_num - MACRO_SVP_NPU_EXTRA_INPUT_NUM,
TD_FAILURE, ENUM_SVP_ERR_LEVEL_ERROR, "num of data buffer(%lu) should be %lu when create task buf!\n",
num, g_svp_npu_model[task->cfg.model_idx].input_num - MACRO_SVP_NPU_EXTRA_INPUT_NUM);
task_buf = sample_common_svp_npu_create_input_data_buffer(task,
g_svp_npu_model[task->cfg.model_idx].input_num - MACRO_SVP_NPU_EXTRA_INPUT_NUM);
macro_svp_check_exps_return(task_buf == TD_NULL, TD_FAILURE, ENUM_SVP_ERR_LEVEL_ERROR,
"create task buf failed!\n");
ret = svp_acl_mdl_add_dataset_buffer(task->input_dataset, task_buf);
if (ret != SVP_ACL_SUCCESS) {
macro_svp_trace_err("add task buf failed!\n");
(td_void)sample_svp_npu_destroy_data_buffer(task_buf);
return TD_FAILURE;
}
return TD_SUCCESS;
}
td_s32 sample_common_svp_npu_create_work_buf(struct_svp_npu_task_info *task)
{
size_t num;
svp_acl_data_buffer *work_buf = TD_NULL;
svp_acl_error ret;
if (sample_svp_check_task_cfg(task) != TD_SUCCESS) {
macro_svp_trace_err("check task cfg failed!\n");
return TD_FAILURE;
}
macro_svp_check_exps_return(task->input_dataset == TD_NULL, TD_FAILURE, ENUM_SVP_ERR_LEVEL_ERROR,
"input_dataset is NULL!\n");
num = svp_acl_mdl_get_dataset_num_buffers(task->input_dataset);
macro_svp_check_exps_return(num != g_svp_npu_model[task->cfg.model_idx].input_num - 1,
TD_FAILURE, ENUM_SVP_ERR_LEVEL_ERROR, "num of data buffer(%lu) should be %lu when create work buf!\n",
num, g_svp_npu_model[task->cfg.model_idx].input_num - 1);
work_buf = sample_common_svp_npu_create_input_data_buffer(task, g_svp_npu_model[task->cfg.model_idx].input_num - 1);
macro_svp_check_exps_return(work_buf == TD_NULL, TD_FAILURE, ENUM_SVP_ERR_LEVEL_ERROR,
"create work buf failed!\n");
ret = svp_acl_mdl_add_dataset_buffer(task->input_dataset, work_buf);
if (ret != SVP_ACL_SUCCESS) {
macro_svp_trace_err("add work buf failed!\n");
(td_void)sample_svp_npu_destroy_data_buffer(work_buf);
return TD_FAILURE;
}
return TD_SUCCESS;
}
td_s32 sample_common_svp_npu_get_work_buf_info(const struct_svp_npu_task_info *task,
td_u32 *work_buf_size, td_u32 *work_buf_stride)
{
if (sample_svp_check_task_cfg(task) != TD_SUCCESS) {
macro_svp_trace_err("check task cfg failed!\n");
return TD_FAILURE;
}
*work_buf_stride = (td_u32)svp_acl_mdl_get_input_default_stride(g_svp_npu_model[task->cfg.model_idx].model_desc,
g_svp_npu_model[task->cfg.model_idx].input_num - 1);
if (*work_buf_stride == 0) {
macro_svp_trace_err("get work buf stride failed!\n");
return TD_FAILURE;
}
*work_buf_size = (td_u32)svp_acl_mdl_get_input_size_by_index(g_svp_npu_model[task->cfg.model_idx].model_desc,
g_svp_npu_model[task->cfg.model_idx].input_num - 1);
if (*work_buf_size == 0) {
macro_svp_trace_err("get work buf size failed!\n");
return TD_FAILURE;
}
return TD_SUCCESS;
}
td_s32 sample_common_svp_npu_share_work_buf(const struct_svp_npu_shared_work_buf *shared_work_buf,
const struct_svp_npu_task_info *task)
{
svp_acl_error ret;
svp_acl_data_buffer *work_buf = TD_NULL;
if (sample_svp_check_task_cfg(task) != TD_SUCCESS) {
macro_svp_trace_err("check task cfg failed!\n");
return TD_FAILURE;
}
macro_svp_check_exps_return(shared_work_buf == TD_NULL, TD_FAILURE, ENUM_SVP_ERR_LEVEL_ERROR,
"shared_work_buf is NULL!\n");
macro_svp_check_exps_return(shared_work_buf->work_buf_ptr == TD_NULL, TD_FAILURE, ENUM_SVP_ERR_LEVEL_ERROR,
"work_buf_ptr is NULL!\n");
macro_svp_check_exps_return(task->work_buf_ptr != TD_NULL, TD_FAILURE, ENUM_SVP_ERR_LEVEL_ERROR,
"task has created work buf!\n");
work_buf = svp_acl_create_data_buffer(shared_work_buf->work_buf_ptr, shared_work_buf->work_buf_size,
shared_work_buf->work_buf_stride);
macro_svp_check_exps_return(work_buf == TD_NULL, TD_FAILURE, ENUM_SVP_ERR_LEVEL_ERROR,
"create work buf failed!\n");
ret = svp_acl_mdl_add_dataset_buffer(task->input_dataset, work_buf);
if (ret != SVP_ACL_SUCCESS) {
macro_svp_trace_err("add work buf failed!\n");
(td_void)svp_acl_destroy_data_buffer(work_buf);
return TD_FAILURE;
}
return TD_SUCCESS;
}
/* print the top n confidence values with indexes */
static td_void sample_svp_npu_sort_output_result(const td_float *src, td_u32 src_len,
struct_svp_npu_top_n_result *dst, td_u32 dst_len)
{
td_u32 i, j, index;
td_bool charge;
for (i = 0; i < src_len; i++) {
charge = TD_FALSE;
for (j = 0; j < dst_len; j++) {
if (src[i] > dst[j].score) {
index = j;
charge = TD_TRUE;
break;
}
}
if (charge == TD_TRUE) {
for (j = dst_len - 1; j > index; j--) {
dst[j].score = dst[j - 1].score;
dst[j].class_id = dst[j - 1].class_id;
}
dst[index].score = src[i];
dst[index].class_id = i;
}
}
}
td_void sample_common_svp_npu_output_classification_result(const struct_svp_npu_task_info *task)
{
svp_acl_data_buffer *data_buffer = TD_NULL;
td_void *data = TD_NULL;
td_u32 i, j, n;
svp_acl_error ret;
size_t stride;
svp_acl_mdl_io_dims dims;
struct_svp_npu_top_n_result top[MACRO_SVP_NPU_SHOW_TOP_NUM] = { 0 };
if (sample_svp_check_task_cfg(task) != TD_SUCCESS) {
macro_svp_trace_err("check task cfg failed!\n");
return;
}
macro_svp_check_exps_return_void(task->output_dataset == TD_NULL, ENUM_SVP_ERR_LEVEL_ERROR,
"task->output_dataset is NULL!\n");
for (i = 0; i < svp_acl_mdl_get_dataset_num_buffers(task->output_dataset); i++) {
data_buffer = svp_acl_mdl_get_dataset_buffer(task->output_dataset, i);
macro_svp_check_exps_return_void(data_buffer == TD_NULL, ENUM_SVP_ERR_LEVEL_ERROR,
"get %u-th data buffer is NULL!\n", i);
data = svp_acl_get_data_buffer_addr(data_buffer);
macro_svp_check_exps_return_void(data == TD_NULL, ENUM_SVP_ERR_LEVEL_ERROR,
"get %u-th data addr is NULL!\n", i);
stride = svp_acl_get_data_buffer_stride(data_buffer);
macro_svp_check_exps_return_void(data == TD_NULL, ENUM_SVP_ERR_LEVEL_ERROR,
"get %u-th data stride is 0!\n", i);
ret = svp_acl_mdl_get_output_dims(g_svp_npu_model[task->cfg.model_idx].model_desc, i, &dims);
macro_svp_check_exps_return_void(data == TD_NULL, ENUM_SVP_ERR_LEVEL_ERROR,
"get %u-th output dims failed, error code is %d!\n", i, ret);
for (n = 0; n < task->cfg.dynamic_batch_num; n++) {
(td_void)sample_svp_npu_sort_output_result(data, (td_u32)dims.dims[dims.dim_count - 1],
top, MACRO_SVP_NPU_SHOW_TOP_NUM);
macro_svp_trace_info("%u-th batch result:\n", n);
for (j = 0; j < MACRO_SVP_NPU_SHOW_TOP_NUM; j++) {
macro_svp_trace_info("top %d: value[%lf], class_id[%u]!\n", j, top[j].score, top[j].class_id);
}
data += stride;
(td_void)memset_s(top, sizeof(top), 0, sizeof(top));
}
}
macro_svp_trace_info("output data success!\n");
}
td_s32 sample_common_svp_npu_set_dynamic_batch(const struct_svp_npu_task_info *task)
{
svp_acl_error ret;
if (sample_svp_check_task_cfg(task) != TD_SUCCESS) {
macro_svp_trace_err("check task cfg failed!\n");
return TD_FAILURE;
}
ret = svp_acl_mdl_set_dynamic_batch_size(g_svp_npu_model[task->cfg.model_idx].model_id,
task->input_dataset, g_svp_npu_model[task->cfg.model_idx].dynamic_batch_idx, task->cfg.dynamic_batch_num);
macro_svp_check_exps_return(ret != SVP_ACL_SUCCESS, TD_FAILURE, ENUM_SVP_ERR_LEVEL_ERROR,
"set dynamic batch size failed, model id is %u, error code is %d!\n",
g_svp_npu_model[task->cfg.model_idx].model_id, ret);
if (task->cfg.total_t != 0) {
ret = svp_acl_mdl_set_total_t(g_svp_npu_model[task->cfg.model_idx].model_id,
task->input_dataset, task->cfg.total_t);
macro_svp_check_exps_return(ret != SVP_ACL_SUCCESS, TD_FAILURE, ENUM_SVP_ERR_LEVEL_ERROR,
"set total_t failed, model id is %u, error code is %d!\n",
g_svp_npu_model[task->cfg.model_idx].model_id, ret);
}
return TD_SUCCESS;
}
td_s32 sample_common_svp_npu_model_execute(const struct_svp_npu_task_info *task)
{
svp_acl_data_buffer *data_buffer = TD_NULL;
td_void *data = TD_NULL;
size_t size;
td_u32 i;
svp_acl_error ret;
if (sample_svp_check_task_cfg(task) != TD_SUCCESS) {
macro_svp_trace_err("check task cfg failed!\n");
return TD_FAILURE;
}
ret = svp_acl_mdl_execute(g_svp_npu_model[task->cfg.model_idx].model_id, task->input_dataset, task->output_dataset);
macro_svp_check_exps_return(ret != SVP_ACL_SUCCESS, TD_FAILURE, ENUM_SVP_ERR_LEVEL_ERROR,
"svp_acl_mdl_execute failed, model_id is %u, error code is %d!\n",
g_svp_npu_model[task->cfg.model_idx].model_id, ret);
if (task->cfg.is_cached == TD_TRUE) {
for (i = 0; i < g_svp_npu_model[task->cfg.model_idx].output_num; i++) {
data_buffer = svp_acl_mdl_get_dataset_buffer(task->output_dataset, i);
macro_svp_check_exps_return(data_buffer == TD_NULL, TD_FAILURE, ENUM_SVP_ERR_LEVEL_ERROR,
"get %u-th output data_buffer is NULL!\n", i);
data = svp_acl_get_data_buffer_addr(data_buffer);
macro_svp_check_exps_return(data == TD_NULL, TD_FAILURE, ENUM_SVP_ERR_LEVEL_ERROR,
"get %u-th output data is NULL!\n", i);
size = svp_acl_get_data_buffer_size(data_buffer) / task->cfg.max_batch_num * task->cfg.dynamic_batch_num;
macro_svp_check_exps_return(size == 0, TD_FAILURE, ENUM_SVP_ERR_LEVEL_ERROR,
"get %u-th output data size is 0!\n", i);
ret = svp_acl_rt_mem_flush(data, size);
macro_svp_check_exps_return(data_buffer == TD_NULL, TD_FAILURE, ENUM_SVP_ERR_LEVEL_ERROR,
"flush %u-th output data failed, error code is %d!\n", i, ret);
}
}
return ret;
}
static td_void sample_svp_npu_dump_dataset(const struct_svp_npu_task_info *task, const td_char *file_name,
td_bool is_input)
{
td_u32 i, line, total_line_num, line_byte_num, data_num;
svp_acl_error ret;
size_t size, stride;
svp_acl_data_buffer *data_buffer = TD_NULL;
svp_acl_mdl_dataset *dataset = TD_NULL;
td_void *data = TD_NULL;
FILE *fp = TD_NULL;
td_char name[MACRO_SVP_NPU_MAX_NAME_LEN] = {'\0'};
data_num = is_input == TD_TRUE ? g_svp_npu_model[task->cfg.model_idx].input_num - MACRO_SVP_NPU_EXTRA_INPUT_NUM :
g_svp_npu_model[task->cfg.model_idx].output_num;
dataset = is_input == TD_TRUE ? task->input_dataset : task->output_dataset;
for (i = 0; i < data_num; i++) {
ret = sample_svp_npu_get_line_num_and_line_byte_num(task, i, is_input, &total_line_num, &line_byte_num);
macro_svp_check_exps_return_void(ret != TD_SUCCESS, ENUM_SVP_ERR_LEVEL_ERROR,
"get line num and line byte num failed!\n");
data_buffer = svp_acl_mdl_get_dataset_buffer(dataset, i);
macro_svp_check_exps_return_void(data_buffer == TD_NULL, ENUM_SVP_ERR_LEVEL_ERROR,
"get %u-th data_buffer failed!\n", i);
data = svp_acl_get_data_buffer_addr(data_buffer);
macro_svp_check_exps_return_void(data == TD_NULL, ENUM_SVP_ERR_LEVEL_ERROR,
"get %u-th data addr failed!\n", i);
stride = svp_acl_get_data_buffer_stride(data_buffer);
macro_svp_check_exps_return_void(stride == 0, ENUM_SVP_ERR_LEVEL_ERROR,
"get %u-th data stride failed!\n", i);
size = svp_acl_get_data_buffer_size(data_buffer);
macro_svp_check_exps_return_void(size == 0, ENUM_SVP_ERR_LEVEL_ERROR, "get %u-th data size failed!\n", i);
macro_svp_check_exps_return_void(size < (td_u64)task->cfg.dynamic_batch_num * total_line_num * stride,
ENUM_SVP_ERR_LEVEL_ERROR, "%u-th data buffer size(%lu) is less than needed(%llu)!\n",
i, size, (td_u64)task->cfg.dynamic_batch_num * total_line_num * stride);
ret = snprintf_s(name, MACRO_SVP_NPU_MAX_NAME_LEN - 1, MACRO_SVP_NPU_MAX_NAME_LEN - 1, file_name, i);
macro_svp_check_exps_return_void(ret < 0, ENUM_SVP_ERR_LEVEL_ERROR, "create file name failed!\n");
fp = fopen(name, "wb");
macro_svp_check_exps_return_void(fp == TD_NULL, ENUM_SVP_ERR_LEVEL_ERROR, "open file failed!\n");
for (line = 0; line < task->cfg.dynamic_batch_num * total_line_num; line++) {
ret = fwrite(data, line_byte_num, 1, fp);
if (ret != 1) {
fclose(fp);
macro_svp_check_exps_return_void(ret != 1, ENUM_SVP_ERR_LEVEL_ERROR, "write file failed!\n");
}
data += stride;
}
(td_void)fclose(fp);
}
}
td_void sample_common_svp_npu_dump_task_data(const struct_svp_npu_task_info *task)
{
if (sample_svp_check_task_cfg(task) != TD_SUCCESS) {
macro_svp_trace_err("check task cfg failed!\n");
return;
}
macro_svp_check_exps_return_void(task->input_dataset == TD_NULL, ENUM_SVP_ERR_LEVEL_ERROR,
"task->input_dataset is NULL!\n");
macro_svp_check_exps_return_void(task->output_dataset == TD_NULL, ENUM_SVP_ERR_LEVEL_ERROR,
"task->input_dataset is NULL!\n");
(td_void)sample_svp_npu_dump_dataset(task, "input_%u.bin", TD_TRUE);
(td_void)sample_svp_npu_dump_dataset(task, "output_%u.bin", TD_FALSE);
}
td_s32 sample_common_svp_npu_update_input_data_buffer_info(td_u8 *virt_addr, td_u32 size, td_u32 stride, td_u32 idx,
const struct_svp_npu_task_info *task)
{
svp_acl_data_buffer *data_buffer = TD_NULL;
svp_acl_error ret;
data_buffer = svp_acl_mdl_get_dataset_buffer(task->input_dataset, idx);
macro_svp_check_exps_return(data_buffer == TD_NULL, TD_FAILURE, ENUM_SVP_ERR_LEVEL_ERROR,
"get %u-th data_buffer failed!\n", idx);
ret = svp_acl_update_data_buffer(data_buffer, (td_void *)virt_addr, size, stride);
macro_svp_check_exps_return(ret != SVP_ACL_SUCCESS, TD_FAILURE, ENUM_SVP_ERR_LEVEL_ERROR,
"update data buffer failed!\n");
return TD_SUCCESS;
}
td_s32 sample_common_svp_npu_get_input_data_buffer_info(const struct_svp_npu_task_info *task, td_u32 idx,
td_u8 **virt_addr, td_u32 *size, td_u32 *stride)
{
svp_acl_data_buffer *data_buffer = TD_NULL;
if (sample_svp_check_task_cfg(task) != TD_SUCCESS) {
macro_svp_trace_err("check task cfg failed!\n");
return TD_FAILURE;
}
macro_svp_check_exps_return(virt_addr == TD_NULL, TD_FAILURE, ENUM_SVP_ERR_LEVEL_ERROR, "virt_addr is NULL!\n");
macro_svp_check_exps_return(size == TD_NULL, TD_FAILURE, ENUM_SVP_ERR_LEVEL_ERROR, "size is NULL!\n");
macro_svp_check_exps_return(stride == TD_NULL, TD_FAILURE, ENUM_SVP_ERR_LEVEL_ERROR, "size is NULL!\n");
data_buffer = svp_acl_mdl_get_dataset_buffer(task->input_dataset, idx);
macro_svp_check_exps_return(data_buffer == TD_NULL, TD_FAILURE, ENUM_SVP_ERR_LEVEL_ERROR,
"get 0-th data_buffer failed!\n");
*size = (td_u32)svp_acl_get_data_buffer_size(data_buffer);
*stride = (td_u32)svp_acl_get_data_buffer_stride(data_buffer);
*virt_addr = (td_u8 *)svp_acl_get_data_buffer_addr(data_buffer);
return TD_SUCCESS;
}
static td_s32 sample_svp_npu_get_roi_num(const struct_svp_npu_task_info *task, struct_svp_npu_detection_info *info,
ot_struct_svp_rect_info *rect_info)
{
svp_acl_error ret;
size_t num_idx;
svp_acl_mdl_io_dims dims;
svp_acl_data_buffer *data_buffer = TD_NULL;
td_float *data = TD_NULL;
td_float total_num = 0.0;
td_u32 start = 0;
td_u32 i;
ret = svp_acl_mdl_get_output_index_by_name(g_svp_npu_model[task->cfg.model_idx].model_desc,
info->num_name, &num_idx);
macro_svp_check_exps_return(ret != SVP_ACL_SUCCESS, TD_FAILURE, ENUM_SVP_ERR_LEVEL_ERROR,
"get num idx failed!\n");
ret = svp_acl_mdl_get_output_dims(g_svp_npu_model[task->cfg.model_idx].model_desc, num_idx, &dims);
macro_svp_check_exps_return(ret != SVP_ACL_SUCCESS, TD_FAILURE, ENUM_SVP_ERR_LEVEL_ERROR,
"get num dims failed!\n");
data_buffer = svp_acl_mdl_get_dataset_buffer(task->output_dataset, num_idx);
macro_svp_check_exps_return(data_buffer == TD_NULL, TD_FAILURE, ENUM_SVP_ERR_LEVEL_ERROR,
"get num data_buffer is NULL!\n");
data = (td_float *)svp_acl_get_data_buffer_addr(data_buffer);
macro_svp_check_exps_return(data == TD_NULL, TD_FAILURE, ENUM_SVP_ERR_LEVEL_ERROR, "get num data is NULL!\n");
if (info->has_background == TD_TRUE) {
info->roi_offset = (td_u32)(*data);
start++;
}
for (i = start; i < dims.dims[dims.dim_count - 1]; i++) {
total_num += *(data + i);
}
rect_info->num = (td_u32)total_num;
return TD_SUCCESS;
}
static td_s32 sample_svp_npu_get_roi(const struct_svp_npu_task_info *task, const struct_svp_npu_detection_info *info,
const ot_video_frame_info *proc_frame, const ot_video_frame_info *show_frame, ot_struct_svp_rect_info *rect_info)
{
svp_acl_error ret;
size_t roi_idx, stride;
svp_acl_data_buffer *data_buffer = TD_NULL;
td_float *x_min = TD_NULL;
td_float *y_min = TD_NULL;
td_float *x_max = TD_NULL;
td_float *y_max = TD_NULL;
td_u32 roi_offset = info->roi_offset;
td_u32 i;
ret = svp_acl_mdl_get_output_index_by_name(g_svp_npu_model[task->cfg.model_idx].model_desc,
info->roi_name, &roi_idx);
macro_svp_check_exps_return(ret != SVP_ACL_SUCCESS, TD_FAILURE, ENUM_SVP_ERR_LEVEL_ERROR,
"get roi idx failed!\n");
data_buffer = svp_acl_mdl_get_dataset_buffer(task->output_dataset, roi_idx);
macro_svp_check_exps_return(data_buffer == TD_NULL, TD_FAILURE, ENUM_SVP_ERR_LEVEL_ERROR,
"get roi data_buffer is NULL!\n");
stride = svp_acl_get_data_buffer_stride(data_buffer);
macro_svp_check_exps_return(stride == 0, TD_FAILURE, ENUM_SVP_ERR_LEVEL_ERROR, "get roi stride is 0!\n");
x_min = (td_float *)svp_acl_get_data_buffer_addr(data_buffer);
macro_svp_check_exps_return(x_min == TD_NULL, TD_FAILURE, ENUM_SVP_ERR_LEVEL_ERROR, "get roi data is NULL!\n");
y_min = x_min + stride / sizeof(td_float);
x_max = y_min + stride / sizeof(td_float);
y_max = x_max + stride / sizeof(td_float);
for (i = 0; i < rect_info->num; i++) {
rect_info->rect[i].point[MACRO_SVP_NPU_RECT_LEFT_TOP].x = (td_u32)((td_float)x_min[roi_offset] /
proc_frame->video_frame.width * show_frame->video_frame.width) & (~1);
rect_info->rect[i].point[MACRO_SVP_NPU_RECT_LEFT_TOP].y = (td_u32)((td_float)y_min[roi_offset] /
proc_frame->video_frame.height * show_frame->video_frame.height) & (~1);
rect_info->rect[i].point[MACRO_SVP_NPU_RECT_RIGHT_TOP].x = (td_u32)((td_float)x_max[roi_offset] /
proc_frame->video_frame.width * show_frame->video_frame.width) & (~1);
rect_info->rect[i].point[MACRO_SVP_NPU_RECT_RIGHT_TOP].y =
rect_info->rect[i].point[MACRO_SVP_NPU_RECT_LEFT_TOP].y;
rect_info->rect[i].point[MACRO_SVP_NPU_RECT_RIGHT_BOTTOM].x =
rect_info->rect[i].point[MACRO_SVP_NPU_RECT_RIGHT_TOP].x;
rect_info->rect[i].point[MACRO_SVP_NPU_RECT_RIGHT_BOTTOM].y = (td_u32)((td_float)y_max[roi_offset] /
proc_frame->video_frame.height * show_frame->video_frame.height) & (~1);
rect_info->rect[i].point[MACRO_SVP_NPU_RECT_LEFT_BOTTOM].x =
rect_info->rect[i].point[MACRO_SVP_NPU_RECT_LEFT_TOP].x;
rect_info->rect[i].point[MACRO_SVP_NPU_RECT_LEFT_BOTTOM].y =
rect_info->rect[i].point[MACRO_SVP_NPU_RECT_RIGHT_BOTTOM].y;
roi_offset++;
}
return TD_SUCCESS;
}
td_s32 sample_common_svp_npu_roi_to_rect(const struct_svp_npu_task_info *task,
struct_svp_npu_detection_info *detection_info, const ot_video_frame_info *proc_frame,
const ot_video_frame_info *show_frame, ot_struct_svp_rect_info *rect_info)
{
td_s32 ret;
if (sample_svp_check_task_cfg(task) != TD_SUCCESS) {
macro_svp_trace_err("check task cfg failed!\n");
return TD_FAILURE;
}
macro_svp_check_exps_return(detection_info == TD_NULL, TD_FAILURE, ENUM_SVP_ERR_LEVEL_ERROR,
"detection_info is NULL!\n");
macro_svp_check_exps_return(proc_frame == TD_NULL, TD_FAILURE, ENUM_SVP_ERR_LEVEL_ERROR,
"proc_frame is NULL!\n");
macro_svp_check_exps_return(show_frame == TD_NULL, TD_FAILURE, ENUM_SVP_ERR_LEVEL_ERROR,
"show_frame is NULL!\n");
macro_svp_check_exps_return(rect_info == TD_NULL, TD_FAILURE, ENUM_SVP_ERR_LEVEL_ERROR,
"rect_info is NULL!\n");
detection_info->roi_offset = 0;
ret = sample_svp_npu_get_roi_num(task, detection_info, rect_info);
macro_svp_check_exps_return(ret != TD_SUCCESS, TD_FAILURE, ENUM_SVP_ERR_LEVEL_ERROR,
"get roi num failed!\n");
ret = sample_svp_npu_get_roi(task, detection_info, proc_frame, show_frame, rect_info);
macro_svp_check_exps_return(ret != TD_SUCCESS, TD_FAILURE, ENUM_SVP_ERR_LEVEL_ERROR,
"get roi failed!\n");
return TD_SUCCESS;
}
td_s32 sample_common_svp_npu_set_threshold(struct_svp_npu_threshold threshold[], td_u32 threshold_num,
const struct_svp_npu_task_info *task)
{
td_u32 i, n;
svp_acl_error ret;
svp_acl_data_buffer *data_buffer = TD_NULL;
td_float *data = TD_NULL;
size_t idx, size;
if (sample_svp_check_task_cfg(task) != TD_SUCCESS) {
macro_svp_trace_err("check task cfg failed!\n");
return TD_FAILURE;
}
macro_svp_check_exps_return(threshold == TD_NULL, TD_FAILURE, ENUM_SVP_ERR_LEVEL_ERROR, "threshold is NULL!\n");
macro_svp_check_exps_return(threshold_num == 0, TD_FAILURE, ENUM_SVP_ERR_LEVEL_ERROR, "threshold_num is 0!\n");
for (i = 0; i < threshold_num; i++) {
ret = svp_acl_mdl_get_input_index_by_name(g_svp_npu_model[task->cfg.model_idx].model_desc,
threshold[i].name, &idx);
macro_svp_check_exps_return(ret != SVP_ACL_SUCCESS, TD_FAILURE, ENUM_SVP_ERR_LEVEL_ERROR,
"get roi idx failed!\n");
data_buffer = svp_acl_mdl_get_dataset_buffer(task->input_dataset, idx);
macro_svp_check_exps_return(data_buffer == TD_NULL, TD_FAILURE, ENUM_SVP_ERR_LEVEL_ERROR,
"get roi data_buffer is NULL!\n");
size = svp_acl_get_data_buffer_size(data_buffer);
macro_svp_check_exps_return(size < MACRO_SVP_NPU_THRESHOLD_NUM * sizeof(td_float), TD_FAILURE,
ENUM_SVP_ERR_LEVEL_ERROR, "get size(%lu) is less than %lu!\n",
size, MACRO_SVP_NPU_THRESHOLD_NUM * sizeof(td_float));
data = (td_float *)svp_acl_get_data_buffer_addr(data_buffer);
macro_svp_check_exps_return(data == TD_NULL, TD_FAILURE, ENUM_SVP_ERR_LEVEL_ERROR,
"get roi data is NULL!\n");
n = 0;
data[n++] = threshold[i].nms_threshold;
data[n++] = threshold[i].score_threshold;
data[n++] = threshold[i].min_height;
data[n++] = threshold[i].min_width;
}
return TD_SUCCESS;
}
td_s32 sample_common_svp_npu_check_has_aicpu_task(const struct_svp_npu_task_info *task, td_bool *has_aicpu_task)
{
td_u32 aicpu_task_num;
svp_acl_error ret;
if (sample_svp_check_task_cfg(task) != TD_SUCCESS) {
macro_svp_trace_err("check task cfg failed!\n");
return TD_FAILURE;
}
macro_svp_check_exps_return(has_aicpu_task == TD_NULL, TD_FAILURE, ENUM_SVP_ERR_LEVEL_ERROR,
"has_aicpu_task is NULL!\n");
ret = svp_acl_ext_get_mdl_aicpu_task_num(g_svp_npu_model[task->cfg.model_idx].model_id, &aicpu_task_num);
macro_svp_check_exps_return(ret != SVP_ACL_SUCCESS, TD_FAILURE, ENUM_SVP_ERR_LEVEL_ERROR,
"get aicpu task num failed, error code is %d!\n", ret);
*has_aicpu_task = (aicpu_task_num == 0) ? TD_FALSE : TD_TRUE;
return TD_SUCCESS;
}
struct_svp_npu_model_info* sample_common_svp_npu_get_model_info(td_u32 model_idx)
{
macro_svp_check_exps_return(model_idx >= MACRO_SVP_NPU_MAX_MODEL_NUM, NULL, ENUM_SVP_ERR_LEVEL_ERROR,
"model_idx(%u) must be [0, %u)!\n", model_idx, MACRO_SVP_NPU_MAX_MODEL_NUM);
return &g_svp_npu_model[model_idx];
}
Reference in New Issue View Git Blame Copy Permalink