PaddlePaddle
diff --git a/‎paddle/fluid/pir/dialect/operator/ir/op_attribute.cc
Copy file name to clipboard
+23-50Lines changed: 23 additions & 50 deletions b/‎paddle/fluid/pir/dialect/operator/ir/op_attribute.cc
Copy file name to clipboard
+23-50Lines changed: 23 additions & 50 deletions
diff --git a/‎paddle/fluid/pir/dialect/operator/ir/op_dialect.cc
Copy file name to clipboard
+2-2Lines changed: 2 additions & 2 deletions b/‎paddle/fluid/pir/dialect/operator/ir/op_dialect.cc
Copy file name to clipboard
+2-2Lines changed: 2 additions & 2 deletions
diff --git a/‎paddle/fluid/pir/dialect/operator/utils/utils.cc
Copy file name to clipboard
+51-1Lines changed: 51 additions & 1 deletion b/‎paddle/fluid/pir/dialect/operator/utils/utils.cc
Copy file name to clipboard
+51-1Lines changed: 51 additions & 1 deletion
diff --git a/‎paddle/fluid/pir/dialect/operator/utils/utils.h
Copy file name to clipboard
+7-1Lines changed: 7 additions & 1 deletion b/‎paddle/fluid/pir/dialect/operator/utils/utils.h
Copy file name to clipboard
+7-1Lines changed: 7 additions & 1 deletion
@@ -13,6 +13,8 @@
 // limitations under the License.
 
 #include "paddle/fluid/pir/dialect/operator/ir/op_attribute.h"
+#include "paddle/common/enforce.h"
+#include "paddle/common/errors.h"
 
 namespace paddle {
 namespace dialect {
@@ -73,58 +75,37 @@ IntArrayAttribute IntArrayAttribute::Parse(pir::IrParser &parser) {  // NOLINT
 //                       |complex128|Undefined|psting|flaot16
 //                       |bfloat16|num_data_types|all_dtype
 DataTypeAttribute DataTypeAttribute::Parse(pir::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());
+  PADDLE_ENFORCE_EQ(StringToDataTypeMap().count(datatype_token_val) > 0,
+                    true,
+                    common::errors::InvalidArgument(
+                        datatype_token_val + " is not defined in DataType." +
+                        parser.GetErrorLocationInfo()));
   return DataTypeAttribute::get(parser.ctx,
-                                StringToDataType[datatype_token_val]);
+                                StringToDataTypeMap().at(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(pir::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());
+  PADDLE_ENFORCE_EQ(StringToPlaceMap().count(place_token_val) > 0,
+                    true,
+                    common::errors::InvalidArgument(
+                        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]);
+  return PlaceAttribute::get(parser.ctx,
+                             StringToPlaceMap().at(place_token_val));
 }
 
 // Parse a DataLayoutAttribute
@@ -133,28 +114,20 @@ PlaceAttribute PlaceAttribute::Parse(pir::IrParser &parser) {  // NOLINT
 //                           |NCDHW|PSTRING_UNION|STRIDED
 DataLayoutAttribute DataLayoutAttribute::Parse(
     pir::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());
+  PADDLE_ENFORCE_EQ(
+      StringToDataLayoutMap().count(datalayout_token_val) > 0,
+      true,
+      common::errors::InvalidArgument(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]);
+  return DataLayoutAttribute::get(
+      parser.ctx, StringToDataLayoutMap().at(datalayout_token_val));
 }
 
 }  // namespace dialect
 
@@ -527,7 +527,7 @@ struct CustomOpInfoInterfaceModel : public OpYamlInfoInterface::Concept {
       auto attr_name = attr_name_and_type[0];
       auto attr_type_str = attr_name_and_type[1];
       param_names.push_back(attr_name);
-      if (AttrTypeMap().find(attr_type_str) == AttrTypeMap().end()) {
+      if (CppTypeToAttrTypeMap().count(attr_type_str) == 0) {
         PADDLE_THROW(platform::errors::Unimplemented(
             "Unsupported `%s` type value as custom attribute now. "
             "Supported data types include `bool`, `int`, `float`, "
@@ -537,7 +537,7 @@ struct CustomOpInfoInterfaceModel : public OpYamlInfoInterface::Concept {
             "the attribute data type and data type string are matched.",
             attr_type_str));
       }
-      std::string attr_pir_type = AttrTypeMap().at(attr_type_str);
+      std::string attr_pir_type = CppTypeToAttrTypeMap().at(attr_type_str);
       attributes_info.emplace_back(attr_name, attr_pir_type, "");
     }
 
 
@@ -495,7 +495,7 @@ std::vector<int64_t> ParseValueShape(const pir::Value& shape,
   return vec_shape;
 }
 
-const std::unordered_map<std::string, std::string>& AttrTypeMap() {
+const std::unordered_map<std::string, std::string>& CppTypeToAttrTypeMap() {
   static const std::unordered_map<std::string, std::string> attr_type_map = {
       {"bool", "pir::BoolAttribute"},
       {"int", "pir::Int32Attribute"},
@@ -509,5 +509,55 @@ const std::unordered_map<std::string, std::string>& AttrTypeMap() {
   return attr_type_map;
 }
 
+const std::unordered_map<std::string, phi::DataType>& StringToDataTypeMap() {
+  static std::unordered_map<std::string, phi::DataType> data_type_map{
+      {"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}};
+  return data_type_map;
+}
+
+const std::unordered_map<std::string, phi::Place>& StringToPlaceMap() {
+  static std::unordered_map<std::string, phi::Place> place_map{
+      {"cpu", phi::CPUPlace{}},
+      {"gpu", phi::GPUPlace{}},
+      {"gpu_pinned", phi::GPUPinnedPlace{}},
+      {"xpu", phi::XPUPlace{}},
+      {"ipu", phi::IPUPlace{}},
+      {":", phi::CustomPlace{}},
+      {"undefined", phi::Place{}}};
+  return place_map;
+}
+
+const std::unordered_map<std::string, phi::DataLayout>&
+StringToDataLayoutMap() {
+  static std::unordered_map<std::string, phi::DataLayout> data_layout_map{
+      {"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}};
+  return data_layout_map;
+}
+
 }  // namespace dialect
 }  // namespace paddle
@@ -167,7 +167,13 @@ phi::DataType GetValueDataType(const pir::Value& value);
 std::vector<int64_t> ParseValueShape(const pir::Value& shape_,
                                      bool* is_from_tensor);
 
-const std::unordered_map<std::string, std::string>& AttrTypeMap();
+const std::unordered_map<std::string, std::string>& CppTypeToAttrTypeMap();
+
+const std::unordered_map<std::string, phi::DataType>& StringToDataTypeMap();
+
+const std::unordered_map<std::string, phi::Place>& StringToPlaceMap();
+
+const std::unordered_map<std::string, phi::DataLayout>& StringToDataLayoutMap();
 
 }  // namespace dialect
 }  // namespace paddle