[IR] Refine PhiKernelOp attributes name and delete some unused code (#54891)

zhangbo9674 · web-flow · commit 9137adb92400 · 2023-06-28T20:48:19.000+08:00
* refine code

* add some interface for phi kernel op

* fix compile bug

* delete unused code

* support code

* fix bug

* refine code

* delete unused code

* fix compile bug

* fix compile bug

* delete unused code

* add elementwise add op

* fix compile bug
diff --git a/paddle/fluid/framework/new_executor/interpreter/interpreter_util.cc b/paddle/fluid/framework/new_executor/interpreter/interpreter_util.cc
@@ -967,8 +967,8 @@ void BuildOpFuncList(
 
     auto attr_info = std::get<1>(yaml_info);
 
-    op_func_node.infer_shape_interface_ =
-        op_info.GetInterfaceImpl<paddle::dialect::InferShapeInterface>();
+    op_func_node.infer_meta_interface_ =
+        op_info.GetInterfaceImpl<paddle::dialect::InferMetaInterface>();
 
     VLOG(6) << "op name" << op_func_node.phi_op_name_;
 
diff --git a/paddle/fluid/framework/new_executor/new_executor_defs.cc b/paddle/fluid/framework/new_executor/new_executor_defs.cc
@@ -161,7 +161,7 @@ Instruction::Instruction(size_t id,
     is_artificial_ = true;
   }
 
-  if (op_func_node_.infer_shape_interface_ != nullptr) {
+  if (op_func_node_.infer_meta_interface_ != nullptr) {
     pre_define_context_ = true;
   }
   PADDLE_ENFORCE_GE(id,
diff --git a/paddle/fluid/framework/new_executor/new_executor_defs.h b/paddle/fluid/framework/new_executor/new_executor_defs.h
@@ -20,7 +20,7 @@
 
 #include "paddle/fluid/framework/operator.h"
 #include "paddle/fluid/framework/variable_helper.h"
-#include "paddle/fluid/ir/interface/infershape.h"
+#include "paddle/fluid/ir/interface/infermeta.h"
 #include "paddle/fluid/platform/device_event_base.h"
 #include "paddle/fluid/platform/event.h"
 #include "paddle/phi/core/utils/rw_lock.h"
@@ -177,8 +177,7 @@ struct OpFuncNode {
   phi::KernelContext kernel_context_;
   phi::InferMetaContext infer_meta_context_;
   std::string phi_op_name_;
-  paddle::dialect::InferShapeInterface::Concept* infer_shape_interface_{
-      nullptr};
+  paddle::dialect::InferMetaInterface::Concept* infer_meta_interface_{nullptr};
 };
 
 class Instruction {
diff --git a/paddle/fluid/framework/new_executor/new_ir_interpreter.cc b/paddle/fluid/framework/new_executor/new_ir_interpreter.cc
@@ -963,7 +963,7 @@ void NewIRInterpreter::RunInstruction(const Instruction& instr_node) {
       VLOG(5) << "run new ir selected kernel";
       auto op_func_node = const_cast<OpFuncNode*>((instr_node.OpFunc()));
       VLOG(5) << "begin to run op " << op_func_node->phi_op_name_;
-      op_func_node->infer_shape_interface_->infer_shape_(
+      op_func_node->infer_meta_interface_->infer_meta_(
           &(op_func_node->infer_meta_context_));
       VLOG(5) << "after run infer meta";
       (*(op_func_node->phi_kernel_))(&(op_func_node->kernel_context_));
diff --git a/paddle/fluid/ir/dialect/CMakeLists.txt b/paddle/fluid/ir/dialect/CMakeLists.txt
@@ -17,8 +17,10 @@ set(op_backward_yaml_file2
     ${PADDLE_SOURCE_DIR}/paddle/fluid/operators/generator/parsed_ops/legacy_backward_ops.parsed.yaml
 )
 set(op_yaml_file3 ${PADDLE_SOURCE_DIR}/paddle/fluid/ir/dialect/pd_op.yaml)
+set(op_yaml_file4
+    ${PADDLE_SOURCE_DIR}/paddle/fluid/ir/dialect/pd_legacy_op.yaml)
 set(op_yaml_files
-    ${op_forward_yaml_file1},${op_forward_yaml_file2},${op_backward_yaml_file1},${op_backward_yaml_file2},${op_yaml_file3}
+    ${op_forward_yaml_file1},${op_forward_yaml_file2},${op_backward_yaml_file1},${op_backward_yaml_file2},${op_yaml_file3},${op_yaml_file4}
 )
 set(op_namespace paddle,dialect)
 set(dialect_name pd)
diff --git a/paddle/fluid/ir/dialect/kernel_op.cc b/paddle/fluid/ir/dialect/kernel_op.cc
@@ -13,21 +13,57 @@
 // limitations under the License.
 
 #include "paddle/fluid/ir/dialect/kernel_op.h"
+#include "paddle/fluid/ir/dialect/kernel_attribute.h"
+#include "paddle/ir/core/builtin_attribute.h"
+#include "paddle/phi/core/enforce.h"
 
 namespace paddle {
 namespace dialect {
 
-const char *PhiKernelOp::attributes_name[attributes_num] = {
-    "base_op", "infermeta_fn", "kernel_fn"};
+const char* PhiKernelOp::attributes_name[attributes_num] = {
+    "op_name", "kernel_name", "kernel_key"};
 
 void PhiKernelOp::Verify() {
   VLOG(4) << "Verifying inputs, outputs and attributes for: PhiKernelOp.";
 
-  // Verify inputs type:
+  auto& attributes = this->attributes();
 
-  // Verify if attributes contain attribute name in attributes_name:
-  //   if (!attributes.at("parameter_name").isa<StrAttribute>()) {
-  //     throw("Type of attribute: parameter_name is not right.");
+  PADDLE_ENFORCE(attributes.count("op_name") > 0 &&
+                     attributes.at("op_name").isa<ir::StrAttribute>(),
+                 phi::errors::PreconditionNotMet(
+                     "Type of attribute: op_name is not right."));
+
+  PADDLE_ENFORCE(attributes.count("kernel_name") > 0 &&
+                     attributes.at("kernel_name").isa<ir::StrAttribute>(),
+                 phi::errors::PreconditionNotMet(
+                     "Type of attribute: kernel_name is not right."));
+
+  PADDLE_ENFORCE(attributes.count("kernel_key") > 0 &&
+                     attributes.at("kernel_key").isa<KernelAttribute>(),
+                 phi::errors::PreconditionNotMet(
+                     "Type of attribute: kernel_key is not right."));
+}
+
+const std::string PhiKernelOp::op_name() {
+  return operation()
+      ->attributes()
+      .at("op_name")
+      .dyn_cast<ir::StrAttribute>()
+      .data();
+}
+const std::string PhiKernelOp::kernel_name() {
+  return operation()
+      ->attributes()
+      .at("kernel_name")
+      .dyn_cast<ir::StrAttribute>()
+      .data();
+}
+phi::KernelKey PhiKernelOp::kernel_key() {
+  return operation()
+      ->attributes()
+      .at("kernel_key")
+      .dyn_cast<KernelAttribute>()
+      .data();
 }
 
 }  // namespace dialect
diff --git a/paddle/fluid/ir/dialect/kernel_op.h b/paddle/fluid/ir/dialect/kernel_op.h
@@ -16,6 +16,7 @@
 
 #include "paddle/ir/core/builder.h"
 #include "paddle/ir/core/op_base.h"
+#include "paddle/phi/core/kernel_factory.h"
 
 namespace paddle {
 namespace dialect {
@@ -26,6 +27,9 @@ class PhiKernelOp : public ir::Op<PhiKernelOp> {
   static const char *name() { return "phi.kernel"; }
   static constexpr uint32_t attributes_num = 3;
   static const char *attributes_name[attributes_num];
+  const std::string op_name();
+  const std::string kernel_name();
+  phi::KernelKey kernel_key();
   void Verify();
 };
 
diff --git a/paddle/fluid/ir/dialect/op_gen.py b/paddle/fluid/ir/dialect/op_gen.py
@@ -39,7 +39,7 @@
 #include "paddle/fluid/ir/dialect/utils.h"
 #include "paddle/fluid/ir/dialect/op_yaml_info_util.h"
 #include "paddle/fluid/ir/interface/op_yaml_info.h"
-#include "paddle/fluid/ir/interface/infershape.h"
+#include "paddle/fluid/ir/interface/infermeta.h"
 #include "paddle/fluid/framework/infershape_utils.h"
 #include "paddle/phi/core/infermeta_utils.h"
 
@@ -143,7 +143,7 @@ class {op_name} : public ir::Op<{op_name}{interfaces}{traits}> {{
 }}
 """
 OP_INFER_SHAPE_TEMPLATE = """
-void {op_name}::InferShape( phi::InferMetaContext *infer_meta ) {{
+void {op_name}::InferMeta( phi::InferMetaContext *infer_meta ) {{
   auto fn = PD_INFER_META(phi::{infer_meta_func});
   fn(infer_meta);
 }}
@@ -298,9 +298,9 @@ def __init__(self, op_yaml_item, op_compat_item):
         self.infer_meta_map = self.parse_infer_meta_map()
         self.kernel_map = self.parse_kernel_map()
         if 'infer_meta' in self.op_yaml_item:
-            self.infer_shape_func = self.op_yaml_item['infer_meta']["func"]
+            self.infer_meta_func = self.op_yaml_item['infer_meta']["func"]
         else:
-            self.infer_shape_func = None
+            self.infer_meta_func = None
 
         # parse inplace && view
         self.inplace_map = self.parse_op_inplace_info()
@@ -1218,10 +1218,10 @@ def OpGenerator(
         op_traits = []
 
         exclusive_interface_str = ""
-        if op_info.infer_shape_func:
-            op_interfaces += ["InferShapeInterface"]
+        if op_info.infer_meta_func:
+            op_interfaces += ["InferMetaInterface"]
             exclusive_interface_str += (
-                "  static void InferShape( phi::InferMetaContext *infer_meta );"
+                "  static void InferMeta( phi::InferMetaContext *infer_meta );"
             )
 
         # If op has inplace info, we will generate inplace op and non-inplace op.
@@ -1472,11 +1472,11 @@ def OpGenerator(
                 op_output_optional_list,
             )
 
-            op_infer_shape_str = ""
-            if op_info.infer_shape_func:
-                op_infer_shape_str = OP_INFER_SHAPE_TEMPLATE.format(
+            op_infer_meta_str = ""
+            if op_info.infer_meta_func:
+                op_infer_meta_str = OP_INFER_SHAPE_TEMPLATE.format(
                     op_name=op_class_name,
-                    infer_meta_func=op_info.infer_shape_func,
+                    infer_meta_func=op_info.infer_meta_func,
                 )
 
             ops_name_list.append(op_class_name)
@@ -1487,7 +1487,7 @@ def OpGenerator(
             if len(op_mutable_attribute_name_list) > 0:
                 ops_defined_list.append(build_func_with_muta_attr_is_input)
             ops_defined_list.append(op_verify_str)
-            ops_defined_list.append(op_infer_shape_str)
+            ops_defined_list.append(op_infer_meta_str)
 
     # (4) Generate head file str
     op_namespaces_prev = ""
diff --git a/paddle/fluid/ir/dialect/pd_legacy_op.yaml b/paddle/fluid/ir/dialect/pd_legacy_op.yaml
@@ -0,0 +1,32 @@
+- name: elementwise_add
+  inputs:
+  - typename: Tensor
+    name: x
+    optional: false
+    no_need_buffer: false
+    data_transform: {}
+  - typename: Tensor
+    name: y
+    optional: false
+    no_need_buffer: false
+    data_transform: {}
+  attrs:
+  - {typename: int, name: axis}
+  outputs:
+  - {typename: Tensor, name: out, optional: false, intermediate: false}
+  no_need_buffer: null
+  data_transform: null
+  infer_meta:
+    func: ElementwiseInferMeta
+    param: [x, y]
+  kernel:
+    func: [add_raw]
+    param: [x, y]
+    backend: null
+    layout: null
+    data_type: null
+    dispatch: {add: null}
+    force_backend: null
+  inplace: {out: x}
+  view: null
+  backward: add_grad
diff --git a/paddle/fluid/ir/interface/infermeta.h b/paddle/fluid/ir/interface/infermeta.h
@@ -18,28 +18,28 @@
 
 namespace paddle {
 namespace dialect {
-class InferShapeInterface : public ir::OpInterfaceBase<InferShapeInterface> {
+class InferMetaInterface : public ir::OpInterfaceBase<InferMetaInterface> {
  public:
   struct Concept {
-    explicit Concept(void (*infer_shape)(phi::InferMetaContext *))
-        : infer_shape_(infer_shape) {}
-    void (*infer_shape_)(phi::InferMetaContext *);
+    explicit Concept(void (*infer_meta)(phi::InferMetaContext *))
+        : infer_meta_(infer_meta) {}
+    void (*infer_meta_)(phi::InferMetaContext *);
   };
 
   template <class ConcreteOp>
   struct Model : public Concept {
-    static void InferShape(phi::InferMetaContext *infer_meta) {
-      return ConcreteOp::InferShape(infer_meta);
+    static void InferMeta(phi::InferMetaContext *infer_meta) {
+      return ConcreteOp::InferMeta(infer_meta);
     }
 
-    Model() : Concept(InferShape) {}
+    Model() : Concept(InferMeta) {}
   };
 
-  InferShapeInterface(ir::Operation *op, Concept *impl)
-      : ir::OpInterfaceBase<InferShapeInterface>(op), impl_(impl) {}
+  InferMetaInterface(ir::Operation *op, Concept *impl)
+      : ir::OpInterfaceBase<InferMetaInterface>(op), impl_(impl) {}
 
-  void InferShape(phi::InferMetaContext *infer_meta) {
-    impl_->infer_shape_(infer_meta);
+  void InferMeta(phi::InferMetaContext *infer_meta) {
+    impl_->infer_meta_(infer_meta);
   }
 
  private:
@@ -49,4 +49,4 @@ class InferShapeInterface : public ir::OpInterfaceBase<InferShapeInterface> {
 }  // namespace dialect
 }  // namespace paddle
 
-IR_DECLARE_EXPLICIT_TYPE_ID(paddle::dialect::InferShapeInterface)
+IR_DECLARE_EXPLICIT_TYPE_ID(paddle::dialect::InferMetaInterface)
diff --git a/paddle/fluid/ir/interface/interface.cc b/paddle/fluid/ir/interface/interface.cc
@@ -12,8 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include "paddle/fluid/ir/interface/infershape.h"
+#include "paddle/fluid/ir/interface/infermeta.h"
 #include "paddle/fluid/ir/interface/op_yaml_info.h"
 
-IR_DEFINE_EXPLICIT_TYPE_ID(paddle::dialect::InferShapeInterface)
+IR_DEFINE_EXPLICIT_TYPE_ID(paddle::dialect::InferMetaInterface)
 IR_DEFINE_EXPLICIT_TYPE_ID(paddle::dialect::OpYamlInfoInterface)
diff --git a/paddle/fluid/ir/phi_kernel_adaptor/phi_kernel_adaptor.h b/paddle/fluid/ir/phi_kernel_adaptor/phi_kernel_adaptor.h
@@ -19,7 +19,7 @@
 #include "paddle/fluid/ir/dialect/pd_op.h"
 #include "paddle/fluid/ir/dialect/pd_type.h"
 #include "paddle/fluid/ir/dialect/utils.h"
-#include "paddle/fluid/ir/interface/infershape.h"
+#include "paddle/fluid/ir/interface/infermeta.h"
 #include "paddle/fluid/ir/interface/op_yaml_info.h"
 #include "paddle/ir/core/builtin_attribute.h"
 #include "paddle/ir/core/builtin_dialect.h"
@@ -52,59 +52,6 @@ class PhiKernelAdaptor {
  public:
   explicit PhiKernelAdaptor(paddle::framework::Scope* scope) : scope_(scope) {}
 
-  void run(ir::Program* program) {
-    auto block = program->block();
-    std::unordered_map<ir::Value, std::string> name_map;
-
-    ir::BuildScope(block, scope_, &name_map);
-
-    auto* dev_ctx = phi::DeviceContextPool::Instance().Get(phi::CPUPlace());
-    phi::Place cpu_place(phi::AllocationType::CPU);
-    for (auto it = block->begin(); it != block->end(); ++it) {
-      VLOG(6) << "begin to run op " << (*it)->name();
-
-      auto attr_map = (*it)->attributes();
-
-      paddle::dialect::OpYamlInfoInterface op_info_interface =
-          (*it)->dyn_cast<paddle::dialect::OpYamlInfoInterface>();
-      auto op_info_res = op_info_interface.GetOpInfo();
-
-      paddle::dialect::InferShapeInterface interface =
-          (*it)->dyn_cast<paddle::dialect::InferShapeInterface>();
-      phi::InferMetaContext ctx;
-
-      ir::BuildInferMetaContext((*it), name_map, scope_, op_info_res, &ctx);
-
-      interface.InferShape(&ctx);
-
-      auto runtime_info = std::get<3>(op_info_res);
-
-      auto phi_kernels = phi::KernelFactory::Instance().SelectKernelMap(
-          runtime_info.kernel_func[0]);
-
-      phi::KernelKey kernel_key(phi::TransToPhiBackend(cpu_place),
-                                phi::DataLayout::ANY,
-                                phi::DataType::FLOAT32);
-      if (runtime_info.kernel_func[0] == "full_int_array") {
-        kernel_key.set_dtype(phi::DataType::INT64);
-      }
-      auto found_it = phi_kernels.find(kernel_key);
-      if (found_it == phi_kernels.end()) {
-        PADDLE_THROW(paddle::platform::errors::NotFound(
-            "can not found kerenl for [%s]", (*it)->name()));
-      } else {
-        phi::KernelContext kernel_ctx(dev_ctx);
-
-        ir::BuildPhiKernelContext(
-            (*it), name_map, scope_, op_info_res, &kernel_ctx);
-        found_it->second(&kernel_ctx);
-
-        auto out_value = (*it)->result(0);
-        out_name = name_map[out_value];
-      }
-    }
-  }
-
   void run_kernel_prog(ir::Program* program) {
     auto block = program->block();
     std::unordered_map<ir::Value, std::string> name_map;
@@ -128,14 +75,14 @@ class PhiKernelAdaptor {
 
       auto attr_info = std::get<1>(yaml_info);
 
-      auto infer_shape_impl =
-          op1_info.GetInterfaceImpl<paddle::dialect::InferShapeInterface>();
+      auto infer_meta_impl =
+          op1_info.GetInterfaceImpl<paddle::dialect::InferMetaInterface>();
 
       phi::InferMetaContext ctx;
 
       ir::BuildInferMetaContext((*it), name_map, scope_, yaml_info, &ctx);
 
-      infer_shape_impl->infer_shape_(&ctx);
+      infer_meta_impl->infer_meta_(&ctx);
 
       auto kernel_name =
           attr_map.at("kernel_name").dyn_cast<ir::StrAttribute>().data();
diff --git a/paddle/fluid/ir/phi_kernel_adaptor/phi_kernel_util.cc b/paddle/fluid/ir/phi_kernel_adaptor/phi_kernel_util.cc
diff --git a/test/cpp/ir/core/CMakeLists.txt b/test/cpp/ir/core/CMakeLists.txt
diff --git a/test/cpp/ir/core/ir_exe_test.cc b/test/cpp/ir/core/ir_exe_test.cc
diff --git a/test/cpp/ir/core/ir_infershape_test.cc b/test/cpp/ir/core/ir_infershape_test.cc
diff --git a/test/cpp/ir/core/ir_phi_kernel_op_test.cc b/test/cpp/ir/core/ir_phi_kernel_op_test.cc
diff --git a/test/cpp/ir/core/phi_kernel_adaptor.h b/test/cpp/ir/core/phi_kernel_adaptor.h

Original file line number	Diff line number	Diff line change
`@@ -161,7 +161,7 @@ Instruction::Instruction(size_t id,`
`161`	`161`	`is_artificial_ = true;`
`162`	`162`	`}`
`163`	`163`
`164`		`- if (op_func_node_.infer_shape_interface_ != nullptr) {`
	`164`	`+ if (op_func_node_.infer_meta_interface_ != nullptr) {`
`165`	`165`	`pre_define_context_ = true;`
`166`	`166`	`}`
`167`	`167`	`PADDLE_ENFORCE_GE(id,`
Original file line number	Diff line number	Diff line change
`@@ -17,8 +17,10 @@ set(op_backward_yaml_file2`
`17`	`17`	`${PADDLE_SOURCE_DIR}/paddle/fluid/operators/generator/parsed_ops/legacy_backward_ops.parsed.yaml`
`18`	`18`	`)`
`19`	`19`	`set(op_yaml_file3 ${PADDLE_SOURCE_DIR}/paddle/fluid/ir/dialect/pd_op.yaml)`
	`20`	`+set(op_yaml_file4`
	`21`	`+ ${PADDLE_SOURCE_DIR}/paddle/fluid/ir/dialect/pd_legacy_op.yaml)`
`20`	`22`	`set(op_yaml_files`
`21`		`- ${op_forward_yaml_file1},${op_forward_yaml_file2},${op_backward_yaml_file1},${op_backward_yaml_file2},${op_yaml_file3}`
	`23`	`+ ${op_forward_yaml_file1},${op_forward_yaml_file2},${op_backward_yaml_file1},${op_backward_yaml_file2},${op_yaml_file3},${op_yaml_file4}`
`22`	`24`	`)`
`23`	`25`	`set(op_namespace paddle,dialect)`
`24`	`26`	`set(dialect_name pd)`