PaddlePaddle
diff --git a/‎paddle/phi/kernels/xpu/abs_grad_kernel.cc
Copy file name to clipboard
+3-3Lines changed: 3 additions & 3 deletions b/‎paddle/phi/kernels/xpu/abs_grad_kernel.cc
Copy file name to clipboard
+3-3Lines changed: 3 additions & 3 deletions
diff --git a/‎paddle/phi/kernels/xpu/abs_kernel.cc
Copy file name to clipboard
+3-3Lines changed: 3 additions & 3 deletions b/‎paddle/phi/kernels/xpu/abs_kernel.cc
Copy file name to clipboard
+3-3Lines changed: 3 additions & 3 deletions
diff --git a/‎paddle/phi/kernels/xpu/adagrad_kernel.cc
Copy file name to clipboard
+4-4Lines changed: 4 additions & 4 deletions b/‎paddle/phi/kernels/xpu/adagrad_kernel.cc
Copy file name to clipboard
+4-4Lines changed: 4 additions & 4 deletions
diff --git a/‎paddle/phi/kernels/xpu/bitwise.cc
Copy file name to clipboard
+7-7Lines changed: 7 additions & 7 deletions b/‎paddle/phi/kernels/xpu/bitwise.cc
Copy file name to clipboard
+7-7Lines changed: 7 additions & 7 deletions
diff --git a/‎paddle/phi/kernels/xpu/cast_kernel.cc
Copy file name to clipboard
+3-3Lines changed: 3 additions & 3 deletions b/‎paddle/phi/kernels/xpu/cast_kernel.cc
Copy file name to clipboard
+3-3Lines changed: 3 additions & 3 deletions
diff --git a/‎paddle/phi/kernels/xpu/clip_grad_kernel.cc
Copy file name to clipboard
+3-3Lines changed: 3 additions & 3 deletions b/‎paddle/phi/kernels/xpu/clip_grad_kernel.cc
Copy file name to clipboard
+3-3Lines changed: 3 additions & 3 deletions
diff --git a/‎paddle/phi/kernels/xpu/complex_grad_kernel.cc
Copy file name to clipboard
+3-3Lines changed: 3 additions & 3 deletions b/‎paddle/phi/kernels/xpu/complex_grad_kernel.cc
Copy file name to clipboard
+3-3Lines changed: 3 additions & 3 deletions
diff --git a/‎paddle/phi/kernels/xpu/conv_transpose_grad_kernel.cc
Copy file name to clipboard
+7-7Lines changed: 7 additions & 7 deletions b/‎paddle/phi/kernels/xpu/conv_transpose_grad_kernel.cc
Copy file name to clipboard
+7-7Lines changed: 7 additions & 7 deletions
diff --git a/‎paddle/phi/kernels/xpu/conv_transpose_kernel.cc
Copy file name to clipboard
+14-14Lines changed: 14 additions & 14 deletions b/‎paddle/phi/kernels/xpu/conv_transpose_kernel.cc
Copy file name to clipboard
+14-14Lines changed: 14 additions & 14 deletions
diff --git a/‎paddle/phi/kernels/xpu/dequantization_kernel.cc
Copy file name to clipboard
+10-9Lines changed: 10 additions & 9 deletions b/‎paddle/phi/kernels/xpu/dequantization_kernel.cc
Copy file name to clipboard
+10-9Lines changed: 10 additions & 9 deletions
@@ -21,16 +21,16 @@
 namespace phi {
 
 template <typename T, typename Context>
-void AbsGradKernel(const Context& ctx,
+void AbsGradKernel(const Context& dev_ctx,
                    const DenseTensor& x,
                    const DenseTensor& dout,
                    DenseTensor* dx) {
-  ctx.template Alloc<T>(dx);
+  dev_ctx.template Alloc<T>(dx);
   if (dx && dx->numel() == 0) {
     return;
   }
   using XPUType = typename XPUTypeTrait<T>::Type;
-  int r = xpu::abs_grad(ctx.x_context(),
+  int r = xpu::abs_grad(dev_ctx.x_context(),
                         reinterpret_cast<const XPUType*>(x.data<T>()),
                         reinterpret_cast<const XPUType*>(dout.data<T>()),
                         reinterpret_cast<const XPUType*>(dout.data<T>()),
 
@@ -20,13 +20,13 @@
 namespace phi {
 
 template <typename T, typename Context>
-void AbsKernel(const Context& ctx, const DenseTensor& x, DenseTensor* out) {
-  ctx.template Alloc<T>(out);
+void AbsKernel(const Context& dev_ctx, const DenseTensor& x, DenseTensor* out) {
+  dev_ctx.template Alloc<T>(out);
   if (out->numel() == 0) {
     return;
   }
   using XPUType = typename XPUTypeTrait<T>::Type;
-  int r = xpu::abs<XPUType>(ctx.x_context(),
+  int r = xpu::abs<XPUType>(dev_ctx.x_context(),
                             reinterpret_cast<const XPUType*>(x.data<T>()),
                             reinterpret_cast<XPUType*>(out->data<T>()),
                             x.numel());
 
@@ -19,7 +19,7 @@
 namespace phi {
 
 template <typename T, typename Context>
-void AdagradDenseKernel(const Context& ctx,
+void AdagradDenseKernel(const Context& dev_ctx,
                         const DenseTensor& param,
                         const DenseTensor& grad,
                         const DenseTensor& moment,
@@ -30,12 +30,12 @@ void AdagradDenseKernel(const Context& ctx,
                         DenseTensor* param_out_tensor,
                         DenseTensor* moment_out_tensor,
                         DenseTensor* master_param_outs) {
-  ctx.template Alloc<T>(param_out_tensor);
-  ctx.template Alloc<T>(moment_out_tensor);
+  dev_ctx.template Alloc<T>(param_out_tensor);
+  dev_ctx.template Alloc<T>(moment_out_tensor);
 
   T epsilon = static_cast<T>(epsilon_t);
 
-  int r = xpu::adagrad(ctx.x_context(),
+  int r = xpu::adagrad(dev_ctx.x_context(),
                        param.data<T>(),
                        grad.data<T>(),
                        moment.data<T>(),
 
@@ -21,37 +21,37 @@
 namespace phi {
 
 template <typename T, typename Context>
-void BitwiseNotKernel(const Context& ctx,
+void BitwiseNotKernel(const Context& dev_ctx,
                       const DenseTensor& x,
                       DenseTensor* out) {
   using XPUDataType = typename XPUTypeTrait<T>::Type;
-  ctx.template Alloc<T>(out);
-  int r = xpu::logical_not(ctx.x_context(),
+  dev_ctx.template Alloc<T>(out);
+  int r = xpu::logical_not(dev_ctx.x_context(),
                            reinterpret_cast<const XPUDataType*>(x.data<T>()),
                            reinterpret_cast<XPUDataType*>(out->data<T>()),
                            x.numel());
   PADDLE_ENFORCE_XDNN_SUCCESS(r, "logical_not");
 }
 
 template <typename T, typename Context>
-void BitwiseAndKernel(const Context& ctx,
+void BitwiseAndKernel(const Context& dev_ctx,
                       const DenseTensor& x,
                       const DenseTensor& y,
                       DenseTensor* out) {
   // XPU api do not support bitwise operation now.
   // However, because bitwise and logical operation is identical for bool type,
   // we can implement bitwise_and_bool kernel by calling their logical
   // counterpart. Need to be changed when adding support to other types.
-  LogicalAndKernel<T, Context>(ctx, x, y, out);
+  LogicalAndKernel<T, Context>(dev_ctx, x, y, out);
 }
 
 template <typename T, typename Context>
-void BitwiseOrKernel(const Context& ctx,
+void BitwiseOrKernel(const Context& dev_ctx,
                      const DenseTensor& x,
                      const DenseTensor& y,
                      DenseTensor* out) {
   // Same reason as bitwise_and
-  LogicalOrKernel<T, Context>(ctx, x, y, out);
+  LogicalOrKernel<T, Context>(dev_ctx, x, y, out);
 }
 }  // namespace phi
 
 
@@ -23,13 +23,13 @@ namespace phi {
 
 #ifdef PADDLE_WITH_XPU_FFT
 template <class T, class Context>
-static DenseTensor Fill(const Context& ctx,
+static DenseTensor Fill(const Context& dev_ctx,
                         std::vector<int> shape,
                         T fill_value) {
   DenseTensor ret;
   ret.Resize(common::make_ddim(shape));
-  ctx.template Alloc<T>(&ret);
-  funcs::SetConstant<Context, T>()(ctx, &ret, fill_value);
+  dev_ctx.template Alloc<T>(&ret);
+  funcs::SetConstant<Context, T>()(dev_ctx, &ret, fill_value);
   return ret;
 }
 #endif
 
@@ -20,16 +20,16 @@
 namespace phi {
 
 template <typename T, typename Context>
-void ClipGradKernel(const Context& ctx,
+void ClipGradKernel(const Context& dev_ctx,
                     const DenseTensor& x,
                     const DenseTensor& out_grad,
                     const Scalar& min,
                     const Scalar& max,
                     DenseTensor* x_grad) {
-  ctx.template Alloc<T>(x_grad);
+  dev_ctx.template Alloc<T>(x_grad);
   using XPUDataType = typename XPUTypeTrait<T>::Type;
   int r =
-      xpu::clamp_grad(ctx.x_context(),
+      xpu::clamp_grad(dev_ctx.x_context(),
                       reinterpret_cast<const XPUDataType*>(x.data<T>()),
                       reinterpret_cast<const XPUDataType*>(out_grad.data<T>()),
                       reinterpret_cast<XPUDataType*>(x_grad->data<T>()),
 
@@ -32,13 +32,13 @@ int complex_spilt_float(int N, float2* in, float* real, float* imag);
 namespace phi {
 
 template <class T, class Context>
-static DenseTensor Fill(const Context& ctx,
+static DenseTensor Fill(const Context& dev_ctx,
                         std::vector<int> shape,
                         T fill_value) {
   DenseTensor ret;
   ret.Resize(common::make_ddim(shape));
-  ctx.template Alloc<T>(&ret);
-  funcs::SetConstant<Context, T>()(ctx, &ret, fill_value);
+  dev_ctx.template Alloc<T>(&ret);
+  funcs::SetConstant<Context, T>()(dev_ctx, &ret, fill_value);
   return ret;
 }
 
 
@@ -21,7 +21,7 @@
 
 namespace phi {
 template <typename T, typename Context>
-void Conv2dTransposeGradKernel(const Context& ctx,
+void Conv2dTransposeGradKernel(const Context& dev_ctx,
                                const DenseTensor& x,
                                const DenseTensor& filter,
                                const DenseTensor& dout,
@@ -72,17 +72,17 @@ void Conv2dTransposeGradKernel(const Context& ctx,
   const int64_t img_xh = dout.dims()[2];
   const int64_t img_xw = dout.dims()[3];
   if (dx) {
-    ctx.template Alloc<T>(dx);
+    dev_ctx.template Alloc<T>(dx);
   }
   if (dfilter) {
-    ctx.template Alloc<T>(dfilter);
+    dev_ctx.template Alloc<T>(dfilter);
   }
   int fc_calc_type = FCCalcType<T>();
   if (fc_calc_type == XPUFCCalcType::FC_INT32 ||
       fc_calc_type == XPUFCCalcType::FC_INT32_WITH_LL) {
     // xpu api do not support int31 quantization now.
     int r = xpu::conv2d_transpose_grad<float, float, float, int_with_ll_t>(
-        ctx.x_context(),
+        dev_ctx.x_context(),
         x.data<T>(),
         filter_.data<T>(),
         dout.data<T>(),
@@ -109,7 +109,7 @@ void Conv2dTransposeGradKernel(const Context& ctx,
     PADDLE_ENFORCE_XDNN_SUCCESS(r, "conv2d_transpose_grad");
   } else {
     int r = xpu::conv2d_transpose_grad<float, float, float, int16_t>(
-        ctx.x_context(),
+        dev_ctx.x_context(),
         x.data<T>(),
         filter_.data<T>(),
         dout.data<T>(),
@@ -138,7 +138,7 @@ void Conv2dTransposeGradKernel(const Context& ctx,
 }
 
 template <typename T, typename Context>
-void DepthwiseConv2dTransposeGradKernel(const Context& ctx,
+void DepthwiseConv2dTransposeGradKernel(const Context& dev_ctx,
                                         const DenseTensor& x,
                                         const DenseTensor& filter,
                                         const DenseTensor& dout,
@@ -152,7 +152,7 @@ void DepthwiseConv2dTransposeGradKernel(const Context& ctx,
                                         const std::string& data_format,
                                         DenseTensor* dx,
                                         DenseTensor* dfilter) {
-  Conv2dTransposeGradKernel<T, Context>(ctx,
+  Conv2dTransposeGradKernel<T, Context>(dev_ctx,
                                         x,
                                         filter,
                                         dout,
 
@@ -28,7 +28,7 @@ namespace xpudnn = baidu::xpu::xpudnn;
 namespace phi {
 
 template <typename T, typename Context>
-void Conv2dTransposeKernel(const Context& ctx,
+void Conv2dTransposeKernel(const Context& dev_ctx,
                            const DenseTensor& x,
                            const DenseTensor& filter,
                            const std::vector<int>& strides,
@@ -42,7 +42,7 @@ void Conv2dTransposeKernel(const Context& ctx,
                            DenseTensor* out) {
   using XPUType = typename XPUTypeTrait<T>::Type;
 
-  ctx.template Alloc<T>(out);
+  dev_ctx.template Alloc<T>(out);
 
   PADDLE_ENFORCE_EQ(
       data_format == "NHWC" || data_format == "NDHWC",
@@ -77,7 +77,7 @@ void Conv2dTransposeKernel(const Context& ctx,
   int fc_calc_type = FCCalcType<XPUType>();
   if (fc_calc_type == XPUFCCalcType::FC_INT32) {
     int r = xpudnn::conv2d_transpose_fusion_v2<float, float, float, int32_t>(
-        ctx.x_context(),
+        dev_ctx.x_context(),
         x.data<float>(),
         filter.data<float>(),
         out->data<float>(),
@@ -101,7 +101,7 @@ void Conv2dTransposeKernel(const Context& ctx,
     PADDLE_ENFORCE_XDNN_SUCCESS(r, "conv2d_transpose_fusion_v2");
   } else if (fc_calc_type == XPUFCCalcType::FC_FLOAT) {
     int r = xpudnn::conv2d_transpose_fusion_v2<float, float, float, float>(
-        ctx.x_context(),
+        dev_ctx.x_context(),
         x.data<float>(),
         filter.data<float>(),
         out->data<float>(),
@@ -129,7 +129,7 @@ void Conv2dTransposeKernel(const Context& ctx,
                  "is specified, "
               << "use int31 instead";
       int r = xpudnn::conv2d_transpose_fusion_v2<float, float, float, int32_t>(
-          ctx.x_context(),
+          dev_ctx.x_context(),
           x.data<float>(),
           filter.data<float>(),
           out->data<float>(),
@@ -158,7 +158,7 @@ void Conv2dTransposeKernel(const Context& ctx,
       int64_t img_yw = static_cast<int64_t>(x.dims()[3]);
       int r = xpudnn::
           conv2d_transpose_fusion_v2<float, float, float, int_with_ll_t>(
-              ctx.x_context(),
+              dev_ctx.x_context(),
               x.data<float>(),
               filter.data<float>(),
               out->data<float>(),
@@ -184,7 +184,7 @@ void Conv2dTransposeKernel(const Context& ctx,
   } else {
     int r =
         xpudnn::conv2d_transpose_fusion_v2<XPUType, XPUType, XPUType, int16_t>(
-            ctx.x_context(),
+            dev_ctx.x_context(),
             reinterpret_cast<const XPUType*>(x.data<T>()),
             reinterpret_cast<const XPUType*>(filter.data<T>()),
             reinterpret_cast<XPUType*>(out->data<T>()),
@@ -231,7 +231,7 @@ void Conv2dTransposeKernel(const Context& ctx,
   int fc_calc_type = FCCalcType<XPUType>();
   if (fc_calc_type == XPUFCCalcType::FC_INT32) {
     int r = xpu::conv2d_transpose_v2<float, float, float, int32_t>(
-        ctx.x_context(),
+        dev_ctx.x_context(),
         x.data<float>(),
         filter.data<float>(),
         out->data<float>(),
@@ -252,7 +252,7 @@ void Conv2dTransposeKernel(const Context& ctx,
     PADDLE_ENFORCE_XDNN_SUCCESS(r, "conv2d_transpose_v2");
   } else if (fc_calc_type == XPUFCCalcType::FC_FLOAT) {
     int r = xpu::conv2d_transpose_v2<float, float, float, float>(
-        ctx.x_context(),
+        dev_ctx.x_context(),
         x.data<float>(),
         filter.data<float>(),
         out->data<float>(),
@@ -277,7 +277,7 @@ void Conv2dTransposeKernel(const Context& ctx,
                  "is specified, "
               << "use int31 instead";
       int r = xpu::conv2d_transpose_v2<float, float, float, int32_t>(
-          ctx.x_context(),
+          dev_ctx.x_context(),
           x.data<float>(),
           filter.data<float>(),
           out->data<float>(),
@@ -302,7 +302,7 @@ void Conv2dTransposeKernel(const Context& ctx,
       int64_t img_yh = x.dims()[2];
       int64_t img_yw = x.dims()[3];
       int r = xpu::conv2d_transpose<float, float, float, int_with_ll_t>(
-          ctx.x_context(),
+          dev_ctx.x_context(),
           x.data<float>(),
           filter.data<float>(),
           out->data<float>(),
@@ -324,7 +324,7 @@ void Conv2dTransposeKernel(const Context& ctx,
     }
   } else {
     int r = xpu::conv2d_transpose_v2<XPUType, XPUType, XPUType, int16_t>(
-        ctx.x_context(),
+        dev_ctx.x_context(),
         reinterpret_cast<const XPUType*>(x.data<T>()),
         reinterpret_cast<const XPUType*>(filter.data<T>()),
         reinterpret_cast<XPUType*>(out->data<T>()),
@@ -477,7 +477,7 @@ void Conv3dTransposeKernel(const Context& dev_ctx,
 }
 
 template <typename T, typename Context>
-void DepthwiseConv2dTransposeKernel(const Context& ctx,
+void DepthwiseConv2dTransposeKernel(const Context& dev_ctx,
                                     const DenseTensor& x,
                                     const DenseTensor& filter,
                                     const std::vector<int>& strides,
@@ -489,7 +489,7 @@ void DepthwiseConv2dTransposeKernel(const Context& ctx,
                                     const std::vector<int>& dilations,
                                     const std::string& data_format,
                                     DenseTensor* out) {
-  Conv2dTransposeKernel<T, Context>(ctx,
+  Conv2dTransposeKernel<T, Context>(dev_ctx,
                                     x,
                                     filter,
                                     strides,
 
@@ -17,23 +17,24 @@
 
 namespace phi {
 template <typename TX, typename TY, typename Context>
-void DeQuantizeKernelImpl(const Context& ctx,
+void DeQuantizeKernelImpl(const Context& dev_ctx,
                           const DenseTensor& x,
                           float scale,
                           DenseTensor* y) {
   using XPUInX = typename XPUTypeTrait<TX>::Type;
   using XPUOutY = typename XPUTypeTrait<TY>::Type;
 
-  auto* y_data = ctx.template Alloc<TY>(y);
+  auto* y_data = dev_ctx.template Alloc<TY>(y);
   const auto* x_data = x.data<TX>();
   int64_t len = x.numel();
-  int max_ptr_size = ctx.x_context()->max_ptr_size();
-  xpu::ctx_guard RAII_GUARD(ctx.x_context());
+  int max_ptr_size = dev_ctx.x_context()->max_ptr_size();
+  xpu::ctx_guard RAII_GUARD(dev_ctx.x_context());
   auto max_data = RAII_GUARD.alloc_l3_or_gm<float>(max_ptr_size);
-  int r = xpu::constant<float>(ctx.x_context(), max_data, max_ptr_size, scale);
+  int r =
+      xpu::constant<float>(dev_ctx.x_context(), max_data, max_ptr_size, scale);
   PADDLE_ENFORCE_XDNN_SUCCESS(r, "constant");
   r = xpu::dequantization<XPUInX, XPUOutY>(
-      ctx.x_context(),
+      dev_ctx.x_context(),
       reinterpret_cast<const XPUInX*>(x_data),
       reinterpret_cast<XPUOutY*>(y_data),
       len,
@@ -42,17 +43,17 @@ void DeQuantizeKernelImpl(const Context& ctx,
 }
 
 template <typename T, typename Context>
-void DeQuantizeKernel(const Context& ctx,
+void DeQuantizeKernel(const Context& dev_ctx,
                       const DenseTensor& x,
                       DataType out_dtype,
                       float scale,
                       DenseTensor* y) {
   switch (out_dtype) {
     case DataType::FLOAT32:
-      DeQuantizeKernelImpl<T, float, Context>(ctx, x, scale, y);
+      DeQuantizeKernelImpl<T, float, Context>(dev_ctx, x, scale, y);
       break;
     case DataType::FLOAT16:
-      DeQuantizeKernelImpl<T, dtype::float16, Context>(ctx, x, scale, y);
+      DeQuantizeKernelImpl<T, dtype::float16, Context>(dev_ctx, x, scale, y);
       break;
     default:
       PADDLE_THROW(common::errors::Unavailable(