fix code review

mindspore/lite/nnacl/arg_min_max.c

@@ -33,7 +33,7 @@ void GetCalcParameter(const int *shape, int dims_number, int axis, int *pre_axis
   }
 }
 
-void ArgMinMaxTopk1(const void *input, void *output, const int *shape, ArgMinMaxParameter *param) {
+void ArgMinMaxTopk1(const void *input, void *output, const int *shape, const ArgMinMaxParameter *param) {
   int pre_axis_count = 1;
   int axis_count = 1;
   int after_axis_count = 1;
@@ -48,7 +48,7 @@ void ArgMinMaxTopk1(const void *input, void *output, const int *shape, ArgMinMax
   }
 }
 
-void ArgMinMaxTopknFp32(const float *input, float *output, const int *in_shape, ArgMinMaxParameter *param) {
+void ArgMinMaxTopknFp32(const float *input, float *output, const int *in_shape, const ArgMinMaxParameter *param) {
   if (param->get_max_) {
     switch (param->axis_) {
       case 0:
@@ -82,7 +82,7 @@ void ArgMinMaxTopknFp32(const float *input, float *output, const int *in_shape,
   }
 }
 
-void ArgMinMax(const void *input, void *output, const int *in_shape, ArgMinMaxParameter *param) {
+void ArgMinMax(const void *input, void *output, const int *in_shape, const ArgMinMaxParameter *param) {
   if (param->topk_ == 1) {
     ArgMinMaxTopk1(input, output, in_shape, param);
     return;

mindspore/lite/nnacl/arg_min_max.h

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

mindspore/lite/nnacl/arithmetic_common.c

@@ -17,8 +17,8 @@
 #include "nnacl/arithmetic_common.h"
 #include "nnacl/nnacl_utils.h"
 
-void TileOneDimension(float *inData, float *outData, int dim, size_t ndim, int *inShape, int *inStrides,
-                      int *outStrides, int *multiple) {
+void TileOneDimension(const float *inData, float *outData, int dim, size_t ndim, const int *inShape,
+                      const int *inStrides, const int *outStrides, const int *multiple) {
   int srcDimSize = inShape[dim];
   if (dim == ndim - 1) {
     for (int i = 0; i < multiple[dim]; i++) {
@@ -35,8 +35,8 @@ void TileOneDimension(float *inData, float *outData, int dim, size_t ndim, int *
   }
 }
 
-void TileOneDimensionUint8(uint8_t *inData, uint8_t *outData, int dim, size_t ndim, int *inShape, int *inStrides,
-                           int *outStrides, int *multiple) {
+void TileOneDimensionUint8(const uint8_t *inData, uint8_t *outData, int dim, size_t ndim, const int *inShape,
+                           const int *inStrides, const int *outStrides, const int *multiple) {
   int srcDimSize = inShape[dim];
   if (dim == ndim - 1) {
     for (int i = 0; i < multiple[dim]; i++) {
@@ -74,7 +74,8 @@ void CalcMultiplesAndStrides(ArithmeticParameter *param) {
   ComputeStrides(param->out_shape_, param->out_strides_, param->ndim_);
 }
 
-void TileDimensions(float *data0, float *data1, float *tile_data0, float *tile_data1, ArithmeticParameter *param) {
+void TileDimensions(const float *data0, const float *data1, float *tile_data0, float *tile_data1,
+                    ArithmeticParameter *param) {
   CalcMultiplesAndStrides(param);
   TileOneDimension(data0, tile_data0, 0, param->ndim_, param->in_shape0_, param->in_strides0_, param->out_strides_,
                    param->multiples0_);
@@ -82,7 +83,7 @@ void TileDimensions(float *data0, float *data1, float *tile_data0, float *tile_d
                    param->multiples1_);
 }
 
-void TileDimensionsUint8(uint8_t *data0, uint8_t *data1, uint8_t *tile_data0, uint8_t *tile_data1,
+void TileDimensionsUint8(const uint8_t *data0, const uint8_t *data1, uint8_t *tile_data0, uint8_t *tile_data1,
                          ArithmeticParameter *param) {
   CalcMultiplesAndStrides(param);
   TileOneDimensionUint8(data0, tile_data0, 0, param->ndim_, param->in_shape0_, param->in_strides0_, param->out_strides_,
@@ -91,7 +92,7 @@ void TileDimensionsUint8(uint8_t *data0, uint8_t *data1, uint8_t *tile_data0, ui
                         param->multiples1_);
 }
 
-void TileDimensionsInt8(int8_t *data0, int8_t *data1, int8_t *tile_data0, int8_t *tile_data1,
+void TileDimensionsInt8(const int8_t *data0, const int8_t *data1, int8_t *tile_data0, int8_t *tile_data1,
                         ArithmeticParameter *param) {
   CalcMultiplesAndStrides(param);
   TileOneDimensionUint8((uint8_t *)(data0), (uint8_t *)(tile_data0), 0, param->ndim_, param->in_shape0_,

mindspore/lite/nnacl/arithmetic_common.h

@@ -47,18 +47,19 @@ typedef struct ArithmeticParameter {
 #ifdef __cplusplus
 extern "C" {
 #endif
-void TileOneDimension(float *inData, float *outData, int dim, size_t ndim, int *inShape, int *inStrides,
-                      int *outStrides, int *multiple);
+void TileOneDimension(const float *inData, float *outData, int dim, size_t ndim, const int *inShape,
+                      const int *inStrides, const int *outStrides, const int *multiple);
 void ComputeStrides(const int *shape, int *strides, const int ndim);
 
 void CalcMultiplesAndStrides(ArithmeticParameter *param);
 
-void TileOneDimensionUint8(uint8_t *inData, uint8_t *outData, int dim, size_t ndim, int *inShape, int *inStrides,
-                           int *outStrides, int *multiple);
-void TileDimensions(float *data0, float *data1, float *tile_data0, float *tile_data1, ArithmeticParameter *param);
-void TileDimensionsUint8(uint8_t *data0, uint8_t *data1, uint8_t *tile_data0, uint8_t *tile_data1,
+void TileOneDimensionUint8(const uint8_t *inData, uint8_t *outData, int dim, size_t ndim, const int *inShape,
+                           const int *inStrides, const int *outStrides, const int *multiple);
+void TileDimensions(const float *data0, const float *data1, float *tile_data0, float *tile_data1,
+                    ArithmeticParameter *param);
+void TileDimensionsUint8(const uint8_t *data0, const uint8_t *data1, uint8_t *tile_data0, uint8_t *tile_data1,
                          ArithmeticParameter *param);
-void TileDimensionsInt8(int8_t *data0, int8_t *data1, int8_t *tile_data0, int8_t *tile_data1,
+void TileDimensionsInt8(const int8_t *data0, const int8_t *data1, int8_t *tile_data0, int8_t *tile_data1,
                         ArithmeticParameter *param);
 #ifdef __cplusplus
 }

mindspore/lite/nnacl/flatten.c

@@ -16,6 +16,6 @@
 #include "nnacl/flatten.h"
 #include <string.h>
 
-void Flatten(const void *input, void *output, FlattenParameter *flatten_param) {
+void Flatten(const void *input, void *output, const FlattenParameter *flatten_param) {
   memcpy(output, input, flatten_param->size);
 }

mindspore/lite/nnacl/flatten.h

@@ -25,7 +25,7 @@ typedef struct FlattenParameter {
 #ifdef __cplusplus
 extern "C" {
 #endif
-void Flatten(const void *input, void *output, FlattenParameter *flatten_param);
+void Flatten(const void *input, void *output, const FlattenParameter *flatten_param);
 #ifdef __cplusplus
 }
 #endif

mindspore/lite/nnacl/fp32/arg_min_max_fp32.c

@@ -43,7 +43,7 @@ int ArgCompareDescFp32(const void *a, const void *b) {
   return 0;
 }
 
-void ArgMaxDim0OutValue(const float *input, float *output, const int *in_shape, ArgMinMaxParameter *param) {
+void ArgMaxDim0OutValue(const float *input, float *output, const int *in_shape, const ArgMinMaxParameter *param) {
   for (int32_t i = 0; i < param->in_strides_[0]; ++i) {
     for (int j = 0; j < in_shape[0]; ++j) {
       size_t offset = param->in_strides_[0] * j + i;
@@ -58,7 +58,7 @@ void ArgMaxDim0OutValue(const float *input, float *output, const int *in_shape,
   }
 }
 
-void ArgMaxDim0OutIndex(const float *input, float *output, const int *in_shape, ArgMinMaxParameter *param) {
+void ArgMaxDim0OutIndex(const float *input, float *output, const int *in_shape, const ArgMinMaxParameter *param) {
   for (int32_t i = 0; i < param->in_strides_[0]; ++i) {
     for (int j = 0; j < in_shape[0]; ++j) {
       size_t offset = param->in_strides_[0] * j + i;
@@ -73,7 +73,7 @@ void ArgMaxDim0OutIndex(const float *input, float *output, const int *in_shape,
   }
 }
 
-void ArgMinDim0OutValue(const float *input, float *output, const int *in_shape, ArgMinMaxParameter *param) {
+void ArgMinDim0OutValue(const float *input, float *output, const int *in_shape, const ArgMinMaxParameter *param) {
   for (int32_t i = 0; i < param->in_strides_[0]; ++i) {
     for (int j = 0; j < in_shape[0]; ++j) {
       size_t offset = param->in_strides_[0] * j + i;
@@ -88,7 +88,7 @@ void ArgMinDim0OutValue(const float *input, float *output, const int *in_shape,
   }
 }
 
-void ArgMinDim0OutIndex(const float *input, float *output, const int *in_shape, ArgMinMaxParameter *param) {
+void ArgMinDim0OutIndex(const float *input, float *output, const int *in_shape, const ArgMinMaxParameter *param) {
   for (int32_t i = 0; i < param->in_strides_[0]; ++i) {
     for (int j = 0; j < in_shape[0]; ++j) {
       size_t offset = param->in_strides_[0] * j + i;
@@ -103,7 +103,7 @@ void ArgMinDim0OutIndex(const float *input, float *output, const int *in_shape,
   }
 }
 
-void ArgMaxDim1OutValue(const float *input, float *output, const int *in_shape, ArgMinMaxParameter *param) {
+void ArgMaxDim1OutValue(const float *input, float *output, const int *in_shape, const ArgMinMaxParameter *param) {
   int in_shape1 = in_shape[1];
   for (int i = 0; i < in_shape[0]; ++i) {
     size_t in_dim0_offset = i * param->in_strides_[0];
@@ -123,7 +123,7 @@ void ArgMaxDim1OutValue(const float *input, float *output, const int *in_shape,
   }
 }
 
-void ArgMaxDim1OutIndex(const float *input, float *output, const int *in_shape, ArgMinMaxParameter *param) {
+void ArgMaxDim1OutIndex(const float *input, float *output, const int *in_shape, const ArgMinMaxParameter *param) {
   int in_shape1 = in_shape[1];
   for (int i = 0; i < in_shape[0]; ++i) {
     size_t in_dim0_offset = i * param->in_strides_[0];
@@ -143,7 +143,7 @@ void ArgMaxDim1OutIndex(const float *input, float *output, const int *in_shape,
   }
 }
 
-void ArgMinDim1OutValue(const float *input, float *output, const int *in_shape, ArgMinMaxParameter *param) {
+void ArgMinDim1OutValue(const float *input, float *output, const int *in_shape, const ArgMinMaxParameter *param) {
   int in_shape1 = in_shape[1];
   for (int i = 0; i < in_shape[0]; ++i) {
     size_t in_dim0_offset = i * param->in_strides_[0];
@@ -163,7 +163,7 @@ void ArgMinDim1OutValue(const float *input, float *output, const int *in_shape,
   }
 }
 
-void ArgMinDim1OutIndex(const float *input, float *output, const int *in_shape, ArgMinMaxParameter *param) {
+void ArgMinDim1OutIndex(const float *input, float *output, const int *in_shape, const ArgMinMaxParameter *param) {
   int in_shape1 = in_shape[1];
   for (int i = 0; i < in_shape[0]; ++i) {
     size_t in_dim0_offset = i * param->in_strides_[0];
@@ -183,7 +183,7 @@ void ArgMinDim1OutIndex(const float *input, float *output, const int *in_shape,
   }
 }
 
-void ArgMaxDim2OutValue(const float *input, float *output, const int *in_shape, ArgMinMaxParameter *param) {
+void ArgMaxDim2OutValue(const float *input, float *output, const int *in_shape, const ArgMinMaxParameter *param) {
   int in_shape1 = in_shape[1];
   int in_shape2 = in_shape[2];
   for (int i = 0; i < in_shape[0]; ++i) {
@@ -208,7 +208,7 @@ void ArgMaxDim2OutValue(const float *input, float *output, const int *in_shape,
   }
 }
 
-void ArgMaxDim2OutIndex(const float *input, float *output, const int *in_shape, ArgMinMaxParameter *param) {
+void ArgMaxDim2OutIndex(const float *input, float *output, const int *in_shape, const ArgMinMaxParameter *param) {
   int in_shape1 = in_shape[1];
   int in_shape2 = in_shape[2];
   for (int i = 0; i < in_shape[0]; ++i) {
@@ -233,7 +233,7 @@ void ArgMaxDim2OutIndex(const float *input, float *output, const int *in_shape,
   }
 }
 
-void ArgMinDim2OutValue(const float *input, float *output, const int *in_shape, ArgMinMaxParameter *param) {
+void ArgMinDim2OutValue(const float *input, float *output, const int *in_shape, const ArgMinMaxParameter *param) {
   int in_shape1 = in_shape[1];
   int in_shape2 = in_shape[2];
   for (int i = 0; i < in_shape[0]; ++i) {
@@ -258,7 +258,7 @@ void ArgMinDim2OutValue(const float *input, float *output, const int *in_shape,
   }
 }
 
-void ArgMinDim2OutIndex(const float *input, float *output, const int *in_shape, ArgMinMaxParameter *param) {
+void ArgMinDim2OutIndex(const float *input, float *output, const int *in_shape, const ArgMinMaxParameter *param) {
   int in_shape1 = in_shape[1];
   int in_shape2 = in_shape[2];
   for (int i = 0; i < in_shape[0]; ++i) {
@@ -283,7 +283,7 @@ void ArgMinDim2OutIndex(const float *input, float *output, const int *in_shape,
   }
 }
 
-void ArgMaxDim3OutValue(const float *input, float *output, const int *in_shape, ArgMinMaxParameter *param) {
+void ArgMaxDim3OutValue(const float *input, float *output, const int *in_shape, const ArgMinMaxParameter *param) {
   int in_shape1 = in_shape[1];
   int in_shape2 = in_shape[2];
   int in_shape3 = in_shape[3];
@@ -311,7 +311,7 @@ void ArgMaxDim3OutValue(const float *input, float *output, const int *in_shape,
   }
 }
 
-void ArgMaxDim3OutIndex(const float *input, float *output, const int *in_shape, ArgMinMaxParameter *param) {
+void ArgMaxDim3OutIndex(const float *input, float *output, const int *in_shape, const ArgMinMaxParameter *param) {
   int in_shape1 = in_shape[1];
   int in_shape2 = in_shape[2];
   int in_shape3 = in_shape[3];
@@ -339,7 +339,7 @@ void ArgMaxDim3OutIndex(const float *input, float *output, const int *in_shape,
   }
 }
 
-void ArgMinDim3OutValue(const float *input, float *output, const int *in_shape, ArgMinMaxParameter *param) {
+void ArgMinDim3OutValue(const float *input, float *output, const int *in_shape, const ArgMinMaxParameter *param) {
   int in_shape1 = in_shape[1];
   int in_shape2 = in_shape[2];
   int in_shape3 = in_shape[3];
@@ -367,7 +367,7 @@ void ArgMinDim3OutValue(const float *input, float *output, const int *in_shape,
   }
 }
 
-void ArgMinDim3OutIndex(const float *input, float *output, const int *in_shape, ArgMinMaxParameter *param) {
+void ArgMinDim3OutIndex(const float *input, float *output, const int *in_shape, const ArgMinMaxParameter *param) {
   int in_shape1 = in_shape[1];
   int in_shape2 = in_shape[2];
   int in_shape3 = in_shape[3];
@@ -395,7 +395,7 @@ void ArgMinDim3OutIndex(const float *input, float *output, const int *in_shape,
   }
 }
 
-void ArgMaxDim0(const float *input, float *output, const int *in_shape, ArgMinMaxParameter *param) {
+void ArgMaxDim0(const float *input, float *output, const int *in_shape, const ArgMinMaxParameter *param) {
   if (param->out_value_) {
     ArgMaxDim0OutValue(input, output, in_shape, param);
   } else {
@@ -403,7 +403,7 @@ void ArgMaxDim0(const float *input, float *output, const int *in_shape, ArgMinMa
   }
 }
 
-void ArgMinDim0(const float *input, float *output, const int *in_shape, ArgMinMaxParameter *param) {
+void ArgMinDim0(const float *input, float *output, const int *in_shape, const ArgMinMaxParameter *param) {
   if (param->out_value_) {
     ArgMinDim0OutValue(input, output, in_shape, param);
   } else {
@@ -411,7 +411,7 @@ void ArgMinDim0(const float *input, float *output, const int *in_shape, ArgMinMa
   }
 }
 
-void ArgMaxDim1(const float *input, float *output, const int *in_shape, ArgMinMaxParameter *param) {
+void ArgMaxDim1(const float *input, float *output, const int *in_shape, const ArgMinMaxParameter *param) {
   if (param->out_value_) {
     ArgMaxDim1OutValue(input, output, in_shape, param);
   } else {
@@ -419,7 +419,7 @@ void ArgMaxDim1(const float *input, float *output, const int *in_shape, ArgMinMa
   }
 }
 
-void ArgMinDim1(const float *input, float *output, const int *in_shape, ArgMinMaxParameter *param) {
+void ArgMinDim1(const float *input, float *output, const int *in_shape, const ArgMinMaxParameter *param) {
   if (param->out_value_) {
     ArgMinDim1OutValue(input, output, in_shape, param);
   } else {
@@ -427,7 +427,7 @@ void ArgMinDim1(const float *input, float *output, const int *in_shape, ArgMinMa
   }
 }
 
-void ArgMaxDim2(const float *input, float *output, const int *in_shape, ArgMinMaxParameter *param) {
+void ArgMaxDim2(const float *input, float *output, const int *in_shape, const ArgMinMaxParameter *param) {
   if (param->out_value_) {
     ArgMaxDim2OutValue(input, output, in_shape, param);
   } else {
@@ -435,7 +435,7 @@ void ArgMaxDim2(const float *input, float *output, const int *in_shape, ArgMinMa
   }
 }
 
-void ArgMinDim2(const float *input, float *output, const int *in_shape, ArgMinMaxParameter *param) {
+void ArgMinDim2(const float *input, float *output, const int *in_shape, const ArgMinMaxParameter *param) {
   if (param->out_value_) {
     ArgMinDim2OutValue(input, output, in_shape, param);
   } else {
@@ -443,7 +443,7 @@ void ArgMinDim2(const float *input, float *output, const int *in_shape, ArgMinMa
   }
 }
 
-void ArgMaxDim3(const float *input, float *output, const int *in_shape, ArgMinMaxParameter *param) {
+void ArgMaxDim3(const float *input, float *output, const int *in_shape, const ArgMinMaxParameter *param) {
   if (param->out_value_) {
     ArgMaxDim3OutValue(input, output, in_shape, param);
   } else {
@@ -451,7 +451,7 @@ void ArgMaxDim3(const float *input, float *output, const int *in_shape, ArgMinMa
   }
 }
 
-void ArgMinDim3(const float *input, float *output, const int *in_shape, ArgMinMaxParameter *param) {
+void ArgMinDim3(const float *input, float *output, const int *in_shape, const ArgMinMaxParameter *param) {
   if (param->out_value_) {
     ArgMinDim3OutValue(input, output, in_shape, param);
   } else {
@@ -459,7 +459,7 @@ void ArgMinDim3(const float *input, float *output, const int *in_shape, ArgMinMa
   }
 }
 
-void ArgMax(const float *input, float *output, ArgMinMaxParameter *param, int pre_axis_count, int axis_count,
+void ArgMax(const float *input, float *output, const ArgMinMaxParameter *param, int pre_axis_count, int axis_count,
             int after_axis_count) {
   bool out_value = param->out_value_;
   for (int i = 0; i < pre_axis_count; ++i) {
@@ -480,7 +480,7 @@ void ArgMax(const float *input, float *output, ArgMinMaxParameter *param, int pr
   }
 }
 
-void ArgMin(const float *input, float *output, ArgMinMaxParameter *param, int pre_axis_count, int axis_count,
+void ArgMin(const float *input, float *output, const ArgMinMaxParameter *param, int pre_axis_count, int axis_count,
             int after_axis_count) {
   bool out_value = param->out_value_;
   for (int i = 0; i < pre_axis_count; ++i) {

mindspore/lite/nnacl/fp32/arg_min_max_fp32.h

@@ -21,18 +21,18 @@
 #ifdef __cplusplus
 extern "C" {
 #endif
-void ArgMax(const float *input, float *output, ArgMinMaxParameter *param, int pre_axis_count, int axis_count,
+void ArgMax(const float *input, float *output, const ArgMinMaxParameter *param, int pre_axis_count, int axis_count,
             int after_axis_count);
-void ArgMin(const float *input, float *output, ArgMinMaxParameter *param, int pre_axis_count, int axis_count,
+void ArgMin(const float *input, float *output, const ArgMinMaxParameter *param, int pre_axis_count, int axis_count,
             int after_axis_count);
-void ArgMaxDim0(const float *input, float *output, const int *in_shape, ArgMinMaxParameter *param);
-void ArgMinDim0(const float *input, float *output, const int *in_shape, ArgMinMaxParameter *param);
-void ArgMaxDim1(const float *input, float *output, const int *in_shape, ArgMinMaxParameter *param);
-void ArgMinDim1(const float *input, float *output, const int *in_shape, ArgMinMaxParameter *param);
-void ArgMaxDim2(const float *input, float *output, const int *in_shape, ArgMinMaxParameter *param);
-void ArgMinDim2(const float *input, float *output, const int *in_shape, ArgMinMaxParameter *param);
-void ArgMaxDim3(const float *input, float *output, const int *in_shape, ArgMinMaxParameter *param);
-void ArgMinDim3(const float *input, float *output, const int *in_shape, ArgMinMaxParameter *param);
+void ArgMaxDim0(const float *input, float *output, const int *in_shape, const ArgMinMaxParameter *param);
+void ArgMinDim0(const float *input, float *output, const int *in_shape, const ArgMinMaxParameter *param);
+void ArgMaxDim1(const float *input, float *output, const int *in_shape, const ArgMinMaxParameter *param);
+void ArgMinDim1(const float *input, float *output, const int *in_shape, const ArgMinMaxParameter *param);
+void ArgMaxDim2(const float *input, float *output, const int *in_shape, const ArgMinMaxParameter *param);
+void ArgMinDim2(const float *input, float *output, const int *in_shape, const ArgMinMaxParameter *param);
+void ArgMaxDim3(const float *input, float *output, const int *in_shape, const ArgMinMaxParameter *param);
+void ArgMinDim3(const float *input, float *output, const int *in_shape, const ArgMinMaxParameter *param);
 #ifdef __cplusplus
 }
 #endif

mindspore/lite/nnacl/fp32/arithmetic_fp32.c

@@ -615,8 +615,8 @@ int ElementMulRelu6Int(const int *input0, const int *input1, int *output, const
   return NNACL_OK;
 }
 
-int BroadcastMul(float *input0, float *input1, float *tile_input0, float *tile_input1, float *output, int element_size,
-                 ArithmeticParameter *param) {
+int BroadcastMul(const float *input0, const float *input1, float *tile_input0, float *tile_input1, float *output,
+                 int element_size, ArithmeticParameter *param) {
   TileDimensions(input0, input1, tile_input0, tile_input1, param);
   return ElementMul(tile_input0, tile_input1, output, element_size);
 }
@@ -690,21 +690,21 @@ int ElementAddInt(const int *input0, const int *input1, int *output, const int e
   return NNACL_OK;
 }
 
-int ElementAddInt8(int8_t *input0, int8_t *input1, int8_t *output, int element_size) {
+int ElementAddInt8(const int8_t *input0, const int8_t *input1, int8_t *output, int element_size) {
   for (int i = 0; i < element_size; i++) {
     output[i] = input0[i] + input1[i];
   }
   return NNACL_OK;
 }
 
-int BroadcastAdd(float *input0, float *input1, float *tile_input0, float *tile_input1, float *output, int element_size,
-                 ArithmeticParameter *param) {
+int BroadcastAdd(const float *input0, const float *input1, float *tile_input0, float *tile_input1, float *output,
+                 int element_size, ArithmeticParameter *param) {
   TileDimensions(input0, input1, tile_input0, tile_input1, param);
   return ElementAdd(tile_input0, tile_input1, output, element_size);
 }
 
-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 BroadcastAddInt8(const int8_t *input0, const int8_t *input1, int8_t *tile_input0, int8_t *tile_input1,
+                     int8_t *output, int element_size, ArithmeticParameter *param) {
   TileDimensionsInt8(input0, input1, tile_input0, tile_input1, param);
   return ElementAddInt8(tile_input0, tile_input1, output, element_size);
 }
@@ -763,8 +763,8 @@ int ElementSubRelu6(const float *input0, const float *input1, float *output, con
   return NNACL_OK;
 }
 
-int BroadcastSub(float *input0, float *input1, float *tile_input0, float *tile_input1, float *output, int element_size,
-                 ArithmeticParameter *param) {
+int BroadcastSub(const float *input0, const float *input1, float *tile_input0, float *tile_input1, float *output,
+                 int element_size, ArithmeticParameter *param) {
   TileDimensions(input0, input1, tile_input0, tile_input1, param);
   return ElementSub(tile_input0, tile_input1, output, element_size);
 }
@@ -791,8 +791,8 @@ int ElementDivRelu6(const float *input0, const float *input1, float *output, con
   return NNACL_OK;
 }
 
-int BroadcastDiv(float *input0, float *input1, float *tile_input0, float *tile_input1, float *output, int element_size,
-                 ArithmeticParameter *param) {
+int BroadcastDiv(const float *input0, const float *input1, float *tile_input0, float *tile_input1, float *output,
+                 int element_size, ArithmeticParameter *param) {
   TileDimensions(input0, input1, tile_input0, tile_input1, param);
   return ElementDiv(tile_input0, tile_input1, output, element_size);
 }
@@ -811,7 +811,7 @@ int ElementFloorModInt(const int *input0, const int *input1, int *output, const
   return NNACL_OK;
 }
 
-int BroadcastFloorMod(float *input0, float *input1, float *tile_input0, float *tile_input1, float *output,
+int BroadcastFloorMod(const float *input0, const float *input1, float *tile_input0, float *tile_input1, float *output,
                       int element_size, ArithmeticParameter *param) {
   TileDimensions(input0, input1, tile_input0, tile_input1, param);
   return ElementFloorMod(tile_input0, tile_input1, output, element_size);
@@ -831,7 +831,7 @@ int ElementFloorDivInt(const int *input0, const int *input1, int *output, const
   return NNACL_OK;
 }
 
-int BroadcastFloorDiv(float *input0, float *input1, float *tile_input0, float *tile_input1, float *output,
+int BroadcastFloorDiv(const float *input0, const float *input1, float *tile_input0, float *tile_input1, float *output,
                       int element_size, ArithmeticParameter *param) {
   TileDimensions(input0, input1, tile_input0, tile_input1, param);
   return ElementFloorDiv(tile_input0, tile_input1, output, element_size);
@@ -862,13 +862,13 @@ int ElementSquaredDifference(const float *input0, const float *input1, float *ou
   return ElementMul(output, output, output, element_size);
 }
 
-int BroadcastSquaredDifference(float *input0, float *input1, float *tile_input0, float *tile_input1, float *output,
-                               int element_size, ArithmeticParameter *param) {
+int BroadcastSquaredDifference(const float *input0, const float *input1, float *tile_input0, float *tile_input1,
+                               float *output, int element_size, ArithmeticParameter *param) {
   BroadcastSub(input0, input1, tile_input0, tile_input1, output, element_size, param);
   return ElementMul(output, output, output, element_size);
 }
 
-int BroadcastLogicalAnd(float *input0, float *input1, float *tile_input0, float *tile_input1, float *output,
+int BroadcastLogicalAnd(const float *input0, const float *input1, float *tile_input0, float *tile_input1, float *output,
                         int element_size, ArithmeticParameter *param) {
   TileDimensions(input0, input1, tile_input0, tile_input1, param);
   return ElementLogicalAnd(tile_input0, tile_input1, output, element_size);
@@ -894,7 +894,7 @@ int ElementLogicalOr(const float *input0, const float *input1, float *output, co
   return NNACL_OK;
 }
 
-int BroadcastLogicalOr(float *input0, float *input1, float *tile_input0, float *tile_input1, float *output,
+int BroadcastLogicalOr(const float *input0, const float *input1, float *tile_input0, float *tile_input1, float *output,
                        int element_size, ArithmeticParameter *param) {
   TileDimensions(input0, input1, tile_input0, tile_input1, param);
   return ElementLogicalOr(tile_input0, tile_input1, output, element_size);
@@ -916,7 +916,7 @@ int ElementMaximum(const float *input0, const float *input1, float *output, cons
   return NNACL_OK;
 }
 
-int BroadcastMaximum(float *input0, float *input1, float *tile_input0, float *tile_input1, float *output,
+int BroadcastMaximum(const float *input0, const float *input1, float *tile_input0, float *tile_input1, float *output,
                      int element_size, ArithmeticParameter *param) {
   TileDimensions(input0, input1, tile_input0, tile_input1, param);
   return ElementMaximum(tile_input0, tile_input1, output, element_size);
@@ -938,7 +938,7 @@ int ElementMinimum(const float *input0, const float *input1, float *output, cons
   return NNACL_OK;
 }
 
-int BroadcastMinimum(float *input0, float *input1, float *tile_input0, float *tile_input1, float *output,
+int BroadcastMinimum(const float *input0, const float *input1, float *tile_input0, float *tile_input1, float *output,
                      int element_size, ArithmeticParameter *param) {
   TileDimensions(input0, input1, tile_input0, tile_input1, param);
   return ElementMinimum(tile_input0, tile_input1, output, element_size);
@@ -970,7 +970,7 @@ int ElementNotEqual(const float *input0, const float *input1, float *output, con
   return NNACL_OK;
 }
 
-int BroadcastNotEqual(float *input0, float *input1, float *tile_input0, float *tile_input1, float *output,
+int BroadcastNotEqual(const float *input0, const float *input1, float *tile_input0, float *tile_input1, float *output,
                       int element_size, ArithmeticParameter *param) {
   TileDimensions(input0, input1, tile_input0, tile_input1, param);
   return ElementNotEqual(tile_input0, tile_input1, output, element_size);
@@ -1002,7 +1002,7 @@ int ElementEqual(const float *input0, const float *input1, float *output, const
   return NNACL_OK;
 }
 
-int BroadcastEqual(float *input0, float *input1, float *tile_input0, float *tile_input1, float *output,
+int BroadcastEqual(const float *input0, const float *input1, float *tile_input0, float *tile_input1, float *output,
                    int element_size, ArithmeticParameter *param) {
   TileDimensions(input0, input1, tile_input0, tile_input1, param);
   return ElementEqual(tile_input0, tile_input1, output, element_size);
@@ -1026,8 +1026,8 @@ int ElementLess(const float *input0, const float *input1, float *output, const i
   return NNACL_OK;
 }
 
-int BroadcastLess(float *input0, float *input1, float *tile_input0, float *tile_input1, float *output, int element_size,
-                  ArithmeticParameter *param) {
+int BroadcastLess(const float *input0, const float *input1, float *tile_input0, float *tile_input1, float *output,
+                  int element_size, ArithmeticParameter *param) {
   TileDimensions(input0, input1, tile_input0, tile_input1, param);
   return ElementLess(tile_input0, tile_input1, output, element_size);
 }
@@ -1050,7 +1050,7 @@ int ElementLessEqual(const float *input0, const float *input1, float *output, co
   return NNACL_OK;
 }
 
-int BroadcastLessEqual(float *input0, float *input1, float *tile_input0, float *tile_input1, float *output,
+int BroadcastLessEqual(const float *input0, const float *input1, float *tile_input0, float *tile_input1, float *output,
                        int element_size, ArithmeticParameter *param) {
   TileDimensions(input0, input1, tile_input0, tile_input1, param);
   return ElementLessEqual(tile_input0, tile_input1, output, element_size);
@@ -1074,7 +1074,7 @@ int ElementGreater(const float *input0, const float *input1, float *output, cons
   return NNACL_OK;
 }
 
-int BroadcastGreater(float *input0, float *input1, float *tile_input0, float *tile_input1, float *output,
+int BroadcastGreater(const float *input0, const float *input1, float *tile_input0, float *tile_input1, float *output,
                      int element_size, ArithmeticParameter *param) {
   TileDimensions(input0, input1, tile_input0, tile_input1, param);
   return ElementGreater(tile_input0, tile_input1, output, element_size);
@@ -1098,8 +1098,8 @@ int ElementGreaterEqual(const float *input0, const float *input1, float *output,
   return NNACL_OK;
 }
 
-int BroadcastGreaterEqual(float *input0, float *input1, float *tile_input0, float *tile_input1, float *output,
-                          int element_size, ArithmeticParameter *param) {
+int BroadcastGreaterEqual(const float *input0, const float *input1, float *tile_input0, float *tile_input1,
+                          float *output, int element_size, ArithmeticParameter *param) {
   TileDimensions(input0, input1, tile_input0, tile_input1, param);
   return ElementGreaterEqual(tile_input0, tile_input1, output, element_size);
 }
@@ -1111,7 +1111,7 @@ int ArithmeticInferShape(int **in_shape, size_t *dim_size, int *out_shape, int *
                          int *in_datatype, int *out_datatype, OpParameter *param) {
   *out_format = in_format[0];
   *out_datatype = in_datatype[0];
-  ArithmeticParameter *arithmetic_parameter = (ArithmeticParameter *)param;
+  const ArithmeticParameter *arithmetic_parameter = (const ArithmeticParameter *)param;
   int ndim0 = dim_size[0];
   int ndim1 = dim_size[1];
   int *in_shape0 = in_shape[0];

mindspore/lite/nnacl/fp32/arithmetic_fp32.h

@@ -64,85 +64,85 @@ int ElementMulRelu6(const float *input0, const float *input1, float *output, con
 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,
-                 ArithmeticParameter *param);
+int BroadcastMul(const float *input0, const float *input1, float *tile_input0, float *tile_input1, float *output,
+                 int element_size, ArithmeticParameter *param);
 
 int ElementAdd(const float *input0, const float *input1, float *output, const int element_size);
 int ElementAddRelu(const float *input0, const float *input1, float *output, const int element_size);
 int ElementAddRelu6(const float *input0, const float *input1, float *output, const 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,
-                 ArithmeticParameter *param);
-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 BroadcastAdd(const float *input0, const float *input1, float *tile_input0, float *tile_input1, float *output,
+                 int element_size, ArithmeticParameter *param);
+int BroadcastAddInt8(const int8_t *input0, const int8_t *input1, int8_t *tile_input0, int8_t *tile_input1,
+                     int8_t *output, int element_size, ArithmeticParameter *param);
 
 int ElementSub(const float *input0, const float *input1, float *output, const int element_size);
 int ElementSubRelu(const float *input0, const float *input1, float *output, const 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,
-                 ArithmeticParameter *param);
+int BroadcastSub(const float *input0, const float *input1, float *tile_input0, float *tile_input1, float *output,
+                 int element_size, ArithmeticParameter *param);
 
 int ElementDiv(const float *input0, const float *input1, float *output, const int element_size);
 int ElementDivRelu(const float *input0, const float *input1, float *output, const 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,
-                 ArithmeticParameter *param);
+int BroadcastDiv(const float *input0, const float *input1, float *tile_input0, float *tile_input1, float *output,
+                 int element_size, ArithmeticParameter *param);
 
 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(const float *input0, const float *input1, float *tile_input0, float *tile_input1, float *output,
                         int element_size, ArithmeticParameter *param);
 
 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(const float *input0, const float *input1, float *tile_input0, float *tile_input1, float *output,
                        int element_size, ArithmeticParameter *param);
 
 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(const float *input0, const float *input1, float *tile_input0, float *tile_input1, float *output,
                      int element_size, ArithmeticParameter *param);
 
 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(const float *input0, const float *input1, float *tile_input0, float *tile_input1, float *output,
                      int element_size, ArithmeticParameter *param);
 
 int ElementFloorDiv(const float *input0, const float *input1, float *output, const 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(const float *input0, const float *input1, float *tile_input0, float *tile_input1, float *output,
                       int element_size, ArithmeticParameter *param);
 
 int ElementFloorMod(const float *input0, const float *input1, float *output, const 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(const float *input0, const float *input1, float *tile_input0, float *tile_input1, float *output,
                       int element_size, ArithmeticParameter *param);
 
 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 element_size, ArithmeticParameter *param);
+int BroadcastSquaredDifference(const float *input0, const float *input1, float *tile_input0, float *tile_input1,
+                               float *output, int element_size, ArithmeticParameter *param);
 
 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(const float *input0, const float *input1, float *tile_input0, float *tile_input1, float *output,
                       int element_size, ArithmeticParameter *param);
 
 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(const float *input0, const float *input1, float *tile_input0, float *tile_input1, float *output,
                    int element_size, ArithmeticParameter *param);
 
 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,
-                  ArithmeticParameter *param);
+int BroadcastLess(const float *input0, const float *input1, float *tile_input0, float *tile_input1, float *output,
+                  int element_size, ArithmeticParameter *param);
 
 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(const float *input0, const float *input1, float *tile_input0, float *tile_input1, float *output,
                        int element_size, ArithmeticParameter *param);
 
 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(const float *input0, const float *input1, float *tile_input0, float *tile_input1, float *output,
                      int element_size, ArithmeticParameter *param);
 
 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 element_size, ArithmeticParameter *param);
+int BroadcastGreaterEqual(const float *input0, const float *input1, float *tile_input0, float *tile_input1,
+                          float *output, int element_size, ArithmeticParameter *param);
 
 #ifdef ENABLE_NNACL_INFER_SHAPE
 int ArithmeticInferShape(int **in_shape, size_t *dim_size, int *out_shape, int *in_format, int *out_format,

mindspore/lite/nnacl/fp32/batchnorm_fp32.c

@@ -19,8 +19,8 @@
 #include "nnacl/batchnorm_parameter.h"
 #include "nnacl/op_base.h"
 
-void BatchNormFp32(const void *input, const void *mean, const void *variance, BatchNormParameter *param, int task_id,
-                   void *output) {
+void BatchNormFp32(const void *input, const void *mean, const void *variance, const BatchNormParameter *param,
+                   int task_id, void *output) {
   int units_per_thread = UP_DIV(param->unit_, param->op_parameter_.thread_num_);
   int completed_units = task_id * units_per_thread;
   int cur_unit = MSMIN(units_per_thread, param->unit_ - completed_units);
@@ -37,7 +37,7 @@ void BatchNormFp32(const void *input, const void *mean, const void *variance, Ba
 }
 
 void FusedBatchNormFp32(const void *input, const void *scale, const void *offset, const void *mean,
-                        const void *variance, BatchNormParameter *param, int task_id, void *output) {
+                        const void *variance, const BatchNormParameter *param, int task_id, void *output) {
   int units_per_thread = UP_DIV(param->unit_, param->op_parameter_.thread_num_);
   int completed_units = task_id * units_per_thread;
   int cur_unit = MSMIN(units_per_thread, param->unit_ - completed_units);
@@ -53,7 +53,7 @@ void FusedBatchNormFp32(const void *input, const void *scale, const void *offset
   }
 }
 
-void FusedBatchNormFp32MeanVar(const float *input, float *run_mean, float *run_var, BatchNormParameter *param,
+void FusedBatchNormFp32MeanVar(const float *input, float *run_mean, float *run_var, const BatchNormParameter *param,
                                float *save_mean, float *save_var) {
   const float N = (float)param->unit_;
   const float VN = N;

mindspore/lite/nnacl/fp32/batchnorm_fp32.h

@@ -23,12 +23,12 @@
 extern "C" {
 #endif
 
-void BatchNormFp32(const void *input, const void *mean, const void *variance, BatchNormParameter *param, int task_id,
-                   void *output);
+void BatchNormFp32(const void *input, const void *mean, const void *variance, const BatchNormParameter *param,
+                   int task_id, void *output);
 void FusedBatchNormFp32(const void *input, const void *scale, const void *offset, const void *mean,
-                        const void *variance, BatchNormParameter *param, int task_id, void *output);
+                        const void *variance, const BatchNormParameter *param, int task_id, void *output);
 
-void FusedBatchNormFp32MeanVar(const float *input, float *run_mean, float *run_var, BatchNormParameter *param,
+void FusedBatchNormFp32MeanVar(const float *input, float *run_mean, float *run_var, const BatchNormParameter *param,
                                float *save_mean, float *save_var);
 #ifdef __cplusplus
 }

mindspore/lite/nnacl/fp32/concat_fp32.c

@@ -17,8 +17,8 @@
 #include "nnacl/fp32/concat_fp32.h"
 #include <string.h>
 
-void Concat(void **input, int input_num, int axis, int **inputs_output_shape, size_t shape_size, void *output,
-            int task_id, int thread_num) {
+void Concat(const void **input, int input_num, int axis, const int **inputs_output_shape, size_t shape_size,
+            void *output, int task_id, int thread_num) {
   int before_axis_size = 1;
   for (int i = 0; i < axis; ++i) {
     before_axis_size *= inputs_output_shape[0][i];
@@ -32,12 +32,12 @@ void Concat(void **input, int input_num, int axis, int **inputs_output_shape, si
   uint8_t *dst_base = (output);
   size_t output_stride = after_axis_size * inputs_output_shape[input_num][axis];
   for (int i = 0; i < input_num; ++i) {
-    uint8_t *src_base = (input[i]);
+    const uint8_t *src_base = (input[i]);
     size_t input_stride = after_axis_size * inputs_output_shape[i][axis];
     int offset = UP_DIV(input_stride, thread_num);
     int count = MSMIN(offset, input_stride - offset * task_id);
     for (int j = 0; j < before_axis_size; j++) {
-      uint8_t *src = src_base + j * input_stride + task_id * offset;
+      const uint8_t *src = src_base + j * input_stride + task_id * offset;
       uint8_t *dst = dst_base + j * output_stride + axis_offset * after_axis_size + task_id * offset;
       memcpy(dst, src, count);
     }

mindspore/lite/nnacl/fp32/concat_fp32.h

@@ -22,8 +22,8 @@
 #ifdef __cplusplus
 extern "C" {
 #endif
-void Concat(void **input, int input_num, int axis, int **inputs_output_shape, size_t shape_size, void *output,
-            int task_id, int thread_num);
+void Concat(const void **input, int input_num, int axis, const int **inputs_output_shape, size_t shape_size,
+            void *output, int task_id, int thread_num);
 #ifdef __cplusplus
 }
 #endif

mindspore/lite/nnacl/fp32/constant_of_shape_fp32.c

@@ -16,7 +16,7 @@
 
 #include "nnacl/fp32/constant_of_shape_fp32.h"
 
-int ConstantOfShape(float *output, int tid, ConstantOfShapeParameter *param) {
+int ConstantOfShape(float *output, int tid, const ConstantOfShapeParameter *param) {
   int size = param->unit_;
   float data = param->value_;
   int ind_st = MSMIN(tid * size, param->element_sz_);
@@ -27,7 +27,7 @@ int ConstantOfShape(float *output, int tid, ConstantOfShapeParameter *param) {
   return NNACL_OK;
 }
 
-int ConstantOfShapeInt(int32_t *output, int tid, ConstantOfShapeParameter *param) {
+int ConstantOfShapeInt(int32_t *output, int tid, const ConstantOfShapeParameter *param) {
   int size = param->unit_;
   float data = param->value_;
   int ind_st = MSMIN(tid * size, param->element_sz_);

mindspore/lite/nnacl/fp32/constant_of_shape_fp32.h

@@ -33,8 +33,8 @@ typedef struct ConstantOfShapeParameter {
 #ifdef __cplusplus
 extern "C" {
 #endif
-int ConstantOfShape(float *output, int tid, ConstantOfShapeParameter *param);
-int ConstantOfShapeInt(int32_t *output, int tid, ConstantOfShapeParameter *param);
+int ConstantOfShape(float *output, int tid, const ConstantOfShapeParameter *param);
+int ConstantOfShapeInt(int32_t *output, int tid, const ConstantOfShapeParameter *param);
 #ifdef __cplusplus
 }
 #endif

mindspore/lite/nnacl/fp32/conv_fp32.c

@@ -22,7 +22,7 @@
 
 // fp32 conv common
 void ConvFp32(const 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, const ConvParameter *conv_param) {
   int out_channel = conv_param->output_channel_;
   int deep = conv_param->kernel_h_ * conv_param->kernel_w_ * conv_param->input_channel_;
   int output_count = conv_param->output_h_ * conv_param->output_w_;
@@ -61,8 +61,8 @@ void ConvFp32(const float *input_data, float *packed_input, const float *packed_
 
 // fp32 conv winograd
 void ConvWinogardFp32(const 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,
-                      OutputTransFunc out_func) {
+                      TmpBufferAddress *buffer_list, int task_id, const ConvParameter *conv_param,
+                      InputTransFunc in_func, OutputTransFunc out_func) {
   int in_channel = conv_param->input_channel_;
   int out_w_block = UP_DIV(conv_param->output_w_, conv_param->output_unit_);
   int out_h_block = UP_DIV(conv_param->output_h_, conv_param->output_unit_);

mindspore/lite/nnacl/fp32/conv_fp32.h

@@ -35,12 +35,12 @@ extern "C" {
 
 // fp32 convolution common (im2col+gemm)
 void ConvFp32(const 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, const ConvParameter *conv_param);
 
 // fp32 convolution winograd
 void ConvWinogardFp32(const 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,
-                      OutputTransFunc out_func);
+                      TmpBufferAddress *buffer_list, int task_id, const ConvParameter *conv_param,
+                      InputTransFunc in_func, OutputTransFunc out_func);
 #ifdef __cplusplus
 }
 #endif

mindspore/lite/nnacl/fp32/crop_fp32.c

@@ -18,7 +18,7 @@
 #include "nnacl/op_base.h"
 #include "nnacl/crop_parameter.h"
 
-void Pad4DOffset(CropParameter *crop_param, int64_t *offset) {
+void Pad4DOffset(const CropParameter *crop_param, int64_t *offset) {
   int axis = crop_param->axis_;
   for (int i = DIMENSION_4D - 1; i >= 0; --i) {
     int offset_index = i - axis;
@@ -30,8 +30,8 @@ void Pad4DOffset(CropParameter *crop_param, int64_t *offset) {
   }
 }
 
-void Crop4D(const float *input, float *output, const int *in_shape, const int *out_shape, CropParameter *crop_param,
-            int thread_id) {
+void Crop4D(const float *input, float *output, const int *in_shape, const int *out_shape,
+            const CropParameter *crop_param, int thread_id) {
   int64_t offset_pad[DIMENSION_4D];
   Pad4DOffset(crop_param, offset_pad);
   int out_shape1 = out_shape[1];
@@ -66,7 +66,7 @@ void Crop4D(const float *input, float *output, const int *in_shape, const int *o
 }
 
 void Crop4DNoParallel(const float *input, float *output, const int *in_shape, const int *out_shape,
-                      CropParameter *crop_param) {
+                      const CropParameter *crop_param) {
   int64_t offset_pad[DIMENSION_4D];
   Pad4DOffset(crop_param, offset_pad);
   size_t in_dim2_stride = in_shape[3];

mindspore/lite/nnacl/fp32/crop_fp32.h

@@ -23,10 +23,10 @@
 #ifdef __cplusplus
 extern "C" {
 #endif
-void Crop4D(const float *input, float *output, const int *in_shape, const int *out_shape, CropParameter *crop_param,
-            int thread_id);
+void Crop4D(const float *input, float *output, const int *in_shape, const int *out_shape,
+            const CropParameter *crop_param, int thread_id);
 void Crop4DNoParallel(const float *input, float *output, const int *in_shape, const int *out_shape,
-                      CropParameter *crop_param);
+                      const CropParameter *crop_param);
 #ifdef __cplusplus
 }
 #endif

mindspore/lite/nnacl/fp32/deconv_fp32.c

@@ -34,7 +34,7 @@ void PackDeConvWeightFp32(const float *weight, float *dst, int input_channel, in
 }
 
 void DeConvPostFp32C8(const float *src, float *tmp, const float *bias, float *dst, int output_channel,
-                      ConvParameter *conv_param) {
+                      const ConvParameter *conv_param) {
   /* arm64 row12x8-major(ih*iw x oc*kh*kw)  ->  row8-major(oh*ow x oc) */
   /* arm32 row4x8-major(ih*iw x oc*kh*kw)   ->  row8-major(oh*ow x oc) */
   size_t input_plane = conv_param->input_w_ * conv_param->input_h_;

mindspore/lite/nnacl/fp32/deconv_fp32.h

@@ -30,7 +30,7 @@ extern "C" {
 #endif
 void PackDeConvWeightFp32(const float *weight, float *dst, int input_channel, int output_channel, int plane);
 void DeConvPostFp32C8(const float *src, float *tmp_out, const float *bias, float *dst, int output_channel,
-                      ConvParameter *conv_param);
+                      const ConvParameter *conv_param);
 #ifdef __cplusplus
 }
 #endif

mindspore/lite/nnacl/fp32/deconv_winograd_fp32.c

@@ -16,8 +16,8 @@
 
 #include "nnacl/fp32/deconv_winograd_fp32.h"
 
-int PackDeConvWgDataFp32(float *nhwc_weight, DeConvComputeUnit *unit, ConvParameter *conv_param,
-                         DeConvParam *deconv_param) {
+int PackDeConvWgDataFp32(const float *nhwc_weight, DeConvComputeUnit *unit, const ConvParameter *conv_param,
+                         const DeConvParam *deconv_param) {
   int tmp_kernel_plane = unit->w_size_ * unit->h_size_;
   int size = conv_param->input_channel_ * conv_param->output_channel_ * tmp_kernel_plane;
   float *current_unit_weight = (float *)malloc(size * sizeof(float));
@@ -25,13 +25,14 @@ int PackDeConvWgDataFp32(float *nhwc_weight, DeConvComputeUnit *unit, ConvParame
     return NNACL_NULL_PTR;
   }
   for (int ic = 0; ic < conv_param->input_channel_; ic++) {
-    float *src_ic = nhwc_weight + deconv_param->kernel_plane_ * conv_param->output_channel_ * ic;
+    const float *src_ic = nhwc_weight + deconv_param->kernel_plane_ * conv_param->output_channel_ * ic;
     float *dst_ic = current_unit_weight + tmp_kernel_plane * conv_param->output_channel_ * ic;
     for (int uhi = 0; uhi < unit->h_size_; uhi++) {
       for (int uwi = 0; uwi < unit->w_size_; uwi++) {
         int src_h_offset = unit->h_start_ + uhi * conv_param->stride_h_;
         int src_w_offset = unit->w_start_ + uwi * conv_param->stride_w_;
-        float *src_hw = src_ic + (src_h_offset * conv_param->kernel_w_ + src_w_offset) * conv_param->output_channel_;
+        const float *src_hw =
+          src_ic + (src_h_offset * conv_param->kernel_w_ + src_w_offset) * conv_param->output_channel_;
         float *dst_hw = dst_ic + (uhi * unit->w_size_ + uwi) * conv_param->output_channel_;
         memcpy(dst_hw, src_hw, conv_param->output_channel_ * sizeof(float));
       }
@@ -132,10 +133,10 @@ int PackDeConvWgDataFp32(float *nhwc_weight, DeConvComputeUnit *unit, ConvParame
   return NNACL_OK;
 }
 
-void DeConvWgInputPack(float *src_ptr, float *dst_ptr, int channel, int stride) {
+void DeConvWgInputPack(const float *src_ptr, float *dst_ptr, int channel, int stride) {
   int ic4div = channel / C4NUM;
   int ic4mod = channel % C4NUM;
-  float *src = src_ptr;
+  const float *src = src_ptr;
   float *dst = dst_ptr;
 
   for (int ic = 0; ic < ic4div; ic++) {
@@ -340,9 +341,10 @@ void DeConvWgMerge(const float *src, float *dst, size_t src_stride, size_t dst_s
   return;
 }
 
-void DeConvWgCalWgFp32(const float *tile_in, float *tile_out, float *weight_buf, float *tmp_buf, const float *at_buf,
-                       float *a_mid_buf, float *trans_a_buf, bool *transfered, const float *bt_buf, float *b_tmp_buf,
-                       int unit_size, int w_start, int h_start, ConvParameter *conv_param, DeConvParam *deconv_param) {
+void DeConvWgCalWgFp32(const float *tile_in, float *tile_out, const float *weight_buf, float *tmp_buf,
+                       const float *at_buf, float *a_mid_buf, float *trans_a_buf, bool *transfered, const float *bt_buf,
+                       float *b_tmp_buf, int unit_size, int w_start, int h_start, const ConvParameter *conv_param,
+                       const DeConvParam *deconv_param) {
   int winograd_plane = unit_size * unit_size;
   if (!transfered[unit_size]) {
     WinogradTransLeft(tile_in, at_buf, a_mid_buf, DECONV_WINOGRAD_DEFAULT_UNIT, unit_size, DECONV_WINOGRAD_DEFAULT_UNIT,
@@ -355,7 +357,7 @@ void DeConvWgCalWgFp32(const float *tile_in, float *tile_out, float *weight_buf,
   for (int index = 0; index < winograd_plane; index++) {
     float *src = trans_a_buf + index * DECONV_WINOGRAD_DEFAULT_TILE * deconv_param->ic_up4_;
     float *dst = tmp_buf + index * deconv_param->oc_up4_ * DECONV_WINOGRAD_DEFAULT_TILE;
-    float *weight = weight_buf + index * deconv_param->ic_up4_ * deconv_param->oc_up4_;
+    const float *weight = weight_buf + index * deconv_param->ic_up4_ * deconv_param->oc_up4_;
     TiledC4MatmulFp32(dst, src, weight, DECONV_WINOGRAD_DEFAULT_TILE * C4NUM, deconv_param->ic_div4_,
                       deconv_param->oc_div4_);
   }
@@ -380,15 +382,16 @@ void DeConvWgCalWgFp32(const float *tile_in, float *tile_out, float *weight_buf,
   return;
 }
 
-void DeConvWgCalCommFp32(float *tile_in, float *tile_out, const float *weight, float *tmp_buf, int h_start, int w_start,
-                         int h_size, int w_size, ConvParameter *conv_param, DeConvParam *deconv_param) {
+void DeConvWgCalCommFp32(const float *tile_in, float *tile_out, const float *weight, float *tmp_buf, int h_start,
+                         int w_start, int h_size, int w_size, const ConvParameter *conv_param,
+                         const DeConvParam *deconv_param) {
   int count = deconv_param->oc_div4_ * w_size * h_size;
   int in_stride = DECONV_WINOGRAD_DEFAULT_TILE * deconv_param->ic_up4_;
   int out_stride = DECONV_WINOGRAD_DEFAULT_TILE * deconv_param->oc_up4_;
 
   for (int hi = 0; hi < DECONV_WINOGRAD_DEFAULT_UNIT; hi++) {
     for (int wi = 0; wi < DECONV_WINOGRAD_DEFAULT_UNIT; wi++) {
-      float *src_in = tile_in + (wi + hi * DECONV_WINOGRAD_DEFAULT_UNIT) * in_stride;
+      const float *src_in = tile_in + (wi + hi * DECONV_WINOGRAD_DEFAULT_UNIT) * in_stride;
       TiledC4MatmulFp32(tmp_buf, src_in, weight, DECONV_WINOGRAD_DEFAULT_TILE * 4, deconv_param->ic_div4_, count);
 
       for (int uhi = 0; uhi < h_size; uhi++) {
@@ -406,8 +409,8 @@ void DeConvWgCalCommFp32(float *tile_in, float *tile_out, const float *weight, f
   return;
 }
 
-void DeconvWg(float *nhwc_input_, float *tile_in, float *tile_out, int start_index, int calculate_count,
-              ConvParameter *conv_param, DeConvParam *deconv_param, int task_id) {
+void DeconvWg(const float *nhwc_input_, float *tile_in, float *tile_out, int start_index, int calculate_count,
+              const ConvParameter *conv_param, DeConvParam *deconv_param, int task_id) {
   /* pack tile input */
   int tile_in_unit_stride = deconv_param->ic_up4_ * DECONV_WINOGRAD_DEFAULT_TILE;
 #ifdef ENABLE_ARM
@@ -439,7 +442,7 @@ void DeconvWg(float *nhwc_input_, float *tile_in, float *tile_out, int start_ind
           continue;
         }
 
-        float *src = nhwc_input_ + (w_index + h_index * conv_param->input_w_) * conv_param->input_channel_;
+        const float *src = nhwc_input_ + (w_index + h_index * conv_param->input_w_) * conv_param->input_channel_;
         DeConvWgInputPack(src, dst, conv_param->input_channel_, DECONV_WINOGRAD_DEFAULT_TILE * C4NUM);
       }
     }
@@ -474,8 +477,8 @@ void DeconvWg(float *nhwc_input_, float *tile_in, float *tile_out, int start_ind
   return;
 }
 
-void DeconvWgPost(float *tile_out, float *nc4hw4_output, ConvParameter *conv_param, DeConvParam *deconv_param,
-                  int calculate_count, int tile_index) {
+void DeconvWgPost(const float *tile_out, float *nc4hw4_output, const ConvParameter *conv_param,
+                  const DeConvParam *deconv_param, int calculate_count, int tile_index) {
   /* merge */
   int src_unit_stride = deconv_param->oc_up4_ * DECONV_WINOGRAD_DEFAULT_TILE;
 
@@ -483,7 +486,7 @@ void DeconvWgPost(float *tile_out, float *nc4hw4_output, ConvParameter *conv_par
   int dst_stride = conv_param->output_w_ * conv_param->output_h_ * C4NUM;
 
   for (int index = 0; index < calculate_count; ++index) {
-    float *src_start = tile_out + index * C4NUM;
+    const float *src_start = tile_out + index * C4NUM;
 
     int plane_index = tile_index * DECONV_WINOGRAD_DEFAULT_TILE + index;
     int w_unit_index = plane_index % deconv_param->in_tile_w_count_;
@@ -499,7 +502,7 @@ void DeconvWgPost(float *tile_out, float *nc4hw4_output, ConvParameter *conv_par
 
     for (int hi = merge_h_start; hi < merge_h_end; hi++) {
       for (int wi = merge_w_start; wi < merge_w_end; wi++) {
-        float *src = src_start + (hi * deconv_param->out_tile_w_ + wi) * src_unit_stride;
+        const float *src = src_start + (hi * deconv_param->out_tile_w_ + wi) * src_unit_stride;
         float *dst = dst_start + (hi * conv_param->output_w_ + wi) * C4NUM;
         DeConvWgMerge(src, dst, src_stride, dst_stride, deconv_param->oc_div4_);
       }

mindspore/lite/nnacl/fp32/deconv_winograd_fp32.h

@@ -28,12 +28,12 @@
 extern "C" {
 #endif
 
-int PackDeConvWgDataFp32(float *nhwc_weight, DeConvComputeUnit *unit, ConvParameter *conv_param,
-                         DeConvParam *deconv_param);
-void DeconvWg(float *nhwc_input_, float *tile_in, float *tile_out, int start_index, int calculate_count,
-              ConvParameter *conv_param, DeConvParam *deconv_param, int task_id);
-void DeconvWgPost(float *tile_out, float *nc4hw4_output, ConvParameter *conv_param, DeConvParam *deconv_param,
-                  int calculate_count, int tile_index);
+int PackDeConvWgDataFp32(const float *nhwc_weight, DeConvComputeUnit *unit, const ConvParameter *conv_param,
+                         const DeConvParam *deconv_param);
+void DeconvWg(const float *nhwc_input_, float *tile_in, float *tile_out, int start_index, int calculate_count,
+              const ConvParameter *conv_param, DeConvParam *deconv_param, int task_id);
+void DeconvWgPost(const float *tile_out, float *nc4hw4_output, const ConvParameter *conv_param,
+                  const DeConvParam *deconv_param, int calculate_count, int tile_index);
 void TiledC4MatmulFp32(float *dst, const float *src, const float *weight, size_t ic4, size_t cal_num, size_t oc4);
 
 #ifdef __cplusplus

mindspore/lite/nnacl/fp32/detection_post_process_fp32.c

@@ -36,8 +36,8 @@ float IntersectionOverUnion(const BboxCorner *a, const BboxCorner *b) {
   return inter / (area_a + area_b - inter);
 }
 
-int DecodeBoxes(const int num_boxes, const float *input_boxes, const float *anchors,
-                DetectionPostProcessParameter *param) {
+int DecodeBoxes(int num_boxes, const float *input_boxes, const float *anchors,
+                const DetectionPostProcessParameter *param) {
   if (input_boxes == NULL || anchors == NULL || param == NULL) {
     return NNACL_NULL_PTR;
   }