Replace platform::XPUDeviceContext phi::XPUContext (#64065)

co63oc · web-flow · commit d8f4cb0a0809 · 2024-05-09T14:28:20.000+08:00
* Fix

* ci
diff --git a/paddle/fluid/operators/activation_op.kps b/paddle/fluid/operators/activation_op.kps
diff --git a/paddle/fluid/operators/collective/c_allgather_op_xpu.cc b/paddle/fluid/operators/collective/c_allgather_op_xpu.cc
@@ -94,9 +94,7 @@ class CAllGatherOpXPUKernel : public framework::OpKernel<T> {
 
     if (ctx.Attr<bool>("use_calc_stream")) {
       auto dev_ctx = platform::DeviceContextPool::Instance().Get(place);
-      stream = static_cast<platform::XPUDeviceContext*>(dev_ctx)
-                   ->x_context()
-                   ->xpu_stream;
+      stream = static_cast<phi::XPUContext*>(dev_ctx)->x_context()->xpu_stream;
     }
 
     if (comm_ctx) {
diff --git a/paddle/fluid/operators/collective/c_allreduce_op.h b/paddle/fluid/operators/collective/c_allreduce_op.h
@@ -238,9 +238,7 @@ class CAllReduceOpXPUKernel : public framework::OpKernel<T> {
     }
     if (ctx.Attr<bool>("use_calc_stream")) {
       auto dev_ctx = platform::DeviceContextPool::Instance().Get(place);
-      stream = static_cast<platform::XPUDeviceContext*>(dev_ctx)
-                   ->x_context()
-                   ->xpu_stream;
+      stream = static_cast<phi::XPUContext*>(dev_ctx)->x_context()->xpu_stream;
     }
 
     BKCLOp bkcl_red_type = BKCL_ADD;
diff --git a/paddle/fluid/operators/collective/c_allreduce_sum_op.kps b/paddle/fluid/operators/collective/c_allreduce_sum_op.kps
@@ -38,7 +38,7 @@ namespace plat = paddle::platform;
 
 REGISTER_OP_KERNEL(c_allreduce_sum,
                    KP,
-                   plat::XPUPlace,
+                   phi::XPUPlace,
                    ops::CAllReduceOpXPUKernel<ops::kRedSum, float>);
 
 #endif
diff --git a/paddle/fluid/operators/collective/c_broadcast_op_xpu.cc b/paddle/fluid/operators/collective/c_broadcast_op_xpu.cc
@@ -73,9 +73,7 @@ class CBroadcastOpXPUKernel : public framework::OpKernel<T> {
     }
     if (ctx.Attr<bool>("use_calc_stream")) {
       auto dev_ctx = platform::DeviceContextPool::Instance().Get(place);
-      stream = static_cast<platform::XPUDeviceContext*>(dev_ctx)
-                   ->x_context()
-                   ->xpu_stream;
+      stream = static_cast<phi::XPUContext*>(dev_ctx)->x_context()->xpu_stream;
     }
     if (comm_ctx) {
       comm_ctx->Broadcast(out, *x, root, stream);
@@ -101,8 +99,7 @@ class CBroadcastOpXPUKernel : public framework::OpKernel<T> {
               static_cast<phi::DenseTensor*>(out));
         }
       } else {
-        auto& dev_ctx =
-            ctx.template device_context<platform::XPUDeviceContext>();
+        auto& dev_ctx = ctx.template device_context<phi::XPUContext>();
         dev_ctx.template Alloc<T>(out);
         send_recv_buffer = out->data<T>();
         PADDLE_ENFORCE_XPU_SUCCESS(bkcl_broadcast(comm->comm(),
diff --git a/paddle/fluid/operators/collective/c_reduce_op.h b/paddle/fluid/operators/collective/c_reduce_op.h
@@ -181,9 +181,7 @@ class CReduceOpXPUKernel : public framework::OpKernel<T> {
     }
     if (ctx.Attr<bool>("use_calc_stream")) {
       auto dev_ctx = platform::DeviceContextPool::Instance().Get(place);
-      stream = static_cast<platform::XPUDeviceContext*>(dev_ctx)
-                   ->x_context()
-                   ->xpu_stream;
+      stream = static_cast<phi::XPUContext*>(dev_ctx)->x_context()->xpu_stream;
     }
 
     BKCLOp bkcl_red_type = BKCL_ADD;
diff --git a/paddle/fluid/operators/collective/c_sync_calc_stream_op.h b/paddle/fluid/operators/collective/c_sync_calc_stream_op.h
@@ -54,7 +54,7 @@ class CSyncCalcStreamKernel : public framework::OpKernel<T> {
                       phi::errors::PreconditionNotMet(
                           "Sync stream op can run on xpu place only for now."));
 
-    auto dev_ctx = static_cast<platform::XPUDeviceContext*>(
+    auto dev_ctx = static_cast<phi::XPUContext*>(
         platform::DeviceContextPool::Instance().Get(place));
     dev_ctx->Wait();
 #else
diff --git a/paddle/fluid/operators/collective/c_sync_calc_stream_op.kps b/paddle/fluid/operators/collective/c_sync_calc_stream_op.kps
@@ -38,7 +38,7 @@ namespace plat = paddle::platform;
 
 REGISTER_OP_KERNEL(c_sync_calc_stream,
                    KP,
-                   plat::XPUPlace,
-                   ops::CSyncCalcStreamKernel<float, plat::XPUPlace>);
+                   phi::XPUPlace,
+                   ops::CSyncCalcStreamKernel<float, phi::XPUPlace>);
 
 #endif
diff --git a/paddle/fluid/operators/collective/c_sync_comm_stream_op.kps b/paddle/fluid/operators/collective/c_sync_comm_stream_op.kps
@@ -38,7 +38,7 @@ namespace plat = paddle::platform;
 
 REGISTER_OP_KERNEL(c_sync_comm_stream,
                    KP,
-                   plat::XPUPlace,
-                   ops::CSyncCommStreamKernel<float, plat::XPUPlace>);
+                   phi::XPUPlace,
+                   ops::CSyncCommStreamKernel<float, phi::XPUPlace>);
 
 #endif
diff --git a/paddle/fluid/operators/collective/mp_allreduce_sum_op.kps b/paddle/fluid/operators/collective/mp_allreduce_sum_op.kps
@@ -24,7 +24,7 @@ namespace plat = paddle::platform;
 
 REGISTER_OP_KERNEL(mp_allreduce_sum,
                    KP,
-                   plat::XPUPlace,
+                   phi::XPUPlace,
                    ops::CAllReduceOpXPUKernel<ops::kRedSum, float>);
 
 #endif
diff --git a/paddle/fluid/operators/controlflow/logical_op_xpu.h b/paddle/fluid/operators/controlflow/logical_op_xpu.h
@@ -48,8 +48,7 @@ class BinaryLogicalOpXPUKernel : public framework::OpKernel<T> {
     bool* out_ptr = out->mutable_data<bool>(context.GetPlace());
     const T* x_ptr = x->data<T>();
     const T* y_ptr = y->data<T>();
-    auto& dev_ctx =
-        context.template device_context<paddle::platform::XPUDeviceContext>();
+    auto& dev_ctx = context.template device_context<phi::XPUContext>();
     phi::DenseTensor broadcast_x;
     phi::DenseTensor broadcast_y;
     bool need_broad_cast = false;
@@ -171,8 +170,7 @@ class UnaryLogicalOpXPUKernel : public framework::OpKernel<T> {
       return;
     }
     out->mutable_data<bool>(context.GetPlace());
-    auto& dev_ctx =
-        context.template device_context<paddle::platform::XPUDeviceContext>();
+    auto& dev_ctx = context.template device_context<phi::XPUContext>();
     int ret = xpu::logical_not<bool>(
         dev_ctx.x_context(), x->data<T>(), out->data<T>(), x->numel());
     PADDLE_ENFORCE_EQ(
diff --git a/paddle/fluid/operators/elementwise/elementwise_xpu.h b/paddle/fluid/operators/elementwise/elementwise_xpu.h
@@ -51,8 +51,7 @@ void XPUElementwise(const framework::ExecutionContext& ctx,
   auto* z = ctx.Output<phi::DenseTensor>("Out");
   int axis = ctx.Attr<int>("axis");
 
-  auto& dev_ctx =
-      ctx.template device_context<paddle::platform::XPUDeviceContext>();
+  auto& dev_ctx = ctx.template device_context<phi::XPUContext>();
   phi::XPUElementwise<T, XPUType>(dev_ctx, x, *y, axis, z, func);
 }
 
@@ -75,8 +74,7 @@ void XPUElementwiseGrad(const framework::ExecutionContext& ctx,
   auto* dy = ctx.Output<phi::DenseTensor>(framework::GradVarName("Y"));
   int axis = ctx.Attr<int>("axis");
 
-  auto& dev_ctx =
-      ctx.template device_context<paddle::platform::XPUDeviceContext>();
+  auto& dev_ctx = ctx.template device_context<phi::XPUContext>();
   phi::XPUElementwiseGrad<T, XPUType>(
       dev_ctx, *x, *y, *dz, axis, dx, dy, func, use_x_y_data);
 }
diff --git a/paddle/fluid/operators/flatten_op_xpu.cc b/paddle/fluid/operators/flatten_op_xpu.cc
@@ -18,16 +18,14 @@ limitations under the License. */
 
 namespace ops = paddle::operators;
 
-REGISTER_OP_XPU_KERNEL(
-    flatten2,
-    ops::Flatten2Kernel<paddle::platform::XPUDeviceContext, float>,
-    ops::Flatten2Kernel<paddle::platform::XPUDeviceContext, int>,
-    ops::Flatten2Kernel<paddle::platform::XPUDeviceContext, int8_t>,
-    ops::Flatten2Kernel<paddle::platform::XPUDeviceContext, int64_t>);
-REGISTER_OP_XPU_KERNEL(
-    flatten2_grad,
-    ops::Flatten2GradKernel<paddle::platform::XPUDeviceContext, float>,
-    ops::Flatten2GradKernel<paddle::platform::XPUDeviceContext, int>,
-    ops::Flatten2GradKernel<paddle::platform::XPUDeviceContext, int8_t>,
-    ops::Flatten2GradKernel<paddle::platform::XPUDeviceContext, int64_t>);
+REGISTER_OP_XPU_KERNEL(flatten2,
+                       ops::Flatten2Kernel<phi::XPUContext, float>,
+                       ops::Flatten2Kernel<phi::XPUContext, int>,
+                       ops::Flatten2Kernel<phi::XPUContext, int8_t>,
+                       ops::Flatten2Kernel<phi::XPUContext, int64_t>);
+REGISTER_OP_XPU_KERNEL(flatten2_grad,
+                       ops::Flatten2GradKernel<phi::XPUContext, float>,
+                       ops::Flatten2GradKernel<phi::XPUContext, int>,
+                       ops::Flatten2GradKernel<phi::XPUContext, int8_t>,
+                       ops::Flatten2GradKernel<phi::XPUContext, int64_t>);
 #endif
diff --git a/paddle/fluid/operators/fused/resnet_basic_block_op_xpu.cc b/paddle/fluid/operators/fused/resnet_basic_block_op_xpu.cc
@@ -369,7 +369,7 @@ class ResNetBasicBlockXPUKernel : public framework::OpKernel<T> {
       }
     }
 
-    auto& dev_ctx = ctx.template device_context<platform::XPUDeviceContext>();
+    auto& dev_ctx = ctx.template device_context<phi::XPUContext>();
     xpu::ctx_guard RAII_GUARD(dev_ctx.x_context());
     int r = XPU_SUCCESS;
 
@@ -822,7 +822,7 @@ class ResNetBasicBlockGradXPUKernel : public framework::OpKernel<T> {
       }
     }
 
-    auto& dev_ctx = ctx.template device_context<platform::XPUDeviceContext>();
+    auto& dev_ctx = ctx.template device_context<phi::XPUContext>();
     xpu::ctx_guard RAII_GUARD(dev_ctx.x_context());
     int r = XPU_SUCCESS;
 
diff --git a/paddle/fluid/operators/fused/resnet_unit_op_xpu.cc b/paddle/fluid/operators/fused/resnet_unit_op_xpu.cc
@@ -63,7 +63,7 @@ class ResNetUnitXPUKernel : public framework::OpKernel<T> {
     bool is_test = ctx.Attr<bool>("is_test");
     bool is_train = !is_test && !use_global_stats;
     std::string act_type = ctx.Attr<std::string>("act_type");
-    auto &dev_ctx = ctx.template device_context<platform::XPUDeviceContext>();
+    auto &dev_ctx = ctx.template device_context<phi::XPUContext>();
 
     std::vector<const XPUType *> x_list = {
         reinterpret_cast<const XPUType *>(input_x->data<T>())};
@@ -223,7 +223,7 @@ class ResNetUnitGradXPUKernel : public framework::OpKernel<T> {
     bool fuse_add = ctx.Attr<bool>("fuse_add");
     std::string act_type = ctx.Attr<std::string>("act_type");
 
-    auto &dev_ctx = ctx.template device_context<platform::XPUDeviceContext>();
+    auto &dev_ctx = ctx.template device_context<phi::XPUContext>();
 
     std::vector<const XPUType *> x_list = {
         reinterpret_cast<const XPUType *>(x->data<T>())};
diff --git a/paddle/fluid/operators/math/beam_search_xpu.cc b/paddle/fluid/operators/math/beam_search_xpu.cc
@@ -46,9 +46,9 @@ void CopyDataByCondition(const T *x, T **y, int len, const Place &place) {
 }
 
 template <typename T>
-class BeamSearchFunctor<platform::XPUDeviceContext, T> {
+class BeamSearchFunctor<phi::XPUContext, T> {
  public:
-  void operator()(const platform::XPUDeviceContext &context,
+  void operator()(const phi::XPUContext &context,
                   const phi::DenseTensor *pre_ids,
                   const phi::DenseTensor *pre_scores,
                   const phi::DenseTensor *ids,
@@ -354,10 +354,10 @@ class BeamSearchFunctor<platform::XPUDeviceContext, T> {
   }
 };
 
-template class BeamSearchFunctor<platform::XPUDeviceContext, int>;
-template class BeamSearchFunctor<platform::XPUDeviceContext, int64_t>;
-template class BeamSearchFunctor<platform::XPUDeviceContext, float>;
-template class BeamSearchFunctor<platform::XPUDeviceContext, double>;
+template class BeamSearchFunctor<phi::XPUContext, int>;
+template class BeamSearchFunctor<phi::XPUContext, int64_t>;
+template class BeamSearchFunctor<phi::XPUContext, float>;
+template class BeamSearchFunctor<phi::XPUContext, double>;
 
 }  // namespace math
 }  // namespace operators
diff --git a/paddle/fluid/operators/math/concat_and_split.cc b/paddle/fluid/operators/math/concat_and_split.cc
@@ -67,9 +67,9 @@ class SplitFunctor<phi::CPUContext, T> {
  * each dimension must be the same, except the axis dimension.
  */
 template <typename T>
-class ConcatFunctor<platform::XPUDeviceContext, T> {
+class ConcatFunctor<phi::XPUContext, T> {
  public:
-  void operator()(const platform::XPUDeviceContext& context,
+  void operator()(const phi::XPUContext& context,
                   const std::vector<phi::DenseTensor>& input,
                   int axis,
                   phi::DenseTensor* output) {
@@ -119,9 +119,9 @@ class ConcatFunctor<platform::XPUDeviceContext, T> {
 };
 
 template <typename T>
-class SplitFunctor<platform::XPUDeviceContext, T> {
+class SplitFunctor<phi::XPUContext, T> {
  public:
-  void operator()(const platform::XPUDeviceContext& context,
+  void operator()(const phi::XPUContext& context,
                   const phi::DenseTensor& input,
                   const std::vector<const phi::DenseTensor*>& ref_inputs,
                   const int axis,
@@ -185,9 +185,9 @@ class SplitFunctor<platform::XPUDeviceContext, T> {
 FOR_ALL_TYPES(DEFINE_FUNCTOR);
 
 #ifdef PADDLE_WITH_XPU
-#define DEFINE_XPU_FUNCTOR(type)                                  \
-  template class ConcatFunctor<platform::XPUDeviceContext, type>; \
-  template class SplitFunctor<platform::XPUDeviceContext, type>;
+#define DEFINE_XPU_FUNCTOR(type)                       \
+  template class ConcatFunctor<phi::XPUContext, type>; \
+  template class SplitFunctor<phi::XPUContext, type>;
 
 DEFINE_XPU_FUNCTOR(float)
 DEFINE_XPU_FUNCTOR(phi::dtype::float16)
diff --git a/paddle/fluid/operators/matmul_op_xpu.cc b/paddle/fluid/operators/matmul_op_xpu.cc
@@ -45,8 +45,7 @@ class MatMulXPUKernel : public framework::OpKernel<T> {
 
     phi::XpuFcInfo fc_info;
     phi::GetFCInfo(x_dims, y_dims, trans_x, trans_y, &fc_info);
-    auto& dev_ctx =
-        context.template device_context<paddle::platform::XPUDeviceContext>();
+    auto& dev_ctx = context.template device_context<phi::XPUContext>();
     xpu::Context* xpu_ctx = dev_ctx.x_context();
 
     phi::MatMulXPUFunction<XPUType>(
@@ -99,8 +98,7 @@ class MatMulGradXPUKernel : public framework::OpKernel<T> {
     if (dy) {
       dy->mutable_data<T>(context.GetPlace());
     }
-    auto& dev_ctx =
-        context.template device_context<paddle::platform::XPUDeviceContext>();
+    auto& dev_ctx = context.template device_context<phi::XPUContext>();
 
     const XPUType* dout_ptr = reinterpret_cast<const XPUType*>(dout.data<T>());
     const XPUType* x_ptr = reinterpret_cast<const XPUType*>(x.data<T>());
@@ -153,16 +151,12 @@ namespace ops = paddle::operators;
 
 REGISTER_OP_XPU_KERNEL(
     matmul,
-    ops::MatMulXPUKernel<paddle::platform::XPUDeviceContext, float>,
-    ops::MatMulXPUKernel<paddle::platform::XPUDeviceContext,
-                         phi::dtype::bfloat16>,
-    ops::MatMulXPUKernel<paddle::platform::XPUDeviceContext,
-                         phi::dtype::float16>);
+    ops::MatMulXPUKernel<phi::XPUContext, float>,
+    ops::MatMulXPUKernel<phi::XPUContext, phi::dtype::bfloat16>,
+    ops::MatMulXPUKernel<phi::XPUContext, phi::dtype::float16>);
 REGISTER_OP_XPU_KERNEL(
     matmul_grad,
-    ops::MatMulGradXPUKernel<paddle::platform::XPUDeviceContext, float>,
-    ops::MatMulGradXPUKernel<paddle::platform::XPUDeviceContext,
-                             phi::dtype::bfloat16>,
-    ops::MatMulGradXPUKernel<paddle::platform::XPUDeviceContext,
-                             phi::dtype::float16>);
+    ops::MatMulGradXPUKernel<phi::XPUContext, float>,
+    ops::MatMulGradXPUKernel<phi::XPUContext, phi::dtype::bfloat16>,
+    ops::MatMulGradXPUKernel<phi::XPUContext, phi::dtype::float16>);
 #endif
diff --git a/paddle/fluid/operators/one_hot_op_xpu.cc b/paddle/fluid/operators/one_hot_op_xpu.cc
@@ -67,8 +67,7 @@ class OneHotXPUKernel : public framework::OpKernel<T> {
 }  // namespace paddle
 
 namespace ops = paddle::operators;
-REGISTER_OP_XPU_KERNEL(
-    one_hot,
-    ops::OneHotXPUKernel<paddle::platform::XPUDeviceContext, int>,
-    ops::OneHotXPUKernel<paddle::platform::XPUDeviceContext, int64_t>);
+REGISTER_OP_XPU_KERNEL(one_hot,
+                       ops::OneHotXPUKernel<phi::XPUContext, int>,
+                       ops::OneHotXPUKernel<phi::XPUContext, int64_t>);
 #endif
diff --git a/paddle/fluid/operators/reader/buffered_reader.cc b/paddle/fluid/operators/reader/buffered_reader.cc
@@ -68,8 +68,8 @@ BufferedReader::BufferedReader(
   if (platform::is_xpu_place(place_)) {
     int dev_idx = place_.device;
     compute_stream_ =
-        ((platform::XPUDeviceContext *)(platform::DeviceContextPool::Instance()
-                                            .Get(place_)))
+        ((phi::XPUContext *)(platform::DeviceContextPool::Instance().Get(
+             place_)))
             ->stream();
     events_.resize(buffer_size);
     for (auto &event : events_) {
diff --git a/paddle/fluid/operators/reduce_ops/logsumexp_op_xpu.cc b/paddle/fluid/operators/reduce_ops/logsumexp_op_xpu.cc
@@ -74,7 +74,6 @@ namespace ops = paddle::operators;
 // phi::LogsumexpKernel rather than XPULogsumexpKernel here. And if register
 // xpu logsumexp kernel in phi, op logsumexp will run XPULogsumexpKernel here
 // and raise error.
-REGISTER_OP_XPU_KERNEL(
-    logsumexp,
-    ops::XPULogsumexpKernel<paddle::platform::XPUDeviceContext, float>);
+REGISTER_OP_XPU_KERNEL(logsumexp,
+                       ops::XPULogsumexpKernel<phi::XPUContext, float>);
 #endif
diff --git a/paddle/fluid/operators/reduce_ops/reduce_op.h b/paddle/fluid/operators/reduce_ops/reduce_op.h
@@ -776,8 +776,7 @@ class ReduceCudaKernel : public framework::OpKernel<T> {
         static_cast<framework::proto::VarType::Type>(out_dtype));
     std::vector<int> dims = context.Attr<std::vector<int>>("dim");
 #ifdef PADDLE_WITH_XPU_KP
-    auto& dev_ctx =
-        context.template device_context<paddle::platform::XPUDeviceContext>();
+    auto& dev_ctx = context.template device_context<phi::XPUContext>();
 #else
     auto& dev_ctx = context.cuda_device_context();
 #endif
diff --git a/paddle/fluid/operators/reshape_op.cc b/paddle/fluid/operators/reshape_op.cc
@@ -436,7 +436,7 @@ class ReshapeKernel {
 #endif
 #ifdef PADDLE_WITH_XPU
     if (platform::is_xpu_place(ctx.GetPlace())) {
-      auto &dev_ctx = ctx.device_context<platform::XPUDeviceContext>();
+      auto &dev_ctx = ctx.device_context<phi::XPUContext>();
       phi::ReshapeInferKernel(static_cast<const phi::XPUContext &>(dev_ctx),
                               *in,
                               pt_scalar_shape,
@@ -467,7 +467,7 @@ class ReshapeGradKernel {
 #endif
 #ifdef PADDLE_WITH_XPU
     if (platform::is_xpu_place(ctx.GetPlace())) {
-      auto &dev_ctx = ctx.device_context<platform::XPUDeviceContext>();
+      auto &dev_ctx = ctx.device_context<phi::XPUContext>();
       phi::ReshapeGradKernel(
           static_cast<const phi::XPUContext &>(dev_ctx), *d_out, d_x);
     }
@@ -497,7 +497,7 @@ class ReshapeDoubleGradKernel {
 #endif
 #ifdef PADDLE_WITH_XPU
     if (platform::is_xpu_place(ctx.GetPlace())) {
-      auto &dev_ctx = ctx.device_context<platform::XPUDeviceContext>();
+      auto &dev_ctx = ctx.device_context<phi::XPUContext>();
       phi::ReshapeDoubleGradKernel(
           static_cast<const phi::XPUContext &>(dev_ctx), *d_out, *dd_x, dd_out);
     }
diff --git a/paddle/fluid/operators/top_k_op_xpu.cc b/paddle/fluid/operators/top_k_op_xpu.cc
@@ -55,7 +55,7 @@ class TopkXPUKernel : public framework::OpKernel<T> {
     T* output_data = output->mutable_data<T>(ctx.GetPlace());
     int64_t* indices_data = indices->mutable_data<int64_t>(ctx.GetPlace());
 
-    auto& dev_ctx = ctx.template device_context<platform::XPUDeviceContext>();
+    auto& dev_ctx = ctx.template device_context<phi::XPUContext>();
     // allocate temp memory for int32 index
     xpu::ctx_guard RAII_GUARD(dev_ctx.x_context());
     int* indices_int_data = RAII_GUARD.alloc_l3_or_gm<int>(indices->numel());

Original file line number	Diff line number	Diff line change
`@@ -94,9 +94,7 @@ class CAllGatherOpXPUKernel : public framework::OpKernel<T> {`
`94`	`94`
`95`	`95`	`if (ctx.Attr<bool>("use_calc_stream")) {`
`96`	`96`	`auto dev_ctx = platform::DeviceContextPool::Instance().Get(place);`
`97`		`- stream = static_cast<platform::XPUDeviceContext*>(dev_ctx)`
`98`		`- ->x_context()`
`99`		`- ->xpu_stream;`
	`97`	`+ stream = static_cast<phi::XPUContext*>(dev_ctx)->x_context()->xpu_stream;`
`100`	`98`	`}`
`101`	`99`
`102`	`100`	`if (comm_ctx) {`
Original file line number	Diff line number	Diff line change
`@@ -238,9 +238,7 @@ class CAllReduceOpXPUKernel : public framework::OpKernel<T> {`
`238`	`238`	`}`
`239`	`239`	`if (ctx.Attr<bool>("use_calc_stream")) {`
`240`	`240`	`auto dev_ctx = platform::DeviceContextPool::Instance().Get(place);`
`241`		`- stream = static_cast<platform::XPUDeviceContext*>(dev_ctx)`
`242`		`- ->x_context()`
`243`		`- ->xpu_stream;`
	`241`	`+ stream = static_cast<phi::XPUContext*>(dev_ctx)->x_context()->xpu_stream;`
`244`	`242`	`}`
`245`	`243`
`246`	`244`	`BKCLOp bkcl_red_type = BKCL_ADD;`
Original file line number	Diff line number	Diff line change
`@@ -181,9 +181,7 @@ class CReduceOpXPUKernel : public framework::OpKernel<T> {`
`181`	`181`	`}`
`182`	`182`	`if (ctx.Attr<bool>("use_calc_stream")) {`
`183`	`183`	`auto dev_ctx = platform::DeviceContextPool::Instance().Get(place);`
`184`		`- stream = static_cast<platform::XPUDeviceContext*>(dev_ctx)`
`185`		`- ->x_context()`
`186`		`- ->xpu_stream;`
	`184`	`+ stream = static_cast<phi::XPUContext*>(dev_ctx)->x_context()->xpu_stream;`
`187`	`185`	`}`
`188`	`186`
`189`	`187`	`BKCLOp bkcl_red_type = BKCL_ADD;`