[IR] Support op attribute and refactor for new op definition

paddle/fluid/dialect/op_gen.py

@@ -1186,7 +1186,7 @@ def OpGenerator(
                     )
 
             # generate op verify function
-            if "GradOp" in op_class_name or "Grad_Op" in op_class_name:
+            if "Grad" in op_class_name:
                 op_verify_str = GRAD_OP_VERIFY_TEMPLATE.format(
                     op_name=op_class_name,
                 )

paddle/fluid/dialect/pd_attribute.cc

@@ -18,7 +18,9 @@ namespace paddle {
 namespace dialect {
 phi::IntArray IntArrayAttribute::data() const { return storage()->GetAsKey(); }
 
-phi::Scalar ScalarAttribute::data() const { return storage()->GetAsKey(); }
+paddle::experimental::Scalar ScalarAttribute::data() const {
+  return storage()->GetAsKey();
+}
 
 phi::DataType DataTypeAttribute::data() const { return storage()->GetAsKey(); }
 

paddle/fluid/dialect/pd_attribute.h

@@ -43,7 +43,7 @@ class ScalarAttribute : public ir::Attribute {
     return storage() < right.storage();
   }
 
-  phi::Scalar data() const;
+  paddle::experimental::Scalar data() const;
 };
 
 class DataTypeAttribute : public ir::Attribute {

paddle/fluid/dialect/pd_attribute_storage.h

@@ -55,7 +55,7 @@ struct IntArrayAttributeStorage : public ir::AttributeStorage {
 };
 
 struct ScalarAttributeStorage : public ir::AttributeStorage {
-  using ParamKey = phi::Scalar;
+  using ParamKey = paddle::experimental::Scalar;
 
   explicit ScalarAttributeStorage(const ParamKey &key) { data_ = key; }
 
@@ -73,7 +73,7 @@ struct ScalarAttributeStorage : public ir::AttributeStorage {
   ParamKey GetAsKey() const { return ParamKey(data_); }
 
  private:
-  phi::Scalar data_;
+  paddle::experimental::Scalar data_;
 };
 
 struct DataTypeAttributeStorage : public ir::AttributeStorage {

paddle/fluid/dialect/pd_interface.h

@@ -36,7 +36,10 @@ class GetOpInfoInterface : public ir::OpInterfaceBase<GetOpInfoInterface> {
   struct Model : public Concept {
     static OpInfoTuple GetOpInfo() { return ConcreteOp::GetOpInfo(); }
 
-    Model() : Concept(GetOpInfo) {}
+    Model() : Concept(GetOpInfo) {
+      static_assert(sizeof(Model) == sizeof(Concept),
+                    "sizeof(Model) != sizeof(Concept)");
+    }
   };
 
   GetOpInfoInterface(ir::Operation *op, Concept *impl)

paddle/fluid/dialect/pd_op.yaml

@@ -1,12 +1,7 @@
 - name: feed
-  inputs:
-  - typename: Tensor[]
-    name: x
-    optional: false
-    no_need_buffer: false
-    data_transform: {}
+  inputs: []
   attrs:
-  - {typename: int, name: col}
+  - {typename: str, name: name}
   outputs:
   - {typename: Tensor, name: out, optional: false, intermediate: false}
   no_need_buffer: null
@@ -21,9 +16,8 @@
     no_need_buffer: false
     data_transform: {}
   attrs:
-  - {typename: int, name: col}
-  outputs:
-  - {typename: 'Tensor[]', name: out, optional: false, intermediate: false}
+  - {typename: str, name: name}
+  outputs: []
   no_need_buffer: null
   data_transform: null
   inplace: null

paddle/fluid/translator/attribute_translator.cc

@@ -0,0 +1,231 @@
+// Copyright (c) 2023 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.
+
+#include "paddle/fluid/translator/attribute_translator.h"
+
+#include <string>
+#include <vector>
+
+#include "paddle/fluid/dialect/pd_attribute.h"
+#include "paddle/phi/common/data_type.h"
+#include "paddle/phi/common/int_array.h"
+#include "paddle/phi/common/layout.h"
+#include "paddle/phi/common/place.h"
+#include "paddle/phi/common/scalar.h"
+#include "paddle/utils/variant.h"
+
+namespace paddle {
+namespace translator {
+
+class AttributeVisitor {
+ public:
+  ir::IrContext* ctx;
+  AttributeVisitor() { ctx = ir::IrContext::Instance(); }
+  ~AttributeVisitor() {}
+
+ public:
+  virtual ir::Attribute operator()(int i) {
+    VLOG(10) << "translating int";
+    return ir::Int32_tAttribute::get(ctx, i);
+  }
+
+  virtual ir::Attribute operator()(float f) {
+    VLOG(10) << "translating float";
+    return ir::FloatAttribute::get(ctx, f);
+  }
+
+  virtual ir::Attribute operator()(bool b) {
+    VLOG(10) << "translating bool";
+    return ir::BoolAttribute::get(ctx, b);
+  }
+
+  virtual ir::Attribute operator()(double d) {
+    VLOG(10) << "translating double";
+    return ir::DoubleAttribute::get(ctx, d);
+  }
+
+  virtual ir::Attribute operator()(std::string str) {
+    VLOG(10) << "translating string";
+    return ir::StrAttribute::get(ctx, str);
+  }
+
+  virtual ir::Attribute operator()(const paddle::experimental::Scalar& scalar) {
+    VLOG(10) << "translating scalar";
+    return paddle::dialect::ScalarAttribute::get(ctx, scalar);
+  }
+
+  virtual ir::Attribute operator()(const std::vector<std::string>& strs) {
+    VLOG(10) << "translating vector<string>";
+    std::vector<ir::Attribute> attrs;
+    attrs.reserve(strs.size());
+    for (const auto& v : strs) {
+      attrs.push_back(ir::StrAttribute::get(ctx, v));
+    }
+    return ir::ArrayAttribute::get(ctx, attrs);
+  }
+
+  virtual ir::Attribute operator()(const std::vector<float>& fs) {
+    VLOG(10) << "translating vector<float>";
+    std::vector<ir::Attribute> attrs;
+    attrs.reserve(fs.size());
+    for (const auto& v : fs) {
+      attrs.push_back(ir::FloatAttribute::get(ctx, v));
+    }
+    return ir::ArrayAttribute::get(ctx, attrs);
+  }
+
+  virtual ir::Attribute operator()(const std::vector<int>& is) {
+    VLOG(10) << "translating vector<int>";
+    std::vector<ir::Attribute> attrs;
+    attrs.reserve(is.size());
+    for (const auto& v : is) {
+      attrs.push_back(ir::Int32_tAttribute::get(ctx, v));
+    }
+    return ir::ArrayAttribute::get(ctx, attrs);
+  }
+
+  virtual ir::Attribute operator()(const std::vector<bool>& bs) {
+    VLOG(10) << "translating vector<bool>";
+    std::vector<ir::Attribute> attrs;
+    attrs.reserve(bs.size());
+    for (const auto& v : bs) {
+      attrs.push_back(ir::BoolAttribute::get(ctx, v));
+    }
+    return ir::ArrayAttribute::get(ctx, attrs);
+  }
+
+  virtual ir::Attribute operator()(const std::vector<int64_t>& i64s) {
+    VLOG(10) << "translating vector<int64>";
+    std::vector<ir::Attribute> attrs;
+    attrs.reserve(i64s.size());
+    for (const auto& v : i64s) {
+      attrs.push_back(ir::Int64_tAttribute::get(ctx, v));
+    }
+    return ir::ArrayAttribute::get(ctx, attrs);
+  }
+
+  virtual ir::Attribute operator()(const std::vector<double>& ds) {
+    VLOG(10) << "translating vector<double>";
+    std::vector<ir::Attribute> attrs;
+    attrs.reserve(ds.size());
+    for (const auto& v : ds) {
+      attrs.push_back(ir::DoubleAttribute::get(ctx, v));
+    }
+    return ir::ArrayAttribute::get(ctx, attrs);
+  }
+
+  virtual ir::Attribute operator()(
+      const std::vector<paddle::experimental::Scalar>& ss) {
+    VLOG(10) << "translating vector<scalar>";
+    std::vector<ir::Attribute> attrs;
+    attrs.reserve(ss.size());
+    for (const auto& v : ss) {
+      attrs.push_back(paddle::dialect::ScalarAttribute::get(ctx, v));
+    }
+    return ir::ArrayAttribute::get(ctx, attrs);
+  }
+
+  virtual ir::Attribute operator()(const paddle::blank& blank) {
+    VLOG(10) << "translating paddle::blank";
+    return ir::Attribute(nullptr);
+  }
+
+  template <typename T>
+  ir::Attribute operator()(T attr) {
+    VLOG(10) << "translating null type";
+    return ir::Attribute(nullptr);
+  }
+};
+
+class IntArrayAttributeVisitor : public AttributeVisitor {
+ public:
+  using AttributeVisitor::AttributeVisitor;
+  ir::Attribute operator()(const std::vector<int>& is) override {
+    VLOG(10) << "translating vector<int> to IntArray";
+    phi::IntArray data(is);
+    return paddle::dialect::IntArrayAttribute::get(ctx, data);
+  }
+
+  ir::Attribute operator()(const std::vector<int64_t>& is) override {
+    VLOG(10) << "translating vector<int> to IntArray";
+    phi::IntArray data(is);
+    return paddle::dialect::IntArrayAttribute::get(ctx, data);
+  }
+};
+
+class ScalarAttributeVisitor : public AttributeVisitor {
+ public:
+  using AttributeVisitor::AttributeVisitor;
+  ir::Attribute operator()(int i) override {
+    VLOG(10) << "translating int to Scalar";
+    phi::Scalar data(i);
+    return paddle::dialect::ScalarAttribute::get(ctx, data);
+  }
+
+  ir::Attribute operator()(float f) override {
+    VLOG(10) << "translating float to Scalar";
+    phi::Scalar data(f);
+    return paddle::dialect::ScalarAttribute::get(ctx, data);
+  }
+};
+
+class DataTypeAttributeVisitor : public AttributeVisitor {
+ public:
+  using AttributeVisitor::AttributeVisitor;
+  ir::Attribute operator()(int i) override {
+    VLOG(10) << "translating int to DataType: " << i;
+    phi::DataType data = static_cast<phi::DataType>(i);
+    return paddle::dialect::DataTypeAttribute::get(ctx, data);
+  }
+};
+
+class PlaceAttributeVisitor : public AttributeVisitor {
+ public:
+  using AttributeVisitor::AttributeVisitor;
+
+  ir::Attribute operator()(const paddle::blank& blank) override {
+    VLOG(10) << "translating paddle::blank";
+    phi::Place data(phi::AllocationType::CPU);
+    return paddle::dialect::PlaceAttribute::get(ctx, data);
+  }
+};
+
+AttributeTranslator::AttributeTranslator() {
+  general_visitor = new AttributeVisitor();
+  special_visitors["paddle::dialect::IntArrayAttribute"] =
+      new IntArrayAttributeVisitor();
+  special_visitors["paddle::dialect::ScalarAttribute"] =
+      new ScalarAttributeVisitor();
+  special_visitors["paddle::dialect::DataTypeAttribute"] =
+      new DataTypeAttributeVisitor();
+  special_visitors["paddle::dialect::PlaceAttribute"] =
+      new PlaceAttributeVisitor();
+}
+
+ir::Attribute AttributeTranslator::operator()(
+    const framework::Attribute& attr) {
+  return paddle::visit(*general_visitor, attr);
+}
+
+ir::Attribute AttributeTranslator::operator()(
+    const std::string& target_type, const framework::Attribute& attr) {
+  if (special_visitors.find(target_type) == special_visitors.end()) {
+    VLOG(10) << "[" << target_type << "] not found";
+    return paddle::visit(*general_visitor, attr);
+  }
+  return paddle::visit(*(special_visitors.at(target_type)), attr);
+}
+
+}  // namespace translator
+}  // namespace paddle

paddle/fluid/translator/attribute_translator.h

@@ -0,0 +1,54 @@
+// Copyright (c) 2023 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.
+
+#include <string>
+#include <unordered_map>
+
+#include "paddle/fluid/framework/attribute.h"
+#include "paddle/fluid/framework/type_defs.h"
+#include "paddle/ir/core/attribute.h"
+#include "paddle/ir/core/builtin_attribute.h"
+#include "paddle/ir/core/ir_context.h"
+
+#pragma once
+
+namespace paddle {
+namespace translator {
+
+class AttributeVisitor;
+
+class AttributeTranslator {
+ private:
+  AttributeTranslator();
+  AttributeVisitor* general_visitor;
+  std::unordered_map<std::string, AttributeVisitor*> special_visitors;
+
+ public:
+  AttributeTranslator(const AttributeTranslator&) = delete;
+  AttributeTranslator& operator=(const AttributeTranslator&) = delete;
+  AttributeTranslator(AttributeTranslator&&) = delete;
+  AttributeTranslator& operator=(AttributeTranslator&&) = delete;
+
+  static auto& instance() {
+    static AttributeTranslator attribute_translator;
+    return attribute_translator;
+  }
+
+  ir::Attribute operator()(const framework::Attribute& attr);
+  ir::Attribute operator()(const std::string& target_type,
+                           const framework::Attribute& attr);
+};
+
+}  // namespace translator
+}  // namespace paddle