colin
/
TIM-VX
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

wrapper public ovxlib api (#320) 

Co-authored-by: zhouheng.zheng <zhouheng.zheng@ouotlook.com>
This commit is contained in:
Zhouheng Zheng 2022-03-15 21:24:15 +08:00 committed by GitHub
parent b02aa8b8c4
commit 4d5013edf9
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
3 changed files with 193 additions and 61 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

54
src/tim/vx/internal/include/kernel/vsi_nn_kernel.h
View File

@ -1018,6 +1018,60 @@ vsi_nn_tensor_t* vsi_nn_merge_input_zeropoint_to_bias
vsi_nn_tensor_t * bias
);
void vsi_nn_kernel_add_source_internal
(
vsi_nn_kernel_t * kernel,
vsi_nn_gpu_source_fmt_e fmt,
size_t source_num,
va_list args
);
OVXLIB_API vsi_nn_kernel_t * vsi_nn_KernelCreate
(
vsi_nn_kernel_type_e type
);
OVXLIB_API void vsi_nn_KernelAddSource
(
vsi_nn_kernel_t * kernel,
vsi_nn_gpu_source_fmt_e fmt,
size_t source_num,
...
);
OVXLIB_API void vsi_nn_KernelAddBuildOption
(
vsi_nn_kernel_t * kernel,
const char * option
);
OVXLIB_API vsi_status vsi_nn_KernelNodePassParam
(
vsi_nn_kernel_node_t node,
vsi_nn_kernel_node_param_t * params,
size_t num
);
OVXLIB_API vsi_nn_kernel_node_t vsi_nn_KernelCreateNodeExt
(
vsi_nn_graph_t * graph,
vsi_nn_kernel_t * kernel,
const char** resources
);
OVXLIB_API vsi_nn_kernel_scalar_t vsi_nn_kernelScalarCreate
(
vsi_nn_graph_t * graph,
vsi_nn_kernel_dtype_e dtype,
const void * data
);
OVXLIB_API vsi_status vsi_nn_KernelGpuConfig
(
vsi_nn_kernel_node_t node,
const gpu_param_t * gpu_param
);
static inline const char* vsi_nn_kernel_type_str
(
vsi_nn_kernel_type_e type

174
src/tim/vx/internal/src/kernel/vsi_nn_kernel.c
View File

@ -1051,54 +1051,10 @@ void vsi_nn_kernel_add_source
...
)
{
va_list arg;
size_t i;
vsi_nn_kernel_source_info_t* source;
if( source_num == 0 )
{
return;
}
if( fmt >= VSI_NN_GPU_SOURCE_FMT_NUM )
{
VSILOGE("Unknown source type %d", fmt);
return;
}
if( kernel->gpu.sources[fmt].data )
{
VSILOGE("Kernel source %d has been attached!", fmt);
return;
}
source = &(kernel->gpu.sources[fmt]);
va_start( arg, source_num );
if( source_num > 0 )
{
const size_t mem_size = sizeof(vsi_nn_kernel_source_t) * source_num;
source->data = (vsi_nn_kernel_source_t*)malloc( mem_size );
if( !source->data )
{
VSILOGE("Out of memory, create kernel source fail.");
return;
}
memset( source->data, 0, mem_size );
}
for( i = 0; i < source_num; i ++ )
{
vsi_nn_kernel_source_t src = va_arg( arg, vsi_nn_kernel_source_t );
size_t size = strlen( src );
source->data[i] = (vsi_nn_kernel_source_t)malloc( size * sizeof(char) + 1 );
if( source->data[i] )
{
memcpy( source->data[i], src, size );
source->data[i][size] = 0;
}
else
{
VSILOGE("Malloc source memory fail.");
return;
}
}
source->num = source_num;
va_end(arg);
va_list args;
va_start( args, source_num );
vsi_nn_kernel_add_source_internal( kernel, fmt, source_num, args );
va_end( args );
} /* vsi_nn_kernel_add_source() */
void vsi_nn_kernel_add_build_option
@ -1554,6 +1510,128 @@ vsi_status vsi_nn_kernel_pirority_set
return status;
} /* vsi_nn_kernel_pirority_set() */
vsi_nn_kernel_t * vsi_nn_KernelCreate(vsi_nn_kernel_type_e type)
{
return vsi_nn_kernel_create(type);
}/* vsi_nn_KernelCreate() */
void vsi_nn_kernel_add_source_internal
(
vsi_nn_kernel_t * kernel,
vsi_nn_gpu_source_fmt_e fmt,
size_t source_num,
va_list args
)
{
size_t i;
vsi_nn_kernel_source_info_t* source;
if( source_num == 0 )
{
return;
}
if( fmt >= VSI_NN_GPU_SOURCE_FMT_NUM )
{
VSILOGE("Unknown source type %d", fmt);
return;
}
if( kernel->gpu.sources[fmt].data )
{
VSILOGE("Kernel source %d has been attached!", fmt);
return;
}
source = &(kernel->gpu.sources[fmt]);
if( source_num > 0 )
{
const size_t mem_size = sizeof(vsi_nn_kernel_source_t) * source_num;
source->data = (vsi_nn_kernel_source_t*)malloc( mem_size );
if( !source->data )
{
VSILOGE("Out of memory, create kernel source fail.");
return;
}
memset( source->data, 0, mem_size );
}
for( i = 0; i < source_num; i ++ )
{
vsi_nn_kernel_source_t src = va_arg( args, vsi_nn_kernel_source_t );
size_t size = strlen( src );
source->data[i] = (vsi_nn_kernel_source_t)malloc( size * sizeof(char) + 1 );
if( source->data[i] )
{
memcpy( source->data[i], src, size );
source->data[i][size] = 0;
}
else
{
VSILOGE("Malloc source memory fail.");
return;
}
}
source->num = source_num;
}/* vsi_nn_kernel_add_source_internal() */
void vsi_nn_KernelAddSource
(
vsi_nn_kernel_t * kernel,
vsi_nn_gpu_source_fmt_e fmt,
size_t source_num,
...
)
{
va_list args;
va_start( args, source_num);
vsi_nn_kernel_add_source_internal( kernel, fmt, source_num, args );
va_end( args );
}/* vsi_nn_KernelAddSource() */
void vsi_nn_KernelAddBuildOption
(
vsi_nn_kernel_t * kernel,
const char * option
)
{
vsi_nn_kernel_add_build_option( kernel, option );
}/* vsi_nn_KernelAddBuildOption() */
vsi_status vsi_nn_KernelNodePassParam
(
vsi_nn_kernel_node_t node,
vsi_nn_kernel_node_param_t * params,
size_t num
)
{
return vsi_nn_kernel_node_pass_param( node, params, num );
}/* vsi_nn_KernelNodePassParam() */
vsi_nn_kernel_node_t vsi_nn_KernelCreateNodeExt
(
vsi_nn_graph_t * graph,
vsi_nn_kernel_t * kernel,
const char** resources
)
{
return vsi_nn_kernel_create_node_ext( graph, kernel, resources );
}/* vsi_nn_KernelCreateNodeExt() */
vsi_nn_kernel_scalar_t vsi_nn_kernelScalarCreate
(
vsi_nn_graph_t * graph,
vsi_nn_kernel_dtype_e dtype,
const void * data
)
{
return vsi_nn_kernel_scalar_create( graph, dtype, data );
}/* vsi_nn_kernelScalarCreate() */
vsi_status vsi_nn_KernelGpuConfig
(
vsi_nn_kernel_node_t node,
const gpu_param_t * gpu_param
)
{
return vsi_nn_kernel_gpu_config( node, gpu_param );
}/* vsi_nn_KernelGpuConfig() */
static vsi_bool _check_shader_support(vsi_nn_graph_t* graph)
{
int32_t enableShader = graph->ctx->options.enable_shader;

26
src/tim/vx/ops/custom_base.cc
View File

@ -95,7 +95,7 @@ vsi_bool op_setup(vsi_nn_node_t* self, vsi_nn_tensor_t** inputs,
vsi_bool op_compute(vsi_nn_node_t* self, vsi_nn_tensor_t** inputs,
vsi_nn_tensor_t** outputs) {
vsi_status status = VSI_FAILURE;
auto kernel = vsi_nn_kernel_create(VSI_NN_KERNEL_TYPE_CL);
auto kernel = vsi_nn_KernelCreate(VSI_NN_KERNEL_TYPE_CL);
CustomOpBase* op_this =
reinterpret_cast<CustomOpBase*>(self->nn_param.client_param);
@ -149,18 +149,18 @@ vsi_bool op_compute(vsi_nn_node_t* self, vsi_nn_tensor_t** inputs,
kernel->info.initialize =
reinterpret_cast<vx_kernel_initialize_f>(op_this->init_kernel_);
vsi_nn_kernel_add_source(kernel, VSI_NN_GPU_SOURCE_FMT_EXECUTABLE, 1,
vsi_nn_KernelAddSource(kernel, VSI_NN_GPU_SOURCE_FMT_EXECUTABLE, 1,
"executable_name");
vsi_nn_kernel_add_source(kernel, VSI_NN_GPU_SOURCE_FMT_CODE, 2, "helper",
vsi_nn_KernelAddSource(kernel, VSI_NN_GPU_SOURCE_FMT_CODE, 2, "helper",
"fmt_code_name");
const char* tmp[] = {"", op_this->kernel_resource_};
const char** resource = tmp;
vsi_nn_kernel_add_build_option(kernel, build_option.c_str());
vsi_nn_KernelAddBuildOption(kernel, build_option.c_str());
auto node = vsi_nn_kernel_create_node_ext(self->graph, kernel, resource);
auto node = vsi_nn_KernelCreateNodeExt(self->graph, kernel, resource);
if (node) {
vsi_nn_kernel_node_param_t node_params[param_num] = {NULL};
vsi_nn_kernel_node_pack_io(node_params, param_num, inputs,
@ -170,22 +170,22 @@ vsi_bool op_compute(vsi_nn_node_t* self, vsi_nn_tensor_t** inputs,
uint32_t input_start = op_this->input_num_ + op_this->output_num_;
for (uint32_t i = 0; i < op_this->param_list_.size(); i++) {
if (op_this->param_list_[i].type == tim::vx::DataType::FLOAT32) {
node_params[input_start++] = vsi_nn_kernel_scalar_create(
node_params[input_start++] = vsi_nn_kernelScalarCreate(
self->graph, F32, &(op_this->param_list_[i].data.f));
} else if (op_this->param_list_[i].type == tim::vx::DataType::UINT32) {
node_params[input_start++] = vsi_nn_kernel_scalar_create(
node_params[input_start++] = vsi_nn_kernelScalarCreate(
self->graph, U32, &(op_this->param_list_[i].data.ui));
} else if (op_this->param_list_[i].type == tim::vx::DataType::INT32) {
node_params[input_start++] = vsi_nn_kernel_scalar_create(
node_params[input_start++] = vsi_nn_kernelScalarCreate(
self->graph, I32, &(op_this->param_list_[i].data.i));
} else if (op_this->param_list_[i].type == tim::vx::DataType::BOOL8) {
node_params[input_start++] = vsi_nn_kernel_scalar_create(
node_params[input_start++] = vsi_nn_kernelScalarCreate(
self->graph, BOOL8, &(op_this->param_list_[i].data.b));
}else if (op_this->param_list_[i].type == tim::vx::DataType::UINT8) {
node_params[input_start++] = vsi_nn_kernel_scalar_create(
node_params[input_start++] = vsi_nn_kernelScalarCreate(
self->graph, U8, &(op_this->param_list_[i].data.b));
} else if (op_this->param_list_[i].type == tim::vx::DataType::INT8) {
node_params[input_start++] = vsi_nn_kernel_scalar_create(
node_params[input_start++] = vsi_nn_kernelScalarCreate(
self->graph, I8, &(op_this->param_list_[i].data.b));
} else{
std::cout << "Can not find scalar type in op compute" << std::endl;
@ -194,7 +194,7 @@ vsi_bool op_compute(vsi_nn_node_t* self, vsi_nn_tensor_t** inputs,
}
input_start = op_this->input_num_ + op_this->output_num_;
status = vsi_nn_kernel_node_pass_param(node, node_params, param_num);
status = vsi_nn_KernelNodePassParam(node, node_params, param_num);
for (uint32_t i = 0; i < param_num; i++) {
vsi_nn_kernel_scalar_release(&node_params[input_start + i]);
}
@ -240,7 +240,7 @@ vx_status derive_kernel_init(vx_node node, const vx_reference* param,
gpu_param.local_size[0] = local_size[0];
gpu_param.local_size[1] = local_size[1];
gpu_param.local_size[2] = local_size[2];
status = vsi_nn_kernel_gpu_config(node, &gpu_param);
status = vsi_nn_KernelGpuConfig(node, &gpu_param);
return status;
}