PaddlePaddle
diff --git a/‎paddle/fluid/pir/serialize_deserialize/include/ir_deserialize.h
Copy file name to clipboard
+3-3Lines changed: 3 additions & 3 deletions b/‎paddle/fluid/pir/serialize_deserialize/include/ir_deserialize.h
Copy file name to clipboard
+3-3Lines changed: 3 additions & 3 deletions
diff --git a/‎paddle/fluid/pir/serialize_deserialize/include/version_compat.h
Copy file name to clipboard
+6-1Lines changed: 6 additions & 1 deletion b/‎paddle/fluid/pir/serialize_deserialize/include/version_compat.h
Copy file name to clipboard
+6-1Lines changed: 6 additions & 1 deletion
diff --git a/‎paddle/fluid/pir/serialize_deserialize/src/interface.cc
Copy file name to clipboard
+10-2Lines changed: 10 additions & 2 deletions b/‎paddle/fluid/pir/serialize_deserialize/src/interface.cc
Copy file name to clipboard
+10-2Lines changed: 10 additions & 2 deletions
diff --git a/‎paddle/fluid/pir/serialize_deserialize/src/ir_deserialize.cc
Copy file name to clipboard
+53Lines changed: 53 additions & 0 deletions b/‎paddle/fluid/pir/serialize_deserialize/src/ir_deserialize.cc
Copy file name to clipboard
+53Lines changed: 53 additions & 0 deletions
diff --git a/‎paddle/fluid/pir/serialize_deserialize/src/patch_util.cc
Copy file name to clipboard
+30-10Lines changed: 30 additions & 10 deletions b/‎paddle/fluid/pir/serialize_deserialize/src/patch_util.cc
Copy file name to clipboard
+30-10Lines changed: 30 additions & 10 deletions
diff --git a/‎paddle/fluid/pir/serialize_deserialize/src/schema.cc
Copy file name to clipboard
+6-6Lines changed: 6 additions & 6 deletions b/‎paddle/fluid/pir/serialize_deserialize/src/schema.cc
Copy file name to clipboard
+6-6Lines changed: 6 additions & 6 deletions
@@ -34,9 +34,9 @@ class ProgramReader {
 
   // static void staticInit()
 
-  void RecoverProgram(Json* program_json,
-                      pir::Program* recover_program,
-                      pir::PatchBuilder* builder);
+  void IR_API RecoverProgram(Json* program_json,
+                             pir::Program* recover_program,
+                             pir::PatchBuilder* builder);
   pir::Type RecoverType(Json* type_json);
   pir::AttributeMap RecoverOpAttributesMap(Json* attrs_json);
   ~ProgramReader() = default;
 
@@ -16,6 +16,7 @@
 
 #include <string>
 #include <unordered_map>
+#include <unordered_set>
 #include "paddle/fluid/pir/serialize_deserialize/include/schema.h"
 #include "paddle/fluid/pir/serialize_deserialize/include/third_party.h"
 #include "paddle/pir/include/core/dll_decl.h"
@@ -33,7 +34,9 @@ class PatchBuilder {
   PatchBuilder& operator=(const PatchBuilder&) = delete;
   PatchBuilder& operator=(PatchBuilder&&);
 
-  void IR_API BuildPatch(const std::string& path);
+  void IR_API BuildPatch(const std::string& path,
+                         uint64_t pir_version,
+                         uint64_t max_version);
   /* If file_version != pir_vefrsion, set file_version for finding patch yamls.
    */
   void SetFileVersion(const uint64_t version) { file_version_ = version; }
@@ -51,6 +54,7 @@ class PatchBuilder {
   Json GetJsonTypePatch(const std::string& name) { return type_patches_[name]; }
   Json GetJsonAttrPatch(const std::string& name) { return attr_patches_[name]; }
   std::unordered_map<std::string, Json> GetOpAttrPatchMap(const Json op_patch);
+  void ApplyOpPairPatches(int64_t* id);
   void ApplyOpPatches(const std::string& op_name, Json* json, Json patch);
   void ApplyTypePatches(const std::string& type_name, Json* json, Json patch);
   void ApplyAttrPatches(const std::string& attr_name, Json* json, Json patch);
@@ -61,6 +65,7 @@ class PatchBuilder {
  private:
   uint64_t file_version_;
   uint64_t pir_version_;
+  std::unordered_set<Json> op_pair_patches_;
   std::unordered_map<std::string, Json> op_patches_;
   std::unordered_map<std::string, Json> type_patches_;
   std::unordered_map<std::string, Json> attr_patches_;
 
@@ -14,7 +14,6 @@
 
 #include "paddle/fluid/pir/serialize_deserialize/include/interface.h"
 #include <stdio.h>
-#include <filesystem>
 #include "paddle/common/enforce.h"
 #include "paddle/fluid/pir/serialize_deserialize/include/ir_deserialize.h"
 #include "paddle/fluid/pir/serialize_deserialize/include/ir_serialize.h"
@@ -85,9 +84,18 @@ bool ReadModule(const std::string& file_path,
         data.at(BASE_CODE).at(PIRVERSION).template get<uint64_t>();
     if (file_version != (uint64_t)pir_version) {
       builder.SetFileVersion(file_version);
+      // Set max_version to the max version number of release pir plus 1.
+      auto max_version = GetMaxReleasePirVersion() + 1;
+      // If pir_version_ is not 0, we will build patch from file_version_ to
+      // pir_version_; If pir_version_ is 0, we will first build patch from
+      // file_version_ to max_version, and then add 0.yaml to the end.
+      auto version = pir_version == 0 ? max_version : pir_version;
+      VLOG(6) << "file_version: " << file_version
+              << ", pir_version: " << pir_version
+              << ", final_version: " << version;
       std::filesystem::path patch_path = std::filesystem::path(PATCH_PATH);
       VLOG(8) << "Patch path: " << patch_path;
-      builder.BuildPatch(patch_path.string());
+      builder.BuildPatch(patch_path.string(), version, max_version);
     }
   } else {
     PADDLE_THROW(common::errors::InvalidArgument("Invalid model file."));
 
@@ -93,6 +93,30 @@ void ProgramReader::ReadBlock(Json* block_json, pir::Block* block) {
 
   Json& ops_json = block_json->at(BLOCKOPS);
   if (!ops_json.empty()) {
+    // get value id for op_pair io patch
+    VLOG(6) << "Begin to read value num ...";
+    int64_t max_value_id = 0;
+    for (auto& op_json : ops_json) {
+      if (op_json.at(ID).template get<std::string>() == PARAMETEROP) {
+        int64_t id = op_json.at(OPRESULTS).at(VALUE_ID).template get<int64_t>();
+        max_value_id = std::max(max_value_id, id);
+        continue;
+      }
+      Json& operands_json = op_json.at(OPOPERANDS);
+      for (auto& operand_json : operands_json) {
+        int64_t id = operand_json.at(VALUE_ID).template get<int64_t>();
+        max_value_id = std::max(max_value_id, id);
+      }
+      Json& opresults_json = op_json.at(OPRESULTS);
+      for (auto& opresult_json : opresults_json) {
+        int64_t id = opresult_json.at(VALUE_ID).template get<int64_t>();
+        max_value_id = std::max(max_value_id, id);
+      }
+    }
+    max_value_id += id_value_map.size();
+    VLOG(6) << "max_value_id: " << max_value_id;
+    // Apply op_pair io patch
+    patch_builder->ApplyOpPairPatches(&max_value_id);
     for (auto& op_json : ops_json) {
       block->push_back(ReadOp(&op_json));
     }
@@ -214,6 +238,16 @@ pir::Operation* ProgramReader::ReadOp(Json* op_json) {
     VLOG(8) << " get attr_patch:  " << attr_patch;
     patch_builder->ApplyOpPatches(op_name, op_json, op_patch);
     VLOG(8) << op_name << " has been patched: " << *op_json;
+    // Apply patch to op name
+    // This happens when changing an op into another dialect
+    if (op_patch.contains("NEW_NAME")) {
+      std::string new_name =
+          op_patch.at("NEW_NAME").template get<std::string>();
+      VLOG(8) << "change op name from " << op_name << " to " << new_name;
+      op_name = new_name;
+      op_json->at(ID) = op_name;
+      VLOG(8) << "op_json after changing name: " << *op_json;
+    }
   }
   GetDecompressOpName(&op_name);
   VLOG(4) << "Read op_name = " << op_name << ".";
@@ -299,20 +333,37 @@ pir::AttributeMap ProgramReader::ReadAttributesMap(
     Json* opresult_attrs_json,
     const std::unordered_map<std::string, Json>& attr_patch) {
   pir::AttributeMap attributes;
+  // Add new attribute from patch
+  if (attr_patch.count("A_ADD")) {
+    for (auto& attr_json : attr_patch.at("A_ADD")) {
+      attrs_json->insert(attrs_json->end(), attr_json);
+    }
+    VLOG(8) << "attr has been added: " << *attrs_json;
+  }
   for (auto& attr_json : *attrs_json) {
     auto attr_name = attr_json.at(NAME).template get<std::string>();
     if (attr_patch.count(attr_name)) {
       Json patch = attr_patch.at(attr_name);
+      VLOG(8) << attr_name << " has patch: " << patch;
       patch_builder->ApplyAttrPatches(attr_name, &attr_json, patch);
       VLOG(8) << attr_name << " has been patched: " << attr_json;
     }
+    // Get attr_name again after patch
+    attr_name = attr_json.at(NAME).template get<std::string>();
     if (attr_json.contains(ATTR_TYPE)) {
       attributes.insert({attr_name, ReadAttribute(&attr_json)});
     } else {
       VLOG(6) << "Attribute " << attr_name << " Deleted.";
     }
   }
   VLOG(6) << "Finish Read pir::AttributeMap.";
+  // Add new opresult attribute from patch
+  if (attr_patch.count("OA_ADD")) {
+    for (auto& attr_json : attr_patch.at("OA_ADD")) {
+      opresult_attrs_json->insert(opresult_attrs_json->end(), attr_json);
+    }
+    VLOG(8) << "opresult attr has been added: " << *opresult_attrs_json;
+  }
   for (auto& attr_json : *opresult_attrs_json) {
     auto attr_name = attr_json.at(NAME).template get<std::string>();
     VLOG(8) << attr_name << " patch: " << attr_patch;
@@ -323,6 +374,8 @@ pir::AttributeMap ProgramReader::ReadAttributesMap(
       patch_builder->ApplyAttrPatches(attr_name, &attr_json, patch);
       VLOG(8) << attr_name << " has been patched: " << attr_json;
     }
+    // Get attr_name again after patch
+    attr_name = attr_json.at(NAME).template get<std::string>();
     if (attr_json.contains(ATTR_TYPE)) {
       attributes.insert({attr_name, ReadAttribute(&attr_json)});
     } else {
 
@@ -263,6 +263,7 @@ Json ParseOpPairPatches(const YAML::Node &root) {
       j_patch["op_pair"].push_back(op_name);
     }
     j_patch["patch"] = Json::object();
+    j_patch["patch"]["op_pair"] = j_patch["op_pair"];
     // parse actions
     auto actions = node["actions"];
     for (size_t j = 0; j < actions.size(); j++) {
@@ -275,21 +276,21 @@ Json ParseOpPairPatches(const YAML::Node &root) {
         int out_id = action["object"][0].as<int>();
         int in_id = action["object"][1].as<int>();
         Json j_add_out;
-        j_add_out[VALUE_ID] = out_id;
+        j_add_out[ID] = out_id;
         j_add_out[TYPE_TYPE] = BuildTypeJsonPatch(action);
         j_patch["patch"][OPRESULTS]["ADD"].push_back(j_add_out);
         Json j_add_in;
-        j_add_in[VALUE_ID] = in_id;
+        j_add_in[ID] = in_id;
         j_patch["patch"][OPOPERANDS]["ADD"].push_back(j_add_in);
       } else if (action_name == "delete_value") {
         VLOG(8) << "Patch for deleting values.";
         int out_id = action["object"][0].as<int>();
         int in_id = action["object"][1].as<int>();
         Json j_del_out;
-        j_del_out[VALUE_ID] = out_id;
+        j_del_out[ID] = out_id;
         j_patch["patch"][OPRESULTS]["DELETE"].push_back(j_del_out);
         Json j_del_in;
-        j_del_in[VALUE_ID] = in_id;
+        j_del_in[ID] = in_id;
         j_patch["patch"][OPOPERANDS]["DELETE"].push_back(j_del_in);
       }
     }
@@ -332,7 +333,13 @@ Json ParseOpPatches(const YAML::Node &root) {
         Json j_attr;
         j_attr[NAME] = attr_name;
         j_attr[ATTR_TYPE] = BuildAttrJsonPatch(action);
-        j_patch["patch"][ATTRS].push_back(j_attr);
+        if (action_name == "add_attr") {
+          Json j_add = Json::object();
+          j_add["ADD"] = j_attr;
+          j_patch["patch"][ATTRS].push_back(j_add);
+        } else {
+          j_patch["patch"][ATTRS].push_back(j_attr);
+        }
       } else if (action_name == "add_output_attr" ||
                  action_name == "modify_output_attr" ||
                  action_name == "delete_output_attr") {
@@ -341,7 +348,13 @@ Json ParseOpPatches(const YAML::Node &root) {
         Json j_attr;
         j_attr[NAME] = attr_name;
         j_attr[ATTR_TYPE] = BuildAttrJsonPatch(action);
-        j_patch["patch"][OPRESULTS_ATTRS].push_back(j_attr);
+        if (action_name == "add_output_attr") {
+          Json j_add = Json::object();
+          j_add["ADD"] = j_attr;
+          j_patch["patch"][OPRESULTS_ATTRS].push_back(j_add);
+        } else {
+          j_patch["patch"][OPRESULTS_ATTRS].push_back(j_attr);
+        }
       } else if (action_name == "modify_attr_name" ||
                  action_name == "modify_output_attr_name") {
         VLOG(8) << "Patch for modify attr name.";
@@ -355,22 +368,29 @@ Json ParseOpPatches(const YAML::Node &root) {
         j_patch["patch"][col].push_back(j_attr);
       } else if (action_name == "delete_input") {
         VLOG(8) << "Patch for delete_input";
+        Json j_input;
         int op_id = action["object"].as<int>();
-        j_patch["patch"][OPOPERANDS]["DELETE"].push_back(op_id);
+        j_input[ID] = op_id;
+        j_patch["patch"][OPOPERANDS]["DELETE"].push_back(j_input);
       } else if (action_name == "add_output") {
         VLOG(8) << "Patch for add_output";
         Json j_output;
         int op_id = action["object"].as<int>();
-        j_output[VALUE_ID] = op_id;
+        j_output[ID] = op_id;
         j_output[TYPE_TYPE] = BuildTypeJsonPatch(action);
         j_patch["patch"][OPRESULTS]["ADD"].push_back(j_output);
       } else if (action_name == "modify_output_type") {
         VLOG(8) << "Patch for modify_output_type";
         int op_id = action["object"].as<int>();
         Json j_type;
-        j_type[VALUE_ID] = op_id;
+        j_type[ID] = op_id;
         j_type[TYPE_TYPE] = BuildTypeJsonPatch(action);
-        j_patch["patch"][OPRESULTS].push_back(j_type);
+        j_patch["patch"][OPRESULTS]["UPDATE"].push_back(j_type);
+      } else if (action_name == "modify_name") {
+        VLOG(8) << "Patch for modify_name";
+        std::string op_name = action["default"].as<std::string>();
+        GetCompressOpName(&op_name);
+        j_patch["patch"]["NEW_NAME"] = op_name;
       }
     }
     json_patch.push_back(j_patch);
 
@@ -14,8 +14,10 @@
 
 #include "paddle/fluid/pir/serialize_deserialize/include/schema.h"
 #include <cstdlib>
-#include <filesystem>
+#include "paddle/fluid/pir/serialize_deserialize/include/third_party.h"
 #include "paddle/phi/core/enforce.h"
+#include "test/cpp/pir/tools/test1_dialect.h"
+#include "test/cpp/pir/tools/test_dialect.h"
 namespace pir {
 
 std::pair<std::string, std::string> GetContentSplitByDot(
@@ -53,6 +55,9 @@ DialectIdMap::DialectIdMap() {
   insert(pir::ControlFlowDialect::name(), "2");
   insert(paddle::dialect::CustomOpDialect::name(), "3");
   insert(paddle::dialect::DistDialect::name(), "4");
+  // TestDialect for test use
+  insert(test::TestDialect::name(), "5");
+  insert(test1::Test1Dialect::name(), "6");
 }
 void DialectIdMap::insert(const std::string& key, const std::string& value) {
   CompressDialect[key] = value;
@@ -86,11 +91,6 @@ std::string DialectIdMap::GetDecompressDialectId(const std::string& id) {
 
 uint64_t GetPirVersion() {
   VLOG(8) << "Get PIR Version: ";
-  // const char* paddle_root = PADDLE_ROOT;
-  // VLOG(8) << "Paddle path: " << paddle_root;
-  // std::filesystem::path patch_path = std::filesystem::path(paddle_root) /
-  //                                    "python" / "paddle" / "pir" /
-  //                                    "serialize_deserialize" / "patch";
   std::filesystem::path patch_path = std::filesystem::path(PATCH_PATH);
   VLOG(8) << "Patch path: " << patch_path;
   int version = 0;