PaddlePaddle
diff --git a/‎paddle/fluid/operators/fused/resnet_basic_block_op_xpu.cc
Copy file name to clipboard
+215-210Lines changed: 215 additions & 210 deletions b/‎paddle/fluid/operators/fused/resnet_basic_block_op_xpu.cc
Copy file name to clipboard
+215-210Lines changed: 215 additions & 210 deletions
diff --git a/‎paddle/phi/kernels/fusion/xpu/conv_transpose_xpu_kernel.cc
Copy file name to clipboard
+4-4Lines changed: 4 additions & 4 deletions b/‎paddle/phi/kernels/fusion/xpu/conv_transpose_xpu_kernel.cc
Copy file name to clipboard
+4-4Lines changed: 4 additions & 4 deletions
diff --git a/‎paddle/phi/kernels/fusion/xpu/fused_rope_grad_kernel.cc
Copy file name to clipboard
+14-14Lines changed: 14 additions & 14 deletions b/‎paddle/phi/kernels/fusion/xpu/fused_rope_grad_kernel.cc
Copy file name to clipboard
+14-14Lines changed: 14 additions & 14 deletions
diff --git a/‎paddle/phi/kernels/fusion/xpu/fused_rope_kernel.cc
Copy file name to clipboard
+15-14Lines changed: 15 additions & 14 deletions b/‎paddle/phi/kernels/fusion/xpu/fused_rope_kernel.cc
Copy file name to clipboard
+15-14Lines changed: 15 additions & 14 deletions
diff --git a/‎paddle/phi/kernels/fusion/xpu/fused_rope_utils.h
Copy file name to clipboard
+24-24Lines changed: 24 additions & 24 deletions b/‎paddle/phi/kernels/fusion/xpu/fused_rope_utils.h
Copy file name to clipboard
+24-24Lines changed: 24 additions & 24 deletions
diff --git a/‎paddle/phi/kernels/xpu/bmm_grad_kernel.cc
Copy file name to clipboard
+2-2Lines changed: 2 additions & 2 deletions b/‎paddle/phi/kernels/xpu/bmm_grad_kernel.cc
Copy file name to clipboard
+2-2Lines changed: 2 additions & 2 deletions
diff --git a/‎paddle/phi/kernels/xpu/bmm_kernel.cc
Copy file name to clipboard
+2-2Lines changed: 2 additions & 2 deletions b/‎paddle/phi/kernels/xpu/bmm_kernel.cc
Copy file name to clipboard
+2-2Lines changed: 2 additions & 2 deletions
@@ -39,7 +39,7 @@ void Conv2dTransposeXPUKernel(const Context& ctx,
                               const std::string& act_type,
                               DenseTensor* out,
                               DenseTensor* out_max) {
-  using XPUT = typename XPUTypeTrait<T>::Type;
+  using XPUType = typename XPUTypeTrait<T>::Type;
 
   ctx.template Alloc<T>(out);
   ctx.template Alloc<float>(out_max);
@@ -71,11 +71,11 @@ void Conv2dTransposeXPUKernel(const Context& ctx,
       x_max.get_ptr() == nullptr ? nullptr : x_max.get_ptr()->data<float>();
   auto filter_max_data = filter_max.data<float>();
 
-  int r = xpu::conv2d_transpose_fusion_v2<XPUT, int16_t, XPUT, int16_t>(
+  int r = xpu::conv2d_transpose_fusion_v2<XPUType, int16_t, XPUType, int16_t>(
       ctx.x_context(),
-      reinterpret_cast<const XPUT*>(x.data<T>()),
+      reinterpret_cast<const XPUType*>(x.data<T>()),
       filter.data<int16_t>(),
-      reinterpret_cast<XPUT*>(out->data<T>()),
+      reinterpret_cast<XPUType*>(out->data<T>()),
       batch_size,
       img_yc,
       img_xh,
 
@@ -32,7 +32,7 @@ void FusedRopeGradKernel(const Context& dev_ctx,
                          DenseTensor* dq,
                          DenseTensor* dk,
                          DenseTensor* dv) {
-  using XPUT = typename XPUTypeTrait<T>::Type;
+  using XPUType = typename XPUTypeTrait<T>::Type;
   if (dout_q.numel() <= 0) {
     return;
   }
@@ -48,8 +48,8 @@ void FusedRopeGradKernel(const Context& dev_ctx,
 
   xpu::ctx_guard RAII_GUARD(dev_ctx.x_context());
   int64_t sin_cos_len = batch_size * seq_len * head_dim;
-  auto* sin_data = RAII_GUARD.alloc_l3_or_gm<XPUT>(sin_cos_len);
-  auto* cos_data = RAII_GUARD.alloc_l3_or_gm<XPUT>(sin_cos_len);
+  auto* sin_data = RAII_GUARD.alloc_l3_or_gm<XPUType>(sin_cos_len);
+  auto* cos_data = RAII_GUARD.alloc_l3_or_gm<XPUType>(sin_cos_len);
 
   if (sin.get_ptr() && cos.get_ptr()) {
     PADDLE_ENFORCE_EQ(sin.get_ptr()->dims(),
@@ -61,9 +61,9 @@ void FusedRopeGradKernel(const Context& dev_ctx,
                           cos.get_ptr()->dims()));
   }
 
-  XPUGetSinCosData<XPUT, Context>(
+  XPUGetSinCosData<XPUType, Context>(
       dev_ctx, sin, position_ids, sin_data, batch_size, seq_len, head_dim);
-  XPUGetSinCosData<XPUT, Context>(
+  XPUGetSinCosData<XPUType, Context>(
       dev_ctx, cos, position_ids, cos_data, batch_size, seq_len, head_dim);
 
   if (use_neox_rotary_style) {
@@ -72,10 +72,10 @@ void FusedRopeGradKernel(const Context& dev_ctx,
         phi::errors::Unimplemented("XPU do not support rotary_embedding_grad "
                                    "with use_neox_rotary_style set."));
   } else {
-    auto* dq_data = reinterpret_cast<XPUT*>(dev_ctx.template Alloc<T>(dq));
-    XPUFusedRotaryHalf<XPUT, Context>(
+    auto* dq_data = reinterpret_cast<XPUType*>(dev_ctx.template Alloc<T>(dq));
+    XPUFusedRotaryHalf<XPUType, Context>(
         dev_ctx,
-        reinterpret_cast<const XPUT*>(dout_q.data<T>()),
+        reinterpret_cast<const XPUType*>(dout_q.data<T>()),
         sin_data,
         cos_data,
         dq_data,
@@ -86,10 +86,10 @@ void FusedRopeGradKernel(const Context& dev_ctx,
         true);
 
     if (dout_k.get_ptr()) {
-      auto* dk_data = reinterpret_cast<XPUT*>(dev_ctx.template Alloc<T>(dk));
-      XPUFusedRotaryHalf<XPUT, Context>(
+      auto* dk_data = reinterpret_cast<XPUType*>(dev_ctx.template Alloc<T>(dk));
+      XPUFusedRotaryHalf<XPUType, Context>(
           dev_ctx,
-          reinterpret_cast<const XPUT*>(dout_k->data<T>()),
+          reinterpret_cast<const XPUType*>(dout_k->data<T>()),
           sin_data,
           cos_data,
           dk_data,
@@ -101,10 +101,10 @@ void FusedRopeGradKernel(const Context& dev_ctx,
     }
 
     if (dout_v.get_ptr()) {
-      auto* dv_data = reinterpret_cast<XPUT*>(dev_ctx.template Alloc<T>(dv));
-      XPUFusedRotaryHalf<XPUT, Context>(
+      auto* dv_data = reinterpret_cast<XPUType*>(dev_ctx.template Alloc<T>(dv));
+      XPUFusedRotaryHalf<XPUType, Context>(
           dev_ctx,
-          reinterpret_cast<const XPUT*>(dout_v->data<T>()),
+          reinterpret_cast<const XPUType*>(dout_v->data<T>()),
           sin_data,
           cos_data,
           dv_data,
 
@@ -33,7 +33,7 @@ void FusedRopeKernel(const Context& dev_ctx,
                      DenseTensor* out_q,
                      DenseTensor* out_k,
                      DenseTensor* out_v) {
-  using XPUT = typename XPUTypeTrait<T>::Type;
+  using XPUType = typename XPUTypeTrait<T>::Type;
   if (q.numel() <= 0) {
     return;
   }
@@ -54,8 +54,8 @@ void FusedRopeKernel(const Context& dev_ctx,
   xpu::ctx_guard RAII_GUARD(dev_ctx.x_context());
 
   int64_t sin_cos_len = batch_size * seq_len * head_dim;
-  auto* sin_data = RAII_GUARD.alloc_l3_or_gm<XPUT>(sin_cos_len);
-  auto* cos_data = RAII_GUARD.alloc_l3_or_gm<XPUT>(sin_cos_len);
+  auto* sin_data = RAII_GUARD.alloc_l3_or_gm<XPUType>(sin_cos_len);
+  auto* cos_data = RAII_GUARD.alloc_l3_or_gm<XPUType>(sin_cos_len);
 
   if (sin.get_ptr() && cos.get_ptr()) {
     PADDLE_ENFORCE_EQ(sin.get_ptr()->dims(),
@@ -67,20 +67,21 @@ void FusedRopeKernel(const Context& dev_ctx,
                           cos.get_ptr()->dims()));
   }
 
-  XPUGetSinCosData<XPUT, Context>(
+  XPUGetSinCosData<XPUType, Context>(
       dev_ctx, sin, position_ids, sin_data, batch_size, seq_len, head_dim);
-  XPUGetSinCosData<XPUT, Context>(
+  XPUGetSinCosData<XPUType, Context>(
       dev_ctx, cos, position_ids, cos_data, batch_size, seq_len, head_dim);
 
   if (use_neox_rotary_style) {
     // TODO(lijin23): support rotary_embedding every_two.
     PADDLE_THROW(phi::errors::Unimplemented(
         "XPU do not support rotary_embedding with use_neox_rotary_style set."));
   } else {
-    auto* outq_data = reinterpret_cast<XPUT*>(dev_ctx.template Alloc<T>(out_q));
-    XPUFusedRotaryHalf<XPUT, Context>(
+    auto* outq_data =
+        reinterpret_cast<XPUType*>(dev_ctx.template Alloc<T>(out_q));
+    XPUFusedRotaryHalf<XPUType, Context>(
         dev_ctx,
-        reinterpret_cast<const XPUT*>(q.data<T>()),
+        reinterpret_cast<const XPUType*>(q.data<T>()),
         sin_data,
         cos_data,
         outq_data,
@@ -91,10 +92,10 @@ void FusedRopeKernel(const Context& dev_ctx,
 
     if (k) {
       auto* outk_data =
-          reinterpret_cast<XPUT*>(dev_ctx.template Alloc<T>(out_k));
-      XPUFusedRotaryHalf<XPUT, Context>(
+          reinterpret_cast<XPUType*>(dev_ctx.template Alloc<T>(out_k));
+      XPUFusedRotaryHalf<XPUType, Context>(
           dev_ctx,
-          reinterpret_cast<const XPUT*>(k->data<T>()),
+          reinterpret_cast<const XPUType*>(k->data<T>()),
           sin_data,
           cos_data,
           outk_data,
@@ -106,10 +107,10 @@ void FusedRopeKernel(const Context& dev_ctx,
 
     if (v) {
       auto* outv_data =
-          reinterpret_cast<XPUT*>(dev_ctx.template Alloc<T>(out_v));
-      XPUFusedRotaryHalf<XPUT, Context>(
+          reinterpret_cast<XPUType*>(dev_ctx.template Alloc<T>(out_v));
+      XPUFusedRotaryHalf<XPUType, Context>(
           dev_ctx,
-          reinterpret_cast<const XPUT*>(v->data<T>()),
+          reinterpret_cast<const XPUType*>(v->data<T>()),
           sin_data,
           cos_data,
           outv_data,
 
@@ -17,11 +17,11 @@
 
 namespace phi {
 namespace fusion {
-template <typename XPUT, typename Context>
+template <typename XPUType, typename Context>
 void XPUGetSinCosData(const Context& dev_ctx,
                       const paddle::optional<DenseTensor>& sin_cos,
                       const paddle::optional<DenseTensor>& position_ids,
-                      XPUT* sin_cos_data,
+                      XPUType* sin_cos_data,
                       int64_t batch_size,
                       int64_t seq_len,
                       int64_t head_dim) {
@@ -68,22 +68,22 @@ void XPUGetSinCosData(const Context& dev_ctx,
           phi::errors::InvalidArgument(
               "The batch_size and seq_len of position_ids must be the same as "
               "those of q."));
-      using XPUTFp16 = typename XPUTypeTrait<phi::dtype::float16>::Type;
-      using XPUTBf16 = typename XPUTypeTrait<phi::dtype::bfloat16>::Type;
-      if (std::is_same<XPUT, XPUTBf16>::value) {
-        int ret = xpu::gather<XPUTFp16, int64_t>(
+      using XPUTypeFp16 = typename XPUTypeTrait<phi::dtype::float16>::Type;
+      using XPUTypeBf16 = typename XPUTypeTrait<phi::dtype::bfloat16>::Type;
+      if (std::is_same<XPUType, XPUTypeBf16>::value) {
+        int ret = xpu::gather<XPUTypeFp16, int64_t>(
             dev_ctx.x_context(),
-            reinterpret_cast<const XPUTFp16*>(sin_cos->data()),
+            reinterpret_cast<const XPUTypeFp16*>(sin_cos->data()),
             position_ids->data<int64_t>(),
-            reinterpret_cast<XPUTFp16*>(sin_cos_data),
+            reinterpret_cast<XPUTypeFp16*>(sin_cos_data),
             {seq_len, head_dim},
             batch_size * seq_len,
             0);
         PADDLE_ENFORCE_XDNN_SUCCESS(ret, "gather");
       } else {
-        int ret = xpu::gather<XPUT, int64_t>(
+        int ret = xpu::gather<XPUType, int64_t>(
             dev_ctx.x_context(),
-            reinterpret_cast<const XPUT*>(sin_cos->data()),
+            reinterpret_cast<const XPUType*>(sin_cos->data()),
             position_ids->data<int64_t>(),
             sin_cos_data,
             {seq_len, head_dim},
@@ -92,37 +92,37 @@ void XPUGetSinCosData(const Context& dev_ctx,
         PADDLE_ENFORCE_XDNN_SUCCESS(ret, "gather");
       }
     } else {
-      int ret =
-          xpu::broadcast<XPUT>(dev_ctx.x_context(),
-                               reinterpret_cast<const XPUT*>(sin_cos->data()),
-                               sin_cos_data,
-                               {1, seq_len, head_dim},
-                               {batch_size, seq_len, head_dim});
+      int ret = xpu::broadcast<XPUType>(
+          dev_ctx.x_context(),
+          reinterpret_cast<const XPUType*>(sin_cos->data()),
+          sin_cos_data,
+          {1, seq_len, head_dim},
+          {batch_size, seq_len, head_dim});
       PADDLE_ENFORCE_XDNN_SUCCESS(ret, "broadcast");
     }
   } else {
     int ret = xpu::constant(dev_ctx.x_context(),
                             sin_cos_data,
                             batch_size * seq_len * head_dim,
-                            static_cast<XPUT>(0.0f));
+                            static_cast<XPUType>(0.0f));
     PADDLE_ENFORCE_XDNN_SUCCESS(ret, "constant");
   }
 }
 
-template <typename XPUT, typename Context>
+template <typename XPUType, typename Context>
 void XPUFusedRotaryHalf(const Context& dev_ctx,
-                        const XPUT* in_data,
-                        const XPUT* sin_data,
-                        const XPUT* cos_data,
-                        XPUT* out_data,
+                        const XPUType* in_data,
+                        const XPUType* sin_data,
+                        const XPUType* cos_data,
+                        XPUType* out_data,
                         int64_t batch_size,
                         int64_t seq_len,
                         int64_t num_heads,
                         int64_t head_dim,
                         bool is_bwd = false) {
-  auto func = &xpu::rotary_no_freqs_embedding_v2<XPUT>;
+  auto func = &xpu::rotary_no_freqs_embedding_v2<XPUType>;
   if (is_bwd) {
-    func = &xpu::rotary_no_freqs_embedding_v2_grad<XPUT>;
+    func = &xpu::rotary_no_freqs_embedding_v2_grad<XPUType>;
   }
 
   int ret =
 
@@ -25,10 +25,10 @@ void MatMul(const Context& dev_ctx,
             const DenseTensor& b,
             bool trans_b,
             DenseTensor* out) {
-  using XPUT = typename XPUTypeTrait<T>::Type;
+  using XPUType = typename XPUTypeTrait<T>::Type;
   dev_ctx.template Alloc<T>(out);
   xpu::Context* xpu_ctx = dev_ctx.x_context();
-  int fccal_type = FCCalcType<XPUT>();
+  int fccal_type = FCCalcType<XPUType>();
   if (fccal_type == XPUFCCalcType::FC_INT32) {
     MatMulXPUFunction<T, int32_t>(a, b, out, trans_a, trans_b, xpu_ctx);
   } else if (fccal_type == XPUFCCalcType::FC_FLOAT) {
 
@@ -20,7 +20,7 @@ void BmmKernel(const Context& dev_ctx,
                const DenseTensor& x,
                const DenseTensor& y,
                DenseTensor* out) {
-  using XPUT = typename XPUTypeTrait<T>::Type;
+  using XPUType = typename XPUTypeTrait<T>::Type;
   dev_ctx.template Alloc<T>(out);
   if (x.numel() == 0 || y.numel() == 0) {
     return;
@@ -63,7 +63,7 @@ void BmmKernel(const Context& dev_ctx,
           y_dims[1]));
 
   xpu::Context* xpu_ctx = dev_ctx.x_context();
-  int fccal_type = FCCalcType<XPUT>();
+  int fccal_type = FCCalcType<XPUType>();
   if (fccal_type == XPUFCCalcType::FC_INT32) {
     MatMulXPUFunction<T, int32_t>(x, y, out, trans_x, trans_y, xpu_ctx);
   } else if (fccal_type == XPUFCCalcType::FC_FLOAT) {