!15884 fix code style check

From: @zyx5256
Reviewed-by: @wuxuejian,@liangchenghui
Signed-off-by: @wuxuejian

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

@@ -21,9 +21,8 @@
 
 namespace mindspore {
 namespace kernel {
-
 template <typename T>
-void EltWiseGradCPUKernel<T>::ReluGrad(const T *input1, const T *input2, T *out, size_t start, size_t end) {
+void EltWiseGradCPUKernel<T>::ReluGrad(const T *input1, const T *input2, T *out, size_t start, size_t end) const {
   for (size_t i = start; i < end; i++) {
     if (input2[i] > 0) {
       out[i] = input1[i];
@@ -34,7 +33,7 @@ void EltWiseGradCPUKernel<T>::ReluGrad(const T *input1, const T *input2, T *out,
 }
 
 template <typename T>
-void EltWiseGradCPUKernel<T>::ReLU6Grad(const T *input1, const T *input2, T *out, size_t start, size_t end) {
+void EltWiseGradCPUKernel<T>::ReLU6Grad(const T *input1, const T *input2, T *out, size_t start, size_t end) const {
   for (size_t i = start; i < end; i++) {
     if (input2[i] > 0 && input2[i] <= 6) {
       out[i] = input1[i];
@@ -45,7 +44,7 @@ void EltWiseGradCPUKernel<T>::ReLU6Grad(const T *input1, const T *input2, T *out
 }
 
 template <typename T>
-void EltWiseGradCPUKernel<T>::AbsGrad(const T *input1, const T *input2, T *out, size_t start, size_t end) {
+void EltWiseGradCPUKernel<T>::AbsGrad(const T *input1, const T *input2, T *out, size_t start, size_t end) const {
   for (size_t i = start; i < end; i++) {
     if (input1[i] > 0) {
       out[i] = input2[i];
@@ -58,21 +57,21 @@ void EltWiseGradCPUKernel<T>::AbsGrad(const T *input1, const T *input2, T *out,
 }
 
 template <typename T>
-void EltWiseGradCPUKernel<T>::SigmoidGrad(const T *input1, const T *input2, T *out, size_t start, size_t end) {
+void EltWiseGradCPUKernel<T>::SigmoidGrad(const T *input1, const T *input2, T *out, size_t start, size_t end) const {
   for (size_t i = start; i < end; i++) {
     out[i] = input2[i] * input1[i] * (1 - input1[i]);
   }
 }
 
 template <typename T>
-void EltWiseGradCPUKernel<T>::SqrtGrad(const T *input1, const T *input2, T *out, size_t start, size_t end) {
+void EltWiseGradCPUKernel<T>::SqrtGrad(const T *input1, const T *input2, T *out, size_t start, size_t end) const {
   for (size_t i = start; i < end; i++) {
     out[i] = input2[i] / (input1[i] * 2);
   }
 }
 
 template <typename T>
-void EltWiseGradCPUKernel<T>::TanhGrad(const T *input1, const T *input2, T *out, size_t start, size_t end) {
+void EltWiseGradCPUKernel<T>::TanhGrad(const T *input1, const T *input2, T *out, size_t start, size_t end) const {
   for (size_t i = start; i < end; i++) {
     T tmp = input1[i] * input1[i];
     out[i] = input2[i] * (1 - tmp);
@@ -80,7 +79,7 @@ void EltWiseGradCPUKernel<T>::TanhGrad(const T *input1, const T *input2, T *out,
 }
 
 template <typename T>
-void EltWiseGradCPUKernel<T>::GeluGrad(const T *input1, const T *input2, T *out, size_t start, size_t end) {
+void EltWiseGradCPUKernel<T>::GeluGrad(const T *input1, const T *input2, T *out, size_t start, size_t end) const {
   for (size_t i = start; i < end; i++) {
     T x = input2[i];
     auto double_x = static_cast<T>(x);
@@ -92,7 +91,7 @@ void EltWiseGradCPUKernel<T>::GeluGrad(const T *input1, const T *input2, T *out,
 }
 
 template <typename T>
-void EltWiseGradCPUKernel<T>::AsinGrad(const T *input1, const T *input2, T *out, size_t start, size_t end) {
+void EltWiseGradCPUKernel<T>::AsinGrad(const T *input1, const T *input2, T *out, size_t start, size_t end) const {
   for (size_t i = start; i < end; i++) {
     T dividend = input2[i];
     T divisor = sqrt(1 - input1[i] * input1[i]);
@@ -113,7 +112,7 @@ void EltWiseGradCPUKernel<T>::AsinGrad(const T *input1, const T *input2, T *out,
 }
 
 template <typename T>
-void EltWiseGradCPUKernel<T>::ACosGrad(const T *input1, const T *input2, T *out, size_t start, size_t end) {
+void EltWiseGradCPUKernel<T>::ACosGrad(const T *input1, const T *input2, T *out, size_t start, size_t end) const {
   for (size_t i = start; i < end; i++) {
     T dividend = -input2[i];
     T divisor = sqrt(1 - input1[i] * input1[i]);
@@ -134,7 +133,7 @@ void EltWiseGradCPUKernel<T>::ACosGrad(const T *input1, const T *input2, T *out,
 }
 
 template <typename T>
-void EltWiseGradCPUKernel<T>::AtanGrad(const T *input1, const T *input2, T *out, size_t start, size_t end) {
+void EltWiseGradCPUKernel<T>::AtanGrad(const T *input1, const T *input2, T *out, size_t start, size_t end) const {
   for (size_t i = start; i < end; i++) {
     T dividend = input2[i];
     const T divisor = 1 + input1[i] * input1[i];
@@ -155,7 +154,7 @@ void EltWiseGradCPUKernel<T>::AtanGrad(const T *input1, const T *input2, T *out,
 }
 
 template <typename T>
-void EltWiseGradCPUKernel<T>::AsinhGrad(const T *input1, const T *input2, T *out, size_t start, size_t end) {
+void EltWiseGradCPUKernel<T>::AsinhGrad(const T *input1, const T *input2, T *out, size_t start, size_t end) const {
   for (size_t i = start; i < end; i++) {
     T dividend = input2[i];
     T divisor = sqrt(1 + input1[i] * input1[i]);
@@ -176,7 +175,7 @@ void EltWiseGradCPUKernel<T>::AsinhGrad(const T *input1, const T *input2, T *out
 }
 
 template <typename T>
-void EltWiseGradCPUKernel<T>::AcoshGrad(const T *input1, const T *input2, T *out, size_t start, size_t end) {
+void EltWiseGradCPUKernel<T>::AcoshGrad(const T *input1, const T *input2, T *out, size_t start, size_t end) const {
   for (size_t i = start; i < end; i++) {
     T dividend = input2[i];
     T divisor = sqrt(input1[i] * input1[i] - 1);
@@ -204,7 +203,7 @@ void EltWiseGradCPUKernel<T>::InitKernel(const CNodePtr &kernel_node) {
 
 template <typename T>
 bool EltWiseGradCPUKernel<T>::Launch(const std::vector<kernel::AddressPtr> &inputs,
-                                     const std::vector<kernel::AddressPtr> & /*workspace*/,
+                                     const std::vector<kernel::AddressPtr> &,
                                      const std::vector<kernel::AddressPtr> &outputs) {
   static const std::map<std::string,
                         std::function<void(EltWiseGradCPUKernel *, const T *, const T *, T *, size_t, size_t)>>

mindspore/ccsrc/backend/kernel_compiler/cpu/eltwise_grad_cpu_kernel.h

@@ -36,18 +36,18 @@ class EltWiseGradCPUKernel : public CPUKernel {
               const std::vector<AddressPtr> &outputs) override;
 
  private:
-  void ReluGrad(const T *input1, const T *input2, T *out, size_t start, size_t end);
-  void ReLU6Grad(const T *input1, const T *input2, T *out, size_t start, size_t end);
-  void AbsGrad(const T *input1, const T *input2, T *out, size_t start, size_t end);
-  void SigmoidGrad(const T *input1, const T *input2, T *out, size_t start, size_t end);
-  void SqrtGrad(const T *input1, const T *input2, T *out, size_t start, size_t end);
-  void TanhGrad(const T *input1, const T *input2, T *out, size_t start, size_t end);
-  void GeluGrad(const T *input1, const T *input2, T *out, size_t start, size_t end);
-  void AsinGrad(const T *input1, const T *input2, T *out, size_t start, size_t end);
-  void ACosGrad(const T *input1, const T *input2, T *out, size_t start, size_t end);
-  void AtanGrad(const T *input1, const T *input2, T *out, size_t start, size_t end);
-  void AsinhGrad(const T *input1, const T *input2, T *out, size_t start, size_t end);
-  void AcoshGrad(const T *input1, const T *input2, T *out, size_t start, size_t end);
+  void ReluGrad(const T *input1, const T *input2, T *out, size_t start, size_t end) const;
+  void ReLU6Grad(const T *input1, const T *input2, T *out, size_t start, size_t end) const;
+  void AbsGrad(const T *input1, const T *input2, T *out, size_t start, size_t end) const;
+  void SigmoidGrad(const T *input1, const T *input2, T *out, size_t start, size_t end) const;
+  void SqrtGrad(const T *input1, const T *input2, T *out, size_t start, size_t end) const;
+  void TanhGrad(const T *input1, const T *input2, T *out, size_t start, size_t end) const;
+  void GeluGrad(const T *input1, const T *input2, T *out, size_t start, size_t end) const;
+  void AsinGrad(const T *input1, const T *input2, T *out, size_t start, size_t end) const;
+  void ACosGrad(const T *input1, const T *input2, T *out, size_t start, size_t end) const;
+  void AtanGrad(const T *input1, const T *input2, T *out, size_t start, size_t end) const;
+  void AsinhGrad(const T *input1, const T *input2, T *out, size_t start, size_t end) const;
+  void AcoshGrad(const T *input1, const T *input2, T *out, size_t start, size_t end) const;
 
   std::string kernel_name_ = "";
 };

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

@@ -90,7 +90,7 @@ bool PackCpuFwdKernel<T>::Launch(const std::vector<AddressPtr> &inputs, const st
 }
 
 template <typename T>
-bool PackCpuFwdKernel<T>::CheckParam(const std::vector<AddressPtr> &outputs) {
+bool PackCpuFwdKernel<T>::CheckParam(const std::vector<AddressPtr> &outputs) const {
   if (outputs.size() != 1) {
     MS_LOG(EXCEPTION) << "Output number is " << outputs.size() << ", but PackGpuFwdKernel needs 1 output.";
     return false;

mindspore/ccsrc/backend/kernel_compiler/cpu/pack_cpu_kernel.h

@@ -34,7 +34,7 @@ class PackCpuFwdKernel : public CPUKernel {
               const std::vector<AddressPtr> &outputs) override;
 
  private:
-  bool CheckParam(const std::vector<AddressPtr> &outputs);
+  bool CheckParam(const std::vector<AddressPtr> &outputs) const;
   void PackTensor(T *output, size_t start, size_t end);
 
   int axis_;

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

@@ -30,7 +30,7 @@ void TensorAddCPUKernel<T>::InitKernel(const CNodePtr &kernel_node) {
 
 template <typename T>
 bool TensorAddCPUKernel<T>::Launch(const std::vector<kernel::AddressPtr> &inputs,
-                                   const std::vector<kernel::AddressPtr> & /*workspace*/,
+                                   const std::vector<kernel::AddressPtr> &,
                                    const std::vector<kernel::AddressPtr> &outputs) {
   T *input_addr_a = reinterpret_cast<T *>(inputs[0]->addr);
   T *input_addr_b = reinterpret_cast<T *>(inputs[1]->addr);

mindspore/ccsrc/backend/kernel_compiler/gpu/nn/adagrad_gpu_kernel.h

@@ -36,7 +36,7 @@ class AdagradGpuKernel : public GpuKernel {
   const std::vector<size_t> &GetOutputSizeList() const override { return output_size_list_; }
   const std::vector<size_t> &GetWorkspaceSizeList() const override { return workspace_size_list_; }
 
-  bool Launch(const std::vector<AddressPtr> &inputs, const std::vector<AddressPtr> & /*workspace*/,
+  bool Launch(const std::vector<AddressPtr> &inputs, const std::vector<AddressPtr> &,
               const std::vector<AddressPtr> &outputs, void *stream_ptr) override {
     T *variable = GetDeviceAddress<T>(inputs, 0);
     T *accumulation = GetDeviceAddress<T>(inputs, 1);