add xpu_support op function (#48606)

*test=kunlun

paddle/fluid/framework/operator.cc

@@ -1319,9 +1319,10 @@ bool OperatorWithKernel::SupportXPU() const {
           op_kernels.end(),
           [this](OpKernelMap::const_reference kern_pair) {
             return platform::is_xpu_place(kern_pair.first.place_) &&
-                   paddle::platform::is_xpu_support_op(type_,
-                                                       kern_pair.first) &&
-                   !paddle::platform::is_in_xpu_black_list(type_);
+                   paddle::platform::is_xpu_support_op(
+                       type_,
+                       framework::TransToPhiDataType(
+                           kern_pair.first.data_type_));
           });
     }
   }
@@ -1409,8 +1410,8 @@ bool OperatorWithKernel::SupportsKernelType(
 #if defined(PADDLE_WITH_XPU) && !defined(PADDLE_WITH_XPU_KP)
   if (paddle::platform::is_xpu_place(kernel_type.place_)) {
     return kernel_iter != kernels.end() &&
-           paddle::platform::is_xpu_support_op(type_, kernel_type) &&
-           !paddle::platform::is_in_xpu_black_list(type_);
+           paddle::platform::is_xpu_support_op(
+               type_, framework::TransToPhiDataType(kernel_type.data_type_));
   }
 #endif
 
@@ -1418,7 +1419,8 @@ bool OperatorWithKernel::SupportsKernelType(
   if (paddle::platform::is_xpu_place(kernel_type.place_)) {
     bool use_xpu_kp_kernel_rt =
         FLAGS_run_kp_kernel &&
-        paddle::platform::is_xpu_kp_support_op(type_, kernel_type);
+        paddle::platform::is_xpu_support_op(
+            type_, framework::TransToPhiDataType(kernel_type.data_type_));
     bool use_xpu_kp_kernel_debug =
         paddle::platform::is_in_xpu_kpwhite_list(type_);
     bool is_xpu_kp_support = (use_xpu_kp_kernel_rt || use_xpu_kp_kernel_debug);
@@ -1428,8 +1430,8 @@ bool OperatorWithKernel::SupportsKernelType(
       return kernels.find(tmp_kernel_type) != kernels.end();
     }
     return kernel_iter != kernels.end() &&
-           paddle::platform::is_xpu_support_op(type_, kernel_type) &&
-           !paddle::platform::is_in_xpu_black_list(type_);
+           paddle::platform::is_xpu_support_op(
+               type_, framework::TransToPhiDataType(kernel_type.data_type_));
   }
 #endif
 
@@ -1591,7 +1593,8 @@ void OperatorWithKernel::RunImpl(const Scope& scope,
       if (paddle::platform::is_xpu_place(kernel_type_->place_)) {
         bool use_xpu_kp_kernel_rt =
             FLAGS_run_kp_kernel &&
-            paddle::platform::is_xpu_kp_support_op(type_, *kernel_type_);
+            paddle::platform::is_xpu_support_op(
+                type_, framework::TransToPhiDataType(kernel_type_->data_type_));
         bool use_xpu_kp_kernel_debug =
             paddle::platform::is_in_xpu_kpwhite_list(type_);
         if (use_xpu_kp_kernel_rt) {
@@ -1668,7 +1671,8 @@ void OperatorWithKernel::RunImpl(const Scope& scope,
       if (paddle::platform::is_xpu_place(kernel_type_->place_)) {
         bool use_xpu_kp_kernel_rt =
             FLAGS_run_kp_kernel &&
-            paddle::platform::is_xpu_kp_support_op(type_, *kernel_type_);
+            paddle::platform::is_xpu_support_op(
+                type_, framework::TransToPhiDataType(kernel_type_->data_type_));
         bool use_xpu_kp_kernel_debug =
             paddle::platform::is_in_xpu_kpwhite_list(type_);
         if (use_xpu_kp_kernel_rt) {
@@ -1709,14 +1713,15 @@ void OperatorWithKernel::RunImpl(const Scope& scope,
 #if defined(PADDLE_WITH_XPU)
     bool is_xpu_unsupport =
         paddle::platform::is_xpu_place(kernel_type_->place_) &&
-            !paddle::platform::is_xpu_support_op(type_, *kernel_type_.get()) ||
-        paddle::platform::is_in_xpu_black_list(type_);
+        !paddle::platform::is_xpu_support_op(
+            type_, framework::TransToPhiDataType(kernel_type_->data_type_));
 #endif
 #ifdef PADDLE_WITH_XPU_KP
     bool use_xpu_kp_kernel_rt =
         paddle::platform::is_xpu_place(kernel_type_->place_) &&
         FLAGS_run_kp_kernel &&
-        paddle::platform::is_xpu_kp_support_op(type_, *kernel_type_);
+        paddle::platform::is_xpu_support_op(
+            type_, framework::TransToPhiDataType(kernel_type_->data_type_));
     bool use_xpu_kp_kernel_debug =
         paddle::platform::is_xpu_place(kernel_type_->place_) &&
         paddle::platform::is_in_xpu_kpwhite_list(type_);
@@ -2051,8 +2056,9 @@ void OperatorWithKernel::ChooseKernel(const ExecutionContext& ctx) const {
 #if defined(PADDLE_WITH_XPU) && !defined(PADDLE_WITH_XPU_KP)
   if (platform::is_xpu_place(expected_kernel_key.place_) &&
       (kernel_iter == kernels.end() ||
-       !paddle::platform::is_xpu_support_op(type_, expected_kernel_key) ||
-       paddle::platform::is_in_xpu_black_list(type_))) {
+       !paddle::platform::is_xpu_support_op(
+           type_,
+           framework::TransToPhiDataType(expected_kernel_key.data_type_)))) {
     VLOG(3) << "fluid missing XPU kernel: " << type_
             << ", expected_kernel_key:" << expected_kernel_key
             << ", fallbacking to CPU one!";
@@ -2065,7 +2071,9 @@ void OperatorWithKernel::ChooseKernel(const ExecutionContext& ctx) const {
   if (paddle::platform::is_xpu_place(expected_kernel_key.place_)) {
     bool use_xpu_kp_kernel_rt =
         FLAGS_run_kp_kernel &&
-        paddle::platform::is_xpu_kp_support_op(type_, expected_kernel_key);
+        paddle::platform::is_xpu_support_op(
+            type_,
+            framework::TransToPhiDataType(expected_kernel_key.data_type_));
     bool use_xpu_kp_kernel_debug =
         paddle::platform::is_in_xpu_kpwhite_list(type_);
     if (use_xpu_kp_kernel_rt) {
@@ -2093,9 +2101,8 @@ void OperatorWithKernel::ChooseKernel(const ExecutionContext& ctx) const {
                 << ", using_kernel_key:" << expected_kernel_key;
       }
     }
-    bool is_xpu_unsupport =
-        (!paddle::platform::is_xpu_support_op(type_, expected_kernel_key) ||
-         paddle::platform::is_in_xpu_black_list(type_));
+    bool is_xpu_unsupport = (!paddle::platform::is_xpu_support_op(
+        type_, framework::TransToPhiDataType(expected_kernel_key.data_type_)));
     if (!is_xpu_kp_support &&
         (kernel_iter == kernels.end() || is_xpu_unsupport)) {
       VLOG(3) << "fluid missing XPU kernel: " << type_

paddle/fluid/imperative/prepared_operator.cc

@@ -255,9 +255,9 @@ PreparedOp PrepareImpl(
 #if defined(PADDLE_WITH_XPU)
   bool is_xpu_unsupport =
       paddle::platform::is_xpu_place(expected_kernel_key.place_) &&
-          !paddle::platform::is_xpu_support_op(op.Type(),
-                                               expected_kernel_key) ||
-      paddle::platform::is_in_xpu_black_list(op.Type());
+      !paddle::platform::is_xpu_support_op(
+          op.Type(),
+          framework::TransToPhiDataType(expected_kernel_key.data_type_));
 #endif
 
 #ifdef PADDLE_WITH_MLU
@@ -292,8 +292,10 @@ PreparedOp PrepareImpl(
 #ifdef PADDLE_WITH_XPU_KP
     if (paddle::platform::is_xpu_place(expected_kernel_key.place_)) {
       bool use_xpu_kp_kernel_rt =
-          FLAGS_run_kp_kernel && paddle::platform::is_xpu_kp_support_op(
-                                     op.Type(), expected_kernel_key);
+          FLAGS_run_kp_kernel &&
+          paddle::platform::is_xpu_support_op(
+              op.Type(),
+              framework::TransToPhiDataType(expected_kernel_key.data_type_));
       bool use_xpu_kp_kernel_debug =
           paddle::platform::is_in_xpu_kpwhite_list(op.Type());
       if (use_xpu_kp_kernel_rt) {
@@ -368,7 +370,9 @@ PreparedOp PrepareImpl(
   bool use_xpu_kp_kernel_rt =
       paddle::platform::is_xpu_place(expected_kernel_key.place_) &&
       FLAGS_run_kp_kernel &&
-      paddle::platform::is_xpu_kp_support_op(op.Type(), expected_kernel_key);
+      paddle::platform::is_xpu_support_op(
+          op.Type(),
+          framework::TransToPhiDataType(expected_kernel_key.data_type_));
   bool use_xpu_kp_kernel_debug =
       paddle::platform::is_xpu_place(expected_kernel_key.place_) &&
       paddle::platform::is_in_xpu_kpwhite_list(op.Type());

paddle/fluid/platform/device/xpu/xpu1_op_list.h

-/* Copyright (c) 2021 PaddlePaddle Authors. All Rights Reserved.
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-    http://www.apache.org/licenses/LICENSE-2.0
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License. */
-#pragma once
-
-#ifdef PADDLE_WITH_XPU
-#include <string>
-#include <unordered_map>
-#include <unordered_set>
-
-#include "paddle/fluid/framework/op_kernel_type.h"
-
-namespace paddle {
-namespace platform {
-
-using vartype = paddle::framework::proto::VarType;
-using pOpKernelType = paddle::framework::OpKernelType;
-using XPUKernelSet =
-    std::unordered_set<pOpKernelType, paddle::framework::OpKernelType::Hash>;
-using XPUOpMap = std::unordered_map<std::string, XPUKernelSet>;
-
-XPUOpMap& get_kl1_ops() {
-  // KL1支持的op，通过op_name, data_type, place来索引
-  static XPUOpMap s_xpu1_kernels{
-      {"abs", XPUKernelSet({pOpKernelType(vartype::FP32, XPUPlace())})},
-      {"accuracy", XPUKernelSet({pOpKernelType(vartype::FP32, XPUPlace())})},
-      {"adam", XPUKernelSet({pOpKernelType(vartype::FP32, XPUPlace())})},
-      {"adamw", XPUKernelSet({pOpKernelType(vartype::FP32, XPUPlace())})},
-      {"affine_channel_grad",
-       XPUKernelSet({pOpKernelType(vartype::FP32, XPUPlace())})},
-      {"affine_channel",
-       XPUKernelSet({pOpKernelType(vartype::FP32, XPUPlace())})},
-      {"arg_max", XPUKernelSet({pOpKernelType(vartype::FP32, XPUPlace())})},
-      {"assign",
-       XPUKernelSet({pOpKernelType(vartype::FP32, XPUPlace()),
-                     pOpKernelType(vartype::FP64, XPUPlace()),
-                     pOpKernelType(vartype::INT32, XPUPlace()),
-                     pOpKernelType(vartype::INT64, XPUPlace()),
-                     pOpKernelType(vartype::BOOL, XPUPlace())})},
-      {"batch_norm_grad",
-       XPUKernelSet({pOpKernelType(vartype::FP32, XPUPlace())})},
-      {"batch_norm", XPUKernelSet({pOpKernelType(vartype::FP32, XPUPlace())})},
-      {"bilinear_interp",
-       XPUKernelSet({pOpKernelType(vartype::FP32, XPUPlace())})},
-      {"bilinear_interp_grad",
-       XPUKernelSet({pOpKernelType(vartype::FP32, XPUPlace())})},
-      {"bilinear_interp_v2",
-       XPUKernelSet({pOpKernelType(vartype::FP32, XPUPlace())})},
-      {"bilinear_interp_v2_grad",
-       XPUKernelSet({pOpKernelType(vartype::FP32, XPUPlace())})},
-      {"broadcast",
-       XPUKernelSet({pOpKernelType(vartype::FP32, XPUPlace()),
-                     pOpKernelType(vartype::FP64, XPUPlace()),
-                     pOpKernelType(vartype::INT32, XPUPlace()),
-                     pOpKernelType(vartype::INT64, XPUPlace())})},
-      {"cast",
-       XPUKernelSet({pOpKernelType(vartype::FP32, XPUPlace()),
-                     pOpKernelType(vartype::INT64, XPUPlace()),
-                     pOpKernelType(vartype::INT32, XPUPlace())})},
-      {"clip_by_norm",
-       XPUKernelSet({pOpKernelType(vartype::FP32, XPUPlace())})},
-      {"coalesce_tensor",
-       XPUKernelSet({pOpKernelType(vartype::FP32, XPUPlace()),
-                     pOpKernelType(vartype::FP64, XPUPlace()),
-                     pOpKernelType(vartype::INT32, XPUPlace())})},
-      {"concat", XPUKernelSet({pOpKernelType(vartype::FP32, XPUPlace())})},
-      {"concat_grad", XPUKernelSet({pOpKernelType(vartype::FP32, XPUPlace())})},
-      {"conv2d", XPUKernelSet({pOpKernelType(vartype::FP32, XPUPlace())})},
-      {"conv2d_grad", XPUKernelSet({pOpKernelType(vartype::FP32, XPUPlace())})},
-      {"deformable_conv",
-       XPUKernelSet({pOpKernelType(vartype::FP32, XPUPlace())})},
-      {"deformable_conv_grad",
-       XPUKernelSet({pOpKernelType(vartype::FP32, XPUPlace())})},
-      {"depthwise_conv2d",
-       XPUKernelSet({pOpKernelType(vartype::FP32, XPUPlace())})},
-      {"depthwise_conv2d_grad",
-       XPUKernelSet({pOpKernelType(vartype::FP32, XPUPlace())})},
-      {"dropout", XPUKernelSet({pOpKernelType(vartype::FP32, XPUPlace())})},
-      {"dropout_grad",
-       XPUKernelSet({pOpKernelType(vartype::FP32, XPUPlace())})},
-      {"c_allreduce_sum",
-       XPUKernelSet({pOpKernelType(vartype::FP32, XPUPlace())})},
-      {"c_reduce_sum",
-       XPUKernelSet({pOpKernelType(vartype::FP32, XPUPlace())})},
-      {"elementwise_add",
-       XPUKernelSet({pOpKernelType(vartype::FP32, XPUPlace())})},
-      {"elementwise_add_grad",
-       XPUKernelSet({pOpKernelType(vartype::FP32, XPUPlace())})},
-      {"elementwise_div_grad",
-       XPUKernelSet({pOpKernelType(vartype::FP32, XPUPlace())})},
-      {"elementwise_div",
-       XPUKernelSet({pOpKernelType(vartype::FP32, XPUPlace())})},
-      {"elementwise_floordiv",
-       XPUKernelSet({pOpKernelType(vartype::FP32, XPUPlace())})},
-      {"elementwise_max_grad",
-       XPUKernelSet({pOpKernelType(vartype::FP32, XPUPlace())})},
-      {"elementwise_max",
-       XPUKernelSet({pOpKernelType(vartype::FP32, XPUPlace())})},
-      {"elementwise_min_grad",
-       XPUKernelSet({pOpKernelType(vartype::FP32, XPUPlace())})},
-      {"elementwise_min",
-       XPUKernelSet({pOpKernelType(vartype::FP32, XPUPlace())})},
-      {"elementwise_mul_grad",
-       XPUKernelSet({pOpKernelType(vartype::FP32, XPUPlace())})},
-      {"elementwise_mul",
-       XPUKernelSet({pOpKernelType(vartype::FP32, XPUPlace())})},
-      {"elementwise_pow",
-       XPUKernelSet({pOpKernelType(vartype::FP32, XPUPlace())})},
-      {"elementwise_sub_grad",
-       XPUKernelSet({pOpKernelType(vartype::FP32, XPUPlace())})},
-      {"elementwise_sub",
-       XPUKernelSet({pOpKernelType(vartype::FP32, XPUPlace())})},
-      {"equal", XPUKernelSet({pOpKernelType(vartype::INT64, XPUPlace())})},
-      {"expand_as_v2",
-       XPUKernelSet({pOpKernelType(vartype::INT32, XPUPlace()),
-                     pOpKernelType(vartype::INT64, XPUPlace()),
-                     pOpKernelType(vartype::BOOL, XPUPlace()),
-                     pOpKernelType(vartype::FP16, XPUPlace()),
-                     pOpKernelType(vartype::FP32, XPUPlace())})},
-      {"expand_v2",
-       XPUKernelSet({pOpKernelType(vartype::INT32, XPUPlace()),
-                     pOpKernelType(vartype::INT64, XPUPlace()),
-                     pOpKernelType(vartype::BOOL, XPUPlace()),
-                     pOpKernelType(vartype::FP16, XPUPlace()),
-                     pOpKernelType(vartype::FP32, XPUPlace())})},
-      {"fill_any_like",
-       XPUKernelSet({pOpKernelType(vartype::INT64, XPUPlace())})},
-      {"fill_constant",
-       XPUKernelSet({pOpKernelType(vartype::INT32, XPUPlace()),
-                     pOpKernelType(vartype::INT64, XPUPlace()),
-                     pOpKernelType(vartype::FP64, XPUPlace()),
-                     pOpKernelType(vartype::BOOL, XPUPlace()),
-                     pOpKernelType(vartype::FP32, XPUPlace())})},
-      {"gather_grad", XPUKernelSet({pOpKernelType(vartype::FP32, XPUPlace())})},
-      {"gather", XPUKernelSet({pOpKernelType(vartype::FP32, XPUPlace())})},
-      {"gaussian_random",
-       XPUKernelSet({pOpKernelType(vartype::FP32, XPUPlace())})},
-      {"gelu_grad", XPUKernelSet({pOpKernelType(vartype::FP32, XPUPlace())})},
-      {"gelu", XPUKernelSet({pOpKernelType(vartype::FP32, XPUPlace())})},
-      {"hard_switch_grad",
-       XPUKernelSet({pOpKernelType(vartype::FP32, XPUPlace())})},
-      {"hard_switch", XPUKernelSet({pOpKernelType(vartype::FP32, XPUPlace())})},
-      {"iou_similarity",
-       XPUKernelSet({pOpKernelType(vartype::FP32, XPUPlace())})},
-      {"lamb", XPUKernelSet({pOpKernelType(vartype::FP32, XPUPlace())})},
-      {"layer_norm_grad",
-       XPUKernelSet({pOpKernelType(vartype::FP32, XPUPlace())})},
-      {"layer_norm", XPUKernelSet({pOpKernelType(vartype::FP32, XPUPlace())})},
-      {"leaky_relu_grad",
-       XPUKernelSet({pOpKernelType(vartype::FP32, XPUPlace())})},
-      {"leaky_relu", XPUKernelSet({pOpKernelType(vartype::FP32, XPUPlace())})},
-      {"load",
-       XPUKernelSet({pOpKernelType(vartype::FP64, XPUPlace()),
-                     pOpKernelType(vartype::INT8, XPUPlace()),
-                     pOpKernelType(vartype::INT32, XPUPlace()),
-                     pOpKernelType(vartype::INT64, XPUPlace()),
-                     pOpKernelType(vartype::FP32, XPUPlace())})},
-      {"logicaland",
-       XPUKernelSet({pOpKernelType(vartype::BOOL, XPUPlace()),
-                     pOpKernelType(vartype::INT8, XPUPlace()),
-                     pOpKernelType(vartype::INT16, XPUPlace()),
-                     pOpKernelType(vartype::INT32, XPUPlace()),
-                     pOpKernelType(vartype::INT64, XPUPlace()),
-                     pOpKernelType(vartype::FP32, XPUPlace())})},
-      {"logicalnot",
-       XPUKernelSet({pOpKernelType(vartype::BOOL, XPUPlace()),
-                     pOpKernelType(vartype::INT8, XPUPlace()),
-                     pOpKernelType(vartype::INT16, XPUPlace()),
-                     pOpKernelType(vartype::INT32, XPUPlace()),
-                     pOpKernelType(vartype::INT64, XPUPlace()),
-                     pOpKernelType(vartype::FP32, XPUPlace())})},
-      {"logicalor",
-       XPUKernelSet({pOpKernelType(vartype::BOOL, XPUPlace()),
-                     pOpKernelType(vartype::INT8, XPUPlace()),
-                     pOpKernelType(vartype::INT16, XPUPlace()),
-                     pOpKernelType(vartype::INT32, XPUPlace()),
-                     pOpKernelType(vartype::INT64, XPUPlace()),
-                     pOpKernelType(vartype::FP32, XPUPlace())})},
-      {"log_loss_grad",
-       XPUKernelSet({pOpKernelType(vartype::FP32, XPUPlace())})},
-      {"log_loss", XPUKernelSet({pOpKernelType(vartype::FP32, XPUPlace())})},
-      {"logsumexp", XPUKernelSet({pOpKernelType(vartype::FP32, XPUPlace())})},
-      {"log", XPUKernelSet({pOpKernelType(vartype::FP32, XPUPlace())})},
-      {"lookup_table_v2_grad",
-       XPUKernelSet({pOpKernelType(vartype::FP32, XPUPlace())})},
-      {"lookup_table_v2",
-       XPUKernelSet({pOpKernelType(vartype::FP32, XPUPlace())})},
-      {"matmul_grad", XPUKernelSet({pOpKernelType(vartype::FP32, XPUPlace())})},
-      {"matmul_v2_grad",
-       XPUKernelSet({pOpKernelType(vartype::FP32, XPUPlace())})},
-      {"matmul_v2", XPUKernelSet({pOpKernelType(vartype::FP32, XPUPlace())})},
-      {"matmul", XPUKernelSet({pOpKernelType(vartype::FP32, XPUPlace())})},
-      {"mean_grad", XPUKernelSet({pOpKernelType(vartype::FP32, XPUPlace())})},
-      {"mean", XPUKernelSet({pOpKernelType(vartype::FP32, XPUPlace())})},
-      {"momentum", XPUKernelSet({pOpKernelType(vartype::FP32, XPUPlace())})},
-      {"mul_grad", XPUKernelSet({pOpKernelType(vartype::FP32, XPUPlace())})},
-      {"mul", XPUKernelSet({pOpKernelType(vartype::FP32, XPUPlace())})},
-      {"nearest_interp_grad",
-       XPUKernelSet({pOpKernelType(vartype::FP32, XPUPlace())})},
-      {"nearest_interp_v2_grad",
-       XPUKernelSet({pOpKernelType(vartype::FP32, XPUPlace())})},
-      {"nearest_interp_v2",
-       XPUKernelSet({pOpKernelType(vartype::FP32, XPUPlace())})},
-      {"nearest_interp",
-       XPUKernelSet({pOpKernelType(vartype::FP32, XPUPlace())})},
-      {"one_hot_v2",
-       XPUKernelSet({pOpKernelType(vartype::INT32, XPUPlace()),
-                     pOpKernelType(vartype::INT64, XPUPlace())})},
-      {"one_hot",
-       XPUKernelSet({pOpKernelType(vartype::INT32, XPUPlace()),
-                     pOpKernelType(vartype::INT64, XPUPlace())})},
-      {"pool2d_grad", XPUKernelSet({pOpKernelType(vartype::FP32, XPUPlace())})},
-      {"pool2d", XPUKernelSet({pOpKernelType(vartype::FP32, XPUPlace())})},
-      {"pow", XPUKernelSet({pOpKernelType(vartype::FP32, XPUPlace())})},
-      {"range",
-       XPUKernelSet({pOpKernelType(vartype::FP64, XPUPlace()),
-                     pOpKernelType(vartype::INT64, XPUPlace()),
-                     pOpKernelType(vartype::INT32, XPUPlace()),
-                     pOpKernelType(vartype::FP32, XPUPlace())})},
-      {"reduce_max_grad",
-       XPUKernelSet({pOpKernelType(vartype::FP32, XPUPlace())})},
-      {"reduce_max", XPUKernelSet({pOpKernelType(vartype::FP32, XPUPlace())})},
-      {"reduce_mean", XPUKernelSet({pOpKernelType(vartype::FP32, XPUPlace())})},
-      {"reduce_mean_grad",
-       XPUKernelSet({pOpKernelType(vartype::FP32, XPUPlace())})},
-      {"reduce_prod", XPUKernelSet({pOpKernelType(vartype::FP32, XPUPlace())})},
-      {"reduce_sum_grad",
-       XPUKernelSet({pOpKernelType(vartype::FP32, XPUPlace())})},
-      {"reduce_sum", XPUKernelSet({pOpKernelType(vartype::FP32, XPUPlace())})},
-      {"relu_grad", XPUKernelSet({pOpKernelType(vartype::FP32, XPUPlace())})},
-      {"relu", XPUKernelSet({pOpKernelType(vartype::FP32, XPUPlace())})},
-      {"reshape2_grad",
-       XPUKernelSet({pOpKernelType(vartype::FP64, XPUPlace()),
-                     pOpKernelType(vartype::INT64, XPUPlace()),
-                     pOpKernelType(vartype::INT32, XPUPlace()),
-                     pOpKernelType(vartype::BOOL, XPUPlace()),
-                     pOpKernelType(vartype::FP32, XPUPlace())})},
-      {"reshape2",
-       XPUKernelSet({pOpKernelType(vartype::FP64, XPUPlace()),
-                     pOpKernelType(vartype::INT64, XPUPlace()),
-                     pOpKernelType(vartype::INT32, XPUPlace()),
-                     pOpKernelType(vartype::BOOL, XPUPlace()),
-                     pOpKernelType(vartype::FP32, XPUPlace())})},
-      {"rmsprop", XPUKernelSet({pOpKernelType(vartype::FP32, XPUPlace())})},
-      {"rnn_grad", XPUKernelSet({pOpKernelType(vartype::FP32, XPUPlace())})},
-      {"rnn", XPUKernelSet({pOpKernelType(vartype::FP32, XPUPlace())})},
-      {"roi_align_grad",
-       XPUKernelSet({pOpKernelType(vartype::FP32, XPUPlace())})},
-      {"roi_align", XPUKernelSet({pOpKernelType(vartype::FP32, XPUPlace())})},
-      {"scale", XPUKernelSet({pOpKernelType(vartype::FP32, XPUPlace())})},
-      {"sgd", XPUKernelSet({pOpKernelType(vartype::FP32, XPUPlace())})},
-      {"shape",
-       XPUKernelSet({pOpKernelType(vartype::FP64, XPUPlace()),
-                     pOpKernelType(vartype::INT64, XPUPlace()),
-                     pOpKernelType(vartype::INT32, XPUPlace()),
-                     pOpKernelType(vartype::BOOL, XPUPlace()),
-                     pOpKernelType(vartype::FP32, XPUPlace())})},
-      {"sigmoid_grad",
-       XPUKernelSet({pOpKernelType(vartype::FP32, XPUPlace())})},
-      {"sigmoid", XPUKernelSet({pOpKernelType(vartype::FP32, XPUPlace())})},
-      {"sign", XPUKernelSet({pOpKernelType(vartype::FP32, XPUPlace())})},
-      {"slice_grad", XPUKernelSet({pOpKernelType(vartype::FP32, XPUPlace())})},
-      {"slice",
-       XPUKernelSet({pOpKernelType(vartype::FP32, XPUPlace()),
-                     pOpKernelType(vartype::INT32, XPUPlace())})},
-      {"softmax_grad",
-       XPUKernelSet({pOpKernelType(vartype::FP32, XPUPlace())})},
-      {"softmax_with_cross_entropy",
-       XPUKernelSet({pOpKernelType(vartype::FP32, XPUPlace())})},
-      {"softmax_with_cross_entropy_grad",
-       XPUKernelSet({pOpKernelType(vartype::FP32, XPUPlace())})},
-      {"softmax", XPUKernelSet({pOpKernelType(vartype::FP32, XPUPlace())})},
-      {"split",
-       XPUKernelSet({pOpKernelType(vartype::FP32, XPUPlace()),
-                     pOpKernelType(vartype::INT32, XPUPlace())})},
-      {"sqrt_grad", XPUKernelSet({pOpKernelType(vartype::FP32, XPUPlace())})},
-      {"sqrt", XPUKernelSet({pOpKernelType(vartype::FP32, XPUPlace())})},
-      {"square_grad", XPUKernelSet({pOpKernelType(vartype::FP32, XPUPlace())})},
-      {"square", XPUKernelSet({pOpKernelType(vartype::FP32, XPUPlace())})},
-      {"squeeze2_grad",
-       XPUKernelSet({pOpKernelType(vartype::FP64, XPUPlace()),
-                     pOpKernelType(vartype::INT64, XPUPlace()),
-                     pOpKernelType(vartype::INT32, XPUPlace()),
-                     pOpKernelType(vartype::BOOL, XPUPlace()),
-                     pOpKernelType(vartype::INT8, XPUPlace()),
-                     pOpKernelType(vartype::UINT8, XPUPlace()),
-                     pOpKernelType(vartype::FP32, XPUPlace())})},
-      {"squeeze2",
-       XPUKernelSet({pOpKernelType(vartype::FP64, XPUPlace()),
-                     pOpKernelType(vartype::INT64, XPUPlace()),
-                     pOpKernelType(vartype::INT32, XPUPlace()),
-                     pOpKernelType(vartype::BOOL, XPUPlace()),
-                     pOpKernelType(vartype::INT8, XPUPlace()),
-                     pOpKernelType(vartype::UINT8, XPUPlace()),
-                     pOpKernelType(vartype::FP32, XPUPlace())})},
-      {"squeeze_grad",
-       XPUKernelSet({pOpKernelType(vartype::FP64, XPUPlace()),
-                     pOpKernelType(vartype::INT64, XPUPlace()),
-                     pOpKernelType(vartype::INT32, XPUPlace()),
-                     pOpKernelType(vartype::BOOL, XPUPlace()),
-                     pOpKernelType(vartype::INT8, XPUPlace()),
-                     pOpKernelType(vartype::UINT8, XPUPlace()),
-                     pOpKernelType(vartype::FP32, XPUPlace())})},
-      {"squeeze",
-       XPUKernelSet({pOpKernelType(vartype::FP64, XPUPlace()),
-                     pOpKernelType(vartype::INT64, XPUPlace()),
-                     pOpKernelType(vartype::INT32, XPUPlace()),
-                     pOpKernelType(vartype::BOOL, XPUPlace()),
-                     pOpKernelType(vartype::INT8, XPUPlace()),
-                     pOpKernelType(vartype::UINT8, XPUPlace()),
-                     pOpKernelType(vartype::FP32, XPUPlace())})},
-      {"stack", XPUKernelSet({pOpKernelType(vartype::FP32, XPUPlace())})},
-      {"stack_grad", XPUKernelSet({pOpKernelType(vartype::FP32, XPUPlace())})},
-      {"sum", XPUKernelSet({pOpKernelType(vartype::FP32, XPUPlace())})},
-      {"tanh_grad", XPUKernelSet({pOpKernelType(vartype::FP32, XPUPlace())})},
-      {"tanh", XPUKernelSet({pOpKernelType(vartype::FP32, XPUPlace())})},
-      {"top_k", XPUKernelSet({pOpKernelType(vartype::FP32, XPUPlace())})},
-      {"transpose2_grad",
-       XPUKernelSet({pOpKernelType(vartype::FP32, XPUPlace())})},
-      {"transpose2", XPUKernelSet({pOpKernelType(vartype::FP32, XPUPlace())})},
-      {"transpose_grad",
-       XPUKernelSet({pOpKernelType(vartype::FP32, XPUPlace())})},
-      {"transpose", XPUKernelSet({pOpKernelType(vartype::FP32, XPUPlace())})},
-      {"truncated_gaussian_random",
-       XPUKernelSet({pOpKernelType(vartype::FP32, XPUPlace())})},
-      {"uniform_random",
-       XPUKernelSet({pOpKernelType(vartype::FP32, XPUPlace())})},
-      {"unsqueeze2_grad",
-       XPUKernelSet({pOpKernelType(vartype::FP64, XPUPlace()),
-                     pOpKernelType(vartype::INT64, XPUPlace()),
-                     pOpKernelType(vartype::INT32, XPUPlace()),
-                     pOpKernelType(vartype::BOOL, XPUPlace()),
-                     pOpKernelType(vartype::INT8, XPUPlace()),
-                     pOpKernelType(vartype::UINT8, XPUPlace()),
-                     pOpKernelType(vartype::FP32, XPUPlace())})},
-      {"unsqueeze2",
-       XPUKernelSet({pOpKernelType(vartype::FP64, XPUPlace()),
-                     pOpKernelType(vartype::INT64, XPUPlace()),
-                     pOpKernelType(vartype::INT32, XPUPlace()),
-                     pOpKernelType(vartype::BOOL, XPUPlace()),
-                     pOpKernelType(vartype::INT8, XPUPlace()),
-                     pOpKernelType(vartype::UINT8, XPUPlace()),
-                     pOpKernelType(vartype::FP32, XPUPlace())})},
-      {"unsqueeze_grad",
-       XPUKernelSet({pOpKernelType(vartype::FP64, XPUPlace()),
-                     pOpKernelType(vartype::INT64, XPUPlace()),
-                     pOpKernelType(vartype::INT32, XPUPlace()),
-                     pOpKernelType(vartype::BOOL, XPUPlace()),
-                     pOpKernelType(vartype::INT8, XPUPlace()),
-                     pOpKernelType(vartype::UINT8, XPUPlace()),
-                     pOpKernelType(vartype::FP32, XPUPlace())})},
-      {"unsqueeze",
-       XPUKernelSet({pOpKernelType(vartype::FP64, XPUPlace()),
-                     pOpKernelType(vartype::INT64, XPUPlace()),
-                     pOpKernelType(vartype::INT32, XPUPlace()),
-                     pOpKernelType(vartype::BOOL, XPUPlace()),
-                     pOpKernelType(vartype::INT8, XPUPlace()),
-                     pOpKernelType(vartype::UINT8, XPUPlace()),
-                     pOpKernelType(vartype::FP32, XPUPlace())})},
-      {"where_index", XPUKernelSet({pOpKernelType(vartype::BOOL, XPUPlace())})},
-      // AddMore
-  };
-
-  return s_xpu1_kernels;
-}
-
-}  // namespace platform
-}  // namespace paddle
-#endif

paddle/fluid/platform/device/xpu/xpu_op_list.cc

@@ -15,25 +15,14 @@ limitations under the License. */
 #include <string>
 #include <unordered_set>
 
-#include "paddle/fluid/platform/device/xpu/xpu1_op_list.h"
-#include "paddle/fluid/platform/device/xpu/xpu2_op_list.h"
+#include "paddle/fluid/framework/convert_utils.h"
 #include "paddle/fluid/platform/device/xpu/xpu_info.h"
 #include "paddle/fluid/platform/device/xpu/xpu_op_kpfirst_list.h"
+#include "paddle/phi/backends/xpu/xpu_op_list.h"
 
 namespace paddle {
 namespace platform {
 
-bool is_xpu_support_op(const std::string& op_name, const pOpKernelType& type) {
-  auto v = get_xpu_version(type.place_.device);
-  auto& ops = (v == phi::backends::xpu::XPUVersion::XPU1) ? get_kl1_ops()
-                                                          : get_kl2_ops();
-  if (ops.find(op_name) != ops.end() &&
-      ops[op_name].find(type) != ops[op_name].end()) {
-    return true;
-  }
-  return false;
-}
-
 // ops_string contains op_list(e.g., 'mul,mul_grad'), parse the op string and
 // insert op to op set
 static void tokenize(const std::string& ops,
@@ -50,18 +39,6 @@ static void tokenize(const std::string& ops,
 }
 
 #ifdef PADDLE_WITH_XPU_KP
-bool is_xpu_kp_support_op(const std::string& op_name,
-                          const pOpKernelType& type) {
-  auto v = get_xpu_version(type.place_.device);
-  auto& ops = (v == phi::backends::xpu::XPUVersion::XPU1) ? get_kl1_ops()
-                                                          : get_kp_ops();
-  if (ops.find(op_name) != ops.end() &&
-      ops[op_name].find(type) != ops[op_name].end()) {
-    return true;
-  }
-  return false;
-}
-
 bool is_in_xpu_kpwhite_list(const std::string& op_name) {
   static bool inited = false;
   static std::unordered_set<std::string> xpu_kpwhite_list;
@@ -88,49 +65,37 @@ bool is_in_xpu_kpwhite_list(const std::string& op_name) {
 }
 #endif
 
-#ifdef PADDLE_WITH_XPU_KP
-std::vector<vartype::Type> get_xpu_kp_op_support_type(
-    const std::string& op_name, phi::backends::xpu::XPUVersion version) {
-  std::vector<vartype::Type> res;
-  auto& ops = version == phi::backends::xpu::XPUVersion::XPU1 ? get_kl1_ops()
-                                                              : get_kp_ops();
-  if (ops.find(op_name) != ops.end()) {
-    XPUKernelSet& type_set = ops[op_name];
-    for (auto& item : type_set) {
-      res.push_back(item.data_type_);
-    }
-  }
-  return res;
-}
-#endif
-
 std::vector<vartype::Type> get_xpu_op_support_type(
     const std::string& op_name, phi::backends::xpu::XPUVersion version) {
+  auto& ops = version == phi::backends::xpu::XPUVersion::XPU1
+                  ? phi::backends::xpu::get_kl1_ops()
+                  : phi::backends::xpu::get_kl2_ops();
   std::vector<vartype::Type> res;
-  auto& ops = version == phi::backends::xpu::XPUVersion::XPU1 ? get_kl1_ops()
-                                                              : get_kl2_ops();
   if (ops.find(op_name) != ops.end()) {
-    XPUKernelSet& type_set = ops[op_name];
-    for (auto& item : type_set) {
-      res.push_back(item.data_type_);
+    auto& dtypes = ops[op_name];
+    for (auto& type : dtypes) {
+      res.push_back(static_cast<vartype::Type>(phi::TransToProtoVarType(type)));
     }
   }
   return res;
 }
 
 XPUOpListMap get_xpu_op_list(phi::backends::xpu::XPUVersion version) {
+  auto& ops = version == phi::backends::xpu::XPUVersion::XPU1
+                  ? phi::backends::xpu::get_kl1_ops()
+                  : phi::backends::xpu::get_kl2_ops();
   XPUOpListMap res;
-  auto& ops = version == phi::backends::xpu::XPUVersion::XPU1 ? get_kl1_ops()
-                                                              : get_kl2_ops();
   for (auto& op : ops) {
-    std::vector<vartype::Type> op_vartypes;
+    std::vector<vartype::Type> op_types;
     for (auto& item : op.second) {
-      op_vartypes.push_back(item.data_type_);
+      op_types.push_back(
+          static_cast<vartype::Type>(phi::TransToProtoVarType(item)));
     }
-    res[op.first] = std::move(op_vartypes);
+    res[op.first] = std::move(op_types);
   }
   return res;
 }
+
 }  // namespace platform
 }  // namespace paddle
 #endif

paddle/fluid/platform/device/xpu/xpu_op_list.h

@@ -21,22 +21,17 @@ limitations under the License. */
 namespace paddle {
 namespace platform {
 
-using pOpKernelType = paddle::framework::OpKernelType;
-using vartype = paddle::framework::proto::VarType;
-using XPUOpListMap =
-    std::unordered_map<std::string, std::vector<vartype::Type>>;
-
-bool is_xpu_support_op(const std::string& op_name, const pOpKernelType& type);
 using phi::backends::xpu::is_in_xpu_black_list;
+using phi::backends::xpu::is_xpu_support_op;
 
 #ifdef PADDLE_WITH_XPU_KP
-bool is_xpu_kp_support_op(const std::string& op_name,
-                          const pOpKernelType& type);
 bool is_in_xpu_kpwhite_list(const std::string& op_name);
-std::vector<vartype::Type> get_xpu_kp_op_support_type(
-    const std::string& op_name, phi::backends::xpu::XPUVersion version);
 #endif
 
+using vartype = paddle::framework::proto::VarType;
+using XPUOpListMap =
+    std::unordered_map<std::string, std::vector<vartype::Type>>;
+
 std::vector<vartype::Type> get_xpu_op_support_type(
     const std::string& op_name, phi::backends::xpu::XPUVersion version);
 XPUOpListMap get_xpu_op_list(phi::backends::xpu::XPUVersion version);

paddle/fluid/pybind/place.cc

@@ -456,7 +456,7 @@ void BindPlace(pybind11::module &m) {  // NOLINT
 #ifdef PADDLE_WITH_XPU_KP
   m.def("get_xpu_device_op_support_types",
         [](const std::string &op_name, phi::backends::xpu::XPUVersion version) {
-          return platform::get_xpu_kp_op_support_type(op_name, version);
+          return platform::get_xpu_op_support_type(op_name, version);
         });
 #else
   m.def("get_xpu_device_op_support_types",

paddle/phi/backends/xpu/CMakeLists.txt

 cc_library(
   phi_xpu_op_list
-  SRCS xpu_op_list.cc
+  SRCS xpu_op_list.cc xpu1_op_list.cc xpu2_op_list.cc
   DEPS glog)

paddle/phi/backends/xpu/xpu1_op_list.cc

+/* Copyright (c) 2022 PaddlePaddle Authors. All Rights Reserved.
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or
+agreed to in writing, software distributed under the License is distributed on
+an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
+or implied. See the License for the specific language governing permissions and
+limitations under the License. */
+
+#ifdef PADDLE_WITH_XPU
+#include <string>
+#include <unordered_map>
+#include <unordered_set>
+#include "paddle/phi/backends/xpu/xpu_op_list.h"
+
+namespace phi {
+namespace backends {
+namespace xpu {
+
+XPUOpMap& get_kl1_ops() {
+  // KL1支持的op，通过op_name, data_type
+  static XPUOpMap s_xpu1_kernels{
+      // AddMore
+  };
+
+  PD_THROW("get_kl1_ops unsupported");
+  return s_xpu1_kernels;
+}
+
+}  // namespace xpu
+}  // namespace backends
+}  // namespace phi
+#endif

paddle/phi/backends/xpu/xpu2_op_list.cc

+/* Copyright (c) 2022 PaddlePaddle Authors. All Rights Reserved.
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or
+agreed to in writing, software distributed under the License is distributed on
+an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
+or implied. See the License for the specific language governing permissions and
+limitations under the License. */
+
+#ifdef PADDLE_WITH_XPU
+#include <string>
+#include <unordered_map>
+#include <unordered_set>
+#include "paddle/phi/backends/xpu/xpu_op_list.h"
+
+namespace phi {
+namespace backends {
+namespace xpu {
+
+XPUOpMap& get_kl2_ops() {
+  // KL2支持的op，通过op_name, data_type, place来索引
+  static XPUOpMap s_xpu2_kernels{
+      {"abs", XPUKernelSet({phi::DataType::FLOAT32})},
+      {"abs_grad",
+       XPUKernelSet({phi::DataType::FLOAT32, phi::DataType::FLOAT16})},
+      {"adadelta", XPUKernelSet({phi::DataType::FLOAT32})},
+      {"adamw", XPUKernelSet({phi::DataType::FLOAT32, phi::DataType::FLOAT16})},
+      {"adam", XPUKernelSet({phi::DataType::FLOAT32, phi::DataType::FLOAT16})},
+      {"arg_max", XPUKernelSet({phi::DataType::FLOAT32})},
+      {"argsort_grad",
+       XPUKernelSet({phi::DataType::INT32,
+                     phi::DataType::INT64,
+                     phi::DataType::FLOAT32})},
+      {"argsort",
+       XPUKernelSet({phi::DataType::INT32,
+                     phi::DataType::INT64,
+                     phi::DataType::FLOAT32})},
+      {"assign",
+       XPUKernelSet({phi::DataType::FLOAT32,
+                     phi::DataType::FLOAT64,
+                     phi::DataType::INT32,
+                     phi::DataType::INT64,
+                     phi::DataType::BOOL})},
+      {"assign_value", XPUKernelSet({phi::DataType::FLOAT32})},
+      {"batch_norm_grad", XPUKernelSet({phi::DataType::FLOAT32})},
+      {"batch_norm", XPUKernelSet({phi::DataType::FLOAT32})},
+      {"bmm", XPUKernelSet({phi::DataType::FLOAT32})},
+      {"bmm_grad", XPUKernelSet({phi::DataType::FLOAT32})},
+      {"bce_loss_grad", XPUKernelSet({phi::DataType::FLOAT32})},
+      {"bce_loss", XPUKernelSet({phi::DataType::FLOAT32})},
+      {"beam_search",
+       XPUKernelSet({phi::DataType::FLOAT32,
+                     phi::DataType::FLOAT64,
+                     phi::DataType::INT32,
+                     phi::DataType::INT64})},
+      {"beam_search_decode",
+       XPUKernelSet({phi::DataType::FLOAT32,
+                     phi::DataType::FLOAT64,
+                     phi::DataType::FLOAT16,
+                     phi::DataType::INT32,
+                     phi::DataType::INT64})},
+      {"bilinear_interp_v2", XPUKernelSet({phi::DataType::FLOAT32})},
+      {"bilinear_interp_v2_grad", XPUKernelSet({phi::DataType::FLOAT32})},
+      {"broadcast", XPUKernelSet({phi::DataType::FLOAT32})},
+      {"c_allgather",
+       XPUKernelSet({phi::DataType::FLOAT16,
+                     phi::DataType::FLOAT32,
+                     phi::DataType::FLOAT64,
+                     phi::DataType::INT32,
+                     phi::DataType::INT64})},
+      {"c_allreduce_sum",
+       XPUKernelSet({phi::DataType::FLOAT16,
+                     phi::DataType::FLOAT32,
+                     phi::DataType::INT32})},
+      {"c_embedding", XPUKernelSet({phi::DataType::FLOAT32})},
+      {"c_identity",
+       XPUKernelSet({phi::DataType::FLOAT16,
+                     phi::DataType::FLOAT32,
+                     phi::DataType::FLOAT64,
+                     phi::DataType::INT32,
+                     phi::DataType::INT64})},
+      {"c_sync_calc_stream", XPUKernelSet({phi::DataType::FLOAT32})},
+      {"c_sync_comm_stream", XPUKernelSet({phi::DataType::FLOAT32})},
+      {"cast",
+       XPUKernelSet({phi::DataType::FLOAT32,
+                     phi::DataType::FLOAT16,
+                     phi::DataType::FLOAT64,
+                     phi::DataType::BOOL,
+                     phi::DataType::UINT8,
+                     phi::DataType::INT64,
+                     phi::DataType::INT32})},
+      {"check_finite_and_unscale",
+       XPUKernelSet({phi::DataType::FLOAT32, phi::DataType::FLOAT16})},
+      {"clip", XPUKernelSet({phi::DataType::FLOAT32})},
+      {"clip_by_norm", XPUKernelSet({phi::DataType::FLOAT32})},
+      {"coalesce_tensor", XPUKernelSet({phi::DataType::FLOAT32})},
+      {"concat_grad",
+       XPUKernelSet({phi::DataType::FLOAT32, phi::DataType::FLOAT16})},
+      {"concat",
+       XPUKernelSet({phi::DataType::FLOAT32,
+                     phi::DataType::FLOAT16,
+                     phi::DataType::INT64})},
+      {"conv2d_grad",
+       XPUKernelSet({phi::DataType::FLOAT32, phi::DataType::FLOAT16})},
+      {"conv2d",
+       XPUKernelSet({phi::DataType::FLOAT32, phi::DataType::FLOAT16})},
+      {"conv3d_grad",
+       XPUKernelSet({phi::DataType::FLOAT32, phi::DataType::FLOAT16})},
+      {"conv3d",
+       XPUKernelSet({phi::DataType::FLOAT32, phi::DataType::FLOAT16})},
+      {"conv2d_transpose_grad", XPUKernelSet({phi::DataType::FLOAT32})},
+      {"conv2d_transpose", XPUKernelSet({phi::DataType::FLOAT32})},
+      {"cumsum",
+       XPUKernelSet({phi::DataType::FLOAT32,
+                     phi::DataType::INT32,
+                     phi::DataType::INT64})},
+      {"deformable_conv_grad", XPUKernelSet({phi::DataType::FLOAT32})},
+      {"deformable_conv", XPUKernelSet({phi::DataType::FLOAT32})},
+      {"depthwise_conv2d_grad", XPUKernelSet({phi::DataType::FLOAT32})},
+      {"depthwise_conv2d", XPUKernelSet({phi::DataType::FLOAT32})},
+      {"dropout_grad",
+       XPUKernelSet({phi::DataType::FLOAT32, phi::DataType::FLOAT16})},
+      {"dropout",
+       XPUKernelSet({phi::DataType::FLOAT32, phi::DataType::FLOAT16})},
+      {"elementwise_add_grad",
+       XPUKernelSet({phi::DataType::FLOAT32, phi::DataType::FLOAT16})},
+      {"elementwise_add",
+       XPUKernelSet({phi::DataType::FLOAT32, phi::DataType::FLOAT16})},
+      {"elementwise_div_grad",
+       XPUKernelSet({phi::DataType::FLOAT32, phi::DataType::FLOAT16})},
+      {"elementwise_div",
+       XPUKernelSet({phi::DataType::FLOAT32, phi::DataType::FLOAT16})},
+      {"elementwise_floordiv",
+       XPUKernelSet({phi::DataType::FLOAT32, phi::DataType::FLOAT16})},
+      {"elementwise_max_grad",
+       XPUKernelSet({phi::DataType::FLOAT32, phi::DataType::FLOAT16})},
+      {"elementwise_max",
+       XPUKernelSet({phi::DataType::FLOAT32, phi::DataType::FLOAT16})},
+      {"elementwise_min_grad",
+       XPUKernelSet({phi::DataType::FLOAT32, phi::DataType::FLOAT16})},
+      {"elementwise_min",
+       XPUKernelSet({phi::DataType::FLOAT32, phi::DataType::FLOAT16})},
+      {"elementwise_mul_grad",
+       XPUKernelSet({phi::DataType::FLOAT32, phi::DataType::FLOAT16})},
+      {"elementwise_mul",
+       XPUKernelSet({phi::DataType::FLOAT32, phi::DataType::FLOAT16})},
+      {"elementwise_pow",
+       XPUKernelSet({phi::DataType::FLOAT32, phi::DataType::FLOAT16})},
+      {"elementwise_sub_grad",
+       XPUKernelSet({phi::DataType::FLOAT32, phi::DataType::FLOAT16})},
+      {"elementwise_sub",
+       XPUKernelSet({phi::DataType::FLOAT32,
+                     phi::DataType::FLOAT16,
+                     phi::DataType::INT64})},
+      {"elementwise_mod",
+       XPUKernelSet({phi::DataType::FLOAT32,
+                     phi::DataType::FLOAT16,
+                     phi::DataType::INT64,
+                     phi::DataType::INT32})},
+      {"empty",
+       XPUKernelSet({phi::DataType::INT64,
+                     phi::DataType::INT32,
+                     phi::DataType::INT16,
+                     phi::DataType::INT8,
+                     phi::DataType::UINT8,
+                     phi::DataType::BOOL,
+                     phi::DataType::FLOAT16,
+                     phi::DataType::FLOAT32,
+                     phi::DataType::FLOAT64})},
+      {"embedding_sparse_grad", XPUKernelSet({phi::DataType::FLOAT32})},
+      {"equal",
+       XPUKernelSet({phi::DataType::INT64,
+                     phi::DataType::INT32,
+                     phi::DataType::FLOAT32})},
+      {"exp_grad", XPUKernelSet({phi::DataType::FLOAT32})},
+      {"exp", XPUKernelSet({phi::DataType::FLOAT32})},
+      {"expand_as_v2",
+       XPUKernelSet({phi::DataType::INT32,
+                     phi::DataType::INT64,
+                     phi::DataType::BOOL,
+                     phi::DataType::FLOAT16,
+                     phi::DataType::FLOAT32})},
+      {"expand_v2",
+       XPUKernelSet({phi::DataType::INT32,
+                     phi::DataType::INT64,
+                     phi::DataType::BOOL,
+                     phi::DataType::FLOAT16,
+                     phi::DataType::FLOAT32})},
+      {"fill_any_like",
+       XPUKernelSet({phi::DataType::INT64,
+                     phi::DataType::INT32,
+                     phi::DataType::FLOAT16,
+                     phi::DataType::FLOAT32})},
+      {"fill_constant",
+       XPUKernelSet({phi::DataType::INT64,
+                     phi::DataType::INT32,
+                     phi::DataType::INT16,
+                     phi::DataType::UINT8,
+                     phi::DataType::BOOL,
+                     phi::DataType::FLOAT64,
+                     phi::DataType::FLOAT32,
+                     phi::DataType::FLOAT16,
+                     phi::DataType::COMPLEX64,
+                     phi::DataType::COMPLEX128})},
+      {"flatten2_grad",
+       XPUKernelSet({phi::DataType::INT64,
+                     phi::DataType::INT32,
+                     phi::DataType::INT8,
+                     phi::DataType::FLOAT32})},
+      {"flatten2",
+       XPUKernelSet({phi::DataType::INT64,
+                     phi::DataType::INT32,
+                     phi::DataType::INT8,
+                     phi::DataType::FLOAT32})},
+      {"flatten_contiguous_range_grad",
+       XPUKernelSet({phi::DataType::INT64,
+                     phi::DataType::INT32,
+                     phi::DataType::INT8,
+                     phi::DataType::FLOAT16,
+                     phi::DataType::FLOAT32})},
+      {"flatten_contiguous_range",
+       XPUKernelSet({phi::DataType::INT64,
+                     phi::DataType::INT32,
+                     phi::DataType::INT8,
+                     phi::DataType::FLOAT16,
+                     phi::DataType::FLOAT32})},
+      {"flatten_grad",
+       XPUKernelSet({phi::DataType::INT64,
+                     phi::DataType::INT32,
+                     phi::DataType::INT8,
+                     phi::DataType::FLOAT32})},
+      {"flatten",
+       XPUKernelSet({phi::DataType::INT64,
+                     phi::DataType::INT32,
+                     phi::DataType::INT8,
+                     phi::DataType::FLOAT32})},
+      {"unfold",
+       XPUKernelSet({phi::DataType::FLOAT32, phi::DataType::FLOAT16})},
+      {"unfold_grad",
+       XPUKernelSet({phi::DataType::FLOAT32, phi::DataType::FLOAT16})},
+      {"floor", XPUKernelSet({phi::DataType::FLOAT32})},
+      {"gather_grad",
+       XPUKernelSet({phi::DataType::FLOAT32, phi::DataType::FLOAT16})},
+      {"gather_nd",
+       XPUKernelSet({phi::DataType::INT32,
+                     phi::DataType::INT64,
+                     phi::DataType::FLOAT32})},
+      {"gather",
+       XPUKernelSet({phi::DataType::FLOAT32, phi::DataType::FLOAT16})},
+      {"gaussian_random", XPUKernelSet({phi::DataType::FLOAT32})},
+      {"gelu_grad",
+       XPUKernelSet({phi::DataType::FLOAT32, phi::DataType::FLOAT16})},
+      {"gelu", XPUKernelSet({phi::DataType::FLOAT32, phi::DataType::FLOAT16})},
+      {"generate_proposals_v2", XPUKernelSet({phi::DataType::FLOAT32})},
+      {"grad_add",
+       XPUKernelSet({phi::DataType::FLOAT32, phi::DataType::FLOAT16})},
+      {"greater_equal",
+       XPUKernelSet({phi::DataType::INT64,
+                     phi::DataType::INT32,
+                     phi::DataType::FLOAT32})},
+      {"greater_than",
+       XPUKernelSet({phi::DataType::INT64,
+                     phi::DataType::INT32,
+                     phi::DataType::FLOAT32})},
+      {"grid_sampler", XPUKernelSet({phi::DataType::FLOAT32})},
+      {"hard_sigmoid_grad", XPUKernelSet({phi::DataType::FLOAT32})},
+      {"hard_sigmoid", XPUKernelSet({phi::DataType::FLOAT32})},
+      {"hard_swish_grad",
+       XPUKernelSet({phi::DataType::FLOAT32, phi::DataType::FLOAT16})},
+      {"hard_swish", XPUKernelSet({phi::DataType::FLOAT32})},
+      {"huber_loss_grad", XPUKernelSet({phi::DataType::FLOAT32})},
+      {"huber_loss", XPUKernelSet({phi::DataType::FLOAT32})},
+      {"kldiv_loss", XPUKernelSet({phi::DataType::FLOAT32})},
+      {"kldiv_loss_grad", XPUKernelSet({phi::DataType::FLOAT32})},
+      {"iou_similarity", XPUKernelSet({phi::DataType::FLOAT32})},
+      {"index_select",
+       XPUKernelSet({phi::DataType::FLOAT32,
+                     phi::DataType::INT32,
+                     phi::DataType::INT64})},
+      {"instance_norm", XPUKernelSet({phi::DataType::FLOAT32})},
+      {"instance_norm_grad", XPUKernelSet({phi::DataType::FLOAT32})},
+      {"label_smooth", XPUKernelSet({phi::DataType::FLOAT32})},
+      {"lamb", XPUKernelSet({phi::DataType::FLOAT32, phi::DataType::FLOAT16})},
+      {"lars_momentum",
+       XPUKernelSet({phi::DataType::FLOAT32, phi::DataType::FLOAT16})},
+      {"layer_norm_grad",
+       XPUKernelSet({phi::DataType::FLOAT32, phi::DataType::FLOAT16})},
+      {"layer_norm",
+       XPUKernelSet({phi::DataType::FLOAT32, phi::DataType::FLOAT16})},
+      {"leaky_relu_grad", XPUKernelSet({phi::DataType::FLOAT32})},
+      {"leaky_relu", XPUKernelSet({phi::DataType::FLOAT32})},
+      {"less_equal",
+       XPUKernelSet({phi::DataType::INT64,
+                     phi::DataType::INT32,
+                     phi::DataType::FLOAT32})},
+      {"less_than",
+       XPUKernelSet({phi::DataType::INT64,
+                     phi::DataType::INT32,
+                     phi::DataType::FLOAT32})},
+      {"load_combine",
+       XPUKernelSet({phi::DataType::FLOAT32,
+                     phi::DataType::FLOAT64,
+                     phi::DataType::INT8,
+                     phi::DataType::INT32,
+                     phi::DataType::INT64})},
+      {"log", XPUKernelSet({phi::DataType::FLOAT32})},
+      {"log_grad", XPUKernelSet({phi::DataType::FLOAT32})},
+      {"log_softmax", XPUKernelSet({phi::DataType::FLOAT32})},
+      {"log_softmax_grad", XPUKernelSet({phi::DataType::FLOAT32})},
+      {"lookup_table_v2_grad", XPUKernelSet({phi::DataType::FLOAT32})},
+      {"lookup_table_v2", XPUKernelSet({phi::DataType::FLOAT32})},
+      {"masked_select",
+       XPUKernelSet({phi::DataType::INT32,
+                     phi::DataType::INT64,
+                     phi::DataType::FLOAT16,
+                     phi::DataType::FLOAT32})},
+      {"masked_select_grad",
+       XPUKernelSet({phi::DataType::INT32,
+                     phi::DataType::INT64,
+                     phi::DataType::BOOL,
+                     phi::DataType::FLOAT16,
+                     phi::DataType::FLOAT32})},
+      {"matmul_grad",
+       XPUKernelSet({phi::DataType::FLOAT32, phi::DataType::FLOAT16})},
+      {"matmul_v2_grad",
+       XPUKernelSet({phi::DataType::FLOAT32, phi::DataType::FLOAT16})},
+      {"matmul_v2",
+       XPUKernelSet({phi::DataType::FLOAT32, phi::DataType::FLOAT16})},
+      {"matmul",
+       XPUKernelSet({phi::DataType::FLOAT32, phi::DataType::FLOAT16})},
+      {"mean_grad",
+       XPUKernelSet({phi::DataType::FLOAT32, phi::DataType::FLOAT16})},
+      {"mean", XPUKernelSet({phi::DataType::FLOAT32, phi::DataType::FLOAT16})},
+      {"merged_momentum",
+       XPUKernelSet({phi::DataType::FLOAT32, phi::DataType::FLOAT16})},
+      {"mish_grad", XPUKernelSet({phi::DataType::FLOAT32})},
+      {"mish", XPUKernelSet({phi::DataType::FLOAT32})},
+      {"momentum",
+       XPUKernelSet({phi::DataType::FLOAT32, phi::DataType::FLOAT16})},
+      {"mul", XPUKernelSet({phi::DataType::FLOAT32, phi::DataType::FLOAT16})},
+      {"mul_grad",
+       XPUKernelSet({phi::DataType::FLOAT32, phi::DataType::FLOAT16})},
+      {"nearest_interp_v2", XPUKernelSet({phi::DataType::FLOAT32})},
+      {"nearest_interp_v2_grad", XPUKernelSet({phi::DataType::FLOAT32})},
+      {"not_equal",
+       XPUKernelSet({phi::DataType::INT64,
+                     phi::DataType::INT32,
+                     phi::DataType::FLOAT32})},
+      {"one_hot", XPUKernelSet({phi::DataType::INT32, phi::DataType::INT64})},
+      {"one_hot_v2",
+       XPUKernelSet({phi::DataType::INT32, phi::DataType::INT64})},
+      {"p_norm", XPUKernelSet({phi::DataType::FLOAT32})},
+      {"p_norm_grad", XPUKernelSet({phi::DataType::FLOAT32})},
+      {"pad3d_grad", XPUKernelSet({phi::DataType::FLOAT32})},
+      {"pad3d", XPUKernelSet({phi::DataType::FLOAT32})},
+      {"pool2d_grad",
+       XPUKernelSet({phi::DataType::FLOAT32, phi::DataType::FLOAT16})},
+      {"pool2d",
+       XPUKernelSet({phi::DataType::FLOAT32, phi::DataType::FLOAT16})},
+      {"pow", XPUKernelSet({phi::DataType::FLOAT32})},
+      {"pow_grad", XPUKernelSet({phi::DataType::FLOAT32})},
+      {"pow2_decay_with_linear_warmup", XPUKernelSet({phi::DataType::FLOAT32})},
+      {"prior_box", XPUKernelSet({phi::DataType::FLOAT32})},
+      {"range", XPUKernelSet({phi::DataType::FLOAT32, phi::DataType::INT64})},
+      {"reciprocal", XPUKernelSet({phi::DataType::FLOAT32})},
+      {"reciprocal_grad",
+       XPUKernelSet({phi::DataType::FLOAT32, phi::DataType::FLOAT16})},
+      {"reduce_max_grad", XPUKernelSet({phi::DataType::FLOAT32})},
+      {"reduce_max", XPUKernelSet({phi::DataType::FLOAT32})},
+      {"reduce_mean_grad", XPUKernelSet({phi::DataType::FLOAT32})},
+      {"reduce_mean", XPUKernelSet({phi::DataType::FLOAT32})},
+      {"reduce_min", XPUKernelSet({phi::DataType::FLOAT32})},
+      {"reduce_prod", XPUKernelSet({phi::DataType::FLOAT32})},
+      {"reduce_sum_grad", XPUKernelSet({phi::DataType::FLOAT32})},
+      {"reduce_sum", XPUKernelSet({phi::DataType::FLOAT32})},
+      {"relu6", XPUKernelSet({phi::DataType::FLOAT32})},
+      {"relu6_grad", XPUKernelSet({phi::DataType::FLOAT32})},
+      {"relu_grad",
+       XPUKernelSet({phi::DataType::FLOAT32, phi::DataType::FLOAT16})},
+      {"relu", XPUKernelSet({phi::DataType::FLOAT32, phi::DataType::FLOAT16})},
+      {"reshape2_grad",
+       XPUKernelSet({phi::DataType::FLOAT64,
+                     phi::DataType::FLOAT16,
+                     phi::DataType::INT64,
+                     phi::DataType::INT32,
+                     phi::DataType::BOOL,
+                     phi::DataType::FLOAT32})},
+      {"reshape2",
+       XPUKernelSet({phi::DataType::FLOAT64,
+                     phi::DataType::FLOAT16,
+                     phi::DataType::INT64,
+                     phi::DataType::INT32,
+                     phi::DataType::BOOL,
+                     phi::DataType::FLOAT32})},
+      {"resnet_unit",
+       XPUKernelSet({phi::DataType::FLOAT16, phi::DataType::FLOAT32})},
+      {"resnet_unit_grad",
+       XPUKernelSet({phi::DataType::FLOAT16, phi::DataType::FLOAT32})},
+      {"rmsprop", XPUKernelSet({phi::DataType::FLOAT32})},
+      {"rnn", XPUKernelSet({phi::DataType::FLOAT32})},
+      {"rnn_grad", XPUKernelSet({phi::DataType::FLOAT32})},
+      {"roi_align", XPUKernelSet({phi::DataType::FLOAT32})},
+      {"roi_align_grad", XPUKernelSet({phi::DataType::FLOAT32})},
+      {"roll", XPUKernelSet({phi::DataType::FLOAT32})},
+      {"roll_grad", XPUKernelSet({phi::DataType::FLOAT32})},
+      {"scale",
+       XPUKernelSet({phi::DataType::FLOAT32,
+                     phi::DataType::FLOAT16,
+                     phi::DataType::INT64})},
+      {"scatter",
+       XPUKernelSet({phi::DataType::INT64,
+                     phi::DataType::INT32,
+                     phi::DataType::FLOAT32})},
+      {"sampling_id",
+       XPUKernelSet({phi::DataType::FLOAT32, phi::DataType::FLOAT64})},
+      {"sgd", XPUKernelSet({phi::DataType::FLOAT32, phi::DataType::FLOAT16})},
+      {"sgd_dense_param_sparse_grad",
+       XPUKernelSet({phi::DataType::FLOAT32, phi::DataType::FLOAT16})},
+      {"silu_grad",
+       XPUKernelSet({phi::DataType::FLOAT32, phi::DataType::FLOAT16})},
+      {"silu", XPUKernelSet({phi::DataType::FLOAT32, phi::DataType::FLOAT16})},
+      {"sigmoid_cross_entropy_with_logits_grad",
+       XPUKernelSet({phi::DataType::FLOAT32})},
+      {"sigmoid_cross_entropy_with_logits",
+       XPUKernelSet({phi::DataType::FLOAT32})},
+      {"shape", XPUKernelSet({phi::DataType::FLOAT32, phi::DataType::INT64})},
+      {"sigmoid", XPUKernelSet({phi::DataType::FLOAT32})},
+      {"sigmoid_grad", XPUKernelSet({phi::DataType::FLOAT32})},
+      {"sign", XPUKernelSet({phi::DataType::FLOAT32})},
+      {"slice_grad",
+       XPUKernelSet({phi::DataType::FLOAT32,
+                     phi::DataType::FLOAT16,
+                     phi::DataType::INT32})},
+      {"slice",
+       XPUKernelSet({phi::DataType::FLOAT32,
+                     phi::DataType::FLOAT16,
+                     phi::DataType::INT32,
+                     phi::DataType::INT64})},
+      {"softmax",
+       XPUKernelSet({phi::DataType::FLOAT32, phi::DataType::FLOAT16})},
+      {"softmax_grad",
+       XPUKernelSet({phi::DataType::FLOAT32, phi::DataType::FLOAT16})},
+      {"softmax_with_cross_entropy_grad",
+       XPUKernelSet({phi::DataType::FLOAT32, phi::DataType::FLOAT16})},
+      {"softmax_with_cross_entropy",
+       XPUKernelSet({phi::DataType::FLOAT32, phi::DataType::FLOAT16})},
+      {"softplus", XPUKernelSet({phi::DataType::FLOAT32})},
+      {"softplus_grad", XPUKernelSet({phi::DataType::FLOAT32})},
+      {"split",
+       XPUKernelSet({phi::DataType::FLOAT32,
+                     phi::DataType::FLOAT16,
+                     phi::DataType::INT32})},
+      {"split_with_num",
+       XPUKernelSet({phi::DataType::FLOAT32,
+                     phi::DataType::FLOAT16,
+                     phi::DataType::INT32})},
+      {"sqrt", XPUKernelSet({phi::DataType::FLOAT32})},
+      {"sqrt_grad", XPUKernelSet({phi::DataType::FLOAT32})},
+      {"square_grad", XPUKernelSet({phi::DataType::FLOAT32})},
+      {"square",
+       XPUKernelSet({phi::DataType::FLOAT32, phi::DataType::FLOAT16})},
+      {"squeeze2_grad",
+       XPUKernelSet({phi::DataType::FLOAT64,
+                     phi::DataType::INT64,
+                     phi::DataType::INT32,
+                     phi::DataType::BOOL,
+                     phi::DataType::INT8,
+                     phi::DataType::UINT8,
+                     phi::DataType::FLOAT32})},
+      {"squeeze2",
+       XPUKernelSet({phi::DataType::FLOAT64,
+                     phi::DataType::INT64,
+                     phi::DataType::INT32,
+                     phi::DataType::BOOL,
+                     phi::DataType::INT8,
+                     phi::DataType::UINT8,
+                     phi::DataType::FLOAT32})},
+      {"squeeze_grad",
+       XPUKernelSet({phi::DataType::FLOAT64,
+                     phi::DataType::INT64,
+                     phi::DataType::INT32,
+                     phi::DataType::BOOL,
+                     phi::DataType::INT8,
+                     phi::DataType::UINT8,
+                     phi::DataType::FLOAT32})},
+      {"squeeze",
+       XPUKernelSet({phi::DataType::FLOAT64,
+                     phi::DataType::INT64,
+                     phi::DataType::INT32,
+                     phi::DataType::BOOL,
+                     phi::DataType::INT8,
+                     phi::DataType::UINT8,
+                     phi::DataType::FLOAT32})},
+      {"stack",
+       XPUKernelSet({phi::DataType::FLOAT32,
+                     phi::DataType::INT64,
+                     phi::DataType::INT32})},
+      {"stack_grad",
+       XPUKernelSet({phi::DataType::FLOAT32, phi::DataType::INT32})},
+      {"strided_slice",
+       XPUKernelSet({phi::DataType::FLOAT32,
+                     phi::DataType::FLOAT16,
+                     phi::DataType::INT16,
+                     phi::DataType::INT32})},
+      {"strided_slice_grad",
+       XPUKernelSet({phi::DataType::FLOAT32,
+                     phi::DataType::FLOAT16,
+                     phi::DataType::INT16,
+                     phi::DataType::INT32})},
+      {"sum", XPUKernelSet({phi::DataType::FLOAT32, phi::DataType::FLOAT16})},
+      {"swish", XPUKernelSet({phi::DataType::FLOAT32})},
+      {"swish_grad", XPUKernelSet({phi::DataType::FLOAT32})},
+      {"tanh_grad",
+       XPUKernelSet({phi::DataType::FLOAT32, phi::DataType::FLOAT16})},
+      {"tanh", XPUKernelSet({phi::DataType::FLOAT32, phi::DataType::FLOAT16})},
+      {"temporal_shift", XPUKernelSet({phi::DataType::FLOAT32})},
+      {"temporal_shift_grad", XPUKernelSet({phi::DataType::FLOAT32})},
+      {"tril_triu",
+       XPUKernelSet({phi::DataType::FLOAT32, phi::DataType::INT32})},
+      {"tril_triu_grad",
+       XPUKernelSet({phi::DataType::FLOAT32, phi::DataType::INT32})},
+      {"tile",
+       XPUKernelSet({phi::DataType::INT32,
+                     phi::DataType::INT64,
+                     phi::DataType::BOOL,
+                     phi::DataType::FLOAT32})},
+      {"transpose2_grad",
+       XPUKernelSet({phi::DataType::FLOAT32, phi::DataType::FLOAT16})},
+      {"transpose2",
+       XPUKernelSet({phi::DataType::FLOAT32, phi::DataType::FLOAT16})},
+      {"transpose_grad",
+       XPUKernelSet({phi::DataType::FLOAT32, phi::DataType::FLOAT16})},
+      {"transpose",
+       XPUKernelSet({phi::DataType::FLOAT32, phi::DataType::FLOAT16})},
+      {"truncated_gaussian_random", XPUKernelSet({phi::DataType::FLOAT32})},
+      {"top_k", XPUKernelSet({phi::DataType::FLOAT32, phi::DataType::FLOAT16})},
+      {"top_k_v2", XPUKernelSet({phi::DataType::FLOAT32})},
+      {"update_loss_scaling",
+       XPUKernelSet({phi::DataType::FLOAT32, phi::DataType::FLOAT16})},
+      {"uniform_random", XPUKernelSet({phi::DataType::FLOAT32})},
+      {"unsqueeze2_grad",
+       XPUKernelSet({phi::DataType::FLOAT64,
+                     phi::DataType::INT64,
+                     phi::DataType::INT32,
+                     phi::DataType::BOOL,
+                     phi::DataType::INT8,
+                     phi::DataType::UINT8,
+                     phi::DataType::FLOAT32,
+                     phi::DataType::FLOAT16})},
+      {"unsqueeze2",
+       XPUKernelSet({phi::DataType::FLOAT64,
+                     phi::DataType::INT64,
+                     phi::DataType::INT32,
+                     phi::DataType::BOOL,
+                     phi::DataType::INT8,
+                     phi::DataType::UINT8,
+                     phi::DataType::FLOAT32,
+                     phi::DataType::FLOAT16})},
+      {"unsqueeze_with_xshape",
+       XPUKernelSet({phi::DataType::FLOAT64,
+                     phi::DataType::INT64,
+                     phi::DataType::INT32,
+                     phi::DataType::BOOL,
+                     phi::DataType::INT8,
+                     phi::DataType::UINT8,
+                     phi::DataType::FLOAT32,
+                     phi::DataType::FLOAT16})},
+      {"unsqueeze_grad",
+       XPUKernelSet({phi::DataType::FLOAT64,
+                     phi::DataType::INT64,
+                     phi::DataType::INT32,
+                     phi::DataType::BOOL,
+                     phi::DataType::INT8,
+                     phi::DataType::UINT8,
+                     phi::DataType::FLOAT32})},
+      {"unsqueeze",
+       XPUKernelSet({phi::DataType::FLOAT64,
+                     phi::DataType::INT64,
+                     phi::DataType::INT32,
+                     phi::DataType::BOOL,
+                     phi::DataType::INT8,
+                     phi::DataType::UINT8,
+                     phi::DataType::FLOAT32})},
+      {"warpctc_grad", XPUKernelSet({phi::DataType::FLOAT32})},
+      {"warpctc", XPUKernelSet({phi::DataType::FLOAT32})},
+      {"where_index",
+       XPUKernelSet({phi::DataType::INT32,
+                     phi::DataType::BOOL,
+                     phi::DataType::FLOAT32})},
+      {"where",
+       XPUKernelSet({phi::DataType::INT32,
+                     phi::DataType::INT64,
+                     phi::DataType::FLOAT32})},
+
+      // AddMore
+      {"sequence_conv", XPUKernelSet({phi::DataType::FLOAT32})},
+      {"sequence_conv_grad", XPUKernelSet({phi::DataType::FLOAT32})},
+      {"sequence_unpad", XPUKernelSet({phi::DataType::FLOAT32})},
+      // Fused op
+      {"resnet_basic_block_grad", XPUKernelSet({phi::DataType::FLOAT32})},
+      {"resnet_basic_block", XPUKernelSet({phi::DataType::FLOAT32})},
+      {"fused_gemm_epilogue",
+       XPUKernelSet({phi::DataType::FLOAT32, phi::DataType::FLOAT16})},
+      {"fused_gemm_epilogue_grad",
+       XPUKernelSet({phi::DataType::FLOAT32, phi::DataType::FLOAT16})},
+      {"fused_attention",
+       XPUKernelSet({phi::DataType::FLOAT32, phi::DataType::FLOAT16})},
+      {"fused_attention_grad",
+       XPUKernelSet({phi::DataType::FLOAT32, phi::DataType::FLOAT16})},
+      {"fused_feedforward",
+       XPUKernelSet({phi::DataType::FLOAT32, phi::DataType::FLOAT16})},
+      {"fused_feedforward_grad",
+       XPUKernelSet({phi::DataType::FLOAT32, phi::DataType::FLOAT16})},
+  };
+
+  return s_xpu2_kernels;
+}
+
+}  // namespace xpu
+}  // namespace backends
+}  // namespace phi
+#endif

paddle/phi/backends/xpu/xpu_op_list.cc

@@ -10,11 +10,11 @@ See the License for the specific language governing permissions and
 limitations under the License. */
 #ifdef PADDLE_WITH_XPU
 #include "paddle/phi/backends/xpu/xpu_op_list.h"
-
 #include <glog/logging.h>
 #include <mutex>
 #include <string>
 #include <unordered_set>
+#include "paddle/phi/backends/xpu/xpu_info.h"
 
 namespace phi {
 namespace backends {
@@ -35,7 +35,7 @@ static void tokenize(const std::string& ops,
   op_set->insert(ops.substr(beg));
 }
 
-bool is_in_xpu_black_list(const std::string& op_name) {
+bool is_in_xpu_black_list(const std::string& fluid_op_name) {
   static bool inited = false;
   static std::unordered_set<std::string> xpu_black_list;
   static std::mutex s_mtx;
@@ -54,7 +54,20 @@ bool is_in_xpu_black_list(const std::string& op_name) {
       }
     }
   }
-  if (xpu_black_list.find(op_name) != xpu_black_list.end()) {
+  if (xpu_black_list.find(fluid_op_name) != xpu_black_list.end()) {
+    return true;
+  }
+  return false;
+}
+
+bool is_xpu_support_op(const std::string& fluid_op_name,
+                       const phi::DataType type) {
+  if (is_in_xpu_black_list(fluid_op_name)) return false;
+  auto v = get_xpu_version(0);
+  auto& ops = (v == phi::backends::xpu::XPUVersion::XPU1) ? get_kl1_ops()
+                                                          : get_kl2_ops();
+  if (ops.find(fluid_op_name) != ops.end() &&
+      ops[fluid_op_name].find(type) != ops[fluid_op_name].end()) {
     return true;
   }
   return false;

paddle/phi/backends/xpu/xpu_op_list.h

@@ -12,12 +12,23 @@ limitations under the License. */
 
 #ifdef PADDLE_WITH_XPU
 #include <string>
+#include <unordered_map>
+#include <unordered_set>
+#include "paddle/phi/common/data_type.h"
 
 namespace phi {
 namespace backends {
 namespace xpu {
 
-bool is_in_xpu_black_list(const std::string& op_name);
+using XPUKernelSet = std::unordered_set<phi::DataType>;
+using XPUOpMap = std::unordered_map<std::string, XPUKernelSet>;
+
+XPUOpMap& get_kl1_ops();
+XPUOpMap& get_kl2_ops();
+
+bool is_in_xpu_black_list(const std::string& fluid_op_name);
+bool is_xpu_support_op(const std::string& fluid_op_name,
+                       const phi::DataType type);
 
 }  // namespace xpu
 }  // namespace backends

paddle/phi/core/kernel_factory.cc

@@ -151,7 +151,8 @@ KernelResult KernelFactory::SelectKernelOrThrowError(
 #if defined(PADDLE_WITH_XPU) && !defined(PADDLE_WITH_XPU_KP)
   VLOG(6) << "fluid_op_name: " << TransToFluidOpName(kernel_name);
   if ((FLAGS_enable_api_kernel_fallback && kernel_iter == iter->second.end()) ||
-      phi::backends::xpu::is_in_xpu_black_list(TransToFluidOpName(kernel_name))
+      !phi::backends::xpu::is_xpu_support_op(TransToFluidOpName(kernel_name),
+                                             kernel_key.dtype())
 #else
   if ((FLAGS_enable_api_kernel_fallback && kernel_iter == iter->second.end())
 #endif