[XPU] update xhpc to impove performance of strided_copy

Author: cqulilujia

cmake/external/xpu.cmake

@@ -30,7 +30,7 @@ set(XPU_XFA_LIB_NAME "libxpu_flash_attention.so")
 set(XPU_XPUDNN_LIB_NAME "libxpu_dnn.so")
 
 if(NOT DEFINED XPU_XHPC_BASE_DATE)
-  set(XPU_XHPC_BASE_DATE "dev/20250417")
+  set(XPU_XHPC_BASE_DATE "dev/20250514")
 endif()
 set(XPU_XCCL_BASE_VERSION "3.0.2.5") # For XRE5
 if(NOT DEFINED XPU_XFT_BASE_VERSION)

paddle/phi/kernels/xpu/activation_grad_kernel.cc

@@ -144,7 +144,7 @@ int xpu_activation_backward(const Context& dev_ctx,
                                               const XPUType*,
                                               const XPUType*,
                                               XPUType*,
-                                              int)> func) {
+                                              int64_t)> func) {
   /* TODO: relu tanh sigmoid are inplace */
   const XPUType* x_data = nullptr;
   const XPUType* y_data = nullptr;
@@ -606,8 +606,19 @@ struct XPURsqrtGradFunctor : public funcs::BaseActivationFunctor<T> {
                   const DenseTensor* out,
                   const DenseTensor* dout,
                   DenseTensor* dx) const {
-    int r = xpu_activation_backward<Context, T, XPUType>(
-        dev_ctx, x, out, dout, dx, xpu::rsqrt_grad<XPUType>);
+    dev_ctx.template Alloc<T>(dx);
+    const XPUType* out_data = nullptr;
+    const XPUType* dout_data = nullptr;
+    if (out != nullptr) {
+      out_data = reinterpret_cast<const XPUType*>(out->data<T>());
+    }
+    if (dout != nullptr) {
+      dout_data = reinterpret_cast<const XPUType*>(dout->data<T>());
+    }
+    XPUType* dx_data = reinterpret_cast<XPUType*>(dx->data<T>());
+
+    int r = xpu::rsqrt_grad(
+        dev_ctx.x_context(), out_data, dout_data, dx_data, dx->numel());
     PADDLE_ENFORCE_XDNN_SUCCESS(r, "rsqrt_grad");
   }
 };

paddle/phi/kernels/xpu/strided_copy_kernel.cc

@@ -54,11 +54,6 @@ void StridedCopyKernel(const Context& dev_ctx,
                               "StridedCopyKernel's out tensor must complete "
                               "mutable data before call kernel."));
 
-  // The following XPU operators have performance issues and are temporarily
-  // disabled. A temporary workaround has been implemented: "First copy data to
-  // CPU, perform computation using CPU operator logic, then copy results back
-  // to XPU".
-  /*
   // use XPUCopyTypeTrait to deal with double and int16_t copy instead of
   // XPUTypeTrait
   using XPUType = typename XPUCopyTypeTrait<T>::Type;
@@ -74,80 +69,17 @@ void StridedCopyKernel(const Context& dev_ctx,
     r = xpu::copy<XPUType>(dev_ctx.x_context(), input_data, output_data, 1);
     PADDLE_ENFORCE_XDNN_SUCCESS(r, "copy");
   } else {
+    int64_t data_size = input.Holder()->size() - input.meta().offset;
     r = xpu::strided_copy<XPUType>(dev_ctx.x_context(),
                                    input_data,
                                    output_data,
+                                   data_size,
                                    common::vectorize<int64_t>(input.dims()),
                                    common::vectorize<int64_t>(out->dims()),
                                    common::vectorize<int64_t>(input.strides()),
                                    common::vectorize<int64_t>(out->strides()));
     PADDLE_ENFORCE_XDNN_SUCCESS(r, "strided_copy");
   }
-  */
-
-  // wait before copy
-  dev_ctx.Wait();
-
-  // CPU buffer for input
-  char* input_on_cpu = new char[input.Holder()->size()];
-  memory_utils::Copy(CPUPlace(),
-                     static_cast<void*>(input_on_cpu),
-                     dev_ctx.GetPlace(),
-                     static_cast<const void*>(input.Holder()->ptr()),
-                     input.Holder()->size());
-
-  // CPU buffer for out
-  char* output_on_cpu = new char[out->Holder()->size()];
-  memory_utils::Copy(CPUPlace(),
-                     static_cast<void*>(output_on_cpu),
-                     dev_ctx.GetPlace(),
-                     static_cast<const void*>(out->Holder()->ptr()),
-                     out->Holder()->size());
-
-  // wait after copy
-  dev_ctx.Wait();
-
-  // follow paddle/phi/kernels/cpu/strided_copy_kernel.cc
-  const T* input_data =
-      reinterpret_cast<T*>(input_on_cpu + input.meta().offset);
-  int input_rank = input.dims().size();
-  const int64_t* input_dims = input.dims().Get();
-  const int64_t* input_stride = input.strides().Get();
-
-  T* output_data = reinterpret_cast<T*>(output_on_cpu + offset);
-  int output_rank = meta.dims.size();
-  const int64_t* output_dims = meta.dims.Get();
-  const int64_t* output_stride = meta.strides.Get();
-
-  auto numel = input.numel();
-
-  for (int64_t i = 0; i < numel; i++) {
-    int64_t input_offset = 0;
-    int64_t index_tmp = i;
-    for (int dim = input_rank - 1; dim >= 0; --dim) {
-      input_offset += (index_tmp % input_dims[dim]) * input_stride[dim];
-      index_tmp = index_tmp / input_dims[dim];
-    }
-    int64_t output_offset = 0;
-    index_tmp = i;
-    for (int dim = output_rank - 1; dim >= 0; --dim) {
-      output_offset += (index_tmp % output_dims[dim]) * output_stride[dim];
-      index_tmp = index_tmp / output_dims[dim];
-    }
-    output_data[output_offset] = input_data[input_offset];
-  }
-
-  // copy out tensor, from cpu to xpu
-  memory_utils::Copy(dev_ctx.GetPlace(),
-                     static_cast<void*>(out->Holder()->ptr()),
-                     CPUPlace(),
-                     static_cast<const void*>(output_on_cpu),
-                     out->Holder()->size());
-  // wait after copy
-  dev_ctx.Wait();
-
-  delete[] input_on_cpu;
-  delete[] output_on_cpu;
 }
 
 }  // namespace phi