!22121 Fix code check

Merge pull request !22121 from zuochuanyong/fix_codecheck

mindspore/ccsrc/backend/kernel_compiler/cpu/binary_cross_entropy_cpu_kernel.cc

@@ -41,8 +41,7 @@ void BinaryCrossEntropyCpuKernel::LaunchToScalar(const int &input_size, const in
 }
 
 template <typename T>
-void BinaryCrossEntropyCpuKernel::Launchkernel(const std::vector<AddressPtr> &inputs,
-                                               const std::vector<AddressPtr> &workspace,
+void BinaryCrossEntropyCpuKernel::Launchkernel(const std::vector<AddressPtr> &inputs, const std::vector<AddressPtr> &,
                                                const std::vector<AddressPtr> &outputs) {
   T *input_x = reinterpret_cast<T *>(inputs[0]->addr);
   T *input_y = reinterpret_cast<T *>(inputs[1]->addr);
@@ -63,7 +62,8 @@ void BinaryCrossEntropyCpuKernel::Launchkernel(const std::vector<AddressPtr> &in
     }
   } else if (reduction_ == 0 && (!weight_defined_)) {
     for (size_t i = 0; i < input_size_; i++) {
-      T value = -(input_y[i] * log(input_x[i] + epsilon) + (one - input_y[i]) * log(one - input_x[i] + epsilon));
+      T value = static_cast<T>(
+        -(input_y[i] * log(input_x[i] + epsilon) + (one - input_y[i]) * log(one - input_x[i] + epsilon)));
       loss[i] = value;
     }
   } else if ((reduction_ != 0) && weight_defined_) {
@@ -74,7 +74,8 @@ void BinaryCrossEntropyCpuKernel::Launchkernel(const std::vector<AddressPtr> &in
     }
   } else {
     for (size_t i = 0; i < input_size_; i++) {
-      T value = -(input_y[i] * log(input_x[i] + epsilon) + (one - input_y[i]) * log(one - input_x[i] + epsilon));
+      T value = static_cast<T>(
+        -(input_y[i] * log(input_x[i] + epsilon) + (one - input_y[i]) * log(one - input_x[i] + epsilon)));
       tmp_loss[i] = value;
     }
   }

mindspore/ccsrc/backend/kernel_compiler/cpu/mkldnn/conv_cpu_kernel.cc

@@ -39,7 +39,7 @@ void ConvCPUKernel::InitKernel(const CNodePtr &kernel_node) {
   }
   std::vector<size_t> kernel_size;
   for (size_t i = kKernelStartAxis; i < src_dim; ++i) {
-    kernel_size.emplace_back(weight_shape[i]);
+    (void)kernel_size.emplace_back(weight_shape[i]);
   }
   size_t group = LongToSize(AnfAlgo::GetNodeAttr<int64_t>(kernel_node, GROUP));
   if (group > 1) {
@@ -80,10 +80,10 @@ void ConvCPUKernel::InitKernel(const CNodePtr &kernel_node) {
   dnnl::memory::dims strides;
   dnnl::memory::dims dilates;
   for (size_t i = kKernelStartAxis; i < src_dim; ++i) {
-    stride.emplace_back(stride_ori[i]);
-    strides.emplace_back(stride_ori[i]);
-    dilation.emplace_back(dilation_ori[i]);
-    dilates.emplace_back(dilation_ori[i] - 1);
+    (void)stride.emplace_back(stride_ori[i]);
+    (void)strides.emplace_back(stride_ori[i]);
+    (void)dilation.emplace_back(dilation_ori[i]);
+    (void)dilates.emplace_back(dilation_ori[i] - 1);
   }
   std::vector<int> int_padding_l;
   std::vector<int> int_padding_r;
@@ -95,8 +95,8 @@ void ConvCPUKernel::InitKernel(const CNodePtr &kernel_node) {
   dnnl::memory::dims padding_l;
   dnnl::memory::dims padding_r;
   for (size_t i = 0; i < int_padding_l.size(); ++i) {
-    padding_l.emplace_back(int_padding_l[i]);
-    padding_r.emplace_back(int_padding_r[i]);
+    (void)padding_l.emplace_back(int_padding_l[i]);
+    (void)padding_r.emplace_back(int_padding_r[i]);
   }
   dnnl::convolution_forward::desc desc =
     dnnl::convolution_forward::desc(dnnl::prop_kind::forward_training, dnnl::algorithm::convolution_auto, src_desc,
@@ -109,8 +109,7 @@ void ConvCPUKernel::InitKernel(const CNodePtr &kernel_node) {
   AddArgument(DNNL_ARG_DST, dst_desc);
 }
 
-bool ConvCPUKernel::Launch(const std::vector<kernel::AddressPtr> &inputs,
-                           const std::vector<kernel::AddressPtr> & /*workspace*/,
+bool ConvCPUKernel::Launch(const std::vector<kernel::AddressPtr> &inputs, const std::vector<kernel::AddressPtr> &,
                            const std::vector<kernel::AddressPtr> &outputs) {
   if (inputs.size() < kConvInputTensorNum || outputs.empty()) {
     MS_LOG(EXCEPTION) << "Error input output size!";

mindspore/ccsrc/backend/kernel_compiler/cpu/mkldnn/mkl_cpu_kernel.cc

@@ -32,7 +32,7 @@ void MKLCPUKernel::GetPadding(const CNodePtr &kernel_node, const std::string &pa
   }
   std::vector<int> weight_height;
   for (size_t i = 2; i < dim; ++i) {
-    weight_height.emplace_back(src_shape[i]);
+    (void)weight_height.emplace_back(src_shape[i]);
   }
 
   MS_LOG(INFO) << "pad mode: " << pad_mode;

mindspore/ccsrc/backend/kernel_compiler/cpu/mkldnn/pooling_cpu_kernel.cc

@@ -22,9 +22,13 @@
 
 namespace mindspore {
 namespace kernel {
+constexpr size_t kPoolingMinDim = 4;
+constexpr size_t kPoolingMaxDim = 5;
+constexpr size_t kPoolingOffsetDim = 2;
+
 void PoolingCPUKernel::InitInputOutputSize(const CNodePtr &kernel_node) {
   CPUKernel::InitInputOutputSize(kernel_node);
-  workspace_size_list_.emplace_back(workspace_size_);
+  (void)workspace_size_list_.emplace_back(workspace_size_);
 }
 
 void PoolingCPUKernel::InitKernel(const CNodePtr &kernel_node) {
@@ -42,7 +46,7 @@ void PoolingCPUKernel::InitKernel(const CNodePtr &kernel_node) {
   (void)std::transform(strides_me.begin(), strides_me.end(), std::back_inserter(strides),
                        [](const int64_t &value) { return static_cast<int>(value); });
   auto dim = origin_kernel_sizes.size();
-  if (dim < 4 || dim > 5 || dim != strides.size()) {
+  if (dim < kPoolingMinDim || dim > kPoolingMaxDim || dim != strides.size()) {
     MS_LOG(EXCEPTION) << "Invalid kernel size " << origin_kernel_sizes.size() << " or stride size " << strides.size();
   }
   std::vector<int> stride;
@@ -51,25 +55,25 @@ void PoolingCPUKernel::InitKernel(const CNodePtr &kernel_node) {
   std::vector<size_t> kernel_size;
   std::vector<int> dummy_dilation;
   for (size_t i = 2; i < dim; ++i) {
-    stride.emplace_back(strides[i]);
-    kernels_dims.emplace_back(origin_kernel_sizes[i]);
-    strides_dims.emplace_back(strides[i]);
-    kernel_size.emplace_back(IntToSize(origin_kernel_sizes[i]));
-    dummy_dilation.emplace_back(1);
+    (void)stride.emplace_back(strides[i]);
+    (void)kernels_dims.emplace_back(origin_kernel_sizes[i]);
+    (void)strides_dims.emplace_back(strides[i]);
+    (void)kernel_size.emplace_back(IntToSize(origin_kernel_sizes[i]));
+    (void)dummy_dilation.emplace_back(1);
   }
 
   std::vector<int> int_padding_l;
   std::vector<int> int_padding_r;
   const std::string pad_mode = AnfAlgo::GetNodeAttr<std::string>(kernel_node, PAD_MODE);
   GetPadding(kernel_node, pad_mode, src_shape, kernel_size, stride, &int_padding_l, &int_padding_r, dummy_dilation);
-  if (int_padding_l.size() != dim - 2 || int_padding_r.size() != dim - 2) {
+  if (int_padding_l.size() != dim - kPoolingOffsetDim || int_padding_r.size() != dim - kPoolingOffsetDim) {
     MS_LOG(EXCEPTION) << "Pooling get padding failed!";
   }
   dnnl::memory::dims padding_l;
   dnnl::memory::dims padding_r;
-  for (size_t i = 0; i < dim - 2; ++i) {
-    padding_l.emplace_back(int_padding_l[i]);
-    padding_r.emplace_back(int_padding_r[i]);
+  for (size_t i = 0; i < dim - kPoolingOffsetDim; ++i) {
+    (void)padding_l.emplace_back(int_padding_l[i]);
+    (void)padding_r.emplace_back(int_padding_r[i]);
   }
   dnnl::pooling_forward::desc desc =
     dnnl::pooling_forward::desc(dnnl::prop_kind::forward_training, dnnl::algorithm::pooling_max, src_desc, dst_desc,