m53297601
/
mindspore
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

fix static checking of lite ops

Browse Source
pull/7928/head
liuwenhao4 4 years ago
parent fff8dff071
commit 04d688d7ed
116 changed files with 416 additions and 344 deletions
Show Stats Download Patch File Download Diff File

6
mindspore/lite/internal/src/kernel/fp32/arithmetic.cc
Unescape View File

@ -22,9 +22,9 @@
#include "nnacl/arithmetic_common.h" #include "nnacl/arithmetic_common.h"
#include "nnacl/fp32/arithmetic.h" #include "nnacl/fp32/arithmetic.h"
typedef int (*ArithmeticRun)(float *input0, float *input1, float *output, int element_size); typedef int (*ArithmeticRun)(const float *input0, const float *input1, float *output, const int element_size);
typedef int (*ArithmeticOptRun)(float *input0, float *input1, float *output, int element_size, typedef int (*ArithmeticOptRun)(const float *input0, const float *input1, float *output, const int element_size,
ArithmeticParameter *param); const ArithmeticParameter *param);
int BroadcastRun(float *input0, float *input1, float *output, int dim, int out_count, int break_pos, int BroadcastRun(float *input0, float *input1, float *output, int dim, int out_count, int break_pos,
ArithmeticRun arithmetic_run, ArithmeticParameter *params) { ArithmeticRun arithmetic_run, ArithmeticParameter *params) {

2
mindspore/lite/nnacl/arithmetic_common.c
Unescape View File

@ -52,7 +52,7 @@ void TileOneDimensionUint8(uint8_t *inData, uint8_t *outData, int dim, size_t nd
} }
} }
void ComputeStrides(int *shape, int *strides, int ndim) { void ComputeStrides(const int *shape, int *strides, const int ndim) {
int stride = 1; int stride = 1;
for (int i = ndim - 1; i >= 0; i--) { for (int i = ndim - 1; i >= 0; i--) {
strides[i] = stride; strides[i] = stride;

2
mindspore/lite/nnacl/arithmetic_common.h
Unescape View File

@ -49,7 +49,7 @@ extern "C" {
#endif #endif
void TileOneDimension(float *inData, float *outData, int dim, size_t ndim, int *inShape, int *inStrides, void TileOneDimension(float *inData, float *outData, int dim, size_t ndim, int *inShape, int *inStrides,
int *outStrides, int *multiple); int *outStrides, int *multiple);
void ComputeStrides(int *shape, int *strides, int ndim); void ComputeStrides(const int *shape, int *strides, const int ndim);
void CalcMultiplesAndStrides(ArithmeticParameter *param); void CalcMultiplesAndStrides(ArithmeticParameter *param);

2
mindspore/lite/nnacl/depth_to_space.c
Unescape View File

@ -16,7 +16,7 @@
#include "nnacl/depth_to_space.h" #include "nnacl/depth_to_space.h"
#include <string.h> #include <string.h>
void DepthToSpaceForNHWC(const void *input, void *output, int *in_shape, DepthToSpaceParameter *param) { void DepthToSpaceForNHWC(const void *input, void *output, const int *in_shape, const DepthToSpaceParameter *param) {
int32_t block_size = param->block_size_; int32_t block_size = param->block_size_;
int32_t in_shape_dim2 = in_shape[2]; int32_t in_shape_dim2 = in_shape[2];
int32_t in_shape_dim1 = in_shape[1]; int32_t in_shape_dim1 = in_shape[1];

2
mindspore/lite/nnacl/depth_to_space.h
Unescape View File

@ -20,7 +20,7 @@
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
void DepthToSpaceForNHWC(const void *input, void *output, int *in_shape, DepthToSpaceParameter *param); void DepthToSpaceForNHWC(const void *input, void *output, const int *in_shape, const DepthToSpaceParameter *param);
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif

110
mindspore/lite/nnacl/fp32/arithmetic.c
View File

File diff suppressed because it is too large Load Diff

110
mindspore/lite/nnacl/fp32/arithmetic.h
Unescape View File

@ -26,105 +26,121 @@
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
int ElementOptAdd(float *input0, float *input1, float *output, int element_size, ArithmeticParameter *param); int ElementOptAdd(const float *input0, const float *input1, float *output, const int element_size,
int ElementOptAddInt(int *input0, int *input1, int *output, int element_size, ArithmeticParameter *param); const ArithmeticParameter *param);
int ElementOptAddRelu(float *input0, float *input1, float *output, int element_size, ArithmeticParameter *param); int ElementOptAddInt(const int *input0, const int *input1, int *output, const int element_size,
int ElementOptAddRelu6(float *input0, float *input1, float *output, int element_size, ArithmeticParameter *param); const ArithmeticParameter *param);
int ElementOptSub(float *input0, float *input1, float *output, int element_size, ArithmeticParameter *param); int ElementOptAddRelu(const float *input0, const float *input1, float *output, const int element_size,
int ElementOptSubRelu(float *input0, float *input1, float *output, int element_size, ArithmeticParameter *param); const ArithmeticParameter *param);
int ElementOptSubRelu6(float *input0, float *input1, float *output, int element_size, ArithmeticParameter *param); int ElementOptAddRelu6(const float *input0, const float *input1, float *output, const int element_size,
int ElementOptMul(float *input0, float *input1, float *output, int element_size, ArithmeticParameter *param); const ArithmeticParameter *param);
int ElementOptMulRelu(float *input0, float *input1, float *output, int element_size, ArithmeticParameter *param); int ElementOptSub(const float *input0, const float *input1, float *output, const int element_size,
int ElementOptMulRelu6(float *input0, float *input1, float *output, int element_size, ArithmeticParameter *param); const ArithmeticParameter *param);
int ElementOptMulInt(int *input0, int *input1, int *output, int element_size, ArithmeticParameter *param); int ElementOptSubRelu(const float *input0, const float *input1, float *output, const int element_size,
int ElementOptMulReluInt(int *input0, int *input1, int *output, int element_size, ArithmeticParameter *param); const ArithmeticParameter *param);
int ElementOptMulRelu6Int(int *input0, int *input1, int *output, int element_size, ArithmeticParameter *param); int ElementOptSubRelu6(const float *input0, const float *input1, float *output, const int element_size,
int ElementOptDiv(float *input0, float *input1, float *output, int element_size, ArithmeticParameter *param); const ArithmeticParameter *param);
int ElementOptDivRelu(float *input0, float *input1, float *output, int element_size, ArithmeticParameter *param); int ElementOptMul(const float *input0, const float *input1, float *output, const int element_size,
int ElementOptDivRelu6(float *input0, float *input1, float *output, int element_size, ArithmeticParameter *param); const ArithmeticParameter *param);
int ElementMul(float *input0, float *input1, float *output, int element_size); int ElementOptMulRelu(const float *input0, const float *input1, float *output, const int element_size,
int ElementMulRelu(float *input0, float *input1, float *output, int element_size); const ArithmeticParameter *param);
int ElementMulRelu6(float *input0, float *input1, float *output, int element_size); int ElementOptMulRelu6(const float *input0, const float *input1, float *output, const int element_size,
int ElementMulInt(int *input0, int *input1, int *output, int element_size); const ArithmeticParameter *param);
int ElementMulReluInt(int *input0, int *input1, int *output, int element_size); int ElementOptMulInt(const int *input0, const int *input1, int *output, const int element_size,
int ElementMulRelu6Int(int *input0, int *input1, int *output, int element_size); const ArithmeticParameter *param);
int ElementOptMulReluInt(const int *input0, const int *input1, int *output, const int element_size,
const ArithmeticParameter *param);
int ElementOptMulRelu6Int(const int *input0, const int *input1, int *output, const int element_size,
const ArithmeticParameter *param);
int ElementOptDiv(const float *input0, const float *input1, float *output, const int element_size,
const ArithmeticParameter *param);
int ElementOptDivRelu(const float *input0, const float *input1, float *output, const int element_size,
const ArithmeticParameter *param);
int ElementOptDivRelu6(const float *input0, const float *input1, float *output, const int element_size,
const ArithmeticParameter *param);
int ElementMul(const float *input0, const float *input1, float *output, const int element_size);
int ElementMulRelu(const float *input0, const float *input1, float *output, const int element_size);
int ElementMulRelu6(const float *input0, const float *input1, float *output, const int element_size);
int ElementMulInt(const int *input0, const int *input1, int *output, const int element_size);
int ElementMulReluInt(const int *input0, const int *input1, int *output, const int element_size);
int ElementMulRelu6Int(const int *input0, const int *input1, int *output, const int element_size);
int BroadcastMul(float *input0, float *input1, float *tile_input0, float *tile_input1, float *output, int element_size, int BroadcastMul(float *input0, float *input1, float *tile_input0, float *tile_input1, float *output, int element_size,
ArithmeticParameter *param); ArithmeticParameter *param);
int ElementAdd(float *input0, float *input1, float *output, int element_size); int ElementAdd(const float *input0, const float *input1, float *output, const int element_size);
int ElementAddRelu(float *input0, float *input1, float *output, int element_size); int ElementAddRelu(const float *input0, const float *input1, float *output, const int element_size);
int ElementAddRelu6(float *input0, float *input1, float *output, int element_size); int ElementAddRelu6(const float *input0, const float *input1, float *output, const int element_size);
int ElementAddInt(int *input0, int *input1, int *output, int element_size); int ElementAddInt(const int *input0, const int *input1, int *output, const int element_size);
int BroadcastAdd(float *input0, float *input1, float *tile_input0, float *tile_input1, float *output, int element_size, int BroadcastAdd(float *input0, float *input1, float *tile_input0, float *tile_input1, float *output, int element_size,
ArithmeticParameter *param); ArithmeticParameter *param);
int BroadcastAddInt8(int8_t *input0, int8_t *input1, int8_t *tile_input0, int8_t *tile_input1, int8_t *output, int BroadcastAddInt8(int8_t *input0, int8_t *input1, int8_t *tile_input0, int8_t *tile_input1, int8_t *output,
int element_size, ArithmeticParameter *param); int element_size, ArithmeticParameter *param);
int ElementSub(float *input0, float *input1, float *output, int element_size); int ElementSub(const float *input0, const float *input1, float *output, const int element_size);
int ElementSubRelu(float *input0, float *input1, float *output, int element_size); int ElementSubRelu(const float *input0, const float *input1, float *output, const int element_size);
int ElementSubRelu6(float *input0, float *input1, float *output, int element_size); int ElementSubRelu6(const float *input0, const float *input1, float *output, const int element_size);
int BroadcastSub(float *input0, float *input1, float *tile_input0, float *tile_input1, float *output, int element_size, int BroadcastSub(float *input0, float *input1, float *tile_input0, float *tile_input1, float *output, int element_size,
ArithmeticParameter *param); ArithmeticParameter *param);
int ElementDiv(float *input0, float *input1, float *output, int element_size); int ElementDiv(const float *input0, const float *input1, float *output, const int element_size);
int ElementDivRelu(float *input0, float *input1, float *output, int element_size); int ElementDivRelu(const float *input0, const float *input1, float *output, const int element_size);
int ElementDivRelu6(float *input0, float *input1, float *output, int element_size); int ElementDivRelu6(const float *input0, const float *input1, float *output, const int element_size);
int BroadcastDiv(float *input0, float *input1, float *tile_input0, float *tile_input1, float *output, int element_size, int BroadcastDiv(float *input0, float *input1, float *tile_input0, float *tile_input1, float *output, int element_size,
ArithmeticParameter *param); ArithmeticParameter *param);
int ElementLogicalAnd(float *input0, float *input1, float *output, int element_size); int ElementLogicalAnd(const float *input0, const float *input1, float *output, const int element_size);
int BroadcastLogicalAnd(float *input0, float *input1, float *tile_input0, float *tile_input1, float *output, int BroadcastLogicalAnd(float *input0, float *input1, float *tile_input0, float *tile_input1, float *output,
int element_size, ArithmeticParameter *param); int element_size, ArithmeticParameter *param);
int ElementLogicalOr(float *input0, float *input1, float *output, int element_size); int ElementLogicalOr(const float *input0, const float *input1, float *output, const int element_size);
int BroadcastLogicalOr(float *input0, float *input1, float *tile_input0, float *tile_input1, float *output, int BroadcastLogicalOr(float *input0, float *input1, float *tile_input0, float *tile_input1, float *output,
int element_size, ArithmeticParameter *param); int element_size, ArithmeticParameter *param);
int ElementMaximum(float *input0, float *input1, float *output, int element_size); int ElementMaximum(const float *input0, const float *input1, float *output, const int element_size);
int BroadcastMaximum(float *input0, float *input1, float *tile_input0, float *tile_input1, float *output, int BroadcastMaximum(float *input0, float *input1, float *tile_input0, float *tile_input1, float *output,
int element_size, ArithmeticParameter *param); int element_size, ArithmeticParameter *param);
int ElementMinimum(float *input0, float *input1, float *output, int element_size); int ElementMinimum(const float *input0, const float *input1, float *output, const int element_size);
int BroadcastMinimum(float *input0, float *input1, float *tile_input0, float *tile_input1, float *output, int BroadcastMinimum(float *input0, float *input1, float *tile_input0, float *tile_input1, float *output,
int element_size, ArithmeticParameter *param); int element_size, ArithmeticParameter *param);
int ElementFloorDiv(float *input0, float *input1, float *output, int element_size); int ElementFloorDiv(const float *input0, const float *input1, float *output, const int element_size);
int ElementFloorDivInt(int *input0, int *input1, int *output, int element_size); int ElementFloorDivInt(const int *input0, const int *input1, int *output, const int element_size);
int BroadcastFloorDiv(float *input0, float *input1, float *tile_input0, float *tile_input1, float *output, int BroadcastFloorDiv(float *input0, float *input1, float *tile_input0, float *tile_input1, float *output,
int element_size, ArithmeticParameter *param); int element_size, ArithmeticParameter *param);
int ElementFloorMod(float *input0, float *input1, float *output, int element_size); int ElementFloorMod(const float *input0, const float *input1, float *output, const int element_size);
int ElementFloorModInt(int *input0, int *input1, int *output, int element_size); int ElementFloorModInt(const int *input0, const int *input1, int *output, const int element_size);
int BroadcastFloorMod(float *input0, float *input1, float *tile_input0, float *tile_input1, float *output, int BroadcastFloorMod(float *input0, float *input1, float *tile_input0, float *tile_input1, float *output,
int element_size, ArithmeticParameter *param); int element_size, ArithmeticParameter *param);
int ElementSquaredDifference(float *input0, float *input1, float *output, int element_size); int ElementSquaredDifference(const float *input0, const float *input1, float *output, const int element_size);
int BroadcastSquaredDifference(float *input0, float *input1, float *tile_input0, float *tile_input1, float *output, int BroadcastSquaredDifference(float *input0, float *input1, float *tile_input0, float *tile_input1, float *output,
int element_size, ArithmeticParameter *param); int element_size, ArithmeticParameter *param);
int ElementNotEqual(float *input0, float *input1, float *output, int element_size); int ElementNotEqual(const float *input0, const float *input1, float *output, const int element_size);
int BroadcastNotEqual(float *input0, float *input1, float *tile_input0, float *tile_input1, float *output, int BroadcastNotEqual(float *input0, float *input1, float *tile_input0, float *tile_input1, float *output,
int element_size, ArithmeticParameter *param); int element_size, ArithmeticParameter *param);
int ElementEqual(float *input0, float *input1, float *output, int element_size); int ElementEqual(const float *input0, const float *input1, float *output, const int element_size);
int BroadcastEqual(float *input0, float *input1, float *tile_input0, float *tile_input1, float *output, int BroadcastEqual(float *input0, float *input1, float *tile_input0, float *tile_input1, float *output,
int element_size, ArithmeticParameter *param); int element_size, ArithmeticParameter *param);
int ElementLess(float *input0, float *input1, float *output, int element_size); int ElementLess(const float *input0, const float *input1, float *output, const int element_size);
int BroadcastLess(float *input0, float *input1, float *tile_input0, float *tile_input1, float *output, int element_size, int BroadcastLess(float *input0, float *input1, float *tile_input0, float *tile_input1, float *output, int element_size,
ArithmeticParameter *param); ArithmeticParameter *param);
int ElementLessEqual(float *input0, float *input1, float *output, int element_size); int ElementLessEqual(const float *input0, const float *input1, float *output, const int element_size);
int BroadcastLessEqual(float *input0, float *input1, float *tile_input0, float *tile_input1, float *output, int BroadcastLessEqual(float *input0, float *input1, float *tile_input0, float *tile_input1, float *output,
int element_size, ArithmeticParameter *param); int element_size, ArithmeticParameter *param);
int ElementGreater(float *input0, float *input1, float *output, int element_size); int ElementGreater(const float *input0, const float *input1, float *output, const int element_size);
int BroadcastGreater(float *input0, float *input1, float *tile_input0, float *tile_input1, float *output, int BroadcastGreater(float *input0, float *input1, float *tile_input0, float *tile_input1, float *output,
int element_size, ArithmeticParameter *param); int element_size, ArithmeticParameter *param);
int ElementGreaterEqual(float *input0, float *input1, float *output, int element_size); int ElementGreaterEqual(const float *input0, const float *input1, float *output, const int element_size);
int BroadcastGreaterEqual(float *input0, float *input1, float *tile_input0, float *tile_input1, float *output, int BroadcastGreaterEqual(float *input0, float *input1, float *tile_input0, float *tile_input1, float *output,
int element_size, ArithmeticParameter *param); int element_size, ArithmeticParameter *param);

1
mindspore/lite/nnacl/fp32/batchnorm.c
Unescape View File

@ -18,7 +18,6 @@
#include <math.h> #include <math.h>
#include "nnacl/batchnorm_parameter.h" #include "nnacl/batchnorm_parameter.h"
#include "nnacl/op_base.h" #include "nnacl/op_base.h"
#include "nnacl/errorcode.h"
void BatchNormFp32(const void *input, const void *mean, const void *variance, BatchNormParameter *param, int task_id, void BatchNormFp32(const void *input, const void *mean, const void *variance, BatchNormParameter *param, int task_id,
void *output) { void *output) {

4
mindspore/lite/nnacl/fp32/conv.c
Unescape View File

@ -21,7 +21,7 @@
#include "nnacl/fp32/matmul.h" #include "nnacl/fp32/matmul.h"
// fp32 conv common // fp32 conv common
void ConvFp32(float *input_data, float *packed_input, float *packed_weight, const float *bias_data, void ConvFp32(float *input_data, float *packed_input, const float *packed_weight, const float *bias_data,
float *col_major_input, float *output_data, int task_id, ConvParameter *conv_param) { float *col_major_input, float *output_data, int task_id, ConvParameter *conv_param) {
int kernel_h = conv_param->kernel_h_; int kernel_h = conv_param->kernel_h_;
int kernel_w = conv_param->kernel_w_; int kernel_w = conv_param->kernel_w_;
@ -70,7 +70,7 @@ void ConvFp32(float *input_data, float *packed_input, float *packed_weight, cons
} }
// fp32 conv winograd // fp32 conv winograd
void ConvWinogardFp32(float *input_data, float *trans_weight, const float *bias_data, float *output_data, void ConvWinogardFp32(float *input_data, const float *trans_weight, const float *bias_data, float *output_data,
TmpBufferAddress *buffer_list, int task_id, ConvParameter *conv_param, InputTransFunc in_func, TmpBufferAddress *buffer_list, int task_id, ConvParameter *conv_param, InputTransFunc in_func,
OutputTransFunc out_func) { OutputTransFunc out_func) {
int thread_num = conv_param->thread_num_; int thread_num = conv_param->thread_num_;

4
mindspore/lite/nnacl/fp32/conv.h
Unescape View File

@ -34,11 +34,11 @@ extern "C" {
#endif #endif
// fp32 convolution common (im2col+gemm) // fp32 convolution common (im2col+gemm)
void ConvFp32(float *input_data, float *packed_input, float *packed_weight, const float *bias_data, void ConvFp32(float *input_data, float *packed_input, const float *packed_weight, const float *bias_data,
float *col_major_input, float *output_data, int task_id, ConvParameter *conv_param); float *col_major_input, float *output_data, int task_id, ConvParameter *conv_param);
// fp32 convolution winograd // fp32 convolution winograd
void ConvWinogardFp32(float *input_data, float *trans_weight, const float *bias_data, float *output_data, void ConvWinogardFp32(float *input_data, const float *trans_weight, const float *bias_data, float *output_data,
TmpBufferAddress *buffer_list, int task_id, ConvParameter *conv_param, InputTransFunc in_func, TmpBufferAddress *buffer_list, int task_id, ConvParameter *conv_param, InputTransFunc in_func,
OutputTransFunc out_func); OutputTransFunc out_func);
#ifdef __cplusplus #ifdef __cplusplus

34
mindspore/lite/nnacl/fp32/deconv_winograd.c
Unescape View File

@ -56,7 +56,9 @@ int PackDeConvWgDataFp32(float *nhwc_weight, DeConvComputeUnit *unit, ConvParame
/* winograd AT */ /* winograd AT */
unit->winograd_.AT_ = malloc(unit->winograd_.i_ * unit->winograd_.o_ * sizeof(float)); unit->winograd_.AT_ = malloc(unit->winograd_.i_ * unit->winograd_.o_ * sizeof(float));
if (unit->winograd_.AT_ == NULL) { if (unit->winograd_.AT_ == NULL) {
free(current_unit_weight); if (current_unit_weight != NULL) {
free(current_unit_weight);
}
return NNACL_NULL_PTR; return NNACL_NULL_PTR;
} }
memcpy(unit->winograd_.AT_, matrix_at, unit->winograd_.i_ * unit->winograd_.o_ * sizeof(float)); memcpy(unit->winograd_.AT_, matrix_at, unit->winograd_.i_ * unit->winograd_.o_ * sizeof(float));
@ -64,8 +66,12 @@ int PackDeConvWgDataFp32(float *nhwc_weight, DeConvComputeUnit *unit, ConvParame
/* winograd BT */ /* winograd BT */
unit->winograd_.BT_ = malloc(unit->winograd_.o_ * unit->winograd_.o_ * sizeof(float)); unit->winograd_.BT_ = malloc(unit->winograd_.o_ * unit->winograd_.o_ * sizeof(float));
if (unit->winograd_.BT_ == NULL) { if (unit->winograd_.BT_ == NULL) {
free(current_unit_weight); if (current_unit_weight != NULL) {
free(unit->winograd_.AT_); free(current_unit_weight);
}
if (unit->winograd_.AT_ != NULL) {
free(unit->winograd_.AT_);
}
return NNACL_NULL_PTR; return NNACL_NULL_PTR;
} }
memcpy(unit->winograd_.BT_, matrix_bt, unit->winograd_.o_ * unit->winograd_.o_ * sizeof(float)); memcpy(unit->winograd_.BT_, matrix_bt, unit->winograd_.o_ * unit->winograd_.o_ * sizeof(float));
@ -74,9 +80,15 @@ int PackDeConvWgDataFp32(float *nhwc_weight, DeConvComputeUnit *unit, ConvParame
size = conv_param->input_channel_ * conv_param->output_channel_ * unit->winograd_.kh_ * unit->winograd_.kw_; size = conv_param->input_channel_ * conv_param->output_channel_ * unit->winograd_.kh_ * unit->winograd_.kw_;
float *winograd_unit_weight = (float *)malloc(size * sizeof(float)); float *winograd_unit_weight = (float *)malloc(size * sizeof(float));
if (winograd_unit_weight == NULL) { if (winograd_unit_weight == NULL) {
free(current_unit_weight); if (current_unit_weight != NULL) {
free(unit->winograd_.AT_); free(current_unit_weight);
free(unit->winograd_.BT_); }
if (unit->winograd_.AT_ != NULL) {
free(unit->winograd_.AT_);
}
if (unit->winograd_.BT_ != NULL) {
free(unit->winograd_.BT_);
}
return NNACL_NULL_PTR; return NNACL_NULL_PTR;
} }
WinogradWeightTransform(current_unit_weight, winograd_unit_weight, matrix_g, matrix_gt, C4NUM, unit->winograd_.kh_, WinogradWeightTransform(current_unit_weight, winograd_unit_weight, matrix_g, matrix_gt, C4NUM, unit->winograd_.kh_,
@ -105,7 +117,9 @@ int PackDeConvWgDataFp32(float *nhwc_weight, DeConvComputeUnit *unit, ConvParame
} }
} }
free(current_unit_weight); if (current_unit_weight != NULL) {
free(current_unit_weight);
}
return NNACL_OK; return NNACL_OK;
} }
@ -317,7 +331,7 @@ void DeConvWgMerge(const float *src, float *dst, size_t src_stride, size_t dst_s
return; return;
} }
void _deConvWinograd(float *tile_in, float *tile_out, float *weight_buf, float *tmp_buf, float *at_buf, void _deConvWinograd(const float *tile_in, float *tile_out, float *weight_buf, float *tmp_buf, float *at_buf,
float *a_mid_buf, float *trans_a_buf, bool *transfered, float *bt_buf, float *b_tmp_buf, float *a_mid_buf, float *trans_a_buf, bool *transfered, float *bt_buf, float *b_tmp_buf,
int unit_size, int w_start, int h_start, ConvParameter *conv_param, DeConvParam *deconv_param) { int unit_size, int w_start, int h_start, ConvParameter *conv_param, DeConvParam *deconv_param) {
int winograd_plane = unit_size * unit_size; int winograd_plane = unit_size * unit_size;
@ -357,8 +371,8 @@ void _deConvWinograd(float *tile_in, float *tile_out, float *weight_buf, float *
return; return;
} }
void _deConvCommon(float *tile_in, float *tile_out, float *weight, float *tmp_buf, int h_start, int w_start, int h_size, void _deConvCommon(float *tile_in, float *tile_out, const float *weight, float *tmp_buf, int h_start, int w_start,
int w_size, ConvParameter *conv_param, DeConvParam *deconv_param) { int h_size, int w_size, ConvParameter *conv_param, DeConvParam *deconv_param) {
int count = deconv_param->oc_div4_ * w_size * h_size; int count = deconv_param->oc_div4_ * w_size * h_size;
int in_stride = DECONV_WINOGRAD_DEFAULT_TILE * deconv_param->ic_up4_; int in_stride = DECONV_WINOGRAD_DEFAULT_TILE * deconv_param->ic_up4_;
int out_stride = DECONV_WINOGRAD_DEFAULT_TILE * deconv_param->oc_up4_; int out_stride = DECONV_WINOGRAD_DEFAULT_TILE * deconv_param->oc_up4_;

6
mindspore/lite/nnacl/fp32/detection_post_process.c
Unescape View File

@ -274,9 +274,9 @@ int NmsMultiClassesFast(const int num_boxes, const int num_classes_with_bg, cons
return output_num; return output_num;
} }
int DetectionPostProcess(const int num_boxes, const int num_classes_with_bg, float *input_boxes, float *input_scores, int DetectionPostProcess(const int num_boxes, const int num_classes_with_bg, float *input_boxes,
float *input_anchors, float *output_boxes, float *output_classes, float *output_scores, const float *input_scores, float *input_anchors, float *output_boxes, float *output_classes,
float *output_num, DetectionPostProcessParameter *param) { float *output_scores, float *output_num, DetectionPostProcessParameter *param) {
BboxCenter scaler; BboxCenter scaler;
scaler.y = param->y_scale_; scaler.y = param->y_scale_;
scaler.x = param->x_scale_; scaler.x = param->x_scale_;

6
mindspore/lite/nnacl/fp32/detection_post_process.h
Unescape View File

@ -43,9 +43,9 @@ typedef struct {
extern "C" { extern "C" {
#endif #endif
int DetectionPostProcess(const int num_boxes, const int num_classes_with_bg, float *input_boxes, float *input_scores, int DetectionPostProcess(const int num_boxes, const int num_classes_with_bg, float *input_boxes,
float *input_anchors, float *output_boxes, float *output_classes, float *output_scores, const float *input_scores, float *input_anchors, float *output_boxes, float *output_classes,
float *output_num, DetectionPostProcessParameter *param); float *output_scores, float *output_num, DetectionPostProcessParameter *param);
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif

2
mindspore/lite/nnacl/fp32/elu.c
Unescape View File

@ -18,7 +18,7 @@
#include <math.h> #include <math.h>
#include "nnacl/errorcode.h" #include "nnacl/errorcode.h"
void Calculate_Data(float *input_data, float *output_data, int num, EluParameter *parameter) { void Calculate_Data(const float *input_data, float *output_data, int num, EluParameter *parameter) {
output_data[num] = input_data[num] < 0 ? parameter->alpha_ * expm1(input_data[num]) : input_data[num]; output_data[num] = input_data[num] < 0 ? parameter->alpha_ * expm1(input_data[num]) : input_data[num];
} }

2
mindspore/lite/nnacl/fp32/exp.c
Unescape View File

@ -18,7 +18,7 @@
#include <math.h> #include <math.h>
#include "nnacl/errorcode.h" #include "nnacl/errorcode.h"
int Exp(float *input_data, float *output_data, ExpParameter *parameter, int task_id) { int Exp(const float *input_data, float *output_data, ExpParameter *parameter, int task_id) {
if (parameter->scale_ == 1) { if (parameter->scale_ == 1) {
for (size_t i = task_id; i < parameter->element_num_; i += parameter->thread_num_) { for (size_t i = task_id; i < parameter->element_num_; i += parameter->thread_num_) {
output_data[i] = expf(input_data[i]); output_data[i] = expf(input_data[i]);

2
mindspore/lite/nnacl/fp32/exp.h
Unescape View File

@ -33,7 +33,7 @@ typedef struct ExpParameter {
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
int Exp(float *input_data, float *output_data, ExpParameter *parameter, int task_id); int Exp(const float *input_data, float *output_data, ExpParameter *parameter, int task_id);
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif

2
mindspore/lite/nnacl/fp32/expandDims.c
Unescape View File

@ -18,7 +18,7 @@
#include <string.h> #include <string.h>
#include "nnacl/errorcode.h" #include "nnacl/errorcode.h"
int ExpandDims(void *input_ptr, void *output_ptr, size_t data_size) { int ExpandDims(const void *input_ptr, void *output_ptr, size_t data_size) {
memcpy(output_ptr, input_ptr, data_size); memcpy(output_ptr, input_ptr, data_size);
return NNACL_OK; return NNACL_OK;
} }

2
mindspore/lite/nnacl/fp32/expandDims.h
Unescape View File

@ -27,7 +27,7 @@ typedef struct ExpandDimsParameter {
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
int ExpandDims(void *input_ptr, void *output_ptr, size_t data_size); int ExpandDims(const void *input_ptr, void *output_ptr, size_t data_size);
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif

6
mindspore/lite/nnacl/fp32/gather.c
Unescape View File

@ -18,7 +18,7 @@
#include <string.h> #include <string.h>
#include "nnacl/errorcode.h" #include "nnacl/errorcode.h"
inline int Stride(int *shape, int rank, int index) { inline int Stride(const int *shape, int rank, int index) {
int i, stride = 1; int i, stride = 1;
for (i = index + 1; i < rank; ++i) { for (i = index + 1; i < rank; ++i) {
stride *= shape[i]; stride *= shape[i];
@ -26,7 +26,7 @@ inline int Stride(int *shape, int rank, int index) {
return stride; return stride;
} }
int Gather(float *input, int outer_size, int inner_size, int limit, int *indices, int indices_element_size, int Gather(float *input, int outer_size, int inner_size, int limit, const int *indices, int indices_element_size,
float *output) { float *output) {
int i, m; int i, m;
for (m = 0; m < outer_size; ++m) { for (m = 0; m < outer_size; ++m) {
@ -42,7 +42,7 @@ int Gather(float *input, int outer_size, int inner_size, int limit, int *indices
return NNACL_OK; return NNACL_OK;
} }
int GatherInt32(const int32_t *input, int outer_size, int inner_size, int limit, int *indices, int GatherInt32(const int32_t *input, int outer_size, int inner_size, int limit, const int *indices,
int indices_element_size, int32_t *output) { int indices_element_size, int32_t *output) {
int i, m; int i, m;
for (m = 0; m < outer_size; ++m) { for (m = 0; m < outer_size; ++m) {

6
mindspore/lite/nnacl/fp32/gather.h
Unescape View File

@ -22,10 +22,10 @@
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
int Gather(float *input, int outer_size, int inner_size, int limit, int *indices, int indices_element_size, int Gather(float *input, int outer_size, int inner_size, int limit, const int *indices, int indices_element_size,
float *output); float *output);
int GatherInt32(const int32_t *input, int outer_size, int inner_size, int limit, int *indices, int indices_element_size, int GatherInt32(const int32_t *input, int outer_size, int inner_size, int limit, const int *indices,
int32_t *output); int indices_element_size, int32_t *output);
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif

2
mindspore/lite/nnacl/fp32/gatherNd.c
Unescape View File

@ -18,7 +18,7 @@
#include <string.h> #include <string.h>
#include "nnacl/errorcode.h" #include "nnacl/errorcode.h"
int GatherNd(float *input, float *output, int *in_offset, int area, int count) { int GatherNd(const float *input, float *output, int *in_offset, int area, int count) {
int i = 0; int i = 0;
for (i = 0; i < count; i++) { for (i = 0; i < count; i++) {
(void)memcpy(output + area * i, input + in_offset[i], area * sizeof(float)); (void)memcpy(output + area * i, input + in_offset[i], area * sizeof(float));

2
mindspore/lite/nnacl/fp32/gatherNd.h
Unescape View File

@ -27,7 +27,7 @@ typedef struct GatherNdParameter {
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
int GatherNd(float *input, float *output, int *in_offset, int area, int count); int GatherNd(const float *input, float *output, int *in_offset, int area, int count);
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif

4
mindspore/lite/nnacl/fp32/lstm.c
Unescape View File

@ -79,13 +79,13 @@ void ElementMulAcc(const float *input0, const float *input1, float *output, int
} }
} }
void UpdataState(float *cell_state, float *forget_gate, float *input_gate, float *cell_gate, int batch, void UpdataState(float *cell_state, float *forget_gate, const float *input_gate, float *cell_gate, int batch,
int hidden_size) { int hidden_size) {
ElementMul(forget_gate, cell_state, cell_state, batch * hidden_size); ElementMul(forget_gate, cell_state, cell_state, batch * hidden_size);
ElementMulAcc(input_gate, cell_gate, cell_state, batch * hidden_size); ElementMulAcc(input_gate, cell_gate, cell_state, batch * hidden_size);
} }
void UpdataOutput(float *cell_state, float *output_gate, float *hidden_state, int batch, int hidden_size) { void UpdataOutput(const float *cell_state, float *output_gate, float *hidden_state, int batch, int hidden_size) {
Tanh(cell_state, batch * hidden_size, hidden_state); Tanh(cell_state, batch * hidden_size, hidden_state);
ElementMul(hidden_state, output_gate, hidden_state, batch * hidden_size); ElementMul(hidden_state, output_gate, hidden_state, batch * hidden_size);
} }

2
mindspore/lite/nnacl/fp32/matmul.c
Unescape View File

@ -16,7 +16,7 @@
#include "nnacl/fp32/matmul.h" #include "nnacl/fp32/matmul.h"
void RowMajor2ColMajor(float *src_ptr, float *dst_ptr, int row, int col) { void RowMajor2ColMajor(const float *src_ptr, float *dst_ptr, int row, int col) {
for (int r = 0; r < row; ++r) { for (int r = 0; r < row; ++r) {
for (int c = 0; c < col; ++c) { for (int c = 0; c < col; ++c) {
dst_ptr[c * row + r] = src_ptr[r * col + c]; dst_ptr[c * row + r] = src_ptr[r * col + c];

2
mindspore/lite/nnacl/fp32/matmul.h
Unescape View File

@ -29,7 +29,7 @@ extern "C" {
void MatMulOpt(const float *a, const float *b, float *c, const float *bias, ActType act_type, int deep, int row, void MatMulOpt(const float *a, const float *b, float *c, const float *bias, ActType act_type, int deep, int row,
int col, size_t stride, int out_type); int col, size_t stride, int out_type);
void MatVecMul(const float *a, const float *b, float *c, const float *bias, ActType act_type, int depth, int col); void MatVecMul(const float *a, const float *b, float *c, const float *bias, ActType act_type, int depth, int col);
void RowMajor2ColMajor(float *src_ptr, float *dst_ptr, int row, int col); void RowMajor2ColMajor(const float *src_ptr, float *dst_ptr, int row, int col);
void RowMajor2Row4Major(float *src_ptr, float *dst_ptr, int row, int col); void RowMajor2Row4Major(float *src_ptr, float *dst_ptr, int row, int col);
void RowMajor2Row8Major(float *src_ptr, float *dst_ptr, int row, int col); void RowMajor2Row8Major(float *src_ptr, float *dst_ptr, int row, int col);
void RowMajor2Row12Major(float *src_ptr, float *dst_ptr, int row, int col); void RowMajor2Row12Major(float *src_ptr, float *dst_ptr, int row, int col);

Some files were not shown because too many files have changed in this diff Show More

Write Preview
Loading…
Cancel
Save