[NewIR] Add parser to deserialize

paddle/fluid/ir/dialect/paddle_dialect/ir/pd_attribute.cc

@@ -16,7 +16,7 @@
 
 namespace paddle {
 namespace dialect {
-const phi::IntArray& IntArrayAttribute::data() const {
+const phi::IntArray &IntArrayAttribute::data() const {
   return storage()->GetAsKey();
 }
 
@@ -48,6 +48,109 @@ phi::Scalar ScalarAttribute::data() {
   }
 }
 
+IntArrayAttribute IntArrayAttribute::Parse(ir::IrParser &parser) {  // NOLINT
+  Token buket_token = parser.ConsumeToken();
+  std::vector<int32_t> vec{};
+  while (parser.PeekToken().val_ != "]") {
+    Token val_token = parser.ConsumeToken();
+    vec.push_back(atoll(val_token.val_.c_str()));
+    if (parser.PeekToken().val_ == "]") break;
+    parser.ConsumeToken();
+  }
+  parser.ConsumeToken();
+  return IntArrayAttribute::get(parser.ctx, vec);
+}
+
+// Parse a DataTypeAttribute
+// DataTypeAttribute ->  bool|uint8|int8|uint16|int16|uint32
+//                       |int32|uint64|int64|float32|complex64
+//                       |complex128|Undefined|psting|flaot16
+//                       |bfloat16|num_data_types|all_dtype
+DataTypeAttribute DataTypeAttribute::Parse(ir::IrParser &parser) {  // NOLINT
+  std::unordered_map<std::string, phi::DataType> StringToDataType{
+      {"bool", phi::DataType::BOOL},
+      {"uint8", phi::DataType::UINT8},
+      {"int8", phi::DataType::INT8},
+      {"uint16", phi::DataType::UINT16},
+      {"int16", phi::DataType::INT16},
+      {"uint32", phi::DataType::UINT32},
+      {"int32", phi::DataType::INT32},
+      {"uint64", phi::DataType::UINT64},
+      {"int64", phi::DataType::INT64},
+      {"float32", phi::DataType::FLOAT32},
+      {"complex64", phi::DataType::COMPLEX64},
+      {"complex128", phi::DataType::COMPLEX128},
+      {"Undefined", phi::DataType::UNDEFINED},
+      {"psting", phi::DataType::PSTRING},
+      {"float16", phi::DataType::FLOAT16},
+      {"bfloat16", phi::DataType::BFLOAT16},
+      {"float64", phi::DataType::FLOAT64}};
+  std::string datatype_token_val = parser.ConsumeToken().val_;
+  IR_ENFORCE(StringToDataType.count(datatype_token_val) > 0,
+             datatype_token_val + " is not defined in DataType." +
+                 parser.GetErrorLocationInfo());
+  return DataTypeAttribute::get(parser.ctx,
+                                StringToDataType[datatype_token_val]);
+}
+
+// Parse a PlaceAttribute
+// PlaceAttribute   ->    Place(cpu)|Place(gpu:0)|Place(gpu_pinned)
+//                        |Place(xpu:0)|Place(ipu:0)|Place(:0)|undefined
+PlaceAttribute PlaceAttribute::Parse(ir::IrParser &parser) {  // NOLINT
+  std::unordered_map<std::string, phi::Place> StringToPlace{
+      {"cpu", phi::CPUPlace{}},
+      {"gpu", phi::GPUPlace{}},
+      {"gpu_pinned", phi::GPUPinnedPlace{}},
+      {"xpu", phi::XPUPlace{}},
+      {"ipu", phi::IPUPlace{}},
+      {":", phi::CustomPlace{}},
+      {"undefined", phi::Place{}}};
+  parser.ConsumeAToken("Place");
+  parser.ConsumeAToken("(");
+  std::string place_token_val = parser.ConsumeToken().val_;
+  IR_ENFORCE(StringToPlace.count(place_token_val) > 0,
+             place_token_val + " is not defined in Place." +
+                 parser.GetErrorLocationInfo());
+  if (parser.PeekToken().val_ == ":") {
+    parser.ConsumeAToken(":");
+    parser.ConsumeToken();
+  } else if (place_token_val == ":") {
+    parser.ConsumeToken();
+  }
+  parser.ConsumeAToken(")");
+  return PlaceAttribute::get(parser.ctx, StringToPlace[place_token_val]);
+}
+
+// Parse a DataLayoutAttribute
+// DataLayoutAttribute  ->   NHWC|NCHW|Undefined(0)|ONEDNN
+//                           |SPARSE_COO|SPARSE_CSR|NDHWC
+//                           |NCDHW|PSTRING_UNION|STRIDED
+DataLayoutAttribute DataLayoutAttribute::Parse(
+    ir::IrParser &parser) {  // NOLINT
+  std::unordered_map<std::string, phi::DataLayout> StringToDataLayout{
+      {"NHWC", phi::DataLayout::kNHWC},
+      {"NCHW", phi::DataLayout::kNCHW},
+      {"Undefined", phi::DataLayout::kAnyLayout},
+      {"ONEDNN", phi::DataLayout::ONEDNN},
+      {"SPARSE_COO", phi::DataLayout::SPARSE_COO},
+      {"SPARSE_CSR", phi::DataLayout::SPARSE_CSR},
+      {"NDHWC", phi::DataLayout::kNDHWC},
+      {"NCDHW", phi::DataLayout::kNCDHW},
+      {"PSTRING_UNION", phi::DataLayout::PSTRING_UNION},
+      {"STRIDED", phi::DataLayout::STRIDED}};
+  std::string datalayout_token_val = parser.ConsumeToken().val_;
+  IR_ENFORCE(StringToDataLayout.count(datalayout_token_val) > 0,
+             datalayout_token_val + " is not defined in DataLayout." +
+                 parser.GetErrorLocationInfo());
+  if (datalayout_token_val == "Undefined") {
+    parser.ConsumeAToken("(");
+    parser.ConsumeAToken("AnyLayout");
+    parser.ConsumeAToken(")");
+  }
+  return DataLayoutAttribute::get(parser.ctx,
+                                  StringToDataLayout[datalayout_token_val]);
+}
+
 }  // namespace dialect
 }  // namespace paddle
 

paddle/fluid/ir/dialect/paddle_dialect/ir/pd_attribute.h

@@ -18,6 +18,7 @@
 #include "paddle/fluid/ir/dialect/paddle_dialect/utils/utils.h"
 #include "paddle/ir/core/attribute.h"
 #include "paddle/ir/core/builtin_attribute.h"
+#include "paddle/ir/core/ir_parser.h"
 #include "paddle/phi/common/scalar.h"
 #include "paddle/phi/core/enforce.h"
 
@@ -34,6 +35,8 @@ class IntArrayAttribute : public ir::Attribute {
     return storage() < right.storage();
   }
 
+  static IntArrayAttribute Parse(ir::IrParser &parser);  // NOLINT
+
   const phi::IntArray &data() const;
 };
 
@@ -68,6 +71,8 @@ class DataTypeAttribute : public ir::Attribute {
     return storage() < right.storage();
   }
 
+  static DataTypeAttribute Parse(ir::IrParser &parser);  // NOLINT
+
   phi::DataType data() const;
 };
 
@@ -81,6 +86,8 @@ class PlaceAttribute : public ir::Attribute {
     return storage() < right.storage();
   }
 
+  static PlaceAttribute Parse(ir::IrParser &parser);  // NOLINT
+
   phi::Place data() const;
 };
 
@@ -95,6 +102,7 @@ class DataLayoutAttribute : public ir::Attribute {
     return storage() < right.storage();
   }
 
+  static DataLayoutAttribute Parse(ir::IrParser &parser);  // NOLINT
   phi::DataLayout data() const;
 };
 

paddle/fluid/ir/dialect/paddle_dialect/ir/pd_dialect.cc

@@ -76,9 +76,12 @@ void PaddleDialect::PrintType(ir::Type type, std::ostream &os) const {
 }
 
 void PaddleDialect::PrintAttribute(ir::Attribute attr, std::ostream &os) const {
+  os << "(" << attr.dialect().name();
+  os << '.';
   if (auto int_array_attr = attr.dyn_cast<IntArrayAttribute>()) {
     phi::IntArray data = int_array_attr.data();
-    os << "IntArray[";
+    os << "IntArray)"
+       << "[";
     const auto &inner_data = data.GetData();
     ir::PrintInterleave(
         inner_data.begin(),
@@ -87,16 +90,64 @@ void PaddleDialect::PrintAttribute(ir::Attribute attr, std::ostream &os) const {
         [&os]() { os << ","; });
     os << "]";
   } else if (auto data_type_attr = attr.dyn_cast<DataTypeAttribute>()) {
-    os << data_type_attr.data();
+    os << "DataType)" << data_type_attr.data();
   } else if (auto place_type_attr = attr.dyn_cast<PlaceAttribute>()) {
-    os << place_type_attr.data();
+    os << "Place)" << place_type_attr.data();
   } else if (auto data_layout_attr = attr.dyn_cast<DataLayoutAttribute>()) {
-    os << data_layout_attr.data();
+    os << "DataLayout)" << data_layout_attr.data();
   } else {
     os << "<#AttrNotImplemented>";
   }
 }
 
+ir::Type PaddleDialect::ParseType(ir::IrParser &parser) {  // NOLINT
+  parser.ConsumeAToken("pd.tensor");
+  parser.ConsumeAToken("<");
+  std::vector<int> dim{};
+  Token dim_token = parser.PeekToken();
+  while (dim_token.token_type_ == DIGIT) {
+    dim_token = parser.ConsumeToken();
+    dim.push_back(atoi(dim_token.val_.c_str()));
+    std::string peek_token_val = parser.PeekToken().val_;
+    if (peek_token_val[0] != 'x') {
+      break;
+    }
+    parser.ConsumeToken();
+    parser.lexer->Unget(peek_token_val.size() - 1);
+    if (parser.PeekToken().token_type_ != DIGIT) {
+      break;
+    }
+  }
+  phi::DDim ddim = phi::make_ddim(dim);
+  ir::Type dtype = parser.ParseType();
+  std::vector<std::vector<size_t>> lod;
+  std::vector<size_t> lodv;
+  lodv.push_back(0);
+  lod.push_back(lodv);
+  parser.ConsumeAToken(">");
+  return DenseTensorType::get(
+      parser.ctx, dtype, ddim, phi::DataLayout::UNDEFINED, lod, 0);
+}
+
+ir::Attribute PaddleDialect::ParseAttribute(ir::IrParser &parser) {  // NOLINT
+  std::string type_name = parser.ConsumeToken().val_;
+  std::string attribute_name =
+      type_name.substr(type_name.find('.') + 1, std::string::npos);
+  parser.ConsumeAToken(")");
+  if (attribute_name == "IntArray") {
+    return IntArrayAttribute::Parse(parser);
+  } else if (attribute_name == "DataType") {
+    return DataTypeAttribute::Parse(parser);
+  } else if (attribute_name == "Place") {
+    return PlaceAttribute::Parse(parser);
+  } else if (attribute_name == "DataLayout") {
+    return DataLayoutAttribute::Parse(parser);
+  } else {
+    IR_THROW("No function to parse " + attribute_name + " exists!" +
+             parser.GetErrorLocationInfo());
+  }
+}
+
 }  // namespace dialect
 }  // namespace paddle
 

paddle/fluid/ir/dialect/paddle_dialect/ir/pd_dialect.h

@@ -27,6 +27,8 @@ class PaddleDialect : public ir::Dialect {
 
   void PrintType(ir::Type type, std::ostream& os) const;
   void PrintAttribute(ir::Attribute type, std::ostream& os) const;
+  ir::Type ParseType(ir::IrParser& parser);            // NOLINT
+  ir::Attribute ParseAttribute(ir::IrParser& parser);  // NOLINT
 
  private:
   void initialize();

paddle/ir/core/CMakeLists.txt

@@ -3,4 +3,8 @@ set(NEWIR_BINARY_DIR "${PADDLE_BINARY_DIR}/paddle/ir")
 
 file(GLOB IR_SRCS "*.cc")
 
+file(GLOB IR_PARSER_SRCS "parser/*.cc")
+
+list(APPEND IR_SRCS ${IR_PARSER_SRCS})
+
 ir_library(ir_core SRCS ${IR_SRCS} DEPS ddim)

paddle/ir/core/attribute.h

@@ -68,6 +68,8 @@ class IR_API Attribute {
   /// @param os
   void Print(std::ostream &os) const;
 
+  static Attribute Parse(std::istream &is, IrContext *ctx);
+
   ///
   /// \brief Methods for type judgment and cast.
   ///

paddle/ir/core/dialect.h

@@ -29,7 +29,7 @@ namespace ir {
 
 class Operation;
 class IrPrinter;
-
+class IrParser;
 class DialectInterface;
 ///
 /// \brief Dialect can basically be understood as a namespace. In Dialect, we
@@ -145,9 +145,21 @@ class IR_API Dialect {
     IR_THROW("dialect has no registered attribute printing hook");
   }
 
+  virtual Type ParseType(IrParser &parser) {  // NOLINT
+    IR_THROW("dialect has no registered type parsing hook");
+  }
+
+  virtual Attribute ParseAttribute(IrParser &parser) {  // NOLINT
+    IR_THROW("dialect has no registered attribute parsing hook");
+  }
+
   virtual void PrintOperation(const Operation *op,
                               IrPrinter &printer) const;  // NOLINT
 
+  virtual Operation ParseOperation(IrParser &parser) {  // NOLINT
+    IR_THROW("dialect has no registered operation parsing hook");
+  }
+
  private:
   Dialect(const Dialect &) = delete;
 

paddle/ir/core/ir_parser.h

@@ -0,0 +1,71 @@
+// 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.
+
+#pragma once
+#include "paddle/ir/core/ir_context.h"
+#include "paddle/ir/core/operation.h"
+#include "paddle/ir/core/parser/lexer.h"
+#include "paddle/ir/core/program.h"
+
+using OpResultMap = std::map<string, ir::OpResult>;
+using AttributeMap = std::unordered_map<std::string, ir::Attribute>;
+using OpAttributeInfoMap = std::map<string, string>;
+
+namespace ir {
+class IrParser {
+ public:
+  std::unique_ptr<Lexer> lexer;
+  IrContext* ctx;
+  OpResultMap opresultmap;
+  std::unique_ptr<Builder> builder;
+
+ public:
+  IrParser(IrContext* ctx, std::istream& is);
+
+  ~IrParser() = default;
+
+  Token ConsumeToken();
+
+  Token PeekToken();
+
+  std::unique_ptr<Program> ParseProgram();
+
+  void ParseRegion(Region& region);  // NOLINT
+
+  void ParseBlock(Block& block);  // NOLINT
+
+  Operation* ParseOperation();
+
+  OpInfo ParseOpInfo();
+
+  std::vector<std::string> ParseOpResultIndex();
+
+  std::vector<OpResult> ParseOpRandList();
+
+  AttributeMap ParseAttributeMap();
+
+  std::vector<Type> ParseFunctionTypeList();
+
+  OpResult GetNullValue();
+
+  Type ParseType();
+
+  Attribute ParseAttribute();
+
+  string GetErrorLocationInfo();
+
+  void ConsumeAToken(string expect_token_val);
+};
+
+}  // namespace ir