Digi
/
meta-digi
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
meta-digi/meta-digi-dey/dynamic-layers/x-linux-ai/recipes-samples/image-classification/files/nbg/vnn_utils.cc

1371 lines
39 KiB
C++
Raw Blame History

/*
* vnn_utils.cc
*
* This provides helper functions for nbg-benchmark tool and wrappers around OpenVX lib
* function. The function are mainly used for converting data types and loading
* network binary graph.
*
* Author: Othmane AHL ZOUAOUI <othmane.ahlzouaoui@st.com> for STMicroelectronics.
*
* Copyright (c) 2023 STMicroelectronics. All rights reserved.
*
* This software component is licensed by ST under BSD 3-Clause license,
* the "License"; You may not use this file except in compliance with the
* License. You may obtain a copy of the License at:
*
* http://www.opensource.org/licenses/BSD-3-Clause
*/
#include <stdarg.h>
#include "vnn_utils.h"
#ifdef WIN32
static vx_float32 round(vx_float32 x)
{
#if defined(_M_X64)
return (vx_float32) _copysignf(floorf(fabsf(x) + 0.5f), x);
#else
return (vx_float32) _copysign(floorf(fabsf(x) + 0.5f), x);
#endif
}
#endif
vx_uint32 vnn_GetTypeSize(vx_enum format)
{
switch(format)
{
case VX_TYPE_INT8:
case VX_TYPE_UINT8:
case VX_DF_IMAGE_U8:
return 1;
case VX_TYPE_INT16:
case VX_TYPE_UINT16:
case VX_DF_IMAGE_S16:
case VX_DF_IMAGE_U16:
return 2;
case VX_TYPE_INT32:
case VX_TYPE_UINT32:
case VX_DF_IMAGE_S32:
case VX_DF_IMAGE_U32:
return 4;
case VX_TYPE_INT64:
case VX_TYPE_UINT64:
return 8;
case VX_TYPE_FLOAT32:
case VX_DF_IMAGE_F32:
return 4;
case VX_TYPE_FLOAT64:
return 8;
case VX_TYPE_ENUM:
return 4;
case VX_TYPE_FLOAT16:
return 2;
default:
printf("Not support format:%d,line=%d\n",format,__LINE__);
}
return 0;
}
vx_int8 vnn_Fp32toInt8(vx_float32 val, vx_int8 fixedPointPos)
{
vx_int8 result = 0;
if (fixedPointPos > 0)
{
vx_int32 data = (vx_int32) round(val * (vx_float32)(1 << fixedPointPos));
result = (vx_int8)((data > 127) ? 127 : (data < -128) ? -128 : data);
}
else
{
vx_int32 data = (vx_int32) round(val * (1.0f / (vx_float32)(1 << -fixedPointPos)));
result = (vx_int8)((data > 127) ? 127 : (data < -128) ? -128 : data);
}
return result;
}
vx_float32 vnn_Int8toFp32(vx_int8 val, vx_int8 fixedPointPos)
{
vx_float32 result = 0.0f;
if (fixedPointPos > 0)
{
result = (vx_float32)val * (1.0f / ((vx_uint32) (1 << fixedPointPos)));
}
else
{
result = (vx_float32)val * ((vx_float32) (1 << -fixedPointPos));
}
return result;
}
vx_uint8 vnn_Fp32toUint8(vx_float32 val, vx_int32 zeroPoint, vx_float32 scale)
{
vx_uint8 result = 0;
vx_int32 data;
data = (vx_int32) round((val / scale + (vx_uint8)zeroPoint));
if (data > 255)
data = 255;
if (data < 0)
data = 0;
result = (vx_uint8)(data);
return result;
}
vx_float32 vnn_Uint8toFp32(vx_uint8 val, vx_int32 zeroPoint, vx_float32 scale)
{
vx_float32 result = 0.0f;
result = (val - (vx_uint8)zeroPoint) * scale;
return result;
}
vx_int8 vnn_Fp32toAsymInt8(vx_float32 val, vx_int32 zeroPoint, vx_float32 scale)
{
vx_int8 result = 0;
vx_int32 data;
data = (vx_int32) round((val / scale + (vx_uint8)zeroPoint));
if (data > 127)
data = 127;
if (data < -128)
data = -128;
result = (vx_int8)(data);
return result;
}
vx_float32 vnn_AsymInt8toFp32(vx_int8 val, vx_int32 zeroPoint, vx_float32 scale)
{
vx_float32 result = 0.0f;
result = (val - (vx_int8)zeroPoint) * scale;
return result;
}
vx_float32 vnn_Int16toFp32(vx_int16 val, vx_int8 fixedPointPos)
{
vx_float32 result = 0.0f;
vx_float32 value = val;
if (fixedPointPos > 0)
{
result = value * (1.0f / ((vx_uint32) (1 << fixedPointPos)));
}
else
{
result = value * ((vx_float32) (1 << -fixedPointPos));
}
return result;
}
vx_int16 vnn_Fp32toInt16(vx_float32 val, vx_int8 fixedPointPos)
{
vx_int16 result = 0;
if (fixedPointPos > 0)
{
vx_int32 data = (vx_int32) round(val * (vx_float32)(1 << fixedPointPos));
result = (vx_int16)((data > 32767) ? 32767 : (data < -32768) ? -32768 : data);
}
else
{
vx_int32 data = (vx_int32) round(val * (1.0f / (vx_float32)(1 << -fixedPointPos)));
result = (vx_int16)((data > 32767) ? 32767 : (data < -32768) ? -32768 : data);
}
return result;
}
vx_int16 vnn_Fp32toAsymInt16(vx_float32 val, vx_int32 zeroPoint, vx_float32 scale)
{
vx_int16 result = 0;
vx_int32 data;
data = (vx_int32) round((val / scale + (vx_int16)zeroPoint));
if (data > 32767)
data = 32767;
if (data < -32768)
data = -32768;
result = (vx_int16)(data);
return result;
}
vx_float32 vnn_AsymInt16toFp32(vx_int16 val, vx_int32 zeroPoint, vx_float32 scale)
{
vx_float32 result = 0.0f;
result = (val - (vx_int16)zeroPoint) * scale;
return result;
}
vx_int16 vnn_Fp32toFp16(vx_float32 val)
{
#define F16_EXPONENT_BITS 0x1F
#define F16_EXPONENT_BIAS 15
#define F16_EXPONENT_SHIFT 10
#define F16_MANTISSA_BITS ((1 << F16_EXPONENT_SHIFT) - 1)
#define F16_MANTISSA_SHIFT (23 - F16_EXPONENT_SHIFT)
#define F16_MAX_EXPONENT (F16_EXPONENT_BITS << F16_EXPONENT_SHIFT)
vx_uint32 f32 = (*(vx_uint32 *) &val);
vx_int16 f16 = 0;
/* Decode IEEE 754 little-endian 32-bit floating-point value */
int sign = (f32 >> 16) & 0x8000;
/* Map exponent to the range [-127,128] */
int exponent = ((f32 >> 23) & 0xff) - 127;
int mantissa = f32 & 0x007fffff;
if (exponent == 128)
{ /* Infinity or NaN */
if (mantissa)
{
/* Flush NaN to 0. */
f16 = (vx_int16)sign;
}
else
{
/* Clamp to HALF_MAX/HALF_MIN. */
f16 = (vx_int16)(sign | ((F16_EXPONENT_BITS - 1) << F16_EXPONENT_SHIFT) | F16_MANTISSA_BITS);
}
}
else if (exponent > 15)
{ /* Overflow - clamp to HALF_MAX/HALF_MIN. */
f16 = (vx_int16)(sign | ((F16_EXPONENT_BITS - 1) << F16_EXPONENT_SHIFT) | F16_MANTISSA_BITS);
}
else if (exponent > -15)
{ /* Representable value */
/* RTNE */
int roundingBit = (mantissa >> (F16_MANTISSA_SHIFT - 1)) & 0x1;
int stickyBits = mantissa & 0xFFF;
exponent += F16_EXPONENT_BIAS;
mantissa >>= F16_MANTISSA_SHIFT;
if (roundingBit)
{
if (stickyBits || (mantissa & 0x1))
{
mantissa++;
if (mantissa > F16_MANTISSA_BITS)
{
exponent++;
if (exponent > 30)
{
/* Clamp to HALF_MAX/HALF_MIN. */
exponent--;
mantissa--;
}
else
{
mantissa &= F16_MANTISSA_BITS;
}
}
}
}
f16 = (vx_int16)(sign | exponent << F16_EXPONENT_SHIFT | mantissa);
}
else
{
f16 = (vx_int16)sign;
}
return f16;
}
vx_float32 vnn_Fp16toFp32(const vx_uint16 in)
{
vx_uint32 t1;
vx_uint32 t2;
vx_uint32 t3;
vx_float32 out;
t1 = in & 0x7fff; // Non-sign bits
t2 = in & 0x8000; // Sign bit
t3 = in & 0x7c00; // Exponent
t1 <<= 13; // Align mantissa on MSB
t2 <<= 16; // Shift sign bit into position
t1 += 0x38000000; // Adjust bias
t1 = (t3 == 0 ? 0 : t1); // Denormals-as-zero
t1 |= t2; // Re-insert sign bit
*((uint32_t*)&out) = t1;
return out;
}
vx_uint32 vnn_GetTensorSize(vx_tensor tensor)
{
vx_uint32 size[6];
vx_uint32 num=1,num_of_dim=0;
vx_uint32 i = 0;
vxQueryTensor(tensor, VX_TENSOR_NUMBER_OF_DIMS, &num_of_dim, sizeof(num_of_dim));
vxQueryTensor(tensor, VX_TENSOR_DIMS, size, sizeof(size));
for(i = 0; i < num_of_dim;i++)
num = num*size[i];
return num;
}
vx_uint32 vnn_GetTensorDims(vx_tensor tensor)
{
vx_uint32 size[6];
vx_uint32 num_of_dim=0;
vxQueryTensor(tensor, VX_TENSOR_NUMBER_OF_DIMS, &num_of_dim, sizeof(num_of_dim));
return num_of_dim;
}
vx_uint32 vnn_GetTensorBufferSize(vx_tensor tensor)
{
vx_uint32 size[6];
vx_uint32 num=1,num_of_dim=0;
vx_enum data_format;
vx_uint32 i = 0;
vxQueryTensor(tensor, VX_TENSOR_NUMBER_OF_DIMS, &num_of_dim, sizeof(num_of_dim));
vxQueryTensor(tensor, VX_TENSOR_DIMS, size, sizeof(size));
vxQueryTensor(tensor, VX_TENSOR_DATA_TYPE, &data_format, sizeof(data_format));
num = vnn_GetTypeSize(data_format);
for(i = 0; i < num_of_dim;i++)
num = num*size[i];
return num;
}
vx_status vnn_CopyTensorToData(vx_tensor tensor,void **buf)
{
vx_uint32 size[MAX_NUM_DIMS];
vx_size stride[MAX_NUM_DIMS];
vx_size start[MAX_NUM_DIMS];
vx_size end[MAX_NUM_DIMS];
vx_uint32 num_of_dim=0;
vx_status status = VX_SUCCESS;
vx_uint32 i = 0;
vx_enum data_format;
vx_uint32 data_size = 0;
vx_context context = vxGetContext((vx_reference)tensor);
status |= vxQueryTensor(tensor, VX_TENSOR_NUMBER_OF_DIMS, &num_of_dim, sizeof(num_of_dim));
status |=vxQueryTensor(tensor, VX_TENSOR_DIMS, size, sizeof(size));
status |=vxQueryTensor(tensor, VX_TENSOR_DATA_TYPE, &data_format, sizeof(data_format));
stride[0] = vnn_GetTypeSize(data_format);
for (i=0; i< num_of_dim; i++)
{
start[i] = 0;
end[i] = (vx_size)size[i];
if(i>0)
{
stride[i] = stride[i - 1] * size[i - 1];
}
}
data_size = vnn_GetTensorBufferSize(tensor);
if(*buf == NULL)
*buf = (void*)malloc(data_size);
status = vxCopyTensorPatch(tensor, num_of_dim,start,end,stride,(void*)*buf, VX_READ_ONLY,0);
return status;
}
vx_status vnn_CopyTensorToFloat32Data(vx_tensor tensor,vx_float32 **buf)
{
vx_uint32 size[6];
vx_uint32 stride_size[6];
vx_uint32 num=1,num_of_dim=0;
vx_tensor_addressing user_addr = NULL;
vx_status status = VX_SUCCESS;
vx_uint32 i = 0;
vx_enum data_format,quant_format;
vx_uint32 data_size = 0;
vx_context context = vxGetContext((vx_reference)tensor);
void *data = NULL;
status |=vxQueryTensor(tensor, VX_TENSOR_DATA_TYPE, &data_format, sizeof(data_format));
status |=vxQueryTensor(tensor, VX_TENSOR_QUANT_FORMAT, &quant_format, sizeof(data_format));
num = vnn_GetTensorSize(tensor);
if(*buf == NULL)
*buf = (vx_float32*)malloc(num * sizeof(vx_float32));
status |= vnn_CopyTensorToData(tensor,&data);
if(quant_format == VX_QUANT_DYNAMIC_FIXED_POINT && data_format == VX_TYPE_INT8)
{
vx_int8 fl=0;
status |=vxQueryTensor(tensor, VX_TENSOR_FIXED_POINT_POSITION, &fl, sizeof(fl));
if(data_format == VX_TYPE_INT8)
{
for(i = 0;i < num; i++)
(*buf)[i]= vnn_Int8toFp32( ((vx_int8*)data)[i],fl);
}
}
else if(quant_format == VX_QUANT_DYNAMIC_FIXED_POINT && data_format == VX_TYPE_INT16)
{
vx_int8 fl=0;
status |=vxQueryTensor(tensor, VX_TENSOR_FIXED_POINT_POSITION, &fl, sizeof(fl));
for(i = 0;i < num; i++)
(*buf)[i]= vnn_Int16toFp32( ((vx_int16*)data)[i],fl);
}
else if(quant_format == VX_QUANT_AFFINE_SCALE && data_format == VX_TYPE_UINT8)
{
vx_int32 zp=0;
vx_float32 scale;
status |=vxQueryTensor(tensor, VX_TENSOR_ZERO_POINT, &zp, sizeof(zp));
status |=vxQueryTensor(tensor, VX_TENSOR_SCALE, &scale, sizeof(scale));
for(i = 0;i < num; i++)
(*buf)[i]= vnn_Uint8toFp32( ((vx_uint8*)data)[i],zp,scale);
}
else if(quant_format == VX_QUANT_AFFINE_SCALE && data_format == VX_TYPE_INT8)
{
vx_int32 zp=0;
vx_float32 scale;
status |=vxQueryTensor(tensor, VX_TENSOR_ZERO_POINT, &zp, sizeof(zp));
status |=vxQueryTensor(tensor, VX_TENSOR_SCALE, &scale, sizeof(scale));
for(i = 0;i < num; i++)
(*buf)[i]= vnn_AsymInt8toFp32( ((vx_int8*)data)[i],zp,scale);
}
else if(quant_format == VX_QUANT_AFFINE_SCALE && data_format == VX_TYPE_INT16)
{
vx_int32 zp=0;
vx_float32 scale;
status |=vxQueryTensor(tensor, VX_TENSOR_ZERO_POINT, &zp, sizeof(zp));
status |=vxQueryTensor(tensor, VX_TENSOR_SCALE, &scale, sizeof(scale));
for(i = 0;i < num; i++)
(*buf)[i]= vnn_AsymInt16toFp32( ((vx_int8*)data)[i],zp,scale);
}
else if (quant_format ==VX_QUANT_NONE && data_format == VX_TYPE_UINT8)
{
for(i = 0;i < num; i++)
(*buf)[i] = ((vx_uint8*)data)[i];
}
else if(data_format == VX_TYPE_FLOAT16)/*VX_QUANT_NONE*/
{
for(i = 0;i < num; i++)
(*buf)[i]= vnn_Fp16toFp32( ((vx_int16*)data)[i]);
}
else if(data_format == VX_TYPE_FLOAT32)/*VX_QUANT_NONE*/
{
for(i = 0;i < num; i++)
(*buf)[i] = ((vx_float32*)data)[i];
}
else if(quant_format ==VX_QUANT_NONE && data_format == VX_TYPE_INT32)/*VX_QUANT_NONE*/
{
for(i = 0;i < num; i++)
(*buf)[i] = (vx_float32)(((vx_int32*)data)[i]);
}
else if(quant_format ==VX_QUANT_NONE && data_format == VX_TYPE_UINT32)/*VX_QUANT_NONE*/
{
for(i = 0;i < num; i++)
(*buf)[i] = (vx_float32)(((vx_uint32*)data)[i]);
}
else
{
printf("can't support format!\n");
status = VX_FAILURE;
}
if(data){
free(data);
}
return status;
}
vx_status vnn_CopyDataToTensor(vx_tensor tensor,void *buf)
{
vx_uint32 size[MAX_NUM_DIMS];
vx_size stride[MAX_NUM_DIMS];
vx_size start[MAX_NUM_DIMS];
vx_size end[MAX_NUM_DIMS];
vx_uint32 num_of_dim=0;
vx_tensor_addressing user_addr = NULL;
vx_status status = VX_SUCCESS;
vx_uint32 i = 0;
vx_enum data_format;
vx_uint32 data_size = 0;
vx_context context = vxGetContext((vx_reference)tensor);
status |= vxQueryTensor(tensor, VX_TENSOR_NUMBER_OF_DIMS, &num_of_dim, sizeof(num_of_dim));
status |=vxQueryTensor(tensor, VX_TENSOR_DIMS, size, sizeof(size));
status |=vxQueryTensor(tensor, VX_TENSOR_DATA_TYPE, &data_format, sizeof(data_format));
stride[0] = vnn_GetTypeSize(data_format);
for (i=0; i< num_of_dim; i++)
{
start[i] = 0;
end[i] = (vx_size)size[i];
if(i>0)
{
stride[i] = stride[i - 1] * size[i - 1];
}
}
status = vxCopyTensorPatch(tensor, num_of_dim,start,end,stride,buf, VX_WRITE_ONLY,0);
return status;
}
vx_status vnn_CopyFloat32DataToTensor(vx_tensor tensor,vx_float32 *buf)
{
vx_uint32 size[6];
vx_uint32 stride_size[6];
vx_uint32 num=1,num_of_dim=0;
vx_tensor_addressing user_addr = NULL;
vx_status status = VX_SUCCESS;
vx_uint32 i = 0;
vx_enum data_format,quant_format;
vx_uint32 data_size = 0;
vx_context context = vxGetContext((vx_reference)tensor);
void *data = NULL;
status |=vxQueryTensor(tensor, VX_TENSOR_DATA_TYPE, &data_format, sizeof(data_format));
status |=vxQueryTensor(tensor, VX_TENSOR_QUANT_FORMAT, &quant_format, sizeof(data_format));
num = vnn_GetTensorSize(tensor);
data = (void*)malloc(vnn_GetTensorBufferSize(tensor));
if(quant_format == VX_QUANT_DYNAMIC_FIXED_POINT && data_format == VX_TYPE_INT8)
{
vx_int8 fl=0;
status |=vxQueryTensor(tensor, VX_TENSOR_FIXED_POINT_POSITION, &fl, sizeof(fl));
if(data_format == VX_TYPE_INT8)
{
for(i = 0;i < num; i++)
((vx_int8*)data)[i] = vnn_Fp32toInt8(buf[i],fl);
}
}
else if(quant_format == VX_QUANT_DYNAMIC_FIXED_POINT && data_format == VX_TYPE_INT16)
{
vx_int8 fl=0;
status |=vxQueryTensor(tensor, VX_TENSOR_FIXED_POINT_POSITION, &fl, sizeof(fl));
for(i = 0;i < num; i++)
((vx_int16*)data)[i] = vnn_Fp32toInt16(buf[i],fl);
}
else if(quant_format == VX_QUANT_AFFINE_SCALE && data_format == VX_TYPE_UINT8)
{
vx_int32 zp=0;
vx_float32 scale;
status |=vxQueryTensor(tensor, VX_TENSOR_ZERO_POINT, &zp, sizeof(zp));
status |=vxQueryTensor(tensor, VX_TENSOR_SCALE, &scale, sizeof(scale));
for(i = 0;i < num; i++)
((vx_uint8*)data)[i] = vnn_Fp32toUint8(buf[i],zp,scale);
}
else if(quant_format == VX_QUANT_AFFINE_SCALE && data_format == VX_TYPE_INT8)
{
vx_int32 zp=0;
vx_float32 scale;
status |=vxQueryTensor(tensor, VX_TENSOR_ZERO_POINT, &zp, sizeof(zp));
status |=vxQueryTensor(tensor, VX_TENSOR_SCALE, &scale, sizeof(scale));
for(i = 0;i < num; i++)
((vx_int8*)data)[i] = vnn_Fp32toAsymInt8(buf[i],zp,scale);
}
else if(quant_format == VX_QUANT_AFFINE_SCALE && data_format == VX_TYPE_INT16)
{
vx_int32 zp=0;
vx_float32 scale;
status |=vxQueryTensor(tensor, VX_TENSOR_ZERO_POINT, &zp, sizeof(zp));
status |=vxQueryTensor(tensor, VX_TENSOR_SCALE, &scale, sizeof(scale));
for(i = 0;i < num; i++)
((vx_int16*)data)[i] = vnn_Fp32toAsymInt16(buf[i],zp,scale);
}
else if(quant_format == VX_QUANT_NONE && data_format == VX_TYPE_UINT8)
{
for(i = 0;i < num; i++)
((vx_uint8*)data)[i] = (vx_uint8)buf[i];
}
else if(data_format == VX_TYPE_FLOAT16)/*VX_QUANT_NONE*/
{
for(i = 0;i < num; i++)
((vx_int16*)data)[i] = vnn_Fp32toFp16(buf[i]);
}
else if(data_format == VX_TYPE_FLOAT32)/*VX_QUANT_NONE*/
{
for(i = 0;i < num; i++)
((vx_float32*)data)[i] = buf[i];
}
else if(quant_format == VX_QUANT_NONE && data_format == VX_TYPE_INT32)/*VX_QUANT_NONE*/
{
for(i = 0;i < num; i++)
((vx_int32*)data)[i] = (vx_int32)buf[i];
}
else if(quant_format == VX_QUANT_NONE && data_format == VX_TYPE_UINT32)/*VX_QUANT_NONE*/
{
for(i = 0;i < num; i++)
((vx_uint32*)data)[i] = (vx_uint32)buf[i];
}
else
{
printf("can't support format!\n");
status = VX_FAILURE;
}
status |= vnn_CopyDataToTensor(tensor,data);
if(data){
free(data);
}
return status;
}
static file_type get_file_type(const char *file_name)
{
const char *ptr;
char sep = '.';
uint32_t pos,n;
char buff[32] = {0};
ptr = strrchr(file_name, sep);
pos = ptr - file_name;
n = strlen(file_name) - (pos + 1);
strncpy(buff, file_name+(pos+1), n);
if(strcmp(buff, "tensor") == 0
|| strcmp(buff, "txt") == 0)
{
return FILE_TYPE_TEXT;
}
else if(strcmp(buff, "bin") == 0
|| strcmp(buff, "dat") == 0)
{
return FILE_TYPE_BIN;
}
else
{
return FILE_TYPE_NOT_SUPPORT;
}
}
vx_status vnn_LoadTensorRandom(vx_tensor tensor)
{
vx_status status = VX_SUCCESS;
vx_int32 i=0;
char dumpInput[128];
vx_int32 num = vnn_GetTensorSize(tensor);
vx_uint8 *buf = (vx_uint8*)malloc(num*sizeof(vx_uint8));
memset(buf, 0, num * sizeof(vx_uint8));
status |= vnn_CopyDataToTensor(tensor,buf);
_CHECK_STATUS(status, exit);
//printf("Info: Copied a buffer of a size of %d to tensor.\n", num);
snprintf(dumpInput, sizeof(dumpInput), "input.dat");
vnn_SaveTensorToFileAsBinary(tensor, dumpInput);
status = VX_SUCCESS;
if(buf)
free(buf);
exit:
return status;
}
vx_status vnn_LoadTensorFromFile(vx_tensor tensor,char *filename)
{
vx_status status = VX_SUCCESS;
vx_int32 i=0;
file_type ft = get_file_type(filename);
if(ft == FILE_TYPE_TEXT) /*tensor*/
{
vx_int32 num = vnn_GetTensorSize(tensor);
vx_float32 *buf = (vx_float32*)malloc(num*sizeof(vx_float32));
FILE *fp = fopen(filename,"r");
if(fp)
{
for(i = 0;i < num;i++)
{
vx_int32 ret = fscanf(fp,"%f",&buf[i]);
if(ret <=0 )
{
printf("There is no enough data!\n");
status = VX_FAILURE;
break;
}
}
status |= vnn_CopyFloat32DataToTensor(tensor,buf);
}
else
{
printf("can't open file %s\n",filename);
status |= VX_FAILURE;
}
if(buf){
free(buf);
}
if(fp)
fclose(fp);
}
else if(ft == FILE_TYPE_BIN) /*dat or bin*/
{
vx_int32 size = vnn_GetTensorBufferSize(tensor);
void *buf = (void*)malloc(size);
FILE *fp = fopen(filename,"rb");
if(fp)
{
vx_int32 ret = fread(buf,1,size,fp);
if(ret < size)
{
printf("There is no enough data!\n");
status = VX_FAILURE;
}
vnn_CopyDataToTensor(tensor,buf);
}
else
{
printf("can't open file %s\n",filename);
status |= VX_FAILURE;
}
if(buf){
free(buf);
}
if(fp)
fclose(fp);
}
else
{
printf("not support file type:%s\n",filename);
status |= VX_FAILURE;
}
return status;
}
vx_status vnn_SaveTensorToFileAsFloat32(vx_tensor tensor,char *filename)
{
vx_status status = VX_SUCCESS;
vx_float32 *buf = NULL;
vx_int32 i=0;
FILE *fp = NULL;
vx_uint32 size[6];
vx_uint32 num=0;
num = vnn_GetTensorSize(tensor);
fp = fopen(filename,"w");
if(fp)
{
status |= vnn_CopyTensorToFloat32Data(tensor,&buf);
for(i = 0;i<num;i++)
fprintf(fp,"%f\n",buf[i]);
fclose(fp);
}
else
status = VX_FAILURE;
if(buf){
free(buf);
}
return status;
}
vx_status vnn_SaveTensorToFileAsBinary(vx_tensor tensor,char *filename)
{
vx_status status = VX_SUCCESS;
void *buf = NULL;
vx_int32 i=0;
FILE *fp = NULL;
vx_uint32 size[6];
vx_uint32 num_of_dim=0;
vx_uint32 buf_size = vnn_GetTensorBufferSize(tensor);
fp = fopen(filename,"wb");
if(fp)
{
status |= vnn_CopyTensorToData(tensor,&buf);
fwrite(buf,1,buf_size,fp);
fclose(fp);
}
else
status = VX_FAILURE;
if(buf){
free(buf);
}
return status;
}
static vx_status LoadBinaryFromFile(char *filename,void *buf, vx_int32 size)
{
FILE *fp = fopen(filename,"rb");
vx_int32 ret = fread(buf,1,size,fp);
fclose(fp);
return ret == size ? VX_SUCCESS : VX_FAILURE;
}
static vx_status LoadTextFromFile(char *filename,void *buf, vx_int32 size,vx_enum data_type)
{
vx_status status = VX_SUCCESS;
vx_float32 *temp = (vx_float32*)malloc(size*sizeof(vx_float32));
FILE *fp = fopen(filename,"r");
vx_int32 elm_size = vnn_GetTypeSize(data_type);
vx_int32 count = size/elm_size;
for(int i=0;i< count;i++)
fscanf(fp,"%f",&temp[i]);
fclose(fp);
switch(data_type)
{
case VX_TYPE_INT8:
for(int i=0;i< count;i++)
((vx_int8*)buf)[i] = (vx_int8)temp[i];
break;
case VX_TYPE_UINT8:
case VX_DF_IMAGE_U8:
for(int i=0;i< count;i++)
((vx_uint8*)buf)[i] = (vx_uint8)temp[i];
break;
case VX_TYPE_INT16:
case VX_DF_IMAGE_S16:
for(int i=0;i< count;i++)
((vx_int16*)buf)[i] = (vx_int16)temp[i];
break;
case VX_DF_IMAGE_U16:
case VX_TYPE_UINT16:
for(int i=0;i< count;i++)
((vx_uint16*)buf)[i] = (vx_uint16)temp[i];
break;
case VX_TYPE_INT32:
case VX_DF_IMAGE_S32:
for(int i=0;i< count;i++)
((vx_int32*)buf)[i] = (vx_int32)temp[i];
break;
case VX_TYPE_UINT32:
case VX_DF_IMAGE_U32:
for(int i=0;i< count;i++)
((vx_uint32*)buf)[i] = (vx_uint32)temp[i];
break;
case VX_TYPE_FLOAT32:
case VX_DF_IMAGE_F32:
for(int i=0;i< count;i++)
((vx_float32*)buf)[i] = (vx_float32)temp[i];
break;
default:
printf("Not support format:%d,line=%d\n",data_type,__LINE__);
status = VX_FAILURE;
}
if(temp){
free(temp);
}
return status;
}
static vx_status SaveBinaryToFile(char *filename,void *buf, vx_int32 size)
{
FILE *fp = fopen(filename,"wb");
vx_int32 ret = fwrite(buf,1,size,fp);
fclose(fp);
return ret == size ? VX_SUCCESS : VX_FAILURE;
}
static vx_status SaveTextToFile(char *filename,void *buf, vx_int32 size,vx_enum data_type)
{
vx_status status = VX_SUCCESS;
vx_int32 elm_size = vnn_GetTypeSize(data_type);
vx_int32 count = size/elm_size;
vx_float32 *temp = (vx_float32*)malloc(count*sizeof(vx_float32));
switch(data_type)
{
case VX_TYPE_INT8:
for(int i=0;i< count;i++)
temp[i] = (vx_float32)((vx_int8*)buf)[i];
break;
case VX_TYPE_UINT8:
case VX_DF_IMAGE_U8:
for(int i=0;i< count;i++)
temp[i] = (vx_float32)((vx_uint8*)buf)[i];
break;
case VX_TYPE_INT16:
case VX_DF_IMAGE_S16:
for(int i=0;i< count;i++)
temp[i] = (vx_float32)((vx_int16*)buf)[i];
break;
case VX_DF_IMAGE_U16:
case VX_TYPE_UINT16:
for(int i=0;i< count;i++)
temp[i] = (vx_float32)((vx_uint16*)buf)[i];
break;
case VX_TYPE_INT32:
case VX_DF_IMAGE_S32:
for(int i=0;i< count;i++)
temp[i] = (vx_float32)((vx_int32*)buf)[i];
break;
case VX_TYPE_UINT32:
case VX_DF_IMAGE_U32:
for(int i=0;i< count;i++)
temp[i] = (vx_float32)((vx_uint32*)buf)[i];
break;
case VX_TYPE_FLOAT32:
case VX_DF_IMAGE_F32:
for(int i=0;i< count;i++)
temp[i] = ((vx_float32*)buf)[i];
break;
default:
printf("Not support format:%d,line=%d\n",data_type,__LINE__);
status = VX_FAILURE;
}
FILE *fp = fopen(filename,"w");
for(int i=0;i< count;i++)
fprintf(fp,"%f\n",temp[i]);
fclose(fp);
if(temp){
free(temp);
}
return status;
}
vx_status vnn_LoadImageFromFile(vx_image image,char *filename)
{
vx_status status = VX_SUCCESS;
vx_int32 i=0;
file_type ft = get_file_type(filename);
vx_imagepatch_addressing_t imgInfo = VX_IMAGEPATCH_ADDR_INIT;
vx_uint32 width,height;
vx_df_image format;
vxQueryImage(image, VX_IMAGE_WIDTH, &width, sizeof(vx_uint32));
vxQueryImage(image, VX_IMAGE_HEIGHT, &height, sizeof(vx_uint32));
vxQueryImage(image, VX_IMAGE_FORMAT, &format, sizeof(format));
void* ptr = NULL;
vx_rectangle_t rect = {0,0,width,height};
vx_map_id map_id = 0;
vx_int32 size = width*height*vnn_GetTypeSize(format);
status |= vxMapImagePatch(image, &rect, 0, &map_id, &imgInfo, (void**)&ptr, VX_WRITE_ONLY, VX_MEMORY_TYPE_HOST, 0);
if(ft == FILE_TYPE_TEXT)
LoadTextFromFile(filename,ptr,size,format);
else if(ft == FILE_TYPE_BIN)
LoadBinaryFromFile(filename,ptr,size);
else
{
status = VX_FAILURE;
printf("Not support file type:%d,line=%d\n",filename,__LINE__);
}
status |= vxUnmapImagePatch(image, map_id);
return status;
}
vx_status vnn_SaveImageToFile(vx_image image,char *filename)
{
vx_status status = VX_SUCCESS;
vx_int32 i=0;
file_type ft = get_file_type(filename);
vx_imagepatch_addressing_t imgInfo = VX_IMAGEPATCH_ADDR_INIT;
vx_uint32 width,height;
vx_df_image format;
vxQueryImage(image, VX_IMAGE_WIDTH, &width, sizeof(vx_uint32));
vxQueryImage(image, VX_IMAGE_HEIGHT, &height, sizeof(vx_uint32));
vxQueryImage(image, VX_IMAGE_FORMAT, &format, sizeof(format));
void* ptr = NULL;
vx_rectangle_t rect = {0,0,width,height};
vx_map_id map_id = 0;
vx_int32 size = width*height*vnn_GetTypeSize(format);
status |= vxMapImagePatch(image, &rect, 0, &map_id, &imgInfo, (void**)&ptr, VX_READ_ONLY, VX_MEMORY_TYPE_HOST, 0);
if(ft == FILE_TYPE_TEXT)
SaveTextToFile(filename,ptr,size,format);
else if(ft == FILE_TYPE_BIN)
SaveBinaryToFile(filename,ptr,size);
else
{
status = VX_FAILURE;
printf("Not support file type:%d,line=%d\n",filename,__LINE__);
}
status |= vxUnmapImagePatch(image, map_id);
return status;
}
vx_status vnn_LoadArrayFromFile(vx_array arr,char *filename)
{
vx_status status = VX_SUCCESS;
vx_int32 i=0;
file_type ft = get_file_type(filename);
vx_size itemNumber = 0;
vx_size itemSize = 0;
vx_enum itemType;
vxQueryArray(arr, VX_ARRAY_CAPACITY, &itemNumber, sizeof(itemNumber));
vxQueryArray(arr, VX_ARRAY_ITEMSIZE, &itemSize, sizeof(itemSize));
vxQueryArray(arr, VX_ARRAY_ITEMTYPE, &itemType, sizeof(itemType));
void* ptr = NULL;
vx_map_id map_id = 0;
vx_int32 size = itemNumber*itemSize;
status |= vxMapArrayRange(arr, 0, itemNumber,&map_id, &itemSize, (void**)&ptr, VX_WRITE_ONLY,VX_MEMORY_TYPE_HOST,0);
if(ft == FILE_TYPE_TEXT)
LoadTextFromFile(filename,ptr,size,itemType);
else if(ft == FILE_TYPE_BIN)
LoadBinaryFromFile(filename,ptr,size);
else
{
status = VX_FAILURE;
printf("Not support file type:%d,line=%d\n",filename,__LINE__);
}
status |= vxUnmapArrayRange(arr, map_id);
return status;
}
vx_status vnn_SaveArrayToFile(vx_array arr,char *filename)
{
vx_status status = VX_SUCCESS;
vx_int32 i=0;
file_type ft = get_file_type(filename);
vx_size itemNumber = 0;
vx_size itemSize = 0;
vx_enum itemType;
vxQueryArray(arr, VX_ARRAY_CAPACITY, &itemNumber, sizeof(itemNumber));
vxQueryArray(arr, VX_ARRAY_ITEMSIZE, &itemSize, sizeof(itemSize));
vxQueryArray(arr, VX_ARRAY_ITEMTYPE, &itemType, sizeof(itemType));
void* ptr = NULL;
vx_map_id map_id = 0;
vx_int32 size = itemNumber*itemSize;
status |= vxMapArrayRange(arr, 0, itemNumber,&map_id, &itemSize, (void**)&ptr, VX_READ_ONLY,VX_MEMORY_TYPE_HOST,0);
if(ft == FILE_TYPE_TEXT)
SaveTextToFile(filename,ptr,size,itemType);
else if(ft == FILE_TYPE_BIN)
SaveBinaryToFile(filename,ptr,size);
else
{
status = VX_FAILURE;
printf("Not support file type:%d,line=%d\n",filename,__LINE__);
}
status |= vxUnmapArrayRange(arr, map_id);
return status;
}
vx_status vnn_LoadScalarFromFile(vx_scalar scalar,char *filename)
{
vx_status status = VX_SUCCESS;
vx_int32 i=0;
file_type ft = get_file_type(filename);
vx_enum data_type;
vx_float32 value;
vxQueryScalar(scalar, VX_SCALAR_TYPE, &data_type, sizeof(data_type));
vx_int32 size = vnn_GetTypeSize(data_type);
if(ft == FILE_TYPE_TEXT)
LoadTextFromFile(filename,&value,size,data_type);
else if(ft == FILE_TYPE_BIN)
LoadBinaryFromFile(filename,&value,size);
else
{
status = VX_FAILURE;
printf("Not support file type:%d,line=%d\n",filename,__LINE__);
}
vxCopyScalar(scalar,&value,VX_WRITE_ONLY,VX_MEMORY_TYPE_HOST);
return status;
}
vx_status vnn_SaveScalarToFile(vx_scalar scalar,char *filename)
{
vx_status status = VX_SUCCESS;
vx_int32 i=0;
file_type ft = get_file_type(filename);
vx_enum data_type;
vx_float32 value;
vxQueryScalar(scalar, VX_SCALAR_TYPE, &data_type, sizeof(data_type));
vx_int32 size = vnn_GetTypeSize(data_type);
vxCopyScalar(scalar,&value,VX_READ_ONLY,VX_MEMORY_TYPE_HOST);
if(ft == FILE_TYPE_TEXT)
SaveTextToFile(filename,&value,size,data_type);
else if(ft == FILE_TYPE_BIN)
SaveBinaryToFile(filename,&value,size);
else
{
status = VX_FAILURE;
printf("Not support file type:%d,line=%d\n",filename,__LINE__);
}
return status;
}
vx_status vnn_LoadDataFromFile(inout_obj* obj,char *filename)
{
vx_status status = VX_FAILURE;
if(obj->data_type == VX_TYPE_TENSOR)
{
status = vnn_LoadTensorFromFile(obj->u.tensor,filename);
_CHECK_STATUS(status, exit);
}
else if(obj->data_type == VX_TYPE_IMAGE)
{
status = vnn_LoadImageFromFile(obj->u.image,filename);
_CHECK_STATUS(status, exit);
}
else if(obj->data_type == VX_TYPE_ARRAY)
{
status = vnn_LoadArrayFromFile(obj->u.array,filename);
_CHECK_STATUS(status, exit);
}
else if(obj->data_type == VX_TYPE_SCALAR)
{
status = vnn_LoadScalarFromFile(obj->u.scalar,filename);
_CHECK_STATUS(status, exit);
}
else
{
status = VX_FAILURE;
_CHECK_STATUS(status, exit);
}
exit:
return status;
}
vx_status vnn_SaveDataToFile(inout_obj* obj,char *filename)
{
vx_status status = VX_FAILURE;
if(obj->data_type == VX_TYPE_TENSOR)
{
file_type ft = get_file_type(filename);
if(ft == FILE_TYPE_TEXT)
status = vnn_SaveTensorToFileAsFloat32(obj->u.tensor,filename);
else if (ft == FILE_TYPE_BIN)
status = vnn_SaveTensorToFileAsBinary(obj->u.tensor,filename);
else
status = VX_FAILURE;
_CHECK_STATUS(status, exit);
}
else if(obj->data_type == VX_TYPE_IMAGE)
{
status = vnn_SaveImageToFile(obj->u.image,filename);
_CHECK_STATUS(status, exit);
}
else if(obj->data_type == VX_TYPE_ARRAY)
{
status = vnn_SaveArrayToFile(obj->u.array,filename);
_CHECK_STATUS(status, exit);
}
else if(obj->data_type == VX_TYPE_SCALAR)
{
status = vnn_SaveScalarToFile(obj->u.scalar,filename);
_CHECK_STATUS(status, exit);
}
else
{
status = VX_FAILURE;
_CHECK_STATUS(status, exit);
}
exit:
return status;
}
vx_bool get_top
(
float *pfProb,
float *pfMaxProb,
uint32_t *pMaxClass,
uint32_t outputCount,
uint32_t topNum
)
{
uint32_t i, j;
#define MAX_TOP_NUM 20
if (topNum > MAX_TOP_NUM) return vx_false_e;
memset(pfMaxProb, 0, sizeof(float) * topNum);
memset(pMaxClass, 0xff, sizeof(float) * topNum);
for (j = 0; j < topNum; j++)
{
for (i=0; i<outputCount; i++)
{
if ((i == *(pMaxClass+0)) || (i == *(pMaxClass+1)) || (i == *(pMaxClass+2)) ||
(i == *(pMaxClass+3)) || (i == *(pMaxClass+4)))
{
continue;
}
if (pfProb[i] > *(pfMaxProb+j))
{
*(pfMaxProb+j) = pfProb[i];
*(pMaxClass+j) = i;
}
}
}
return vx_true_e;
}
vx_status vnn_ShowTensorTop5(vx_tensor tensor)
{
vx_status status = VX_SUCCESS;
vx_float32 *buf = NULL;
vx_int32 num = vnn_GetTensorSize(tensor);
uint32_t MaxClass[5];
vx_float32 fMaxProb[5];
vx_int32 i=0;
status |= vnn_CopyTensorToFloat32Data(tensor,&buf);
if (!get_top(buf, fMaxProb, MaxClass, num, 5))
{
printf("Fail to show result.\n");
status |= VX_SUCCESS;
goto final;
}
printf(" --- Top5 ---\n");
for(i=0; i<5; i++)
{
printf("%3d: %8.6f\n", MaxClass[i], fMaxProb[i]);
}
final:
if(buf){
free(buf);
}
return status;
}
vx_status vnn_ShowTop5(inout_obj* obj)
{
if(obj->data_type == VX_TYPE_TENSOR)
return vnn_ShowTensorTop5(obj->u.tensor);
return VX_SUCCESS;
}
vx_status vnn_QueryInputsAndOutputsParam(vx_kernel kernel,inout_param *input,vx_int32 *in_cnt,inout_param *output,vx_int32 *out_cnt)
{
vx_status status = VX_SUCCESS;
int i = 0;
/* Query number of parameters in kernel. num_params = input_count + output_count */
vx_uint32 num_params;
vx_int32 input_count=0,output_count=0;
vx_enum direction = 0;
vxQueryKernel(kernel, VX_KERNEL_PARAMETERS, &num_params, sizeof(vx_uint32));
for (i = 0; i < num_params; i++)
{
inout_param *ptrInOut = NULL;
vx_parameter param_kernel = NULL;
vx_meta_format meta;
vx_size _dim_size[MAX_NUM_DIMS],_dim_count;
param_kernel = vxGetKernelParameterByIndex(kernel, i);
vxQueryParameter(param_kernel, VX_PARAMETER_DIRECTION, &direction, sizeof(enum vx_type_e));
if(direction == VX_INPUT)
{
ptrInOut = &input[input_count];
input_count++;
}
else
{
ptrInOut = &output[output_count];
output_count++;
}
vxQueryParameter(param_kernel,VX_PARAMETER_META_FORMAT,&meta, sizeof(vx_meta_format));
vxQueryMetaFormatAttribute(meta, VX_REFERENCE_TYPE, &ptrInOut->data_type, sizeof(ptrInOut->data_type));
vxQueryParameter(param_kernel,VX_PARAMETER_META_FORMAT, &meta, sizeof(vx_meta_format));
vxQueryMetaFormatAttribute(meta, VX_TENSOR_NUMBER_OF_DIMS,&_dim_count, sizeof(_dim_count));
ptrInOut->dim_count = _dim_count;
vxQueryMetaFormatAttribute(meta, VX_TENSOR_DIMS, &_dim_size, sizeof(_dim_size));
for(int n = 0;n<ptrInOut->dim_count;n++)
ptrInOut->dim_size[n] = _dim_size[n];
vxQueryMetaFormatAttribute(meta, VX_TENSOR_DATA_TYPE, &ptrInOut->data_format, sizeof(ptrInOut->data_format));
vxQueryMetaFormatAttribute(meta, VX_TENSOR_QUANT_FORMAT, &ptrInOut->quan_format, sizeof(ptrInOut->quan_format));
switch (ptrInOut->quan_format)
{
case VX_QUANT_DYNAMIC_FIXED_POINT:
vxQueryMetaFormatAttribute(meta,VX_TENSOR_FIXED_POINT_POSITION, &ptrInOut->fixed_pos, sizeof(ptrInOut->fixed_pos));
break;
case VX_QUANT_AFFINE_SCALE:
vxQueryMetaFormatAttribute(meta, VX_TENSOR_ZERO_POINT, &ptrInOut->tf_zerop, sizeof(ptrInOut->tf_zerop));
vxQueryMetaFormatAttribute(meta, VX_TENSOR_SCALE, &ptrInOut->tf_scale, sizeof(ptrInOut->tf_scale));
break;
case VX_QUANT_NONE:
break;
case VX_QUANT_AFFINE_SCALE_PER_CHANNEL:
default:
status = VX_FAILURE;
printf("Quant format %u is not supported!", ptrInOut->quan_format);
_CHECK_STATUS(status, exit);
break;
}
vnn_Log("index:%d,in:%d, data_type:%d\ndim_cnt: %d, dims: %d, %d, %d, %d\nscale: %f, zp: %d, fixPos: %d\nquant_format:%d,data_format: %d\n", i,direction, ptrInOut->data_type,
ptrInOut->dim_count, ptrInOut->dim_size[0], ptrInOut->dim_size[1],ptrInOut->dim_size[2], ptrInOut->dim_size[3],
ptrInOut->tf_scale, ptrInOut->tf_zerop, ptrInOut->fixed_pos, ptrInOut->quan_format,
ptrInOut->data_format);
}
*in_cnt = input_count;
*out_cnt = output_count;
exit:
return status;
}
vx_status vnn_CreateObject(vx_context context, inout_param *param, inout_obj *obj)
{
vx_status status = VX_SUCCESS;
if(param->data_type == VX_TYPE_TENSOR)
{
vx_tensor_create_params_t ts_params;
ts_params.data_format = param->data_format;
ts_params.num_of_dims = param->dim_count;
ts_params.sizes = param->dim_size;
ts_params.quant_format = param->quan_format;
if(param->quan_format == VX_QUANT_AFFINE_SCALE)
{
ts_params.quant_data.affine.scale = param->tf_scale;
ts_params.quant_data.affine.zeroPoint = param->tf_zerop;
}
else if(param->quan_format == VX_QUANT_DYNAMIC_FIXED_POINT)
{
ts_params.quant_data.dfp.fixed_point_pos = (vx_int8)param->fixed_pos;
}
else
{
/*nothing*/
}
obj->u.tensor = vxCreateTensor2(context, &ts_params, sizeof(ts_params));
obj->data_type = param->data_type;
_CHECK_OBJ(obj->u.tensor,exit);
}
else if (param->data_type == VX_TYPE_IMAGE)
{
obj->u.image = vxCreateImage(context, param->dim_size[0],param->dim_size[1],param->data_format);
obj->data_type = VX_TYPE_IMAGE;
_CHECK_OBJ(obj->u.image,exit);
}
else if (param->data_type == VX_TYPE_ARRAY)
{
obj->u.array = vxCreateArray(context, param->data_format, param->dim_size[0]);
obj->data_type = VX_TYPE_ARRAY;
_CHECK_OBJ(obj->u.array,exit);
for(int i=0; i < param->dim_size[0];i++)
{
vx_float32 zero = 0;
vxAddArrayItems(obj->u.array,1,&zero,0);
}
}
else if (param->data_type == VX_TYPE_SCALAR)
{
vx_float32 num = 0;
obj->u.scalar = vxCreateScalar(context, param->data_format, &num);
obj->data_type = VX_TYPE_SCALAR;
_CHECK_OBJ(obj->u.scalar,exit);
}
else
{
printf("Not support output data type:%d\n",param->data_type);
status = VX_FAILURE;
}
exit:
return status;
}
vx_status vnn_ReleaseObject(inout_obj *obj)
{
vx_status status = VX_SUCCESS;
if(obj->data_type == VX_TYPE_TENSOR)
{
vxReleaseTensor( &obj->u.tensor);
}
else if (obj->data_type == VX_TYPE_IMAGE)
{
vxReleaseImage( &obj->u.image);
}
else if (obj->data_type == VX_TYPE_ARRAY)
{
vxReleaseArray( &obj->u.array);
}
else if (obj->data_type == VX_TYPE_SCALAR)
{
vxReleaseScalar( &obj->u.scalar);
}
else
{
printf("Not support output data type:%d\n",obj->data_type);
status = VX_FAILURE;
}
return status;
}
void vnn_Log
(
const char *fmt,
...
)
{
char arg_buffer[VSI_NN_MAX_DEBUG_BUFFER_LEN] = {0};
va_list arg;
vx_int32 debug = 0;
char *debug_s = getenv("VNN_DEBUG");
if(debug_s)
{
debug = atoi(debug_s);
}
if(debug != 1)
{
return ;
}
va_start(arg, fmt);
vsnprintf(arg_buffer, VSI_NN_MAX_DEBUG_BUFFER_LEN, fmt, arg);
va_end(arg);
fprintf(stderr, "%s\n", arg_buffer);
}
Reference in New Issue View Git Blame Copy Permalink