diff --git a/paddle/phi/kernels/legacy/compare_kernel.h b/paddle/phi/kernels/legacy/compare_kernel.h
index 541ec10d244da..95ea7081a1cfa 100644
--- a/paddle/phi/kernels/legacy/compare_kernel.h
+++ b/paddle/phi/kernels/legacy/compare_kernel.h
@@ -19,42 +19,42 @@ limitations under the License. */
 namespace phi {
 
 template <typename T, typename Context>
-void LessThanRawKernel(const Context& ctx,
+void LessThanRawKernel(const Context& dev_ctx,
                        const DenseTensor& x,
                        const DenseTensor& y,
                        int axis,
                        DenseTensor* out);
 
 template <typename T, typename Context>
-void LessEqualRawKernel(const Context& ctx,
+void LessEqualRawKernel(const Context& dev_ctx,
                         const DenseTensor& x,
                         const DenseTensor& y,
                         int axis,
                         DenseTensor* out);
 
 template <typename T, typename Context>
-void GreaterThanRawKernel(const Context& ctx,
+void GreaterThanRawKernel(const Context& dev_ctx,
                           const DenseTensor& x,
                           const DenseTensor& y,
                           int axis,
                           DenseTensor* out);
 
 template <typename T, typename Context>
-void GreaterEqualRawKernel(const Context& ctx,
+void GreaterEqualRawKernel(const Context& dev_ctx,
                            const DenseTensor& x,
                            const DenseTensor& y,
                            int axis,
                            DenseTensor* out);
 
 template <typename T, typename Context>
-void EqualRawKernel(const Context& ctx,
+void EqualRawKernel(const Context& dev_ctx,
                     const DenseTensor& x,
                     const DenseTensor& y,
                     int axis,
                     DenseTensor* out);
 
 template <typename T, typename Context>
-void NotEqualRawKernel(const Context& ctx,
+void NotEqualRawKernel(const Context& dev_ctx,
                        const DenseTensor& x,
                        const DenseTensor& y,
                        int axis,
diff --git a/paddle/phi/kernels/legacy/cpu/compare_kernel.cc b/paddle/phi/kernels/legacy/cpu/compare_kernel.cc
index 5b11c81f573a8..77800701c94b2 100644
--- a/paddle/phi/kernels/legacy/cpu/compare_kernel.cc
+++ b/paddle/phi/kernels/legacy/cpu/compare_kernel.cc
@@ -25,23 +25,23 @@ template <typename T,
           typename Context,
           typename Functor,
           typename InverseFunctor>
-inline void CompareRawKernelImpl(const Context& ctx,
+inline void CompareRawKernelImpl(const Context& dev_ctx,
                                  const DenseTensor& x,
                                  const DenseTensor& y,
                                  int axis,
                                  DenseTensor* out) {
-  ctx.template Alloc<bool>(out);
+  dev_ctx.template Alloc<bool>(out);
   if (x.dims().size() >= y.dims().size()) {
     funcs::ElementwiseCompute<Functor, T, bool>(
-        ctx, x, y, Functor(), out, axis);
+        dev_ctx, x, y, Functor(), out, axis);
   } else {
     funcs::ElementwiseCompute<InverseFunctor, T, bool>(
-        ctx, x, y, InverseFunctor(), out, axis);
+        dev_ctx, x, y, InverseFunctor(), out, axis);
   }
 }
 
 template <typename T, typename Context>
-void LessThanRawKernel(const Context& ctx,
+void LessThanRawKernel(const Context& dev_ctx,
                        const DenseTensor& x,
                        const DenseTensor& y,
                        int axis,
@@ -49,11 +49,11 @@ void LessThanRawKernel(const Context& ctx,
   CompareRawKernelImpl<T,
                        Context,
                        funcs::LessThanFunctor<T>,
-                       funcs::GreaterThanFunctor<T>>(ctx, x, y, axis, out);
+                       funcs::GreaterThanFunctor<T>>(dev_ctx, x, y, axis, out);
 }
 
 template <typename T, typename Context>
-void LessEqualRawKernel(const Context& ctx,
+void LessEqualRawKernel(const Context& dev_ctx,
                         const DenseTensor& x,
                         const DenseTensor& y,
                         int axis,
@@ -61,11 +61,11 @@ void LessEqualRawKernel(const Context& ctx,
   CompareRawKernelImpl<T,
                        Context,
                        funcs::LessEqualFunctor<T>,
-                       funcs::GreaterEqualFunctor<T>>(ctx, x, y, axis, out);
+                       funcs::GreaterEqualFunctor<T>>(dev_ctx, x, y, axis, out);
 }
 
 template <typename T, typename Context>
-void GreaterThanRawKernel(const Context& ctx,
+void GreaterThanRawKernel(const Context& dev_ctx,
                           const DenseTensor& x,
                           const DenseTensor& y,
                           int axis,
@@ -73,10 +73,10 @@ void GreaterThanRawKernel(const Context& ctx,
   CompareRawKernelImpl<T,
                        Context,
                        funcs::GreaterThanFunctor<T>,
-                       funcs::LessThanFunctor<T>>(ctx, x, y, axis, out);
+                       funcs::LessThanFunctor<T>>(dev_ctx, x, y, axis, out);
 }
 template <typename T, typename Context>
-void GreaterEqualRawKernel(const Context& ctx,
+void GreaterEqualRawKernel(const Context& dev_ctx,
                            const DenseTensor& x,
                            const DenseTensor& y,
                            int axis,
@@ -84,10 +84,10 @@ void GreaterEqualRawKernel(const Context& ctx,
   CompareRawKernelImpl<T,
                        Context,
                        funcs::GreaterEqualFunctor<T>,
-                       funcs::LessEqualFunctor<T>>(ctx, x, y, axis, out);
+                       funcs::LessEqualFunctor<T>>(dev_ctx, x, y, axis, out);
 }
 template <typename T, typename Context>
-void EqualRawKernel(const Context& ctx,
+void EqualRawKernel(const Context& dev_ctx,
                     const DenseTensor& x,
                     const DenseTensor& y,
                     int axis,
@@ -95,10 +95,10 @@ void EqualRawKernel(const Context& ctx,
   CompareRawKernelImpl<T,
                        Context,
                        funcs::EqualFunctor<T>,
-                       funcs::EqualFunctor<T>>(ctx, x, y, axis, out);
+                       funcs::EqualFunctor<T>>(dev_ctx, x, y, axis, out);
 }
 template <typename T, typename Context>
-void NotEqualRawKernel(const Context& ctx,
+void NotEqualRawKernel(const Context& dev_ctx,
                        const DenseTensor& x,
                        const DenseTensor& y,
                        int axis,
@@ -106,7 +106,7 @@ void NotEqualRawKernel(const Context& ctx,
   CompareRawKernelImpl<T,
                        Context,
                        funcs::NotEqualFunctor<T>,
-                       funcs::NotEqualFunctor<T>>(ctx, x, y, axis, out);
+                       funcs::NotEqualFunctor<T>>(dev_ctx, x, y, axis, out);
 }
 }  // namespace phi
 
diff --git a/paddle/phi/kernels/legacy/cpu/legacy_generate_proposals_kernel.cc b/paddle/phi/kernels/legacy/cpu/legacy_generate_proposals_kernel.cc
index 5e6249249b1ee..a77372f459202 100644
--- a/paddle/phi/kernels/legacy/cpu/legacy_generate_proposals_kernel.cc
+++ b/paddle/phi/kernels/legacy/cpu/legacy_generate_proposals_kernel.cc
@@ -28,7 +28,7 @@ namespace phi {
 
 template <typename T>
 std::pair<phi::DenseTensor, phi::DenseTensor> ProposalForOneImage(
-    const phi::CPUContext &ctx,
+    const phi::CPUContext &dev_ctx,
     const phi::DenseTensor &im_info_slice,
     const phi::DenseTensor &anchors,
     const phi::DenseTensor &variances,
@@ -44,7 +44,7 @@ std::pair<phi::DenseTensor, phi::DenseTensor> ProposalForOneImage(
   // Sort index
   phi::DenseTensor index_t;
   index_t.Resize({scores_slice.numel()});
-  int *index = ctx.Alloc<int>(&index_t);
+  int *index = dev_ctx.Alloc<int>(&index_t);
   for (int i = 0; i < scores_slice.numel(); ++i) {
     index[i] = i;
   }
@@ -65,53 +65,54 @@ std::pair<phi::DenseTensor, phi::DenseTensor> ProposalForOneImage(
   bbox_sel.Resize({index_t.numel(), 4});
   anchor_sel.Resize({index_t.numel(), 4});
   var_sel.Resize({index_t.numel(), 4});
-  ctx.Alloc<T>(&scores_sel);
-  ctx.Alloc<T>(&bbox_sel);
-  ctx.Alloc<T>(&anchor_sel);
-  ctx.Alloc<T>(&var_sel);
+  dev_ctx.Alloc<T>(&scores_sel);
+  dev_ctx.Alloc<T>(&bbox_sel);
+  dev_ctx.Alloc<T>(&anchor_sel);
+  dev_ctx.Alloc<T>(&var_sel);
 
-  phi::funcs::CPUGather<T>(ctx, scores_slice, index_t, &scores_sel);
-  phi::funcs::CPUGather<T>(ctx, bbox_deltas_slice, index_t, &bbox_sel);
-  phi::funcs::CPUGather<T>(ctx, anchors, index_t, &anchor_sel);
-  phi::funcs::CPUGather<T>(ctx, variances, index_t, &var_sel);
+  phi::funcs::CPUGather<T>(dev_ctx, scores_slice, index_t, &scores_sel);
+  phi::funcs::CPUGather<T>(dev_ctx, bbox_deltas_slice, index_t, &bbox_sel);
+  phi::funcs::CPUGather<T>(dev_ctx, anchors, index_t, &anchor_sel);
+  phi::funcs::CPUGather<T>(dev_ctx, variances, index_t, &var_sel);
 
   phi::DenseTensor proposals;
   proposals.Resize({index_t.numel(), 4});
-  ctx.Alloc<T>(&proposals);
-  phi::funcs::BoxCoder<T>(ctx, &anchor_sel, &bbox_sel, &var_sel, &proposals);
+  dev_ctx.Alloc<T>(&proposals);
+  phi::funcs::BoxCoder<T>(
+      dev_ctx, &anchor_sel, &bbox_sel, &var_sel, &proposals);
 
   phi::funcs::ClipTiledBoxes<T>(
-      ctx, im_info_slice, proposals, &proposals, false);
+      dev_ctx, im_info_slice, proposals, &proposals, false);
 
   phi::DenseTensor keep;
   phi::funcs::FilterBoxes<T>(
-      ctx, &proposals, min_size, im_info_slice, true, &keep);
+      dev_ctx, &proposals, min_size, im_info_slice, true, &keep);
   // Handle the case when there is no keep index left
   if (keep.numel() == 0) {
     phi::funcs::SetConstant<phi::CPUContext, T> set_zero;
     bbox_sel.Resize({1, 4});
-    ctx.Alloc<T>(&bbox_sel);
-    set_zero(ctx, &bbox_sel, static_cast<T>(0));
+    dev_ctx.Alloc<T>(&bbox_sel);
+    set_zero(dev_ctx, &bbox_sel, static_cast<T>(0));
     phi::DenseTensor scores_filter;
     scores_filter.Resize({1, 1});
-    ctx.Alloc<T>(&scores_filter);
-    set_zero(ctx, &scores_filter, static_cast<T>(0));
+    dev_ctx.Alloc<T>(&scores_filter);
+    set_zero(dev_ctx, &scores_filter, static_cast<T>(0));
     return std::make_pair(bbox_sel, scores_filter);
   }
 
   phi::DenseTensor scores_filter;
   bbox_sel.Resize({keep.numel(), 4});
   scores_filter.Resize({keep.numel(), 1});
-  ctx.Alloc<T>(&bbox_sel);
-  ctx.Alloc<T>(&scores_filter);
-  phi::funcs::CPUGather<T>(ctx, proposals, keep, &bbox_sel);
-  phi::funcs::CPUGather<T>(ctx, scores_sel, keep, &scores_filter);
+  dev_ctx.Alloc<T>(&bbox_sel);
+  dev_ctx.Alloc<T>(&scores_filter);
+  phi::funcs::CPUGather<T>(dev_ctx, proposals, keep, &bbox_sel);
+  phi::funcs::CPUGather<T>(dev_ctx, scores_sel, keep, &scores_filter);
   if (nms_thresh <= 0) {
     return std::make_pair(bbox_sel, scores_filter);
   }
 
   phi::DenseTensor keep_nms =
-      phi::funcs::NMS<T>(ctx, &bbox_sel, &scores_filter, nms_thresh, eta);
+      phi::funcs::NMS<T>(dev_ctx, &bbox_sel, &scores_filter, nms_thresh, eta);
 
   if (post_nms_top_n > 0 && post_nms_top_n < keep_nms.numel()) {
     keep_nms.Resize({post_nms_top_n});
@@ -119,10 +120,10 @@ std::pair<phi::DenseTensor, phi::DenseTensor> ProposalForOneImage(
 
   proposals.Resize({keep_nms.numel(), 4});
   scores_sel.Resize({keep_nms.numel(), 1});
-  ctx.Alloc<T>(&proposals);
-  ctx.Alloc<T>(&scores_sel);
-  phi::funcs::CPUGather<T>(ctx, bbox_sel, keep_nms, &proposals);
-  phi::funcs::CPUGather<T>(ctx, scores_filter, keep_nms, &scores_sel);
+  dev_ctx.Alloc<T>(&proposals);
+  dev_ctx.Alloc<T>(&scores_sel);
+  phi::funcs::CPUGather<T>(dev_ctx, bbox_sel, keep_nms, &proposals);
+  phi::funcs::CPUGather<T>(dev_ctx, scores_filter, keep_nms, &scores_sel);
 
   return std::make_pair(proposals, scores_sel);
 }
diff --git a/paddle/phi/kernels/legacy/cpu/one_hot_kernel.cc b/paddle/phi/kernels/legacy/cpu/one_hot_kernel.cc
index 85347e71c606f..d475c5fec98d9 100644
--- a/paddle/phi/kernels/legacy/cpu/one_hot_kernel.cc
+++ b/paddle/phi/kernels/legacy/cpu/one_hot_kernel.cc
@@ -25,20 +25,20 @@ struct OneHotV2OpFunctor {
   const DenseTensor* in_;
   DenseTensor* out_;
   int depth_;
-  const DeviceContext& ctx_;
+  const DeviceContext& dev_ctx_;
 
   OneHotV2OpFunctor(const DenseTensor* in,
                     DenseTensor* out,
                     int depth,
-                    const DeviceContext& ctx)
-      : in_(in), out_(out), depth_(depth), ctx_(ctx) {}
+                    const DeviceContext& dev_ctx)
+      : in_(in), out_(out), depth_(depth), dev_ctx_(dev_ctx) {}
 
   template <typename OutT>
   void apply() const {
     auto* p_in_data = in_->data<InT>();
     auto numel = in_->numel();
-    auto* p_out_data = ctx_.template Alloc<OutT>(out_);
-    funcs::set_constant(ctx_, out_, 0.0);
+    auto* p_out_data = dev_ctx_.template Alloc<OutT>(out_);
+    funcs::set_constant(dev_ctx_, out_, 0.0);
 
     for (int i = 0; i < numel; ++i) {
       PADDLE_ENFORCE_GE(
diff --git a/paddle/phi/kernels/legacy/gpu/layer_norm_cuda_kernel.h b/paddle/phi/kernels/legacy/gpu/layer_norm_cuda_kernel.h
index 39bd2837b9e45..f6d81228b34b6 100644
--- a/paddle/phi/kernels/legacy/gpu/layer_norm_cuda_kernel.h
+++ b/paddle/phi/kernels/legacy/gpu/layer_norm_cuda_kernel.h
@@ -943,7 +943,7 @@ void HostApplyRMSNorm(V* output,
 }
 
 template <typename T, typename Context>
-void cuda_rms_norm(const Context& ctx,
+void cuda_rms_norm(const Context& dev_ctx,
                    const DenseTensor& x,
                    const DenseTensor& scale,
                    int rows,
@@ -960,7 +960,7 @@ void cuda_rms_norm(const Context& ctx,
       cols,                                                  \
       epsilon,                                               \
       const_cast<scalar_t_out*>(scale.data<scalar_t_out>()), \
-      ctx.stream())
+      dev_ctx.stream())
   // scale.dtype() same as y->dtype()
   if (scale.dtype() == phi::DataType::FLOAT32) {
     DISPATCH_FWD_CASE(float);
@@ -971,7 +971,7 @@ void cuda_rms_norm(const Context& ctx,
 }
 
 template <typename T, typename U, typename V, typename Context>
-void HostRMSNormGradient(const Context& ctx,
+void HostRMSNormGradient(const Context& dev_ctx,
                          const V* dout,
                          const U* invvar,
                          const DenseTensor& input,
@@ -992,7 +992,7 @@ void HostRMSNormGradient(const Context& ctx,
     const int nshared2 = nshared2_a > nshared2_b ? nshared2_a : nshared2_b;
     auto place = input.place();
     DenseTensor part_grad_gamma =
-        phi::Empty<float, Context>(ctx, {part_size, n2});
+        phi::Empty<float, Context>(dev_ctx, {part_size, n2});
     cuComputePartGradGammaBeta<<<blocks2, threads2, nshared2, stream>>>(
         dout,
         input.data<T>(),
@@ -1038,7 +1038,7 @@ void HostRMSNormGradient(const Context& ctx,
 }
 
 template <typename T, typename Context>
-void cuda_rms_norm_gradient(const Context& ctx,
+void cuda_rms_norm_gradient(const Context& dev_ctx,
                             const DenseTensor& x,
                             const DenseTensor& scale,
                             const DenseTensor& invvar,
@@ -1050,7 +1050,7 @@ void cuda_rms_norm_gradient(const Context& ctx,
                             DenseTensor* grad_scale) {
 #define DISPATCH_BWD_CASE(scalar_t_out)                 \
   HostRMSNormGradient<T, float, scalar_t_out, Context>( \
-      ctx,                                              \
+      dev_ctx,                                          \
       dy.data<scalar_t_out>(),                          \
       invvar.data<float>(),                             \
       x,                                                \
@@ -1060,7 +1060,7 @@ void cuda_rms_norm_gradient(const Context& ctx,
       epsilon,                                          \
       grad_x->data<T>(),                                \
       grad_scale->data<scalar_t_out>(),                 \
-      ctx.stream())
+      dev_ctx.stream())
   if (scale.dtype() == phi::DataType::FLOAT32) {
     DISPATCH_BWD_CASE(float);
   } else if (scale.dtype() == phi::DataType::BFLOAT16) {
diff --git a/paddle/phi/kernels/legacy/gpu/legacy_generate_proposals_kernel.cu b/paddle/phi/kernels/legacy/gpu/legacy_generate_proposals_kernel.cu
index c7630a3717a41..90e1a9f1c498a 100644
--- a/paddle/phi/kernels/legacy/gpu/legacy_generate_proposals_kernel.cu
+++ b/paddle/phi/kernels/legacy/gpu/legacy_generate_proposals_kernel.cu
@@ -30,7 +30,7 @@ namespace phi {
 namespace {
 template <typename T>
 static std::pair<phi::DenseTensor, phi::DenseTensor> ProposalForOneImage(
-    const phi::GPUContext &ctx,
+    const phi::GPUContext &dev_ctx,
     const phi::DenseTensor &im_info,
     const phi::DenseTensor &anchors,
     const phi::DenseTensor &variances,
@@ -43,7 +43,7 @@ static std::pair<phi::DenseTensor, phi::DenseTensor> ProposalForOneImage(
     float eta) {
   // 1. pre nms
   phi::DenseTensor scores_sort, index_sort;
-  phi::funcs::SortDescending<T>(ctx, scores, &scores_sort, &index_sort);
+  phi::funcs::SortDescending<T>(dev_ctx, scores, &scores_sort, &index_sort);
   int num = scores.numel();
   int pre_nms_num = (pre_nms_top_n <= 0 || pre_nms_top_n > num) ? scores.numel()
                                                                 : pre_nms_top_n;
@@ -53,10 +53,10 @@ static std::pair<phi::DenseTensor, phi::DenseTensor> ProposalForOneImage(
   // 2. box decode and clipping
   phi::DenseTensor proposals;
   proposals.Resize({pre_nms_num, 4});
-  ctx.Alloc<T>(&proposals);
+  dev_ctx.Alloc<T>(&proposals);
 
   {
-    phi::funcs::ForRange<phi::GPUContext> for_range(ctx, pre_nms_num);
+    phi::funcs::ForRange<phi::GPUContext> for_range(dev_ctx, pre_nms_num);
     for_range(phi::funcs::BoxDecodeAndClipFunctor<T>{anchors.data<T>(),
                                                      bbox_deltas.data<T>(),
                                                      variances.data<T>(),
@@ -69,10 +69,10 @@ static std::pair<phi::DenseTensor, phi::DenseTensor> ProposalForOneImage(
   phi::DenseTensor keep_index, keep_num_t;
   keep_index.Resize({pre_nms_num});
   keep_num_t.Resize({1});
-  ctx.Alloc<int>(&keep_index);
-  ctx.Alloc<int>(&keep_num_t);
+  dev_ctx.Alloc<int>(&keep_index);
+  dev_ctx.Alloc<int>(&keep_num_t);
   min_size = std::max(min_size, 1.0f);
-  auto stream = ctx.stream();
+  auto stream = dev_ctx.stream();
   phi::funcs::FilterBBoxes<T, 512>
       <<<1, 512, 0, stream>>>(proposals.data<T>(),
                               im_info.data<T>(),
@@ -81,14 +81,14 @@ static std::pair<phi::DenseTensor, phi::DenseTensor> ProposalForOneImage(
                               keep_num_t.data<int>(),
                               keep_index.data<int>());
   int keep_num;
-  const auto gpu_place = ctx.GetPlace();
+  const auto gpu_place = dev_ctx.GetPlace();
   phi::memory_utils::Copy(phi::CPUPlace(),
                           &keep_num,
                           gpu_place,
                           keep_num_t.data<int>(),
                           sizeof(int),
-                          ctx.stream());
-  ctx.Wait();
+                          dev_ctx.stream());
+  dev_ctx.Wait();
   keep_index.Resize({keep_num});
 
   phi::DenseTensor scores_filter, proposals_filter;
@@ -97,18 +97,18 @@ static std::pair<phi::DenseTensor, phi::DenseTensor> ProposalForOneImage(
     phi::funcs::SetConstant<phi::GPUContext, T> set_zero;
     proposals_filter.Resize({1, 4});
     scores_filter.Resize({1, 1});
-    ctx.Alloc<T>(&proposals_filter);
-    ctx.Alloc<T>(&scores_filter);
-    set_zero(ctx, &proposals_filter, static_cast<T>(0));
-    set_zero(ctx, &scores_filter, static_cast<T>(0));
+    dev_ctx.Alloc<T>(&proposals_filter);
+    dev_ctx.Alloc<T>(&scores_filter);
+    set_zero(dev_ctx, &proposals_filter, static_cast<T>(0));
+    set_zero(dev_ctx, &scores_filter, static_cast<T>(0));
     return std::make_pair(proposals_filter, scores_filter);
   }
   proposals_filter.Resize({keep_num, 4});
   scores_filter.Resize({keep_num, 1});
-  ctx.Alloc<T>(&proposals_filter);
-  ctx.Alloc<T>(&scores_filter);
-  phi::funcs::GPUGather<T>(ctx, proposals, keep_index, &proposals_filter);
-  phi::funcs::GPUGather<T>(ctx, scores_sort, keep_index, &scores_filter);
+  dev_ctx.Alloc<T>(&proposals_filter);
+  dev_ctx.Alloc<T>(&scores_filter);
+  phi::funcs::GPUGather<T>(dev_ctx, proposals, keep_index, &proposals_filter);
+  phi::funcs::GPUGather<T>(dev_ctx, scores_sort, keep_index, &scores_filter);
 
   if (nms_thresh <= 0) {
     return std::make_pair(proposals_filter, scores_filter);
@@ -116,7 +116,8 @@ static std::pair<phi::DenseTensor, phi::DenseTensor> ProposalForOneImage(
 
   // 4. nms
   phi::DenseTensor keep_nms;
-  phi::funcs::NMS<T>(ctx, proposals_filter, keep_index, nms_thresh, &keep_nms);
+  phi::funcs::NMS<T>(
+      dev_ctx, proposals_filter, keep_index, nms_thresh, &keep_nms);
   if (post_nms_top_n > 0 && post_nms_top_n < keep_nms.numel()) {
     keep_nms.Resize({post_nms_top_n});
   }
@@ -124,10 +125,10 @@ static std::pair<phi::DenseTensor, phi::DenseTensor> ProposalForOneImage(
   phi::DenseTensor scores_nms, proposals_nms;
   proposals_nms.Resize({keep_nms.numel(), 4});
   scores_nms.Resize({keep_nms.numel(), 1});
-  ctx.Alloc<T>(&proposals_nms);
-  ctx.Alloc<T>(&scores_nms);
-  phi::funcs::GPUGather<T>(ctx, proposals_filter, keep_nms, &proposals_nms);
-  phi::funcs::GPUGather<T>(ctx, scores_filter, keep_nms, &scores_nms);
+  dev_ctx.Alloc<T>(&proposals_nms);
+  dev_ctx.Alloc<T>(&scores_nms);
+  phi::funcs::GPUGather<T>(dev_ctx, proposals_filter, keep_nms, &proposals_nms);
+  phi::funcs::GPUGather<T>(dev_ctx, scores_filter, keep_nms, &scores_nms);
 
   return std::make_pair(proposals_nms, scores_nms);
 }
diff --git a/paddle/phi/kernels/legacy/gpu/one_hot_kernel.cu b/paddle/phi/kernels/legacy/gpu/one_hot_kernel.cu
index c64f2e2d75566..8030231e7fa02 100644
--- a/paddle/phi/kernels/legacy/gpu/one_hot_kernel.cu
+++ b/paddle/phi/kernels/legacy/gpu/one_hot_kernel.cu
@@ -44,24 +44,24 @@ template <typename DeviceContext, typename InT>
 struct OneHotV2OpCUDAFunctor {
   const DenseTensor* in_;
   DenseTensor* out_;
-  const DeviceContext& ctx_;
+  const DeviceContext& dev_ctx_;
   int depth_;
 
   OneHotV2OpCUDAFunctor(const DenseTensor* in,
                         DenseTensor* out,
                         int depth,
-                        const DeviceContext& ctx)
-      : in_(in), out_(out), depth_(depth), ctx_(ctx) {}
+                        const DeviceContext& dev_ctx)
+      : in_(in), out_(out), depth_(depth), dev_ctx_(dev_ctx) {}
 
   template <typename OutT>
   void apply() const {
     auto* p_in_data = in_->data<InT>();
     auto numel = in_->numel();
-    auto* p_out_data = ctx_.template Alloc<OutT>(out_);
-    auto stream = ctx_.stream();
-    funcs::set_constant(ctx_, out_, 0.0);
+    auto* p_out_data = dev_ctx_.template Alloc<OutT>(out_);
+    auto stream = dev_ctx_.stream();
+    funcs::set_constant(dev_ctx_, out_, 0.0);
 
-    auto config = phi::backends::gpu::GetGpuLaunchConfig1D(ctx_, numel);
+    auto config = phi::backends::gpu::GetGpuLaunchConfig1D(dev_ctx_, numel);
 
     FillOutputKernel<<<config.block_per_grid,
                        config.thread_per_block,
diff --git a/paddle/phi/kernels/legacy/kps/compare_kernel.cu b/paddle/phi/kernels/legacy/kps/compare_kernel.cu
index c3aaea92ead2d..5f4b4ebf1f304 100644
--- a/paddle/phi/kernels/legacy/kps/compare_kernel.cu
+++ b/paddle/phi/kernels/legacy/kps/compare_kernel.cu
@@ -34,77 +34,77 @@
 namespace phi {
 
 template <typename T, typename Context, typename Functor>
-inline void CompareRawKernelImpl(const Context& ctx,
+inline void CompareRawKernelImpl(const Context& dev_ctx,
                                  const DenseTensor& x,
                                  const DenseTensor& y,
                                  int axis,
                                  DenseTensor* out) {
-  ctx.template Alloc<bool>(out);
+  dev_ctx.template Alloc<bool>(out);
   out->set_type(phi::DataType::BOOL);
   if (out->numel() == 0) return;
   std::vector<const DenseTensor*> ins{&x, &y};
   std::vector<DenseTensor*> outs{out};
-  funcs::BroadcastKernel<bool>(ctx, ins, &outs, Functor(), axis);
+  funcs::BroadcastKernel<bool>(dev_ctx, ins, &outs, Functor(), axis);
 }
 
 template <typename T, typename Context>
-void LessThanRawKernel(const Context& ctx,
+void LessThanRawKernel(const Context& dev_ctx,
                        const DenseTensor& x,
                        const DenseTensor& y,
                        int axis,
                        DenseTensor* out) {
   CompareRawKernelImpl<T, Context, funcs::LessThanFunctor<T>>(
-      ctx, x, y, axis, out);
+      dev_ctx, x, y, axis, out);
 }
 
 template <typename T, typename Context>
-void LessEqualRawKernel(const Context& ctx,
+void LessEqualRawKernel(const Context& dev_ctx,
                         const DenseTensor& x,
                         const DenseTensor& y,
                         int axis,
                         DenseTensor* out) {
   CompareRawKernelImpl<T, Context, funcs::LessEqualFunctor<T>>(
-      ctx, x, y, axis, out);
+      dev_ctx, x, y, axis, out);
 }
 
 template <typename T, typename Context>
-void GreaterThanRawKernel(const Context& ctx,
+void GreaterThanRawKernel(const Context& dev_ctx,
                           const DenseTensor& x,
                           const DenseTensor& y,
                           int axis,
                           DenseTensor* out) {
   CompareRawKernelImpl<T, Context, funcs::GreaterThanFunctor<T>>(
-      ctx, x, y, axis, out);
+      dev_ctx, x, y, axis, out);
 }
 
 template <typename T, typename Context>
-void GreaterEqualRawKernel(const Context& ctx,
+void GreaterEqualRawKernel(const Context& dev_ctx,
                            const DenseTensor& x,
                            const DenseTensor& y,
                            int axis,
                            DenseTensor* out) {
   CompareRawKernelImpl<T, Context, funcs::GreaterEqualFunctor<T>>(
-      ctx, x, y, axis, out);
+      dev_ctx, x, y, axis, out);
 }
 
 template <typename T, typename Context>
-void EqualRawKernel(const Context& ctx,
+void EqualRawKernel(const Context& dev_ctx,
                     const DenseTensor& x,
                     const DenseTensor& y,
                     int axis,
                     DenseTensor* out) {
   CompareRawKernelImpl<T, Context, funcs::EqualFunctor<T>>(
-      ctx, x, y, axis, out);
+      dev_ctx, x, y, axis, out);
 }
 
 template <typename T, typename Context>
-void NotEqualRawKernel(const Context& ctx,
+void NotEqualRawKernel(const Context& dev_ctx,
                        const DenseTensor& x,
                        const DenseTensor& y,
                        int axis,
                        DenseTensor* out) {
   CompareRawKernelImpl<T, Context, funcs::NotEqualFunctor<T>>(
-      ctx, x, y, axis, out);
+      dev_ctx, x, y, axis, out);
 }
 
 }  // namespace phi
diff --git a/paddle/phi/kernels/legacy/xpu/compare_kernel.cc b/paddle/phi/kernels/legacy/xpu/compare_kernel.cc
index 3d461517ac6f2..4253b86915d45 100644
--- a/paddle/phi/kernels/legacy/xpu/compare_kernel.cc
+++ b/paddle/phi/kernels/legacy/xpu/compare_kernel.cc
@@ -61,13 +61,13 @@ void XPUCompareRawKernelImpl(
                        int axis,                                         \
                        DenseTensor* out) {                               \
     using XPUType = typename XPUTypeTrait<T>::Type;                      \
-    auto f = [](xpu::Context* ctx,                                       \
+    auto f = [](xpu::Context* xpu_ctx,                                   \
                 const XPUType* x,                                        \
                 const XPUType* y,                                        \
                 bool* z,                                                 \
                 const std::vector<int64_t>& xshape,                      \
                 const std::vector<int64_t>& yshape) {                    \
-      return functor(ctx, x, y, z, xshape, yshape);                      \
+      return functor(xpu_ctx, x, y, z, xshape, yshape);                  \
     };                                                                   \
     XPUCompareRawKernelImpl<T, XPUType, Context>(dev_ctx, x, y, out, f); \
   }
diff --git a/paddle/phi/kernels/legacy/xpu/elementwise_add_kernel.cc b/paddle/phi/kernels/legacy/xpu/elementwise_add_kernel.cc
index 2ca79cd26160b..b3a891f280f66 100644
--- a/paddle/phi/kernels/legacy/xpu/elementwise_add_kernel.cc
+++ b/paddle/phi/kernels/legacy/xpu/elementwise_add_kernel.cc
@@ -36,13 +36,13 @@ void AddRawKernel(const Context& dev_ctx,
                   DenseTensor* out) {
   using XPUType = typename XPUTypeTrait<T>::Type;
 
-  auto f = [](xpu::Context* ctx,
+  auto f = [](xpu::Context* xpu_ctx,
               const XPUType* x,
               const XPUType* y,
               XPUType* z,
               const std::vector<int64_t>& xshape,
               const std::vector<int64_t>& yshape) {
-    return xpu::broadcast_add<XPUType>(ctx, x, y, z, xshape, yshape);
+    return xpu::broadcast_add<XPUType>(xpu_ctx, x, y, z, xshape, yshape);
   };
 
   XPUElementwise<T, XPUType>(dev_ctx, x, y, axis, out, f);
diff --git a/paddle/phi/kernels/legacy/xpu/elementwise_divide_kernel.cc b/paddle/phi/kernels/legacy/xpu/elementwise_divide_kernel.cc
index 3fed6a52fdff4..d87bf7362581b 100644
--- a/paddle/phi/kernels/legacy/xpu/elementwise_divide_kernel.cc
+++ b/paddle/phi/kernels/legacy/xpu/elementwise_divide_kernel.cc
@@ -31,13 +31,13 @@ void DivideRawKernel(const Context& dev_ctx,
                      int axis,
                      DenseTensor* out) {
   using XPUType = typename XPUTypeTrait<T>::Type;
-  auto f = [](xpu::Context* ctx,
+  auto f = [](xpu::Context* xpu_ctx,
               const XPUType* x,
               const XPUType* y,
               XPUType* z,
               const std::vector<int64_t>& xshape,
               const std::vector<int64_t>& yshape) {
-    return xpu::broadcast_div<XPUType>(ctx, x, y, z, xshape, yshape);
+    return xpu::broadcast_div<XPUType>(xpu_ctx, x, y, z, xshape, yshape);
   };
 
   XPUElementwise<T, XPUType>(dev_ctx, x, y, axis, out, f);
diff --git a/paddle/phi/kernels/legacy/xpu/elementwise_kernel.cc b/paddle/phi/kernels/legacy/xpu/elementwise_kernel.cc
index 0825014319dfe..ce9aa48b883b2 100644
--- a/paddle/phi/kernels/legacy/xpu/elementwise_kernel.cc
+++ b/paddle/phi/kernels/legacy/xpu/elementwise_kernel.cc
@@ -31,13 +31,13 @@ void MaximumRawKernel(const Context& dev_ctx,
   }
 
   using XPUType = typename XPUTypeTrait<T>::Type;
-  auto f = [](xpu::Context* ctx,
+  auto f = [](xpu::Context* xpu_ctx,
               const XPUType* x,
               const XPUType* y,
               XPUType* z,
               const std::vector<int64_t>& xshape,
               const std::vector<int64_t>& yshape) {
-    return xpu::broadcast_max<XPUType>(ctx, x, y, z, xshape, yshape);
+    return xpu::broadcast_max<XPUType>(xpu_ctx, x, y, z, xshape, yshape);
   };
 
   XPUElementwise<T, XPUType>(dev_ctx, x, y, axis, out, f);
@@ -55,13 +55,13 @@ void MinimumRawKernel(const Context& dev_ctx,
   }
 
   using XPUType = typename XPUTypeTrait<T>::Type;
-  auto f = [](xpu::Context* ctx,
+  auto f = [](xpu::Context* xpu_ctx,
               const XPUType* x,
               const XPUType* y,
               XPUType* z,
               const std::vector<int64_t>& xshape,
               const std::vector<int64_t>& yshape) {
-    return xpu::broadcast_min<XPUType>(ctx, x, y, z, xshape, yshape);
+    return xpu::broadcast_min<XPUType>(xpu_ctx, x, y, z, xshape, yshape);
   };
 
   XPUElementwise<T, XPUType>(dev_ctx, x, y, axis, out, f);
@@ -74,13 +74,13 @@ void RemainderRawKernel(const Context& dev_ctx,
                         int axis,
                         DenseTensor* out) {
   using XPUType = typename XPUTypeTrait<T>::Type;
-  auto f = [](xpu::Context* ctx,
+  auto f = [](xpu::Context* xpu_ctx,
               const XPUType* x,
               const XPUType* y,
               XPUType* z,
               const std::vector<int64_t>& xshape,
               const std::vector<int64_t>& yshape) {
-    return xpu::broadcast_mod<XPUType>(ctx, x, y, z, xshape, yshape);
+    return xpu::broadcast_mod<XPUType>(xpu_ctx, x, y, z, xshape, yshape);
   };
 
   XPUElementwise<T, XPUType>(dev_ctx, x, y, axis, out, f);
@@ -93,13 +93,13 @@ void FloorDivideRawKernel(const Context& dev_ctx,
                           int axis,
                           DenseTensor* out) {
   using XPUType = typename XPUTypeTrait<T>::Type;
-  auto f = [](xpu::Context* ctx,
+  auto f = [](xpu::Context* xpu_ctx,
               const XPUType* x,
               const XPUType* y,
               XPUType* z,
               const std::vector<int64_t>& xshape,
               const std::vector<int64_t>& yshape) {
-    return xpu::broadcast_floordiv<XPUType>(ctx, x, y, z, xshape, yshape);
+    return xpu::broadcast_floordiv<XPUType>(xpu_ctx, x, y, z, xshape, yshape);
   };
 
   XPUElementwise<T, XPUType>(dev_ctx, x, y, axis, out, f);
@@ -112,13 +112,13 @@ void ElementwisePowRawKernel(const Context& dev_ctx,
                              int axis,
                              DenseTensor* out) {
   using XPUType = typename XPUTypeTrait<T>::Type;
-  auto f = [](xpu::Context* ctx,
+  auto f = [](xpu::Context* xpu_ctx,
               const XPUType* x,
               const XPUType* y,
               XPUType* z,
               const std::vector<int64_t>& xshape,
               const std::vector<int64_t>& yshape) {
-    return xpu::broadcast_pow<XPUType>(ctx, x, y, z, xshape, yshape);
+    return xpu::broadcast_pow<XPUType>(xpu_ctx, x, y, z, xshape, yshape);
   };
 
   XPUElementwise<T, XPUType>(dev_ctx, x, y, axis, out, f);
diff --git a/paddle/phi/kernels/legacy/xpu/elementwise_multiply_kernel.cc b/paddle/phi/kernels/legacy/xpu/elementwise_multiply_kernel.cc
index d64499498ae8b..e3cf1e7f377f2 100644
--- a/paddle/phi/kernels/legacy/xpu/elementwise_multiply_kernel.cc
+++ b/paddle/phi/kernels/legacy/xpu/elementwise_multiply_kernel.cc
@@ -31,13 +31,13 @@ void MultiplyRawKernel(const Context& dev_ctx,
                        int axis,
                        DenseTensor* out) {
   using XPUType = typename XPUTypeTrait<T>::Type;
-  auto f = [](xpu::Context* ctx,
+  auto f = [](xpu::Context* xpu_ctx,
               const XPUType* x,
               const XPUType* y,
               XPUType* z,
               const std::vector<int64_t>& xshape,
               const std::vector<int64_t>& yshape) {
-    return xpu::broadcast_mul<XPUType>(ctx, x, y, z, xshape, yshape);
+    return xpu::broadcast_mul<XPUType>(xpu_ctx, x, y, z, xshape, yshape);
   };
 
   XPUElementwise<T, XPUType>(dev_ctx, x, y, axis, out, f);
diff --git a/paddle/phi/kernels/legacy/xpu/elementwise_subtract_kernel.cc b/paddle/phi/kernels/legacy/xpu/elementwise_subtract_kernel.cc
index bf5ea1381965f..231b84a8dd91a 100644
--- a/paddle/phi/kernels/legacy/xpu/elementwise_subtract_kernel.cc
+++ b/paddle/phi/kernels/legacy/xpu/elementwise_subtract_kernel.cc
@@ -26,13 +26,13 @@ void SubtractRawKernel(const Context& dev_ctx,
                        int axis,
                        DenseTensor* out) {
   using XPUType = typename XPUTypeTrait<T>::Type;
-  auto f = [](xpu::Context* ctx,
+  auto f = [](xpu::Context* xpu_ctx,
               const XPUType* x,
               const XPUType* y,
               XPUType* z,
               const std::vector<int64_t>& xshape,
               const std::vector<int64_t>& yshape) {
-    return xpu::broadcast_sub<XPUType>(ctx, x, y, z, xshape, yshape);
+    return xpu::broadcast_sub<XPUType>(xpu_ctx, x, y, z, xshape, yshape);
   };
 
   phi::XPUElementwise<T, XPUType>(dev_ctx, x, y, axis, out, f);
diff --git a/paddle/phi/kernels/legacy/xpu/one_hot_kernel.cc b/paddle/phi/kernels/legacy/xpu/one_hot_kernel.cc
index 02edbd128430b..76903f89660e7 100644
--- a/paddle/phi/kernels/legacy/xpu/one_hot_kernel.cc
+++ b/paddle/phi/kernels/legacy/xpu/one_hot_kernel.cc
@@ -25,21 +25,21 @@ struct OneHotV2OpFunctor {
   const DenseTensor* in_;
   DenseTensor* out_;
   int depth_;
-  const Context& ctx_;
+  const Context& dev_ctx_;
 
   OneHotV2OpFunctor(const DenseTensor* in,
                     DenseTensor* out,
                     int depth,
-                    const Context& ctx)
-      : in_(in), out_(out), depth_(depth), ctx_(ctx) {}
+                    const Context& dev_ctx)
+      : in_(in), out_(out), depth_(depth), dev_ctx_(dev_ctx) {}
 
   template <typename OutT>
   void apply() const {
     auto* p_in_data = in_->data<InT>();
     auto numel = in_->numel();
-    auto* p_out_data = ctx_.template Alloc<float>(out_);
+    auto* p_out_data = dev_ctx_.template Alloc<float>(out_);
     int r = xpu::one_hot<InT>(
-        ctx_.x_context(), p_in_data, p_out_data, numel, depth_, 1.0, 0.0);
+        dev_ctx_.x_context(), p_in_data, p_out_data, numel, depth_, 1.0, 0.0);
     PADDLE_ENFORCE_XDNN_SUCCESS(r, "one_hot");
   }
 };
diff --git a/paddle/phi/kernels/legacy/xpu/reduce_max_kernel.cc b/paddle/phi/kernels/legacy/xpu/reduce_max_kernel.cc
index 4cb8d9d043924..8c5881603e2e6 100644
--- a/paddle/phi/kernels/legacy/xpu/reduce_max_kernel.cc
+++ b/paddle/phi/kernels/legacy/xpu/reduce_max_kernel.cc
@@ -30,12 +30,12 @@ void MaxRawKernel(const Context& dev_ctx,
                   DenseTensor* out) {
   reduce_all = recompute_reduce_all(x, dims, reduce_all);
   using XPUType = typename XPUTypeTrait<T>::Type;
-  auto f = [](xpu::Context* ctx,
+  auto f = [](xpu::Context* xpu_ctx,
               const T* x,
               T* y,
               const std::vector<int64_t>& xdims,
               const std::vector<int64_t>& reduce_dims) {
-    return xpu::reduce_max<XPUType>(ctx,
+    return xpu::reduce_max<XPUType>(xpu_ctx,
                                     reinterpret_cast<const XPUType*>(x),
                                     reinterpret_cast<XPUType*>(y),
                                     xdims,
diff --git a/paddle/phi/kernels/stride/index_select_kernel.cc b/paddle/phi/kernels/stride/index_select_kernel.cc
index 0f3a8aae1e4e7..6db84f5c89180 100644
--- a/paddle/phi/kernels/stride/index_select_kernel.cc
+++ b/paddle/phi/kernels/stride/index_select_kernel.cc
@@ -25,7 +25,7 @@ COMMON_DECLARE_bool(use_stride_kernel);
 namespace phi {
 
 template <typename Context>
-void IndexSelectStridedKernel(const Context& ctx,
+void IndexSelectStridedKernel(const Context& dev_ctx,
                               const DenseTensor& x,
                               int64_t index,
                               int dim,
diff --git a/paddle/phi/kernels/stride/slice_kernel.cc b/paddle/phi/kernels/stride/slice_kernel.cc
index fe65a002b67df..bff461867c37d 100644
--- a/paddle/phi/kernels/stride/slice_kernel.cc
+++ b/paddle/phi/kernels/stride/slice_kernel.cc
@@ -26,7 +26,7 @@ COMMON_DECLARE_bool(use_stride_kernel);
 namespace phi {
 
 template <typename Context>
-void SliceStridedKernel(const Context& ctx,
+void SliceStridedKernel(const Context& dev_ctx,
                         const DenseTensor& input,
                         const std::vector<int64_t>& axes,
                         const IntArray& starts_arr,
diff --git a/paddle/phi/kernels/stride/transpose_kernel.cc b/paddle/phi/kernels/stride/transpose_kernel.cc
index aaa4773f60808..a5d627c461326 100644
--- a/paddle/phi/kernels/stride/transpose_kernel.cc
+++ b/paddle/phi/kernels/stride/transpose_kernel.cc
@@ -22,7 +22,7 @@ COMMON_DECLARE_bool(use_stride_kernel);
 namespace phi {
 
 template <typename Context>
-void TransposeStridedKernel(const Context& ctx,
+void TransposeStridedKernel(const Context& dev_ctx,
                             const DenseTensor& x,
                             const std::vector<int>& axis,
                             DenseTensor* out) {