PaddlePaddle
diff --git a/‎paddle/fluid/inference/api/paddle_pass_builder.cc
Copy file name to clipboard
+1Lines changed: 1 addition & 0 deletions b/‎paddle/fluid/inference/api/paddle_pass_builder.cc
Copy file name to clipboard
+1Lines changed: 1 addition & 0 deletions
diff --git a/‎paddle/fluid/pir/transforms/onednn/matmul_elementwise_add_fuse_pass.cc
Copy file name to clipboard
+63-50Lines changed: 63 additions & 50 deletions b/‎paddle/fluid/pir/transforms/onednn/matmul_elementwise_add_fuse_pass.cc
Copy file name to clipboard
+63-50Lines changed: 63 additions & 50 deletions
@@ -624,6 +624,7 @@ const std::vector<std::string> kPirMkldnnPasses{
     "conv2d_transpose_bias_fuse_pass",
     "conv3d_bias_fuse_pass",
     "batch_norm_act_fuse_pass",
+    "reshape_transpose_matmul_fuse_pass",
     "matmul_elementwise_add_fuse_pass",
     "matmul_activation_fuse_pass",
     "conv_elementwise_add_mkldnn_fuse_pass"};
 
@@ -106,20 +106,17 @@ class FusedMatmulElementwiseAddFusePattern
   std::string matmul_name_;
   std::string fused_matmul_name_;
   uint32_t benefit_;
-  bool as_x_;   // Decide input direction of 1st add
-  bool as_x2_;  // Decide input direction of 2nd add
+  bool as_x_;  // Decide input direction of add
 
  public:
   FusedMatmulElementwiseAddFusePattern(const std::string &matmul_name,
                                        const std::string &fused_matmul_name,
                                        uint32_t benefit,
-                                       bool as_x,
-                                       bool as_x2)
+                                       bool as_x)
       : matmul_name_(matmul_name),
         fused_matmul_name_(fused_matmul_name),
         benefit_(benefit),
-        as_x_(as_x),
-        as_x2_(as_x2) {}
+        as_x_(as_x) {}
 
   std::string name() const override {
     return "FusedMatmulElementwiseAddFusePattern";
@@ -130,20 +127,35 @@ class FusedMatmulElementwiseAddFusePattern
   void operator()(paddle::drr::DrrPatternContext *ctx) const override {
     paddle::drr::SourcePattern pat = ctx->SourcePattern();
 
-    const auto &matmul = pat.Op(matmul_name_,
-                                {{"transpose_x", pat.Attr("transpose_x")},
-                                 {"transpose_y", pat.Attr("transpose_y")}});
+    const auto &matmul =
+        pat.Op(matmul_name_,
+               {{"trans_x", pat.Attr("transpose_x")},
+                {"trans_y", pat.Attr("transpose_y")},
+                {"matmul_alpha", pat.Attr("matmul_alpha")},
+                {"fuse_activation", pat.Attr("fuse_activation")},
+                {"fuse_alpha", pat.Attr("fuse_alpha")},
+                {"fuse_beta", pat.Attr("fuse_beta")},
+                {"fused_output_scale", pat.Attr("fused_output_scale")},
+                {"fused_reshape_x", pat.Attr("fused_reshape_x")},
+                {"fused_transpose_x", pat.Attr("fused_transpose_x")},
+                {"fused_reshape_y", pat.Attr("fused_reshape_y")},
+                {"fused_transpose_y", pat.Attr("fused_transpose_y")},
+                {"fused_reshape_out", pat.Attr("fused_reshape_out")},
+                {"fused_transpose_out", pat.Attr("fused_transpose_out")},
+                {"mkldnn_data_type", pat.Attr("mkldnn_data_type")},
+                {"scale_x", pat.Attr("scale_x")},
+                {"scale_y", pat.Attr("scale_y")},
+                {"scale_in_eltwise", pat.Attr("scale_in_eltwise")},
+                {"scale_out", pat.Attr("scale_out")},
+                {"force_fp32_output", pat.Attr("force_fp32_output")}});
 
     const auto &add = pat.Op(paddle::dialect::AddOp::name());
-    const auto &add2 = pat.Op(paddle::dialect::AddOp::name());
-    matmul({&pat.Tensor("X"), &pat.Tensor("Y")}, {&pat.Tensor("Out")});
+    matmul({&pat.Tensor("X"), &pat.Tensor("Y"), &pat.Tensor("none")},
+           {&pat.Tensor("Out")});
 
     pat.Tensor("add_out") =
         as_x_ ? add(pat.Tensor("Out"), pat.Tensor("residual"))
               : add(pat.Tensor("residual"), pat.Tensor("Out"));
-    pat.Tensor("add_out_end") =
-        as_x2_ ? add2(pat.Tensor("add_out"), pat.Tensor("residual2"))
-               : add2(pat.Tensor("residual2"), pat.Tensor("add_out"));
 
     pat.RequireNativeCall([&](const paddle::drr::MatchContext &match_ctx) {
       std::set<bool> bool_sets = {true, false};
@@ -155,38 +167,42 @@ class FusedMatmulElementwiseAddFusePattern
       return true;
     });
 
-    paddle::drr::ResultPattern res = pat.ResultPattern();
+    pat.RequireNativeCall([&](const paddle::drr::MatchContext &match_ctx) {
+      auto none_tensor = match_ctx.Tensor("none");
+      if (none_tensor.impl() != nullptr) {
+        return false;
+      }
+      return true;
+    });
 
-    const auto &fused_add = res.Op(paddle::dialect::AddOp::name());
-    res.Tensor("residual3") =
-        fused_add(res.Tensor("residual1"), res.Tensor("residual2"));
+    paddle::drr::ResultPattern res = pat.ResultPattern();
 
     const auto &fused_matmul =
         res.Op(fused_matmul_name_,
                {{
                    {"trans_x", pat.Attr("transpose_x")},
                    {"trans_y", pat.Attr("transpose_y")},
-                   {"matmul_alpha", res.Float32Attr(1.0f)},
-                   {"fuse_activation", res.StrAttr("")},
-                   {"fuse_alpha", res.Float32Attr(0.0f)},
-                   {"fuse_beta", res.Float32Attr(0.0f)},
-                   {"fused_output_scale", res.Float32Attr(1.0f)},
-                   {"fused_reshape_x", res.VectorInt32Attr({})},
-                   {"fused_transpose_x", res.VectorInt32Attr({})},
-                   {"fused_reshape_y", res.VectorInt32Attr({})},
-                   {"fused_transpose_y", res.VectorInt32Attr({})},
-                   {"fused_reshape_out", res.VectorInt32Attr({})},
-                   {"fused_transpose_out", res.VectorInt32Attr({})},
-                   {"mkldnn_data_type", res.StrAttr("float32")},
-                   {"scale_x", res.Float32Attr(1.0f)},
-                   {"scale_y", res.Float32Attr(1.0f)},
-                   {"scale_in_eltwise", res.Float32Attr(0.0f)},
-                   {"scale_out", res.Float32Attr(1.0f)},
-                   {"force_fp32_output", res.BoolAttr(false)},
+                   {"matmul_alpha", pat.Attr("matmul_alpha")},
+                   {"fuse_activation", pat.Attr("fuse_activation")},
+                   {"fuse_alpha", pat.Attr("fuse_alpha")},
+                   {"fuse_beta", pat.Attr("fuse_beta")},
+                   {"fused_output_scale", pat.Attr("fused_output_scale")},
+                   {"fused_reshape_x", pat.Attr("fused_reshape_x")},
+                   {"fused_transpose_x", pat.Attr("fused_transpose_x")},
+                   {"fused_reshape_y", pat.Attr("fused_reshape_y")},
+                   {"fused_transpose_y", pat.Attr("fused_transpose_y")},
+                   {"fused_reshape_out", pat.Attr("fused_reshape_out")},
+                   {"fused_transpose_out", pat.Attr("fused_transpose_out")},
+                   {"mkldnn_data_type", pat.Attr("mkldnn_data_type")},
+                   {"scale_x", pat.Attr("scale_x")},
+                   {"scale_y", pat.Attr("scale_y")},
+                   {"scale_in_eltwise", pat.Attr("scale_in_eltwise")},
+                   {"scale_out", pat.Attr("scale_out")},
+                   {"force_fp32_output", pat.Attr("force_fp32_output")},
                }});
 
-    fused_matmul({&res.Tensor("X"), &res.Tensor("Y"), &res.Tensor("residual3")},
-                 {&res.Tensor("add_out_end")});
+    fused_matmul({&res.Tensor("X"), &res.Tensor("Y"), &res.Tensor("residual")},
+                 {&res.Tensor("add_out")});
   }
 };
 
@@ -209,17 +225,15 @@ class MatmulElementwiseAddFusePass : public pir::PatternRewritePass {
       benefit_idx++;
     }
 
-    for (auto as_x : bool_set)
-      for (auto as_x2 : bool_set) {
-        ps.Add(paddle::drr::Create<FusedMatmulElementwiseAddFusePattern>(
-            context,
-            paddle::dialect::MatmulOp::name(),
-            paddle::onednn::dialect::FusedMatmulOp::name(),
-            benefit_idx,
-            as_x,
-            as_x2));
-        benefit_idx++;
-      }
+    for (auto as_x : bool_set) {
+      ps.Add(paddle::drr::Create<FusedMatmulElementwiseAddFusePattern>(
+          context,
+          paddle::onednn::dialect::FusedMatmulOp::name(),
+          paddle::onednn::dialect::FusedMatmulOp::name(),
+          benefit_idx,
+          as_x));
+      benefit_idx++;
+    }
     return ps;
   }
 };
@@ -230,8 +244,7 @@ namespace pir {
 
 std::unique_ptr<Pass> CreateMatmulElementwiseAddFusePass() {
   // pd_op.matmul + pd_op.add -> onednn_op.fused_matmul
-  // pd_op.matmul + pd_op.add + pd_op.add -> pd_op.add + onednn_op.fused_matmul
-  // -> onednn_op.fused_matmul
+  // onednn_op.fused_matmul + pd_op.add -> onednn_op.fused_matmul
   return std::make_unique<MatmulElementwiseAddFusePass>();
 }
 }  // namespace pir