!6567 [MS][LITE][CPU] code clean

Merge pull request !6567 from liuzhongkai/code_clean

mindspore/lite/nnacl/fp16/pooling_fp16.c

@@ -15,8 +15,9 @@
  */
 #include "nnacl/fp16/pooling_fp16.h"
 #include <float.h>
+#include "nnacl/errorcode.h"
 
-void AvgPoolingFp16(const float16_t *input_ptr, float16_t *output_ptr, PoolingParameter *pooling_param, int task_id) {
+int AvgPoolingFp16(const float16_t *input_ptr, float16_t *output_ptr, PoolingParameter *pooling_param, int task_id) {
   int stride_w = pooling_param->stride_w_;
   int stride_h = pooling_param->stride_h_;
   int pad_w = pooling_param->pad_l_;
@@ -83,6 +84,9 @@ void AvgPoolingFp16(const float16_t *input_ptr, float16_t *output_ptr, PoolingPa
           if (pooling_param->avg_mode_ == 1) {
             real_count = window;
           }
+          if (real_count == 0) {
+            return NNACL_ERR;
+          }
 #ifdef ENABLE_NEON
           vst1q_f16(output_ptr + out_channel_offset, tmp_avg / vdupq_n_f16(real_count));
 #else
@@ -118,6 +122,9 @@ void AvgPoolingFp16(const float16_t *input_ptr, float16_t *output_ptr, PoolingPa
           if (pooling_param->avg_mode_ == 1) {
             real_count = window;
           }
+          if (real_count == 0) {
+            return NNACL_ERR;
+          }
 #ifdef ENABLE_NEON
           vst1_f16(output_ptr + out_channel_offset, tmp_avg / vdup_n_f16(real_count));
 #else
@@ -140,11 +147,15 @@ void AvgPoolingFp16(const float16_t *input_ptr, float16_t *output_ptr, PoolingPa
               ++real_count;
             }  // win_w loop
           }    // win_h loop
+          if (real_count == 0) {
+            return NNACL_ERR;
+          }
           *(output_ptr + out_channel_offset) = tmp_avg / (float16_t)real_count;
         }  // channel_res loop
       }    // real_cal_num loop
     }      // out_plane loop
   }        // out_batch loop
+  return NNACL_OK;
 }
 
 void MaxPoolingFp16(const float16_t *input_ptr, float16_t *output_ptr, PoolingParameter *pooling_param, int task_id) {

mindspore/lite/nnacl/fp16/pooling_fp16.h

@@ -24,7 +24,7 @@
 #ifdef __cplusplus
 extern "C" {
 #endif
-void AvgPoolingFp16(const float16_t *input_ptr, float16_t *output_ptr, PoolingParameter *pooling_param, int task_id);
+int AvgPoolingFp16(const float16_t *input_ptr, float16_t *output_ptr, PoolingParameter *pooling_param, int task_id);
 
 void MaxPoolingFp16(const float16_t *input_ptr, float16_t *output_ptr, PoolingParameter *pooling_param, int task_id);
 #ifdef __cplusplus

mindspore/lite/nnacl/fp32/pooling.c

@@ -16,8 +16,9 @@
 
 #include "nnacl/fp32/pooling.h"
 #include <float.h>
+#include "nnacl/errorcode.h"
 
-void AvgPooling(const float *input_ptr, float *output_ptr, PoolingParameter *pooling_param, int task_id, float minf,
+int AvgPooling(const float *input_ptr, float *output_ptr, PoolingParameter *pooling_param, int task_id, float minf,
                 float maxf) {
   int stride_w = pooling_param->stride_w_;
   int stride_h = pooling_param->stride_h_;
@@ -92,6 +93,9 @@ void AvgPooling(const float *input_ptr, float *output_ptr, PoolingParameter *poo
           if (pooling_param->avg_mode_ == 1) {
             real_count = window;
           }
+          if (real_count == 0) {
+            return NNACL_ERR;
+          }
 #ifdef ENABLE_NEON
           tmp_avg = tmp_avg / vdupq_n_f32(real_count);
           tmp_avg = vmaxq_f32(tmp_avg, min_value);
@@ -132,6 +136,9 @@ void AvgPooling(const float *input_ptr, float *output_ptr, PoolingParameter *poo
           if (pooling_param->avg_mode_ == 1) {
             real_count = window;
           }
+          if (real_count == 0) {
+              return NNACL_ERR;
+          }
           tmp_avg = tmp_avg / (float)real_count;
           tmp_avg = fmax(tmp_avg, minf);
           tmp_avg = fmin(tmp_avg, maxf);
@@ -140,6 +147,7 @@ void AvgPooling(const float *input_ptr, float *output_ptr, PoolingParameter *poo
       }    // real_cal_num loop
     }      // out_plane loop
   }        // out_batch loop
+  return NNACL_OK;
 }
 
 void MaxPooling(const float *input_ptr, float *output_ptr, PoolingParameter *pooling_param, int task_id, float minf,

mindspore/lite/nnacl/fp32/pooling.h

@@ -27,7 +27,7 @@
 #ifdef __cplusplus
 extern "C" {
 #endif
-void AvgPooling(const float *input_ptr, float *output_ptr, PoolingParameter *pooling_param, int task_id, float minf,
+int AvgPooling(const float *input_ptr, float *output_ptr, PoolingParameter *pooling_param, int task_id, float minf,
                 float maxf);
 void MaxPooling(const float *input_ptr, float *output_ptr, PoolingParameter *pooling_param, int task_id, float minf,
                 float maxf);

mindspore/lite/nnacl/int8/pooling_int8.c

@@ -16,8 +16,9 @@
 
 #include "nnacl/int8/pooling_int8.h"
 #include "nnacl/common_func.h"
+#include "nnacl/errorcode.h"
 
-void AvgPoolingInt8(const int8_t *input_ptr, int8_t *output_ptr, PoolingParameter *pooling_param, int task_id) {
+int AvgPoolingInt8(const int8_t *input_ptr, int8_t *output_ptr, PoolingParameter *pooling_param, int task_id) {
   int stride_w = pooling_param->stride_w_;
   int stride_h = pooling_param->stride_h_;
   int pad_w = pooling_param->pad_l_;
@@ -64,6 +65,9 @@ void AvgPoolingInt8(const int8_t *input_ptr, int8_t *output_ptr, PoolingParamete
             }
           }  // win_w loop
         }    // win_h loop
+        if (real_count == 0) {
+          return NNACL_ERR;
+        }
         int16_t tmp_out = round((float)tmp_avg / (float)real_count);
         tmp_out = (int8_t)(round((tmp_out - input_zp) * real_multiplier) + output_zp);
         int8_t real_out = tmp_out < out_min ? out_min : tmp_out;
@@ -72,9 +76,10 @@ void AvgPoolingInt8(const int8_t *input_ptr, int8_t *output_ptr, PoolingParamete
       }  // in_channel loop
     }    // out_plane loop
   }      // out_batch loop
+  return NNACL_OK;
 }
 
-void AvgPoolingOptInt8(const int8_t *input_ptr, int8_t *output_ptr, PoolingParameter *pooling_param, int task_id) {
+int AvgPoolingOptInt8(const int8_t *input_ptr, int8_t *output_ptr, PoolingParameter *pooling_param, int task_id) {
   int stride_w = pooling_param->stride_w_;
   int stride_h = pooling_param->stride_h_;
   int pad_w = pooling_param->pad_l_;
@@ -118,6 +123,9 @@ void AvgPoolingOptInt8(const int8_t *input_ptr, int8_t *output_ptr, PoolingParam
         int kh_s = MSMAX(0, -in_h_index);
         int kh_e = MSMIN(win_h, in_h - in_h_index);
         int real_count = (kw_e - kw_s) * (kh_e - kh_s);
+        if (real_count == 0) {
+          return NNACL_ERR;
+        }
 
         // 16 channels
         for (int j = 0; j < c16; j++) {
@@ -272,6 +280,7 @@ void AvgPoolingOptInt8(const int8_t *input_ptr, int8_t *output_ptr, PoolingParam
       }    // out_plane loop
     }      // out_batch loop
   }
+  return NNACL_OK;
 }
 
 void MaxPoolingInt8(const int8_t *input_ptr, int8_t *output_ptr, PoolingParameter *pooling_param, int task_id) {

mindspore/lite/nnacl/int8/pooling_int8.h

@@ -26,9 +26,9 @@
 #ifdef __cplusplus
 extern "C" {
 #endif
-void AvgPoolingInt8(const int8_t *input_ptr, int8_t *output_ptr, PoolingParameter *pooling_param, int task_id);
+int AvgPoolingInt8(const int8_t *input_ptr, int8_t *output_ptr, PoolingParameter *pooling_param, int task_id);
 
-void AvgPoolingOptInt8(const int8_t *input_ptr, int8_t *output_ptr, PoolingParameter *pooling_param, int task_id);
+int AvgPoolingOptInt8(const int8_t *input_ptr, int8_t *output_ptr, PoolingParameter *pooling_param, int task_id);
 
 void MaxPoolingInt8(const int8_t *input_ptr, int8_t *output_ptr, PoolingParameter *pooling_param, int task_id);
 

mindspore/lite/nnacl/minimal_filtering_generator.c

@@ -33,8 +33,8 @@ void Polynomial(float *interval, float *m, int degree) {
 void DiagonalPlusMatrix(float *matrix, float *diagonal_matrix, int degree) {
   int data_num = (degree + 1) * (degree + 1);
   memset(diagonal_matrix, 0, data_num * sizeof(float));
-  for (int i = 0; i < (degree + 1); ++i) {
-    for (int j = 0; j < (degree + 1); ++j) {
+  for (int i = 0; i < degree; ++i) {
+    for (int j = 0; j < degree; ++j) {
       if (j == i) diagonal_matrix[i * (degree + 1) + j] = matrix[i];
     }
   }
@@ -156,7 +156,7 @@ int CookToomFilter(float *matrix_a, float *matrix_at, float *matrix_b, float *ma
                    float *matrix_gt, float coefficient, int out_unit, int filter_size) {
   int in_unit = out_unit + filter_size - 1;
   int degree = in_unit - 1;
-  if (degree > MAX_LEN || (in_unit * in_unit) > MAX_LEN || degree > MAX_LEN || (in_unit * filter_size) > MAX_LEN) {
+  if (degree > MAX_LEN || (in_unit * in_unit) > MAX_LEN || (in_unit * filter_size) > MAX_LEN) {
     return NNACL_ERR;
   }
   float polynomial_m[MAX_LEN];             // degree

mindspore/lite/nnacl/winograd_transform.c

@@ -351,11 +351,11 @@ void Conv3x3Fp32InputTransform(const float *input_data, float *trans_input, floa
 
 void Conv3x3Fp32FilterTransform(float *weight_data, float *trans_weight, int iC4, int output_channel, int kernel_plane,
                                 int oc_block) {
-  int oc_plane_block = UP_DIV(output_channel, oc_block);
-  int dst_step = iC4 * C4NUM * oc_block * oc_plane_block;
   if (oc_block == 0) {
     return;
   }
+  int oc_plane_block = UP_DIV(output_channel, oc_block);
+  int dst_step = iC4 * C4NUM * oc_block * oc_plane_block;
   for (int o = 0; o < output_channel; o++) {
     int oc_block_num = o / oc_block;
     int oc_block_rem = o % oc_block;

mindspore/lite/nnacl/winograd_utils.c

@@ -361,12 +361,12 @@ void InputTransform8x8Unit(const float *src_data, float *dst_data, int src_step,
 }
 
 OutputTransFunc GetOutputTransFunc(int input_unit, int output_unit) {
-  if (input_unit == 4) {
-    return OutputTransFuncList4[output_unit];
-  } else if (input_unit == 6) {
-    return OutputTransFuncList6[output_unit];
-  } else if (input_unit == 8) {
-    return OutputTransFuncList8[output_unit];
+  if (input_unit == 4 && output_unit < 4) {
+      return OutputTransFuncList4[output_unit];
+  } else if (input_unit == 6 && output_unit < 6) {
+      return OutputTransFuncList6[output_unit];
+  } else if (input_unit == 8 && output_unit < 8) {
+      return OutputTransFuncList8[output_unit];
   } else {
     return NULL;
   }

mindspore/lite/src/lite_session.cc

@@ -91,6 +91,7 @@ int LiteSession::ConvertTensors(const lite::Model *model) {
         auto dst_data = dstTensor->MutableData();
         if (dst_data == nullptr) {
           MS_LOG(ERROR) << "MutableData from " << i << "th tensor is nullptr";
+          free(dstTensor);
           return RET_ERROR;
         }
         memcpy(dst_data, srcTensor->data()->data(), dstTensor->Size());

mindspore/lite/src/model.cc

@@ -34,6 +34,7 @@ bool ConvertNodes(const schema::MetaGraph *meta_graph, Model *model) {
     node->primitive_ = PrimitiveC::Create(const_cast<schema::Primitive *>(src_prim));
     if (node->primitive_ == nullptr) {
       MS_LOG(ERROR) << "unpack primitive == nullptr!";
+      free(node);
       return false;
     }
     node->primitive_->SetQuantType(c_node->quantType());

mindspore/lite/src/ops/depend.cc

@@ -40,10 +40,6 @@ int Depend::UnPackAttr(const Primitive &prim, const std::vector<AnfNodePtr> &inp
       return RET_ERROR;
     }
     this->primitive_->value.value = attr;
-    if (this->primitive_->value.value == nullptr) {
-      MS_LOG(ERROR) << "primitive value is nullptr";
-      return RET_ERROR;
-    }
   }
   return RET_OK;
 }

mindspore/lite/src/runtime/kernel/arm/fp16/pooling_fp16.cc

@@ -56,7 +56,11 @@ int PoolingFp16CPUKernel::RunImpl(int task_id) {
   if (pooling_param_->pool_mode_ == PoolMode_MaxPool) {
     MaxPoolingFp16(fp16_input_, fp16_output_, pooling_param_, task_id);
   } else {
-    AvgPoolingFp16(fp16_input_, fp16_output_, pooling_param_, task_id);
+    auto ret = AvgPoolingFp16(fp16_input_, fp16_output_, pooling_param_, task_id);
+    if (ret != RET_OK) {
+      MS_LOG(ERROR) << "AvgPooling run failed.";
+      return ret;
+    }
   }
   return RET_OK;
 }

mindspore/lite/src/runtime/kernel/arm/fp32/pooling.cc

@@ -64,7 +64,11 @@ int PoolingCPUKernel::RunImpl(int task_id) {
   if (pooling_param_->pool_mode_ == PoolMode_MaxPool) {
     MaxPooling(input_ptr, output_ptr, pooling_param_, task_id, minf, maxf);
   } else {
-    AvgPooling(input_ptr, output_ptr, pooling_param_, task_id, minf, maxf);
+    auto ret = AvgPooling(input_ptr, output_ptr, pooling_param_, task_id, minf, maxf);
+    if (ret != RET_OK) {
+      MS_LOG(ERROR) << "AcgPooling run failed.";
+      return ret;
+    }
   }
   return RET_OK;
 }

mindspore/lite/src/runtime/kernel/arm/int8/pooling_int8.cc

@@ -68,7 +68,11 @@ int PoolingInt8CPUKernel::RunImpl(int task_id) {
       MaxPoolingOptInt8(input_data, output_data, pooling_param_, task_id);
     }
   } else {
-    AvgPoolingOptInt8(input_data, output_data, pooling_param_, task_id);
+    auto ret = AvgPoolingOptInt8(input_data, output_data, pooling_param_, task_id);
+    if (ret != RET_OK) {
+      MS_LOG(ERROR) << "AvgPooling run failed.";
+      return ret;
+    }
   }
   return RET_OK;
 }