test,test=develop (#53847)

39f365c4 · Galaxy1458 · GitHub · 16fcbb9b · 39f365c4 · 39f365c4
19 changed file
--- a/paddle/phi/kernels/cpu/viterbi_decode_kernel.cc
+++ b/paddle/phi/kernels/cpu/viterbi_decode_kernel.cc
@@ -34,7 +34,7 @@ namespace phi {

 template <typename Context, typename T, typename IndType>
 struct Argmax {
-  void operator()(const Context& dev_ctx,
+  void operator()(const Context& dev_ctx UNUSED,
                  const DenseTensor& input,
                  DenseTensor* out_idx,
                  DenseTensor* out,

--- a/paddle/phi/kernels/cpu/yolo_loss_grad_kernel.cc
+++ b/paddle/phi/kernels/cpu/yolo_loss_grad_kernel.cc
@@ -128,14 +128,14 @@ void YoloLossGradKernel(const Context& dev_ctx,
                        const std::vector<int>& anchors,
                        const std::vector<int>& anchor_mask,
                        int class_num,
-                        float ignore_thresh,
+                        float ignore_thresh UNUSED,
                        int downsample_ratio,
                        bool use_label_smooth,
-                        float scale_x_y,
+                        float scale_x_y UNUSED,
                        DenseTensor* x_grad,
-                        DenseTensor* gt_box_grad,
-                        DenseTensor* gt_label_grad,
-                        DenseTensor* gt_score_grad) {
+                        DenseTensor* gt_box_grad UNUSED,
+                        DenseTensor* gt_label_grad UNUSED,
+                        DenseTensor* gt_score_grad UNUSED) {
  auto* input = &x;
  auto input_grad = x_grad;
  auto* objness_mask = &objectness_mask;

--- a/paddle/phi/kernels/funcs/activation_functor.h
+++ b/paddle/phi/kernels/funcs/activation_functor.h
@@ -1651,7 +1651,7 @@ struct ELUGradFunctor : public BaseActivationFunctor<T> {
            typename Out,
            typename dOut,
            typename dX>
-  void operator()(Device d, X x, Out out, dOut dout, dX dx) const {
+  void operator()(Device d, X x UNUSED, Out out, dOut dout, dX dx) const {
    // case 1: alpha >= 0
    // dx = dout, if out > 0
    // dx = dout * (out + alpha), if out <= 0

--- a/paddle/phi/kernels/funcs/adam_functors.h
+++ b/paddle/phi/kernels/funcs/adam_functors.h
@@ -455,7 +455,7 @@ class SparseAdamFunctor<T, CPUAdam, T> {
                    const int64_t* rows,
                    int64_t row_numel,
                    int64_t row_count,
-                    bool lazy_mode)
+                    bool lazy_mode UNUSED)
      : beta1_(beta1),
        beta2_(beta2),
        epsilon_(epsilon),

--- a/paddle/phi/kernels/funcs/blas/blas_impl.h
+++ b/paddle/phi/kernels/funcs/blas/blas_impl.h
@@ -71,7 +71,7 @@ struct CBlas<phi::dtype::bfloat16> {
  }

  template <typename... ARGS>
-  static void VCOPY(ARGS... args) {
+  static void VCOPY(ARGS... args UNUSED) {
    PADDLE_THROW(phi::errors::Unimplemented(
        "Blas VCOPY do not supported on CPU with bfloat16,"
        " please check your code"));

--- a/paddle/phi/kernels/funcs/deformable_conv_functor.cc
+++ b/paddle/phi/kernels/funcs/deformable_conv_functor.cc
@@ -99,7 +99,7 @@ inline void ModulatedDeformableIm2colCPUKernel(
 }

 template <typename T, typename Context>
-void ModulatedDeformableIm2col(const Context& dev_ctx,
+void ModulatedDeformableIm2col(const Context& dev_ctx UNUSED,
                               const T* data_im,
                               const T* data_offset,
                               const T* data_mask,

--- a/paddle/phi/kernels/funcs/detail/gru_cpu_kernel.h
+++ b/paddle/phi/kernels/funcs/detail/gru_cpu_kernel.h
@@ -932,13 +932,13 @@ inline void gru_backward(const Context &context,

 template <class OpGruGrad, typename T, typename Context>
 inline void cpu_gru_backward(const Context &context,
-                             OpGruGrad op_gru_grad,
+                             OpGruGrad op_gru_grad UNUSED,
                             phi::funcs::GRUMetaValue<T> value,
                             phi::funcs::GRUMetaGrad<T> grad,
                             int frame_size,
                             int batch_size,
-                             ActivationType active_node,
-                             ActivationType active_gate) {
+                             ActivationType active_node UNUSED,
+                             ActivationType active_gate UNUSED) {
  for (int b = 0; b < batch_size; ++b) {
    // eigen
    gru_backward(context, value, grad, frame_size);

--- a/paddle/phi/kernels/funcs/elementwise_functor.h
+++ b/paddle/phi/kernels/funcs/elementwise_functor.h
@@ -274,7 +274,7 @@ struct FMaxFunctor<int64_t> {

 template <typename T>
 struct FMaxGradDx {
-  HOSTDEVICE T operator()(T x, T y, T out, T dout) const {
+  HOSTDEVICE T operator()(T x, T y, T out UNUSED, T dout) const {
    return dout * static_cast<T>((x >= y) || isnan(y));
  }
 };
@@ -308,7 +308,7 @@ struct FMaxGradDx<int64_t> {

 template <typename T>
 struct FMaxGradDy {
-  HOSTDEVICE T operator()(T x, T y, T out, T dout) const {
+  HOSTDEVICE T operator()(T x, T y, T out UNUSED, T dout) const {
    return dout * static_cast<T>(!((x >= y) || isnan(y)));
  }
 };
@@ -342,7 +342,7 @@ struct FMaxGradDy<int> {

 template <typename T>
 struct FMinGradDx {
-  HOSTDEVICE T operator()(T x, T y, T out, T dout) const {
+  HOSTDEVICE T operator()(T x, T y, T out UNUSED, T dout) const {
    return dout * static_cast<T>((x <= y) || isnan(y));
  }
 };
@@ -376,7 +376,7 @@ struct FMinGradDx<int64_t> {

 template <typename T>
 struct FMinGradDy {
-  HOSTDEVICE T operator()(T x, T y, T out, T dout) const {
+  HOSTDEVICE T operator()(T x, T y, T out UNUSED, T dout) const {
    return dout * static_cast<T>(!((x <= y) || isnan(y)));
  }
 };

--- a/paddle/phi/kernels/funcs/fft.cc
+++ b/paddle/phi/kernels/funcs/fft.cc
@@ -210,7 +210,7 @@ static T compute_factor(size_t size, FFTNormMode normalization) {

 template <typename Ti, typename To>
 struct FFTC2CFunctor<phi::CPUContext, Ti, To> {
-  void operator()(const phi::CPUContext& ctx,
+  void operator()(const phi::CPUContext& ctx UNUSED,
                  const DenseTensor& x,
                  DenseTensor* out,
                  const std::vector<int64_t>& axes,
@@ -253,7 +253,7 @@ struct FFTC2CFunctor<phi::CPUContext, Ti, To> {

 template <typename Ti, typename To>
 struct FFTR2CFunctor<phi::CPUContext, Ti, To> {
-  void operator()(const phi::CPUContext& ctx,
+  void operator()(const phi::CPUContext& ctx UNUSED,
                  const DenseTensor& x,
                  DenseTensor* out,
                  const std::vector<int64_t>& axes,
@@ -310,7 +310,7 @@ struct FFTR2CFunctor<phi::CPUContext, Ti, To> {

 template <typename Ti, typename To>
 struct FFTC2RFunctor<phi::CPUContext, Ti, To> {
-  void operator()(const phi::CPUContext& ctx,
+  void operator()(const phi::CPUContext& ctx UNUSED,
                  const DenseTensor& x,
                  DenseTensor* out,
                  const std::vector<int64_t>& axes,

--- a/paddle/phi/kernels/funcs/functors.h
+++ b/paddle/phi/kernels/funcs/functors.h
@@ -21,14 +21,14 @@ namespace phi {
 namespace funcs {
 template <typename T>
 struct MulGradFunctor {
-  inline HOSTDEVICE T Dx(T x, T y) { return y; }
-  inline HOSTDEVICE T Dy(T x, T y) { return x; }
+  inline HOSTDEVICE T Dx(T x UNUSED, T y) { return y; }
+  inline HOSTDEVICE T Dy(T x, T y UNUSED) { return x; }
 };

 template <typename T>
 struct AddGradFunctor {
-  inline HOSTDEVICE T Dx(T x, T y) { return static_cast<T>(1.); }
-  inline HOSTDEVICE T Dy(T x, T y) { return static_cast<T>(1.); }
+  inline HOSTDEVICE T Dx(T x UNUSED, T y UNUSED) { return static_cast<T>(1.); }
+  inline HOSTDEVICE T Dy(T x UNUSED, T y UNUSED) { return static_cast<T>(1.); }
 };

 template <typename T>
@@ -48,9 +48,9 @@ template <typename T>
 struct ScaleGradFunctor {
  explicit ScaleGradFunctor(T coeff) : coeff_(coeff) {}

-  inline HOSTDEVICE T UseX(T x) { return coeff_; }
-  inline HOSTDEVICE T UseOut(T out) { return coeff_; }
-  inline HOSTDEVICE T UseXAndOut(T x, T out) { return coeff_; }
+  inline HOSTDEVICE T UseX(T x UNUSED) { return coeff_; }
+  inline HOSTDEVICE T UseOut(T out UNUSED) { return coeff_; }
+  inline HOSTDEVICE T UseXAndOut(T x UNUSED, T out UNUSED) { return coeff_; }

 private:
  T coeff_;
@@ -71,7 +71,7 @@ struct ReluGradFunctor {
  inline HOSTDEVICE T UseOut(T out) {
    return out > static_cast<T>(0) ? static_cast<T>(1) : static_cast<T>(0);
  }
-  inline HOSTDEVICE T UseXAndOut(T x, T out) {
+  inline HOSTDEVICE T UseXAndOut(T x UNUSED, T out) {
    return out > static_cast<T>(0) ? static_cast<T>(1) : static_cast<T>(0);
  }
 };
@@ -93,7 +93,7 @@ template <typename T>
 struct TanhGradFunctor {
  inline HOSTDEVICE T UseX(T x) { return static_cast<T>(1) - x * x; }
  inline HOSTDEVICE T UseOut(T out) { return static_cast<T>(1) - out * out; }
-  inline HOSTDEVICE T UseXAndOut(T x, T out) {
+  inline HOSTDEVICE T UseXAndOut(T x UNUSED, T out) {
    return static_cast<T>(1) - out * out;
  }
 };
@@ -113,7 +113,7 @@ template <typename T>
 struct SigmoidGradFunctor {
  inline HOSTDEVICE T UseX(T x) { return x * (static_cast<T>(1) - x); }
  inline HOSTDEVICE T UseOut(T out) { return out * (static_cast<T>(1) - out); }
-  inline HOSTDEVICE T UseXAndOut(T x, T out) {
+  inline HOSTDEVICE T UseXAndOut(T x UNUSED, T out) {
    return out * (static_cast<T>(1) - out);
  }
 };
@@ -161,7 +161,7 @@ struct GeluGradFunctor {
             static_cast<MT>(0.5) * (static_cast<MT>(1) + tanh_out);
    return static_cast<T>(ans);
  }
-  inline HOSTDEVICE T UseXAndOut(T x, T out) {
+  inline HOSTDEVICE T UseXAndOut(T x, T out UNUSED) {
    MT mx = static_cast<MT>(x);
    MT tanh_out =
        tanh(static_cast<MT>(0.79788456) * mx *

--- a/paddle/phi/kernels/funcs/im2col.cc
+++ b/paddle/phi/kernels/funcs/im2col.cc
@@ -30,7 +30,7 @@ namespace funcs {
 template <class T, typename DeviceContext>
 class Im2ColFunctor<phi::funcs::ColFormat::kCFO, DeviceContext, T> {
 public:
-  void operator()(const DeviceContext& context,
+  void operator()(const DeviceContext& context UNUSED,
                  const phi::DenseTensor& im,
                  const std::vector<int>& dilation,
                  const std::vector<int>& stride,
@@ -75,7 +75,7 @@ class Im2ColFunctor<phi::funcs::ColFormat::kCFO, DeviceContext, T> {
 template <class T, typename DeviceContext>
 class Col2ImFunctor<phi::funcs::ColFormat::kCFO, DeviceContext, T> {
 public:
-  void operator()(const DeviceContext& context,
+  void operator()(const DeviceContext& context UNUSED,
                  const phi::DenseTensor& col,
                  const std::vector<int>& dilation,
                  const std::vector<int>& stride,
@@ -175,13 +175,13 @@ template class Col2ImFunctor<phi::funcs::ColFormat::kCFO,
 template <class T, typename DeviceContext>
 class Im2ColFunctor<phi::funcs::ColFormat::kOCF, DeviceContext, T> {
 public:
-  void operator()(const DeviceContext& context,
+  void operator()(const DeviceContext& context UNUSED,
                  const phi::DenseTensor& im,
-                  const std::vector<int>& dilation,
+                  const std::vector<int>& dilation UNUSED,
                  const std::vector<int>& stride,
                  const std::vector<int>& padding,
                  phi::DenseTensor* col,
-                  const DataLayout data_layout) {
+                  const DataLayout data_layout UNUSED) {
    PADDLE_ENFORCE_EQ(im.dims().size(),
                      3,
                      phi::errors::InvalidArgument(
@@ -248,13 +248,13 @@ class Im2ColFunctor<phi::funcs::ColFormat::kOCF, DeviceContext, T> {
 template <class T, typename DeviceContext>
 class Col2ImFunctor<phi::funcs::ColFormat::kOCF, DeviceContext, T> {
 public:
-  void operator()(const DeviceContext& context,
+  void operator()(const DeviceContext& context UNUSED,
                  const phi::DenseTensor& col,
-                  const std::vector<int>& dilation,
+                  const std::vector<int>& dilation UNUSED,
                  const std::vector<int>& stride,
                  const std::vector<int>& padding,
                  phi::DenseTensor* im,
-                  const DataLayout data_layout) {
+                  const DataLayout data_layout UNUSED) {
    PADDLE_ENFORCE_EQ(im->dims().size(),
                      3,
                      phi::errors::InvalidArgument(

--- a/paddle/phi/kernels/funcs/isfinite_functor.h
+++ b/paddle/phi/kernels/funcs/isfinite_functor.h
@@ -31,7 +31,7 @@ struct IsNanFunctor {
 template <typename T>
 struct IsNanFunctor<T,
                    typename std::enable_if<std::is_integral<T>::value>::type> {
-  HOSTDEVICE bool operator()(const T& a) const { return false; }
+  HOSTDEVICE bool operator()(const T& a UNUSED) const { return false; }
 };

 // isnan is defined in namespace std in float16.h, but
@@ -66,7 +66,7 @@ struct IsInfFunctor {
 template <typename T>
 struct IsInfFunctor<T,
                    typename std::enable_if<std::is_integral<T>::value>::type> {
-  HOSTDEVICE bool operator()(const T& a) const { return false; }
+  HOSTDEVICE bool operator()(const T& a UNUSED) const { return false; }
 };

 template <>
@@ -98,7 +98,7 @@ template <typename T>
 struct IsFiniteFunctor<
    T,
    typename std::enable_if<std::is_integral<T>::value>::type> {
-  HOSTDEVICE bool operator()(const T& a) const { return true; }
+  HOSTDEVICE bool operator()(const T& a UNUSED) const { return true; }
 };

 template <>

--- a/paddle/phi/kernels/funcs/layer_norm_util.h
+++ b/paddle/phi/kernels/funcs/layer_norm_util.h
@@ -126,7 +126,9 @@ class ColwiseSum2D<phi::GPUContext, T> {
 template <typename T>
 class ColwiseSum2D<phi::CPUContext, T> {
 public:
-  ColwiseSum2D(int left, int right, const phi::CPUContext& dev_ctx) {}
+  ColwiseSum2D(int left UNUSED,
+               int right UNUSED,
+               const phi::CPUContext& dev_ctx UNUSED) {}

  void operator()(const phi::CPUContext& context,
                  const DenseTensor& input,

--- a/paddle/phi/kernels/funcs/math_function.cc
+++ b/paddle/phi/kernels/funcs/math_function.cc
@@ -243,7 +243,7 @@ template struct RowwiseMean<phi::CPUContext, double>;

 template <typename T>
 struct RowwiseAdd<phi::CPUContext, T> {
-  void operator()(const phi::CPUContext& context,
+  void operator()(const phi::CPUContext& context UNUSED,
                  const phi::DenseTensor& input,
                  const phi::DenseTensor& vector,
                  phi::DenseTensor* output) {

--- a/paddle/phi/kernels/funcs/pooling.cc
+++ b/paddle/phi/kernels/funcs/pooling.cc
@@ -1622,10 +1622,10 @@ class MaxPool2dWithIndexGradFunctor<CPUContext, T1, T2> {
  void operator()(const CPUContext& context,
                  const DenseTensor& output_grad,
                  const DenseTensor& mask,
-                  const std::vector<int>& ksize,
-                  const std::vector<int>& strides,
-                  const std::vector<int>& paddings,
-                  bool adaptive,
+                  const std::vector<int>& ksize UNUSED,
+                  const std::vector<int>& strides UNUSED,
+                  const std::vector<int>& paddings UNUSED,
+                  bool adaptive UNUSED,
                  DenseTensor* input_grad) {
    const int batch_size = input_grad->dims()[0];
    const int input_height = input_grad->dims()[2];
@@ -1775,10 +1775,10 @@ class MaxPool3dWithIndexGradFunctor<CPUContext, T1, T2> {
  void operator()(const CPUContext& context,
                  const DenseTensor& output_grad,
                  const DenseTensor& mask,
-                  const std::vector<int>& ksize,
-                  const std::vector<int>& strides,
-                  const std::vector<int>& paddings,
-                  bool adaptive,
+                  const std::vector<int>& ksize UNUSED,
+                  const std::vector<int>& strides UNUSED,
+                  const std::vector<int>& paddings UNUSED,
+                  bool adaptive UNUSED,
                  DenseTensor* input_grad) {
    const int batch_size = input_grad->dims()[0];
    const int input_depth = input_grad->dims()[2];

--- a/paddle/phi/kernels/funcs/pooling.h
+++ b/paddle/phi/kernels/funcs/pooling.h
@@ -45,7 +45,7 @@ class MaxPool {
 public:
  DEVICE inline T initial() { return static_cast<T>(-FLT_MAX); }
  HOSTDEVICE inline void compute(const T& x, T* y) { *y = *y > x ? *y : x; }
-  DEVICE inline void finalize(const T& pool_field, T* y) {}
+  DEVICE inline void finalize(const T& pool_field UNUSED, T* y UNUSED) {}
 };

 template <class T>
@@ -59,7 +59,7 @@ class AvgPool {
    return static_cast<T>(0);
  }

-  DEVICE inline void compute(const T& x, T* y) {
+  DEVICE inline void compute(const T& x, T* y UNUSED) {
    intermediate_res += static_cast<MT>(x);
  }

@@ -83,7 +83,7 @@ class AvgPoolGrad {
 public:
  static constexpr bool use_x = false;
  HOSTDEVICE inline void compute(
-      const T& x, const T& y, const T& dy, T scale, T* dx) {
+      const T& x UNUSED, const T& y UNUSED, const T& dy, T scale, T* dx) {
    *dx += (scale * dy);
  }
 };

--- a/paddle/phi/kernels/funcs/selected_rows_functor.cc
+++ b/paddle/phi/kernels/funcs/selected_rows_functor.cc
@@ -420,7 +420,7 @@ typename std::enable_if<!std::is_integral<T>::value>::type elementwise_add_to(

 template <typename T, typename DeviceContext>
 typename std::enable_if<std::is_integral<T>::value>::type elementwise_add_to(
-    phi::funcs::BlasT<DeviceContext, T>* blas,
+    phi::funcs::BlasT<DeviceContext, T>* blas UNUSED,
    size_t data_len,
    const T* in,
    T* out) {

--- a/paddle/phi/kernels/funcs/sequence2batch.cc
+++ b/paddle/phi/kernels/funcs/sequence2batch.cc
@@ -20,7 +20,7 @@ namespace funcs {
 template <typename T>
 class CopyMatrixRowsFunctor<phi::CPUContext, T> {
 public:
-  void operator()(const phi::CPUContext& context,
+  void operator()(const phi::CPUContext& context UNUSED,
                  const phi::DenseTensor& src,
                  phi::Vector<size_t> index_lod,
                  phi::DenseTensor* dst,

--- a/paddle/phi/kernels/funcs/sequence_pooling.cc
+++ b/paddle/phi/kernels/funcs/sequence_pooling.cc
@@ -36,7 +36,7 @@ using EigenMatrix = phi::EigenMatrix<T, MajorType, IndexType>;
 template <typename T, bool is_test>
 class MaxSeqPoolFunctor {
 public:
-  void operator()(const phi::CPUContext& context,
+  void operator()(const phi::CPUContext& context UNUSED,
                  const phi::DenseTensor& input,
                  T pad_value,
                  phi::DenseTensor* output,
@@ -115,11 +115,11 @@ class MaxSeqPoolFunctor {
 template <typename T>
 class MaxSeqPoolFunctor<T, true> {
 public:
-  void operator()(const phi::CPUContext& context,
+  void operator()(const phi::CPUContext& context UNUSED,
                  const phi::DenseTensor& input,
                  T pad_value,
                  phi::DenseTensor* output,
-                  phi::DenseTensor* index) {
+                  phi::DenseTensor* index UNUSED) {
    auto in_dims = input.dims();
    auto out_dims = output->dims();
    PADDLE_ENFORCE_GT(in_dims.size(),
@@ -239,7 +239,7 @@ class MaxSeqPoolGradFunctor {
 template <typename T>
 class LastSeqPoolFunctor {
 public:
-  void operator()(const phi::CPUContext& context,
+  void operator()(const phi::CPUContext& context UNUSED,
                  const phi::DenseTensor& input,
                  T pad_value,
                  phi::DenseTensor* output) {
@@ -273,7 +273,7 @@ class LastSeqPoolFunctor {
 template <typename T>
 class FirstSeqPoolFunctor {
 public:
-  void operator()(const phi::CPUContext& context,
+  void operator()(const phi::CPUContext& context UNUSED,
                  const phi::DenseTensor& input,
                  T pad_value,
                  phi::DenseTensor* output) {