PaddlePaddle
diff --git a/‎paddle/fluid/inference/api/analysis_predictor.cc
Copy file name to clipboard
+6-2Lines changed: 6 additions & 2 deletions b/‎paddle/fluid/inference/api/analysis_predictor.cc
Copy file name to clipboard
+6-2Lines changed: 6 additions & 2 deletions
diff --git a/‎paddle/fluid/pir/transforms/constant_folding_pass.cc
Copy file name to clipboard
+54-21Lines changed: 54 additions & 21 deletions b/‎paddle/fluid/pir/transforms/constant_folding_pass.cc
Copy file name to clipboard
+54-21Lines changed: 54 additions & 21 deletions
diff --git a/‎paddle/fluid/pir/transforms/fusion/conv2d_add_act_fuse_pass.cc
Copy file name to clipboard
+188Lines changed: 188 additions & 0 deletions b/‎paddle/fluid/pir/transforms/fusion/conv2d_add_act_fuse_pass.cc
Copy file name to clipboard
+188Lines changed: 188 additions & 0 deletions
diff --git a/‎paddle/fluid/pir/transforms/fusion/conv2d_add_act_fuse_pass.h
Copy file name to clipboard
+26Lines changed: 26 additions & 0 deletions b/‎paddle/fluid/pir/transforms/fusion/conv2d_add_act_fuse_pass.h
Copy file name to clipboard
+26Lines changed: 26 additions & 0 deletions
@@ -105,7 +105,9 @@
 #include "paddle/fluid/ir_adaptor/translator/translate.h"
 #include "paddle/fluid/pir/transforms/constant_folding_pass.h"
 #include "paddle/fluid/pir/transforms/dead_code_elimination_pass.h"
-#include "paddle/fluid/pir/transforms/fusion/conv2d_fuse_pass.h"
+#include "paddle/fluid/pir/transforms/fusion/conv2d_add_act_fuse_pass.h"
+#include "paddle/fluid/pir/transforms/fusion/conv2d_add_fuse_pass.h"
+#include "paddle/fluid/pir/transforms/fusion/conv2d_bn_fuse_pass.h"
 #include "paddle/fluid/pir/transforms/inplace_pass.h"
 #include "paddle/fluid/pir/transforms/params_sync_among_devices_pass.h"
 #include "paddle/fluid/pir/transforms/pd_op_to_kernel_pass.h"
@@ -782,7 +784,9 @@ bool AnalysisPredictor::PrepareExecutor() {
       ::pir::PassManager pm_for_op_program(::pir::IrContext::Instance(), 2);
       //----------------------------------------------------------------------------------------------//
       // Operator fusion pass
-      pm_for_op_program.AddPass(::pir::CreateConv2dFusePass());
+      pm_for_op_program.AddPass(::pir::CreateConv2dBnFusePass());
+      pm_for_op_program.AddPass(::pir::CreateConv2dAddActFusePass());
+      pm_for_op_program.AddPass(::pir::CreateConv2dAddFusePass());
       //----------------------------------------------------------------------------------------------//
 
       //----------------------------------------------------------------------------------------------//
 
@@ -72,22 +72,31 @@ class ConstantFoldingPattern : public pir::RewritePattern {
     // 1. Some ops do not need to be processed
     if (op->HasTrait<pir::SideEffectTrait>() ||
         op->isa<pir::ConstantTensorOp>() || op->isa<pir::ParameterOp>() ||
-        op->isa<paddle::dialect::FeedOp>())
+        op->isa<paddle::dialect::FeedOp>()) {
       return false;
+    }
 
     for (uint32_t i = 0; i < op->num_operands(); i++) {
+      if (!op->operand_source(i)) {
+        continue;
+      }
       // 2. inputs must come from parameter op or constant op
-      // 3. inputs must be a dense tensor type
       if (!(pir::GetDefiningOpForInput(op, i)->isa<pir::ParameterOp>() ||
-            pir::GetDefiningOpForInput(op, i)->isa<pir::ConstantTensorOp>()) ||
-          !op->operand_source(i)
+            pir::GetDefiningOpForInput(op, i)->isa<pir::ConstantTensorOp>())) {
+        return false;
+      }
+      // 3. inputs must be a dense tensor type
+      if (!op->operand_source(i)
                .type()
                .isa<paddle::dialect::DenseTensorType>()) {
         return false;
       }
     }
 
     for (uint32_t i = 0; i < op->num_results(); i++) {
+      if (!op->result(i)) {
+        continue;
+      }
       // 4. outputs must be a dense tensor type
       if (!op->result(i).type().isa<paddle::dialect::DenseTensorType>()) {
         return false;
@@ -115,7 +124,24 @@ class ConstantFoldingPattern : public pir::RewritePattern {
 
     rewriter.SetInsertionPointToStart(rewriter.block());
     // TODO(liuyuanle): support multiple output
-    if (ReplaceResultByParameter(op)) {
+    if (ReplaceResultByParameterOp(op)) {
+      auto* output_var = scope_->FindVar(output_var_name);
+      PADDLE_ENFORCE_NOT_NULL(
+          output_var,
+          phi::errors::InvalidArgument("Parameter var [%s] not in scope.",
+                                       output_var_name));
+      if (output_var->IsType<phi::DenseTensor>()) {
+        auto* output_tensor = output_var->GetMutable<phi::DenseTensor>();
+        if (output_tensor->place().GetType() != place_.GetType()) {
+          phi::DenseTensor temp_tensor;
+          temp_tensor.Resize(output_tensor->dims());
+          paddle::framework::TensorCopySync(
+              *output_tensor, phi::CPUPlace{}, &temp_tensor);
+          output_tensor->clear();
+          paddle::framework::TensorCopySync(temp_tensor, place_, output_tensor);
+        }
+      }
+
       auto parameter_op = rewriter.Build<pir::ParameterOp>(
           output_var_name, op->result(0).type());
       parameter_op->set_attribute(
@@ -138,7 +164,7 @@ class ConstantFoldingPattern : public pir::RewritePattern {
   bool CheckUseOps(const std::vector<pir::Operation*>& use_ops) const {
     for (auto* use_op : use_ops) {
       if (use_op->isa<pir::CombineOp>()) {
-        if (!ReplaceResultByParameter(use_op)) return false;
+        if (!ReplaceResultByParameterOp(use_op)) return false;
       } else if (use_op->HasInterface<paddle::dialect::OpYamlInfoInterface>()) {
         auto [input_infos, _1, _2, _3, _4] =
             use_op->dyn_cast<paddle::dialect::OpYamlInfoInterface>()
@@ -156,7 +182,7 @@ class ConstantFoldingPattern : public pir::RewritePattern {
     return true;
   }
 
-  bool ReplaceResultByParameter(pir::Operation* op) const {
+  bool ReplaceResultByParameterOp(pir::Operation* op) const {
     for (uint32_t i = 0; i < op->num_results(); i++) {
       auto use_ops = pir::GetUseOpsForOutput(op, i);
       if (!CheckUseOps(use_ops)) return false;
@@ -174,22 +200,29 @@ class ConstantFoldingPattern : public pir::RewritePattern {
     // prepare op inputs
     std::vector<pir::Value> op_inputs;
     for (uint32_t i = 0; i < op->num_operands(); i++) {
-      const auto& param_name =
-          pir::GetParameterNameFromValue(op->operand_source(i));
-      auto* param_var = scope_->FindVar(param_name);
-      PADDLE_ENFORCE_NOT_NULL(
-          param_var,
-          phi::errors::InvalidArgument("Parameter var not in scope."));
-
-      auto parameter_op = builder.Build<pir::ParameterOp>(
-          param_name, op->operand_source(i).type());
-      if (op->operand_source(i).use_count() <= 1) {
-        deleted_vars_->push_back(param_name);
+      if (op->operand_source(i)) {
+        const auto& param_name =
+            pir::GetParameterNameFromValue(op->operand_source(i));
+        auto* param_var = scope_->FindVar(param_name);
+        PADDLE_ENFORCE_NOT_NULL(
+            param_var,
+            phi::errors::InvalidArgument("Parameter var [%s] not in scope.",
+                                         param_name));
+
+        auto parameter_op = builder.Build<pir::ParameterOp>(
+            param_name, op->operand_source(i).type());
+        if (op->operand_source(i).use_count() <= 1) {
+          deleted_vars_->push_back(param_name);
+        } else {
+          parameter_op->set_attribute(
+              kAttrIsPersisable,
+              rewriter.array_attr({rewriter.bool_attr(true)}));
+        }
+        op_inputs.push_back(parameter_op->result(0));
       } else {
-        parameter_op->set_attribute(
-            kAttrIsPersisable, rewriter.array_attr({rewriter.bool_attr(true)}));
+        op_inputs.push_back(
+            op->operand_source(i).dyn_cast<pir::OpResult>() /*nullptr*/);
       }
-      op_inputs.push_back(parameter_op->result(0));
     }
 
     // prepare op outputs
 
@@ -0,0 +1,188 @@
+// 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
+//
+//     https://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/pir/pass/pass_registry.h"
+#include "paddle/pir/pattern_rewrite/pattern_rewrite_driver.h"
+
+#include "paddle/fluid/pir/dialect/operator/ir/pd_op.h"
+#include "paddle/fluid/pir/transforms/fusion/conv2d_add_act_fuse_pass.h"
+
+#include "paddle/fluid/pir/dialect/operator/ir/op_dialect.h"
+#include "paddle/fluid/pir/dialect/operator/ir/op_type.h"
+#include "paddle/fluid/pir/transforms/transform_general_functions.h"
+#include "paddle/phi/core/ddim.h"
+
+namespace {
+
+class Conv2dAddActFusePattern
+    : public pir::OpRewritePattern<paddle::dialect::AddOp> {
+ public:
+  using pir::OpRewritePattern<paddle::dialect::AddOp>::OpRewritePattern;
+
+  bool MatchAndRewrite(
+      paddle::dialect::AddOp op,
+      pir::PatternRewriter &rewriter) const override {  // NOLINT
+    paddle::dialect::Conv2dOp conv2d_op =
+        pir::GetDefiningOpForInput(op, 0)
+            ->dyn_cast<paddle::dialect::Conv2dOp>();
+    if (!conv2d_op) return false;
+
+    pir::OpResult conv2d_out = conv2d_op.out();
+    if (!conv2d_out.HasOneUse()) return false;
+
+    pir::Value add_input = op.x();
+    IR_ENFORCE(add_input == conv2d_out);
+
+    pir::OpResult add_out = op.out();
+    if (!add_out.HasOneUse()) return false;
+
+    auto next_op_list = pir::GetUseOpsForOutput(op, 0);
+    if (next_op_list.size() == 0) return false;
+
+    auto next_op = next_op_list[0];
+    std::string act_name = "";
+    if (next_op->isa<paddle::dialect::ReluOp>()) {
+      act_name = "relu";
+    }
+#if CUDNN_VERSION >= 8000 && CUDNN_VERSION < 8700
+    if (next_op->isa<paddle::dialect::TanhOp>()) {
+      act_name = "tanh";
+    } else if (next_op->isa<paddle::dialect::SigmoidOp>()) {
+      act_name = "sigmoid";
+    }
+#endif
+    if (act_name == "") return false;
+
+    auto conv2d_fusion_attributes = conv2d_op->attributes();
+    conv2d_fusion_attributes["activation"] = rewriter.str_attr(act_name);
+    conv2d_fusion_attributes["split_channels"] =
+        rewriter.array_attr(std::vector<pir::Attribute>{});
+    conv2d_fusion_attributes["exhaustive_search"] = rewriter.bool_attr(false);
+    conv2d_fusion_attributes["workspace_size_MB"] = rewriter.int32_attr(32);
+    conv2d_fusion_attributes["fuse_alpha"] = rewriter.float_attr(0.0f);
+    auto conv2d_fuse_op = rewriter.Build<paddle::dialect::Conv2dFusionOp>(
+        conv2d_op.input().dyn_cast<pir::OpResult>(),
+        conv2d_op.filter().dyn_cast<pir::OpResult>(),
+        op.y().dyn_cast<pir::OpResult>(),
+        pir::Value{}.dyn_cast<pir::OpResult>(),
+        conv2d_fusion_attributes);
+    rewriter.ReplaceOp(next_op,
+                       std::vector<pir::Value>{conv2d_fuse_op.output()});
+    rewriter.EraseOp(op);
+    rewriter.EraseOp(conv2d_op);
+    return true;
+  }
+};
+
+class Conv2dAdd2ActFusePattern
+    : public pir::OpRewritePattern<paddle::dialect::AddOp> {
+ public:
+  using pir::OpRewritePattern<paddle::dialect::AddOp>::OpRewritePattern;
+
+  bool MatchAndRewrite(
+      paddle::dialect::AddOp add2_op,
+      pir::PatternRewriter &rewriter) const override {  // NOLINT
+    paddle::dialect::AddOp add1_op = pir::GetDefiningOpForInput(add2_op, 1)
+                                         ->dyn_cast<paddle::dialect::AddOp>();
+    if (!add1_op) return false;
+
+    pir::OpResult add1_out = add1_op.out();
+    if (!add1_out.HasOneUse()) return false;
+
+    paddle::dialect::Conv2dOp conv2d_op =
+        pir::GetDefiningOpForInput(add1_op, 0)
+            ->dyn_cast<paddle::dialect::Conv2dOp>();
+    if (!conv2d_op) return false;
+
+    pir::OpResult conv2d_out = conv2d_op.out();
+    if (!conv2d_out.HasOneUse()) return false;
+
+    auto next_op_list = pir::GetUseOpsForOutput(add2_op, 0);
+    if (next_op_list.size() == 0) return false;
+    auto next_op = next_op_list[0];
+    std::string act_name = "";
+    if (next_op->isa<paddle::dialect::ReluOp>()) {
+      act_name = "relu";
+    }
+#if CUDNN_VERSION >= 8000 && CUDNN_VERSION < 8700
+    if (next_op->isa<paddle::dialect::TanhOp>()) {
+      act_name = "tanh";
+    } else if (next_op->isa<paddle::dialect::SigmoidOp>()) {
+      act_name = "sigmoid";
+    }
+#endif
+    if (act_name == "") {
+      return false;
+    }
+
+    auto conv2d_fusion_attributes = conv2d_op->attributes();
+    conv2d_fusion_attributes["activation"] = rewriter.str_attr(act_name);
+    conv2d_fusion_attributes["split_channels"] =
+        rewriter.array_attr(std::vector<pir::Attribute>{});
+    conv2d_fusion_attributes["exhaustive_search"] = rewriter.bool_attr(false);
+    conv2d_fusion_attributes["workspace_size_MB"] = rewriter.int32_attr(32);
+    conv2d_fusion_attributes["fuse_alpha"] = rewriter.float_attr(0.0f);
+    auto conv2d_fuse_op = rewriter.Build<paddle::dialect::Conv2dFusionOp>(
+        conv2d_op.input().dyn_cast<pir::OpResult>(),
+        conv2d_op.filter().dyn_cast<pir::OpResult>(),
+        add1_op.y().dyn_cast<pir::OpResult>(),
+        add2_op.x().dyn_cast<pir::OpResult>(),
+        conv2d_fusion_attributes);
+    rewriter.ReplaceOp(next_op,
+                       std::vector<pir::Value>{conv2d_fuse_op.output()});
+
+    rewriter.EraseOp(add2_op);
+    rewriter.EraseOp(add1_op);
+    rewriter.EraseOp(conv2d_op);
+    return true;
+  }
+};
+
+class Conv2dAddActFusePass : public pir::PatternRewritePass {
+ public:
+  Conv2dAddActFusePass()
+      : pir::PatternRewritePass("conv2d_add_act_fuse_pass", 2) {}
+
+  pir::RewritePatternSet InitializePatterns(pir::IrContext *context) override {
+    pir::RewritePatternSet ps(context);
+
+    auto conv2d_add_act_fuse_pattern =
+        std::make_unique<Conv2dAddActFusePattern>(
+            context,
+            1,
+            std::vector<std::string>{paddle::dialect::Conv2dFusionOp::name()});
+    auto conv2d_doublue_add_act_fuse_pattern =
+        std::make_unique<Conv2dAdd2ActFusePattern>(
+            context,
+            1,
+            std::vector<std::string>{paddle::dialect::Conv2dFusionOp::name()});
+
+    // conv2d+add+add+act->conv2d_fusion
+    ps.Add(std::move(conv2d_doublue_add_act_fuse_pattern));
+    // conv2d+add+act->conv2d_fusion
+    ps.Add(std::move(conv2d_add_act_fuse_pattern));
+    return ps;
+  }
+};
+
+}  // namespace
+
+namespace pir {
+
+std::unique_ptr<Pass> CreateConv2dAddActFusePass() {
+  return std::make_unique<Conv2dAddActFusePass>();
+}
+
+}  // namespace pir
+
+REGISTER_IR_PASS(conv2d_add_act_fuse_pass, Conv2dAddActFusePass);
@@ -0,0 +1,26 @@
+// 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
+//
+//     https://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 <memory>
+#include "paddle/pir/core/dll_decl.h"
+
+namespace pir {
+
+class Pass;
+
+IR_API std::unique_ptr<Pass> CreateConv2dAddActFusePass();
+
+}  // namespace pir