From 0922d8dc69ecdd581345900b5753c674453d6ed4 Mon Sep 17 00:00:00 2001
From: jiahongyu <jiahongyu@baidu.com>
Date: Thu, 11 Apr 2024 09:56:49 +0000
Subject: [PATCH 01/99] [CINN] Support horizontal fusion

---
 paddle/cinn/api/op_topo_pattern.h             |  2 +-
 .../cluster_policy/relative_judge_policy.h    |  2 +-
 .../frontend/group_cluster/pattern_graph.cc   |  4 +-
 test/ir/pir/cinn/test_horizontal_fusion.py    | 63 +++++++++++++++++++
 4 files changed, 68 insertions(+), 3 deletions(-)
 create mode 100644 test/ir/pir/cinn/test_horizontal_fusion.py

diff --git a/paddle/cinn/api/op_topo_pattern.h b/paddle/cinn/api/op_topo_pattern.h
index 34f17fbfde9e0e..96e94840871101 100644
--- a/paddle/cinn/api/op_topo_pattern.h
+++ b/paddle/cinn/api/op_topo_pattern.h
@@ -31,7 +31,7 @@ struct InjectiveSourcePattern {};
 template <typename T>
 struct SingleReductionOpPattern {};
 
-// ElementWise/Broadcast ops which have shardable dimentions and reduction
+// ElementWise/Broadcast ops which have shardable dimensions and reduction
 // ancestors.
 template <typename T>
 struct PartialShardablePattern {};
diff --git a/paddle/cinn/frontend/group_cluster/cluster_policy/relative_judge_policy.h b/paddle/cinn/frontend/group_cluster/cluster_policy/relative_judge_policy.h
index e98b68dc893af4..9352a4efe12619 100644
--- a/paddle/cinn/frontend/group_cluster/cluster_policy/relative_judge_policy.h
+++ b/paddle/cinn/frontend/group_cluster/cluster_policy/relative_judge_policy.h
@@ -155,7 +155,7 @@ static ValueDimRelation CreateOpRelativenessForReduce(pir::Operation* op) {
   int out_idx = 0;
   bool keep_dim = GetReduceOpKeepDims(op);
   for (int i = 0; i < input_rank; i++) {
-    if (std::find(reduce_axis_idx.begin(), reduce_axis_idx.end(), i) !=
+    if (std::find(reduce_axis_idx.begin(), reduce_axis_idx.end(), i) ==
         reduce_axis_idx.end()) {
       res[ValueDim(op->operand_source(0), i)]
          [ValueDim(op->result(0), out_idx)] = true;
diff --git a/paddle/cinn/frontend/group_cluster/pattern_graph.cc b/paddle/cinn/frontend/group_cluster/pattern_graph.cc
index bbd49d1b17503e..465613db8e7921 100644
--- a/paddle/cinn/frontend/group_cluster/pattern_graph.cc
+++ b/paddle/cinn/frontend/group_cluster/pattern_graph.cc
@@ -91,7 +91,9 @@ void PatternGraph::ReduceLiftReduceTree() {
 
 void PatternGraph::HorizontalFusion() {
   GraphTransformer<NodePattern,
-                   StmtPatternGraphMatcher<TrivialPattern>,
+                   Or<Or<StmtPatternGraphMatcher<TrivialPattern>,
+                         StmtPatternGraphMatcher<ReduceTreePlusTrivialPattern>>,
+                      StmtPatternGraphMatcher<ReduceTreePattern>>,
                    LiftToHorizontalFusionPatternOperation>(this);
 
   GraphTransformer<NodePairPattern,
diff --git a/test/ir/pir/cinn/test_horizontal_fusion.py b/test/ir/pir/cinn/test_horizontal_fusion.py
new file mode 100644
index 00000000000000..83556ec647bf89
--- /dev/null
+++ b/test/ir/pir/cinn/test_horizontal_fusion.py
@@ -0,0 +1,63 @@
+# Copyright (c) 2024 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.
+import unittest
+
+import numpy as np
+import utils
+
+import paddle
+
+
+class HorizontalSubGraph(paddle.nn.Layer):
+    def __init__(self):
+        super().__init__()
+
+    def forward(self, x):
+        tmp1 = paddle.sum(x, axis=-1)
+        tmp2 = paddle.sum(x * x, axis=-1)
+        return tmp1 * tmp2
+
+
+class TestHorizontalGraph(unittest.TestCase):
+    def setUp(self):
+        paddle.seed(2024)
+        self.prepare_data()
+
+    def prepare_data(self):
+        self.x = paddle.randn([256, 128], dtype="bfloat16")
+        self.x.stop_gradient = True
+
+    def check_jit_kernel_info(self, static_fn):
+        utils.check_jit_kernel_number(static_fn, 1)
+        utils.check_jit_kernel_structure(static_fn, {utils.JIT_KERNEL_NAME: 1})
+
+    def eval(self, use_cinn):
+        net = HorizontalSubGraph()
+        net.eval()
+        net = utils.apply_to_static(net, use_cinn)
+        out = net(self.x)
+        if use_cinn:
+            self.check_jit_kernel_info(net.forward)
+        return out
+
+    def test_eval(self):
+        cinn_out = self.eval(use_cinn=True)
+        dy_out = self.eval(use_cinn=False)
+        np.testing.assert_allclose(
+            cinn_out.numpy(), dy_out.numpy(), atol=1e-6, rtol=1e-6
+        )
+
+
+if __name__ == '__main__':
+    unittest.main()

From e219ce31feee414b5f2cf32aa20f1ae42e0661ae Mon Sep 17 00:00:00 2001
From: jiahongyu <jiahongyu@baidu.com>
Date: Fri, 12 Apr 2024 02:32:02 +0000
Subject: [PATCH 02/99] Change data type

---
 test/ir/pir/cinn/test_horizontal_fusion.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/ir/pir/cinn/test_horizontal_fusion.py b/test/ir/pir/cinn/test_horizontal_fusion.py
index 83556ec647bf89..b9bcf8b7010a1f 100644
--- a/test/ir/pir/cinn/test_horizontal_fusion.py
+++ b/test/ir/pir/cinn/test_horizontal_fusion.py
@@ -35,7 +35,7 @@ def setUp(self):
         self.prepare_data()
 
     def prepare_data(self):
-        self.x = paddle.randn([256, 128], dtype="bfloat16")
+        self.x = paddle.randn([256, 128], dtype="float32")
         self.x.stop_gradient = True
 
     def check_jit_kernel_info(self, static_fn):

From a3bb64b335fa1f4dbd190432d48bf160b9f2c0f5 Mon Sep 17 00:00:00 2001
From: jiahongyu <jiahongyu@baidu.com>
Date: Mon, 22 Apr 2024 08:56:39 +0000
Subject: [PATCH 03/99] Support horizontal fusion

---
 paddle/cinn/operator_fusion/backend/pattern.h | 17 ----
 .../cinn/operator_fusion/frontend/pattern.h   | 17 ----
 paddle/cinn/operator_fusion/pattern.h         | 21 ++++-
 paddle/cinn/operator_fusion/pattern_graph.cc  | 13 ++-
 paddle/cinn/operator_fusion/pattern_graph.h   | 93 +++++++++++++++----
 5 files changed, 103 insertions(+), 58 deletions(-)

diff --git a/paddle/cinn/operator_fusion/backend/pattern.h b/paddle/cinn/operator_fusion/backend/pattern.h
index 7006fb02b829e4..4df4e9419cc62b 100644
--- a/paddle/cinn/operator_fusion/backend/pattern.h
+++ b/paddle/cinn/operator_fusion/backend/pattern.h
@@ -68,21 +68,4 @@ struct UnsupportPattern<BackendStage> {
   static std::string name() { return "Unsupport"; }
 };
 
-template <>
-struct HorizontalFusionPattern<BackendStage> {
-  explicit HorizontalFusionPattern(
-      const std::vector<StmtPattern<BackendStage>>& patterns)
-      : patterns_(patterns) {}
-  std::vector<StmtPattern<BackendStage>> patterns_;
-  std::vector<pir::Operation*> ops() const {
-    std::vector<pir::Operation*> result;
-    for (const auto& pattern : patterns_) {
-      auto ops = GetOpsInPattern(pattern);
-      ExtendVector(&result, ops);
-    }
-    return result;
-  }
-  static std::string name() { return "HorizontalFusionPattern"; }
-};
-
 }  // namespace cinn::fusion
diff --git a/paddle/cinn/operator_fusion/frontend/pattern.h b/paddle/cinn/operator_fusion/frontend/pattern.h
index e267483e56586d..5c2641a808ce1a 100644
--- a/paddle/cinn/operator_fusion/frontend/pattern.h
+++ b/paddle/cinn/operator_fusion/frontend/pattern.h
@@ -72,21 +72,4 @@ struct UnsupportPattern<FrontendStage> {
   static std::string name() { return "Unsupport"; }
 };
 
-template <>
-struct HorizontalFusionPattern<FrontendStage> {
-  explicit HorizontalFusionPattern(
-      const std::vector<StmtPattern<FrontendStage>>& patterns)
-      : patterns_(patterns) {}
-  std::vector<StmtPattern<FrontendStage>> patterns_;
-  std::vector<pir::Operation*> ops() const {
-    std::vector<pir::Operation*> result;
-    for (const auto& pattern : patterns_) {
-      auto ops = GetOpsInPattern(pattern);
-      ExtendVector(&result, ops);
-    }
-    return result;
-  }
-  static std::string name() { return "HorizontalFusionPattern"; }
-};
-
 }  // namespace cinn::fusion
diff --git a/paddle/cinn/operator_fusion/pattern.h b/paddle/cinn/operator_fusion/pattern.h
index 908b4a4348bfc6..73558dd1535ad9 100644
--- a/paddle/cinn/operator_fusion/pattern.h
+++ b/paddle/cinn/operator_fusion/pattern.h
@@ -79,9 +79,26 @@ struct ReduceTreePlusTrivialPattern {
 };
 
 template <typename T>
-class UnsupportPattern {};
+struct StmtPattern;
+
+template <typename T>
+struct UnsupportPattern {};
+
 template <typename T>
-class HorizontalFusionPattern {};
+struct HorizontalFusionPattern {
+  explicit HorizontalFusionPattern(const std::vector<StmtPattern<T>>& patterns)
+      : patterns_(patterns) {}
+  std::vector<StmtPattern<T>> patterns_;
+  std::vector<pir::Operation*> ops() const {
+    std::vector<pir::Operation*> result;
+    for (const auto& pattern : patterns_) {
+      auto ops = GetOpsInPattern(pattern);
+      ExtendVector(&result, ops);
+    }
+    return result;
+  }
+  static std::string name() { return "HorizontalFusionPattern"; }
+};
 
 template <typename T>
 using StmtPatternBase = std::variant<TrivialPattern<T>,
diff --git a/paddle/cinn/operator_fusion/pattern_graph.cc b/paddle/cinn/operator_fusion/pattern_graph.cc
index a8ab68cf809b36..4c3a745cbb95e4 100644
--- a/paddle/cinn/operator_fusion/pattern_graph.cc
+++ b/paddle/cinn/operator_fusion/pattern_graph.cc
@@ -99,14 +99,17 @@ void PatternGraph<T>::ReduceLiftReduceTree() {
 
 template <typename T>
 void PatternGraph<T>::HorizontalFusion() {
-  GraphTransformer<NodePattern,
-                   T,
-                   StmtPatternGraphMatcher<TrivialPattern<T>>,
-                   LiftToHorizontalFusionPatternOperation>(this);
+  GraphTransformer<
+      NodePattern,
+      T,
+      Or<Or<StmtPatternGraphMatcher<TrivialPattern<T>>,
+            StmtPatternGraphMatcher<ReduceTreePlusTrivialPattern<T>>>,
+         StmtPatternGraphMatcher<ReduceTreePattern<T>>>,
+      LiftToHorizontalFusionPatternOperation>(this);
 
   GraphTransformer<NodePairPattern,
                    T,
-                   HorizontalFusionConstrain,
+                   HorizontalFusionConstrain<T>,
                    HorizontalFusionOperation>(this);
 }
 
diff --git a/paddle/cinn/operator_fusion/pattern_graph.h b/paddle/cinn/operator_fusion/pattern_graph.h
index e6ba1342623491..4103e6b1ce491c 100644
--- a/paddle/cinn/operator_fusion/pattern_graph.h
+++ b/paddle/cinn/operator_fusion/pattern_graph.h
@@ -322,29 +322,88 @@ struct CanFuseReduceTreeAndTrivialMatcher {
   }
 };
 
+template <typename T>
 struct HorizontalFusionConstrain {
-  template <typename T>
   bool operator()(const PatternGraph<T>& graph,
-                  const PatternNodePtr<T>& first,
-                  const PatternNodePtr<T>& second) {
-    if (!StmtPatternGraphMatcher<HorizontalFusionPattern<T>>()(graph, first)) {
+                  const PatternNodePtr<T>& lhs,
+                  const PatternNodePtr<T>& rhs) {
+    if (!StmtPatternGraphMatcher<HorizontalFusionPattern<T>>()(graph, lhs)) {
       return false;
     }
-    if (!StmtPatternGraphMatcher<HorizontalFusionPattern<T>>()(graph, second)) {
+    if (!StmtPatternGraphMatcher<HorizontalFusionPattern<T>>()(graph, rhs)) {
       return false;
     }
-    const auto& first_dim = first->sink_op()
-                                ->result(0)
-                                .type()
-                                .template dyn_cast<pir::DenseTensorType>()
-                                .dims();
-    const auto& second_dim = second->sink_op()
-                                 ->result(0)
-                                 .type()
-                                 .template dyn_cast<pir::DenseTensorType>()
-                                 .dims();
-    return graph.topo_manager().CanFuse(first, second) &&
-           first_dim == second_dim;
+    const auto& lhs_pattern =
+        lhs->stmt_pattern().template Get<HorizontalFusionPattern>();
+    const auto& rhs_pattern =
+        rhs->stmt_pattern().template Get<HorizontalFusionPattern>();
+
+    return graph.topo_manager().CanFuse(lhs, rhs) &&
+           PatternDimMatch(lhs_pattern.patterns_.back(),
+                           rhs_pattern.patterns_.back());
+  }
+
+  const pir::DenseTensorType::Dim& GetInputDim(pir::Operation* op) {
+    return op->operand_source(0)
+        .type()
+        .template dyn_cast<pir::DenseTensorType>()
+        .dims();
+  }
+
+  const pir::DenseTensorType::Dim& GetOutputDim(pir::Operation* op) {
+    return op->result(0)
+        .type()
+        .template dyn_cast<pir::DenseTensorType>()
+        .dims();
+  }
+
+  template <template <typename> class LhsPattern,
+            template <typename>
+            class RhsPattern>
+  bool PatternDimMatchImpl(const LhsPattern<T>& lhs, const RhsPattern<T>& rhs) {
+    VLOG(4) << "Horizontal Fusion failed with default pattern lhs = "
+            << lhs.name() << ", rhs = " << rhs.name();
+    return false;
+  }
+
+  bool PatternDimMatchImpl(const TrivialPattern<T>& lhs,
+                           const TrivialPattern<T>& rhs) {
+    VLOG(4) << "Horizontal Fusion between TrivialPattern";
+    return GetOutputDim(lhs.ops().back()) == GetOutputDim(rhs.ops().back());
+  }
+
+  bool PatternDimMatchImpl(const ReduceTreePattern<T>& lhs,
+                           const ReduceTreePattern<T>& rhs) {
+    VLOG(4) << "Horizontal Fusion between ReduceTreePattern";
+    const auto& lhs_op = lhs.GetRootPattern().GetReduceOp();
+    const auto& rhs_op = rhs.GetRootPattern().GetReduceOp();
+    return GetOutputDim(lhs_op) == GetOutputDim(rhs_op) &&
+           GetInputDim(lhs_op) == GetInputDim(rhs_op);
+  }
+
+  bool PatternDimMatchImpl(const ReduceTreePattern<T>& lhs,
+                           const ReduceTreePlusTrivialPattern<T>& rhs) {
+    VLOG(4) << "Horizontal Fusion between ReduceTreePattern and "
+               "ReduceTreePlusTrivialPattern";
+    const auto& lhs_op = lhs.GetRootPattern().GetReduceOp();
+    const auto& rhs_op = rhs.tree.GetRootPattern().GetReduceOp();
+    return GetOutputDim(lhs_op) == GetOutputDim(rhs_op) &&
+           GetInputDim(lhs_op) == GetInputDim(rhs_op);
+  }
+
+  bool PatternDimMatchImpl(const ReduceTreePlusTrivialPattern<T>& lhs,
+                           const ReduceTreePattern<T>& rhs) {
+    return PatternDimMatchImpl(rhs, lhs);
+  }
+
+  bool PatternDimMatch(const StmtPattern<T>& lhs_pattern,
+                       const StmtPattern<T>& rhs_pattern) {
+    return std::visit(
+        [&](const auto& lhs, const auto& rhs) {
+          return PatternDimMatchImpl(lhs, rhs);
+        },
+        lhs_pattern.variant(),
+        rhs_pattern.variant());
   }
 };
 

From 2c0d7545abacbd0aa5c6735f05761c87d4c8e154 Mon Sep 17 00:00:00 2001
From: jiahongyu <jiahongyu@baidu.com>
Date: Mon, 22 Apr 2024 11:56:43 +0000
Subject: [PATCH 04/99] Fix compile error

---
 paddle/cinn/operator_fusion/pattern_graph.h | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/paddle/cinn/operator_fusion/pattern_graph.h b/paddle/cinn/operator_fusion/pattern_graph.h
index 4103e6b1ce491c..847afb95bac2c8 100644
--- a/paddle/cinn/operator_fusion/pattern_graph.h
+++ b/paddle/cinn/operator_fusion/pattern_graph.h
@@ -334,9 +334,9 @@ struct HorizontalFusionConstrain {
       return false;
     }
     const auto& lhs_pattern =
-        lhs->stmt_pattern().template Get<HorizontalFusionPattern>();
+        std::get<HorizontalFusionPattern<T>>(lhs->stmt_pattern());
     const auto& rhs_pattern =
-        rhs->stmt_pattern().template Get<HorizontalFusionPattern>();
+        std::get<HorizontalFusionPattern<T>>(rhs->stmt_pattern());
 
     return graph.topo_manager().CanFuse(lhs, rhs) &&
            PatternDimMatch(lhs_pattern.patterns_.back(),

From 278effde0e76a4b0fb855e2e5086eee53bab52aa Mon Sep 17 00:00:00 2001
From: xiongkun <xiongkun03@baidu.com>
Date: Tue, 23 Apr 2024 04:43:58 +0000
Subject: [PATCH 05/99] add topo sort in backend fusion

---
 .../hlir/framework/pir/trivial_op_util.cc     |   2 +-
 .../operator_fusion/backend/pattern_fuser.cc  | 107 +++++++++++++++++-
 2 files changed, 107 insertions(+), 2 deletions(-)

diff --git a/paddle/cinn/hlir/framework/pir/trivial_op_util.cc b/paddle/cinn/hlir/framework/pir/trivial_op_util.cc
index 17443d39fae254..cc7fab0a7c6af8 100644
--- a/paddle/cinn/hlir/framework/pir/trivial_op_util.cc
+++ b/paddle/cinn/hlir/framework/pir/trivial_op_util.cc
@@ -301,7 +301,7 @@ ExprSetFinder ChildTensorLoads = Collector(
 
 ExprSetFinder ChildTensorStores = Collector(
     [](const ir::Expr* e) {
-      return e->As<ir::Load>() && e->As<ir::Store>()->is_addr_tensor();
+      return e->As<ir::Store>() && e->As<ir::Store>()->is_addr_tensor();
     },
     "ChildTensorStores");
 
diff --git a/paddle/cinn/operator_fusion/backend/pattern_fuser.cc b/paddle/cinn/operator_fusion/backend/pattern_fuser.cc
index 61e8fd658f94a6..501a226caeda37 100644
--- a/paddle/cinn/operator_fusion/backend/pattern_fuser.cc
+++ b/paddle/cinn/operator_fusion/backend/pattern_fuser.cc
@@ -198,6 +198,111 @@ struct FusionOp2Expr {
   }
 };
 
+std::vector<ir::Tensor> GetOutputTensors(const ir::Expr& op_expr) {
+  using cinn::hlir::framework::pir::trivial_fusion_detail::ExprSetFinderUtils::
+      ChildScheduleBlockRealizes;
+  using cinn::hlir::framework::pir::trivial_fusion_detail::ExprSetFinderUtils::
+      ChildTensorStores;
+  using cinn::hlir::framework::pir::trivial_fusion_detail::ExprSetFinderUtils::
+      ScheduleBlockRealizeIsNotInit;
+  const auto& tensors =
+      (ChildScheduleBlockRealizes * ScheduleBlockRealizeIsNotInit *
+       ChildTensorStores)(op_expr);
+  std::function<ir::Tensor(ir::Expr)> func = [](const ir::Expr& expr) {
+    return expr.As<ir::Store>()->tensor.as_tensor_ref();
+  };
+  return MapVector(tensors, func);
+}
+
+std::vector<ir::Tensor> GetInputTensors(const ir::Expr& op_expr) {
+  using cinn::hlir::framework::pir::trivial_fusion_detail::ExprSetFinderUtils::
+      ChildScheduleBlockRealizes;
+  using cinn::hlir::framework::pir::trivial_fusion_detail::ExprSetFinderUtils::
+      ChildTensorLoads;
+  using cinn::hlir::framework::pir::trivial_fusion_detail::ExprSetFinderUtils::
+      ScheduleBlockRealizeIsNotInit;
+  const auto& exprs =
+      (ChildScheduleBlockRealizes * ScheduleBlockRealizeIsNotInit *
+       ChildTensorLoads)(op_expr);
+  std::function<ir::Tensor(ir::Expr)> func = [](const ir::Expr& expr) {
+    return expr.As<ir::Load>()->tensor.as_tensor_ref();
+  };
+  const auto& inputs = MapVector(exprs, func);
+  const auto& outputs = GetOutputTensors(op_expr);
+  return FilterVector(inputs, [&outputs](const ir::Tensor& tensor) {
+    return std::find(outputs.begin(), outputs.end(), tensor) == outputs.end();
+  });
+}
+
+std::vector<ir::Expr> TopoSort(const std::vector<ir::Expr>& op_exprs) {
+  // Topo Sort is important for CINN GroupSchedule.
+  std::map<ir::Tensor, std::vector<const ir::Expr*>> tensor2defining_op;
+  std::map<ir::Tensor, std::vector<const ir::Expr*>> tensor2used_op;
+  for (const auto& op : op_exprs) {
+    auto inputs = GetInputTensors(op);
+    auto outputs = GetOutputTensors(op);
+    if (VLOG_IS_ON(4)) {
+      VLOG(4) << "Ir::Expr is: \n" << op;
+      VLOG(4) << "Inputs: ";
+      for (const auto& input : inputs) {
+        VLOG(4) << input->name;
+      }
+      VLOG(4) << "Outputs: ";
+      for (const auto& output : outputs) {
+        VLOG(4) << output->name;
+      }
+    }
+    for (const auto& input : inputs) {
+      tensor2used_op[input].push_back(&op);
+    }
+    for (const auto& output : outputs) {
+      tensor2defining_op[output].push_back(&op);
+    }
+  }
+
+  // Collect Downstreams
+  std::map<const ir::Expr*, std::vector<const ir::Expr*>> op2downstreams;
+  std::map<const ir::Expr*, int> degrees;
+  for (const auto& op : op_exprs) {
+    degrees[&op] = 0;
+    auto outputs = GetOutputTensors(op);
+    std::vector<const ir::Expr*> downstreams;
+    for (const auto& output : outputs) {
+      downstreams = ConcatVector(downstreams, tensor2used_op[output]);
+    }
+    for (const auto& downstream : downstreams) {
+      degrees[downstream]++;
+    }
+    op2downstreams[&op] = downstreams;
+  }
+
+  // Topo Sort
+  std::vector<const ir::Expr*> result;
+  std::queue<const ir::Expr*> q;
+  for (const auto& op : op_exprs) {
+    if (degrees[&op] == 0) {
+      q.push(&op);
+    }
+  }
+  while (!q.empty()) {
+    auto* cur = q.front();
+    q.pop();
+    result.push_back(cur);
+    for (const auto& downstream : op2downstreams[cur]) {
+      degrees[downstream]--;
+      if (degrees[downstream] == 0) {
+        q.push(downstream);
+      }
+    }
+  }
+  CHECK_EQ(result.size(), op_exprs.size());
+  std::vector<ir::Expr> sorted_result;
+  for (const auto& op : result) {
+    sorted_result.push_back(*op);
+  }
+  return sorted_result;
+}
+
 std::vector<ir::Expr> GetExprFromPattern(
     const StmtPattern<BackendStage>& pattern) {
   const auto& fusion_ops = GetFusionOpFromPattern(pattern);
@@ -205,7 +310,7 @@ std::vector<ir::Expr> GetExprFromPattern(
   for (const auto& op : fusion_ops) {
     results = ConcatVector(results, std::visit(FusionOp2Expr(), op));
   }
-  return results;
+  return TopoSort(results);
 }
 
 }  // namespace cinn::fusion

From 06fb22c5a9211e9dc7319ac797f7d82c26027f76 Mon Sep 17 00:00:00 2001
From: feifei-111 <2364819892@qq.com>
Date: Wed, 24 Apr 2024 02:38:15 +0000
Subject: [PATCH 06/99] update

---
 paddle/cinn/operator_fusion/backend/pattern.h | 16 ++++++
 .../cinn/operator_fusion/frontend/pattern.h   | 15 ++++++
 paddle/cinn/operator_fusion/pattern.h         |  4 ++
 paddle/cinn/operator_fusion/pattern_graph.cc  | 46 ++++++++++++++++
 paddle/cinn/operator_fusion/pattern_graph.h   | 53 +++++++++++++++++++
 5 files changed, 134 insertions(+)

diff --git a/paddle/cinn/operator_fusion/backend/pattern.h b/paddle/cinn/operator_fusion/backend/pattern.h
index 7006fb02b829e4..5e40a87156f871 100644
--- a/paddle/cinn/operator_fusion/backend/pattern.h
+++ b/paddle/cinn/operator_fusion/backend/pattern.h
@@ -68,6 +68,22 @@ struct UnsupportPattern<BackendStage> {
   static std::string name() { return "Unsupport"; }
 };
 
+template <typename T>
+struct AnchorPattern {
+  explicit AnchorPattern(const std::vector<pir::Operation*>& ops,
+                         const std::vector<pir::Value>* outputs,
+                         const std::vector<pir::Value>* anchors)
+      : ops_(ops), outputs_(outputs), anchors_(anchors) {}
+  std::vector<pir::Operation*> ops_;
+  std::vector<pir::Value> outputs_;
+  pir::Value anchor_;  // Choose only one anchor
+  FusionOp fusion_op;
+  std::vector<pir::Operation*> ops() const { return ops_; }
+  std::vector<pir::Value> outputs() const { return outputs_; }
+  pir::Value anchor() const { return anchor_; }
+  static std::string name() { return "AnchorPattern"; }
+};
+
 template <>
 struct HorizontalFusionPattern<BackendStage> {
   explicit HorizontalFusionPattern(
diff --git a/paddle/cinn/operator_fusion/frontend/pattern.h b/paddle/cinn/operator_fusion/frontend/pattern.h
index e267483e56586d..6fe434c3becb46 100644
--- a/paddle/cinn/operator_fusion/frontend/pattern.h
+++ b/paddle/cinn/operator_fusion/frontend/pattern.h
@@ -72,6 +72,21 @@ struct UnsupportPattern<FrontendStage> {
   static std::string name() { return "Unsupport"; }
 };
 
+template <typename T>
+struct AnchorPattern {
+  explicit AnchorPattern(const std::vector<pir::Operation*>& ops,
+                         const std::vector<pir::Value>* outputs,
+                         const std::vector<pir::Value>* anchors)
+      : ops_(ops), outputs_(outputs), anchors_(anchors) {}
+  std::vector<pir::Operation*> ops_;
+  std::vector<pir::Value> outputs_;
+  pir::Value anchor_;  // Choose only one anchor
+  std::vector<pir::Operation*> ops() const { return ops_; }
+  std::vector<pir::Value> outputs() const { return outputs_; }
+  pir::Value anchor() const { return anchor_; }
+  static std::string name() { return "AnchorPattern"; }
+};
+
 template <>
 struct HorizontalFusionPattern<FrontendStage> {
   explicit HorizontalFusionPattern(
diff --git a/paddle/cinn/operator_fusion/pattern.h b/paddle/cinn/operator_fusion/pattern.h
index 908b4a4348bfc6..b58f1475272632 100644
--- a/paddle/cinn/operator_fusion/pattern.h
+++ b/paddle/cinn/operator_fusion/pattern.h
@@ -80,6 +80,10 @@ struct ReduceTreePlusTrivialPattern {
 
 template <typename T>
 class UnsupportPattern {};
+
+template <typename T>
+struct AnchorPattern {};
+
 template <typename T>
 class HorizontalFusionPattern {};
 
diff --git a/paddle/cinn/operator_fusion/pattern_graph.cc b/paddle/cinn/operator_fusion/pattern_graph.cc
index a8ab68cf809b36..444d8f6629f2cf 100644
--- a/paddle/cinn/operator_fusion/pattern_graph.cc
+++ b/paddle/cinn/operator_fusion/pattern_graph.cc
@@ -25,6 +25,8 @@ template <typename T>
 std::vector<PatternNodePtr<T>> PatternGraph<T>::ClusterOps() {
   VLOG(4) << "[Group Cluster] Initial Condition: " << GraphInfo();
 
+  // TODO(@wuzhanfei) Remove All IsOutputPattern Check
+
   VLOG(4) << "[Group Cluster] Start SinkTrivialPattern";
   SinkTrivialPattern();
   VLOG(4) << "[Group Cluster] After SinkTrivialPattern: " << GraphInfo();
@@ -44,6 +46,21 @@ std::vector<PatternNodePtr<T>> PatternGraph<T>::ClusterOps() {
   ReduceTree_Trivial_Fusion();
   VLOG(4) << "[Group Cluster] After ReduceTree_Trivial_Fusion: " << GraphInfo();
 
+  // All -> AnchorPattern
+  VLOG(4) << "[Group Cluster] Start LiftToAnchorPattern";
+  LiftToAnchorPattern();
+  VLOG(4) << "[Group Cluster] After LiftToAnchorPattern: " << GraphInfo();
+
+  // All -> AnchorPattern
+  VLOG(4) << "[Group Cluster] Start AnchorPatternFusion";
+  AnchorPatternFusion();
+  VLOG(4) << "[Group Cluster] After AnchorPatternFusion: " << GraphInfo();
+
+  // All -> AnchorPattern
+  VLOG(4) << "[Group Cluster] Start SplitRecomputePattern";
+  SplitRecomputePattern();
+  VLOG(4) << "[Group Cluster] After SplitRecomputePattern: " << GraphInfo();
+
   // Horizontal fusion.
   VLOG(4) << "[Group Cluster] Start HorizontalFusion";
   HorizontalFusion();
@@ -80,6 +97,8 @@ std::vector<PatternNodePtr<T>> PatternGraph<T>::SortByTopoOrder() {
 
 template <typename T>
 void PatternGraph<T>::SinkTrivialPattern() {
+  // TODO(@wuzhanfei) change sink trivial pattern algorithm, skip pattern with
+  // multi downstream
   GraphTransformer<
       NodePattern,
       T,
@@ -99,6 +118,8 @@ void PatternGraph<T>::ReduceLiftReduceTree() {
 
 template <typename T>
 void PatternGraph<T>::HorizontalFusion() {
+  // TODO(@wuzhanfei) need a new matcher, or check under fusion pattern
+  // operation?
   GraphTransformer<NodePattern,
                    T,
                    StmtPatternGraphMatcher<TrivialPattern<T>>,
@@ -127,6 +148,31 @@ void PatternGraph<T>::ReduceTree_Trivial_Fusion() {
       MergeReduceTreeAndTrivialOperation>(this);
 }
 
+template <typename T>
+void PatternGraph<T>::LiftToAnchorPattern() {
+  // TODO(@wuzhanfei)
+  GraphTransformer<NodePattern, T, AlwaysTrue<T>, LiftToAnchorPatternOperation>(
+      this);
+}
+
+template <typename T>
+void PatternGraph<T>::AnchorPatternFusion() {
+  // TODO(@wuzhanfei)
+  GraphTransformer<ReverseTopoNodePairPattern,
+                   T,
+                   DownstreamGreaterThan<1>,
+                   FuseAnchorPatternOperation>(this);
+}
+
+template <typename T>
+void PatternGraph<T>::SplitRecomputePattern() {
+  // TODO(@wuzhanfei)
+  GraphTransformer<NodePattern,
+                   T,
+                   RecomputeNodeMatcher,
+                   SplitRecomputeOperation>(this);
+}
+
 template <typename T>
 PatternGraph<T>::PatternGraph(const std::vector<PatternContent<T>>& contents,
                               const std::vector<pir::Value>& outputs,
diff --git a/paddle/cinn/operator_fusion/pattern_graph.h b/paddle/cinn/operator_fusion/pattern_graph.h
index e6ba1342623491..a727dffc68b510 100644
--- a/paddle/cinn/operator_fusion/pattern_graph.h
+++ b/paddle/cinn/operator_fusion/pattern_graph.h
@@ -42,6 +42,9 @@ class PatternGraph {
   void ReduceLiftReduceTree();
   void ReduceTreeGrown();
   void ReduceTree_Trivial_Fusion();
+  void LiftToAnchorPattern();
+  void AnchorPatternFusion();
+  void SplitRecomputePattern();
 
   void RemoveNode(const PatternNodePtr<T>& node);
   void AppendNode(const PatternNodePtr<T>& node);
@@ -73,6 +76,7 @@ struct NodePattern {};
 struct EdgePattern {};
 struct GraphPattern {};     // not implemented.
 struct NodePairPattern {};  // not implemented.
+struct ReverseTopoNodePairPattern {};
 
 template <typename Kind,
           typename Phrase,
@@ -149,6 +153,14 @@ struct SearchAlgorithm<NodePairPattern, Phrase, GraphMatcher, GraphOperation> {
   }
 };
 
+template <typename Phrase, typename GraphMatcher, typename GraphOperation>
+struct SearchAlgorithm<ReverseTopoNodePairPattern,
+                       Phrase,
+                       GraphMatcher,
+                       GraphOperation> {
+  // TODO(@wuzhanfei)
+};
+
 // Operation
 
 struct MergeReduceTreeOperation {
@@ -210,6 +222,7 @@ struct LiftReduceToReduceTreeOperation {
 };
 
 struct MergeTrivialPatternOperation {
+  // TOOD(@wuzhanfei)
   template <typename Phrase>
   void operator()(PatternGraph<Phrase>* graph,
                   PatternNodePtr<Phrase> upstream) {
@@ -246,6 +259,29 @@ struct LiftToHorizontalFusionPatternOperation {
   }
 };
 
+struct LiftToAnchorPatternOperation {
+  template <typename Phrase>
+  void operator()(PatternGraph<Phrase>* graph, PatternNodePtr<Phrase> node) {
+    // TODO(@wuzhanfei)
+  }
+};
+
+struct FuseAnchorPatternOperation {
+  template <typename Phrase>
+  void operator()(PatternGraph<Phrase>* graph,
+                  PatternNodePtr<Phrase> upstream,
+                  const PatternNodePtr<Phrase>& downstream) {
+    // TODO(@wuzhanfei)
+  }
+};
+
+struct SplitRecomputeOperation {
+  template <typename Phrase>
+  void operator()(PatternGraph<Phrase>* graph, PatternNodePtr<Phrase> node) {
+    // TODO(@wuzhanfei)
+  }
+};
+
 struct HorizontalFusionOperation {
   template <typename Phrase>
   void operator()(PatternGraph<Phrase>* graph,
@@ -322,6 +358,13 @@ struct CanFuseReduceTreeAndTrivialMatcher {
   }
 };
 
+struct RecomputeNodeMatcher {
+  template <typename T>
+  bool operator()(const PatternGraph<T>& graph, const PatternNodePtr<T>& node) {
+    // TODO(@wuzhanfei)
+  }
+};
+
 struct HorizontalFusionConstrain {
   template <typename T>
   bool operator()(const PatternGraph<T>& graph,
@@ -364,6 +407,8 @@ struct IsOutputNodeMatcher {
 };
 
 struct IsNotOutputNodeMatcher {
+  // TODO(@wuzhanfei) after move yield_store before group cluster, remove this
+  // matcher
   template <typename T>
   bool operator()(const PatternGraph<T>& graph, const PatternNodePtr<T>& node) {
     bool res = !IsOutputNodeMatcher()(graph, node);
@@ -379,6 +424,14 @@ struct DownstreamSmallerThan {
   }
 };
 
+template <int N>
+struct DownstreamGreaterThan {
+  template <typename T>
+  bool operator()(const PatternGraph<T>& graph, const PatternNodePtr<T>& node) {
+    return node->downstream().size() > N;
+  }
+};
+
 template <typename A, typename B>
 struct And {
   template <typename T>

From ee3e694c1d631673a048fbfc1cc400c7b1bce063 Mon Sep 17 00:00:00 2001
From: zhangbaizhou <zhangbaizhou@baidu.com>
Date: Wed, 24 Apr 2024 06:03:55 +0000
Subject: [PATCH 07/99] reorder yield_store op adding

---
 .../operator/transforms/add_cinn_pass.cc      |  2 +-
 .../transforms/add_store_in_fusion_op_pass.cc |  9 +----
 .../policy/relative_judge_policy.h            |  2 +-
 .../policy/shardable_axes_base.cc             | 40 +++++++++----------
 4 files changed, 23 insertions(+), 30 deletions(-)

diff --git a/paddle/cinn/hlir/dialect/operator/transforms/add_cinn_pass.cc b/paddle/cinn/hlir/dialect/operator/transforms/add_cinn_pass.cc
index d695be6a4f777f..ed4272024707f0 100644
--- a/paddle/cinn/hlir/dialect/operator/transforms/add_cinn_pass.cc
+++ b/paddle/cinn/hlir/dialect/operator/transforms/add_cinn_pass.cc
@@ -149,8 +149,8 @@ void ApplyDivideGroupOpToFusionOpPass(
         CreatePassManager) {
   std::shared_ptr<pir::PassManager> pass_manager = CreatePassManager();
   if (FLAGS_group_schedule_tiling_first) {
-    pass_manager->AddPass(cinn::dialect::ir::CreateCinnGroupClusterPass());
     pass_manager->AddPass(cinn::dialect::ir::CreateAddStoreInFusionOpPass());
+    pass_manager->AddPass(cinn::dialect::ir::CreateCinnGroupClusterPass());
   } else {
     pass_manager->AddPass(
         cinn::dialect::ir::CreateDivideGroupOpToFusionOpPass());
diff --git a/paddle/cinn/hlir/dialect/operator/transforms/add_store_in_fusion_op_pass.cc b/paddle/cinn/hlir/dialect/operator/transforms/add_store_in_fusion_op_pass.cc
index d66943dfc8bf93..964225960a7cdb 100644
--- a/paddle/cinn/hlir/dialect/operator/transforms/add_store_in_fusion_op_pass.cc
+++ b/paddle/cinn/hlir/dialect/operator/transforms/add_store_in_fusion_op_pass.cc
@@ -76,14 +76,7 @@ class AddStoreInFusionOpPass : public pir::Pass {
     for (uint32_t i = 0; i < op->num_regions(); ++i) {
       for (auto& block : op->region(i)) {
         for (auto& op : block) {
-          if (op.isa<cinn::dialect::FusionOp>()) {
-            auto fusion_op = op.dyn_cast<cinn::dialect::FusionOp>();
-            if (fusion_op.GetOperators().size() == 2 &&
-                fusion_op.GetOperators()
-                    .front()
-                    ->isa<cinn::dialect::ReshapeOp>()) {
-              continue;
-            }
+          if (op.isa<cinn::dialect::GroupOp>()) {
             auto [_, num_rewrites] =
                 pir::ApplyPatternsGreedily(&op, patterns_, cfg);
             AddStatistics(num_rewrites);
diff --git a/paddle/cinn/operator_fusion/policy/relative_judge_policy.h b/paddle/cinn/operator_fusion/policy/relative_judge_policy.h
index f7f3a5f7786594..a02ed6370072a7 100644
--- a/paddle/cinn/operator_fusion/policy/relative_judge_policy.h
+++ b/paddle/cinn/operator_fusion/policy/relative_judge_policy.h
@@ -215,7 +215,7 @@ static std::optional<ValueDimRelation> CreateOpRelativenessForSpecialOps(
     return CreateOpRelativenessForDefault(op);
   }
   if (op->name() == "cinn_op.yield_store") {
-    return CreateOpRelativenessForDefault(op);
+    return CreateOpRelativenessForElementWise(op);
   }
   return {};
 }
diff --git a/paddle/cinn/operator_fusion/policy/shardable_axes_base.cc b/paddle/cinn/operator_fusion/policy/shardable_axes_base.cc
index f4ef2691c16a59..1c6c32dbd6b4cd 100644
--- a/paddle/cinn/operator_fusion/policy/shardable_axes_base.cc
+++ b/paddle/cinn/operator_fusion/policy/shardable_axes_base.cc
@@ -71,26 +71,6 @@ ShardableAxesSignature CreateDefaultSignature(pir::Operation* op) {
   return result;
 }
 
-std::optional<ShardableAxesSignature> CreateSignatureForSpecialOps(
-    pir::Operation* op) {
-  if (op->isa<cinn::dialect::ReshapeOp>()) {
-    return CreateDefaultSignature(op);
-  }
-  if (op->name() == "cinn_op.generate_shape") {
-    return CreateDefaultSignature(op);
-  }
-  if (op->name() == "cinn_op.yield_store") {
-    return CreateDefaultSignature(op);
-  }
-  if (op->name() == "cinn_op.reshape") {
-    return CreateDefaultSignature(op);
-  }
-  if (op->name() == "pd_op.reshape") {
-    return CreateDefaultSignature(op);
-  }
-  return std::nullopt;
-}
-
 ShardableAxesSignature CreateSignatureForReduce(pir::Operation* reduce_op) {
   CHECK_EQ(reduce_op->num_operands(), 1);
   CHECK_EQ(reduce_op->num_results(), 1);
@@ -178,6 +158,26 @@ ShardableAxesSignature CreateSignatureForBroadcast(
   return result;
 }
 
+std::optional<ShardableAxesSignature> CreateSignatureForSpecialOps(
+    pir::Operation* op) {
+  if (op->isa<cinn::dialect::ReshapeOp>()) {
+    return CreateDefaultSignature(op);
+  }
+  if (op->name() == "cinn_op.generate_shape") {
+    return CreateDefaultSignature(op);
+  }
+  if (op->name() == "cinn_op.yield_store") {
+    return CreateSignatureForElementWise(op);
+  }
+  if (op->name() == "cinn_op.reshape") {
+    return CreateDefaultSignature(op);
+  }
+  if (op->name() == "pd_op.reshape") {
+    return CreateDefaultSignature(op);
+  }
+  return std::nullopt;
+}
+
 ShardableAxesSignature ShardableAxesInfoManager::CreateShardableSignature(
     pir::Operation* op) {
   auto special_result = CreateSignatureForSpecialOps(op);

From 0752aa109e991e1c08d7a8a045fb1fd93c74ed43 Mon Sep 17 00:00:00 2001
From: zhangbaizhou <zhangbaizhou@baidu.com>
Date: Wed, 24 Apr 2024 09:09:42 +0000
Subject: [PATCH 08/99] rename fusion to group

---
 .../hlir/dialect/operator/transforms/add_cinn_pass.cc  |  2 +-
 .../operator/transforms/add_store_in_fusion_op_pass.cc | 10 +++++-----
 .../operator/transforms/add_store_in_fusion_op_pass.h  |  2 +-
 test/cpp/pir/cinn/pir_all_path_test.cc                 |  2 +-
 4 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/paddle/cinn/hlir/dialect/operator/transforms/add_cinn_pass.cc b/paddle/cinn/hlir/dialect/operator/transforms/add_cinn_pass.cc
index ed4272024707f0..4923a2658be382 100644
--- a/paddle/cinn/hlir/dialect/operator/transforms/add_cinn_pass.cc
+++ b/paddle/cinn/hlir/dialect/operator/transforms/add_cinn_pass.cc
@@ -149,7 +149,7 @@ void ApplyDivideGroupOpToFusionOpPass(
         CreatePassManager) {
   std::shared_ptr<pir::PassManager> pass_manager = CreatePassManager();
   if (FLAGS_group_schedule_tiling_first) {
-    pass_manager->AddPass(cinn::dialect::ir::CreateAddStoreInFusionOpPass());
+    pass_manager->AddPass(cinn::dialect::ir::CreateAddStoreInGroupOpPass());
     pass_manager->AddPass(cinn::dialect::ir::CreateCinnGroupClusterPass());
   } else {
     pass_manager->AddPass(
diff --git a/paddle/cinn/hlir/dialect/operator/transforms/add_store_in_fusion_op_pass.cc b/paddle/cinn/hlir/dialect/operator/transforms/add_store_in_fusion_op_pass.cc
index 964225960a7cdb..f7f830ec248932 100644
--- a/paddle/cinn/hlir/dialect/operator/transforms/add_store_in_fusion_op_pass.cc
+++ b/paddle/cinn/hlir/dialect/operator/transforms/add_store_in_fusion_op_pass.cc
@@ -56,10 +56,10 @@ class AddYieldStoreInFusionOpPattern
   }
 };
 
-class AddStoreInFusionOpPass : public pir::Pass {
+class AddStoreInGroupOpPass : public pir::Pass {
  public:
-  AddStoreInFusionOpPass()
-      : pir::Pass("add_store_in_fusion_op", /*opt_level=*/1) {}
+  AddStoreInGroupOpPass()
+      : pir::Pass("add_store_in_group_op", /*opt_level=*/1) {}
 
   bool Initialize(pir::IrContext* context) override {
     pir::RewritePatternSet ps(context);
@@ -94,8 +94,8 @@ class AddStoreInFusionOpPass : public pir::Pass {
   pir::FrozenRewritePatternSet patterns_;
 };
 
-std::unique_ptr<pir::Pass> CreateAddStoreInFusionOpPass() {
-  return std::make_unique<AddStoreInFusionOpPass>();
+std::unique_ptr<pir::Pass> CreateAddStoreInGroupOpPass() {
+  return std::make_unique<AddStoreInGroupOpPass>();
 }
 
 }  // namespace ir
diff --git a/paddle/cinn/hlir/dialect/operator/transforms/add_store_in_fusion_op_pass.h b/paddle/cinn/hlir/dialect/operator/transforms/add_store_in_fusion_op_pass.h
index 403e9a13ce38b8..ece6758854f2b7 100644
--- a/paddle/cinn/hlir/dialect/operator/transforms/add_store_in_fusion_op_pass.h
+++ b/paddle/cinn/hlir/dialect/operator/transforms/add_store_in_fusion_op_pass.h
@@ -21,7 +21,7 @@ namespace cinn {
 namespace dialect {
 namespace ir {
 
-std::unique_ptr<pir::Pass> CreateAddStoreInFusionOpPass();
+std::unique_ptr<pir::Pass> CreateAddStoreInGroupOpPass();
 
 }  // namespace ir
 }  // namespace dialect
diff --git a/test/cpp/pir/cinn/pir_all_path_test.cc b/test/cpp/pir/cinn/pir_all_path_test.cc
index 0c660c228a5dea..50ce849691ecdb 100644
--- a/test/cpp/pir/cinn/pir_all_path_test.cc
+++ b/test/cpp/pir/cinn/pir_all_path_test.cc
@@ -71,7 +71,7 @@ static void RunAndCheckResult(::pir::Program* program,
   pm.AddPass(pir::CreateDeadCodeEliminationPass());
   pm.AddPass(pir::CreateBuildCinnPass());
   pm.AddPass(cinn::dialect::ir::CreateCinnGroupClusterPass());
-  pm.AddPass(cinn::dialect::ir::CreateAddStoreInFusionOpPass());
+  pm.AddPass(cinn::dialect::ir::CreateAddStoreInGroupOpPass());
   pm.AddPass(pir::CreateDeadCodeEliminationPass());
   pm.AddPass(cinn::dialect::ir::CreateLowerCinnFusionOpPass());
   pm.EnableIRPrinting();

From 770f496b80669ce994a26c1772fdd409cec4d00b Mon Sep 17 00:00:00 2001
From: zhangbaizhou <zhangbaizhou@baidu.com>
Date: Wed, 24 Apr 2024 09:23:47 +0000
Subject: [PATCH 09/99] remove IsNotOutputNodeMatcher

---
 paddle/cinn/operator_fusion/pattern_graph.cc | 14 ++++++--------
 paddle/cinn/operator_fusion/pattern_graph.h  | 10 ----------
 2 files changed, 6 insertions(+), 18 deletions(-)

diff --git a/paddle/cinn/operator_fusion/pattern_graph.cc b/paddle/cinn/operator_fusion/pattern_graph.cc
index 444d8f6629f2cf..28f3063b7fb938 100644
--- a/paddle/cinn/operator_fusion/pattern_graph.cc
+++ b/paddle/cinn/operator_fusion/pattern_graph.cc
@@ -102,8 +102,7 @@ void PatternGraph<T>::SinkTrivialPattern() {
   GraphTransformer<
       NodePattern,
       T,
-      And<And<NonSinkNodeMatcher, StmtPatternGraphMatcher<TrivialPattern<T>>>,
-          IsNotOutputNodeMatcher>,
+      And<NonSinkNodeMatcher, StmtPatternGraphMatcher<TrivialPattern<T>>>,
       MergeTrivialPatternOperation>(this);
 }
 
@@ -135,17 +134,16 @@ template <typename T>
 void PatternGraph<T>::ReduceTreeGrown() {
   GraphTransformer<NodePattern,
                    T,
-                   And<CanFuseReduceTreeMatcher, IsNotOutputNodeMatcher>,
+                   CanFuseReduceTreeMatcher,
                    MergeReduceTreeOperation>(this);
 }
 
 template <typename T>
 void PatternGraph<T>::ReduceTree_Trivial_Fusion() {
-  GraphTransformer<
-      NodePattern,
-      T,
-      And<CanFuseReduceTreeAndTrivialMatcher, IsNotOutputNodeMatcher>,
-      MergeReduceTreeAndTrivialOperation>(this);
+  GraphTransformer<NodePattern,
+                   T,
+                   CanFuseReduceTreeAndTrivialMatcher,
+                   MergeReduceTreeAndTrivialOperation>(this);
 }
 
 template <typename T>
diff --git a/paddle/cinn/operator_fusion/pattern_graph.h b/paddle/cinn/operator_fusion/pattern_graph.h
index a727dffc68b510..2fb1c6bf236b06 100644
--- a/paddle/cinn/operator_fusion/pattern_graph.h
+++ b/paddle/cinn/operator_fusion/pattern_graph.h
@@ -406,16 +406,6 @@ struct IsOutputNodeMatcher {
   }
 };
 
-struct IsNotOutputNodeMatcher {
-  // TODO(@wuzhanfei) after move yield_store before group cluster, remove this
-  // matcher
-  template <typename T>
-  bool operator()(const PatternGraph<T>& graph, const PatternNodePtr<T>& node) {
-    bool res = !IsOutputNodeMatcher()(graph, node);
-    return res;
-  }
-};
-
 template <int N>
 struct DownstreamSmallerThan {
   template <typename T>

From f9f7f946fa0b19bd10a9cb7b404a925d84675b23 Mon Sep 17 00:00:00 2001
From: feifei-111 <2364819892@qq.com>
Date: Wed, 24 Apr 2024 11:05:16 +0000
Subject: [PATCH 10/99] update

---
 paddle/cinn/operator_fusion/pattern_graph.cc | 14 ++++++++--
 paddle/cinn/operator_fusion/pattern_graph.h  | 27 ++++++++++++++++++--
 2 files changed, 37 insertions(+), 4 deletions(-)

diff --git a/paddle/cinn/operator_fusion/pattern_graph.cc b/paddle/cinn/operator_fusion/pattern_graph.cc
index 444d8f6629f2cf..12366f1b43baed 100644
--- a/paddle/cinn/operator_fusion/pattern_graph.cc
+++ b/paddle/cinn/operator_fusion/pattern_graph.cc
@@ -160,8 +160,18 @@ void PatternGraph<T>::AnchorPatternFusion() {
   // TODO(@wuzhanfei)
   GraphTransformer<ReverseTopoNodePairPattern,
                    T,
-                   DownstreamGreaterThan<1>,
-                   FuseAnchorPatternOperation>(this);
+                   HasUpstreamAnchorMatcher,
+                   FuseUpstreamAnchorOperation>(this);
+
+  GraphTransformer<NodePairPattern,
+                   T,
+                   HasUpstreamAnchorMatcher,
+                   FuseUpstreamAnchorOperation>(this);
+
+  GraphTransformer<NodePairPattern,
+                   T,
+                   HasDownstreamAnchorMatcher,
+                   FuseDownstreamAnchorOperation>(this);
 }
 
 template <typename T>
diff --git a/paddle/cinn/operator_fusion/pattern_graph.h b/paddle/cinn/operator_fusion/pattern_graph.h
index a727dffc68b510..a5a6f6c13b1947 100644
--- a/paddle/cinn/operator_fusion/pattern_graph.h
+++ b/paddle/cinn/operator_fusion/pattern_graph.h
@@ -266,11 +266,20 @@ struct LiftToAnchorPatternOperation {
   }
 };
 
-struct FuseAnchorPatternOperation {
+struct FuseUpstreamAnchorOperation {
   template <typename Phrase>
   void operator()(PatternGraph<Phrase>* graph,
                   PatternNodePtr<Phrase> upstream,
-                  const PatternNodePtr<Phrase>& downstream) {
+                  PatternNodePtr<Phrase> downstream) {
+    // TODO(@wuzhanfei)
+  }
+};
+
+struct FuseDownstreamAnchorOperation {
+  template <typename Phrase>
+  void operator()(PatternGraph<Phrase>* graph,
+                  PatternNodePtr<Phrase> upstream,
+                  PatternNodePtr<Phrase> downstream) {
     // TODO(@wuzhanfei)
   }
 };
@@ -365,6 +374,20 @@ struct RecomputeNodeMatcher {
   }
 };
 
+struct HasUpstreamAnchorMatcher {
+  template <typename T>
+  bool operator()(const PatternGraph<T>& graph, const PatternNodePtr<T>& node) {
+    // TODO(@wuzhanfei)
+  }
+};
+
+struct HasDownstreamAnchorMatcher {
+  template <typename T>
+  bool operator()(const PatternGraph<T>& graph, const PatternNodePtr<T>& node) {
+    // TODO(@wuzhanfei)
+  }
+};
+
 struct HorizontalFusionConstrain {
   template <typename T>
   bool operator()(const PatternGraph<T>& graph,

From 0d0097f8639582d69cffb6b49c2ae98d37919b37 Mon Sep 17 00:00:00 2001
From: feifei-111 <2364819892@qq.com>
Date: Thu, 25 Apr 2024 03:49:45 +0000
Subject: [PATCH 11/99] update

---
 third_party/pybind | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/third_party/pybind b/third_party/pybind
index 0bd8896a4010f2..3e9dfa28669416 160000
--- a/third_party/pybind
+++ b/third_party/pybind
@@ -1 +1 @@
-Subproject commit 0bd8896a4010f2d91b2340570c24fa08606ec406
+Subproject commit 3e9dfa2866941655c56877882565e7577de6fc7b

From d634fe5922ecc294a0de4446e2e8a41fc54caf7e Mon Sep 17 00:00:00 2001
From: feifei-111 <2364819892@qq.com>
Date: Thu, 25 Apr 2024 07:30:24 +0000
Subject: [PATCH 12/99] update

---
 paddle/cinn/operator_fusion/backend/pattern.h |  13 +-
 .../cinn/operator_fusion/frontend/pattern.h   |  10 +-
 .../graph_transformer/matcher.h               | 182 ++++++++
 .../graph_transformer/operation.h             | 176 ++++++++
 .../graph_transformer/search_algorithm.h      | 120 +++++
 paddle/cinn/operator_fusion/group_cluster.h   |  13 +-
 paddle/cinn/operator_fusion/pattern_graph.cc  |  12 +-
 paddle/cinn/operator_fusion/pattern_graph.h   | 417 +-----------------
 .../operator_fusion/policy/CMakeLists.txt     |   1 -
 .../policy/general_topo_policy.h              |   8 +-
 .../cinn/operator_fusion/policy/policy_base.h |  44 ++
 .../operator_fusion/policy/policy_manager.cc  |  46 --
 .../operator_fusion/policy/policy_manager.h   |  45 +-
 .../policy/relative_judge_policy.h            |  13 +-
 .../policy/shardable_axes_policy.cc           |  99 -----
 .../policy/shardable_axes_policy.h            |  43 --
 16 files changed, 582 insertions(+), 660 deletions(-)
 create mode 100644 paddle/cinn/operator_fusion/graph_transformer/matcher.h
 create mode 100644 paddle/cinn/operator_fusion/graph_transformer/operation.h
 create mode 100644 paddle/cinn/operator_fusion/graph_transformer/search_algorithm.h
 create mode 100644 paddle/cinn/operator_fusion/policy/policy_base.h
 delete mode 100644 paddle/cinn/operator_fusion/policy/policy_manager.cc
 delete mode 100644 paddle/cinn/operator_fusion/policy/shardable_axes_policy.cc
 delete mode 100644 paddle/cinn/operator_fusion/policy/shardable_axes_policy.h

diff --git a/paddle/cinn/operator_fusion/backend/pattern.h b/paddle/cinn/operator_fusion/backend/pattern.h
index 5e40a87156f871..e34c31be68cdca 100644
--- a/paddle/cinn/operator_fusion/backend/pattern.h
+++ b/paddle/cinn/operator_fusion/backend/pattern.h
@@ -68,16 +68,17 @@ struct UnsupportPattern<BackendStage> {
   static std::string name() { return "Unsupport"; }
 };
 
-template <typename T>
-struct AnchorPattern {
+template <>
+struct AnchorPattern<BackendStage> {
   explicit AnchorPattern(const std::vector<pir::Operation*>& ops,
-                         const std::vector<pir::Value>* outputs,
-                         const std::vector<pir::Value>* anchors)
-      : ops_(ops), outputs_(outputs), anchors_(anchors) {}
+                         const std::vector<pir::Value>& outputs,
+                         const pir::Value& anchor,
+                         const FusionOp& fusion_op)
+      : ops_(ops), outputs_(outputs), anchor_(anchor), fusion_op_(fusion_op) {}
   std::vector<pir::Operation*> ops_;
   std::vector<pir::Value> outputs_;
   pir::Value anchor_;  // Choose only one anchor
-  FusionOp fusion_op;
+  FusionOp fusion_op_;
   std::vector<pir::Operation*> ops() const { return ops_; }
   std::vector<pir::Value> outputs() const { return outputs_; }
   pir::Value anchor() const { return anchor_; }
diff --git a/paddle/cinn/operator_fusion/frontend/pattern.h b/paddle/cinn/operator_fusion/frontend/pattern.h
index 6fe434c3becb46..59a3298f15e200 100644
--- a/paddle/cinn/operator_fusion/frontend/pattern.h
+++ b/paddle/cinn/operator_fusion/frontend/pattern.h
@@ -72,12 +72,12 @@ struct UnsupportPattern<FrontendStage> {
   static std::string name() { return "Unsupport"; }
 };
 
-template <typename T>
-struct AnchorPattern {
+template <>
+struct AnchorPattern<FrontendStage> {
   explicit AnchorPattern(const std::vector<pir::Operation*>& ops,
-                         const std::vector<pir::Value>* outputs,
-                         const std::vector<pir::Value>* anchors)
-      : ops_(ops), outputs_(outputs), anchors_(anchors) {}
+                         const std::vector<pir::Value>& outputs,
+                         const pir::Value& anchor)
+      : ops_(ops), outputs_(outputs), anchor_(anchor) {}
   std::vector<pir::Operation*> ops_;
   std::vector<pir::Value> outputs_;
   pir::Value anchor_;  // Choose only one anchor
diff --git a/paddle/cinn/operator_fusion/graph_transformer/matcher.h b/paddle/cinn/operator_fusion/graph_transformer/matcher.h
new file mode 100644
index 00000000000000..11049409da0527
--- /dev/null
+++ b/paddle/cinn/operator_fusion/graph_transformer/matcher.h
@@ -0,0 +1,182 @@
+// Copyright (c) 2024 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/cinn/operator_fusion/pattern_graph.h"
+
+namespace cinn::fusion {
+// Matcher
+
+template <typename StmtPattern>
+struct AlwaysTrue {
+  template <typename T>
+  bool operator()(const PatternGraph<T>& graph, const PatternNodePtr<T>& node) {
+    return true;
+  }
+};
+
+template <typename StmtPattern>
+struct StmtPatternGraphMatcher {
+  template <typename T>
+  bool operator()(const PatternGraph<T>& graph, const PatternNodePtr<T>& node) {
+    return GetPatternName(node->stmt_pattern()) == StmtPattern::name();
+  }
+};
+
+struct CanFuseRxTMatcher {
+  template <typename T>
+  bool operator()(const PatternGraph<T>& graph, const PatternNodePtr<T>& node) {
+    return (
+        std::holds_alternative<ReduceTreePattern<T>>(node->stmt_pattern()) &&
+        !node->downstream().empty() &&
+        std::holds_alternative<TrivialPattern<T>>(
+            node->downstream().at(0)->stmt_pattern()));
+  }
+};
+
+struct CanFuseReduceTreeMatcher {
+  template <typename T>
+  bool operator()(const PatternGraph<T>& graph, const PatternNodePtr<T>& node) {
+    return StmtPatternGraphMatcher<ReduceTreePattern<T>>()(graph, node) &&
+           !node->downstream().empty() &&
+           std::holds_alternative<ReduceTreePattern<T>>(
+               node->downstream().at(0)->stmt_pattern()) &&
+           graph.policy_manager().GetPolicy<GeneralTopoPolicy>().CanFuse(
+               node, node->downstream().at(0)) &&
+           graph.policy_manager().GetPolicy<RelativeJudgePolicy>().CanFuse(
+               node, node->downstream().at(0));
+  }
+};
+
+struct CanFuseReduceTreeAndTrivialMatcher {
+  template <typename T>
+  bool operator()(const PatternGraph<T>& graph, const PatternNodePtr<T>& node) {
+    return StmtPatternGraphMatcher<ReduceTreePattern<T>>()(graph, node) &&
+           !node->downstream().empty() &&
+           std::holds_alternative<TrivialPattern<T>>(
+               node->downstream().at(0)->stmt_pattern()) &&
+           graph.policy_manager().GetPolicy<GeneralTopoPolicy>().CanFuse(
+               node, node->downstream().at(0)) &&
+           graph.policy_manager().GetPolicy<RelativeJudgePolicy>().CanFuse(
+               node, node->downstream().at(0));
+  }
+};
+
+struct RecomputeNodeMatcher {
+  template <typename T>
+  bool operator()(const PatternGraph<T>& graph, const PatternNodePtr<T>& node) {
+    // TODO(@wuzhanfei)
+    return false;
+  }
+};
+
+struct HasUpstreamAnchorMatcher {
+  template <typename T>
+  bool operator()(const PatternGraph<T>& graph, const PatternNodePtr<T>& node) {
+    // TODO(@wuzhanfei)
+    return false;
+  }
+};
+
+struct HasDownstreamAnchorMatcher {
+  template <typename T>
+  bool operator()(const PatternGraph<T>& graph, const PatternNodePtr<T>& node) {
+    // TODO(@wuzhanfei)
+    return false
+  }
+};
+
+struct HorizontalFusionMatcher {
+  template <typename T>
+  bool operator()(const PatternGraph<T>& graph,
+                  const PatternNodePtr<T>& first,
+                  const PatternNodePtr<T>& second) {
+    if (!StmtPatternGraphMatcher<HorizontalFusionPattern<T>>()(graph, first)) {
+      return false;
+    }
+    if (!StmtPatternGraphMatcher<HorizontalFusionPattern<T>>()(graph, second)) {
+      return false;
+    }
+    const auto& first_dim = first->sink_op()
+                                ->result(0)
+                                .type()
+                                .template dyn_cast<pir::DenseTensorType>()
+                                .dims();
+    const auto& second_dim = second->sink_op()
+                                 ->result(0)
+                                 .type()
+                                 .template dyn_cast<pir::DenseTensorType>()
+                                 .dims();
+    return graph.policy_manager.GetPolicy<GeneralTopoPolicy>().CanFuse(
+               first, second) &&
+           first_dim == second_dim;
+  }
+};
+
+struct NonSinkNodeMatcher {
+  template <typename T>
+  bool operator()(const PatternGraph<T>& graph, const PatternNodePtr<T>& node) {
+    return !node->downstream().empty();
+  }
+};
+
+struct IsOutputNodeMatcher {
+  template <typename T>
+  bool operator()(const PatternGraph<T>& graph, const PatternNodePtr<T>& node) {
+    bool res = IsAnyFirstInSecond(node->sink_op()->results(), graph.outputs());
+    return res;
+  }
+};
+
+template <int N>
+struct DownstreamSmallerThan {
+  template <typename T>
+  bool operator()(const PatternGraph<T>& graph, const PatternNodePtr<T>& node) {
+    return node->downstream().size() < N;
+  }
+};
+
+template <int N>
+struct DownstreamGreaterThan {
+  template <typename T>
+  bool operator()(const PatternGraph<T>& graph, const PatternNodePtr<T>& node) {
+    return node->downstream().size() > N;
+  }
+};
+
+template <typename A, typename B>
+struct And {
+  template <typename T>
+  bool operator()(const PatternGraph<T>& graph, const PatternNodePtr<T>& node) {
+    return A()(graph, node) && B()(graph, node);
+  }
+};
+
+template <typename A, typename B>
+struct Or {
+  template <typename T>
+  bool operator()(const PatternGraph<T>& graph, const PatternNodePtr<T>& node) {
+    return A()(graph, node) || B()(graph, node);
+  }
+};
+
+template <typename A>
+struct Not {
+  template <typename T>
+  bool operator()(const PatternGraph<T>& graph, const PatternNodePtr<T>& node) {
+    return !A()(graph, node);
+  }
+};
+
+}  // namespace cinn::fusion
diff --git a/paddle/cinn/operator_fusion/graph_transformer/operation.h b/paddle/cinn/operator_fusion/graph_transformer/operation.h
new file mode 100644
index 00000000000000..55c6dd35aef0d2
--- /dev/null
+++ b/paddle/cinn/operator_fusion/graph_transformer/operation.h
@@ -0,0 +1,176 @@
+// Copyright (c) 2024 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/cinn/operator_fusion/pattern_graph.h"
+
+namespace cinn::fusion {
+
+// Operation
+
+struct MergeReduceTreeOperation {
+  template <typename Phrase>
+  void operator()(PatternGraph<Phrase>* graph, PatternNodePtr<Phrase> node) {
+    PADDLE_ENFORCE_EQ(
+        node->downstream().size(),
+        1,
+        phi::errors::PreconditionNotMet(
+            "The downstream of the ReduceTree node should be 1, but got %d.",
+            node->downstream().size()));
+    auto downstream = node->downstream().at(0);
+    auto merged_node = graph->MergeNode(node, downstream, MergePattern<Phrase>);
+    graph->RemoveNode(downstream);
+    graph->RemoveNode(node);
+    VLOG(4) << "MergeReduceTreeOperation: \nupstream " << node->DebugStr()
+            << "\ndownstream " << downstream->DebugStr() << "\nmerged "
+            << merged_node->DebugStr();
+  }
+};
+
+struct MergeReduceTreeAndTrivialOperation {
+  template <typename Phrase>
+  void operator()(PatternGraph<Phrase>* graph, PatternNodePtr<Phrase> node) {
+    PADDLE_ENFORCE_EQ(
+        node->downstream().size(),
+        1,
+        phi::errors::PreconditionNotMet(
+            "The downstream of the ReduceTree node should be 1, but got %d.",
+            node->downstream().size()));
+    auto downstream = node->downstream().at(0);
+    auto fake_reduce_iter_idx = graph->policy_manager()
+                                    .GetPolicy<RelativeJudgePolicy>()
+                                    .GetFakeReduceIterIdx(node, downstream);
+    const auto merge_pattern_fn = [&fake_reduce_iter_idx](
+                                      const StmtPattern<Phrase>& first,
+                                      const StmtPattern<Phrase>& secend) {
+      auto rt_pattern = std::get<ReduceTreePlusTrivialPattern<Phrase>>(
+          MergePattern<Phrase>(first, secend));
+      rt_pattern.fake_reduce_iter_idx = fake_reduce_iter_idx;
+      return rt_pattern;
+    };
+    PatternNodePtr<Phrase> merged_node =
+        graph->MergeNode(node, downstream, merge_pattern_fn);
+    graph->RemoveNode(downstream);
+    graph->RemoveNode(node);
+    VLOG(4) << "MergeReduceTreeAndTrivialOperation: \nupstream "
+            << node->DebugStr() << "\ndownstream " << downstream->DebugStr()
+            << "\nmerged " << merged_node->DebugStr();
+  }
+};
+
+struct LiftReduceToReduceTreeOperation {
+  template <typename Phrase>
+  void operator()(PatternGraph<Phrase>* graph, PatternNodePtr<Phrase> node) {
+    const auto& reduce_pattern = ToReducePattern<Phrase>(node->stmt_pattern());
+    node->set_stmt_pattern(ReduceTreePattern<Phrase>({}, reduce_pattern));
+    VLOG(4) << "LiftReduceToReduceTreeOperation: \nnode " << node->DebugStr();
+  }
+};
+
+struct MergeTrivialPatternOperation {
+  // TOOD(@wuzhanfei)
+  template <typename Phrase>
+  void operator()(PatternGraph<Phrase>* graph,
+                  PatternNodePtr<Phrase> upstream) {
+    std::vector<PatternNodePtr<Phrase>> fusion_candidate =
+        upstream->downstream();
+    upstream->ClearDownstream();
+    for (const auto& downstream : fusion_candidate) {
+      if (std::holds_alternative<ReducePattern<Phrase>>(
+              downstream->stmt_pattern()) ||
+          std::holds_alternative<TrivialPattern<Phrase>>(
+              downstream->stmt_pattern())) {
+        auto merged_node =
+            graph->MergeNode(upstream, downstream, MergePattern<Phrase>);
+        graph->RemoveNode(downstream);
+        VLOG(4) << "MergeTrivialPatternOperation: \nupstream "
+                << upstream->DebugStr() << "\ndownstream "
+                << downstream->DebugStr() << "\nmerged "
+                << merged_node->DebugStr();
+      } else {
+        upstream->AddNodeToDownstream(downstream);
+      }
+    }
+    if (upstream->downstream().empty()) {
+      graph->RemoveNode(upstream);
+    }
+  }
+};
+
+struct LiftToHorizontalFusionPatternOperation {
+  template <typename Phrase>
+  void operator()(PatternGraph<Phrase>* graph, PatternNodePtr<Phrase> node) {
+    node->set_stmt_pattern(
+        HorizontalFusionPattern<Phrase>({node->stmt_pattern()}));
+  }
+};
+
+struct LiftToAnchorPatternOperation {
+  template <typename Phrase>
+  void operator()(PatternGraph<Phrase>* graph, PatternNodePtr<Phrase> node) {
+    // TODO(@wuzhanfei)
+  }
+};
+
+struct FuseUpstreamAnchorOperation {
+  template <typename Phrase>
+  void operator()(PatternGraph<Phrase>* graph,
+                  PatternNodePtr<Phrase> upstream,
+                  PatternNodePtr<Phrase> downstream) {
+    // TODO(@wuzhanfei)
+  }
+};
+
+struct FuseDownstreamAnchorOperation {
+  template <typename Phrase>
+  void operator()(PatternGraph<Phrase>* graph,
+                  PatternNodePtr<Phrase> upstream,
+                  PatternNodePtr<Phrase> downstream) {
+    // TODO(@wuzhanfei)
+  }
+};
+
+struct SplitRecomputeOperation {
+  template <typename Phrase>
+  void operator()(PatternGraph<Phrase>* graph, PatternNodePtr<Phrase> node) {
+    // TODO(@wuzhanfei)
+  }
+};
+
+struct HorizontalFusionOperation {
+  template <typename Phrase>
+  void operator()(PatternGraph<Phrase>* graph,
+                  const PatternNodePtr<Phrase>& i,
+                  const PatternNodePtr<Phrase>& j) {
+    PADDLE_ENFORCE_EQ(
+        GetPatternName(i->stmt_pattern()),
+        HorizontalFusionPattern<Phrase>::name(),
+        phi::errors::PreconditionNotMet(
+            "The pattern of the first node should be HorizontalFusionPattern, "
+            "but got %s.",
+            GetPatternName(i->stmt_pattern())));
+    PADDLE_ENFORCE_EQ(
+        GetPatternName(j->stmt_pattern()),
+        HorizontalFusionPattern<Phrase>::name(),
+        phi::errors::PreconditionNotMet(
+            "The pattern of the second node should be HorizontalFusionPattern, "
+            "but got %s.",
+            GetPatternName(j->stmt_pattern())));
+    graph->MergeNode(i, j, MergePattern<Phrase>);
+    graph->RemoveNode(i);
+    graph->RemoveNode(j);
+  }
+};
+
+}  // namespace cinn::fusion
diff --git a/paddle/cinn/operator_fusion/graph_transformer/search_algorithm.h b/paddle/cinn/operator_fusion/graph_transformer/search_algorithm.h
new file mode 100644
index 00000000000000..2a2a504bfc42fa
--- /dev/null
+++ b/paddle/cinn/operator_fusion/graph_transformer/search_algorithm.h
@@ -0,0 +1,120 @@
+// Copyright (c) 2024 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/cinn/operator_fusion/pattern_graph.h"
+
+namespace cinn::fusion {
+
+struct NodePattern {};
+struct EdgePattern {};
+struct GraphPattern {};     // not implemented.
+struct NodePairPattern {};  // not implemented.
+struct ReverseTopoNodePairPattern {};
+
+template <typename Kind,
+          typename Phrase,
+          typename GraphMatcher,
+          typename GraphOperation>
+struct SearchAlgorithm {};
+
+template <typename Phrase, typename GraphMatcher, typename GraphOperation>
+struct SearchAlgorithm<NodePattern, Phrase, GraphMatcher, GraphOperation> {
+  PatternGraph<Phrase>* graph_;
+  PatternNodePtrSet<Phrase> visited_nodes;
+
+  explicit SearchAlgorithm(PatternGraph<Phrase>* graph) {
+    VLOG(4) << "Create NodePattern algorithm.";
+    graph_ = graph;
+  }
+
+  PatternNodePtr<Phrase> FindMatchedNode() {
+    for (PatternNodePtr<Phrase> iter_node : graph_->all_pattern_nodes()) {
+      if (GraphMatcher()(*graph_, iter_node) &&
+          !visited_nodes.count(iter_node)) {
+        visited_nodes.insert(iter_node);
+        VLOG(4) << "Find Matched Node: " << iter_node;
+        return iter_node;
+      }
+    }
+    VLOG(4) << "Can't find matched node any more.";
+    return nullptr;
+  }
+
+  void operator()() {
+    while (true) {
+      PatternNodePtr<Phrase> node = FindMatchedNode();
+      if (node == nullptr) {
+        break;
+      }
+      GraphOperation()(graph_, node);
+    }
+  }
+};
+
+template <typename Phrase, typename GraphMatcher, typename GraphOperation>
+struct SearchAlgorithm<NodePairPattern, Phrase, GraphMatcher, GraphOperation> {
+  PatternGraph<Phrase>* graph_;
+  std::set<std::pair<PatternNodePtr<Phrase>, PatternNodePtr<Phrase>>>
+      visited_node_pair;
+  explicit SearchAlgorithm(PatternGraph<Phrase>* graph) {
+    VLOG(4) << "Create NodePairPattern algorithm.";
+    graph_ = graph;
+  }
+  std::optional<std::pair<PatternNodePtr<Phrase>, PatternNodePtr<Phrase>>>
+  FindMatchedPair() {
+    for (PatternNodePtr<Phrase> i : graph_->all_pattern_nodes()) {
+      for (PatternNodePtr<Phrase> j : graph_->all_pattern_nodes()) {
+        if (i == j) continue;
+        const auto& pair = std::make_pair(i, j);
+        if (GraphMatcher()(*graph_, i, j) && !visited_node_pair.count(pair)) {
+          visited_node_pair.insert(pair);
+          VLOG(4) << "Find Matched Node Pair: (" << i << ", " << j << ")";
+          return pair;
+        }
+      }
+    }
+    VLOG(4) << "Can't find matched node any more.";
+    return {};
+  }
+  void operator()() {
+    while (true) {
+      const auto& node = FindMatchedPair();
+      if (!node.has_value()) break;
+      const auto& [i, j] = node.value();
+      GraphOperation()(graph_, i, j);
+    }
+  }
+};
+
+template <typename Phrase, typename GraphMatcher, typename GraphOperation>
+struct SearchAlgorithm<ReverseTopoNodePairPattern,
+                       Phrase,
+                       GraphMatcher,
+                       GraphOperation> {
+  // TODO(@wuzhanfei)
+};
+
+template <typename Kind,
+          typename Phrase,
+          typename GraphMatcher,
+          typename GraphOperation>
+void GraphTransformer(PatternGraph<Phrase>* graph) {
+  VLOG(4) << "Start GraphTransformer...";
+  auto alog =
+      SearchAlgorithm<Kind, Phrase, GraphMatcher, GraphOperation>(graph);
+  alog();
+}
+
+}  // namespace cinn::fusion
diff --git a/paddle/cinn/operator_fusion/group_cluster.h b/paddle/cinn/operator_fusion/group_cluster.h
index 2c6f2072ad528a..95407a298fa767 100644
--- a/paddle/cinn/operator_fusion/group_cluster.h
+++ b/paddle/cinn/operator_fusion/group_cluster.h
@@ -19,9 +19,7 @@
 #include "paddle/cinn/operator_fusion/frontend/pattern.h"
 #include "paddle/cinn/operator_fusion/frontend/pattern_fuser.h"
 #include "paddle/cinn/operator_fusion/pattern_graph.h"
-#include "paddle/cinn/operator_fusion/policy/general_topo_policy.h"
-#include "paddle/cinn/operator_fusion/policy/relative_judge_policy.h"
-#include "paddle/cinn/operator_fusion/policy/shardable_axes_policy.h"
+#include "paddle/cinn/operator_fusion/policy/policy_manager.h"
 
 namespace cinn::fusion {
 
@@ -67,14 +65,13 @@ inline std::vector<fusion::PatternNodePtr<T>> ClusterOps(
   const auto& general_topo_policy =
       std::make_shared<fusion::GeneralTopoPolicy<T>>();
 
-  auto policy_manager =
-      fusion::PolicyManager<T>({relative_judge_policy, general_topo_policy});
+  fusion::PolicyManager<T> policy_manager();
 
-  auto topo_manager = fusion::PolicyManager<T>({general_topo_policy});
+  policy_manager.SetPolicy(relative_judge_policy);
+  policy_manager.SetPolicy(general_topo_policy);
 
   VLOG(4) << "Start Create PatternGraph";
-  fusion::PatternGraph<T> graph(
-      content_without_yield, outputs, policy_manager, topo_manager);
+  fusion::PatternGraph<T> graph(content_without_yield, outputs, policy_manager);
   auto result = graph.ClusterOps();
 
   VLOG(4) << "End Cluster Ops! result size:" << result.size();
diff --git a/paddle/cinn/operator_fusion/pattern_graph.cc b/paddle/cinn/operator_fusion/pattern_graph.cc
index ac30011806db62..bd4bd962b0877c 100644
--- a/paddle/cinn/operator_fusion/pattern_graph.cc
+++ b/paddle/cinn/operator_fusion/pattern_graph.cc
@@ -18,6 +18,9 @@
 #include "paddle/cinn/operator_fusion/backend/pattern_fuser.h"
 #include "paddle/cinn/operator_fusion/frontend/pattern.h"
 #include "paddle/cinn/operator_fusion/frontend/pattern_fuser.h"
+#include "paddle/cinn/operator_fusion/graph_transformer/matcher.h"
+#include "paddle/cinn/operator_fusion/graph_transformer/operation.h"
+#include "paddle/cinn/operator_fusion/graph_transformer/search_algorithm.h"
 
 namespace cinn::fusion {
 
@@ -126,7 +129,7 @@ void PatternGraph<T>::HorizontalFusion() {
 
   GraphTransformer<NodePairPattern,
                    T,
-                   HorizontalFusionConstrain,
+                   HorizontalFusionMatcher,
                    HorizontalFusionOperation>(this);
 }
 
@@ -184,11 +187,8 @@ void PatternGraph<T>::SplitRecomputePattern() {
 template <typename T>
 PatternGraph<T>::PatternGraph(const std::vector<PatternContent<T>>& contents,
                               const std::vector<pir::Value>& outputs,
-                              const PolicyManager<T> policy_manager,
-                              const PolicyManager<T> topo_manager)
-    : policy_manager_(policy_manager),
-      topo_manager_(topo_manager),
-      outputs_(outputs) {
+                              const PolicyManager<T> policy_manager)
+    : policy_manager_(policy_manager), outputs_(outputs) {
   std::unordered_map<pir::Operation*, PatternNodePtr<T>> op_to_node_map;
 
   VLOG(4) << "len(outputs) = " << outputs_.size();
diff --git a/paddle/cinn/operator_fusion/pattern_graph.h b/paddle/cinn/operator_fusion/pattern_graph.h
index 9c511939d616b3..433a9849566737 100644
--- a/paddle/cinn/operator_fusion/pattern_graph.h
+++ b/paddle/cinn/operator_fusion/pattern_graph.h
@@ -32,8 +32,7 @@ class PatternGraph {
  public:
   PatternGraph(const std::vector<PatternContent<T>>& nodes,
                const std::vector<pir::Value>& outputs,
-               const PolicyManager<T> policy_manager,
-               const PolicyManager<T> topo_manager);
+               const PolicyManager<T> policy_manager);
 
   std::vector<PatternNodePtr<T>> ClusterOps();
 
@@ -59,425 +58,11 @@ class PatternGraph {
   }
   const std::vector<pir::Value>& outputs() const { return outputs_; }
   const PolicyManager<T>& policy_manager() const { return policy_manager_; }
-  const PolicyManager<T>& topo_manager() const { return topo_manager_; }
 
  private:
   PatternNodePtrSet<T> all_pattern_nodes_;
   std::vector<pir::Value> outputs_;
   PolicyManager<T> policy_manager_;
-  PolicyManager<T> topo_manager_;
 };
 
-// PatternGraphFusionOperation := (GraphMatcher, GraphOperation)
-// SearchAlgorithm := NodePattern | EdgePattern | GraphMatcher
-// GraphOperation := Merge2Node | SplitNode | SplitAllAndMergeDownstream
-
-struct NodePattern {};
-struct EdgePattern {};
-struct GraphPattern {};     // not implemented.
-struct NodePairPattern {};  // not implemented.
-struct ReverseTopoNodePairPattern {};
-
-template <typename Kind,
-          typename Phrase,
-          typename GraphMatcher,
-          typename GraphOperation>
-struct SearchAlgorithm {};
-
-template <typename Phrase, typename GraphMatcher, typename GraphOperation>
-struct SearchAlgorithm<NodePattern, Phrase, GraphMatcher, GraphOperation> {
-  PatternGraph<Phrase>* graph_;
-  PatternNodePtrSet<Phrase> visited_nodes;
-
-  explicit SearchAlgorithm(PatternGraph<Phrase>* graph) {
-    VLOG(4) << "Create NodePattern algorithm.";
-    graph_ = graph;
-  }
-
-  PatternNodePtr<Phrase> FindMatchedNode() {
-    for (PatternNodePtr<Phrase> iter_node : graph_->all_pattern_nodes()) {
-      if (GraphMatcher()(*graph_, iter_node) &&
-          !visited_nodes.count(iter_node)) {
-        visited_nodes.insert(iter_node);
-        VLOG(4) << "Find Matched Node: " << iter_node;
-        return iter_node;
-      }
-    }
-    VLOG(4) << "Can't find matched node any more.";
-    return nullptr;
-  }
-
-  void operator()() {
-    while (true) {
-      PatternNodePtr<Phrase> node = FindMatchedNode();
-      if (node == nullptr) {
-        break;
-      }
-      GraphOperation()(graph_, node);
-    }
-  }
-};
-
-template <typename Phrase, typename GraphMatcher, typename GraphOperation>
-struct SearchAlgorithm<NodePairPattern, Phrase, GraphMatcher, GraphOperation> {
-  PatternGraph<Phrase>* graph_;
-  std::set<std::pair<PatternNodePtr<Phrase>, PatternNodePtr<Phrase>>>
-      visited_node_pair;
-  explicit SearchAlgorithm(PatternGraph<Phrase>* graph) {
-    VLOG(4) << "Create NodePairPattern algorithm.";
-    graph_ = graph;
-  }
-  std::optional<std::pair<PatternNodePtr<Phrase>, PatternNodePtr<Phrase>>>
-  FindMatchedPair() {
-    for (PatternNodePtr<Phrase> i : graph_->all_pattern_nodes()) {
-      for (PatternNodePtr<Phrase> j : graph_->all_pattern_nodes()) {
-        if (i == j) continue;
-        const auto& pair = std::make_pair(i, j);
-        if (GraphMatcher()(*graph_, i, j) && !visited_node_pair.count(pair)) {
-          visited_node_pair.insert(pair);
-          VLOG(4) << "Find Matched Node Pair: (" << i << ", " << j << ")";
-          return pair;
-        }
-      }
-    }
-    VLOG(4) << "Can't find matched node any more.";
-    return {};
-  }
-  void operator()() {
-    while (true) {
-      const auto& node = FindMatchedPair();
-      if (!node.has_value()) break;
-      const auto& [i, j] = node.value();
-      GraphOperation()(graph_, i, j);
-    }
-  }
-};
-
-template <typename Phrase, typename GraphMatcher, typename GraphOperation>
-struct SearchAlgorithm<ReverseTopoNodePairPattern,
-                       Phrase,
-                       GraphMatcher,
-                       GraphOperation> {
-  // TODO(@wuzhanfei)
-};
-
-// Operation
-
-struct MergeReduceTreeOperation {
-  template <typename Phrase>
-  void operator()(PatternGraph<Phrase>* graph, PatternNodePtr<Phrase> node) {
-    PADDLE_ENFORCE_EQ(
-        node->downstream().size(),
-        1,
-        phi::errors::PreconditionNotMet(
-            "The downstream of the ReduceTree node should be 1, but got %d.",
-            node->downstream().size()));
-    auto downstream = node->downstream().at(0);
-    auto merged_node = graph->MergeNode(node, downstream, MergePattern<Phrase>);
-    graph->RemoveNode(downstream);
-    graph->RemoveNode(node);
-    VLOG(4) << "MergeReduceTreeOperation: \nupstream " << node->DebugStr()
-            << "\ndownstream " << downstream->DebugStr() << "\nmerged "
-            << merged_node->DebugStr();
-  }
-};
-
-struct MergeReduceTreeAndTrivialOperation {
-  template <typename Phrase>
-  void operator()(PatternGraph<Phrase>* graph, PatternNodePtr<Phrase> node) {
-    PADDLE_ENFORCE_EQ(
-        node->downstream().size(),
-        1,
-        phi::errors::PreconditionNotMet(
-            "The downstream of the ReduceTree node should be 1, but got %d.",
-            node->downstream().size()));
-    auto downstream = node->downstream().at(0);
-    auto fake_reduce_iter_idx =
-        graph->policy_manager().GetFakeReduceIterIdx(node, downstream);
-    const auto merge_pattern_fn = [&fake_reduce_iter_idx](
-                                      const StmtPattern<Phrase>& first,
-                                      const StmtPattern<Phrase>& secend) {
-      auto rt_pattern = std::get<ReduceTreePlusTrivialPattern<Phrase>>(
-          MergePattern<Phrase>(first, secend));
-      rt_pattern.fake_reduce_iter_idx = fake_reduce_iter_idx;
-      return rt_pattern;
-    };
-    PatternNodePtr<Phrase> merged_node =
-        graph->MergeNode(node, downstream, merge_pattern_fn);
-    graph->RemoveNode(downstream);
-    graph->RemoveNode(node);
-    VLOG(4) << "MergeReduceTreeAndTrivialOperation: \nupstream "
-            << node->DebugStr() << "\ndownstream " << downstream->DebugStr()
-            << "\nmerged " << merged_node->DebugStr();
-  }
-};
-
-struct LiftReduceToReduceTreeOperation {
-  template <typename Phrase>
-  void operator()(PatternGraph<Phrase>* graph, PatternNodePtr<Phrase> node) {
-    const auto& reduce_pattern = ToReducePattern<Phrase>(node->stmt_pattern());
-    node->set_stmt_pattern(ReduceTreePattern<Phrase>({}, reduce_pattern));
-    VLOG(4) << "LiftReduceToReduceTreeOperation: \nnode " << node->DebugStr();
-  }
-};
-
-struct MergeTrivialPatternOperation {
-  // TOOD(@wuzhanfei)
-  template <typename Phrase>
-  void operator()(PatternGraph<Phrase>* graph,
-                  PatternNodePtr<Phrase> upstream) {
-    std::vector<PatternNodePtr<Phrase>> fusion_candidate =
-        upstream->downstream();
-    upstream->ClearDownstream();
-    for (const auto& downstream : fusion_candidate) {
-      if (std::holds_alternative<ReducePattern<Phrase>>(
-              downstream->stmt_pattern()) ||
-          std::holds_alternative<TrivialPattern<Phrase>>(
-              downstream->stmt_pattern())) {
-        auto merged_node =
-            graph->MergeNode(upstream, downstream, MergePattern<Phrase>);
-        graph->RemoveNode(downstream);
-        VLOG(4) << "MergeTrivialPatternOperation: \nupstream "
-                << upstream->DebugStr() << "\ndownstream "
-                << downstream->DebugStr() << "\nmerged "
-                << merged_node->DebugStr();
-      } else {
-        upstream->AddNodeToDownstream(downstream);
-      }
-    }
-    if (upstream->downstream().empty()) {
-      graph->RemoveNode(upstream);
-    }
-  }
-};
-
-struct LiftToHorizontalFusionPatternOperation {
-  template <typename Phrase>
-  void operator()(PatternGraph<Phrase>* graph, PatternNodePtr<Phrase> node) {
-    node->set_stmt_pattern(
-        HorizontalFusionPattern<Phrase>({node->stmt_pattern()}));
-  }
-};
-
-struct LiftToAnchorPatternOperation {
-  template <typename Phrase>
-  void operator()(PatternGraph<Phrase>* graph, PatternNodePtr<Phrase> node) {
-    // TODO(@wuzhanfei)
-  }
-};
-
-struct FuseUpstreamAnchorOperation {
-  template <typename Phrase>
-  void operator()(PatternGraph<Phrase>* graph,
-                  PatternNodePtr<Phrase> upstream,
-                  PatternNodePtr<Phrase> downstream) {
-    // TODO(@wuzhanfei)
-  }
-};
-
-struct FuseDownstreamAnchorOperation {
-  template <typename Phrase>
-  void operator()(PatternGraph<Phrase>* graph,
-                  PatternNodePtr<Phrase> upstream,
-                  PatternNodePtr<Phrase> downstream) {
-    // TODO(@wuzhanfei)
-  }
-};
-
-struct SplitRecomputeOperation {
-  template <typename Phrase>
-  void operator()(PatternGraph<Phrase>* graph, PatternNodePtr<Phrase> node) {
-    // TODO(@wuzhanfei)
-  }
-};
-
-struct HorizontalFusionOperation {
-  template <typename Phrase>
-  void operator()(PatternGraph<Phrase>* graph,
-                  const PatternNodePtr<Phrase>& i,
-                  const PatternNodePtr<Phrase>& j) {
-    PADDLE_ENFORCE_EQ(
-        GetPatternName(i->stmt_pattern()),
-        HorizontalFusionPattern<Phrase>::name(),
-        phi::errors::PreconditionNotMet(
-            "The pattern of the first node should be HorizontalFusionPattern, "
-            "but got %s.",
-            GetPatternName(i->stmt_pattern())));
-    PADDLE_ENFORCE_EQ(
-        GetPatternName(j->stmt_pattern()),
-        HorizontalFusionPattern<Phrase>::name(),
-        phi::errors::PreconditionNotMet(
-            "The pattern of the second node should be HorizontalFusionPattern, "
-            "but got %s.",
-            GetPatternName(j->stmt_pattern())));
-    graph->MergeNode(i, j, MergePattern<Phrase>);
-    graph->RemoveNode(i);
-    graph->RemoveNode(j);
-  }
-};
-
-// Matcher
-
-template <typename StmtPattern>
-struct AlwaysTrue {
-  template <typename T>
-  bool operator()(const PatternGraph<T>& graph, const PatternNodePtr<T>& node) {
-    return true;
-  }
-};
-
-template <typename StmtPattern>
-struct StmtPatternGraphMatcher {
-  template <typename T>
-  bool operator()(const PatternGraph<T>& graph, const PatternNodePtr<T>& node) {
-    return GetPatternName(node->stmt_pattern()) == StmtPattern::name();
-  }
-};
-
-struct CanFuseRxTMatcher {
-  template <typename T>
-  bool operator()(const PatternGraph<T>& graph, const PatternNodePtr<T>& node) {
-    return (
-        std::holds_alternative<ReduceTreePattern<T>>(node->stmt_pattern()) &&
-        !node->downstream().empty() &&
-        std::holds_alternative<TrivialPattern<T>>(
-            node->downstream().at(0)->stmt_pattern()));
-  }
-};
-
-struct CanFuseReduceTreeMatcher {
-  template <typename T>
-  bool operator()(const PatternGraph<T>& graph, const PatternNodePtr<T>& node) {
-    return StmtPatternGraphMatcher<ReduceTreePattern<T>>()(graph, node) &&
-           !node->downstream().empty() &&
-           std::holds_alternative<ReduceTreePattern<T>>(
-               node->downstream().at(0)->stmt_pattern()) &&
-           graph.policy_manager().CanFuse(node, node->downstream().at(0));
-  }
-};
-
-struct CanFuseReduceTreeAndTrivialMatcher {
-  template <typename T>
-  bool operator()(const PatternGraph<T>& graph, const PatternNodePtr<T>& node) {
-    return StmtPatternGraphMatcher<ReduceTreePattern<T>>()(graph, node) &&
-           !node->downstream().empty() &&
-           std::holds_alternative<TrivialPattern<T>>(
-               node->downstream().at(0)->stmt_pattern()) &&
-           graph.policy_manager().CanFuse(node, node->downstream().at(0));
-  }
-};
-
-struct RecomputeNodeMatcher {
-  template <typename T>
-  bool operator()(const PatternGraph<T>& graph, const PatternNodePtr<T>& node) {
-    // TODO(@wuzhanfei)
-  }
-};
-
-struct HasUpstreamAnchorMatcher {
-  template <typename T>
-  bool operator()(const PatternGraph<T>& graph, const PatternNodePtr<T>& node) {
-    // TODO(@wuzhanfei)
-  }
-};
-
-struct HasDownstreamAnchorMatcher {
-  template <typename T>
-  bool operator()(const PatternGraph<T>& graph, const PatternNodePtr<T>& node) {
-    // TODO(@wuzhanfei)
-  }
-};
-
-struct HorizontalFusionConstrain {
-  template <typename T>
-  bool operator()(const PatternGraph<T>& graph,
-                  const PatternNodePtr<T>& first,
-                  const PatternNodePtr<T>& second) {
-    if (!StmtPatternGraphMatcher<HorizontalFusionPattern<T>>()(graph, first)) {
-      return false;
-    }
-    if (!StmtPatternGraphMatcher<HorizontalFusionPattern<T>>()(graph, second)) {
-      return false;
-    }
-    const auto& first_dim = first->sink_op()
-                                ->result(0)
-                                .type()
-                                .template dyn_cast<pir::DenseTensorType>()
-                                .dims();
-    const auto& second_dim = second->sink_op()
-                                 ->result(0)
-                                 .type()
-                                 .template dyn_cast<pir::DenseTensorType>()
-                                 .dims();
-    return graph.topo_manager().CanFuse(first, second) &&
-           first_dim == second_dim;
-  }
-};
-
-struct NonSinkNodeMatcher {
-  template <typename T>
-  bool operator()(const PatternGraph<T>& graph, const PatternNodePtr<T>& node) {
-    return !node->downstream().empty();
-  }
-};
-
-struct IsOutputNodeMatcher {
-  template <typename T>
-  bool operator()(const PatternGraph<T>& graph, const PatternNodePtr<T>& node) {
-    bool res = IsAnyFirstInSecond(node->sink_op()->results(), graph.outputs());
-    return res;
-  }
-};
-
-template <int N>
-struct DownstreamSmallerThan {
-  template <typename T>
-  bool operator()(const PatternGraph<T>& graph, const PatternNodePtr<T>& node) {
-    return node->downstream().size() < N;
-  }
-};
-
-template <int N>
-struct DownstreamGreaterThan {
-  template <typename T>
-  bool operator()(const PatternGraph<T>& graph, const PatternNodePtr<T>& node) {
-    return node->downstream().size() > N;
-  }
-};
-
-template <typename A, typename B>
-struct And {
-  template <typename T>
-  bool operator()(const PatternGraph<T>& graph, const PatternNodePtr<T>& node) {
-    return A()(graph, node) && B()(graph, node);
-  }
-};
-
-template <typename A, typename B>
-struct Or {
-  template <typename T>
-  bool operator()(const PatternGraph<T>& graph, const PatternNodePtr<T>& node) {
-    return A()(graph, node) || B()(graph, node);
-  }
-};
-
-template <typename A>
-struct Not {
-  template <typename T>
-  bool operator()(const PatternGraph<T>& graph, const PatternNodePtr<T>& node) {
-    return !A()(graph, node);
-  }
-};
-
-template <typename Kind,
-          typename Phrase,
-          typename GraphMatcher,
-          typename GraphOperation>
-void GraphTransformer(PatternGraph<Phrase>* graph) {
-  VLOG(4) << "Start GraphTransformer...";
-  auto alog =
-      SearchAlgorithm<Kind, Phrase, GraphMatcher, GraphOperation>(graph);
-  alog();
-}
-
 }  // namespace cinn::fusion
diff --git a/paddle/cinn/operator_fusion/policy/CMakeLists.txt b/paddle/cinn/operator_fusion/policy/CMakeLists.txt
index af35ce02bc20f3..2c810204ef9be0 100644
--- a/paddle/cinn/operator_fusion/policy/CMakeLists.txt
+++ b/paddle/cinn/operator_fusion/policy/CMakeLists.txt
@@ -2,7 +2,6 @@ gather_srcs(
   policy_fusion_src
   SRCS
   shardable_axes_base.cc
-  policy_manager.cc
   relative_judge_policy.cc
   general_topo_policy.cc
   shardable_axes_policy.cc
diff --git a/paddle/cinn/operator_fusion/policy/general_topo_policy.h b/paddle/cinn/operator_fusion/policy/general_topo_policy.h
index 8fc8e360dd01d1..96a7d5f609922c 100644
--- a/paddle/cinn/operator_fusion/policy/general_topo_policy.h
+++ b/paddle/cinn/operator_fusion/policy/general_topo_policy.h
@@ -13,15 +13,17 @@
 // limitations under the License.
 
 #pragma once
-#include "paddle/cinn/operator_fusion/policy/policy_manager.h"
+#include "paddle/cinn/operator_fusion/pattern_node.h"
+#include "paddle/cinn/operator_fusion/policy/policy_base.h"
 
 namespace cinn::fusion {
 
 template <typename T>
-class GeneralTopoPolicy final : virtual public Policy<T> {
+class GeneralTopoPolicy final : public PolicyBase<T> {
  public:
+  static constexpr PolicyKind Kind = PolicyKind::GeneralTopo;
   bool CanFuse(const PatternNodePtr<T>& upstream,
-               const PatternNodePtr<T>& downstream) override;
+               const PatternNodePtr<T>& downstream);
   std::string Name() { return "GeneralTopoPolicy"; }
 };
 
diff --git a/paddle/cinn/operator_fusion/policy/policy_base.h b/paddle/cinn/operator_fusion/policy/policy_base.h
new file mode 100644
index 00000000000000..01fcc7a30cbe2b
--- /dev/null
+++ b/paddle/cinn/operator_fusion/policy/policy_base.h
@@ -0,0 +1,44 @@
+// Copyright (c) 2024 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 <memory>
+#include <unordered_map>
+
+namespace cinn::fusion {
+
+enum PolicyKind { GeneralTopo = 1, RelativeJudge = 2, AnchorSearch = 3 };
+
+struct PolicyKindHash {
+  std::size_t operator()(const PolicyKind& t) const {
+    return static_cast<std::size_t>(t);
+  }
+};
+
+template <typename T>
+class PolicyBase {};
+
+template <typename T>
+using PolicyPtr = std::shared_ptr<PolicyBase<T>>;
+
+template <typename T>
+using PolicyMap = std::unordered_map<PolicyKind, PolicyPtr<T>, PolicyKindHash>;
+
+}  // namespace cinn::fusion
+
+template <typename T>
+struct GeneralTopoPolicy final : public PolicyBase<T> {
+  static constexpr PolicyKind Kind = PolicyKind::GeneralTopo;
+  int i = 123;
+};
diff --git a/paddle/cinn/operator_fusion/policy/policy_manager.cc b/paddle/cinn/operator_fusion/policy/policy_manager.cc
deleted file mode 100644
index 5d21dfed23b902..00000000000000
--- a/paddle/cinn/operator_fusion/policy/policy_manager.cc
+++ /dev/null
@@ -1,46 +0,0 @@
-// Copyright (c) 2024 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.
-
-#include "paddle/cinn/operator_fusion/policy/policy_manager.h"
-#include "paddle/cinn/operator_fusion/backend/pattern.h"
-#include "paddle/cinn/operator_fusion/frontend/pattern.h"
-#include "paddle/common/enforce.h"
-
-namespace cinn::fusion {
-
-template <typename T>
-bool PolicyManager<T>::CanFuse(const PatternNodePtr<T>& upstream,
-                               const PatternNodePtr<T>& downstream) const {
-  for (const auto& policy : policies_) {
-    if (!policy->CanFuse(upstream, downstream)) return false;
-  }
-  return true;
-}
-
-template <typename T>
-std::vector<size_t> PolicyManager<T>::GetFakeReduceIterIdx(
-    const PatternNodePtr<T>& upstream,
-    const PatternNodePtr<T>& downstream) const {
-  for (const auto& policy : policies_) {
-    if (policy->Name() == "RelativeJudgePolicy") {
-      return policy->GetFakeReduceIterIdx(upstream, downstream);
-    }
-  }
-  return {};
-}
-
-template class PolicyManager<FrontendStage>;
-template class PolicyManager<BackendStage>;
-
-}  // namespace cinn::fusion
diff --git a/paddle/cinn/operator_fusion/policy/policy_manager.h b/paddle/cinn/operator_fusion/policy/policy_manager.h
index 33c4227f7b1c7d..3e5f18c2903b5c 100644
--- a/paddle/cinn/operator_fusion/policy/policy_manager.h
+++ b/paddle/cinn/operator_fusion/policy/policy_manager.h
@@ -15,37 +15,40 @@
 #pragma once
 
 #include "paddle/cinn/operator_fusion/pattern_node.h"
+#include "paddle/cinn/operator_fusion/policy/general_topo_policy.h"
+#include "paddle/cinn/operator_fusion/policy/policy_base.h"
+#include "paddle/cinn/operator_fusion/policy/relative_judge_policy.h"
 
 namespace cinn::fusion {
 
 template <typename T>
-class Policy {
+class PolicyManager {
  public:
-  virtual std::string Name() = 0;
-  virtual bool CanFuse(const PatternNodePtr<T>& upstream,
-                       const PatternNodePtr<T>& downstream) = 0;
-  virtual std::vector<size_t> GetFakeReduceIterIdx(
-      const PatternNodePtr<T>& upstream, const PatternNodePtr<T>& downstream) {
-    return {};
+  PolicyManager() {}
+
+  template <typename U>
+  PolicyKind GetKey() {
+    return U::Kind;
   }
-};
 
-template <typename T>
-using PolicyPtr = std::shared_ptr<Policy<T>>;
+  template <template <typename> typename POLICY>
+  void SetPolicy(const std::shared_ptr<POLICY<T>>& policy) {
+    policies[GetKey<POLICY<T>>()] =
+        std::static_pointer_cast<PolicyBase<T>>(policy);
+  }
 
-template <typename T>
-class PolicyManager {
- public:
-  explicit PolicyManager(const std::vector<PolicyPtr<T>>& policies)
-      : policies_(policies) {}
-  bool CanFuse(const PatternNodePtr<T>& upstream,
-               const PatternNodePtr<T>& downstream) const;
-  std::vector<size_t> GetFakeReduceIterIdx(
-      const PatternNodePtr<T>& upstream,
-      const PatternNodePtr<T>& downstream) const;
+  template <template <typename> typename POLICY>
+  std::shared_ptr<POLICY<T>> GetPolicy() {
+    PADDLE_ENFORCE_NE(
+        policies.find(GetKey<POLICY<T>>()),
+        policies.end(),
+        phi::errors::NotFound(
+            "The upstream nodes of the merged node are not unique."));
+    return std::static_pointer_cast<POLICY<T>>(policies[GetKey<POLICY<T>>()]);
+  }
 
  private:
-  std::vector<PolicyPtr<T>> policies_;
+  PolicyMap<T> policies;
 };
 
 }  // namespace cinn::fusion
diff --git a/paddle/cinn/operator_fusion/policy/relative_judge_policy.h b/paddle/cinn/operator_fusion/policy/relative_judge_policy.h
index 8b92a9d441075f..24ec1bca1e1793 100644
--- a/paddle/cinn/operator_fusion/policy/relative_judge_policy.h
+++ b/paddle/cinn/operator_fusion/policy/relative_judge_policy.h
@@ -14,8 +14,9 @@
 
 #pragma once
 #include <functional>
+#include "paddle/cinn/operator_fusion/pattern_node.h"
 #include "paddle/cinn/operator_fusion/policy/dim_relation.h"
-#include "paddle/cinn/operator_fusion/policy/policy_manager.h"
+#include "paddle/cinn/operator_fusion/policy/policy_base.h"
 #include "paddle/cinn/operator_fusion/policy/shardable_axes_base.h"
 #include "paddle/cinn/operator_fusion/utils.h"
 #include "paddle/common/enforce.h"
@@ -23,8 +24,9 @@
 namespace cinn::fusion {
 
 template <typename T>
-class RelativeJudgePolicy final : public Policy<T> {
+class RelativeJudgePolicy final : public PolicyBase<T> {
  public:
+  static constexpr PolicyKind Kind = PolicyKind::RelativeJudge;
   RelativeJudgePolicy(const std::vector<pir::Operation*>& ops,
                       pir::ShapeConstraintIRAnalysis* shape_analysis)
       : axes_info_(ops, shape_analysis) {
@@ -33,13 +35,12 @@ class RelativeJudgePolicy final : public Policy<T> {
     VLOG(4) << "[relative_judge_policy] End AnalysisIndexExprRelation.";
   }
   bool CanFuse(const PatternNodePtr<T>& upstream,
-               const PatternNodePtr<T>& downstream) override;
+               const PatternNodePtr<T>& downstream);
 
   std::string Name() { return "RelativeJudgePolicy"; }
 
-  std::vector<size_t> GetFakeReduceIterIdx(
-      const PatternNodePtr<T>& upstream,
-      const PatternNodePtr<T>& downstream) override;
+  std::vector<size_t> GetFakeReduceIterIdx(const PatternNodePtr<T>& upstream,
+                                           const PatternNodePtr<T>& downstream);
 
   bool IsRelated(DimUsage in, DimUsage out) {
     return index_expr_map_[in].count(out) == 1;
diff --git a/paddle/cinn/operator_fusion/policy/shardable_axes_policy.cc b/paddle/cinn/operator_fusion/policy/shardable_axes_policy.cc
deleted file mode 100644
index 4b8b758f449cd5..00000000000000
--- a/paddle/cinn/operator_fusion/policy/shardable_axes_policy.cc
+++ /dev/null
@@ -1,99 +0,0 @@
-// Copyright (c) 2024 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.
-
-#include "paddle/cinn/operator_fusion/policy/shardable_axes_policy.h"
-#include "paddle/cinn/operator_fusion/backend/pattern.h"
-#include "paddle/cinn/operator_fusion/frontend/pattern.h"
-
-namespace cinn::fusion {
-
-template <typename T>
-bool ShardableAxesRRFusePolicy<T>::IsDownstreamStmtDependReduceOp(
-    pir::Operation* reduce, const StmtPattern<T>& downstream) {
-  const auto& values = GetPatternInputValues(downstream);
-  for (const auto& value : reduce->results()) {
-    if (std::find(values.begin(), values.end(), value) != values.end()) {
-      return true;
-    }
-  }
-  return false;
-}
-
-template <typename T>
-std::optional<ReducePattern<T>>
-ShardableAxesRRFusePolicy<T>::GetDownstreamFromCandidate(
-    const ReducePattern<T>& upstream,
-    const std::vector<ReducePattern<T>>& candidates) {
-  pir::Operation* reduce = upstream.GetReduceOp();
-  for (const auto& candidate : candidates) {
-    if (IsDownstreamStmtDependReduceOp(reduce, candidate)) {
-      return candidate;
-    }
-  }
-  return {};
-}
-
-static std::set<std::string> GetReduceAxesName(
-    const ShardableAxesSignature& signature) {
-  const auto& input_names = signature.inputs[0].axis_names;
-  const auto& output_names = signature.outputs[0].axis_names;
-  std::set<std::string> res(input_names.begin(), input_names.end());
-  for (const auto& n : output_names) {
-    res.erase(n);
-  }
-  return res;
-}
-
-template <typename T>
-bool ShardableAxesRRFusePolicy<T>::ReduceTreeGrownCanMerge(
-    const PatternNodePtr<T>& upstream, const PatternNodePtr<T>& downstream) {
-  if (!upstream->IsReduceTree() || !downstream->IsReduceTree()) {
-    return false;
-  }
-  const auto& upstream_tree =
-      std::get<ReduceTreePattern>(upstream->stmt_pattern());
-  const auto& downstream_tree =
-      std::get<ReduceTreePattern>(downstream->stmt_pattern());
-  const auto& maybe_downstream_op = GetDownstreamFromCandidate(
-      upstream_tree.GetRootPattern(), downstream_tree.reduce_patterns_);
-  if (!maybe_downstream_op.has_value()) {
-    return false;
-  }
-  const pir::Value& reduce_out_value =
-      upstream_tree.GetRootPattern().GetReduceOp()->result(0);
-  pir::Operation* downstream_reduce_op =
-      maybe_downstream_op.value().GetReduceOp();
-  const auto& reduce_names =
-      GetReduceAxesName(axes_info_.GetSignature(downstream_reduce_op));
-  for (const auto& n :
-       axes_info_.GetAxes(downstream_reduce_op->result(0)).axis_names) {
-    if (reduce_names.count(n) > 0) {
-      // not meeting the BroadcastEdge condition.
-      return false;
-    }
-  }
-  return true;
-}
-
-template <typename T>
-bool ShardableAxesRRFusePolicy<T>::CanFuse(
-    const PatternNodePtr<T>& upstream, const PatternNodePtr<T>& downstream) {
-  // TODO(wuzhanfei) shardable axes policy
-  return ReduceTreeGrownCanMerge(upstream, downstream);
-}
-
-template class RelativeJudgePolicy<FrontendStage>;
-template class RelativeJudgePolicy<BackendStage>;
-
-}  // namespace cinn::fusion
diff --git a/paddle/cinn/operator_fusion/policy/shardable_axes_policy.h b/paddle/cinn/operator_fusion/policy/shardable_axes_policy.h
deleted file mode 100644
index de9c183997d7e7..00000000000000
--- a/paddle/cinn/operator_fusion/policy/shardable_axes_policy.h
+++ /dev/null
@@ -1,43 +0,0 @@
-// Copyright (c) 2024 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/cinn/operator_fusion/policy/policy_manager.h"
-#include "paddle/cinn/operator_fusion/policy/shardable_axes_base.h"
-
-namespace cinn::fusion {
-
-template <typename T>
-class ShardableAxesRRFusePolicy final : public Policy<T> {
- public:
-  ShardableAxesRRFusePolicy(
-      const std::vector<pir::Operation*>& ops,         // NOLINT
-      pir::ShapeConstraintIRAnalysis* shape_analysis)  // NOLINT
-      : axes_info_(ops, shape_analysis) {}
-  bool CanFuse(const PatternNodePtr<T>& upstream,
-               const PatternNodePtr<T>& downstream) override;
-  std::string Name() { return "ShardableAxesRRFusePolicy"; }
-
- private:
-  bool ReduceTreeGrownCanMerge(const PatternNodePtr<T>&,
-                               const PatternNodePtr<T>&);
-  std::optional<ReducePattern<T>> GetDownstreamFromCandidate(
-      const ReducePattern<T>& upstream,
-      const std::vector<ReducePattern<T>>& candidates);
-  ShardableAxesInfoManager axes_info_;
-  bool IsDownstreamStmtDependReduceOp(pir::Operation* reduce,
-                                      const StmtPattern<T>& downstream);
-};
-
-}  // namespace cinn::fusion

From 1ccbfb5bff3a8247482cc6da9173bb11ce27e5ef Mon Sep 17 00:00:00 2001
From: feifei-111 <2364819892@qq.com>
Date: Thu, 25 Apr 2024 14:34:07 +0000
Subject: [PATCH 13/99] update policy manager

---
 .../graph_transformer/matcher.h               | 35 ++++++++++++-------
 .../graph_transformer/operation.h             | 12 +++----
 .../graph_transformer/search_algorithm.h      |  2 ++
 paddle/cinn/operator_fusion/group_cluster.h   |  2 +-
 .../operator_fusion/policy/CMakeLists.txt     | 10 ++----
 .../cinn/operator_fusion/policy/policy_base.h |  6 ----
 .../operator_fusion/policy/policy_manager.h   | 16 ++++-----
 test/quantization/CMakeLists.txt              |  1 +
 8 files changed, 40 insertions(+), 44 deletions(-)

diff --git a/paddle/cinn/operator_fusion/graph_transformer/matcher.h b/paddle/cinn/operator_fusion/graph_transformer/matcher.h
index 11049409da0527..89803388e3a204 100644
--- a/paddle/cinn/operator_fusion/graph_transformer/matcher.h
+++ b/paddle/cinn/operator_fusion/graph_transformer/matcher.h
@@ -52,10 +52,12 @@ struct CanFuseReduceTreeMatcher {
            !node->downstream().empty() &&
            std::holds_alternative<ReduceTreePattern<T>>(
                node->downstream().at(0)->stmt_pattern()) &&
-           graph.policy_manager().GetPolicy<GeneralTopoPolicy>().CanFuse(
-               node, node->downstream().at(0)) &&
-           graph.policy_manager().GetPolicy<RelativeJudgePolicy>().CanFuse(
-               node, node->downstream().at(0));
+           graph.policy_manager()
+               .template GetPolicy<GeneralTopoPolicy>()
+               ->CanFuse(node, node->downstream().at(0)) &&
+           graph.policy_manager()
+               .template GetPolicy<RelativeJudgePolicy>()
+               ->CanFuse(node, node->downstream().at(0));
   }
 };
 
@@ -66,10 +68,12 @@ struct CanFuseReduceTreeAndTrivialMatcher {
            !node->downstream().empty() &&
            std::holds_alternative<TrivialPattern<T>>(
                node->downstream().at(0)->stmt_pattern()) &&
-           graph.policy_manager().GetPolicy<GeneralTopoPolicy>().CanFuse(
-               node, node->downstream().at(0)) &&
-           graph.policy_manager().GetPolicy<RelativeJudgePolicy>().CanFuse(
-               node, node->downstream().at(0));
+           graph.policy_manager()
+               .template GetPolicy<GeneralTopoPolicy>()
+               ->CanFuse(node, node->downstream().at(0)) &&
+           graph.policy_manager()
+               .template GetPolicy<RelativeJudgePolicy>()
+               ->CanFuse(node, node->downstream().at(0));
   }
 };
 
@@ -83,7 +87,9 @@ struct RecomputeNodeMatcher {
 
 struct HasUpstreamAnchorMatcher {
   template <typename T>
-  bool operator()(const PatternGraph<T>& graph, const PatternNodePtr<T>& node) {
+  bool operator()(const PatternGraph<T>& graph,
+                  const PatternNodePtr<T>& upstream,
+                  const PatternNodePtr<T>& downstream) {
     // TODO(@wuzhanfei)
     return false;
   }
@@ -91,9 +97,11 @@ struct HasUpstreamAnchorMatcher {
 
 struct HasDownstreamAnchorMatcher {
   template <typename T>
-  bool operator()(const PatternGraph<T>& graph, const PatternNodePtr<T>& node) {
+  bool operator()(const PatternGraph<T>& graph,
+                  const PatternNodePtr<T>& upstream,
+                  const PatternNodePtr<T>& downstream) {
     // TODO(@wuzhanfei)
-    return false
+    return false;
   }
 };
 
@@ -118,8 +126,9 @@ struct HorizontalFusionMatcher {
                                  .type()
                                  .template dyn_cast<pir::DenseTensorType>()
                                  .dims();
-    return graph.policy_manager.GetPolicy<GeneralTopoPolicy>().CanFuse(
-               first, second) &&
+    return graph.policy_manager()
+               .template GetPolicy<GeneralTopoPolicy>()
+               ->CanFuse(first, second) &&
            first_dim == second_dim;
   }
 };
diff --git a/paddle/cinn/operator_fusion/graph_transformer/operation.h b/paddle/cinn/operator_fusion/graph_transformer/operation.h
index 55c6dd35aef0d2..51dc26c4c631d0 100644
--- a/paddle/cinn/operator_fusion/graph_transformer/operation.h
+++ b/paddle/cinn/operator_fusion/graph_transformer/operation.h
@@ -49,8 +49,8 @@ struct MergeReduceTreeAndTrivialOperation {
             node->downstream().size()));
     auto downstream = node->downstream().at(0);
     auto fake_reduce_iter_idx = graph->policy_manager()
-                                    .GetPolicy<RelativeJudgePolicy>()
-                                    .GetFakeReduceIterIdx(node, downstream);
+                                    .template GetPolicy<RelativeJudgePolicy>()
+                                    ->GetFakeReduceIterIdx(node, downstream);
     const auto merge_pattern_fn = [&fake_reduce_iter_idx](
                                       const StmtPattern<Phrase>& first,
                                       const StmtPattern<Phrase>& secend) {
@@ -126,8 +126,8 @@ struct LiftToAnchorPatternOperation {
 struct FuseUpstreamAnchorOperation {
   template <typename Phrase>
   void operator()(PatternGraph<Phrase>* graph,
-                  PatternNodePtr<Phrase> upstream,
-                  PatternNodePtr<Phrase> downstream) {
+                  const PatternNodePtr<Phrase>& upstream,
+                  const PatternNodePtr<Phrase>& downstream) {
     // TODO(@wuzhanfei)
   }
 };
@@ -135,8 +135,8 @@ struct FuseUpstreamAnchorOperation {
 struct FuseDownstreamAnchorOperation {
   template <typename Phrase>
   void operator()(PatternGraph<Phrase>* graph,
-                  PatternNodePtr<Phrase> upstream,
-                  PatternNodePtr<Phrase> downstream) {
+                  const PatternNodePtr<Phrase>& upstream,
+                  const PatternNodePtr<Phrase>& downstream) {
     // TODO(@wuzhanfei)
   }
 };
diff --git a/paddle/cinn/operator_fusion/graph_transformer/search_algorithm.h b/paddle/cinn/operator_fusion/graph_transformer/search_algorithm.h
index 2a2a504bfc42fa..dd424ca4245be5 100644
--- a/paddle/cinn/operator_fusion/graph_transformer/search_algorithm.h
+++ b/paddle/cinn/operator_fusion/graph_transformer/search_algorithm.h
@@ -104,6 +104,8 @@ struct SearchAlgorithm<ReverseTopoNodePairPattern,
                        GraphMatcher,
                        GraphOperation> {
   // TODO(@wuzhanfei)
+  explicit SearchAlgorithm(PatternGraph<Phrase>* graph) {}
+  void operator()() {}
 };
 
 template <typename Kind,
diff --git a/paddle/cinn/operator_fusion/group_cluster.h b/paddle/cinn/operator_fusion/group_cluster.h
index 95407a298fa767..1a30e3bf9607de 100644
--- a/paddle/cinn/operator_fusion/group_cluster.h
+++ b/paddle/cinn/operator_fusion/group_cluster.h
@@ -65,7 +65,7 @@ inline std::vector<fusion::PatternNodePtr<T>> ClusterOps(
   const auto& general_topo_policy =
       std::make_shared<fusion::GeneralTopoPolicy<T>>();
 
-  fusion::PolicyManager<T> policy_manager();
+  fusion::PolicyManager<T> policy_manager;
 
   policy_manager.SetPolicy(relative_judge_policy);
   policy_manager.SetPolicy(general_topo_policy);
diff --git a/paddle/cinn/operator_fusion/policy/CMakeLists.txt b/paddle/cinn/operator_fusion/policy/CMakeLists.txt
index 2c810204ef9be0..95e290f26ef72b 100644
--- a/paddle/cinn/operator_fusion/policy/CMakeLists.txt
+++ b/paddle/cinn/operator_fusion/policy/CMakeLists.txt
@@ -1,8 +1,2 @@
-gather_srcs(
-  policy_fusion_src
-  SRCS
-  shardable_axes_base.cc
-  relative_judge_policy.cc
-  general_topo_policy.cc
-  shardable_axes_policy.cc
-  dim_relation.cc)
+gather_srcs(policy_fusion_src SRCS shardable_axes_base.cc
+            relative_judge_policy.cc general_topo_policy.cc dim_relation.cc)
diff --git a/paddle/cinn/operator_fusion/policy/policy_base.h b/paddle/cinn/operator_fusion/policy/policy_base.h
index 01fcc7a30cbe2b..ea351c01cad9cd 100644
--- a/paddle/cinn/operator_fusion/policy/policy_base.h
+++ b/paddle/cinn/operator_fusion/policy/policy_base.h
@@ -36,9 +36,3 @@ template <typename T>
 using PolicyMap = std::unordered_map<PolicyKind, PolicyPtr<T>, PolicyKindHash>;
 
 }  // namespace cinn::fusion
-
-template <typename T>
-struct GeneralTopoPolicy final : public PolicyBase<T> {
-  static constexpr PolicyKind Kind = PolicyKind::GeneralTopo;
-  int i = 123;
-};
diff --git a/paddle/cinn/operator_fusion/policy/policy_manager.h b/paddle/cinn/operator_fusion/policy/policy_manager.h
index 3e5f18c2903b5c..60b78399e3c7ba 100644
--- a/paddle/cinn/operator_fusion/policy/policy_manager.h
+++ b/paddle/cinn/operator_fusion/policy/policy_manager.h
@@ -26,25 +26,21 @@ class PolicyManager {
  public:
   PolicyManager() {}
 
-  template <typename U>
-  PolicyKind GetKey() {
-    return U::Kind;
-  }
-
   template <template <typename> typename POLICY>
   void SetPolicy(const std::shared_ptr<POLICY<T>>& policy) {
-    policies[GetKey<POLICY<T>>()] =
-        std::static_pointer_cast<PolicyBase<T>>(policy);
+    auto key = POLICY<T>::Kind;
+    policies[key] = std::static_pointer_cast<PolicyBase<T>>(policy);
   }
 
   template <template <typename> typename POLICY>
-  std::shared_ptr<POLICY<T>> GetPolicy() {
+  std::shared_ptr<POLICY<T>> GetPolicy() const {
+    auto key = POLICY<T>::Kind;
     PADDLE_ENFORCE_NE(
-        policies.find(GetKey<POLICY<T>>()),
+        policies.find(key),
         policies.end(),
         phi::errors::NotFound(
             "The upstream nodes of the merged node are not unique."));
-    return std::static_pointer_cast<POLICY<T>>(policies[GetKey<POLICY<T>>()]);
+    return std::static_pointer_cast<POLICY<T>>(policies.at(key));
   }
 
  private:
diff --git a/test/quantization/CMakeLists.txt b/test/quantization/CMakeLists.txt
index d8253eb5f20071..e18f8c0a38096c 100644
--- a/test/quantization/CMakeLists.txt
+++ b/test/quantization/CMakeLists.txt
@@ -1,3 +1,4 @@
+include(../cpp/inference/test.cmake)
 file(
   GLOB TEST_OPS
   RELATIVE "${CMAKE_CURRENT_SOURCE_DIR}"

From e39186cd7d8c25db3056890d0bc825ae98c414db Mon Sep 17 00:00:00 2001
From: feifei-111 <2364819892@qq.com>
Date: Fri, 26 Apr 2024 03:54:46 +0000
Subject: [PATCH 14/99] update

---
 paddle/cinn/operator_fusion/CMakeLists.txt    |  3 +-
 .../pir_graph_analyzing/CMakeLists.txt        |  1 +
 .../pir_graph_analyzing/anchor_transform.cc   | 15 ++++++++
 .../pir_graph_analyzing/anchor_transform.h    | 15 ++++++++
 .../dim_relation.cc                           |  2 +-
 .../dim_relation.h                            |  0
 .../shardable_axes_base.cc                    |  2 +-
 .../shardable_axes_base.h                     |  0
 .../operator_fusion/policy/CMakeLists.txt     |  4 +--
 .../policy/anchor_search_policy.cc            | 15 ++++++++
 .../policy/anchor_search_policy.h             | 34 +++++++++++++++++++
 .../policy/relative_judge_policy.h            |  4 +--
 12 files changed, 88 insertions(+), 7 deletions(-)
 create mode 100644 paddle/cinn/operator_fusion/pir_graph_analyzing/CMakeLists.txt
 create mode 100644 paddle/cinn/operator_fusion/pir_graph_analyzing/anchor_transform.cc
 create mode 100644 paddle/cinn/operator_fusion/pir_graph_analyzing/anchor_transform.h
 rename paddle/cinn/operator_fusion/{policy => pir_graph_analyzing}/dim_relation.cc (99%)
 rename paddle/cinn/operator_fusion/{policy => pir_graph_analyzing}/dim_relation.h (100%)
 rename paddle/cinn/operator_fusion/{policy => pir_graph_analyzing}/shardable_axes_base.cc (99%)
 rename paddle/cinn/operator_fusion/{policy => pir_graph_analyzing}/shardable_axes_base.h (100%)
 create mode 100644 paddle/cinn/operator_fusion/policy/anchor_search_policy.cc
 create mode 100644 paddle/cinn/operator_fusion/policy/anchor_search_policy.h

diff --git a/paddle/cinn/operator_fusion/CMakeLists.txt b/paddle/cinn/operator_fusion/CMakeLists.txt
index d5a46bd4ef2e2a..7e756c6701205a 100644
--- a/paddle/cinn/operator_fusion/CMakeLists.txt
+++ b/paddle/cinn/operator_fusion/CMakeLists.txt
@@ -1,9 +1,10 @@
 add_subdirectory(frontend)
 add_subdirectory(backend)
 add_subdirectory(policy)
+add_subdirectory(pir_graph_analyzing)
 
 cc_library(
   op_fusion
   SRCS ${frontend_fusion_src} ${backend_fusion_src} ${policy_fusion_src}
-       pattern_graph.cc
+       ${fusion_graph_analyzing} pattern_graph.cc
   DEPS phi)
diff --git a/paddle/cinn/operator_fusion/pir_graph_analyzing/CMakeLists.txt b/paddle/cinn/operator_fusion/pir_graph_analyzing/CMakeLists.txt
new file mode 100644
index 00000000000000..450e9806cff0b3
--- /dev/null
+++ b/paddle/cinn/operator_fusion/pir_graph_analyzing/CMakeLists.txt
@@ -0,0 +1 @@
+gather_srcs(fusion_graph_analyzing SRCS shardable_axes_base.cc dim_relation.cc)
diff --git a/paddle/cinn/operator_fusion/pir_graph_analyzing/anchor_transform.cc b/paddle/cinn/operator_fusion/pir_graph_analyzing/anchor_transform.cc
new file mode 100644
index 00000000000000..06033922deaf8d
--- /dev/null
+++ b/paddle/cinn/operator_fusion/pir_graph_analyzing/anchor_transform.cc
@@ -0,0 +1,15 @@
+// Copyright (c) 2024 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.
+
+#include "paddle/cinn/operator_fusion/pir_graph_analyzing/anchor_transform.h"
diff --git a/paddle/cinn/operator_fusion/pir_graph_analyzing/anchor_transform.h b/paddle/cinn/operator_fusion/pir_graph_analyzing/anchor_transform.h
new file mode 100644
index 00000000000000..8f5f6dd8c0d7d2
--- /dev/null
+++ b/paddle/cinn/operator_fusion/pir_graph_analyzing/anchor_transform.h
@@ -0,0 +1,15 @@
+// Copyright (c) 2024 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
diff --git a/paddle/cinn/operator_fusion/policy/dim_relation.cc b/paddle/cinn/operator_fusion/pir_graph_analyzing/dim_relation.cc
similarity index 99%
rename from paddle/cinn/operator_fusion/policy/dim_relation.cc
rename to paddle/cinn/operator_fusion/pir_graph_analyzing/dim_relation.cc
index 910359260bec8d..f3866a8e70896a 100644
--- a/paddle/cinn/operator_fusion/policy/dim_relation.cc
+++ b/paddle/cinn/operator_fusion/pir_graph_analyzing/dim_relation.cc
@@ -12,7 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include "paddle/cinn/operator_fusion/policy/dim_relation.h"
+#include "paddle/cinn/operator_fusion/pir_graph_analyzing/dim_relation.h"
 
 namespace cinn::fusion {
 
diff --git a/paddle/cinn/operator_fusion/policy/dim_relation.h b/paddle/cinn/operator_fusion/pir_graph_analyzing/dim_relation.h
similarity index 100%
rename from paddle/cinn/operator_fusion/policy/dim_relation.h
rename to paddle/cinn/operator_fusion/pir_graph_analyzing/dim_relation.h
diff --git a/paddle/cinn/operator_fusion/policy/shardable_axes_base.cc b/paddle/cinn/operator_fusion/pir_graph_analyzing/shardable_axes_base.cc
similarity index 99%
rename from paddle/cinn/operator_fusion/policy/shardable_axes_base.cc
rename to paddle/cinn/operator_fusion/pir_graph_analyzing/shardable_axes_base.cc
index 4192ae43aab6b5..44d42de346ca79 100644
--- a/paddle/cinn/operator_fusion/policy/shardable_axes_base.cc
+++ b/paddle/cinn/operator_fusion/pir_graph_analyzing/shardable_axes_base.cc
@@ -13,7 +13,7 @@
 // limitations under the License.
 
 #pragma once
-#include "paddle/cinn/operator_fusion/policy/shardable_axes_base.h"
+#include "paddle/cinn/operator_fusion/pir_graph_analyzing/shardable_axes_base.h"
 
 namespace cinn::fusion {
 
diff --git a/paddle/cinn/operator_fusion/policy/shardable_axes_base.h b/paddle/cinn/operator_fusion/pir_graph_analyzing/shardable_axes_base.h
similarity index 100%
rename from paddle/cinn/operator_fusion/policy/shardable_axes_base.h
rename to paddle/cinn/operator_fusion/pir_graph_analyzing/shardable_axes_base.h
diff --git a/paddle/cinn/operator_fusion/policy/CMakeLists.txt b/paddle/cinn/operator_fusion/policy/CMakeLists.txt
index 95e290f26ef72b..6b9ca2de0933db 100644
--- a/paddle/cinn/operator_fusion/policy/CMakeLists.txt
+++ b/paddle/cinn/operator_fusion/policy/CMakeLists.txt
@@ -1,2 +1,2 @@
-gather_srcs(policy_fusion_src SRCS shardable_axes_base.cc
-            relative_judge_policy.cc general_topo_policy.cc dim_relation.cc)
+gather_srcs(policy_fusion_src SRCS relative_judge_policy.cc
+            general_topo_policy.cc)
diff --git a/paddle/cinn/operator_fusion/policy/anchor_search_policy.cc b/paddle/cinn/operator_fusion/policy/anchor_search_policy.cc
new file mode 100644
index 00000000000000..b8b095306b7871
--- /dev/null
+++ b/paddle/cinn/operator_fusion/policy/anchor_search_policy.cc
@@ -0,0 +1,15 @@
+// Copyright (c) 2024 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.
+
+#include "paddle/cinn/operator_fusion/policy/anchor_search_policy.h"
diff --git a/paddle/cinn/operator_fusion/policy/anchor_search_policy.h b/paddle/cinn/operator_fusion/policy/anchor_search_policy.h
new file mode 100644
index 00000000000000..30eb476f63a43c
--- /dev/null
+++ b/paddle/cinn/operator_fusion/policy/anchor_search_policy.h
@@ -0,0 +1,34 @@
+// Copyright (c) 2024 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 <functional>
+#include "paddle/cinn/operator_fusion/pattern_node.h"
+#include "paddle/cinn/operator_fusion/policy/policy_base.h"
+#include "paddle/cinn/operator_fusion/utils.h"
+#include "paddle/common/enforce.h"
+
+namespace cinn::fusion {
+
+template <typename T>
+class AnchorSearchPolicy final : : public PolicyBase<T> {
+  static constexpr PolicyKind Kind = PolicyKind::AnchorSearch;
+  bool HasUpstreamAnchor(const PatternNodePtr<T>& upstream,
+                         const PatternNodePtr<T>& downstream);
+  bool HasDownstreamAnchor(const PatternNodePtr<T>& upstream,
+                           const PatternNodePtr<T>& downstream);
+  std::string Name() { return "AnchorSearchPolicy"; }
+};
+
+}  // namespace cinn::fusion
diff --git a/paddle/cinn/operator_fusion/policy/relative_judge_policy.h b/paddle/cinn/operator_fusion/policy/relative_judge_policy.h
index 24ec1bca1e1793..d01fbe37a38853 100644
--- a/paddle/cinn/operator_fusion/policy/relative_judge_policy.h
+++ b/paddle/cinn/operator_fusion/policy/relative_judge_policy.h
@@ -15,9 +15,9 @@
 #pragma once
 #include <functional>
 #include "paddle/cinn/operator_fusion/pattern_node.h"
-#include "paddle/cinn/operator_fusion/policy/dim_relation.h"
+#include "paddle/cinn/operator_fusion/pir_graph_analyzing/dim_relation.h"
+#include "paddle/cinn/operator_fusion/pir_graph_analyzing/shardable_axes_base.h"
 #include "paddle/cinn/operator_fusion/policy/policy_base.h"
-#include "paddle/cinn/operator_fusion/policy/shardable_axes_base.h"
 #include "paddle/cinn/operator_fusion/utils.h"
 #include "paddle/common/enforce.h"
 

From 7d2e6868b4351d7a79eab86437d2b61bd03d985b Mon Sep 17 00:00:00 2001
From: zhangbaizhou <zhangbaizhou@baidu.com>
Date: Fri, 26 Apr 2024 06:35:27 +0000
Subject: [PATCH 15/99] add reverse topo search algorithm for op fusion

---
 .../graph_transformer/search_algorithm.h      | 67 ++++++++++++++++++-
 1 file changed, 64 insertions(+), 3 deletions(-)

diff --git a/paddle/cinn/operator_fusion/graph_transformer/search_algorithm.h b/paddle/cinn/operator_fusion/graph_transformer/search_algorithm.h
index dd424ca4245be5..db15ce8aa9ba00 100644
--- a/paddle/cinn/operator_fusion/graph_transformer/search_algorithm.h
+++ b/paddle/cinn/operator_fusion/graph_transformer/search_algorithm.h
@@ -103,9 +103,70 @@ struct SearchAlgorithm<ReverseTopoNodePairPattern,
                        Phrase,
                        GraphMatcher,
                        GraphOperation> {
-  // TODO(@wuzhanfei)
-  explicit SearchAlgorithm(PatternGraph<Phrase>* graph) {}
-  void operator()() {}
+  PatternGraph<Phrase>* graph_;
+  std::queue<PatternNodePtr<Phrase>> reverse_topo_nodes;
+
+  explicit SearchAlgorithm(PatternGraph<Phrase>* graph) {
+    VLOG(4) << "Create ReverseTopoNodePairPattern algorithm.";
+    graph_ = graph;
+
+    // Do reverse topological sort, and store the results in reverse_topo_nodes.
+    std::unordered_map<PatternNodePtr<Phrase>, int>
+        unvisited_nodes_to_out_degree;
+    for (const auto& node_ptr : graph->all_pattern_nodes()) {
+      unvisited_nodes_to_out_degree[node_ptr] = node_ptr->downstream().size();
+    }
+
+    while (!unvisited_nodes_to_out_degree.empty()) {
+      const auto& it =
+          std::find_if(unvisited_nodes_to_out_degree.begin(),
+                       unvisited_nodes_to_out_degree.end(),
+                       [&](const auto& pair) { return pair.second == 0; });
+      reverse_topo_nodes.push(it->first);
+      for (const auto& upstream : it->first->upstream()) {
+        --unvisited_nodes_to_out_degree[upstream];
+      }
+      unvisited_nodes_to_out_degree.erase(it);
+    }
+  }
+
+  std::optional<std::pair<PatternNodePtr<Phrase>, PatternNodePtr<Phrase>>>
+  FindMatchedPair() {
+    //  Keep picking the front element of reverse_topo_nodes as candidate of
+    //  upstream node. Please make sure that the downstream node is merged into
+    //  the upstream node during merging, and the upstream node will not
+    //  disappear after merging, else the logic here should be modified.
+    while (!reverse_topo_nodes.empty()) {
+      const auto& upstream_candidate = reverse_topo_nodes.front();
+
+      // If the node has downstream, try searching for its candidate downstream
+      // using GraphMatcher.
+      if (!upstream_candidate->downstream().empty()) {
+        for (const auto& downstream_candidate :
+             upstream_candidate->downstream()) {
+          if (GraphMatcher()(
+                  *graph_, upstream_candidate, downstream_candidate)) {
+            VLOG(4) << "Find Matched Node Pair: (" << upstream_candidate << ", "
+                    << downstream_candidate << ")";
+            return std::make_pair(upstream_candidate, downstream_candidate);
+          }
+        }
+      }
+      reverse_topo_nodes.pop();
+    }
+
+    VLOG(4) << "Can't find matched node any more.";
+    return {};
+  }
+
+  void operator()() {
+    while (true) {
+      const auto& node = FindMatchedPair();
+      if (!node.has_value()) break;
+      const auto& [upstream, downstream] = node.value();
+      GraphOperation()(graph_, upstream, downstream);
+    }
+  }
 };
 
 template <typename Kind,

From 2a98eea476f583bc40286a55970df7c75eeafd83 Mon Sep 17 00:00:00 2001
From: xiongkun <xiongkun03@baidu.com>
Date: Fri, 26 Apr 2024 11:22:11 +0000
Subject: [PATCH 16/99] horizontal support dynamic shape and enhance fusion
 ability

---
 .../transforms/cinn_group_cluster_pass.cc     |   3 +
 .../lowering_pass/broadcast_with_cf.cc        |  10 ++
 paddle/cinn/operator_fusion/backend/pattern.h |   5 +-
 .../operator_fusion/backend/pattern_fuser.cc  |   6 +-
 .../cinn/operator_fusion/frontend/pattern.h   |   7 +-
 .../operator_fusion/frontend/pattern_fuser.cc |   4 +-
 paddle/cinn/operator_fusion/pattern_fuser.h   |  83 ++++++++++++
 paddle/cinn/operator_fusion/pattern_graph.h   |  20 ++-
 .../policy/relative_judge_policy.h            |  76 -----------
 paddle/cinn/operator_fusion/utils.h           | 123 ++++++++++++++++++
 10 files changed, 241 insertions(+), 96 deletions(-)

diff --git a/paddle/cinn/hlir/dialect/operator/transforms/cinn_group_cluster_pass.cc b/paddle/cinn/hlir/dialect/operator/transforms/cinn_group_cluster_pass.cc
index 0ab46ce44f4f1c..d26df065d95730 100644
--- a/paddle/cinn/hlir/dialect/operator/transforms/cinn_group_cluster_pass.cc
+++ b/paddle/cinn/hlir/dialect/operator/transforms/cinn_group_cluster_pass.cc
@@ -394,6 +394,9 @@ class CinnGroupClusterPass : public pir::PatternRewritePass {
   }
 
   bool CanApplyOn(pir::Operation* op) const override {
+    if (op->isa<cinn::dialect::FusionOp>()) {
+      return false;
+    }
     return op->num_regions() > 0;
   }
 };
diff --git a/paddle/cinn/hlir/dialect/operator/transforms/lowering_pass/broadcast_with_cf.cc b/paddle/cinn/hlir/dialect/operator/transforms/lowering_pass/broadcast_with_cf.cc
index 22917b41d5b1c5..78e30be0a055eb 100644
--- a/paddle/cinn/hlir/dialect/operator/transforms/lowering_pass/broadcast_with_cf.cc
+++ b/paddle/cinn/hlir/dialect/operator/transforms/lowering_pass/broadcast_with_cf.cc
@@ -298,6 +298,16 @@ void SetLeafBlockByGroupView(
                         value_dim_exprs_list,
                         value_to_dim_expr_idx);
 
+  // We should update the GlobalShapeAnalysisCache after the group is cloned.
+  for (const auto& op : new_group->ops()) {
+    for (const auto& v : op->results()) {
+      auto* shape_analysis =
+          &pir::ShapeAnalysisManager::Instance().Get(op->GetParentProgram());
+      shape_analysis->SetShapeOrDataForValue(v,
+                                             new_group->GetShapeOrDataExprs(v));
+    }
+  }
+
   // Insert YieldOp for outputs
   std::vector<pir::Value> outputs;
   builder.SetInsertionPointToBlockEnd(block);
diff --git a/paddle/cinn/operator_fusion/backend/pattern.h b/paddle/cinn/operator_fusion/backend/pattern.h
index 7006fb02b829e4..405dfbed9e6c41 100644
--- a/paddle/cinn/operator_fusion/backend/pattern.h
+++ b/paddle/cinn/operator_fusion/backend/pattern.h
@@ -39,12 +39,15 @@ using FusionOp = std::variant<ReduceOp, TrivialOp>;
 template <>
 struct TrivialPattern<BackendStage> {
   explicit TrivialPattern(const std::vector<pir::Operation*>& ops,
+                          pir::Operation* sink_op,
                           const TrivialOp& op)
-      : ops_(ops), trivial_op(op) {}
+      : ops_(ops), sink_op(sink_op), trivial_op(op) {}
   std::vector<pir::Operation*> ops_;
+  pir::Operation* sink_op;
   TrivialOp trivial_op;
   static std::string name() { return "Trivial"; }
   std::vector<pir::Operation*> ops() const { return ops_; }
+  pir::Operation* sink() const { return sink_op; }
 };
 
 template <>
diff --git a/paddle/cinn/operator_fusion/backend/pattern_fuser.cc b/paddle/cinn/operator_fusion/backend/pattern_fuser.cc
index 61e8fd658f94a6..a99fd32e573720 100644
--- a/paddle/cinn/operator_fusion/backend/pattern_fuser.cc
+++ b/paddle/cinn/operator_fusion/backend/pattern_fuser.cc
@@ -34,8 +34,8 @@ StmtPattern<BackendStage> ConvertToStmtPattern(
              kind == hlir::framework::kBroadcast ||
              kind == hlir::framework::kInjective) {
     CHECK(content.expr.has_value());
-    return TrivialPattern<BackendStage>({content.op},
-                                        TrivialOp(content.expr.value()));
+    return TrivialPattern<BackendStage>(
+        {content.op}, content.op, TrivialOp(content.expr.value()));
   } else {
     CHECK(false);
     return UnsupportPattern<BackendStage>({content.op});
@@ -74,7 +74,7 @@ StmtPattern<BackendStage> MergePatternImpl(
   const auto& trivial_op =
       cinn::hlir::framework::pir::trivial_fusion_detail::TrivalxOther_Fusion(
           first.trivial_op, second.trivial_op);
-  return TrivialPattern<BackendStage>(ops, trivial_op);
+  return TrivialPattern<BackendStage>(ops, second.sink(), trivial_op);
 }
 
 template <>
diff --git a/paddle/cinn/operator_fusion/frontend/pattern.h b/paddle/cinn/operator_fusion/frontend/pattern.h
index e267483e56586d..61b225deeefc56 100644
--- a/paddle/cinn/operator_fusion/frontend/pattern.h
+++ b/paddle/cinn/operator_fusion/frontend/pattern.h
@@ -47,11 +47,14 @@ struct hash<cinn::fusion::FrontendContent> {
 namespace cinn::fusion {
 template <>
 struct TrivialPattern<FrontendStage> {
-  explicit TrivialPattern(const std::vector<pir::Operation*>& ops)
-      : ops_(ops) {}
+  explicit TrivialPattern(const std::vector<pir::Operation*>& ops,
+                          pir::Operation* sink_op)
+      : ops_(ops), sink_op(sink_op) {}
   std::vector<pir::Operation*> ops_;
+  pir::Operation* sink_op;
   static std::string name() { return "Trivial"; }
   std::vector<pir::Operation*> ops() const { return ops_; }
+  pir::Operation* sink() const { return sink_op; }
 };
 
 template <>
diff --git a/paddle/cinn/operator_fusion/frontend/pattern_fuser.cc b/paddle/cinn/operator_fusion/frontend/pattern_fuser.cc
index 332230f4099791..a956220baae182 100644
--- a/paddle/cinn/operator_fusion/frontend/pattern_fuser.cc
+++ b/paddle/cinn/operator_fusion/frontend/pattern_fuser.cc
@@ -28,7 +28,7 @@ StmtPattern<FrontendStage> ConvertToStmtPattern(
   } else if (kind == hlir::framework::kElementWise ||
              kind == hlir::framework::kBroadcast ||
              kind == hlir::framework::kInjective) {
-    return TrivialPattern<FrontendStage>({content.op});
+    return TrivialPattern<FrontendStage>({content.op}, content.op);
   } else {
     return UnsupportPattern<FrontendStage>({content.op});
   }
@@ -58,7 +58,7 @@ StmtPattern<FrontendStage> MergePatternImpl(
   const auto& contents =
       UniqueConcatVector(GetOpsInPattern<FrontendStage>(first),
                          GetOpsInPattern<FrontendStage>(second));
-  return TrivialPattern<FrontendStage>(contents);
+  return TrivialPattern<FrontendStage>(contents, second.sink());
 }
 
 template <>
diff --git a/paddle/cinn/operator_fusion/pattern_fuser.h b/paddle/cinn/operator_fusion/pattern_fuser.h
index 802031b6b23045..a8d4da6935c4a5 100644
--- a/paddle/cinn/operator_fusion/pattern_fuser.h
+++ b/paddle/cinn/operator_fusion/pattern_fuser.h
@@ -55,6 +55,89 @@ std::vector<pir::Operation*> GetOpsInPattern(const StmtPattern<T>& pattern) {
                     pattern.variant());
 }
 
+using LoopFramework = std::vector<symbol::DimExpr>;
+
+// std::optional({}) means not sure.
+// std::optional will cause SegmentFault, TODO: fix this.
+using MaybeLoopFramework = LoopFramework;
+
+template <typename T>
+MaybeLoopFramework GetLoopFramework(const StmtPattern<T>& pattern);
+
+template <typename T>
+struct LoopFrameworkVisitor {
+  MaybeLoopFramework operator()(const ReducePattern<T>& pattern) {
+    pir::Operation* reduce_op = pattern.GetReduceOp();
+    const auto& flatten_loops = GetDimExprsFromValue(reduce_op->result(0));
+    const auto& reduce_axes = GetReduceAxisIdx(reduce_op);
+    const auto& reduce_loops = GatherVector(
+        GetDimExprsFromValue(reduce_op->operand(0).source()), reduce_axes);
+    return ConcatVector(flatten_loops, reduce_loops);
+  }
+
+  MaybeLoopFramework operator()(const ReduceTreePattern<T>& pattern) {
+    return GetLoopFramework(StmtPattern<T>(pattern.GetRootPattern()));
+  }
+
+  MaybeLoopFramework operator()(const TrivialPattern<T>& pattern) {
+    pir::Operation* t_op = pattern.sink();
+    const auto& dims = GetDimExprsFromValue(t_op->result(0));
+    const auto& exprs = GetDimExprsFromValue(t_op->result(0));
+    return exprs;
+  }
+
+  MaybeLoopFramework operator()(const HorizontalFusionPattern<T>& pattern) {
+    // Horizontal Fusion must have the same loop framework.
+    const auto& exprs =
+        GetLoopFramework(StmtPattern<T>(pattern.patterns_.back()));
+    return exprs;
+  }
+
+  MaybeLoopFramework operator()(
+      const ReduceTreePlusTrivialPattern<T>& pattern) {
+    const auto& sink_trivial = pattern.sink_trivial;
+    const auto& trivial_loop =
+        GetLoopFramework(StmtPattern<T>(pattern.sink_trivial));
+    if (pattern.fake_reduce_iter_idx.empty()) {
+      // we add reduce loop to the end;
+      int reduce_axes_len =
+          GetReduceAxisIdx(pattern.tree.GetRootPattern().GetReduceOp()).size();
+      const auto& reduce_loop =
+          GetLoopFramework(StmtPattern<T>(pattern.tree.GetRootPattern()));
+      return ConcatVector(
+          trivial_loop,
+          SliceVector(reduce_loop, -reduce_axes_len, reduce_loop.size()));
+    } else {
+      // we always put fake into the end to make the loop framework consistent.
+      const auto& non_fake = GatherVector(
+          trivial_loop,
+          ExcludeIndex(trivial_loop.size(), pattern.fake_reduce_iter_idx));
+      const auto& fake =
+          GatherVector(trivial_loop, pattern.fake_reduce_iter_idx);
+      return ConcatVector(non_fake, fake);
+    }
+  }
+
+  MaybeLoopFramework operator()(const UnsupportPattern<T>& pattern) {
+    PADDLE_ENFORCE(false, "Not support GetLoopRange.");
+  }
+};
+
+template <typename T>
+MaybeLoopFramework GetLoopFramework(const StmtPattern<T>& pattern) {
+  return std::visit(LoopFrameworkVisitor<T>(), pattern.variant());
+}
+
+template <typename T>
+bool IsLoopFrameworkEqual(const StmtPattern<T>& lhs,
+                          const StmtPattern<T>& rhs) {
+  auto lhs_loop = GetLoopFramework(lhs);
+  auto rhs_loop = GetLoopFramework(rhs);
+  VLOG(4) << "lhs loop range is:" << utils::Join(lhs_loop, ",");
+  VLOG(4) << "rhs loop range is:" << utils::Join(rhs_loop, ",");
+  return lhs_loop == rhs_loop;
+}
+
 template <typename T>
 bool IsReducePattern(const StmtPattern<T>& pattern) {
   return std::holds_alternative<ReducePattern<T>>(pattern);
diff --git a/paddle/cinn/operator_fusion/pattern_graph.h b/paddle/cinn/operator_fusion/pattern_graph.h
index e6ba1342623491..eeb7d34df3b8d5 100644
--- a/paddle/cinn/operator_fusion/pattern_graph.h
+++ b/paddle/cinn/operator_fusion/pattern_graph.h
@@ -333,18 +333,14 @@ struct HorizontalFusionConstrain {
     if (!StmtPatternGraphMatcher<HorizontalFusionPattern<T>>()(graph, second)) {
       return false;
     }
-    const auto& first_dim = first->sink_op()
-                                ->result(0)
-                                .type()
-                                .template dyn_cast<pir::DenseTensorType>()
-                                .dims();
-    const auto& second_dim = second->sink_op()
-                                 ->result(0)
-                                 .type()
-                                 .template dyn_cast<pir::DenseTensorType>()
-                                 .dims();
-    return graph.topo_manager().CanFuse(first, second) &&
-           first_dim == second_dim;
+    const auto& lhs_pattern =
+        std::get<HorizontalFusionPattern<T>>(lhs->stmt_pattern());
+    const auto& rhs_pattern =
+        std::get<HorizontalFusionPattern<T>>(rhs->stmt_pattern());
+
+    return graph.topo_manager().CanFuse(lhs, rhs) &&
+           IsLoopFrameworkEqual(lhs_pattern.patterns_.back(),
+                                rhs_pattern.patterns_.back());
   }
 };
 
diff --git a/paddle/cinn/operator_fusion/policy/relative_judge_policy.h b/paddle/cinn/operator_fusion/policy/relative_judge_policy.h
index f7f3a5f7786594..ae2f4181920eb2 100644
--- a/paddle/cinn/operator_fusion/policy/relative_judge_policy.h
+++ b/paddle/cinn/operator_fusion/policy/relative_judge_policy.h
@@ -21,86 +21,10 @@
 
 namespace cinn::fusion {
 
-struct ValueDim {
-  pir::Value v_;
-  size_t idx_;
-  std::weak_ptr<pir::ShapeConstraintIRAnalysis> shape_analysis_;
-  ValueDim(pir::Value v, size_t idx) : v_(v), idx_(idx) {
-    // Just get a related op to get the shape analysis. It can be value's
-    // upstream op (defining op) or downstream op (user op).
-    const auto get_related_op_from_value =
-        [](const pir::Value& v) -> pir::Operation* {
-      if (v.defining_op() != nullptr) {
-        return v.defining_op();
-      }
-      // For inputs of the program, the defining_op is nullptr, we use it's user
-      // as the related op.
-      PADDLE_ENFORCE_EQ(v.use_empty(),
-                        false,
-                        phi::errors::PreconditionNotMet(
-                            "Value is an input value, it should have a use."));
-      return v.first_use().owner();
-    };
-    shape_analysis_ = pir::ShapeAnalysisManager::Instance()
-                          .Get(get_related_op_from_value(v)->GetParentProgram())
-                          .shared_from_this();
-  }
-  ValueDim() = default;
-  ValueDim(const ValueDim& v) = default;
-  bool operator==(const ValueDim& v) const {
-    return (idx_ == v.idx_) && (v_ == v.v_);
-  }
-
-  symbol::DimExpr GetSymbolicDim() const {
-    return shape_analysis().GetProductDimExpr(v_, {static_cast<int>(idx_)});
-  }
-
-  bool SymbolicEqualTo(const ValueDim& other) const {
-    return shape_analysis().IsEqual(GetSymbolicDim(), other.GetSymbolicDim());
-  }
-
-  std::string DebugStr() const {
-    std::ostringstream oss;
-    oss << "ValueDim: ";
-    oss << "Index: " << idx_;
-    oss << ", ";
-    v_.defining_op()->Print(oss);
-    return oss.str();
-  }
-
-  pir::ShapeConstraintIRAnalysis& shape_analysis() const {
-    auto shape_analysis_ptr = shape_analysis_.lock();
-    PADDLE_ENFORCE_NOT_NULL(
-        shape_analysis_ptr,
-        phi::errors::PreconditionNotMet("shape_analysis_ptr is nullptr."));
-    return *shape_analysis_ptr;
-  }
-};
-
-struct ValueDimHash {
-  std::size_t operator()(const ValueDim& p) const {
-    auto h1 = std::hash<size_t>{}(p.idx_);
-    auto h2 = std::hash<pir::Value>{}(p.v_);
-    // Mainly for demonstration purposes, i.e. works but is overly simple
-    // In the real world, use sth. like boost.hash_combine
-    return h1 ^ (h2 << 1);
-  }
-};
-
 using ValueDimRelation =
     std::unordered_map<ValueDim,
                        std::unordered_map<ValueDim, bool, ValueDimHash>,
                        ValueDimHash>;
-// ValueDimRelation[in][out] = True; means f(out) = in is related.
-
-static std::vector<ValueDim> GetAllValueDimFromValue(const pir::Value& v) {
-  std::vector<ValueDim> value_dims;
-  size_t rank = GetRank(v);
-  for (size_t i = 0; i < rank; ++i) {
-    value_dims.emplace_back(v, i);
-  }
-  return value_dims;
-}
 
 static std::vector<ValueDim> GetAllInputValueDim(pir::Operation* op) {
   std::vector<ValueDim> value_dims;
diff --git a/paddle/cinn/operator_fusion/utils.h b/paddle/cinn/operator_fusion/utils.h
index 5cad91e2c98fe0..7431d2aa5b4e88 100644
--- a/paddle/cinn/operator_fusion/utils.h
+++ b/paddle/cinn/operator_fusion/utils.h
@@ -187,4 +187,127 @@ std::vector<T> UniqueConcatVector(const std::vector<T>& first,
   return result;
 }
 
+struct ValueDim {
+  pir::Value v_;
+  size_t idx_;
+  std::weak_ptr<pir::ShapeConstraintIRAnalysis> shape_analysis_;
+  ValueDim(pir::Value v, size_t idx) : v_(v), idx_(idx) {
+    // Just get a related op to get the shape analysis. It can be value's
+    // upstream op (defining op) or downstream op (user op).
+    const auto get_related_op_from_value =
+        [](const pir::Value& v) -> pir::Operation* {
+      if (v.defining_op() != nullptr) {
+        return v.defining_op();
+      }
+      // For inputs of the program, the defining_op is nullptr, we use it's user
+      // as the related op.
+      PADDLE_ENFORCE_EQ(v.use_empty(),
+                        false,
+                        phi::errors::PreconditionNotMet(
+                            "Value is an input value, it should have a use."));
+      return v.first_use().owner();
+    };
+    shape_analysis_ = pir::ShapeAnalysisManager::Instance()
+                          .Get(get_related_op_from_value(v)->GetParentProgram())
+                          .shared_from_this();
+  }
+  ValueDim() = default;
+  ValueDim(const ValueDim& v) = default;
+  bool operator==(const ValueDim& v) const {
+    return (idx_ == v.idx_) && (v_ == v.v_);
+  }
+
+  symbol::DimExpr GetSymbolicDim() const {
+    return shape_analysis().GetProductDimExpr(v_, {static_cast<int>(idx_)});
+  }
+
+  bool SymbolicEqualTo(const ValueDim& other) const {
+    return shape_analysis().IsEqual(GetSymbolicDim(), other.GetSymbolicDim());
+  }
+
+  std::string DebugStr() const {
+    std::ostringstream oss;
+    oss << "ValueDim: ";
+    oss << "Index: " << idx_;
+    oss << ", ";
+    v_.defining_op()->Print(oss);
+    return oss.str();
+  }
+
+  pir::ShapeConstraintIRAnalysis& shape_analysis() const {
+    auto shape_analysis_ptr = shape_analysis_.lock();
+    PADDLE_ENFORCE_NOT_NULL(
+        shape_analysis_ptr,
+        phi::errors::PreconditionNotMet("shape_analysis_ptr is nullptr."));
+    return *shape_analysis_ptr;
+  }
+};
+
+static std::vector<ValueDim> GetAllValueDimFromValue(const pir::Value& v) {
+  std::vector<ValueDim> value_dims;
+  size_t rank = GetRank(v);
+  for (size_t i = 0; i < rank; ++i) {
+    value_dims.emplace_back(v, i);
+  }
+  return value_dims;
+}
+
+struct ValueDimHash {
+  std::size_t operator()(const ValueDim& p) const {
+    auto h1 = std::hash<size_t>{}(p.idx_);
+    auto h2 = std::hash<pir::Value>{}(p.v_);
+    // Mainly for demonstration purposes, i.e. works but is overly simple
+    // In the real world, use sth. like boost.hash_combine
+    return h1 ^ (h2 << 1);
+  }
+};
+
+static std::vector<symbol::DimExpr> GetDimExprsFromValue(pir::Value value) {
+  const auto& value_dims = GetAllValueDimFromValue(value);
+  VLOG(4) << "Start Print:";
+  std::function<symbol::DimExpr(ValueDim)> func =
+      [](const ValueDim& value_dim) {
+        const auto& symbolic_dim = value_dim.GetSymbolicDim();
+        VLOG(4) << symbolic_dim;
+        return symbolic_dim;
+      };
+  return MapVector(value_dims, func);
+}
+
+template <typename T, typename Int>
+std::vector<T> GatherVector(const std::vector<T>& inp,
+                            std::vector<Int> gathers) {
+  std::vector<T> result;
+  for (auto i : gathers) {
+    result.push_back(inp[i]);
+  }
+  return result;
+}
+
+template <typename Int>
+std::vector<Int> ExcludeIndex(int n, std::vector<Int> excludes) {
+  std::vector<Int> result;
+  for (int i = 0; i < n; ++i) {
+    if (std::find(excludes.begin(), excludes.end(), i) == excludes.end()) {
+      result.push_back(i);
+    }
+  }
+  return result;
+}
+
+template <typename T>
+std::vector<T> SliceVector(const std::vector<T>& inp, int start, int end) {
+  if (start < 0) {
+    start = inp.size() + start;
+  }
+  if (end < 0) {
+    end = inp.size() + end;
+  }
+  std::vector<T> result;
+  for (int i = start; i < end; ++i) {
+    result.push_back(inp[i]);
+  }
+  return result;
+}
+
 }  // namespace cinn::fusion

From c30917a08a78a79ffdf08ddba113f16b84a2e670 Mon Sep 17 00:00:00 2001
From: xiongkun <xiongkun03@baidu.com>
Date: Sat, 27 Apr 2024 14:09:47 +0000
Subject: [PATCH 17/99] fix

---
 paddle/cinn/operator_fusion/pattern_graph.h | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/paddle/cinn/operator_fusion/pattern_graph.h b/paddle/cinn/operator_fusion/pattern_graph.h
index eeb7d34df3b8d5..792c780bc25cef 100644
--- a/paddle/cinn/operator_fusion/pattern_graph.h
+++ b/paddle/cinn/operator_fusion/pattern_graph.h
@@ -334,11 +334,11 @@ struct HorizontalFusionConstrain {
       return false;
     }
     const auto& lhs_pattern =
-        std::get<HorizontalFusionPattern<T>>(lhs->stmt_pattern());
+        std::get<HorizontalFusionPattern<T>>(first->stmt_pattern());
     const auto& rhs_pattern =
-        std::get<HorizontalFusionPattern<T>>(rhs->stmt_pattern());
+        std::get<HorizontalFusionPattern<T>>(second->stmt_pattern());
 
-    return graph.topo_manager().CanFuse(lhs, rhs) &&
+    return graph.topo_manager().CanFuse(first, second) &&
            IsLoopFrameworkEqual(lhs_pattern.patterns_.back(),
                                 rhs_pattern.patterns_.back());
   }
@@ -410,4 +410,4 @@ void GraphTransformer(PatternGraph<Phrase>* graph) {
   alog();
 }
 
-}  // namespace cinn::fusion
+}  // namespace cinn::fusion
\ No newline at end of file

From 3a5ff20e46a96a198083c2f0029be44521413f12 Mon Sep 17 00:00:00 2001
From: xiongkun <xiongkun03@baidu.com>
Date: Sun, 28 Apr 2024 03:06:19 +0000
Subject: [PATCH 18/99] xx

---
 third_party/pybind | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/third_party/pybind b/third_party/pybind
index 0bd8896a4010f2..3e9dfa28669416 160000
--- a/third_party/pybind
+++ b/third_party/pybind
@@ -1 +1 @@
-Subproject commit 0bd8896a4010f2d91b2340570c24fa08606ec406
+Subproject commit 3e9dfa2866941655c56877882565e7577de6fc7b

From 9745be198ad4cdb437123a3376369cebbd07698d Mon Sep 17 00:00:00 2001
From: zhangbaizhou <zhangbaizhou@baidu.com>
Date: Sun, 28 Apr 2024 03:27:50 +0000
Subject: [PATCH 19/99] move logic of reverse topo sort to pattern_graph.cc

---
 .../graph_transformer/search_algorithm.h      | 19 ++-----------
 paddle/cinn/operator_fusion/pattern_graph.cc  | 28 +++++++++++++++++++
 2 files changed, 31 insertions(+), 16 deletions(-)

diff --git a/paddle/cinn/operator_fusion/graph_transformer/search_algorithm.h b/paddle/cinn/operator_fusion/graph_transformer/search_algorithm.h
index db15ce8aa9ba00..354b7fca137bbf 100644
--- a/paddle/cinn/operator_fusion/graph_transformer/search_algorithm.h
+++ b/paddle/cinn/operator_fusion/graph_transformer/search_algorithm.h
@@ -111,22 +111,9 @@ struct SearchAlgorithm<ReverseTopoNodePairPattern,
     graph_ = graph;
 
     // Do reverse topological sort, and store the results in reverse_topo_nodes.
-    std::unordered_map<PatternNodePtr<Phrase>, int>
-        unvisited_nodes_to_out_degree;
-    for (const auto& node_ptr : graph->all_pattern_nodes()) {
-      unvisited_nodes_to_out_degree[node_ptr] = node_ptr->downstream().size();
-    }
-
-    while (!unvisited_nodes_to_out_degree.empty()) {
-      const auto& it =
-          std::find_if(unvisited_nodes_to_out_degree.begin(),
-                       unvisited_nodes_to_out_degree.end(),
-                       [&](const auto& pair) { return pair.second == 0; });
-      reverse_topo_nodes.push(it->first);
-      for (const auto& upstream : it->first->upstream()) {
-        --unvisited_nodes_to_out_degree[upstream];
-      }
-      unvisited_nodes_to_out_degree.erase(it);
+    auto reverse_topo_sort_result = graph->SortByReverseTopoOrder();
+    for (const auto& node : reverse_topo_sort_result) {
+      reverse_topo_nodes.push(node);
     }
   }
 
diff --git a/paddle/cinn/operator_fusion/pattern_graph.cc b/paddle/cinn/operator_fusion/pattern_graph.cc
index bd4bd962b0877c..9bff297462af6b 100644
--- a/paddle/cinn/operator_fusion/pattern_graph.cc
+++ b/paddle/cinn/operator_fusion/pattern_graph.cc
@@ -98,6 +98,34 @@ std::vector<PatternNodePtr<T>> PatternGraph<T>::SortByTopoOrder() {
   return res;
 }
 
+template <typename T>
+std::vector<PatternNodePtr<T>> PatternGraph<T>::SortByReverseTopoOrder() {
+  // sort all_pattern_nodes_ by reverse topo order.
+  std::vector<PatternNodePtr<T>> res;
+  std::list<PatternNodePtr<T>> reverse_topo_queue;
+  std::map<PatternNodePtr<T>, int> degree;
+
+  for (const auto& node : all_pattern_nodes_) {
+    degree[node] = node->downstream().size();
+    if (degree[node] == 0) {
+      reverse_topo_queue.push_back(node);
+    }
+  }
+
+  while (!reverse_topo_queue.empty()) {
+    PatternNodePtr<T> node = reverse_topo_queue.front();
+    reverse_topo_queue.pop_front();
+    res.push_back(node);
+    for (const auto& upstream : node->upstream()) {
+      degree[upstream]--;
+      if (degree[upstream] == 0) {
+        reverse_topo_queue.push_back(upstream);
+      }
+    }
+  }
+  return res;
+}
+
 template <typename T>
 void PatternGraph<T>::SinkTrivialPattern() {
   // TODO(@wuzhanfei) change sink trivial pattern algorithm, skip pattern with

From 303a7669c151be7400b73807b255d9e9e8699c98 Mon Sep 17 00:00:00 2001
From: xiongkun <xiongkun03@baidu.com>
Date: Sun, 28 Apr 2024 07:40:09 +0000
Subject: [PATCH 20/99] fix some bugs

---
 .../hlir/framework/pir/trivial_op_util.cc     |  2 +-
 paddle/cinn/operator_fusion/pattern_graph.cc  |  6 +++++-
 paddle/cinn/operator_fusion/pattern_graph.h   | 19 +++++++++++++++----
 .../operator_fusion/policy/dim_relation.h     |  6 +++++-
 4 files changed, 26 insertions(+), 7 deletions(-)

diff --git a/paddle/cinn/hlir/framework/pir/trivial_op_util.cc b/paddle/cinn/hlir/framework/pir/trivial_op_util.cc
index 17443d39fae254..cc7fab0a7c6af8 100644
--- a/paddle/cinn/hlir/framework/pir/trivial_op_util.cc
+++ b/paddle/cinn/hlir/framework/pir/trivial_op_util.cc
@@ -301,7 +301,7 @@ ExprSetFinder ChildTensorLoads = Collector(
 
 ExprSetFinder ChildTensorStores = Collector(
     [](const ir::Expr* e) {
-      return e->As<ir::Load>() && e->As<ir::Store>()->is_addr_tensor();
+      return e->As<ir::Store>() && e->As<ir::Store>()->is_addr_tensor();
     },
     "ChildTensorStores");
 
diff --git a/paddle/cinn/operator_fusion/pattern_graph.cc b/paddle/cinn/operator_fusion/pattern_graph.cc
index a8ab68cf809b36..cf5e7e4888b64e 100644
--- a/paddle/cinn/operator_fusion/pattern_graph.cc
+++ b/paddle/cinn/operator_fusion/pattern_graph.cc
@@ -101,7 +101,10 @@ template <typename T>
 void PatternGraph<T>::HorizontalFusion() {
   GraphTransformer<NodePattern,
                    T,
-                   StmtPatternGraphMatcher<TrivialPattern<T>>,
+                   Or<StmtPatternGraphMatcher<TrivialPattern<T>>,
+                      StmtPatternGraphMatcher<ReduceTreePlusTrivialPattern<T>>,
+                      StmtPatternGraphMatcher<ReducePattern<T>>,
+                      StmtPatternGraphMatcher<ReduceTreePattern<T>>>,
                    LiftToHorizontalFusionPatternOperation>(this);
 
   GraphTransformer<NodePairPattern,
@@ -213,6 +216,7 @@ std::string PatternGraph<T>::GraphInfo() const {
   for (const auto& v : all_pattern_nodes_) {
     ss << "\n" << v->DebugStr();
     ss << "\n    IsOutput: " << IsOutputNodeMatcher()(*this, v);
+    ss << "\n    Loop Framework is: " << GetLoopFramework(v->stmt_pattern());
   }
   ss << "\n===============================";
   return ss.str();
diff --git a/paddle/cinn/operator_fusion/pattern_graph.h b/paddle/cinn/operator_fusion/pattern_graph.h
index 792c780bc25cef..1e4d0d7991f552 100644
--- a/paddle/cinn/operator_fusion/pattern_graph.h
+++ b/paddle/cinn/operator_fusion/pattern_graph.h
@@ -383,11 +383,22 @@ struct And {
   }
 };
 
-template <typename A, typename B>
-struct Or {
+template <typename... Args>
+struct Or {};
+
+template <typename A>
+struct Or<A> {
+  template <typename T>
+  bool operator()(const PatternGraph<T>& graph, const PatternNodePtr<T>& node) {
+    return A()(graph, node);
+  }
+};
+
+template <typename A, typename... Args>
+struct Or<A, Args...> {
   template <typename T>
   bool operator()(const PatternGraph<T>& graph, const PatternNodePtr<T>& node) {
-    return A()(graph, node) || B()(graph, node);
+    return A()(graph, node) || Or<Args...>()(graph, node);
   }
 };
 
@@ -410,4 +421,4 @@ void GraphTransformer(PatternGraph<Phrase>* graph) {
   alog();
 }
 
-}  // namespace cinn::fusion
\ No newline at end of file
+}  // namespace cinn::fusion
diff --git a/paddle/cinn/operator_fusion/policy/dim_relation.h b/paddle/cinn/operator_fusion/policy/dim_relation.h
index 02a7036109b1c3..730e9296f913b2 100644
--- a/paddle/cinn/operator_fusion/policy/dim_relation.h
+++ b/paddle/cinn/operator_fusion/policy/dim_relation.h
@@ -73,7 +73,11 @@ struct DimUsage {
     oss << ", Index: " << idx_;
     oss << ", UsageIdx: " << usage_idx_;
     oss << ", ";
-    v_.defining_op()->Print(oss);
+    if (v_.defining_op()) {
+      v_.defining_op()->Print(oss);
+    } else {
+      oss << "No defining op.";
+    }
     return oss.str();
   }
 };

From 3b7490815a335708e2ba36ede33db469490fb8c9 Mon Sep 17 00:00:00 2001
From: feifei-111 <2364819892@qq.com>
Date: Sun, 28 Apr 2024 07:52:46 +0000
Subject: [PATCH 21/99] update

---
 paddle/cinn/operator_fusion/backend/pattern.h | 25 ++++------
 .../cinn/operator_fusion/frontend/pattern.h   | 22 +++------
 paddle/cinn/operator_fusion/pattern.h         | 20 ++++++--
 .../pir_graph_analyzing/anchor_transform.cc   |  4 ++
 .../pir_graph_analyzing/anchor_transform.h    | 46 +++++++++++++++++++
 .../policy/anchor_search_policy.cc            | 20 ++++++++
 .../policy/anchor_search_policy.h             |  1 +
 .../policy/general_topo_policy.cc             |  2 -
 8 files changed, 103 insertions(+), 37 deletions(-)

diff --git a/paddle/cinn/operator_fusion/backend/pattern.h b/paddle/cinn/operator_fusion/backend/pattern.h
index e34c31be68cdca..c6a19b8e8d8e33 100644
--- a/paddle/cinn/operator_fusion/backend/pattern.h
+++ b/paddle/cinn/operator_fusion/backend/pattern.h
@@ -17,6 +17,7 @@
 #include "paddle/cinn/ir/ir_base.h"
 #include "paddle/cinn/operator_fusion/pattern.h"
 #include "paddle/cinn/operator_fusion/pattern_fuser.h"
+#include "paddle/cinn/operator_fusion/pir_graph_analyzing/anchor_transform.h"
 #include "paddle/cinn/operator_fusion/utils.h"
 
 namespace cinn::fusion {
@@ -68,23 +69,6 @@ struct UnsupportPattern<BackendStage> {
   static std::string name() { return "Unsupport"; }
 };
 
-template <>
-struct AnchorPattern<BackendStage> {
-  explicit AnchorPattern(const std::vector<pir::Operation*>& ops,
-                         const std::vector<pir::Value>& outputs,
-                         const pir::Value& anchor,
-                         const FusionOp& fusion_op)
-      : ops_(ops), outputs_(outputs), anchor_(anchor), fusion_op_(fusion_op) {}
-  std::vector<pir::Operation*> ops_;
-  std::vector<pir::Value> outputs_;
-  pir::Value anchor_;  // Choose only one anchor
-  FusionOp fusion_op_;
-  std::vector<pir::Operation*> ops() const { return ops_; }
-  std::vector<pir::Value> outputs() const { return outputs_; }
-  pir::Value anchor() const { return anchor_; }
-  static std::string name() { return "AnchorPattern"; }
-};
-
 template <>
 struct HorizontalFusionPattern<BackendStage> {
   explicit HorizontalFusionPattern(
@@ -102,4 +86,11 @@ struct HorizontalFusionPattern<BackendStage> {
   static std::string name() { return "HorizontalFusionPattern"; }
 };
 
+template <>
+struct ValueExpr<BackendStage> {
+  AnchorTransformRoute transform_route;
+  pir::Value root_value;
+  FusionOp root_fusion_op;
+};
+
 }  // namespace cinn::fusion
diff --git a/paddle/cinn/operator_fusion/frontend/pattern.h b/paddle/cinn/operator_fusion/frontend/pattern.h
index 59a3298f15e200..cba5f97b67dc47 100644
--- a/paddle/cinn/operator_fusion/frontend/pattern.h
+++ b/paddle/cinn/operator_fusion/frontend/pattern.h
@@ -15,6 +15,7 @@
 #pragma once
 #include "paddle/cinn/operator_fusion/pattern.h"
 #include "paddle/cinn/operator_fusion/pattern_fuser.h"
+#include "paddle/cinn/operator_fusion/pir_graph_analyzing/anchor_transform.h"
 #include "paddle/cinn/operator_fusion/utils.h"
 
 namespace cinn::fusion {
@@ -72,21 +73,6 @@ struct UnsupportPattern<FrontendStage> {
   static std::string name() { return "Unsupport"; }
 };
 
-template <>
-struct AnchorPattern<FrontendStage> {
-  explicit AnchorPattern(const std::vector<pir::Operation*>& ops,
-                         const std::vector<pir::Value>& outputs,
-                         const pir::Value& anchor)
-      : ops_(ops), outputs_(outputs), anchor_(anchor) {}
-  std::vector<pir::Operation*> ops_;
-  std::vector<pir::Value> outputs_;
-  pir::Value anchor_;  // Choose only one anchor
-  std::vector<pir::Operation*> ops() const { return ops_; }
-  std::vector<pir::Value> outputs() const { return outputs_; }
-  pir::Value anchor() const { return anchor_; }
-  static std::string name() { return "AnchorPattern"; }
-};
-
 template <>
 struct HorizontalFusionPattern<FrontendStage> {
   explicit HorizontalFusionPattern(
@@ -104,4 +90,10 @@ struct HorizontalFusionPattern<FrontendStage> {
   static std::string name() { return "HorizontalFusionPattern"; }
 };
 
+template <>
+struct ValueExpr<FrontendStage> {
+  AnchorTransformRoute transform_route;
+  pir::Value root_value;
+};
+
 }  // namespace cinn::fusion
diff --git a/paddle/cinn/operator_fusion/pattern.h b/paddle/cinn/operator_fusion/pattern.h
index b58f1475272632..d08e820f23ed14 100644
--- a/paddle/cinn/operator_fusion/pattern.h
+++ b/paddle/cinn/operator_fusion/pattern.h
@@ -18,6 +18,7 @@
 #include <variant>
 #include <vector>
 #include "glog/logging.h"
+#include "paddle/cinn/operator_fusion/pir_graph_analyzing/anchor_transform.h"
 #include "paddle/cinn/operator_fusion/utils.h"
 #include "paddle/pir/include/core/operation.h"
 
@@ -81,9 +82,6 @@ struct ReduceTreePlusTrivialPattern {
 template <typename T>
 class UnsupportPattern {};
 
-template <typename T>
-struct AnchorPattern {};
-
 template <typename T>
 class HorizontalFusionPattern {};
 
@@ -102,4 +100,20 @@ struct StmtPattern final : public StmtPatternBase<T> {
     return static_cast<const StmtPatternBase<T>&>(*this);
   }
 };
+
+template <typename T>
+struct AnchorPattern {
+  explicit AnchorPattern(
+      const std::vector<pir::Operation*>& ops,
+      const pir::Value& anchor const AnchorState<T>& anchor_state)
+      : ops_(ops), anchor_(anchor), {}
+  std::vector<pir::Operation*> ops_;
+  pir::Value anchor_;  // Choose only one anchor
+  AnchorState<T> anchor_state;
+  std::vector<pir::Operation*> ops() const { return ops_; }
+  std::vector<pir::Value> outputs() const { return outputs_; }
+  pir::Value anchor() const { return anchor_; }
+  static std::string name() { return "AnchorPattern"; }
+};
+
 }  // namespace cinn::fusion
diff --git a/paddle/cinn/operator_fusion/pir_graph_analyzing/anchor_transform.cc b/paddle/cinn/operator_fusion/pir_graph_analyzing/anchor_transform.cc
index 06033922deaf8d..e5c3719bc6a4bf 100644
--- a/paddle/cinn/operator_fusion/pir_graph_analyzing/anchor_transform.cc
+++ b/paddle/cinn/operator_fusion/pir_graph_analyzing/anchor_transform.cc
@@ -13,3 +13,7 @@
 // limitations under the License.
 
 #include "paddle/cinn/operator_fusion/pir_graph_analyzing/anchor_transform.h"
+
+namespace cinn::fusion {
+AnchorTransform CreateAnchorTransform(TransformInfo info) {}
+}  // namespace cinn::fusion
diff --git a/paddle/cinn/operator_fusion/pir_graph_analyzing/anchor_transform.h b/paddle/cinn/operator_fusion/pir_graph_analyzing/anchor_transform.h
index 8f5f6dd8c0d7d2..9f2e2d1827321f 100644
--- a/paddle/cinn/operator_fusion/pir_graph_analyzing/anchor_transform.h
+++ b/paddle/cinn/operator_fusion/pir_graph_analyzing/anchor_transform.h
@@ -13,3 +13,49 @@
 // limitations under the License.
 
 #pragma once
+
+#include <variant>
+#include "paddle/cinn/operator_fusion/utils.h"
+
+namespace cinn::fusion {
+struct TransformInfo {
+  pir::Operation* op;
+  size_t input_idx;
+  size_t output_idx;
+  bool is_upstream_anchor;
+  pir::Value InputValue() { return op->operand_source(input_idx); }
+  pir::Value OutputValue() { return op->result(output_idx); }
+};
+
+struct UnsupportTransform {
+  TransformInfo info;
+};
+
+struct IdentityTransform {
+  TransformInfo info;
+};
+
+struct AppendDimTransform {
+  TransformInfo info;
+};
+
+struct DeleteDimTransform {
+  TransformInfo info;
+};
+
+using AnchorTransform = std::variant<UnsupportTransform,
+                                     IdentityTransform,
+                                     AppendDimTransform,
+                                     DeleteDimTransform>;
+using AnchorTransformRoute = std::vector<AnchorTransform>;
+
+template <typename T>
+struct ValueExpr {};
+
+template <typename T>
+struct AnchorState {
+  std::vector<ValueExpr<T>> output_exprs;
+};
+
+AnchorTransform CreateAnchorTransform(TransformInfo info);
+}  // namespace cinn::fusion
diff --git a/paddle/cinn/operator_fusion/policy/anchor_search_policy.cc b/paddle/cinn/operator_fusion/policy/anchor_search_policy.cc
index b8b095306b7871..7c63372961b9bd 100644
--- a/paddle/cinn/operator_fusion/policy/anchor_search_policy.cc
+++ b/paddle/cinn/operator_fusion/policy/anchor_search_policy.cc
@@ -13,3 +13,23 @@
 // limitations under the License.
 
 #include "paddle/cinn/operator_fusion/policy/anchor_search_policy.h"
+#include "paddle/cinn/operator_fusion/backend/pattern.h"
+#include "paddle/cinn/operator_fusion/frontend/pattern.h"
+
+namespace cinn::fusion {
+
+std::vector<AnchorTransformRoute> FindAnchorTransformRoute(
+    pir::Value begin, pir::Value end, std::unordered_set<pir::Operation*> ops) {
+}
+bool IsLegalRoute(AnchorTransformRoute route) {}
+
+template <typename T>
+bool AnchorSearchPolicy<T>::HasUpstreamAnchor(
+    const PatternNodePtr<T>& upstream, const PatternNodePtr<T>& downstream) {}
+template <typename T>
+bool AnchorSearchPolicy<T>::HasDownstreamAnchor(
+    const PatternNodePtr<T>& upstream, const PatternNodePtr<T>& downstream) {}
+
+template class AnchorSearchPolicy<FrontendStage>;
+template class AnchorSearchPolicy<BackendStage>;
+}  // namespace cinn::fusion
diff --git a/paddle/cinn/operator_fusion/policy/anchor_search_policy.h b/paddle/cinn/operator_fusion/policy/anchor_search_policy.h
index 30eb476f63a43c..8d8a4a8ccc89ea 100644
--- a/paddle/cinn/operator_fusion/policy/anchor_search_policy.h
+++ b/paddle/cinn/operator_fusion/policy/anchor_search_policy.h
@@ -15,6 +15,7 @@
 #pragma once
 #include <functional>
 #include "paddle/cinn/operator_fusion/pattern_node.h"
+#include "paddle/cinn/operator_fusion/pir_graph_analyzing/anchor_transform.h"
 #include "paddle/cinn/operator_fusion/policy/policy_base.h"
 #include "paddle/cinn/operator_fusion/utils.h"
 #include "paddle/common/enforce.h"
diff --git a/paddle/cinn/operator_fusion/policy/general_topo_policy.cc b/paddle/cinn/operator_fusion/policy/general_topo_policy.cc
index e4cca9804a79f2..2929167bc57dee 100644
--- a/paddle/cinn/operator_fusion/policy/general_topo_policy.cc
+++ b/paddle/cinn/operator_fusion/policy/general_topo_policy.cc
@@ -14,9 +14,7 @@
 
 #include "paddle/cinn/operator_fusion/policy/general_topo_policy.h"
 #include "paddle/cinn/operator_fusion/backend/pattern.h"
-#include "paddle/cinn/operator_fusion/backend/pattern_fuser.h"
 #include "paddle/cinn/operator_fusion/frontend/pattern.h"
-#include "paddle/cinn/operator_fusion/frontend/pattern_fuser.h"
 
 namespace cinn::fusion {
 

From 18a3eb8d11bb1fd428ab747911843e2779d87251 Mon Sep 17 00:00:00 2001
From: zhangbaizhou <zhangbaizhou@baidu.com>
Date: Sun, 28 Apr 2024 08:11:55 +0000
Subject: [PATCH 22/99] skip multi-downstream nodes when doing trivial sink

---
 .../graph_transformer/matcher.h               | 19 +++---
 .../graph_transformer/operation.h             | 59 +++++++++++--------
 paddle/cinn/operator_fusion/pattern_graph.cc  | 13 ++--
 paddle/cinn/operator_fusion/pattern_graph.h   |  1 +
 4 files changed, 53 insertions(+), 39 deletions(-)

diff --git a/paddle/cinn/operator_fusion/graph_transformer/matcher.h b/paddle/cinn/operator_fusion/graph_transformer/matcher.h
index 89803388e3a204..0274941dd464f6 100644
--- a/paddle/cinn/operator_fusion/graph_transformer/matcher.h
+++ b/paddle/cinn/operator_fusion/graph_transformer/matcher.h
@@ -45,6 +45,18 @@ struct CanFuseRxTMatcher {
   }
 };
 
+struct SinkTrivialMatcher {
+  template <typename T>
+  bool operator()(const PatternGraph<T>& graph, const PatternNodePtr<T>& node) {
+    return StmtPatternGraphMatcher<TrivialPattern<T>>()(graph, node) &&
+           node->downstream().size() == 1 &&
+           (std::holds_alternative<ReducePattern<Phrase>>(
+                node->downstream().at(0)->stmt_pattern()) ||
+            std::holds_alternative<TrivialPattern<Phrase>>(
+                node->downstream().at(0)->stmt_pattern()));
+  }
+};
+
 struct CanFuseReduceTreeMatcher {
   template <typename T>
   bool operator()(const PatternGraph<T>& graph, const PatternNodePtr<T>& node) {
@@ -133,13 +145,6 @@ struct HorizontalFusionMatcher {
   }
 };
 
-struct NonSinkNodeMatcher {
-  template <typename T>
-  bool operator()(const PatternGraph<T>& graph, const PatternNodePtr<T>& node) {
-    return !node->downstream().empty();
-  }
-};
-
 struct IsOutputNodeMatcher {
   template <typename T>
   bool operator()(const PatternGraph<T>& graph, const PatternNodePtr<T>& node) {
diff --git a/paddle/cinn/operator_fusion/graph_transformer/operation.h b/paddle/cinn/operator_fusion/graph_transformer/operation.h
index 51dc26c4c631d0..fa41ed2d5598d9 100644
--- a/paddle/cinn/operator_fusion/graph_transformer/operation.h
+++ b/paddle/cinn/operator_fusion/graph_transformer/operation.h
@@ -79,35 +79,48 @@ struct LiftReduceToReduceTreeOperation {
 };
 
 struct MergeTrivialPatternOperation {
-  // TOOD(@wuzhanfei)
   template <typename Phrase>
   void operator()(PatternGraph<Phrase>* graph,
                   PatternNodePtr<Phrase> upstream) {
-    std::vector<PatternNodePtr<Phrase>> fusion_candidate =
-        upstream->downstream();
-    upstream->ClearDownstream();
-    for (const auto& downstream : fusion_candidate) {
-      if (std::holds_alternative<ReducePattern<Phrase>>(
-              downstream->stmt_pattern()) ||
-          std::holds_alternative<TrivialPattern<Phrase>>(
-              downstream->stmt_pattern())) {
-        auto merged_node =
-            graph->MergeNode(upstream, downstream, MergePattern<Phrase>);
-        graph->RemoveNode(downstream);
-        VLOG(4) << "MergeTrivialPatternOperation: \nupstream "
-                << upstream->DebugStr() << "\ndownstream "
-                << downstream->DebugStr() << "\nmerged "
-                << merged_node->DebugStr();
-      } else {
-        upstream->AddNodeToDownstream(downstream);
-      }
-    }
-    if (upstream->downstream().empty()) {
-      graph->RemoveNode(upstream);
-    }
+    const auto& downstream = node->downstream().at(0);
+    auto merged_node =
+        graph->MergeNode(upstream, downstream, MergePattern<Phrase>);
+    graph->RemoveNode(downstream);
+    VLOG(4) << "MergeTrivialPatternOperation: \nupstream "
+            << upstream->DebugStr() << "\ndownstream " << downstream->DebugStr()
+            << "\nmerged " << merged_node->DebugStr();
   }
 };
 
+// struct MergeTrivialPatternOperation {
+//   template <typename Phrase>
+//   void operator()(PatternGraph<Phrase>* graph,
+//                   PatternNodePtr<Phrase> upstream) {
+//     std::vector<PatternNodePtr<Phrase>> fusion_candidate =
+//         upstream->downstream();
+//     upstream->ClearDownstream();
+//     for (const auto& downstream : fusion_candidate) {
+//       if (std::holds_alternative<ReducePattern<Phrase>>(
+//               downstream->stmt_pattern()) ||
+//           std::holds_alternative<TrivialPattern<Phrase>>(
+//               downstream->stmt_pattern())) {
+//         auto merged_node =
+//             graph->MergeNode(upstream, downstream, MergePattern<Phrase>);
+//         graph->RemoveNode(downstream);
+//         VLOG(4) << "MergeTrivialPatternOperation: \nupstream "
+//                 << upstream->DebugStr() << "\ndownstream "
+//                 << downstream->DebugStr() << "\nmerged "
+//                 << merged_node->DebugStr();
+//       } else {
+//         upstream->AddNodeToDownstream(downstream);
+//       }
+//     }
+//     if (upstream->downstream().empty()) {
+//       graph->RemoveNode(upstream);
+//     }
+//   }
+// };
+
 struct LiftToHorizontalFusionPatternOperation {
   template <typename Phrase>
   void operator()(PatternGraph<Phrase>* graph, PatternNodePtr<Phrase> node) {
diff --git a/paddle/cinn/operator_fusion/pattern_graph.cc b/paddle/cinn/operator_fusion/pattern_graph.cc
index 9bff297462af6b..bb68f7bc3d1d74 100644
--- a/paddle/cinn/operator_fusion/pattern_graph.cc
+++ b/paddle/cinn/operator_fusion/pattern_graph.cc
@@ -28,8 +28,6 @@ template <typename T>
 std::vector<PatternNodePtr<T>> PatternGraph<T>::ClusterOps() {
   VLOG(4) << "[Group Cluster] Initial Condition: " << GraphInfo();
 
-  // TODO(@wuzhanfei) Remove All IsOutputPattern Check
-
   VLOG(4) << "[Group Cluster] Start SinkTrivialPattern";
   SinkTrivialPattern();
   VLOG(4) << "[Group Cluster] After SinkTrivialPattern: " << GraphInfo();
@@ -128,13 +126,10 @@ std::vector<PatternNodePtr<T>> PatternGraph<T>::SortByReverseTopoOrder() {
 
 template <typename T>
 void PatternGraph<T>::SinkTrivialPattern() {
-  // TODO(@wuzhanfei) change sink trivial pattern algorithm, skip pattern with
-  // multi downstream
-  GraphTransformer<
-      NodePattern,
-      T,
-      And<NonSinkNodeMatcher, StmtPatternGraphMatcher<TrivialPattern<T>>>,
-      MergeTrivialPatternOperation>(this);
+  GraphTransformer<NodePattern,
+                   T,
+                   SinkTrivialMatcher,
+                   MergeTrivialPatternOperation>(this);
 }
 
 template <typename T>
diff --git a/paddle/cinn/operator_fusion/pattern_graph.h b/paddle/cinn/operator_fusion/pattern_graph.h
index 433a9849566737..cedf52f63a6125 100644
--- a/paddle/cinn/operator_fusion/pattern_graph.h
+++ b/paddle/cinn/operator_fusion/pattern_graph.h
@@ -52,6 +52,7 @@ class PatternGraph {
                               const PatternNodePtr<T>& downstream,
                               MergePatternFn<T> merge_pattern_fn);
   std::vector<PatternNodePtr<T>> SortByTopoOrder();
+  std::vector<PatternNodePtr<T>> SortByReverseTopoOrder();
 
   const PatternNodePtrSet<T>& all_pattern_nodes() const {
     return all_pattern_nodes_;

From cfa49e29f5233821f866ab2fc44046f39cd072d6 Mon Sep 17 00:00:00 2001
From: xiongkun <xiongkun03@baidu.com>
Date: Sun, 28 Apr 2024 09:53:34 +0000
Subject: [PATCH 23/99] fix

---
 .../cinn/hlir/dialect/operator/transforms/add_cinn_pass.cc | 2 +-
 .../dialect/operator/transforms/cinn_group_cluster_pass.cc | 2 +-
 paddle/cinn/hlir/framework/pir/op_lowering_impl.cc         | 3 ++-
 paddle/cinn/hlir/framework/pir/trivial_op_impl.cc          | 6 +++---
 paddle/cinn/hlir/framework/pir/trivial_op_impl.h           | 3 ++-
 paddle/cinn/operator_fusion/backend/pattern_fuser.cc       | 7 ++++---
 paddle/cinn/operator_fusion/group_cluster.h                | 5 +++--
 7 files changed, 16 insertions(+), 12 deletions(-)

diff --git a/paddle/cinn/hlir/dialect/operator/transforms/add_cinn_pass.cc b/paddle/cinn/hlir/dialect/operator/transforms/add_cinn_pass.cc
index d695be6a4f777f..53ba0fbd1b67ad 100644
--- a/paddle/cinn/hlir/dialect/operator/transforms/add_cinn_pass.cc
+++ b/paddle/cinn/hlir/dialect/operator/transforms/add_cinn_pass.cc
@@ -150,7 +150,7 @@ void ApplyDivideGroupOpToFusionOpPass(
   std::shared_ptr<pir::PassManager> pass_manager = CreatePassManager();
   if (FLAGS_group_schedule_tiling_first) {
     pass_manager->AddPass(cinn::dialect::ir::CreateCinnGroupClusterPass());
-    pass_manager->AddPass(cinn::dialect::ir::CreateAddStoreInFusionOpPass());
+    // pass_manager->AddPass(cinn::dialect::ir::CreateAddStoreInFusionOpPass());
   } else {
     pass_manager->AddPass(
         cinn::dialect::ir::CreateDivideGroupOpToFusionOpPass());
diff --git a/paddle/cinn/hlir/dialect/operator/transforms/cinn_group_cluster_pass.cc b/paddle/cinn/hlir/dialect/operator/transforms/cinn_group_cluster_pass.cc
index d26df065d95730..94eaa3f526a238 100644
--- a/paddle/cinn/hlir/dialect/operator/transforms/cinn_group_cluster_pass.cc
+++ b/paddle/cinn/hlir/dialect/operator/transforms/cinn_group_cluster_pass.cc
@@ -248,7 +248,7 @@ std::vector<GroupClusterNode> GroupSplit(cinn::dialect::GroupOp group_op) {
   std::function<cinn::fusion::FrontendContent(pir::Operation*)> func =
       [](pir::Operation* op) { return cinn::fusion::FrontendContent(op); };
   const auto& contents = cinn::fusion::MapVector(group_op.GetOperators(), func);
-  auto cluster_result = cinn::fusion::ClusterOps(contents);
+  auto cluster_result = cinn::fusion::ClusterOps(contents, {});
   std::vector<std::vector<pir::Operation*>> result;
   std::transform(
       cluster_result.begin(),
diff --git a/paddle/cinn/hlir/framework/pir/op_lowering_impl.cc b/paddle/cinn/hlir/framework/pir/op_lowering_impl.cc
index e199115fa51de2..e8d15096f8cfa5 100644
--- a/paddle/cinn/hlir/framework/pir/op_lowering_impl.cc
+++ b/paddle/cinn/hlir/framework/pir/op_lowering_impl.cc
@@ -203,7 +203,8 @@ BucketLoweredFuncsWrapper OpLowererImpl::BucketLower(
 
   // =========== OpFusion ============
 
-  func_bodies = OperationFusion(ops, func_bodies);
+  // VLOG(4) << "Bucket Lower output values is : " << group->output_values();
+  func_bodies = OperationFusion(ops, func_bodies, group->output_values());
   const auto& fusion_group_info = GetFusionGroupInfo(func_bodies);
 
   // =========== CodeGen And Optimizer ================
diff --git a/paddle/cinn/hlir/framework/pir/trivial_op_impl.cc b/paddle/cinn/hlir/framework/pir/trivial_op_impl.cc
index 910bb59f4a3ad4..bd0f764630ff4f 100644
--- a/paddle/cinn/hlir/framework/pir/trivial_op_impl.cc
+++ b/paddle/cinn/hlir/framework/pir/trivial_op_impl.cc
@@ -563,7 +563,8 @@ std::pair<TrivialOp, ReduceOp> SplitReduceOp(const ReduceOp& reduce_op) {
 
 std::vector<ir::Expr> OperationFusion(
     const std::vector<::pir::Operation*>& original_ops,
-    const std::vector<ir::Expr>& op_compute_bodies) {
+    const std::vector<ir::Expr>& op_compute_bodies,
+    const std::vector<::pir::Value>& outputs) {
   CHECK(FLAGS_group_schedule_tiling_first)
       << "TrivialFusion must be used with tiling first, set "
          "FLAGS_group_schedule_tiling_first=1";
@@ -578,10 +579,9 @@ std::vector<ir::Expr> OperationFusion(
   std::vector<cinn::fusion::BackendContent> contents;
   for (int i = 0; i < ops.size(); i++) {
     contents.emplace_back(ops[i], op_compute_bodies[i]);
-    // contents.emplace_back(ops[i]);
   }
   const auto& fusion_nodes =
-      cinn::fusion::ClusterOps<cinn::fusion::BackendStage>(contents);
+      cinn::fusion::ClusterOps<cinn::fusion::BackendStage>(contents, outputs);
 
   CHECK(fusion_nodes.size() == 1)
       << "Only support one fusion node in backend now.";
diff --git a/paddle/cinn/hlir/framework/pir/trivial_op_impl.h b/paddle/cinn/hlir/framework/pir/trivial_op_impl.h
index 48eddf48528705..46375381237d5b 100644
--- a/paddle/cinn/hlir/framework/pir/trivial_op_impl.h
+++ b/paddle/cinn/hlir/framework/pir/trivial_op_impl.h
@@ -180,7 +180,8 @@ FusionGroupInfo GetFusionGroupInfo(
 
 std::vector<ir::Expr> OperationFusion(
     const std::vector<::pir::Operation*>& ops,
-    const std::vector<ir::Expr>& op_compute_bodies);
+    const std::vector<ir::Expr>& op_compute_bodies,
+    const std::vector<::pir::Value>& outputs);
 
 }  // namespace pir
 }  // namespace framework
diff --git a/paddle/cinn/operator_fusion/backend/pattern_fuser.cc b/paddle/cinn/operator_fusion/backend/pattern_fuser.cc
index 11e3de0688ed4e..91526eca23e7ad 100644
--- a/paddle/cinn/operator_fusion/backend/pattern_fuser.cc
+++ b/paddle/cinn/operator_fusion/backend/pattern_fuser.cc
@@ -81,9 +81,6 @@ template <>
 StmtPattern<BackendStage> MergePatternImpl(
     const HorizontalFusionPattern<BackendStage>& first,
     const HorizontalFusionPattern<BackendStage>& second) {
-  const auto& contents =
-      UniqueConcatVector(GetOpsInPattern<BackendStage>(first),
-                         GetOpsInPattern<BackendStage>(second));
   return HorizontalFusionPattern<BackendStage>({first, second});
 }
 
@@ -170,6 +167,8 @@ struct FusionOpGetter {
   std::vector<FusionOp> operator()(
       const HorizontalFusionPattern<BackendStage>& pattern) {
     std::vector<FusionOp> result;
+    VLOG(4) << "Get Fusion Ops from HorizontalFusionPattern: "
+            << pattern.patterns_.size();
     for (const auto& sub_pattern : pattern.patterns_) {
       result = ConcatVector(result, GetFusionOpFromPattern(sub_pattern));
     }
@@ -306,6 +305,8 @@ std::vector<ir::Expr> TopoSort(const std::vector<ir::Expr>& op_exprs) {
 std::vector<ir::Expr> GetExprFromPattern(
     const StmtPattern<BackendStage>& pattern) {
   const auto& fusion_ops = GetFusionOpFromPattern(pattern);
+  VLOG(4) << "GetExprFromPattern from " << GetPatternName(pattern)
+          << " : get fusion op number : " << fusion_ops.size();
   std::vector<ir::Expr> results;
   for (const auto& op : fusion_ops) {
     results = ConcatVector(results, std::visit(FusionOp2Expr(), op));
diff --git a/paddle/cinn/operator_fusion/group_cluster.h b/paddle/cinn/operator_fusion/group_cluster.h
index 2c6f2072ad528a..cf9523dc5dd6c7 100644
--- a/paddle/cinn/operator_fusion/group_cluster.h
+++ b/paddle/cinn/operator_fusion/group_cluster.h
@@ -27,7 +27,8 @@ namespace cinn::fusion {
 
 template <typename T>
 inline std::vector<fusion::PatternNodePtr<T>> ClusterOps(
-    const std::vector<fusion::PatternContent<T>>& contents) {
+    const std::vector<fusion::PatternContent<T>>& contents,
+    const std::vector<pir::Value>& output_values) {
   std::function<pir::Operation*(fusion::PatternContent<T>)> func =
       [](const fusion::PatternContent<T>& content) { return content.op; };
   const auto& origin_ops = fusion::MapVector(contents, func);
@@ -36,7 +37,7 @@ inline std::vector<fusion::PatternNodePtr<T>> ClusterOps(
   VLOG(4) << "Input Group with size " << origin_ops.size() << " :\n"
           << fusion::OpsDebugStr(origin_ops);
 
-  std::vector<pir::Value> outputs;
+  std::vector<pir::Value> outputs = output_values;
   const auto& ops = [&] {
     std::vector<pir::Operation*> ops;
     for (const auto& content : contents) {

From 64590a69f463e6f6b0b7fb42f72ee747b0d5c57e Mon Sep 17 00:00:00 2001
From: xiongkun <xiongkun03@baidu.com>
Date: Sun, 28 Apr 2024 11:08:37 +0000
Subject: [PATCH 24/99] xxxx

---
 paddle/cinn/operator_fusion/pattern_fuser.h | 15 ++++++++++++++-
 1 file changed, 14 insertions(+), 1 deletion(-)

diff --git a/paddle/cinn/operator_fusion/pattern_fuser.h b/paddle/cinn/operator_fusion/pattern_fuser.h
index a8d4da6935c4a5..00d7cc88a2c9f6 100644
--- a/paddle/cinn/operator_fusion/pattern_fuser.h
+++ b/paddle/cinn/operator_fusion/pattern_fuser.h
@@ -128,6 +128,19 @@ MaybeLoopFramework GetLoopFramework(const StmtPattern<T>& pattern) {
   return std::visit(LoopFrameworkVisitor<T>(), pattern.variant());
 }
 
+static MaybeLoopFramework SqueezeLoopFramework(
+    const MaybeLoopFramework& loop_framework) {
+  MaybeLoopFramework result;
+  for (int i = 0; i < loop_framework.size(); i++) {
+    if (loop_framework[i] == 1) {
+      continue;  // skip 1
+    } else {
+      result.push_back(loop_framework[i]);
+    }
+  }
+  return result;
+}
+
 template <typename T>
 bool IsLoopFrameworkEqual(const StmtPattern<T>& lhs,
                           const StmtPattern<T>& rhs) {
@@ -135,7 +148,7 @@ bool IsLoopFrameworkEqual(const StmtPattern<T>& lhs,
   auto rhs_loop = GetLoopFramework(rhs);
   VLOG(4) << "lhs loop range is:" << utils::Join(lhs_loop, ",");
   VLOG(4) << "rhs loop range is:" << utils::Join(rhs_loop, ",");
-  return lhs_loop == rhs_loop;
+  return SqueezeLoopFramework(lhs_loop) == SqueezeLoopFramework(rhs_loop);
 }
 
 template <typename T>

From 4c4eeb7858045559cb53e3e0bc445ea805780587 Mon Sep 17 00:00:00 2001
From: xiongkun <xiongkun03@baidu.com>
Date: Sun, 28 Apr 2024 11:46:34 +0000
Subject: [PATCH 25/99] fix

---
 paddle/cinn/ir/group_schedule/dy_shape_group_scheduler.cc | 2 +-
 paddle/cinn/operator_fusion/backend/pattern_fuser.cc      | 3 +++
 2 files changed, 4 insertions(+), 1 deletion(-)

diff --git a/paddle/cinn/ir/group_schedule/dy_shape_group_scheduler.cc b/paddle/cinn/ir/group_schedule/dy_shape_group_scheduler.cc
index e604055cf3b93e..e414dadb5cd9d9 100644
--- a/paddle/cinn/ir/group_schedule/dy_shape_group_scheduler.cc
+++ b/paddle/cinn/ir/group_schedule/dy_shape_group_scheduler.cc
@@ -36,7 +36,7 @@ void DynamicShapeGroupScheduler::Init() {
   VLOG(4) << "original group func body: \n"
           << ir_sch_->GetModule().GetExprs()[0];
   InitBuckets();
-  tactics_.emplace_back(CreateLoopReorderAlignmentTactic());
+  // tactics_.emplace_back(CreateLoopReorderAlignmentTactic());
   VLOG(4) << "CreateLoopReorderAlignmentTactic End";
   tactics_.emplace_back(CreateTileFirstGeneralTactic());
   VLOG(4) << "CreateTileFirstGeneralTactic End";
diff --git a/paddle/cinn/operator_fusion/backend/pattern_fuser.cc b/paddle/cinn/operator_fusion/backend/pattern_fuser.cc
index 91526eca23e7ad..1fb285184680c6 100644
--- a/paddle/cinn/operator_fusion/backend/pattern_fuser.cc
+++ b/paddle/cinn/operator_fusion/backend/pattern_fuser.cc
@@ -264,6 +264,8 @@ std::vector<ir::Expr> TopoSort(const std::vector<ir::Expr>& op_exprs) {
   std::map<const ir::Expr*, int> degrees;
   for (const auto& op : op_exprs) {
     degrees[&op] = 0;
+  }
+  for (const auto& op : op_exprs) {
     auto outputs = GetOutputTensors(op);
     std::vector<const ir::Expr*> downstreams;
     for (const auto& output : outputs) {
@@ -285,6 +287,7 @@ std::vector<ir::Expr> TopoSort(const std::vector<ir::Expr>& op_exprs) {
   }
   while (!q.empty()) {
     auto* cur = q.front();
+    VLOG(4) << "Topo Sort Visit Order is:" << GetOutputTensors(*cur)[0]->name;
     q.pop();
     result.push_back(cur);
     for (const auto& downstream : op2downstreams[cur]) {

From c17322a6910e0612d05c5db42fd4d037e7c61b33 Mon Sep 17 00:00:00 2001
From: feifei-111 <2364819892@qq.com>
Date: Mon, 29 Apr 2024 04:01:33 +0000
Subject: [PATCH 26/99] update

---
 .../pir_graph_analyzing/anchor_transform.cc   | 91 ++++++++++++++++++-
 .../pir_graph_analyzing/anchor_transform.h    |  4 +-
 .../pir_graph_analyzing/dim_relation.cc       | 32 +------
 .../shardable_axes_base.cc                    |  2 +-
 paddle/cinn/operator_fusion/utils.h           | 38 +++++++-
 5 files changed, 129 insertions(+), 38 deletions(-)

diff --git a/paddle/cinn/operator_fusion/pir_graph_analyzing/anchor_transform.cc b/paddle/cinn/operator_fusion/pir_graph_analyzing/anchor_transform.cc
index e5c3719bc6a4bf..86906b1e36e529 100644
--- a/paddle/cinn/operator_fusion/pir_graph_analyzing/anchor_transform.cc
+++ b/paddle/cinn/operator_fusion/pir_graph_analyzing/anchor_transform.cc
@@ -15,5 +15,94 @@
 #include "paddle/cinn/operator_fusion/pir_graph_analyzing/anchor_transform.h"
 
 namespace cinn::fusion {
-AnchorTransform CreateAnchorTransform(TransformInfo info) {}
+
+AnchorTransform CreateDefaultAnchorTransform(const TransformInfo& info) {
+  return UnsupportTransform(info);
+}
+
+AnchorTransform CreateAnchorTransformForElementWise(const TransformInfo& info) {
+  return IdentityTransform(info);
+}
+
+AnchorTransform CreateAnchorTransformForReduce(const TransformInfo& info) {
+  if (info.op->num_operands() != 1 || info.input_idx != 0) {
+    return CreateDefaultAnchorTransform(info);
+  }
+
+  if (info.is_upstream_anchor) {
+    return AppendDimTransform(info,
+                              GetReduceAxisIdx(pir::Operation * reduce_op))
+  } else {
+    return CreateDefaultAnchorTransform(info);
+  }
+}
+
+AnchorTransform CreateAnchorTransformForBroadcast(const TransformInfo& info) {
+  if (info.op->num_operands() != 1 || info.input_idx != 0) {
+    return CreateDefaultAnchorTransform(info);
+  }
+
+  if (info.is_upstream_anchor) {
+    auto related_dims = GetNonBroadCastDims(info.op);
+    size_t output_rank = GetRank(info.OutputValue());
+    std::vector<size_t> used_dim_mask = std::vector<size_t>(output_rank, 0);
+    std::vector<size_t> delete_dim_idx;
+    for (const auto& [input_dim_idx, output_dim_idx] : related_dims) {
+      used_dim_mask[output_dim_idx] = 1;
+    }
+    for (size_t used_dim : used_dim_mask) {
+      if (used_dim == 0) {
+        delete_dim_idx.emplace_back();
+      }
+    }
+    return DeleteDimTransform(info, delete_dim_idx);
+  } else {
+    return CreateDefaultAnchorTransform(info);
+  }
+}
+
+AnchorTransform CreateAnchorTransformForSpecialOps(const TransformInfo& info) {
+  if (info.op->num_results() != 1) {
+    VLOG(4) << "Now we do not support op with multi outputs, create default: "
+            << info.op->name();
+    return CreateDefaultAnchorTransform(info);
+  }
+  if (info.op->isa<cinn::dialect::ReshapeOp>()) {
+    return CreateDefaultAnchorTransform(info);
+  }
+  if (info.op->name() == "cinn_op.generate_shape") {
+    return CreateDefaultAnchorTransform(info);
+  }
+  if (info.op->name() == "cinn_op.yield_store") {
+    return CreateDefaultAnchorTransform(info);
+  }
+  if (info.op->name() == "cinn_op.reshape") {
+    return CreateDefaultAnchorTransform(info);
+  }
+  if (info.op->name() == "pd_op.reshape") {
+    return CreateDefaultAnchorTransform(info);
+  }
+  return std::nullopt;
+}
+
+AnchorTransform CreateAnchorTransform(const TransformInfo& info) {
+  auto special_result = CreateAnchorTransformForSpecialOps(info);
+  if (special_result != std::nullopt) {
+    return special_result.value();
+  }
+
+  const hlir::framework::OpPatternKind kind = GetOpPatternKind(info.op);
+  if (kind == hlir::framework::kReduction) {
+    result = CreateAnchorTransformForReduce(info);
+  } else if (kind == hlir::framework::kElementWise) {
+    result = CreateAnchorTransformForElementWise(info);
+  } else if (kind == hlir::framework::kBroadcast) {
+    result = CreateAnchorTransformForBroadcast(info);
+  } else {
+    result = CreateDefaultAnchorTransform(info);
+  }
+
+  return result;
+}
+
 }  // namespace cinn::fusion
diff --git a/paddle/cinn/operator_fusion/pir_graph_analyzing/anchor_transform.h b/paddle/cinn/operator_fusion/pir_graph_analyzing/anchor_transform.h
index 9f2e2d1827321f..0f9b824e197fd5 100644
--- a/paddle/cinn/operator_fusion/pir_graph_analyzing/anchor_transform.h
+++ b/paddle/cinn/operator_fusion/pir_graph_analyzing/anchor_transform.h
@@ -37,10 +37,12 @@ struct IdentityTransform {
 
 struct AppendDimTransform {
   TransformInfo info;
+  std::vector<size_t> append_dims;
 };
 
 struct DeleteDimTransform {
   TransformInfo info;
+  std::vector<size_t> delete_dims;
 };
 
 using AnchorTransform = std::variant<UnsupportTransform,
@@ -57,5 +59,5 @@ struct AnchorState {
   std::vector<ValueExpr<T>> output_exprs;
 };
 
-AnchorTransform CreateAnchorTransform(TransformInfo info);
+AnchorTransform CreateAnchorTransform(const TransformInfo& info);
 }  // namespace cinn::fusion
diff --git a/paddle/cinn/operator_fusion/pir_graph_analyzing/dim_relation.cc b/paddle/cinn/operator_fusion/pir_graph_analyzing/dim_relation.cc
index f3866a8e70896a..4eb40dee7c372d 100644
--- a/paddle/cinn/operator_fusion/pir_graph_analyzing/dim_relation.cc
+++ b/paddle/cinn/operator_fusion/pir_graph_analyzing/dim_relation.cc
@@ -97,36 +97,6 @@ static DimUsageRelation CreateOpRelativenessForElementWise(pir::Operation* op) {
   return res;
 }
 
-static std::vector<std::pair<size_t, size_t>> GetNonBroadCastDims(
-    pir::Operation* op) {
-  std::vector<std::pair<size_t, size_t>> res;
-  auto* shape_analysis =
-      &pir::ShapeAnalysisManager::Instance().Get(op->GetParentProgram());
-
-  const auto& broad_cast_value = GetBroadcastOpInputOuputValue(op);
-  CHECK(broad_cast_value.has_value());
-
-  const auto& [input_value, output_value] = broad_cast_value.value();
-  const int input_rank = GetRank(input_value);
-  const int output_rank = GetRank(output_value);
-  CHECK_GE(output_rank, input_rank);
-
-  // Compare axis one by one, from back to front.
-  // The rule of broadcasting:
-  // https://www.paddlepaddle.org.cn/documentation/docs/zh/guides/beginner/tensor_cn.html#id7
-  for (int i = 1; i <= input_rank; ++i) {
-    int input_axis = input_rank - i;
-    int output_axis = output_rank - i;
-    if (input_axis < 0 || output_axis < 0) break;
-    if (shape_analysis->IsProductEqual(
-            input_value, {input_axis}, output_value, {output_axis})) {
-      res.emplace_back(input_axis, output_axis);
-    }
-  }
-
-  return res;
-}
-
 static DimUsageRelation CreateOpRelativenessForBroadcast(pir::Operation* op) {
   DimUsageRelation res;
   const auto& in_value = op->operand(0).source();
@@ -147,7 +117,7 @@ static DimUsageRelation CreateOpRelativenessForReduce(pir::Operation* op) {
   const size_t input_rank = GetRank(op->operand_source(0));
   int out_idx = 0;
   bool keep_dim = GetReduceOpKeepDims(op);
-  for (int i = 0; i < input_rank; i++) {
+  for (size_t i = 0; i < input_rank; i++) {
     if (std::find(reduce_axis_idx.begin(), reduce_axis_idx.end(), i) ==
         reduce_axis_idx.end()) {
       auto input_dim = DimUsage(
diff --git a/paddle/cinn/operator_fusion/pir_graph_analyzing/shardable_axes_base.cc b/paddle/cinn/operator_fusion/pir_graph_analyzing/shardable_axes_base.cc
index 44d42de346ca79..1f0bc34b66312e 100644
--- a/paddle/cinn/operator_fusion/pir_graph_analyzing/shardable_axes_base.cc
+++ b/paddle/cinn/operator_fusion/pir_graph_analyzing/shardable_axes_base.cc
@@ -110,7 +110,7 @@ ShardableAxesSignature CreateSignatureForReduce(pir::Operation* reduce_op) {
   bool keep_dim = GetReduceOpKeepDims(reduce_op);
   auto output_axes = std::vector<std::string>();
 
-  for (int i = 0; i < input_rank; i++) {
+  for (size_t i = 0; i < input_rank; i++) {
     if (reduce_axis_idx.empty() ||
         std::find(reduce_axis_idx.begin(), reduce_axis_idx.end(), i) !=
             reduce_axis_idx.end()) {
diff --git a/paddle/cinn/operator_fusion/utils.h b/paddle/cinn/operator_fusion/utils.h
index 1cecec00be9ec6..b83a101f2d0135 100644
--- a/paddle/cinn/operator_fusion/utils.h
+++ b/paddle/cinn/operator_fusion/utils.h
@@ -44,26 +44,26 @@ static size_t GetRank(pir::Value value) {
   return value.type().dyn_cast<pir::DenseTensorType>().dims().size();
 }
 
-static std::vector<int64_t> GetReduceAxisIdx(pir::Operation* reduce_op) {
+static std::vector<size_t> GetReduceAxisIdx(pir::Operation* reduce_op) {
   const size_t input_rank = GetRank(reduce_op->operand_source(0));
   const auto& attr_val = reduce_op->attributes().at("dim");
   CHECK(attr_val.isa<::pir::ArrayAttribute>());
   const auto& axis_attr = attr_val.dyn_cast<::pir::ArrayAttribute>();
   if (axis_attr.empty()) {
     // dim: [] means reduce_all.
-    std::vector<int64_t> all_axis;
+    std::vector<size_t> all_axis;
     for (int i = 0; i < input_rank; ++i) {
       all_axis.push_back(i);
     }
     return all_axis;
   }
-  std::vector<int64_t> reduce_axis_idx;
+  std::vector<size_t> reduce_axis_idx;
   if (input_rank == 0) {
     VLOG(4) << "Reduce op has 0D Tensor input, return empty reduce_axis";
     return reduce_axis_idx;
   }
   for (int i = 0; i < axis_attr.size(); ++i) {
-    int64_t axis = axis_attr.at(i).dyn_cast<::pir::Int64Attribute>().data();
+    size_t axis = axis_attr.at(i).dyn_cast<::pir::Int64Attribute>().data();
     if (axis < 0) {
       axis += input_rank;
     }
@@ -81,6 +81,36 @@ static bool GetReduceOpKeepDims(pir::Operation* reduce_op) {
   return attr_val.dyn_cast<::pir::BoolAttribute>().data();
 }
 
+static std::vector<std::pair<size_t, size_t>> GetNonBroadCastDims(
+    pir::Operation* op) {
+  std::vector<std::pair<size_t, size_t>> res;
+  auto* shape_analysis =
+      &pir::ShapeAnalysisManager::Instance().Get(op->GetParentProgram());
+
+  const auto& broad_cast_value = GetBroadcastOpInputOuputValue(op);
+  CHECK(broad_cast_value.has_value());
+
+  const auto& [input_value, output_value] = broad_cast_value.value();
+  const int input_rank = GetRank(input_value);
+  const int output_rank = GetRank(output_value);
+  CHECK_GE(output_rank, input_rank);
+
+  // Compare axis one by one, from back to front.
+  // The rule of broadcasting:
+  // https://www.paddlepaddle.org.cn/documentation/docs/zh/guides/beginner/tensor_cn.html#id7
+  for (int i = 1; i <= input_rank; ++i) {
+    int input_axis = input_rank - i;
+    int output_axis = output_rank - i;
+    if (input_axis < 0 || output_axis < 0) break;
+    if (shape_analysis->IsProductEqual(
+            input_value, {input_axis}, output_value, {output_axis})) {
+      res.emplace_back(input_axis, output_axis);
+    }
+  }
+
+  return res;
+}
+
 static std::string OpsDebugStr(std::vector<pir::Operation*> ops) {
   std::stringstream ss;
   pir::IrPrinter printer(ss);

From ada835ed0c4fedb19769ad32ca2c6fb158cb46d7 Mon Sep 17 00:00:00 2001
From: zhangbaizhou <zhangbaizhou@baidu.com>
Date: Mon, 29 Apr 2024 07:09:04 +0000
Subject: [PATCH 27/99] LiftToAnchorPattern Implementation

---
 .../graph_transformer/operation.h             |  2 +-
 paddle/cinn/operator_fusion/pattern.h         | 35 ++++++++++---------
 2 files changed, 20 insertions(+), 17 deletions(-)

diff --git a/paddle/cinn/operator_fusion/graph_transformer/operation.h b/paddle/cinn/operator_fusion/graph_transformer/operation.h
index fa41ed2d5598d9..5f1cd26f4d6724 100644
--- a/paddle/cinn/operator_fusion/graph_transformer/operation.h
+++ b/paddle/cinn/operator_fusion/graph_transformer/operation.h
@@ -132,7 +132,7 @@ struct LiftToHorizontalFusionPatternOperation {
 struct LiftToAnchorPatternOperation {
   template <typename Phrase>
   void operator()(PatternGraph<Phrase>* graph, PatternNodePtr<Phrase> node) {
-    // TODO(@wuzhanfei)
+    node->set_stmt_pattern(AnchorPattern<Phrase>(node->stmt_pattern()));
   }
 };
 
diff --git a/paddle/cinn/operator_fusion/pattern.h b/paddle/cinn/operator_fusion/pattern.h
index d08e820f23ed14..b9298dbc3fb76a 100644
--- a/paddle/cinn/operator_fusion/pattern.h
+++ b/paddle/cinn/operator_fusion/pattern.h
@@ -79,6 +79,24 @@ struct ReduceTreePlusTrivialPattern {
   std::vector<size_t> fake_reduce_iter_idx;
 };
 
+template <typename T>
+struct AnchorPattern {
+  explicit AnchorPattern(const StmtPattern<T>& pattern) : pattern_(pattern) {
+    ExtendVector(ops_, GetOpsInPattern(pattern));
+    // TODO(@wuzhanfei): initialize anchor_ and anchor_state using ops_ and
+    // pattern
+  }
+
+  StmtPattern<T> pattern_;
+  std::vector<pir::Operation*> ops_;
+  pir::Value anchor_;  // Choose only one anchor
+  AnchorState<T> anchor_state;
+  std::vector<pir::Operation*> ops() const { return ops_; }
+  std::vector<pir::Value> outputs() const { return outputs_; }
+  pir::Value anchor() const { return anchor_; }
+  static std::string name() { return "AnchorPattern"; }
+};
+
 template <typename T>
 class UnsupportPattern {};
 
@@ -90,6 +108,7 @@ using StmtPatternBase = std::variant<TrivialPattern<T>,
                                      ReducePattern<T>,
                                      ReduceTreePattern<T>,
                                      ReduceTreePlusTrivialPattern<T>,
+                                     AnchorPattern<T>,
                                      HorizontalFusionPattern<T>,
                                      UnsupportPattern<T>>;
 
@@ -100,20 +119,4 @@ struct StmtPattern final : public StmtPatternBase<T> {
     return static_cast<const StmtPatternBase<T>&>(*this);
   }
 };
-
-template <typename T>
-struct AnchorPattern {
-  explicit AnchorPattern(
-      const std::vector<pir::Operation*>& ops,
-      const pir::Value& anchor const AnchorState<T>& anchor_state)
-      : ops_(ops), anchor_(anchor), {}
-  std::vector<pir::Operation*> ops_;
-  pir::Value anchor_;  // Choose only one anchor
-  AnchorState<T> anchor_state;
-  std::vector<pir::Operation*> ops() const { return ops_; }
-  std::vector<pir::Value> outputs() const { return outputs_; }
-  pir::Value anchor() const { return anchor_; }
-  static std::string name() { return "AnchorPattern"; }
-};
-
 }  // namespace cinn::fusion

From a7a0b0cd72d49cb3f9171a484fdb90cff5be88dd Mon Sep 17 00:00:00 2001
From: feifei-111 <2364819892@qq.com>
Date: Mon, 29 Apr 2024 08:20:18 +0000
Subject: [PATCH 28/99] update

---
 paddle/cinn/operator_fusion/pattern.h         | 33 ++++----
 .../pir_graph_analyzing/anchor_transform.cc   | 42 ++++++++--
 .../pir_graph_analyzing/anchor_transform.h    | 29 ++++++-
 .../pir_graph_analyzing/dim_relation.cc       | 12 ---
 .../pir_graph_analyzing/dim_relation.h        |  1 -
 .../policy/anchor_search_policy.cc            | 77 ++++++++++++++++++-
 paddle/cinn/operator_fusion/utils.h           | 33 ++++++++
 7 files changed, 184 insertions(+), 43 deletions(-)

diff --git a/paddle/cinn/operator_fusion/pattern.h b/paddle/cinn/operator_fusion/pattern.h
index d08e820f23ed14..e585be0dcae0da 100644
--- a/paddle/cinn/operator_fusion/pattern.h
+++ b/paddle/cinn/operator_fusion/pattern.h
@@ -85,22 +85,6 @@ class UnsupportPattern {};
 template <typename T>
 class HorizontalFusionPattern {};
 
-template <typename T>
-using StmtPatternBase = std::variant<TrivialPattern<T>,
-                                     ReducePattern<T>,
-                                     ReduceTreePattern<T>,
-                                     ReduceTreePlusTrivialPattern<T>,
-                                     HorizontalFusionPattern<T>,
-                                     UnsupportPattern<T>>;
-
-template <typename T>
-struct StmtPattern final : public StmtPatternBase<T> {
-  using StmtPatternBase<T>::StmtPatternBase;
-  const StmtPatternBase<T>& variant() const {
-    return static_cast<const StmtPatternBase<T>&>(*this);
-  }
-};
-
 template <typename T>
 struct AnchorPattern {
   explicit AnchorPattern(
@@ -116,4 +100,21 @@ struct AnchorPattern {
   static std::string name() { return "AnchorPattern"; }
 };
 
+template <typename T>
+using StmtPatternBase = std::variant<TrivialPattern<T>,
+                                     ReducePattern<T>,
+                                     ReduceTreePattern<T>,
+                                     ReduceTreePlusTrivialPattern<T>,
+                                     HorizontalFusionPattern<T>,
+                                     UnsupportPattern<T>,
+                                     AnchorPattern<T>>;
+
+template <typename T>
+struct StmtPattern final : public StmtPatternBase<T> {
+  using StmtPatternBase<T>::StmtPatternBase;
+  const StmtPatternBase<T>& variant() const {
+    return static_cast<const StmtPatternBase<T>&>(*this);
+  }
+};
+
 }  // namespace cinn::fusion
diff --git a/paddle/cinn/operator_fusion/pir_graph_analyzing/anchor_transform.cc b/paddle/cinn/operator_fusion/pir_graph_analyzing/anchor_transform.cc
index 86906b1e36e529..2fafa7403bf3ad 100644
--- a/paddle/cinn/operator_fusion/pir_graph_analyzing/anchor_transform.cc
+++ b/paddle/cinn/operator_fusion/pir_graph_analyzing/anchor_transform.cc
@@ -17,11 +17,11 @@
 namespace cinn::fusion {
 
 AnchorTransform CreateDefaultAnchorTransform(const TransformInfo& info) {
-  return UnsupportTransform(info);
+  return std::make_shared<UnsupportTransform>(info);
 }
 
 AnchorTransform CreateAnchorTransformForElementWise(const TransformInfo& info) {
-  return IdentityTransform(info);
+  return std::make_shared<IdentityTransform>(info);
 }
 
 AnchorTransform CreateAnchorTransformForReduce(const TransformInfo& info) {
@@ -30,8 +30,8 @@ AnchorTransform CreateAnchorTransformForReduce(const TransformInfo& info) {
   }
 
   if (info.is_upstream_anchor) {
-    return AppendDimTransform(info,
-                              GetReduceAxisIdx(pir::Operation * reduce_op))
+    return std::make_shared<AppendDimTransform>(
+        info, GetReduceAxisIdx(pir::Operation * reduce_op))
   } else {
     return CreateDefaultAnchorTransform(info);
   }
@@ -55,13 +55,14 @@ AnchorTransform CreateAnchorTransformForBroadcast(const TransformInfo& info) {
         delete_dim_idx.emplace_back();
       }
     }
-    return DeleteDimTransform(info, delete_dim_idx);
+    return std::make_shared<DeleteDimTransform>(info, delete_dim_idx);
   } else {
     return CreateDefaultAnchorTransform(info);
   }
 }
 
-AnchorTransform CreateAnchorTransformForSpecialOps(const TransformInfo& info) {
+std::optional<AnchorTransform> CreateAnchorTransformForSpecialOps(
+    const TransformInfo& info) {
   if (info.op->num_results() != 1) {
     VLOG(4) << "Now we do not support op with multi outputs, create default: "
             << info.op->name();
@@ -105,4 +106,33 @@ AnchorTransform CreateAnchorTransform(const TransformInfo& info) {
   return result;
 }
 
+std::vector<AnchorTransform> PossibleTransform(pir::Value v) {
+  std::vector<AnchorTransform> result;
+
+  // Transform to Upstream
+  auto defining_op = v.defining_op();
+  size_t output_idx = GetResultIdx(v, defining_op);
+  for (size_t i = 0; i < defining_op->num_operands(); ++i) {
+    result.emplace_back(
+        CreateAnchorTransform(TransformInfo(defining_op, i, output_idx, true)));
+  }
+
+  // Transform to Downstream
+  for (auto consumer_it = v.use_begin(); consumer_it != v.use_end();
+       ++consumer_it) {
+    auto downstream_op = consumer_it->owner();
+    size_t input_idx = GetOperandIdx(v, downstream_op);
+    for (size_t i = 0; i < downstream_op.num_results(); i++) {
+      result.emplace_back(CreateAnchorTransform(
+          TransformInfo(downstream_op, input_idx, i, false)));
+    }
+  }
+
+  return results;
+}
+
+TransformInfo GetTransformInfo(AnchorTransform trans) {
+  return std::visit([](auto&& arg{}) { return arg->info; }, trans);
+}
+
 }  // namespace cinn::fusion
diff --git a/paddle/cinn/operator_fusion/pir_graph_analyzing/anchor_transform.h b/paddle/cinn/operator_fusion/pir_graph_analyzing/anchor_transform.h
index 0f9b824e197fd5..f5d75d4b9ee237 100644
--- a/paddle/cinn/operator_fusion/pir_graph_analyzing/anchor_transform.h
+++ b/paddle/cinn/operator_fusion/pir_graph_analyzing/anchor_transform.h
@@ -25,6 +25,20 @@ struct TransformInfo {
   bool is_upstream_anchor;
   pir::Value InputValue() { return op->operand_source(input_idx); }
   pir::Value OutputValue() { return op->result(output_idx); }
+  pir::Value SrcValue() {
+    if (is_upstream_anchor) {
+      return OutputValue();
+    } else {
+      return InputValue();
+    }
+  }
+  pir::Value DstValue() {
+    if (is_upstream_anchor) {
+      return InputValue();
+    } else {
+      return OutputValue();
+    }
+  }
 };
 
 struct UnsupportTransform {
@@ -45,10 +59,15 @@ struct DeleteDimTransform {
   std::vector<size_t> delete_dims;
 };
 
-using AnchorTransform = std::variant<UnsupportTransform,
-                                     IdentityTransform,
-                                     AppendDimTransform,
-                                     DeleteDimTransform>;
+using UnsupportTransformPtr = std::shared_ptr<UnsupportTransform>;
+using IdentityTransformPtr = std::shared_ptr<IdentityTransform>;
+using AppendDimTransformPtr = std::shared_ptr<AppendDimTransform>;
+using DeleteDimTransformPtr = std::shared_ptr<DeleteDimTransform>;
+
+using AnchorTransform = std::variant<UnsupportTransformPtr,
+                                     IdentityTransformPtr,
+                                     AppendDimTransformPtr,
+                                     DeleteDimTransformPtr>;
 using AnchorTransformRoute = std::vector<AnchorTransform>;
 
 template <typename T>
@@ -60,4 +79,6 @@ struct AnchorState {
 };
 
 AnchorTransform CreateAnchorTransform(const TransformInfo& info);
+std::vector<AnchorTransform> PossibleTransform(pir::Value v);
+TransformInfo GetTransformInfo(AnchorTransform trans);
 }  // namespace cinn::fusion
diff --git a/paddle/cinn/operator_fusion/pir_graph_analyzing/dim_relation.cc b/paddle/cinn/operator_fusion/pir_graph_analyzing/dim_relation.cc
index 4eb40dee7c372d..b0944f835fd604 100644
--- a/paddle/cinn/operator_fusion/pir_graph_analyzing/dim_relation.cc
+++ b/paddle/cinn/operator_fusion/pir_graph_analyzing/dim_relation.cc
@@ -16,18 +16,6 @@
 
 namespace cinn::fusion {
 
-const size_t GetUsageIdx(const pir::Value& v, pir::Operation* op) {
-  size_t i = 0;
-  for (auto consumer_it = v.use_begin(); consumer_it != v.use_end();
-       ++consumer_it, ++i) {
-    if (consumer_it->owner() == op) {
-      return i;
-    }
-  }
-  PADDLE_THROW(phi::errors::NotFound(
-      "Can not find the usage of value %s in op %s", v.impl(), op->name()));
-}
-
 ValueUsage GetValueUsage(const pir::Value& v, const size_t usage_idx) {
   ValueUsage valud_dim;
   size_t rank = GetRank(v);
diff --git a/paddle/cinn/operator_fusion/pir_graph_analyzing/dim_relation.h b/paddle/cinn/operator_fusion/pir_graph_analyzing/dim_relation.h
index 02a7036109b1c3..8b6b4f016bf321 100644
--- a/paddle/cinn/operator_fusion/pir_graph_analyzing/dim_relation.h
+++ b/paddle/cinn/operator_fusion/pir_graph_analyzing/dim_relation.h
@@ -103,7 +103,6 @@ using DimUsageRelation =
 
 DimUsageRelation AnalysisIndexExprRelation(
     const std::vector<pir::Operation*>& ops);
-const size_t GetUsageIdx(const pir::Value& v, pir::Operation* op);
 ValueUsage GetValueUsage(const pir::Value& v, const size_t usage_idx);
 std::string RelationDebugStr(const DimUsageRelation& relation);
 
diff --git a/paddle/cinn/operator_fusion/policy/anchor_search_policy.cc b/paddle/cinn/operator_fusion/policy/anchor_search_policy.cc
index 7c63372961b9bd..3c48a28e276937 100644
--- a/paddle/cinn/operator_fusion/policy/anchor_search_policy.cc
+++ b/paddle/cinn/operator_fusion/policy/anchor_search_policy.cc
@@ -18,17 +18,86 @@
 
 namespace cinn::fusion {
 
-std::vector<AnchorTransformRoute> FindAnchorTransformRoute(
+bool IsLegalRoute(const AnchorTransformRoute& route) {
+  // TODO(@wuzhanfei) we need to judge if this tranform route will reduce
+  // performance
+  return True;
+}
+
+std::optional<AnchorTransformRoute> SearchAnchorTransformRecursively(
+    const pir::Value& begin,
+    const pir::Value& end,
+    AnchorTransformRoute* cur_route,
+    std::unordered_set<pir::Value>* visited,
+    const std::unordered_set<pir::Operation*>& ops) {
+  auto transforms = PossibleTransform(begin);
+  for (auto anchor_transform : transforms) {
+    auto info = GetTransformInfo(anchor_transform);
+    auto dst_value = info.DstValue();
+    cur_route->emplace_back(anchor_transform);
+
+    if (std::holds_alternative<UnsupportTransformPtr>(anchor_transform) ||
+        ops.find(info.op) == ops.end() ||
+        visited->find(dst_value) != visited->end() || !IsLegalRoute(*cur_route))
+      continue;
+
+    visited->emplace(dst_value);
+    if (dst_value == end) {
+      return *cur_route;
+    }
+
+    auto recursive_result = SearchAnchorTransformRecursively(
+        dst_value, end, cur_route, visited, ops);
+    if (recursive_result != std::nullopt) {
+      return recursive_result;
+    }
+
+    cur_route->pop_back();
+  }
+
+  return std::nullopt;
+}
+
+std::optional<AnchorTransformRoute> FindAnchorTransformRoute(
     pir::Value begin, pir::Value end, std::unordered_set<pir::Operation*> ops) {
+  AnchorTransformRoute cur_route;
+  std::unordered_set<pir::Value> visited;
+  visited.emplace(begin);
+
+  return SearchAnchorTransformRecursively(
+      begin, end, &cur_route, &visited, ops);
 }
-bool IsLegalRoute(AnchorTransformRoute route) {}
 
 template <typename T>
 bool AnchorSearchPolicy<T>::HasUpstreamAnchor(
-    const PatternNodePtr<T>& upstream, const PatternNodePtr<T>& downstream) {}
+    const PatternNodePtr<T>& upstream, const PatternNodePtr<T>& downstream) {
+  const auto& upstream_anchor_pattern =
+      std::get<AnchorPattern<T>>(upstream->stmt_pattern());
+  const auto& downstream_anchor_pattern =
+      std::get<AnchorPattern<T>>(downstream->stmt_pattern());
+
+  return FindAnchorTransformRoute(
+             upstream_anchor_pattern.anchor(),
+             downstream_anchor_pattern.anchor(),
+             ToSet(ConcatVector(upstream_anchor_pattern.ops(),
+                                downstream_anchor_pattern.ops()))) !=
+         std::nullopt;
+}
 template <typename T>
 bool AnchorSearchPolicy<T>::HasDownstreamAnchor(
-    const PatternNodePtr<T>& upstream, const PatternNodePtr<T>& downstream) {}
+    const PatternNodePtr<T>& upstream, const PatternNodePtr<T>& downstream) {
+  const auto& upstream_anchor_pattern =
+      std::get<AnchorPattern<T>>(upstream->stmt_pattern());
+  const auto& downstream_anchor_pattern =
+      std::get<AnchorPattern<T>>(downstream->stmt_pattern());
+
+  return FindAnchorTransformRoute(
+             downstream_anchor_pattern.anchor(),
+             upstream_anchor_pattern.anchor(),
+             ToSet(ConcatVector(upstream_anchor_pattern.ops(),
+                                downstream_anchor_pattern.ops()))) !=
+         std::nullopt;
+}
 
 template class AnchorSearchPolicy<FrontendStage>;
 template class AnchorSearchPolicy<BackendStage>;
diff --git a/paddle/cinn/operator_fusion/utils.h b/paddle/cinn/operator_fusion/utils.h
index b83a101f2d0135..e917795ced7787 100644
--- a/paddle/cinn/operator_fusion/utils.h
+++ b/paddle/cinn/operator_fusion/utils.h
@@ -238,4 +238,37 @@ std::vector<T> GatherVectorExcept(const std::vector<T>& source,
   return result;
 }
 
+static const size_t GetUsageIdx(const pir::Value& v, pir::Operation* op) {
+  size_t i = 0;
+  for (auto consumer_it = v.use_begin(); consumer_it != v.use_end();
+       ++consumer_it, ++i) {
+    if (consumer_it->owner() == op) {
+      return i;
+    }
+  }
+  PADDLE_THROW(phi::errors::NotFound(
+      "Can not find the usage of value %s in op %s", v.impl(), op->name()));
+}
+
+static const size_t GetOperandIdx(const pir::Value& v, pir::Operation* op) {
+  for (size_t i = 0; i < op->num_operands(); i++) {
+    if (op->operand(i) == v) {
+      return i;
+    }
+  }
+  PADDLE_THROW(phi::errors::NotFound(
+      "Can not find the value %s as operand of op %s", v.impl(), op->name()));
+}
+
+static const size_t GetResultIdx(const pir::Value& v, pir::Operation* op) {
+  size_t i = 0;
+  for (size_t i = 0; i < op->num_results(); i++) {
+    if (op->result(i) == v) {
+      return i;
+    }
+  }
+  PADDLE_THROW(phi::errors::NotFound(
+      "Can not find the value %s as result of op %s", v.impl(), op->name()));
+}
+
 }  // namespace cinn::fusion

From 8e7d785cc9a7793b281d8ff34d9f3dfb1272951f Mon Sep 17 00:00:00 2001
From: zhangbaizhou <zhangbaizhou@baidu.com>
Date: Mon, 29 Apr 2024 10:59:13 +0000
Subject: [PATCH 29/99] update LiftToAnchorPattern

---
 paddle/cinn/operator_fusion/graph_transformer/operation.h | 4 +++-
 paddle/cinn/operator_fusion/pattern.h                     | 2 +-
 2 files changed, 4 insertions(+), 2 deletions(-)

diff --git a/paddle/cinn/operator_fusion/graph_transformer/operation.h b/paddle/cinn/operator_fusion/graph_transformer/operation.h
index 5f1cd26f4d6724..7df6ffd6fe141f 100644
--- a/paddle/cinn/operator_fusion/graph_transformer/operation.h
+++ b/paddle/cinn/operator_fusion/graph_transformer/operation.h
@@ -132,7 +132,9 @@ struct LiftToHorizontalFusionPatternOperation {
 struct LiftToAnchorPatternOperation {
   template <typename Phrase>
   void operator()(PatternGraph<Phrase>* graph, PatternNodePtr<Phrase> node) {
-    node->set_stmt_pattern(AnchorPattern<Phrase>(node->stmt_pattern()));
+    std::vector<pir::Operation*> ops = GetOpsInPattern(pattern);
+    pir::Value anchor = node->sink_op()->result(0);
+    node->set_stmt_pattern(AnchorPattern<Phrase>(ops, anchor));
   }
 };
 
diff --git a/paddle/cinn/operator_fusion/pattern.h b/paddle/cinn/operator_fusion/pattern.h
index eebdc9be642ced..b38edadadaa500 100644
--- a/paddle/cinn/operator_fusion/pattern.h
+++ b/paddle/cinn/operator_fusion/pattern.h
@@ -91,7 +91,7 @@ struct AnchorPattern {
       const std::vector<pir::Operation*>& ops,
       const pir::Value& anchor const AnchorState<T>& anchor_state)
       : ops_(ops), anchor_(anchor), {
-    // TODO(@wuzhanfei)
+    // TODO(@wuzhanfei): Initialize anchor state
   }
   std::vector<pir::Operation*> ops_;
   pir::Value anchor_;  // Choose only one anchor

From f6f58ee0915ef6f99273d4a4b89d0c5f33dad90e Mon Sep 17 00:00:00 2001
From: xiongkun <xiongkun03@baidu.com>
Date: Mon, 29 Apr 2024 15:45:08 +0000
Subject: [PATCH 30/99] horizontal operator fusion enhance

---
 .../hlir/framework/pir/trivial_op_impl.cc     |  22 ++-
 .../cinn/hlir/framework/pir/trivial_op_impl.h |   2 +
 .../hlir/framework/pir/trivial_op_util.cc     |  74 +++++++-
 .../cinn/hlir/framework/pir/trivial_op_util.h |  13 +-
 .../operator_fusion/backend/pattern_fuser.cc  | 167 +++++++++++++-----
 .../operator_fusion/backend/pattern_fuser.h   |   5 -
 .../operator_fusion/frontend/pattern_fuser.cc |  10 --
 .../operator_fusion/frontend/pattern_fuser.h  |   5 -
 paddle/cinn/operator_fusion/pattern.h         |  18 +-
 paddle/cinn/operator_fusion/pattern_fuser.h   |  66 ++++++-
 paddle/cinn/operator_fusion/pattern_graph.h   |  16 +-
 paddle/cinn/operator_fusion/utils.h           |  11 ++
 .../pir/cinn/test_fusion_softmax_subgraph.py  | 125 +++++++++++++
 13 files changed, 440 insertions(+), 94 deletions(-)
 create mode 100644 test/ir/pir/cinn/test_fusion_softmax_subgraph.py

diff --git a/paddle/cinn/hlir/framework/pir/trivial_op_impl.cc b/paddle/cinn/hlir/framework/pir/trivial_op_impl.cc
index bd0f764630ff4f..090eb658142c99 100644
--- a/paddle/cinn/hlir/framework/pir/trivial_op_impl.cc
+++ b/paddle/cinn/hlir/framework/pir/trivial_op_impl.cc
@@ -186,17 +186,21 @@ std::vector<ir::Var> GetOutputIters(const FusibleOp& op) {
   return AppendBound(std::visit(Visitor(), op), _GetRootExpr(op));
 }
 
+std::vector<ir::Var> GetAllIterVars(const ir::Expr& expr) {
+  ir::Expr compute_schedule_block_realize =
+      (ExprSetFinderUtils::ChildScheduleBlockRealizes *
+       ExprSetFinderUtils::ScheduleBlockRealizeIsNotInit)
+          .GetSingle(expr);
+
+  const std::vector<Expr>& all_iter_expr =
+      compute_schedule_block_realize.As<ir::ScheduleBlockRealize>()
+          ->iter_values;
+  return ComposeUtils::ExprVec2VarVec(all_iter_expr);
+}
+
 std::vector<ir::Var> GetReduceIters(const ReduceOp& op) {
   auto GetUnorderedAllIterVars = [](const ReduceOp& op) {
-    ir::Expr compute_schedule_block_realize =
-        (ExprSetFinderUtils::ChildScheduleBlockRealizes *
-         ExprSetFinderUtils::ScheduleBlockRealizeIsNotInit)
-            .GetSingle(_GetRootExpr(op));
-
-    const std::vector<Expr>& all_iter_expr =
-        compute_schedule_block_realize.As<ir::ScheduleBlockRealize>()
-            ->iter_values;
-    return ComposeUtils::ExprVec2VarVec(all_iter_expr);
+    return GetAllIterVars(_GetRootExpr(op));
   };
 
   // Iter Vars not appearing in outer_iter_vars are pushed into
diff --git a/paddle/cinn/hlir/framework/pir/trivial_op_impl.h b/paddle/cinn/hlir/framework/pir/trivial_op_impl.h
index 46375381237d5b..fe09dc8ae37e46 100644
--- a/paddle/cinn/hlir/framework/pir/trivial_op_impl.h
+++ b/paddle/cinn/hlir/framework/pir/trivial_op_impl.h
@@ -161,6 +161,8 @@ FusibleOp SinkTrivialLoopAlign(TrivialOp trivial_op,
                                ReduceOp reduce_op,
                                std::vector<size_t> fake_reduce_iter_idx);
 
+std::vector<ir::Var> GetAllIterVars(const ir::Expr& expr);
+
 }  // namespace trivial_fusion_detail
 
 struct FusionGroupInfo {
diff --git a/paddle/cinn/hlir/framework/pir/trivial_op_util.cc b/paddle/cinn/hlir/framework/pir/trivial_op_util.cc
index cc7fab0a7c6af8..4a52d91eca3ac0 100644
--- a/paddle/cinn/hlir/framework/pir/trivial_op_util.cc
+++ b/paddle/cinn/hlir/framework/pir/trivial_op_util.cc
@@ -55,7 +55,7 @@ std::vector<ir::Expr> VarVec2ExprVec(const std::vector<ir::Var>& in) {
 std::vector<ir::Expr> GetEachTensorLoadExpr(const ir::Expr& body,
                                             const ir::Tensor& tensor) {
   VLOG(4) << "GetEachTensorLoadExpr: " << tensor;
-  std::set<Expr> load_exprs = cinn::ir::ir_utils::CollectIRNodesWithoutTensor(
+  std::vector<Expr> load_exprs = cinn::ir::ir_utils::CollectIRNodesInOrder(
       body, [&tensor](const Expr* expr) {
         return expr->As<ir::Load>() && expr->As<ir::Load>()->is_addr_tensor() &&
                expr->As<ir::Load>()->tensor.as_tensor_ref()->name ==
@@ -64,7 +64,7 @@ std::vector<ir::Expr> GetEachTensorLoadExpr(const ir::Expr& body,
   for (auto& t : load_exprs) {
     VLOG(4) << "GetEachTensorLoadExpr Found: " << t << " " << t.ptr();
   }
-  return std::vector(load_exprs.begin(), load_exprs.end());
+  return load_exprs;
 }
 
 MappingTargetExprToDestExprMutator::MappingTargetExprToDestExprMutator(
@@ -82,6 +82,16 @@ void MappingTargetExprToDestExprMutator::Visit(const ir::Load* load, Expr* op) {
     IRMutator::Visit(load, op);
   }
 }
+
+void MappingTargetExprToDestExprMutator::Visit(const ir::For* for_node,
+                                               Expr* op) {
+  if (for_node == source_.ptr()) {
+    *op = dest_;
+  } else {
+    IRMutator::Visit(for_node, op);
+  }
+}
+
 void MappingTargetExprToDestExprMutator::Visit(const ir::Store* store,
                                                Expr* op) {
   if (store == source_.ptr()) {
@@ -90,6 +100,7 @@ void MappingTargetExprToDestExprMutator::Visit(const ir::Store* store,
     IRMutator::Visit(store, op);
   }
 }
+
 void MappingTargetExprToDestExprMutator::Visit(const ir::Reduce* reduce,
                                                Expr* op) {
   if (reduce == source_.ptr()) {
@@ -193,7 +204,7 @@ ExprSetFinder ExprSetFinder::operator*(ExprSetFinder x) const {
     std::vector<ir::Expr> res;
     for (const auto& r : rs) {
       const auto& x_res = x.f_(r);
-      res.insert(res.begin(), x_res.begin(), x_res.end());
+      res.insert(res.end(), x_res.begin(), x_res.end());
     }
     return res;
   };
@@ -243,6 +254,15 @@ ExprSetFinder ScheduleBlockRealizeNotRoot = FilterMaker(
     },
     "ScheduleBlockRealizeNotRoot");
 
+ExprSetFinder ScheduleBlockRealizeIsRoot = FilterMaker(
+    [](const ir::Expr& e) -> bool {
+      return (e.As<ir::ScheduleBlockRealize>() &&
+              e.As<ir::ScheduleBlockRealize>()
+                      ->schedule_block.As<ir::ScheduleBlock>()
+                      ->name.find("root") != std::string::npos);
+    },
+    "ScheduleBlockRealizeIsRoot");
+
 ExprSetFinder ScheduleBlockRealizeIsNotInit = FilterMaker(
     [](const ir::Expr& e) -> bool {
       return (e.As<ir::ScheduleBlockRealize>() &&
@@ -274,6 +294,12 @@ ExprSetFinder ChildScheduleBlockRealizes =
         "ChildScheduleBlockRealizes") *
     ScheduleBlockRealizeNotRoot;
 
+ExprSetFinder ChildRootScheduleBlockRealizes =
+    Collector(
+        [](const ir::Expr* e) { return e->As<ir::ScheduleBlockRealize>(); },
+        "ChildScheduleBlockRealizes") *
+    ScheduleBlockRealizeIsRoot;
+
 ExprSetFinder IsForIterVar(const ir::Var& var) {
   return FilterMaker(
       [var = var](const ir::Expr& e) -> bool {
@@ -321,8 +347,10 @@ ExprSetFinder FindFather(const ir::Expr& root) {
   const auto& f = [&](const auto& child) -> ExprSet {
     ExprSetFinder find_child =
         Collector([child](const ir::Expr* e) { return *e == child; });
-    const auto& father_collector = Collector(
-        [&](const ir::Expr* current) { return !find_child(*current).empty(); });
+    const auto& father_collector = Collector([&](const ir::Expr* current) {
+      auto res = (*current != child) && !find_child(*current).empty();
+      return res;
+    });
     return father_collector(root);
   };
   return ExprSetFinder(f, "FindFather");
@@ -370,6 +398,34 @@ ExprTransformer WrapForsTransformer(const std::vector<ir::Var>& vs) {
   return ExprTransformer(f);
 }
 
+ExprTransformer UnsqueezeForTransformer(
+    const ExprSetFinderUtils::ExprSetFinder& followed_finder,
+    const ir::Var& to_append_var) {
+  const auto& f = [&](const ir::Expr& e) -> ir::Expr {
+    auto copied_e = ir::ir_utils::IRCopy(e);
+    ir::Expr followed_expr = followed_finder.GetSingle(copied_e);
+    // (ExprSetFinderUtils::ChildFors *
+    // ExprSetFinderUtils::IsForIterVar(following_for_iter_var)).GetSingle(copied_e);
+    VLOG(6) << "UnsqueezeForTransformer: for insert after " << followed_expr;
+    if (followed_expr.As<ir::For>()) {
+      followed_expr.As<ir::For>()->body = ir::Block::Make({WrapForTransformer(
+          to_append_var)(followed_expr.As<ir::For>()->body)});
+    } else if (followed_expr.As<ir::ScheduleBlockRealize>()) {
+      const auto& schedule_block = followed_expr.As<ir::ScheduleBlockRealize>()
+                                       ->schedule_block.As<ir::ScheduleBlock>();
+      schedule_block->body =
+          WrapForTransformer(to_append_var)(schedule_block->body);
+    } else {
+      VLOG(6) << "UnsqueezeForTransformer: only support insert after a (For / "
+                 "ScheduleBlockRealizer): "
+              << followed_expr;
+    }
+    VLOG(6) << "UnsqueezeForTransformer: After changed: " << copied_e;
+    return copied_e;
+  };
+  return ExprTransformer(f);
+}
+
 ExprTransformer ChangeTensorLoadTransformer(const ir::Tensor& tensor,
                                             const ir::Expr& dst_load) {
   const auto& f = [&](const ir::Expr& e) -> ir::Expr {
@@ -417,6 +473,14 @@ ExprTransformer ChangeVarTransformer(const std::vector<ir::Var>& target_vars,
   return ExprTransformer(f);
 }
 
+ExprTransformer ReplaceVarTransformer(const std::vector<ir::Var>& target_vars,
+                                      const std::vector<ir::Expr>& dest_expr) {
+  const auto& f = [=](const ir::Expr& e) -> ir::Expr {
+    return ComposeUtils::CopyedReplaceExpr(e, target_vars, dest_expr);
+  };
+  return ExprTransformer(f);
+}
+
 bool IsReduceBool(const ir::Expr& lhs, const ir::Expr& rhs) {
   return lhs.type().is_bool() || rhs.type().is_bool();
 }
diff --git a/paddle/cinn/hlir/framework/pir/trivial_op_util.h b/paddle/cinn/hlir/framework/pir/trivial_op_util.h
index 9dbddc6ada18c6..9f620ff3f886f0 100644
--- a/paddle/cinn/hlir/framework/pir/trivial_op_util.h
+++ b/paddle/cinn/hlir/framework/pir/trivial_op_util.h
@@ -74,6 +74,7 @@ struct MappingTargetExprToDestExprMutator : public ir::IRMutator<> {
   void Visit(const ir::Load* load, Expr* op) override;
   void Visit(const ir::Store* store, Expr* op) override;
   void Visit(const ir::Reduce* reduce, Expr* op) override;
+  void Visit(const ir::For* for_node, Expr* op) override;
 
  private:
   ir::Expr source_;
@@ -128,7 +129,7 @@ template <typename Teller>
 ExprSetFinder Collector(Teller t, std::string name = "") {
   return ExprSetFinder(
       [=](const ir::Expr& x) -> ExprSet {
-        const auto& rs = cinn::ir::ir_utils::CollectIRNodesWithoutTensor(x, t);
+        const auto& rs = cinn::ir::ir_utils::CollectIRNodesInOrder(x, t);
         return std::vector(rs.begin(), rs.end());
       },
       name);
@@ -166,6 +167,8 @@ extern ExprSetFinder ChildScheduleBlocks;
 
 extern ExprSetFinder ChildScheduleBlockRealizes;
 
+extern ExprSetFinder ChildRootScheduleBlockRealizes;
+
 extern ExprSetFinder For2Min;
 
 extern ExprSetFinder For2Max;
@@ -226,6 +229,14 @@ std::vector<ir::Var> CreateInnerBlockVars(
 ExprTransformer ChangeVarTransformer(const std::vector<ir::Var>& target_vars,
                                      const std::vector<ir::Var>& dest_vars);
 
+ExprTransformer ReplaceVarTransformer(const std::vector<ir::Var>& target_vars,
+                                      const std::vector<ir::Expr>& dest_exprs);
+
+// insert after followed_finder. only support For and ScheduleBlockRealizer
+ExprTransformer UnsqueezeForTransformer(
+    const ExprSetFinderUtils::ExprSetFinder& followed_finder,
+    const ir::Var& to_append_var);
+
 ExprTransformer SubstitudeByScheduleBlockRealize(const ir::Expr& realize);
 
 ExprTransformer WrapScheduleRealizer(const std::vector<ir::Var>& block_vars,
diff --git a/paddle/cinn/operator_fusion/backend/pattern_fuser.cc b/paddle/cinn/operator_fusion/backend/pattern_fuser.cc
index 1fb285184680c6..d6717acb05cb76 100644
--- a/paddle/cinn/operator_fusion/backend/pattern_fuser.cc
+++ b/paddle/cinn/operator_fusion/backend/pattern_fuser.cc
@@ -77,13 +77,6 @@ StmtPattern<BackendStage> MergePatternImpl(
   return TrivialPattern<BackendStage>(ops, second.sink(), trivial_op);
 }
 
-template <>
-StmtPattern<BackendStage> MergePatternImpl(
-    const HorizontalFusionPattern<BackendStage>& first,
-    const HorizontalFusionPattern<BackendStage>& second) {
-  return HorizontalFusionPattern<BackendStage>({first, second});
-}
-
 /// Start: Tmp Transform Operation for ReduceTree
 std::vector<FusionOp> ReduceTransformRecursive(
     ReduceOp reduce_op,
@@ -138,65 +131,151 @@ std::vector<FusionOp> ReduceTreeTrivialTransformRecursive(
 }
 
 /// End: Tmp Transform Operation for reduce tree
+///
+struct FusionOp2Expr {
+  std::vector<ir::Expr> operator()(const TrivialOp& op) {
+    return {op.GetFuncBody()};
+  }
+  std::vector<ir::Expr> operator()(const ReduceOp& op) {
+    const auto& t_r = SplitReduceOp(op);
+    return {t_r.first.GetFuncBody(), t_r.second.GetFuncBody()};
+  }
+};
 
-std::vector<FusionOp> GetFusionOpFromPattern(
+std::vector<ir::Expr> GetExprFromPattern(
     const StmtPattern<BackendStage>& pattern);
 
-struct FusionOpGetter {
-  std::vector<FusionOp> operator()(
+static std::vector<ir::Var> GetAllForIters(const ir::Expr& expr) {
+  using cinn::hlir::framework::pir::trivial_fusion_detail::ExprSetFinderUtils::
+      ChildFors;
+  using cinn::hlir::framework::pir::trivial_fusion_detail::ExprSetFinderUtils::
+      ChildScheduleBlockRealizes;
+  using cinn::hlir::framework::pir::trivial_fusion_detail::ExprSetFinderUtils::
+      FindFather;
+  using cinn::hlir::framework::pir::trivial_fusion_detail::ExprSetFinderUtils::
+      IsFor;
+  using cinn::hlir::framework::pir::trivial_fusion_detail::ExprSetFinderUtils::
+      ScheduleBlockRealizeIsNotInit;
+  const auto& all_father_fors =
+      (ChildScheduleBlockRealizes * ScheduleBlockRealizeIsNotInit *
+       FindFather(expr) * IsFor)(expr);
+  std::vector<ir::Var> vars;
+  for (const auto& for_expr : all_father_fors) {
+    vars.push_back(for_expr.As<ir::For>()->loop_var);
+  }
+  VLOG(4) << "GetAllForIters : " << expr
+          << "\n var is : " << utils::Join(vars, ",");
+  return vars;
+}
+
+ir::Expr UnSqueezeExpr(const ir::Expr& expr,
+                       const std::vector<int> padding_vec) {
+  using cinn::hlir::framework::pir::trivial_fusion_detail::AppendBound;
+  using cinn::hlir::framework::pir::trivial_fusion_detail::ExprSetFinderUtils::
+      ChildFors;
+  using cinn::hlir::framework::pir::trivial_fusion_detail::ExprSetFinderUtils::
+      ChildRootScheduleBlockRealizes;
+  using cinn::hlir::framework::pir::trivial_fusion_detail::ExprSetFinderUtils::
+      ChildScheduleBlockRealizes;
+  using cinn::hlir::framework::pir::trivial_fusion_detail::ExprSetFinderUtils::
+      IsForIterVar;
+  using cinn::hlir::framework::pir::trivial_fusion_detail::
+      ExprTransformerUtils::ReplaceVarTransformer;
+  using cinn::hlir::framework::pir::trivial_fusion_detail::
+      ExprTransformerUtils::UnsqueezeForTransformer;
+  VLOG(4) << "UnSqueezeExpr: " << expr
+          << "\npadding vector: " << utils::Join(padding_vec, ", ");
+  const auto& vars_in_expr = AppendBound(GetAllForIters(expr), expr);
+  // get the all vars.
+  int counter = 0;
+  auto gen_next_name = [&counter]() {
+    counter += 1;
+    return "expand_var_" + std::to_string(counter);
+  };
+  std::vector<ir::Var> vars;
+  int pointer = 0;
+  for (int i = 0; i < vars_in_expr.size() + padding_vec.size(); i++) {
+    if (std::find(padding_vec.begin(), padding_vec.end(), i) !=
+        padding_vec.end()) {
+      vars.emplace_back(Expr(0), Expr(1), gen_next_name());
+    } else {
+      vars.push_back(vars_in_expr[pointer++]);
+    }
+  }
+  // update the is_reduce of expand_var.
+  for (int i : padding_vec) {
+    if (i == 0) {
+      vars[i]->is_reduce_axis = false;
+    } else {
+      vars[i]->is_reduce_axis = vars[i - 1]->is_reduce_axis;
+    }
+  }
+
+  // sequencely unsqueeze the ir::Expr.
+  ir::Expr result = expr;
+  for (int i : padding_vec) {
+    if (i > 0) {
+      result = UnsqueezeForTransformer((ChildFors * IsForIterVar(vars[i - 1])),
+                                       vars[i])(result);
+    } else {
+      result = UnsqueezeForTransformer(ChildRootScheduleBlockRealizes,
+                                       vars[i])(result);
+    }
+  }
+  return result;
+}
+
+struct IrExprGetter {
+  std::vector<ir::Expr> operator()(
       const TrivialPattern<BackendStage>& pattern) {
-    return {pattern.trivial_op};
+    return FusionOp2Expr()(pattern.trivial_op);
   }
 
-  std::vector<FusionOp> operator()(const ReducePattern<BackendStage>& pattern) {
-    return {pattern.reduce_op};
+  std::vector<ir::Expr> operator()(const ReducePattern<BackendStage>& pattern) {
+    return FusionOp2Expr()(pattern.reduce_op);
   }
 
-  std::vector<FusionOp> operator()(
+  std::vector<ir::Expr> operator()(
       const ReduceTreePattern<BackendStage>& pattern) {
-    return ReduceTransformRecursive(pattern.GetRootPattern().reduce_op,
-                                    pattern);
+    const auto& fusion_op =
+        ReduceTransformRecursive(pattern.GetRootPattern().reduce_op, pattern);
+    std::function<std::vector<ir::Expr>(const FusionOp& f)> func =
+        [](const FusionOp& op) { return std::visit(FusionOp2Expr(), op); };
+    return VectorFlatMap(fusion_op, func);
   }
 
-  std::vector<FusionOp> operator()(
+  std::vector<ir::Expr> operator()(
       const ReduceTreePlusTrivialPattern<BackendStage>& pattern) {
-    return ReduceTreeTrivialTransformRecursive(pattern.sink_trivial.trivial_op,
-                                               pattern);
+    std::function<std::vector<ir::Expr>(const FusionOp& f)> func =
+        [](const FusionOp& op) { return std::visit(FusionOp2Expr(), op); };
+    const auto& fusion_ops = ReduceTreeTrivialTransformRecursive(
+        pattern.sink_trivial.trivial_op, pattern);
+    return VectorFlatMap(fusion_ops, func);
   }
 
-  std::vector<FusionOp> operator()(
+  std::vector<ir::Expr> operator()(
       const HorizontalFusionPattern<BackendStage>& pattern) {
-    std::vector<FusionOp> result;
+    std::vector<ir::Expr> result;
     VLOG(4) << "Get Fusion Ops from HorizontalFusionPattern: "
-            << pattern.patterns_.size();
-    for (const auto& sub_pattern : pattern.patterns_) {
-      result = ConcatVector(result, GetFusionOpFromPattern(sub_pattern));
+            << pattern.padding_patterns_.size();
+    for (const auto& sub_pattern : pattern.padding_patterns_) {
+      std::function<ir::Expr(ir::Expr)> func =
+          [&sub_pattern](const ir::Expr& expr) {
+            return UnSqueezeExpr(expr, sub_pattern.padding_pos);
+          };
+      result = ConcatVector(
+          result, MapVector(GetExprFromPattern(sub_pattern.pattern), func));
     }
     return result;
   }
 
-  std::vector<FusionOp> operator()(
+  std::vector<ir::Expr> operator()(
       const UnsupportPattern<BackendStage>& pattern) {
     CHECK(false) << "Not Implemented.";
   }
 };
 
 // tmp transform for reduce_tree and reduce_tree_trivial.
-std::vector<FusionOp> GetFusionOpFromPattern(
-    const StmtPattern<BackendStage>& pattern) {
-  return std::visit(FusionOpGetter(), pattern.variant());
-}
-
-struct FusionOp2Expr {
-  std::vector<ir::Expr> operator()(const TrivialOp& op) {
-    return {op.GetFuncBody()};
-  }
-  std::vector<ir::Expr> operator()(const ReduceOp& op) {
-    const auto& t_r = SplitReduceOp(op);
-    return {t_r.first.GetFuncBody(), t_r.second.GetFuncBody()};
-  }
-};
-
 std::vector<ir::Tensor> GetOutputTensors(const ir::Expr& op_expr) {
   using cinn::hlir::framework::pir::trivial_fusion_detail::ExprSetFinderUtils::
       ChildScheduleBlockRealizes;
@@ -307,13 +386,7 @@ std::vector<ir::Expr> TopoSort(const std::vector<ir::Expr>& op_exprs) {
 
 std::vector<ir::Expr> GetExprFromPattern(
     const StmtPattern<BackendStage>& pattern) {
-  const auto& fusion_ops = GetFusionOpFromPattern(pattern);
-  VLOG(4) << "GetExprFromPattern from " << GetPatternName(pattern)
-          << " : get fusion op number : " << fusion_ops.size();
-  std::vector<ir::Expr> results;
-  for (const auto& op : fusion_ops) {
-    results = ConcatVector(results, std::visit(FusionOp2Expr(), op));
-  }
+  const auto& results = std::visit(IrExprGetter(), pattern.variant());
   return TopoSort(results);
 }
 
diff --git a/paddle/cinn/operator_fusion/backend/pattern_fuser.h b/paddle/cinn/operator_fusion/backend/pattern_fuser.h
index a460d67f8e02fd..345972f36cab22 100644
--- a/paddle/cinn/operator_fusion/backend/pattern_fuser.h
+++ b/paddle/cinn/operator_fusion/backend/pattern_fuser.h
@@ -41,11 +41,6 @@ StmtPattern<BackendStage> MergePatternImpl(
     const TrivialPattern<BackendStage>& first,
     const TrivialPattern<BackendStage>& second);
 
-template <>
-StmtPattern<BackendStage> MergePatternImpl(
-    const HorizontalFusionPattern<BackendStage>& first,
-    const HorizontalFusionPattern<BackendStage>& second);
-
 std::vector<ir::Expr> GetExprFromPattern(
     const StmtPattern<BackendStage>& pattern);
 
diff --git a/paddle/cinn/operator_fusion/frontend/pattern_fuser.cc b/paddle/cinn/operator_fusion/frontend/pattern_fuser.cc
index a956220baae182..f7dca31623879d 100644
--- a/paddle/cinn/operator_fusion/frontend/pattern_fuser.cc
+++ b/paddle/cinn/operator_fusion/frontend/pattern_fuser.cc
@@ -61,14 +61,4 @@ StmtPattern<FrontendStage> MergePatternImpl(
   return TrivialPattern<FrontendStage>(contents, second.sink());
 }
 
-template <>
-StmtPattern<FrontendStage> MergePatternImpl(
-    const HorizontalFusionPattern<FrontendStage>& first,
-    const HorizontalFusionPattern<FrontendStage>& second) {
-  const auto& contents =
-      UniqueConcatVector(GetOpsInPattern<FrontendStage>(first),
-                         GetOpsInPattern<FrontendStage>(second));
-  return HorizontalFusionPattern<FrontendStage>({first, second});
-}
-
 }  // namespace cinn::fusion
diff --git a/paddle/cinn/operator_fusion/frontend/pattern_fuser.h b/paddle/cinn/operator_fusion/frontend/pattern_fuser.h
index d92b8429ad16b6..cd6dfbcf8fed45 100644
--- a/paddle/cinn/operator_fusion/frontend/pattern_fuser.h
+++ b/paddle/cinn/operator_fusion/frontend/pattern_fuser.h
@@ -41,9 +41,4 @@ StmtPattern<FrontendStage> MergePatternImpl(
     const TrivialPattern<FrontendStage>& first,
     const TrivialPattern<FrontendStage>& second);
 
-template <>
-StmtPattern<FrontendStage> MergePatternImpl(
-    const HorizontalFusionPattern<FrontendStage>& first,
-    const HorizontalFusionPattern<FrontendStage>& second);
-
 }  // namespace cinn::fusion
diff --git a/paddle/cinn/operator_fusion/pattern.h b/paddle/cinn/operator_fusion/pattern.h
index 73558dd1535ad9..fd31fb81f06fb7 100644
--- a/paddle/cinn/operator_fusion/pattern.h
+++ b/paddle/cinn/operator_fusion/pattern.h
@@ -86,13 +86,21 @@ struct UnsupportPattern {};
 
 template <typename T>
 struct HorizontalFusionPattern {
-  explicit HorizontalFusionPattern(const std::vector<StmtPattern<T>>& patterns)
-      : patterns_(patterns) {}
-  std::vector<StmtPattern<T>> patterns_;
+  struct PaddingStmtPattern {
+    StmtPattern<T> pattern;
+    std::vector<int> padding_pos;
+    PaddingStmtPattern(const StmtPattern<T>& pattern,
+                       const std::vector<int>& padding_pos)
+        : pattern(pattern), padding_pos(padding_pos) {}
+  };
+  explicit HorizontalFusionPattern(
+      const std::vector<PaddingStmtPattern>& patterns)
+      : padding_patterns_(patterns) {}
+  std::vector<PaddingStmtPattern> padding_patterns_;
   std::vector<pir::Operation*> ops() const {
     std::vector<pir::Operation*> result;
-    for (const auto& pattern : patterns_) {
-      auto ops = GetOpsInPattern(pattern);
+    for (const auto& pattern : padding_patterns_) {
+      auto ops = GetOpsInPattern(pattern.pattern);
       ExtendVector(&result, ops);
     }
     return result;
diff --git a/paddle/cinn/operator_fusion/pattern_fuser.h b/paddle/cinn/operator_fusion/pattern_fuser.h
index 00d7cc88a2c9f6..6c7f62e8304b43 100644
--- a/paddle/cinn/operator_fusion/pattern_fuser.h
+++ b/paddle/cinn/operator_fusion/pattern_fuser.h
@@ -88,8 +88,19 @@ struct LoopFrameworkVisitor {
 
   MaybeLoopFramework operator()(const HorizontalFusionPattern<T>& pattern) {
     // Horizontal Fusion must have the same loop framework.
-    const auto& exprs =
-        GetLoopFramework(StmtPattern<T>(pattern.patterns_.back()));
+    VLOG(4) << "Get horizontal fusion pattern for loop framework.";
+    const auto& base_exprs = GetLoopFramework(
+        StmtPattern<T>(pattern.padding_patterns_.back().pattern));
+    const auto& padding_vector = pattern.padding_patterns_.back().padding_pos;
+    std::vector<symbol::DimExpr> exprs(
+        base_exprs.size() + padding_vector.size(), 1);
+    int pointer = 0;
+    for (int i = 0; i < exprs.size(); i++) {
+      if (std::find(padding_vector.begin(), padding_vector.end(), i) ==
+          padding_vector.end()) {
+        exprs[i] = base_exprs[pointer++];
+      }
+    }
     return exprs;
   }
 
@@ -255,6 +266,57 @@ StmtPattern<T> MergePatternImpl(const ReduceTreePattern<T>& upstream,
   return result;
 }
 
+inline auto GetPaddingVector(const MaybeLoopFramework& first,
+                             const MaybeLoopFramework& second) {
+  // two pointer to get the padding body.
+  std::vector<int> padding_f;
+  std::vector<int> padding_s;
+  VLOG(4) << "GetPaddingVector for: " << utils::Join(first, ",") << " vs "
+          << utils::Join(second, ",");
+  std::function<void(int, int, int)> recursive_padding =
+      [&first, &second, &padding_f, &padding_s, &recursive_padding](
+          int pf, int ps, int padding_size) {
+        if (pf == first.size() && ps == second.size()) {
+          return;
+        } else if (pf == first.size()) {
+          PADDLE_ENFORCE(second[ps] == 1, "second[ps] must be '1' to padding.");
+          padding_f.push_back(padding_size);
+          recursive_padding(pf, ps + 1, padding_size + 1);
+        } else if (ps == second.size()) {
+          PADDLE_ENFORCE(first[pf] == 1, "second[ps] must be '1' to padding.");
+          padding_s.push_back(padding_size);
+          recursive_padding(pf + 1, ps, padding_size + 1);
+        } else if (second[ps] == first[pf]) {
+          recursive_padding(pf + 1, ps + 1, padding_size + 1);
+        } else if (second[ps] == 1) {
+          padding_f.push_back(padding_size);
+          recursive_padding(pf, ps + 1, padding_size + 1);
+        } else if (first[ps] == 1) {
+          padding_s.push_back(padding_size);
+          recursive_padding(pf + 1, ps, padding_size + 1);
+        } else {
+          PADDLE_THROW("Padding Error.");
+        }
+      };
+  recursive_padding(0, 0, 0);
+  VLOG(4) << "GetPaddingVector result: " << utils::Join(padding_f, ",")
+          << " vs " << utils::Join(padding_s, ",");
+  return std::tuple(padding_f, padding_s);
+}
+
+template <typename T>
+StmtPattern<T> MergePatternImpl(const HorizontalFusionPattern<T>& first,
+                                const HorizontalFusionPattern<T>& second) {
+  const auto& [f, s] =
+      GetPaddingVector(GetLoopFramework(StmtPattern<T>(first)),
+                       GetLoopFramework(StmtPattern<T>(second)));
+  typename HorizontalFusionPattern<T>::PaddingStmtPattern pad_first = {first,
+                                                                       f};
+  typename HorizontalFusionPattern<T>::PaddingStmtPattern pad_second = {second,
+                                                                        s};
+  return HorizontalFusionPattern<T>({pad_first, pad_second});
+}
+
 template <typename T>
 StmtPattern<T> MergePatternImpl(const ReduceTreePattern<T>& first,
                                 const TrivialPattern<T>& second);
diff --git a/paddle/cinn/operator_fusion/pattern_graph.h b/paddle/cinn/operator_fusion/pattern_graph.h
index e6e1559e02f9a5..e113af683b53d9 100644
--- a/paddle/cinn/operator_fusion/pattern_graph.h
+++ b/paddle/cinn/operator_fusion/pattern_graph.h
@@ -241,8 +241,9 @@ struct MergeTrivialPatternOperation {
 struct LiftToHorizontalFusionPatternOperation {
   template <typename Phrase>
   void operator()(PatternGraph<Phrase>* graph, PatternNodePtr<Phrase> node) {
-    node->set_stmt_pattern(
-        HorizontalFusionPattern<Phrase>({node->stmt_pattern()}));
+    node->set_stmt_pattern(HorizontalFusionPattern<Phrase>(
+        {typename HorizontalFusionPattern<Phrase>::PaddingStmtPattern(
+            node->stmt_pattern(), {})}));
   }
 };
 
@@ -251,6 +252,7 @@ struct HorizontalFusionOperation {
   void operator()(PatternGraph<Phrase>* graph,
                   const PatternNodePtr<Phrase>& i,
                   const PatternNodePtr<Phrase>& j) {
+    VLOG(4) << "Start HorizontalFusionOperation";
     PADDLE_ENFORCE_EQ(
         GetPatternName(i->stmt_pattern()),
         HorizontalFusionPattern<Phrase>::name(),
@@ -265,9 +267,13 @@ struct HorizontalFusionOperation {
             "The pattern of the second node should be HorizontalFusionPattern, "
             "but got %s.",
             GetPatternName(j->stmt_pattern())));
-    graph->MergeNode(i, j, MergePattern<Phrase>);
+    auto merged_node = graph->MergeNode(i, j, MergePattern<Phrase>);
+    VLOG(4) << "MergeHorizontalPattern: \ni " << i->DebugStr() << "\nj "
+            << j->DebugStr() << "\nmerged " << merged_node->DebugStr();
     graph->RemoveNode(i);
     graph->RemoveNode(j);
+    VLOG(4) << "After HorizontalFusionOperation, Graph is"
+            << graph->GraphInfo();
   }
 };
 
@@ -339,8 +345,8 @@ struct HorizontalFusionConstrain {
         std::get<HorizontalFusionPattern<T>>(rhs->stmt_pattern());
 
     return graph.topo_manager().CanFuse(lhs, rhs) &&
-           IsLoopFrameworkEqual(lhs_pattern.patterns_.back(),
-                                rhs_pattern.patterns_.back());
+           IsLoopFrameworkEqual(lhs_pattern.padding_patterns_.back().pattern,
+                                rhs_pattern.padding_patterns_.back().pattern);
   }
 };
 
diff --git a/paddle/cinn/operator_fusion/utils.h b/paddle/cinn/operator_fusion/utils.h
index 29d8a2f0e064c0..fae75363a3fe9e 100644
--- a/paddle/cinn/operator_fusion/utils.h
+++ b/paddle/cinn/operator_fusion/utils.h
@@ -330,4 +330,15 @@ std::vector<T> SliceVector(const std::vector<T>& inp, int start, int end) {
   }
   return result;
 }
+
+template <typename T, typename U>
+std::vector<U> VectorFlatMap(
+    const std::vector<T>& inp,
+    const std::function<std::vector<U>(const T&)>& func) {
+  std::vector<U> result;
+  for (const auto& i : inp) {
+    result = ConcatVector(result, func(i));
+  }
+  return result;
+}
 }  // namespace cinn::fusion
diff --git a/test/ir/pir/cinn/test_fusion_softmax_subgraph.py b/test/ir/pir/cinn/test_fusion_softmax_subgraph.py
new file mode 100644
index 00000000000000..950530a1bd28eb
--- /dev/null
+++ b/test/ir/pir/cinn/test_fusion_softmax_subgraph.py
@@ -0,0 +1,125 @@
+# Copyright (c) 2024 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.
+
+import os
+import unittest
+
+import numpy
+
+os.environ['FLAGS_cinn_new_group_scheduler'] = '1'
+os.environ['FLAGS_group_schedule_tiling_first'] = '1'
+os.environ['FLAGS_prim_all'] = 'true'
+os.environ['FLAGS_prim_enable_dynamic'] = 'true'
+os.environ['FLAGS_print_ir'] = '1'
+os.environ['FLAGS_enable_pir_api'] = '1'
+os.environ['FLAGS_use_cinn'] = '1'
+os.environ['FLAGS_cinn_bucket_compile'] = '1'
+
+from utils import check_jit_kernel_number
+
+import paddle
+
+build_strategy = paddle.static.BuildStrategy()
+build_strategy.build_cinn_pass = True
+
+
+class TestFusion(unittest.TestCase):
+    def setUp(self):
+        pass
+
+    def tearDown(self):
+        pass
+
+    def compare_result(
+        self, dy_compute, data_init, input_spec, expect_fusion_num
+    ):
+        static_compute = paddle.jit.to_static(
+            full_graph=True,
+            build_strategy=build_strategy,
+            input_spec=input_spec(),
+        )(dy_compute)
+        inputs = data_init()
+        dy_out = dy_compute(*inputs)
+        st_out = static_compute(*inputs)
+        if isinstance(dy_out, paddle.Tensor):
+            numpy.testing.assert_allclose(dy_out, st_out, atol=1e-5, rtol=1e-6)
+            return
+        for d, s in zip(dy_out, st_out):
+            numpy.testing.assert_allclose(d, s, atol=1e-5, rtol=1e-6)
+        check_jit_kernel_number(static_compute, expect_fusion_num)
+
+    def test_softmax(self):
+        def func(var_40, var_106):
+            var_109 = paddle.cast(var_40, dtype='float32')
+            var_110 = var_106 + var_109
+            var_111 = paddle.cast(var_110, dtype='float32')
+            var_112 = paddle.max(var_111, keepdim=True, axis=[-1])
+            var_113 = var_111 - var_112
+            var_114 = paddle.exp(var_113)
+            var_115 = paddle.sum(var_114, keepdim=True, axis=[-1])
+            var_116 = var_114 / var_115
+            var_117 = paddle.cast(var_116, dtype='float32')
+            return var_116, var_117
+
+        def init():
+            var_40 = paddle.rand([1, 1, 17, 17])
+            var_40 = paddle.cast(var_40, 'float64')
+            var_106 = paddle.rand([1, 32, 17, 17])
+            return var_40, var_106
+
+        def input_spec():
+            return [
+                paddle.static.InputSpec(
+                    shape=[1, 1, 17, 17], dtype='float64', name='var_40'
+                ),
+                paddle.static.InputSpec(
+                    shape=[1, 32, 17, 17], dtype='float32', name='var_106'
+                ),
+            ]
+
+        self.compare_result(func, init, input_spec, 1)
+
+    def test_horizontal_1(self):
+        def func(x):
+            ret1 = x * 2 * 2
+            ret2 = paddle.reshape(ret1, [1, 1, 17, 17])
+            return ret1, ret2
+
+        def init():
+            x = paddle.rand([17, 17])
+            return (x,)
+
+        def input_spec():
+            return None
+
+        self.compare_result(func, init, input_spec, 1)
+
+    def test_horizontal_2(self):
+        def func(x):
+            ret1 = x * 2 * 2
+            ret2 = paddle.reshape(ret1, [1, 17, 1, 1, 17, 1, 1])
+            return ret1, ret2
+
+        def init():
+            x = paddle.rand([17, 17])
+            return (x,)
+
+        def input_spec():
+            return None
+
+        self.compare_result(func, init, input_spec, 1)
+
+
+if __name__ == "__main__":
+    unittest.main()

From affebad64dbaf2b6b34e7789ff53b9a2141825ec Mon Sep 17 00:00:00 2001
From: zhangbaizhou <zhangbaizhou@baidu.com>
Date: Tue, 30 Apr 2024 06:28:53 +0000
Subject: [PATCH 31/99] Implementation of anchor pattern recomputing mechanism

---
 .../operator_fusion/backend/pattern_fuser.cc  |  7 ++
 .../operator_fusion/backend/pattern_fuser.h   |  5 ++
 .../operator_fusion/frontend/pattern_fuser.cc |  7 ++
 .../operator_fusion/frontend/pattern_fuser.h  |  5 ++
 .../graph_transformer/matcher.h               |  5 +-
 .../graph_transformer/operation.h             | 85 ++++++++++---------
 paddle/cinn/operator_fusion/pattern.h         | 21 +++++
 paddle/cinn/operator_fusion/pattern_fuser.h   |  7 ++
 paddle/cinn/operator_fusion/pattern_graph.cc  |  2 -
 .../operator_fusion/policy/policy_manager.h   |  1 +
 10 files changed, 103 insertions(+), 42 deletions(-)

diff --git a/paddle/cinn/operator_fusion/backend/pattern_fuser.cc b/paddle/cinn/operator_fusion/backend/pattern_fuser.cc
index 61e8fd658f94a6..2f1af83d9c1a99 100644
--- a/paddle/cinn/operator_fusion/backend/pattern_fuser.cc
+++ b/paddle/cinn/operator_fusion/backend/pattern_fuser.cc
@@ -77,6 +77,13 @@ StmtPattern<BackendStage> MergePatternImpl(
   return TrivialPattern<BackendStage>(ops, trivial_op);
 }
 
+template <>
+StmtPattern<BackendStage> MergePatternImpl(
+    const AnchorPattern<BackendStage>& first,
+    const AnchorPattern<BackendStage>& second) {
+  // TODO(@wuzhanfei)
+}
+
 template <>
 StmtPattern<BackendStage> MergePatternImpl(
     const HorizontalFusionPattern<BackendStage>& first,
diff --git a/paddle/cinn/operator_fusion/backend/pattern_fuser.h b/paddle/cinn/operator_fusion/backend/pattern_fuser.h
index a460d67f8e02fd..fcd3a3acf0f5f5 100644
--- a/paddle/cinn/operator_fusion/backend/pattern_fuser.h
+++ b/paddle/cinn/operator_fusion/backend/pattern_fuser.h
@@ -41,6 +41,11 @@ StmtPattern<BackendStage> MergePatternImpl(
     const TrivialPattern<BackendStage>& first,
     const TrivialPattern<BackendStage>& second);
 
+template <>
+StmtPattern<BackendStage> MergePatternImpl(
+    const AnchorPattern<BackendStage>& first,
+    const AnchorPattern<BackendStage>& second);
+
 template <>
 StmtPattern<BackendStage> MergePatternImpl(
     const HorizontalFusionPattern<BackendStage>& first,
diff --git a/paddle/cinn/operator_fusion/frontend/pattern_fuser.cc b/paddle/cinn/operator_fusion/frontend/pattern_fuser.cc
index 332230f4099791..5207a499b0cadc 100644
--- a/paddle/cinn/operator_fusion/frontend/pattern_fuser.cc
+++ b/paddle/cinn/operator_fusion/frontend/pattern_fuser.cc
@@ -61,6 +61,13 @@ StmtPattern<FrontendStage> MergePatternImpl(
   return TrivialPattern<FrontendStage>(contents);
 }
 
+template <>
+StmtPattern<FrontendStage> MergePatternImpl(
+    const AnchorPattern<FrontendStage>& first,
+    const AnchorPattern<FrontendStage>& second) {
+  // TODO(@wuzhanfei)
+}
+
 template <>
 StmtPattern<FrontendStage> MergePatternImpl(
     const HorizontalFusionPattern<FrontendStage>& first,
diff --git a/paddle/cinn/operator_fusion/frontend/pattern_fuser.h b/paddle/cinn/operator_fusion/frontend/pattern_fuser.h
index d92b8429ad16b6..9830fd57ed226c 100644
--- a/paddle/cinn/operator_fusion/frontend/pattern_fuser.h
+++ b/paddle/cinn/operator_fusion/frontend/pattern_fuser.h
@@ -41,6 +41,11 @@ StmtPattern<FrontendStage> MergePatternImpl(
     const TrivialPattern<FrontendStage>& first,
     const TrivialPattern<FrontendStage>& second);
 
+template <>
+StmtPattern<FrontendStage> MergePatternImpl(
+    const AnchorPattern<FrontendStage>& first,
+    const AnchorPattern<FrontendStage>& second);
+
 template <>
 StmtPattern<FrontendStage> MergePatternImpl(
     const HorizontalFusionPattern<FrontendStage>& first,
diff --git a/paddle/cinn/operator_fusion/graph_transformer/matcher.h b/paddle/cinn/operator_fusion/graph_transformer/matcher.h
index 0274941dd464f6..0e3cba7623f75e 100644
--- a/paddle/cinn/operator_fusion/graph_transformer/matcher.h
+++ b/paddle/cinn/operator_fusion/graph_transformer/matcher.h
@@ -92,8 +92,9 @@ struct CanFuseReduceTreeAndTrivialMatcher {
 struct RecomputeNodeMatcher {
   template <typename T>
   bool operator()(const PatternGraph<T>& graph, const PatternNodePtr<T>& node) {
-    // TODO(@wuzhanfei)
-    return false;
+    return StmtPatternGraphMatcher<AnchorPattern<T>>()(graph, node) &&
+           node->downstream().size() > 1 &&
+           (node->stmt_pattern.can_recompute());
   }
 };
 
diff --git a/paddle/cinn/operator_fusion/graph_transformer/operation.h b/paddle/cinn/operator_fusion/graph_transformer/operation.h
index 7df6ffd6fe141f..44fb22e5f6a745 100644
--- a/paddle/cinn/operator_fusion/graph_transformer/operation.h
+++ b/paddle/cinn/operator_fusion/graph_transformer/operation.h
@@ -80,47 +80,23 @@ struct LiftReduceToReduceTreeOperation {
 
 struct MergeTrivialPatternOperation {
   template <typename Phrase>
-  void operator()(PatternGraph<Phrase>* graph,
-                  PatternNodePtr<Phrase> upstream) {
+  void operator()(PatternGraph<Phrase>* graph, PatternNodePtr<Phrase> node) {
+    PADDLE_ENFORCE_EQ(
+        node->downstream().size(),
+        1,
+        phi::errors::PreconditionNotMet("The downstream of the Sink Trivial "
+                                        "Pattern node should be 1, but got %d.",
+                                        node->downstream().size()));
     const auto& downstream = node->downstream().at(0);
-    auto merged_node =
-        graph->MergeNode(upstream, downstream, MergePattern<Phrase>);
+    auto merged_node = graph->MergeNode(node, downstream, MergePattern<Phrase>);
     graph->RemoveNode(downstream);
-    VLOG(4) << "MergeTrivialPatternOperation: \nupstream "
-            << upstream->DebugStr() << "\ndownstream " << downstream->DebugStr()
-            << "\nmerged " << merged_node->DebugStr();
+    graph->RemoveNode(node);
+    VLOG(4) << "MergeTrivialPatternOperation: \nupstream " << node->DebugStr()
+            << "\ndownstream " << downstream->DebugStr() << "\nmerged "
+            << merged_node->DebugStr();
   }
 };
 
-// struct MergeTrivialPatternOperation {
-//   template <typename Phrase>
-//   void operator()(PatternGraph<Phrase>* graph,
-//                   PatternNodePtr<Phrase> upstream) {
-//     std::vector<PatternNodePtr<Phrase>> fusion_candidate =
-//         upstream->downstream();
-//     upstream->ClearDownstream();
-//     for (const auto& downstream : fusion_candidate) {
-//       if (std::holds_alternative<ReducePattern<Phrase>>(
-//               downstream->stmt_pattern()) ||
-//           std::holds_alternative<TrivialPattern<Phrase>>(
-//               downstream->stmt_pattern())) {
-//         auto merged_node =
-//             graph->MergeNode(upstream, downstream, MergePattern<Phrase>);
-//         graph->RemoveNode(downstream);
-//         VLOG(4) << "MergeTrivialPatternOperation: \nupstream "
-//                 << upstream->DebugStr() << "\ndownstream "
-//                 << downstream->DebugStr() << "\nmerged "
-//                 << merged_node->DebugStr();
-//       } else {
-//         upstream->AddNodeToDownstream(downstream);
-//       }
-//     }
-//     if (upstream->downstream().empty()) {
-//       graph->RemoveNode(upstream);
-//     }
-//   }
-// };
-
 struct LiftToHorizontalFusionPatternOperation {
   template <typename Phrase>
   void operator()(PatternGraph<Phrase>* graph, PatternNodePtr<Phrase> node) {
@@ -158,8 +134,41 @@ struct FuseDownstreamAnchorOperation {
 
 struct SplitRecomputeOperation {
   template <typename Phrase>
-  void operator()(PatternGraph<Phrase>* graph, PatternNodePtr<Phrase> node) {
-    // TODO(@wuzhanfei)
+  void operator()(PatternGraph<Phrase>* graph,
+                  PatternNodePtr<Phrase> upstream) {
+    PADDLE_ENFORCE_GT(upstream->downstream().size(),
+                      1,
+                      phi::errors::PreconditionNotMet(
+                          "The downstream of node for recomputation should be "
+                          "more than 1, but got %d.",
+                          upstream->downstream().size()));
+
+    std::vector<PatternNodePtr<Phrase>> fusion_candidate =
+        upstream->downstream();
+    upstream->ClearDownstream();
+
+    for (const auto& downstream : fusion_candidate) {
+      bool can_fuse = graph->policy_manager()
+                          .template GetPolicy<AnchorSearchPolicy>()
+                          ->HasDownstreamAnchor(upstream, downstream) ||
+                      graph->policy_manager()
+                          .template GetPolicy<AnchorSearchPolicy>()
+                          ->HasUpstreamAnchor(upstream, downstream);
+      if (can_fuse) {
+        auto merged_node =
+            graph->MergeNode(upstream, downstream, MergePattern<Phrase>);
+        graph->RemoveNode(downstream);
+        VLOG(4) << "Spliting recomputable anchor pattern: \nupstream "
+                << upstream->DebugStr() << "\ndownstream "
+                << downstream->DebugStr() << "\nmerged "
+                << merged_node->DebugStr();
+      } else {
+        upstream->AddNodeToDownstream(downstream);
+      }
+    }
+    if (upstream->downstream().empty()) {
+      graph->RemoveNode(upstream);
+    }
   }
 };
 
diff --git a/paddle/cinn/operator_fusion/pattern.h b/paddle/cinn/operator_fusion/pattern.h
index b38edadadaa500..fd87cac01faa71 100644
--- a/paddle/cinn/operator_fusion/pattern.h
+++ b/paddle/cinn/operator_fusion/pattern.h
@@ -99,6 +99,27 @@ struct AnchorPattern {
   std::vector<pir::Operation*> ops() const { return ops_; }
   std::vector<pir::Value> outputs() const { return outputs_; }
   pir::Value anchor() const { return anchor_; }
+
+  bool can_recompute() const {
+    // Current Algorithm:
+    // An AnchorPattern can be recomputed iff:
+    // 1. It didn't go through any pattern merging during prior fusions, which
+    // means it only has one output_expr in anchor_state.
+    // 2. It only contains trivial ops.
+
+    if (anchor_state.output_exprs.size() > 1) {
+      return false;
+    }
+
+    for (const auto& op : ops_) {
+      const auto& op_kind = GetOpPatternKind(op);
+      if (op_kind >= hlir::framework::kReduction) {
+        return false;
+      }
+    }
+
+    return true;
+  }
   static std::string name() { return "AnchorPattern"; }
 };
 
diff --git a/paddle/cinn/operator_fusion/pattern_fuser.h b/paddle/cinn/operator_fusion/pattern_fuser.h
index 802031b6b23045..83ab1f13c4c32e 100644
--- a/paddle/cinn/operator_fusion/pattern_fuser.h
+++ b/paddle/cinn/operator_fusion/pattern_fuser.h
@@ -171,6 +171,10 @@ template <typename T>
 StmtPattern<T> MergePatternImpl(const TrivialPattern<T>& first,
                                 const TrivialPattern<T>& second);
 
+template <typename T>
+StmtPattern<T> MergePatternImpl(const AnchorPattern<T>& first,
+                                const AnchorPattern<T>& second);
+
 template <typename T>
 StmtPattern<T> MergePatternImpl(const HorizontalFusionPattern<T>& first,
                                 const HorizontalFusionPattern<T>& second);
@@ -193,6 +197,9 @@ StmtPattern<T> MergePattern(const StmtPattern<T>& first,
       [&](const TrivialPattern<T>& lhs, const TrivialPattern<T>& rhs) {
         return MergePatternImpl(lhs, rhs);
       },
+      [&](const AnchorPattern<T>& lhs, const AnchorPattern<T>& rhs) {
+        return MergePatternImpl(lhs, rhs);
+      },
       [&](const HorizontalFusionPattern<T>& lhs,
           const HorizontalFusionPattern<T>& rhs) {
         return MergePatternImpl(lhs, rhs);
diff --git a/paddle/cinn/operator_fusion/pattern_graph.cc b/paddle/cinn/operator_fusion/pattern_graph.cc
index bb68f7bc3d1d74..9ce395212f2eab 100644
--- a/paddle/cinn/operator_fusion/pattern_graph.cc
+++ b/paddle/cinn/operator_fusion/pattern_graph.cc
@@ -174,7 +174,6 @@ void PatternGraph<T>::ReduceTree_Trivial_Fusion() {
 
 template <typename T>
 void PatternGraph<T>::LiftToAnchorPattern() {
-  // TODO(@wuzhanfei)
   GraphTransformer<NodePattern, T, AlwaysTrue<T>, LiftToAnchorPatternOperation>(
       this);
 }
@@ -200,7 +199,6 @@ void PatternGraph<T>::AnchorPatternFusion() {
 
 template <typename T>
 void PatternGraph<T>::SplitRecomputePattern() {
-  // TODO(@wuzhanfei)
   GraphTransformer<NodePattern,
                    T,
                    RecomputeNodeMatcher,
diff --git a/paddle/cinn/operator_fusion/policy/policy_manager.h b/paddle/cinn/operator_fusion/policy/policy_manager.h
index 60b78399e3c7ba..21f00032eb0049 100644
--- a/paddle/cinn/operator_fusion/policy/policy_manager.h
+++ b/paddle/cinn/operator_fusion/policy/policy_manager.h
@@ -15,6 +15,7 @@
 #pragma once
 
 #include "paddle/cinn/operator_fusion/pattern_node.h"
+#include "paddle/cinn/operator_fusion/policy/anchor_search_policy.h"
 #include "paddle/cinn/operator_fusion/policy/general_topo_policy.h"
 #include "paddle/cinn/operator_fusion/policy/policy_base.h"
 #include "paddle/cinn/operator_fusion/policy/relative_judge_policy.h"

From c70b7b1e18a9f88f75840a3d6ab0c51a707492b8 Mon Sep 17 00:00:00 2001
From: feifei-111 <2364819892@qq.com>
Date: Sun, 5 May 2024 09:55:05 +0000
Subject: [PATCH 32/99] update

---
 .../operator_fusion/graph_transformer/operation.h    |  6 ++++--
 paddle/cinn/operator_fusion/pattern.h                | 12 ++++++------
 paddle/cinn/operator_fusion/pattern_graph.cc         |  7 +++++--
 3 files changed, 15 insertions(+), 10 deletions(-)

diff --git a/paddle/cinn/operator_fusion/graph_transformer/operation.h b/paddle/cinn/operator_fusion/graph_transformer/operation.h
index 44fb22e5f6a745..be9efa0ab42b40 100644
--- a/paddle/cinn/operator_fusion/graph_transformer/operation.h
+++ b/paddle/cinn/operator_fusion/graph_transformer/operation.h
@@ -13,6 +13,7 @@
 // limitations under the License.
 
 #pragma once
+#include "paddle/cinn/operator_fusion/pattern_fuser.h"
 #include "paddle/cinn/operator_fusion/pattern_graph.h"
 
 namespace cinn::fusion {
@@ -108,9 +109,10 @@ struct LiftToHorizontalFusionPatternOperation {
 struct LiftToAnchorPatternOperation {
   template <typename Phrase>
   void operator()(PatternGraph<Phrase>* graph, PatternNodePtr<Phrase> node) {
-    std::vector<pir::Operation*> ops = GetOpsInPattern(pattern);
+    std::vector<pir::Operation*> ops = GetOpsInPattern(node->stmt_pattern());
     pir::Value anchor = node->sink_op()->result(0);
-    node->set_stmt_pattern(AnchorPattern<Phrase>(ops, anchor));
+    node->set_stmt_pattern(AnchorPattern<Phrase>(
+        ops, anchor, InitAnchorState(node->stmt_pattern())));
   }
 };
 
diff --git a/paddle/cinn/operator_fusion/pattern.h b/paddle/cinn/operator_fusion/pattern.h
index fd87cac01faa71..1e7573816f199d 100644
--- a/paddle/cinn/operator_fusion/pattern.h
+++ b/paddle/cinn/operator_fusion/pattern.h
@@ -87,18 +87,18 @@ class HorizontalFusionPattern {};
 
 template <typename T>
 struct AnchorPattern {
-  explicit AnchorPattern(
-      const std::vector<pir::Operation*>& ops,
-      const pir::Value& anchor const AnchorState<T>& anchor_state)
-      : ops_(ops), anchor_(anchor), {
+  explicit AnchorPattern(const std::vector<pir::Operation*>& ops,
+                         const pir::Value& anchor,
+                         const AnchorState<T>& anchor_state)
+      : ops_(ops), anchor_(anchor), anchor_state_(anchor_state) {
     // TODO(@wuzhanfei): Initialize anchor state
   }
   std::vector<pir::Operation*> ops_;
   pir::Value anchor_;  // Choose only one anchor
-  AnchorState<T> anchor_state;
+  AnchorState<T> anchor_state_;
   std::vector<pir::Operation*> ops() const { return ops_; }
-  std::vector<pir::Value> outputs() const { return outputs_; }
   pir::Value anchor() const { return anchor_; }
+  pir::Value anchor_state() const { return anchor_state_; }
 
   bool can_recompute() const {
     // Current Algorithm:
diff --git a/paddle/cinn/operator_fusion/pattern_graph.cc b/paddle/cinn/operator_fusion/pattern_graph.cc
index 9ce395212f2eab..f8826f5d08d2f6 100644
--- a/paddle/cinn/operator_fusion/pattern_graph.cc
+++ b/paddle/cinn/operator_fusion/pattern_graph.cc
@@ -174,8 +174,11 @@ void PatternGraph<T>::ReduceTree_Trivial_Fusion() {
 
 template <typename T>
 void PatternGraph<T>::LiftToAnchorPattern() {
-  GraphTransformer<NodePattern, T, AlwaysTrue<T>, LiftToAnchorPatternOperation>(
-      this);
+  GraphTransformer<
+      NodePattern,
+      T,
+      Not<StmtPatternGraphMatcher<ReduceTreePlusTrivialPattern<T>>>,
+      LiftToAnchorPatternOperation>(this);
 }
 
 template <typename T>

From 7d4c58f9724f3cf6e9d9f3cc563d9b18ad013f4d Mon Sep 17 00:00:00 2001
From: feifei-111 <2364819892@qq.com>
Date: Mon, 6 May 2024 06:42:54 +0000
Subject: [PATCH 33/99] update

---
 paddle/cinn/operator_fusion/backend/pattern.h | 19 ++--------
 .../operator_fusion/backend/pattern_fuser.cc  | 12 +++++++
 .../operator_fusion/backend/pattern_fuser.h   |  7 ++++
 .../cinn/operator_fusion/frontend/pattern.h   | 18 +---------
 .../operator_fusion/frontend/pattern_fuser.cc | 12 +++++++
 .../operator_fusion/frontend/pattern_fuser.h  |  7 ++++
 .../graph_transformer/matcher.h               | 11 +++---
 .../graph_transformer/operation.h             | 14 +++++---
 paddle/cinn/operator_fusion/pattern_fuser.h   | 28 +++++++++++++++
 paddle/cinn/operator_fusion/pattern_graph.cc  |  3 +-
 .../pir_graph_analyzing/anchor_transform.cc   | 36 +++++++++++--------
 11 files changed, 108 insertions(+), 59 deletions(-)

diff --git a/paddle/cinn/operator_fusion/backend/pattern.h b/paddle/cinn/operator_fusion/backend/pattern.h
index f7e32a4109b8c6..92f54212184a5d 100644
--- a/paddle/cinn/operator_fusion/backend/pattern.h
+++ b/paddle/cinn/operator_fusion/backend/pattern.h
@@ -72,25 +72,10 @@ struct UnsupportPattern<BackendStage> {
   static std::string name() { return "Unsupport"; }
 };
 
-template <>
-struct HorizontalFusionPattern<BackendStage> {
-  explicit HorizontalFusionPattern(
-      const std::vector<StmtPattern<BackendStage>>& patterns)
-      : patterns_(patterns) {}
-  std::vector<StmtPattern<BackendStage>> patterns_;
-  std::vector<pir::Operation*> ops() const {
-    std::vector<pir::Operation*> result;
-    for (const auto& pattern : patterns_) {
-      auto ops = GetOpsInPattern(pattern);
-      ExtendVector(&result, ops);
-    }
-    return result;
-  }
-  static std::string name() { return "HorizontalFusionPattern"; }
-};
-
 template <>
 struct ValueExpr<BackendStage> {
+  explicit ValueExpr(const pir::Value& root, const FusionOp& op)
+      : root_value(root), root_fusion_op(op) {}
   AnchorTransformRoute transform_route;
   pir::Value root_value;
   FusionOp root_fusion_op;
diff --git a/paddle/cinn/operator_fusion/backend/pattern_fuser.cc b/paddle/cinn/operator_fusion/backend/pattern_fuser.cc
index df4e95901346a4..d69ef25bc0d617 100644
--- a/paddle/cinn/operator_fusion/backend/pattern_fuser.cc
+++ b/paddle/cinn/operator_fusion/backend/pattern_fuser.cc
@@ -407,4 +407,16 @@ std::vector<ir::Expr> GetExprFromPattern(
   return TopoSort(results);
 }
 
+template <>
+ValueExpr<BackendStage> InitValueExprImpl(
+    const TrivialPattern<BackendStage>& pattern, pir::Value anchor) {
+  return ValueExpr<BackendStage>(anchor, pattern.trivial_op);
+}
+
+template <>
+ValueExpr<BackendStage> InitValueExprImpl(
+    const ReducePattern<BackendStage>& pattern, pir::Value anchor) {
+  return ValueExpr<BackendStage>(anchor, pattern.reduce_op);
+}
+
 }  // namespace cinn::fusion
diff --git a/paddle/cinn/operator_fusion/backend/pattern_fuser.h b/paddle/cinn/operator_fusion/backend/pattern_fuser.h
index fcd3a3acf0f5f5..6f17cbc8395777 100644
--- a/paddle/cinn/operator_fusion/backend/pattern_fuser.h
+++ b/paddle/cinn/operator_fusion/backend/pattern_fuser.h
@@ -54,4 +54,11 @@ StmtPattern<BackendStage> MergePatternImpl(
 std::vector<ir::Expr> GetExprFromPattern(
     const StmtPattern<BackendStage>& pattern);
 
+template <>
+ValueExpr<BackendStage> InitValueExprImpl(
+    const TrivialPattern<BackendStage>& pattern, pir::Value anchor);
+
+template <>
+ValueExpr<BackendStage> InitValueExprImpl(
+    const ReducePattern<BackendStage>& pattern, pir::Value anchor);
 }  // namespace cinn::fusion
diff --git a/paddle/cinn/operator_fusion/frontend/pattern.h b/paddle/cinn/operator_fusion/frontend/pattern.h
index ffae727e60b46e..88fa941218f922 100644
--- a/paddle/cinn/operator_fusion/frontend/pattern.h
+++ b/paddle/cinn/operator_fusion/frontend/pattern.h
@@ -76,25 +76,9 @@ struct UnsupportPattern<FrontendStage> {
   static std::string name() { return "Unsupport"; }
 };
 
-template <>
-struct HorizontalFusionPattern<FrontendStage> {
-  explicit HorizontalFusionPattern(
-      const std::vector<StmtPattern<FrontendStage>>& patterns)
-      : patterns_(patterns) {}
-  std::vector<StmtPattern<FrontendStage>> patterns_;
-  std::vector<pir::Operation*> ops() const {
-    std::vector<pir::Operation*> result;
-    for (const auto& pattern : patterns_) {
-      auto ops = GetOpsInPattern(pattern);
-      ExtendVector(&result, ops);
-    }
-    return result;
-  }
-  static std::string name() { return "HorizontalFusionPattern"; }
-};
-
 template <>
 struct ValueExpr<FrontendStage> {
+  explicit ValueExpr(const pir::Value& root) : root_value(root) {}
   AnchorTransformRoute transform_route;
   pir::Value root_value;
 };
diff --git a/paddle/cinn/operator_fusion/frontend/pattern_fuser.cc b/paddle/cinn/operator_fusion/frontend/pattern_fuser.cc
index 7916f210ff469d..30a13c887b119b 100644
--- a/paddle/cinn/operator_fusion/frontend/pattern_fuser.cc
+++ b/paddle/cinn/operator_fusion/frontend/pattern_fuser.cc
@@ -78,4 +78,16 @@ StmtPattern<FrontendStage> MergePatternImpl(
   return HorizontalFusionPattern<FrontendStage>({first, second});
 }
 
+template <>
+ValueExpr<FrontendStage> InitValueExprImpl(
+    const TrivialPattern<FrontendStage>& pattern, pir::Value anchor) {
+  return ValueExpr<FrontendStage>(anchor);
+}
+
+template <>
+ValueExpr<FrontendStage> InitValueExprImpl(
+    const ReducePattern<FrontendStage>& pattern, pir::Value anchor) {
+  return ValueExpr<FrontendStage>(anchor);
+}
+
 }  // namespace cinn::fusion
diff --git a/paddle/cinn/operator_fusion/frontend/pattern_fuser.h b/paddle/cinn/operator_fusion/frontend/pattern_fuser.h
index 9830fd57ed226c..6336ad01a738ed 100644
--- a/paddle/cinn/operator_fusion/frontend/pattern_fuser.h
+++ b/paddle/cinn/operator_fusion/frontend/pattern_fuser.h
@@ -51,4 +51,11 @@ StmtPattern<FrontendStage> MergePatternImpl(
     const HorizontalFusionPattern<FrontendStage>& first,
     const HorizontalFusionPattern<FrontendStage>& second);
 
+template <>
+ValueExpr<FrontendStage> InitValueExprImpl(
+    const TrivialPattern<FrontendStage>& pattern, pir::Value anchor);
+
+template <>
+ValueExpr<FrontendStage> InitValueExprImpl(
+    const ReducePattern<FrontendStage>& pattern, pir::Value anchor);
 }  // namespace cinn::fusion
diff --git a/paddle/cinn/operator_fusion/graph_transformer/matcher.h b/paddle/cinn/operator_fusion/graph_transformer/matcher.h
index c5373b84e3fd82..fa87f219eb7122 100644
--- a/paddle/cinn/operator_fusion/graph_transformer/matcher.h
+++ b/paddle/cinn/operator_fusion/graph_transformer/matcher.h
@@ -18,7 +18,6 @@
 namespace cinn::fusion {
 // Matcher
 
-template <typename StmtPattern>
 struct AlwaysTrue {
   template <typename T>
   bool operator()(const PatternGraph<T>& graph, const PatternNodePtr<T>& node) {
@@ -103,8 +102,9 @@ struct HasUpstreamAnchorMatcher {
   bool operator()(const PatternGraph<T>& graph,
                   const PatternNodePtr<T>& upstream,
                   const PatternNodePtr<T>& downstream) {
-    // TODO(@wuzhanfei)
-    return false;
+    return graph.policy_manager()
+        .template GetPolicy<AnchorSearchPolicy>()
+        ->HasUpstreamAnchor(upstream, downstream);
   }
 };
 
@@ -113,8 +113,9 @@ struct HasDownstreamAnchorMatcher {
   bool operator()(const PatternGraph<T>& graph,
                   const PatternNodePtr<T>& upstream,
                   const PatternNodePtr<T>& downstream) {
-    // TODO(@wuzhanfei)
-    return false;
+    return graph.policy_manager()
+        .template GetPolicy<AnchorSearchPolicy>()
+        ->HasDownstreamAnchor(upstream, downstream);
   }
 };
 
diff --git a/paddle/cinn/operator_fusion/graph_transformer/operation.h b/paddle/cinn/operator_fusion/graph_transformer/operation.h
index 8b15a58330c0bb..2947922b771328 100644
--- a/paddle/cinn/operator_fusion/graph_transformer/operation.h
+++ b/paddle/cinn/operator_fusion/graph_transformer/operation.h
@@ -75,7 +75,6 @@ struct LiftReduceToReduceTreeOperation {
   void operator()(PatternGraph<Phrase>* graph, PatternNodePtr<Phrase> node) {
     const auto& reduce_pattern = ToReducePattern<Phrase>(node->stmt_pattern());
     node->set_stmt_pattern(ReduceTreePattern<Phrase>({}, reduce_pattern));
-    VLOG(4) << "LiftReduceToReduceTreeOperation: \nnode " << node->DebugStr();
   }
 };
 
@@ -111,9 +110,13 @@ struct LiftToAnchorPatternOperation {
   template <typename Phrase>
   void operator()(PatternGraph<Phrase>* graph, PatternNodePtr<Phrase> node) {
     std::vector<pir::Operation*> ops = GetOpsInPattern(node->stmt_pattern());
-    pir::Value anchor = node->sink_op()->result(0);
+    // TODO(@wuzhanfei) move sink_op into pattern (currently, part of pattern
+    // type has sink and the others not) then, update logic here
+    pir::Value anchor = node->sink_op();
     node->set_stmt_pattern(AnchorPattern<Phrase>(
-        ops, anchor, InitAnchorState(node->stmt_pattern())));
+        ops,
+        anchor,
+        AnchorState<Phrase>({InitValueExpr(node->stmt_pattern(), anchor)})));
   }
 };
 
@@ -122,7 +125,10 @@ struct FuseUpstreamAnchorOperation {
   void operator()(PatternGraph<Phrase>* graph,
                   const PatternNodePtr<Phrase>& upstream,
                   const PatternNodePtr<Phrase>& downstream) {
-    // TODO(@wuzhanfei)
+    auto merged_node =
+        graph->MergeNode(upstream, downstream, MergePattern<Phrase>);
+    graph->RemoveNode(upstream);
+    graph->RemoveNode(downstream);
   }
 };
 
diff --git a/paddle/cinn/operator_fusion/pattern_fuser.h b/paddle/cinn/operator_fusion/pattern_fuser.h
index 6bfa67e236c3de..f7133ac54a035e 100644
--- a/paddle/cinn/operator_fusion/pattern_fuser.h
+++ b/paddle/cinn/operator_fusion/pattern_fuser.h
@@ -55,6 +55,12 @@ std::vector<pir::Operation*> GetOpsInPattern(const StmtPattern<T>& pattern) {
                     pattern.variant());
 }
 
+template <typename T>
+pir::Operation* GetSinkOpInPattern(const StmtPattern<T>& pattern) {
+  return std::visit([](const auto& impl) { return impl.sink_op(); },
+                    pattern.variant());
+}
+
 using LoopFramework = std::vector<symbol::DimExpr>;
 
 // std::optional({}) means not sure.
@@ -370,4 +376,26 @@ StmtPattern<T> MergePattern(const StmtPattern<T>& first,
   return std::visit(PatternMatch, first.variant(), second.variant());
 }
 
+template <typename T>
+ValueExpr<T> InitValueExprImpl(const TrivialPattern<T>& pattern,
+                               pir::Value anchor);
+
+template <typename T>
+ValueExpr<T> InitValueExprImpl(const ReducePattern<T>& pattern,
+                               pir::Value anchor);
+
+template <typename T>
+ValueExpr<T> InitValueExpr(const StmtPattern<T>& pattern, pir::Value anchor) {
+  return std::visit(
+      [anchor](const auto& arg) {
+        using U = std::decay_t<decltype(arg)>;
+        if constexpr (std::is_same_v<U, TrivialPattern<T>>) {
+          return InitValueExprImpl(arg, anchor);
+        } else if constexpr (std::is_same_v<U, ReducePattern<T>>) {
+          return InitValueExprImpl(arg, anchor);
+        }
+      },
+      s.variant());
+}
+
 }  // namespace cinn::fusion
diff --git a/paddle/cinn/operator_fusion/pattern_graph.cc b/paddle/cinn/operator_fusion/pattern_graph.cc
index fc07398801a667..602ee967716256 100644
--- a/paddle/cinn/operator_fusion/pattern_graph.cc
+++ b/paddle/cinn/operator_fusion/pattern_graph.cc
@@ -180,7 +180,8 @@ void PatternGraph<T>::LiftToAnchorPattern() {
   GraphTransformer<
       NodePattern,
       T,
-      Not<StmtPatternGraphMatcher<ReduceTreePlusTrivialPattern<T>>>,
+      And<Not<StmtPatternGraphMatcher<ReduceTreePattern<T>>>,
+          Not<StmtPatternGraphMatcher<ReduceTreePlusTrivialPattern<T>>>>,
       LiftToAnchorPatternOperation>(this);
 }
 
diff --git a/paddle/cinn/operator_fusion/pir_graph_analyzing/anchor_transform.cc b/paddle/cinn/operator_fusion/pir_graph_analyzing/anchor_transform.cc
index 2fafa7403bf3ad..f74f12a5816bcc 100644
--- a/paddle/cinn/operator_fusion/pir_graph_analyzing/anchor_transform.cc
+++ b/paddle/cinn/operator_fusion/pir_graph_analyzing/anchor_transform.cc
@@ -30,8 +30,11 @@ AnchorTransform CreateAnchorTransformForReduce(const TransformInfo& info) {
   }
 
   if (info.is_upstream_anchor) {
-    return std::make_shared<AppendDimTransform>(
-        info, GetReduceAxisIdx(pir::Operation * reduce_op))
+    // TODO(@wuzhanfei) do not support reduce currently
+
+    // return std::make_shared<AppendDimTransform>(
+    //     info, GetReduceAxisIdx(pir::Operation * reduce_op))
+    return CreateDefaultAnchorTransform(info);
   } else {
     return CreateDefaultAnchorTransform(info);
   }
@@ -43,19 +46,22 @@ AnchorTransform CreateAnchorTransformForBroadcast(const TransformInfo& info) {
   }
 
   if (info.is_upstream_anchor) {
-    auto related_dims = GetNonBroadCastDims(info.op);
-    size_t output_rank = GetRank(info.OutputValue());
-    std::vector<size_t> used_dim_mask = std::vector<size_t>(output_rank, 0);
-    std::vector<size_t> delete_dim_idx;
-    for (const auto& [input_dim_idx, output_dim_idx] : related_dims) {
-      used_dim_mask[output_dim_idx] = 1;
-    }
-    for (size_t used_dim : used_dim_mask) {
-      if (used_dim == 0) {
-        delete_dim_idx.emplace_back();
-      }
-    }
-    return std::make_shared<DeleteDimTransform>(info, delete_dim_idx);
+    // TODO(@wuzhanfei) do not support broadcast currently
+
+    // auto related_dims = GetNonBroadCastDims(info.op);
+    // size_t output_rank = GetRank(info.OutputValue());
+    // std::vector<size_t> used_dim_mask = std::vector<size_t>(output_rank, 0);
+    // std::vector<size_t> delete_dim_idx;
+    // for (const auto& [input_dim_idx, output_dim_idx] : related_dims) {
+    //   used_dim_mask[output_dim_idx] = 1;
+    // }
+    // for (size_t used_dim : used_dim_mask) {
+    //   if (used_dim == 0) {
+    //     delete_dim_idx.emplace_back();
+    //   }
+    // }
+    // return std::make_shared<DeleteDimTransform>(info, delete_dim_idx);
+    return CreateDefaultAnchorTransform(info);
   } else {
     return CreateDefaultAnchorTransform(info);
   }

From 23048b536af88f145521cdb33d31daa274b8ee61 Mon Sep 17 00:00:00 2001
From: feifei-111 <2364819892@qq.com>
Date: Mon, 6 May 2024 12:21:22 +0000
Subject: [PATCH 34/99] update

---
 paddle/cinn/operator_fusion/backend/pattern.h |  8 +++-
 .../operator_fusion/backend/pattern_fuser.cc  | 25 ++++-------
 .../operator_fusion/backend/pattern_fuser.h   |  8 ++--
 .../cinn/operator_fusion/frontend/pattern.h   |  8 +++-
 .../operator_fusion/frontend/pattern_fuser.cc | 25 ++++-------
 .../operator_fusion/frontend/pattern_fuser.h  |  8 ++--
 .../graph_transformer/operation.h             | 36 ++++++++++++++--
 paddle/cinn/operator_fusion/pattern.h         | 19 ++++-----
 paddle/cinn/operator_fusion/pattern_fuser.h   | 38 +++++++++++++----
 .../pir_graph_analyzing/anchor_transform.h    |  9 +++-
 .../policy/anchor_search_policy.cc            | 41 ++++++++++++++-----
 .../policy/anchor_search_policy.h             |  5 +++
 paddle/cinn/operator_fusion/utils.h           |  2 +-
 13 files changed, 151 insertions(+), 81 deletions(-)

diff --git a/paddle/cinn/operator_fusion/backend/pattern.h b/paddle/cinn/operator_fusion/backend/pattern.h
index 92f54212184a5d..51cdd327eacaa9 100644
--- a/paddle/cinn/operator_fusion/backend/pattern.h
+++ b/paddle/cinn/operator_fusion/backend/pattern.h
@@ -73,12 +73,16 @@ struct UnsupportPattern<BackendStage> {
 };
 
 template <>
-struct ValueExpr<BackendStage> {
-  explicit ValueExpr(const pir::Value& root, const FusionOp& op)
+struct ExprPromise<BackendStage> {
+  explicit ExprPromise(const pir::Value& root, const FusionOp& op)
       : root_value(root), root_fusion_op(op) {}
   AnchorTransformRoute transform_route;
   pir::Value root_value;
   FusionOp root_fusion_op;
+
+  void update(const AnchorTransformRoute& route) {
+    transform_route.insert(transform_route.end(), route.begin(), route.end());
+  }
 };
 
 }  // namespace cinn::fusion
diff --git a/paddle/cinn/operator_fusion/backend/pattern_fuser.cc b/paddle/cinn/operator_fusion/backend/pattern_fuser.cc
index d69ef25bc0d617..eb3c42607bc5a9 100644
--- a/paddle/cinn/operator_fusion/backend/pattern_fuser.cc
+++ b/paddle/cinn/operator_fusion/backend/pattern_fuser.cc
@@ -79,19 +79,12 @@ StmtPattern<BackendStage> MergePatternImpl(
 
 template <>
 StmtPattern<BackendStage> MergePatternImpl(
-    const AnchorPattern<BackendStage>& first,
-    const AnchorPattern<BackendStage>& second) {
-  // TODO(@wuzhanfei)
-}
-
-template <>
-StmtPattern<BackendStage> MergePatternImpl(
-    const HorizontalFusionPattern<BackendStage>& first,
-    const HorizontalFusionPattern<BackendStage>& second) {
+    const AnchorPattern<BackendStage>& source,
+    const AnchorPattern<BackendStage>& dest) {
   const auto& contents =
-      UniqueConcatVector(GetOpsInPattern<BackendStage>(first),
-                         GetOpsInPattern<BackendStage>(second));
-  return HorizontalFusionPattern<BackendStage>({first, second});
+      UniqueConcatVector(GetOpsInPattern<BackendStage>(source),
+                         GetOpsInPattern<BackendStage>(dest));
+  return AnchorPattern<BackendStage>(contents, source.anchor(), {});
 }
 
 /// Start: Tmp Transform Operation for ReduceTree
@@ -408,15 +401,15 @@ std::vector<ir::Expr> GetExprFromPattern(
 }
 
 template <>
-ValueExpr<BackendStage> InitValueExprImpl(
+ExprPromise<BackendStage> InitExprPromiseImpl(
     const TrivialPattern<BackendStage>& pattern, pir::Value anchor) {
-  return ValueExpr<BackendStage>(anchor, pattern.trivial_op);
+  return ExprPromise<BackendStage>(anchor, pattern.trivial_op);
 }
 
 template <>
-ValueExpr<BackendStage> InitValueExprImpl(
+ExprPromise<BackendStage> InitExprPromiseImpl(
     const ReducePattern<BackendStage>& pattern, pir::Value anchor) {
-  return ValueExpr<BackendStage>(anchor, pattern.reduce_op);
+  return ExprPromise<BackendStage>(anchor, pattern.reduce_op);
 }
 
 }  // namespace cinn::fusion
diff --git a/paddle/cinn/operator_fusion/backend/pattern_fuser.h b/paddle/cinn/operator_fusion/backend/pattern_fuser.h
index 6f17cbc8395777..11188ff92998b9 100644
--- a/paddle/cinn/operator_fusion/backend/pattern_fuser.h
+++ b/paddle/cinn/operator_fusion/backend/pattern_fuser.h
@@ -43,8 +43,8 @@ StmtPattern<BackendStage> MergePatternImpl(
 
 template <>
 StmtPattern<BackendStage> MergePatternImpl(
-    const AnchorPattern<BackendStage>& first,
-    const AnchorPattern<BackendStage>& second);
+    const AnchorPattern<BackendStage>& source,
+    const AnchorPattern<BackendStage>& dest);
 
 template <>
 StmtPattern<BackendStage> MergePatternImpl(
@@ -55,10 +55,10 @@ std::vector<ir::Expr> GetExprFromPattern(
     const StmtPattern<BackendStage>& pattern);
 
 template <>
-ValueExpr<BackendStage> InitValueExprImpl(
+ExprPromise<BackendStage> InitExprPromiseImpl(
     const TrivialPattern<BackendStage>& pattern, pir::Value anchor);
 
 template <>
-ValueExpr<BackendStage> InitValueExprImpl(
+ExprPromise<BackendStage> InitExprPromiseImpl(
     const ReducePattern<BackendStage>& pattern, pir::Value anchor);
 }  // namespace cinn::fusion
diff --git a/paddle/cinn/operator_fusion/frontend/pattern.h b/paddle/cinn/operator_fusion/frontend/pattern.h
index 88fa941218f922..942286c77153c6 100644
--- a/paddle/cinn/operator_fusion/frontend/pattern.h
+++ b/paddle/cinn/operator_fusion/frontend/pattern.h
@@ -77,9 +77,13 @@ struct UnsupportPattern<FrontendStage> {
 };
 
 template <>
-struct ValueExpr<FrontendStage> {
-  explicit ValueExpr(const pir::Value& root) : root_value(root) {}
+struct ExprPromise<FrontendStage> {
+  explicit ExprPromise(const pir::Value& root) : root_value(root) {}
   AnchorTransformRoute transform_route;
   pir::Value root_value;
+
+  void update(const AnchorTransformRoute& route) {
+    transform_route.insert(transform_route.end(), route.begin(), route.end());
+  }
 };
 }  // namespace cinn::fusion
diff --git a/paddle/cinn/operator_fusion/frontend/pattern_fuser.cc b/paddle/cinn/operator_fusion/frontend/pattern_fuser.cc
index 30a13c887b119b..6a58245e2d5e41 100644
--- a/paddle/cinn/operator_fusion/frontend/pattern_fuser.cc
+++ b/paddle/cinn/operator_fusion/frontend/pattern_fuser.cc
@@ -63,31 +63,24 @@ StmtPattern<FrontendStage> MergePatternImpl(
 
 template <>
 StmtPattern<FrontendStage> MergePatternImpl(
-    const AnchorPattern<FrontendStage>& first,
-    const AnchorPattern<FrontendStage>& second) {
-  // TODO(@wuzhanfei)
-}
-
-template <>
-StmtPattern<FrontendStage> MergePatternImpl(
-    const HorizontalFusionPattern<FrontendStage>& first,
-    const HorizontalFusionPattern<FrontendStage>& second) {
+    const AnchorPattern<FrontendStage>& source,
+    const AnchorPattern<FrontendStage>& dest) {
   const auto& contents =
-      UniqueConcatVector(GetOpsInPattern<FrontendStage>(first),
-                         GetOpsInPattern<FrontendStage>(second));
-  return HorizontalFusionPattern<FrontendStage>({first, second});
+      UniqueConcatVector(GetOpsInPattern<FrontendStage>(source),
+                         GetOpsInPattern<FrontendStage>(dest));
+  return AnchorPattern<FrontendStage>(contents, source.anchor(), {});
 }
 
 template <>
-ValueExpr<FrontendStage> InitValueExprImpl(
+ExprPromise<FrontendStage> InitExprPromiseImpl(
     const TrivialPattern<FrontendStage>& pattern, pir::Value anchor) {
-  return ValueExpr<FrontendStage>(anchor);
+  return ExprPromise<FrontendStage>(anchor);
 }
 
 template <>
-ValueExpr<FrontendStage> InitValueExprImpl(
+ExprPromise<FrontendStage> InitExprPromiseImpl(
     const ReducePattern<FrontendStage>& pattern, pir::Value anchor) {
-  return ValueExpr<FrontendStage>(anchor);
+  return ExprPromise<FrontendStage>(anchor);
 }
 
 }  // namespace cinn::fusion
diff --git a/paddle/cinn/operator_fusion/frontend/pattern_fuser.h b/paddle/cinn/operator_fusion/frontend/pattern_fuser.h
index 6336ad01a738ed..3ea2afaaf912ef 100644
--- a/paddle/cinn/operator_fusion/frontend/pattern_fuser.h
+++ b/paddle/cinn/operator_fusion/frontend/pattern_fuser.h
@@ -43,8 +43,8 @@ StmtPattern<FrontendStage> MergePatternImpl(
 
 template <>
 StmtPattern<FrontendStage> MergePatternImpl(
-    const AnchorPattern<FrontendStage>& first,
-    const AnchorPattern<FrontendStage>& second);
+    const AnchorPattern<FrontendStage>& source,
+    const AnchorPattern<FrontendStage>& dest);
 
 template <>
 StmtPattern<FrontendStage> MergePatternImpl(
@@ -52,10 +52,10 @@ StmtPattern<FrontendStage> MergePatternImpl(
     const HorizontalFusionPattern<FrontendStage>& second);
 
 template <>
-ValueExpr<FrontendStage> InitValueExprImpl(
+ExprPromise<FrontendStage> InitExprPromiseImpl(
     const TrivialPattern<FrontendStage>& pattern, pir::Value anchor);
 
 template <>
-ValueExpr<FrontendStage> InitValueExprImpl(
+ExprPromise<FrontendStage> InitExprPromiseImpl(
     const ReducePattern<FrontendStage>& pattern, pir::Value anchor);
 }  // namespace cinn::fusion
diff --git a/paddle/cinn/operator_fusion/graph_transformer/operation.h b/paddle/cinn/operator_fusion/graph_transformer/operation.h
index 2947922b771328..4c6c0b30c3783b 100644
--- a/paddle/cinn/operator_fusion/graph_transformer/operation.h
+++ b/paddle/cinn/operator_fusion/graph_transformer/operation.h
@@ -116,7 +116,7 @@ struct LiftToAnchorPatternOperation {
     node->set_stmt_pattern(AnchorPattern<Phrase>(
         ops,
         anchor,
-        AnchorState<Phrase>({InitValueExpr(node->stmt_pattern(), anchor)})));
+        AnchorState<Phrase>({InitExprPromise(node->stmt_pattern(), anchor)})));
   }
 };
 
@@ -125,8 +125,29 @@ struct FuseUpstreamAnchorOperation {
   void operator()(PatternGraph<Phrase>* graph,
                   const PatternNodePtr<Phrase>& upstream,
                   const PatternNodePtr<Phrase>& downstream) {
-    auto merged_node =
-        graph->MergeNode(upstream, downstream, MergePattern<Phrase>);
+    auto optional_transform_route =
+        graph->policy_manager()
+            .template GetPolicy<AnchorSearchPolicy>()
+            ->FindUpstreamAnchorTransformRoute(upstream, downstream);
+    PADDLE_ENFORCE_NE(
+        optional_transform_route.value(),
+        std::nullopt,
+        phi::errors::PreconditionNotMet("Transform Route Not Found"));
+
+    auto transform_route = optional_transform_route.value();
+
+    const auto merge_pattern_fn = [](const StmtPattern<Phrase>& source,
+                                     const StmtPattern<Phrase>& destination) {
+      auto new_anchor_pattern = std::get<AnchorPattern<Phrase>>(
+          MergePattern<Phrase>(source, destination));
+      auto transformed_anchor_state = ApplyAnchorTransformRoute<Phrase>(
+          GetAnchorState(destination), transform_route);
+      new_anchor_pattern.anchor_state.update(GetAnchorState(source));
+      new_anchor_pattern.anchor_state.update(transformed_anchor_state);
+      return new_anchor_pattern;
+    };
+
+    auto merged_node = graph->MergeNode(upstream, downstream, merge_pattern_fn);
     graph->RemoveNode(upstream);
     graph->RemoveNode(downstream);
   }
@@ -137,7 +158,14 @@ struct FuseDownstreamAnchorOperation {
   void operator()(PatternGraph<Phrase>* graph,
                   const PatternNodePtr<Phrase>& upstream,
                   const PatternNodePtr<Phrase>& downstream) {
-    // TODO(@wuzhanfei)
+    const auto merge_pattern_fn = [&fake_reduce_iter_idx](
+                                      const StmtPattern<Phrase>& destination,
+                                      const StmtPattern<Phrase>& source) {
+      return MergePattern<Phrase>(source, destination);
+    };
+    auto merged_node = graph->MergeNode(upstream, downstream, merge_pattern_fn);
+    graph->RemoveNode(upstream);
+    graph->RemoveNode(downstream);
   }
 };
 
diff --git a/paddle/cinn/operator_fusion/pattern.h b/paddle/cinn/operator_fusion/pattern.h
index 1b69676dfc6684..d246b8cbe89465 100644
--- a/paddle/cinn/operator_fusion/pattern.h
+++ b/paddle/cinn/operator_fusion/pattern.h
@@ -114,16 +114,12 @@ struct AnchorPattern {
   explicit AnchorPattern(const std::vector<pir::Operation*>& ops,
                          const pir::Value& anchor,
                          const AnchorState<T>& anchor_state)
-      : ops_(ops), anchor_(anchor), anchor_state_(anchor_state) {
-    // TODO(@wuzhanfei): Initialize anchor state
-  }
-  std::vector<pir::Operation*> ops_;
-  pir::Value anchor_;  // Choose only one anchor
-  AnchorState<T> anchor_state_;
+      : ops_(ops), anchor_(anchor), anchor_state_(anchor_state) {}
+  AnchorState<T> anchor_state;
+
+  static std::string name() { return "AnchorPattern"; }
   std::vector<pir::Operation*> ops() const { return ops_; }
   pir::Value anchor() const { return anchor_; }
-  pir::Value anchor_state() const { return anchor_state_; }
-
   bool can_recompute() const {
     // Current Algorithm:
     // An AnchorPattern can be recomputed iff:
@@ -131,7 +127,7 @@ struct AnchorPattern {
     // means it only has one output_expr in anchor_state.
     // 2. It only contains trivial ops.
 
-    if (anchor_state.output_exprs.size() > 1) {
+    if (anchor_state.promise.size() > 1) {
       return false;
     }
 
@@ -144,7 +140,10 @@ struct AnchorPattern {
 
     return true;
   }
-  static std::string name() { return "AnchorPattern"; }
+
+ private:
+  std::vector<pir::Operation*> ops_;
+  pir::Value anchor_;  // Choose only one anchor
 };
 
 template <typename T>
diff --git a/paddle/cinn/operator_fusion/pattern_fuser.h b/paddle/cinn/operator_fusion/pattern_fuser.h
index f7133ac54a035e..b92d5b2f568901 100644
--- a/paddle/cinn/operator_fusion/pattern_fuser.h
+++ b/paddle/cinn/operator_fusion/pattern_fuser.h
@@ -336,8 +336,8 @@ StmtPattern<T> MergePatternImpl(const TrivialPattern<T>& first,
                                 const TrivialPattern<T>& second);
 
 template <typename T>
-StmtPattern<T> MergePatternImpl(const AnchorPattern<T>& first,
-                                const AnchorPattern<T>& second);
+StmtPattern<T> MergePatternImpl(const AnchorPattern<T>& source,
+                                const AnchorPattern<T>& dest);
 
 template <typename T>
 StmtPattern<T> MergePatternImpl(const HorizontalFusionPattern<T>& first,
@@ -377,25 +377,45 @@ StmtPattern<T> MergePattern(const StmtPattern<T>& first,
 }
 
 template <typename T>
-ValueExpr<T> InitValueExprImpl(const TrivialPattern<T>& pattern,
-                               pir::Value anchor);
+ExprPromise<T> InitExprPromiseImpl(const TrivialPattern<T>& pattern,
+                                   pir::Value anchor);
 
 template <typename T>
-ValueExpr<T> InitValueExprImpl(const ReducePattern<T>& pattern,
-                               pir::Value anchor);
+ExprPromise<T> InitExprPromiseImpl(const ReducePattern<T>& pattern,
+                                   pir::Value anchor);
 
 template <typename T>
-ValueExpr<T> InitValueExpr(const StmtPattern<T>& pattern, pir::Value anchor) {
+ExprPromise<T> InitExprPromise(const StmtPattern<T>& pattern,
+                               pir::Value anchor) {
   return std::visit(
       [anchor](const auto& arg) {
         using U = std::decay_t<decltype(arg)>;
         if constexpr (std::is_same_v<U, TrivialPattern<T>>) {
-          return InitValueExprImpl(arg, anchor);
+          return InitExprPromiseImpl(arg, anchor);
         } else if constexpr (std::is_same_v<U, ReducePattern<T>>) {
-          return InitValueExprImpl(arg, anchor);
+          return InitExprPromiseImpl(arg, anchor);
         }
       },
       s.variant());
 }
 
+template <typename T>
+ReducePattern<T> GetAnchorState(const StmtPattern<T>& pattern) {
+  return std::visit([](const auto& arg) { return arg.anchor_state; },
+                    pattern.variant());
+}
+
+template <typename T>
+AnchorState<T> ApplyAnchorTransformRoute(const AnchorState<T>& anchor_state,
+                                         const AnchorTransformRoute& route) {
+  return std::visit(
+      [route](const auto& arg) {
+        AnchorState<T> result = anchor_state;
+        for (auto promise : anchor_state.promise) {
+          promise.transform_route.update(route);
+        }
+      },
+      anchor_state);
+}
+
 }  // namespace cinn::fusion
diff --git a/paddle/cinn/operator_fusion/pir_graph_analyzing/anchor_transform.h b/paddle/cinn/operator_fusion/pir_graph_analyzing/anchor_transform.h
index f5d75d4b9ee237..6f4ae1701f5d65 100644
--- a/paddle/cinn/operator_fusion/pir_graph_analyzing/anchor_transform.h
+++ b/paddle/cinn/operator_fusion/pir_graph_analyzing/anchor_transform.h
@@ -71,11 +71,16 @@ using AnchorTransform = std::variant<UnsupportTransformPtr,
 using AnchorTransformRoute = std::vector<AnchorTransform>;
 
 template <typename T>
-struct ValueExpr {};
+struct ExprPromise {};
 
 template <typename T>
 struct AnchorState {
-  std::vector<ValueExpr<T>> output_exprs;
+  std::vector<ExprPromise<T>> promise;
+
+  void update(AnchorState<T> new_state) {
+    auto new_exprs = new_state.promise;
+    promise.insert(promise.end(), new_exprs.begin(), new_exprs.end());
+  }
 };
 
 AnchorTransform CreateAnchorTransform(const TransformInfo& info);
diff --git a/paddle/cinn/operator_fusion/policy/anchor_search_policy.cc b/paddle/cinn/operator_fusion/policy/anchor_search_policy.cc
index 3c48a28e276937..3accdec620560a 100644
--- a/paddle/cinn/operator_fusion/policy/anchor_search_policy.cc
+++ b/paddle/cinn/operator_fusion/policy/anchor_search_policy.cc
@@ -69,7 +69,8 @@ std::optional<AnchorTransformRoute> FindAnchorTransformRoute(
 }
 
 template <typename T>
-bool AnchorSearchPolicy<T>::HasUpstreamAnchor(
+std::optional<AnchorTransformRoute>
+AnchorSearchPolicy<T>::FindUpstreamAnchorTransformRoute(
     const PatternNodePtr<T>& upstream, const PatternNodePtr<T>& downstream) {
   const auto& upstream_anchor_pattern =
       std::get<AnchorPattern<T>>(upstream->stmt_pattern());
@@ -77,14 +78,15 @@ bool AnchorSearchPolicy<T>::HasUpstreamAnchor(
       std::get<AnchorPattern<T>>(downstream->stmt_pattern());
 
   return FindAnchorTransformRoute(
-             upstream_anchor_pattern.anchor(),
-             downstream_anchor_pattern.anchor(),
-             ToSet(ConcatVector(upstream_anchor_pattern.ops(),
-                                downstream_anchor_pattern.ops()))) !=
-         std::nullopt;
+      upstream_anchor_pattern.anchor(),
+      downstream_anchor_pattern.anchor(),
+      ToSet(ConcatVector(upstream_anchor_pattern.ops(),
+                         downstream_anchor_pattern.ops())));
 }
+
 template <typename T>
-bool AnchorSearchPolicy<T>::HasDownstreamAnchor(
+std::optional<AnchorTransformRoute>
+AnchorSearchPolicy<T>::FindDownstreamAnchorTransformRoute(
     const PatternNodePtr<T>& upstream, const PatternNodePtr<T>& downstream) {
   const auto& upstream_anchor_pattern =
       std::get<AnchorPattern<T>>(upstream->stmt_pattern());
@@ -92,13 +94,30 @@ bool AnchorSearchPolicy<T>::HasDownstreamAnchor(
       std::get<AnchorPattern<T>>(downstream->stmt_pattern());
 
   return FindAnchorTransformRoute(
-             downstream_anchor_pattern.anchor(),
-             upstream_anchor_pattern.anchor(),
-             ToSet(ConcatVector(upstream_anchor_pattern.ops(),
-                                downstream_anchor_pattern.ops()))) !=
+      downstream_anchor_pattern.anchor(),
+      upstream_anchor_pattern.anchor(),
+      ToSet(ConcatVector(upstream_anchor_pattern.ops(),
+                         downstream_anchor_pattern.ops())));
+}
+
+template <typename T>
+bool AnchorSearchPolicy<T>::HasUpstreamAnchor(
+    const PatternNodePtr<T>& upstream, const PatternNodePtr<T>& downstream) {
+  return FindUpstreamAnchorTransformRoute(upstream, downstream).value() !=
          std::nullopt;
 }
 
+template <typename T>
+bool AnchorSearchPolicy<T>::HasDownstreamAnchor(
+    const PatternNodePtr<T>& upstream, const PatternNodePtr<T>& downstream) {
+  return FindDownstreamAnchorTransformRoute(upstream, downstream).value() !=
+         std::nullopt;
+}
+
+template <typename T>
+AnchorState<T> AnchorSearchPolicy<T>::MergeAnchorState(
+    const AnchorState<T>& source, const AnchorState<T>& dest) {}
+
 template class AnchorSearchPolicy<FrontendStage>;
 template class AnchorSearchPolicy<BackendStage>;
 }  // namespace cinn::fusion
diff --git a/paddle/cinn/operator_fusion/policy/anchor_search_policy.h b/paddle/cinn/operator_fusion/policy/anchor_search_policy.h
index 8d8a4a8ccc89ea..e41c5b3e4e35e2 100644
--- a/paddle/cinn/operator_fusion/policy/anchor_search_policy.h
+++ b/paddle/cinn/operator_fusion/policy/anchor_search_policy.h
@@ -29,6 +29,11 @@ class AnchorSearchPolicy final : : public PolicyBase<T> {
                          const PatternNodePtr<T>& downstream);
   bool HasDownstreamAnchor(const PatternNodePtr<T>& upstream,
                            const PatternNodePtr<T>& downstream);
+  std::optional<AnchorTransformRoute> FindUpstreamAnchorTransformRoute(
+      const PatternNodePtr<T>& upstream, const PatternNodePtr<T>& downstream);
+  std::optional<AnchorTransformRoute> FindDownstreamAnchorTransformRoute(
+      const PatternNodePtr<T>& upstream, const PatternNodePtr<T>& downstream);
+
   std::string Name() { return "AnchorSearchPolicy"; }
 };
 
diff --git a/paddle/cinn/operator_fusion/utils.h b/paddle/cinn/operator_fusion/utils.h
index 3be7b4246051ba..8ba733b2c4a1cb 100644
--- a/paddle/cinn/operator_fusion/utils.h
+++ b/paddle/cinn/operator_fusion/utils.h
@@ -51,7 +51,7 @@ static size_t GetCompitableRank(pir::Value value) {
   return rank == 0 ? 1 : rank;
 }
 
-static std::vector<int64_t> GetReduceAxisIdx(pir::Operation* reduce_op) {
+static std::vector<size_t> GetReduceAxisIdx(pir::Operation* reduce_op) {
   const size_t input_rank = GetCompitableRank(reduce_op->operand_source(0));
   const auto& attr_val = reduce_op->attributes().at("dim");
   CHECK(attr_val.isa<::pir::ArrayAttribute>());

From d04e6f2e7a48f055f02712e41a65467b3a55077c Mon Sep 17 00:00:00 2001
From: feifei-111 <2364819892@qq.com>
Date: Tue, 7 May 2024 04:07:09 +0000
Subject: [PATCH 35/99] update

---
 .../operator_fusion/backend/pattern_fuser.cc  | 36 +++++++++++++++++++
 .../graph_transformer/operation.h             | 26 +++++++++++---
 2 files changed, 58 insertions(+), 4 deletions(-)

diff --git a/paddle/cinn/operator_fusion/backend/pattern_fuser.cc b/paddle/cinn/operator_fusion/backend/pattern_fuser.cc
index eb3c42607bc5a9..820275c0c7a3de 100644
--- a/paddle/cinn/operator_fusion/backend/pattern_fuser.cc
+++ b/paddle/cinn/operator_fusion/backend/pattern_fuser.cc
@@ -152,6 +152,23 @@ struct FusionOp2Expr {
   }
 };
 
+struct ApplyTransform {
+  explicit ApplyTransform(const ir::Expr& expr) : expr_(expr) {}
+  ir::Expr operator()(const UnsupportTransformPtr& transform) {
+    PADDLE_THROW("Can not do UnsupportTransform");
+  }
+  ir::Expr operator()(const IdentityTransformPtr& transform) { return expr_; }
+  ir::Expr operator()(const AppendDimTransformPtr& transform) {
+    PADDLE_THROW("AppendDimTransform not implemented");
+  }
+  ir::Expr operator()(const DeleteDimTransformPtr& transform) {
+    PADDLE_THROW("DeleteDimTransform not implemented");
+  }
+
+ private:
+  ir::Expr expr_;
+};
+
 std::vector<ir::Expr> GetExprFromPattern(
     const StmtPattern<BackendStage>& pattern);
 
@@ -235,6 +252,19 @@ ir::Expr UnSqueezeExpr(const ir::Expr& expr,
   return result;
 }
 
+std::vector<ir::Expr> ApplyTransformToPromise(
+    const ExprPromise<BackendStage>& promise) {
+  std::function<ir::Expr(ir::Expr)> do_transform =
+      [transform_route = promise.transform_route](ir::Expr target) -> ir::Expr {
+    for (auto transform : transform_route) {
+      target = std::visit(ApplyTransform(target), transform);
+    }
+    return target;
+  };
+  return MapVector(std::visit(FusionOp2Expr(), promise.root_fusion_op),
+                   do_transform);
+}
+
 struct IrExprGetter {
   std::vector<ir::Expr> operator()(
       const TrivialPattern<BackendStage>& pattern) {
@@ -279,6 +309,12 @@ struct IrExprGetter {
     return result;
   }
 
+  std::vector<ir::Expr> operator()(const AnchorPattern<BackendStage>& pattern) {
+    std::vector<ir::Expr> result;
+    for (auto promise : pattern.anchor_state.promise) {
+    }
+  }
+
   std::vector<ir::Expr> operator()(
       const UnsupportPattern<BackendStage>& pattern) {
     CHECK(false) << "Not Implemented.";
diff --git a/paddle/cinn/operator_fusion/graph_transformer/operation.h b/paddle/cinn/operator_fusion/graph_transformer/operation.h
index 4c6c0b30c3783b..fafbd133d14983 100644
--- a/paddle/cinn/operator_fusion/graph_transformer/operation.h
+++ b/paddle/cinn/operator_fusion/graph_transformer/operation.h
@@ -158,11 +158,29 @@ struct FuseDownstreamAnchorOperation {
   void operator()(PatternGraph<Phrase>* graph,
                   const PatternNodePtr<Phrase>& upstream,
                   const PatternNodePtr<Phrase>& downstream) {
-    const auto merge_pattern_fn = [&fake_reduce_iter_idx](
-                                      const StmtPattern<Phrase>& destination,
-                                      const StmtPattern<Phrase>& source) {
-      return MergePattern<Phrase>(source, destination);
+    auto optional_transform_route =
+        graph->policy_manager()
+            .template GetPolicy<AnchorSearchPolicy>()
+            ->FindDownstreamAnchorTransformRoute(upstream, downstream);
+
+    PADDLE_ENFORCE_NE(
+        optional_transform_route.value(),
+        std::nullopt,
+        phi::errors::PreconditionNotMet("Transform Route Not Found"));
+
+    auto transform_route = optional_transform_route.value();
+
+    const auto merge_pattern_fn = [](const StmtPattern<Phrase>& destination,
+                                     const StmtPattern<Phrase>& source) {
+      auto new_anchor_pattern = std::get<AnchorPattern<Phrase>>(
+          MergePattern<Phrase>(source, destination));
+      auto transformed_anchor_state = ApplyAnchorTransformRoute<Phrase>(
+          GetAnchorState(destination), transform_route);
+      new_anchor_pattern.anchor_state.update(GetAnchorState(source));
+      new_anchor_pattern.anchor_state.update(transformed_anchor_state);
+      return new_anchor_pattern;
     };
+
     auto merged_node = graph->MergeNode(upstream, downstream, merge_pattern_fn);
     graph->RemoveNode(upstream);
     graph->RemoveNode(downstream);

From 7f25695d889668767df80bcca4f4d5710fd577fd Mon Sep 17 00:00:00 2001
From: feifei-111 <2364819892@qq.com>
Date: Tue, 7 May 2024 04:08:54 +0000
Subject: [PATCH 36/99] update

---
 paddle/cinn/operator_fusion/backend/pattern_fuser.cc | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/paddle/cinn/operator_fusion/backend/pattern_fuser.cc b/paddle/cinn/operator_fusion/backend/pattern_fuser.cc
index 820275c0c7a3de..03b1692bb97780 100644
--- a/paddle/cinn/operator_fusion/backend/pattern_fuser.cc
+++ b/paddle/cinn/operator_fusion/backend/pattern_fuser.cc
@@ -312,7 +312,9 @@ struct IrExprGetter {
   std::vector<ir::Expr> operator()(const AnchorPattern<BackendStage>& pattern) {
     std::vector<ir::Expr> result;
     for (auto promise : pattern.anchor_state.promise) {
+      result = ConcatVector(result, ApplyTransformToPromise(promise));
     }
+    return result;
   }
 
   std::vector<ir::Expr> operator()(

From 5e4e24afd373f8e000766dcf8d50306fd955be5a Mon Sep 17 00:00:00 2001
From: feifei-111 <2364819892@qq.com>
Date: Tue, 7 May 2024 07:54:45 +0000
Subject: [PATCH 37/99] fix compile err

---
 .../operator_fusion/backend/pattern_fuser.cc  |  3 +-
 .../operator_fusion/frontend/pattern_fuser.cc |  3 +-
 .../graph_transformer/matcher.h               | 10 +++--
 .../graph_transformer/operation.h             | 33 ++++++++++------
 paddle/cinn/operator_fusion/pattern.h         |  4 +-
 paddle/cinn/operator_fusion/pattern_fuser.h   | 39 +++++++++----------
 .../pir_graph_analyzing/CMakeLists.txt        |  3 +-
 .../pir_graph_analyzing/anchor_transform.h    |  2 +
 .../shardable_axes_base.cc                    |  4 +-
 .../operator_fusion/policy/CMakeLists.txt     |  2 +-
 .../policy/anchor_search_policy.cc            |  5 +--
 .../policy/anchor_search_policy.h             |  2 +-
 paddle/cinn/operator_fusion/utils.h           | 33 ++++++++--------
 13 files changed, 80 insertions(+), 63 deletions(-)

diff --git a/paddle/cinn/operator_fusion/backend/pattern_fuser.cc b/paddle/cinn/operator_fusion/backend/pattern_fuser.cc
index 03b1692bb97780..fd02326ae3a1d6 100644
--- a/paddle/cinn/operator_fusion/backend/pattern_fuser.cc
+++ b/paddle/cinn/operator_fusion/backend/pattern_fuser.cc
@@ -84,7 +84,8 @@ StmtPattern<BackendStage> MergePatternImpl(
   const auto& contents =
       UniqueConcatVector(GetOpsInPattern<BackendStage>(source),
                          GetOpsInPattern<BackendStage>(dest));
-  return AnchorPattern<BackendStage>(contents, source.anchor(), {});
+  return AnchorPattern<BackendStage>(
+      contents, source.anchor(), AnchorState<BackendStage>({}));
 }
 
 /// Start: Tmp Transform Operation for ReduceTree
diff --git a/paddle/cinn/operator_fusion/frontend/pattern_fuser.cc b/paddle/cinn/operator_fusion/frontend/pattern_fuser.cc
index 6a58245e2d5e41..7417cba2806b45 100644
--- a/paddle/cinn/operator_fusion/frontend/pattern_fuser.cc
+++ b/paddle/cinn/operator_fusion/frontend/pattern_fuser.cc
@@ -68,7 +68,8 @@ StmtPattern<FrontendStage> MergePatternImpl(
   const auto& contents =
       UniqueConcatVector(GetOpsInPattern<FrontendStage>(source),
                          GetOpsInPattern<FrontendStage>(dest));
-  return AnchorPattern<FrontendStage>(contents, source.anchor(), {});
+  return AnchorPattern<FrontendStage>(
+      contents, source.anchor(), AnchorState<FrontendStage>({}));
 }
 
 template <>
diff --git a/paddle/cinn/operator_fusion/graph_transformer/matcher.h b/paddle/cinn/operator_fusion/graph_transformer/matcher.h
index fa87f219eb7122..db43fa23ee1eeb 100644
--- a/paddle/cinn/operator_fusion/graph_transformer/matcher.h
+++ b/paddle/cinn/operator_fusion/graph_transformer/matcher.h
@@ -49,9 +49,9 @@ struct SinkTrivialMatcher {
   bool operator()(const PatternGraph<T>& graph, const PatternNodePtr<T>& node) {
     return StmtPatternGraphMatcher<TrivialPattern<T>>()(graph, node) &&
            node->downstream().size() == 1 &&
-           (std::holds_alternative<ReducePattern<Phrase>>(
+           (std::holds_alternative<ReducePattern<T>>(
                 node->downstream().at(0)->stmt_pattern()) ||
-            std::holds_alternative<TrivialPattern<Phrase>>(
+            std::holds_alternative<TrivialPattern<T>>(
                 node->downstream().at(0)->stmt_pattern()));
   }
 };
@@ -93,7 +93,7 @@ struct RecomputeNodeMatcher {
   bool operator()(const PatternGraph<T>& graph, const PatternNodePtr<T>& node) {
     return StmtPatternGraphMatcher<AnchorPattern<T>>()(graph, node) &&
            node->downstream().size() > 1 &&
-           (node->stmt_pattern.can_recompute());
+           (std::get<AnchorPattern<T>>(node->stmt_pattern()).can_recompute());
   }
 };
 
@@ -135,7 +135,9 @@ struct HorizontalFusionMatcher {
     const auto& rhs_pattern =
         std::get<HorizontalFusionPattern<T>>(rhs->stmt_pattern());
 
-    return graph.topo_manager().CanFuse(lhs, rhs) &&
+    return graph.policy_manager()
+               .template GetPolicy<GeneralTopoPolicy>()
+               ->CanFuse(lhs, rhs) &&
            IsLoopFrameworkEqual(lhs_pattern.padding_patterns_.back().pattern,
                                 rhs_pattern.padding_patterns_.back().pattern);
   }
diff --git a/paddle/cinn/operator_fusion/graph_transformer/operation.h b/paddle/cinn/operator_fusion/graph_transformer/operation.h
index fafbd133d14983..416b9cbbdd32c4 100644
--- a/paddle/cinn/operator_fusion/graph_transformer/operation.h
+++ b/paddle/cinn/operator_fusion/graph_transformer/operation.h
@@ -112,7 +112,12 @@ struct LiftToAnchorPatternOperation {
     std::vector<pir::Operation*> ops = GetOpsInPattern(node->stmt_pattern());
     // TODO(@wuzhanfei) move sink_op into pattern (currently, part of pattern
     // type has sink and the others not) then, update logic here
-    pir::Value anchor = node->sink_op();
+    PADDLE_ENFORCE_EQ(
+        node->sink_op()->num_results(),
+        1,
+        phi::errors::PreconditionNotMet(
+            "Op with multi output value can not lift to AnchorPattern"));
+    pir::Value anchor = node->sink_op()->result(0);
     node->set_stmt_pattern(AnchorPattern<Phrase>(
         ops,
         anchor,
@@ -130,19 +135,22 @@ struct FuseUpstreamAnchorOperation {
             .template GetPolicy<AnchorSearchPolicy>()
             ->FindUpstreamAnchorTransformRoute(upstream, downstream);
     PADDLE_ENFORCE_NE(
-        optional_transform_route.value(),
+        optional_transform_route,
         std::nullopt,
         phi::errors::PreconditionNotMet("Transform Route Not Found"));
 
     auto transform_route = optional_transform_route.value();
 
-    const auto merge_pattern_fn = [](const StmtPattern<Phrase>& source,
-                                     const StmtPattern<Phrase>& destination) {
+    const auto merge_pattern_fn = [transform_route](
+                                      const StmtPattern<Phrase>& source,
+                                      const StmtPattern<Phrase>& destination) {
       auto new_anchor_pattern = std::get<AnchorPattern<Phrase>>(
           MergePattern<Phrase>(source, destination));
       auto transformed_anchor_state = ApplyAnchorTransformRoute<Phrase>(
-          GetAnchorState(destination), transform_route);
-      new_anchor_pattern.anchor_state.update(GetAnchorState(source));
+          GetAnchorState(std::get<AnchorPattern<Phrase>>(destination)),
+          transform_route);
+      new_anchor_pattern.anchor_state.update(
+          GetAnchorState(std::get<AnchorPattern<Phrase>>(source)));
       new_anchor_pattern.anchor_state.update(transformed_anchor_state);
       return new_anchor_pattern;
     };
@@ -164,19 +172,22 @@ struct FuseDownstreamAnchorOperation {
             ->FindDownstreamAnchorTransformRoute(upstream, downstream);
 
     PADDLE_ENFORCE_NE(
-        optional_transform_route.value(),
+        optional_transform_route,
         std::nullopt,
         phi::errors::PreconditionNotMet("Transform Route Not Found"));
 
     auto transform_route = optional_transform_route.value();
 
-    const auto merge_pattern_fn = [](const StmtPattern<Phrase>& destination,
-                                     const StmtPattern<Phrase>& source) {
+    const auto merge_pattern_fn = [transform_route](
+                                      const StmtPattern<Phrase>& destination,
+                                      const StmtPattern<Phrase>& source) {
       auto new_anchor_pattern = std::get<AnchorPattern<Phrase>>(
           MergePattern<Phrase>(source, destination));
       auto transformed_anchor_state = ApplyAnchorTransformRoute<Phrase>(
-          GetAnchorState(destination), transform_route);
-      new_anchor_pattern.anchor_state.update(GetAnchorState(source));
+          GetAnchorState(std::get<AnchorPattern<Phrase>>(destination)),
+          transform_route);
+      new_anchor_pattern.anchor_state.update(
+          GetAnchorState(std::get<AnchorPattern<Phrase>>(source)));
       new_anchor_pattern.anchor_state.update(transformed_anchor_state);
       return new_anchor_pattern;
     };
diff --git a/paddle/cinn/operator_fusion/pattern.h b/paddle/cinn/operator_fusion/pattern.h
index d246b8cbe89465..cf85375a2713fd 100644
--- a/paddle/cinn/operator_fusion/pattern.h
+++ b/paddle/cinn/operator_fusion/pattern.h
@@ -113,8 +113,8 @@ template <typename T>
 struct AnchorPattern {
   explicit AnchorPattern(const std::vector<pir::Operation*>& ops,
                          const pir::Value& anchor,
-                         const AnchorState<T>& anchor_state)
-      : ops_(ops), anchor_(anchor), anchor_state_(anchor_state) {}
+                         const AnchorState<T>& init_anchor_state)
+      : ops_(ops), anchor_(anchor), anchor_state(init_anchor_state) {}
   AnchorState<T> anchor_state;
 
   static std::string name() { return "AnchorPattern"; }
diff --git a/paddle/cinn/operator_fusion/pattern_fuser.h b/paddle/cinn/operator_fusion/pattern_fuser.h
index b92d5b2f568901..5b21b59380e9fc 100644
--- a/paddle/cinn/operator_fusion/pattern_fuser.h
+++ b/paddle/cinn/operator_fusion/pattern_fuser.h
@@ -138,6 +138,10 @@ struct LoopFrameworkVisitor {
   MaybeLoopFramework operator()(const UnsupportPattern<T>& pattern) {
     PADDLE_ENFORCE(false, "Not support GetLoopRange.");
   }
+
+  MaybeLoopFramework operator()(const AnchorPattern<T>& pattern) {
+    PADDLE_ENFORCE(false, "Not support GetLoopRange.");
+  }
 };
 
 template <typename T>
@@ -384,38 +388,33 @@ template <typename T>
 ExprPromise<T> InitExprPromiseImpl(const ReducePattern<T>& pattern,
                                    pir::Value anchor);
 
+template <typename T, template <typename> typename PATTERN>
+ExprPromise<T> InitExprPromiseImpl(const PATTERN<T>& pattern,
+                                   pir::Value anchor) {
+  PADDLE_THROW("Can not Init ExprPromise");
+}
+
 template <typename T>
 ExprPromise<T> InitExprPromise(const StmtPattern<T>& pattern,
                                pir::Value anchor) {
   return std::visit(
-      [anchor](const auto& arg) {
-        using U = std::decay_t<decltype(arg)>;
-        if constexpr (std::is_same_v<U, TrivialPattern<T>>) {
-          return InitExprPromiseImpl(arg, anchor);
-        } else if constexpr (std::is_same_v<U, ReducePattern<T>>) {
-          return InitExprPromiseImpl(arg, anchor);
-        }
-      },
-      s.variant());
+      [anchor](const auto& arg) { return InitExprPromiseImpl(arg, anchor); },
+      pattern.variant());
 }
 
 template <typename T>
-ReducePattern<T> GetAnchorState(const StmtPattern<T>& pattern) {
-  return std::visit([](const auto& arg) { return arg.anchor_state; },
-                    pattern.variant());
+AnchorState<T> GetAnchorState(const AnchorPattern<T>& pattern) {
+  return pattern.anchor_state;
 }
 
 template <typename T>
 AnchorState<T> ApplyAnchorTransformRoute(const AnchorState<T>& anchor_state,
                                          const AnchorTransformRoute& route) {
-  return std::visit(
-      [route](const auto& arg) {
-        AnchorState<T> result = anchor_state;
-        for (auto promise : anchor_state.promise) {
-          promise.transform_route.update(route);
-        }
-      },
-      anchor_state);
+  AnchorState<T> result = anchor_state;
+  for (auto promise : result.promise) {
+    promise.update(route);
+  }
+  return result;
 }
 
 }  // namespace cinn::fusion
diff --git a/paddle/cinn/operator_fusion/pir_graph_analyzing/CMakeLists.txt b/paddle/cinn/operator_fusion/pir_graph_analyzing/CMakeLists.txt
index 450e9806cff0b3..563a72214d0b7e 100644
--- a/paddle/cinn/operator_fusion/pir_graph_analyzing/CMakeLists.txt
+++ b/paddle/cinn/operator_fusion/pir_graph_analyzing/CMakeLists.txt
@@ -1 +1,2 @@
-gather_srcs(fusion_graph_analyzing SRCS shardable_axes_base.cc dim_relation.cc)
+gather_srcs(fusion_graph_analyzing SRCS shardable_axes_base.cc dim_relation.cc,
+            anchor_transform.cc)
diff --git a/paddle/cinn/operator_fusion/pir_graph_analyzing/anchor_transform.h b/paddle/cinn/operator_fusion/pir_graph_analyzing/anchor_transform.h
index 6f4ae1701f5d65..8b558bbce578bd 100644
--- a/paddle/cinn/operator_fusion/pir_graph_analyzing/anchor_transform.h
+++ b/paddle/cinn/operator_fusion/pir_graph_analyzing/anchor_transform.h
@@ -75,6 +75,8 @@ struct ExprPromise {};
 
 template <typename T>
 struct AnchorState {
+  explicit AnchorState(const std::vector<ExprPromise<T>>& init_promise)
+      : promise(init_promise) {}
   std::vector<ExprPromise<T>> promise;
 
   void update(AnchorState<T> new_state) {
diff --git a/paddle/cinn/operator_fusion/pir_graph_analyzing/shardable_axes_base.cc b/paddle/cinn/operator_fusion/pir_graph_analyzing/shardable_axes_base.cc
index cf88b858976a4e..585163d9d42e55 100644
--- a/paddle/cinn/operator_fusion/pir_graph_analyzing/shardable_axes_base.cc
+++ b/paddle/cinn/operator_fusion/pir_graph_analyzing/shardable_axes_base.cc
@@ -115,8 +115,8 @@ ShardableAxesSignature CreateSignatureForReduce(pir::Operation* reduce_op) {
   auto input_axes = CreateNewNamesWithRank(input_rank);
 
   const auto reduce_axis_idx = [&]() -> decltype(auto) {
-    const std::vector<int64_t> axis_idx = GetReduceAxisIdx(reduce_op);
-    return std::unordered_set<int64_t>(axis_idx.begin(), axis_idx.end());
+    const std::vector<size_t> axis_idx = GetReduceAxisIdx(reduce_op);
+    return std::unordered_set<size_t>(axis_idx.begin(), axis_idx.end());
   }();
   PADDLE_ENFORCE_NE(
       reduce_axis_idx.size(),
diff --git a/paddle/cinn/operator_fusion/policy/CMakeLists.txt b/paddle/cinn/operator_fusion/policy/CMakeLists.txt
index 6b9ca2de0933db..748f78815823d6 100644
--- a/paddle/cinn/operator_fusion/policy/CMakeLists.txt
+++ b/paddle/cinn/operator_fusion/policy/CMakeLists.txt
@@ -1,2 +1,2 @@
 gather_srcs(policy_fusion_src SRCS relative_judge_policy.cc
-            general_topo_policy.cc)
+            general_topo_policy.cc, anchor_search_policy.cc)
diff --git a/paddle/cinn/operator_fusion/policy/anchor_search_policy.cc b/paddle/cinn/operator_fusion/policy/anchor_search_policy.cc
index 3accdec620560a..582b9fc9abb1a9 100644
--- a/paddle/cinn/operator_fusion/policy/anchor_search_policy.cc
+++ b/paddle/cinn/operator_fusion/policy/anchor_search_policy.cc
@@ -103,14 +103,13 @@ AnchorSearchPolicy<T>::FindDownstreamAnchorTransformRoute(
 template <typename T>
 bool AnchorSearchPolicy<T>::HasUpstreamAnchor(
     const PatternNodePtr<T>& upstream, const PatternNodePtr<T>& downstream) {
-  return FindUpstreamAnchorTransformRoute(upstream, downstream).value() !=
-         std::nullopt;
+  return FindUpstreamAnchorTransformRoute(upstream, downstream) != std::nullopt;
 }
 
 template <typename T>
 bool AnchorSearchPolicy<T>::HasDownstreamAnchor(
     const PatternNodePtr<T>& upstream, const PatternNodePtr<T>& downstream) {
-  return FindDownstreamAnchorTransformRoute(upstream, downstream).value() !=
+  return FindDownstreamAnchorTransformRoute(upstream, downstream) !=
          std::nullopt;
 }
 
diff --git a/paddle/cinn/operator_fusion/policy/anchor_search_policy.h b/paddle/cinn/operator_fusion/policy/anchor_search_policy.h
index e41c5b3e4e35e2..6b71f3efc70336 100644
--- a/paddle/cinn/operator_fusion/policy/anchor_search_policy.h
+++ b/paddle/cinn/operator_fusion/policy/anchor_search_policy.h
@@ -23,7 +23,7 @@
 namespace cinn::fusion {
 
 template <typename T>
-class AnchorSearchPolicy final : : public PolicyBase<T> {
+struct AnchorSearchPolicy final : public PolicyBase<T> {
   static constexpr PolicyKind Kind = PolicyKind::AnchorSearch;
   bool HasUpstreamAnchor(const PatternNodePtr<T>& upstream,
                          const PatternNodePtr<T>& downstream);
diff --git a/paddle/cinn/operator_fusion/utils.h b/paddle/cinn/operator_fusion/utils.h
index 8ba733b2c4a1cb..3c75906705ab0d 100644
--- a/paddle/cinn/operator_fusion/utils.h
+++ b/paddle/cinn/operator_fusion/utils.h
@@ -88,6 +88,22 @@ static bool GetReduceOpKeepDims(pir::Operation* reduce_op) {
   return attr_val.dyn_cast<::pir::BoolAttribute>().data();
 }
 
+static std::optional<std::pair<pir::Value, pir::Value>>
+GetBroadcastOpInputOuputValue(pir::Operation* op) {
+  auto* mut_op = const_cast<pir::Operation*>(op);
+  if (op->isa<paddle::dialect::ExpandOp>()) {
+    auto expand_op = mut_op->dyn_cast<paddle::dialect::ExpandOp>();
+    return std::make_pair(expand_op.x(), expand_op.out());
+  } else if (op->isa<cinn::dialect::BroadcastOp>()) {
+    auto broadcast_op = mut_op->dyn_cast<cinn::dialect::BroadcastOp>();
+    return std::make_pair(broadcast_op.x(), broadcast_op.out());
+  } else {
+    PADDLE_THROW(
+        phi::errors::Unimplemented("Unsupported broadcast op, %s", op->name()));
+  }
+  return std::nullopt;
+}
+
 static std::vector<std::pair<size_t, size_t>> GetNonBroadCastDims(
     pir::Operation* op) {
   std::vector<std::pair<size_t, size_t>> res;
@@ -128,21 +144,6 @@ static std::string OpsDebugStr(std::vector<pir::Operation*> ops) {
   return ss.str();
 }
 
-static std::optional<std::pair<pir::Value, pir::Value>>
-GetBroadcastOpInputOuputValue(pir::Operation* op) {
-  auto* mut_op = const_cast<pir::Operation*>(op);
-  if (op->isa<paddle::dialect::ExpandOp>()) {
-    auto expand_op = mut_op->dyn_cast<paddle::dialect::ExpandOp>();
-    return std::make_pair(expand_op.x(), expand_op.out());
-  } else if (op->isa<cinn::dialect::BroadcastOp>()) {
-    auto broadcast_op = mut_op->dyn_cast<cinn::dialect::BroadcastOp>();
-    return std::make_pair(broadcast_op.x(), broadcast_op.out());
-  } else {
-    CHECK(false) << "Unsupported broadcast op: " << op->name();
-  }
-  return std::nullopt;
-}
-
 template <typename T>
 void RemoveFromVector(std::vector<T>* vec, T item) {
   auto iter = std::find(vec->begin(), vec->end(), item);
@@ -393,7 +394,7 @@ static const size_t GetUsageIdx(const pir::Value& v, pir::Operation* op) {
 
 static const size_t GetOperandIdx(const pir::Value& v, pir::Operation* op) {
   for (size_t i = 0; i < op->num_operands(); i++) {
-    if (op->operand(i) == v) {
+    if (op->operand(i).source() == v) {
       return i;
     }
   }

From 0b622073ef395f5b17c94a2f89516dccabe75fda Mon Sep 17 00:00:00 2001
From: feifei-111 <2364819892@qq.com>
Date: Tue, 7 May 2024 09:17:37 +0000
Subject: [PATCH 38/99] update

---
 .../operator_fusion/backend/pattern_fuser.h   |  5 ----
 .../operator_fusion/frontend/pattern_fuser.h  |  5 ----
 paddle/cinn/operator_fusion/pattern_fuser.h   |  4 ---
 .../pir_graph_analyzing/CMakeLists.txt        |  2 +-
 .../pir_graph_analyzing/anchor_transform.cc   |  7 +++---
 .../pir_graph_analyzing/anchor_transform.h    | 25 ++++++++++++++++---
 .../operator_fusion/policy/CMakeLists.txt     |  2 +-
 .../policy/anchor_search_policy.cc            | 14 ++++-------
 paddle/cinn/operator_fusion/utils.h           |  6 +++++
 test/quantization/CMakeLists.txt              |  4 +--
 10 files changed, 39 insertions(+), 35 deletions(-)

diff --git a/paddle/cinn/operator_fusion/backend/pattern_fuser.h b/paddle/cinn/operator_fusion/backend/pattern_fuser.h
index 11188ff92998b9..1fa9a0a4a6a5be 100644
--- a/paddle/cinn/operator_fusion/backend/pattern_fuser.h
+++ b/paddle/cinn/operator_fusion/backend/pattern_fuser.h
@@ -46,11 +46,6 @@ StmtPattern<BackendStage> MergePatternImpl(
     const AnchorPattern<BackendStage>& source,
     const AnchorPattern<BackendStage>& dest);
 
-template <>
-StmtPattern<BackendStage> MergePatternImpl(
-    const HorizontalFusionPattern<BackendStage>& first,
-    const HorizontalFusionPattern<BackendStage>& second);
-
 std::vector<ir::Expr> GetExprFromPattern(
     const StmtPattern<BackendStage>& pattern);
 
diff --git a/paddle/cinn/operator_fusion/frontend/pattern_fuser.h b/paddle/cinn/operator_fusion/frontend/pattern_fuser.h
index 3ea2afaaf912ef..ee064b305cd4ef 100644
--- a/paddle/cinn/operator_fusion/frontend/pattern_fuser.h
+++ b/paddle/cinn/operator_fusion/frontend/pattern_fuser.h
@@ -46,11 +46,6 @@ StmtPattern<FrontendStage> MergePatternImpl(
     const AnchorPattern<FrontendStage>& source,
     const AnchorPattern<FrontendStage>& dest);
 
-template <>
-StmtPattern<FrontendStage> MergePatternImpl(
-    const HorizontalFusionPattern<FrontendStage>& first,
-    const HorizontalFusionPattern<FrontendStage>& second);
-
 template <>
 ExprPromise<FrontendStage> InitExprPromiseImpl(
     const TrivialPattern<FrontendStage>& pattern, pir::Value anchor);
diff --git a/paddle/cinn/operator_fusion/pattern_fuser.h b/paddle/cinn/operator_fusion/pattern_fuser.h
index 5b21b59380e9fc..d9936bcc326edd 100644
--- a/paddle/cinn/operator_fusion/pattern_fuser.h
+++ b/paddle/cinn/operator_fusion/pattern_fuser.h
@@ -343,10 +343,6 @@ template <typename T>
 StmtPattern<T> MergePatternImpl(const AnchorPattern<T>& source,
                                 const AnchorPattern<T>& dest);
 
-template <typename T>
-StmtPattern<T> MergePatternImpl(const HorizontalFusionPattern<T>& first,
-                                const HorizontalFusionPattern<T>& second);
-
 template <typename T>
 StmtPattern<T> MergePattern(const StmtPattern<T>& first,
                             const StmtPattern<T>& second) {
diff --git a/paddle/cinn/operator_fusion/pir_graph_analyzing/CMakeLists.txt b/paddle/cinn/operator_fusion/pir_graph_analyzing/CMakeLists.txt
index 563a72214d0b7e..7a5d0ed449cbd8 100644
--- a/paddle/cinn/operator_fusion/pir_graph_analyzing/CMakeLists.txt
+++ b/paddle/cinn/operator_fusion/pir_graph_analyzing/CMakeLists.txt
@@ -1,2 +1,2 @@
-gather_srcs(fusion_graph_analyzing SRCS shardable_axes_base.cc dim_relation.cc,
+gather_srcs(fusion_graph_analyzing SRCS shardable_axes_base.cc dim_relation.cc
             anchor_transform.cc)
diff --git a/paddle/cinn/operator_fusion/pir_graph_analyzing/anchor_transform.cc b/paddle/cinn/operator_fusion/pir_graph_analyzing/anchor_transform.cc
index f74f12a5816bcc..9c2bca8b4fbf0b 100644
--- a/paddle/cinn/operator_fusion/pir_graph_analyzing/anchor_transform.cc
+++ b/paddle/cinn/operator_fusion/pir_graph_analyzing/anchor_transform.cc
@@ -99,6 +99,7 @@ AnchorTransform CreateAnchorTransform(const TransformInfo& info) {
   }
 
   const hlir::framework::OpPatternKind kind = GetOpPatternKind(info.op);
+  AnchorTransform result;
   if (kind == hlir::framework::kReduction) {
     result = CreateAnchorTransformForReduce(info);
   } else if (kind == hlir::framework::kElementWise) {
@@ -128,17 +129,17 @@ std::vector<AnchorTransform> PossibleTransform(pir::Value v) {
        ++consumer_it) {
     auto downstream_op = consumer_it->owner();
     size_t input_idx = GetOperandIdx(v, downstream_op);
-    for (size_t i = 0; i < downstream_op.num_results(); i++) {
+    for (size_t i = 0; i < downstream_op->num_results(); i++) {
       result.emplace_back(CreateAnchorTransform(
           TransformInfo(downstream_op, input_idx, i, false)));
     }
   }
 
-  return results;
+  return result;
 }
 
 TransformInfo GetTransformInfo(AnchorTransform trans) {
-  return std::visit([](auto&& arg{}) { return arg->info; }, trans);
+  return std::visit([](auto&& arg) { return arg->info; }, trans);
 }
 
 }  // namespace cinn::fusion
diff --git a/paddle/cinn/operator_fusion/pir_graph_analyzing/anchor_transform.h b/paddle/cinn/operator_fusion/pir_graph_analyzing/anchor_transform.h
index 8b558bbce578bd..45be7bad2dc2cd 100644
--- a/paddle/cinn/operator_fusion/pir_graph_analyzing/anchor_transform.h
+++ b/paddle/cinn/operator_fusion/pir_graph_analyzing/anchor_transform.h
@@ -19,10 +19,14 @@
 
 namespace cinn::fusion {
 struct TransformInfo {
-  pir::Operation* op;
-  size_t input_idx;
-  size_t output_idx;
-  bool is_upstream_anchor;
+  explicit TransformInfo(pir::Operation* op_,
+                         size_t input_idx_,
+                         size_t output_idx_,
+                         bool is_upstream_anchor_)
+      : op(op_),
+        input_idx(input_idx_),
+        output_idx(output_idx_),
+        is_upstream_anchor(is_upstream_anchor_) {}
   pir::Value InputValue() { return op->operand_source(input_idx); }
   pir::Value OutputValue() { return op->result(output_idx); }
   pir::Value SrcValue() {
@@ -39,22 +43,35 @@ struct TransformInfo {
       return OutputValue();
     }
   }
+
+  pir::Operation* op;
+  size_t input_idx;
+  size_t output_idx;
+  bool is_upstream_anchor;
 };
 
 struct UnsupportTransform {
+  explicit UnsupportTransform(const TransformInfo& info_) : info(info_) {}
   TransformInfo info;
 };
 
 struct IdentityTransform {
+  explicit IdentityTransform(const TransformInfo& info_) : info(info_) {}
   TransformInfo info;
 };
 
 struct AppendDimTransform {
+  explicit AppendDimTransform(const TransformInfo& info_,
+                              const std::vector<size_t>& append_dims_)
+      : info(info_), append_dims(append_dims_) {}
   TransformInfo info;
   std::vector<size_t> append_dims;
 };
 
 struct DeleteDimTransform {
+  explicit DeleteDimTransform(const TransformInfo& info_,
+                              const std::vector<size_t>& delete_dims_)
+      : info(info_), delete_dims(delete_dims_) {}
   TransformInfo info;
   std::vector<size_t> delete_dims;
 };
diff --git a/paddle/cinn/operator_fusion/policy/CMakeLists.txt b/paddle/cinn/operator_fusion/policy/CMakeLists.txt
index 748f78815823d6..95ab7a8317a393 100644
--- a/paddle/cinn/operator_fusion/policy/CMakeLists.txt
+++ b/paddle/cinn/operator_fusion/policy/CMakeLists.txt
@@ -1,2 +1,2 @@
 gather_srcs(policy_fusion_src SRCS relative_judge_policy.cc
-            general_topo_policy.cc, anchor_search_policy.cc)
+            general_topo_policy.cc anchor_search_policy.cc)
diff --git a/paddle/cinn/operator_fusion/policy/anchor_search_policy.cc b/paddle/cinn/operator_fusion/policy/anchor_search_policy.cc
index 582b9fc9abb1a9..bc0f715d5fb8d6 100644
--- a/paddle/cinn/operator_fusion/policy/anchor_search_policy.cc
+++ b/paddle/cinn/operator_fusion/policy/anchor_search_policy.cc
@@ -21,7 +21,7 @@ namespace cinn::fusion {
 bool IsLegalRoute(const AnchorTransformRoute& route) {
   // TODO(@wuzhanfei) we need to judge if this tranform route will reduce
   // performance
-  return True;
+  return true;
 }
 
 std::optional<AnchorTransformRoute> SearchAnchorTransformRecursively(
@@ -80,8 +80,8 @@ AnchorSearchPolicy<T>::FindUpstreamAnchorTransformRoute(
   return FindAnchorTransformRoute(
       upstream_anchor_pattern.anchor(),
       downstream_anchor_pattern.anchor(),
-      ToSet(ConcatVector(upstream_anchor_pattern.ops(),
-                         downstream_anchor_pattern.ops())));
+      ToUnorderedSet(ConcatVector(upstream_anchor_pattern.ops(),
+                                  downstream_anchor_pattern.ops())));
 }
 
 template <typename T>
@@ -96,8 +96,8 @@ AnchorSearchPolicy<T>::FindDownstreamAnchorTransformRoute(
   return FindAnchorTransformRoute(
       downstream_anchor_pattern.anchor(),
       upstream_anchor_pattern.anchor(),
-      ToSet(ConcatVector(upstream_anchor_pattern.ops(),
-                         downstream_anchor_pattern.ops())));
+      ToUnorderedSet(ConcatVector(upstream_anchor_pattern.ops(),
+                                  downstream_anchor_pattern.ops())));
 }
 
 template <typename T>
@@ -113,10 +113,6 @@ bool AnchorSearchPolicy<T>::HasDownstreamAnchor(
          std::nullopt;
 }
 
-template <typename T>
-AnchorState<T> AnchorSearchPolicy<T>::MergeAnchorState(
-    const AnchorState<T>& source, const AnchorState<T>& dest) {}
-
 template class AnchorSearchPolicy<FrontendStage>;
 template class AnchorSearchPolicy<BackendStage>;
 }  // namespace cinn::fusion
diff --git a/paddle/cinn/operator_fusion/utils.h b/paddle/cinn/operator_fusion/utils.h
index 3c75906705ab0d..28d3e2b2893f2a 100644
--- a/paddle/cinn/operator_fusion/utils.h
+++ b/paddle/cinn/operator_fusion/utils.h
@@ -196,6 +196,12 @@ std::set<T> ToSet(const std::vector<T>& input) {
   return result;
 }
 
+template <typename T>
+std::unordered_set<T> ToUnorderedSet(const std::vector<T>& input) {
+  std::unordered_set<T> result(input.begin(), input.end());
+  return result;
+}
+
 template <typename T>
 bool IsAnyFirstInSecond(const std::vector<T>& first,
                         const std::vector<T>& second) {
diff --git a/test/quantization/CMakeLists.txt b/test/quantization/CMakeLists.txt
index f9fa50f3068061..e18f8c0a38096c 100644
--- a/test/quantization/CMakeLists.txt
+++ b/test/quantization/CMakeLists.txt
@@ -1,6 +1,4 @@
-if(ON_INFER)
-  include(../cpp/inference/test.cmake)
-endif()
+include(../cpp/inference/test.cmake)
 file(
   GLOB TEST_OPS
   RELATIVE "${CMAKE_CURRENT_SOURCE_DIR}"

From 5495a0872689057f79927c815fc2c2311314d5fc Mon Sep 17 00:00:00 2001
From: feifei-111 <2364819892@qq.com>
Date: Tue, 7 May 2024 11:53:52 +0000
Subject: [PATCH 39/99] fix horizontal fusion

---
 paddle/cinn/operator_fusion/pattern_fuser.h  | 4 ++--
 paddle/cinn/operator_fusion/pattern_graph.cc | 3 ++-
 paddle/cinn/operator_fusion/utils.h          | 2 +-
 3 files changed, 5 insertions(+), 4 deletions(-)

diff --git a/paddle/cinn/operator_fusion/pattern_fuser.h b/paddle/cinn/operator_fusion/pattern_fuser.h
index d9936bcc326edd..22456a5b0cedbc 100644
--- a/paddle/cinn/operator_fusion/pattern_fuser.h
+++ b/paddle/cinn/operator_fusion/pattern_fuser.h
@@ -87,7 +87,6 @@ struct LoopFrameworkVisitor {
 
   MaybeLoopFramework operator()(const TrivialPattern<T>& pattern) {
     pir::Operation* t_op = pattern.sink();
-    const auto& dims = GetDimExprsFromValue(t_op->result(0));
     const auto& exprs = GetDimExprsFromValue(t_op->result(0));
     return exprs;
   }
@@ -140,7 +139,8 @@ struct LoopFrameworkVisitor {
   }
 
   MaybeLoopFramework operator()(const AnchorPattern<T>& pattern) {
-    PADDLE_ENFORCE(false, "Not support GetLoopRange.");
+    const auto& exprs = GetDimExprsFromValue(pattern.anchor());
+    return exprs
   }
 };
 
diff --git a/paddle/cinn/operator_fusion/pattern_graph.cc b/paddle/cinn/operator_fusion/pattern_graph.cc
index 602ee967716256..7ad6041ec81b8b 100644
--- a/paddle/cinn/operator_fusion/pattern_graph.cc
+++ b/paddle/cinn/operator_fusion/pattern_graph.cc
@@ -150,7 +150,8 @@ void PatternGraph<T>::HorizontalFusion() {
                    Or<StmtPatternGraphMatcher<TrivialPattern<T>>,
                       StmtPatternGraphMatcher<ReduceTreePlusTrivialPattern<T>>,
                       StmtPatternGraphMatcher<ReducePattern<T>>,
-                      StmtPatternGraphMatcher<ReduceTreePattern<T>>>,
+                      StmtPatternGraphMatcher<ReduceTreePattern<T>>,
+                      StmtPatternGraphMatcher<AnchorPattern<T>>>,
                    LiftToHorizontalFusionPatternOperation>(this);
 
   GraphTransformer<NodePairPattern,
diff --git a/paddle/cinn/operator_fusion/utils.h b/paddle/cinn/operator_fusion/utils.h
index 28d3e2b2893f2a..089659d7148301 100644
--- a/paddle/cinn/operator_fusion/utils.h
+++ b/paddle/cinn/operator_fusion/utils.h
@@ -70,7 +70,7 @@ static std::vector<size_t> GetReduceAxisIdx(pir::Operation* reduce_op) {
     return reduce_axis_idx;
   }
   for (int i = 0; i < axis_attr.size(); ++i) {
-    size_t axis = axis_attr.at(i).dyn_cast<::pir::Int64Attribute>().data();
+    int64_t axis = axis_attr.at(i).dyn_cast<::pir::Int64Attribute>().data();
     if (axis < 0) {
       axis += input_rank;
     }

From 5289176d35b964d07eedbc31e999750f0a96ffca Mon Sep 17 00:00:00 2001
From: feifei-111 <2364819892@qq.com>
Date: Tue, 7 May 2024 12:06:40 +0000
Subject: [PATCH 40/99] fix syntax err

---
 paddle/cinn/operator_fusion/pattern_fuser.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/paddle/cinn/operator_fusion/pattern_fuser.h b/paddle/cinn/operator_fusion/pattern_fuser.h
index 22456a5b0cedbc..f46158295378ac 100644
--- a/paddle/cinn/operator_fusion/pattern_fuser.h
+++ b/paddle/cinn/operator_fusion/pattern_fuser.h
@@ -140,7 +140,7 @@ struct LoopFrameworkVisitor {
 
   MaybeLoopFramework operator()(const AnchorPattern<T>& pattern) {
     const auto& exprs = GetDimExprsFromValue(pattern.anchor());
-    return exprs
+    return exprs;
   }
 };
 

From dcb950059669bad85273890e4490946f56b064c6 Mon Sep 17 00:00:00 2001
From: feifei-111 <2364819892@qq.com>
Date: Wed, 8 May 2024 03:32:46 +0000
Subject: [PATCH 41/99] register anchor policy

---
 paddle/cinn/operator_fusion/group_cluster.h         | 4 ++++
 paddle/cinn/operator_fusion/policy/policy_manager.h | 8 +++-----
 2 files changed, 7 insertions(+), 5 deletions(-)

diff --git a/paddle/cinn/operator_fusion/group_cluster.h b/paddle/cinn/operator_fusion/group_cluster.h
index f90560b33e043d..436ed664903f51 100644
--- a/paddle/cinn/operator_fusion/group_cluster.h
+++ b/paddle/cinn/operator_fusion/group_cluster.h
@@ -66,10 +66,14 @@ inline std::vector<fusion::PatternNodePtr<T>> ClusterOps(
   const auto& general_topo_policy =
       std::make_shared<fusion::GeneralTopoPolicy<T>>();
 
+  const auto& anchor_search_policy =
+      std::make_shared<fusion::AnchorSearchPolicy<T>>();
+
   fusion::PolicyManager<T> policy_manager;
 
   policy_manager.SetPolicy(relative_judge_policy);
   policy_manager.SetPolicy(general_topo_policy);
+  policy_manager.SetPolicy(anchor_search_policy);
 
   VLOG(4) << "Start Create PatternGraph";
   fusion::PatternGraph<T> graph(content_without_yield, outputs, policy_manager);
diff --git a/paddle/cinn/operator_fusion/policy/policy_manager.h b/paddle/cinn/operator_fusion/policy/policy_manager.h
index 21f00032eb0049..6ad1380b83e870 100644
--- a/paddle/cinn/operator_fusion/policy/policy_manager.h
+++ b/paddle/cinn/operator_fusion/policy/policy_manager.h
@@ -36,11 +36,9 @@ class PolicyManager {
   template <template <typename> typename POLICY>
   std::shared_ptr<POLICY<T>> GetPolicy() const {
     auto key = POLICY<T>::Kind;
-    PADDLE_ENFORCE_NE(
-        policies.find(key),
-        policies.end(),
-        phi::errors::NotFound(
-            "The upstream nodes of the merged node are not unique."));
+    PADDLE_ENFORCE_NE(policies.find(key),
+                      policies.end(),
+                      phi::errors::NotFound("Policy %d Not Found", key));
     return std::static_pointer_cast<POLICY<T>>(policies.at(key));
   }
 

From aa9b9ff962107e68aa4ab910c290b74cfc8440ae Mon Sep 17 00:00:00 2001
From: feifei-111 <2364819892@qq.com>
Date: Wed, 8 May 2024 06:48:11 +0000
Subject: [PATCH 42/99] update

---
 .../graph_transformer/operation.h             | 45 +++++++++-----
 .../graph_transformer/search_algorithm.h      | 60 +++++++------------
 2 files changed, 52 insertions(+), 53 deletions(-)

diff --git a/paddle/cinn/operator_fusion/graph_transformer/operation.h b/paddle/cinn/operator_fusion/graph_transformer/operation.h
index 416b9cbbdd32c4..d00ee7de2142c9 100644
--- a/paddle/cinn/operator_fusion/graph_transformer/operation.h
+++ b/paddle/cinn/operator_fusion/graph_transformer/operation.h
@@ -22,7 +22,8 @@ namespace cinn::fusion {
 
 struct MergeReduceTreeOperation {
   template <typename Phrase>
-  void operator()(PatternGraph<Phrase>* graph, PatternNodePtr<Phrase> node) {
+  PatternNodePtr<Phrase> operator()(PatternGraph<Phrase>* graph,
+                                    PatternNodePtr<Phrase> node) {
     PADDLE_ENFORCE_EQ(
         node->downstream().size(),
         1,
@@ -36,12 +37,14 @@ struct MergeReduceTreeOperation {
     VLOG(4) << "MergeReduceTreeOperation: \nupstream " << node->DebugStr()
             << "\ndownstream " << downstream->DebugStr() << "\nmerged "
             << merged_node->DebugStr();
+    return merged_node;
   }
 };
 
 struct MergeReduceTreeAndTrivialOperation {
   template <typename Phrase>
-  void operator()(PatternGraph<Phrase>* graph, PatternNodePtr<Phrase> node) {
+  PatternNodePtr<Phrase> operator()(PatternGraph<Phrase>* graph,
+                                    PatternNodePtr<Phrase> node) {
     PADDLE_ENFORCE_EQ(
         node->downstream().size(),
         1,
@@ -67,20 +70,24 @@ struct MergeReduceTreeAndTrivialOperation {
     VLOG(4) << "MergeReduceTreeAndTrivialOperation: \nupstream "
             << node->DebugStr() << "\ndownstream " << downstream->DebugStr()
             << "\nmerged " << merged_node->DebugStr();
+    return merged_node;
   }
 };
 
 struct LiftReduceToReduceTreeOperation {
   template <typename Phrase>
-  void operator()(PatternGraph<Phrase>* graph, PatternNodePtr<Phrase> node) {
+  PatternNodePtr<Phrase> operator()(PatternGraph<Phrase>* graph,
+                                    PatternNodePtr<Phrase> node) {
     const auto& reduce_pattern = ToReducePattern<Phrase>(node->stmt_pattern());
     node->set_stmt_pattern(ReduceTreePattern<Phrase>({}, reduce_pattern));
+    return node;
   }
 };
 
 struct MergeTrivialPatternOperation {
   template <typename Phrase>
-  void operator()(PatternGraph<Phrase>* graph, PatternNodePtr<Phrase> node) {
+  PatternNodePtr<Phrase> operator()(PatternGraph<Phrase>* graph,
+                                    PatternNodePtr<Phrase> node) {
     PADDLE_ENFORCE_EQ(
         node->downstream().size(),
         1,
@@ -94,21 +101,25 @@ struct MergeTrivialPatternOperation {
     VLOG(4) << "MergeTrivialPatternOperation: \nupstream " << node->DebugStr()
             << "\ndownstream " << downstream->DebugStr() << "\nmerged "
             << merged_node->DebugStr();
+    return merged_node;
   }
 };
 
 struct LiftToHorizontalFusionPatternOperation {
   template <typename Phrase>
-  void operator()(PatternGraph<Phrase>* graph, PatternNodePtr<Phrase> node) {
+  PatternNodePtr<Phrase> operator()(PatternGraph<Phrase>* graph,
+                                    PatternNodePtr<Phrase> node) {
     node->set_stmt_pattern(HorizontalFusionPattern<Phrase>(
         {typename HorizontalFusionPattern<Phrase>::PaddingStmtPattern(
             node->stmt_pattern(), {})}));
+    return node;
   }
 };
 
 struct LiftToAnchorPatternOperation {
   template <typename Phrase>
-  void operator()(PatternGraph<Phrase>* graph, PatternNodePtr<Phrase> node) {
+  PatternNodePtr<Phrase> operator()(PatternGraph<Phrase>* graph,
+                                    PatternNodePtr<Phrase> node) {
     std::vector<pir::Operation*> ops = GetOpsInPattern(node->stmt_pattern());
     // TODO(@wuzhanfei) move sink_op into pattern (currently, part of pattern
     // type has sink and the others not) then, update logic here
@@ -122,14 +133,15 @@ struct LiftToAnchorPatternOperation {
         ops,
         anchor,
         AnchorState<Phrase>({InitExprPromise(node->stmt_pattern(), anchor)})));
+    return node;
   }
 };
 
 struct FuseUpstreamAnchorOperation {
   template <typename Phrase>
-  void operator()(PatternGraph<Phrase>* graph,
-                  const PatternNodePtr<Phrase>& upstream,
-                  const PatternNodePtr<Phrase>& downstream) {
+  PatternNodePtr<Phrase> operator()(PatternGraph<Phrase>* graph,
+                                    const PatternNodePtr<Phrase>& upstream,
+                                    const PatternNodePtr<Phrase>& downstream) {
     auto optional_transform_route =
         graph->policy_manager()
             .template GetPolicy<AnchorSearchPolicy>()
@@ -158,14 +170,15 @@ struct FuseUpstreamAnchorOperation {
     auto merged_node = graph->MergeNode(upstream, downstream, merge_pattern_fn);
     graph->RemoveNode(upstream);
     graph->RemoveNode(downstream);
+    return merged_node;
   }
 };
 
 struct FuseDownstreamAnchorOperation {
   template <typename Phrase>
-  void operator()(PatternGraph<Phrase>* graph,
-                  const PatternNodePtr<Phrase>& upstream,
-                  const PatternNodePtr<Phrase>& downstream) {
+  PatternNodePtr<Phrase> operator()(PatternGraph<Phrase>* graph,
+                                    const PatternNodePtr<Phrase>& upstream,
+                                    const PatternNodePtr<Phrase>& downstream) {
     auto optional_transform_route =
         graph->policy_manager()
             .template GetPolicy<AnchorSearchPolicy>()
@@ -195,6 +208,7 @@ struct FuseDownstreamAnchorOperation {
     auto merged_node = graph->MergeNode(upstream, downstream, merge_pattern_fn);
     graph->RemoveNode(upstream);
     graph->RemoveNode(downstream);
+    return merged_node;
   }
 };
 
@@ -240,9 +254,9 @@ struct SplitRecomputeOperation {
 
 struct HorizontalFusionOperation {
   template <typename Phrase>
-  void operator()(PatternGraph<Phrase>* graph,
-                  const PatternNodePtr<Phrase>& i,
-                  const PatternNodePtr<Phrase>& j) {
+  PatternNodePtr<Phrase> operator()(PatternGraph<Phrase>* graph,
+                                    const PatternNodePtr<Phrase>& i,
+                                    const PatternNodePtr<Phrase>& j) {
     VLOG(4) << "Start HorizontalFusionOperation";
     PADDLE_ENFORCE_EQ(
         GetPatternName(i->stmt_pattern()),
@@ -265,6 +279,7 @@ struct HorizontalFusionOperation {
     graph->RemoveNode(j);
     VLOG(4) << "After HorizontalFusionOperation, Graph is"
             << graph->GraphInfo();
+    return merged_node;
   }
 };
 
diff --git a/paddle/cinn/operator_fusion/graph_transformer/search_algorithm.h b/paddle/cinn/operator_fusion/graph_transformer/search_algorithm.h
index 354b7fca137bbf..e896f24b086ff8 100644
--- a/paddle/cinn/operator_fusion/graph_transformer/search_algorithm.h
+++ b/paddle/cinn/operator_fusion/graph_transformer/search_algorithm.h
@@ -104,54 +104,38 @@ struct SearchAlgorithm<ReverseTopoNodePairPattern,
                        GraphMatcher,
                        GraphOperation> {
   PatternGraph<Phrase>* graph_;
-  std::queue<PatternNodePtr<Phrase>> reverse_topo_nodes;
+  std::queue<PatternNodePtr<Phrase>> reverse_topo_queue;
+  std::unordered_map<PatternNodePtr<Phrase>, int> degree;
 
   explicit SearchAlgorithm(PatternGraph<Phrase>* graph) {
     VLOG(4) << "Create ReverseTopoNodePairPattern algorithm.";
     graph_ = graph;
-
-    // Do reverse topological sort, and store the results in reverse_topo_nodes.
-    auto reverse_topo_sort_result = graph->SortByReverseTopoOrder();
-    for (const auto& node : reverse_topo_sort_result) {
-      reverse_topo_nodes.push(node);
+    for (const auto& node : graph_->all_pattern_nodes()) {
+      degree[node] = node->downstream().size();
+      if (degree[node] == 0) {
+        reverse_topo_queue.push(node);
+      }
     }
   }
 
-  std::optional<std::pair<PatternNodePtr<Phrase>, PatternNodePtr<Phrase>>>
-  FindMatchedPair() {
-    //  Keep picking the front element of reverse_topo_nodes as candidate of
-    //  upstream node. Please make sure that the downstream node is merged into
-    //  the upstream node during merging, and the upstream node will not
-    //  disappear after merging, else the logic here should be modified.
-    while (!reverse_topo_nodes.empty()) {
-      const auto& upstream_candidate = reverse_topo_nodes.front();
-
-      // If the node has downstream, try searching for its candidate downstream
-      // using GraphMatcher.
-      if (!upstream_candidate->downstream().empty()) {
-        for (const auto& downstream_candidate :
-             upstream_candidate->downstream()) {
-          if (GraphMatcher()(
-                  *graph_, upstream_candidate, downstream_candidate)) {
-            VLOG(4) << "Find Matched Node Pair: (" << upstream_candidate << ", "
-                    << downstream_candidate << ")";
-            return std::make_pair(upstream_candidate, downstream_candidate);
-          }
+  void operator()() {
+    while (!reverse_topo_queue.empty()) {
+      PatternNodePtr<Phrase> node = reverse_topo_queue.front();
+      reverse_topo_queue.pop();
+
+      for (const auto& upstream : node->upstream()) {
+        degree[upstream]--;
+        if (degree[upstream] == 0) {
+          reverse_topo_queue.push(upstream);
         }
       }
-      reverse_topo_nodes.pop();
-    }
-
-    VLOG(4) << "Can't find matched node any more.";
-    return {};
-  }
 
-  void operator()() {
-    while (true) {
-      const auto& node = FindMatchedPair();
-      if (!node.has_value()) break;
-      const auto& [upstream, downstream] = node.value();
-      GraphOperation()(graph_, upstream, downstream);
+      auto fusion_candidates = node->downstream();
+      for (const auto& downstream : fusion_candidates) {
+        if (GraphMatcher()(*graph_, node, downstream)) {
+          node = GraphOperation()(graph_, node, downstream);
+        }
+      }
     }
   }
 };

From e10f83a4aa27b668764ef789dd23f52d20181bfb Mon Sep 17 00:00:00 2001
From: feifei-111 <2364819892@qq.com>
Date: Wed, 8 May 2024 07:39:35 +0000
Subject: [PATCH 43/99] update

---
 .../graph_transformer/operation.h             | 24 ++++++++++++++++
 .../pir_graph_analyzing/anchor_transform.cc   |  3 --
 .../pir_graph_analyzing/anchor_transform.h    | 28 +++++++++++++++++++
 .../pir_graph_analyzing/dim_relation.cc       |  3 --
 .../shardable_axes_base.cc                    |  3 --
 .../policy/anchor_search_policy.cc            | 21 ++++++++++----
 6 files changed, 68 insertions(+), 14 deletions(-)

diff --git a/paddle/cinn/operator_fusion/graph_transformer/operation.h b/paddle/cinn/operator_fusion/graph_transformer/operation.h
index d00ee7de2142c9..a8b892f3dd10de 100644
--- a/paddle/cinn/operator_fusion/graph_transformer/operation.h
+++ b/paddle/cinn/operator_fusion/graph_transformer/operation.h
@@ -170,6 +170,18 @@ struct FuseUpstreamAnchorOperation {
     auto merged_node = graph->MergeNode(upstream, downstream, merge_pattern_fn);
     graph->RemoveNode(upstream);
     graph->RemoveNode(downstream);
+    VLOG(4) << "upstream anchor: "
+            << std::get<AnchorPattern<Phrase>>(upstream->stmt_pattern())
+                   .anchor()
+                   .impl()
+            << ", downstream anchor: "
+            << std::get<AnchorPattern<Phrase>>(downstream->stmt_pattern())
+                   .anchor()
+                   .impl()
+            << ", merged node anchor: "
+            << std::get<AnchorPattern<Phrase>>(merged_node->stmt_pattern())
+                   .anchor()
+                   .impl();
     return merged_node;
   }
 };
@@ -208,6 +220,18 @@ struct FuseDownstreamAnchorOperation {
     auto merged_node = graph->MergeNode(upstream, downstream, merge_pattern_fn);
     graph->RemoveNode(upstream);
     graph->RemoveNode(downstream);
+    VLOG(4) << "upstream anchor: "
+            << std::get<AnchorPattern<Phrase>>(upstream->stmt_pattern())
+                   .anchor()
+                   .impl()
+            << ", downstream anchor: "
+            << std::get<AnchorPattern<Phrase>>(downstream->stmt_pattern())
+                   .anchor()
+                   .impl()
+            << ", merged node anchor: "
+            << std::get<AnchorPattern<Phrase>>(merged_node->stmt_pattern())
+                   .anchor()
+                   .impl();
     return merged_node;
   }
 };
diff --git a/paddle/cinn/operator_fusion/pir_graph_analyzing/anchor_transform.cc b/paddle/cinn/operator_fusion/pir_graph_analyzing/anchor_transform.cc
index 9c2bca8b4fbf0b..b28916bb47e589 100644
--- a/paddle/cinn/operator_fusion/pir_graph_analyzing/anchor_transform.cc
+++ b/paddle/cinn/operator_fusion/pir_graph_analyzing/anchor_transform.cc
@@ -80,9 +80,6 @@ std::optional<AnchorTransform> CreateAnchorTransformForSpecialOps(
   if (info.op->name() == "cinn_op.generate_shape") {
     return CreateDefaultAnchorTransform(info);
   }
-  if (info.op->name() == "cinn_op.yield_store") {
-    return CreateDefaultAnchorTransform(info);
-  }
   if (info.op->name() == "cinn_op.reshape") {
     return CreateDefaultAnchorTransform(info);
   }
diff --git a/paddle/cinn/operator_fusion/pir_graph_analyzing/anchor_transform.h b/paddle/cinn/operator_fusion/pir_graph_analyzing/anchor_transform.h
index 45be7bad2dc2cd..b148f954e1a028 100644
--- a/paddle/cinn/operator_fusion/pir_graph_analyzing/anchor_transform.h
+++ b/paddle/cinn/operator_fusion/pir_graph_analyzing/anchor_transform.h
@@ -44,6 +44,14 @@ struct TransformInfo {
     }
   }
 
+  std::string DebugStr() const {
+    std::stringstream ss;
+    ss << "op: " << op << ", input_idx: " << input_idx
+       << ", output_idx: " << output_idx
+       << ", is_upstream_anchor: " << is_upstream_anchor;
+    return ss.str();
+  }
+
   pir::Operation* op;
   size_t input_idx;
   size_t output_idx;
@@ -53,11 +61,21 @@ struct TransformInfo {
 struct UnsupportTransform {
   explicit UnsupportTransform(const TransformInfo& info_) : info(info_) {}
   TransformInfo info;
+  std::string DebugStr() const {
+    std::stringstream ss;
+    ss << "UnsupportTransform || " << info.DebugStr();
+    return ss.str();
+  }
 };
 
 struct IdentityTransform {
   explicit IdentityTransform(const TransformInfo& info_) : info(info_) {}
   TransformInfo info;
+  std::string DebugStr() const {
+    std::stringstream ss;
+    ss << "IdentityTransform || " << info.DebugStr();
+    return ss.str();
+  }
 };
 
 struct AppendDimTransform {
@@ -66,6 +84,11 @@ struct AppendDimTransform {
       : info(info_), append_dims(append_dims_) {}
   TransformInfo info;
   std::vector<size_t> append_dims;
+  std::string DebugStr() const {
+    std::stringstream ss;
+    ss << "AppendDimTransform || " << info.DebugStr();
+    return ss.str();
+  }
 };
 
 struct DeleteDimTransform {
@@ -74,6 +97,11 @@ struct DeleteDimTransform {
       : info(info_), delete_dims(delete_dims_) {}
   TransformInfo info;
   std::vector<size_t> delete_dims;
+  std::string DebugStr() const {
+    std::stringstream ss;
+    ss << "DeleteDimTransform || " << info.DebugStr();
+    return ss.str();
+  }
 };
 
 using UnsupportTransformPtr = std::shared_ptr<UnsupportTransform>;
diff --git a/paddle/cinn/operator_fusion/pir_graph_analyzing/dim_relation.cc b/paddle/cinn/operator_fusion/pir_graph_analyzing/dim_relation.cc
index 3ed1998ad8e416..a72e5e0a33c344 100644
--- a/paddle/cinn/operator_fusion/pir_graph_analyzing/dim_relation.cc
+++ b/paddle/cinn/operator_fusion/pir_graph_analyzing/dim_relation.cc
@@ -145,9 +145,6 @@ static std::optional<DimUsageRelation> CreateOpRelativenessForSpecialOps(
   if (op->name() == "cinn_op.generate_shape") {
     return CreateOpRelativenessForDefault(op);
   }
-  if (op->name() == "cinn_op.yield_store") {
-    return CreateOpRelativenessForDefault(op);
-  }
   return {};
 }
 
diff --git a/paddle/cinn/operator_fusion/pir_graph_analyzing/shardable_axes_base.cc b/paddle/cinn/operator_fusion/pir_graph_analyzing/shardable_axes_base.cc
index 585163d9d42e55..4947b486630b73 100644
--- a/paddle/cinn/operator_fusion/pir_graph_analyzing/shardable_axes_base.cc
+++ b/paddle/cinn/operator_fusion/pir_graph_analyzing/shardable_axes_base.cc
@@ -88,9 +88,6 @@ std::optional<ShardableAxesSignature> CreateSignatureForSpecialOps(
   if (op->name() == "cinn_op.generate_shape") {
     return CreateDefaultSignature(op);
   }
-  if (op->name() == "cinn_op.yield_store") {
-    return CreateDefaultSignature(op);
-  }
   if (op->name() == "cinn_op.reshape") {
     return CreateDefaultSignature(op);
   }
diff --git a/paddle/cinn/operator_fusion/policy/anchor_search_policy.cc b/paddle/cinn/operator_fusion/policy/anchor_search_policy.cc
index bc0f715d5fb8d6..a16065f4e3fb05 100644
--- a/paddle/cinn/operator_fusion/policy/anchor_search_policy.cc
+++ b/paddle/cinn/operator_fusion/policy/anchor_search_policy.cc
@@ -64,8 +64,12 @@ std::optional<AnchorTransformRoute> FindAnchorTransformRoute(
   std::unordered_set<pir::Value> visited;
   visited.emplace(begin);
 
-  return SearchAnchorTransformRecursively(
-      begin, end, &cur_route, &visited, ops);
+  auto result =
+      SearchAnchorTransformRecursively(begin, end, &cur_route, &visited, ops);
+  if (VLOG_IS_ON(4)) {
+    // TODO(@wuzhanfei) add log
+  }
+  return result;
 }
 
 template <typename T>
@@ -103,14 +107,21 @@ AnchorSearchPolicy<T>::FindDownstreamAnchorTransformRoute(
 template <typename T>
 bool AnchorSearchPolicy<T>::HasUpstreamAnchor(
     const PatternNodePtr<T>& upstream, const PatternNodePtr<T>& downstream) {
-  return FindUpstreamAnchorTransformRoute(upstream, downstream) != std::nullopt;
+  auto result =
+      FindUpstreamAnchorTransformRoute(upstream, downstream) != std::nullopt;
+  VLOG(4) << "[AnchorSearchPolicy] HasUpstreamAnchor between " << upstream
+          << ", " << downstream << " : " << result;
+  return result;
 }
 
 template <typename T>
 bool AnchorSearchPolicy<T>::HasDownstreamAnchor(
     const PatternNodePtr<T>& upstream, const PatternNodePtr<T>& downstream) {
-  return FindDownstreamAnchorTransformRoute(upstream, downstream) !=
-         std::nullopt;
+  auto result =
+      FindDownstreamAnchorTransformRoute(upstream, downstream) != std::nullopt;
+  VLOG(4) << "[AnchorSearchPolicy] HasDownstreamAnchor between " << upstream
+          << ", " << downstream << " : " << result;
+  return result;
 }
 
 template class AnchorSearchPolicy<FrontendStage>;

From 0f8b3f54667c67c978c17b155e2773eef3bb0c8e Mon Sep 17 00:00:00 2001
From: zhangbaizhou <zhangbaizhou@baidu.com>
Date: Wed, 8 May 2024 09:20:11 +0000
Subject: [PATCH 44/99] support LiftToAnchorPattern for reduce tree pattern

---
 .../operator/transforms/cinn_to_pd_util.cc    |  4 +--
 .../graph_transformer/matcher.h               | 29 ++++++++++++++++---
 paddle/cinn/operator_fusion/pattern_graph.cc  | 11 +++----
 3 files changed, 31 insertions(+), 13 deletions(-)

diff --git a/paddle/cinn/hlir/dialect/operator/transforms/cinn_to_pd_util.cc b/paddle/cinn/hlir/dialect/operator/transforms/cinn_to_pd_util.cc
index 387e69ff42d633..96cbeb792a28ec 100644
--- a/paddle/cinn/hlir/dialect/operator/transforms/cinn_to_pd_util.cc
+++ b/paddle/cinn/hlir/dialect/operator/transforms/cinn_to_pd_util.cc
@@ -37,8 +37,8 @@ pir::Attribute ArrayAttributeToIntArrayAttribute(
 }
 
 const auto& handler_reduce_max_op =
-    [&](::pir::Operation* op,
-        const ::pir::Builder& builder) -> ::pir::Operation* {
+    [](::pir::Operation* op,
+       const ::pir::Builder& builder) -> ::pir::Operation* {
   VLOG(6) << "transform " << op->name() << " from cinn_op to pd_op";
   auto cinn_op = op->dyn_cast<cinn::dialect::ReduceMaxOp>();
   auto attr = cinn_op.attributes();
diff --git a/paddle/cinn/operator_fusion/graph_transformer/matcher.h b/paddle/cinn/operator_fusion/graph_transformer/matcher.h
index db43fa23ee1eeb..de62a28b18adb6 100644
--- a/paddle/cinn/operator_fusion/graph_transformer/matcher.h
+++ b/paddle/cinn/operator_fusion/graph_transformer/matcher.h
@@ -88,6 +88,21 @@ struct CanFuseReduceTreeAndTrivialMatcher {
   }
 };
 
+struct LiftToAnchorPatternMatcher {
+  template <typename T>
+  bool operator()(const PatternGraph<T>& graph, const PatternNodePtr<T>& node) {
+    bool not_reduce_tree =
+        !StmtPatternGraphMatcher<ReduceTreePattern<T>>()(graph, node) &&
+        !StmtPatternGraphMatcher<ReduceTreePlusTrivialPattern<T>>()(graph,
+                                                                    node);
+    bool reduce_tree_with_single_reduce =
+        StmtPatternGraphMatcher<ReduceTreePattern<T>>()(graph, node) &&
+        std::get<ReduceTreePattern<T>>(node->stmt_pattern()).childs().size() ==
+            0;
+    return not_reduce_tree || reduce_tree_with_single_reduce;
+  }
+};
+
 struct RecomputeNodeMatcher {
   template <typename T>
   bool operator()(const PatternGraph<T>& graph, const PatternNodePtr<T>& node) {
@@ -103,8 +118,11 @@ struct HasUpstreamAnchorMatcher {
                   const PatternNodePtr<T>& upstream,
                   const PatternNodePtr<T>& downstream) {
     return graph.policy_manager()
-        .template GetPolicy<AnchorSearchPolicy>()
-        ->HasUpstreamAnchor(upstream, downstream);
+               .template GetPolicy<GeneralTopoPolicy>()
+               ->CanFuse(upstream, downstream) &&
+           graph.policy_manager()
+               .template GetPolicy<AnchorSearchPolicy>()
+               ->HasUpstreamAnchor(upstream, downstream);
   }
 };
 
@@ -114,8 +132,11 @@ struct HasDownstreamAnchorMatcher {
                   const PatternNodePtr<T>& upstream,
                   const PatternNodePtr<T>& downstream) {
     return graph.policy_manager()
-        .template GetPolicy<AnchorSearchPolicy>()
-        ->HasDownstreamAnchor(upstream, downstream);
+               .template GetPolicy<GeneralTopoPolicy>()
+               ->CanFuse(upstream, downstream) &&
+           graph.policy_manager()
+               .template GetPolicy<AnchorSearchPolicy>()
+               ->HasDownstreamAnchor(upstream, downstream);
   }
 };
 
diff --git a/paddle/cinn/operator_fusion/pattern_graph.cc b/paddle/cinn/operator_fusion/pattern_graph.cc
index 7ad6041ec81b8b..4ddc52c5dd1493 100644
--- a/paddle/cinn/operator_fusion/pattern_graph.cc
+++ b/paddle/cinn/operator_fusion/pattern_graph.cc
@@ -178,17 +178,14 @@ void PatternGraph<T>::ReduceTree_Trivial_Fusion() {
 
 template <typename T>
 void PatternGraph<T>::LiftToAnchorPattern() {
-  GraphTransformer<
-      NodePattern,
-      T,
-      And<Not<StmtPatternGraphMatcher<ReduceTreePattern<T>>>,
-          Not<StmtPatternGraphMatcher<ReduceTreePlusTrivialPattern<T>>>>,
-      LiftToAnchorPatternOperation>(this);
+  GraphTransformer<NodePattern,
+                   T,
+                   LiftToAnchorPatternMatcher,
+                   LiftToAnchorPatternOperation>(this);
 }
 
 template <typename T>
 void PatternGraph<T>::AnchorPatternFusion() {
-  // TODO(@wuzhanfei)
   GraphTransformer<ReverseTopoNodePairPattern,
                    T,
                    HasUpstreamAnchorMatcher,

From 2fcb77974684448ee4a52a16ea85ecd8edd5ded0 Mon Sep 17 00:00:00 2001
From: feifei-111 <2364819892@qq.com>
Date: Wed, 8 May 2024 09:33:06 +0000
Subject: [PATCH 45/99] update

---
 paddle/cinn/operator_fusion/graph_transformer/matcher.h  | 8 ++++++++
 .../pir_graph_analyzing/anchor_transform.cc              | 9 +++++++++
 .../pir_graph_analyzing/anchor_transform.h               | 3 ++-
 .../cinn/operator_fusion/policy/anchor_search_policy.cc  | 9 ++++++++-
 4 files changed, 27 insertions(+), 2 deletions(-)

diff --git a/paddle/cinn/operator_fusion/graph_transformer/matcher.h b/paddle/cinn/operator_fusion/graph_transformer/matcher.h
index db43fa23ee1eeb..6d602054b120ab 100644
--- a/paddle/cinn/operator_fusion/graph_transformer/matcher.h
+++ b/paddle/cinn/operator_fusion/graph_transformer/matcher.h
@@ -102,6 +102,10 @@ struct HasUpstreamAnchorMatcher {
   bool operator()(const PatternGraph<T>& graph,
                   const PatternNodePtr<T>& upstream,
                   const PatternNodePtr<T>& downstream) {
+    if (!StmtPatternGraphMatcher<AnchorPattern<T>>()(graph, upstream) ||
+        !StmtPatternGraphMatcher<AnchorPattern<T>>()(graph, downstream)) {
+      return false;
+    }
     return graph.policy_manager()
         .template GetPolicy<AnchorSearchPolicy>()
         ->HasUpstreamAnchor(upstream, downstream);
@@ -113,6 +117,10 @@ struct HasDownstreamAnchorMatcher {
   bool operator()(const PatternGraph<T>& graph,
                   const PatternNodePtr<T>& upstream,
                   const PatternNodePtr<T>& downstream) {
+    if (!StmtPatternGraphMatcher<AnchorPattern<T>>()(graph, upstream) ||
+        !StmtPatternGraphMatcher<AnchorPattern<T>>()(graph, downstream)) {
+      return false;
+    }
     return graph.policy_manager()
         .template GetPolicy<AnchorSearchPolicy>()
         ->HasDownstreamAnchor(upstream, downstream);
diff --git a/paddle/cinn/operator_fusion/pir_graph_analyzing/anchor_transform.cc b/paddle/cinn/operator_fusion/pir_graph_analyzing/anchor_transform.cc
index b28916bb47e589..436f5f0346c8f2 100644
--- a/paddle/cinn/operator_fusion/pir_graph_analyzing/anchor_transform.cc
+++ b/paddle/cinn/operator_fusion/pir_graph_analyzing/anchor_transform.cc
@@ -132,6 +132,11 @@ std::vector<AnchorTransform> PossibleTransform(pir::Value v) {
     }
   }
 
+  VLOG(4) << "PossibleTransform Result:";
+  for (const auto& trans : result) {
+    VLOG(4) << DebugStrOfAnchorTransform(trans);
+  }
+
   return result;
 }
 
@@ -139,4 +144,8 @@ TransformInfo GetTransformInfo(AnchorTransform trans) {
   return std::visit([](auto&& arg) { return arg->info; }, trans);
 }
 
+std::string DebugStrOfAnchorTransform(AnchorTransform trans) {
+  return std::visit([](auto&& arg) { return arg->DebugStr(); }, trans);
+}
+
 }  // namespace cinn::fusion
diff --git a/paddle/cinn/operator_fusion/pir_graph_analyzing/anchor_transform.h b/paddle/cinn/operator_fusion/pir_graph_analyzing/anchor_transform.h
index b148f954e1a028..cb4600ef4340cf 100644
--- a/paddle/cinn/operator_fusion/pir_graph_analyzing/anchor_transform.h
+++ b/paddle/cinn/operator_fusion/pir_graph_analyzing/anchor_transform.h
@@ -46,7 +46,7 @@ struct TransformInfo {
 
   std::string DebugStr() const {
     std::stringstream ss;
-    ss << "op: " << op << ", input_idx: " << input_idx
+    ss << "op: " << op->name() << ", input_idx: " << input_idx
        << ", output_idx: " << output_idx
        << ", is_upstream_anchor: " << is_upstream_anchor;
     return ss.str();
@@ -133,4 +133,5 @@ struct AnchorState {
 AnchorTransform CreateAnchorTransform(const TransformInfo& info);
 std::vector<AnchorTransform> PossibleTransform(pir::Value v);
 TransformInfo GetTransformInfo(AnchorTransform trans);
+std::string DebugStrOfAnchorTransform(AnchorTransform trans);
 }  // namespace cinn::fusion
diff --git a/paddle/cinn/operator_fusion/policy/anchor_search_policy.cc b/paddle/cinn/operator_fusion/policy/anchor_search_policy.cc
index a16065f4e3fb05..7e5370f8b3dddf 100644
--- a/paddle/cinn/operator_fusion/policy/anchor_search_policy.cc
+++ b/paddle/cinn/operator_fusion/policy/anchor_search_policy.cc
@@ -67,7 +67,14 @@ std::optional<AnchorTransformRoute> FindAnchorTransformRoute(
   auto result =
       SearchAnchorTransformRecursively(begin, end, &cur_route, &visited, ops);
   if (VLOG_IS_ON(4)) {
-    // TODO(@wuzhanfei) add log
+    if (result == std::nullopt) {
+      VLOG(4) << "FindAnchorTransformRoute: Not Found";
+    } else {
+      VLOG(4) << "FindAnchorTransformRoute: ";
+      for (const auto& trans : result.value()) {
+        VLOG(4) << DebugStrOfAnchorTransform(trans);
+      }
+    }
   }
   return result;
 }

From 3c35a1f2c09b68f1e0890979886b9b585b566f99 Mon Sep 17 00:00:00 2001
From: feifei-111 <2364819892@qq.com>
Date: Wed, 8 May 2024 11:42:37 +0000
Subject: [PATCH 46/99] update

---
 paddle/cinn/hlir/framework/pir/trivial_op_impl.cc | 1 +
 paddle/cinn/operator_fusion/pattern_fuser.h       | 6 ++++++
 2 files changed, 7 insertions(+)

diff --git a/paddle/cinn/hlir/framework/pir/trivial_op_impl.cc b/paddle/cinn/hlir/framework/pir/trivial_op_impl.cc
index 96b113ce8dc95a..1a8a82664104f7 100644
--- a/paddle/cinn/hlir/framework/pir/trivial_op_impl.cc
+++ b/paddle/cinn/hlir/framework/pir/trivial_op_impl.cc
@@ -584,6 +584,7 @@ std::vector<ir::Expr> OperationFusion(
   std::vector<cinn::fusion::BackendContent> contents;
   for (int i = 0; i < ops.size(); i++) {
     contents.emplace_back(ops[i], op_compute_bodies[i]);
+    VLOG(4) << "Input Funcbody: " << op_compute_bodies[i];
   }
   const auto& fusion_nodes =
       cinn::fusion::ClusterOps<cinn::fusion::BackendStage>(contents, outputs);
diff --git a/paddle/cinn/operator_fusion/pattern_fuser.h b/paddle/cinn/operator_fusion/pattern_fuser.h
index f46158295378ac..4e81c7da3b864b 100644
--- a/paddle/cinn/operator_fusion/pattern_fuser.h
+++ b/paddle/cinn/operator_fusion/pattern_fuser.h
@@ -384,6 +384,12 @@ template <typename T>
 ExprPromise<T> InitExprPromiseImpl(const ReducePattern<T>& pattern,
                                    pir::Value anchor);
 
+template <typename T>
+ExprPromise<T> InitExprPromiseImpl(const ReduceTreePattern<T>& pattern,
+                                   pir::Value anchor) {
+  return InitExprPromiseImpl(pattern.GetRootPattern(), anchor);
+}
+
 template <typename T, template <typename> typename PATTERN>
 ExprPromise<T> InitExprPromiseImpl(const PATTERN<T>& pattern,
                                    pir::Value anchor) {

From 80f31efe19956547997b87fafbb60fdc3eae3a2b Mon Sep 17 00:00:00 2001
From: feifei-111 <2364819892@qq.com>
Date: Wed, 8 May 2024 12:23:31 +0000
Subject: [PATCH 47/99] fix add_store_in_group_op

---
 .../operator/transforms/add_store_in_fusion_op_pass.cc    | 8 ++------
 1 file changed, 2 insertions(+), 6 deletions(-)

diff --git a/paddle/cinn/hlir/dialect/operator/transforms/add_store_in_fusion_op_pass.cc b/paddle/cinn/hlir/dialect/operator/transforms/add_store_in_fusion_op_pass.cc
index f7f830ec248932..cb14eb873c9046 100644
--- a/paddle/cinn/hlir/dialect/operator/transforms/add_store_in_fusion_op_pass.cc
+++ b/paddle/cinn/hlir/dialect/operator/transforms/add_store_in_fusion_op_pass.cc
@@ -25,7 +25,7 @@ namespace cinn {
 namespace dialect {
 namespace ir {
 
-class AddYieldStoreInFusionOpPattern
+class AddYieldStoreInGroupOpPattern
     : public pir::OpRewritePattern<::pir::YieldOp> {
  public:
   using pir::OpRewritePattern<::pir::YieldOp>::OpRewritePattern;
@@ -35,10 +35,6 @@ class AddYieldStoreInFusionOpPattern
     auto& shape_analysis =
         pir::ShapeAnalysisManager::Instance().Get(op->GetParentProgram());
     for (auto i = 0; i < op->num_operands(); ++i) {
-      if (op->operand_source(i).use_count() == 1) {
-        continue;
-      }
-
       rewriter.SetInsertionPointAfter(op->operand_source(i).defining_op());
       auto store_op = rewriter.Build<cinn::dialect::YieldStoreOp>(
           op->operand_source(i), op->operand_source(i).type());
@@ -63,7 +59,7 @@ class AddStoreInGroupOpPass : public pir::Pass {
 
   bool Initialize(pir::IrContext* context) override {
     pir::RewritePatternSet ps(context);
-    ps.Add<AddYieldStoreInFusionOpPattern>(context);
+    ps.Add<AddYieldStoreInGroupOpPattern>(context);
 
     patterns_ = pir::FrozenRewritePatternSet(std::move(ps));
     return true;

From 8d12de7909c1bff2ed17d6b1c0dffa3051243404 Mon Sep 17 00:00:00 2001
From: feifei-111 <2364819892@qq.com>
Date: Thu, 9 May 2024 03:07:37 +0000
Subject: [PATCH 48/99] fix pir all path test

---
 ...store_in_fusion_op_pass.cc => add_store_in_group_op_pass.cc} | 2 +-
 ...d_store_in_fusion_op_pass.h => add_store_in_group_op_pass.h} | 0
 test/cpp/pir/cinn/pir_all_path_test.cc                          | 2 +-
 3 files changed, 2 insertions(+), 2 deletions(-)
 rename paddle/cinn/hlir/dialect/operator/transforms/{add_store_in_fusion_op_pass.cc => add_store_in_group_op_pass.cc} (99%)
 rename paddle/cinn/hlir/dialect/operator/transforms/{add_store_in_fusion_op_pass.h => add_store_in_group_op_pass.h} (100%)

diff --git a/paddle/cinn/hlir/dialect/operator/transforms/add_store_in_fusion_op_pass.cc b/paddle/cinn/hlir/dialect/operator/transforms/add_store_in_group_op_pass.cc
similarity index 99%
rename from paddle/cinn/hlir/dialect/operator/transforms/add_store_in_fusion_op_pass.cc
rename to paddle/cinn/hlir/dialect/operator/transforms/add_store_in_group_op_pass.cc
index cb14eb873c9046..d4fa61e54fa974 100644
--- a/paddle/cinn/hlir/dialect/operator/transforms/add_store_in_fusion_op_pass.cc
+++ b/paddle/cinn/hlir/dialect/operator/transforms/add_store_in_group_op_pass.cc
@@ -12,7 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include "paddle/cinn/hlir/dialect/operator/transforms/add_store_in_fusion_op_pass.h"
+#include "paddle/cinn/hlir/dialect/operator/transforms/add_store_in_group_op_pass.h"
 
 #include "paddle/cinn/hlir/dialect/operator/ir/cinn_op.h"
 #include "paddle/cinn/hlir/dialect/operator/ir/manual_op.h"
diff --git a/paddle/cinn/hlir/dialect/operator/transforms/add_store_in_fusion_op_pass.h b/paddle/cinn/hlir/dialect/operator/transforms/add_store_in_group_op_pass.h
similarity index 100%
rename from paddle/cinn/hlir/dialect/operator/transforms/add_store_in_fusion_op_pass.h
rename to paddle/cinn/hlir/dialect/operator/transforms/add_store_in_group_op_pass.h
diff --git a/test/cpp/pir/cinn/pir_all_path_test.cc b/test/cpp/pir/cinn/pir_all_path_test.cc
index 7568855e1f71ca..9c511d1cc1380a 100644
--- a/test/cpp/pir/cinn/pir_all_path_test.cc
+++ b/test/cpp/pir/cinn/pir_all_path_test.cc
@@ -74,8 +74,8 @@ static void RunAndCheckResult(::pir::Program* program,
   CHECK_EQ(stage_1_pm.Run(program), true);
 
   pir::PassManager stage_2_pm(ctx);
+  stage_2_pm.AddPass(cinn::dialect::ir::CreateAddStoreInGroupOpPass());
   stage_2_pm.AddPass(cinn::dialect::ir::CreateCinnGroupClusterPass());
-  stage_2_pm.AddPass(cinn::dialect::ir::CreateAddStoreInFusionOpPass());
   stage_2_pm.AddPass(pir::CreateDeadCodeEliminationPass());
   stage_2_pm.AddPass(cinn::dialect::ir::CreateLowerCinnFusionOpPass());
   stage_2_pm.EnableIRPrinting();

From 2b61681fc2f59dfb7ad48ae79f38cb7212505894 Mon Sep 17 00:00:00 2001
From: feifei-111 <2364819892@qq.com>
Date: Thu, 9 May 2024 06:23:38 +0000
Subject: [PATCH 49/99] update

---
 paddle/cinn/hlir/dialect/operator/transforms/add_cinn_pass.cc | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/paddle/cinn/hlir/dialect/operator/transforms/add_cinn_pass.cc b/paddle/cinn/hlir/dialect/operator/transforms/add_cinn_pass.cc
index 99606db199f7ee..e39a8f865fca4f 100644
--- a/paddle/cinn/hlir/dialect/operator/transforms/add_cinn_pass.cc
+++ b/paddle/cinn/hlir/dialect/operator/transforms/add_cinn_pass.cc
@@ -28,7 +28,7 @@
 #include "paddle/cinn/hlir/dialect/operator/ir/op_dialect.h"
 #include "paddle/cinn/hlir/dialect/operator/transforms/accuracy_check_pass.h"
 #include "paddle/cinn/hlir/dialect/operator/transforms/add_broadcast_to_elementwise_pass.h"
-#include "paddle/cinn/hlir/dialect/operator/transforms/add_store_in_fusion_op_pass.h"
+#include "paddle/cinn/hlir/dialect/operator/transforms/add_store_in_group_op_pass.h"
 #include "paddle/cinn/hlir/dialect/operator/transforms/cinn_group_cluster_pass.h"
 #include "paddle/cinn/hlir/dialect/operator/transforms/dynamic_reshape_pass.h"
 #include "paddle/cinn/hlir/dialect/operator/transforms/fold_manipulation_ops_pass.h"

From 04a9223c449e0dd0506aab5069b3c16b7c7b6f22 Mon Sep 17 00:00:00 2001
From: feifei-111 <2364819892@qq.com>
Date: Thu, 9 May 2024 07:44:52 +0000
Subject: [PATCH 50/99] fix split recompute

---
 .../operator_fusion/backend/pattern_fuser.cc  | 27 +++++++++++++++++++
 .../operator_fusion/backend/pattern_fuser.h   | 20 ++++++++++++++
 .../operator_fusion/frontend/pattern_fuser.cc | 27 +++++++++++++++++++
 .../operator_fusion/frontend/pattern_fuser.h  | 20 ++++++++++++++
 .../graph_transformer/matcher.h               |  1 -
 .../graph_transformer/operation.h             | 23 ++++++++++------
 paddle/cinn/operator_fusion/pattern_fuser.h   | 26 ++++++++++++++++++
 paddle/cinn/operator_fusion/pattern_graph.cc  |  2 --
 test/cpp/pir/cinn/pir_all_path_test.cc        |  2 +-
 9 files changed, 136 insertions(+), 12 deletions(-)

diff --git a/paddle/cinn/operator_fusion/backend/pattern_fuser.cc b/paddle/cinn/operator_fusion/backend/pattern_fuser.cc
index fd02326ae3a1d6..bd1e26eb1dc5b8 100644
--- a/paddle/cinn/operator_fusion/backend/pattern_fuser.cc
+++ b/paddle/cinn/operator_fusion/backend/pattern_fuser.cc
@@ -77,6 +77,27 @@ StmtPattern<BackendStage> MergePatternImpl(
   return TrivialPattern<BackendStage>(ops, second.sink(), trivial_op);
 }
 
+template <>
+StmtPattern<BackendStage> MergePatternImpl(
+    const TrivialPattern<BackendStage>& first,
+    const ReduceTreePattern<BackendStage>& second) {
+  // TODO(@wuzhanfei)
+}
+
+template <>
+StmtPattern<BackendStage> MergePatternImpl(
+    const TrivialPattern<BackendStage>& first,
+    const ReduceTreePlusTrivialPattern<BackendStage>& second) {
+  // TODO(@wuzhanfei)
+}
+
+template <>
+StmtPattern<BackendStage> MergePatternImpl(
+    const TrivialPattern<BackendStage>& first,
+    const AnchorPattern<BackendStage>& second) {
+  // TODO(@wuzhanfei)
+}
+
 template <>
 StmtPattern<BackendStage> MergePatternImpl(
     const AnchorPattern<BackendStage>& source,
@@ -451,4 +472,10 @@ ExprPromise<BackendStage> InitExprPromiseImpl(
   return ExprPromise<BackendStage>(anchor, pattern.reduce_op);
 }
 
+template <>
+TrivialPattern<BackendStage> RecoverAnchorPatternToTrivial(
+    const AnchorPattern<BackendStage>& anchor_pattern) {
+  // TODO(@wuzhanfei)
+}
+
 }  // namespace cinn::fusion
diff --git a/paddle/cinn/operator_fusion/backend/pattern_fuser.h b/paddle/cinn/operator_fusion/backend/pattern_fuser.h
index 1fa9a0a4a6a5be..56d9a1c4b84476 100644
--- a/paddle/cinn/operator_fusion/backend/pattern_fuser.h
+++ b/paddle/cinn/operator_fusion/backend/pattern_fuser.h
@@ -41,6 +41,21 @@ StmtPattern<BackendStage> MergePatternImpl(
     const TrivialPattern<BackendStage>& first,
     const TrivialPattern<BackendStage>& second);
 
+template <>
+StmtPattern<BackendStage> MergePatternImpl(
+    const TrivialPattern<BackendStage>& first,
+    const ReduceTreePattern<BackendStage>& second);
+
+template <>
+StmtPattern<BackendStage> MergePatternImpl(
+    const TrivialPattern<BackendStage>& first,
+    const ReduceTreePlusTrivialPattern<BackendStage>& second);
+
+template <>
+StmtPattern<BackendStage> MergePatternImpl(
+    const TrivialPattern<BackendStage>& first,
+    const AnchorPattern<BackendStage>& second);
+
 template <>
 StmtPattern<BackendStage> MergePatternImpl(
     const AnchorPattern<BackendStage>& source,
@@ -56,4 +71,9 @@ ExprPromise<BackendStage> InitExprPromiseImpl(
 template <>
 ExprPromise<BackendStage> InitExprPromiseImpl(
     const ReducePattern<BackendStage>& pattern, pir::Value anchor);
+
+template <>
+TrivialPattern<BackendStage> RecoverAnchorPatternToTrivial(
+    const AnchorPattern<BackendStage>& anchor_pattern);
+
 }  // namespace cinn::fusion
diff --git a/paddle/cinn/operator_fusion/frontend/pattern_fuser.cc b/paddle/cinn/operator_fusion/frontend/pattern_fuser.cc
index 7417cba2806b45..3a40ff8f6a0fa3 100644
--- a/paddle/cinn/operator_fusion/frontend/pattern_fuser.cc
+++ b/paddle/cinn/operator_fusion/frontend/pattern_fuser.cc
@@ -61,6 +61,27 @@ StmtPattern<FrontendStage> MergePatternImpl(
   return TrivialPattern<FrontendStage>(contents, second.sink());
 }
 
+template <>
+StmtPattern<FrontendStage> MergePatternImpl(
+    const TrivialPattern<FrontendStage>& first,
+    const ReduceTreePattern<FrontendStage>& second) {
+  // TODO(@wuzhanfei)
+}
+
+template <>
+StmtPattern<FrontendStage> MergePatternImpl(
+    const TrivialPattern<FrontendStage>& first,
+    const ReduceTreePlusTrivialPattern<FrontendStage>& second) {
+  // TODO(@wuzhanfei)
+}
+
+template <>
+StmtPattern<FrontendStage> MergePatternImpl(
+    const TrivialPattern<FrontendStage>& first,
+    const AnchorPattern<FrontendStage>& second) {
+  // TODO(@wuzhanfei)
+}
+
 template <>
 StmtPattern<FrontendStage> MergePatternImpl(
     const AnchorPattern<FrontendStage>& source,
@@ -84,4 +105,10 @@ ExprPromise<FrontendStage> InitExprPromiseImpl(
   return ExprPromise<FrontendStage>(anchor);
 }
 
+template <>
+TrivialPattern<FrontendStage> RecoverAnchorPatternToTrivial(
+    const AnchorPattern<FrontendStage>& anchor_pattern) {
+  // TODO(@wuzhanfei)
+}
+
 }  // namespace cinn::fusion
diff --git a/paddle/cinn/operator_fusion/frontend/pattern_fuser.h b/paddle/cinn/operator_fusion/frontend/pattern_fuser.h
index ee064b305cd4ef..88d09fd70324c0 100644
--- a/paddle/cinn/operator_fusion/frontend/pattern_fuser.h
+++ b/paddle/cinn/operator_fusion/frontend/pattern_fuser.h
@@ -41,6 +41,21 @@ StmtPattern<FrontendStage> MergePatternImpl(
     const TrivialPattern<FrontendStage>& first,
     const TrivialPattern<FrontendStage>& second);
 
+template <>
+StmtPattern<FrontendStage> MergePatternImpl(
+    const TrivialPattern<FrontendStage>& first,
+    const ReduceTreePattern<FrontendStage>& second);
+
+template <>
+StmtPattern<FrontendStage> MergePatternImpl(
+    const TrivialPattern<FrontendStage>& first,
+    const ReduceTreePlusTrivialPattern<FrontendStage>& second);
+
+template <>
+StmtPattern<FrontendStage> MergePatternImpl(
+    const TrivialPattern<FrontendStage>& first,
+    const AnchorPattern<FrontendStage>& second);
+
 template <>
 StmtPattern<FrontendStage> MergePatternImpl(
     const AnchorPattern<FrontendStage>& source,
@@ -53,4 +68,9 @@ ExprPromise<FrontendStage> InitExprPromiseImpl(
 template <>
 ExprPromise<FrontendStage> InitExprPromiseImpl(
     const ReducePattern<FrontendStage>& pattern, pir::Value anchor);
+
+template <>
+TrivialPattern<FrontendStage> RecoverAnchorPatternToTrivial(
+    const AnchorPattern<FrontendStage>& anchor_pattern);
+
 }  // namespace cinn::fusion
diff --git a/paddle/cinn/operator_fusion/graph_transformer/matcher.h b/paddle/cinn/operator_fusion/graph_transformer/matcher.h
index 8075b0e8455887..4f4fab3e2d0d24 100644
--- a/paddle/cinn/operator_fusion/graph_transformer/matcher.h
+++ b/paddle/cinn/operator_fusion/graph_transformer/matcher.h
@@ -107,7 +107,6 @@ struct RecomputeNodeMatcher {
   template <typename T>
   bool operator()(const PatternGraph<T>& graph, const PatternNodePtr<T>& node) {
     return StmtPatternGraphMatcher<AnchorPattern<T>>()(graph, node) &&
-           node->downstream().size() > 1 &&
            (std::get<AnchorPattern<T>>(node->stmt_pattern()).can_recompute());
   }
 };
diff --git a/paddle/cinn/operator_fusion/graph_transformer/operation.h b/paddle/cinn/operator_fusion/graph_transformer/operation.h
index a8b892f3dd10de..c40fa2445d0a4f 100644
--- a/paddle/cinn/operator_fusion/graph_transformer/operation.h
+++ b/paddle/cinn/operator_fusion/graph_transformer/operation.h
@@ -251,13 +251,22 @@ struct SplitRecomputeOperation {
         upstream->downstream();
     upstream->ClearDownstream();
 
+    upstream->set_stmt_pattern(RecoverAnchorPatternToTrivial(
+        std::get<AnchorPattern<Phrase>>(upstream->stmt_pattern())));
+
     for (const auto& downstream : fusion_candidate) {
-      bool can_fuse = graph->policy_manager()
-                          .template GetPolicy<AnchorSearchPolicy>()
-                          ->HasDownstreamAnchor(upstream, downstream) ||
-                      graph->policy_manager()
-                          .template GetPolicy<AnchorSearchPolicy>()
-                          ->HasUpstreamAnchor(upstream, downstream);
+      bool can_fuse =
+          std::holds_alternative<ReducePattern<Phrase>>(
+              downstream->stmt_pattern()) ||
+          std::holds_alternative<TrivialPattern<Phrase>>(
+              downstream->stmt_pattern()) ||
+          std::holds_alternative<ReduceTreePattern<Phrase>>(
+              downstream->stmt_pattern()) ||
+          std::holds_alternative<ReduceTreePlusTrivialPattern<Phrase>>(
+              downstream->stmt_pattern()) ||
+          std::holds_alternative<AnchorPattern<Phrase>>(
+              downstream->stmt_pattern());
+
       if (can_fuse) {
         auto merged_node =
             graph->MergeNode(upstream, downstream, MergePattern<Phrase>);
@@ -301,8 +310,6 @@ struct HorizontalFusionOperation {
             << j->DebugStr() << "\nmerged " << merged_node->DebugStr();
     graph->RemoveNode(i);
     graph->RemoveNode(j);
-    VLOG(4) << "After HorizontalFusionOperation, Graph is"
-            << graph->GraphInfo();
     return merged_node;
   }
 };
diff --git a/paddle/cinn/operator_fusion/pattern_fuser.h b/paddle/cinn/operator_fusion/pattern_fuser.h
index 4e81c7da3b864b..4f3524ca3e04c0 100644
--- a/paddle/cinn/operator_fusion/pattern_fuser.h
+++ b/paddle/cinn/operator_fusion/pattern_fuser.h
@@ -339,6 +339,18 @@ template <typename T>
 StmtPattern<T> MergePatternImpl(const TrivialPattern<T>& first,
                                 const TrivialPattern<T>& second);
 
+template <typename T>
+StmtPattern<T> MergePatternImpl(const TrivialPattern<T>& first,
+                                const ReduceTreePattern<T>& second);
+
+template <typename T>
+StmtPattern<T> MergePatternImpl(const TrivialPattern<T>& first,
+                                const ReduceTreePlusTrivialPattern<T>& second);
+
+template <typename T>
+StmtPattern<T> MergePatternImpl(const TrivialPattern<T>& first,
+                                const AnchorPattern<T>& second);
+
 template <typename T>
 StmtPattern<T> MergePatternImpl(const AnchorPattern<T>& source,
                                 const AnchorPattern<T>& dest);
@@ -361,6 +373,16 @@ StmtPattern<T> MergePattern(const StmtPattern<T>& first,
       [&](const TrivialPattern<T>& lhs, const TrivialPattern<T>& rhs) {
         return MergePatternImpl(lhs, rhs);
       },
+      [&](const TrivialPattern<T>& lhs, const ReduceTreePattern<T>& rhs) {
+        return MergePatternImpl(lhs, rhs);
+      },
+      [&](const TrivialPattern<T>& lhs,
+          const ReduceTreePlusTrivialPattern<T>& rhs) {
+        return MergePatternImpl(lhs, rhs);
+      },
+      [&](const TrivialPattern<T>& lhs, const AnchorPattern<T>& rhs) {
+        return MergePatternImpl(lhs, rhs);
+      },
       [&](const AnchorPattern<T>& lhs, const AnchorPattern<T>& rhs) {
         return MergePatternImpl(lhs, rhs);
       },
@@ -404,6 +426,10 @@ ExprPromise<T> InitExprPromise(const StmtPattern<T>& pattern,
       pattern.variant());
 }
 
+template <typename T>
+TrivialPattern<T> RecoverAnchorPatternToTrivial(
+    const AnchorPattern<T>& anchor_pattern);
+
 template <typename T>
 AnchorState<T> GetAnchorState(const AnchorPattern<T>& pattern) {
   return pattern.anchor_state;
diff --git a/paddle/cinn/operator_fusion/pattern_graph.cc b/paddle/cinn/operator_fusion/pattern_graph.cc
index 4ddc52c5dd1493..382f36f11879a2 100644
--- a/paddle/cinn/operator_fusion/pattern_graph.cc
+++ b/paddle/cinn/operator_fusion/pattern_graph.cc
@@ -143,8 +143,6 @@ void PatternGraph<T>::ReduceLiftReduceTree() {
 
 template <typename T>
 void PatternGraph<T>::HorizontalFusion() {
-  // TODO(@wuzhanfei) need a new matcher, or check under fusion pattern
-  // operation?
   GraphTransformer<NodePattern,
                    T,
                    Or<StmtPatternGraphMatcher<TrivialPattern<T>>,
diff --git a/test/cpp/pir/cinn/pir_all_path_test.cc b/test/cpp/pir/cinn/pir_all_path_test.cc
index 9c511d1cc1380a..5b789d039d3b0a 100644
--- a/test/cpp/pir/cinn/pir_all_path_test.cc
+++ b/test/cpp/pir/cinn/pir_all_path_test.cc
@@ -20,7 +20,7 @@
 #include "paddle/cinn/hlir/dialect/operator/ir/manual_op.h"
 #include "paddle/cinn/hlir/dialect/operator/ir/op_dialect.h"
 #include "paddle/cinn/hlir/dialect/operator/transforms/add_broadcast_to_elementwise_pass.h"
-#include "paddle/cinn/hlir/dialect/operator/transforms/add_store_in_fusion_op_pass.h"
+#include "paddle/cinn/hlir/dialect/operator/transforms/add_store_in_group_op_pass.h"
 #include "paddle/cinn/hlir/dialect/operator/transforms/cinn_group_cluster_pass.h"
 #include "paddle/cinn/hlir/dialect/operator/transforms/group_merge/divide_group_op_to_fusion_op_pass.h"
 #include "paddle/cinn/hlir/dialect/operator/transforms/lowering_pass/lower_cinn_fusion_op_pass.h"

From 78a514ccefa32e6ecdb685878b6055ff0dc9f5c7 Mon Sep 17 00:00:00 2001
From: feifei-111 <2364819892@qq.com>
Date: Thu, 9 May 2024 11:50:01 +0000
Subject: [PATCH 51/99] update

---
 .../cinn/operator_fusion/backend/pattern_fuser.cc  | 14 +++++++++++++-
 .../cinn/operator_fusion/frontend/pattern_fuser.cc | 10 +++++++++-
 2 files changed, 22 insertions(+), 2 deletions(-)

diff --git a/paddle/cinn/operator_fusion/backend/pattern_fuser.cc b/paddle/cinn/operator_fusion/backend/pattern_fuser.cc
index bd1e26eb1dc5b8..b155619a693ae7 100644
--- a/paddle/cinn/operator_fusion/backend/pattern_fuser.cc
+++ b/paddle/cinn/operator_fusion/backend/pattern_fuser.cc
@@ -475,7 +475,19 @@ ExprPromise<BackendStage> InitExprPromiseImpl(
 template <>
 TrivialPattern<BackendStage> RecoverAnchorPatternToTrivial(
     const AnchorPattern<BackendStage>& anchor_pattern) {
-  // TODO(@wuzhanfei)
+  PADDLE_ENFORCE(anchor_pattern.anchor_state.promise.size() == 1 &&
+                     std::holds_alternative<TrivialOp>(
+                         anchor_pattern.anchor_state.promise[0].root_fusion_op),
+                 phi::errors::PreconditionNotMet(
+                     "Can only recover AnchorPatter whose anchor_state size is "
+                     "1 (exact %d) and holds TrivialOp",
+                     anchor_pattern.anchor_state.promise.size()));
+
+  return TrivialPattern<BackendStage>(
+      anchor_pattern.ops(),
+      anchor_pattern.anchor().defining_op(),
+      std::get<TrivialOp>(
+          anchor_pattern.anchor_state.promise[0].root_fusion_op));
 }
 
 }  // namespace cinn::fusion
diff --git a/paddle/cinn/operator_fusion/frontend/pattern_fuser.cc b/paddle/cinn/operator_fusion/frontend/pattern_fuser.cc
index 3a40ff8f6a0fa3..986745530d509b 100644
--- a/paddle/cinn/operator_fusion/frontend/pattern_fuser.cc
+++ b/paddle/cinn/operator_fusion/frontend/pattern_fuser.cc
@@ -108,7 +108,15 @@ ExprPromise<FrontendStage> InitExprPromiseImpl(
 template <>
 TrivialPattern<FrontendStage> RecoverAnchorPatternToTrivial(
     const AnchorPattern<FrontendStage>& anchor_pattern) {
-  // TODO(@wuzhanfei)
+  PADDLE_ENFORCE_EQ(anchor_pattern.anchor_state.promise.size(),
+                    1,
+                    phi::errors::PreconditionNotMet(
+                        "Can only recover AnchorPattern whose anchor_state "
+                        "size is 1 (exact %d)",
+                        anchor_pattern.anchor_state.promise.size()));
+
+  return TrivialPattern<FrontendStage>(anchor_pattern.ops(),
+                                       anchor_pattern.anchor().defining_op());
 }
 
 }  // namespace cinn::fusion

From 37238248d8a06336e9013e0569230acb637ceb47 Mon Sep 17 00:00:00 2001
From: feifei-111 <2364819892@qq.com>
Date: Thu, 9 May 2024 12:55:00 +0000
Subject: [PATCH 52/99] update

---
 paddle/cinn/operator_fusion/backend/pattern.h |  6 ++--
 .../operator_fusion/backend/pattern_fuser.cc  | 16 +--------
 .../operator_fusion/backend/pattern_fuser.h   | 10 ------
 .../cinn/operator_fusion/frontend/pattern.h   |  6 ++--
 .../operator_fusion/frontend/pattern_fuser.cc | 16 +--------
 .../operator_fusion/frontend/pattern_fuser.h  | 10 ------
 paddle/cinn/operator_fusion/pattern_fuser.h   | 35 +++++++++++++++++--
 paddle/cinn/operator_fusion/utils.h           | 25 +++++++++++++
 8 files changed, 65 insertions(+), 59 deletions(-)

diff --git a/paddle/cinn/operator_fusion/backend/pattern.h b/paddle/cinn/operator_fusion/backend/pattern.h
index 51cdd327eacaa9..50e22fc0bb2000 100644
--- a/paddle/cinn/operator_fusion/backend/pattern.h
+++ b/paddle/cinn/operator_fusion/backend/pattern.h
@@ -42,13 +42,13 @@ struct TrivialPattern<BackendStage> {
   explicit TrivialPattern(const std::vector<pir::Operation*>& ops,
                           pir::Operation* sink_op,
                           const TrivialOp& op)
-      : ops_(ops), sink_op(sink_op), trivial_op(op) {}
+      : ops_(ops), sink_op_(sink_op), trivial_op(op) {}
   std::vector<pir::Operation*> ops_;
-  pir::Operation* sink_op;
+  pir::Operation* sink_op_;
   TrivialOp trivial_op;
   static std::string name() { return "Trivial"; }
   std::vector<pir::Operation*> ops() const { return ops_; }
-  pir::Operation* sink() const { return sink_op; }
+  pir::Operation* sink_op() const { return sink_op_; }
 };
 
 template <>
diff --git a/paddle/cinn/operator_fusion/backend/pattern_fuser.cc b/paddle/cinn/operator_fusion/backend/pattern_fuser.cc
index b155619a693ae7..3f2f81c184158a 100644
--- a/paddle/cinn/operator_fusion/backend/pattern_fuser.cc
+++ b/paddle/cinn/operator_fusion/backend/pattern_fuser.cc
@@ -74,21 +74,7 @@ StmtPattern<BackendStage> MergePatternImpl(
   const auto& trivial_op =
       cinn::hlir::framework::pir::trivial_fusion_detail::TrivalxOther_Fusion(
           first.trivial_op, second.trivial_op);
-  return TrivialPattern<BackendStage>(ops, second.sink(), trivial_op);
-}
-
-template <>
-StmtPattern<BackendStage> MergePatternImpl(
-    const TrivialPattern<BackendStage>& first,
-    const ReduceTreePattern<BackendStage>& second) {
-  // TODO(@wuzhanfei)
-}
-
-template <>
-StmtPattern<BackendStage> MergePatternImpl(
-    const TrivialPattern<BackendStage>& first,
-    const ReduceTreePlusTrivialPattern<BackendStage>& second) {
-  // TODO(@wuzhanfei)
+  return TrivialPattern<BackendStage>(ops, second.sink_op(), trivial_op);
 }
 
 template <>
diff --git a/paddle/cinn/operator_fusion/backend/pattern_fuser.h b/paddle/cinn/operator_fusion/backend/pattern_fuser.h
index 56d9a1c4b84476..97ee70df9c149e 100644
--- a/paddle/cinn/operator_fusion/backend/pattern_fuser.h
+++ b/paddle/cinn/operator_fusion/backend/pattern_fuser.h
@@ -41,16 +41,6 @@ StmtPattern<BackendStage> MergePatternImpl(
     const TrivialPattern<BackendStage>& first,
     const TrivialPattern<BackendStage>& second);
 
-template <>
-StmtPattern<BackendStage> MergePatternImpl(
-    const TrivialPattern<BackendStage>& first,
-    const ReduceTreePattern<BackendStage>& second);
-
-template <>
-StmtPattern<BackendStage> MergePatternImpl(
-    const TrivialPattern<BackendStage>& first,
-    const ReduceTreePlusTrivialPattern<BackendStage>& second);
-
 template <>
 StmtPattern<BackendStage> MergePatternImpl(
     const TrivialPattern<BackendStage>& first,
diff --git a/paddle/cinn/operator_fusion/frontend/pattern.h b/paddle/cinn/operator_fusion/frontend/pattern.h
index 942286c77153c6..d7363383b8cc51 100644
--- a/paddle/cinn/operator_fusion/frontend/pattern.h
+++ b/paddle/cinn/operator_fusion/frontend/pattern.h
@@ -50,12 +50,12 @@ template <>
 struct TrivialPattern<FrontendStage> {
   explicit TrivialPattern(const std::vector<pir::Operation*>& ops,
                           pir::Operation* sink_op)
-      : ops_(ops), sink_op(sink_op) {}
+      : ops_(ops), sink_op_(sink_op) {}
   std::vector<pir::Operation*> ops_;
-  pir::Operation* sink_op;
+  pir::Operation* sink_op_;
   static std::string name() { return "Trivial"; }
   std::vector<pir::Operation*> ops() const { return ops_; }
-  pir::Operation* sink() const { return sink_op; }
+  pir::Operation* sink_op() const { return sink_op_; }
 };
 
 template <>
diff --git a/paddle/cinn/operator_fusion/frontend/pattern_fuser.cc b/paddle/cinn/operator_fusion/frontend/pattern_fuser.cc
index 986745530d509b..256a4ec432d8b3 100644
--- a/paddle/cinn/operator_fusion/frontend/pattern_fuser.cc
+++ b/paddle/cinn/operator_fusion/frontend/pattern_fuser.cc
@@ -58,21 +58,7 @@ StmtPattern<FrontendStage> MergePatternImpl(
   const auto& contents =
       UniqueConcatVector(GetOpsInPattern<FrontendStage>(first),
                          GetOpsInPattern<FrontendStage>(second));
-  return TrivialPattern<FrontendStage>(contents, second.sink());
-}
-
-template <>
-StmtPattern<FrontendStage> MergePatternImpl(
-    const TrivialPattern<FrontendStage>& first,
-    const ReduceTreePattern<FrontendStage>& second) {
-  // TODO(@wuzhanfei)
-}
-
-template <>
-StmtPattern<FrontendStage> MergePatternImpl(
-    const TrivialPattern<FrontendStage>& first,
-    const ReduceTreePlusTrivialPattern<FrontendStage>& second) {
-  // TODO(@wuzhanfei)
+  return TrivialPattern<FrontendStage>(contents, second.sink_op());
 }
 
 template <>
diff --git a/paddle/cinn/operator_fusion/frontend/pattern_fuser.h b/paddle/cinn/operator_fusion/frontend/pattern_fuser.h
index 88d09fd70324c0..5997d38e84cbea 100644
--- a/paddle/cinn/operator_fusion/frontend/pattern_fuser.h
+++ b/paddle/cinn/operator_fusion/frontend/pattern_fuser.h
@@ -41,16 +41,6 @@ StmtPattern<FrontendStage> MergePatternImpl(
     const TrivialPattern<FrontendStage>& first,
     const TrivialPattern<FrontendStage>& second);
 
-template <>
-StmtPattern<FrontendStage> MergePatternImpl(
-    const TrivialPattern<FrontendStage>& first,
-    const ReduceTreePattern<FrontendStage>& second);
-
-template <>
-StmtPattern<FrontendStage> MergePatternImpl(
-    const TrivialPattern<FrontendStage>& first,
-    const ReduceTreePlusTrivialPattern<FrontendStage>& second);
-
 template <>
 StmtPattern<FrontendStage> MergePatternImpl(
     const TrivialPattern<FrontendStage>& first,
diff --git a/paddle/cinn/operator_fusion/pattern_fuser.h b/paddle/cinn/operator_fusion/pattern_fuser.h
index 4f3524ca3e04c0..904dfa21206672 100644
--- a/paddle/cinn/operator_fusion/pattern_fuser.h
+++ b/paddle/cinn/operator_fusion/pattern_fuser.h
@@ -86,7 +86,7 @@ struct LoopFrameworkVisitor {
   }
 
   MaybeLoopFramework operator()(const TrivialPattern<T>& pattern) {
-    pir::Operation* t_op = pattern.sink();
+    pir::Operation* t_op = pattern.sink_op();
     const auto& exprs = GetDimExprsFromValue(t_op->result(0));
     return exprs;
   }
@@ -327,6 +327,17 @@ StmtPattern<T> MergePatternImpl(const HorizontalFusionPattern<T>& first,
   return HorizontalFusionPattern<T>({pad_first, pad_second});
 }
 
+template <typename A, typename B>
+B FusePatternIfConnected(A up_pattern,
+                         B down_pattern,
+                         std::vector<pir::Operation*> connect_ops) {
+  if (AnyTargetInCandidate(connect_ops, down_pattern.ops())) {
+    return std::get<B>(MergePatternImpl(up_pattern, down_pattern));
+  } else {
+    return down_pattern;
+  }
+}
+
 template <typename T>
 StmtPattern<T> MergePatternImpl(const ReduceTreePattern<T>& first,
                                 const TrivialPattern<T>& second);
@@ -341,11 +352,29 @@ StmtPattern<T> MergePatternImpl(const TrivialPattern<T>& first,
 
 template <typename T>
 StmtPattern<T> MergePatternImpl(const TrivialPattern<T>& first,
-                                const ReduceTreePattern<T>& second);
+                                const ReduceTreePattern<T>& second) {
+  auto connect_ops = FindDownstreamOps(first.sink_op());
+
+  auto old_childs = second.childs();
+  std::vector<ReduceTreePattern<T>> new_childs;
+  for (const auto& old_child : old_childs) {
+    new_childs.emplace_back(
+        FusePatternIfConnected(first, old_child, connect_ops));
+  }
+
+  return ReduceTreePattern<T>(
+      new_childs,
+      FusePatternIfConnected(first, second.GetRootPattern(), connect_ops));
+}
 
 template <typename T>
 StmtPattern<T> MergePatternImpl(const TrivialPattern<T>& first,
-                                const ReduceTreePlusTrivialPattern<T>& second);
+                                const ReduceTreePlusTrivialPattern<T>& second) {
+  auto connect_ops = FindDownstreamOps(first.sink_op());
+  return ReduceTreePlusTrivialPattern<T>(
+      FusePatternIfConnected(first, second.tree, connect_ops),
+      FusePatternIfConnected(first, second.sink_trivial, connect_ops));
+}
 
 template <typename T>
 StmtPattern<T> MergePatternImpl(const TrivialPattern<T>& first,
diff --git a/paddle/cinn/operator_fusion/utils.h b/paddle/cinn/operator_fusion/utils.h
index 089659d7148301..567753260beb9c 100644
--- a/paddle/cinn/operator_fusion/utils.h
+++ b/paddle/cinn/operator_fusion/utils.h
@@ -386,6 +386,30 @@ std::vector<U> VectorFlatMap(
   return result;
 }
 
+template <typename T>
+bool AnyTargetInCandidate(const std::vector<T>& targets,
+                          const std::vector<T>& candidate) {
+  std::unordered_set<T> pool = ToUnorderedSet(candidate);
+  for (const auto& item : targets) {
+    if (pool.find(item) != pool.end()) {
+      return true;
+    }
+  }
+  return false;
+}
+
+static std::vector<pir::Operation*> FindDownstreamOps(pir::Operation* op) {
+  std::vector<pir::Operation*> result;
+  for (int i = 0; i < op->num_results(); i++) {
+    auto v = op->result(i);
+    for (auto consumer_it = v.use_begin(); consumer_it != v.use_end();
+         ++consumer_it) {
+      result.emplace_back(consumer_it->owner());
+    }
+  }
+  return result;
+}
+
 static const size_t GetUsageIdx(const pir::Value& v, pir::Operation* op) {
   size_t i = 0;
   for (auto consumer_it = v.use_begin(); consumer_it != v.use_end();
@@ -418,4 +442,5 @@ static const size_t GetResultIdx(const pir::Value& v, pir::Operation* op) {
   PADDLE_THROW(phi::errors::NotFound(
       "Can not find the value %s as result of op %s", v.impl(), op->name()));
 }
+
 }  // namespace cinn::fusion

From 74ed2e8252cd6a58824e5f6a61e19abb5980c7d4 Mon Sep 17 00:00:00 2001
From: feifei-111 <2364819892@qq.com>
Date: Fri, 10 May 2024 03:02:46 +0000
Subject: [PATCH 53/99] update

---
 .../cinn/operator_fusion/backend/pattern_fuser.cc | 15 ++++++++++++---
 .../operator_fusion/frontend/pattern_fuser.cc     |  6 +++++-
 2 files changed, 17 insertions(+), 4 deletions(-)

diff --git a/paddle/cinn/operator_fusion/backend/pattern_fuser.cc b/paddle/cinn/operator_fusion/backend/pattern_fuser.cc
index 3f2f81c184158a..d6e4bfce64dfda 100644
--- a/paddle/cinn/operator_fusion/backend/pattern_fuser.cc
+++ b/paddle/cinn/operator_fusion/backend/pattern_fuser.cc
@@ -81,7 +81,17 @@ template <>
 StmtPattern<BackendStage> MergePatternImpl(
     const TrivialPattern<BackendStage>& first,
     const AnchorPattern<BackendStage>& second) {
-  // TODO(@wuzhanfei)
+  for (auto promise : second.anchor_state.promise) {
+    promise.root_fusion_op =
+        cinn::hlir::framework::pir::trivial_fusion_detail::TrivalxOther_Fusion(
+            first.trivial_op, promise.root_fusion_op);
+  }
+
+  return AnchorPattern<BackendStage>(
+      UniqueConcatVector(GetOpsInPattern<BackendStage>(first),
+                         GetOpsInPattern<BackendStage>(second)),
+      second.anchor(),
+      second.anchor_state);
 }
 
 template <>
@@ -126,8 +136,7 @@ std::vector<FusionOp> ReduceTreeTrivialTransformRecursive(
   VLOG(4) << "ReduceTrivialTransformRecursive: "
           << *_GetFuncBodyPointer(root_op);
   std::vector<FusionOp> result;
-  // for (const auto& child_tree : ) {
-  //
+
   const auto& child_tree = rt_pattern.tree;
   const auto& child_reduce_op = child_tree.GetRootPattern().reduce_op;
   auto transformed_nodes = cinn::hlir::framework::pir::trivial_fusion_detail::
diff --git a/paddle/cinn/operator_fusion/frontend/pattern_fuser.cc b/paddle/cinn/operator_fusion/frontend/pattern_fuser.cc
index 256a4ec432d8b3..543d96fd7e80e3 100644
--- a/paddle/cinn/operator_fusion/frontend/pattern_fuser.cc
+++ b/paddle/cinn/operator_fusion/frontend/pattern_fuser.cc
@@ -65,7 +65,11 @@ template <>
 StmtPattern<FrontendStage> MergePatternImpl(
     const TrivialPattern<FrontendStage>& first,
     const AnchorPattern<FrontendStage>& second) {
-  // TODO(@wuzhanfei)
+  return AnchorPattern<FrontendStage>(
+      UniqueConcatVector(GetOpsInPattern<FrontendStage>(first),
+                         GetOpsInPattern<FrontendStage>(second)),
+      second.anchor(),
+      second.anchor_state);
 }
 
 template <>

From 0937f0d36a5bfe8a084beae07392d56c8a66398a Mon Sep 17 00:00:00 2001
From: feifei-111 <2364819892@qq.com>
Date: Fri, 10 May 2024 03:26:28 +0000
Subject: [PATCH 54/99] fix compile

---
 paddle/cinn/operator_fusion/backend/pattern_fuser.cc | 9 ++++++---
 1 file changed, 6 insertions(+), 3 deletions(-)

diff --git a/paddle/cinn/operator_fusion/backend/pattern_fuser.cc b/paddle/cinn/operator_fusion/backend/pattern_fuser.cc
index d6e4bfce64dfda..99526888853dc0 100644
--- a/paddle/cinn/operator_fusion/backend/pattern_fuser.cc
+++ b/paddle/cinn/operator_fusion/backend/pattern_fuser.cc
@@ -82,9 +82,12 @@ StmtPattern<BackendStage> MergePatternImpl(
     const TrivialPattern<BackendStage>& first,
     const AnchorPattern<BackendStage>& second) {
   for (auto promise : second.anchor_state.promise) {
-    promise.root_fusion_op =
-        cinn::hlir::framework::pir::trivial_fusion_detail::TrivalxOther_Fusion(
-            first.trivial_op, promise.root_fusion_op);
+    promise.root_fusion_op = std::visit(
+        [first](const auto& arg) -> FusionOp {
+          return cinn::hlir::framework::pir::trivial_fusion_detail::
+              TrivalxOther_Fusion(first.trivial_op, arg);
+        },
+        promise.root_fusion_op);
   }
 
   return AnchorPattern<BackendStage>(

From 2102d7200950d6fd858d05aa87e870f360403c72 Mon Sep 17 00:00:00 2001
From: feifei-111 <2364819892@qq.com>
Date: Fri, 10 May 2024 03:31:02 +0000
Subject: [PATCH 55/99] update

---
 paddle/cinn/operator_fusion/graph_transformer/operation.h | 7 -------
 1 file changed, 7 deletions(-)

diff --git a/paddle/cinn/operator_fusion/graph_transformer/operation.h b/paddle/cinn/operator_fusion/graph_transformer/operation.h
index c40fa2445d0a4f..1711bb978996d3 100644
--- a/paddle/cinn/operator_fusion/graph_transformer/operation.h
+++ b/paddle/cinn/operator_fusion/graph_transformer/operation.h
@@ -240,13 +240,6 @@ struct SplitRecomputeOperation {
   template <typename Phrase>
   void operator()(PatternGraph<Phrase>* graph,
                   PatternNodePtr<Phrase> upstream) {
-    PADDLE_ENFORCE_GT(upstream->downstream().size(),
-                      1,
-                      phi::errors::PreconditionNotMet(
-                          "The downstream of node for recomputation should be "
-                          "more than 1, but got %d.",
-                          upstream->downstream().size()));
-
     std::vector<PatternNodePtr<Phrase>> fusion_candidate =
         upstream->downstream();
     upstream->ClearDownstream();

From 49963ef8dd1e008e4e5dc16df065bffc300e04a7 Mon Sep 17 00:00:00 2001
From: feifei-111 <2364819892@qq.com>
Date: Fri, 10 May 2024 03:34:13 +0000
Subject: [PATCH 56/99] fix recompute matcher er

---
 paddle/cinn/operator_fusion/graph_transformer/matcher.h   | 1 +
 paddle/cinn/operator_fusion/graph_transformer/operation.h | 7 +++++++
 2 files changed, 8 insertions(+)

diff --git a/paddle/cinn/operator_fusion/graph_transformer/matcher.h b/paddle/cinn/operator_fusion/graph_transformer/matcher.h
index 4f4fab3e2d0d24..1e4c59967606dd 100644
--- a/paddle/cinn/operator_fusion/graph_transformer/matcher.h
+++ b/paddle/cinn/operator_fusion/graph_transformer/matcher.h
@@ -107,6 +107,7 @@ struct RecomputeNodeMatcher {
   template <typename T>
   bool operator()(const PatternGraph<T>& graph, const PatternNodePtr<T>& node) {
     return StmtPatternGraphMatcher<AnchorPattern<T>>()(graph, node) &&
+           node->downstream().size() >= 1 &&
            (std::get<AnchorPattern<T>>(node->stmt_pattern()).can_recompute());
   }
 };
diff --git a/paddle/cinn/operator_fusion/graph_transformer/operation.h b/paddle/cinn/operator_fusion/graph_transformer/operation.h
index 1711bb978996d3..c91a73a18cb86d 100644
--- a/paddle/cinn/operator_fusion/graph_transformer/operation.h
+++ b/paddle/cinn/operator_fusion/graph_transformer/operation.h
@@ -240,6 +240,13 @@ struct SplitRecomputeOperation {
   template <typename Phrase>
   void operator()(PatternGraph<Phrase>* graph,
                   PatternNodePtr<Phrase> upstream) {
+    PADDLE_ENFORCE_GE(upstream->downstream().size(),
+                      1,
+                      phi::errors::PreconditionNotMet(
+                          "The downstream of node for recomputation should be "
+                          ">= 1, but got %d.",
+                          upstream->downstream().size()));
+
     std::vector<PatternNodePtr<Phrase>> fusion_candidate =
         upstream->downstream();
     upstream->ClearDownstream();

From 79eec1c8b936a2c63938616bcd880144818a399d Mon Sep 17 00:00:00 2001
From: feifei-111 <2364819892@qq.com>
Date: Fri, 10 May 2024 05:06:01 +0000
Subject: [PATCH 57/99] update

---
 paddle/cinn/hlir/framework/pir/trivial_op_util.cc    |  4 ++--
 paddle/cinn/operator_fusion/backend/pattern_fuser.cc | 12 +++++++-----
 2 files changed, 9 insertions(+), 7 deletions(-)

diff --git a/paddle/cinn/hlir/framework/pir/trivial_op_util.cc b/paddle/cinn/hlir/framework/pir/trivial_op_util.cc
index 0b0578bad4aa33..72100a6a85ac25 100644
--- a/paddle/cinn/hlir/framework/pir/trivial_op_util.cc
+++ b/paddle/cinn/hlir/framework/pir/trivial_op_util.cc
@@ -163,12 +163,12 @@ void SubstitudeTargetExprWithDestExpr(const ir::Expr& source,
                                       const ir::Expr& dest,
                                       ir::Expr* body) {
   VLOG(4) << "SubstitideExpr Start";
-  VLOG(4) << "Substitide Body : " << *body;
+  VLOG(5) << "Substitide Body : " << *body;
   VLOG(4) << "Substitide From : " << source;
   VLOG(4) << "Substitide To   : " << dest;
   MappingTargetExprToDestExprMutator mapper(source, dest);
   mapper(body);
-  VLOG(4) << "SubstitideExpr Result: " << *body;
+  VLOG(5) << "SubstitideExpr Result: " << *body;
 }
 
 ir::Expr SubstitudeIndexVector(const Expr& source,
diff --git a/paddle/cinn/operator_fusion/backend/pattern_fuser.cc b/paddle/cinn/operator_fusion/backend/pattern_fuser.cc
index 99526888853dc0..29d8c11b476f8a 100644
--- a/paddle/cinn/operator_fusion/backend/pattern_fuser.cc
+++ b/paddle/cinn/operator_fusion/backend/pattern_fuser.cc
@@ -81,20 +81,22 @@ template <>
 StmtPattern<BackendStage> MergePatternImpl(
     const TrivialPattern<BackendStage>& first,
     const AnchorPattern<BackendStage>& second) {
-  for (auto promise : second.anchor_state.promise) {
-    promise.root_fusion_op = std::visit(
+  AnchorState<BackendStage> new_anchor_state = second.anchor_state;
+
+  for (int i = 0; i < new_anchor_state.promise.size(); i++) {
+    new_anchor_state.promise[i].root_fusion_op = std::visit(
         [first](const auto& arg) -> FusionOp {
           return cinn::hlir::framework::pir::trivial_fusion_detail::
               TrivalxOther_Fusion(first.trivial_op, arg);
         },
-        promise.root_fusion_op);
+        new_anchor_state.promise[i].root_fusion_op);
   }
 
   return AnchorPattern<BackendStage>(
       UniqueConcatVector(GetOpsInPattern<BackendStage>(first),
                          GetOpsInPattern<BackendStage>(second)),
       second.anchor(),
-      second.anchor_state);
+      new_anchor_state);
 }
 
 template <>
@@ -387,7 +389,7 @@ std::vector<ir::Expr> TopoSort(const std::vector<ir::Expr>& op_exprs) {
   for (const auto& op : op_exprs) {
     auto inputs = GetInputTensors(op);
     auto outputs = GetOutputTensors(op);
-    if (VLOG_IS_ON(4)) {
+    if (VLOG_IS_ON(5)) {
       VLOG(4) << "Ir::Expr is: \n" << op;
       VLOG(4) << "Inputs: ";
       for (const auto& input : inputs) {

From 108fad74478123d5111dc9d5b4ac286d574473a1 Mon Sep 17 00:00:00 2001
From: feifei-111 <2364819892@qq.com>
Date: Fri, 10 May 2024 07:30:35 +0000
Subject: [PATCH 58/99] update

---
 .../operator_fusion/pir_graph_analyzing/anchor_transform.cc   | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/paddle/cinn/operator_fusion/pir_graph_analyzing/anchor_transform.cc b/paddle/cinn/operator_fusion/pir_graph_analyzing/anchor_transform.cc
index 436f5f0346c8f2..4ab397ed8cdb8c 100644
--- a/paddle/cinn/operator_fusion/pir_graph_analyzing/anchor_transform.cc
+++ b/paddle/cinn/operator_fusion/pir_graph_analyzing/anchor_transform.cc
@@ -86,6 +86,10 @@ std::optional<AnchorTransform> CreateAnchorTransformForSpecialOps(
   if (info.op->name() == "pd_op.reshape") {
     return CreateDefaultAnchorTransform(info);
   }
+  // these op has no OpPatternKind
+  if (info.op->name() == "pd_op.if" || info.op->name() == "pd_op.embedding") {
+    return CreateDefaultAnchorTransform(info);
+  }
   return std::nullopt;
 }
 

From afdb4e0b464c1ddb1b4e4297fd07fc20e8bc8e8b Mon Sep 17 00:00:00 2001
From: feifei-111 <2364819892@qq.com>
Date: Fri, 10 May 2024 08:48:19 +0000
Subject: [PATCH 59/99] reduce logs

---
 paddle/cinn/operator_fusion/group_cluster.h               | 2 +-
 .../operator_fusion/pir_graph_analyzing/dim_relation.cc   | 4 ++--
 .../pir_graph_analyzing/shardable_axes_base.cc            | 8 ++++----
 paddle/cinn/operator_fusion/utils.h                       | 2 --
 4 files changed, 7 insertions(+), 9 deletions(-)

diff --git a/paddle/cinn/operator_fusion/group_cluster.h b/paddle/cinn/operator_fusion/group_cluster.h
index 436ed664903f51..6882fa241b19cb 100644
--- a/paddle/cinn/operator_fusion/group_cluster.h
+++ b/paddle/cinn/operator_fusion/group_cluster.h
@@ -83,7 +83,7 @@ inline std::vector<fusion::PatternNodePtr<T>> ClusterOps(
   for (const auto& node : result) {
     VLOG(4) << "\n"
             << node->DebugStr() << "\n"
-            << fusion::StmtPatternDebugStr(node->stmt_pattern());
+            << fusion::StmtPatternDebugStr(node->stmt_pattern()) << "\n";
   }
 
   return result;
diff --git a/paddle/cinn/operator_fusion/pir_graph_analyzing/dim_relation.cc b/paddle/cinn/operator_fusion/pir_graph_analyzing/dim_relation.cc
index a72e5e0a33c344..60ebca4dcf2b72 100644
--- a/paddle/cinn/operator_fusion/pir_graph_analyzing/dim_relation.cc
+++ b/paddle/cinn/operator_fusion/pir_graph_analyzing/dim_relation.cc
@@ -151,7 +151,7 @@ static std::optional<DimUsageRelation> CreateOpRelativenessForSpecialOps(
 static DimUsageRelation GetSingleOpRelation(pir::Operation* op) {
   const auto& special_result = CreateOpRelativenessForSpecialOps(op);
   if (special_result != std::nullopt) {
-    VLOG(4) << "[DimUsageRelation] GetSingleOpRelation for special op: \n"
+    VLOG(5) << "[DimUsageRelation] GetSingleOpRelation for special op: \n"
             << op->name() << " : " << RelationDebugStr(special_result.value());
     return special_result.value();
   }
@@ -167,7 +167,7 @@ static DimUsageRelation GetSingleOpRelation(pir::Operation* op) {
   } else {
     result = CreateOpRelativenessForDefault(op);
   }
-  VLOG(4) << "[DimUsageRelation] GetSingleOpRelation: \n"
+  VLOG(5) << "[DimUsageRelation] GetSingleOpRelation: \n"
           << op->name() << " : " << RelationDebugStr(result);
   return result;
 }
diff --git a/paddle/cinn/operator_fusion/pir_graph_analyzing/shardable_axes_base.cc b/paddle/cinn/operator_fusion/pir_graph_analyzing/shardable_axes_base.cc
index 4947b486630b73..acc508617fcdd0 100644
--- a/paddle/cinn/operator_fusion/pir_graph_analyzing/shardable_axes_base.cc
+++ b/paddle/cinn/operator_fusion/pir_graph_analyzing/shardable_axes_base.cc
@@ -264,7 +264,7 @@ ShardableAxesInfoManager::ShardableAxesInfoManager(
 
   const auto CombineAxes = [&](const ShardableAxes& root,
                                const ShardableAxes& non_root) {
-    VLOG(4) << "start CombineAxes: " << root.DebugStr() << " with "
+    VLOG(5) << "start CombineAxes: " << root.DebugStr() << " with "
             << non_root.DebugStr();
     PADDLE_ENFORCE_EQ(
         root.axis_names.size(),
@@ -280,7 +280,7 @@ ShardableAxesInfoManager::ShardableAxesInfoManager(
     for (int i = 0; i < op->num_operands(); ++i) {
       auto value = op->operand_source(i);
       auto axes = axes_signature.inputs[i];
-      VLOG(4) << op->name() << " " << i << "-th input " << value.impl()
+      VLOG(5) << op->name() << " " << i << "-th input " << value.impl()
               << " axes: " << axes.DebugStr();
       if (value_axes_map_.find(value) == value_axes_map_.end()) {
         value_axes_map_[value] = axes;
@@ -294,7 +294,7 @@ ShardableAxesInfoManager::ShardableAxesInfoManager(
     for (int i = 0; i < op->num_results(); ++i) {
       auto value = op->result(i);
       auto axes = axes_signature.outputs[i];
-      VLOG(4) << op->name() << " " << i << "-th output " << value.impl()
+      VLOG(5) << op->name() << " " << i << "-th output " << value.impl()
               << " axes: " << axes.DebugStr();
       if (value_axes_map_.find(value) == value_axes_map_.end()) {
         value_axes_map_[value] = axes;
@@ -307,7 +307,7 @@ ShardableAxesInfoManager::ShardableAxesInfoManager(
     }
   }
 
-  VLOG(4) << NameUnionDebugStr();
+  VLOG(5) << NameUnionDebugStr();
 }
 
 std::string ShardableAxes::DebugStr() const {
diff --git a/paddle/cinn/operator_fusion/utils.h b/paddle/cinn/operator_fusion/utils.h
index 567753260beb9c..d85eb9693afb75 100644
--- a/paddle/cinn/operator_fusion/utils.h
+++ b/paddle/cinn/operator_fusion/utils.h
@@ -317,11 +317,9 @@ struct ValueDimHash {
 
 static std::vector<symbol::DimExpr> GetDimExprsFromValue(pir::Value value) {
   const auto& value_dims = GetAllValueDimFromValue(value);
-  VLOG(4) << "Start Print:";
   std::function<symbol::DimExpr(ValueDim)> func =
       [](const ValueDim& value_dim) {
         const auto& symbolic_dim = value_dim.GetSymbolicDim();
-        VLOG(4) << symbolic_dim;
         return symbolic_dim;
       };
   return MapVector(value_dims, func);

From 5cead78524748770be918a39bcc4af848b71da98 Mon Sep 17 00:00:00 2001
From: feifei-111 <2364819892@qq.com>
Date: Fri, 10 May 2024 10:55:38 +0000
Subject: [PATCH 60/99] fix SearchAnchorTransformRecursively

---
 .../pir_graph_analyzing/anchor_transform.cc   | 20 ++++++++++++++-----
 .../pir_graph_analyzing/anchor_transform.h    |  7 ++++---
 .../policy/anchor_search_policy.cc            |  8 +++++---
 3 files changed, 24 insertions(+), 11 deletions(-)

diff --git a/paddle/cinn/operator_fusion/pir_graph_analyzing/anchor_transform.cc b/paddle/cinn/operator_fusion/pir_graph_analyzing/anchor_transform.cc
index 4ab397ed8cdb8c..e30cf085cc35fd 100644
--- a/paddle/cinn/operator_fusion/pir_graph_analyzing/anchor_transform.cc
+++ b/paddle/cinn/operator_fusion/pir_graph_analyzing/anchor_transform.cc
@@ -119,10 +119,12 @@ std::vector<AnchorTransform> PossibleTransform(pir::Value v) {
 
   // Transform to Upstream
   auto defining_op = v.defining_op();
-  size_t output_idx = GetResultIdx(v, defining_op);
-  for (size_t i = 0; i < defining_op->num_operands(); ++i) {
-    result.emplace_back(
-        CreateAnchorTransform(TransformInfo(defining_op, i, output_idx, true)));
+  if (defining_op != nullptr) {
+    size_t output_idx = GetResultIdx(v, defining_op);
+    for (size_t i = 0; i < defining_op->num_operands(); ++i) {
+      result.emplace_back(CreateAnchorTransform(
+          TransformInfo(defining_op, i, output_idx, true)));
+    }
   }
 
   // Transform to Downstream
@@ -148,8 +150,16 @@ TransformInfo GetTransformInfo(AnchorTransform trans) {
   return std::visit([](auto&& arg) { return arg->info; }, trans);
 }
 
-std::string DebugStrOfAnchorTransform(AnchorTransform trans) {
+std::string DebugStrOfAnchorTransform(const AnchorTransform& trans) {
   return std::visit([](auto&& arg) { return arg->DebugStr(); }, trans);
 }
 
+std::string DebugStrOfAnchorTransformRoute(const AnchorTransformRoute& route) {
+  std::stringstream ss;
+  for (const auto& trans : route) {
+    ss << DebugStrOfAnchorTransform(trans) << "\n";
+  }
+  return ss.str();
+}
+
 }  // namespace cinn::fusion
diff --git a/paddle/cinn/operator_fusion/pir_graph_analyzing/anchor_transform.h b/paddle/cinn/operator_fusion/pir_graph_analyzing/anchor_transform.h
index cb4600ef4340cf..4c4616999a6a86 100644
--- a/paddle/cinn/operator_fusion/pir_graph_analyzing/anchor_transform.h
+++ b/paddle/cinn/operator_fusion/pir_graph_analyzing/anchor_transform.h
@@ -46,8 +46,8 @@ struct TransformInfo {
 
   std::string DebugStr() const {
     std::stringstream ss;
-    ss << "op: " << op->name() << ", input_idx: " << input_idx
-       << ", output_idx: " << output_idx
+    ss << "op: " << op->name() << "[id:" << op->id()
+       << "], input_idx: " << input_idx << ", output_idx: " << output_idx
        << ", is_upstream_anchor: " << is_upstream_anchor;
     return ss.str();
   }
@@ -133,5 +133,6 @@ struct AnchorState {
 AnchorTransform CreateAnchorTransform(const TransformInfo& info);
 std::vector<AnchorTransform> PossibleTransform(pir::Value v);
 TransformInfo GetTransformInfo(AnchorTransform trans);
-std::string DebugStrOfAnchorTransform(AnchorTransform trans);
+std::string DebugStrOfAnchorTransform(const AnchorTransform& trans);
+std::string DebugStrOfAnchorTransformRoute(const AnchorTransformRoute& route);
 }  // namespace cinn::fusion
diff --git a/paddle/cinn/operator_fusion/policy/anchor_search_policy.cc b/paddle/cinn/operator_fusion/policy/anchor_search_policy.cc
index 7e5370f8b3dddf..a7ee7a1ae5de95 100644
--- a/paddle/cinn/operator_fusion/policy/anchor_search_policy.cc
+++ b/paddle/cinn/operator_fusion/policy/anchor_search_policy.cc
@@ -30,11 +30,12 @@ std::optional<AnchorTransformRoute> SearchAnchorTransformRecursively(
     AnchorTransformRoute* cur_route,
     std::unordered_set<pir::Value>* visited,
     const std::unordered_set<pir::Operation*>& ops) {
+  VLOG(4) << "[SearchAnchorTransformRecursively] Curent Route:\n"
+          << DebugStrOfAnchorTransformRoute(*cur_route);
   auto transforms = PossibleTransform(begin);
   for (auto anchor_transform : transforms) {
     auto info = GetTransformInfo(anchor_transform);
     auto dst_value = info.DstValue();
-    cur_route->emplace_back(anchor_transform);
 
     if (std::holds_alternative<UnsupportTransformPtr>(anchor_transform) ||
         ops.find(info.op) == ops.end() ||
@@ -46,13 +47,14 @@ std::optional<AnchorTransformRoute> SearchAnchorTransformRecursively(
       return *cur_route;
     }
 
+    cur_route->emplace_back(anchor_transform);
     auto recursive_result = SearchAnchorTransformRecursively(
         dst_value, end, cur_route, visited, ops);
+    cur_route->pop_back();
+
     if (recursive_result != std::nullopt) {
       return recursive_result;
     }
-
-    cur_route->pop_back();
   }
 
   return std::nullopt;

From 86e2920ac242230e69387cfbf3e00a6d090ee5b4 Mon Sep 17 00:00:00 2001
From: feifei-111 <2364819892@qq.com>
Date: Sat, 11 May 2024 02:31:43 +0000
Subject: [PATCH 61/99] update

---
 paddle/cinn/operator_fusion/backend/pattern.h            | 8 ++++++++
 paddle/cinn/operator_fusion/frontend/pattern.h           | 7 +++++++
 .../pir_graph_analyzing/anchor_transform.h               | 9 +++++++++
 3 files changed, 24 insertions(+)

diff --git a/paddle/cinn/operator_fusion/backend/pattern.h b/paddle/cinn/operator_fusion/backend/pattern.h
index 50e22fc0bb2000..6c76a6aa57dde4 100644
--- a/paddle/cinn/operator_fusion/backend/pattern.h
+++ b/paddle/cinn/operator_fusion/backend/pattern.h
@@ -83,6 +83,14 @@ struct ExprPromise<BackendStage> {
   void update(const AnchorTransformRoute& route) {
     transform_route.insert(transform_route.end(), route.begin(), route.end());
   }
+
+  std::string DebugStr() const {
+    std::stringstream ss;
+    ss << "[ExprPromise] root_value: " << root_value.impl() << "\n";
+    ss << "[ExprPromise] root_expr: " << GetComputeBody(root_fusion_op) << "\n";
+    ss << DebugStrOfAnchorTransformRoute(transform_route) << "\n";
+    return ss.str();
+  }
 };
 
 }  // namespace cinn::fusion
diff --git a/paddle/cinn/operator_fusion/frontend/pattern.h b/paddle/cinn/operator_fusion/frontend/pattern.h
index d7363383b8cc51..a8dccf1128bebd 100644
--- a/paddle/cinn/operator_fusion/frontend/pattern.h
+++ b/paddle/cinn/operator_fusion/frontend/pattern.h
@@ -85,5 +85,12 @@ struct ExprPromise<FrontendStage> {
   void update(const AnchorTransformRoute& route) {
     transform_route.insert(transform_route.end(), route.begin(), route.end());
   }
+
+  std::string DebugStr() const {
+    std::stringstream ss;
+    ss << "[ExprPromise] root_value: " << root_value.impl() << "\n";
+    ss << DebugStrOfAnchorTransformRoute(transform_route) << "\n";
+    return ss.str();
+  }
 };
 }  // namespace cinn::fusion
diff --git a/paddle/cinn/operator_fusion/pir_graph_analyzing/anchor_transform.h b/paddle/cinn/operator_fusion/pir_graph_analyzing/anchor_transform.h
index 4c4616999a6a86..1160abdce4c252 100644
--- a/paddle/cinn/operator_fusion/pir_graph_analyzing/anchor_transform.h
+++ b/paddle/cinn/operator_fusion/pir_graph_analyzing/anchor_transform.h
@@ -128,6 +128,15 @@ struct AnchorState {
     auto new_exprs = new_state.promise;
     promise.insert(promise.end(), new_exprs.begin(), new_exprs.end());
   }
+
+  std::string DebugStr() const {
+    std::stringstream ss;
+    ss << "[AnchorState]\n";
+    for (const auto& expr_promise : promise) {
+      ss << expr_promise.DebugStr() << "\n";
+    }
+    return ss.str();
+  }
 };
 
 AnchorTransform CreateAnchorTransform(const TransformInfo& info);

From 46778a002f0f2b05aac21a6f6545596eceecedb9 Mon Sep 17 00:00:00 2001
From: feifei-111 <2364819892@qq.com>
Date: Sat, 11 May 2024 02:57:55 +0000
Subject: [PATCH 62/99] recover add_store_in_fusion_op

---
 .../operator/transforms/add_cinn_pass.cc      |  2 +
 .../transforms/add_store_in_fusion_op_pass.cc | 97 +++++++++++++++++++
 .../transforms/add_store_in_fusion_op_pass.h  | 28 ++++++
 test/cpp/pir/cinn/pir_all_path_test.cc        |  2 +
 4 files changed, 129 insertions(+)
 create mode 100644 paddle/cinn/hlir/dialect/operator/transforms/add_store_in_fusion_op_pass.cc
 create mode 100644 paddle/cinn/hlir/dialect/operator/transforms/add_store_in_fusion_op_pass.h

diff --git a/paddle/cinn/hlir/dialect/operator/transforms/add_cinn_pass.cc b/paddle/cinn/hlir/dialect/operator/transforms/add_cinn_pass.cc
index e39a8f865fca4f..c8d555df54faa8 100644
--- a/paddle/cinn/hlir/dialect/operator/transforms/add_cinn_pass.cc
+++ b/paddle/cinn/hlir/dialect/operator/transforms/add_cinn_pass.cc
@@ -28,6 +28,7 @@
 #include "paddle/cinn/hlir/dialect/operator/ir/op_dialect.h"
 #include "paddle/cinn/hlir/dialect/operator/transforms/accuracy_check_pass.h"
 #include "paddle/cinn/hlir/dialect/operator/transforms/add_broadcast_to_elementwise_pass.h"
+#include "paddle/cinn/hlir/dialect/operator/transforms/add_store_in_fusion_op_pass.h"
 #include "paddle/cinn/hlir/dialect/operator/transforms/add_store_in_group_op_pass.h"
 #include "paddle/cinn/hlir/dialect/operator/transforms/cinn_group_cluster_pass.h"
 #include "paddle/cinn/hlir/dialect/operator/transforms/dynamic_reshape_pass.h"
@@ -157,6 +158,7 @@ void ApplyDivideGroupOpToFusionOpPass(
   if (FLAGS_group_schedule_tiling_first) {
     pass_manager->AddPass(cinn::dialect::ir::CreateAddStoreInGroupOpPass());
     pass_manager->AddPass(cinn::dialect::ir::CreateCinnGroupClusterPass());
+    pass_manager->AddPass(cinn::dialect::ir::CreateAddStoreInFusionOpPass());
   } else {
     pass_manager->AddPass(
         cinn::dialect::ir::CreateDivideGroupOpToFusionOpPass());
diff --git a/paddle/cinn/hlir/dialect/operator/transforms/add_store_in_fusion_op_pass.cc b/paddle/cinn/hlir/dialect/operator/transforms/add_store_in_fusion_op_pass.cc
new file mode 100644
index 00000000000000..8fda84de661286
--- /dev/null
+++ b/paddle/cinn/hlir/dialect/operator/transforms/add_store_in_fusion_op_pass.cc
@@ -0,0 +1,97 @@
+// Copyright (c) 2024 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.
+
+#include "paddle/cinn/hlir/dialect/operator/transforms/add_store_in_fusion_op_pass.h"
+
+#include "paddle/cinn/hlir/dialect/operator/ir/cinn_op.h"
+#include "paddle/cinn/hlir/dialect/operator/ir/manual_op.h"
+#include "paddle/fluid/pir/dialect/operator/ir/pd_op.h"
+#include "paddle/pir/include/core/builtin_type_interfaces.h"
+#include "paddle/pir/include/dialect/control_flow/ir/cf_op.h"
+#include "paddle/pir/include/pattern_rewrite/pattern_rewrite_driver.h"
+
+namespace cinn {
+namespace dialect {
+namespace ir {
+
+class AddYieldStoreInFusionOpPattern
+    : public pir::OpRewritePattern<::pir::YieldOp> {
+ public:
+  using pir::OpRewritePattern<::pir::YieldOp>::OpRewritePattern;
+
+  bool MatchAndRewrite(::pir::YieldOp op,
+                       pir::PatternRewriter& rewriter) const override {
+    auto& shape_analysis =
+        pir::ShapeAnalysisManager::Instance().Get(op->GetParentProgram());
+    for (auto i = 0; i < op->num_operands(); ++i) {
+      rewriter.SetInsertionPointAfter(op->operand_source(i).defining_op());
+      auto store_op = rewriter.Build<cinn::dialect::YieldStoreOp>(
+          op->operand_source(i), op->operand_source(i).type());
+      auto orignal_base = op->operand_source(i);
+      op->operand(i).set_source(store_op.result(0));
+
+      shape_analysis.SetShapeOrDataForValue(
+          store_op.result(0),
+          shape_analysis.GetShapeOrDataForValue(orignal_base));
+    }
+
+    return true;
+  }
+};
+
+class AddStoreInFusionOpPass : public pir::Pass {
+ public:
+  AddStoreInFusionOpPass()
+      : pir::Pass("add_store_in_fusion_op", /*opt_level=*/1) {}
+
+  bool Initialize(pir::IrContext* context) override {
+    pir::RewritePatternSet ps(context);
+    ps.Add<AddYieldStoreInFusionOpPattern>(context);
+
+    patterns_ = pir::FrozenRewritePatternSet(std::move(ps));
+    return true;
+  }
+
+  void Run(pir::Operation* op) override {
+    pir::GreedyRewriteConfig cfg;
+    cfg.use_top_down_traversal = true;
+    cfg.max_iterations = 1;
+    for (uint32_t i = 0; i < op->num_regions(); ++i) {
+      for (auto& block : op->region(i)) {
+        for (auto& op : block) {
+          if (op.isa<cinn::dialect::FusionOp>()) {
+            auto [_, num_rewrites] =
+                pir::ApplyPatternsGreedily(&op, patterns_, cfg);
+            AddStatistics(num_rewrites);
+          }
+        }
+      }
+    }
+  }
+
+  bool CanApplyOn(pir::Operation* op) const override {
+    return op->num_regions() > 0;
+  }
+
+ private:
+  pir::FrozenRewritePatternSet patterns_;
+};
+
+std::unique_ptr<pir::Pass> CreateAddStoreInFusionOpPass() {
+  return std::make_unique<AddStoreInFusionOpPass>();
+}
+
+}  // namespace ir
+}  // namespace dialect
+}  // namespace cinn
diff --git a/paddle/cinn/hlir/dialect/operator/transforms/add_store_in_fusion_op_pass.h b/paddle/cinn/hlir/dialect/operator/transforms/add_store_in_fusion_op_pass.h
new file mode 100644
index 00000000000000..403e9a13ce38b8
--- /dev/null
+++ b/paddle/cinn/hlir/dialect/operator/transforms/add_store_in_fusion_op_pass.h
@@ -0,0 +1,28 @@
+// Copyright (c) 2024 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 <memory>
+#include "paddle/pir/include/pass/pass.h"
+
+namespace cinn {
+namespace dialect {
+namespace ir {
+
+std::unique_ptr<pir::Pass> CreateAddStoreInFusionOpPass();
+
+}  // namespace ir
+}  // namespace dialect
+}  // namespace cinn
diff --git a/test/cpp/pir/cinn/pir_all_path_test.cc b/test/cpp/pir/cinn/pir_all_path_test.cc
index 5b789d039d3b0a..32e57b53867aa8 100644
--- a/test/cpp/pir/cinn/pir_all_path_test.cc
+++ b/test/cpp/pir/cinn/pir_all_path_test.cc
@@ -20,6 +20,7 @@
 #include "paddle/cinn/hlir/dialect/operator/ir/manual_op.h"
 #include "paddle/cinn/hlir/dialect/operator/ir/op_dialect.h"
 #include "paddle/cinn/hlir/dialect/operator/transforms/add_broadcast_to_elementwise_pass.h"
+#include "paddle/cinn/hlir/dialect/operator/transforms/add_store_in_fusion_op_pass.h"
 #include "paddle/cinn/hlir/dialect/operator/transforms/add_store_in_group_op_pass.h"
 #include "paddle/cinn/hlir/dialect/operator/transforms/cinn_group_cluster_pass.h"
 #include "paddle/cinn/hlir/dialect/operator/transforms/group_merge/divide_group_op_to_fusion_op_pass.h"
@@ -76,6 +77,7 @@ static void RunAndCheckResult(::pir::Program* program,
   pir::PassManager stage_2_pm(ctx);
   stage_2_pm.AddPass(cinn::dialect::ir::CreateAddStoreInGroupOpPass());
   stage_2_pm.AddPass(cinn::dialect::ir::CreateCinnGroupClusterPass());
+  stage_2_pm.AddPass(cinn::dialect::ir::CreateAddStoreInFusionOpPass());
   stage_2_pm.AddPass(pir::CreateDeadCodeEliminationPass());
   stage_2_pm.AddPass(cinn::dialect::ir::CreateLowerCinnFusionOpPass());
   stage_2_pm.EnableIRPrinting();

From cd05e81db73306451690408364ba52e055f20406 Mon Sep 17 00:00:00 2001
From: feifei-111 <2364819892@qq.com>
Date: Sat, 11 May 2024 03:28:24 +0000
Subject: [PATCH 63/99] update

---
 paddle/cinn/hlir/dialect/operator/transforms/add_cinn_pass.cc | 1 -
 test/cpp/pir/cinn/pir_all_path_test.cc                        | 1 -
 2 files changed, 2 deletions(-)

diff --git a/paddle/cinn/hlir/dialect/operator/transforms/add_cinn_pass.cc b/paddle/cinn/hlir/dialect/operator/transforms/add_cinn_pass.cc
index c8d555df54faa8..a3ae3deb615ee8 100644
--- a/paddle/cinn/hlir/dialect/operator/transforms/add_cinn_pass.cc
+++ b/paddle/cinn/hlir/dialect/operator/transforms/add_cinn_pass.cc
@@ -158,7 +158,6 @@ void ApplyDivideGroupOpToFusionOpPass(
   if (FLAGS_group_schedule_tiling_first) {
     pass_manager->AddPass(cinn::dialect::ir::CreateAddStoreInGroupOpPass());
     pass_manager->AddPass(cinn::dialect::ir::CreateCinnGroupClusterPass());
-    pass_manager->AddPass(cinn::dialect::ir::CreateAddStoreInFusionOpPass());
   } else {
     pass_manager->AddPass(
         cinn::dialect::ir::CreateDivideGroupOpToFusionOpPass());
diff --git a/test/cpp/pir/cinn/pir_all_path_test.cc b/test/cpp/pir/cinn/pir_all_path_test.cc
index 32e57b53867aa8..382c9e2385ab88 100644
--- a/test/cpp/pir/cinn/pir_all_path_test.cc
+++ b/test/cpp/pir/cinn/pir_all_path_test.cc
@@ -77,7 +77,6 @@ static void RunAndCheckResult(::pir::Program* program,
   pir::PassManager stage_2_pm(ctx);
   stage_2_pm.AddPass(cinn::dialect::ir::CreateAddStoreInGroupOpPass());
   stage_2_pm.AddPass(cinn::dialect::ir::CreateCinnGroupClusterPass());
-  stage_2_pm.AddPass(cinn::dialect::ir::CreateAddStoreInFusionOpPass());
   stage_2_pm.AddPass(pir::CreateDeadCodeEliminationPass());
   stage_2_pm.AddPass(cinn::dialect::ir::CreateLowerCinnFusionOpPass());
   stage_2_pm.EnableIRPrinting();

From 1dc23e63182639e37125f122ba6a0d8632a86c14 Mon Sep 17 00:00:00 2001
From: feifei-111 <2364819892@qq.com>
Date: Sat, 11 May 2024 06:35:23 +0000
Subject: [PATCH 64/99] update

---
 .../graph_transformer/matcher.h               | 19 ++--
 .../graph_transformer/operation.h             | 96 ++++++++-----------
 paddle/cinn/operator_fusion/pattern_graph.cc  |  9 +-
 3 files changed, 53 insertions(+), 71 deletions(-)

diff --git a/paddle/cinn/operator_fusion/graph_transformer/matcher.h b/paddle/cinn/operator_fusion/graph_transformer/matcher.h
index 1e4c59967606dd..21c37c74e9e03d 100644
--- a/paddle/cinn/operator_fusion/graph_transformer/matcher.h
+++ b/paddle/cinn/operator_fusion/graph_transformer/matcher.h
@@ -44,18 +44,6 @@ struct CanFuseRxTMatcher {
   }
 };
 
-struct SinkTrivialMatcher {
-  template <typename T>
-  bool operator()(const PatternGraph<T>& graph, const PatternNodePtr<T>& node) {
-    return StmtPatternGraphMatcher<TrivialPattern<T>>()(graph, node) &&
-           node->downstream().size() == 1 &&
-           (std::holds_alternative<ReducePattern<T>>(
-                node->downstream().at(0)->stmt_pattern()) ||
-            std::holds_alternative<TrivialPattern<T>>(
-                node->downstream().at(0)->stmt_pattern()));
-  }
-};
-
 struct CanFuseReduceTreeMatcher {
   template <typename T>
   bool operator()(const PatternGraph<T>& graph, const PatternNodePtr<T>& node) {
@@ -172,6 +160,13 @@ struct HorizontalFusionMatcher {
   }
 };
 
+struct NonSinkNodeMatcher {
+  template <typename T>
+  bool operator()(const PatternGraph<T>& graph, const PatternNodePtr<T>& node) {
+    return !node->downstream().empty();
+  }
+};
+
 struct IsOutputNodeMatcher {
   template <typename T>
   bool operator()(const PatternGraph<T>& graph, const PatternNodePtr<T>& node) {
diff --git a/paddle/cinn/operator_fusion/graph_transformer/operation.h b/paddle/cinn/operator_fusion/graph_transformer/operation.h
index c91a73a18cb86d..168bb1b311a6ab 100644
--- a/paddle/cinn/operator_fusion/graph_transformer/operation.h
+++ b/paddle/cinn/operator_fusion/graph_transformer/operation.h
@@ -86,22 +86,46 @@ struct LiftReduceToReduceTreeOperation {
 
 struct MergeTrivialPatternOperation {
   template <typename Phrase>
-  PatternNodePtr<Phrase> operator()(PatternGraph<Phrase>* graph,
-                                    PatternNodePtr<Phrase> node) {
-    PADDLE_ENFORCE_EQ(
-        node->downstream().size(),
-        1,
-        phi::errors::PreconditionNotMet("The downstream of the Sink Trivial "
-                                        "Pattern node should be 1, but got %d.",
-                                        node->downstream().size()));
-    const auto& downstream = node->downstream().at(0);
-    auto merged_node = graph->MergeNode(node, downstream, MergePattern<Phrase>);
-    graph->RemoveNode(downstream);
-    graph->RemoveNode(node);
-    VLOG(4) << "MergeTrivialPatternOperation: \nupstream " << node->DebugStr()
-            << "\ndownstream " << downstream->DebugStr() << "\nmerged "
-            << merged_node->DebugStr();
-    return merged_node;
+  void operator()(PatternGraph<Phrase>* graph, PatternNodePtr<Phrase> node) {
+    PADDLE_ENFORCE_GE(upstream->downstream().size(),
+                      1,
+                      phi::errors::PreconditionNotMet(
+                          "The trivial pattern wait for sinking should has "
+                          "at least 1 downstream , but got %d.",
+                          upstream->downstream().size()));
+
+    std::vector<PatternNodePtr<Phrase>> fusion_candidate =
+        upstream->downstream();
+    upstream->ClearDownstream();
+
+    for (const auto& downstream : fusion_candidate) {
+      bool can_fuse =
+          std::holds_alternative<ReducePattern<Phrase>>(
+              downstream->stmt_pattern()) ||
+          std::holds_alternative<TrivialPattern<Phrase>>(
+              downstream->stmt_pattern()) ||
+          std::holds_alternative<ReduceTreePattern<Phrase>>(
+              downstream->stmt_pattern()) ||
+          std::holds_alternative<ReduceTreePlusTrivialPattern<Phrase>>(
+              downstream->stmt_pattern()) ||
+          std::holds_alternative<AnchorPattern<Phrase>>(
+              downstream->stmt_pattern());
+
+      if (can_fuse) {
+        auto merged_node =
+            graph->MergeNode(upstream, downstream, MergePattern<Phrase>);
+        graph->RemoveNode(downstream);
+        VLOG(4) << "Spliting trivial pattern: \nupstream "
+                << upstream->DebugStr() << "\ndownstream "
+                << downstream->DebugStr() << "\nmerged "
+                << merged_node->DebugStr();
+      } else {
+        upstream->AddNodeToDownstream(downstream);
+      }
+    }
+    if (upstream->downstream().empty()) {
+      graph->RemoveNode(upstream);
+    }
   }
 };
 
@@ -240,48 +264,10 @@ struct SplitRecomputeOperation {
   template <typename Phrase>
   void operator()(PatternGraph<Phrase>* graph,
                   PatternNodePtr<Phrase> upstream) {
-    PADDLE_ENFORCE_GE(upstream->downstream().size(),
-                      1,
-                      phi::errors::PreconditionNotMet(
-                          "The downstream of node for recomputation should be "
-                          ">= 1, but got %d.",
-                          upstream->downstream().size()));
-
-    std::vector<PatternNodePtr<Phrase>> fusion_candidate =
-        upstream->downstream();
-    upstream->ClearDownstream();
-
     upstream->set_stmt_pattern(RecoverAnchorPatternToTrivial(
         std::get<AnchorPattern<Phrase>>(upstream->stmt_pattern())));
 
-    for (const auto& downstream : fusion_candidate) {
-      bool can_fuse =
-          std::holds_alternative<ReducePattern<Phrase>>(
-              downstream->stmt_pattern()) ||
-          std::holds_alternative<TrivialPattern<Phrase>>(
-              downstream->stmt_pattern()) ||
-          std::holds_alternative<ReduceTreePattern<Phrase>>(
-              downstream->stmt_pattern()) ||
-          std::holds_alternative<ReduceTreePlusTrivialPattern<Phrase>>(
-              downstream->stmt_pattern()) ||
-          std::holds_alternative<AnchorPattern<Phrase>>(
-              downstream->stmt_pattern());
-
-      if (can_fuse) {
-        auto merged_node =
-            graph->MergeNode(upstream, downstream, MergePattern<Phrase>);
-        graph->RemoveNode(downstream);
-        VLOG(4) << "Spliting recomputable anchor pattern: \nupstream "
-                << upstream->DebugStr() << "\ndownstream "
-                << downstream->DebugStr() << "\nmerged "
-                << merged_node->DebugStr();
-      } else {
-        upstream->AddNodeToDownstream(downstream);
-      }
-    }
-    if (upstream->downstream().empty()) {
-      graph->RemoveNode(upstream);
-    }
+    MergeTrivialPatternOperation(graph, upstream);
   }
 };
 
diff --git a/paddle/cinn/operator_fusion/pattern_graph.cc b/paddle/cinn/operator_fusion/pattern_graph.cc
index 382f36f11879a2..2afb14c472e424 100644
--- a/paddle/cinn/operator_fusion/pattern_graph.cc
+++ b/paddle/cinn/operator_fusion/pattern_graph.cc
@@ -126,10 +126,11 @@ std::vector<PatternNodePtr<T>> PatternGraph<T>::SortByReverseTopoOrder() {
 
 template <typename T>
 void PatternGraph<T>::SinkTrivialPattern() {
-  GraphTransformer<NodePattern,
-                   T,
-                   SinkTrivialMatcher,
-                   MergeTrivialPatternOperation>(this);
+  GraphTransformer<
+      NodePattern,
+      T,
+      And<NonSinkNodeMatcher, StmtPatternGraphMatcher<TrivialPattern<T>>>,
+      MergeTrivialPatternOperation>(this);
 }
 
 template <typename T>

From 54cd100f735d3e6e03c9b3b430ba3d7118bde8c5 Mon Sep 17 00:00:00 2001
From: feifei-111 <2364819892@qq.com>
Date: Sat, 11 May 2024 07:17:57 +0000
Subject: [PATCH 65/99] update

---
 .../operator_fusion/graph_transformer/matcher.h | 17 ++++++++++++++---
 .../graph_transformer/operation.h               |  5 +++--
 paddle/cinn/operator_fusion/pattern_graph.cc    | 11 ++++++-----
 3 files changed, 23 insertions(+), 10 deletions(-)

diff --git a/paddle/cinn/operator_fusion/graph_transformer/matcher.h b/paddle/cinn/operator_fusion/graph_transformer/matcher.h
index 21c37c74e9e03d..c0b3297dc92951 100644
--- a/paddle/cinn/operator_fusion/graph_transformer/matcher.h
+++ b/paddle/cinn/operator_fusion/graph_transformer/matcher.h
@@ -191,11 +191,22 @@ struct DownstreamGreaterThan {
   }
 };
 
-template <typename A, typename B>
-struct And {
+template <typename... Args>
+struct And {};
+
+template <typename A>
+struct And<A> {
+  template <typename T>
+  bool operator()(const PatternGraph<T>& graph, const PatternNodePtr<T>& node) {
+    return A()(graph, node);
+  }
+};
+
+template <typename A, typename... Args>
+struct And<A, Args...> {
   template <typename T>
   bool operator()(const PatternGraph<T>& graph, const PatternNodePtr<T>& node) {
-    return A()(graph, node) && B()(graph, node);
+    return A()(graph, node) && And<Args...>()(graph, node);
   }
 };
 
diff --git a/paddle/cinn/operator_fusion/graph_transformer/operation.h b/paddle/cinn/operator_fusion/graph_transformer/operation.h
index 168bb1b311a6ab..fae1dc7dd1f247 100644
--- a/paddle/cinn/operator_fusion/graph_transformer/operation.h
+++ b/paddle/cinn/operator_fusion/graph_transformer/operation.h
@@ -86,7 +86,8 @@ struct LiftReduceToReduceTreeOperation {
 
 struct MergeTrivialPatternOperation {
   template <typename Phrase>
-  void operator()(PatternGraph<Phrase>* graph, PatternNodePtr<Phrase> node) {
+  void operator()(PatternGraph<Phrase>* graph,
+                  PatternNodePtr<Phrase> upstream) {
     PADDLE_ENFORCE_GE(upstream->downstream().size(),
                       1,
                       phi::errors::PreconditionNotMet(
@@ -267,7 +268,7 @@ struct SplitRecomputeOperation {
     upstream->set_stmt_pattern(RecoverAnchorPatternToTrivial(
         std::get<AnchorPattern<Phrase>>(upstream->stmt_pattern())));
 
-    MergeTrivialPatternOperation(graph, upstream);
+    MergeTrivialPatternOperation()(graph, upstream);
   }
 };
 
diff --git a/paddle/cinn/operator_fusion/pattern_graph.cc b/paddle/cinn/operator_fusion/pattern_graph.cc
index 2afb14c472e424..394eabb58f85ff 100644
--- a/paddle/cinn/operator_fusion/pattern_graph.cc
+++ b/paddle/cinn/operator_fusion/pattern_graph.cc
@@ -126,11 +126,12 @@ std::vector<PatternNodePtr<T>> PatternGraph<T>::SortByReverseTopoOrder() {
 
 template <typename T>
 void PatternGraph<T>::SinkTrivialPattern() {
-  GraphTransformer<
-      NodePattern,
-      T,
-      And<NonSinkNodeMatcher, StmtPatternGraphMatcher<TrivialPattern<T>>>,
-      MergeTrivialPatternOperation>(this);
+  GraphTransformer<NodePattern,
+                   T,
+                   And<StmtPatternGraphMatcher<TrivialPattern<T>>,
+                       DownstreamSmallerThan<2>,
+                       NonSinkNodeMatcher>,
+                   MergeTrivialPatternOperation>(this);
 }
 
 template <typename T>

From b36ec3060b1a2eaddac5b1894cc5ae6d9fd7445a Mon Sep 17 00:00:00 2001
From: feifei-111 <2364819892@qq.com>
Date: Mon, 27 May 2024 11:37:21 +0000
Subject: [PATCH 66/99] refine codes and add interpreter

---
 paddle/cinn/operator_fusion/CMakeLists.txt    |   3 +-
 .../operator_fusion/backend/CMakeLists.txt    |   1 -
 paddle/cinn/operator_fusion/backend/pattern.h |  96 -------
 .../operator_fusion/backend/pattern_fuser.h   |  69 -----
 .../operator_fusion/frontend/CMakeLists.txt   |   1 -
 .../cinn/operator_fusion/frontend/pattern.h   |  96 -------
 .../operator_fusion/frontend/pattern_fuser.cc | 112 --------
 .../operator_fusion/frontend/pattern_fuser.h  |  66 -----
 .../fusion_tracker/CMakeLists.txt             |   1 +
 .../interpreter.cc}                           |   3 +-
 .../fusion_tracker/interpreter.h              |  18 ++
 .../operator_fusion/fusion_tracker/tracker.h  |  54 ++++
 .../graph_transformer/operation.h             | 166 +++++-------
 .../graph_transformer/search_algorithm.h      |  62 ++---
 paddle/cinn/operator_fusion/group_cluster.h   |  21 +-
 paddle/cinn/operator_fusion/pattern.h         | 243 ++++++++++++------
 paddle/cinn/operator_fusion/pattern_fuser.cc  |  91 +++++++
 paddle/cinn/operator_fusion/pattern_fuser.h   | 227 +++++++---------
 paddle/cinn/operator_fusion/pattern_graph.cc  | 121 ++++-----
 paddle/cinn/operator_fusion/pattern_graph.h   |  36 ++-
 paddle/cinn/operator_fusion/pattern_node.h    |  21 +-
 .../pir_graph_analyzing/anchor_transform.h    |  25 +-
 .../policy/anchor_search_policy.cc            |  30 +--
 .../policy/anchor_search_policy.h             |  15 +-
 .../policy/general_topo_policy.cc             |  15 +-
 .../policy/general_topo_policy.h              |   7 +-
 .../cinn/operator_fusion/policy/policy_base.h |   7 +-
 .../operator_fusion/policy/policy_manager.h   |  19 +-
 .../policy/relative_judge_policy.cc           |  59 ++---
 .../policy/relative_judge_policy.h            |  25 +-
 30 files changed, 697 insertions(+), 1013 deletions(-)
 delete mode 100644 paddle/cinn/operator_fusion/backend/CMakeLists.txt
 delete mode 100644 paddle/cinn/operator_fusion/backend/pattern.h
 delete mode 100644 paddle/cinn/operator_fusion/backend/pattern_fuser.h
 delete mode 100644 paddle/cinn/operator_fusion/frontend/CMakeLists.txt
 delete mode 100644 paddle/cinn/operator_fusion/frontend/pattern.h
 delete mode 100644 paddle/cinn/operator_fusion/frontend/pattern_fuser.cc
 delete mode 100644 paddle/cinn/operator_fusion/frontend/pattern_fuser.h
 create mode 100644 paddle/cinn/operator_fusion/fusion_tracker/CMakeLists.txt
 rename paddle/cinn/operator_fusion/{backend/pattern_fuser.cc => fusion_tracker/interpreter.cc} (99%)
 create mode 100644 paddle/cinn/operator_fusion/fusion_tracker/interpreter.h
 create mode 100644 paddle/cinn/operator_fusion/fusion_tracker/tracker.h
 create mode 100644 paddle/cinn/operator_fusion/pattern_fuser.cc

diff --git a/paddle/cinn/operator_fusion/CMakeLists.txt b/paddle/cinn/operator_fusion/CMakeLists.txt
index 7e756c6701205a..b57c646032e19f 100644
--- a/paddle/cinn/operator_fusion/CMakeLists.txt
+++ b/paddle/cinn/operator_fusion/CMakeLists.txt
@@ -2,9 +2,10 @@ add_subdirectory(frontend)
 add_subdirectory(backend)
 add_subdirectory(policy)
 add_subdirectory(pir_graph_analyzing)
+add_subdirectory(fusion_tracker)
 
 cc_library(
   op_fusion
   SRCS ${frontend_fusion_src} ${backend_fusion_src} ${policy_fusion_src}
-       ${fusion_graph_analyzing} pattern_graph.cc
+       ${fusion_graph_analyzing} ${fusion_tracker_src} pattern_graph.cc
   DEPS phi)
diff --git a/paddle/cinn/operator_fusion/backend/CMakeLists.txt b/paddle/cinn/operator_fusion/backend/CMakeLists.txt
deleted file mode 100644
index fe18d42b10fec0..00000000000000
--- a/paddle/cinn/operator_fusion/backend/CMakeLists.txt
+++ /dev/null
@@ -1 +0,0 @@
-gather_srcs(backend_fusion_src SRCS pattern_fuser.cc)
diff --git a/paddle/cinn/operator_fusion/backend/pattern.h b/paddle/cinn/operator_fusion/backend/pattern.h
deleted file mode 100644
index 6c76a6aa57dde4..00000000000000
--- a/paddle/cinn/operator_fusion/backend/pattern.h
+++ /dev/null
@@ -1,96 +0,0 @@
-// Copyright (c) 2024 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/cinn/hlir/framework/pir/trivial_op_impl.h"
-#include "paddle/cinn/ir/ir_base.h"
-#include "paddle/cinn/operator_fusion/pattern.h"
-#include "paddle/cinn/operator_fusion/pattern_fuser.h"
-#include "paddle/cinn/operator_fusion/pir_graph_analyzing/anchor_transform.h"
-#include "paddle/cinn/operator_fusion/utils.h"
-
-namespace cinn::fusion {
-
-struct BackendStage {};
-
-template <>
-struct PatternContent<BackendStage> {
-  explicit PatternContent<BackendStage>(pir::Operation* op,
-                                        std::optional<ir::Expr> expr)
-      : op(op), expr(expr) {}
-  pir::Operation* op;
-  std::optional<ir::Expr> expr;
-};
-
-using BackendContent = PatternContent<BackendStage>;
-using TrivialOp = cinn::hlir::framework::pir::trivial_fusion_detail::TrivialOp;
-using ReduceOp = cinn::hlir::framework::pir::trivial_fusion_detail::ReduceOp;
-using FusionOp = std::variant<ReduceOp, TrivialOp>;
-template <>
-struct TrivialPattern<BackendStage> {
-  explicit TrivialPattern(const std::vector<pir::Operation*>& ops,
-                          pir::Operation* sink_op,
-                          const TrivialOp& op)
-      : ops_(ops), sink_op_(sink_op), trivial_op(op) {}
-  std::vector<pir::Operation*> ops_;
-  pir::Operation* sink_op_;
-  TrivialOp trivial_op;
-  static std::string name() { return "Trivial"; }
-  std::vector<pir::Operation*> ops() const { return ops_; }
-  pir::Operation* sink_op() const { return sink_op_; }
-};
-
-template <>
-struct ReducePattern<BackendStage> {
-  explicit ReducePattern(const std::vector<pir::Operation*>& ops,
-                         const ReduceOp& op)
-      : ops_(ops), reduce_op(op) {}
-  std::vector<pir::Operation*> ops_;
-  ReduceOp reduce_op;
-  std::vector<pir::Operation*> ops() const { return ops_; }
-  pir::Operation* GetReduceOp() const { return ops_.back(); }
-  static std::string name() { return "Reduce"; }
-};
-
-template <>
-struct UnsupportPattern<BackendStage> {
-  explicit UnsupportPattern(const std::vector<pir::Operation*>& ops)
-      : ops_(ops) {}
-  std::vector<pir::Operation*> ops_;
-  std::vector<pir::Operation*> ops() const { return ops_; }
-  static std::string name() { return "Unsupport"; }
-};
-
-template <>
-struct ExprPromise<BackendStage> {
-  explicit ExprPromise(const pir::Value& root, const FusionOp& op)
-      : root_value(root), root_fusion_op(op) {}
-  AnchorTransformRoute transform_route;
-  pir::Value root_value;
-  FusionOp root_fusion_op;
-
-  void update(const AnchorTransformRoute& route) {
-    transform_route.insert(transform_route.end(), route.begin(), route.end());
-  }
-
-  std::string DebugStr() const {
-    std::stringstream ss;
-    ss << "[ExprPromise] root_value: " << root_value.impl() << "\n";
-    ss << "[ExprPromise] root_expr: " << GetComputeBody(root_fusion_op) << "\n";
-    ss << DebugStrOfAnchorTransformRoute(transform_route) << "\n";
-    return ss.str();
-  }
-};
-
-}  // namespace cinn::fusion
diff --git a/paddle/cinn/operator_fusion/backend/pattern_fuser.h b/paddle/cinn/operator_fusion/backend/pattern_fuser.h
deleted file mode 100644
index 97ee70df9c149e..00000000000000
--- a/paddle/cinn/operator_fusion/backend/pattern_fuser.h
+++ /dev/null
@@ -1,69 +0,0 @@
-// Copyright (c) 2024 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/cinn/operator_fusion/backend/pattern.h"
-#include "paddle/cinn/operator_fusion/pattern.h"
-#include "paddle/cinn/operator_fusion/pattern_fuser.h"
-
-namespace cinn::fusion {
-
-// extern template to don't allow compiler specialize the following code.
-
-template <>
-StmtPattern<BackendStage> ConvertToStmtPattern(
-    const PatternContent<BackendStage>& content);
-
-template <>
-StmtPattern<BackendStage> MergePatternImpl(
-    const ReduceTreePattern<BackendStage>& first,
-    const TrivialPattern<BackendStage>& second);
-
-template <>
-StmtPattern<BackendStage> MergePatternImpl(
-    const TrivialPattern<BackendStage>& first,
-    const ReducePattern<BackendStage>& second);
-
-template <>
-StmtPattern<BackendStage> MergePatternImpl(
-    const TrivialPattern<BackendStage>& first,
-    const TrivialPattern<BackendStage>& second);
-
-template <>
-StmtPattern<BackendStage> MergePatternImpl(
-    const TrivialPattern<BackendStage>& first,
-    const AnchorPattern<BackendStage>& second);
-
-template <>
-StmtPattern<BackendStage> MergePatternImpl(
-    const AnchorPattern<BackendStage>& source,
-    const AnchorPattern<BackendStage>& dest);
-
-std::vector<ir::Expr> GetExprFromPattern(
-    const StmtPattern<BackendStage>& pattern);
-
-template <>
-ExprPromise<BackendStage> InitExprPromiseImpl(
-    const TrivialPattern<BackendStage>& pattern, pir::Value anchor);
-
-template <>
-ExprPromise<BackendStage> InitExprPromiseImpl(
-    const ReducePattern<BackendStage>& pattern, pir::Value anchor);
-
-template <>
-TrivialPattern<BackendStage> RecoverAnchorPatternToTrivial(
-    const AnchorPattern<BackendStage>& anchor_pattern);
-
-}  // namespace cinn::fusion
diff --git a/paddle/cinn/operator_fusion/frontend/CMakeLists.txt b/paddle/cinn/operator_fusion/frontend/CMakeLists.txt
deleted file mode 100644
index e9683e520ef5a4..00000000000000
--- a/paddle/cinn/operator_fusion/frontend/CMakeLists.txt
+++ /dev/null
@@ -1 +0,0 @@
-gather_srcs(frontend_fusion_src SRCS pattern_fuser.cc)
diff --git a/paddle/cinn/operator_fusion/frontend/pattern.h b/paddle/cinn/operator_fusion/frontend/pattern.h
deleted file mode 100644
index a8dccf1128bebd..00000000000000
--- a/paddle/cinn/operator_fusion/frontend/pattern.h
+++ /dev/null
@@ -1,96 +0,0 @@
-// Copyright (c) 2024 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/cinn/operator_fusion/pattern.h"
-#include "paddle/cinn/operator_fusion/pattern_fuser.h"
-#include "paddle/cinn/operator_fusion/pir_graph_analyzing/anchor_transform.h"
-#include "paddle/cinn/operator_fusion/utils.h"
-
-namespace cinn::fusion {
-
-struct FrontendStage {};
-
-template <>
-struct PatternContent<FrontendStage> {
-  explicit PatternContent<FrontendStage>(pir::Operation* op) : op(op) {}
-  pir::Operation* op;
-  bool operator==(const PatternContent<FrontendStage>& other) const {
-    return op == other.op;
-  }
-};
-
-using FrontendContent = PatternContent<FrontendStage>;
-
-}  // namespace cinn::fusion
-
-namespace std {
-template <>
-struct hash<cinn::fusion::FrontendContent> {
-  size_t operator()(const cinn::fusion::FrontendContent& content) const {
-    return std::hash<pir::Operation*>()(content.op);
-  }
-};
-
-}  // namespace std
-
-namespace cinn::fusion {
-template <>
-struct TrivialPattern<FrontendStage> {
-  explicit TrivialPattern(const std::vector<pir::Operation*>& ops,
-                          pir::Operation* sink_op)
-      : ops_(ops), sink_op_(sink_op) {}
-  std::vector<pir::Operation*> ops_;
-  pir::Operation* sink_op_;
-  static std::string name() { return "Trivial"; }
-  std::vector<pir::Operation*> ops() const { return ops_; }
-  pir::Operation* sink_op() const { return sink_op_; }
-};
-
-template <>
-struct ReducePattern<FrontendStage> {
-  explicit ReducePattern(const std::vector<pir::Operation*>& ops) : ops_(ops) {}
-  std::vector<pir::Operation*> ops_;
-  std::vector<pir::Operation*> ops() const { return ops_; }
-  pir::Operation* GetReduceOp() const { return ops_.back(); }
-  static std::string name() { return "Reduce"; }
-};
-
-template <>
-struct UnsupportPattern<FrontendStage> {
-  explicit UnsupportPattern(const std::vector<pir::Operation*>& ops)
-      : ops_(ops) {}
-  std::vector<pir::Operation*> ops_;
-  std::vector<pir::Operation*> ops() const { return ops_; }
-  static std::string name() { return "Unsupport"; }
-};
-
-template <>
-struct ExprPromise<FrontendStage> {
-  explicit ExprPromise(const pir::Value& root) : root_value(root) {}
-  AnchorTransformRoute transform_route;
-  pir::Value root_value;
-
-  void update(const AnchorTransformRoute& route) {
-    transform_route.insert(transform_route.end(), route.begin(), route.end());
-  }
-
-  std::string DebugStr() const {
-    std::stringstream ss;
-    ss << "[ExprPromise] root_value: " << root_value.impl() << "\n";
-    ss << DebugStrOfAnchorTransformRoute(transform_route) << "\n";
-    return ss.str();
-  }
-};
-}  // namespace cinn::fusion
diff --git a/paddle/cinn/operator_fusion/frontend/pattern_fuser.cc b/paddle/cinn/operator_fusion/frontend/pattern_fuser.cc
deleted file mode 100644
index 543d96fd7e80e3..00000000000000
--- a/paddle/cinn/operator_fusion/frontend/pattern_fuser.cc
+++ /dev/null
@@ -1,112 +0,0 @@
-// Copyright (c) 2024 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/cinn/operator_fusion/frontend/pattern_fuser.h"
-#include "paddle/cinn/operator_fusion/frontend/pattern.h"
-
-namespace cinn::fusion {
-
-template <>
-StmtPattern<FrontendStage> ConvertToStmtPattern(
-    const PatternContent<FrontendStage>& content) {
-  const auto& kind = GetOpPatternKind(content.op);
-  if (kind == hlir::framework::kReduction) {
-    return ReducePattern<FrontendStage>({content.op});
-  } else if (kind == hlir::framework::kElementWise ||
-             kind == hlir::framework::kBroadcast ||
-             kind == hlir::framework::kInjective) {
-    return TrivialPattern<FrontendStage>({content.op}, content.op);
-  } else {
-    return UnsupportPattern<FrontendStage>({content.op});
-  }
-}
-
-template <>
-StmtPattern<FrontendStage> MergePatternImpl(
-    const ReduceTreePattern<FrontendStage>& first,
-    const TrivialPattern<FrontendStage>& second) {
-  return ReduceTreePlusTrivialPattern<FrontendStage>(first, second);
-}
-
-template <>
-StmtPattern<FrontendStage> MergePatternImpl(
-    const TrivialPattern<FrontendStage>& first,
-    const ReducePattern<FrontendStage>& second) {
-  const auto& contents =
-      UniqueConcatVector(GetOpsInPattern<FrontendStage>(first),
-                         GetOpsInPattern<FrontendStage>(second));
-  return ReducePattern<FrontendStage>(contents);
-}
-
-template <>
-StmtPattern<FrontendStage> MergePatternImpl(
-    const TrivialPattern<FrontendStage>& first,
-    const TrivialPattern<FrontendStage>& second) {
-  const auto& contents =
-      UniqueConcatVector(GetOpsInPattern<FrontendStage>(first),
-                         GetOpsInPattern<FrontendStage>(second));
-  return TrivialPattern<FrontendStage>(contents, second.sink_op());
-}
-
-template <>
-StmtPattern<FrontendStage> MergePatternImpl(
-    const TrivialPattern<FrontendStage>& first,
-    const AnchorPattern<FrontendStage>& second) {
-  return AnchorPattern<FrontendStage>(
-      UniqueConcatVector(GetOpsInPattern<FrontendStage>(first),
-                         GetOpsInPattern<FrontendStage>(second)),
-      second.anchor(),
-      second.anchor_state);
-}
-
-template <>
-StmtPattern<FrontendStage> MergePatternImpl(
-    const AnchorPattern<FrontendStage>& source,
-    const AnchorPattern<FrontendStage>& dest) {
-  const auto& contents =
-      UniqueConcatVector(GetOpsInPattern<FrontendStage>(source),
-                         GetOpsInPattern<FrontendStage>(dest));
-  return AnchorPattern<FrontendStage>(
-      contents, source.anchor(), AnchorState<FrontendStage>({}));
-}
-
-template <>
-ExprPromise<FrontendStage> InitExprPromiseImpl(
-    const TrivialPattern<FrontendStage>& pattern, pir::Value anchor) {
-  return ExprPromise<FrontendStage>(anchor);
-}
-
-template <>
-ExprPromise<FrontendStage> InitExprPromiseImpl(
-    const ReducePattern<FrontendStage>& pattern, pir::Value anchor) {
-  return ExprPromise<FrontendStage>(anchor);
-}
-
-template <>
-TrivialPattern<FrontendStage> RecoverAnchorPatternToTrivial(
-    const AnchorPattern<FrontendStage>& anchor_pattern) {
-  PADDLE_ENFORCE_EQ(anchor_pattern.anchor_state.promise.size(),
-                    1,
-                    phi::errors::PreconditionNotMet(
-                        "Can only recover AnchorPattern whose anchor_state "
-                        "size is 1 (exact %d)",
-                        anchor_pattern.anchor_state.promise.size()));
-
-  return TrivialPattern<FrontendStage>(anchor_pattern.ops(),
-                                       anchor_pattern.anchor().defining_op());
-}
-
-}  // namespace cinn::fusion
diff --git a/paddle/cinn/operator_fusion/frontend/pattern_fuser.h b/paddle/cinn/operator_fusion/frontend/pattern_fuser.h
deleted file mode 100644
index 5997d38e84cbea..00000000000000
--- a/paddle/cinn/operator_fusion/frontend/pattern_fuser.h
+++ /dev/null
@@ -1,66 +0,0 @@
-// Copyright (c) 2024 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/cinn/operator_fusion/frontend/pattern.h"
-#include "paddle/cinn/operator_fusion/pattern.h"
-#include "paddle/cinn/operator_fusion/pattern_fuser.h"
-
-namespace cinn::fusion {
-
-// extern template to don't allow compiler specialize the following code.
-
-template <>
-StmtPattern<FrontendStage> ConvertToStmtPattern(
-    const PatternContent<FrontendStage>& content);
-
-template <>
-StmtPattern<FrontendStage> MergePatternImpl(
-    const ReduceTreePattern<FrontendStage>& first,
-    const TrivialPattern<FrontendStage>& second);
-
-template <>
-StmtPattern<FrontendStage> MergePatternImpl(
-    const TrivialPattern<FrontendStage>& first,
-    const ReducePattern<FrontendStage>& second);
-
-template <>
-StmtPattern<FrontendStage> MergePatternImpl(
-    const TrivialPattern<FrontendStage>& first,
-    const TrivialPattern<FrontendStage>& second);
-
-template <>
-StmtPattern<FrontendStage> MergePatternImpl(
-    const TrivialPattern<FrontendStage>& first,
-    const AnchorPattern<FrontendStage>& second);
-
-template <>
-StmtPattern<FrontendStage> MergePatternImpl(
-    const AnchorPattern<FrontendStage>& source,
-    const AnchorPattern<FrontendStage>& dest);
-
-template <>
-ExprPromise<FrontendStage> InitExprPromiseImpl(
-    const TrivialPattern<FrontendStage>& pattern, pir::Value anchor);
-
-template <>
-ExprPromise<FrontendStage> InitExprPromiseImpl(
-    const ReducePattern<FrontendStage>& pattern, pir::Value anchor);
-
-template <>
-TrivialPattern<FrontendStage> RecoverAnchorPatternToTrivial(
-    const AnchorPattern<FrontendStage>& anchor_pattern);
-
-}  // namespace cinn::fusion
diff --git a/paddle/cinn/operator_fusion/fusion_tracker/CMakeLists.txt b/paddle/cinn/operator_fusion/fusion_tracker/CMakeLists.txt
new file mode 100644
index 00000000000000..0d61eb7cef95b3
--- /dev/null
+++ b/paddle/cinn/operator_fusion/fusion_tracker/CMakeLists.txt
@@ -0,0 +1 @@
+gather_srcs(fusion_tracker_src SRCS interpreter.cc)
diff --git a/paddle/cinn/operator_fusion/backend/pattern_fuser.cc b/paddle/cinn/operator_fusion/fusion_tracker/interpreter.cc
similarity index 99%
rename from paddle/cinn/operator_fusion/backend/pattern_fuser.cc
rename to paddle/cinn/operator_fusion/fusion_tracker/interpreter.cc
index 7a8400ecc4ec23..6e67320dacf555 100644
--- a/paddle/cinn/operator_fusion/backend/pattern_fuser.cc
+++ b/paddle/cinn/operator_fusion/fusion_tracker/interpreter.cc
@@ -17,8 +17,7 @@
 #include "glog/logging.h"
 
 #include "paddle/cinn/hlir/framework/pir/trivial_op_impl.h"
-#include "paddle/cinn/operator_fusion/backend/pattern.h"
-#include "paddle/cinn/operator_fusion/backend/pattern_fuser.h"
+#include "paddle/cinn/operator_fusion/fusion_tracker/interpreter.h"
 
 namespace cinn::fusion {
 
diff --git a/paddle/cinn/operator_fusion/fusion_tracker/interpreter.h b/paddle/cinn/operator_fusion/fusion_tracker/interpreter.h
new file mode 100644
index 00000000000000..3d53c4f8eaa8e7
--- /dev/null
+++ b/paddle/cinn/operator_fusion/fusion_tracker/interpreter.h
@@ -0,0 +1,18 @@
+// Copyright (c) 2024 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/cinn/operator_fusion/fusion_tracker/tracker.h"
+
+struct FusionInterpreter {};
diff --git a/paddle/cinn/operator_fusion/fusion_tracker/tracker.h b/paddle/cinn/operator_fusion/fusion_tracker/tracker.h
new file mode 100644
index 00000000000000..d81774d9b3fe8f
--- /dev/null
+++ b/paddle/cinn/operator_fusion/fusion_tracker/tracker.h
@@ -0,0 +1,54 @@
+// Copyright (c) 2024 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/cinn/ir/ir_base.h"
+#include "paddle/cinn/operator_fusion/pattern.h"
+#include "paddle/cinn/operator_fusion/pattern_fuser.h"
+#include "paddle/cinn/operator_fusion/utils.h"
+
+namespace cinn::fusion {
+
+using TrivialOp = cinn::hlir::framework::pir::trivial_fusion_detail::TrivialOp;
+using ReduceOp = cinn::hlir::framework::pir::trivial_fusion_detail::ReduceOp;
+using FusionOp = std::variant<ReduceOp, TrivialOp>;
+
+struct FusionScope {
+  std::unordered_map<std::string, std::vector<FusionOp>> scope_;
+  std::string DebugStr() const;
+};
+
+struct FusionInstruction {
+  virtual void Apply(FusionScope* scope);
+};
+
+using FusionInstrPtr = std::shared_ptr<FusionInstruction>;
+
+struct TrivialInlineInstr : public FusionInstruction {};
+struct TmpTransformInstr : public FusionInstruction {};
+struct AnchorMatchInstr : public FusionInstruction {};
+struct InitPatternInstr : public FusionInstruction {};
+struct RemovePatternInstr : public FusionInstruction {};
+
+struct FusionTracker {
+  FusionTracker() = default;
+  FusionTracker(const FusionTracker& up, const FusionTracker& down) {
+    ExtendVector(&instructions_, up.instructions_);
+    ExtendVector(&instructions_, down.instructions_);
+  }
+  void append(FusionInstrPtr instr) { instructions_.emplace_back(instr); }
+  std::vector<FusionInstrPtr> instructions_;
+  std::string DebugStr() const;
+};
+}  // namespace cinn::fusion
diff --git a/paddle/cinn/operator_fusion/graph_transformer/operation.h b/paddle/cinn/operator_fusion/graph_transformer/operation.h
index fae1dc7dd1f247..6b1709914638d8 100644
--- a/paddle/cinn/operator_fusion/graph_transformer/operation.h
+++ b/paddle/cinn/operator_fusion/graph_transformer/operation.h
@@ -21,9 +21,7 @@ namespace cinn::fusion {
 // Operation
 
 struct MergeReduceTreeOperation {
-  template <typename Phrase>
-  PatternNodePtr<Phrase> operator()(PatternGraph<Phrase>* graph,
-                                    PatternNodePtr<Phrase> node) {
+  PatternNodePtr operator()(PatternGraph* graph, PatternNodePtr node) {
     PADDLE_ENFORCE_EQ(
         node->downstream().size(),
         1,
@@ -31,7 +29,7 @@ struct MergeReduceTreeOperation {
             "The downstream of the ReduceTree node should be 1, but got %d.",
             node->downstream().size()));
     auto downstream = node->downstream().at(0);
-    auto merged_node = graph->MergeNode(node, downstream, MergePattern<Phrase>);
+    auto merged_node = graph->MergeNode(node, downstream, MergePattern);
     graph->RemoveNode(downstream);
     graph->RemoveNode(node);
     VLOG(4) << "MergeReduceTreeOperation: \nupstream " << node->DebugStr()
@@ -42,9 +40,7 @@ struct MergeReduceTreeOperation {
 };
 
 struct MergeReduceTreeAndTrivialOperation {
-  template <typename Phrase>
-  PatternNodePtr<Phrase> operator()(PatternGraph<Phrase>* graph,
-                                    PatternNodePtr<Phrase> node) {
+  PatternNodePtr operator()(PatternGraph* graph, PatternNodePtr node) {
     PADDLE_ENFORCE_EQ(
         node->downstream().size(),
         1,
@@ -56,14 +52,14 @@ struct MergeReduceTreeAndTrivialOperation {
                                     .template GetPolicy<RelativeJudgePolicy>()
                                     ->GetFakeReduceIterIdx(node, downstream);
     const auto merge_pattern_fn = [&fake_reduce_iter_idx](
-                                      const StmtPattern<Phrase>& first,
-                                      const StmtPattern<Phrase>& secend) {
-      auto rt_pattern = std::get<ReduceTreePlusTrivialPattern<Phrase>>(
-          MergePattern<Phrase>(first, secend));
+                                      const StmtPattern& first,
+                                      const StmtPattern& secend) {
+      auto rt_pattern =
+          std::get<ReduceTreePlusTrivialPattern>(MergePattern(first, secend));
       rt_pattern.fake_reduce_iter_idx = fake_reduce_iter_idx;
       return rt_pattern;
     };
-    PatternNodePtr<Phrase> merged_node =
+    PatternNodePtr merged_node =
         graph->MergeNode(node, downstream, merge_pattern_fn);
     graph->RemoveNode(downstream);
     graph->RemoveNode(node);
@@ -75,19 +71,15 @@ struct MergeReduceTreeAndTrivialOperation {
 };
 
 struct LiftReduceToReduceTreeOperation {
-  template <typename Phrase>
-  PatternNodePtr<Phrase> operator()(PatternGraph<Phrase>* graph,
-                                    PatternNodePtr<Phrase> node) {
-    const auto& reduce_pattern = ToReducePattern<Phrase>(node->stmt_pattern());
-    node->set_stmt_pattern(ReduceTreePattern<Phrase>({}, reduce_pattern));
+  PatternNodePtr operator()(PatternGraph* graph, PatternNodePtr node) {
+    const auto& reduce_pattern = ToReducePattern(node->stmt_pattern());
+    node->set_stmt_pattern(ReduceTreePattern({}, reduce_pattern));
     return node;
   }
 };
 
 struct MergeTrivialPatternOperation {
-  template <typename Phrase>
-  void operator()(PatternGraph<Phrase>* graph,
-                  PatternNodePtr<Phrase> upstream) {
+  void operator()(PatternGraph* graph, PatternNodePtr upstream) {
     PADDLE_ENFORCE_GE(upstream->downstream().size(),
                       1,
                       phi::errors::PreconditionNotMet(
@@ -95,26 +87,21 @@ struct MergeTrivialPatternOperation {
                           "at least 1 downstream , but got %d.",
                           upstream->downstream().size()));
 
-    std::vector<PatternNodePtr<Phrase>> fusion_candidate =
-        upstream->downstream();
+    std::vector<PatternNodePtr> fusion_candidate = upstream->downstream();
     upstream->ClearDownstream();
 
     for (const auto& downstream : fusion_candidate) {
       bool can_fuse =
-          std::holds_alternative<ReducePattern<Phrase>>(
+          std::holds_alternative<ReducePattern>(downstream->stmt_pattern()) ||
+          std::holds_alternative<TrivialPattern>(downstream->stmt_pattern()) ||
+          std::holds_alternative<ReduceTreePattern>(
               downstream->stmt_pattern()) ||
-          std::holds_alternative<TrivialPattern<Phrase>>(
+          std::holds_alternative<ReduceTreePlusTrivialPattern>(
               downstream->stmt_pattern()) ||
-          std::holds_alternative<ReduceTreePattern<Phrase>>(
-              downstream->stmt_pattern()) ||
-          std::holds_alternative<ReduceTreePlusTrivialPattern<Phrase>>(
-              downstream->stmt_pattern()) ||
-          std::holds_alternative<AnchorPattern<Phrase>>(
-              downstream->stmt_pattern());
+          std::holds_alternative<AnchorPattern>(downstream->stmt_pattern());
 
       if (can_fuse) {
-        auto merged_node =
-            graph->MergeNode(upstream, downstream, MergePattern<Phrase>);
+        auto merged_node = graph->MergeNode(upstream, downstream, MergePattern);
         graph->RemoveNode(downstream);
         VLOG(4) << "Spliting trivial pattern: \nupstream "
                 << upstream->DebugStr() << "\ndownstream "
@@ -131,20 +118,16 @@ struct MergeTrivialPatternOperation {
 };
 
 struct LiftToHorizontalFusionPatternOperation {
-  template <typename Phrase>
-  PatternNodePtr<Phrase> operator()(PatternGraph<Phrase>* graph,
-                                    PatternNodePtr<Phrase> node) {
-    node->set_stmt_pattern(HorizontalFusionPattern<Phrase>(
-        {typename HorizontalFusionPattern<Phrase>::PaddingStmtPattern(
+  PatternNodePtr operator()(PatternGraph* graph, PatternNodePtr node) {
+    node->set_stmt_pattern(HorizontalFusionPattern(
+        {typename HorizontalFusionPattern::PaddingStmtPattern(
             node->stmt_pattern(), {})}));
     return node;
   }
 };
 
 struct LiftToAnchorPatternOperation {
-  template <typename Phrase>
-  PatternNodePtr<Phrase> operator()(PatternGraph<Phrase>* graph,
-                                    PatternNodePtr<Phrase> node) {
+  PatternNodePtr operator()(PatternGraph* graph, PatternNodePtr node) {
     std::vector<pir::Operation*> ops = GetOpsInPattern(node->stmt_pattern());
     // TODO(@wuzhanfei) move sink_op into pattern (currently, part of pattern
     // type has sink and the others not) then, update logic here
@@ -154,19 +137,18 @@ struct LiftToAnchorPatternOperation {
         phi::errors::PreconditionNotMet(
             "Op with multi output value can not lift to AnchorPattern"));
     pir::Value anchor = node->sink_op()->result(0);
-    node->set_stmt_pattern(AnchorPattern<Phrase>(
+    node->set_stmt_pattern(AnchorPattern(
         ops,
         anchor,
-        AnchorState<Phrase>({InitExprPromise(node->stmt_pattern(), anchor)})));
+        AnchorState({InitExprPromise(node->stmt_pattern(), anchor)})));
     return node;
   }
 };
 
 struct FuseUpstreamAnchorOperation {
-  template <typename Phrase>
-  PatternNodePtr<Phrase> operator()(PatternGraph<Phrase>* graph,
-                                    const PatternNodePtr<Phrase>& upstream,
-                                    const PatternNodePtr<Phrase>& downstream) {
+  PatternNodePtr operator()(PatternGraph* graph,
+                            const PatternNodePtr& upstream,
+                            const PatternNodePtr& downstream) {
     auto optional_transform_route =
         graph->policy_manager()
             .template GetPolicy<AnchorSearchPolicy>()
@@ -179,15 +161,15 @@ struct FuseUpstreamAnchorOperation {
     auto transform_route = optional_transform_route.value();
 
     const auto merge_pattern_fn = [transform_route](
-                                      const StmtPattern<Phrase>& source,
-                                      const StmtPattern<Phrase>& destination) {
-      auto new_anchor_pattern = std::get<AnchorPattern<Phrase>>(
-          MergePattern<Phrase>(source, destination));
-      auto transformed_anchor_state = ApplyAnchorTransformRoute<Phrase>(
-          GetAnchorState(std::get<AnchorPattern<Phrase>>(destination)),
+                                      const StmtPattern& source,
+                                      const StmtPattern& destination) {
+      auto new_anchor_pattern =
+          std::get<AnchorPattern>(MergePattern(source, destination));
+      auto transformed_anchor_state = ApplyAnchorTransformRoute(
+          GetAnchorState(std::get<AnchorPattern>(destination)),
           transform_route);
       new_anchor_pattern.anchor_state.update(
-          GetAnchorState(std::get<AnchorPattern<Phrase>>(source)));
+          GetAnchorState(std::get<AnchorPattern>(source)));
       new_anchor_pattern.anchor_state.update(transformed_anchor_state);
       return new_anchor_pattern;
     };
@@ -195,27 +177,21 @@ struct FuseUpstreamAnchorOperation {
     auto merged_node = graph->MergeNode(upstream, downstream, merge_pattern_fn);
     graph->RemoveNode(upstream);
     graph->RemoveNode(downstream);
-    VLOG(4) << "upstream anchor: "
-            << std::get<AnchorPattern<Phrase>>(upstream->stmt_pattern())
-                   .anchor()
-                   .impl()
-            << ", downstream anchor: "
-            << std::get<AnchorPattern<Phrase>>(downstream->stmt_pattern())
-                   .anchor()
-                   .impl()
-            << ", merged node anchor: "
-            << std::get<AnchorPattern<Phrase>>(merged_node->stmt_pattern())
-                   .anchor()
-                   .impl();
+    VLOG(4)
+        << "upstream anchor: "
+        << std::get<AnchorPattern>(upstream->stmt_pattern()).anchor().impl()
+        << ", downstream anchor: "
+        << std::get<AnchorPattern>(downstream->stmt_pattern()).anchor().impl()
+        << ", merged node anchor: "
+        << std::get<AnchorPattern>(merged_node->stmt_pattern()).anchor().impl();
     return merged_node;
   }
 };
 
 struct FuseDownstreamAnchorOperation {
-  template <typename Phrase>
-  PatternNodePtr<Phrase> operator()(PatternGraph<Phrase>* graph,
-                                    const PatternNodePtr<Phrase>& upstream,
-                                    const PatternNodePtr<Phrase>& downstream) {
+  PatternNodePtr operator()(PatternGraph* graph,
+                            const PatternNodePtr& upstream,
+                            const PatternNodePtr& downstream) {
     auto optional_transform_route =
         graph->policy_manager()
             .template GetPolicy<AnchorSearchPolicy>()
@@ -229,15 +205,15 @@ struct FuseDownstreamAnchorOperation {
     auto transform_route = optional_transform_route.value();
 
     const auto merge_pattern_fn = [transform_route](
-                                      const StmtPattern<Phrase>& destination,
-                                      const StmtPattern<Phrase>& source) {
-      auto new_anchor_pattern = std::get<AnchorPattern<Phrase>>(
-          MergePattern<Phrase>(source, destination));
-      auto transformed_anchor_state = ApplyAnchorTransformRoute<Phrase>(
-          GetAnchorState(std::get<AnchorPattern<Phrase>>(destination)),
+                                      const StmtPattern& destination,
+                                      const StmtPattern& source) {
+      auto new_anchor_pattern =
+          std::get<AnchorPattern>(MergePattern(source, destination));
+      auto transformed_anchor_state = ApplyAnchorTransformRoute(
+          GetAnchorState(std::get<AnchorPattern>(destination)),
           transform_route);
       new_anchor_pattern.anchor_state.update(
-          GetAnchorState(std::get<AnchorPattern<Phrase>>(source)));
+          GetAnchorState(std::get<AnchorPattern>(source)));
       new_anchor_pattern.anchor_state.update(transformed_anchor_state);
       return new_anchor_pattern;
     };
@@ -245,54 +221,46 @@ struct FuseDownstreamAnchorOperation {
     auto merged_node = graph->MergeNode(upstream, downstream, merge_pattern_fn);
     graph->RemoveNode(upstream);
     graph->RemoveNode(downstream);
-    VLOG(4) << "upstream anchor: "
-            << std::get<AnchorPattern<Phrase>>(upstream->stmt_pattern())
-                   .anchor()
-                   .impl()
-            << ", downstream anchor: "
-            << std::get<AnchorPattern<Phrase>>(downstream->stmt_pattern())
-                   .anchor()
-                   .impl()
-            << ", merged node anchor: "
-            << std::get<AnchorPattern<Phrase>>(merged_node->stmt_pattern())
-                   .anchor()
-                   .impl();
+    VLOG(4)
+        << "upstream anchor: "
+        << std::get<AnchorPattern>(upstream->stmt_pattern()).anchor().impl()
+        << ", downstream anchor: "
+        << std::get<AnchorPattern>(downstream->stmt_pattern()).anchor().impl()
+        << ", merged node anchor: "
+        << std::get<AnchorPattern>(merged_node->stmt_pattern()).anchor().impl();
     return merged_node;
   }
 };
 
 struct SplitRecomputeOperation {
-  template <typename Phrase>
-  void operator()(PatternGraph<Phrase>* graph,
-                  PatternNodePtr<Phrase> upstream) {
+  void operator()(PatternGraph* graph, PatternNodePtr upstream) {
     upstream->set_stmt_pattern(RecoverAnchorPatternToTrivial(
-        std::get<AnchorPattern<Phrase>>(upstream->stmt_pattern())));
+        std::get<AnchorPattern>(upstream->stmt_pattern())));
 
     MergeTrivialPatternOperation()(graph, upstream);
   }
 };
 
 struct HorizontalFusionOperation {
-  template <typename Phrase>
-  PatternNodePtr<Phrase> operator()(PatternGraph<Phrase>* graph,
-                                    const PatternNodePtr<Phrase>& i,
-                                    const PatternNodePtr<Phrase>& j) {
+  PatternNodePtr operator()(PatternGraph* graph,
+                            const PatternNodePtr& i,
+                            const PatternNodePtr& j) {
     VLOG(4) << "Start HorizontalFusionOperation";
     PADDLE_ENFORCE_EQ(
         GetPatternName(i->stmt_pattern()),
-        HorizontalFusionPattern<Phrase>::name(),
+        HorizontalFusionPattern::name(),
         phi::errors::PreconditionNotMet(
             "The pattern of the first node should be HorizontalFusionPattern, "
             "but got %s.",
             GetPatternName(i->stmt_pattern())));
     PADDLE_ENFORCE_EQ(
         GetPatternName(j->stmt_pattern()),
-        HorizontalFusionPattern<Phrase>::name(),
+        HorizontalFusionPattern::name(),
         phi::errors::PreconditionNotMet(
             "The pattern of the second node should be HorizontalFusionPattern, "
             "but got %s.",
             GetPatternName(j->stmt_pattern())));
-    auto merged_node = graph->MergeNode(i, j, MergePattern<Phrase>);
+    auto merged_node = graph->MergeNode(i, j, MergePattern);
     VLOG(4) << "MergeHorizontalPattern: \ni " << i->DebugStr() << "\nj "
             << j->DebugStr() << "\nmerged " << merged_node->DebugStr();
     graph->RemoveNode(i);
diff --git a/paddle/cinn/operator_fusion/graph_transformer/search_algorithm.h b/paddle/cinn/operator_fusion/graph_transformer/search_algorithm.h
index e896f24b086ff8..910c5c8a9b0399 100644
--- a/paddle/cinn/operator_fusion/graph_transformer/search_algorithm.h
+++ b/paddle/cinn/operator_fusion/graph_transformer/search_algorithm.h
@@ -23,24 +23,21 @@ struct GraphPattern {};     // not implemented.
 struct NodePairPattern {};  // not implemented.
 struct ReverseTopoNodePairPattern {};
 
-template <typename Kind,
-          typename Phrase,
-          typename GraphMatcher,
-          typename GraphOperation>
+template <typename Kind, typename GraphMatcher, typename GraphOperation>
 struct SearchAlgorithm {};
 
-template <typename Phrase, typename GraphMatcher, typename GraphOperation>
-struct SearchAlgorithm<NodePattern, Phrase, GraphMatcher, GraphOperation> {
-  PatternGraph<Phrase>* graph_;
-  PatternNodePtrSet<Phrase> visited_nodes;
+template <typename GraphMatcher, typename GraphOperation>
+struct SearchAlgorithm<NodePattern, GraphMatcher, GraphOperation> {
+  PatternGraph* graph_;
+  PatternNodePtrSet visited_nodes;
 
-  explicit SearchAlgorithm(PatternGraph<Phrase>* graph) {
+  explicit SearchAlgorithm(PatternGraph* graph) {
     VLOG(4) << "Create NodePattern algorithm.";
     graph_ = graph;
   }
 
-  PatternNodePtr<Phrase> FindMatchedNode() {
-    for (PatternNodePtr<Phrase> iter_node : graph_->all_pattern_nodes()) {
+  PatternNodePtr FindMatchedNode() {
+    for (PatternNodePtr iter_node : graph_->all_pattern_nodes()) {
       if (GraphMatcher()(*graph_, iter_node) &&
           !visited_nodes.count(iter_node)) {
         visited_nodes.insert(iter_node);
@@ -54,7 +51,7 @@ struct SearchAlgorithm<NodePattern, Phrase, GraphMatcher, GraphOperation> {
 
   void operator()() {
     while (true) {
-      PatternNodePtr<Phrase> node = FindMatchedNode();
+      PatternNodePtr node = FindMatchedNode();
       if (node == nullptr) {
         break;
       }
@@ -63,19 +60,17 @@ struct SearchAlgorithm<NodePattern, Phrase, GraphMatcher, GraphOperation> {
   }
 };
 
-template <typename Phrase, typename GraphMatcher, typename GraphOperation>
-struct SearchAlgorithm<NodePairPattern, Phrase, GraphMatcher, GraphOperation> {
-  PatternGraph<Phrase>* graph_;
-  std::set<std::pair<PatternNodePtr<Phrase>, PatternNodePtr<Phrase>>>
-      visited_node_pair;
-  explicit SearchAlgorithm(PatternGraph<Phrase>* graph) {
+template <typename GraphMatcher, typename GraphOperation>
+struct SearchAlgorithm<NodePairPattern, GraphMatcher, GraphOperation> {
+  PatternGraph* graph_;
+  std::set<std::pair<PatternNodePtr, PatternNodePtr>> visited_node_pair;
+  explicit SearchAlgorithm(PatternGraph* graph) {
     VLOG(4) << "Create NodePairPattern algorithm.";
     graph_ = graph;
   }
-  std::optional<std::pair<PatternNodePtr<Phrase>, PatternNodePtr<Phrase>>>
-  FindMatchedPair() {
-    for (PatternNodePtr<Phrase> i : graph_->all_pattern_nodes()) {
-      for (PatternNodePtr<Phrase> j : graph_->all_pattern_nodes()) {
+  std::optional<std::pair<PatternNodePtr, PatternNodePtr>> FindMatchedPair() {
+    for (PatternNodePtr i : graph_->all_pattern_nodes()) {
+      for (PatternNodePtr j : graph_->all_pattern_nodes()) {
         if (i == j) continue;
         const auto& pair = std::make_pair(i, j);
         if (GraphMatcher()(*graph_, i, j) && !visited_node_pair.count(pair)) {
@@ -98,16 +93,15 @@ struct SearchAlgorithm<NodePairPattern, Phrase, GraphMatcher, GraphOperation> {
   }
 };
 
-template <typename Phrase, typename GraphMatcher, typename GraphOperation>
+template <typename GraphMatcher, typename GraphOperation>
 struct SearchAlgorithm<ReverseTopoNodePairPattern,
-                       Phrase,
                        GraphMatcher,
                        GraphOperation> {
-  PatternGraph<Phrase>* graph_;
-  std::queue<PatternNodePtr<Phrase>> reverse_topo_queue;
-  std::unordered_map<PatternNodePtr<Phrase>, int> degree;
+  PatternGraph* graph_;
+  std::queue<PatternNodePtr> reverse_topo_queue;
+  std::unordered_map<PatternNodePtr, int> degree;
 
-  explicit SearchAlgorithm(PatternGraph<Phrase>* graph) {
+  explicit SearchAlgorithm(PatternGraph* graph) {
     VLOG(4) << "Create ReverseTopoNodePairPattern algorithm.";
     graph_ = graph;
     for (const auto& node : graph_->all_pattern_nodes()) {
@@ -120,7 +114,7 @@ struct SearchAlgorithm<ReverseTopoNodePairPattern,
 
   void operator()() {
     while (!reverse_topo_queue.empty()) {
-      PatternNodePtr<Phrase> node = reverse_topo_queue.front();
+      PatternNodePtr node = reverse_topo_queue.front();
       reverse_topo_queue.pop();
 
       for (const auto& upstream : node->upstream()) {
@@ -140,14 +134,10 @@ struct SearchAlgorithm<ReverseTopoNodePairPattern,
   }
 };
 
-template <typename Kind,
-          typename Phrase,
-          typename GraphMatcher,
-          typename GraphOperation>
-void GraphTransformer(PatternGraph<Phrase>* graph) {
+template <typename Kind, typename GraphMatcher, typename GraphOperation>
+void GraphTransformer(PatternGraph* graph) {
   VLOG(4) << "Start GraphTransformer...";
-  auto alog =
-      SearchAlgorithm<Kind, Phrase, GraphMatcher, GraphOperation>(graph);
+  auto alog = SearchAlgorithm<Kind, GraphMatcher, GraphOperation>(graph);
   alog();
 }
 
diff --git a/paddle/cinn/operator_fusion/group_cluster.h b/paddle/cinn/operator_fusion/group_cluster.h
index 2b848c97df1bbf..8648d3684c7ac9 100644
--- a/paddle/cinn/operator_fusion/group_cluster.h
+++ b/paddle/cinn/operator_fusion/group_cluster.h
@@ -23,12 +23,11 @@
 
 namespace cinn::fusion {
 
-template <typename T>
-inline std::vector<fusion::PatternNodePtr<T>> ClusterOps(
-    const std::vector<fusion::PatternContent<T>>& contents,
+inline std::vector<fusion::PatternNodePtr> ClusterOps(
+    const std::vector<fusion::PatternContent>& contents,
     const std::vector<pir::Value>& output_values) {
-  std::function<pir::Operation*(fusion::PatternContent<T>)> func =
-      [](const fusion::PatternContent<T>& content) { return content.op; };
+  std::function<pir::Operation*(fusion::PatternContent)> func =
+      [](const fusion::PatternContent& content) { return content.op; };
   const auto& origin_ops = fusion::MapVector(contents, func);
   CHECK_GT(origin_ops.size(), 0);
   VLOG(4) << "Start Cluster Ops!";
@@ -51,7 +50,7 @@ inline std::vector<fusion::PatternNodePtr<T>> ClusterOps(
   }();
 
   const auto& content_without_yield =
-      FilterVector(contents, [](const fusion::PatternContent<T>& content) {
+      FilterVector(contents, [](const fusion::PatternContent& content) {
         return content.op->name() != "cf.yield";
       });
 
@@ -61,22 +60,22 @@ inline std::vector<fusion::PatternNodePtr<T>> ClusterOps(
 
   VLOG(4) << "Start Create Policies and PolicyManager!";
   const auto& relative_judge_policy =
-      std::make_shared<fusion::RelativeJudgePolicy<T>>(ops, shape_analysis);
+      std::make_shared<fusion::RelativeJudgePolicy>(ops, shape_analysis);
 
   const auto& general_topo_policy =
-      std::make_shared<fusion::GeneralTopoPolicy<T>>();
+      std::make_shared<fusion::GeneralTopoPolicy>();
 
   const auto& anchor_search_policy =
-      std::make_shared<fusion::AnchorSearchPolicy<T>>();
+      std::make_shared<fusion::AnchorSearchPolicy>();
 
-  fusion::PolicyManager<T> policy_manager;
+  fusion::PolicyManager policy_manager;
 
   policy_manager.SetPolicy(relative_judge_policy);
   policy_manager.SetPolicy(general_topo_policy);
   policy_manager.SetPolicy(anchor_search_policy);
 
   VLOG(4) << "Start Create PatternGraph";
-  fusion::PatternGraph<T> graph(content_without_yield, outputs, policy_manager);
+  fusion::PatternGraph graph(content_without_yield, outputs, policy_manager);
   auto result = graph.ClusterOps();
 
   VLOG(4) << "End Cluster Ops! result size:" << result.size();
diff --git a/paddle/cinn/operator_fusion/pattern.h b/paddle/cinn/operator_fusion/pattern.h
index cf85375a2713fd..9966c06191e7d3 100644
--- a/paddle/cinn/operator_fusion/pattern.h
+++ b/paddle/cinn/operator_fusion/pattern.h
@@ -24,21 +24,65 @@
 
 namespace cinn::fusion {
 
-template <typename T>
-struct PatternContent {};
+struct PatternContent {
+  explicit PatternContent(pir::Operation* op) : op(op) {}
+  pir::Operation* op;
+  bool operator==(const PatternContent& other) const { return op == other.op; }
+};
 
-template <typename T>
-class TrivialPattern {};
+struct StmtPattern;
+struct FusionTracker;
 
-template <typename T>
-class ReducePattern {};
+struct TrivialPattern {
+  explicit TrivialPattern(const std::vector<pir::Operation*>& ops,
+                          pir::Operation* sink_op,
+                          const FusionTracker& tracker)
+      : ops_(ops), sink_op_(sink_op), tracker_(tracker) {
+    name_ = UniqueName();
+  }
+  std::vector<pir::Operation*> ops_;
+  pir::Operation* sink_op_;
+  std::vector<pir::Operation*> ops() const { return ops_; }
+  pir::Operation* sink_op() const { return sink_op_; }
+
+  static std::string UniqueName() {
+    static std::atomic<int64_t> counter = 0;
+    counter += 1;
+    return "T_" + std::to_string(counter);
+  }
+  std::string name() { return name_; }
+  std::string name_;
+  FusionTracker tracker_;
+};
+
+struct ReducePattern {
+  explicit ReducePattern(const std::vector<pir::Operation*>& ops,
+                         const FusionTracker& tracker)
+      : ops_(ops), tracker_(tracker) {
+    name_ = UniqueName();
+  }
+  std::vector<pir::Operation*> ops_;
+  std::vector<pir::Operation*> ops() const { return ops_; }
+  pir::Operation* GetReduceOp() const { return ops_.back(); }
+
+  static std::string UniqueName() {
+    static std::atomic<int64_t> counter = 0;
+    counter += 1;
+    return "T_" + std::to_string(counter);
+  }
+  std::string name() { return name_; }
+  std::string name_;
+  FusionTracker tracker_;
+};
 
-template <typename T>
 struct ReduceTreePattern {
-  explicit ReduceTreePattern(const std::vector<ReduceTreePattern<T>>& childs,
-                             const ReducePattern<T>& root)
-      : childs_(childs), root_(root) {}
-  const ReducePattern<T>& GetRootPattern() const { return root_; }
+  explicit ReduceTreePattern(const std::vector<ReduceTreePattern>& childs,
+                             const ReducePattern& root,
+                             const FusionTracker& tracker)
+      : childs_(childs), root_(root), tracker_(tracker) {
+    name_ = UniqueName();
+  }
+  const ReducePattern& GetRootPattern() const { return root_; }
   std::vector<pir::Operation*> ops() const {
     std::vector<pir::Operation*> result{root_.ops()};
     for (const auto& child : childs_) {
@@ -46,78 +90,68 @@ struct ReduceTreePattern {
     }
     return result;
   }
-  static std::string name() { return "ReduceTree"; }
-  const std::vector<ReduceTreePattern<T>>& childs() const { return childs_; }
-  std::vector<ReduceTreePattern<T>>& childs() { return childs_; }
-  void InsertChild(const ReduceTreePattern<T>& child) {
-    childs_.push_back(child);
-  }
-  std::vector<ReducePattern<T>> FlattenReducePattern() const {
-    std::vector<ReducePattern<T>> result;
+  const std::vector<ReduceTreePattern>& childs() const { return childs_; }
+  std::vector<ReduceTreePattern>& childs() { return childs_; }
+  void InsertChild(const ReduceTreePattern& child) { childs_.push_back(child); }
+  std::vector<ReducePattern> FlattenReducePattern() const {
+    std::vector<ReducePattern> result;
     for (const auto& child : childs_) {
       result = ConcatVector(result, child.FlattenReducePattern());
     }
     return result;
   }
 
+  static std::string UniqueName() {
+    static std::atomic<int64_t> counter = 0;
+    counter += 1;
+    return "RTree_" + std::to_string(counter);
+  }
+  std::string name() { return name_; }
+  std::string name_;
+  FusionTracker tracker_;
+
  private:
-  std::vector<ReduceTreePattern<T>> childs_;
-  ReducePattern<T> root_;
+  std::vector<ReduceTreePattern> childs_;
+  ReducePattern root_;
 };
 
-template <typename T>
 struct ReduceTreePlusTrivialPattern {
-  explicit ReduceTreePlusTrivialPattern(const ReduceTreePattern<T>& tree,
-                                        const TrivialPattern<T>& sink_trivial)
-      : tree(tree), sink_trivial(sink_trivial) {}
-  ReduceTreePattern<T> tree;
-  TrivialPattern<T> sink_trivial;
+  explicit ReduceTreePlusTrivialPattern(const ReduceTreePattern& tree,
+                                        const TrivialPattern& sink_trivial,
+                                        const FusionTracker& tracker)
+      : tree(tree), sink_trivial(sink_trivial), tracker_(tracker) {
+    name_ = UniqueName();
+  }
+  ReduceTreePattern tree;
+  TrivialPattern sink_trivial;
   std::vector<pir::Operation*> ops() const {
     return UniqueConcatVector(tree.ops(), sink_trivial.ops());
   }
-  static std::string name() { return "ReduceTree+Trivial"; }
   std::vector<size_t> fake_reduce_iter_idx;
-};
 
-template <typename T>
-struct StmtPattern;
-
-template <typename T>
-struct UnsupportPattern {};
-
-template <typename T>
-struct HorizontalFusionPattern {
-  struct PaddingStmtPattern {
-    StmtPattern<T> pattern;
-    std::vector<int> padding_pos;
-    PaddingStmtPattern(const StmtPattern<T>& pattern,
-                       const std::vector<int>& padding_pos)
-        : pattern(pattern), padding_pos(padding_pos) {}
-  };
-  explicit HorizontalFusionPattern(
-      const std::vector<PaddingStmtPattern>& patterns)
-      : padding_patterns_(patterns) {}
-  std::vector<PaddingStmtPattern> padding_patterns_;
-  std::vector<pir::Operation*> ops() const {
-    std::vector<pir::Operation*> result;
-    for (const auto& pattern : padding_patterns_) {
-      auto ops = GetOpsInPattern(pattern.pattern);
-      ExtendVector(&result, ops);
-    }
-    return result;
+  static std::string UniqueName() {
+    static std::atomic<int64_t> counter = 0;
+    counter += 1;
+    return "RTreeT_" + std::to_string(counter);
   }
-  static std::string name() { return "HorizontalFusionPattern"; }
+  std::string name() { return name_; }
+  std::string name_;
+  FusionTracker tracker_;
 };
 
-template <typename T>
 struct AnchorPattern {
   explicit AnchorPattern(const std::vector<pir::Operation*>& ops,
                          const pir::Value& anchor,
-                         const AnchorState<T>& init_anchor_state)
-      : ops_(ops), anchor_(anchor), anchor_state(init_anchor_state) {}
-  AnchorState<T> anchor_state;
+                         const AnchorState& init_anchor_state,
+                         const FusionTracker& tracker)
+      : ops_(ops),
+        anchor_(anchor),
+        anchor_state(init_anchor_state),
+        tracker_(tracker) {
+    name_ = UniqueName();
+  }
+  AnchorState anchor_state;
 
-  static std::string name() { return "AnchorPattern"; }
   std::vector<pir::Operation*> ops() const { return ops_; }
   pir::Value anchor() const { return anchor_; }
   bool can_recompute() const {
@@ -141,25 +175,84 @@ struct AnchorPattern {
     return true;
   }
 
+  static std::string UniqueName() {
+    static std::atomic<int64_t> counter = 0;
+    counter += 1;
+    return "Anchor_" + std::to_string(counter);
+  }
+  std::string name() { return name_; }
+  std::string name_;
+  FusionTracker tracker_;
+
  private:
   std::vector<pir::Operation*> ops_;
   pir::Value anchor_;  // Choose only one anchor
 };
 
-template <typename T>
-using StmtPatternBase = std::variant<TrivialPattern<T>,
-                                     ReducePattern<T>,
-                                     ReduceTreePattern<T>,
-                                     ReduceTreePlusTrivialPattern<T>,
-                                     HorizontalFusionPattern<T>,
-                                     UnsupportPattern<T>,
-                                     AnchorPattern<T>>;
-
-template <typename T>
-struct StmtPattern final : public StmtPatternBase<T> {
-  using StmtPatternBase<T>::StmtPatternBase;
-  const StmtPatternBase<T>& variant() const {
-    return static_cast<const StmtPatternBase<T>&>(*this);
+struct HorizontalFusionPattern {
+  struct PaddingStmtPattern {
+    StmtPattern pattern;
+    std::vector<int> padding_pos;
+    PaddingStmtPattern(const StmtPattern& pattern,
+                       const std::vector<int>& padding_pos)
+        : pattern(pattern), padding_pos(padding_pos), tracker_(tracker) {}
+  };
+  explicit HorizontalFusionPattern(
+      const std::vector<PaddingStmtPattern>& patterns,
+      const FusionTracker& tracker)
+      : padding_patterns_(patterns) {
+    name_ = UniqueName();
+  }
+  std::vector<PaddingStmtPattern> padding_patterns_;
+  std::vector<pir::Operation*> ops() const {
+    std::vector<pir::Operation*> result;
+    for (const auto& pattern : padding_patterns_) {
+      auto ops = GetOpsInPattern(pattern.pattern);
+      ExtendVector(&result, ops);
+    }
+    return result;
+  }
+
+  static std::string UniqueName() {
+    static std::atomic<int64_t> counter = 0;
+    counter += 1;
+    return "Horizontal_" + std::to_string(counter);
+  }
+  std::string name() { return name_; }
+  std::string name_;
+  FusionTracker tracker_;
+};
+
+struct UnsupportPattern {
+  explicit UnsupportPattern(const std::vector<pir::Operation*>& ops,
+                            const FusionTracker& tracker)
+      : ops_(ops), tracker_(tracker) {
+    name_ = UniqueName();
+  }
+  std::vector<pir::Operation*> ops_;
+  std::vector<pir::Operation*> ops() const { return ops_; }
+  static std::string UniqueName() {
+    static std::atomic<int64_t> counter = 0;
+    counter += 1;
+    return "Unsupport_" + std::to_string(counter);
+  }
+  std::string name() { return name_; }
+  std::string name_;
+  FusionTracker tracker_;
+};
+
+using StmtPatternBase = std::variant<TrivialPattern,
+                                     ReducePattern,
+                                     ReduceTreePattern,
+                                     ReduceTreePlusTrivialPattern,
+                                     HorizontalFusionPattern,
+                                     UnsupportPattern,
+                                     AnchorPattern>;
+
+struct StmtPattern final : public StmtPatternBase {
+  using StmtPatternBase::StmtPatternBase;
+  const StmtPatternBase& variant() const {
+    return static_cast<const StmtPatternBase&>(*this);
   }
 };
 
diff --git a/paddle/cinn/operator_fusion/pattern_fuser.cc b/paddle/cinn/operator_fusion/pattern_fuser.cc
new file mode 100644
index 00000000000000..bbcb54798f141e
--- /dev/null
+++ b/paddle/cinn/operator_fusion/pattern_fuser.cc
@@ -0,0 +1,91 @@
+// Copyright (c) 2024 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/cinn/operator_fusion/pattern_fuser.h"
+
+namespace cinn::fusion {
+
+StmtPattern ConvertToStmtPattern(const PatternContent& content) {
+  const auto& kind = GetOpPatternKind(content.op);
+  if (kind == hlir::framework::kReduction) {
+    return ReducePattern({content.op});
+  } else if (kind == hlir::framework::kElementWise ||
+             kind == hlir::framework::kBroadcast ||
+             kind == hlir::framework::kInjective) {
+    return TrivialPattern({content.op}, content.op);
+  } else {
+    return UnsupportPattern({content.op});
+  }
+}
+
+StmtPattern MergePatternImpl(const ReduceTreePattern& first,
+                             const TrivialPattern& second) {
+  return ReduceTreePlusTrivialPattern(first, second);
+}
+
+StmtPattern MergePatternImpl(const TrivialPattern& first,
+                             const ReducePattern& second) {
+  const auto& contents =
+      UniqueConcatVector(GetOpsInPattern(first), GetOpsInPattern(second));
+  return ReducePattern(contents);
+}
+
+StmtPattern MergePatternImpl(const TrivialPattern& first,
+                             const TrivialPattern& second) {
+  const auto& contents =
+      UniqueConcatVector(GetOpsInPattern(first), GetOpsInPattern(second));
+  return TrivialPattern(contents, second.sink_op());
+}
+
+StmtPattern MergePatternImpl(const TrivialPattern& first,
+                             const AnchorPattern& second) {
+  return AnchorPattern(
+      UniqueConcatVector(GetOpsInPattern(first), GetOpsInPattern(second)),
+      second.anchor(),
+      second.anchor_state);
+}
+
+StmtPattern MergePatternImpl(const AnchorPattern& source,
+                             const AnchorPattern& dest) {
+  const auto& contents =
+      UniqueConcatVector(GetOpsInPattern(source), GetOpsInPattern(dest));
+  return AnchorPattern(contents, source.anchor(), AnchorState({}));
+}
+
+ExprPromise InitExprPromiseImpl(const TrivialPattern& pattern,
+                                pir::Value anchor) {
+  return ExprPromise(anchor);
+}
+
+ExprPromise InitExprPromiseImpl(const ReducePattern& pattern,
+                                pir::Value anchor) {
+  return ExprPromise(anchor);
+}
+
+TrivialPattern RecoverAnchorPatternToTrivial(
+    const AnchorPattern& anchor_pattern) {
+  PADDLE_ENFORCE_EQ(anchor_pattern.anchor_state.promise.size(),
+                    1,
+                    phi::errors::PreconditionNotMet(
+                        "Can only recover AnchorPattern whose anchor_state "
+                        "size is 1 (exact %d)",
+                        anchor_pattern.anchor_state.promise.size()));
+
+  return TrivialPattern(anchor_pattern.ops(),
+                        anchor_pattern.anchor().defining_op());
+}
+
+}  // namespace cinn::fusion
diff --git a/paddle/cinn/operator_fusion/pattern_fuser.h b/paddle/cinn/operator_fusion/pattern_fuser.h
index be9911e2f263a9..35a448feb399cc 100644
--- a/paddle/cinn/operator_fusion/pattern_fuser.h
+++ b/paddle/cinn/operator_fusion/pattern_fuser.h
@@ -36,21 +36,17 @@
 
 namespace cinn::fusion {
 
-template <typename T>
-ReducePattern<T> ToReducePattern(const StmtPattern<T>& second) {
-  return std::get<ReducePattern<T>>(second);
+ReducePattern ToReducePattern(const StmtPattern& second) {
+  return std::get<ReducePattern>(second);
 }
 
-template <typename T>
-std::string GetPatternName(const StmtPattern<T>& s) {
+std::string GetPatternName(const StmtPattern& s) {
   return std::visit([](const auto& impl) { return impl.name(); }, s.variant());
 }
 
-template <typename T>
-StmtPattern<T> ConvertToStmtPattern(const PatternContent<T>& content);
+StmtPattern ConvertToStmtPattern(const PatternContent& content);
 
-template <typename T>
-std::vector<pir::Operation*> GetOpsInPattern(const StmtPattern<T>& pattern) {
+std::vector<pir::Operation*> GetOpsInPattern(const StmtPattern& pattern) {
   return std::visit([](const auto& impl) { return impl.ops(); },
                     pattern.variant());
 }
@@ -61,8 +57,7 @@ using LoopFramework = std::vector<symbol::DimExpr>;
 // std::optional will cause SegmentFault, TODO: fix this.
 using MaybeLoopFramework = LoopFramework;
 
-template <typename T>
-MaybeLoopFramework GetLoopFramework(const StmtPattern<T>& pattern);
+MaybeLoopFramework GetLoopFramework(const StmtPattern& pattern);
 
 static MaybeLoopFramework SqueezeLoopFramework(
     const MaybeLoopFramework& loop_framework) {
@@ -77,9 +72,7 @@ static MaybeLoopFramework SqueezeLoopFramework(
   return result;
 }
 
-template <typename T>
-bool IsLoopFrameworkEqual(const StmtPattern<T>& lhs,
-                          const StmtPattern<T>& rhs) {
+bool IsLoopFrameworkEqual(const StmtPattern& lhs, const StmtPattern& rhs) {
   auto lhs_loop = GetLoopFramework(lhs);
   auto rhs_loop = GetLoopFramework(rhs);
   VLOG(4) << "lhs loop range is:" << utils::Join(lhs_loop, ",");
@@ -87,15 +80,13 @@ bool IsLoopFrameworkEqual(const StmtPattern<T>& lhs,
   return SqueezeLoopFramework(lhs_loop) == SqueezeLoopFramework(rhs_loop);
 }
 
-template <typename T>
-pir::Operation* GetSinkOpInPattern(const StmtPattern<T>& pattern) {
+pir::Operation* GetSinkOpInPattern(const StmtPattern& pattern) {
   return std::visit([](const auto& impl) { return impl.sink_op(); },
                     pattern.variant());
 }
 
-template <typename T>
 struct LoopFrameworkVisitor {
-  MaybeLoopFramework operator()(const ReducePattern<T>& pattern) {
+  MaybeLoopFramework operator()(const ReducePattern& pattern) {
     pir::Operation* reduce_op = pattern.GetReduceOp();
     const auto& flatten_loops = GetDimExprsFromValue(reduce_op->result(0));
     const auto& reduce_axes = GetReduceAxisIdx(reduce_op);
@@ -104,21 +95,21 @@ struct LoopFrameworkVisitor {
     return ConcatVector(flatten_loops, reduce_loops);
   }
 
-  MaybeLoopFramework operator()(const ReduceTreePattern<T>& pattern) {
-    return GetLoopFramework(StmtPattern<T>(pattern.GetRootPattern()));
+  MaybeLoopFramework operator()(const ReduceTreePattern& pattern) {
+    return GetLoopFramework(StmtPattern(pattern.GetRootPattern()));
   }
 
-  MaybeLoopFramework operator()(const TrivialPattern<T>& pattern) {
+  MaybeLoopFramework operator()(const TrivialPattern& pattern) {
     pir::Operation* t_op = pattern.sink_op();
     const auto& exprs = GetDimExprsFromValue(t_op->result(0));
     return exprs;
   }
 
-  MaybeLoopFramework operator()(const HorizontalFusionPattern<T>& pattern) {
+  MaybeLoopFramework operator()(const HorizontalFusionPattern& pattern) {
     // Horizontal Fusion must have the same loop framework.
     VLOG(4) << "Get horizontal fusion pattern for loop framework.";
-    const auto& base_exprs = GetLoopFramework(
-        StmtPattern<T>(pattern.padding_patterns_.back().pattern));
+    const auto& base_exprs =
+        GetLoopFramework(StmtPattern(pattern.padding_patterns_.back().pattern));
     const auto& padding_vector = pattern.padding_patterns_.back().padding_pos;
     std::vector<symbol::DimExpr> exprs(
         base_exprs.size() + padding_vector.size(), 1);
@@ -132,17 +123,16 @@ struct LoopFrameworkVisitor {
     return exprs;
   }
 
-  MaybeLoopFramework operator()(
-      const ReduceTreePlusTrivialPattern<T>& pattern) {
+  MaybeLoopFramework operator()(const ReduceTreePlusTrivialPattern& pattern) {
     const auto& sink_trivial = pattern.sink_trivial;
     const auto& trivial_loop =
-        GetLoopFramework(StmtPattern<T>(pattern.sink_trivial));
+        GetLoopFramework(StmtPattern(pattern.sink_trivial));
     if (pattern.fake_reduce_iter_idx.empty()) {
       // we add reduce loop to the end;
       int reduce_axes_len =
           GetReduceAxisIdx(pattern.tree.GetRootPattern().GetReduceOp()).size();
       const auto& reduce_loop =
-          GetLoopFramework(StmtPattern<T>(pattern.tree.GetRootPattern()));
+          GetLoopFramework(StmtPattern(pattern.tree.GetRootPattern()));
       return ConcatVector(
           trivial_loop,
           SliceVector(reduce_loop, -reduce_axes_len, reduce_loop.size()));
@@ -157,49 +147,42 @@ struct LoopFrameworkVisitor {
     }
   }
 
-  MaybeLoopFramework operator()(const UnsupportPattern<T>& pattern) {
+  MaybeLoopFramework operator()(const UnsupportPattern& pattern) {
     PADDLE_ENFORCE(false, "Not support GetLoopRange.");
   }
 
-  MaybeLoopFramework operator()(const AnchorPattern<T>& pattern) {
+  MaybeLoopFramework operator()(const AnchorPattern& pattern) {
     const auto& exprs = GetDimExprsFromValue(pattern.anchor());
     return exprs;
   }
 };
 
-template <typename T>
-MaybeLoopFramework GetLoopFramework(const StmtPattern<T>& pattern) {
-  return std::visit(LoopFrameworkVisitor<T>(), pattern.variant());
+MaybeLoopFramework GetLoopFramework(const StmtPattern& pattern) {
+  return std::visit(LoopFrameworkVisitor(), pattern.variant());
 }
 
-template <typename T>
-bool IsReducePattern(const StmtPattern<T>& pattern) {
-  return std::holds_alternative<ReducePattern<T>>(pattern);
+bool IsReducePattern(const StmtPattern& pattern) {
+  return std::holds_alternative<ReducePattern>(pattern);
 }
 
-template <typename T>
-bool IsReduceTreePattern(const StmtPattern<T>& pattern) {
-  return std::holds_alternative<ReduceTreePattern<T>>(pattern);
+bool IsReduceTreePattern(const StmtPattern& pattern) {
+  return std::holds_alternative<ReduceTreePattern>(pattern);
 }
 
-template <typename T>
-bool IsOpsDependents(const StmtPattern<T>& pattern) {
-  return std::holds_alternative<ReduceTreePattern<T>>(pattern);
+bool IsOpsDependents(const StmtPattern& pattern) {
+  return std::holds_alternative<ReduceTreePattern>(pattern);
 }
 
-template <typename T>
-bool IsUnsupportPattern(const StmtPattern<T>& pattern) {
-  return std::holds_alternative<UnsupportPattern<T>>(pattern);
+bool IsUnsupportPattern(const StmtPattern& pattern) {
+  return std::holds_alternative<UnsupportPattern>(pattern);
 }
 
-template <typename T>
-bool IsReduceTrivialPattern(const StmtPattern<T>& pattern) {
-  return std::holds_alternative<ReduceTreePlusTrivialPattern<T>>(pattern);
+bool IsReduceTrivialPattern(const StmtPattern& pattern) {
+  return std::holds_alternative<ReduceTreePlusTrivialPattern>(pattern);
 }
 
-template <typename T>
 std::unordered_set<pir::Value> GetPatternInputValuesIncludeInner(
-    const StmtPattern<T>& A) {
+    const StmtPattern& A) {
   std::unordered_set<pir::Value> result;
   for (const auto& op : GetOpsInPattern(A)) {
     for (const auto& value : op->operands()) {
@@ -209,9 +192,8 @@ std::unordered_set<pir::Value> GetPatternInputValuesIncludeInner(
   return result;
 }
 
-template <typename T>
 std::unordered_set<pir::Value> GetPatternOutputValuesIncludedInner(
-    const StmtPattern<T>& A) {
+    const StmtPattern& A) {
   std::unordered_set<pir::Value> result;
   for (const auto& op : GetOpsInPattern(A)) {
     for (const auto& value : op->results()) {
@@ -221,8 +203,7 @@ std::unordered_set<pir::Value> GetPatternOutputValuesIncludedInner(
   return result;
 }
 
-template <typename T>
-std::unordered_set<pir::Value> GetPatternInputValues(const StmtPattern<T>& A) {
+std::unordered_set<pir::Value> GetPatternInputValues(const StmtPattern& A) {
   auto all_input_values = GetPatternInputValuesIncludeInner(A);
   for (const auto& value : GetPatternOutputValuesIncludedInner(A)) {
     all_input_values.erase(value);
@@ -231,8 +212,7 @@ std::unordered_set<pir::Value> GetPatternInputValues(const StmtPattern<T>& A) {
   return all_input_values;
 }
 
-template <typename T>
-std::string StmtPatternDebugStr(const StmtPattern<T>& stmt) {
+std::string StmtPatternDebugStr(const StmtPattern& stmt) {
   std::stringstream ss;
   auto all_ops = GetOpsInPattern(stmt);
   ss << "StmtPattern, size " << all_ops.size() << " :\n";
@@ -252,9 +232,8 @@ static bool IsDirectUpstream(const pir::Operation* upstream,
   return false;
 }
 
-template <typename T>
-int InsertDownstreamIntoTree(const ReduceTreePattern<T>& upstream,
-                             ReduceTreePattern<T>& downstream) {  // NOLINT
+int InsertDownstreamIntoTree(const ReduceTreePattern& upstream,
+                             ReduceTreePattern& downstream) {  // NOLINT
   if (IsDirectUpstream(upstream.GetRootPattern().GetReduceOp(),
                        downstream.GetRootPattern().GetReduceOp())) {
     downstream.InsertChild(upstream);
@@ -267,10 +246,9 @@ int InsertDownstreamIntoTree(const ReduceTreePattern<T>& upstream,
   return insert_num;
 }
 
-template <typename T>
-StmtPattern<T> MergePatternImpl(const ReduceTreePattern<T>& upstream,
-                                const ReduceTreePattern<T>& downstream) {
-  ReduceTreePattern<T> result = downstream;  // copy first.
+StmtPattern MergePatternImpl(const ReduceTreePattern& upstream,
+                             const ReduceTreePattern& downstream) {
+  ReduceTreePattern result = downstream;  // copy first.
   int insert_num = InsertDownstreamIntoTree(upstream, result);
   CHECK(insert_num == 1) << "Must insert only once, but insert " << insert_num;
   return result;
@@ -315,17 +293,13 @@ inline auto GetPaddingVector(const MaybeLoopFramework& first,
   return std::tuple(padding_f, padding_s);
 }
 
-template <typename T>
-StmtPattern<T> MergePatternImpl(const HorizontalFusionPattern<T>& first,
-                                const HorizontalFusionPattern<T>& second) {
-  const auto& [f, s] =
-      GetPaddingVector(GetLoopFramework(StmtPattern<T>(first)),
-                       GetLoopFramework(StmtPattern<T>(second)));
-  typename HorizontalFusionPattern<T>::PaddingStmtPattern pad_first = {first,
-                                                                       f};
-  typename HorizontalFusionPattern<T>::PaddingStmtPattern pad_second = {second,
-                                                                        s};
-  return HorizontalFusionPattern<T>({pad_first, pad_second});
+StmtPattern MergePatternImpl(const HorizontalFusionPattern& first,
+                             const HorizontalFusionPattern& second) {
+  const auto& [f, s] = GetPaddingVector(GetLoopFramework(StmtPattern(first)),
+                                        GetLoopFramework(StmtPattern(second)));
+  typename HorizontalFusionPattern::PaddingStmtPattern pad_first = {first, f};
+  typename HorizontalFusionPattern::PaddingStmtPattern pad_second = {second, s};
+  return HorizontalFusionPattern({pad_first, pad_second});
 }
 
 template <typename A, typename B>
@@ -339,88 +313,78 @@ B FusePatternIfConnected(A up_pattern,
   }
 }
 
-template <typename T>
-StmtPattern<T> MergePatternImpl(const ReduceTreePattern<T>& first,
-                                const TrivialPattern<T>& second);
+StmtPattern MergePatternImpl(const ReduceTreePattern& first,
+                             const TrivialPattern& second);
 
-template <typename T>
-StmtPattern<T> MergePatternImpl(const TrivialPattern<T>& first,
-                                const ReducePattern<T>& second);
+StmtPattern MergePatternImpl(const TrivialPattern& first,
+                             const ReducePattern& second);
 
-template <typename T>
-StmtPattern<T> MergePatternImpl(const TrivialPattern<T>& first,
-                                const TrivialPattern<T>& second);
+StmtPattern MergePatternImpl(const TrivialPattern& first,
+                             const TrivialPattern& second);
 
-template <typename T>
-StmtPattern<T> MergePatternImpl(const TrivialPattern<T>& first,
-                                const ReduceTreePattern<T>& second) {
+StmtPattern MergePatternImpl(const TrivialPattern& first,
+                             const ReduceTreePattern& second) {
   auto connect_ops = FindDownstreamOps(first.sink_op());
 
   auto old_childs = second.childs();
-  std::vector<ReduceTreePattern<T>> new_childs;
+  std::vector<ReduceTreePattern> new_childs;
   for (const auto& old_child : old_childs) {
     new_childs.emplace_back(
         FusePatternIfConnected(first, old_child, connect_ops));
   }
 
-  return ReduceTreePattern<T>(
+  return ReduceTreePattern(
       new_childs,
       FusePatternIfConnected(first, second.GetRootPattern(), connect_ops));
 }
 
-template <typename T>
-StmtPattern<T> MergePatternImpl(const TrivialPattern<T>& first,
-                                const ReduceTreePlusTrivialPattern<T>& second) {
+StmtPattern MergePatternImpl(const TrivialPattern& first,
+                             const ReduceTreePlusTrivialPattern& second) {
   auto connect_ops = FindDownstreamOps(first.sink_op());
-  return ReduceTreePlusTrivialPattern<T>(
+  return ReduceTreePlusTrivialPattern(
       FusePatternIfConnected(first, second.tree, connect_ops),
       FusePatternIfConnected(first, second.sink_trivial, connect_ops));
 }
 
-template <typename T>
-StmtPattern<T> MergePatternImpl(const TrivialPattern<T>& first,
-                                const AnchorPattern<T>& second);
+StmtPattern MergePatternImpl(const TrivialPattern& first,
+                             const AnchorPattern& second);
 
-template <typename T>
-StmtPattern<T> MergePatternImpl(const AnchorPattern<T>& source,
-                                const AnchorPattern<T>& dest);
+StmtPattern MergePatternImpl(const AnchorPattern& source,
+                             const AnchorPattern& dest);
 
-template <typename T>
-StmtPattern<T> MergePattern(const StmtPattern<T>& first,
-                            const StmtPattern<T>& second) {
+StmtPattern MergePattern(const StmtPattern& first, const StmtPattern& second) {
   VLOG(4) << "MergePattern: " << GetPatternName(first) << " x "
           << GetPatternName(second);
   const auto PatternMatch = adt::match{
-      [&](const ReduceTreePattern<T>& lhs, const ReduceTreePattern<T>& rhs) {
+      [&](const ReduceTreePattern& lhs, const ReduceTreePattern& rhs) {
         return MergePatternImpl(lhs, rhs);
       },
-      [&](const ReduceTreePattern<T>& lhs, const TrivialPattern<T>& rhs) {
+      [&](const ReduceTreePattern& lhs, const TrivialPattern& rhs) {
         return MergePatternImpl(lhs, rhs);
       },
-      [&](const TrivialPattern<T>& lhs, const ReducePattern<T>& rhs) {
+      [&](const TrivialPattern& lhs, const ReducePattern& rhs) {
         return MergePatternImpl(lhs, rhs);
       },
-      [&](const TrivialPattern<T>& lhs, const TrivialPattern<T>& rhs) {
+      [&](const TrivialPattern& lhs, const TrivialPattern& rhs) {
         return MergePatternImpl(lhs, rhs);
       },
-      [&](const TrivialPattern<T>& lhs, const ReduceTreePattern<T>& rhs) {
+      [&](const TrivialPattern& lhs, const ReduceTreePattern& rhs) {
         return MergePatternImpl(lhs, rhs);
       },
-      [&](const TrivialPattern<T>& lhs,
-          const ReduceTreePlusTrivialPattern<T>& rhs) {
+      [&](const TrivialPattern& lhs, const ReduceTreePlusTrivialPattern& rhs) {
         return MergePatternImpl(lhs, rhs);
       },
-      [&](const TrivialPattern<T>& lhs, const AnchorPattern<T>& rhs) {
+      [&](const TrivialPattern& lhs, const AnchorPattern& rhs) {
         return MergePatternImpl(lhs, rhs);
       },
-      [&](const AnchorPattern<T>& lhs, const AnchorPattern<T>& rhs) {
+      [&](const AnchorPattern& lhs, const AnchorPattern& rhs) {
         return MergePatternImpl(lhs, rhs);
       },
-      [&](const HorizontalFusionPattern<T>& lhs,
-          const HorizontalFusionPattern<T>& rhs) {
+      [&](const HorizontalFusionPattern& lhs,
+          const HorizontalFusionPattern& rhs) {
         return MergePatternImpl(lhs, rhs);
       },
-      [&](const auto& lhs, const auto& rhs) -> StmtPattern<T> {
+      [&](const auto& lhs, const auto& rhs) -> StmtPattern {
         CHECK(false) << "Found not support merge!" << GetPatternName(first)
                      << "X" << GetPatternName(second);
       },
@@ -428,47 +392,38 @@ StmtPattern<T> MergePattern(const StmtPattern<T>& first,
   return std::visit(PatternMatch, first.variant(), second.variant());
 }
 
-template <typename T>
-ExprPromise<T> InitExprPromiseImpl(const TrivialPattern<T>& pattern,
-                                   pir::Value anchor);
+ExprPromise InitExprPromiseImpl(const TrivialPattern& pattern,
+                                pir::Value anchor);
 
-template <typename T>
-ExprPromise<T> InitExprPromiseImpl(const ReducePattern<T>& pattern,
-                                   pir::Value anchor);
+ExprPromise InitExprPromiseImpl(const ReducePattern& pattern,
+                                pir::Value anchor);
 
-template <typename T>
-ExprPromise<T> InitExprPromiseImpl(const ReduceTreePattern<T>& pattern,
-                                   pir::Value anchor) {
+ExprPromise InitExprPromiseImpl(const ReduceTreePattern& pattern,
+                                pir::Value anchor) {
   return InitExprPromiseImpl(pattern.GetRootPattern(), anchor);
 }
 
 template <typename T, template <typename> typename PATTERN>
-ExprPromise<T> InitExprPromiseImpl(const PATTERN<T>& pattern,
-                                   pir::Value anchor) {
+ExprPromise InitExprPromiseImpl(const PATTERN& pattern, pir::Value anchor) {
   PADDLE_THROW("Can not Init ExprPromise");
 }
 
-template <typename T>
-ExprPromise<T> InitExprPromise(const StmtPattern<T>& pattern,
-                               pir::Value anchor) {
+ExprPromise InitExprPromise(const StmtPattern& pattern, pir::Value anchor) {
   return std::visit(
       [anchor](const auto& arg) { return InitExprPromiseImpl(arg, anchor); },
       pattern.variant());
 }
 
-template <typename T>
-TrivialPattern<T> RecoverAnchorPatternToTrivial(
-    const AnchorPattern<T>& anchor_pattern);
+TrivialPattern RecoverAnchorPatternToTrivial(
+    const AnchorPattern& anchor_pattern);
 
-template <typename T>
-AnchorState<T> GetAnchorState(const AnchorPattern<T>& pattern) {
+AnchorState GetAnchorState(const AnchorPattern& pattern) {
   return pattern.anchor_state;
 }
 
-template <typename T>
-AnchorState<T> ApplyAnchorTransformRoute(const AnchorState<T>& anchor_state,
-                                         const AnchorTransformRoute& route) {
-  AnchorState<T> result = anchor_state;
+AnchorState ApplyAnchorTransformRoute(const AnchorState& anchor_state,
+                                      const AnchorTransformRoute& route) {
+  AnchorState result = anchor_state;
   for (auto promise : result.promise) {
     promise.update(route);
   }
diff --git a/paddle/cinn/operator_fusion/pattern_graph.cc b/paddle/cinn/operator_fusion/pattern_graph.cc
index 394eabb58f85ff..0cf3f788f20cca 100644
--- a/paddle/cinn/operator_fusion/pattern_graph.cc
+++ b/paddle/cinn/operator_fusion/pattern_graph.cc
@@ -24,8 +24,7 @@
 
 namespace cinn::fusion {
 
-template <typename T>
-std::vector<PatternNodePtr<T>> PatternGraph<T>::ClusterOps() {
+std::vector<PatternNodePtr> PatternGraph::ClusterOps() {
   VLOG(4) << "[Group Cluster] Initial Condition: " << GraphInfo();
 
   VLOG(4) << "[Group Cluster] Start SinkTrivialPattern";
@@ -70,12 +69,11 @@ std::vector<PatternNodePtr<T>> PatternGraph<T>::ClusterOps() {
   return SortByTopoOrder();
 }
 
-template <typename T>
-std::vector<PatternNodePtr<T>> PatternGraph<T>::SortByTopoOrder() {
+std::vector<PatternNodePtr> PatternGraph::SortByTopoOrder() {
   // sort all_pattern_nodes_ by topo order.
-  std::vector<PatternNodePtr<T>> res;
-  std::list<PatternNodePtr<T>> topo_queue;
-  std::map<PatternNodePtr<T>, int> degree;
+  std::vector<PatternNodePtr> res;
+  std::list<PatternNodePtr> topo_queue;
+  std::map<PatternNodePtr, int> degree;
   for (const auto& node : all_pattern_nodes_) {
     degree[node] = node->upstream().size();
     if (degree[node] == 0) {
@@ -83,7 +81,7 @@ std::vector<PatternNodePtr<T>> PatternGraph<T>::SortByTopoOrder() {
     }
   }
   while (!topo_queue.empty()) {
-    PatternNodePtr<T> node = topo_queue.front();
+    PatternNodePtr node = topo_queue.front();
     topo_queue.pop_front();
     res.push_back(node);
     for (const auto& downstream_op : node->downstream()) {
@@ -96,12 +94,11 @@ std::vector<PatternNodePtr<T>> PatternGraph<T>::SortByTopoOrder() {
   return res;
 }
 
-template <typename T>
-std::vector<PatternNodePtr<T>> PatternGraph<T>::SortByReverseTopoOrder() {
+std::vector<PatternNodePtr> PatternGraph::SortByReverseTopoOrder() {
   // sort all_pattern_nodes_ by reverse topo order.
-  std::vector<PatternNodePtr<T>> res;
-  std::list<PatternNodePtr<T>> reverse_topo_queue;
-  std::map<PatternNodePtr<T>, int> degree;
+  std::vector<PatternNodePtr> res;
+  std::list<PatternNodePtr> reverse_topo_queue;
+  std::map<PatternNodePtr, int> degree;
 
   for (const auto& node : all_pattern_nodes_) {
     degree[node] = node->downstream().size();
@@ -111,7 +108,7 @@ std::vector<PatternNodePtr<T>> PatternGraph<T>::SortByReverseTopoOrder() {
   }
 
   while (!reverse_topo_queue.empty()) {
-    PatternNodePtr<T> node = reverse_topo_queue.front();
+    PatternNodePtr node = reverse_topo_queue.front();
     reverse_topo_queue.pop_front();
     res.push_back(node);
     for (const auto& upstream : node->upstream()) {
@@ -124,98 +121,77 @@ std::vector<PatternNodePtr<T>> PatternGraph<T>::SortByReverseTopoOrder() {
   return res;
 }
 
-template <typename T>
-void PatternGraph<T>::SinkTrivialPattern() {
+void PatternGraph::SinkTrivialPattern() {
   GraphTransformer<NodePattern,
-                   T,
-                   And<StmtPatternGraphMatcher<TrivialPattern<T>>,
+                   And<StmtPatternGraphMatcher<TrivialPattern>,
                        DownstreamSmallerThan<2>,
                        NonSinkNodeMatcher>,
                    MergeTrivialPatternOperation>(this);
 }
 
-template <typename T>
-void PatternGraph<T>::ReduceLiftReduceTree() {
+void PatternGraph::ReduceLiftReduceTree() {
   GraphTransformer<
       NodePattern,
-      T,
-      And<DownstreamSmallerThan<2>, StmtPatternGraphMatcher<ReducePattern<T>>>,
+      And<DownstreamSmallerThan<2>, StmtPatternGraphMatcher<ReducePattern>>,
       LiftReduceToReduceTreeOperation>(this);
 }
 
-template <typename T>
-void PatternGraph<T>::HorizontalFusion() {
+void PatternGraph::HorizontalFusion() {
   GraphTransformer<NodePattern,
-                   T,
-                   Or<StmtPatternGraphMatcher<TrivialPattern<T>>,
-                      StmtPatternGraphMatcher<ReduceTreePlusTrivialPattern<T>>,
-                      StmtPatternGraphMatcher<ReducePattern<T>>,
-                      StmtPatternGraphMatcher<ReduceTreePattern<T>>,
-                      StmtPatternGraphMatcher<AnchorPattern<T>>>,
+                   Or<StmtPatternGraphMatcher<TrivialPattern>,
+                      StmtPatternGraphMatcher<ReduceTreePlusTrivialPattern>,
+                      StmtPatternGraphMatcher<ReducePattern>,
+                      StmtPatternGraphMatcher<ReduceTreePattern>,
+                      StmtPatternGraphMatcher<AnchorPattern>>,
                    LiftToHorizontalFusionPatternOperation>(this);
 
   GraphTransformer<NodePairPattern,
-                   T,
-                   HorizontalFusionMatcher<T>,
+                   HorizontalFusionMatcher,
                    HorizontalFusionOperation>(this);
 }
 
-template <typename T>
-void PatternGraph<T>::ReduceTreeGrown() {
+void PatternGraph::ReduceTreeGrown() {
   GraphTransformer<NodePattern,
-                   T,
                    CanFuseReduceTreeMatcher,
                    MergeReduceTreeOperation>(this);
 }
 
-template <typename T>
-void PatternGraph<T>::ReduceTree_Trivial_Fusion() {
+void PatternGraph::ReduceTree_Trivial_Fusion() {
   GraphTransformer<NodePattern,
-                   T,
                    CanFuseReduceTreeAndTrivialMatcher,
                    MergeReduceTreeAndTrivialOperation>(this);
 }
 
-template <typename T>
-void PatternGraph<T>::LiftToAnchorPattern() {
+void PatternGraph::LiftToAnchorPattern() {
   GraphTransformer<NodePattern,
-                   T,
                    LiftToAnchorPatternMatcher,
                    LiftToAnchorPatternOperation>(this);
 }
 
-template <typename T>
-void PatternGraph<T>::AnchorPatternFusion() {
+void PatternGraph::AnchorPatternFusion() {
   GraphTransformer<ReverseTopoNodePairPattern,
-                   T,
                    HasUpstreamAnchorMatcher,
                    FuseUpstreamAnchorOperation>(this);
 
   GraphTransformer<NodePairPattern,
-                   T,
                    HasUpstreamAnchorMatcher,
                    FuseUpstreamAnchorOperation>(this);
 
   GraphTransformer<NodePairPattern,
-                   T,
                    HasDownstreamAnchorMatcher,
                    FuseDownstreamAnchorOperation>(this);
 }
 
-template <typename T>
-void PatternGraph<T>::SplitRecomputePattern() {
-  GraphTransformer<NodePattern,
-                   T,
-                   RecomputeNodeMatcher,
-                   SplitRecomputeOperation>(this);
+void PatternGraph::SplitRecomputePattern() {
+  GraphTransformer<NodePattern, RecomputeNodeMatcher, SplitRecomputeOperation>(
+      this);
 }
 
-template <typename T>
-PatternGraph<T>::PatternGraph(const std::vector<PatternContent<T>>& contents,
-                              const std::vector<pir::Value>& outputs,
-                              const PolicyManager<T> policy_manager)
+PatternGraph::PatternGraph(const std::vector<PatternContent>& contents,
+                           const std::vector<pir::Value>& outputs,
+                           const PolicyManager policy_manager)
     : policy_manager_(policy_manager), outputs_(outputs) {
-  std::unordered_map<pir::Operation*, PatternNodePtr<T>> op_to_node_map;
+  std::unordered_map<pir::Operation*, PatternNodePtr> op_to_node_map;
 
   VLOG(4) << "len(outputs) = " << outputs_.size();
   for (const auto& v : outputs) {
@@ -223,19 +199,19 @@ PatternGraph<T>::PatternGraph(const std::vector<PatternContent<T>>& contents,
   }
 
   for (const auto& content : contents) {
-    PatternNodePtr<T> node = std::make_shared<PatternNode<T>>(content);
+    PatternNodePtr node = std::make_shared<PatternNode>(content);
     op_to_node_map[content.op] = node;
     all_pattern_nodes_.emplace(node);
   }
 
   for (const auto& content : contents) {
-    PatternNodePtr<T> cur_node = op_to_node_map[content.op];
+    PatternNodePtr cur_node = op_to_node_map[content.op];
 
     // add upstream nodes
     for (int i = 0; i < content.op->num_operands(); ++i) {
       ::pir::Operation* input_op = content.op->operand_source(i).defining_op();
       if (op_to_node_map.find(input_op) != op_to_node_map.end()) {
-        PatternNodePtr<T> upstream_node = op_to_node_map[input_op];
+        PatternNodePtr upstream_node = op_to_node_map[input_op];
         cur_node->AddNodeToUpstream(upstream_node);
       }
     }
@@ -248,7 +224,7 @@ PatternGraph<T>::PatternGraph(const std::vector<PatternContent<T>>& contents,
            ++consumer_it) {
         ::pir::Operation* output_op = consumer_it->owner();
         if (op_to_node_map.find(output_op) != op_to_node_map.end()) {
-          PatternNodePtr<T> downstream_node = op_to_node_map[output_op];
+          PatternNodePtr downstream_node = op_to_node_map[output_op];
           cur_node->AddNodeToDownstream(downstream_node);
         }
       }
@@ -265,29 +241,29 @@ PatternGraph<T>::PatternGraph(const std::vector<PatternContent<T>>& contents,
 }
 
 template <typename T>
-void PatternGraph<T>::RemoveNode(const PatternNodePtr<T>& node) {
+void PatternGraph::RemoveNode(const PatternNodePtr& node) {
   VLOG(4) << "Start Remove: " << node;
   if (all_pattern_nodes_.find(node) != all_pattern_nodes_.end()) {
     VLOG(4) << "Removed! ";
     all_pattern_nodes_.erase(node);
   }
 
-  for (const PatternNodePtr<T>& upstream : node->upstream()) {
+  for (const PatternNodePtr& upstream : node->upstream()) {
     upstream->RemoveNodeFromDownstream(node);
   }
 
-  for (const PatternNodePtr<T>& downstream : node->downstream()) {
+  for (const PatternNodePtr& downstream : node->downstream()) {
     downstream->RemoveNodeFromUpstream(node);
   }
 }
 
 template <typename T>
-void PatternGraph<T>::AppendNode(const PatternNodePtr<T>& node) {
+void PatternGraph::AppendNode(const PatternNodePtr& node) {
   all_pattern_nodes_.emplace(node);
 }
 
 template <typename T>
-std::string PatternGraph<T>::GraphInfo() const {
+std::string PatternGraph::GraphInfo() const {
   std::stringstream ss;
   ss << "\n========= GraphInfo ===========";
   for (const auto& v : all_pattern_nodes_) {
@@ -300,12 +276,11 @@ std::string PatternGraph<T>::GraphInfo() const {
 }
 
 template <typename T>
-PatternNodePtr<T> PatternGraph<T>::MergeNode(
-    const PatternNodePtr<T>& upstream,
-    const PatternNodePtr<T>& downstream,
-    MergePatternFn<T> merge_pattern_fn) {
-  PatternNodePtr<T> merged_node =
-      std::make_shared<PatternNode<T>>(upstream, downstream, merge_pattern_fn);
+PatternNodePtr PatternGraph::MergeNode(const PatternNodePtr& upstream,
+                                       const PatternNodePtr& downstream,
+                                       MergePatternFn merge_pattern_fn) {
+  PatternNodePtr merged_node =
+      std::make_shared<PatternNode>(upstream, downstream, merge_pattern_fn);
 
   // Update upstream and downstream nodes.
   for (const auto& upstream_node : merged_node->upstream()) {
@@ -319,7 +294,7 @@ PatternNodePtr<T> PatternGraph<T>::MergeNode(
     downstream_node->RemoveNodeFromDownstream(downstream);
   }
 
-  const auto vec_unique = [](const std::vector<PatternNodePtr<T>>& vec) {
+  const auto vec_unique = [](const std::vector<PatternNodePtr>& vec) {
     auto set = std::unordered_set(vec.begin(), vec.end());
     return set.size() == vec.size();
   };
diff --git a/paddle/cinn/operator_fusion/pattern_graph.h b/paddle/cinn/operator_fusion/pattern_graph.h
index cedf52f63a6125..17435139959a69 100644
--- a/paddle/cinn/operator_fusion/pattern_graph.h
+++ b/paddle/cinn/operator_fusion/pattern_graph.h
@@ -21,20 +21,18 @@
 
 namespace cinn::fusion {
 
-template <typename T>
-using PatternNodePtrSet = std::unordered_set<PatternNodePtr<T>>;
-template <typename T>
+using PatternNodePtrSet = std::unordered_set<PatternNodePtr>;
+
 using MergePatternFn =
-    std::function<StmtPattern<T>(const StmtPattern<T>&, const StmtPattern<T>&)>;
+    std::function<StmtPattern(const StmtPattern&, const StmtPattern&)>;
 
-template <typename T>
 class PatternGraph {
  public:
-  PatternGraph(const std::vector<PatternContent<T>>& nodes,
+  PatternGraph(const std::vector<PatternContent>& nodes,
                const std::vector<pir::Value>& outputs,
-               const PolicyManager<T> policy_manager);
+               const PolicyManager policy_manager);
 
-  std::vector<PatternNodePtr<T>> ClusterOps();
+  std::vector<PatternNodePtr> ClusterOps();
 
   void SinkTrivialPattern();
   void HorizontalFusion();
@@ -45,25 +43,25 @@ class PatternGraph {
   void AnchorPatternFusion();
   void SplitRecomputePattern();
 
-  void RemoveNode(const PatternNodePtr<T>& node);
-  void AppendNode(const PatternNodePtr<T>& node);
+  void RemoveNode(const PatternNodePtr& node);
+  void AppendNode(const PatternNodePtr& node);
   std::string GraphInfo() const;
-  PatternNodePtr<T> MergeNode(const PatternNodePtr<T>& upstream,
-                              const PatternNodePtr<T>& downstream,
-                              MergePatternFn<T> merge_pattern_fn);
-  std::vector<PatternNodePtr<T>> SortByTopoOrder();
-  std::vector<PatternNodePtr<T>> SortByReverseTopoOrder();
+  PatternNodePtr MergeNode(const PatternNodePtr& upstream,
+                           const PatternNodePtr& downstream,
+                           MergePatternFn merge_pattern_fn);
+  std::vector<PatternNodePtr> SortByTopoOrder();
+  std::vector<PatternNodePtr> SortByReverseTopoOrder();
 
-  const PatternNodePtrSet<T>& all_pattern_nodes() const {
+  const PatternNodePtrSet& all_pattern_nodes() const {
     return all_pattern_nodes_;
   }
   const std::vector<pir::Value>& outputs() const { return outputs_; }
-  const PolicyManager<T>& policy_manager() const { return policy_manager_; }
+  const PolicyManager& policy_manager() const { return policy_manager_; }
 
  private:
-  PatternNodePtrSet<T> all_pattern_nodes_;
+  PatternNodePtrSet all_pattern_nodes_;
   std::vector<pir::Value> outputs_;
-  PolicyManager<T> policy_manager_;
+  PolicyManager policy_manager_;
 };
 
 }  // namespace cinn::fusion
diff --git a/paddle/cinn/operator_fusion/pattern_node.h b/paddle/cinn/operator_fusion/pattern_node.h
index 459522b8341de2..13f1938964068e 100644
--- a/paddle/cinn/operator_fusion/pattern_node.h
+++ b/paddle/cinn/operator_fusion/pattern_node.h
@@ -20,14 +20,13 @@
 
 namespace cinn::fusion {
 
-template <typename T>
 struct PatternNode {
-  using PatternNodePtr = std::shared_ptr<PatternNode<T>>;
-  using MergePatternFn = std::function<StmtPattern<T>(const StmtPattern<T>&,
-                                                      const StmtPattern<T>&)>;
+  using PatternNodePtr = std::shared_ptr<PatternNode>;
+  using MergePatternFn =
+      std::function<StmtPattern(const StmtPattern&, const StmtPattern&)>;
 
-  explicit PatternNode(const PatternContent<T>& content)
-      : sink_op_(content.op), stmt_pattern_(ConvertToStmtPattern<T>(content)) {}
+  explicit PatternNode(const PatternContent& content)
+      : sink_op_(content.op), stmt_pattern_(ConvertToStmtPattern(content)) {}
 
   explicit PatternNode(PatternNodePtr fused_up_node,
                        PatternNodePtr fused_down_node,
@@ -60,10 +59,8 @@ struct PatternNode {
   }
 
   pir::Operation* sink_op() const { return sink_op_; }
-  const StmtPattern<T>& stmt_pattern() const { return stmt_pattern_; }
-  void set_stmt_pattern(const StmtPattern<T>& pattern) {
-    stmt_pattern_ = pattern;
-  }
+  const StmtPattern& stmt_pattern() const { return stmt_pattern_; }
+  void set_stmt_pattern(const StmtPattern& pattern) { stmt_pattern_ = pattern; }
   const std::vector<PatternNodePtr>& upstream() const { return upstream_; }
   const std::vector<PatternNodePtr>& downstream() const { return downstream_; }
   void AddNodeToUpstream(PatternNodePtr node) { upstream_.push_back(node); }
@@ -80,7 +77,7 @@ struct PatternNode {
   void UniqueDownstream() { downstream_ = UniqueVectorBySet(downstream_); }
 
  private:
-  StmtPattern<T> stmt_pattern_;
+  StmtPattern stmt_pattern_;
   pir::Operation* sink_op_;
 
   std::vector<PatternNodePtr> upstream_;
@@ -88,5 +85,5 @@ struct PatternNode {
 };
 
 template <typename T>
-using PatternNodePtr = std::shared_ptr<PatternNode<T>>;
+using PatternNodePtr = std::shared_ptr<PatternNode>;
 }  // namespace cinn::fusion
diff --git a/paddle/cinn/operator_fusion/pir_graph_analyzing/anchor_transform.h b/paddle/cinn/operator_fusion/pir_graph_analyzing/anchor_transform.h
index 1160abdce4c252..67e340d0e8fb38 100644
--- a/paddle/cinn/operator_fusion/pir_graph_analyzing/anchor_transform.h
+++ b/paddle/cinn/operator_fusion/pir_graph_analyzing/anchor_transform.h
@@ -115,16 +115,29 @@ using AnchorTransform = std::variant<UnsupportTransformPtr,
                                      DeleteDimTransformPtr>;
 using AnchorTransformRoute = std::vector<AnchorTransform>;
 
-template <typename T>
-struct ExprPromise {};
+struct ExprPromise {
+  explicit ExprPromise(const pir::Value& root) : root_value(root) {}
+  AnchorTransformRoute transform_route;
+  pir::Value root_value;
+
+  void update(const AnchorTransformRoute& route) {
+    transform_route.insert(transform_route.end(), route.begin(), route.end());
+  }
+
+  std::string DebugStr() const {
+    std::stringstream ss;
+    ss << "[ExprPromise] root_value: " << root_value.impl() << "\n";
+    ss << DebugStrOfAnchorTransformRoute(transform_route) << "\n";
+    return ss.str();
+  }
+};
 
-template <typename T>
 struct AnchorState {
-  explicit AnchorState(const std::vector<ExprPromise<T>>& init_promise)
+  explicit AnchorState(const std::vector<ExprPromise>& init_promise)
       : promise(init_promise) {}
-  std::vector<ExprPromise<T>> promise;
+  std::vector<ExprPromise> promise;
 
-  void update(AnchorState<T> new_state) {
+  void update(AnchorState new_state) {
     auto new_exprs = new_state.promise;
     promise.insert(promise.end(), new_exprs.begin(), new_exprs.end());
   }
diff --git a/paddle/cinn/operator_fusion/policy/anchor_search_policy.cc b/paddle/cinn/operator_fusion/policy/anchor_search_policy.cc
index a7ee7a1ae5de95..6f5b215f5c90cf 100644
--- a/paddle/cinn/operator_fusion/policy/anchor_search_policy.cc
+++ b/paddle/cinn/operator_fusion/policy/anchor_search_policy.cc
@@ -81,14 +81,13 @@ std::optional<AnchorTransformRoute> FindAnchorTransformRoute(
   return result;
 }
 
-template <typename T>
 std::optional<AnchorTransformRoute>
-AnchorSearchPolicy<T>::FindUpstreamAnchorTransformRoute(
-    const PatternNodePtr<T>& upstream, const PatternNodePtr<T>& downstream) {
+AnchorSearchPolicy::FindUpstreamAnchorTransformRoute(
+    const PatternNodePtr& upstream, const PatternNodePtr& downstream) {
   const auto& upstream_anchor_pattern =
-      std::get<AnchorPattern<T>>(upstream->stmt_pattern());
+      std::get<AnchorPattern>(upstream->stmt_pattern());
   const auto& downstream_anchor_pattern =
-      std::get<AnchorPattern<T>>(downstream->stmt_pattern());
+      std::get<AnchorPattern>(downstream->stmt_pattern());
 
   return FindAnchorTransformRoute(
       upstream_anchor_pattern.anchor(),
@@ -97,14 +96,13 @@ AnchorSearchPolicy<T>::FindUpstreamAnchorTransformRoute(
                                   downstream_anchor_pattern.ops())));
 }
 
-template <typename T>
 std::optional<AnchorTransformRoute>
-AnchorSearchPolicy<T>::FindDownstreamAnchorTransformRoute(
-    const PatternNodePtr<T>& upstream, const PatternNodePtr<T>& downstream) {
+AnchorSearchPolicy::FindDownstreamAnchorTransformRoute(
+    const PatternNodePtr& upstream, const PatternNodePtr& downstream) {
   const auto& upstream_anchor_pattern =
-      std::get<AnchorPattern<T>>(upstream->stmt_pattern());
+      std::get<AnchorPattern>(upstream->stmt_pattern());
   const auto& downstream_anchor_pattern =
-      std::get<AnchorPattern<T>>(downstream->stmt_pattern());
+      std::get<AnchorPattern>(downstream->stmt_pattern());
 
   return FindAnchorTransformRoute(
       downstream_anchor_pattern.anchor(),
@@ -113,9 +111,8 @@ AnchorSearchPolicy<T>::FindDownstreamAnchorTransformRoute(
                                   downstream_anchor_pattern.ops())));
 }
 
-template <typename T>
-bool AnchorSearchPolicy<T>::HasUpstreamAnchor(
-    const PatternNodePtr<T>& upstream, const PatternNodePtr<T>& downstream) {
+bool AnchorSearchPolicy::HasUpstreamAnchor(const PatternNodePtr& upstream,
+                                           const PatternNodePtr& downstream) {
   auto result =
       FindUpstreamAnchorTransformRoute(upstream, downstream) != std::nullopt;
   VLOG(4) << "[AnchorSearchPolicy] HasUpstreamAnchor between " << upstream
@@ -123,9 +120,8 @@ bool AnchorSearchPolicy<T>::HasUpstreamAnchor(
   return result;
 }
 
-template <typename T>
-bool AnchorSearchPolicy<T>::HasDownstreamAnchor(
-    const PatternNodePtr<T>& upstream, const PatternNodePtr<T>& downstream) {
+bool AnchorSearchPolicy::HasDownstreamAnchor(const PatternNodePtr& upstream,
+                                             const PatternNodePtr& downstream) {
   auto result =
       FindDownstreamAnchorTransformRoute(upstream, downstream) != std::nullopt;
   VLOG(4) << "[AnchorSearchPolicy] HasDownstreamAnchor between " << upstream
@@ -133,6 +129,4 @@ bool AnchorSearchPolicy<T>::HasDownstreamAnchor(
   return result;
 }
 
-template class AnchorSearchPolicy<FrontendStage>;
-template class AnchorSearchPolicy<BackendStage>;
 }  // namespace cinn::fusion
diff --git a/paddle/cinn/operator_fusion/policy/anchor_search_policy.h b/paddle/cinn/operator_fusion/policy/anchor_search_policy.h
index 6b71f3efc70336..d81c4cdbe07dd8 100644
--- a/paddle/cinn/operator_fusion/policy/anchor_search_policy.h
+++ b/paddle/cinn/operator_fusion/policy/anchor_search_policy.h
@@ -22,17 +22,16 @@
 
 namespace cinn::fusion {
 
-template <typename T>
-struct AnchorSearchPolicy final : public PolicyBase<T> {
+struct AnchorSearchPolicy final : public PolicyBase {
   static constexpr PolicyKind Kind = PolicyKind::AnchorSearch;
-  bool HasUpstreamAnchor(const PatternNodePtr<T>& upstream,
-                         const PatternNodePtr<T>& downstream);
-  bool HasDownstreamAnchor(const PatternNodePtr<T>& upstream,
-                           const PatternNodePtr<T>& downstream);
+  bool HasUpstreamAnchor(const PatternNodePtr& upstream,
+                         const PatternNodePtr& downstream);
+  bool HasDownstreamAnchor(const PatternNodePtr& upstream,
+                           const PatternNodePtr& downstream);
   std::optional<AnchorTransformRoute> FindUpstreamAnchorTransformRoute(
-      const PatternNodePtr<T>& upstream, const PatternNodePtr<T>& downstream);
+      const PatternNodePtr& upstream, const PatternNodePtr& downstream);
   std::optional<AnchorTransformRoute> FindDownstreamAnchorTransformRoute(
-      const PatternNodePtr<T>& upstream, const PatternNodePtr<T>& downstream);
+      const PatternNodePtr& upstream, const PatternNodePtr& downstream);
 
   std::string Name() { return "AnchorSearchPolicy"; }
 };
diff --git a/paddle/cinn/operator_fusion/policy/general_topo_policy.cc b/paddle/cinn/operator_fusion/policy/general_topo_policy.cc
index 2929167bc57dee..a43a4f462fe95b 100644
--- a/paddle/cinn/operator_fusion/policy/general_topo_policy.cc
+++ b/paddle/cinn/operator_fusion/policy/general_topo_policy.cc
@@ -18,9 +18,8 @@
 
 namespace cinn::fusion {
 
-template <typename T>
-bool IsDownstreamNode(const PatternNodePtr<T> start,
-                      const PatternNodePtr<T> target) {
+bool IsDownstreamNode(const PatternNodePtr& start,
+                      const PatternNodePtr& target) {
   if (start == target) return true;
   for (const auto& down_node : start->downstream()) {
     if (IsDownstreamNode(down_node, target)) return true;
@@ -28,9 +27,8 @@ bool IsDownstreamNode(const PatternNodePtr<T> start,
   return false;
 }
 
-template <typename T>
-bool IsIndirectDownstreamNode(const PatternNodePtr<T> start,
-                              const PatternNodePtr<T> target) {
+bool IsIndirectDownstreamNode(const PatternNodePtr& start,
+                              const PatternNodePtr& target) {
   for (const auto& node : start->downstream()) {
     if (node == target) continue;
     if (IsDownstreamNode(node, target)) return true;
@@ -38,9 +36,8 @@ bool IsIndirectDownstreamNode(const PatternNodePtr<T> start,
   return false;
 }
 
-template <typename T>
-bool GeneralTopoPolicy<T>::CanFuse(const PatternNodePtr<T>& first,
-                                   const PatternNodePtr<T>& second) {
+bool GeneralTopoPolicy::CanFuse(const PatternNodePtr& first,
+                                const PatternNodePtr& second) {
   VLOG(4) << "Start GeneralTopoPolicy";
   return !(IsIndirectDownstreamNode(first, second) ||
            IsIndirectDownstreamNode(second, first));
diff --git a/paddle/cinn/operator_fusion/policy/general_topo_policy.h b/paddle/cinn/operator_fusion/policy/general_topo_policy.h
index 96a7d5f609922c..cdfcc9ba447d7f 100644
--- a/paddle/cinn/operator_fusion/policy/general_topo_policy.h
+++ b/paddle/cinn/operator_fusion/policy/general_topo_policy.h
@@ -18,12 +18,11 @@
 
 namespace cinn::fusion {
 
-template <typename T>
-class GeneralTopoPolicy final : public PolicyBase<T> {
+class GeneralTopoPolicy final : public PolicyBase {
  public:
   static constexpr PolicyKind Kind = PolicyKind::GeneralTopo;
-  bool CanFuse(const PatternNodePtr<T>& upstream,
-               const PatternNodePtr<T>& downstream);
+  bool CanFuse(const PatternNodePtr& upstream,
+               const PatternNodePtr& downstream);
   std::string Name() { return "GeneralTopoPolicy"; }
 };
 
diff --git a/paddle/cinn/operator_fusion/policy/policy_base.h b/paddle/cinn/operator_fusion/policy/policy_base.h
index ea351c01cad9cd..a6da0c8842a9a2 100644
--- a/paddle/cinn/operator_fusion/policy/policy_base.h
+++ b/paddle/cinn/operator_fusion/policy/policy_base.h
@@ -26,13 +26,10 @@ struct PolicyKindHash {
   }
 };
 
-template <typename T>
 class PolicyBase {};
 
-template <typename T>
-using PolicyPtr = std::shared_ptr<PolicyBase<T>>;
+using PolicyPtr = std::shared_ptr<PolicyBase>;
 
-template <typename T>
-using PolicyMap = std::unordered_map<PolicyKind, PolicyPtr<T>, PolicyKindHash>;
+using PolicyMap = std::unordered_map<PolicyKind, PolicyPtr, PolicyKindHash>;
 
 }  // namespace cinn::fusion
diff --git a/paddle/cinn/operator_fusion/policy/policy_manager.h b/paddle/cinn/operator_fusion/policy/policy_manager.h
index 6ad1380b83e870..cce5289c034726 100644
--- a/paddle/cinn/operator_fusion/policy/policy_manager.h
+++ b/paddle/cinn/operator_fusion/policy/policy_manager.h
@@ -22,28 +22,27 @@
 
 namespace cinn::fusion {
 
-template <typename T>
 class PolicyManager {
  public:
   PolicyManager() {}
 
-  template <template <typename> typename POLICY>
-  void SetPolicy(const std::shared_ptr<POLICY<T>>& policy) {
-    auto key = POLICY<T>::Kind;
-    policies[key] = std::static_pointer_cast<PolicyBase<T>>(policy);
+  template <typename POLICY>
+  void SetPolicy(const std::shared_ptr<POLICY>& policy) {
+    auto key = POLICY::Kind;
+    policies[key] = std::static_pointer_cast<PolicyBase>(policy);
   }
 
-  template <template <typename> typename POLICY>
-  std::shared_ptr<POLICY<T>> GetPolicy() const {
-    auto key = POLICY<T>::Kind;
+  template <typename POLICY>
+  std::shared_ptr<POLICY> GetPolicy() const {
+    auto key = POLICY::Kind;
     PADDLE_ENFORCE_NE(policies.find(key),
                       policies.end(),
                       phi::errors::NotFound("Policy %d Not Found", key));
-    return std::static_pointer_cast<POLICY<T>>(policies.at(key));
+    return std::static_pointer_cast<POLICY>(policies.at(key));
   }
 
  private:
-  PolicyMap<T> policies;
+  PolicyMap policies;
 };
 
 }  // namespace cinn::fusion
diff --git a/paddle/cinn/operator_fusion/policy/relative_judge_policy.cc b/paddle/cinn/operator_fusion/policy/relative_judge_policy.cc
index ed83c554181c4a..0a25537a889ded 100644
--- a/paddle/cinn/operator_fusion/policy/relative_judge_policy.cc
+++ b/paddle/cinn/operator_fusion/policy/relative_judge_policy.cc
@@ -18,9 +18,8 @@
 
 namespace cinn::fusion {
 
-template <typename T>
-bool RelativeJudgePolicy<T>::IsDownstreamStmtDependReduceOp(
-    pir::Operation* reduce, const StmtPattern<T>& downstream) {
+bool RelativeJudgePolicy::IsDownstreamStmtDependReduceOp(
+    pir::Operation* reduce, const StmtPattern& downstream) {
   const auto& values = GetPatternInputValues(downstream);
   for (const auto& value : reduce->results()) {
     if (std::find(values.begin(), values.end(), value) != values.end()) {
@@ -30,11 +29,9 @@ bool RelativeJudgePolicy<T>::IsDownstreamStmtDependReduceOp(
   return false;
 }
 
-template <typename T>
-std::optional<ReducePattern<T>>
-RelativeJudgePolicy<T>::GetDownstreamFromCandidate(
-    const ReducePattern<T>& upstream,
-    const std::vector<ReducePattern<T>>& candidates) {
+std::optional<ReducePattern> RelativeJudgePolicy::GetDownstreamFromCandidate(
+    const ReducePattern& upstream,
+    const std::vector<ReducePattern>& candidates) {
   pir::Operation* reduce = upstream.GetReduceOp();
   for (const auto& candidate : candidates) {
     if (IsDownstreamStmtDependReduceOp(reduce, candidate)) {
@@ -82,9 +79,8 @@ std::pair<std::vector<DimUsage>, std::vector<DimUsage>> SplitReduceDims(
   return {reduce_dims, non_reduce_dims};
 }
 
-template <typename T>
 std::pair<std::vector<DimUsage>, std::vector<DimUsage>>
-RelativeJudgePolicy<T>::SplitFirstIfRelatedBySecond(
+RelativeJudgePolicy::SplitFirstIfRelatedBySecond(
     const std::vector<DimUsage>& targets,
     const std::vector<DimUsage>& related_with) {
   std::vector<DimUsage> related_dims;
@@ -194,18 +190,17 @@ pir::Operation* FindUserOp(const std::vector<pir::Operation*>& candidates,
   return results.front();
 }
 
-template <typename T>
-bool RelativeJudgePolicy<T>::ReduceTreeGrownCanMerge(
-    const PatternNodePtr<T>& upstream, const PatternNodePtr<T>& downstream) {
+bool RelativeJudgePolicy::ReduceTreeGrownCanMerge(
+    const PatternNodePtr& upstream, const PatternNodePtr& downstream) {
   const auto& upstream_tree =
-      std::get<ReduceTreePattern<T>>(upstream->stmt_pattern());
+      std::get<ReduceTreePattern>(upstream->stmt_pattern());
   const auto& downstream_tree =
-      std::get<ReduceTreePattern<T>>(downstream->stmt_pattern());
+      std::get<ReduceTreePattern>(downstream->stmt_pattern());
 
   VLOG(4) << "upstream->stmt_pattern():"
-          << OpsDebugStr(GetOpsInPattern<T>(upstream_tree));
+          << OpsDebugStr(GetOpsInPattern(upstream_tree));
   VLOG(4) << "downstream->stmt_pattern()"
-          << OpsDebugStr(GetOpsInPattern<T>(downstream_tree));
+          << OpsDebugStr(GetOpsInPattern(downstream_tree));
 
   const auto& maybe_downstream_op = GetDownstreamFromCandidate(
       upstream_tree.GetRootPattern(), downstream_tree.FlattenReducePattern());
@@ -213,7 +208,7 @@ bool RelativeJudgePolicy<T>::ReduceTreeGrownCanMerge(
   for (const auto& r_pattern : downstream_tree.childs()) {
     idx += 1;
     VLOG(4) << "downstream_tree.reduce_patterns_"
-            << "[" << idx << "]" << OpsDebugStr(GetOpsInPattern<T>(r_pattern));
+            << "[" << idx << "]" << OpsDebugStr(GetOpsInPattern(r_pattern));
   }
   if (!maybe_downstream_op.has_value()) {
     VLOG(4) << "can't find candidate from patterns. can fuse return false.";
@@ -239,9 +234,8 @@ bool RelativeJudgePolicy<T>::ReduceTreeGrownCanMerge(
   return res;
 }
 
-template <typename T>
-bool RelativeJudgePolicy<T>::ReducePlusTrivialCanMerge(
-    const PatternNodePtr<T>& upstream, const PatternNodePtr<T>& downstream) {
+bool RelativeJudgePolicy::ReducePlusTrivialCanMerge(
+    const PatternNodePtr& upstream, const PatternNodePtr& downstream) {
   VLOG(4) << "RT can fuse";
 
   const auto& [upstream_reduce_dims, upstream_non_reduce_dims] =
@@ -267,26 +261,23 @@ bool RelativeJudgePolicy<T>::ReducePlusTrivialCanMerge(
   return res;
 }
 
-template <typename T>
-bool RelativeJudgePolicy<T>::CanFuse(const PatternNodePtr<T>& upstream,
-                                     const PatternNodePtr<T>& downstream) {
-  if (std::holds_alternative<ReduceTreePattern<T>>(upstream->stmt_pattern()) &&
-      std::holds_alternative<TrivialPattern<T>>(downstream->stmt_pattern())) {
+bool RelativeJudgePolicy::CanFuse(const PatternNodePtr& upstream,
+                                  const PatternNodePtr& downstream) {
+  if (std::holds_alternative<ReduceTreePattern>(upstream->stmt_pattern()) &&
+      std::holds_alternative<TrivialPattern>(downstream->stmt_pattern())) {
     return ReducePlusTrivialCanMerge(upstream, downstream);
   }
-  if (std::holds_alternative<ReduceTreePattern<T>>(upstream->stmt_pattern()) &&
-      std::holds_alternative<ReduceTreePattern<T>>(
-          downstream->stmt_pattern())) {
+  if (std::holds_alternative<ReduceTreePattern>(upstream->stmt_pattern()) &&
+      std::holds_alternative<ReduceTreePattern>(downstream->stmt_pattern())) {
     return ReduceTreeGrownCanMerge(upstream, downstream);
   }
   return true;  // other case.
 }
 
-template <typename T>
-std::vector<size_t> RelativeJudgePolicy<T>::GetFakeReduceIterIdx(
-    const PatternNodePtr<T>& upstream, const PatternNodePtr<T>& downstream) {
-  if (!std::holds_alternative<ReduceTreePattern<T>>(upstream->stmt_pattern()) &&
-      !std::holds_alternative<TrivialPattern<T>>(downstream->stmt_pattern())) {
+std::vector<size_t> RelativeJudgePolicy::GetFakeReduceIterIdx(
+    const PatternNodePtr& upstream, const PatternNodePtr& downstream) {
+  if (!std::holds_alternative<ReduceTreePattern>(upstream->stmt_pattern()) &&
+      !std::holds_alternative<TrivialPattern>(downstream->stmt_pattern())) {
     PADDLE_THROW("Illegal Call GetFakeReduceIterIdx");
   }
 
diff --git a/paddle/cinn/operator_fusion/policy/relative_judge_policy.h b/paddle/cinn/operator_fusion/policy/relative_judge_policy.h
index d01fbe37a38853..64cb2448d46fc4 100644
--- a/paddle/cinn/operator_fusion/policy/relative_judge_policy.h
+++ b/paddle/cinn/operator_fusion/policy/relative_judge_policy.h
@@ -23,8 +23,7 @@
 
 namespace cinn::fusion {
 
-template <typename T>
-class RelativeJudgePolicy final : public PolicyBase<T> {
+class RelativeJudgePolicy final : public PolicyBase {
  public:
   static constexpr PolicyKind Kind = PolicyKind::RelativeJudge;
   RelativeJudgePolicy(const std::vector<pir::Operation*>& ops,
@@ -34,13 +33,13 @@ class RelativeJudgePolicy final : public PolicyBase<T> {
     index_expr_map_ = AnalysisIndexExprRelation(ops);
     VLOG(4) << "[relative_judge_policy] End AnalysisIndexExprRelation.";
   }
-  bool CanFuse(const PatternNodePtr<T>& upstream,
-               const PatternNodePtr<T>& downstream);
+  bool CanFuse(const PatternNodePtr& upstream,
+               const PatternNodePtr& downstream);
 
   std::string Name() { return "RelativeJudgePolicy"; }
 
-  std::vector<size_t> GetFakeReduceIterIdx(const PatternNodePtr<T>& upstream,
-                                           const PatternNodePtr<T>& downstream);
+  std::vector<size_t> GetFakeReduceIterIdx(const PatternNodePtr& upstream,
+                                           const PatternNodePtr& downstream);
 
   bool IsRelated(DimUsage in, DimUsage out) {
     return index_expr_map_[in].count(out) == 1;
@@ -49,18 +48,16 @@ class RelativeJudgePolicy final : public PolicyBase<T> {
  private:
   DimUsageRelation index_expr_map_;
   ShardableAxesInfoManager axes_info_;
-  bool ReduceTreeGrownCanMerge(const PatternNodePtr<T>&,
-                               const PatternNodePtr<T>&);
-  bool ReducePlusTrivialCanMerge(const PatternNodePtr<T>&,
-                                 const PatternNodePtr<T>&);
+  bool ReduceTreeGrownCanMerge(const PatternNodePtr&, const PatternNodePtr&);
+  bool ReducePlusTrivialCanMerge(const PatternNodePtr&, const PatternNodePtr&);
   std::pair<std::vector<DimUsage>, std::vector<DimUsage>>
   SplitFirstIfRelatedBySecond(const std::vector<DimUsage>& targets,
                               const std::vector<DimUsage>& related_with);
-  std::optional<ReducePattern<T>> GetDownstreamFromCandidate(
-      const ReducePattern<T>& upstream,
-      const std::vector<ReducePattern<T>>& candidates);
+  std::optional<ReducePattern> GetDownstreamFromCandidate(
+      const ReducePattern& upstream,
+      const std::vector<ReducePattern>& candidates);
   bool IsDownstreamStmtDependReduceOp(pir::Operation* reduce,
-                                      const StmtPattern<T>& downstream);
+                                      const StmtPattern& downstream);
 };
 
 }  // namespace cinn::fusion

From 61fb8558030520be8b61b0a90c07cc803f27cfbe Mon Sep 17 00:00:00 2001
From: feifei-111 <2364819892@qq.com>
Date: Wed, 29 May 2024 07:38:44 +0000
Subject: [PATCH 67/99] update

---
 .../fusion_tracker/interpreter.h              |   3 +-
 .../operator_fusion/fusion_tracker/tracker.h  |  78 +++++-
 .../graph_transformer/operation.h             | 122 ++++++----
 paddle/cinn/operator_fusion/pattern.h         |  49 +++-
 paddle/cinn/operator_fusion/pattern_fuser.cc  |  91 -------
 paddle/cinn/operator_fusion/pattern_fuser.h   | 227 ++++++++----------
 paddle/cinn/operator_fusion/pattern_node.h    |   4 +
 7 files changed, 310 insertions(+), 264 deletions(-)
 delete mode 100644 paddle/cinn/operator_fusion/pattern_fuser.cc

diff --git a/paddle/cinn/operator_fusion/fusion_tracker/interpreter.h b/paddle/cinn/operator_fusion/fusion_tracker/interpreter.h
index 3d53c4f8eaa8e7..532146a8d6465d 100644
--- a/paddle/cinn/operator_fusion/fusion_tracker/interpreter.h
+++ b/paddle/cinn/operator_fusion/fusion_tracker/interpreter.h
@@ -13,6 +13,7 @@
 // limitations under the License.
 
 #pragma once
-#include "paddle/cinn/operator_fusion/fusion_tracker/tracker.h"
+#include "paddle/cinn/operator_fusion/pattern.h"
+#include "paddle/cinn/operator_fusion/pattern_fuser.h"
 
 struct FusionInterpreter {};
diff --git a/paddle/cinn/operator_fusion/fusion_tracker/tracker.h b/paddle/cinn/operator_fusion/fusion_tracker/tracker.h
index d81774d9b3fe8f..bde53339c18742 100644
--- a/paddle/cinn/operator_fusion/fusion_tracker/tracker.h
+++ b/paddle/cinn/operator_fusion/fusion_tracker/tracker.h
@@ -14,8 +14,7 @@
 
 #pragma once
 #include "paddle/cinn/ir/ir_base.h"
-#include "paddle/cinn/operator_fusion/pattern.h"
-#include "paddle/cinn/operator_fusion/pattern_fuser.h"
+#include "paddle/cinn/operator_fusion/pir_graph_analyzing/anchor_transform.h"
 #include "paddle/cinn/operator_fusion/utils.h"
 
 namespace cinn::fusion {
@@ -35,10 +34,74 @@ struct FusionInstruction {
 
 using FusionInstrPtr = std::shared_ptr<FusionInstruction>;
 
-struct TrivialInlineInstr : public FusionInstruction {};
-struct TmpTransformInstr : public FusionInstruction {};
-struct AnchorMatchInstr : public FusionInstruction {};
-struct InitPatternInstr : public FusionInstruction {};
+struct TrivialInlineInstr : public FusionInstruction {
+  TrivialInlineInstr(const std::string& upstream,
+                     const std::string& downstream const std::string& result)
+      : upstream_(upstream), downstream_(downstream), result_(result) {}
+  std::string upstream_;
+  std::string downstream_;
+  std::string result_;
+};
+struct TmpTransformInstr : public FusionInstruction {
+  TmpTransformInstr(const std::string& upstream,
+                    const std::string& downstream const std::string& result)
+      : upstream_(upstream), downstream_(downstream), result_(result) {}
+  std::string upstream_;
+  std::string downstream_;
+  std::string result_;
+};
+struct TmpTransformWithFakeReduceIterInstr : public FusionInstruction {
+  TmpTransformInstr(const std::string& upstream,
+                    const std::string& downstream,
+                    const std::string& result,
+                    const vector<size_t>& fake_reduce_iter_idx)
+      : upstream_(upstream),
+        downstream_(downstream),
+        result_(result),
+        fake_reduce_iter_idx_(fake_reduce_iter_idx) {}
+  std::string upstream_;
+  std::string downstream_;
+  std::string result_;
+  vector<size_t> fake_reduce_iter_idx_;
+};
+struct AnchorTransformInstr : public FusionInstruction {
+  TmpTransformInstr(const std::string& upstream,
+                    const std::string& downstream,
+                    const std::string& result,
+                    const AnchorTransformRoute& transform_route,
+                    bool is_upstream_anchor)
+      : upstream_(upstream),
+        downstream_(downstream),
+        result_(result),
+        transform_route_(transform_route),
+        is_upstream_anchor_(is_upstream_anchor) {}
+  std::string upstream_;
+  std::string downstream_;
+  std::string result_;
+  AnchorTransformRoute transform_route_;
+  bool is_upstream_anchor_;
+};
+struct CombineInstr : public FusionInstruction {
+  TmpTransformInstr(const std::string& first,
+                    const std::string& second,
+                    const std::string& result)
+      : first_(first), second_(second), result_(result) {}
+  std::string first_;
+  std::string second_;
+  std::string result_;
+};
+struct InitPatternInstr : public FusionInstruction {
+  InitPatternInstr(pir::Operation* op, const std::string& result)
+      : op_(op), result_(result) {}
+  pir::Operation* op_;
+  std::string result_;
+};
+struct RenamePatternInstr : public FusionInstruction {
+  TmpTransformInstr(const std::string& origin_name, const std::string& new_name)
+      : origin_name_(origin_name), new_name_(new_name) {}
+  std::string origin_name_;
+  std::string new_name_;
+};
 struct RemovePatternInstr : public FusionInstruction {};
 
 struct FusionTracker {
@@ -48,7 +111,8 @@ struct FusionTracker {
     ExtendVector(&instructions_, down.instructions_);
   }
   void append(FusionInstrPtr instr) { instructions_.emplace_back(instr); }
-  std::vector<FusionInstrPtr> instructions_;
   std::string DebugStr() const;
+
+  std::vector<FusionInstrPtr> instructions_;
 };
 }  // namespace cinn::fusion
diff --git a/paddle/cinn/operator_fusion/graph_transformer/operation.h b/paddle/cinn/operator_fusion/graph_transformer/operation.h
index 6b1709914638d8..c50b050981089a 100644
--- a/paddle/cinn/operator_fusion/graph_transformer/operation.h
+++ b/paddle/cinn/operator_fusion/graph_transformer/operation.h
@@ -20,6 +20,47 @@ namespace cinn::fusion {
 
 // Operation
 
+struct MergeTrivialPatternOperation {
+  void operator()(PatternGraph* graph, PatternNodePtr upstream) {
+    PADDLE_ENFORCE_GE(upstream->downstream().size(),
+                      1,
+                      phi::errors::PreconditionNotMet(
+                          "The trivial pattern wait for sinking should has "
+                          "at least 1 downstream , but got %d.",
+                          upstream->downstream().size()));
+
+    std::vector<PatternNodePtr> fusion_candidate = upstream->downstream();
+    upstream->ClearDownstream();
+
+    for (const auto& downstream : fusion_candidate) {
+      bool can_fuse =
+          std::holds_alternative<ReducePattern>(downstream->stmt_pattern()) ||
+          std::holds_alternative<TrivialPattern>(downstream->stmt_pattern()) ||
+          std::holds_alternative<ReduceTreePattern>(
+              downstream->stmt_pattern()) ||
+          std::holds_alternative<ReduceTreePlusTrivialPattern>(
+              downstream->stmt_pattern()) ||
+          std::holds_alternative<AnchorPattern>(downstream->stmt_pattern());
+
+      if (can_fuse) {
+        auto merged_node = graph->MergeNode(upstream, downstream, MergePattern);
+        graph->RemoveNode(downstream);
+        VLOG(4) << "Spliting trivial pattern: \nupstream "
+                << upstream->DebugStr() << "\ndownstream "
+                << downstream->DebugStr() << "\nmerged "
+                << merged_node->DebugStr();
+        merged_node->UpdateTracker(make_shared<TrivialInlineInstr>(
+            upstream->name(), downstream->name(), merged_node->name()));
+      } else {
+        upstream->AddNodeToDownstream(downstream);
+      }
+    }
+    if (upstream->downstream().empty()) {
+      graph->RemoveNode(upstream);
+    }
+  }
+};
+
 struct MergeReduceTreeOperation {
   PatternNodePtr operator()(PatternGraph* graph, PatternNodePtr node) {
     PADDLE_ENFORCE_EQ(
@@ -35,6 +76,8 @@ struct MergeReduceTreeOperation {
     VLOG(4) << "MergeReduceTreeOperation: \nupstream " << node->DebugStr()
             << "\ndownstream " << downstream->DebugStr() << "\nmerged "
             << merged_node->DebugStr();
+    merged_node->UpdateTracker(make_shared<TmpTransformInstr>(
+        upstream->name(), downstream->name(), merged_node->name()));
     return merged_node;
   }
 };
@@ -66,68 +109,43 @@ struct MergeReduceTreeAndTrivialOperation {
     VLOG(4) << "MergeReduceTreeAndTrivialOperation: \nupstream "
             << node->DebugStr() << "\ndownstream " << downstream->DebugStr()
             << "\nmerged " << merged_node->DebugStr();
+    merged_node->UpdateTracker(make_shared<TmpTransformWithFakeReduceIterInstr>(
+                                   upstream->name(),
+                                   downstream->name(),
+                                   merged_node->name(),
+                                   fake_reduce_iter_idx););
     return merged_node;
   }
 };
 
 struct LiftReduceToReduceTreeOperation {
   PatternNodePtr operator()(PatternGraph* graph, PatternNodePtr node) {
-    const auto& reduce_pattern = ToReducePattern(node->stmt_pattern());
-    node->set_stmt_pattern(ReduceTreePattern({}, reduce_pattern));
+    auto origin_name = node->name();
+    const auto& reduce_pattern = std::get<ReducePattern>(node->stmt_pattern());
+    node->set_stmt_pattern(
+        ReduceTreePattern({}, reduce_pattern, *(reduce_pattern.tracker())));
+    node->UpdateTracker(
+        make_shared<RenamePatternInstr>(origin_name, node->name()));
     return node;
   }
 };
 
-struct MergeTrivialPatternOperation {
-  void operator()(PatternGraph* graph, PatternNodePtr upstream) {
-    PADDLE_ENFORCE_GE(upstream->downstream().size(),
-                      1,
-                      phi::errors::PreconditionNotMet(
-                          "The trivial pattern wait for sinking should has "
-                          "at least 1 downstream , but got %d.",
-                          upstream->downstream().size()));
-
-    std::vector<PatternNodePtr> fusion_candidate = upstream->downstream();
-    upstream->ClearDownstream();
-
-    for (const auto& downstream : fusion_candidate) {
-      bool can_fuse =
-          std::holds_alternative<ReducePattern>(downstream->stmt_pattern()) ||
-          std::holds_alternative<TrivialPattern>(downstream->stmt_pattern()) ||
-          std::holds_alternative<ReduceTreePattern>(
-              downstream->stmt_pattern()) ||
-          std::holds_alternative<ReduceTreePlusTrivialPattern>(
-              downstream->stmt_pattern()) ||
-          std::holds_alternative<AnchorPattern>(downstream->stmt_pattern());
-
-      if (can_fuse) {
-        auto merged_node = graph->MergeNode(upstream, downstream, MergePattern);
-        graph->RemoveNode(downstream);
-        VLOG(4) << "Spliting trivial pattern: \nupstream "
-                << upstream->DebugStr() << "\ndownstream "
-                << downstream->DebugStr() << "\nmerged "
-                << merged_node->DebugStr();
-      } else {
-        upstream->AddNodeToDownstream(downstream);
-      }
-    }
-    if (upstream->downstream().empty()) {
-      graph->RemoveNode(upstream);
-    }
-  }
-};
-
 struct LiftToHorizontalFusionPatternOperation {
   PatternNodePtr operator()(PatternGraph* graph, PatternNodePtr node) {
+    auto origin_name = node->name();
     node->set_stmt_pattern(HorizontalFusionPattern(
         {typename HorizontalFusionPattern::PaddingStmtPattern(
-            node->stmt_pattern(), {})}));
+             node->stmt_pattern(), {}),
+         *(node->tracker())}));
+    node->UpdateTracker(
+        make_shared<RenamePatternInstr>(origin_name, node->name()));
     return node;
   }
 };
 
 struct LiftToAnchorPatternOperation {
   PatternNodePtr operator()(PatternGraph* graph, PatternNodePtr node) {
+    auto origin_name = node->name();
     std::vector<pir::Operation*> ops = GetOpsInPattern(node->stmt_pattern());
     // TODO(@wuzhanfei) move sink_op into pattern (currently, part of pattern
     // type has sink and the others not) then, update logic here
@@ -141,6 +159,8 @@ struct LiftToAnchorPatternOperation {
         ops,
         anchor,
         AnchorState({InitExprPromise(node->stmt_pattern(), anchor)})));
+    node->UpdateTracker(
+        make_shared<RenamePatternInstr>(origin_name, node->name()));
     return node;
   }
 };
@@ -184,6 +204,12 @@ struct FuseUpstreamAnchorOperation {
         << std::get<AnchorPattern>(downstream->stmt_pattern()).anchor().impl()
         << ", merged node anchor: "
         << std::get<AnchorPattern>(merged_node->stmt_pattern()).anchor().impl();
+    merged_node->UpdateTracker(
+        make_shared<AnchorTransformInstr>(upstream->name(),
+                                          downstream->name(),
+                                          merged_node->name(),
+                                          transform_route,
+                                          true));
     return merged_node;
   }
 };
@@ -228,15 +254,23 @@ struct FuseDownstreamAnchorOperation {
         << std::get<AnchorPattern>(downstream->stmt_pattern()).anchor().impl()
         << ", merged node anchor: "
         << std::get<AnchorPattern>(merged_node->stmt_pattern()).anchor().impl();
+    merged_node->UpdateTracker(
+        make_shared<AnchorTransformInstr>(upstream->name(),
+                                          downstream->name(),
+                                          merged_node->name(),
+                                          transform_route,
+                                          false));
     return merged_node;
   }
 };
 
 struct SplitRecomputeOperation {
   void operator()(PatternGraph* graph, PatternNodePtr upstream) {
+    auto origin_name = upstream->name();
     upstream->set_stmt_pattern(RecoverAnchorPatternToTrivial(
         std::get<AnchorPattern>(upstream->stmt_pattern())));
-
+    upstream->UpdateTracker(
+        make_shared<RenamePatternInstr>(origin_name, node->name()));
     MergeTrivialPatternOperation()(graph, upstream);
   }
 };
@@ -265,6 +299,8 @@ struct HorizontalFusionOperation {
             << j->DebugStr() << "\nmerged " << merged_node->DebugStr();
     graph->RemoveNode(i);
     graph->RemoveNode(j);
+    merged_node->UpdateTracker(
+        make_shared<CombineInstr>(i->name(), j->name(), merged_node()););
     return merged_node;
   }
 };
diff --git a/paddle/cinn/operator_fusion/pattern.h b/paddle/cinn/operator_fusion/pattern.h
index 9966c06191e7d3..f237b0d48e63c8 100644
--- a/paddle/cinn/operator_fusion/pattern.h
+++ b/paddle/cinn/operator_fusion/pattern.h
@@ -18,6 +18,7 @@
 #include <variant>
 #include <vector>
 #include "glog/logging.h"
+#include "paddle/cinn/operator_fusion/fusion_tracker/tracker.h"
 #include "paddle/cinn/operator_fusion/pir_graph_analyzing/anchor_transform.h"
 #include "paddle/cinn/operator_fusion/utils.h"
 #include "paddle/pir/include/core/operation.h"
@@ -31,7 +32,6 @@ struct PatternContent {
 };
 
 struct StmtPattern;
-struct FusionTracker;
 
 struct TrivialPattern {
   explicit TrivialPattern(const std::vector<pir::Operation*>& ops,
@@ -52,6 +52,7 @@ struct TrivialPattern {
   }
   std::string name() { return name_; }
   std::string name_;
+  FusionTracker* tracker() { return &tracker_; }
   FusionTracker tracker_;
 };
 
@@ -72,6 +73,7 @@ struct ReducePattern {
   }
   std::string name() { return name_; }
   std::string name_;
+  FusionTracker* tracker() { return &tracker_; }
   FusionTracker tracker_;
 };
 
@@ -108,6 +110,7 @@ struct ReduceTreePattern {
   }
   std::string name() { return name_; }
   std::string name_;
+  FusionTracker* tracker() { return &tracker_; }
   FusionTracker tracker_;
 
  private:
@@ -136,6 +139,7 @@ struct ReduceTreePlusTrivialPattern {
   }
   std::string name() { return name_; }
   std::string name_;
+  FusionTracker* tracker() { return &tracker_; }
   FusionTracker tracker_;
 };
 
@@ -182,6 +186,7 @@ struct AnchorPattern {
   }
   std::string name() { return name_; }
   std::string name_;
+  FusionTracker* tracker() { return &tracker_; }
   FusionTracker tracker_;
 
  private:
@@ -220,6 +225,7 @@ struct HorizontalFusionPattern {
   }
   std::string name() { return name_; }
   std::string name_;
+  FusionTracker* tracker() { return &tracker_; }
   FusionTracker tracker_;
 };
 
@@ -238,6 +244,7 @@ struct UnsupportPattern {
   }
   std::string name() { return name_; }
   std::string name_;
+  FusionTracker* tracker() { return &tracker_; }
   FusionTracker tracker_;
 };
 
@@ -256,4 +263,44 @@ struct StmtPattern final : public StmtPatternBase {
   }
 };
 
+std::string StmtPatternDebugStr(const StmtPattern& stmt) {
+  std::stringstream ss;
+  auto all_ops = GetOpsInPattern(stmt);
+  ss << "StmtPattern, size " << all_ops.size() << " :\n";
+  ss << OpsDebugStr(all_ops);
+  return ss.str();
+}
+
+StmtPattern ConvertToStmtPattern(const PatternContent& content) {
+  const auto& kind = GetOpPatternKind(content.op);
+  if (kind == hlir::framework::kReduction) {
+    return ReducePattern({content.op});
+  } else if (kind == hlir::framework::kElementWise ||
+             kind == hlir::framework::kBroadcast ||
+             kind == hlir::framework::kInjective) {
+    return TrivialPattern({content.op}, content.op);
+  } else {
+    return UnsupportPattern({content.op});
+  }
+}
+
+std::string GetPatternName(const StmtPattern& s) {
+  return std::visit([](const auto& impl) { return impl.name(); }, s.variant());
+}
+
+FusionTracker* GetPatternTracker(const StmtPattern& s) {
+  return std::visit([](const auto& impl) { return impl.tracker(); },
+                    s.variant());
+}
+
+std::vector<pir::Operation*> GetOpsInPattern(const StmtPattern& pattern) {
+  return std::visit([](const auto& impl) { return impl.ops(); },
+                    pattern.variant());
+}
+
+pir::Operation* GetSinkOpInPattern(const StmtPattern& pattern) {
+  return std::visit([](const auto& impl) { return impl.sink_op(); },
+                    pattern.variant());
+}
+
 }  // namespace cinn::fusion
diff --git a/paddle/cinn/operator_fusion/pattern_fuser.cc b/paddle/cinn/operator_fusion/pattern_fuser.cc
deleted file mode 100644
index bbcb54798f141e..00000000000000
--- a/paddle/cinn/operator_fusion/pattern_fuser.cc
+++ /dev/null
@@ -1,91 +0,0 @@
-// Copyright (c) 2024 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/cinn/operator_fusion/pattern_fuser.h"
-
-namespace cinn::fusion {
-
-StmtPattern ConvertToStmtPattern(const PatternContent& content) {
-  const auto& kind = GetOpPatternKind(content.op);
-  if (kind == hlir::framework::kReduction) {
-    return ReducePattern({content.op});
-  } else if (kind == hlir::framework::kElementWise ||
-             kind == hlir::framework::kBroadcast ||
-             kind == hlir::framework::kInjective) {
-    return TrivialPattern({content.op}, content.op);
-  } else {
-    return UnsupportPattern({content.op});
-  }
-}
-
-StmtPattern MergePatternImpl(const ReduceTreePattern& first,
-                             const TrivialPattern& second) {
-  return ReduceTreePlusTrivialPattern(first, second);
-}
-
-StmtPattern MergePatternImpl(const TrivialPattern& first,
-                             const ReducePattern& second) {
-  const auto& contents =
-      UniqueConcatVector(GetOpsInPattern(first), GetOpsInPattern(second));
-  return ReducePattern(contents);
-}
-
-StmtPattern MergePatternImpl(const TrivialPattern& first,
-                             const TrivialPattern& second) {
-  const auto& contents =
-      UniqueConcatVector(GetOpsInPattern(first), GetOpsInPattern(second));
-  return TrivialPattern(contents, second.sink_op());
-}
-
-StmtPattern MergePatternImpl(const TrivialPattern& first,
-                             const AnchorPattern& second) {
-  return AnchorPattern(
-      UniqueConcatVector(GetOpsInPattern(first), GetOpsInPattern(second)),
-      second.anchor(),
-      second.anchor_state);
-}
-
-StmtPattern MergePatternImpl(const AnchorPattern& source,
-                             const AnchorPattern& dest) {
-  const auto& contents =
-      UniqueConcatVector(GetOpsInPattern(source), GetOpsInPattern(dest));
-  return AnchorPattern(contents, source.anchor(), AnchorState({}));
-}
-
-ExprPromise InitExprPromiseImpl(const TrivialPattern& pattern,
-                                pir::Value anchor) {
-  return ExprPromise(anchor);
-}
-
-ExprPromise InitExprPromiseImpl(const ReducePattern& pattern,
-                                pir::Value anchor) {
-  return ExprPromise(anchor);
-}
-
-TrivialPattern RecoverAnchorPatternToTrivial(
-    const AnchorPattern& anchor_pattern) {
-  PADDLE_ENFORCE_EQ(anchor_pattern.anchor_state.promise.size(),
-                    1,
-                    phi::errors::PreconditionNotMet(
-                        "Can only recover AnchorPattern whose anchor_state "
-                        "size is 1 (exact %d)",
-                        anchor_pattern.anchor_state.promise.size()));
-
-  return TrivialPattern(anchor_pattern.ops(),
-                        anchor_pattern.anchor().defining_op());
-}
-
-}  // namespace cinn::fusion
diff --git a/paddle/cinn/operator_fusion/pattern_fuser.h b/paddle/cinn/operator_fusion/pattern_fuser.h
index 35a448feb399cc..95ac49511235d5 100644
--- a/paddle/cinn/operator_fusion/pattern_fuser.h
+++ b/paddle/cinn/operator_fusion/pattern_fuser.h
@@ -36,19 +36,35 @@
 
 namespace cinn::fusion {
 
-ReducePattern ToReducePattern(const StmtPattern& second) {
-  return std::get<ReducePattern>(second);
+std::unordered_set<pir::Value> GetPatternInputValuesIncludeInner(
+    const StmtPattern& A) {
+  std::unordered_set<pir::Value> result;
+  for (const auto& op : GetOpsInPattern(A)) {
+    for (const auto& value : op->operands()) {
+      result.insert(value.source());
+    }
+  }
+  return result;
 }
 
-std::string GetPatternName(const StmtPattern& s) {
-  return std::visit([](const auto& impl) { return impl.name(); }, s.variant());
+std::unordered_set<pir::Value> GetPatternOutputValuesIncludedInner(
+    const StmtPattern& A) {
+  std::unordered_set<pir::Value> result;
+  for (const auto& op : GetOpsInPattern(A)) {
+    for (const auto& value : op->results()) {
+      result.insert(value);
+    }
+  }
+  return result;
 }
 
-StmtPattern ConvertToStmtPattern(const PatternContent& content);
-
-std::vector<pir::Operation*> GetOpsInPattern(const StmtPattern& pattern) {
-  return std::visit([](const auto& impl) { return impl.ops(); },
-                    pattern.variant());
+std::unordered_set<pir::Value> GetPatternInputValues(const StmtPattern& A) {
+  auto all_input_values = GetPatternInputValuesIncludeInner(A);
+  for (const auto& value : GetPatternOutputValuesIncludedInner(A)) {
+    all_input_values.erase(value);
+  }
+  VLOG(4) << "GetPatternInputValues: " << all_input_values.size();
+  return all_input_values;
 }
 
 using LoopFramework = std::vector<symbol::DimExpr>;
@@ -80,11 +96,6 @@ bool IsLoopFrameworkEqual(const StmtPattern& lhs, const StmtPattern& rhs) {
   return SqueezeLoopFramework(lhs_loop) == SqueezeLoopFramework(rhs_loop);
 }
 
-pir::Operation* GetSinkOpInPattern(const StmtPattern& pattern) {
-  return std::visit([](const auto& impl) { return impl.sink_op(); },
-                    pattern.variant());
-}
-
 struct LoopFrameworkVisitor {
   MaybeLoopFramework operator()(const ReducePattern& pattern) {
     pir::Operation* reduce_op = pattern.GetReduceOp();
@@ -161,99 +172,6 @@ MaybeLoopFramework GetLoopFramework(const StmtPattern& pattern) {
   return std::visit(LoopFrameworkVisitor(), pattern.variant());
 }
 
-bool IsReducePattern(const StmtPattern& pattern) {
-  return std::holds_alternative<ReducePattern>(pattern);
-}
-
-bool IsReduceTreePattern(const StmtPattern& pattern) {
-  return std::holds_alternative<ReduceTreePattern>(pattern);
-}
-
-bool IsOpsDependents(const StmtPattern& pattern) {
-  return std::holds_alternative<ReduceTreePattern>(pattern);
-}
-
-bool IsUnsupportPattern(const StmtPattern& pattern) {
-  return std::holds_alternative<UnsupportPattern>(pattern);
-}
-
-bool IsReduceTrivialPattern(const StmtPattern& pattern) {
-  return std::holds_alternative<ReduceTreePlusTrivialPattern>(pattern);
-}
-
-std::unordered_set<pir::Value> GetPatternInputValuesIncludeInner(
-    const StmtPattern& A) {
-  std::unordered_set<pir::Value> result;
-  for (const auto& op : GetOpsInPattern(A)) {
-    for (const auto& value : op->operands()) {
-      result.insert(value.source());
-    }
-  }
-  return result;
-}
-
-std::unordered_set<pir::Value> GetPatternOutputValuesIncludedInner(
-    const StmtPattern& A) {
-  std::unordered_set<pir::Value> result;
-  for (const auto& op : GetOpsInPattern(A)) {
-    for (const auto& value : op->results()) {
-      result.insert(value);
-    }
-  }
-  return result;
-}
-
-std::unordered_set<pir::Value> GetPatternInputValues(const StmtPattern& A) {
-  auto all_input_values = GetPatternInputValuesIncludeInner(A);
-  for (const auto& value : GetPatternOutputValuesIncludedInner(A)) {
-    all_input_values.erase(value);
-  }
-  VLOG(4) << "GetPatternInputValues: " << all_input_values.size();
-  return all_input_values;
-}
-
-std::string StmtPatternDebugStr(const StmtPattern& stmt) {
-  std::stringstream ss;
-  auto all_ops = GetOpsInPattern(stmt);
-  ss << "StmtPattern, size " << all_ops.size() << " :\n";
-  ss << OpsDebugStr(all_ops);
-  return ss.str();
-}
-
-static bool IsDirectUpstream(const pir::Operation* upstream,
-                             const pir::Operation* downstream) {
-  for (const auto& value : downstream->results()) {
-    for (const auto& operand : upstream->operands()) {
-      if (value == operand.source()) {
-        return true;
-      }
-    }
-  }
-  return false;
-}
-
-int InsertDownstreamIntoTree(const ReduceTreePattern& upstream,
-                             ReduceTreePattern& downstream) {  // NOLINT
-  if (IsDirectUpstream(upstream.GetRootPattern().GetReduceOp(),
-                       downstream.GetRootPattern().GetReduceOp())) {
-    downstream.InsertChild(upstream);
-    return 1;
-  }
-  int insert_num = 0;
-  for (auto& child : downstream.childs()) {
-    insert_num += InsertDownstreamIntoTree(upstream, child);
-  }
-  return insert_num;
-}
-
-StmtPattern MergePatternImpl(const ReduceTreePattern& upstream,
-                             const ReduceTreePattern& downstream) {
-  ReduceTreePattern result = downstream;  // copy first.
-  int insert_num = InsertDownstreamIntoTree(upstream, result);
-  CHECK(insert_num == 1) << "Must insert only once, but insert " << insert_num;
-  return result;
-}
-
 inline auto GetPaddingVector(const MaybeLoopFramework& first,
                              const MaybeLoopFramework& second) {
   // two pointer to get the padding body.
@@ -302,6 +220,59 @@ StmtPattern MergePatternImpl(const HorizontalFusionPattern& first,
   return HorizontalFusionPattern({pad_first, pad_second});
 }
 
+static bool IsDirectUpstream(const pir::Operation* upstream,
+                             const pir::Operation* downstream) {
+  for (const auto& value : downstream->results()) {
+    for (const auto& operand : upstream->operands()) {
+      if (value == operand.source()) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
+int InsertDownstreamIntoTree(const ReduceTreePattern& upstream,
+                             ReduceTreePattern& downstream) {  // NOLINT
+  if (IsDirectUpstream(upstream.GetRootPattern().GetReduceOp(),
+                       downstream.GetRootPattern().GetReduceOp())) {
+    downstream.InsertChild(upstream);
+    return 1;
+  }
+  int insert_num = 0;
+  for (auto& child : downstream.childs()) {
+    insert_num += InsertDownstreamIntoTree(upstream, child);
+  }
+  return insert_num;
+}
+
+StmtPattern MergePatternImpl(const ReduceTreePattern& upstream,
+                             const ReduceTreePattern& downstream) {
+  ReduceTreePattern result = downstream;  // copy first.
+  int insert_num = InsertDownstreamIntoTree(upstream, result);
+  CHECK(insert_num == 1) << "Must insert only once, but insert " << insert_num;
+  return result;
+}
+
+StmtPattern MergePatternImpl(const ReduceTreePattern& first,
+                             const TrivialPattern& second) {
+  return ReduceTreePlusTrivialPattern(first, second);
+}
+
+StmtPattern MergePatternImpl(const TrivialPattern& first,
+                             const ReducePattern& second) {
+  const auto& contents =
+      UniqueConcatVector(GetOpsInPattern(first), GetOpsInPattern(second));
+  return ReducePattern(contents);
+}
+
+StmtPattern MergePatternImpl(const TrivialPattern& first,
+                             const TrivialPattern& second) {
+  const auto& contents =
+      UniqueConcatVector(GetOpsInPattern(first), GetOpsInPattern(second));
+  return TrivialPattern(contents, second.sink_op());
+}
+
 template <typename A, typename B>
 B FusePatternIfConnected(A up_pattern,
                          B down_pattern,
@@ -313,15 +284,6 @@ B FusePatternIfConnected(A up_pattern,
   }
 }
 
-StmtPattern MergePatternImpl(const ReduceTreePattern& first,
-                             const TrivialPattern& second);
-
-StmtPattern MergePatternImpl(const TrivialPattern& first,
-                             const ReducePattern& second);
-
-StmtPattern MergePatternImpl(const TrivialPattern& first,
-                             const TrivialPattern& second);
-
 StmtPattern MergePatternImpl(const TrivialPattern& first,
                              const ReduceTreePattern& second) {
   auto connect_ops = FindDownstreamOps(first.sink_op());
@@ -347,10 +309,19 @@ StmtPattern MergePatternImpl(const TrivialPattern& first,
 }
 
 StmtPattern MergePatternImpl(const TrivialPattern& first,
-                             const AnchorPattern& second);
+                             const AnchorPattern& second) {
+  return AnchorPattern(
+      UniqueConcatVector(GetOpsInPattern(first), GetOpsInPattern(second)),
+      second.anchor(),
+      second.anchor_state);
+}
 
 StmtPattern MergePatternImpl(const AnchorPattern& source,
-                             const AnchorPattern& dest);
+                             const AnchorPattern& dest) {
+  const auto& contents =
+      UniqueConcatVector(GetOpsInPattern(source), GetOpsInPattern(dest));
+  return AnchorPattern(contents, source.anchor(), AnchorState({}));
+}
 
 StmtPattern MergePattern(const StmtPattern& first, const StmtPattern& second) {
   VLOG(4) << "MergePattern: " << GetPatternName(first) << " x "
@@ -393,10 +364,14 @@ StmtPattern MergePattern(const StmtPattern& first, const StmtPattern& second) {
 }
 
 ExprPromise InitExprPromiseImpl(const TrivialPattern& pattern,
-                                pir::Value anchor);
+                                pir::Value anchor) {
+  return ExprPromise(anchor);
+}
 
 ExprPromise InitExprPromiseImpl(const ReducePattern& pattern,
-                                pir::Value anchor);
+                                pir::Value anchor) {
+  return ExprPromise(anchor);
+}
 
 ExprPromise InitExprPromiseImpl(const ReduceTreePattern& pattern,
                                 pir::Value anchor) {
@@ -415,7 +390,17 @@ ExprPromise InitExprPromise(const StmtPattern& pattern, pir::Value anchor) {
 }
 
 TrivialPattern RecoverAnchorPatternToTrivial(
-    const AnchorPattern& anchor_pattern);
+    const AnchorPattern& anchor_pattern) {
+  PADDLE_ENFORCE_EQ(anchor_pattern.anchor_state.promise.size(),
+                    1,
+                    phi::errors::PreconditionNotMet(
+                        "Can only recover AnchorPattern whose anchor_state "
+                        "size is 1 (exact %d)",
+                        anchor_pattern.anchor_state.promise.size()));
+
+  return TrivialPattern(anchor_pattern.ops(),
+                        anchor_pattern.anchor().defining_op());
+}
 
 AnchorState GetAnchorState(const AnchorPattern& pattern) {
   return pattern.anchor_state;
diff --git a/paddle/cinn/operator_fusion/pattern_node.h b/paddle/cinn/operator_fusion/pattern_node.h
index 13f1938964068e..e1a8dee060bab9 100644
--- a/paddle/cinn/operator_fusion/pattern_node.h
+++ b/paddle/cinn/operator_fusion/pattern_node.h
@@ -63,6 +63,7 @@ struct PatternNode {
   void set_stmt_pattern(const StmtPattern& pattern) { stmt_pattern_ = pattern; }
   const std::vector<PatternNodePtr>& upstream() const { return upstream_; }
   const std::vector<PatternNodePtr>& downstream() const { return downstream_; }
+  const std::string& name() const { return GetPatternName(stmt_pattern_); }
   void AddNodeToUpstream(PatternNodePtr node) { upstream_.push_back(node); }
   void AddNodeToDownstream(PatternNodePtr node) { downstream_.push_back(node); }
   void RemoveNodeFromUpstream(PatternNodePtr node) {
@@ -75,6 +76,9 @@ struct PatternNode {
   void ClearDownstream() { downstream_.clear(); }
   void UniqueUpstream() { upstream_ = UniqueVectorBySet(upstream_); }
   void UniqueDownstream() { downstream_ = UniqueVectorBySet(downstream_); }
+  void UpdateTracker(FusionInstrPtr instr) {
+    GetPatternTracker(stmt_pattern_)->append(instr);
+  }
 
  private:
   StmtPattern stmt_pattern_;

From 6f264e93041a5ddc8775e3408e0d52b8d5b22076 Mon Sep 17 00:00:00 2001
From: feifei-111 <2364819892@qq.com>
Date: Wed, 29 May 2024 12:44:51 +0000
Subject: [PATCH 68/99] update

---
 paddle/cinn/operator_fusion/pattern.h       |  45 ++-
 paddle/cinn/operator_fusion/pattern_fuser.h | 333 +++++++++-----------
 paddle/cinn/operator_fusion/utils.h         |  12 +
 3 files changed, 207 insertions(+), 183 deletions(-)

diff --git a/paddle/cinn/operator_fusion/pattern.h b/paddle/cinn/operator_fusion/pattern.h
index f237b0d48e63c8..012f9f94b18784 100644
--- a/paddle/cinn/operator_fusion/pattern.h
+++ b/paddle/cinn/operator_fusion/pattern.h
@@ -52,7 +52,7 @@ struct TrivialPattern {
   }
   std::string name() { return name_; }
   std::string name_;
-  FusionTracker* tracker() { return &tracker_; }
+
   FusionTracker tracker_;
 };
 
@@ -73,7 +73,7 @@ struct ReducePattern {
   }
   std::string name() { return name_; }
   std::string name_;
-  FusionTracker* tracker() { return &tracker_; }
+
   FusionTracker tracker_;
 };
 
@@ -110,7 +110,7 @@ struct ReduceTreePattern {
   }
   std::string name() { return name_; }
   std::string name_;
-  FusionTracker* tracker() { return &tracker_; }
+
   FusionTracker tracker_;
 
  private:
@@ -139,7 +139,7 @@ struct ReduceTreePlusTrivialPattern {
   }
   std::string name() { return name_; }
   std::string name_;
-  FusionTracker* tracker() { return &tracker_; }
+
   FusionTracker tracker_;
 };
 
@@ -186,7 +186,7 @@ struct AnchorPattern {
   }
   std::string name() { return name_; }
   std::string name_;
-  FusionTracker* tracker() { return &tracker_; }
+
   FusionTracker tracker_;
 
  private:
@@ -225,7 +225,7 @@ struct HorizontalFusionPattern {
   }
   std::string name() { return name_; }
   std::string name_;
-  FusionTracker* tracker() { return &tracker_; }
+
   FusionTracker tracker_;
 };
 
@@ -244,7 +244,7 @@ struct UnsupportPattern {
   }
   std::string name() { return name_; }
   std::string name_;
-  FusionTracker* tracker() { return &tracker_; }
+
   FusionTracker tracker_;
 };
 
@@ -303,4 +303,35 @@ pir::Operation* GetSinkOpInPattern(const StmtPattern& pattern) {
                     pattern.variant());
 }
 
+std::unordered_set<pir::Value> GetPatternInputValuesIncludeInner(
+    const StmtPattern& A) {
+  std::unordered_set<pir::Value> result;
+  for (const auto& op : GetOpsInPattern(A)) {
+    for (const auto& value : op->operands()) {
+      result.insert(value.source());
+    }
+  }
+  return result;
+}
+
+std::unordered_set<pir::Value> GetPatternOutputValuesIncludedInner(
+    const StmtPattern& A) {
+  std::unordered_set<pir::Value> result;
+  for (const auto& op : GetOpsInPattern(A)) {
+    for (const auto& value : op->results()) {
+      result.insert(value);
+    }
+  }
+  return result;
+}
+
+std::unordered_set<pir::Value> GetPatternInputValues(const StmtPattern& A) {
+  auto all_input_values = GetPatternInputValuesIncludeInner(A);
+  for (const auto& value : GetPatternOutputValuesIncludedInner(A)) {
+    all_input_values.erase(value);
+  }
+  VLOG(4) << "GetPatternInputValues: " << all_input_values.size();
+  return all_input_values;
+}
+
 }  // namespace cinn::fusion
diff --git a/paddle/cinn/operator_fusion/pattern_fuser.h b/paddle/cinn/operator_fusion/pattern_fuser.h
index 95ac49511235d5..f7fb02416b1a7b 100644
--- a/paddle/cinn/operator_fusion/pattern_fuser.h
+++ b/paddle/cinn/operator_fusion/pattern_fuser.h
@@ -36,37 +36,170 @@
 
 namespace cinn::fusion {
 
-std::unordered_set<pir::Value> GetPatternInputValuesIncludeInner(
-    const StmtPattern& A) {
-  std::unordered_set<pir::Value> result;
-  for (const auto& op : GetOpsInPattern(A)) {
-    for (const auto& value : op->operands()) {
-      result.insert(value.source());
-    }
+// Trivial x other
+
+StmtPattern MergePatternImpl(const TrivialPattern& first,
+                             const TrivialPattern& second) {
+  const auto& contents =
+      UniqueConcatVector(GetOpsInPattern(first), GetOpsInPattern(second));
+  return TrivialPattern(contents,
+                        second.sink_op(),
+                        FusionTracker(first.tracker_, second.tracker_));
+}
+
+StmtPattern MergePatternImpl(const TrivialPattern& first,
+                             const ReducePattern& second) {
+  const auto& contents =
+      UniqueConcatVector(GetOpsInPattern(first), GetOpsInPattern(second));
+  return ReducePattern(contents,
+                       FusionTracker(first.tracker_, second.tracker_));
+}
+
+template <typename A, typename B>
+B FusePatternIfConnected(A up_pattern,
+                         B down_pattern,
+                         std::vector<pir::Operation*> connect_ops) {
+  if (AnyTargetInCandidate(connect_ops, down_pattern.ops())) {
+    return std::get<B>(MergePatternImpl(up_pattern, down_pattern));
+  } else {
+    return down_pattern;
   }
-  return result;
 }
 
-std::unordered_set<pir::Value> GetPatternOutputValuesIncludedInner(
-    const StmtPattern& A) {
-  std::unordered_set<pir::Value> result;
-  for (const auto& op : GetOpsInPattern(A)) {
-    for (const auto& value : op->results()) {
-      result.insert(value);
-    }
+StmtPattern MergePatternImpl(const TrivialPattern& first,
+                             const ReduceTreePattern& second) {
+  auto connect_ops = FindDownstreamOps(first.sink_op());
+
+  auto old_childs = second.childs();
+  std::vector<ReduceTreePattern> new_childs;
+  for (const auto& old_child : old_childs) {
+    new_childs.emplace_back(
+        FusePatternIfConnected(first, old_child, connect_ops));
+  }
+
+  return ReduceTreePattern(
+      new_childs,
+      FusePatternIfConnected(first, second.GetRootPattern(), connect_ops),
+      FusionTracker(first.tracker_, second.tracker_));
+}
+
+StmtPattern MergePatternImpl(const TrivialPattern& first,
+                             const ReduceTreePlusTrivialPattern& second) {
+  auto connect_ops = FindDownstreamOps(first.sink_op());
+  return ReduceTreePlusTrivialPattern(
+      FusePatternIfConnected(first, second.tree, connect_ops),
+      FusePatternIfConnected(first, second.sink_trivial, connect_ops),
+      FusionTracker(first.tracker_, second.tracker_));
+}
+
+StmtPattern MergePatternImpl(const TrivialPattern& first,
+                             const AnchorPattern& second) {
+  return AnchorPattern(
+      UniqueConcatVector(GetOpsInPattern(first), GetOpsInPattern(second)),
+      second.anchor(),
+      second.anchor_state,
+      FusionTracker(first.tracker_, second.tracker_));
+}
+
+// RR & RT
+
+int InsertDownstreamIntoTree(const ReduceTreePattern& upstream,
+                             ReduceTreePattern& downstream) {  // NOLINT
+  if (IsDirectUpstream(upstream.GetRootPattern().GetReduceOp(),
+                       downstream.GetRootPattern().GetReduceOp())) {
+    downstream.InsertChild(upstream);
+    return 1;
   }
+  int insert_num = 0;
+  for (auto& child : downstream.childs()) {
+    insert_num += InsertDownstreamIntoTree(upstream, child);
+  }
+  return insert_num;
+}
+
+StmtPattern MergePatternImpl(const ReduceTreePattern& upstream,
+                             const ReduceTreePattern& downstream) {
+  ReduceTreePattern result = ReduceTreePattern(
+      dowstream.childs(),
+      downstream.GetRootPattern(),
+      FusionTracker(first.tracker_, second.tracker_));  // copy first.
+  int insert_num = InsertDownstreamIntoTree(upstream, result);
+  CHECK(insert_num == 1) << "Must insert only once, but insert " << insert_num;
   return result;
 }
 
-std::unordered_set<pir::Value> GetPatternInputValues(const StmtPattern& A) {
-  auto all_input_values = GetPatternInputValuesIncludeInner(A);
-  for (const auto& value : GetPatternOutputValuesIncludedInner(A)) {
-    all_input_values.erase(value);
+StmtPattern MergePatternImpl(const ReduceTreePattern& first,
+                             const TrivialPattern& second) {
+  return ReduceTreePlusTrivialPattern(
+      first, second, FusionTracker(first.tracker_, second.tracker_));
+}
+
+// Anchor Fusion
+ExprPromise InitExprPromiseImpl(const TrivialPattern& pattern,
+                                pir::Value anchor) {
+  return ExprPromise(anchor);
+}
+
+ExprPromise InitExprPromiseImpl(const ReducePattern& pattern,
+                                pir::Value anchor) {
+  return ExprPromise(anchor);
+}
+
+ExprPromise InitExprPromiseImpl(const ReduceTreePattern& pattern,
+                                pir::Value anchor) {
+  return InitExprPromiseImpl(pattern.GetRootPattern(), anchor);
+}
+
+template <typename T, template <typename> typename PATTERN>
+ExprPromise InitExprPromiseImpl(const PATTERN& pattern, pir::Value anchor) {
+  PADDLE_THROW("Can not Init ExprPromise");
+}
+
+ExprPromise InitExprPromise(const StmtPattern& pattern, pir::Value anchor) {
+  return std::visit(
+      [anchor](const auto& arg) { return InitExprPromiseImpl(arg, anchor); },
+      pattern.variant());
+}
+
+StmtPattern MergePatternImpl(const AnchorPattern& source,
+                             const AnchorPattern& dest) {
+  const auto& contents =
+      UniqueConcatVector(GetOpsInPattern(source), GetOpsInPattern(dest));
+  return AnchorPattern(contents,
+                       source.anchor(),
+                       AnchorState({}),
+                       FusionTracker(source.tracker_, dest.tracker_));
+}
+
+TrivialPattern RecoverAnchorPatternToTrivial(
+    const AnchorPattern& anchor_pattern) {
+  PADDLE_ENFORCE_EQ(anchor_pattern.anchor_state.promise.size(),
+                    1,
+                    phi::errors::PreconditionNotMet(
+                        "Can only recover AnchorPattern whose anchor_state "
+                        "size is 1 (exact %d)",
+                        anchor_pattern.anchor_state.promise.size()));
+
+  return TrivialPattern(anchor_pattern.ops(),
+                        anchor_pattern.anchor().defining_op(),
+                        anchor_pattern.tracker_);
+}
+
+AnchorState GetAnchorState(const AnchorPattern& pattern) {
+  return pattern.anchor_state;
+}
+
+AnchorState ApplyAnchorTransformRoute(const AnchorState& anchor_state,
+                                      const AnchorTransformRoute& route) {
+  AnchorState result = anchor_state;
+  for (auto promise : result.promise) {
+    promise.update(route);
   }
-  VLOG(4) << "GetPatternInputValues: " << all_input_values.size();
-  return all_input_values;
+  return result;
 }
 
+// Horizontal
+
 using LoopFramework = std::vector<symbol::DimExpr>;
 
 // std::optional({}) means not sure.
@@ -217,111 +350,11 @@ StmtPattern MergePatternImpl(const HorizontalFusionPattern& first,
                                         GetLoopFramework(StmtPattern(second)));
   typename HorizontalFusionPattern::PaddingStmtPattern pad_first = {first, f};
   typename HorizontalFusionPattern::PaddingStmtPattern pad_second = {second, s};
-  return HorizontalFusionPattern({pad_first, pad_second});
-}
-
-static bool IsDirectUpstream(const pir::Operation* upstream,
-                             const pir::Operation* downstream) {
-  for (const auto& value : downstream->results()) {
-    for (const auto& operand : upstream->operands()) {
-      if (value == operand.source()) {
-        return true;
-      }
-    }
-  }
-  return false;
-}
-
-int InsertDownstreamIntoTree(const ReduceTreePattern& upstream,
-                             ReduceTreePattern& downstream) {  // NOLINT
-  if (IsDirectUpstream(upstream.GetRootPattern().GetReduceOp(),
-                       downstream.GetRootPattern().GetReduceOp())) {
-    downstream.InsertChild(upstream);
-    return 1;
-  }
-  int insert_num = 0;
-  for (auto& child : downstream.childs()) {
-    insert_num += InsertDownstreamIntoTree(upstream, child);
-  }
-  return insert_num;
-}
-
-StmtPattern MergePatternImpl(const ReduceTreePattern& upstream,
-                             const ReduceTreePattern& downstream) {
-  ReduceTreePattern result = downstream;  // copy first.
-  int insert_num = InsertDownstreamIntoTree(upstream, result);
-  CHECK(insert_num == 1) << "Must insert only once, but insert " << insert_num;
-  return result;
-}
-
-StmtPattern MergePatternImpl(const ReduceTreePattern& first,
-                             const TrivialPattern& second) {
-  return ReduceTreePlusTrivialPattern(first, second);
-}
-
-StmtPattern MergePatternImpl(const TrivialPattern& first,
-                             const ReducePattern& second) {
-  const auto& contents =
-      UniqueConcatVector(GetOpsInPattern(first), GetOpsInPattern(second));
-  return ReducePattern(contents);
-}
-
-StmtPattern MergePatternImpl(const TrivialPattern& first,
-                             const TrivialPattern& second) {
-  const auto& contents =
-      UniqueConcatVector(GetOpsInPattern(first), GetOpsInPattern(second));
-  return TrivialPattern(contents, second.sink_op());
-}
-
-template <typename A, typename B>
-B FusePatternIfConnected(A up_pattern,
-                         B down_pattern,
-                         std::vector<pir::Operation*> connect_ops) {
-  if (AnyTargetInCandidate(connect_ops, down_pattern.ops())) {
-    return std::get<B>(MergePatternImpl(up_pattern, down_pattern));
-  } else {
-    return down_pattern;
-  }
-}
-
-StmtPattern MergePatternImpl(const TrivialPattern& first,
-                             const ReduceTreePattern& second) {
-  auto connect_ops = FindDownstreamOps(first.sink_op());
-
-  auto old_childs = second.childs();
-  std::vector<ReduceTreePattern> new_childs;
-  for (const auto& old_child : old_childs) {
-    new_childs.emplace_back(
-        FusePatternIfConnected(first, old_child, connect_ops));
-  }
-
-  return ReduceTreePattern(
-      new_childs,
-      FusePatternIfConnected(first, second.GetRootPattern(), connect_ops));
+  return HorizontalFusionPattern(
+      {pad_first, pad_second}, FusionTracker(first.tracker_, second.tracker_));
 }
 
-StmtPattern MergePatternImpl(const TrivialPattern& first,
-                             const ReduceTreePlusTrivialPattern& second) {
-  auto connect_ops = FindDownstreamOps(first.sink_op());
-  return ReduceTreePlusTrivialPattern(
-      FusePatternIfConnected(first, second.tree, connect_ops),
-      FusePatternIfConnected(first, second.sink_trivial, connect_ops));
-}
-
-StmtPattern MergePatternImpl(const TrivialPattern& first,
-                             const AnchorPattern& second) {
-  return AnchorPattern(
-      UniqueConcatVector(GetOpsInPattern(first), GetOpsInPattern(second)),
-      second.anchor(),
-      second.anchor_state);
-}
-
-StmtPattern MergePatternImpl(const AnchorPattern& source,
-                             const AnchorPattern& dest) {
-  const auto& contents =
-      UniqueConcatVector(GetOpsInPattern(source), GetOpsInPattern(dest));
-  return AnchorPattern(contents, source.anchor(), AnchorState({}));
-}
+//
 
 StmtPattern MergePattern(const StmtPattern& first, const StmtPattern& second) {
   VLOG(4) << "MergePattern: " << GetPatternName(first) << " x "
@@ -363,56 +396,4 @@ StmtPattern MergePattern(const StmtPattern& first, const StmtPattern& second) {
   return std::visit(PatternMatch, first.variant(), second.variant());
 }
 
-ExprPromise InitExprPromiseImpl(const TrivialPattern& pattern,
-                                pir::Value anchor) {
-  return ExprPromise(anchor);
-}
-
-ExprPromise InitExprPromiseImpl(const ReducePattern& pattern,
-                                pir::Value anchor) {
-  return ExprPromise(anchor);
-}
-
-ExprPromise InitExprPromiseImpl(const ReduceTreePattern& pattern,
-                                pir::Value anchor) {
-  return InitExprPromiseImpl(pattern.GetRootPattern(), anchor);
-}
-
-template <typename T, template <typename> typename PATTERN>
-ExprPromise InitExprPromiseImpl(const PATTERN& pattern, pir::Value anchor) {
-  PADDLE_THROW("Can not Init ExprPromise");
-}
-
-ExprPromise InitExprPromise(const StmtPattern& pattern, pir::Value anchor) {
-  return std::visit(
-      [anchor](const auto& arg) { return InitExprPromiseImpl(arg, anchor); },
-      pattern.variant());
-}
-
-TrivialPattern RecoverAnchorPatternToTrivial(
-    const AnchorPattern& anchor_pattern) {
-  PADDLE_ENFORCE_EQ(anchor_pattern.anchor_state.promise.size(),
-                    1,
-                    phi::errors::PreconditionNotMet(
-                        "Can only recover AnchorPattern whose anchor_state "
-                        "size is 1 (exact %d)",
-                        anchor_pattern.anchor_state.promise.size()));
-
-  return TrivialPattern(anchor_pattern.ops(),
-                        anchor_pattern.anchor().defining_op());
-}
-
-AnchorState GetAnchorState(const AnchorPattern& pattern) {
-  return pattern.anchor_state;
-}
-
-AnchorState ApplyAnchorTransformRoute(const AnchorState& anchor_state,
-                                      const AnchorTransformRoute& route) {
-  AnchorState result = anchor_state;
-  for (auto promise : result.promise) {
-    promise.update(route);
-  }
-  return result;
-}
-
 }  // namespace cinn::fusion
diff --git a/paddle/cinn/operator_fusion/utils.h b/paddle/cinn/operator_fusion/utils.h
index a15b79d1ceeb7b..0031c640089c42 100644
--- a/paddle/cinn/operator_fusion/utils.h
+++ b/paddle/cinn/operator_fusion/utils.h
@@ -445,4 +445,16 @@ static const size_t GetResultIdx(const pir::Value& v, pir::Operation* op) {
       "Can not find the value %s as result of op %s", v.impl(), op->name()));
 }
 
+static bool IsDirectUpstream(const pir::Operation* upstream,
+                             const pir::Operation* downstream) {
+  for (const auto& value : downstream->results()) {
+    for (const auto& operand : upstream->operands()) {
+      if (value == operand.source()) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
 }  // namespace cinn::fusion

From c6d1edcb88ba4f1c7652fc932a64869e803a25b8 Mon Sep 17 00:00:00 2001
From: feifei-111 <2364819892@qq.com>
Date: Thu, 30 May 2024 14:44:03 +0000
Subject: [PATCH 69/99] support cluster pass and add tracker to fusionOp

---
 .../dialect/operator/ir/attribute_storage.h   | 21 ++++++
 .../hlir/dialect/operator/ir/manual_op.cc     |  9 ++-
 .../cinn/hlir/dialect/operator/ir/manual_op.h |  5 +-
 .../hlir/dialect/operator/ir/op_attribute.cc  |  6 ++
 .../hlir/dialect/operator/ir/op_attribute.h   | 17 +++++
 .../hlir/dialect/operator/ir/op_dialect.cc    |  5 ++
 .../operator/transforms/attr_adt_type_id.h    |  4 +-
 .../transforms/cinn_group_cluster_pass.cc     | 41 +++++++----
 .../transforms/pir_to_py_code_converter.cc    |  6 ++
 .../fusion_tracker/interpreter.h              |  7 ++
 .../operator_fusion/fusion_tracker/tracker.h  | 73 +++++++++----------
 paddle/cinn/operator_fusion/group_cluster.h   |  7 +-
 paddle/cinn/operator_fusion/pattern.h         | 68 +++++++----------
 paddle/cinn/operator_fusion/pattern_fuser.h   | 63 +++++++++++-----
 paddle/cinn/operator_fusion/pattern_graph.cc  |  9 +--
 paddle/cinn/operator_fusion/pattern_graph.h   |  1 -
 paddle/cinn/operator_fusion/pattern_node.h    |  1 -
 .../policy/general_topo_policy.cc             |  3 -
 .../policy/relative_judge_policy.cc           |  3 -
 19 files changed, 212 insertions(+), 137 deletions(-)

diff --git a/paddle/cinn/hlir/dialect/operator/ir/attribute_storage.h b/paddle/cinn/hlir/dialect/operator/ir/attribute_storage.h
index 770eeb4b557014..03bb698e4a9e3d 100644
--- a/paddle/cinn/hlir/dialect/operator/ir/attribute_storage.h
+++ b/paddle/cinn/hlir/dialect/operator/ir/attribute_storage.h
@@ -20,6 +20,7 @@
 #include <vector>
 #include "paddle/cinn/hlir/framework/op.h"
 #include "paddle/cinn/hlir/framework/pir/utils.h"
+#include "paddle/cinn/operator_fusion/fusion_tracker/tracker.h"
 #include "paddle/pir/include/core/attribute_base.h"
 #include "paddle/pir/include/core/operation.h"
 #include "paddle/pir/include/dialect/shape/utils/dim_expr.h"
@@ -100,6 +101,26 @@ struct GroupInfoAttributeStorage : public pir::AttributeStorage {
   ParamKey data_;
 };
 
+struct FusionTrackerPtrAttributeStorage : public pir::AttributeStorage {
+  using ParamKey = cinn::fusion::FusionTrackerPtr;
+  explicit FusionTrackerPtrAttributeStorage(const ParamKey& key) : data_(key) {}
+
+  static FusionTrackerPtrAttributeStorage* Construct(const ParamKey& key) {
+    return new FusionTrackerPtrAttributeStorage(key);
+  }
+
+  static std::size_t HashValue(const ParamKey& key) {
+    return std::hash<ParamKey>()(key);
+  }
+
+  bool operator==(const ParamKey& key) const { return data_ == key; }
+
+  const ParamKey& GetAsKey() const { return data_; }
+
+ private:
+  ParamKey data_;
+};
+
 struct CINNKernelInfoAttributeStorage : public pir::AttributeStorage {
   using ParamKey = cinn::hlir::framework::pir::CINNKernelInfo;
   explicit CINNKernelInfoAttributeStorage(const ParamKey& key) : data_(key) {}
diff --git a/paddle/cinn/hlir/dialect/operator/ir/manual_op.cc b/paddle/cinn/hlir/dialect/operator/ir/manual_op.cc
index 801f8f7654d4cc..40f1c6fc567c8c 100644
--- a/paddle/cinn/hlir/dialect/operator/ir/manual_op.cc
+++ b/paddle/cinn/hlir/dialect/operator/ir/manual_op.cc
@@ -36,7 +36,8 @@ namespace dialect {
 using DenseTensorType = paddle::dialect::DenseTensorType;
 
 const char* GroupOp::attributes_name[GroupOp::attributes_num] = {"group_info"};
-const char* FusionOp::attributes_name[GroupOp::attributes_num] = {"group_info"};
+const char* FusionOp::attributes_name[FusionOp::attributes_num] = {
+    "group_info", "fusion_tracker"};
 const char* ConcatOp::attributes_name[ConcatOp::attributes_num] = {"axis"};
 const char* SplitOp::attributes_name[SplitOp::attributes_num] = {
     "num_or_sections", "axis"};
@@ -145,13 +146,17 @@ void FusionOp::Build(pir::Builder& builder,
 void FusionOp::Build(pir::Builder& builder,             // NOLINT
                      pir::OperationArgument& argument,  // NOLINT
                      const std::vector<pir::Type>& output_types,
-                     const cinn::dialect::GroupInfo& group_info) {
+                     const cinn::dialect::GroupInfo& group_info,
+                     const cinn::fusion::FusionTrackerPtr& tracker) {
   argument.AddRegion(nullptr);
   argument.output_types = output_types;
 
   argument.AddAttribute("group_info",
                         cinn::dialect::GroupInfoAttribute::get(
                             pir::IrContext::Instance(), group_info));
+  argument.AddAttribute("fusion_tracker",
+                        cinn::dialect::FusionTrackerPtrAttribute::get(
+                            pir::IrContext::Instance(), tracker));
 }
 
 pir::Block* FusionOp::block() {
diff --git a/paddle/cinn/hlir/dialect/operator/ir/manual_op.h b/paddle/cinn/hlir/dialect/operator/ir/manual_op.h
index ba43fd7e325f43..e136a0197eb18d 100644
--- a/paddle/cinn/hlir/dialect/operator/ir/manual_op.h
+++ b/paddle/cinn/hlir/dialect/operator/ir/manual_op.h
@@ -66,7 +66,7 @@ class IR_API FusionOp
  public:
   using Op::Op;
   static const char *name() { return "cinn_op.fusion"; }
-  static constexpr uint32_t attributes_num = 1;
+  static constexpr uint32_t attributes_num = 2;
   static const char *attributes_name[attributes_num];
   static void Build(pir::Builder &builder,             // NOLINT
                     pir::OperationArgument &argument,  // NOLINT
@@ -75,7 +75,8 @@ class IR_API FusionOp
   static void Build(pir::Builder &builder,             // NOLINT
                     pir::OperationArgument &argument,  // NOLINT
                     const std::vector<pir::Type> &output_types,
-                    const cinn::dialect::GroupInfo &group_info);
+                    const cinn::dialect::GroupInfo &group_info,
+                    const cinn::fusion::FusionTrackerPtr &tracker);
 
   pir::Block *block();
   pir::Block *block() const;
diff --git a/paddle/cinn/hlir/dialect/operator/ir/op_attribute.cc b/paddle/cinn/hlir/dialect/operator/ir/op_attribute.cc
index f1b4c7c8913a73..6c81e4157604e6 100644
--- a/paddle/cinn/hlir/dialect/operator/ir/op_attribute.cc
+++ b/paddle/cinn/hlir/dialect/operator/ir/op_attribute.cc
@@ -16,6 +16,11 @@
 
 namespace cinn {
 namespace dialect {
+
+const cinn::fusion::FusionTrackerPtr &FusionTrackerPtrAttribute::data() const {
+  return storage()->GetAsKey();
+}
+
 const GroupInfo &GroupInfoAttribute::data() const {
   return storage()->GetAsKey();
 }
@@ -29,3 +34,4 @@ CINNKernelInfoAttribute::data() const {
 
 IR_DEFINE_EXPLICIT_TYPE_ID(cinn::dialect::GroupInfoAttribute)
 IR_DEFINE_EXPLICIT_TYPE_ID(cinn::dialect::CINNKernelInfoAttribute)
+IR_DEFINE_EXPLICIT_TYPE_ID(cinn::dialect::FusionTrackerPtrAttribute)
diff --git a/paddle/cinn/hlir/dialect/operator/ir/op_attribute.h b/paddle/cinn/hlir/dialect/operator/ir/op_attribute.h
index 67e1c61a7ebcbc..c0a8dc451b5987 100644
--- a/paddle/cinn/hlir/dialect/operator/ir/op_attribute.h
+++ b/paddle/cinn/hlir/dialect/operator/ir/op_attribute.h
@@ -14,10 +14,26 @@
 
 #pragma once
 #include "paddle/cinn/hlir/dialect/operator/ir/attribute_storage.h"
+#include "paddle/cinn/operator_fusion/fusion_tracker/tracker.h"
 #include "paddle/pir/include/core/attribute_base.h"
 
 namespace cinn {
 namespace dialect {
+class FusionTrackerPtrAttribute : public pir::Attribute {
+ public:
+  using Attribute::Attribute;
+
+  DECLARE_ATTRIBUTE_UTILITY_FUNCTOR(FusionTrackerPtrAttribute,
+                                    FusionTrackerPtrAttributeStorage);
+
+  bool operator<(const FusionTrackerPtrAttribute& right) const {
+    return storage() < right.storage();
+  }
+
+  static std::string name() { return "fusion_tracker"; }
+
+  const cinn::fusion::FusionTrackerPtr& data() const;
+};
 
 class GroupInfoAttribute : public pir::Attribute {
  public:
@@ -56,3 +72,4 @@ class CINNKernelInfoAttribute : public pir::Attribute {
 
 IR_DECLARE_EXPLICIT_TYPE_ID(cinn::dialect::GroupInfoAttribute)
 IR_DECLARE_EXPLICIT_TYPE_ID(cinn::dialect::CINNKernelInfoAttribute)
+IR_DECLARE_EXPLICIT_TYPE_ID(cinn::dialect::FusionTrackerPtrAttribute)
diff --git a/paddle/cinn/hlir/dialect/operator/ir/op_dialect.cc b/paddle/cinn/hlir/dialect/operator/ir/op_dialect.cc
index 32a534a3970189..de1c54cb8f4b91 100644
--- a/paddle/cinn/hlir/dialect/operator/ir/op_dialect.cc
+++ b/paddle/cinn/hlir/dialect/operator/ir/op_dialect.cc
@@ -60,6 +60,7 @@ void OperatorDialect::initialize() {
   RegisterOp<GenerateShapeOp>();
   RegisterAttribute<GroupInfoAttribute>();
   RegisterAttribute<CINNKernelInfoAttribute>();
+  RegisterAttribute<FusionTrackerPtrAttribute>();
 }
 
 void OperatorDialect::PrintType(pir::Type type, std::ostream &os) const {}
@@ -80,6 +81,10 @@ void OperatorDialect::PrintAttribute(pir::Attribute attr,
 
     os << "(" << cinn_kernel_info.data().fn_ptr;
     os << ')';
+  } else if (attr.isa<FusionTrackerPtrAttribute>()) {
+    auto tracker = attr.dyn_cast<FusionTrackerPtrAttribute>();
+    os << "(" << tracker;
+    os << ')';
   } else {
     PADDLE_THROW(phi::errors::Unimplemented(
         "cinn dialect only support GroupInfo and CINNKernelInfo"));
diff --git a/paddle/cinn/hlir/dialect/operator/transforms/attr_adt_type_id.h b/paddle/cinn/hlir/dialect/operator/transforms/attr_adt_type_id.h
index 82b5bc8d46fb50..067c5eb4f3d221 100644
--- a/paddle/cinn/hlir/dialect/operator/transforms/attr_adt_type_id.h
+++ b/paddle/cinn/hlir/dialect/operator/transforms/attr_adt_type_id.h
@@ -56,6 +56,7 @@ namespace cinn::dialect {
 
 class GroupInfoAttribute;
 class CINNKernelInfoAttribute;
+class FusionTrackerPtrAttribute;
 
 }  // namespace cinn::dialect
 
@@ -86,7 +87,8 @@ class UnclassifiedAttribute {};
   __macro(paddle::dialect::PlaceAttribute)          \
   __macro(paddle::dialect::DataLayoutAttribute)     \
   __macro(cinn::dialect::GroupInfoAttribute)        \
-  __macro(cinn::dialect::CINNKernelInfoAttribute)
+  __macro(cinn::dialect::CINNKernelInfoAttribute)   \
+  __macro(cinn::dialect::FusionTrackerPtrAttribute)
 // clang-format on
 
 using AttrAdtTypeIdBase = ::common::AdtBaseTypeId<
diff --git a/paddle/cinn/hlir/dialect/operator/transforms/cinn_group_cluster_pass.cc b/paddle/cinn/hlir/dialect/operator/transforms/cinn_group_cluster_pass.cc
index f81d7b32b569b4..3d1ed7741c4743 100644
--- a/paddle/cinn/hlir/dialect/operator/transforms/cinn_group_cluster_pass.cc
+++ b/paddle/cinn/hlir/dialect/operator/transforms/cinn_group_cluster_pass.cc
@@ -109,6 +109,8 @@ struct GroupClusterNode {
   std::unordered_set<::pir::Value> GetOutsideInput() const {
     return GetListOutsideInput(ops);
   }
+
+  cinn::fusion::FusionTrackerPtr tracker;
 };
 
 std::vector<::pir::Value> GenerateOutputValue(
@@ -199,7 +201,7 @@ ::pir::GroupOpsVec CloneOps(
   return vec_new_op_list;
 }
 
-::pir::Operation* ReplaceWithGroupOp(
+::pir::Operation* ReplaceWithFusionOp(
     pir::PatternRewriter* rewriter,
     const ::pir::GroupOpsVec& group_ops,
     const GroupClusterNode& node,
@@ -218,8 +220,8 @@ ::pir::Operation* ReplaceWithGroupOp(
   // step 2: Replace the old op with GroupOp.
 
   auto output_types = BuildOutType(output_value);
-  auto new_fusion_op =
-      rewriter->Build<cinn::dialect::FusionOp>(output_types, group_info);
+  auto new_fusion_op = rewriter->Build<cinn::dialect::FusionOp>(
+      output_types, group_info, node.tracker);
   pir::Block* fusion_block = new_fusion_op.block();
 
   for (auto op : vec_new_op_list) {
@@ -245,25 +247,33 @@ ::pir::Operation* ReplaceWithGroupOp(
 }
 
 std::vector<GroupClusterNode> GroupSplit(cinn::dialect::GroupOp group_op) {
-  std::function<cinn::fusion::FrontendContent(pir::Operation*)> func =
-      [](pir::Operation* op) { return cinn::fusion::FrontendContent(op); };
+  std::function<cinn::fusion::PatternContent(pir::Operation*)> func =
+      [](pir::Operation* op) { return cinn::fusion::PatternContent(op); };
   const auto& contents = cinn::fusion::MapVector(group_op.GetOperators(), func);
   auto cluster_result = cinn::fusion::ClusterOps(contents, {});
-  std::vector<std::vector<pir::Operation*>> result;
-  std::transform(
-      cluster_result.begin(),
-      cluster_result.end(),
-      std::back_inserter(result),
-      [](const cinn::fusion::PatternNodePtr<cinn::fusion::FrontendStage> node) {
-        return cinn::fusion::GetOpsInPattern(node->stmt_pattern());
-      });
+  std::vector<std::vector<pir::Operation*>> op_sets;
+  std::vector<cinn::fusion::FusionTrackerPtr> trackers;
+  std::transform(cluster_result.begin(),
+                 cluster_result.end(),
+                 std::back_inserter(op_sets),
+                 [](const cinn::fusion::PatternNodePtr node) {
+                   return cinn::fusion::GetOpsInPattern(node->stmt_pattern());
+                 });
+  std::transform(cluster_result.begin(),
+                 cluster_result.end(),
+                 std::back_inserter(trackers),
+                 [](const cinn::fusion::PatternNodePtr node)
+                     -> cinn::fusion::FusionTrackerPtr {
+                   return cinn::fusion::GetPatternTracker(node->stmt_pattern());
+                 });
 
   // Each stmts corresponds to each fusion op(cluster node).
   // Concat all the ops of patterns in the stmts, and make them the op list of
   // cluster node.
   VLOG(4) << "Start Creating Cluster Nodes!";
   std::vector<GroupClusterNode> output_cluster_nodes;
-  for (const auto& op_set : result) {
+  for (int i = 0; i < op_sets.size(); i++) {
+    auto op_set = op_sets[i];
     GroupClusterNode cluster_node;
     for (const auto* op : op_set) {
       cluster_node.ops.push_back(const_cast<pir::Operation*>(op));
@@ -271,6 +281,7 @@ std::vector<GroupClusterNode> GroupSplit(cinn::dialect::GroupOp group_op) {
       cluster_node.group_kind =
           cluster_node.group_kind > op_kind ? cluster_node.group_kind : op_kind;
     }
+    cluster_node.tracker = trackers[i];
     output_cluster_nodes.push_back(cluster_node);
   }
   VLOG(4) << "Finished Creating Cluster Nodes!";
@@ -349,7 +360,7 @@ class CinnGroupClusterPattern
       VLOG(4) << "cluster node output size: " << output_values.size();
       auto uniq_ops = SortByOriginalOrderAndUniq(group_op, node.ops);
 
-      auto new_group_op = ReplaceWithGroupOp(
+      auto new_group_op = ReplaceWithFusionOp(
           &rewriter, uniq_ops, node, output_values, &ir_mapping);
 
       // TODO(Hongqing-work): delete this after fix bug of
diff --git a/paddle/cinn/hlir/dialect/operator/transforms/pir_to_py_code_converter.cc b/paddle/cinn/hlir/dialect/operator/transforms/pir_to_py_code_converter.cc
index 78703dfe2c618a..0206efb702c54b 100644
--- a/paddle/cinn/hlir/dialect/operator/transforms/pir_to_py_code_converter.cc
+++ b/paddle/cinn/hlir/dialect/operator/transforms/pir_to_py_code_converter.cc
@@ -807,6 +807,12 @@ struct PirToPyCodeConverterHelper {
       ss << "self." << name << "()";
       return ss.str();
     }
+    std::string operator()(TypeId<cinn::dialect::FusionTrackerPtrAttribute>) {
+      const auto& name = cinn::dialect::FusionTrackerPtrAttribute::name();
+      std::stringstream ss;
+      ss << "self." << name << "()";
+      return ss.str();
+    }
     std::string operator()(TypeId<UnclassifiedAttribute>) {
       return "self.UnclassifiedAttribute()";
     }
diff --git a/paddle/cinn/operator_fusion/fusion_tracker/interpreter.h b/paddle/cinn/operator_fusion/fusion_tracker/interpreter.h
index 532146a8d6465d..e69f1d7bd2a279 100644
--- a/paddle/cinn/operator_fusion/fusion_tracker/interpreter.h
+++ b/paddle/cinn/operator_fusion/fusion_tracker/interpreter.h
@@ -16,4 +16,11 @@
 #include "paddle/cinn/operator_fusion/pattern.h"
 #include "paddle/cinn/operator_fusion/pattern_fuser.h"
 
+namespace cinn::fusion {
+struct FusionScope {};
 struct FusionInterpreter {};
+
+using TrivialOp = cinn::hlir::framework::pir::trivial_fusion_detail::TrivialOp;
+using ReduceOp = cinn::hlir::framework::pir::trivial_fusion_detail::ReduceOp;
+using FusionOp = std::variant<ReduceOp, TrivialOp>;
+}  // namespace cinn::fusion
diff --git a/paddle/cinn/operator_fusion/fusion_tracker/tracker.h b/paddle/cinn/operator_fusion/fusion_tracker/tracker.h
index bde53339c18742..26cc90f037c77b 100644
--- a/paddle/cinn/operator_fusion/fusion_tracker/tracker.h
+++ b/paddle/cinn/operator_fusion/fusion_tracker/tracker.h
@@ -13,30 +13,27 @@
 // limitations under the License.
 
 #pragma once
-#include "paddle/cinn/ir/ir_base.h"
 #include "paddle/cinn/operator_fusion/pir_graph_analyzing/anchor_transform.h"
-#include "paddle/cinn/operator_fusion/utils.h"
 
 namespace cinn::fusion {
 
-using TrivialOp = cinn::hlir::framework::pir::trivial_fusion_detail::TrivialOp;
-using ReduceOp = cinn::hlir::framework::pir::trivial_fusion_detail::ReduceOp;
-using FusionOp = std::variant<ReduceOp, TrivialOp>;
-
-struct FusionScope {
-  std::unordered_map<std::string, std::vector<FusionOp>> scope_;
-  std::string DebugStr() const;
-};
-
 struct FusionInstruction {
-  virtual void Apply(FusionScope* scope);
+  virtual size_t hash() const;
+  virtual bool operator==(const FusionInstruction& other) const;
 };
 
 using FusionInstrPtr = std::shared_ptr<FusionInstruction>;
 
+struct InitPatternInstr : public FusionInstruction {
+  InitPatternInstr(pir::Operation* op, const std::string& result)
+      : op_(op), result_(result) {}
+  pir::Operation* op_;
+  std::string result_;
+};
 struct TrivialInlineInstr : public FusionInstruction {
   TrivialInlineInstr(const std::string& upstream,
-                     const std::string& downstream const std::string& result)
+                     const std::string& downstream,
+                     const std::string& result)
       : upstream_(upstream), downstream_(downstream), result_(result) {}
   std::string upstream_;
   std::string downstream_;
@@ -44,17 +41,19 @@ struct TrivialInlineInstr : public FusionInstruction {
 };
 struct TmpTransformInstr : public FusionInstruction {
   TmpTransformInstr(const std::string& upstream,
-                    const std::string& downstream const std::string& result)
+                    const std::string& downstream,
+                    const std::string& result)
       : upstream_(upstream), downstream_(downstream), result_(result) {}
   std::string upstream_;
   std::string downstream_;
   std::string result_;
 };
 struct TmpTransformWithFakeReduceIterInstr : public FusionInstruction {
-  TmpTransformInstr(const std::string& upstream,
-                    const std::string& downstream,
-                    const std::string& result,
-                    const vector<size_t>& fake_reduce_iter_idx)
+  TmpTransformWithFakeReduceIterInstr(
+      const std::string& upstream,
+      const std::string& downstream,
+      const std::string& result,
+      const std::vector<size_t>& fake_reduce_iter_idx)
       : upstream_(upstream),
         downstream_(downstream),
         result_(result),
@@ -62,14 +61,14 @@ struct TmpTransformWithFakeReduceIterInstr : public FusionInstruction {
   std::string upstream_;
   std::string downstream_;
   std::string result_;
-  vector<size_t> fake_reduce_iter_idx_;
+  std::vector<size_t> fake_reduce_iter_idx_;
 };
 struct AnchorTransformInstr : public FusionInstruction {
-  TmpTransformInstr(const std::string& upstream,
-                    const std::string& downstream,
-                    const std::string& result,
-                    const AnchorTransformRoute& transform_route,
-                    bool is_upstream_anchor)
+  AnchorTransformInstr(const std::string& upstream,
+                       const std::string& downstream,
+                       const std::string& result,
+                       const AnchorTransformRoute& transform_route,
+                       bool is_upstream_anchor)
       : upstream_(upstream),
         downstream_(downstream),
         result_(result),
@@ -82,37 +81,35 @@ struct AnchorTransformInstr : public FusionInstruction {
   bool is_upstream_anchor_;
 };
 struct CombineInstr : public FusionInstruction {
-  TmpTransformInstr(const std::string& first,
-                    const std::string& second,
-                    const std::string& result)
+  CombineInstr(const std::string& first,
+               const std::string& second,
+               const std::string& result)
       : first_(first), second_(second), result_(result) {}
   std::string first_;
   std::string second_;
   std::string result_;
 };
-struct InitPatternInstr : public FusionInstruction {
-  InitPatternInstr(pir::Operation* op, const std::string& result)
-      : op_(op), result_(result) {}
-  pir::Operation* op_;
-  std::string result_;
-};
 struct RenamePatternInstr : public FusionInstruction {
-  TmpTransformInstr(const std::string& origin_name, const std::string& new_name)
+  RenamePatternInstr(const std::string& origin_name,
+                     const std::string& new_name)
       : origin_name_(origin_name), new_name_(new_name) {}
   std::string origin_name_;
   std::string new_name_;
 };
-struct RemovePatternInstr : public FusionInstruction {};
+// struct RemovePatternInstr : public FusionInstruction {};
 
 struct FusionTracker {
+  using FusionTrackerPtr = std::shared_ptr<FusionTracker>;
   FusionTracker() = default;
-  FusionTracker(const FusionTracker& up, const FusionTracker& down) {
-    ExtendVector(&instructions_, up.instructions_);
-    ExtendVector(&instructions_, down.instructions_);
+  FusionTracker(const FusionTrackerPtr& up, const FusionTrackerPtr& down) {
+    ExtendVector(&instructions_, up->instructions_);
+    ExtendVector(&instructions_, down->instructions_);
   }
   void append(FusionInstrPtr instr) { instructions_.emplace_back(instr); }
   std::string DebugStr() const;
 
   std::vector<FusionInstrPtr> instructions_;
 };
+
+using FusionTrackerPtr = std::shared_ptr<FusionTracker>;
 }  // namespace cinn::fusion
diff --git a/paddle/cinn/operator_fusion/group_cluster.h b/paddle/cinn/operator_fusion/group_cluster.h
index 8648d3684c7ac9..ea6958c8a90aca 100644
--- a/paddle/cinn/operator_fusion/group_cluster.h
+++ b/paddle/cinn/operator_fusion/group_cluster.h
@@ -14,11 +14,10 @@
 
 #pragma once
 
-#include "paddle/cinn/operator_fusion/backend/pattern.h"
-#include "paddle/cinn/operator_fusion/backend/pattern_fuser.h"
-#include "paddle/cinn/operator_fusion/frontend/pattern.h"
-#include "paddle/cinn/operator_fusion/frontend/pattern_fuser.h"
+#include "paddle/cinn/operator_fusion/pattern.h"
+#include "paddle/cinn/operator_fusion/pattern_fuser.h"
 #include "paddle/cinn/operator_fusion/pattern_graph.h"
+#include "paddle/cinn/operator_fusion/pattern_node.h"
 #include "paddle/cinn/operator_fusion/policy/policy_manager.h"
 
 namespace cinn::fusion {
diff --git a/paddle/cinn/operator_fusion/pattern.h b/paddle/cinn/operator_fusion/pattern.h
index 012f9f94b18784..f1ad5c784cdae1 100644
--- a/paddle/cinn/operator_fusion/pattern.h
+++ b/paddle/cinn/operator_fusion/pattern.h
@@ -36,7 +36,7 @@ struct StmtPattern;
 struct TrivialPattern {
   explicit TrivialPattern(const std::vector<pir::Operation*>& ops,
                           pir::Operation* sink_op,
-                          const FusionTracker& tracker)
+                          const FusionTrackerPtr& tracker)
       : ops_(ops), sink_op_(sink_op), tracker_(tracker) {
     name_ = UniqueName();
   }
@@ -50,15 +50,15 @@ struct TrivialPattern {
     counter += 1;
     return "T_" + std::to_string(counter);
   }
-  std::string name() { return name_; }
+  std::string name() const { return name_; }
   std::string name_;
 
-  FusionTracker tracker_;
+  FusionTrackerPtr tracker_;
 };
 
 struct ReducePattern {
   explicit ReducePattern(const std::vector<pir::Operation*>& ops,
-                         const FusionTracker& tracker)
+                         const FusionTrackerPtr& tracker)
       : ops_(ops), tracker_(tracker) {
     name_ = UniqueName();
   }
@@ -71,16 +71,16 @@ struct ReducePattern {
     counter += 1;
     return "T_" + std::to_string(counter);
   }
-  std::string name() { return name_; }
+  std::string name() const { return name_; }
   std::string name_;
 
-  FusionTracker tracker_;
+  FusionTrackerPtr tracker_;
 };
 
 struct ReduceTreePattern {
   explicit ReduceTreePattern(const std::vector<ReduceTreePattern>& childs,
                              const ReducePattern& root,
-                             const FusionTracker& tracker)
+                             const FusionTrackerPtr& tracker)
       : childs_(childs), root_(root), tracker_(tracker) {
     name_ = UniqueName();
   }
@@ -108,10 +108,10 @@ struct ReduceTreePattern {
     counter += 1;
     return "RTree_" + std::to_string(counter);
   }
-  std::string name() { return name_; }
+  std::string name() const { return name_; }
   std::string name_;
 
-  FusionTracker tracker_;
+  FusionTrackerPtr tracker_;
 
  private:
   std::vector<ReduceTreePattern> childs_;
@@ -121,7 +121,7 @@ struct ReduceTreePattern {
 struct ReduceTreePlusTrivialPattern {
   explicit ReduceTreePlusTrivialPattern(const ReduceTreePattern& tree,
                                         const TrivialPattern& sink_trivial,
-                                        const FusionTracker& tracker)
+                                        const FusionTrackerPtr& tracker)
       : tree(tree), sink_trivial(sink_trivial), tracker_(tracker) {
     name_ = UniqueName();
   }
@@ -137,17 +137,17 @@ struct ReduceTreePlusTrivialPattern {
     counter += 1;
     return "RTreeT_" + std::to_string(counter);
   }
-  std::string name() { return name_; }
+  std::string name() const { return name_; }
   std::string name_;
 
-  FusionTracker tracker_;
+  FusionTrackerPtr tracker_;
 };
 
 struct AnchorPattern {
   explicit AnchorPattern(const std::vector<pir::Operation*>& ops,
                          const pir::Value& anchor,
                          const AnchorState& init_anchor_state,
-                         const FusionTracker& tracker)
+                         const FusionTrackerPtr& tracker)
       : ops_(ops),
         anchor_(anchor),
         anchor_state(init_anchor_state),
@@ -184,10 +184,10 @@ struct AnchorPattern {
     counter += 1;
     return "Anchor_" + std::to_string(counter);
   }
-  std::string name() { return name_; }
+  std::string name() const { return name_; }
   std::string name_;
 
-  FusionTracker tracker_;
+  FusionTrackerPtr tracker_;
 
  private:
   std::vector<pir::Operation*> ops_;
@@ -200,12 +200,12 @@ struct HorizontalFusionPattern {
     std::vector<int> padding_pos;
     PaddingStmtPattern(const StmtPattern& pattern,
                        const std::vector<int>& padding_pos)
-        : pattern(pattern), padding_pos(padding_pos), tracker_(tracker) {}
+        : pattern(pattern), padding_pos(padding_pos) {}
   };
   explicit HorizontalFusionPattern(
       const std::vector<PaddingStmtPattern>& patterns,
-      const FusionTracker& tracker)
-      : padding_patterns_(patterns) {
+      const FusionTrackerPtr& tracker)
+      : padding_patterns_(patterns), tracker_(tracker) {
     name_ = UniqueName();
   }
   std::vector<PaddingStmtPattern> padding_patterns_;
@@ -223,15 +223,15 @@ struct HorizontalFusionPattern {
     counter += 1;
     return "Horizontal_" + std::to_string(counter);
   }
-  std::string name() { return name_; }
+  std::string name() const { return name_; }
   std::string name_;
 
-  FusionTracker tracker_;
+  FusionTrackerPtr tracker_;
 };
 
 struct UnsupportPattern {
   explicit UnsupportPattern(const std::vector<pir::Operation*>& ops,
-                            const FusionTracker& tracker)
+                            const FusionTrackerPtr& tracker)
       : ops_(ops), tracker_(tracker) {
     name_ = UniqueName();
   }
@@ -242,10 +242,10 @@ struct UnsupportPattern {
     counter += 1;
     return "Unsupport_" + std::to_string(counter);
   }
-  std::string name() { return name_; }
+  std::string name() const { return name_; }
   std::string name_;
 
-  FusionTracker tracker_;
+  FusionTrackerPtr tracker_;
 };
 
 using StmtPatternBase = std::variant<TrivialPattern,
@@ -271,25 +271,12 @@ std::string StmtPatternDebugStr(const StmtPattern& stmt) {
   return ss.str();
 }
 
-StmtPattern ConvertToStmtPattern(const PatternContent& content) {
-  const auto& kind = GetOpPatternKind(content.op);
-  if (kind == hlir::framework::kReduction) {
-    return ReducePattern({content.op});
-  } else if (kind == hlir::framework::kElementWise ||
-             kind == hlir::framework::kBroadcast ||
-             kind == hlir::framework::kInjective) {
-    return TrivialPattern({content.op}, content.op);
-  } else {
-    return UnsupportPattern({content.op});
-  }
-}
-
 std::string GetPatternName(const StmtPattern& s) {
   return std::visit([](const auto& impl) { return impl.name(); }, s.variant());
 }
 
-FusionTracker* GetPatternTracker(const StmtPattern& s) {
-  return std::visit([](const auto& impl) { return impl.tracker(); },
+FusionTrackerPtr GetPatternTracker(const StmtPattern& s) {
+  return std::visit([](const auto& impl) { return impl.tracker_; },
                     s.variant());
 }
 
@@ -298,11 +285,6 @@ std::vector<pir::Operation*> GetOpsInPattern(const StmtPattern& pattern) {
                     pattern.variant());
 }
 
-pir::Operation* GetSinkOpInPattern(const StmtPattern& pattern) {
-  return std::visit([](const auto& impl) { return impl.sink_op(); },
-                    pattern.variant());
-}
-
 std::unordered_set<pir::Value> GetPatternInputValuesIncludeInner(
     const StmtPattern& A) {
   std::unordered_set<pir::Value> result;
diff --git a/paddle/cinn/operator_fusion/pattern_fuser.h b/paddle/cinn/operator_fusion/pattern_fuser.h
index f7fb02416b1a7b..d28924a8402b98 100644
--- a/paddle/cinn/operator_fusion/pattern_fuser.h
+++ b/paddle/cinn/operator_fusion/pattern_fuser.h
@@ -36,23 +36,47 @@
 
 namespace cinn::fusion {
 
+StmtPattern ConvertToStmtPattern(const PatternContent& content) {
+  const auto& kind = GetOpPatternKind(content.op);
+  if (kind == hlir::framework::kReduction) {
+    auto result =
+        ReducePattern({content.op}, std::make_shared<FusionTracker>());
+    result.tracker_->append(std::make_shared<InitPatternInstr>(content.op));
+    return result;
+  } else if (kind == hlir::framework::kElementWise ||
+             kind == hlir::framework::kBroadcast ||
+             kind == hlir::framework::kInjective) {
+    auto result = TrivialPattern(
+        {content.op}, content.op, std::make_shared<FusionTracker>());
+    result.tracker_->append(std::make_shared<InitPatternInstr>(content.op));
+    return result;
+  } else {
+    auto result =
+        UnsupportPattern({content.op}, std::make_shared<FusionTracker>());
+    result.tracker_->append(std::make_shared<InitPatternInstr>(content.op));
+    return result;
+  }
+}
+
 // Trivial x other
 
 StmtPattern MergePatternImpl(const TrivialPattern& first,
                              const TrivialPattern& second) {
   const auto& contents =
       UniqueConcatVector(GetOpsInPattern(first), GetOpsInPattern(second));
-  return TrivialPattern(contents,
-                        second.sink_op(),
-                        FusionTracker(first.tracker_, second.tracker_));
+  return TrivialPattern(
+      contents,
+      second.sink_op(),
+      std::make_shared<FusionTracker>(first.tracker_, second.tracker_));
 }
 
 StmtPattern MergePatternImpl(const TrivialPattern& first,
                              const ReducePattern& second) {
   const auto& contents =
       UniqueConcatVector(GetOpsInPattern(first), GetOpsInPattern(second));
-  return ReducePattern(contents,
-                       FusionTracker(first.tracker_, second.tracker_));
+  return ReducePattern(
+      contents,
+      std::make_shared<FusionTracker>(first.tracker_, second.tracker_));
 }
 
 template <typename A, typename B>
@@ -80,7 +104,7 @@ StmtPattern MergePatternImpl(const TrivialPattern& first,
   return ReduceTreePattern(
       new_childs,
       FusePatternIfConnected(first, second.GetRootPattern(), connect_ops),
-      FusionTracker(first.tracker_, second.tracker_));
+      std::make_shared<FusionTracker>(first.tracker_, second.tracker_));
 }
 
 StmtPattern MergePatternImpl(const TrivialPattern& first,
@@ -89,7 +113,7 @@ StmtPattern MergePatternImpl(const TrivialPattern& first,
   return ReduceTreePlusTrivialPattern(
       FusePatternIfConnected(first, second.tree, connect_ops),
       FusePatternIfConnected(first, second.sink_trivial, connect_ops),
-      FusionTracker(first.tracker_, second.tracker_));
+      std::make_shared<FusionTracker>(first.tracker_, second.tracker_));
 }
 
 StmtPattern MergePatternImpl(const TrivialPattern& first,
@@ -98,7 +122,7 @@ StmtPattern MergePatternImpl(const TrivialPattern& first,
       UniqueConcatVector(GetOpsInPattern(first), GetOpsInPattern(second)),
       second.anchor(),
       second.anchor_state,
-      FusionTracker(first.tracker_, second.tracker_));
+      std::make_shared<FusionTracker>(first.tracker_, second.tracker_));
 }
 
 // RR & RT
@@ -120,9 +144,10 @@ int InsertDownstreamIntoTree(const ReduceTreePattern& upstream,
 StmtPattern MergePatternImpl(const ReduceTreePattern& upstream,
                              const ReduceTreePattern& downstream) {
   ReduceTreePattern result = ReduceTreePattern(
-      dowstream.childs(),
+      downstream.childs(),
       downstream.GetRootPattern(),
-      FusionTracker(first.tracker_, second.tracker_));  // copy first.
+      std::make_shared<FusionTracker>(upstream.tracker_,
+                                      downstream.tracker_));  // copy first.
   int insert_num = InsertDownstreamIntoTree(upstream, result);
   CHECK(insert_num == 1) << "Must insert only once, but insert " << insert_num;
   return result;
@@ -131,7 +156,9 @@ StmtPattern MergePatternImpl(const ReduceTreePattern& upstream,
 StmtPattern MergePatternImpl(const ReduceTreePattern& first,
                              const TrivialPattern& second) {
   return ReduceTreePlusTrivialPattern(
-      first, second, FusionTracker(first.tracker_, second.tracker_));
+      first,
+      second,
+      std::make_shared<FusionTracker>(first.tracker_, second.tracker_));
 }
 
 // Anchor Fusion
@@ -150,7 +177,7 @@ ExprPromise InitExprPromiseImpl(const ReduceTreePattern& pattern,
   return InitExprPromiseImpl(pattern.GetRootPattern(), anchor);
 }
 
-template <typename T, template <typename> typename PATTERN>
+template <typename PATTERN>
 ExprPromise InitExprPromiseImpl(const PATTERN& pattern, pir::Value anchor) {
   PADDLE_THROW("Can not Init ExprPromise");
 }
@@ -165,10 +192,11 @@ StmtPattern MergePatternImpl(const AnchorPattern& source,
                              const AnchorPattern& dest) {
   const auto& contents =
       UniqueConcatVector(GetOpsInPattern(source), GetOpsInPattern(dest));
-  return AnchorPattern(contents,
-                       source.anchor(),
-                       AnchorState({}),
-                       FusionTracker(source.tracker_, dest.tracker_));
+  return AnchorPattern(
+      contents,
+      source.anchor(),
+      AnchorState({}),
+      std::make_shared<FusionTracker>(source.tracker_, dest.tracker_));
 }
 
 TrivialPattern RecoverAnchorPatternToTrivial(
@@ -351,7 +379,8 @@ StmtPattern MergePatternImpl(const HorizontalFusionPattern& first,
   typename HorizontalFusionPattern::PaddingStmtPattern pad_first = {first, f};
   typename HorizontalFusionPattern::PaddingStmtPattern pad_second = {second, s};
   return HorizontalFusionPattern(
-      {pad_first, pad_second}, FusionTracker(first.tracker_, second.tracker_));
+      {pad_first, pad_second},
+      std::make_shared<FusionTracker>(first.tracker_, second.tracker_));
 }
 
 //
diff --git a/paddle/cinn/operator_fusion/pattern_graph.cc b/paddle/cinn/operator_fusion/pattern_graph.cc
index 0cf3f788f20cca..1e4254ed4761d4 100644
--- a/paddle/cinn/operator_fusion/pattern_graph.cc
+++ b/paddle/cinn/operator_fusion/pattern_graph.cc
@@ -14,13 +14,11 @@
 
 #include "paddle/cinn/operator_fusion/pattern_graph.h"
 #include <functional>
-#include "paddle/cinn/operator_fusion/backend/pattern.h"
-#include "paddle/cinn/operator_fusion/backend/pattern_fuser.h"
-#include "paddle/cinn/operator_fusion/frontend/pattern.h"
-#include "paddle/cinn/operator_fusion/frontend/pattern_fuser.h"
 #include "paddle/cinn/operator_fusion/graph_transformer/matcher.h"
 #include "paddle/cinn/operator_fusion/graph_transformer/operation.h"
 #include "paddle/cinn/operator_fusion/graph_transformer/search_algorithm.h"
+#include "paddle/cinn/operator_fusion/pattern.h"
+#include "paddle/cinn/operator_fusion/pattern_fuser.h"
 
 namespace cinn::fusion {
 
@@ -315,7 +313,4 @@ PatternNodePtr PatternGraph::MergeNode(const PatternNodePtr& upstream,
   return merged_node;
 }
 
-template class PatternGraph<FrontendStage>;
-template class PatternGraph<BackendStage>;
-
 }  // namespace cinn::fusion
diff --git a/paddle/cinn/operator_fusion/pattern_graph.h b/paddle/cinn/operator_fusion/pattern_graph.h
index 17435139959a69..742e55ed40ab65 100644
--- a/paddle/cinn/operator_fusion/pattern_graph.h
+++ b/paddle/cinn/operator_fusion/pattern_graph.h
@@ -15,7 +15,6 @@
 
 #include "paddle/cinn/operator_fusion/pattern_node.h"
 #include "paddle/cinn/operator_fusion/policy/policy_manager.h"
-#include "paddle/cinn/operator_fusion/policy/relative_judge_policy.h"
 #include "paddle/cinn/operator_fusion/utils.h"
 #include "paddle/common/enforce.h"
 
diff --git a/paddle/cinn/operator_fusion/pattern_node.h b/paddle/cinn/operator_fusion/pattern_node.h
index e1a8dee060bab9..fc068fad6d187f 100644
--- a/paddle/cinn/operator_fusion/pattern_node.h
+++ b/paddle/cinn/operator_fusion/pattern_node.h
@@ -88,6 +88,5 @@ struct PatternNode {
   std::vector<PatternNodePtr> downstream_;
 };
 
-template <typename T>
 using PatternNodePtr = std::shared_ptr<PatternNode>;
 }  // namespace cinn::fusion
diff --git a/paddle/cinn/operator_fusion/policy/general_topo_policy.cc b/paddle/cinn/operator_fusion/policy/general_topo_policy.cc
index a43a4f462fe95b..911b5ee0bf1dcb 100644
--- a/paddle/cinn/operator_fusion/policy/general_topo_policy.cc
+++ b/paddle/cinn/operator_fusion/policy/general_topo_policy.cc
@@ -43,7 +43,4 @@ bool GeneralTopoPolicy::CanFuse(const PatternNodePtr& first,
            IsIndirectDownstreamNode(second, first));
 }
 
-template class GeneralTopoPolicy<FrontendStage>;
-template class GeneralTopoPolicy<BackendStage>;
-
 }  // namespace cinn::fusion
diff --git a/paddle/cinn/operator_fusion/policy/relative_judge_policy.cc b/paddle/cinn/operator_fusion/policy/relative_judge_policy.cc
index 0a25537a889ded..8ba6ed3cf24607 100644
--- a/paddle/cinn/operator_fusion/policy/relative_judge_policy.cc
+++ b/paddle/cinn/operator_fusion/policy/relative_judge_policy.cc
@@ -307,7 +307,4 @@ std::vector<size_t> RelativeJudgePolicy::GetFakeReduceIterIdx(
   return result;
 }
 
-template class RelativeJudgePolicy<FrontendStage>;
-template class RelativeJudgePolicy<BackendStage>;
-
 }  // namespace cinn::fusion

From 78c7abb7e526ec136715af6a31b8e494491cef66 Mon Sep 17 00:00:00 2001
From: feifei-111 <2364819892@qq.com>
Date: Tue, 4 Jun 2024 13:04:56 +0000
Subject: [PATCH 70/99] update

---
 .../fusion_tracker/interpreter.cc             | 51 ++++++++++++++
 .../fusion_tracker/interpreter.h              | 26 +++++--
 .../operator_fusion/fusion_tracker/tracker.h  | 69 +++++++++++++------
 3 files changed, 121 insertions(+), 25 deletions(-)

diff --git a/paddle/cinn/operator_fusion/fusion_tracker/interpreter.cc b/paddle/cinn/operator_fusion/fusion_tracker/interpreter.cc
index 6e67320dacf555..ae4d03d87ce336 100644
--- a/paddle/cinn/operator_fusion/fusion_tracker/interpreter.cc
+++ b/paddle/cinn/operator_fusion/fusion_tracker/interpreter.cc
@@ -21,6 +21,10 @@
 
 namespace cinn::fusion {
 
+using TrivialOp = cinn::hlir::framework::pir::trivial_fusion_detail::TrivialOp;
+using ReduceOp = cinn::hlir::framework::pir::trivial_fusion_detail::ReduceOp;
+using FusionOp = std::variant<ReduceOp, TrivialOp>;
+
 template <>
 StmtPattern<BackendStage> ConvertToStmtPattern(
     const PatternContent<BackendStage>& content) {
@@ -490,4 +494,51 @@ TrivialPattern<BackendStage> RecoverAnchorPatternToTrivial(
           anchor_pattern.anchor_state.promise[0].root_fusion_op));
 }
 
+void RunRenameInstr(const FusionInstrPtr& instr, FusionInterpreter* scope);
+void RunCombineInstr(const FusionInstrPtr& instr, FusionInterpreter* scope);
+void RunReturnInstr(const FusionInstrPtr& instr, FusionInterpreter* scope);
+void RunInitPatternInstr(const FusionInstrPtr& instr, FusionInterpreter* scope);
+void RunTrivialInlineInstr(const FusionInstrPtr& instr,
+                           FusionInterpreter* scope);
+void RunTmpTransformInstr(const FusionInstrPtr& instr,
+                          FusionInterpreter* scope);
+void RunTmpTransformWithFakeReduceIterInstr(const FusionInstrPtr& instr,
+                                            FusionInterpreter* scope);
+void RunAnchorTransformInstr(const FusionInstrPtr& instr,
+                             FusionInterpreter* scope);
+
+PatternExpr FusionInterpreter::Run() {
+  for (const auto instr : tracker->instructions_) {
+    switch (instr->type()) {
+      case T_Rename:
+        RunRenameInstr(instr, this);
+        break;
+      case T_Combine:
+        RunCombineInstr(instr, this);
+        break;
+      case T_InitPattern:
+        RunInitPatternInstr(instr, this);
+        break;
+      case T_TrivialInline:
+        RunTrivialInlineInstr(instr, this);
+        break;
+      case T_TmpTransform:
+        RunTmpTransformInstr(instr, this);
+        break;
+      case T_TmpTransformWithFakeReduceIter:
+        RunTmpTransformWithFakeReduceIterInstr(instr, this);
+        break;
+      case T_AnchorTransform:
+        RunAnchorTransformInstr(instr, this);
+        break;
+      case T_Return:
+        auto ret_ptr = std::dynamic_pointer_cast<ReturnInstr>(instr);
+        if (!ret_ptr) PADDLE_THROW("Non ReturnInstr return T_Return as type.");
+        return scope[ret_ptr->ret_name_];
+      default:
+        PADDLE_THROW("Unsupported Fusion Instrution");
+    }
+  }
+}
+
 }  // namespace cinn::fusion
diff --git a/paddle/cinn/operator_fusion/fusion_tracker/interpreter.h b/paddle/cinn/operator_fusion/fusion_tracker/interpreter.h
index e69f1d7bd2a279..9d1281e092489f 100644
--- a/paddle/cinn/operator_fusion/fusion_tracker/interpreter.h
+++ b/paddle/cinn/operator_fusion/fusion_tracker/interpreter.h
@@ -13,14 +13,30 @@
 // limitations under the License.
 
 #pragma once
+#include <functional>
+#include "paddle/cinn/hlir/framework/pir/trivial_op_impl.h"
+#include "paddle/cinn/operator_fusion/fusion_tracker/tracker.h"
 #include "paddle/cinn/operator_fusion/pattern.h"
 #include "paddle/cinn/operator_fusion/pattern_fuser.h"
 
 namespace cinn::fusion {
-struct FusionScope {};
-struct FusionInterpreter {};
 
-using TrivialOp = cinn::hlir::framework::pir::trivial_fusion_detail::TrivialOp;
-using ReduceOp = cinn::hlir::framework::pir::trivial_fusion_detail::ReduceOp;
-using FusionOp = std::variant<ReduceOp, TrivialOp>;
+struct PatternExpr {
+  std::vector<ir::Expr> exprs;
+};
+using PatternExprPtr = std::shared_ptr<PatternExpr>;
+
+struct FusionInterpreter {
+  FusionInterpreter(
+      const FusionTrackerPtr& tracker,
+      const std::unordered_map<pir::Operator*, ir::Expr>& lowered_expr)
+      : tracker(tracker), lowered_expr(lowered_expr) {}
+
+  std::unordered_map<pir::Operator*, ir::Expr> lowered_expr;
+  std::unordered_map<std::string, PatternExprPtr> scope;
+  FusionTrackerPtr tracker;
+
+  PatternExpr Run();
+};
+
 }  // namespace cinn::fusion
diff --git a/paddle/cinn/operator_fusion/fusion_tracker/tracker.h b/paddle/cinn/operator_fusion/fusion_tracker/tracker.h
index 26cc90f037c77b..447675534300db 100644
--- a/paddle/cinn/operator_fusion/fusion_tracker/tracker.h
+++ b/paddle/cinn/operator_fusion/fusion_tracker/tracker.h
@@ -17,37 +17,81 @@
 
 namespace cinn::fusion {
 
+enum InstructionType {
+  T_Rename,
+  T_Combine,
+  T_Return,
+  T_InitPattern,
+  T_TrivialInline,
+  T_TmpTransform,
+  T_TmpTransformWithFakeReduceIter,
+  T_AnchorTransform,
+};
+
 struct FusionInstruction {
-  virtual size_t hash() const;
-  virtual bool operator==(const FusionInstruction& other) const;
+  virtual InstructionType type();
 };
 
 using FusionInstrPtr = std::shared_ptr<FusionInstruction>;
 
+struct RenamePatternInstr : public FusionInstruction {
+  RenamePatternInstr(const std::string& origin_name,
+                     const std::string& new_name)
+      : origin_name_(origin_name), new_name_(new_name) {}
+  virtual InstructionType type() { return T_Rename; }
+  std::string origin_name_;
+  std::string new_name_;
+};
+
+struct CombineInstr : public FusionInstruction {
+  CombineInstr(const std::string& first,
+               const std::string& second,
+               const std::string& result)
+      : first_(first), second_(second), result_(result) {}
+  virtual InstructionType type() { return T_Combine; }
+  std::string first_;
+  std::string second_;
+  std::string result_;
+};
+
+struct ReturnInstr : public FusionInstruction {
+  RenamePatternInstr(const std::string& ret_name) : ret_name_(ret_name) {}
+  virtual InstructionType type() { return T_Return; }
+  std::string ret_name_;
+};
+
+// struct RemovePatternInstr : public FusionInstruction {};
+
 struct InitPatternInstr : public FusionInstruction {
   InitPatternInstr(pir::Operation* op, const std::string& result)
       : op_(op), result_(result) {}
+  virtual InstructionType type() { return T_InitPattern; }
   pir::Operation* op_;
   std::string result_;
 };
+
 struct TrivialInlineInstr : public FusionInstruction {
   TrivialInlineInstr(const std::string& upstream,
                      const std::string& downstream,
                      const std::string& result)
       : upstream_(upstream), downstream_(downstream), result_(result) {}
+  virtual InstructionType type() { return T_TrivialInline; }
   std::string upstream_;
   std::string downstream_;
   std::string result_;
 };
+
 struct TmpTransformInstr : public FusionInstruction {
   TmpTransformInstr(const std::string& upstream,
                     const std::string& downstream,
                     const std::string& result)
       : upstream_(upstream), downstream_(downstream), result_(result) {}
+  virtual InstructionType type() { return T_TmpTransform; }
   std::string upstream_;
   std::string downstream_;
   std::string result_;
 };
+
 struct TmpTransformWithFakeReduceIterInstr : public FusionInstruction {
   TmpTransformWithFakeReduceIterInstr(
       const std::string& upstream,
@@ -58,11 +102,13 @@ struct TmpTransformWithFakeReduceIterInstr : public FusionInstruction {
         downstream_(downstream),
         result_(result),
         fake_reduce_iter_idx_(fake_reduce_iter_idx) {}
+  virtual InstructionType type() { return T_TmpTransformWithFakeReduceIter; }
   std::string upstream_;
   std::string downstream_;
   std::string result_;
   std::vector<size_t> fake_reduce_iter_idx_;
 };
+
 struct AnchorTransformInstr : public FusionInstruction {
   AnchorTransformInstr(const std::string& upstream,
                        const std::string& downstream,
@@ -74,29 +120,13 @@ struct AnchorTransformInstr : public FusionInstruction {
         result_(result),
         transform_route_(transform_route),
         is_upstream_anchor_(is_upstream_anchor) {}
+  virtual InstructionType type() { return T_AnchorTransform; }
   std::string upstream_;
   std::string downstream_;
   std::string result_;
   AnchorTransformRoute transform_route_;
   bool is_upstream_anchor_;
 };
-struct CombineInstr : public FusionInstruction {
-  CombineInstr(const std::string& first,
-               const std::string& second,
-               const std::string& result)
-      : first_(first), second_(second), result_(result) {}
-  std::string first_;
-  std::string second_;
-  std::string result_;
-};
-struct RenamePatternInstr : public FusionInstruction {
-  RenamePatternInstr(const std::string& origin_name,
-                     const std::string& new_name)
-      : origin_name_(origin_name), new_name_(new_name) {}
-  std::string origin_name_;
-  std::string new_name_;
-};
-// struct RemovePatternInstr : public FusionInstruction {};
 
 struct FusionTracker {
   using FusionTrackerPtr = std::shared_ptr<FusionTracker>;
@@ -107,7 +137,6 @@ struct FusionTracker {
   }
   void append(FusionInstrPtr instr) { instructions_.emplace_back(instr); }
   std::string DebugStr() const;
-
   std::vector<FusionInstrPtr> instructions_;
 };
 

From 84d9b0627a573aacd0dbb6c80b26737d32f1ec9e Mon Sep 17 00:00:00 2001
From: feifei-111 <2364819892@qq.com>
Date: Wed, 5 Jun 2024 01:06:08 +0000
Subject: [PATCH 71/99] update backend

---
 .../fusion_tracker/expr_utils.cc              | 298 +++++++++
 .../fusion_tracker/expr_utils.h               |  53 ++
 .../fusion_tracker/interpreter.cc             | 584 +++---------------
 .../fusion_tracker/interpreter.h              |  27 +-
 .../operator_fusion/fusion_tracker/tracker.h  |  57 +-
 .../graph_transformer/operation.h             |  11 +-
 6 files changed, 499 insertions(+), 531 deletions(-)
 create mode 100644 paddle/cinn/operator_fusion/fusion_tracker/expr_utils.cc
 create mode 100644 paddle/cinn/operator_fusion/fusion_tracker/expr_utils.h

diff --git a/paddle/cinn/operator_fusion/fusion_tracker/expr_utils.cc b/paddle/cinn/operator_fusion/fusion_tracker/expr_utils.cc
new file mode 100644
index 00000000000000..765c55bf8a98a7
--- /dev/null
+++ b/paddle/cinn/operator_fusion/fusion_tracker/expr_utils.cc
@@ -0,0 +1,298 @@
+// Copyright (c) 2024 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/cinn/operator_fusion/fusion_tracker/expr_utils.h"
+
+namespace cinn::fusion {
+
+// tmp transform for reduce_tree and reduce_tree_trivial.
+std::vector<ir::Tensor> GetOutputTensors(const ir::Expr& op_expr) {
+  using cinn::hlir::framework::pir::trivial_fusion_detail::ExprSetFinderUtils::
+      ChildScheduleBlockRealizes;
+  using cinn::hlir::framework::pir::trivial_fusion_detail::ExprSetFinderUtils::
+      ChildTensorStores;
+  using cinn::hlir::framework::pir::trivial_fusion_detail::ExprSetFinderUtils::
+      ScheduleBlockRealizeIsNotInit;
+  const auto& tensors =
+      (ChildScheduleBlockRealizes * ScheduleBlockRealizeIsNotInit *
+       ChildTensorStores)(op_expr);
+  std::function<ir::Tensor(ir::Expr)> func = [](const ir::Expr& expr) {
+    return expr.As<ir::Store>()->tensor.as_tensor_ref();
+  };
+  return MapVector(tensors, func);
+}
+
+std::vector<ir::Tensor> GetInputTensors(const ir::Expr& op_expr) {
+  using cinn::hlir::framework::pir::trivial_fusion_detail::ExprSetFinderUtils::
+      ChildScheduleBlockRealizes;
+  using cinn::hlir::framework::pir::trivial_fusion_detail::ExprSetFinderUtils::
+      ChildTensorLoads;
+  using cinn::hlir::framework::pir::trivial_fusion_detail::ExprSetFinderUtils::
+      ScheduleBlockRealizeIsNotInit;
+  const auto& exprs =
+      (ChildScheduleBlockRealizes * ScheduleBlockRealizeIsNotInit *
+       ChildTensorLoads)(op_expr);
+  std::function<ir::Tensor(ir::Expr)> func = [](const ir::Expr& expr) {
+    return expr.As<ir::Load>()->tensor.as_tensor_ref();
+  };
+  const auto& inputs = MapVector(exprs, func);
+  const auto& outputs = GetOutputTensors(op_expr);
+  return FilterVector(inputs, [&outputs](const ir::Tensor& tensor) {
+    return std::find(outputs.begin(), outputs.end(), tensor) == outputs.end();
+  });
+}
+
+std::vector<ir::Expr> TopoSort(const std::vector<ir::Expr>& op_exprs) {
+  // Topo Sort is important for CINN GroupSchedule.
+  std::map<ir::Tensor, std::vector<const ir::Expr*>> tensor2defining_op;
+  std::map<ir::Tensor, std::vector<const ir::Expr*>> tensor2used_op;
+  for (const auto& op : op_exprs) {
+    auto inputs = GetInputTensors(op);
+    auto outputs = GetOutputTensors(op);
+
+    if (VLOG_IS_ON(5)) {
+      VLOG(4) << "Ir::Expr is: \n" << op;
+      VLOG(4) << "Inputs: ";
+      for (const auto& input : inputs) {
+        VLOG(4) << input->name;
+      }
+      VLOG(4) << "Outputs: ";
+      for (const auto& output : outputs) {
+        VLOG(4) << output->name;
+      }
+    }
+    for (const auto& input : inputs) {
+      tensor2used_op[input].push_back(&op);
+    }
+    for (const auto& output : outputs) {
+      tensor2defining_op[output].push_back(&op);
+    }
+  }
+
+  // Collect Downstreams
+  std::map<const ir::Expr*, std::vector<const ir::Expr*>> op2downstreams;
+  std::map<const ir::Expr*, int> degrees;
+  for (const auto& op : op_exprs) {
+    degrees[&op] = 0;
+  }
+  for (const auto& op : op_exprs) {
+    auto outputs = GetOutputTensors(op);
+    std::vector<const ir::Expr*> downstreams;
+    for (const auto& output : outputs) {
+      downstreams = ConcatVector(downstreams, tensor2used_op[output]);
+    }
+    for (const auto& downstream : downstreams) {
+      degrees[downstream]++;
+    }
+    op2downstreams[&op] = downstreams;
+  }
+
+  // Topo Sort
+  std::vector<const ir::Expr*> result;
+  std::queue<const ir::Expr*> q;
+  for (const auto& op : op_exprs) {
+    if (degrees[&op] == 0) {
+      q.push(&op);
+    }
+  }
+  while (!q.empty()) {
+    auto* cur = q.front();
+    VLOG(4) << "Topo Sort Visit Order is:" << GetOutputTensors(*cur)[0]->name;
+    q.pop();
+    result.push_back(cur);
+    for (const auto& downstream : op2downstreams[cur]) {
+      degrees[downstream]--;
+      if (degrees[downstream] == 0) {
+        q.push(downstream);
+      }
+    }
+  }
+  CHECK_EQ(result.size(), op_exprs.size());
+  std::vector<ir::Expr> sorted_result;
+  for (const auto& op : result) {
+    sorted_result.push_back(*op);
+  }
+  return sorted_result;
+}
+
+/// Start: Tmp Transform Operation for ReduceTree
+std::vector<FusionOp> ReduceTransformRecursive(
+    ReduceOp reduce_op,
+    const ReduceTreePattern<BackendStage>& reduce_tree_pattern,
+    const std::vector<size_t>& fake_reduce_iter_idx = {}) {
+  FusionOp root_op = reduce_op;
+  VLOG(4) << "ReduceTransformRecursive: " << *_GetFuncBodyPointer(root_op);
+  std::vector<FusionOp> result;
+  for (const auto& child_tree : reduce_tree_pattern.childs()) {
+    const auto& child_reduce_op = child_tree.GetRootPattern().reduce_op;
+    auto transformed_nodes = cinn::hlir::framework::pir::trivial_fusion_detail::
+        TransformReduceLoopRange(
+            child_reduce_op, &root_op, fake_reduce_iter_idx);
+    for (auto& node : transformed_nodes) {
+      auto child_flatten =
+          ReduceTransformRecursive(std::get<ReduceOp>(node), child_tree);
+      result.insert(result.end(), child_flatten.begin(), child_flatten.end());
+    }
+  }
+  result.push_back(root_op);
+  VLOG(4) << "ReduceTransformRecursive: End";
+  return result;
+}
+
+std::vector<FusionOp> ReduceTreeTrivialTransformRecursive(
+    TrivialOp trivial_op,
+    const ReduceTreePlusTrivialPattern<BackendStage>& rt_pattern) {
+  FusionOp root_op = trivial_op;
+  VLOG(4) << "ReduceTrivialTransformRecursive: "
+          << *_GetFuncBodyPointer(root_op);
+  std::vector<FusionOp> result;
+
+  const auto& child_tree = rt_pattern.tree;
+  const auto& child_reduce_op = child_tree.GetRootPattern().reduce_op;
+  auto transformed_nodes = cinn::hlir::framework::pir::trivial_fusion_detail::
+      TransformReduceLoopRange(
+          child_reduce_op, &root_op, rt_pattern.fake_reduce_iter_idx);
+  for (auto& node : transformed_nodes) {
+    auto child_flatten = ReduceTransformRecursive(
+        std::get<ReduceOp>(node), child_tree, rt_pattern.fake_reduce_iter_idx);
+    result.insert(result.end(), child_flatten.begin(), child_flatten.end());
+  }
+  //}
+  result.push_back(
+      cinn::hlir::framework::pir::trivial_fusion_detail::SinkTrivialLoopAlign(
+          std::get<TrivialOp>(root_op),
+          rt_pattern.tree.GetRootPattern().reduce_op,
+          rt_pattern.fake_reduce_iter_idx));
+  VLOG(4) << "ReduceTrivialTransformRecursive End;";
+  return result;
+}
+
+static std::vector<ir::Var> GetAllForIters(const ir::Expr& expr) {
+  using cinn::hlir::framework::pir::trivial_fusion_detail::ExprSetFinderUtils::
+      ChildFors;
+  using cinn::hlir::framework::pir::trivial_fusion_detail::ExprSetFinderUtils::
+      ChildScheduleBlockRealizes;
+  using cinn::hlir::framework::pir::trivial_fusion_detail::ExprSetFinderUtils::
+      FindFather;
+  using cinn::hlir::framework::pir::trivial_fusion_detail::ExprSetFinderUtils::
+      IsFor;
+  using cinn::hlir::framework::pir::trivial_fusion_detail::ExprSetFinderUtils::
+      ScheduleBlockRealizeIsNotInit;
+  const auto& all_father_fors =
+      (ChildScheduleBlockRealizes * ScheduleBlockRealizeIsNotInit *
+       FindFather(expr) * IsFor)(expr);
+  std::vector<ir::Var> vars;
+  for (const auto& for_expr : all_father_fors) {
+    vars.push_back(for_expr.As<ir::For>()->loop_var);
+  }
+  VLOG(4) << "GetAllForIters : " << expr
+          << "\n var is : " << utils::Join(vars, ",");
+  return vars;
+}
+
+ir::Expr UnSqueezeExpr(const ir::Expr& expr,
+                       const std::vector<int> padding_vec) {
+  using cinn::hlir::framework::pir::trivial_fusion_detail::AppendBound;
+  using cinn::hlir::framework::pir::trivial_fusion_detail::ExprSetFinderUtils::
+      ChildFors;
+  using cinn::hlir::framework::pir::trivial_fusion_detail::ExprSetFinderUtils::
+      ChildRootScheduleBlockRealizes;
+  using cinn::hlir::framework::pir::trivial_fusion_detail::ExprSetFinderUtils::
+      ChildScheduleBlockRealizes;
+  using cinn::hlir::framework::pir::trivial_fusion_detail::ExprSetFinderUtils::
+      IsForIterVar;
+  using cinn::hlir::framework::pir::trivial_fusion_detail::
+      ExprTransformerUtils::ReplaceVarTransformer;
+  using cinn::hlir::framework::pir::trivial_fusion_detail::
+      ExprTransformerUtils::UnsqueezeForTransformer;
+  VLOG(4) << "UnSqueezeExpr: " << expr
+          << "\npadding vector: " << utils::Join(padding_vec, ", ");
+  const auto& vars_in_expr = AppendBound(GetAllForIters(expr), expr);
+  // get the all vars.
+  int counter = 0;
+  auto GenNextName = [&counter]() {
+    counter += 1;
+    return "expand_var_" + std::to_string(counter);
+  };
+  std::vector<ir::Var> vars;
+  int pointer = 0;
+  for (int i = 0; i < vars_in_expr.size() + padding_vec.size(); i++) {
+    if (std::find(padding_vec.begin(), padding_vec.end(), i) !=
+        padding_vec.end()) {
+      vars.emplace_back(Expr(0), Expr(1), GenNextName());
+    } else {
+      vars.push_back(vars_in_expr[pointer++]);
+    }
+  }
+  // update the is_reduce of expand_var.
+  for (int i : padding_vec) {
+    if (i == 0) {
+      vars[i]->is_reduce_axis = false;
+    } else {
+      vars[i]->is_reduce_axis = vars[i - 1]->is_reduce_axis;
+    }
+  }
+
+  // sequencely unsqueeze the ir::Expr.
+  ir::Expr result = expr;
+  for (int i : padding_vec) {
+    if (i > 0) {
+      result = UnsqueezeForTransformer((ChildFors * IsForIterVar(vars[i - 1])),
+                                       vars[i])(result);
+    } else {
+      result = UnsqueezeForTransformer(ChildRootScheduleBlockRealizes,
+                                       vars[i])(result);
+    }
+  }
+  return result;
+}
+
+struct IrExprGetter {
+  std::vector<ir::Expr> operator()(
+      const ReduceTreePattern<BackendStage>& pattern) {
+    const auto& fusion_op =
+        ReduceTransformRecursive(pattern.GetRootPattern().reduce_op, pattern);
+    std::function<std::vector<ir::Expr>(const FusionOp& f)> func =
+        [](const FusionOp& op) { return std::visit(FusionOp2Expr(), op); };
+    return VectorFlatMap(fusion_op, func);
+  }
+
+  std::vector<ir::Expr> operator()(
+      const ReduceTreePlusTrivialPattern<BackendStage>& pattern) {
+    std::function<std::vector<ir::Expr>(const FusionOp& f)> func =
+        [](const FusionOp& op) { return std::visit(FusionOp2Expr(), op); };
+    const auto& fusion_ops = ReduceTreeTrivialTransformRecursive(
+        pattern.sink_trivial.trivial_op, pattern);
+    return VectorFlatMap(fusion_ops, func);
+  }
+
+  std::vector<ir::Expr> operator()(
+      const HorizontalFusionPattern<BackendStage>& pattern) {
+    std::vector<ir::Expr> result;
+    VLOG(4) << "Get Fusion Ops from HorizontalFusionPattern: "
+            << pattern.padding_patterns_.size();
+    for (const auto& sub_pattern : pattern.padding_patterns_) {
+      std::function<ir::Expr(ir::Expr)> func =
+          [&sub_pattern](const ir::Expr& expr) {
+            return UnSqueezeExpr(expr, sub_pattern.padding_pos);
+          };
+      result = ConcatVector(
+          result, MapVector(GetExprFromPattern(sub_pattern.pattern), func));
+    }
+    return result;
+  }
+};
+
+}  // namespace cinn::fusion
diff --git a/paddle/cinn/operator_fusion/fusion_tracker/expr_utils.h b/paddle/cinn/operator_fusion/fusion_tracker/expr_utils.h
new file mode 100644
index 00000000000000..3a16bd39dd7618
--- /dev/null
+++ b/paddle/cinn/operator_fusion/fusion_tracker/expr_utils.h
@@ -0,0 +1,53 @@
+// Copyright (c) 2024 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/cinn/hlir/framework/pir/trivial_op_impl.h"
+
+namespace cinn::fusion {
+
+using TrivialOp = cinn::hlir::framework::pir::trivial_fusion_detail::TrivialOp;
+using ReduceOp = cinn::hlir::framework::pir::trivial_fusion_detail::ReduceOp;
+using FusionOp = std::variant<ReduceOp, TrivialOp>;
+
+struct FusionOp2Expr {
+  std::vector<ir::Expr> operator()(const TrivialOp& op) {
+    return {op.GetFuncBody()};
+  }
+  std::vector<ir::Expr> operator()(const ReduceOp& op) {
+    const auto& t_r = SplitReduceOp(op);
+    return {t_r.first.GetFuncBody(), t_r.second.GetFuncBody()};
+  }
+};
+
+struct ApplyTransform {
+  explicit ApplyTransform(const ir::Expr& expr) : expr_(expr) {}
+  ir::Expr operator()(const UnsupportTransformPtr& transform) {
+    PADDLE_THROW("Can not do UnsupportTransform");
+  }
+  ir::Expr operator()(const IdentityTransformPtr& transform) { return expr_; }
+  ir::Expr operator()(const AppendDimTransformPtr& transform) {
+    PADDLE_THROW("AppendDimTransform not implemented");
+  }
+  ir::Expr operator()(const DeleteDimTransformPtr& transform) {
+    PADDLE_THROW("DeleteDimTransform not implemented");
+  }
+
+ private:
+  ir::Expr expr_;
+};
+
+std::vector<ir::Expr> TopoSort(const std::vector<ir::Expr>& op_exprs);
+
+}  // namespace cinn::fusion
diff --git a/paddle/cinn/operator_fusion/fusion_tracker/interpreter.cc b/paddle/cinn/operator_fusion/fusion_tracker/interpreter.cc
index ae4d03d87ce336..932cf4d2639dd5 100644
--- a/paddle/cinn/operator_fusion/fusion_tracker/interpreter.cc
+++ b/paddle/cinn/operator_fusion/fusion_tracker/interpreter.cc
@@ -16,529 +16,143 @@
 
 #include "glog/logging.h"
 
-#include "paddle/cinn/hlir/framework/pir/trivial_op_impl.h"
+#include "paddle/cinn/operator_fusion/fusion_tracker/expr_utils.h"
 #include "paddle/cinn/operator_fusion/fusion_tracker/interpreter.h"
 
 namespace cinn::fusion {
 
-using TrivialOp = cinn::hlir::framework::pir::trivial_fusion_detail::TrivialOp;
-using ReduceOp = cinn::hlir::framework::pir::trivial_fusion_detail::ReduceOp;
-using FusionOp = std::variant<ReduceOp, TrivialOp>;
-
-template <>
-StmtPattern<BackendStage> ConvertToStmtPattern(
-    const PatternContent<BackendStage>& content) {
-  const auto& kind = GetOpPatternKind(content.op);
-  if (kind == hlir::framework::kReduction) {
-    CHECK(content.expr.has_value());
-    return ReducePattern<BackendStage>({content.op},
-                                       ReduceOp(content.expr.value()));
-  } else if (kind == hlir::framework::kElementWise ||
-             kind == hlir::framework::kBroadcast ||
-             kind == hlir::framework::kInjective) {
-    CHECK(content.expr.has_value());
-    return TrivialPattern<BackendStage>(
-        {content.op}, content.op, TrivialOp(content.expr.value()));
-  } else {
-    CHECK(false);
-    return UnsupportPattern<BackendStage>({content.op});
-  }
-}
-
-// template StmtPattern<BackendStage> RT_x_RT(const
-// ReduceTreePattern<BackendStage>& upstream, const
-// ReduceTreePattern<BackendStage>& downstream);
-
-template <>
-StmtPattern<BackendStage> MergePatternImpl(
-    const ReduceTreePattern<BackendStage>& first,
-    const TrivialPattern<BackendStage>& second) {
-  return ReduceTreePlusTrivialPattern<BackendStage>(first, second);
-}
-
-template <>
-StmtPattern<BackendStage> MergePatternImpl(
-    const TrivialPattern<BackendStage>& first,
-    const ReducePattern<BackendStage>& second) {
-  const auto& ops = UniqueConcatVector(GetOpsInPattern<BackendStage>(first),
-                                       GetOpsInPattern<BackendStage>(second));
-  const auto& reduce_op =
-      cinn::hlir::framework::pir::trivial_fusion_detail::TrivalxOther_Fusion(
-          first.trivial_op, second.reduce_op);
-  return ReducePattern<BackendStage>(ops, reduce_op);
-}
-
-template <>
-StmtPattern<BackendStage> MergePatternImpl(
-    const TrivialPattern<BackendStage>& first,
-    const TrivialPattern<BackendStage>& second) {
-  const auto& ops = UniqueConcatVector(GetOpsInPattern<BackendStage>(first),
-                                       GetOpsInPattern<BackendStage>(second));
-  const auto& trivial_op =
-      cinn::hlir::framework::pir::trivial_fusion_detail::TrivalxOther_Fusion(
-          first.trivial_op, second.trivial_op);
-  return TrivialPattern<BackendStage>(ops, second.sink_op(), trivial_op);
-}
-
-template <>
-StmtPattern<BackendStage> MergePatternImpl(
-    const TrivialPattern<BackendStage>& first,
-    const AnchorPattern<BackendStage>& second) {
-  AnchorState<BackendStage> new_anchor_state = second.anchor_state;
-
-  for (int i = 0; i < new_anchor_state.promise.size(); i++) {
-    new_anchor_state.promise[i].root_fusion_op = std::visit(
-        [first](const auto& arg) -> FusionOp {
-          return cinn::hlir::framework::pir::trivial_fusion_detail::
-              TrivalxOther_Fusion(first.trivial_op, arg);
-        },
-        new_anchor_state.promise[i].root_fusion_op);
-  }
-
-  return AnchorPattern<BackendStage>(
-      UniqueConcatVector(GetOpsInPattern<BackendStage>(first),
-                         GetOpsInPattern<BackendStage>(second)),
-      second.anchor(),
-      new_anchor_state);
-}
-
-template <>
-StmtPattern<BackendStage> MergePatternImpl(
-    const AnchorPattern<BackendStage>& source,
-    const AnchorPattern<BackendStage>& dest) {
-  const auto& contents =
-      UniqueConcatVector(GetOpsInPattern<BackendStage>(source),
-                         GetOpsInPattern<BackendStage>(dest));
-  return AnchorPattern<BackendStage>(
-      contents, source.anchor(), AnchorState<BackendStage>({}));
-}
-
-/// Start: Tmp Transform Operation for ReduceTree
-std::vector<FusionOp> ReduceTransformRecursive(
-    ReduceOp reduce_op,
-    const ReduceTreePattern<BackendStage>& reduce_tree_pattern,
-    const std::vector<size_t>& fake_reduce_iter_idx = {}) {
-  FusionOp root_op = reduce_op;
-  VLOG(4) << "ReduceTransformRecursive: " << *_GetFuncBodyPointer(root_op);
-  std::vector<FusionOp> result;
-  for (const auto& child_tree : reduce_tree_pattern.childs()) {
-    const auto& child_reduce_op = child_tree.GetRootPattern().reduce_op;
-    auto transformed_nodes = cinn::hlir::framework::pir::trivial_fusion_detail::
-        TransformReduceLoopRange(
-            child_reduce_op, &root_op, fake_reduce_iter_idx);
-    for (auto& node : transformed_nodes) {
-      auto child_flatten =
-          ReduceTransformRecursive(std::get<ReduceOp>(node), child_tree);
-      result.insert(result.end(), child_flatten.begin(), child_flatten.end());
-    }
-  }
-  result.push_back(root_op);
-  VLOG(4) << "ReduceTransformRecursive: End";
-  return result;
-}
-
-std::vector<FusionOp> ReduceTreeTrivialTransformRecursive(
-    TrivialOp trivial_op,
-    const ReduceTreePlusTrivialPattern<BackendStage>& rt_pattern) {
-  FusionOp root_op = trivial_op;
-  VLOG(4) << "ReduceTrivialTransformRecursive: "
-          << *_GetFuncBodyPointer(root_op);
-  std::vector<FusionOp> result;
-
-  const auto& child_tree = rt_pattern.tree;
-  const auto& child_reduce_op = child_tree.GetRootPattern().reduce_op;
-  auto transformed_nodes = cinn::hlir::framework::pir::trivial_fusion_detail::
-      TransformReduceLoopRange(
-          child_reduce_op, &root_op, rt_pattern.fake_reduce_iter_idx);
-  for (auto& node : transformed_nodes) {
-    auto child_flatten = ReduceTransformRecursive(
-        std::get<ReduceOp>(node), child_tree, rt_pattern.fake_reduce_iter_idx);
-    result.insert(result.end(), child_flatten.begin(), child_flatten.end());
-  }
-  //}
-  result.push_back(
+void RunRenameInstr(const std::shared_ptr<RenameInstr>& instr,
+                    FusionInterpreter* interpreter) {
+  interpreter->scope[instr->new_name_] =
+      interpreter->scope[instr->origin_name_];
+  interpreter->scope.erase(instr->origin_name_);
+}
+
+void RunCombineInstr(const std::shared_ptr<CombineInstr>& instr,
+                     FusionInterpreter* interpreter) {
+  interpreter->scope[instr->result_] = CombineScopeElement(
+      interpreter->scope[instr->first_], interpreter->scope[instr->second_]);
+}
+
+void RunInitPatternInstr(const std::shared_ptr<InitPatternInstr>& instr,
+                         FusionInterpreter* interpreter) {
+  ScopeElementPtr new_pattern = std::make_shared<ScopeElement>();
+  new_pattern->fusion_ops.emplace_back((interpreter->lowered_expr)[instr->op_]);
+  interpreter->scope[instr->result_] = new_pattern;
+}
+
+void RunTrivialInlineInstr(const std::shared_ptr<TrivialInlineInstr>& instr,
+                           FusionInterpreter* interpreter) {
+  PADDLE_ENFORCE_EQ(interpreter->scope[instr->upstream_]->fusion_ops.size(), 1);
+  auto upstream_op = std::get<TrivialOp>(
+      interpreter->scope[instr->upstream_]->fusion_ops.front());
+  ScopeElementPtr new_pattern = std::make_shared<ScopeElement>();
+  for (auto downstream_op :
+       interpreter->scope[instr->downstream_]->fusion_ops) {
+    new_pattern->fusion_ops.emplace_back(
+        cinn::hlir::framework::pir::trivial_fusion_detail::TrivalxOther_Fusion(
+            upstream_op, downstream_op));
+  }
+  interpreter->scope[instr->result_] = new_pattern;
+}
+
+void RunTmpTransformInstr(const std::shared_ptr<TmpTransformInstr>& instr,
+                          FusionInterpreter* interpreter) {
+  PADDLE_ENFORCE_EQ(interpreter->scope[instr->upstream_]->fusion_ops.size(), 1);
+  PADDLE_ENFORCE_EQ(interpreter->scope[instr->downstream_]->fusion_ops.size(),
+                    1);
+  auto upstream_op = std::get<ReduceOp>(
+      interpreter->scope[instr->upstream_]->fusion_ops.front());
+  auto downstream_op =
+      interpreter->scope[instr->downstream_]->fusion_ops.front();
+  ScopeElementPtr new_pattern = std::make_shared<ScopeElement>();
+  new_pattern->fusion_ops.emplace(
+      cinn::hlir::framework::pir::trivial_fusion_detail::
+          TransformReduceLoopRange(
+              upstream_op, &downstream_op, instr->fake_reduce_iter_idx_););
+  interpreter->scope[instr->result_] = new_pattern;
+}
+
+void RunTrivialLoopAlignInstr(
+    const std::shared_ptr<TrivialLoopAlignInstr>& instr,
+    FusionInterpreter* interpreter) {
+  PADDLE_ENFORCE_EQ(interpreter->scope[instr->upstream_]->fusion_ops.size(), 1);
+  PADDLE_ENFORCE_EQ(interpreter->scope[instr->downstream_]->fusion_ops.size(),
+                    1);
+  auto upstream_op = std::get<ReduceOp>(
+      interpreter->scope[instr->upstream_]->fusion_ops.front());
+  auto downstream_op = std::get<TrivialOp>(
+      interpreter->scope[instr->downstream_]->fusion_ops.front());
+  ScopeElementPtr new_pattern = std::make_shared<ScopeElement>();
+  new_pattern->fusion_ops.emplace(
       cinn::hlir::framework::pir::trivial_fusion_detail::SinkTrivialLoopAlign(
-          std::get<TrivialOp>(root_op),
-          rt_pattern.tree.GetRootPattern().reduce_op,
-          rt_pattern.fake_reduce_iter_idx));
-  VLOG(4) << "ReduceTrivialTransformRecursive End;";
-  return result;
+          downstream_op, upstream_op, instr->fake_reduce_iter_idx_););
+  interpreter->scope[instr->result_] = new_pattern;
 }
 
-/// End: Tmp Transform Operation for reduce tree
-///
-struct FusionOp2Expr {
-  std::vector<ir::Expr> operator()(const TrivialOp& op) {
-    return {op.GetFuncBody()};
-  }
-  std::vector<ir::Expr> operator()(const ReduceOp& op) {
-    const auto& t_r = SplitReduceOp(op);
-    return {t_r.first.GetFuncBody(), t_r.second.GetFuncBody()};
-  }
-};
-
-struct ApplyTransform {
-  explicit ApplyTransform(const ir::Expr& expr) : expr_(expr) {}
-  ir::Expr operator()(const UnsupportTransformPtr& transform) {
-    PADDLE_THROW("Can not do UnsupportTransform");
-  }
-  ir::Expr operator()(const IdentityTransformPtr& transform) { return expr_; }
-  ir::Expr operator()(const AppendDimTransformPtr& transform) {
-    PADDLE_THROW("AppendDimTransform not implemented");
-  }
-  ir::Expr operator()(const DeleteDimTransformPtr& transform) {
-    PADDLE_THROW("DeleteDimTransform not implemented");
-  }
+void RunAnchorTransformAndReturnInstr(
+    const std::shared_ptr<AnchorTransformAndReturnInstr>& instr,
+    FusionInterpreter* interpreter) {
+  PADDLE_ENFORCE_EQ(interpreter->scope[instr->target_]->fusion_ops.size(), 1);
+  ScopeElementPtr new_pattern = std::make_shared<ScopeElement>();
 
- private:
-  ir::Expr expr_;
-};
-
-std::vector<ir::Expr> GetExprFromPattern(
-    const StmtPattern<BackendStage>& pattern);
-
-static std::vector<ir::Var> GetAllForIters(const ir::Expr& expr) {
-  using cinn::hlir::framework::pir::trivial_fusion_detail::ExprSetFinderUtils::
-      ChildFors;
-  using cinn::hlir::framework::pir::trivial_fusion_detail::ExprSetFinderUtils::
-      ChildScheduleBlockRealizes;
-  using cinn::hlir::framework::pir::trivial_fusion_detail::ExprSetFinderUtils::
-      FindFather;
-  using cinn::hlir::framework::pir::trivial_fusion_detail::ExprSetFinderUtils::
-      IsFor;
-  using cinn::hlir::framework::pir::trivial_fusion_detail::ExprSetFinderUtils::
-      ScheduleBlockRealizeIsNotInit;
-  const auto& all_father_fors =
-      (ChildScheduleBlockRealizes * ScheduleBlockRealizeIsNotInit *
-       FindFather(expr) * IsFor)(expr);
-  std::vector<ir::Var> vars;
-  for (const auto& for_expr : all_father_fors) {
-    vars.push_back(for_expr.As<ir::For>()->loop_var);
-  }
-  VLOG(4) << "GetAllForIters : " << expr
-          << "\n var is : " << utils::Join(vars, ",");
-  return vars;
-}
-
-ir::Expr UnSqueezeExpr(const ir::Expr& expr,
-                       const std::vector<int> padding_vec) {
-  using cinn::hlir::framework::pir::trivial_fusion_detail::AppendBound;
-  using cinn::hlir::framework::pir::trivial_fusion_detail::ExprSetFinderUtils::
-      ChildFors;
-  using cinn::hlir::framework::pir::trivial_fusion_detail::ExprSetFinderUtils::
-      ChildRootScheduleBlockRealizes;
-  using cinn::hlir::framework::pir::trivial_fusion_detail::ExprSetFinderUtils::
-      ChildScheduleBlockRealizes;
-  using cinn::hlir::framework::pir::trivial_fusion_detail::ExprSetFinderUtils::
-      IsForIterVar;
-  using cinn::hlir::framework::pir::trivial_fusion_detail::
-      ExprTransformerUtils::ReplaceVarTransformer;
-  using cinn::hlir::framework::pir::trivial_fusion_detail::
-      ExprTransformerUtils::UnsqueezeForTransformer;
-  VLOG(4) << "UnSqueezeExpr: " << expr
-          << "\npadding vector: " << utils::Join(padding_vec, ", ");
-  const auto& vars_in_expr = AppendBound(GetAllForIters(expr), expr);
-  // get the all vars.
-  int counter = 0;
-  auto GenNextName = [&counter]() {
-    counter += 1;
-    return "expand_var_" + std::to_string(counter);
-  };
-  std::vector<ir::Var> vars;
-  int pointer = 0;
-  for (int i = 0; i < vars_in_expr.size() + padding_vec.size(); i++) {
-    if (std::find(padding_vec.begin(), padding_vec.end(), i) !=
-        padding_vec.end()) {
-      vars.emplace_back(Expr(0), Expr(1), GenNextName());
-    } else {
-      vars.push_back(vars_in_expr[pointer++]);
-    }
-  }
-  // update the is_reduce of expand_var.
-  for (int i : padding_vec) {
-    if (i == 0) {
-      vars[i]->is_reduce_axis = false;
-    } else {
-      vars[i]->is_reduce_axis = vars[i - 1]->is_reduce_axis;
-    }
-  }
-
-  // sequencely unsqueeze the ir::Expr.
-  ir::Expr result = expr;
-  for (int i : padding_vec) {
-    if (i > 0) {
-      result = UnsqueezeForTransformer((ChildFors * IsForIterVar(vars[i - 1])),
-                                       vars[i])(result);
-    } else {
-      result = UnsqueezeForTransformer(ChildRootScheduleBlockRealizes,
-                                       vars[i])(result);
-    }
-  }
-  return result;
-}
-
-std::vector<ir::Expr> ApplyTransformToPromise(
-    const ExprPromise<BackendStage>& promise) {
   std::function<ir::Expr(ir::Expr)> do_transform =
-      [transform_route = promise.transform_route](ir::Expr target) -> ir::Expr {
+      [transform_route = instr->transform_route_](ir::Expr target) -> ir::Expr {
     for (auto transform : transform_route) {
       target = std::visit(ApplyTransform(target), transform);
     }
     return target;
   };
-  return MapVector(std::visit(FusionOp2Expr(), promise.root_fusion_op),
-                   do_transform);
-}
 
-struct IrExprGetter {
-  std::vector<ir::Expr> operator()(
-      const TrivialPattern<BackendStage>& pattern) {
-    return FusionOp2Expr()(pattern.trivial_op);
-  }
-
-  std::vector<ir::Expr> operator()(const ReducePattern<BackendStage>& pattern) {
-    return FusionOp2Expr()(pattern.reduce_op);
-  }
-
-  std::vector<ir::Expr> operator()(
-      const ReduceTreePattern<BackendStage>& pattern) {
-    const auto& fusion_op =
-        ReduceTransformRecursive(pattern.GetRootPattern().reduce_op, pattern);
-    std::function<std::vector<ir::Expr>(const FusionOp& f)> func =
-        [](const FusionOp& op) { return std::visit(FusionOp2Expr(), op); };
-    return VectorFlatMap(fusion_op, func);
-  }
-
-  std::vector<ir::Expr> operator()(
-      const ReduceTreePlusTrivialPattern<BackendStage>& pattern) {
-    std::function<std::vector<ir::Expr>(const FusionOp& f)> func =
-        [](const FusionOp& op) { return std::visit(FusionOp2Expr(), op); };
-    const auto& fusion_ops = ReduceTreeTrivialTransformRecursive(
-        pattern.sink_trivial.trivial_op, pattern);
-    return VectorFlatMap(fusion_ops, func);
-  }
-
-  std::vector<ir::Expr> operator()(
-      const HorizontalFusionPattern<BackendStage>& pattern) {
-    std::vector<ir::Expr> result;
-    VLOG(4) << "Get Fusion Ops from HorizontalFusionPattern: "
-            << pattern.padding_patterns_.size();
-    for (const auto& sub_pattern : pattern.padding_patterns_) {
-      std::function<ir::Expr(ir::Expr)> func =
-          [&sub_pattern](const ir::Expr& expr) {
-            return UnSqueezeExpr(expr, sub_pattern.padding_pos);
-          };
-      result = ConcatVector(
-          result, MapVector(GetExprFromPattern(sub_pattern.pattern), func));
-    }
-    return result;
-  }
-
-  std::vector<ir::Expr> operator()(const AnchorPattern<BackendStage>& pattern) {
-    std::vector<ir::Expr> result;
-    for (auto promise : pattern.anchor_state.promise) {
-      result = ConcatVector(result, ApplyTransformToPromise(promise));
-    }
-    return result;
-  }
-
-  std::vector<ir::Expr> operator()(
-      const UnsupportPattern<BackendStage>& pattern) {
-    CHECK(false) << "Not Implemented.";
-  }
-};
-
-// tmp transform for reduce_tree and reduce_tree_trivial.
-std::vector<ir::Tensor> GetOutputTensors(const ir::Expr& op_expr) {
-  using cinn::hlir::framework::pir::trivial_fusion_detail::ExprSetFinderUtils::
-      ChildScheduleBlockRealizes;
-  using cinn::hlir::framework::pir::trivial_fusion_detail::ExprSetFinderUtils::
-      ChildTensorStores;
-  using cinn::hlir::framework::pir::trivial_fusion_detail::ExprSetFinderUtils::
-      ScheduleBlockRealizeIsNotInit;
-  const auto& tensors =
-      (ChildScheduleBlockRealizes * ScheduleBlockRealizeIsNotInit *
-       ChildTensorStores)(op_expr);
-  std::function<ir::Tensor(ir::Expr)> func = [](const ir::Expr& expr) {
-    return expr.As<ir::Store>()->tensor.as_tensor_ref();
-  };
-  return MapVector(tensors, func);
+  auto exprs = do_transform(std::visit(
+      FusionOp2Expr(), interpreter->scope[instr->target_]->fusion_ops.front()));
+  interpreter.ret_expr.insert(
+      interpreter.ret_expr.end(), exprs.begin(), exprs.end());
 }
 
-std::vector<ir::Tensor> GetInputTensors(const ir::Expr& op_expr) {
-  using cinn::hlir::framework::pir::trivial_fusion_detail::ExprSetFinderUtils::
-      ChildScheduleBlockRealizes;
-  using cinn::hlir::framework::pir::trivial_fusion_detail::ExprSetFinderUtils::
-      ChildTensorLoads;
-  using cinn::hlir::framework::pir::trivial_fusion_detail::ExprSetFinderUtils::
-      ScheduleBlockRealizeIsNotInit;
-  const auto& exprs =
-      (ChildScheduleBlockRealizes * ScheduleBlockRealizeIsNotInit *
-       ChildTensorLoads)(op_expr);
-  std::function<ir::Tensor(ir::Expr)> func = [](const ir::Expr& expr) {
-    return expr.As<ir::Load>()->tensor.as_tensor_ref();
-  };
-  const auto& inputs = MapVector(exprs, func);
-  const auto& outputs = GetOutputTensors(op_expr);
-  return FilterVector(inputs, [&outputs](const ir::Tensor& tensor) {
-    return std::find(outputs.begin(), outputs.end(), tensor) == outputs.end();
-  });
-}
-
-std::vector<ir::Expr> TopoSort(const std::vector<ir::Expr>& op_exprs) {
-  // Topo Sort is important for CINN GroupSchedule.
-  std::map<ir::Tensor, std::vector<const ir::Expr*>> tensor2defining_op;
-  std::map<ir::Tensor, std::vector<const ir::Expr*>> tensor2used_op;
-  for (const auto& op : op_exprs) {
-    auto inputs = GetInputTensors(op);
-    auto outputs = GetOutputTensors(op);
-
-    if (VLOG_IS_ON(5)) {
-      VLOG(4) << "Ir::Expr is: \n" << op;
-      VLOG(4) << "Inputs: ";
-      for (const auto& input : inputs) {
-        VLOG(4) << input->name;
-      }
-      VLOG(4) << "Outputs: ";
-      for (const auto& output : outputs) {
-        VLOG(4) << output->name;
-      }
-    }
-    for (const auto& input : inputs) {
-      tensor2used_op[input].push_back(&op);
-    }
-    for (const auto& output : outputs) {
-      tensor2defining_op[output].push_back(&op);
-    }
-  }
-
-  // Collect Downstreams
-  std::map<const ir::Expr*, std::vector<const ir::Expr*>> op2downstreams;
-  std::map<const ir::Expr*, int> degrees;
-  for (const auto& op : op_exprs) {
-    degrees[&op] = 0;
-  }
-  for (const auto& op : op_exprs) {
-    auto outputs = GetOutputTensors(op);
-    std::vector<const ir::Expr*> downstreams;
-    for (const auto& output : outputs) {
-      downstreams = ConcatVector(downstreams, tensor2used_op[output]);
-    }
-    for (const auto& downstream : downstreams) {
-      degrees[downstream]++;
-    }
-    op2downstreams[&op] = downstreams;
-  }
-
-  // Topo Sort
-  std::vector<const ir::Expr*> result;
-  std::queue<const ir::Expr*> q;
-  for (const auto& op : op_exprs) {
-    if (degrees[&op] == 0) {
-      q.push(&op);
-    }
-  }
-  while (!q.empty()) {
-    auto* cur = q.front();
-    VLOG(4) << "Topo Sort Visit Order is:" << GetOutputTensors(*cur)[0]->name;
-    q.pop();
-    result.push_back(cur);
-    for (const auto& downstream : op2downstreams[cur]) {
-      degrees[downstream]--;
-      if (degrees[downstream] == 0) {
-        q.push(downstream);
-      }
-    }
-  }
-  CHECK_EQ(result.size(), op_exprs.size());
-  std::vector<ir::Expr> sorted_result;
-  for (const auto& op : result) {
-    sorted_result.push_back(*op);
+void RunReturnInstr(const std::shared_ptr<ReturnInstr>& instr,
+                    FusionInterpreter* interpreter) {
+  for (auto fusion_op : interpreter->scope[instr->target_]->fusion_ops) {
+    auto exprs = std::visit(FusionOp2Expr(), fusion_op);
+    interpreter.ret_expr.insert(
+        interpreter.ret_expr.end(), exprs.begin(), exprs.end());
   }
-  return sorted_result;
 }
 
-std::vector<ir::Expr> GetExprFromPattern(
-    const StmtPattern<BackendStage>& pattern) {
-  const auto& results = std::visit(IrExprGetter(), pattern.variant());
-  return TopoSort(results);
-}
-
-template <>
-ExprPromise<BackendStage> InitExprPromiseImpl(
-    const TrivialPattern<BackendStage>& pattern, pir::Value anchor) {
-  return ExprPromise<BackendStage>(anchor, pattern.trivial_op);
-}
-
-template <>
-ExprPromise<BackendStage> InitExprPromiseImpl(
-    const ReducePattern<BackendStage>& pattern, pir::Value anchor) {
-  return ExprPromise<BackendStage>(anchor, pattern.reduce_op);
-}
-
-template <>
-TrivialPattern<BackendStage> RecoverAnchorPatternToTrivial(
-    const AnchorPattern<BackendStage>& anchor_pattern) {
-  PADDLE_ENFORCE(anchor_pattern.anchor_state.promise.size() == 1 &&
-                     std::holds_alternative<TrivialOp>(
-                         anchor_pattern.anchor_state.promise[0].root_fusion_op),
-                 phi::errors::PreconditionNotMet(
-                     "Can only recover AnchorPatter whose anchor_state size is "
-                     "1 (exact %d) and holds TrivialOp",
-                     anchor_pattern.anchor_state.promise.size()));
-
-  return TrivialPattern<BackendStage>(
-      anchor_pattern.ops(),
-      anchor_pattern.anchor().defining_op(),
-      std::get<TrivialOp>(
-          anchor_pattern.anchor_state.promise[0].root_fusion_op));
-}
-
-void RunRenameInstr(const FusionInstrPtr& instr, FusionInterpreter* scope);
-void RunCombineInstr(const FusionInstrPtr& instr, FusionInterpreter* scope);
-void RunReturnInstr(const FusionInstrPtr& instr, FusionInterpreter* scope);
-void RunInitPatternInstr(const FusionInstrPtr& instr, FusionInterpreter* scope);
-void RunTrivialInlineInstr(const FusionInstrPtr& instr,
-                           FusionInterpreter* scope);
-void RunTmpTransformInstr(const FusionInstrPtr& instr,
-                          FusionInterpreter* scope);
-void RunTmpTransformWithFakeReduceIterInstr(const FusionInstrPtr& instr,
-                                            FusionInterpreter* scope);
-void RunAnchorTransformInstr(const FusionInstrPtr& instr,
-                             FusionInterpreter* scope);
-
-PatternExpr FusionInterpreter::Run() {
-  for (const auto instr : tracker->instructions_) {
+std::vector<ir::Expr> FusionInterpreter::Run() {
+  for (auto instr : tracker->instructions_) {
     switch (instr->type()) {
       case T_Rename:
-        RunRenameInstr(instr, this);
+        RunRenameInstr(dynamic_cast_instr_with_err<RenameInstr>(instr), this);
         break;
       case T_Combine:
-        RunCombineInstr(instr, this);
+        RunCombineInstr(dynamic_cast_instr_with_err<CombineInstr>(instr), this);
         break;
       case T_InitPattern:
-        RunInitPatternInstr(instr, this);
+        RunInitPatternInstr(
+            dynamic_cast_instr_with_err<InitPatternInstr>(instr), this);
         break;
       case T_TrivialInline:
-        RunTrivialInlineInstr(instr, this);
+        RunTrivialInlineInstr(
+            dynamic_cast_instr_with_err<TrivialInlineInstr>(instr), this);
         break;
       case T_TmpTransform:
-        RunTmpTransformInstr(instr, this);
-        break;
-      case T_TmpTransformWithFakeReduceIter:
-        RunTmpTransformWithFakeReduceIterInstr(instr, this);
+        RunTmpTransformInstr(
+            dynamic_cast_instr_with_err<TmpTransformInstr>(instr), this);
         break;
       case T_AnchorTransform:
-        RunAnchorTransformInstr(instr, this);
+        RunAnchorTransformAndReturnInstr(
+            dynamic_cast_instr_with_err<AnchorTransformAndReturnInstr>(instr),
+            this);
         break;
       case T_Return:
-        auto ret_ptr = std::dynamic_pointer_cast<ReturnInstr>(instr);
-        if (!ret_ptr) PADDLE_THROW("Non ReturnInstr return T_Return as type.");
-        return scope[ret_ptr->ret_name_];
+        RunReturnInstr(dynamic_cast_instr_with_err<ReturnInstr>(instr), this);
       default:
         PADDLE_THROW("Unsupported Fusion Instrution");
     }
   }
+
+  return TopoSort(ret_expr);
 }
 
 }  // namespace cinn::fusion
diff --git a/paddle/cinn/operator_fusion/fusion_tracker/interpreter.h b/paddle/cinn/operator_fusion/fusion_tracker/interpreter.h
index 9d1281e092489f..cef69d0f6a7f8c 100644
--- a/paddle/cinn/operator_fusion/fusion_tracker/interpreter.h
+++ b/paddle/cinn/operator_fusion/fusion_tracker/interpreter.h
@@ -14,29 +14,40 @@
 
 #pragma once
 #include <functional>
-#include "paddle/cinn/hlir/framework/pir/trivial_op_impl.h"
+#include "paddle/cinn/operator_fusion/fusion_tracker/expr_utils.h"
 #include "paddle/cinn/operator_fusion/fusion_tracker/tracker.h"
 #include "paddle/cinn/operator_fusion/pattern.h"
 #include "paddle/cinn/operator_fusion/pattern_fuser.h"
 
 namespace cinn::fusion {
 
-struct PatternExpr {
-  std::vector<ir::Expr> exprs;
+struct ScopeElement {
+  std::vector<FusionOp> fusion_ops;
 };
-using PatternExprPtr = std::shared_ptr<PatternExpr>;
+using ScopeElementPtr = std::shared_ptr<ScopeElement>;
+
+ScopeElementPtr CombineScopeElement(const ScopeElementPtr& a,
+                                    const ScopeElementPtr& b);
 
 struct FusionInterpreter {
   FusionInterpreter(
       const FusionTrackerPtr& tracker,
-      const std::unordered_map<pir::Operator*, ir::Expr>& lowered_expr)
+      const std::unordered_map<pir::Operation*, FusionOp>& lowered_expr)
       : tracker(tracker), lowered_expr(lowered_expr) {}
 
-  std::unordered_map<pir::Operator*, ir::Expr> lowered_expr;
-  std::unordered_map<std::string, PatternExprPtr> scope;
+  std::unordered_map<pir::Operation*, FusionOp> lowered_expr;
+  std::unordered_map<std::string, ScopeElementPtr> scope;
   FusionTrackerPtr tracker;
 
-  PatternExpr Run();
+  std::vector<ir::Expr> ret_expr;
+  std::vector<ir::Expr> Run();
 };
 
+template <typename T>
+std::shared_ptr<T> dynamic_cast_instr_with_err(FusionInstrPtr instr) {
+  auto chile_instr = std::dynamic_pointer_cast<T>(instr);
+  if (!chile_instr) PADDLE_THROW("Cast Fusion Instr Failed.");
+  return chile_instr;
+}
+
 }  // namespace cinn::fusion
diff --git a/paddle/cinn/operator_fusion/fusion_tracker/tracker.h b/paddle/cinn/operator_fusion/fusion_tracker/tracker.h
index 447675534300db..5e406b7f3de688 100644
--- a/paddle/cinn/operator_fusion/fusion_tracker/tracker.h
+++ b/paddle/cinn/operator_fusion/fusion_tracker/tracker.h
@@ -24,8 +24,8 @@ enum InstructionType {
   T_InitPattern,
   T_TrivialInline,
   T_TmpTransform,
-  T_TmpTransformWithFakeReduceIter,
-  T_AnchorTransform,
+  T_TrivialLoopAlign,
+  T_AnchorTransformAndReturn,
 };
 
 struct FusionInstruction {
@@ -34,9 +34,8 @@ struct FusionInstruction {
 
 using FusionInstrPtr = std::shared_ptr<FusionInstruction>;
 
-struct RenamePatternInstr : public FusionInstruction {
-  RenamePatternInstr(const std::string& origin_name,
-                     const std::string& new_name)
+struct RenameInstr : public FusionInstruction {
+  RenameInstr(const std::string& origin_name, const std::string& new_name)
       : origin_name_(origin_name), new_name_(new_name) {}
   virtual InstructionType type() { return T_Rename; }
   std::string origin_name_;
@@ -55,9 +54,9 @@ struct CombineInstr : public FusionInstruction {
 };
 
 struct ReturnInstr : public FusionInstruction {
-  RenamePatternInstr(const std::string& ret_name) : ret_name_(ret_name) {}
+  explict ReturnInstr(const std::string& target) : target_(target) {}
   virtual InstructionType type() { return T_Return; }
-  std::string ret_name_;
+  std::string target_;
 };
 
 // struct RemovePatternInstr : public FusionInstruction {};
@@ -84,48 +83,44 @@ struct TrivialInlineInstr : public FusionInstruction {
 struct TmpTransformInstr : public FusionInstruction {
   TmpTransformInstr(const std::string& upstream,
                     const std::string& downstream,
-                    const std::string& result)
-      : upstream_(upstream), downstream_(downstream), result_(result) {}
+                    const std::string& result,
+                    const std::vector<size_t>& fake_reduce_iter_idx)
+      : upstream_(upstream),
+        downstream_(downstream),
+        result_(result),
+        fake_reduce_iter_idx_(fake_reduce_iter_idx) {}
   virtual InstructionType type() { return T_TmpTransform; }
   std::string upstream_;
   std::string downstream_;
   std::string result_;
+  std::vector<size_t> fake_reduce_iter_idx_;
 };
 
-struct TmpTransformWithFakeReduceIterInstr : public FusionInstruction {
-  TmpTransformWithFakeReduceIterInstr(
-      const std::string& upstream,
-      const std::string& downstream,
-      const std::string& result,
-      const std::vector<size_t>& fake_reduce_iter_idx)
+struct TrivialLoopAlignInstr : public FusionInstruction {
+  TrivialLoopAlignInstr(const std::string& upstream,
+                        const std::string& downstream,
+                        const std::string& result,
+                        const std::vector<size_t>& fake_reduce_iter_idx)
       : upstream_(upstream),
         downstream_(downstream),
         result_(result),
         fake_reduce_iter_idx_(fake_reduce_iter_idx) {}
-  virtual InstructionType type() { return T_TmpTransformWithFakeReduceIter; }
+  virtual InstructionType type() { return T_TrivialLoopAlign; }
   std::string upstream_;
   std::string downstream_;
   std::string result_;
   std::vector<size_t> fake_reduce_iter_idx_;
 };
 
-struct AnchorTransformInstr : public FusionInstruction {
-  AnchorTransformInstr(const std::string& upstream,
-                       const std::string& downstream,
-                       const std::string& result,
-                       const AnchorTransformRoute& transform_route,
-                       bool is_upstream_anchor)
-      : upstream_(upstream),
-        downstream_(downstream),
-        result_(result),
-        transform_route_(transform_route),
-        is_upstream_anchor_(is_upstream_anchor) {}
-  virtual InstructionType type() { return T_AnchorTransform; }
-  std::string upstream_;
-  std::string downstream_;
+struct AnchorTransformAndReturnInstr : public FusionInstruction {
+  AnchorTransformAndReturnInstr(const std::string& target,
+                                const std::string& result,
+                                const AnchorTransformRoute& transform_route)
+      : target_(target), result_(result), transform_route_(transform_route) {}
+  virtual InstructionType type() { return T_AnchorTransformAndReturn; }
+  std::string target_;
   std::string result_;
   AnchorTransformRoute transform_route_;
-  bool is_upstream_anchor_;
 };
 
 struct FusionTracker {
diff --git a/paddle/cinn/operator_fusion/graph_transformer/operation.h b/paddle/cinn/operator_fusion/graph_transformer/operation.h
index c50b050981089a..64a66086c95137 100644
--- a/paddle/cinn/operator_fusion/graph_transformer/operation.h
+++ b/paddle/cinn/operator_fusion/graph_transformer/operation.h
@@ -124,8 +124,7 @@ struct LiftReduceToReduceTreeOperation {
     const auto& reduce_pattern = std::get<ReducePattern>(node->stmt_pattern());
     node->set_stmt_pattern(
         ReduceTreePattern({}, reduce_pattern, *(reduce_pattern.tracker())));
-    node->UpdateTracker(
-        make_shared<RenamePatternInstr>(origin_name, node->name()));
+    node->UpdateTracker(make_shared<RenameInstr>(origin_name, node->name()));
     return node;
   }
 };
@@ -137,8 +136,7 @@ struct LiftToHorizontalFusionPatternOperation {
         {typename HorizontalFusionPattern::PaddingStmtPattern(
              node->stmt_pattern(), {}),
          *(node->tracker())}));
-    node->UpdateTracker(
-        make_shared<RenamePatternInstr>(origin_name, node->name()));
+    node->UpdateTracker(make_shared<RenameInstr>(origin_name, node->name()));
     return node;
   }
 };
@@ -159,8 +157,7 @@ struct LiftToAnchorPatternOperation {
         ops,
         anchor,
         AnchorState({InitExprPromise(node->stmt_pattern(), anchor)})));
-    node->UpdateTracker(
-        make_shared<RenamePatternInstr>(origin_name, node->name()));
+    node->UpdateTracker(make_shared<RenameInstr>(origin_name, node->name()));
     return node;
   }
 };
@@ -270,7 +267,7 @@ struct SplitRecomputeOperation {
     upstream->set_stmt_pattern(RecoverAnchorPatternToTrivial(
         std::get<AnchorPattern>(upstream->stmt_pattern())));
     upstream->UpdateTracker(
-        make_shared<RenamePatternInstr>(origin_name, node->name()));
+        make_shared<RenameInstr>(origin_name, node->name()));
     MergeTrivialPatternOperation()(graph, upstream);
   }
 };

From 3e6d6ea4ee993e77637c5e01ba23ab4363e26f20 Mon Sep 17 00:00:00 2001
From: feifei-111 <2364819892@qq.com>
Date: Wed, 5 Jun 2024 04:11:38 +0000
Subject: [PATCH 72/99] update

---
 .../fusion_tracker/interpreter.h              |  7 ++++++-
 .../graph_transformer/operation.h             | 21 -------------------
 paddle/cinn/operator_fusion/pattern_fuser.h   | 12 +++++++++++
 paddle/cinn/operator_fusion/pattern_graph.cc  |  8 ++++++-
 paddle/cinn/operator_fusion/pattern_graph.h   |  1 +
 paddle/cinn/operator_fusion/pattern_node.h    |  1 +
 6 files changed, 27 insertions(+), 23 deletions(-)

diff --git a/paddle/cinn/operator_fusion/fusion_tracker/interpreter.h b/paddle/cinn/operator_fusion/fusion_tracker/interpreter.h
index cef69d0f6a7f8c..cf39075724809b 100644
--- a/paddle/cinn/operator_fusion/fusion_tracker/interpreter.h
+++ b/paddle/cinn/operator_fusion/fusion_tracker/interpreter.h
@@ -22,12 +22,17 @@
 namespace cinn::fusion {
 
 struct ScopeElement {
+  ScopeElement() = default;
+  ScopeElemnt(const std::vector<FusionOp> fusion_ops)
+      : fusion_ops(fusion_ops) {}
   std::vector<FusionOp> fusion_ops;
 };
 using ScopeElementPtr = std::shared_ptr<ScopeElement>;
 
 ScopeElementPtr CombineScopeElement(const ScopeElementPtr& a,
-                                    const ScopeElementPtr& b);
+                                    const ScopeElementPtr& b) {
+  return make_shared<ScopeElemnt>(ConcatVector(a->fusion_ops, b->fusion_ops));
+}
 
 struct FusionInterpreter {
   FusionInterpreter(
diff --git a/paddle/cinn/operator_fusion/graph_transformer/operation.h b/paddle/cinn/operator_fusion/graph_transformer/operation.h
index 64a66086c95137..27f4b1a908b60d 100644
--- a/paddle/cinn/operator_fusion/graph_transformer/operation.h
+++ b/paddle/cinn/operator_fusion/graph_transformer/operation.h
@@ -76,8 +76,6 @@ struct MergeReduceTreeOperation {
     VLOG(4) << "MergeReduceTreeOperation: \nupstream " << node->DebugStr()
             << "\ndownstream " << downstream->DebugStr() << "\nmerged "
             << merged_node->DebugStr();
-    merged_node->UpdateTracker(make_shared<TmpTransformInstr>(
-        upstream->name(), downstream->name(), merged_node->name()));
     return merged_node;
   }
 };
@@ -109,11 +107,6 @@ struct MergeReduceTreeAndTrivialOperation {
     VLOG(4) << "MergeReduceTreeAndTrivialOperation: \nupstream "
             << node->DebugStr() << "\ndownstream " << downstream->DebugStr()
             << "\nmerged " << merged_node->DebugStr();
-    merged_node->UpdateTracker(make_shared<TmpTransformWithFakeReduceIterInstr>(
-                                   upstream->name(),
-                                   downstream->name(),
-                                   merged_node->name(),
-                                   fake_reduce_iter_idx););
     return merged_node;
   }
 };
@@ -201,12 +194,6 @@ struct FuseUpstreamAnchorOperation {
         << std::get<AnchorPattern>(downstream->stmt_pattern()).anchor().impl()
         << ", merged node anchor: "
         << std::get<AnchorPattern>(merged_node->stmt_pattern()).anchor().impl();
-    merged_node->UpdateTracker(
-        make_shared<AnchorTransformInstr>(upstream->name(),
-                                          downstream->name(),
-                                          merged_node->name(),
-                                          transform_route,
-                                          true));
     return merged_node;
   }
 };
@@ -251,12 +238,6 @@ struct FuseDownstreamAnchorOperation {
         << std::get<AnchorPattern>(downstream->stmt_pattern()).anchor().impl()
         << ", merged node anchor: "
         << std::get<AnchorPattern>(merged_node->stmt_pattern()).anchor().impl();
-    merged_node->UpdateTracker(
-        make_shared<AnchorTransformInstr>(upstream->name(),
-                                          downstream->name(),
-                                          merged_node->name(),
-                                          transform_route,
-                                          false));
     return merged_node;
   }
 };
@@ -296,8 +277,6 @@ struct HorizontalFusionOperation {
             << j->DebugStr() << "\nmerged " << merged_node->DebugStr();
     graph->RemoveNode(i);
     graph->RemoveNode(j);
-    merged_node->UpdateTracker(
-        make_shared<CombineInstr>(i->name(), j->name(), merged_node()););
     return merged_node;
   }
 };
diff --git a/paddle/cinn/operator_fusion/pattern_fuser.h b/paddle/cinn/operator_fusion/pattern_fuser.h
index d28924a8402b98..e6dc3d0e823641 100644
--- a/paddle/cinn/operator_fusion/pattern_fuser.h
+++ b/paddle/cinn/operator_fusion/pattern_fuser.h
@@ -425,4 +425,16 @@ StmtPattern MergePattern(const StmtPattern& first, const StmtPattern& second) {
   return std::visit(PatternMatch, first.variant(), second.variant());
 }
 
+void SetReturnInstrImpl(const TrivialPattern& pattern) {}
+void SetReturnInstrImpl(const ReducePattern& pattern) {}
+void SetReturnInstrImpl(const ReduceTreePattern& pattern) {}
+void SetReturnInstrImpl(const ReduceTreePlusTrivialPattern& pattern) {}
+void SetReturnInstrImpl(const AnchorPattern& pattern) {}
+void SetReturnInstrImpl(const HorizontalFusionPattern& pattern) {}
+void SetReturnInstrImpl(const UnsupportPattern& pattern) {}
+
+void SetReturnInstr(const StmtPattern& s) {
+  std::visit([](const auto& impl) { SetReturnInstrImpl(impl); }, s.variant());
+}
+
 }  // namespace cinn::fusion
diff --git a/paddle/cinn/operator_fusion/pattern_graph.cc b/paddle/cinn/operator_fusion/pattern_graph.cc
index 1e4254ed4761d4..031f753dbf8d8d 100644
--- a/paddle/cinn/operator_fusion/pattern_graph.cc
+++ b/paddle/cinn/operator_fusion/pattern_graph.cc
@@ -64,7 +64,13 @@ std::vector<PatternNodePtr> PatternGraph::ClusterOps() {
   HorizontalFusion();
   VLOG(4) << "[Group Cluster] After HorizontalFusion: " << GraphInfo();
 
-  return SortByTopoOrder();
+  return ReturnFusionResults();
+}
+
+std::vector<PatternNodePtr> PatternGraph::ReturnFusionResults() {
+  auto sorted_nodes = SortByTopoOrder();
+  for (auto node : sorted_nodes) {
+  }
 }
 
 std::vector<PatternNodePtr> PatternGraph::SortByTopoOrder() {
diff --git a/paddle/cinn/operator_fusion/pattern_graph.h b/paddle/cinn/operator_fusion/pattern_graph.h
index 742e55ed40ab65..9c2ab2d40d5ac3 100644
--- a/paddle/cinn/operator_fusion/pattern_graph.h
+++ b/paddle/cinn/operator_fusion/pattern_graph.h
@@ -41,6 +41,7 @@ class PatternGraph {
   void LiftToAnchorPattern();
   void AnchorPatternFusion();
   void SplitRecomputePattern();
+  std::vector<PatternNodePtr> ReturnFusionResults();
 
   void RemoveNode(const PatternNodePtr& node);
   void AppendNode(const PatternNodePtr& node);
diff --git a/paddle/cinn/operator_fusion/pattern_node.h b/paddle/cinn/operator_fusion/pattern_node.h
index fc068fad6d187f..bd780237a1d2d8 100644
--- a/paddle/cinn/operator_fusion/pattern_node.h
+++ b/paddle/cinn/operator_fusion/pattern_node.h
@@ -64,6 +64,7 @@ struct PatternNode {
   const std::vector<PatternNodePtr>& upstream() const { return upstream_; }
   const std::vector<PatternNodePtr>& downstream() const { return downstream_; }
   const std::string& name() const { return GetPatternName(stmt_pattern_); }
+  void set_return() const { SetReturnInstr(stmt_pattern_); }
   void AddNodeToUpstream(PatternNodePtr node) { upstream_.push_back(node); }
   void AddNodeToDownstream(PatternNodePtr node) { downstream_.push_back(node); }
   void RemoveNodeFromUpstream(PatternNodePtr node) {

From e381852dd7f334c331befe6243d9b9c0a6e49da5 Mon Sep 17 00:00:00 2001
From: feifei-111 <2364819892@qq.com>
Date: Wed, 5 Jun 2024 08:31:57 +0000
Subject: [PATCH 73/99] update

---
 .../transforms/cinn_group_cluster_pass.cc     |   2 +-
 .../fusion_tracker/interpreter.cc             |   6 +-
 .../fusion_tracker/interpreter.h              |   5 +-
 .../operator_fusion/fusion_tracker/tracker.h  |  17 +--
 .../graph_transformer/matcher.h               | 116 +++++++-----------
 .../graph_transformer/operation.h             |  18 +--
 paddle/cinn/operator_fusion/pattern.h         |  67 +++++++++-
 paddle/cinn/operator_fusion/pattern_fuser.h   |  35 +++---
 paddle/cinn/operator_fusion/pattern_graph.cc  |   1 +
 paddle/cinn/operator_fusion/pattern_node.h    |   2 +-
 .../pir_graph_analyzing/anchor_transform.h    |   4 +-
 11 files changed, 157 insertions(+), 116 deletions(-)

diff --git a/paddle/cinn/hlir/dialect/operator/transforms/cinn_group_cluster_pass.cc b/paddle/cinn/hlir/dialect/operator/transforms/cinn_group_cluster_pass.cc
index 3d1ed7741c4743..fcef5d6018f63f 100644
--- a/paddle/cinn/hlir/dialect/operator/transforms/cinn_group_cluster_pass.cc
+++ b/paddle/cinn/hlir/dialect/operator/transforms/cinn_group_cluster_pass.cc
@@ -264,7 +264,7 @@ std::vector<GroupClusterNode> GroupSplit(cinn::dialect::GroupOp group_op) {
                  std::back_inserter(trackers),
                  [](const cinn::fusion::PatternNodePtr node)
                      -> cinn::fusion::FusionTrackerPtr {
-                   return cinn::fusion::GetPatternTracker(node->stmt_pattern());
+                   return cinn::fusion::GetFusionTracker(node->stmt_pattern());
                  });
 
   // Each stmts corresponds to each fusion op(cluster node).
diff --git a/paddle/cinn/operator_fusion/fusion_tracker/interpreter.cc b/paddle/cinn/operator_fusion/fusion_tracker/interpreter.cc
index 932cf4d2639dd5..bf173f65beb396 100644
--- a/paddle/cinn/operator_fusion/fusion_tracker/interpreter.cc
+++ b/paddle/cinn/operator_fusion/fusion_tracker/interpreter.cc
@@ -114,8 +114,8 @@ void RunReturnInstr(const std::shared_ptr<ReturnInstr>& instr,
                     FusionInterpreter* interpreter) {
   for (auto fusion_op : interpreter->scope[instr->target_]->fusion_ops) {
     auto exprs = std::visit(FusionOp2Expr(), fusion_op);
-    interpreter.ret_expr.insert(
-        interpreter.ret_expr.end(), exprs.begin(), exprs.end());
+    interpreter->ret_expr.insert(
+        interpreter->ret_expr.end(), exprs.begin(), exprs.end());
   }
 }
 
@@ -140,7 +140,7 @@ std::vector<ir::Expr> FusionInterpreter::Run() {
         RunTmpTransformInstr(
             dynamic_cast_instr_with_err<TmpTransformInstr>(instr), this);
         break;
-      case T_AnchorTransform:
+      case T_AnchorTransformAndReturn:
         RunAnchorTransformAndReturnInstr(
             dynamic_cast_instr_with_err<AnchorTransformAndReturnInstr>(instr),
             this);
diff --git a/paddle/cinn/operator_fusion/fusion_tracker/interpreter.h b/paddle/cinn/operator_fusion/fusion_tracker/interpreter.h
index cf39075724809b..2a87f8bbb138cf 100644
--- a/paddle/cinn/operator_fusion/fusion_tracker/interpreter.h
+++ b/paddle/cinn/operator_fusion/fusion_tracker/interpreter.h
@@ -23,7 +23,7 @@ namespace cinn::fusion {
 
 struct ScopeElement {
   ScopeElement() = default;
-  ScopeElemnt(const std::vector<FusionOp> fusion_ops)
+  explicit ScopeElement(const std::vector<FusionOp> fusion_ops)
       : fusion_ops(fusion_ops) {}
   std::vector<FusionOp> fusion_ops;
 };
@@ -31,7 +31,8 @@ using ScopeElementPtr = std::shared_ptr<ScopeElement>;
 
 ScopeElementPtr CombineScopeElement(const ScopeElementPtr& a,
                                     const ScopeElementPtr& b) {
-  return make_shared<ScopeElemnt>(ConcatVector(a->fusion_ops, b->fusion_ops));
+  return std::make_shared<ScopeElement>(
+      ConcatVector(a->fusion_ops, b->fusion_ops));
 }
 
 struct FusionInterpreter {
diff --git a/paddle/cinn/operator_fusion/fusion_tracker/tracker.h b/paddle/cinn/operator_fusion/fusion_tracker/tracker.h
index 5e406b7f3de688..e607ae05e7fe76 100644
--- a/paddle/cinn/operator_fusion/fusion_tracker/tracker.h
+++ b/paddle/cinn/operator_fusion/fusion_tracker/tracker.h
@@ -43,18 +43,15 @@ struct RenameInstr : public FusionInstruction {
 };
 
 struct CombineInstr : public FusionInstruction {
-  CombineInstr(const std::string& first,
-               const std::string& second,
-               const std::string& result)
-      : first_(first), second_(second), result_(result) {}
+  CombineInstr(const std::vector<std::string>& names, const std::string& result)
+      : names_(names), result_(result) {}
   virtual InstructionType type() { return T_Combine; }
-  std::string first_;
-  std::string second_;
+  std::vector<std::string> names_;
   std::string result_;
 };
 
 struct ReturnInstr : public FusionInstruction {
-  explict ReturnInstr(const std::string& target) : target_(target) {}
+  explicit ReturnInstr(const std::string& target) : target_(target) {}
   virtual InstructionType type() { return T_Return; }
   std::string target_;
 };
@@ -84,7 +81,7 @@ struct TmpTransformInstr : public FusionInstruction {
   TmpTransformInstr(const std::string& upstream,
                     const std::string& downstream,
                     const std::string& result,
-                    const std::vector<size_t>& fake_reduce_iter_idx)
+                    const std::vector<size_t>& fake_reduce_iter_idx = {})
       : upstream_(upstream),
         downstream_(downstream),
         result_(result),
@@ -114,12 +111,10 @@ struct TrivialLoopAlignInstr : public FusionInstruction {
 
 struct AnchorTransformAndReturnInstr : public FusionInstruction {
   AnchorTransformAndReturnInstr(const std::string& target,
-                                const std::string& result,
                                 const AnchorTransformRoute& transform_route)
-      : target_(target), result_(result), transform_route_(transform_route) {}
+      : target_(target), transform_route_(transform_route) {}
   virtual InstructionType type() { return T_AnchorTransformAndReturn; }
   std::string target_;
-  std::string result_;
   AnchorTransformRoute transform_route_;
 };
 
diff --git a/paddle/cinn/operator_fusion/graph_transformer/matcher.h b/paddle/cinn/operator_fusion/graph_transformer/matcher.h
index c0b3297dc92951..3d3405c7cf4360 100644
--- a/paddle/cinn/operator_fusion/graph_transformer/matcher.h
+++ b/paddle/cinn/operator_fusion/graph_transformer/matcher.h
@@ -19,37 +19,32 @@ namespace cinn::fusion {
 // Matcher
 
 struct AlwaysTrue {
-  template <typename T>
-  bool operator()(const PatternGraph<T>& graph, const PatternNodePtr<T>& node) {
+  bool operator()(const PatternGraph& graph, const PatternNodePtr& node) {
     return true;
   }
 };
 
 template <typename StmtPattern>
 struct StmtPatternGraphMatcher {
-  template <typename T>
-  bool operator()(const PatternGraph<T>& graph, const PatternNodePtr<T>& node) {
+  bool operator()(const PatternGraph& graph, const PatternNodePtr& node) {
     return GetPatternName(node->stmt_pattern()) == StmtPattern::name();
   }
 };
 
 struct CanFuseRxTMatcher {
-  template <typename T>
-  bool operator()(const PatternGraph<T>& graph, const PatternNodePtr<T>& node) {
-    return (
-        std::holds_alternative<ReduceTreePattern<T>>(node->stmt_pattern()) &&
-        !node->downstream().empty() &&
-        std::holds_alternative<TrivialPattern<T>>(
-            node->downstream().at(0)->stmt_pattern()));
+  bool operator()(const PatternGraph& graph, const PatternNodePtr& node) {
+    return (std::holds_alternative<ReduceTreePattern>(node->stmt_pattern()) &&
+            !node->downstream().empty() &&
+            std::holds_alternative<TrivialPattern>(
+                node->downstream().at(0)->stmt_pattern()));
   }
 };
 
 struct CanFuseReduceTreeMatcher {
-  template <typename T>
-  bool operator()(const PatternGraph<T>& graph, const PatternNodePtr<T>& node) {
-    return StmtPatternGraphMatcher<ReduceTreePattern<T>>()(graph, node) &&
+  bool operator()(const PatternGraph& graph, const PatternNodePtr& node) {
+    return StmtPatternGraphMatcher<ReduceTreePattern>()(graph, node) &&
            !node->downstream().empty() &&
-           std::holds_alternative<ReduceTreePattern<T>>(
+           std::holds_alternative<ReduceTreePattern>(
                node->downstream().at(0)->stmt_pattern()) &&
            graph.policy_manager()
                .template GetPolicy<GeneralTopoPolicy>()
@@ -61,11 +56,10 @@ struct CanFuseReduceTreeMatcher {
 };
 
 struct CanFuseReduceTreeAndTrivialMatcher {
-  template <typename T>
-  bool operator()(const PatternGraph<T>& graph, const PatternNodePtr<T>& node) {
-    return StmtPatternGraphMatcher<ReduceTreePattern<T>>()(graph, node) &&
+  bool operator()(const PatternGraph& graph, const PatternNodePtr& node) {
+    return StmtPatternGraphMatcher<ReduceTreePattern>()(graph, node) &&
            !node->downstream().empty() &&
-           std::holds_alternative<TrivialPattern<T>>(
+           std::holds_alternative<TrivialPattern>(
                node->downstream().at(0)->stmt_pattern()) &&
            graph.policy_manager()
                .template GetPolicy<GeneralTopoPolicy>()
@@ -77,36 +71,31 @@ struct CanFuseReduceTreeAndTrivialMatcher {
 };
 
 struct LiftToAnchorPatternMatcher {
-  template <typename T>
-  bool operator()(const PatternGraph<T>& graph, const PatternNodePtr<T>& node) {
+  bool operator()(const PatternGraph& graph, const PatternNodePtr& node) {
     bool not_reduce_tree =
-        !StmtPatternGraphMatcher<ReduceTreePattern<T>>()(graph, node) &&
-        !StmtPatternGraphMatcher<ReduceTreePlusTrivialPattern<T>>()(graph,
-                                                                    node);
+        !StmtPatternGraphMatcher<ReduceTreePattern>()(graph, node) &&
+        !StmtPatternGraphMatcher<ReduceTreePlusTrivialPattern>()(graph, node);
     bool reduce_tree_with_single_reduce =
-        StmtPatternGraphMatcher<ReduceTreePattern<T>>()(graph, node) &&
-        std::get<ReduceTreePattern<T>>(node->stmt_pattern()).childs().size() ==
-            0;
+        StmtPatternGraphMatcher<ReduceTreePattern>()(graph, node) &&
+        std::get<ReduceTreePattern>(node->stmt_pattern()).childs().size() == 0;
     return not_reduce_tree || reduce_tree_with_single_reduce;
   }
 };
 
 struct RecomputeNodeMatcher {
-  template <typename T>
-  bool operator()(const PatternGraph<T>& graph, const PatternNodePtr<T>& node) {
-    return StmtPatternGraphMatcher<AnchorPattern<T>>()(graph, node) &&
+  bool operator()(const PatternGraph& graph, const PatternNodePtr& node) {
+    return StmtPatternGraphMatcher<AnchorPattern>()(graph, node) &&
            node->downstream().size() >= 1 &&
-           (std::get<AnchorPattern<T>>(node->stmt_pattern()).can_recompute());
+           (std::get<AnchorPattern>(node->stmt_pattern()).can_recompute());
   }
 };
 
 struct HasUpstreamAnchorMatcher {
-  template <typename T>
-  bool operator()(const PatternGraph<T>& graph,
-                  const PatternNodePtr<T>& upstream,
-                  const PatternNodePtr<T>& downstream) {
-    if (!StmtPatternGraphMatcher<AnchorPattern<T>>()(graph, upstream) ||
-        !StmtPatternGraphMatcher<AnchorPattern<T>>()(graph, downstream)) {
+  bool operator()(const PatternGraph& graph,
+                  const PatternNodePtr& upstream,
+                  const PatternNodePtr& downstream) {
+    if (!StmtPatternGraphMatcher<AnchorPattern>()(graph, upstream) ||
+        !StmtPatternGraphMatcher<AnchorPattern>()(graph, downstream)) {
       return false;
     }
     return graph.policy_manager()
@@ -119,12 +108,11 @@ struct HasUpstreamAnchorMatcher {
 };
 
 struct HasDownstreamAnchorMatcher {
-  template <typename T>
-  bool operator()(const PatternGraph<T>& graph,
-                  const PatternNodePtr<T>& upstream,
-                  const PatternNodePtr<T>& downstream) {
-    if (!StmtPatternGraphMatcher<AnchorPattern<T>>()(graph, upstream) ||
-        !StmtPatternGraphMatcher<AnchorPattern<T>>()(graph, downstream)) {
+  bool operator()(const PatternGraph& graph,
+                  const PatternNodePtr& upstream,
+                  const PatternNodePtr& downstream) {
+    if (!StmtPatternGraphMatcher<AnchorPattern>()(graph, upstream) ||
+        !StmtPatternGraphMatcher<AnchorPattern>()(graph, downstream)) {
       return false;
     }
     return graph.policy_manager()
@@ -136,21 +124,20 @@ struct HasDownstreamAnchorMatcher {
   }
 };
 
-template <typename T>
 struct HorizontalFusionMatcher {
-  bool operator()(const PatternGraph<T>& graph,
-                  const PatternNodePtr<T>& lhs,
-                  const PatternNodePtr<T>& rhs) {
-    if (!StmtPatternGraphMatcher<HorizontalFusionPattern<T>>()(graph, lhs)) {
+  bool operator()(const PatternGraph& graph,
+                  const PatternNodePtr& lhs,
+                  const PatternNodePtr& rhs) {
+    if (!StmtPatternGraphMatcher<HorizontalFusionPattern>()(graph, lhs)) {
       return false;
     }
-    if (!StmtPatternGraphMatcher<HorizontalFusionPattern<T>>()(graph, rhs)) {
+    if (!StmtPatternGraphMatcher<HorizontalFusionPattern>()(graph, rhs)) {
       return false;
     }
     const auto& lhs_pattern =
-        std::get<HorizontalFusionPattern<T>>(lhs->stmt_pattern());
+        std::get<HorizontalFusionPattern>(lhs->stmt_pattern());
     const auto& rhs_pattern =
-        std::get<HorizontalFusionPattern<T>>(rhs->stmt_pattern());
+        std::get<HorizontalFusionPattern>(rhs->stmt_pattern());
 
     return graph.policy_manager()
                .template GetPolicy<GeneralTopoPolicy>()
@@ -161,15 +148,13 @@ struct HorizontalFusionMatcher {
 };
 
 struct NonSinkNodeMatcher {
-  template <typename T>
-  bool operator()(const PatternGraph<T>& graph, const PatternNodePtr<T>& node) {
+  bool operator()(const PatternGraph& graph, const PatternNodePtr& node) {
     return !node->downstream().empty();
   }
 };
 
 struct IsOutputNodeMatcher {
-  template <typename T>
-  bool operator()(const PatternGraph<T>& graph, const PatternNodePtr<T>& node) {
+  bool operator()(const PatternGraph& graph, const PatternNodePtr& node) {
     bool res = IsAnyFirstInSecond(node->sink_op()->results(), graph.outputs());
     return res;
   }
@@ -177,16 +162,14 @@ struct IsOutputNodeMatcher {
 
 template <int N>
 struct DownstreamSmallerThan {
-  template <typename T>
-  bool operator()(const PatternGraph<T>& graph, const PatternNodePtr<T>& node) {
+  bool operator()(const PatternGraph& graph, const PatternNodePtr& node) {
     return node->downstream().size() < N;
   }
 };
 
 template <int N>
 struct DownstreamGreaterThan {
-  template <typename T>
-  bool operator()(const PatternGraph<T>& graph, const PatternNodePtr<T>& node) {
+  bool operator()(const PatternGraph& graph, const PatternNodePtr& node) {
     return node->downstream().size() > N;
   }
 };
@@ -196,16 +179,14 @@ struct And {};
 
 template <typename A>
 struct And<A> {
-  template <typename T>
-  bool operator()(const PatternGraph<T>& graph, const PatternNodePtr<T>& node) {
+  bool operator()(const PatternGraph& graph, const PatternNodePtr& node) {
     return A()(graph, node);
   }
 };
 
 template <typename A, typename... Args>
 struct And<A, Args...> {
-  template <typename T>
-  bool operator()(const PatternGraph<T>& graph, const PatternNodePtr<T>& node) {
+  bool operator()(const PatternGraph& graph, const PatternNodePtr& node) {
     return A()(graph, node) && And<Args...>()(graph, node);
   }
 };
@@ -215,24 +196,21 @@ struct Or {};
 
 template <typename A>
 struct Or<A> {
-  template <typename T>
-  bool operator()(const PatternGraph<T>& graph, const PatternNodePtr<T>& node) {
+  bool operator()(const PatternGraph& graph, const PatternNodePtr& node) {
     return A()(graph, node);
   }
 };
 
 template <typename A, typename... Args>
 struct Or<A, Args...> {
-  template <typename T>
-  bool operator()(const PatternGraph<T>& graph, const PatternNodePtr<T>& node) {
+  bool operator()(const PatternGraph& graph, const PatternNodePtr& node) {
     return A()(graph, node) || Or<Args...>()(graph, node);
   }
 };
 
 template <typename A>
 struct Not {
-  template <typename T>
-  bool operator()(const PatternGraph<T>& graph, const PatternNodePtr<T>& node) {
+  bool operator()(const PatternGraph& graph, const PatternNodePtr& node) {
     return !A()(graph, node);
   }
 };
diff --git a/paddle/cinn/operator_fusion/graph_transformer/operation.h b/paddle/cinn/operator_fusion/graph_transformer/operation.h
index 27f4b1a908b60d..634cc4d24eaf7a 100644
--- a/paddle/cinn/operator_fusion/graph_transformer/operation.h
+++ b/paddle/cinn/operator_fusion/graph_transformer/operation.h
@@ -116,8 +116,9 @@ struct LiftReduceToReduceTreeOperation {
     auto origin_name = node->name();
     const auto& reduce_pattern = std::get<ReducePattern>(node->stmt_pattern());
     node->set_stmt_pattern(
-        ReduceTreePattern({}, reduce_pattern, *(reduce_pattern.tracker())));
-    node->UpdateTracker(make_shared<RenameInstr>(origin_name, node->name()));
+        ReduceTreePattern({}, reduce_pattern, reduce_pattern.tracker_));
+    node->UpdateTracker(
+        std::make_shared<RenameInstr>(origin_name, node->name()));
     return node;
   }
 };
@@ -127,9 +128,10 @@ struct LiftToHorizontalFusionPatternOperation {
     auto origin_name = node->name();
     node->set_stmt_pattern(HorizontalFusionPattern(
         {typename HorizontalFusionPattern::PaddingStmtPattern(
-             node->stmt_pattern(), {}),
-         *(node->tracker())}));
-    node->UpdateTracker(make_shared<RenameInstr>(origin_name, node->name()));
+            node->stmt_pattern(), {})},
+        GetFusionTracker(node->stmt_pattern())));
+    node->UpdateTracker(
+        std::make_shared<RenameInstr>(origin_name, node->name()));
     return node;
   }
 };
@@ -149,8 +151,8 @@ struct LiftToAnchorPatternOperation {
     node->set_stmt_pattern(AnchorPattern(
         ops,
         anchor,
-        AnchorState({InitExprPromise(node->stmt_pattern(), anchor)})));
-    node->UpdateTracker(make_shared<RenameInstr>(origin_name, node->name()));
+        AnchorState(InitExprPromise(node->stmt_pattern(), anchor)),
+        GetFusionTracker(node->stmt_pattern())));
     return node;
   }
 };
@@ -248,7 +250,7 @@ struct SplitRecomputeOperation {
     upstream->set_stmt_pattern(RecoverAnchorPatternToTrivial(
         std::get<AnchorPattern>(upstream->stmt_pattern())));
     upstream->UpdateTracker(
-        make_shared<RenameInstr>(origin_name, node->name()));
+        std::make_shared<RenameInstr>(origin_name, upstream->name()));
     MergeTrivialPatternOperation()(graph, upstream);
   }
 };
diff --git a/paddle/cinn/operator_fusion/pattern.h b/paddle/cinn/operator_fusion/pattern.h
index f1ad5c784cdae1..014bb73e5c39ff 100644
--- a/paddle/cinn/operator_fusion/pattern.h
+++ b/paddle/cinn/operator_fusion/pattern.h
@@ -14,6 +14,7 @@
 
 #pragma once
 
+#include <functional>
 #include <unordered_set>
 #include <variant>
 #include <vector>
@@ -54,6 +55,8 @@ struct TrivialPattern {
   std::string name_;
 
   FusionTrackerPtr tracker_;
+
+  void set_return() { tracker_->append(make_shared<ReturnInstr>(name_)); }
 };
 
 struct ReducePattern {
@@ -75,6 +78,8 @@ struct ReducePattern {
   std::string name_;
 
   FusionTrackerPtr tracker_;
+
+  void set_return() { tracker_->append(std::make_shared<ReturnInstr>(name_)); }
 };
 
 struct ReduceTreePattern {
@@ -113,6 +118,27 @@ struct ReduceTreePattern {
 
   FusionTrackerPtr tracker_;
 
+  void set_return() {
+    std::vector<std::string> names({GetRootPattern().name()});
+    const auto hook = [tracker = tracker_, &names](const std::string& up,
+                                                   const std::string& down) {
+      tracker->append(std::make_shared<TmpTransformInstr>(up, down, up));
+      names.emplace_back(std::move(std::string(up)));
+    };
+    recursive_call(hook);
+
+    for (auto it = names.end() - 1; it > names.begin(); it--) {
+      tracker_->append(std::make_shared<ReturnInstr>(*it));
+    }
+  }
+  using Hook = std::function<void(const std::string&, const std::string&)>;
+  void recursive_call(const Hook& hook) {
+    for (auto child : childs_) {
+      hook(child.GetRootPattern().name(), GetRootPattern().name());
+      child.recursive_call(hook);
+    }
+  }
+
  private:
   std::vector<ReduceTreePattern> childs_;
   ReducePattern root_;
@@ -141,6 +167,35 @@ struct ReduceTreePlusTrivialPattern {
   std::string name_;
 
   FusionTrackerPtr tracker_;
+  void set_return() {
+    std::vector<std::string> names(
+        {sink_trivial.name(), tree.GetRootPattern().name()});
+    tracker_->append(
+        std::make_shared<TmpTransformInstr>(tree.GetRootPattern().name(),
+                                            sink_trivial.name(),
+                                            tree.GetRootPattern().name(),
+                                            fake_reduce_iter_idx));
+
+    const auto hook =
+        [tracker = tracker_, &names, fake_reduce = fake_reduce_iter_idx](
+            const std::string& up, const std::string& down) {
+          tracker->append(
+              std::make_shared<TmpTransformInstr>(up, down, up, fake_reduce));
+          names.emplace_back(std::move(std::string(up)));
+        };
+
+    tree.recursive_call(hook);
+
+    tracker_->append(
+        std::make_shared<TrivialLoopAlignInstr>(tree.GetRootPattern().name(),
+                                                sink_trivial.name(),
+                                                sink_trivial.name(),
+                                                fake_reduce_iter_idx));
+
+    for (auto it = names.end() - 1; it > names.begin(); it--) {
+      tracker_->append(std::make_shared<ReturnInstr>(*it));
+    }
+  }
 };
 
 struct AnchorPattern {
@@ -188,6 +243,12 @@ struct AnchorPattern {
   std::string name_;
 
   FusionTrackerPtr tracker_;
+  void set_return() {
+    for (auto p : anchor_state.promise) {
+      tracker_->append(std::make_shared<AnchorTransformAndReturnInstr>(
+          p.name_, p.transform_route));
+    }
+  }
 
  private:
   std::vector<pir::Operation*> ops_;
@@ -227,6 +288,9 @@ struct HorizontalFusionPattern {
   std::string name_;
 
   FusionTrackerPtr tracker_;
+  void set_return() {
+    // TODO(@wuzhanfei)
+  }
 };
 
 struct UnsupportPattern {
@@ -246,6 +310,7 @@ struct UnsupportPattern {
   std::string name_;
 
   FusionTrackerPtr tracker_;
+  void set_return() { tracker_->append(make_shared<ReturnInstr>(name_)); }
 };
 
 using StmtPatternBase = std::variant<TrivialPattern,
@@ -275,7 +340,7 @@ std::string GetPatternName(const StmtPattern& s) {
   return std::visit([](const auto& impl) { return impl.name(); }, s.variant());
 }
 
-FusionTrackerPtr GetPatternTracker(const StmtPattern& s) {
+FusionTrackerPtr GetFusionTracker(const StmtPattern& s) {
   return std::visit([](const auto& impl) { return impl.tracker_; },
                     s.variant());
 }
diff --git a/paddle/cinn/operator_fusion/pattern_fuser.h b/paddle/cinn/operator_fusion/pattern_fuser.h
index e6dc3d0e823641..d2814a3b4c44f5 100644
--- a/paddle/cinn/operator_fusion/pattern_fuser.h
+++ b/paddle/cinn/operator_fusion/pattern_fuser.h
@@ -162,27 +162,32 @@ StmtPattern MergePatternImpl(const ReduceTreePattern& first,
 }
 
 // Anchor Fusion
-ExprPromise InitExprPromiseImpl(const TrivialPattern& pattern,
-                                pir::Value anchor) {
-  return ExprPromise(anchor);
+std::vector<ExprPromise> InitExprPromiseImpl(const TrivialPattern& pattern,
+                                             pir::Value anchor) {
+  return {ExprPromise(anchor, pattern.name())};
 }
 
-ExprPromise InitExprPromiseImpl(const ReducePattern& pattern,
-                                pir::Value anchor) {
-  return ExprPromise(anchor);
+std::vector<ExprPromise> InitExprPromiseImpl(const ReducePattern& pattern,
+                                             pir::Value anchor) {
+  return {ExprPromise(anchor, pattern.name())};
 }
 
-ExprPromise InitExprPromiseImpl(const ReduceTreePattern& pattern,
-                                pir::Value anchor) {
+std::vector<ExprPromise> InitExprPromiseImpl(const ReduceTreePattern& pattern,
+                                             pir::Value anchor) {
+  // TODO(@wuzhanfei) this is temporary
+  // now we do not support anchor fusion for reduce op,
+  // so, this is ok currently. but need to be redesigned later
   return InitExprPromiseImpl(pattern.GetRootPattern(), anchor);
 }
 
 template <typename PATTERN>
-ExprPromise InitExprPromiseImpl(const PATTERN& pattern, pir::Value anchor) {
+std::vector<ExprPromise> InitExprPromiseImpl(const PATTERN& pattern,
+                                             pir::Value anchor) {
   PADDLE_THROW("Can not Init ExprPromise");
 }
 
-ExprPromise InitExprPromise(const StmtPattern& pattern, pir::Value anchor) {
+std::vector<ExprPromise> InitExprPromise(const StmtPattern& pattern,
+                                         pir::Value anchor) {
   return std::visit(
       [anchor](const auto& arg) { return InitExprPromiseImpl(arg, anchor); },
       pattern.variant());
@@ -425,16 +430,8 @@ StmtPattern MergePattern(const StmtPattern& first, const StmtPattern& second) {
   return std::visit(PatternMatch, first.variant(), second.variant());
 }
 
-void SetReturnInstrImpl(const TrivialPattern& pattern) {}
-void SetReturnInstrImpl(const ReducePattern& pattern) {}
-void SetReturnInstrImpl(const ReduceTreePattern& pattern) {}
-void SetReturnInstrImpl(const ReduceTreePlusTrivialPattern& pattern) {}
-void SetReturnInstrImpl(const AnchorPattern& pattern) {}
-void SetReturnInstrImpl(const HorizontalFusionPattern& pattern) {}
-void SetReturnInstrImpl(const UnsupportPattern& pattern) {}
-
 void SetReturnInstr(const StmtPattern& s) {
-  std::visit([](const auto& impl) { SetReturnInstrImpl(impl); }, s.variant());
+  std::visit([](const auto& impl) { impl.set_return(); }, s.variant());
 }
 
 }  // namespace cinn::fusion
diff --git a/paddle/cinn/operator_fusion/pattern_graph.cc b/paddle/cinn/operator_fusion/pattern_graph.cc
index 031f753dbf8d8d..48b0146b641a6b 100644
--- a/paddle/cinn/operator_fusion/pattern_graph.cc
+++ b/paddle/cinn/operator_fusion/pattern_graph.cc
@@ -70,6 +70,7 @@ std::vector<PatternNodePtr> PatternGraph::ClusterOps() {
 std::vector<PatternNodePtr> PatternGraph::ReturnFusionResults() {
   auto sorted_nodes = SortByTopoOrder();
   for (auto node : sorted_nodes) {
+    node->set_return();
   }
 }
 
diff --git a/paddle/cinn/operator_fusion/pattern_node.h b/paddle/cinn/operator_fusion/pattern_node.h
index bd780237a1d2d8..faa4c60e4435d5 100644
--- a/paddle/cinn/operator_fusion/pattern_node.h
+++ b/paddle/cinn/operator_fusion/pattern_node.h
@@ -78,7 +78,7 @@ struct PatternNode {
   void UniqueUpstream() { upstream_ = UniqueVectorBySet(upstream_); }
   void UniqueDownstream() { downstream_ = UniqueVectorBySet(downstream_); }
   void UpdateTracker(FusionInstrPtr instr) {
-    GetPatternTracker(stmt_pattern_)->append(instr);
+    GetFusionTracker(stmt_pattern_)->append(instr);
   }
 
  private:
diff --git a/paddle/cinn/operator_fusion/pir_graph_analyzing/anchor_transform.h b/paddle/cinn/operator_fusion/pir_graph_analyzing/anchor_transform.h
index 67e340d0e8fb38..538056bc654003 100644
--- a/paddle/cinn/operator_fusion/pir_graph_analyzing/anchor_transform.h
+++ b/paddle/cinn/operator_fusion/pir_graph_analyzing/anchor_transform.h
@@ -116,9 +116,11 @@ using AnchorTransform = std::variant<UnsupportTransformPtr,
 using AnchorTransformRoute = std::vector<AnchorTransform>;
 
 struct ExprPromise {
-  explicit ExprPromise(const pir::Value& root) : root_value(root) {}
+  explicit ExprPromise(const pir::Value& root, const std::string& name)
+      : root_value(root), name_(name) {}
   AnchorTransformRoute transform_route;
   pir::Value root_value;
+  std::string name_;
 
   void update(const AnchorTransformRoute& route) {
     transform_route.insert(transform_route.end(), route.begin(), route.end());

From ab12d114aca2b197ce483792c67347075e51782f Mon Sep 17 00:00:00 2001
From: feifei-111 <2364819892@qq.com>
Date: Thu, 6 Jun 2024 12:06:25 +0000
Subject: [PATCH 74/99] update

---
 .../fusion_tracker/interpreter.cc             | 24 +++--
 .../operator_fusion/fusion_tracker/tracker.h  | 37 +++++---
 .../graph_transformer/operation.h             | 61 +++++++------
 paddle/cinn/operator_fusion/pattern.h         | 87 ++++++++++++-------
 paddle/cinn/operator_fusion/pattern_fuser.h   | 15 ++--
 paddle/cinn/operator_fusion/pattern_node.h    |  3 +-
 6 files changed, 140 insertions(+), 87 deletions(-)

diff --git a/paddle/cinn/operator_fusion/fusion_tracker/interpreter.cc b/paddle/cinn/operator_fusion/fusion_tracker/interpreter.cc
index bf173f65beb396..a9182a8b05adb0 100644
--- a/paddle/cinn/operator_fusion/fusion_tracker/interpreter.cc
+++ b/paddle/cinn/operator_fusion/fusion_tracker/interpreter.cc
@@ -21,8 +21,8 @@
 
 namespace cinn::fusion {
 
-void RunRenameInstr(const std::shared_ptr<RenameInstr>& instr,
-                    FusionInterpreter* interpreter) {
+void RunCopyInstr(const std::shared_ptr<CopyInstr>& instr,
+                  FusionInterpreter* interpreter) {
   interpreter->scope[instr->new_name_] =
       interpreter->scope[instr->origin_name_];
   interpreter->scope.erase(instr->origin_name_);
@@ -84,15 +84,14 @@ void RunTrivialLoopAlignInstr(
   auto downstream_op = std::get<TrivialOp>(
       interpreter->scope[instr->downstream_]->fusion_ops.front());
   ScopeElementPtr new_pattern = std::make_shared<ScopeElement>();
-  new_pattern->fusion_ops.emplace(
+  new_pattern->fusion_ops.emplace_back(
       cinn::hlir::framework::pir::trivial_fusion_detail::SinkTrivialLoopAlign(
-          downstream_op, upstream_op, instr->fake_reduce_iter_idx_););
+          downstream_op, upstream_op, instr->fake_reduce_iter_idx_));
   interpreter->scope[instr->result_] = new_pattern;
 }
 
-void RunAnchorTransformAndReturnInstr(
-    const std::shared_ptr<AnchorTransformAndReturnInstr>& instr,
-    FusionInterpreter* interpreter) {
+void RunAnchorTransformInstr(const std::shared_ptr<AnchorTransformInstr>& instr,
+                             FusionInterpreter* interpreter) {
   PADDLE_ENFORCE_EQ(interpreter->scope[instr->target_]->fusion_ops.size(), 1);
   ScopeElementPtr new_pattern = std::make_shared<ScopeElement>();
 
@@ -122,8 +121,8 @@ void RunReturnInstr(const std::shared_ptr<ReturnInstr>& instr,
 std::vector<ir::Expr> FusionInterpreter::Run() {
   for (auto instr : tracker->instructions_) {
     switch (instr->type()) {
-      case T_Rename:
-        RunRenameInstr(dynamic_cast_instr_with_err<RenameInstr>(instr), this);
+      case T_Copy:
+        RunCopyInstr(dynamic_cast_instr_with_err<CopyInstr>(instr), this);
         break;
       case T_Combine:
         RunCombineInstr(dynamic_cast_instr_with_err<CombineInstr>(instr), this);
@@ -140,10 +139,9 @@ std::vector<ir::Expr> FusionInterpreter::Run() {
         RunTmpTransformInstr(
             dynamic_cast_instr_with_err<TmpTransformInstr>(instr), this);
         break;
-      case T_AnchorTransformAndReturn:
-        RunAnchorTransformAndReturnInstr(
-            dynamic_cast_instr_with_err<AnchorTransformAndReturnInstr>(instr),
-            this);
+      case T_AnchorTransform:
+        RunAnchorTransformInstr(
+            dynamic_cast_instr_with_err<AnchorTransformInstr>(instr), this);
         break;
       case T_Return:
         RunReturnInstr(dynamic_cast_instr_with_err<ReturnInstr>(instr), this);
diff --git a/paddle/cinn/operator_fusion/fusion_tracker/tracker.h b/paddle/cinn/operator_fusion/fusion_tracker/tracker.h
index e607ae05e7fe76..6f35c5170ae74d 100644
--- a/paddle/cinn/operator_fusion/fusion_tracker/tracker.h
+++ b/paddle/cinn/operator_fusion/fusion_tracker/tracker.h
@@ -18,14 +18,15 @@
 namespace cinn::fusion {
 
 enum InstructionType {
-  T_Rename,
+  T_Copy,
   T_Combine,
   T_Return,
   T_InitPattern,
   T_TrivialInline,
   T_TmpTransform,
   T_TrivialLoopAlign,
-  T_AnchorTransformAndReturn,
+  T_AnchorTransform,
+  T_Padding
 };
 
 struct FusionInstruction {
@@ -34,10 +35,10 @@ struct FusionInstruction {
 
 using FusionInstrPtr = std::shared_ptr<FusionInstruction>;
 
-struct RenameInstr : public FusionInstruction {
-  RenameInstr(const std::string& origin_name, const std::string& new_name)
+struct CopyInstr : public FusionInstruction {
+  CopyInstr(const std::string& origin_name, const std::string& new_name)
       : origin_name_(origin_name), new_name_(new_name) {}
-  virtual InstructionType type() { return T_Rename; }
+  virtual InstructionType type() { return T_Copy; }
   std::string origin_name_;
   std::string new_name_;
 };
@@ -109,18 +110,34 @@ struct TrivialLoopAlignInstr : public FusionInstruction {
   std::vector<size_t> fake_reduce_iter_idx_;
 };
 
-struct AnchorTransformAndReturnInstr : public FusionInstruction {
-  AnchorTransformAndReturnInstr(const std::string& target,
-                                const AnchorTransformRoute& transform_route)
-      : target_(target), transform_route_(transform_route) {}
-  virtual InstructionType type() { return T_AnchorTransformAndReturn; }
+struct AnchorTransformInstr : public FusionInstruction {
+  AnchorTransformInstr(const std::string& target,
+                       const std::string& result,
+                       const AnchorTransformRoute& transform_route)
+      : target_(target), result_(result), transform_route_(transform_route) {}
+  virtual InstructionType type() { return T_AnchorTransform; }
   std::string target_;
+  std::string result_;
   AnchorTransformRoute transform_route_;
 };
 
+struct PaddingInstr : public FusionInstruction {
+  AnchorTransformInstr(const std::string& target,
+                       const std::string& result,
+                       const std::vector<int>& padding_pos)
+      : target_(target), result_(result), padding_pos_(padding_pos) {}
+  virtual InstructionType type() { return T_Padding; }
+  std::string target_;
+  std::string result_;
+  std::vector<int> padding_pos_;
+};
+
 struct FusionTracker {
   using FusionTrackerPtr = std::shared_ptr<FusionTracker>;
   FusionTracker() = default;
+  explicit FusionTracker(const FusionTrackerPtr& other) {
+    ExtendVector(&instructions_, other->instructions_);
+  }
   FusionTracker(const FusionTrackerPtr& up, const FusionTrackerPtr& down) {
     ExtendVector(&instructions_, up->instructions_);
     ExtendVector(&instructions_, down->instructions_);
diff --git a/paddle/cinn/operator_fusion/graph_transformer/operation.h b/paddle/cinn/operator_fusion/graph_transformer/operation.h
index 634cc4d24eaf7a..ecd20be4f6dbdb 100644
--- a/paddle/cinn/operator_fusion/graph_transformer/operation.h
+++ b/paddle/cinn/operator_fusion/graph_transformer/operation.h
@@ -49,7 +49,7 @@ struct MergeTrivialPatternOperation {
                 << upstream->DebugStr() << "\ndownstream "
                 << downstream->DebugStr() << "\nmerged "
                 << merged_node->DebugStr();
-        merged_node->UpdateTracker(make_shared<TrivialInlineInstr>(
+        merged_node->AppendInstr(std::make_shared<TrivialInlineInstr>(
             upstream->name(), downstream->name(), merged_node->name()));
       } else {
         upstream->AddNodeToDownstream(downstream);
@@ -76,6 +76,7 @@ struct MergeReduceTreeOperation {
     VLOG(4) << "MergeReduceTreeOperation: \nupstream " << node->DebugStr()
             << "\ndownstream " << downstream->DebugStr() << "\nmerged "
             << merged_node->DebugStr();
+    merged_node->UpdateTracker();
     return merged_node;
   }
 };
@@ -107,6 +108,7 @@ struct MergeReduceTreeAndTrivialOperation {
     VLOG(4) << "MergeReduceTreeAndTrivialOperation: \nupstream "
             << node->DebugStr() << "\ndownstream " << downstream->DebugStr()
             << "\nmerged " << merged_node->DebugStr();
+    merged_node->UpdateTracker();
     return merged_node;
   }
 };
@@ -115,10 +117,11 @@ struct LiftReduceToReduceTreeOperation {
   PatternNodePtr operator()(PatternGraph* graph, PatternNodePtr node) {
     auto origin_name = node->name();
     const auto& reduce_pattern = std::get<ReducePattern>(node->stmt_pattern());
-    node->set_stmt_pattern(
-        ReduceTreePattern({}, reduce_pattern, reduce_pattern.tracker_));
-    node->UpdateTracker(
-        std::make_shared<RenameInstr>(origin_name, node->name()));
+    node->set_stmt_pattern(ReduceTreePattern(
+        {},
+        reduce_pattern,
+        std::make_shared<FusionTracker>(reduce_pattern.tracker_)));
+    node->AppendInstr(std::make_shared<CopyInstr>(origin_name, node->name()));
     return node;
   }
 };
@@ -129,9 +132,9 @@ struct LiftToHorizontalFusionPatternOperation {
     node->set_stmt_pattern(HorizontalFusionPattern(
         {typename HorizontalFusionPattern::PaddingStmtPattern(
             node->stmt_pattern(), {})},
-        GetFusionTracker(node->stmt_pattern())));
-    node->UpdateTracker(
-        std::make_shared<RenameInstr>(origin_name, node->name()));
+        std::make_shared<FusionTracker>(
+            GetFusionTracker(node->stmt_pattern()))));
+    node->AppendInstr(std::make_shared<CopyInstr>(origin_name, node->name()));
     return node;
   }
 };
@@ -152,7 +155,8 @@ struct LiftToAnchorPatternOperation {
         ops,
         anchor,
         AnchorState(InitExprPromise(node->stmt_pattern(), anchor)),
-        GetFusionTracker(node->stmt_pattern())));
+        std::make_shared<FusionTracker>(
+            GetFusionTracker(node->stmt_pattern()))));
     return node;
   }
 };
@@ -189,13 +193,16 @@ struct FuseUpstreamAnchorOperation {
     auto merged_node = graph->MergeNode(upstream, downstream, merge_pattern_fn);
     graph->RemoveNode(upstream);
     graph->RemoveNode(downstream);
-    VLOG(4)
-        << "upstream anchor: "
-        << std::get<AnchorPattern>(upstream->stmt_pattern()).anchor().impl()
-        << ", downstream anchor: "
-        << std::get<AnchorPattern>(downstream->stmt_pattern()).anchor().impl()
-        << ", merged node anchor: "
-        << std::get<AnchorPattern>(merged_node->stmt_pattern()).anchor().impl();
+    merged_node->UpdateTracker();
+    // VLOG(4)
+    //     << "upstream anchor: "
+    //     << std::get<AnchorPattern>(upstream->stmt_pattern()).anchor().impl()
+    //     << ", downstream anchor: "
+    //     <<
+    //     std::get<AnchorPattern>(downstream->stmt_pattern()).anchor().impl()
+    //     << ", merged node anchor: "
+    //     <<
+    //     std::get<AnchorPattern>(merged_node->stmt_pattern()).anchor().impl();
     return merged_node;
   }
 };
@@ -233,13 +240,16 @@ struct FuseDownstreamAnchorOperation {
     auto merged_node = graph->MergeNode(upstream, downstream, merge_pattern_fn);
     graph->RemoveNode(upstream);
     graph->RemoveNode(downstream);
-    VLOG(4)
-        << "upstream anchor: "
-        << std::get<AnchorPattern>(upstream->stmt_pattern()).anchor().impl()
-        << ", downstream anchor: "
-        << std::get<AnchorPattern>(downstream->stmt_pattern()).anchor().impl()
-        << ", merged node anchor: "
-        << std::get<AnchorPattern>(merged_node->stmt_pattern()).anchor().impl();
+    merged_node->UpdateTracker();
+    // VLOG(4)
+    //     << "upstream anchor: "
+    //     << std::get<AnchorPattern>(upstream->stmt_pattern()).anchor().impl()
+    //     << ", downstream anchor: "
+    //     <<
+    //     std::get<AnchorPattern>(downstream->stmt_pattern()).anchor().impl()
+    //     << ", merged node anchor: "
+    //     <<
+    //     std::get<AnchorPattern>(merged_node->stmt_pattern()).anchor().impl();
     return merged_node;
   }
 };
@@ -249,8 +259,8 @@ struct SplitRecomputeOperation {
     auto origin_name = upstream->name();
     upstream->set_stmt_pattern(RecoverAnchorPatternToTrivial(
         std::get<AnchorPattern>(upstream->stmt_pattern())));
-    upstream->UpdateTracker(
-        std::make_shared<RenameInstr>(origin_name, upstream->name()));
+    upstream->AppendInstr(
+        std::make_shared<CopyInstr>(origin_name, upstream->name()));
     MergeTrivialPatternOperation()(graph, upstream);
   }
 };
@@ -279,6 +289,7 @@ struct HorizontalFusionOperation {
             << j->DebugStr() << "\nmerged " << merged_node->DebugStr();
     graph->RemoveNode(i);
     graph->RemoveNode(j);
+    merged_node->UpdateTracker();
     return merged_node;
   }
 };
diff --git a/paddle/cinn/operator_fusion/pattern.h b/paddle/cinn/operator_fusion/pattern.h
index 014bb73e5c39ff..64734d43575fb8 100644
--- a/paddle/cinn/operator_fusion/pattern.h
+++ b/paddle/cinn/operator_fusion/pattern.h
@@ -33,6 +33,7 @@ struct PatternContent {
 };
 
 struct StmtPattern;
+std::string GetPatternName(const StmtPattern& s);
 
 struct TrivialPattern {
   explicit TrivialPattern(const std::vector<pir::Operation*>& ops,
@@ -55,8 +56,7 @@ struct TrivialPattern {
   std::string name_;
 
   FusionTrackerPtr tracker_;
-
-  void set_return() { tracker_->append(make_shared<ReturnInstr>(name_)); }
+  void update_tracker() {}
 };
 
 struct ReducePattern {
@@ -78,8 +78,7 @@ struct ReducePattern {
   std::string name_;
 
   FusionTrackerPtr tracker_;
-
-  void set_return() { tracker_->append(std::make_shared<ReturnInstr>(name_)); }
+  void update_tracker() {}
 };
 
 struct ReduceTreePattern {
@@ -118,19 +117,20 @@ struct ReduceTreePattern {
 
   FusionTrackerPtr tracker_;
 
-  void set_return() {
-    std::vector<std::string> names({GetRootPattern().name()});
-    const auto hook = [tracker = tracker_, &names](const std::string& up,
-                                                   const std::string& down) {
-      tracker->append(std::make_shared<TmpTransformInstr>(up, down, up));
-      names.emplace_back(std::move(std::string(up)));
+  void update_tracker() {
+    std::vector<std::string> tmp_names({GetRootPattern().name()});
+    int count = 0;
+    const auto hook = [tracker = tracker_, &tmp_names, &count](
+                          const std::string& up, const std::string& down) {
+      std::string tmp_name = "tmp_" + std::to_string(count++);
+      tracker->append(std::make_shared<TmpTransformInstr>(up, down, tmp_name));
+      tmp_names.emplace_back(tmp_name);
     };
     recursive_call(hook);
 
-    for (auto it = names.end() - 1; it > names.begin(); it--) {
-      tracker_->append(std::make_shared<ReturnInstr>(*it));
-    }
+    tracker_->append(std::make_shared<CombineInstr>(tmp_names, name()));
   }
+
   using Hook = std::function<void(const std::string&, const std::string&)>;
   void recursive_call(const Hook& hook) {
     for (auto child : childs_) {
@@ -167,8 +167,9 @@ struct ReduceTreePlusTrivialPattern {
   std::string name_;
 
   FusionTrackerPtr tracker_;
-  void set_return() {
-    std::vector<std::string> names(
+
+  void update_tracker() {
+    std::vector<std::string> tmp_names(
         {sink_trivial.name(), tree.GetRootPattern().name()});
     tracker_->append(
         std::make_shared<TmpTransformInstr>(tree.GetRootPattern().name(),
@@ -176,13 +177,16 @@ struct ReduceTreePlusTrivialPattern {
                                             tree.GetRootPattern().name(),
                                             fake_reduce_iter_idx));
 
-    const auto hook =
-        [tracker = tracker_, &names, fake_reduce = fake_reduce_iter_idx](
-            const std::string& up, const std::string& down) {
-          tracker->append(
-              std::make_shared<TmpTransformInstr>(up, down, up, fake_reduce));
-          names.emplace_back(std::move(std::string(up)));
-        };
+    int count = 0;
+    const auto hook = [tracker = tracker_,
+                       &tmp_names,
+                       fake_reduce = fake_reduce_iter_idx,
+                       &count](const std::string& up, const std::string& down) {
+      std::string tmp_name = "tmp_" + std::to_string(count++);
+      tracker->append(
+          std::make_shared<TmpTransformInstr>(up, down, tmp_name, fake_reduce));
+      tmp_names.emplace_back(tmp_name);
+    };
 
     tree.recursive_call(hook);
 
@@ -192,9 +196,7 @@ struct ReduceTreePlusTrivialPattern {
                                                 sink_trivial.name(),
                                                 fake_reduce_iter_idx));
 
-    for (auto it = names.end() - 1; it > names.begin(); it--) {
-      tracker_->append(std::make_shared<ReturnInstr>(*it));
-    }
+    tracker_->append(std::make_shared<CombineInstr>(tmp_names, name()));
   }
 };
 
@@ -243,11 +245,16 @@ struct AnchorPattern {
   std::string name_;
 
   FusionTrackerPtr tracker_;
-  void set_return() {
-    for (auto p : anchor_state.promise) {
-      tracker_->append(std::make_shared<AnchorTransformAndReturnInstr>(
-          p.name_, p.transform_route));
+  void update_tracker() {
+    std::vector<std::string> tmp_names;
+    for (int i = 0; i < anchor_state.promise.size(); i++) {
+      auto promise = anchor_state.promise[i];
+      std::string tmp_name = "tmp_" + std::to_string(i);
+      tmp_names.emplace_back(tmp_name);
+      tracker_->append(std::make_shared<AnchorTransformInstr>(
+          promise.name_, tmp_name, promise.transform_route));
     }
+    tracker_->append(std::make_shared<CombineInstr>(tmp_names, name()));
   }
 
  private:
@@ -286,11 +293,21 @@ struct HorizontalFusionPattern {
   }
   std::string name() const { return name_; }
   std::string name_;
+  void update_tracker() {
+    std::vector<std::string> tmp_names;
+    for (int i = 0; i < padding_patterns_.size(); i++) {
+      auto padding_pattern = padding_patterns_[i];
+      std::string tmp_name = "tmp_" + std::to_string(i);
+      tmp_names.emplace_back(tmp_name);
+      tracker_->append(std::make_shared<PaddingInstr>(
+          GetPatternName(padding_pattern.pattern),
+          tmp_name,
+          padding_pattern.padding_pos));
+    }
+    tracker_->append(std::make_shared<CombineInstr>(tmp_names, name()));
+  }
 
   FusionTrackerPtr tracker_;
-  void set_return() {
-    // TODO(@wuzhanfei)
-  }
 };
 
 struct UnsupportPattern {
@@ -310,7 +327,7 @@ struct UnsupportPattern {
   std::string name_;
 
   FusionTrackerPtr tracker_;
-  void set_return() { tracker_->append(make_shared<ReturnInstr>(name_)); }
+  void update_tracker() {}
 };
 
 using StmtPatternBase = std::variant<TrivialPattern,
@@ -381,4 +398,8 @@ std::unordered_set<pir::Value> GetPatternInputValues(const StmtPattern& A) {
   return all_input_values;
 }
 
+void PatternUpdateTracker(const StmtPattern& A) {
+  return std::visit([](const auto& impl) { impl.update_tracker(); },
+                    s.variant());
+}
 }  // namespace cinn::fusion
diff --git a/paddle/cinn/operator_fusion/pattern_fuser.h b/paddle/cinn/operator_fusion/pattern_fuser.h
index d2814a3b4c44f5..3d2b8b8e34caf7 100644
--- a/paddle/cinn/operator_fusion/pattern_fuser.h
+++ b/paddle/cinn/operator_fusion/pattern_fuser.h
@@ -177,7 +177,7 @@ std::vector<ExprPromise> InitExprPromiseImpl(const ReduceTreePattern& pattern,
   // TODO(@wuzhanfei) this is temporary
   // now we do not support anchor fusion for reduce op,
   // so, this is ok currently. but need to be redesigned later
-  return InitExprPromiseImpl(pattern.GetRootPattern(), anchor);
+  return {ExprPromise(anchor, pattern.name())};
 }
 
 template <typename PATTERN>
@@ -213,9 +213,10 @@ TrivialPattern RecoverAnchorPatternToTrivial(
                         "size is 1 (exact %d)",
                         anchor_pattern.anchor_state.promise.size()));
 
-  return TrivialPattern(anchor_pattern.ops(),
-                        anchor_pattern.anchor().defining_op(),
-                        anchor_pattern.tracker_);
+  return TrivialPattern(
+      anchor_pattern.ops(),
+      anchor_pattern.anchor().defining_op(),
+      std::make_shared<FusionTracker>(anchor_pattern.tracker_));
 }
 
 AnchorState GetAnchorState(const AnchorPattern& pattern) {
@@ -431,7 +432,11 @@ StmtPattern MergePattern(const StmtPattern& first, const StmtPattern& second) {
 }
 
 void SetReturnInstr(const StmtPattern& s) {
-  std::visit([](const auto& impl) { impl.set_return(); }, s.variant());
+  std::visit(
+      [](const auto& impl) {
+        impl.tracker_->append(std::make_shared<ReturnInstr>(impl.name()));
+      },
+      s.variant());
 }
 
 }  // namespace cinn::fusion
diff --git a/paddle/cinn/operator_fusion/pattern_node.h b/paddle/cinn/operator_fusion/pattern_node.h
index faa4c60e4435d5..7e461fe37f8e96 100644
--- a/paddle/cinn/operator_fusion/pattern_node.h
+++ b/paddle/cinn/operator_fusion/pattern_node.h
@@ -77,9 +77,10 @@ struct PatternNode {
   void ClearDownstream() { downstream_.clear(); }
   void UniqueUpstream() { upstream_ = UniqueVectorBySet(upstream_); }
   void UniqueDownstream() { downstream_ = UniqueVectorBySet(downstream_); }
-  void UpdateTracker(FusionInstrPtr instr) {
+  void AppendInstr(FusionInstrPtr instr) {
     GetFusionTracker(stmt_pattern_)->append(instr);
   }
+  void UpdateTracker() { PatternUpdateTracker(stmt_pattern_); }
 
  private:
   StmtPattern stmt_pattern_;

From 9ae7679370e07f31ad55486ae61028f64f577122 Mon Sep 17 00:00:00 2001
From: feifei-111 <2364819892@qq.com>
Date: Tue, 11 Jun 2024 09:11:23 +0000
Subject: [PATCH 75/99] update

---
 .../transforms/lowering_pass/utils.cc         |  3 +-
 .../hlir/framework/pir/op_lowering_group.h    | 14 ++++--
 .../hlir/framework/pir/op_lowering_impl.cc    |  3 +-
 .../hlir/framework/pir/trivial_op_impl.cc     | 29 +++++-------
 .../cinn/hlir/framework/pir/trivial_op_impl.h |  2 +-
 .../cinn/hlir/framework/pir/trivial_op_util.h |  5 ++
 paddle/cinn/operator_fusion/CMakeLists.txt    |  6 +--
 .../fusion_tracker/CMakeLists.txt             |  2 +-
 .../fusion_tracker/expr_utils.cc              | 46 +++++++++----------
 .../fusion_tracker/expr_utils.h               |  6 ++-
 .../fusion_tracker/interpreter.cc             | 34 +++++++++++---
 .../fusion_tracker/interpreter.h              | 17 ++++---
 .../operator_fusion/fusion_tracker/tracker.h  |  6 +--
 paddle/cinn/operator_fusion/pattern.h         | 18 ++++----
 14 files changed, 109 insertions(+), 82 deletions(-)

diff --git a/paddle/cinn/hlir/dialect/operator/transforms/lowering_pass/utils.cc b/paddle/cinn/hlir/dialect/operator/transforms/lowering_pass/utils.cc
index a36c208f0c96cd..b5b7e78025d7a9 100644
--- a/paddle/cinn/hlir/dialect/operator/transforms/lowering_pass/utils.cc
+++ b/paddle/cinn/hlir/dialect/operator/transforms/lowering_pass/utils.cc
@@ -111,7 +111,8 @@ OpLoweringGroupPtr BuildOpLoweringGroup(pir::Operation* fusion_op_ptr) {
     }
   }
 
-  auto group = std::make_shared<OpLoweringGroup>(ops);
+  auto group = std::make_shared<OpLoweringGroup>(
+      ops, fusion_op_ptr->attribute("fusion_tracker"));
 
   if (fusion_op.attributes().count("group_info")) {
     auto attr = fusion_op.attribute("group_info")
diff --git a/paddle/cinn/hlir/framework/pir/op_lowering_group.h b/paddle/cinn/hlir/framework/pir/op_lowering_group.h
index 935e759ed2331d..8c21907929ba91 100644
--- a/paddle/cinn/hlir/framework/pir/op_lowering_group.h
+++ b/paddle/cinn/hlir/framework/pir/op_lowering_group.h
@@ -22,6 +22,7 @@
 #include "paddle/cinn/common/context.h"
 #include "paddle/cinn/hlir/framework/op.h"
 #include "paddle/cinn/hlir/framework/pir/utils.h"
+#include "paddle/cinn/operator_fusion/fusion_tracker/tracker.h"
 #include "paddle/common/enforce.h"
 #include "paddle/pir/include/core/builtin_type_interfaces.h"
 #include "paddle/pir/include/core/operation.h"
@@ -42,13 +43,15 @@ class OpLoweringGroup {
   OpLoweringGroup(const OpLoweringGroup&) = delete;
   OpLoweringGroup(OpLoweringGroup&&) = delete;
 
-  explicit OpLoweringGroup(const std::vector<::pir::Operation*>& group_ops)
-      : ops_(group_ops) {
+  explicit OpLoweringGroup(const std::vector<::pir::Operation*>& group_ops,
+                           FusionTrackerPtr fusion_tracker_ptr)
+      : ops_(group_ops), fusion_tracker_ptr(fusion_tracker_ptr) {
     fn_name_ = CompatibleInfo::GroupOpsName(ops_);
   }
 
-  explicit OpLoweringGroup(std::initializer_list<::pir::Operation*> group_ops)
-      : ops_(group_ops) {
+  explicit OpLoweringGroup(std::initializer_list<::pir::Operation*> group_ops,
+                           FusionTrackerPtr fusion_tracker_ptr)
+      : ops_(group_ops), fusion_tracker_ptr(fusion_tracker_ptr) {
     fn_name_ = CompatibleInfo::GroupOpsName(ops_);
   }
 
@@ -221,6 +224,9 @@ class OpLoweringGroup {
   std::shared_ptr<adt::MapExprCtx> map_expr_ctx_;
   std::unordered_map<::pir::Value, symbol::ShapeOrDataDimExprs>
       value_to_shape_or_data_exprs_;
+
+ public:
+  FusionTrackerPtr fusion_tracker_ptr;
 };
 
 std::ostream& operator<<(std::ostream& os, const OpLoweringGroup& group);
diff --git a/paddle/cinn/hlir/framework/pir/op_lowering_impl.cc b/paddle/cinn/hlir/framework/pir/op_lowering_impl.cc
index b4b144c3218bce..4f24a3d73428cb 100644
--- a/paddle/cinn/hlir/framework/pir/op_lowering_impl.cc
+++ b/paddle/cinn/hlir/framework/pir/op_lowering_impl.cc
@@ -216,7 +216,8 @@ BucketLoweredFuncsWrapper OpLowererImpl::BucketLower(
   // =========== OpFusion ============
 
   // VLOG(4) << "Bucket Lower output values is : " << group->output_values();
-  func_bodies = OperationFusion(ops, func_bodies, group->output_values());
+  func_bodies = OperationFusion(
+      ops, func_bodies, group->output_values(), group->fusion_tracker_ptr);
   const auto& fusion_group_info = GetFusionGroupInfo(func_bodies);
 
   // =========== CodeGen And Optimizer ================
diff --git a/paddle/cinn/hlir/framework/pir/trivial_op_impl.cc b/paddle/cinn/hlir/framework/pir/trivial_op_impl.cc
index b68f0f5f8ebe08..3170386af27976 100644
--- a/paddle/cinn/hlir/framework/pir/trivial_op_impl.cc
+++ b/paddle/cinn/hlir/framework/pir/trivial_op_impl.cc
@@ -592,7 +592,7 @@ std::vector<ir::Var> GetAllForIters(const ir::Expr& expr) {
 std::vector<ir::Expr> OperationFusion(
     const std::vector<::pir::Operation*>& original_ops,
     const std::vector<ir::Expr>& op_compute_bodies,
-    const std::vector<::pir::Value>& outputs) {
+    FusionTrackerPtr fusion_tracker_ptr) {
   PADDLE_ENFORCE(FLAGS_group_schedule_tiling_first,
                  ::common::errors::PreconditionNotMet(
                      "TrivialFusion must be used with tiling first, set "
@@ -605,19 +605,18 @@ std::vector<ir::Expr> OperationFusion(
         return true;
       });
 
-  std::vector<cinn::fusion::BackendContent> contents;
+  const std::unordered_map<pir::Operation*, trivial_fusion_detail::FusibleOp>
+      initialized_lowered_op;
   for (int i = 0; i < ops.size(); i++) {
-    contents.emplace_back(ops[i], op_compute_bodies[i]);
+    initialized_lowered_op[ops[i]] = IsReduceBody(op_compute_bodies[i])
+                                         ? ReduceOp(op_compute_bodies[i])
+                                         : TrivialOp(op_compute_bodies[i]);
   }
-  const auto& fusion_nodes =
-      cinn::fusion::ClusterOps<cinn::fusion::BackendStage>(contents, outputs);
 
-  PADDLE_ENFORCE_EQ(fusion_nodes.size(),
-                    1,
-                    ::common::errors::Unimplemented(
-                        "Only support one fusion node in backend now."));
+  auto interpreter =
+      FusionInterpreter(fusion_tracker_ptr, initialized_lowered_op);
+  auto output = interpreter.Run();
 
-  const auto& output = GetExprFromPattern(fusion_nodes[0]->stmt_pattern());
   VLOG(4) << "Fusion Result: output size is " << output.size();
   for (const auto& expr : output) {
     VLOG(4) << expr;
@@ -631,15 +630,9 @@ FusionGroupInfo GetFusionGroupInfo(
   using trivial_fusion_detail::GetAllForIters;
   using trivial_fusion_detail::ReduceOp;
   using trivial_fusion_detail::ComposeUtils::ConcatVector;
-  using trivial_fusion_detail::ExprSetFinderUtils::ChildScheduleBlockRealizes;
-  using trivial_fusion_detail::ExprSetFinderUtils::ScheduleBlockRealizeIsInit;
+  using trivial_fusion_detail::IsReduceBody
 
-  FusionGroupInfo group_info = FusionGroupInfo();
-
-  const auto IsReduceBody = [](const ir::Expr& expr_body) {
-    return !(ChildScheduleBlockRealizes * ScheduleBlockRealizeIsInit)(expr_body)
-                .empty();
-  };
+      FusionGroupInfo group_info = FusionGroupInfo();
 
   for (const auto& body : op_compute_bodies) {
     if (IsReduceBody(body)) {
diff --git a/paddle/cinn/hlir/framework/pir/trivial_op_impl.h b/paddle/cinn/hlir/framework/pir/trivial_op_impl.h
index a958c0aa7fe040..4d4c1860675f85 100644
--- a/paddle/cinn/hlir/framework/pir/trivial_op_impl.h
+++ b/paddle/cinn/hlir/framework/pir/trivial_op_impl.h
@@ -182,7 +182,7 @@ FusionGroupInfo GetFusionGroupInfo(
 std::vector<ir::Expr> OperationFusion(
     const std::vector<::pir::Operation*>& ops,
     const std::vector<ir::Expr>& op_compute_bodies,
-    const std::vector<::pir::Value>& outputs);
+    FusionTrackerPtr fusion_tracker_ptr);
 
 }  // namespace pir
 }  // namespace framework
diff --git a/paddle/cinn/hlir/framework/pir/trivial_op_util.h b/paddle/cinn/hlir/framework/pir/trivial_op_util.h
index 6b474c0be9798b..4a4b54ab4cdfa5 100644
--- a/paddle/cinn/hlir/framework/pir/trivial_op_util.h
+++ b/paddle/cinn/hlir/framework/pir/trivial_op_util.h
@@ -264,6 +264,11 @@ bool IsTrivialKind(OpPatternKind kind);
 void CheckFusionInputValid(const std::vector<ir::Expr>& op_compute_bodies,
                            const std::vector<OpPatternKind>& op_patterns);
 
+bool IsReduceBody(const ir::Expr& expr_body) {
+  return !(ExprSetFinderUtils::ChildScheduleBlockRealizes *
+           ExprSetFinderUtils::ScheduleBlockRealizeIsInit)(expr_body)
+              .empty();
+}
 }  // namespace trivial_fusion_detail
 }  // namespace pir
 }  // namespace framework
diff --git a/paddle/cinn/operator_fusion/CMakeLists.txt b/paddle/cinn/operator_fusion/CMakeLists.txt
index b57c646032e19f..c4d5f4c1368cd3 100644
--- a/paddle/cinn/operator_fusion/CMakeLists.txt
+++ b/paddle/cinn/operator_fusion/CMakeLists.txt
@@ -1,11 +1,9 @@
-add_subdirectory(frontend)
-add_subdirectory(backend)
 add_subdirectory(policy)
 add_subdirectory(pir_graph_analyzing)
 add_subdirectory(fusion_tracker)
 
 cc_library(
   op_fusion
-  SRCS ${frontend_fusion_src} ${backend_fusion_src} ${policy_fusion_src}
-       ${fusion_graph_analyzing} ${fusion_tracker_src} pattern_graph.cc
+  SRCS ${policy_fusion_src} ${fusion_graph_analyzing} ${fusion_tracker_src}
+       pattern_graph.cc
   DEPS phi)
diff --git a/paddle/cinn/operator_fusion/fusion_tracker/CMakeLists.txt b/paddle/cinn/operator_fusion/fusion_tracker/CMakeLists.txt
index 0d61eb7cef95b3..9c9284f7c45c0f 100644
--- a/paddle/cinn/operator_fusion/fusion_tracker/CMakeLists.txt
+++ b/paddle/cinn/operator_fusion/fusion_tracker/CMakeLists.txt
@@ -1 +1 @@
-gather_srcs(fusion_tracker_src SRCS interpreter.cc)
+gather_srcs(fusion_tracker_src SRCS interpreter.cc, expr_utils.cc)
diff --git a/paddle/cinn/operator_fusion/fusion_tracker/expr_utils.cc b/paddle/cinn/operator_fusion/fusion_tracker/expr_utils.cc
index 765c55bf8a98a7..966b0dd3801ca6 100644
--- a/paddle/cinn/operator_fusion/fusion_tracker/expr_utils.cc
+++ b/paddle/cinn/operator_fusion/fusion_tracker/expr_utils.cc
@@ -128,13 +128,13 @@ std::vector<ir::Expr> TopoSort(const std::vector<ir::Expr>& op_exprs) {
 }
 
 /// Start: Tmp Transform Operation for ReduceTree
-std::vector<FusionOp> ReduceTransformRecursive(
+std::vector<FusibleOp> ReduceTransformRecursive(
     ReduceOp reduce_op,
     const ReduceTreePattern<BackendStage>& reduce_tree_pattern,
     const std::vector<size_t>& fake_reduce_iter_idx = {}) {
-  FusionOp root_op = reduce_op;
+  FusibleOp root_op = reduce_op;
   VLOG(4) << "ReduceTransformRecursive: " << *_GetFuncBodyPointer(root_op);
-  std::vector<FusionOp> result;
+  std::vector<FusibleOp> result;
   for (const auto& child_tree : reduce_tree_pattern.childs()) {
     const auto& child_reduce_op = child_tree.GetRootPattern().reduce_op;
     auto transformed_nodes = cinn::hlir::framework::pir::trivial_fusion_detail::
@@ -151,13 +151,13 @@ std::vector<FusionOp> ReduceTransformRecursive(
   return result;
 }
 
-std::vector<FusionOp> ReduceTreeTrivialTransformRecursive(
+std::vector<FusibleOp> ReduceTreeTrivialTransformRecursive(
     TrivialOp trivial_op,
     const ReduceTreePlusTrivialPattern<BackendStage>& rt_pattern) {
-  FusionOp root_op = trivial_op;
+  FusibleOp root_op = trivial_op;
   VLOG(4) << "ReduceTrivialTransformRecursive: "
           << *_GetFuncBodyPointer(root_op);
-  std::vector<FusionOp> result;
+  std::vector<FusibleOp> result;
 
   const auto& child_tree = rt_pattern.tree;
   const auto& child_reduce_op = child_tree.GetRootPattern().reduce_op;
@@ -203,7 +203,7 @@ static std::vector<ir::Var> GetAllForIters(const ir::Expr& expr) {
 }
 
 ir::Expr UnSqueezeExpr(const ir::Expr& expr,
-                       const std::vector<int> padding_vec) {
+                       const std::vector<int>& padding_vec) {
   using cinn::hlir::framework::pir::trivial_fusion_detail::AppendBound;
   using cinn::hlir::framework::pir::trivial_fusion_detail::ExprSetFinderUtils::
       ChildFors;
@@ -259,25 +259,23 @@ ir::Expr UnSqueezeExpr(const ir::Expr& expr,
   return result;
 }
 
-struct IrExprGetter {
-  std::vector<ir::Expr> operator()(
-      const ReduceTreePattern<BackendStage>& pattern) {
-    const auto& fusion_op =
-        ReduceTransformRecursive(pattern.GetRootPattern().reduce_op, pattern);
-    std::function<std::vector<ir::Expr>(const FusionOp& f)> func =
-        [](const FusionOp& op) { return std::visit(FusionOp2Expr(), op); };
-    return VectorFlatMap(fusion_op, func);
-  }
-
-  std::vector<ir::Expr> operator()(
-      const ReduceTreePlusTrivialPattern<BackendStage>& pattern) {
-    std::function<std::vector<ir::Expr>(const FusionOp& f)> func =
-        [](const FusionOp& op) { return std::visit(FusionOp2Expr(), op); };
-    const auto& fusion_ops = ReduceTreeTrivialTransformRecursive(
-        pattern.sink_trivial.trivial_op, pattern);
-    return VectorFlatMap(fusion_ops, func);
+std::vector<FusibleOp> DoPadding(const FusibleOp& fusion_op,
+                                 const std::vector<int>& padding_pos) {
+  using cinn::hlir::framework::pir::trivial_fusion_detail::IsReduceBody;
+  std::vector<FusibleOp> results;
+  auto expr_vec = std::visit(FusibleOp2Expr(), fusion_op);
+  for (auto expr : expr_vec) {
+    auto squeezed = UnSqueezeExpr(expr, padding_pos);
+    if (IsReduceBody(expr)) {
+      results.emplace_back(ReduceOp(squeezed));
+    } else {
+      results.emplace_back(TrivialOp(squeezed));
+    }
   }
+  return results;
+}
 
+struct IrExprGetter {
   std::vector<ir::Expr> operator()(
       const HorizontalFusionPattern<BackendStage>& pattern) {
     std::vector<ir::Expr> result;
diff --git a/paddle/cinn/operator_fusion/fusion_tracker/expr_utils.h b/paddle/cinn/operator_fusion/fusion_tracker/expr_utils.h
index 3a16bd39dd7618..cb4cf984089ec4 100644
--- a/paddle/cinn/operator_fusion/fusion_tracker/expr_utils.h
+++ b/paddle/cinn/operator_fusion/fusion_tracker/expr_utils.h
@@ -19,9 +19,9 @@ namespace cinn::fusion {
 
 using TrivialOp = cinn::hlir::framework::pir::trivial_fusion_detail::TrivialOp;
 using ReduceOp = cinn::hlir::framework::pir::trivial_fusion_detail::ReduceOp;
-using FusionOp = std::variant<ReduceOp, TrivialOp>;
+using FusibleOp = cinn::hlir::framework::pir::trivial_fusion_detail::FusibleOp;
 
-struct FusionOp2Expr {
+struct FusibleOp2Expr {
   std::vector<ir::Expr> operator()(const TrivialOp& op) {
     return {op.GetFuncBody()};
   }
@@ -49,5 +49,7 @@ struct ApplyTransform {
 };
 
 std::vector<ir::Expr> TopoSort(const std::vector<ir::Expr>& op_exprs);
+std::vector<FusibleOp> DoPadding(const FusibleOp& fusion_op,
+                                 const std::vector<int>& padding_pos);
 
 }  // namespace cinn::fusion
diff --git a/paddle/cinn/operator_fusion/fusion_tracker/interpreter.cc b/paddle/cinn/operator_fusion/fusion_tracker/interpreter.cc
index a9182a8b05adb0..6fb3fefa333672 100644
--- a/paddle/cinn/operator_fusion/fusion_tracker/interpreter.cc
+++ b/paddle/cinn/operator_fusion/fusion_tracker/interpreter.cc
@@ -37,7 +37,8 @@ void RunCombineInstr(const std::shared_ptr<CombineInstr>& instr,
 void RunInitPatternInstr(const std::shared_ptr<InitPatternInstr>& instr,
                          FusionInterpreter* interpreter) {
   ScopeElementPtr new_pattern = std::make_shared<ScopeElement>();
-  new_pattern->fusion_ops.emplace_back((interpreter->lowered_expr)[instr->op_]);
+  new_pattern->fusion_ops.emplace_back(
+      (interpreter->initialized_lowered_op)[instr->op_]);
   interpreter->scope[instr->result_] = new_pattern;
 }
 
@@ -66,7 +67,7 @@ void RunTmpTransformInstr(const std::shared_ptr<TmpTransformInstr>& instr,
   auto downstream_op =
       interpreter->scope[instr->downstream_]->fusion_ops.front();
   ScopeElementPtr new_pattern = std::make_shared<ScopeElement>();
-  new_pattern->fusion_ops.emplace(
+  new_pattern->fusion_ops.emplace_back(
       cinn::hlir::framework::pir::trivial_fusion_detail::
           TransformReduceLoopRange(
               upstream_op, &downstream_op, instr->fake_reduce_iter_idx_););
@@ -103,16 +104,32 @@ void RunAnchorTransformInstr(const std::shared_ptr<AnchorTransformInstr>& instr,
     return target;
   };
 
-  auto exprs = do_transform(std::visit(
-      FusionOp2Expr(), interpreter->scope[instr->target_]->fusion_ops.front()));
-  interpreter.ret_expr.insert(
-      interpreter.ret_expr.end(), exprs.begin(), exprs.end());
+  auto candidate_exprs = std::visit(
+      FusibleOp2Expr(), interpreter->scope[instr->target_]->fusion_ops.front());
+  for (auto expr : candidate_exprs) {
+    auto transformed_expr = do_transform(expr);
+    if (IsReduceBody(transformed_expr)) {
+      new_pattern->fusion_ops.emplace_back(ReduceOp(transformed_expr));
+    } else {
+      new_pattern->fusion_ops.emplace_back(TrivialOp(transformed_expr));
+    }
+  }
+  interpreter->scope[instr->result_] = new_pattern;
+}
+
+void RunPaddingInstr(const std::shared_ptr<PaddingInstr>& instr,
+                     FusionInterpreter* interpreter) {
+  ScopeElementPtr new_pattern = std::make_shared<ScopeElement>();
+  for (auto fusion_op : interpreter->scope[instr->target_]->fusion_ops) {
+    new_pattern->Extend(DoPadding(fusion_op, instr->padding_pos_));
+  }
+  interpreter->scope[instr->result_] = new_pattern;
 }
 
 void RunReturnInstr(const std::shared_ptr<ReturnInstr>& instr,
                     FusionInterpreter* interpreter) {
   for (auto fusion_op : interpreter->scope[instr->target_]->fusion_ops) {
-    auto exprs = std::visit(FusionOp2Expr(), fusion_op);
+    auto exprs = std::visit(FusibleOp2Expr(), fusion_op);
     interpreter->ret_expr.insert(
         interpreter->ret_expr.end(), exprs.begin(), exprs.end());
   }
@@ -143,6 +160,9 @@ std::vector<ir::Expr> FusionInterpreter::Run() {
         RunAnchorTransformInstr(
             dynamic_cast_instr_with_err<AnchorTransformInstr>(instr), this);
         break;
+      case T_Padding:
+        RunPaddingInstr(dynamic_cast_instr_with_err<PaddingInstr>(instr), this);
+        break;
       case T_Return:
         RunReturnInstr(dynamic_cast_instr_with_err<ReturnInstr>(instr), this);
       default:
diff --git a/paddle/cinn/operator_fusion/fusion_tracker/interpreter.h b/paddle/cinn/operator_fusion/fusion_tracker/interpreter.h
index 2a87f8bbb138cf..e8ac26eb4150ee 100644
--- a/paddle/cinn/operator_fusion/fusion_tracker/interpreter.h
+++ b/paddle/cinn/operator_fusion/fusion_tracker/interpreter.h
@@ -23,9 +23,12 @@ namespace cinn::fusion {
 
 struct ScopeElement {
   ScopeElement() = default;
-  explicit ScopeElement(const std::vector<FusionOp> fusion_ops)
+  explicit ScopeElement(const std::vector<FusibleOp> fusion_ops)
       : fusion_ops(fusion_ops) {}
-  std::vector<FusionOp> fusion_ops;
+  std::vector<FusibleOp> fusion_ops;
+  void Extend(const std::vector<FusibleOp>& other) {
+    fusion_ops.insert(fusion_ops.end(), other.begin(), other.end());
+  }
 };
 using ScopeElementPtr = std::shared_ptr<ScopeElement>;
 
@@ -36,12 +39,12 @@ ScopeElementPtr CombineScopeElement(const ScopeElementPtr& a,
 }
 
 struct FusionInterpreter {
-  FusionInterpreter(
-      const FusionTrackerPtr& tracker,
-      const std::unordered_map<pir::Operation*, FusionOp>& lowered_expr)
-      : tracker(tracker), lowered_expr(lowered_expr) {}
+  FusionInterpreter(const FusionTrackerPtr& tracker,
+                    const std::unordered_map<pir::Operation*, FusibleOp>&
+                        initialized_lowered_op)
+      : tracker(tracker), initialized_lowered_op(initialized_lowered_op) {}
 
-  std::unordered_map<pir::Operation*, FusionOp> lowered_expr;
+  std::unordered_map<pir::Operation*, FusibleOp> initialized_lowered_op;
   std::unordered_map<std::string, ScopeElementPtr> scope;
   FusionTrackerPtr tracker;
 
diff --git a/paddle/cinn/operator_fusion/fusion_tracker/tracker.h b/paddle/cinn/operator_fusion/fusion_tracker/tracker.h
index 6f35c5170ae74d..e1c71081d53f43 100644
--- a/paddle/cinn/operator_fusion/fusion_tracker/tracker.h
+++ b/paddle/cinn/operator_fusion/fusion_tracker/tracker.h
@@ -122,9 +122,9 @@ struct AnchorTransformInstr : public FusionInstruction {
 };
 
 struct PaddingInstr : public FusionInstruction {
-  AnchorTransformInstr(const std::string& target,
-                       const std::string& result,
-                       const std::vector<int>& padding_pos)
+  PaddingInstr(const std::string& target,
+               const std::string& result,
+               const std::vector<int>& padding_pos)
       : target_(target), result_(result), padding_pos_(padding_pos) {}
   virtual InstructionType type() { return T_Padding; }
   std::string target_;
diff --git a/paddle/cinn/operator_fusion/pattern.h b/paddle/cinn/operator_fusion/pattern.h
index 64734d43575fb8..d5f9a216d0b8b5 100644
--- a/paddle/cinn/operator_fusion/pattern.h
+++ b/paddle/cinn/operator_fusion/pattern.h
@@ -56,7 +56,7 @@ struct TrivialPattern {
   std::string name_;
 
   FusionTrackerPtr tracker_;
-  void update_tracker() {}
+  void update_tracker() const {}
 };
 
 struct ReducePattern {
@@ -78,7 +78,7 @@ struct ReducePattern {
   std::string name_;
 
   FusionTrackerPtr tracker_;
-  void update_tracker() {}
+  void update_tracker() const {}
 };
 
 struct ReduceTreePattern {
@@ -117,7 +117,7 @@ struct ReduceTreePattern {
 
   FusionTrackerPtr tracker_;
 
-  void update_tracker() {
+  void update_tracker() const {
     std::vector<std::string> tmp_names({GetRootPattern().name()});
     int count = 0;
     const auto hook = [tracker = tracker_, &tmp_names, &count](
@@ -168,7 +168,7 @@ struct ReduceTreePlusTrivialPattern {
 
   FusionTrackerPtr tracker_;
 
-  void update_tracker() {
+  void update_tracker() const {
     std::vector<std::string> tmp_names(
         {sink_trivial.name(), tree.GetRootPattern().name()});
     tracker_->append(
@@ -245,7 +245,7 @@ struct AnchorPattern {
   std::string name_;
 
   FusionTrackerPtr tracker_;
-  void update_tracker() {
+  void update_tracker() const {
     std::vector<std::string> tmp_names;
     for (int i = 0; i < anchor_state.promise.size(); i++) {
       auto promise = anchor_state.promise[i];
@@ -293,7 +293,7 @@ struct HorizontalFusionPattern {
   }
   std::string name() const { return name_; }
   std::string name_;
-  void update_tracker() {
+  void update_tracker() const {
     std::vector<std::string> tmp_names;
     for (int i = 0; i < padding_patterns_.size(); i++) {
       auto padding_pattern = padding_patterns_[i];
@@ -327,7 +327,7 @@ struct UnsupportPattern {
   std::string name_;
 
   FusionTrackerPtr tracker_;
-  void update_tracker() {}
+  void update_tracker() const {}
 };
 
 using StmtPatternBase = std::variant<TrivialPattern,
@@ -398,8 +398,8 @@ std::unordered_set<pir::Value> GetPatternInputValues(const StmtPattern& A) {
   return all_input_values;
 }
 
-void PatternUpdateTracker(const StmtPattern& A) {
+void PatternUpdateTracker(const StmtPattern& pattern) {
   return std::visit([](const auto& impl) { impl.update_tracker(); },
-                    s.variant());
+                    pattern.variant());
 }
 }  // namespace cinn::fusion

From ff8384b4a576d401adbd5289e7294404f61f9d98 Mon Sep 17 00:00:00 2001
From: feifei-111 <2364819892@qq.com>
Date: Wed, 12 Jun 2024 07:31:55 +0000
Subject: [PATCH 76/99] update

---
 .../dialect/operator/ir/attribute_storage.h   |  5 ++
 .../hlir/framework/pir/op_lowering_impl.cc    |  3 +-
 .../fusion_tracker/CMakeLists.txt             |  2 +-
 .../fusion_tracker/interpreter.h              | 12 +--
 .../operator_fusion/fusion_tracker/tracker.h  | 86 ++++++++++++++++---
 paddle/cinn/operator_fusion/pattern_graph.cc  |  4 -
 .../pir_graph_analyzing/anchor_transform.h    |  3 +-
 .../policy/anchor_search_policy.cc            |  3 +-
 .../policy/general_topo_policy.cc             |  3 +-
 .../policy/relative_judge_policy.cc           |  3 +-
 10 files changed, 88 insertions(+), 36 deletions(-)

diff --git a/paddle/cinn/hlir/dialect/operator/ir/attribute_storage.h b/paddle/cinn/hlir/dialect/operator/ir/attribute_storage.h
index 03bb698e4a9e3d..ba055d59cf8584 100644
--- a/paddle/cinn/hlir/dialect/operator/ir/attribute_storage.h
+++ b/paddle/cinn/hlir/dialect/operator/ir/attribute_storage.h
@@ -101,6 +101,11 @@ struct GroupInfoAttributeStorage : public pir::AttributeStorage {
   ParamKey data_;
 };
 
+namespace cinn::fusion {
+struct FusionTracker;
+using FusionTrackerPtr = std::shared_ptr<FusionTracker>;
+}  // namespace cinn::fusion
+
 struct FusionTrackerPtrAttributeStorage : public pir::AttributeStorage {
   using ParamKey = cinn::fusion::FusionTrackerPtr;
   explicit FusionTrackerPtrAttributeStorage(const ParamKey& key) : data_(key) {}
diff --git a/paddle/cinn/hlir/framework/pir/op_lowering_impl.cc b/paddle/cinn/hlir/framework/pir/op_lowering_impl.cc
index 4f24a3d73428cb..5ad4aa1b87e0d3 100644
--- a/paddle/cinn/hlir/framework/pir/op_lowering_impl.cc
+++ b/paddle/cinn/hlir/framework/pir/op_lowering_impl.cc
@@ -216,8 +216,7 @@ BucketLoweredFuncsWrapper OpLowererImpl::BucketLower(
   // =========== OpFusion ============
 
   // VLOG(4) << "Bucket Lower output values is : " << group->output_values();
-  func_bodies = OperationFusion(
-      ops, func_bodies, group->output_values(), group->fusion_tracker_ptr);
+  func_bodies = OperationFusion(ops, func_bodies, group->fusion_tracker_ptr);
   const auto& fusion_group_info = GetFusionGroupInfo(func_bodies);
 
   // =========== CodeGen And Optimizer ================
diff --git a/paddle/cinn/operator_fusion/fusion_tracker/CMakeLists.txt b/paddle/cinn/operator_fusion/fusion_tracker/CMakeLists.txt
index 9c9284f7c45c0f..af52ce76b4b286 100644
--- a/paddle/cinn/operator_fusion/fusion_tracker/CMakeLists.txt
+++ b/paddle/cinn/operator_fusion/fusion_tracker/CMakeLists.txt
@@ -1 +1 @@
-gather_srcs(fusion_tracker_src SRCS interpreter.cc, expr_utils.cc)
+gather_srcs(fusion_tracker_src SRCS interpreter.cc expr_utils.cc)
diff --git a/paddle/cinn/operator_fusion/fusion_tracker/interpreter.h b/paddle/cinn/operator_fusion/fusion_tracker/interpreter.h
index e8ac26eb4150ee..30f187ea3f9ff3 100644
--- a/paddle/cinn/operator_fusion/fusion_tracker/interpreter.h
+++ b/paddle/cinn/operator_fusion/fusion_tracker/interpreter.h
@@ -42,7 +42,9 @@ struct FusionInterpreter {
   FusionInterpreter(const FusionTrackerPtr& tracker,
                     const std::unordered_map<pir::Operation*, FusibleOp>&
                         initialized_lowered_op)
-      : tracker(tracker), initialized_lowered_op(initialized_lowered_op) {}
+      : tracker(tracker), initialized_lowered_op(initialized_lowered_op) {
+    VLOG(4) << "Create FusionInterpreter, Tracker is:\n" << tracker->DebugStr();
+  }
 
   std::unordered_map<pir::Operation*, FusibleOp> initialized_lowered_op;
   std::unordered_map<std::string, ScopeElementPtr> scope;
@@ -51,12 +53,4 @@ struct FusionInterpreter {
   std::vector<ir::Expr> ret_expr;
   std::vector<ir::Expr> Run();
 };
-
-template <typename T>
-std::shared_ptr<T> dynamic_cast_instr_with_err(FusionInstrPtr instr) {
-  auto chile_instr = std::dynamic_pointer_cast<T>(instr);
-  if (!chile_instr) PADDLE_THROW("Cast Fusion Instr Failed.");
-  return chile_instr;
-}
-
 }  // namespace cinn::fusion
diff --git a/paddle/cinn/operator_fusion/fusion_tracker/tracker.h b/paddle/cinn/operator_fusion/fusion_tracker/tracker.h
index e1c71081d53f43..e9e64af38e389e 100644
--- a/paddle/cinn/operator_fusion/fusion_tracker/tracker.h
+++ b/paddle/cinn/operator_fusion/fusion_tracker/tracker.h
@@ -14,6 +14,7 @@
 
 #pragma once
 #include "paddle/cinn/operator_fusion/pir_graph_analyzing/anchor_transform.h"
+#include "paddle/cinn/operator_fusion/utils.h"
 
 namespace cinn::fusion {
 
@@ -30,31 +31,46 @@ enum InstructionType {
 };
 
 struct FusionInstruction {
-  virtual InstructionType type();
+  virtual InstructionType type() const;
+  virtual std::string DebugStr() const;
 };
 
-using FusionInstrPtr = std::shared_ptr<FusionInstruction>;
-
 struct CopyInstr : public FusionInstruction {
   CopyInstr(const std::string& origin_name, const std::string& new_name)
       : origin_name_(origin_name), new_name_(new_name) {}
-  virtual InstructionType type() { return T_Copy; }
+  virtual InstructionType type() const { return T_Copy; }
   std::string origin_name_;
   std::string new_name_;
+
+  virtual std::string DebugStr() const {
+    return "CopyInstr || " + origin_name_ + " => " + new_name_;
+  }
 };
 
 struct CombineInstr : public FusionInstruction {
   CombineInstr(const std::vector<std::string>& names, const std::string& result)
       : names_(names), result_(result) {}
-  virtual InstructionType type() { return T_Combine; }
+  virtual InstructionType type() const { return T_Combine; }
   std::vector<std::string> names_;
   std::string result_;
+
+  virtual std::string DebugStr() const {
+    std::stringstream ss;
+    ss << "CombineInstr || ";
+    for (auto name : names_) {
+      ss << name << ", ";
+    }
+    ss << "=> " << result_;
+    return ss.str();
+  }
 };
 
 struct ReturnInstr : public FusionInstruction {
   explicit ReturnInstr(const std::string& target) : target_(target) {}
-  virtual InstructionType type() { return T_Return; }
+  virtual InstructionType type() const { return T_Return; }
   std::string target_;
+
+  virtual std::string DebugStr() const { return "ReturnInstr || " + target_; }
 };
 
 // struct RemovePatternInstr : public FusionInstruction {};
@@ -62,9 +78,13 @@ struct ReturnInstr : public FusionInstruction {
 struct InitPatternInstr : public FusionInstruction {
   InitPatternInstr(pir::Operation* op, const std::string& result)
       : op_(op), result_(result) {}
-  virtual InstructionType type() { return T_InitPattern; }
+  virtual InstructionType type() const { return T_InitPattern; }
   pir::Operation* op_;
   std::string result_;
+
+  virtual std::string DebugStr() const {
+    return "InitPatternInstr || " + op_->name() + " => " + result_;
+  }
 };
 
 struct TrivialInlineInstr : public FusionInstruction {
@@ -72,10 +92,15 @@ struct TrivialInlineInstr : public FusionInstruction {
                      const std::string& downstream,
                      const std::string& result)
       : upstream_(upstream), downstream_(downstream), result_(result) {}
-  virtual InstructionType type() { return T_TrivialInline; }
+  virtual InstructionType type() const { return T_TrivialInline; }
   std::string upstream_;
   std::string downstream_;
   std::string result_;
+
+  virtual std::string DebugStr() const {
+    return "TrivialInlineInstr || " + upstream_ + ", " + downstream_ + " => " +
+           result_;
+  }
 };
 
 struct TmpTransformInstr : public FusionInstruction {
@@ -87,11 +112,16 @@ struct TmpTransformInstr : public FusionInstruction {
         downstream_(downstream),
         result_(result),
         fake_reduce_iter_idx_(fake_reduce_iter_idx) {}
-  virtual InstructionType type() { return T_TmpTransform; }
+  virtual InstructionType type() const { return T_TmpTransform; }
   std::string upstream_;
   std::string downstream_;
   std::string result_;
   std::vector<size_t> fake_reduce_iter_idx_;
+
+  virtual std::string DebugStr() const {
+    return "TrivialInlineInstr || " + upstream_ + ", " + downstream_ + " => " +
+           result_;
+  }
 };
 
 struct TrivialLoopAlignInstr : public FusionInstruction {
@@ -103,11 +133,16 @@ struct TrivialLoopAlignInstr : public FusionInstruction {
         downstream_(downstream),
         result_(result),
         fake_reduce_iter_idx_(fake_reduce_iter_idx) {}
-  virtual InstructionType type() { return T_TrivialLoopAlign; }
+  virtual InstructionType type() const { return T_TrivialLoopAlign; }
   std::string upstream_;
   std::string downstream_;
   std::string result_;
   std::vector<size_t> fake_reduce_iter_idx_;
+
+  virtual std::string DebugStr() const {
+    return "TrivialLoopAlignInstr || " + upstream_ + ", " + downstream_ +
+           " => " + result_;
+  }
 };
 
 struct AnchorTransformInstr : public FusionInstruction {
@@ -115,10 +150,14 @@ struct AnchorTransformInstr : public FusionInstruction {
                        const std::string& result,
                        const AnchorTransformRoute& transform_route)
       : target_(target), result_(result), transform_route_(transform_route) {}
-  virtual InstructionType type() { return T_AnchorTransform; }
+  virtual InstructionType type() const { return T_AnchorTransform; }
   std::string target_;
   std::string result_;
   AnchorTransformRoute transform_route_;
+
+  virtual std::string DebugStr() const {
+    return "AnchorTransformInstr || " + target_ + " => " + result_;
+  }
 };
 
 struct PaddingInstr : public FusionInstruction {
@@ -126,12 +165,25 @@ struct PaddingInstr : public FusionInstruction {
                const std::string& result,
                const std::vector<int>& padding_pos)
       : target_(target), result_(result), padding_pos_(padding_pos) {}
-  virtual InstructionType type() { return T_Padding; }
+  virtual InstructionType type() const { return T_Padding; }
   std::string target_;
   std::string result_;
   std::vector<int> padding_pos_;
+
+  virtual std::string DebugStr() const {
+    return "PaddingInstr || " + target_ + " => " + result_;
+  }
 };
 
+using FusionInstrPtr = std::shared_ptr<FusionInstruction>;
+
+template <typename T>
+std::shared_ptr<T> dynamic_cast_instr_with_err(FusionInstrPtr instr) {
+  auto chile_instr = std::dynamic_pointer_cast<T>(instr);
+  if (!chile_instr) PADDLE_THROW("Cast Fusion Instr Failed.");
+  return chile_instr;
+}
+
 struct FusionTracker {
   using FusionTrackerPtr = std::shared_ptr<FusionTracker>;
   FusionTracker() = default;
@@ -143,9 +195,17 @@ struct FusionTracker {
     ExtendVector(&instructions_, down->instructions_);
   }
   void append(FusionInstrPtr instr) { instructions_.emplace_back(instr); }
-  std::string DebugStr() const;
+  std::string DebugStr() const {
+    std::stringstream ss;
+    ss << "FusionTracker: \n";
+    for (auto instr : instructions_) {
+      ss << "  " << instr->DebugStr() << "\n";
+    }
+    return ss.str();
+  }
   std::vector<FusionInstrPtr> instructions_;
 };
 
 using FusionTrackerPtr = std::shared_ptr<FusionTracker>;
+
 }  // namespace cinn::fusion
diff --git a/paddle/cinn/operator_fusion/pattern_graph.cc b/paddle/cinn/operator_fusion/pattern_graph.cc
index 48b0146b641a6b..f8b7e785a9fa6a 100644
--- a/paddle/cinn/operator_fusion/pattern_graph.cc
+++ b/paddle/cinn/operator_fusion/pattern_graph.cc
@@ -245,7 +245,6 @@ PatternGraph::PatternGraph(const std::vector<PatternContent>& contents,
           << all_pattern_nodes_.size();
 }
 
-template <typename T>
 void PatternGraph::RemoveNode(const PatternNodePtr& node) {
   VLOG(4) << "Start Remove: " << node;
   if (all_pattern_nodes_.find(node) != all_pattern_nodes_.end()) {
@@ -262,12 +261,10 @@ void PatternGraph::RemoveNode(const PatternNodePtr& node) {
   }
 }
 
-template <typename T>
 void PatternGraph::AppendNode(const PatternNodePtr& node) {
   all_pattern_nodes_.emplace(node);
 }
 
-template <typename T>
 std::string PatternGraph::GraphInfo() const {
   std::stringstream ss;
   ss << "\n========= GraphInfo ===========";
@@ -280,7 +277,6 @@ std::string PatternGraph::GraphInfo() const {
   return ss.str();
 }
 
-template <typename T>
 PatternNodePtr PatternGraph::MergeNode(const PatternNodePtr& upstream,
                                        const PatternNodePtr& downstream,
                                        MergePatternFn merge_pattern_fn) {
diff --git a/paddle/cinn/operator_fusion/pir_graph_analyzing/anchor_transform.h b/paddle/cinn/operator_fusion/pir_graph_analyzing/anchor_transform.h
index 538056bc654003..6bd690abf1fe2e 100644
--- a/paddle/cinn/operator_fusion/pir_graph_analyzing/anchor_transform.h
+++ b/paddle/cinn/operator_fusion/pir_graph_analyzing/anchor_transform.h
@@ -115,6 +115,8 @@ using AnchorTransform = std::variant<UnsupportTransformPtr,
                                      DeleteDimTransformPtr>;
 using AnchorTransformRoute = std::vector<AnchorTransform>;
 
+std::string DebugStrOfAnchorTransformRoute(const AnchorTransformRoute& route);
+
 struct ExprPromise {
   explicit ExprPromise(const pir::Value& root, const std::string& name)
       : root_value(root), name_(name) {}
@@ -158,5 +160,4 @@ AnchorTransform CreateAnchorTransform(const TransformInfo& info);
 std::vector<AnchorTransform> PossibleTransform(pir::Value v);
 TransformInfo GetTransformInfo(AnchorTransform trans);
 std::string DebugStrOfAnchorTransform(const AnchorTransform& trans);
-std::string DebugStrOfAnchorTransformRoute(const AnchorTransformRoute& route);
 }  // namespace cinn::fusion
diff --git a/paddle/cinn/operator_fusion/policy/anchor_search_policy.cc b/paddle/cinn/operator_fusion/policy/anchor_search_policy.cc
index 6f5b215f5c90cf..b7a216823130e3 100644
--- a/paddle/cinn/operator_fusion/policy/anchor_search_policy.cc
+++ b/paddle/cinn/operator_fusion/policy/anchor_search_policy.cc
@@ -13,8 +13,7 @@
 // limitations under the License.
 
 #include "paddle/cinn/operator_fusion/policy/anchor_search_policy.h"
-#include "paddle/cinn/operator_fusion/backend/pattern.h"
-#include "paddle/cinn/operator_fusion/frontend/pattern.h"
+#include "paddle/cinn/operator_fusion/pattern.h"
 
 namespace cinn::fusion {
 
diff --git a/paddle/cinn/operator_fusion/policy/general_topo_policy.cc b/paddle/cinn/operator_fusion/policy/general_topo_policy.cc
index 911b5ee0bf1dcb..0d08e6a053f9a0 100644
--- a/paddle/cinn/operator_fusion/policy/general_topo_policy.cc
+++ b/paddle/cinn/operator_fusion/policy/general_topo_policy.cc
@@ -13,8 +13,7 @@
 // limitations under the License.
 
 #include "paddle/cinn/operator_fusion/policy/general_topo_policy.h"
-#include "paddle/cinn/operator_fusion/backend/pattern.h"
-#include "paddle/cinn/operator_fusion/frontend/pattern.h"
+#include "paddle/cinn/operator_fusion/pattern.h"
 
 namespace cinn::fusion {
 
diff --git a/paddle/cinn/operator_fusion/policy/relative_judge_policy.cc b/paddle/cinn/operator_fusion/policy/relative_judge_policy.cc
index 8ba6ed3cf24607..42787694bf44a6 100644
--- a/paddle/cinn/operator_fusion/policy/relative_judge_policy.cc
+++ b/paddle/cinn/operator_fusion/policy/relative_judge_policy.cc
@@ -13,8 +13,7 @@
 // limitations under the License.
 
 #include "paddle/cinn/operator_fusion/policy/relative_judge_policy.h"
-#include "paddle/cinn/operator_fusion/backend/pattern.h"
-#include "paddle/cinn/operator_fusion/frontend/pattern.h"
+#include "paddle/cinn/operator_fusion/pattern.h"
 
 namespace cinn::fusion {
 

From e74f49ebf37ff1a7eb6508678a85425370660cee Mon Sep 17 00:00:00 2001
From: feifei-111 <2364819892@qq.com>
Date: Wed, 12 Jun 2024 07:34:01 +0000
Subject: [PATCH 77/99] update

---
 paddle/cinn/hlir/dialect/operator/ir/attribute_storage.h | 5 -----
 1 file changed, 5 deletions(-)

diff --git a/paddle/cinn/hlir/dialect/operator/ir/attribute_storage.h b/paddle/cinn/hlir/dialect/operator/ir/attribute_storage.h
index ba055d59cf8584..03bb698e4a9e3d 100644
--- a/paddle/cinn/hlir/dialect/operator/ir/attribute_storage.h
+++ b/paddle/cinn/hlir/dialect/operator/ir/attribute_storage.h
@@ -101,11 +101,6 @@ struct GroupInfoAttributeStorage : public pir::AttributeStorage {
   ParamKey data_;
 };
 
-namespace cinn::fusion {
-struct FusionTracker;
-using FusionTrackerPtr = std::shared_ptr<FusionTracker>;
-}  // namespace cinn::fusion
-
 struct FusionTrackerPtrAttributeStorage : public pir::AttributeStorage {
   using ParamKey = cinn::fusion::FusionTrackerPtr;
   explicit FusionTrackerPtrAttributeStorage(const ParamKey& key) : data_(key) {}

From f0dbf243ba413bd8ad3ae145eea0239f55963002 Mon Sep 17 00:00:00 2001
From: feifei-111 <2364819892@qq.com>
Date: Wed, 12 Jun 2024 08:02:57 +0000
Subject: [PATCH 78/99] update

---
 .../dialect/operator/transforms/add_cinn_pass.cc   |  1 -
 paddle/cinn/hlir/framework/pir/trivial_op_impl.cc  | 14 ++++----------
 paddle/cinn/hlir/framework/pir/trivial_op_impl.h   |  1 +
 3 files changed, 5 insertions(+), 11 deletions(-)

diff --git a/paddle/cinn/hlir/dialect/operator/transforms/add_cinn_pass.cc b/paddle/cinn/hlir/dialect/operator/transforms/add_cinn_pass.cc
index 6a92dc63f3925f..b1a946d5b4f676 100644
--- a/paddle/cinn/hlir/dialect/operator/transforms/add_cinn_pass.cc
+++ b/paddle/cinn/hlir/dialect/operator/transforms/add_cinn_pass.cc
@@ -159,7 +159,6 @@ void ApplyDivideGroupOpToFusionOpPass(
     const std::function<std::shared_ptr<pir::PassManager>()>&
         CreatePassManager) {
   std::shared_ptr<pir::PassManager> pass_manager = CreatePassManager();
-
   pass_manager->AddPass(cinn::dialect::ir::CreateAddStoreInGroupOpPass());
   pass_manager->AddPass(cinn::dialect::ir::CreateCinnGroupClusterPass());
 
diff --git a/paddle/cinn/hlir/framework/pir/trivial_op_impl.cc b/paddle/cinn/hlir/framework/pir/trivial_op_impl.cc
index efa5e48cf2d50f..ac70dc92962d79 100644
--- a/paddle/cinn/hlir/framework/pir/trivial_op_impl.cc
+++ b/paddle/cinn/hlir/framework/pir/trivial_op_impl.cc
@@ -603,20 +603,14 @@ std::vector<ir::Expr> OperationFusion(
                  ::common::errors::PreconditionNotMet(
                      "TrivialFusion must be used with tiling first, set "
                      "FLAGS_group_schedule_tiling_first=1"));
-  const auto& ops = trivial_fusion_detail::FilterVector(
-      original_ops, [](const ::pir::Operation* op) {
-        if (op->name() == "cinn_op.generate_shape") {
-          return false;
-        }
-        return true;
-      });
 
   const std::unordered_map<pir::Operation*, trivial_fusion_detail::FusibleOp>
       initialized_lowered_op;
   for (int i = 0; i < ops.size(); i++) {
-    initialized_lowered_op[ops[i]] = IsReduceBody(op_compute_bodies[i])
-                                         ? ReduceOp(op_compute_bodies[i])
-                                         : TrivialOp(op_compute_bodies[i]);
+    initialized_lowered_op[ops[i]] =
+        trivial_fusion_detail::IsReduceBody(op_compute_bodies[i])
+            ? ReduceOp(op_compute_bodies[i])
+            : TrivialOp(op_compute_bodies[i]);
   }
 
   auto interpreter =
diff --git a/paddle/cinn/hlir/framework/pir/trivial_op_impl.h b/paddle/cinn/hlir/framework/pir/trivial_op_impl.h
index 4d4c1860675f85..219ced0cde3f7c 100644
--- a/paddle/cinn/hlir/framework/pir/trivial_op_impl.h
+++ b/paddle/cinn/hlir/framework/pir/trivial_op_impl.h
@@ -162,6 +162,7 @@ FusibleOp SinkTrivialLoopAlign(TrivialOp trivial_op,
 std::vector<ir::Var> GetAllIterVars(const ir::Expr& expr);
 
 std::vector<ir::Var> GetAllForIters(const ir::Expr& expr);
+
 }  // namespace trivial_fusion_detail
 
 struct FusionGroupInfo {

From d16b61aab13f8a69534dfd36668b3f0443f34a61 Mon Sep 17 00:00:00 2001
From: feifei-111 <2364819892@qq.com>
Date: Thu, 13 Jun 2024 07:08:13 +0000
Subject: [PATCH 79/99] update

---
 .../hlir/framework/pir/op_lowering_group.h    |  8 ++--
 paddle/cinn/operator_fusion/CMakeLists.txt    |  2 +-
 paddle/cinn/operator_fusion/pattern.h         | 47 ++++++++-----------
 paddle/cinn/operator_fusion/pattern_fuser.h   | 28 +++++------
 .../pir_graph_analyzing/anchor_transform.cc   |  1 +
 .../pir_graph_analyzing/dim_relation.cc       |  1 +
 .../shardable_axes_base.cc                    |  1 +
 paddle/cinn/operator_fusion/utils.h           | 22 +++------
 8 files changed, 47 insertions(+), 63 deletions(-)

diff --git a/paddle/cinn/hlir/framework/pir/op_lowering_group.h b/paddle/cinn/hlir/framework/pir/op_lowering_group.h
index 7b5c350b820a4c..5d2165956fdd90 100644
--- a/paddle/cinn/hlir/framework/pir/op_lowering_group.h
+++ b/paddle/cinn/hlir/framework/pir/op_lowering_group.h
@@ -44,15 +44,15 @@ class OpLoweringGroup {
   OpLoweringGroup(OpLoweringGroup&&) = delete;
 
   explicit OpLoweringGroup(const std::vector<::pir::Operation*>& group_ops,
-                           const std::string& fn_name FusionTrackerPtr
-                               fusion_tracker_ptr)
+                           const std::string& fn_name,
+                           cinn::fusion::FusionTrackerPtr fusion_tracker_ptr)
       : ops_(group_ops),
         fn_name_(fn_name),
         fusion_tracker_ptr(fusion_tracker_ptr) {}
 
   explicit OpLoweringGroup(std::initializer_list<::pir::Operation*> group_ops,
                            const std::string& fn_name,
-                           FusionTrackerPtr fusion_tracker_ptr)
+                           cinn::fusion::FusionTrackerPtr fusion_tracker_ptr)
       : ops_(group_ops),
         fn_name_(fn_name),
         fusion_tracker_ptr(fusion_tracker_ptr) {}
@@ -228,7 +228,7 @@ class OpLoweringGroup {
       value_to_shape_or_data_exprs_;
 
  public:
-  FusionTrackerPtr fusion_tracker_ptr;
+  cinn::fusion::FusionTrackerPtr fusion_tracker_ptr;
 };
 
 std::ostream& operator<<(std::ostream& os, const OpLoweringGroup& group);
diff --git a/paddle/cinn/operator_fusion/CMakeLists.txt b/paddle/cinn/operator_fusion/CMakeLists.txt
index c4d5f4c1368cd3..a2dd9d2bfc4ee5 100644
--- a/paddle/cinn/operator_fusion/CMakeLists.txt
+++ b/paddle/cinn/operator_fusion/CMakeLists.txt
@@ -5,5 +5,5 @@ add_subdirectory(fusion_tracker)
 cc_library(
   op_fusion
   SRCS ${policy_fusion_src} ${fusion_graph_analyzing} ${fusion_tracker_src}
-       pattern_graph.cc
+       pattern_graph.cc utils.cc
   DEPS phi)
diff --git a/paddle/cinn/operator_fusion/pattern.h b/paddle/cinn/operator_fusion/pattern.h
index d5f9a216d0b8b5..8e0e2912577c97 100644
--- a/paddle/cinn/operator_fusion/pattern.h
+++ b/paddle/cinn/operator_fusion/pattern.h
@@ -34,6 +34,7 @@ struct PatternContent {
 
 struct StmtPattern;
 std::string GetPatternName(const StmtPattern& s);
+std::vector<pir::Operation*> GetOpsInPattern(const StmtPattern& pattern);
 
 struct TrivialPattern {
   explicit TrivialPattern(const std::vector<pir::Operation*>& ops,
@@ -120,8 +121,8 @@ struct ReduceTreePattern {
   void update_tracker() const {
     std::vector<std::string> tmp_names({GetRootPattern().name()});
     int count = 0;
-    const auto hook = [tracker = tracker_, &tmp_names, &count](
-                          const std::string& up, const std::string& down) {
+    auto hook = [tracker = tracker_, &tmp_names, &count](
+                    const std::string& up, const std::string& down) {
       std::string tmp_name = "tmp_" + std::to_string(count++);
       tracker->append(std::make_shared<TmpTransformInstr>(up, down, tmp_name));
       tmp_names.emplace_back(tmp_name);
@@ -132,7 +133,7 @@ struct ReduceTreePattern {
   }
 
   using Hook = std::function<void(const std::string&, const std::string&)>;
-  void recursive_call(const Hook& hook) {
+  void recursive_call(const Hook& hook) const {
     for (auto child : childs_) {
       hook(child.GetRootPattern().name(), GetRootPattern().name());
       child.recursive_call(hook);
@@ -178,10 +179,10 @@ struct ReduceTreePlusTrivialPattern {
                                             fake_reduce_iter_idx));
 
     int count = 0;
-    const auto hook = [tracker = tracker_,
-                       &tmp_names,
-                       fake_reduce = fake_reduce_iter_idx,
-                       &count](const std::string& up, const std::string& down) {
+    auto hook = [tracker = tracker_,
+                 &tmp_names,
+                 fake_reduce = fake_reduce_iter_idx,
+                 &count](const std::string& up, const std::string& down) {
       std::string tmp_name = "tmp_" + std::to_string(count++);
       tracker->append(
           std::make_shared<TmpTransformInstr>(up, down, tmp_name, fake_reduce));
@@ -330,20 +331,13 @@ struct UnsupportPattern {
   void update_tracker() const {}
 };
 
-using StmtPatternBase = std::variant<TrivialPattern,
-                                     ReducePattern,
-                                     ReduceTreePattern,
-                                     ReduceTreePlusTrivialPattern,
-                                     HorizontalFusionPattern,
-                                     UnsupportPattern,
-                                     AnchorPattern>;
-
-struct StmtPattern final : public StmtPatternBase {
-  using StmtPatternBase::StmtPatternBase;
-  const StmtPatternBase& variant() const {
-    return static_cast<const StmtPatternBase&>(*this);
-  }
-};
+using StmtPattern = std::variant<TrivialPattern,
+                                 ReducePattern,
+                                 ReduceTreePattern,
+                                 ReduceTreePlusTrivialPattern,
+                                 HorizontalFusionPattern,
+                                 UnsupportPattern,
+                                 AnchorPattern>;
 
 std::string StmtPatternDebugStr(const StmtPattern& stmt) {
   std::stringstream ss;
@@ -354,17 +348,15 @@ std::string StmtPatternDebugStr(const StmtPattern& stmt) {
 }
 
 std::string GetPatternName(const StmtPattern& s) {
-  return std::visit([](const auto& impl) { return impl.name(); }, s.variant());
+  return std::visit([](const auto& impl) { return impl.name(); }, s);
 }
 
 FusionTrackerPtr GetFusionTracker(const StmtPattern& s) {
-  return std::visit([](const auto& impl) { return impl.tracker_; },
-                    s.variant());
+  return std::visit([](const auto& impl) { return impl.tracker_; }, s);
 }
 
 std::vector<pir::Operation*> GetOpsInPattern(const StmtPattern& pattern) {
-  return std::visit([](const auto& impl) { return impl.ops(); },
-                    pattern.variant());
+  return std::visit([](const auto& impl) { return impl.ops(); }, pattern);
 }
 
 std::unordered_set<pir::Value> GetPatternInputValuesIncludeInner(
@@ -399,7 +391,6 @@ std::unordered_set<pir::Value> GetPatternInputValues(const StmtPattern& A) {
 }
 
 void PatternUpdateTracker(const StmtPattern& pattern) {
-  return std::visit([](const auto& impl) { impl.update_tracker(); },
-                    pattern.variant());
+  return std::visit([](const auto& impl) { impl.update_tracker(); }, pattern);
 }
 }  // namespace cinn::fusion
diff --git a/paddle/cinn/operator_fusion/pattern_fuser.h b/paddle/cinn/operator_fusion/pattern_fuser.h
index 3d2b8b8e34caf7..688e483ce72ebd 100644
--- a/paddle/cinn/operator_fusion/pattern_fuser.h
+++ b/paddle/cinn/operator_fusion/pattern_fuser.h
@@ -41,14 +41,16 @@ StmtPattern ConvertToStmtPattern(const PatternContent& content) {
   if (kind == hlir::framework::kReduction) {
     auto result =
         ReducePattern({content.op}, std::make_shared<FusionTracker>());
-    result.tracker_->append(std::make_shared<InitPatternInstr>(content.op));
+    result.tracker_->append(
+        std::make_shared<InitPatternInstr>(content.op, result.name()));
     return result;
   } else if (kind == hlir::framework::kElementWise ||
              kind == hlir::framework::kBroadcast ||
              kind == hlir::framework::kInjective) {
     auto result = TrivialPattern(
         {content.op}, content.op, std::make_shared<FusionTracker>());
-    result.tracker_->append(std::make_shared<InitPatternInstr>(content.op));
+    result.tracker_->append(
+        std::make_shared<InitPatternInstr>(content.op, result.name()));
     return result;
   } else {
     auto result =
@@ -190,7 +192,7 @@ std::vector<ExprPromise> InitExprPromise(const StmtPattern& pattern,
                                          pir::Value anchor) {
   return std::visit(
       [anchor](const auto& arg) { return InitExprPromiseImpl(arg, anchor); },
-      pattern.variant());
+      pattern);
 }
 
 StmtPattern MergePatternImpl(const AnchorPattern& source,
@@ -274,7 +276,7 @@ struct LoopFrameworkVisitor {
   }
 
   MaybeLoopFramework operator()(const ReduceTreePattern& pattern) {
-    return GetLoopFramework(StmtPattern(pattern.GetRootPattern()));
+    return GetLoopFramework(pattern.GetRootPattern());
   }
 
   MaybeLoopFramework operator()(const TrivialPattern& pattern) {
@@ -287,7 +289,7 @@ struct LoopFrameworkVisitor {
     // Horizontal Fusion must have the same loop framework.
     VLOG(4) << "Get horizontal fusion pattern for loop framework.";
     const auto& base_exprs =
-        GetLoopFramework(StmtPattern(pattern.padding_patterns_.back().pattern));
+        GetLoopFramework(pattern.padding_patterns_.back().pattern);
     const auto& padding_vector = pattern.padding_patterns_.back().padding_pos;
     std::vector<symbol::DimExpr> exprs(
         base_exprs.size() + padding_vector.size(), 1);
@@ -303,14 +305,12 @@ struct LoopFrameworkVisitor {
 
   MaybeLoopFramework operator()(const ReduceTreePlusTrivialPattern& pattern) {
     const auto& sink_trivial = pattern.sink_trivial;
-    const auto& trivial_loop =
-        GetLoopFramework(StmtPattern(pattern.sink_trivial));
+    const auto& trivial_loop = GetLoopFramework(pattern.sink_trivial);
     if (pattern.fake_reduce_iter_idx.empty()) {
       // we add reduce loop to the end;
       int reduce_axes_len =
           GetReduceAxisIdx(pattern.tree.GetRootPattern().GetReduceOp()).size();
-      const auto& reduce_loop =
-          GetLoopFramework(StmtPattern(pattern.tree.GetRootPattern()));
+      const auto& reduce_loop = GetLoopFramework(pattern.tree.GetRootPattern());
       return ConcatVector(
           trivial_loop,
           SliceVector(reduce_loop, -reduce_axes_len, reduce_loop.size()));
@@ -336,7 +336,7 @@ struct LoopFrameworkVisitor {
 };
 
 MaybeLoopFramework GetLoopFramework(const StmtPattern& pattern) {
-  return std::visit(LoopFrameworkVisitor(), pattern.variant());
+  return std::visit(LoopFrameworkVisitor(), pattern);
 }
 
 inline auto GetPaddingVector(const MaybeLoopFramework& first,
@@ -380,8 +380,8 @@ inline auto GetPaddingVector(const MaybeLoopFramework& first,
 
 StmtPattern MergePatternImpl(const HorizontalFusionPattern& first,
                              const HorizontalFusionPattern& second) {
-  const auto& [f, s] = GetPaddingVector(GetLoopFramework(StmtPattern(first)),
-                                        GetLoopFramework(StmtPattern(second)));
+  const auto& [f, s] =
+      GetPaddingVector(GetLoopFramework(first), GetLoopFramework(second));
   typename HorizontalFusionPattern::PaddingStmtPattern pad_first = {first, f};
   typename HorizontalFusionPattern::PaddingStmtPattern pad_second = {second, s};
   return HorizontalFusionPattern(
@@ -428,7 +428,7 @@ StmtPattern MergePattern(const StmtPattern& first, const StmtPattern& second) {
                      << "X" << GetPatternName(second);
       },
   };
-  return std::visit(PatternMatch, first.variant(), second.variant());
+  return std::visit(PatternMatch, first, second);
 }
 
 void SetReturnInstr(const StmtPattern& s) {
@@ -436,7 +436,7 @@ void SetReturnInstr(const StmtPattern& s) {
       [](const auto& impl) {
         impl.tracker_->append(std::make_shared<ReturnInstr>(impl.name()));
       },
-      s.variant());
+      s);
 }
 
 }  // namespace cinn::fusion
diff --git a/paddle/cinn/operator_fusion/pir_graph_analyzing/anchor_transform.cc b/paddle/cinn/operator_fusion/pir_graph_analyzing/anchor_transform.cc
index e30cf085cc35fd..ee7f328347798f 100644
--- a/paddle/cinn/operator_fusion/pir_graph_analyzing/anchor_transform.cc
+++ b/paddle/cinn/operator_fusion/pir_graph_analyzing/anchor_transform.cc
@@ -13,6 +13,7 @@
 // limitations under the License.
 
 #include "paddle/cinn/operator_fusion/pir_graph_analyzing/anchor_transform.h"
+#include "paddle/cinn/hlir/dialect/operator/ir/cinn_op.h"
 
 namespace cinn::fusion {
 
diff --git a/paddle/cinn/operator_fusion/pir_graph_analyzing/dim_relation.cc b/paddle/cinn/operator_fusion/pir_graph_analyzing/dim_relation.cc
index 60ebca4dcf2b72..4486e2bde82011 100644
--- a/paddle/cinn/operator_fusion/pir_graph_analyzing/dim_relation.cc
+++ b/paddle/cinn/operator_fusion/pir_graph_analyzing/dim_relation.cc
@@ -13,6 +13,7 @@
 // limitations under the License.
 
 #include "paddle/cinn/operator_fusion/pir_graph_analyzing/dim_relation.h"
+#include "paddle/cinn/hlir/dialect/operator/ir/cinn_op.h"
 
 #include "paddle/common/enforce.h"
 
diff --git a/paddle/cinn/operator_fusion/pir_graph_analyzing/shardable_axes_base.cc b/paddle/cinn/operator_fusion/pir_graph_analyzing/shardable_axes_base.cc
index acc508617fcdd0..394b99da488287 100644
--- a/paddle/cinn/operator_fusion/pir_graph_analyzing/shardable_axes_base.cc
+++ b/paddle/cinn/operator_fusion/pir_graph_analyzing/shardable_axes_base.cc
@@ -13,6 +13,7 @@
 // limitations under the License.
 
 #include "paddle/cinn/operator_fusion/pir_graph_analyzing/shardable_axes_base.h"
+#include "paddle/cinn/hlir/dialect/operator/ir/cinn_op.h"
 #include "paddle/common/enforce.h"
 
 namespace cinn::fusion {
diff --git a/paddle/cinn/operator_fusion/utils.h b/paddle/cinn/operator_fusion/utils.h
index 0031c640089c42..76b8516cab2886 100644
--- a/paddle/cinn/operator_fusion/utils.h
+++ b/paddle/cinn/operator_fusion/utils.h
@@ -27,11 +27,14 @@
 #include <vector>
 
 #include "glog/logging.h"
-#include "paddle/cinn/hlir/dialect/operator/ir/cinn_op.h"
-#include "paddle/cinn/hlir/dialect/operator/ir/manual_op.h"
 #include "paddle/cinn/hlir/framework/op.h"
+#include "paddle/cinn/hlir/framework/pir/utils.h"
 #include "paddle/cinn/utils/string.h"
+#include "paddle/common/enforce.h"
+#include "paddle/pir/include/core/builtin_attribute.h"
+#include "paddle/pir/include/core/builtin_type.h"
 #include "paddle/pir/include/dialect/control_flow/ir/cf_op.h"
+#include "paddle/pir/include/dialect/shape/utils/shape_analysis.h"
 
 namespace cinn::fusion {
 
@@ -89,20 +92,7 @@ static bool GetReduceOpKeepDims(pir::Operation* reduce_op) {
 }
 
 static std::optional<std::pair<pir::Value, pir::Value>>
-GetBroadcastOpInputOuputValue(pir::Operation* op) {
-  auto* mut_op = const_cast<pir::Operation*>(op);
-  if (op->isa<paddle::dialect::ExpandOp>()) {
-    auto expand_op = mut_op->dyn_cast<paddle::dialect::ExpandOp>();
-    return std::make_pair(expand_op.x(), expand_op.out());
-  } else if (op->isa<cinn::dialect::BroadcastOp>()) {
-    auto broadcast_op = mut_op->dyn_cast<cinn::dialect::BroadcastOp>();
-    return std::make_pair(broadcast_op.x(), broadcast_op.out());
-  } else {
-    PADDLE_THROW(
-        phi::errors::Unimplemented("Unsupported broadcast op, %s", op->name()));
-  }
-  return std::nullopt;
-}
+GetBroadcastOpInputOuputValue(pir::Operation* op);
 
 static std::vector<std::pair<size_t, size_t>> GetNonBroadCastDims(
     pir::Operation* op) {

From c31811211bb32e86dd8a8d18631c633afce0f3d6 Mon Sep 17 00:00:00 2001
From: feifei-111 <2364819892@qq.com>
Date: Tue, 18 Jun 2024 08:47:07 +0000
Subject: [PATCH 80/99] fix compile err

---
 .../graph_transformer/operation.h             |  16 +-
 .../graph_transformer/search_algorithm.h      |   1 +
 paddle/cinn/operator_fusion/pattern.h         | 185 ++++++++++--------
 paddle/cinn/operator_fusion/pattern_fuser.h   |  15 +-
 paddle/cinn/operator_fusion/pattern_node.h    |   1 +
 .../pir_graph_analyzing/anchor_transform.h    |   6 +-
 paddle/cinn/operator_fusion/utils.h           |   1 +
 7 files changed, 126 insertions(+), 99 deletions(-)

diff --git a/paddle/cinn/operator_fusion/graph_transformer/operation.h b/paddle/cinn/operator_fusion/graph_transformer/operation.h
index ecd20be4f6dbdb..938f9e51bf6c6a 100644
--- a/paddle/cinn/operator_fusion/graph_transformer/operation.h
+++ b/paddle/cinn/operator_fusion/graph_transformer/operation.h
@@ -50,7 +50,7 @@ struct MergeTrivialPatternOperation {
                 << downstream->DebugStr() << "\nmerged "
                 << merged_node->DebugStr();
         merged_node->AppendInstr(std::make_shared<TrivialInlineInstr>(
-            upstream->name(), downstream->name(), merged_node->name()));
+            upstream->id(), downstream->id(), merged_node->id()));
       } else {
         upstream->AddNodeToDownstream(downstream);
       }
@@ -115,33 +115,33 @@ struct MergeReduceTreeAndTrivialOperation {
 
 struct LiftReduceToReduceTreeOperation {
   PatternNodePtr operator()(PatternGraph* graph, PatternNodePtr node) {
-    auto origin_name = node->name();
+    auto origin_name = node->id();
     const auto& reduce_pattern = std::get<ReducePattern>(node->stmt_pattern());
     node->set_stmt_pattern(ReduceTreePattern(
         {},
         reduce_pattern,
         std::make_shared<FusionTracker>(reduce_pattern.tracker_)));
-    node->AppendInstr(std::make_shared<CopyInstr>(origin_name, node->name()));
+    node->AppendInstr(std::make_shared<CopyInstr>(origin_name, node->id()));
     return node;
   }
 };
 
 struct LiftToHorizontalFusionPatternOperation {
   PatternNodePtr operator()(PatternGraph* graph, PatternNodePtr node) {
-    auto origin_name = node->name();
+    auto origin_name = node->id();
     node->set_stmt_pattern(HorizontalFusionPattern(
         {typename HorizontalFusionPattern::PaddingStmtPattern(
             node->stmt_pattern(), {})},
         std::make_shared<FusionTracker>(
             GetFusionTracker(node->stmt_pattern()))));
-    node->AppendInstr(std::make_shared<CopyInstr>(origin_name, node->name()));
+    node->AppendInstr(std::make_shared<CopyInstr>(origin_name, node->id()));
     return node;
   }
 };
 
 struct LiftToAnchorPatternOperation {
   PatternNodePtr operator()(PatternGraph* graph, PatternNodePtr node) {
-    auto origin_name = node->name();
+    auto origin_name = node->id();
     std::vector<pir::Operation*> ops = GetOpsInPattern(node->stmt_pattern());
     // TODO(@wuzhanfei) move sink_op into pattern (currently, part of pattern
     // type has sink and the others not) then, update logic here
@@ -256,11 +256,11 @@ struct FuseDownstreamAnchorOperation {
 
 struct SplitRecomputeOperation {
   void operator()(PatternGraph* graph, PatternNodePtr upstream) {
-    auto origin_name = upstream->name();
+    auto origin_name = upstream->id();
     upstream->set_stmt_pattern(RecoverAnchorPatternToTrivial(
         std::get<AnchorPattern>(upstream->stmt_pattern())));
     upstream->AppendInstr(
-        std::make_shared<CopyInstr>(origin_name, upstream->name()));
+        std::make_shared<CopyInstr>(origin_name, upstream->id()));
     MergeTrivialPatternOperation()(graph, upstream);
   }
 };
diff --git a/paddle/cinn/operator_fusion/graph_transformer/search_algorithm.h b/paddle/cinn/operator_fusion/graph_transformer/search_algorithm.h
index 910c5c8a9b0399..f85722345321db 100644
--- a/paddle/cinn/operator_fusion/graph_transformer/search_algorithm.h
+++ b/paddle/cinn/operator_fusion/graph_transformer/search_algorithm.h
@@ -13,6 +13,7 @@
 // limitations under the License.
 
 #pragma once
+#include <queue>
 #include "paddle/cinn/operator_fusion/pattern_graph.h"
 
 namespace cinn::fusion {
diff --git a/paddle/cinn/operator_fusion/pattern.h b/paddle/cinn/operator_fusion/pattern.h
index 8e0e2912577c97..3bec13dca77d0c 100644
--- a/paddle/cinn/operator_fusion/pattern.h
+++ b/paddle/cinn/operator_fusion/pattern.h
@@ -32,29 +32,27 @@ struct PatternContent {
   bool operator==(const PatternContent& other) const { return op == other.op; }
 };
 
-struct StmtPattern;
-std::string GetPatternName(const StmtPattern& s);
-std::vector<pir::Operation*> GetOpsInPattern(const StmtPattern& pattern);
-
 struct TrivialPattern {
   explicit TrivialPattern(const std::vector<pir::Operation*>& ops,
                           pir::Operation* sink_op,
                           const FusionTrackerPtr& tracker)
       : ops_(ops), sink_op_(sink_op), tracker_(tracker) {
-    name_ = UniqueName();
+    id_ = UniqueId();
   }
   std::vector<pir::Operation*> ops_;
   pir::Operation* sink_op_;
   std::vector<pir::Operation*> ops() const { return ops_; }
   pir::Operation* sink_op() const { return sink_op_; }
 
-  static std::string UniqueName() {
+  static std::string name() { return "Trivial"; }
+
+  static std::string UniqueId() {
     static std::atomic<int64_t> counter = 0;
     counter += 1;
-    return "T_" + std::to_string(counter);
+    return name() + "_" + std::to_string(counter);
   }
-  std::string name() const { return name_; }
-  std::string name_;
+  std::string id() const { return id_; }
+  std::string id_;
 
   FusionTrackerPtr tracker_;
   void update_tracker() const {}
@@ -64,19 +62,21 @@ struct ReducePattern {
   explicit ReducePattern(const std::vector<pir::Operation*>& ops,
                          const FusionTrackerPtr& tracker)
       : ops_(ops), tracker_(tracker) {
-    name_ = UniqueName();
+    id_ = UniqueId();
   }
   std::vector<pir::Operation*> ops_;
   std::vector<pir::Operation*> ops() const { return ops_; }
   pir::Operation* GetReduceOp() const { return ops_.back(); }
 
-  static std::string UniqueName() {
+  static std::string name() { return "Reduce"; }
+
+  static std::string UniqueId() {
     static std::atomic<int64_t> counter = 0;
     counter += 1;
-    return "T_" + std::to_string(counter);
+    return name() + "_" + std::to_string(counter);
   }
-  std::string name() const { return name_; }
-  std::string name_;
+  std::string id() const { return id_; }
+  std::string id_;
 
   FusionTrackerPtr tracker_;
   void update_tracker() const {}
@@ -87,7 +87,7 @@ struct ReduceTreePattern {
                              const ReducePattern& root,
                              const FusionTrackerPtr& tracker)
       : childs_(childs), root_(root), tracker_(tracker) {
-    name_ = UniqueName();
+    id_ = UniqueId();
   }
   const ReducePattern& GetRootPattern() const { return root_; }
   std::vector<pir::Operation*> ops() const {
@@ -108,18 +108,20 @@ struct ReduceTreePattern {
     return result;
   }
 
-  static std::string UniqueName() {
+  static std::string name() { return "ReduceTree"; }
+
+  static std::string UniqueId() {
     static std::atomic<int64_t> counter = 0;
     counter += 1;
-    return "RTree_" + std::to_string(counter);
+    return name() + "_" + std::to_string(counter);
   }
-  std::string name() const { return name_; }
-  std::string name_;
+  std::string id() const { return id_; }
+  std::string id_;
 
   FusionTrackerPtr tracker_;
 
   void update_tracker() const {
-    std::vector<std::string> tmp_names({GetRootPattern().name()});
+    std::vector<std::string> tmp_names({GetRootPattern().id()});
     int count = 0;
     auto hook = [tracker = tracker_, &tmp_names, &count](
                     const std::string& up, const std::string& down) {
@@ -129,13 +131,13 @@ struct ReduceTreePattern {
     };
     recursive_call(hook);
 
-    tracker_->append(std::make_shared<CombineInstr>(tmp_names, name()));
+    tracker_->append(std::make_shared<CombineInstr>(tmp_names, id()));
   }
 
   using Hook = std::function<void(const std::string&, const std::string&)>;
   void recursive_call(const Hook& hook) const {
     for (auto child : childs_) {
-      hook(child.GetRootPattern().name(), GetRootPattern().name());
+      hook(child.GetRootPattern().id(), GetRootPattern().id());
       child.recursive_call(hook);
     }
   }
@@ -150,7 +152,7 @@ struct ReduceTreePlusTrivialPattern {
                                         const TrivialPattern& sink_trivial,
                                         const FusionTrackerPtr& tracker)
       : tree(tree), sink_trivial(sink_trivial), tracker_(tracker) {
-    name_ = UniqueName();
+    id_ = UniqueId();
   }
   ReduceTreePattern tree;
   TrivialPattern sink_trivial;
@@ -159,23 +161,25 @@ struct ReduceTreePlusTrivialPattern {
   }
   std::vector<size_t> fake_reduce_iter_idx;
 
-  static std::string UniqueName() {
+  static std::string name() { return "ReduceTreePlusTrivial"; }
+
+  static std::string UniqueId() {
     static std::atomic<int64_t> counter = 0;
     counter += 1;
-    return "RTreeT_" + std::to_string(counter);
+    return name() + "_" + std::to_string(counter);
   }
-  std::string name() const { return name_; }
-  std::string name_;
+  std::string id() const { return id_; }
+  std::string id_;
 
   FusionTrackerPtr tracker_;
 
   void update_tracker() const {
     std::vector<std::string> tmp_names(
-        {sink_trivial.name(), tree.GetRootPattern().name()});
+        {sink_trivial.id(), tree.GetRootPattern().id()});
     tracker_->append(
-        std::make_shared<TmpTransformInstr>(tree.GetRootPattern().name(),
-                                            sink_trivial.name(),
-                                            tree.GetRootPattern().name(),
+        std::make_shared<TmpTransformInstr>(tree.GetRootPattern().id(),
+                                            sink_trivial.id(),
+                                            tree.GetRootPattern().id(),
                                             fake_reduce_iter_idx));
 
     int count = 0;
@@ -192,12 +196,12 @@ struct ReduceTreePlusTrivialPattern {
     tree.recursive_call(hook);
 
     tracker_->append(
-        std::make_shared<TrivialLoopAlignInstr>(tree.GetRootPattern().name(),
-                                                sink_trivial.name(),
-                                                sink_trivial.name(),
+        std::make_shared<TrivialLoopAlignInstr>(tree.GetRootPattern().id(),
+                                                sink_trivial.id(),
+                                                sink_trivial.id(),
                                                 fake_reduce_iter_idx));
 
-    tracker_->append(std::make_shared<CombineInstr>(tmp_names, name()));
+    tracker_->append(std::make_shared<CombineInstr>(tmp_names, id()));
   }
 };
 
@@ -210,7 +214,7 @@ struct AnchorPattern {
         anchor_(anchor),
         anchor_state(init_anchor_state),
         tracker_(tracker) {
-    name_ = UniqueName();
+    id_ = UniqueId();
   }
   AnchorState anchor_state;
 
@@ -237,13 +241,15 @@ struct AnchorPattern {
     return true;
   }
 
-  static std::string UniqueName() {
+  static std::string name() { return "Anchor"; }
+
+  static std::string UniqueId() {
     static std::atomic<int64_t> counter = 0;
     counter += 1;
-    return "Anchor_" + std::to_string(counter);
+    return name() + "_" + std::to_string(counter);
   }
-  std::string name() const { return name_; }
-  std::string name_;
+  std::string id() const { return id_; }
+  std::string id_;
 
   FusionTrackerPtr tracker_;
   void update_tracker() const {
@@ -253,9 +259,9 @@ struct AnchorPattern {
       std::string tmp_name = "tmp_" + std::to_string(i);
       tmp_names.emplace_back(tmp_name);
       tracker_->append(std::make_shared<AnchorTransformInstr>(
-          promise.name_, tmp_name, promise.transform_route));
+          promise.id_, tmp_name, promise.transform_route));
     }
-    tracker_->append(std::make_shared<CombineInstr>(tmp_names, name()));
+    tracker_->append(std::make_shared<CombineInstr>(tmp_names, id()));
   }
 
  private:
@@ -264,50 +270,26 @@ struct AnchorPattern {
 };
 
 struct HorizontalFusionPattern {
-  struct PaddingStmtPattern {
-    StmtPattern pattern;
-    std::vector<int> padding_pos;
-    PaddingStmtPattern(const StmtPattern& pattern,
-                       const std::vector<int>& padding_pos)
-        : pattern(pattern), padding_pos(padding_pos) {}
-  };
+  struct PaddingStmtPattern;
   explicit HorizontalFusionPattern(
       const std::vector<PaddingStmtPattern>& patterns,
       const FusionTrackerPtr& tracker)
       : padding_patterns_(patterns), tracker_(tracker) {
-    name_ = UniqueName();
+    id_ = UniqueId();
   }
   std::vector<PaddingStmtPattern> padding_patterns_;
-  std::vector<pir::Operation*> ops() const {
-    std::vector<pir::Operation*> result;
-    for (const auto& pattern : padding_patterns_) {
-      auto ops = GetOpsInPattern(pattern.pattern);
-      ExtendVector(&result, ops);
-    }
-    return result;
-  }
+  std::vector<pir::Operation*> ops() const;
+
+  static std::string name() { return "Horizontal"; }
 
-  static std::string UniqueName() {
+  static std::string UniqueId() {
     static std::atomic<int64_t> counter = 0;
     counter += 1;
-    return "Horizontal_" + std::to_string(counter);
-  }
-  std::string name() const { return name_; }
-  std::string name_;
-  void update_tracker() const {
-    std::vector<std::string> tmp_names;
-    for (int i = 0; i < padding_patterns_.size(); i++) {
-      auto padding_pattern = padding_patterns_[i];
-      std::string tmp_name = "tmp_" + std::to_string(i);
-      tmp_names.emplace_back(tmp_name);
-      tracker_->append(std::make_shared<PaddingInstr>(
-          GetPatternName(padding_pattern.pattern),
-          tmp_name,
-          padding_pattern.padding_pos));
-    }
-    tracker_->append(std::make_shared<CombineInstr>(tmp_names, name()));
+    return name() + "_" + std::to_string(counter);
   }
-
+  std::string id() const { return id_; }
+  std::string id_;
+  void update_tracker() const;
   FusionTrackerPtr tracker_;
 };
 
@@ -315,17 +297,20 @@ struct UnsupportPattern {
   explicit UnsupportPattern(const std::vector<pir::Operation*>& ops,
                             const FusionTrackerPtr& tracker)
       : ops_(ops), tracker_(tracker) {
-    name_ = UniqueName();
+    id_ = UniqueId();
   }
   std::vector<pir::Operation*> ops_;
   std::vector<pir::Operation*> ops() const { return ops_; }
-  static std::string UniqueName() {
+
+  static std::string name() { return "Unsupport"; }
+
+  static std::string UniqueId() {
     static std::atomic<int64_t> counter = 0;
     counter += 1;
-    return "Unsupport_" + std::to_string(counter);
+    return name() + "_" + std::to_string(counter);
   }
-  std::string name() const { return name_; }
-  std::string name_;
+  std::string id() const { return id_; }
+  std::string id_;
 
   FusionTrackerPtr tracker_;
   void update_tracker() const {}
@@ -339,6 +324,40 @@ using StmtPattern = std::variant<TrivialPattern,
                                  UnsupportPattern,
                                  AnchorPattern>;
 
+std::string GetPatternId(const StmtPattern& s);
+std::vector<pir::Operation*> GetOpsInPattern(const StmtPattern& pattern);
+
+struct HorizontalFusionPattern::PaddingStmtPattern {
+  StmtPattern pattern;
+  std::vector<int> padding_pos;
+  PaddingStmtPattern(const StmtPattern& pattern,
+                     const std::vector<int>& padding_pos)
+      : pattern(pattern), padding_pos(padding_pos) {}
+};
+
+void HorizontalFusionPattern::update_tracker() const {
+  std::vector<std::string> tmp_names;
+  for (int i = 0; i < padding_patterns_.size(); i++) {
+    auto padding_pattern = padding_patterns_[i];
+    std::string tmp_name = "tmp_" + std::to_string(i);
+    tmp_names.emplace_back(tmp_name);
+    tracker_->append(
+        std::make_shared<PaddingInstr>(GetPatternId(padding_pattern.pattern),
+                                       tmp_name,
+                                       padding_pattern.padding_pos));
+  }
+  tracker_->append(std::make_shared<CombineInstr>(tmp_names, id()));
+}
+
+std::vector<pir::Operation*> HorizontalFusionPattern::ops() const {
+  std::vector<pir::Operation*> result;
+  for (const auto& pattern : padding_patterns_) {
+    auto ops = GetOpsInPattern(pattern.pattern);
+    ExtendVector(&result, ops);
+  }
+  return result;
+}
+
 std::string StmtPatternDebugStr(const StmtPattern& stmt) {
   std::stringstream ss;
   auto all_ops = GetOpsInPattern(stmt);
@@ -351,6 +370,10 @@ std::string GetPatternName(const StmtPattern& s) {
   return std::visit([](const auto& impl) { return impl.name(); }, s);
 }
 
+std::string GetPatternId(const StmtPattern& s) {
+  return std::visit([](const auto& impl) { return impl.id(); }, s);
+}
+
 FusionTrackerPtr GetFusionTracker(const StmtPattern& s) {
   return std::visit([](const auto& impl) { return impl.tracker_; }, s);
 }
diff --git a/paddle/cinn/operator_fusion/pattern_fuser.h b/paddle/cinn/operator_fusion/pattern_fuser.h
index 688e483ce72ebd..636f36c890a28f 100644
--- a/paddle/cinn/operator_fusion/pattern_fuser.h
+++ b/paddle/cinn/operator_fusion/pattern_fuser.h
@@ -42,7 +42,7 @@ StmtPattern ConvertToStmtPattern(const PatternContent& content) {
     auto result =
         ReducePattern({content.op}, std::make_shared<FusionTracker>());
     result.tracker_->append(
-        std::make_shared<InitPatternInstr>(content.op, result.name()));
+        std::make_shared<InitPatternInstr>(content.op, result.id()));
     return result;
   } else if (kind == hlir::framework::kElementWise ||
              kind == hlir::framework::kBroadcast ||
@@ -50,12 +50,13 @@ StmtPattern ConvertToStmtPattern(const PatternContent& content) {
     auto result = TrivialPattern(
         {content.op}, content.op, std::make_shared<FusionTracker>());
     result.tracker_->append(
-        std::make_shared<InitPatternInstr>(content.op, result.name()));
+        std::make_shared<InitPatternInstr>(content.op, result.id()));
     return result;
   } else {
     auto result =
         UnsupportPattern({content.op}, std::make_shared<FusionTracker>());
-    result.tracker_->append(std::make_shared<InitPatternInstr>(content.op));
+    result.tracker_->append(
+        std::make_shared<InitPatternInstr>(content.op, result.id()));
     return result;
   }
 }
@@ -166,12 +167,12 @@ StmtPattern MergePatternImpl(const ReduceTreePattern& first,
 // Anchor Fusion
 std::vector<ExprPromise> InitExprPromiseImpl(const TrivialPattern& pattern,
                                              pir::Value anchor) {
-  return {ExprPromise(anchor, pattern.name())};
+  return {ExprPromise(anchor, pattern.id())};
 }
 
 std::vector<ExprPromise> InitExprPromiseImpl(const ReducePattern& pattern,
                                              pir::Value anchor) {
-  return {ExprPromise(anchor, pattern.name())};
+  return {ExprPromise(anchor, pattern.id())};
 }
 
 std::vector<ExprPromise> InitExprPromiseImpl(const ReduceTreePattern& pattern,
@@ -179,7 +180,7 @@ std::vector<ExprPromise> InitExprPromiseImpl(const ReduceTreePattern& pattern,
   // TODO(@wuzhanfei) this is temporary
   // now we do not support anchor fusion for reduce op,
   // so, this is ok currently. but need to be redesigned later
-  return {ExprPromise(anchor, pattern.name())};
+  return {ExprPromise(anchor, pattern.id())};
 }
 
 template <typename PATTERN>
@@ -434,7 +435,7 @@ StmtPattern MergePattern(const StmtPattern& first, const StmtPattern& second) {
 void SetReturnInstr(const StmtPattern& s) {
   std::visit(
       [](const auto& impl) {
-        impl.tracker_->append(std::make_shared<ReturnInstr>(impl.name()));
+        impl.tracker_->append(std::make_shared<ReturnInstr>(impl.id()));
       },
       s);
 }
diff --git a/paddle/cinn/operator_fusion/pattern_node.h b/paddle/cinn/operator_fusion/pattern_node.h
index 7e461fe37f8e96..d93ee069980f0a 100644
--- a/paddle/cinn/operator_fusion/pattern_node.h
+++ b/paddle/cinn/operator_fusion/pattern_node.h
@@ -64,6 +64,7 @@ struct PatternNode {
   const std::vector<PatternNodePtr>& upstream() const { return upstream_; }
   const std::vector<PatternNodePtr>& downstream() const { return downstream_; }
   const std::string& name() const { return GetPatternName(stmt_pattern_); }
+  const std::string& id() const { return GetPatternId(stmt_pattern_); }
   void set_return() const { SetReturnInstr(stmt_pattern_); }
   void AddNodeToUpstream(PatternNodePtr node) { upstream_.push_back(node); }
   void AddNodeToDownstream(PatternNodePtr node) { downstream_.push_back(node); }
diff --git a/paddle/cinn/operator_fusion/pir_graph_analyzing/anchor_transform.h b/paddle/cinn/operator_fusion/pir_graph_analyzing/anchor_transform.h
index 6bd690abf1fe2e..8a2acb39f59795 100644
--- a/paddle/cinn/operator_fusion/pir_graph_analyzing/anchor_transform.h
+++ b/paddle/cinn/operator_fusion/pir_graph_analyzing/anchor_transform.h
@@ -118,11 +118,11 @@ using AnchorTransformRoute = std::vector<AnchorTransform>;
 std::string DebugStrOfAnchorTransformRoute(const AnchorTransformRoute& route);
 
 struct ExprPromise {
-  explicit ExprPromise(const pir::Value& root, const std::string& name)
-      : root_value(root), name_(name) {}
+  explicit ExprPromise(const pir::Value& root, const std::string& id)
+      : root_value(root), id_(id) {}
   AnchorTransformRoute transform_route;
   pir::Value root_value;
-  std::string name_;
+  std::string id_;
 
   void update(const AnchorTransformRoute& route) {
     transform_route.insert(transform_route.end(), route.begin(), route.end());
diff --git a/paddle/cinn/operator_fusion/utils.h b/paddle/cinn/operator_fusion/utils.h
index 76b8516cab2886..b035480cdbc2c8 100644
--- a/paddle/cinn/operator_fusion/utils.h
+++ b/paddle/cinn/operator_fusion/utils.h
@@ -31,6 +31,7 @@
 #include "paddle/cinn/hlir/framework/pir/utils.h"
 #include "paddle/cinn/utils/string.h"
 #include "paddle/common/enforce.h"
+#include "paddle/phi/core/enforce.h"
 #include "paddle/pir/include/core/builtin_attribute.h"
 #include "paddle/pir/include/core/builtin_type.h"
 #include "paddle/pir/include/dialect/control_flow/ir/cf_op.h"

From e8c30aef00170fce011e492c3a9ad3af9f394b68 Mon Sep 17 00:00:00 2001
From: feifei-111 <2364819892@qq.com>
Date: Tue, 18 Jun 2024 09:47:31 +0000
Subject: [PATCH 81/99] update

---
 .../hlir/framework/pir/op_lowering_group.cc   |  3 +-
 .../hlir/framework/pir/trivial_op_impl.cc     | 23 +++---
 .../cinn/hlir/framework/pir/trivial_op_impl.h |  3 +-
 .../fusion_tracker/expr_utils.cc              | 70 -------------------
 .../fusion_tracker/interpreter.cc             | 28 ++++----
 .../fusion_tracker/interpreter.h              |  6 --
 6 files changed, 31 insertions(+), 102 deletions(-)

diff --git a/paddle/cinn/hlir/framework/pir/op_lowering_group.cc b/paddle/cinn/hlir/framework/pir/op_lowering_group.cc
index e23ec953431c0d..89cd4b242ba69f 100644
--- a/paddle/cinn/hlir/framework/pir/op_lowering_group.cc
+++ b/paddle/cinn/hlir/framework/pir/op_lowering_group.cc
@@ -147,7 +147,8 @@ std::shared_ptr<OpLoweringGroup> OpLoweringGroup::Clone(
 
   const auto new_fn_name = this->fn_name_ + "_cloned";
   // Construct Base information for new Group
-  auto new_group = std::make_shared<OpLoweringGroup>(new_ops, new_fn_name);
+  auto new_group = std::make_shared<OpLoweringGroup>(
+      new_ops, new_fn_name, this->fusion_tracker_ptr);
   for (auto* op : this->output_ops_) {
     new_group->output_ops_.insert(ops_mapper.at(op));
   }
diff --git a/paddle/cinn/hlir/framework/pir/trivial_op_impl.cc b/paddle/cinn/hlir/framework/pir/trivial_op_impl.cc
index ac70dc92962d79..7d8fed3f68e373 100644
--- a/paddle/cinn/hlir/framework/pir/trivial_op_impl.cc
+++ b/paddle/cinn/hlir/framework/pir/trivial_op_impl.cc
@@ -14,9 +14,8 @@
 
 #include "paddle/cinn/hlir/framework/pir/trivial_op_impl.h"
 #include <variant>
-#include "paddle/cinn/operator_fusion/backend/pattern.h"
-#include "paddle/cinn/operator_fusion/backend/pattern_fuser.h"
 #include "paddle/cinn/operator_fusion/group_cluster.h"
+#include "paddle/cinn/operator_fusion/pattern.h"
 
 #include "paddle/cinn/hlir/dialect/operator/ir/manual_op.h"
 #include "paddle/cinn/hlir/framework/compile_error.h"
@@ -346,7 +345,7 @@ int GetTensorCounter() {
 std::vector<FusibleOp> TransformReduceLoopRange(
     const ReduceOp& upstream,
     FusibleOp* downstream,
-    std::vector<size_t> fake_reduce_iter_idx) {
+    const std::vector<size_t>& fake_reduce_iter_idx) {
   // downstream will be mutated by this transform.
   VLOG(4) << "RRTransform begin";
   VLOG(4) << "RRTransform Upstream is \n" << _GetRootExpr(upstream);
@@ -598,23 +597,25 @@ std::vector<ir::Var> GetAllForIters(const ir::Expr& expr) {
 std::vector<ir::Expr> OperationFusion(
     const std::vector<::pir::Operation*>& ops,
     const std::vector<ir::Expr>& op_compute_bodies,
-    FusionTrackerPtr fusion_tracker_ptr) {
+    cinn::fusion::FusionTrackerPtr fusion_tracker_ptr) {
   PADDLE_ENFORCE(FLAGS_group_schedule_tiling_first,
                  ::common::errors::PreconditionNotMet(
                      "TrivialFusion must be used with tiling first, set "
                      "FLAGS_group_schedule_tiling_first=1"));
 
-  const std::unordered_map<pir::Operation*, trivial_fusion_detail::FusibleOp>
+  std::unordered_map<::pir::Operation*, trivial_fusion_detail::FusibleOp>
       initialized_lowered_op;
   for (int i = 0; i < ops.size(); i++) {
     initialized_lowered_op[ops[i]] =
         trivial_fusion_detail::IsReduceBody(op_compute_bodies[i])
-            ? ReduceOp(op_compute_bodies[i])
-            : TrivialOp(op_compute_bodies[i]);
+            ? trivial_fusion_detail::FusibleOp(
+                  trivial_fusion_detail::ReduceOp(op_compute_bodies[i]))
+            : trivial_fusion_detail::FusibleOp(
+                  trivial_fusion_detail::TrivialOp(op_compute_bodies[i]));
   }
 
-  auto interpreter =
-      FusionInterpreter(fusion_tracker_ptr, initialized_lowered_op);
+  auto interpreter = cinn::fusion::FusionInterpreter(fusion_tracker_ptr,
+                                                     initialized_lowered_op);
   auto output = interpreter.Run();
 
   VLOG(4) << "Fusion Result: output size is " << output.size();
@@ -628,11 +629,11 @@ FusionGroupInfo GetFusionGroupInfo(
     const std::vector<ir::Expr>& op_compute_bodies) {
   using trivial_fusion_detail::AppendBound;
   using trivial_fusion_detail::GetAllForIters;
+  using trivial_fusion_detail::IsReduceBody;
   using trivial_fusion_detail::ReduceOp;
   using trivial_fusion_detail::ComposeUtils::ConcatVector;
-  using trivial_fusion_detail::IsReduceBody
 
-      FusionGroupInfo group_info = FusionGroupInfo();
+  FusionGroupInfo group_info = FusionGroupInfo();
 
   for (const auto& body : op_compute_bodies) {
     if (IsReduceBody(body)) {
diff --git a/paddle/cinn/hlir/framework/pir/trivial_op_impl.h b/paddle/cinn/hlir/framework/pir/trivial_op_impl.h
index 219ced0cde3f7c..cd6dc72efaf45b 100644
--- a/paddle/cinn/hlir/framework/pir/trivial_op_impl.h
+++ b/paddle/cinn/hlir/framework/pir/trivial_op_impl.h
@@ -29,6 +29,7 @@
 #include "paddle/cinn/ir/schedule/ir_schedule.h"
 #include "paddle/cinn/ir/schedule/ir_schedule_util.h"
 #include "paddle/cinn/lang/placeholder.h"
+#include "paddle/cinn/operator_fusion/fusion_tracker/interpreter.h"
 #include "paddle/cinn/operator_fusion/pattern_graph.h"
 #include "paddle/cinn/optim/schedule_block_dce.h"
 #include "paddle/cinn/optim/transform_gpu_forloop.h"
@@ -183,7 +184,7 @@ FusionGroupInfo GetFusionGroupInfo(
 std::vector<ir::Expr> OperationFusion(
     const std::vector<::pir::Operation*>& ops,
     const std::vector<ir::Expr>& op_compute_bodies,
-    FusionTrackerPtr fusion_tracker_ptr);
+    cinn::fusion::FusionTrackerPtr fusion_tracker_ptr);
 
 }  // namespace pir
 }  // namespace framework
diff --git a/paddle/cinn/operator_fusion/fusion_tracker/expr_utils.cc b/paddle/cinn/operator_fusion/fusion_tracker/expr_utils.cc
index 966b0dd3801ca6..324623d6298a8e 100644
--- a/paddle/cinn/operator_fusion/fusion_tracker/expr_utils.cc
+++ b/paddle/cinn/operator_fusion/fusion_tracker/expr_utils.cc
@@ -127,58 +127,6 @@ std::vector<ir::Expr> TopoSort(const std::vector<ir::Expr>& op_exprs) {
   return sorted_result;
 }
 
-/// Start: Tmp Transform Operation for ReduceTree
-std::vector<FusibleOp> ReduceTransformRecursive(
-    ReduceOp reduce_op,
-    const ReduceTreePattern<BackendStage>& reduce_tree_pattern,
-    const std::vector<size_t>& fake_reduce_iter_idx = {}) {
-  FusibleOp root_op = reduce_op;
-  VLOG(4) << "ReduceTransformRecursive: " << *_GetFuncBodyPointer(root_op);
-  std::vector<FusibleOp> result;
-  for (const auto& child_tree : reduce_tree_pattern.childs()) {
-    const auto& child_reduce_op = child_tree.GetRootPattern().reduce_op;
-    auto transformed_nodes = cinn::hlir::framework::pir::trivial_fusion_detail::
-        TransformReduceLoopRange(
-            child_reduce_op, &root_op, fake_reduce_iter_idx);
-    for (auto& node : transformed_nodes) {
-      auto child_flatten =
-          ReduceTransformRecursive(std::get<ReduceOp>(node), child_tree);
-      result.insert(result.end(), child_flatten.begin(), child_flatten.end());
-    }
-  }
-  result.push_back(root_op);
-  VLOG(4) << "ReduceTransformRecursive: End";
-  return result;
-}
-
-std::vector<FusibleOp> ReduceTreeTrivialTransformRecursive(
-    TrivialOp trivial_op,
-    const ReduceTreePlusTrivialPattern<BackendStage>& rt_pattern) {
-  FusibleOp root_op = trivial_op;
-  VLOG(4) << "ReduceTrivialTransformRecursive: "
-          << *_GetFuncBodyPointer(root_op);
-  std::vector<FusibleOp> result;
-
-  const auto& child_tree = rt_pattern.tree;
-  const auto& child_reduce_op = child_tree.GetRootPattern().reduce_op;
-  auto transformed_nodes = cinn::hlir::framework::pir::trivial_fusion_detail::
-      TransformReduceLoopRange(
-          child_reduce_op, &root_op, rt_pattern.fake_reduce_iter_idx);
-  for (auto& node : transformed_nodes) {
-    auto child_flatten = ReduceTransformRecursive(
-        std::get<ReduceOp>(node), child_tree, rt_pattern.fake_reduce_iter_idx);
-    result.insert(result.end(), child_flatten.begin(), child_flatten.end());
-  }
-  //}
-  result.push_back(
-      cinn::hlir::framework::pir::trivial_fusion_detail::SinkTrivialLoopAlign(
-          std::get<TrivialOp>(root_op),
-          rt_pattern.tree.GetRootPattern().reduce_op,
-          rt_pattern.fake_reduce_iter_idx));
-  VLOG(4) << "ReduceTrivialTransformRecursive End;";
-  return result;
-}
-
 static std::vector<ir::Var> GetAllForIters(const ir::Expr& expr) {
   using cinn::hlir::framework::pir::trivial_fusion_detail::ExprSetFinderUtils::
       ChildFors;
@@ -275,22 +223,4 @@ std::vector<FusibleOp> DoPadding(const FusibleOp& fusion_op,
   return results;
 }
 
-struct IrExprGetter {
-  std::vector<ir::Expr> operator()(
-      const HorizontalFusionPattern<BackendStage>& pattern) {
-    std::vector<ir::Expr> result;
-    VLOG(4) << "Get Fusion Ops from HorizontalFusionPattern: "
-            << pattern.padding_patterns_.size();
-    for (const auto& sub_pattern : pattern.padding_patterns_) {
-      std::function<ir::Expr(ir::Expr)> func =
-          [&sub_pattern](const ir::Expr& expr) {
-            return UnSqueezeExpr(expr, sub_pattern.padding_pos);
-          };
-      result = ConcatVector(
-          result, MapVector(GetExprFromPattern(sub_pattern.pattern), func));
-    }
-    return result;
-  }
-};
-
 }  // namespace cinn::fusion
diff --git a/paddle/cinn/operator_fusion/fusion_tracker/interpreter.cc b/paddle/cinn/operator_fusion/fusion_tracker/interpreter.cc
index 6fb3fefa333672..bb64c4b7974f4c 100644
--- a/paddle/cinn/operator_fusion/fusion_tracker/interpreter.cc
+++ b/paddle/cinn/operator_fusion/fusion_tracker/interpreter.cc
@@ -14,10 +14,8 @@
 
 #pragma once
 
-#include "glog/logging.h"
-
-#include "paddle/cinn/operator_fusion/fusion_tracker/expr_utils.h"
 #include "paddle/cinn/operator_fusion/fusion_tracker/interpreter.h"
+#include "glog/logging.h"
 
 namespace cinn::fusion {
 
@@ -30,15 +28,14 @@ void RunCopyInstr(const std::shared_ptr<CopyInstr>& instr,
 
 void RunCombineInstr(const std::shared_ptr<CombineInstr>& instr,
                      FusionInterpreter* interpreter) {
-  interpreter->scope[instr->result_] = CombineScopeElement(
-      interpreter->scope[instr->first_], interpreter->scope[instr->second_]);
+  // TODO(@wuzhanfei)
 }
 
 void RunInitPatternInstr(const std::shared_ptr<InitPatternInstr>& instr,
                          FusionInterpreter* interpreter) {
   ScopeElementPtr new_pattern = std::make_shared<ScopeElement>();
   new_pattern->fusion_ops.emplace_back(
-      (interpreter->initialized_lowered_op)[instr->op_]);
+      interpreter->initialized_lowered_op.at(instr->op_));
   interpreter->scope[instr->result_] = new_pattern;
 }
 
@@ -48,11 +45,16 @@ void RunTrivialInlineInstr(const std::shared_ptr<TrivialInlineInstr>& instr,
   auto upstream_op = std::get<TrivialOp>(
       interpreter->scope[instr->upstream_]->fusion_ops.front());
   ScopeElementPtr new_pattern = std::make_shared<ScopeElement>();
+
+  auto DoTrivialFusion = [upstream_op](const auto& downstream_op) -> FusibleOp {
+    return cinn::hlir::framework::pir::trivial_fusion_detail::
+        TrivalxOther_Fusion(upstream_op, downstream_op);
+  };
+
   for (auto downstream_op :
        interpreter->scope[instr->downstream_]->fusion_ops) {
     new_pattern->fusion_ops.emplace_back(
-        cinn::hlir::framework::pir::trivial_fusion_detail::TrivalxOther_Fusion(
-            upstream_op, downstream_op));
+        std::visit(DoTrivialFusion, downstream_op));
   }
   interpreter->scope[instr->result_] = new_pattern;
 }
@@ -67,10 +69,9 @@ void RunTmpTransformInstr(const std::shared_ptr<TmpTransformInstr>& instr,
   auto downstream_op =
       interpreter->scope[instr->downstream_]->fusion_ops.front();
   ScopeElementPtr new_pattern = std::make_shared<ScopeElement>();
-  new_pattern->fusion_ops.emplace_back(
-      cinn::hlir::framework::pir::trivial_fusion_detail::
-          TransformReduceLoopRange(
-              upstream_op, &downstream_op, instr->fake_reduce_iter_idx_););
+  new_pattern->fusion_ops = cinn::hlir::framework::pir::trivial_fusion_detail::
+      TransformReduceLoopRange(
+          upstream_op, &downstream_op, instr->fake_reduce_iter_idx_);
   interpreter->scope[instr->result_] = new_pattern;
 }
 
@@ -108,7 +109,8 @@ void RunAnchorTransformInstr(const std::shared_ptr<AnchorTransformInstr>& instr,
       FusibleOp2Expr(), interpreter->scope[instr->target_]->fusion_ops.front());
   for (auto expr : candidate_exprs) {
     auto transformed_expr = do_transform(expr);
-    if (IsReduceBody(transformed_expr)) {
+    if (cinn::hlir::framework::pir::trivial_fusion_detail::IsReduceBody(
+            transformed_expr)) {
       new_pattern->fusion_ops.emplace_back(ReduceOp(transformed_expr));
     } else {
       new_pattern->fusion_ops.emplace_back(TrivialOp(transformed_expr));
diff --git a/paddle/cinn/operator_fusion/fusion_tracker/interpreter.h b/paddle/cinn/operator_fusion/fusion_tracker/interpreter.h
index 30f187ea3f9ff3..61a0a877e1b496 100644
--- a/paddle/cinn/operator_fusion/fusion_tracker/interpreter.h
+++ b/paddle/cinn/operator_fusion/fusion_tracker/interpreter.h
@@ -32,12 +32,6 @@ struct ScopeElement {
 };
 using ScopeElementPtr = std::shared_ptr<ScopeElement>;
 
-ScopeElementPtr CombineScopeElement(const ScopeElementPtr& a,
-                                    const ScopeElementPtr& b) {
-  return std::make_shared<ScopeElement>(
-      ConcatVector(a->fusion_ops, b->fusion_ops));
-}
-
 struct FusionInterpreter {
   FusionInterpreter(const FusionTrackerPtr& tracker,
                     const std::unordered_map<pir::Operation*, FusibleOp>&

From 5d0b5b658245360abf9e7d860191c926b8f7b7b6 Mon Sep 17 00:00:00 2001
From: feifei-111 <2364819892@qq.com>
Date: Tue, 18 Jun 2024 09:49:21 +0000
Subject: [PATCH 82/99] update

---
 paddle/cinn/operator_fusion/utils.cc | 37 ++++++++++++++++++++++++++++
 1 file changed, 37 insertions(+)
 create mode 100644 paddle/cinn/operator_fusion/utils.cc

diff --git a/paddle/cinn/operator_fusion/utils.cc b/paddle/cinn/operator_fusion/utils.cc
new file mode 100644
index 00000000000000..074cda8678137a
--- /dev/null
+++ b/paddle/cinn/operator_fusion/utils.cc
@@ -0,0 +1,37 @@
+// Copyright (c) 2024 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.
+
+#include "paddle/cinn/operator_fusion/utils.h"
+#include "paddle/cinn/hlir/dialect/operator/ir/cinn_op.h"
+#include "paddle/cinn/hlir/dialect/operator/ir/manual_op.h"
+
+namespace cinn::fusion {
+
+std::optional<std::pair<pir::Value, pir::Value>> GetBroadcastOpInputOuputValue(
+    pir::Operation* op) {
+  auto* mut_op = const_cast<pir::Operation*>(op);
+  if (op->isa<paddle::dialect::ExpandOp>()) {
+    auto expand_op = mut_op->dyn_cast<paddle::dialect::ExpandOp>();
+    return std::make_pair(expand_op.x(), expand_op.out());
+  } else if (op->isa<cinn::dialect::BroadcastOp>()) {
+    auto broadcast_op = mut_op->dyn_cast<cinn::dialect::BroadcastOp>();
+    return std::make_pair(broadcast_op.x(), broadcast_op.out());
+  } else {
+    PADDLE_THROW(
+        phi::errors::Unimplemented("Unsupported broadcast op, %s", op->name()));
+  }
+  return std::nullopt;
+}
+
+}  // namespace cinn::fusion

From 5f102127d78adddcaf4d5d0f7b06ff7d1ff5aa2d Mon Sep 17 00:00:00 2001
From: feifei-111 <2364819892@qq.com>
Date: Wed, 19 Jun 2024 08:34:39 +0000
Subject: [PATCH 83/99] fix compile err

---
 .../transforms/cinn_group_cluster_pass.cc     |  2 +-
 .../hlir/framework/pir/op_lowering_impl.cc    |  1 +
 .../hlir/framework/pir/trivial_op_impl.cc     | 33 +-------
 .../cinn/hlir/framework/pir/trivial_op_impl.h |  6 --
 .../cinn/hlir/framework/pir/trivial_op_util.h |  2 +-
 paddle/cinn/operator_fusion/CMakeLists.txt    |  2 +-
 .../{group_cluster.h => cluster_interface.h}  |  0
 .../cinn/operator_fusion/fusion_interface.cc  | 49 +++++++++++
 .../cinn/operator_fusion/fusion_interface.h   | 27 ++++++
 paddle/cinn/operator_fusion/pattern.h         | 32 ++++----
 paddle/cinn/operator_fusion/pattern_fuser.h   | 82 ++++++++++---------
 .../shardable_axes_base.cc                    |  6 +-
 paddle/cinn/operator_fusion/utils.h           | 13 +--
 13 files changed, 147 insertions(+), 108 deletions(-)
 rename paddle/cinn/operator_fusion/{group_cluster.h => cluster_interface.h} (100%)
 create mode 100644 paddle/cinn/operator_fusion/fusion_interface.cc
 create mode 100644 paddle/cinn/operator_fusion/fusion_interface.h

diff --git a/paddle/cinn/hlir/dialect/operator/transforms/cinn_group_cluster_pass.cc b/paddle/cinn/hlir/dialect/operator/transforms/cinn_group_cluster_pass.cc
index fcef5d6018f63f..55a8b592619222 100644
--- a/paddle/cinn/hlir/dialect/operator/transforms/cinn_group_cluster_pass.cc
+++ b/paddle/cinn/hlir/dialect/operator/transforms/cinn_group_cluster_pass.cc
@@ -33,7 +33,7 @@
 #include "paddle/cinn/hlir/dialect/operator/ir/manual_op.h"
 #include "paddle/cinn/hlir/dialect/operator/transforms/group_merge/op_with_group_merge_util.h"
 #include "paddle/cinn/hlir/framework/pir/utils.h"
-#include "paddle/cinn/operator_fusion/group_cluster.h"
+#include "paddle/cinn/operator_fusion/cluster_interface.h"
 #include "paddle/common/ddim.h"
 #include "paddle/common/flags.h"
 #include "paddle/fluid/pir/dialect/operator/ir/manual_op.h"
diff --git a/paddle/cinn/hlir/framework/pir/op_lowering_impl.cc b/paddle/cinn/hlir/framework/pir/op_lowering_impl.cc
index 5a41b63bf4a711..dd3ccc4f064823 100644
--- a/paddle/cinn/hlir/framework/pir/op_lowering_impl.cc
+++ b/paddle/cinn/hlir/framework/pir/op_lowering_impl.cc
@@ -36,6 +36,7 @@
 #include "paddle/cinn/ir/ir_analyzer/ir_analyzer.h"
 #include "paddle/cinn/ir/schedule/ir_schedule.h"
 #include "paddle/cinn/lang/placeholder.h"
+#include "paddle/cinn/operator_fusion/fusion_interface.h"
 #include "paddle/cinn/optim/eliminate_common_global_memory_read.h"
 #include "paddle/cinn/optim/if_fusion.h"
 #include "paddle/cinn/optim/rearrange_load_instruction.h"
diff --git a/paddle/cinn/hlir/framework/pir/trivial_op_impl.cc b/paddle/cinn/hlir/framework/pir/trivial_op_impl.cc
index 7d8fed3f68e373..36d3cdd3afb36f 100644
--- a/paddle/cinn/hlir/framework/pir/trivial_op_impl.cc
+++ b/paddle/cinn/hlir/framework/pir/trivial_op_impl.cc
@@ -14,7 +14,7 @@
 
 #include "paddle/cinn/hlir/framework/pir/trivial_op_impl.h"
 #include <variant>
-#include "paddle/cinn/operator_fusion/group_cluster.h"
+#include "paddle/cinn/operator_fusion/cluster_interface.h"
 #include "paddle/cinn/operator_fusion/pattern.h"
 
 #include "paddle/cinn/hlir/dialect/operator/ir/manual_op.h"
@@ -594,37 +594,6 @@ std::vector<ir::Var> GetAllForIters(const ir::Expr& expr) {
 
 }  // namespace trivial_fusion_detail
 
-std::vector<ir::Expr> OperationFusion(
-    const std::vector<::pir::Operation*>& ops,
-    const std::vector<ir::Expr>& op_compute_bodies,
-    cinn::fusion::FusionTrackerPtr fusion_tracker_ptr) {
-  PADDLE_ENFORCE(FLAGS_group_schedule_tiling_first,
-                 ::common::errors::PreconditionNotMet(
-                     "TrivialFusion must be used with tiling first, set "
-                     "FLAGS_group_schedule_tiling_first=1"));
-
-  std::unordered_map<::pir::Operation*, trivial_fusion_detail::FusibleOp>
-      initialized_lowered_op;
-  for (int i = 0; i < ops.size(); i++) {
-    initialized_lowered_op[ops[i]] =
-        trivial_fusion_detail::IsReduceBody(op_compute_bodies[i])
-            ? trivial_fusion_detail::FusibleOp(
-                  trivial_fusion_detail::ReduceOp(op_compute_bodies[i]))
-            : trivial_fusion_detail::FusibleOp(
-                  trivial_fusion_detail::TrivialOp(op_compute_bodies[i]));
-  }
-
-  auto interpreter = cinn::fusion::FusionInterpreter(fusion_tracker_ptr,
-                                                     initialized_lowered_op);
-  auto output = interpreter.Run();
-
-  VLOG(4) << "Fusion Result: output size is " << output.size();
-  for (const auto& expr : output) {
-    VLOG(4) << expr;
-  }
-  return output;
-}
-
 FusionGroupInfo GetFusionGroupInfo(
     const std::vector<ir::Expr>& op_compute_bodies) {
   using trivial_fusion_detail::AppendBound;
diff --git a/paddle/cinn/hlir/framework/pir/trivial_op_impl.h b/paddle/cinn/hlir/framework/pir/trivial_op_impl.h
index cd6dc72efaf45b..2d883572d29e17 100644
--- a/paddle/cinn/hlir/framework/pir/trivial_op_impl.h
+++ b/paddle/cinn/hlir/framework/pir/trivial_op_impl.h
@@ -29,7 +29,6 @@
 #include "paddle/cinn/ir/schedule/ir_schedule.h"
 #include "paddle/cinn/ir/schedule/ir_schedule_util.h"
 #include "paddle/cinn/lang/placeholder.h"
-#include "paddle/cinn/operator_fusion/fusion_tracker/interpreter.h"
 #include "paddle/cinn/operator_fusion/pattern_graph.h"
 #include "paddle/cinn/optim/schedule_block_dce.h"
 #include "paddle/cinn/optim/transform_gpu_forloop.h"
@@ -181,11 +180,6 @@ struct FusionGroupInfo {
 FusionGroupInfo GetFusionGroupInfo(
     const std::vector<ir::Expr>& op_compute_bodies);
 
-std::vector<ir::Expr> OperationFusion(
-    const std::vector<::pir::Operation*>& ops,
-    const std::vector<ir::Expr>& op_compute_bodies,
-    cinn::fusion::FusionTrackerPtr fusion_tracker_ptr);
-
 }  // namespace pir
 }  // namespace framework
 }  // namespace hlir
diff --git a/paddle/cinn/hlir/framework/pir/trivial_op_util.h b/paddle/cinn/hlir/framework/pir/trivial_op_util.h
index 4a4b54ab4cdfa5..c0e7f0d9ac34f3 100644
--- a/paddle/cinn/hlir/framework/pir/trivial_op_util.h
+++ b/paddle/cinn/hlir/framework/pir/trivial_op_util.h
@@ -264,7 +264,7 @@ bool IsTrivialKind(OpPatternKind kind);
 void CheckFusionInputValid(const std::vector<ir::Expr>& op_compute_bodies,
                            const std::vector<OpPatternKind>& op_patterns);
 
-bool IsReduceBody(const ir::Expr& expr_body) {
+static bool IsReduceBody(const ir::Expr& expr_body) {
   return !(ExprSetFinderUtils::ChildScheduleBlockRealizes *
            ExprSetFinderUtils::ScheduleBlockRealizeIsInit)(expr_body)
               .empty();
diff --git a/paddle/cinn/operator_fusion/CMakeLists.txt b/paddle/cinn/operator_fusion/CMakeLists.txt
index a2dd9d2bfc4ee5..ce25ca1d0a7e19 100644
--- a/paddle/cinn/operator_fusion/CMakeLists.txt
+++ b/paddle/cinn/operator_fusion/CMakeLists.txt
@@ -5,5 +5,5 @@ add_subdirectory(fusion_tracker)
 cc_library(
   op_fusion
   SRCS ${policy_fusion_src} ${fusion_graph_analyzing} ${fusion_tracker_src}
-       pattern_graph.cc utils.cc
+       pattern_graph.cc utils.cc fusion_interface.cc
   DEPS phi)
diff --git a/paddle/cinn/operator_fusion/group_cluster.h b/paddle/cinn/operator_fusion/cluster_interface.h
similarity index 100%
rename from paddle/cinn/operator_fusion/group_cluster.h
rename to paddle/cinn/operator_fusion/cluster_interface.h
diff --git a/paddle/cinn/operator_fusion/fusion_interface.cc b/paddle/cinn/operator_fusion/fusion_interface.cc
new file mode 100644
index 00000000000000..beda76c06a7a00
--- /dev/null
+++ b/paddle/cinn/operator_fusion/fusion_interface.cc
@@ -0,0 +1,49 @@
+// Copyright (c) 2024 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/cinn/operator_fusion/fusion_interface.h"
+#include "paddle/cinn/operator_fusion/fusion_tracker/expr_utils.h"
+#include "paddle/cinn/operator_fusion/fusion_tracker/interpreter.h"
+#include "paddle/cinn/operator_fusion/utils.h"
+
+namespace cinn::fusion {
+
+std::vector<ir::Expr> OperationFusion(
+    const std::vector<::pir::Operation*>& ops,
+    const std::vector<ir::Expr>& op_compute_bodies,
+    FusionTrackerPtr fusion_tracker_ptr) {
+  std::unordered_map<::pir::Operation*, FusibleOp> initialized_lowered_op;
+  for (int i = 0; i < ops.size(); i++) {
+    auto fusible_op =
+        cinn::hlir::framework::pir::trivial_fusion_detail::IsReduceBody(
+            op_compute_bodies[i])
+            ? FusibleOp(ReduceOp(op_compute_bodies[i]))
+            : FusibleOp(TrivialOp(op_compute_bodies[i]));
+    initialized_lowered_op.emplace(std::make_pair(ops[i], fusible_op));
+  }
+
+  auto interpreter =
+      FusionInterpreter(fusion_tracker_ptr, initialized_lowered_op);
+  auto output = interpreter.Run();
+
+  VLOG(4) << "Fusion Result: output size is " << output.size();
+  for (const auto& expr : output) {
+    VLOG(4) << expr;
+  }
+  return output;
+}
+
+}  // namespace cinn::fusion
diff --git a/paddle/cinn/operator_fusion/fusion_interface.h b/paddle/cinn/operator_fusion/fusion_interface.h
new file mode 100644
index 00000000000000..ab9a3fbbd22395
--- /dev/null
+++ b/paddle/cinn/operator_fusion/fusion_interface.h
@@ -0,0 +1,27 @@
+// Copyright (c) 2024 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/cinn/operator_fusion/fusion_tracker/tracker.h"
+#include "paddle/cinn/operator_fusion/utils.h"
+
+namespace cinn::fusion {
+
+std::vector<ir::Expr> OperationFusion(
+    const std::vector<::pir::Operation*>& ops,
+    const std::vector<ir::Expr>& op_compute_bodies,
+    FusionTrackerPtr fusion_tracker_ptr);
+
+}
diff --git a/paddle/cinn/operator_fusion/pattern.h b/paddle/cinn/operator_fusion/pattern.h
index 3bec13dca77d0c..bdf18e4165cab3 100644
--- a/paddle/cinn/operator_fusion/pattern.h
+++ b/paddle/cinn/operator_fusion/pattern.h
@@ -278,7 +278,7 @@ struct HorizontalFusionPattern {
     id_ = UniqueId();
   }
   std::vector<PaddingStmtPattern> padding_patterns_;
-  std::vector<pir::Operation*> ops() const;
+  inline std::vector<pir::Operation*> ops() const;
 
   static std::string name() { return "Horizontal"; }
 
@@ -289,7 +289,7 @@ struct HorizontalFusionPattern {
   }
   std::string id() const { return id_; }
   std::string id_;
-  void update_tracker() const;
+  inline void update_tracker() const;
   FusionTrackerPtr tracker_;
 };
 
@@ -324,8 +324,8 @@ using StmtPattern = std::variant<TrivialPattern,
                                  UnsupportPattern,
                                  AnchorPattern>;
 
-std::string GetPatternId(const StmtPattern& s);
-std::vector<pir::Operation*> GetOpsInPattern(const StmtPattern& pattern);
+static std::string GetPatternId(const StmtPattern& s);
+static std::vector<pir::Operation*> GetOpsInPattern(const StmtPattern& pattern);
 
 struct HorizontalFusionPattern::PaddingStmtPattern {
   StmtPattern pattern;
@@ -335,7 +335,7 @@ struct HorizontalFusionPattern::PaddingStmtPattern {
       : pattern(pattern), padding_pos(padding_pos) {}
 };
 
-void HorizontalFusionPattern::update_tracker() const {
+inline void HorizontalFusionPattern::update_tracker() const {
   std::vector<std::string> tmp_names;
   for (int i = 0; i < padding_patterns_.size(); i++) {
     auto padding_pattern = padding_patterns_[i];
@@ -349,7 +349,7 @@ void HorizontalFusionPattern::update_tracker() const {
   tracker_->append(std::make_shared<CombineInstr>(tmp_names, id()));
 }
 
-std::vector<pir::Operation*> HorizontalFusionPattern::ops() const {
+inline std::vector<pir::Operation*> HorizontalFusionPattern::ops() const {
   std::vector<pir::Operation*> result;
   for (const auto& pattern : padding_patterns_) {
     auto ops = GetOpsInPattern(pattern.pattern);
@@ -358,7 +358,7 @@ std::vector<pir::Operation*> HorizontalFusionPattern::ops() const {
   return result;
 }
 
-std::string StmtPatternDebugStr(const StmtPattern& stmt) {
+static std::string StmtPatternDebugStr(const StmtPattern& stmt) {
   std::stringstream ss;
   auto all_ops = GetOpsInPattern(stmt);
   ss << "StmtPattern, size " << all_ops.size() << " :\n";
@@ -366,23 +366,24 @@ std::string StmtPatternDebugStr(const StmtPattern& stmt) {
   return ss.str();
 }
 
-std::string GetPatternName(const StmtPattern& s) {
+static std::string GetPatternName(const StmtPattern& s) {
   return std::visit([](const auto& impl) { return impl.name(); }, s);
 }
 
-std::string GetPatternId(const StmtPattern& s) {
+static std::string GetPatternId(const StmtPattern& s) {
   return std::visit([](const auto& impl) { return impl.id(); }, s);
 }
 
-FusionTrackerPtr GetFusionTracker(const StmtPattern& s) {
+static FusionTrackerPtr GetFusionTracker(const StmtPattern& s) {
   return std::visit([](const auto& impl) { return impl.tracker_; }, s);
 }
 
-std::vector<pir::Operation*> GetOpsInPattern(const StmtPattern& pattern) {
+static std::vector<pir::Operation*> GetOpsInPattern(
+    const StmtPattern& pattern) {
   return std::visit([](const auto& impl) { return impl.ops(); }, pattern);
 }
 
-std::unordered_set<pir::Value> GetPatternInputValuesIncludeInner(
+static std::unordered_set<pir::Value> GetPatternInputValuesIncludeInner(
     const StmtPattern& A) {
   std::unordered_set<pir::Value> result;
   for (const auto& op : GetOpsInPattern(A)) {
@@ -393,7 +394,7 @@ std::unordered_set<pir::Value> GetPatternInputValuesIncludeInner(
   return result;
 }
 
-std::unordered_set<pir::Value> GetPatternOutputValuesIncludedInner(
+static std::unordered_set<pir::Value> GetPatternOutputValuesIncludedInner(
     const StmtPattern& A) {
   std::unordered_set<pir::Value> result;
   for (const auto& op : GetOpsInPattern(A)) {
@@ -404,7 +405,8 @@ std::unordered_set<pir::Value> GetPatternOutputValuesIncludedInner(
   return result;
 }
 
-std::unordered_set<pir::Value> GetPatternInputValues(const StmtPattern& A) {
+static std::unordered_set<pir::Value> GetPatternInputValues(
+    const StmtPattern& A) {
   auto all_input_values = GetPatternInputValuesIncludeInner(A);
   for (const auto& value : GetPatternOutputValuesIncludedInner(A)) {
     all_input_values.erase(value);
@@ -413,7 +415,7 @@ std::unordered_set<pir::Value> GetPatternInputValues(const StmtPattern& A) {
   return all_input_values;
 }
 
-void PatternUpdateTracker(const StmtPattern& pattern) {
+static void PatternUpdateTracker(const StmtPattern& pattern) {
   return std::visit([](const auto& impl) { impl.update_tracker(); }, pattern);
 }
 }  // namespace cinn::fusion
diff --git a/paddle/cinn/operator_fusion/pattern_fuser.h b/paddle/cinn/operator_fusion/pattern_fuser.h
index 636f36c890a28f..6eb5182e022360 100644
--- a/paddle/cinn/operator_fusion/pattern_fuser.h
+++ b/paddle/cinn/operator_fusion/pattern_fuser.h
@@ -36,7 +36,7 @@
 
 namespace cinn::fusion {
 
-StmtPattern ConvertToStmtPattern(const PatternContent& content) {
+static StmtPattern ConvertToStmtPattern(const PatternContent& content) {
   const auto& kind = GetOpPatternKind(content.op);
   if (kind == hlir::framework::kReduction) {
     auto result =
@@ -63,8 +63,8 @@ StmtPattern ConvertToStmtPattern(const PatternContent& content) {
 
 // Trivial x other
 
-StmtPattern MergePatternImpl(const TrivialPattern& first,
-                             const TrivialPattern& second) {
+static StmtPattern MergePatternImpl(const TrivialPattern& first,
+                                    const TrivialPattern& second) {
   const auto& contents =
       UniqueConcatVector(GetOpsInPattern(first), GetOpsInPattern(second));
   return TrivialPattern(
@@ -73,8 +73,8 @@ StmtPattern MergePatternImpl(const TrivialPattern& first,
       std::make_shared<FusionTracker>(first.tracker_, second.tracker_));
 }
 
-StmtPattern MergePatternImpl(const TrivialPattern& first,
-                             const ReducePattern& second) {
+static StmtPattern MergePatternImpl(const TrivialPattern& first,
+                                    const ReducePattern& second) {
   const auto& contents =
       UniqueConcatVector(GetOpsInPattern(first), GetOpsInPattern(second));
   return ReducePattern(
@@ -93,8 +93,8 @@ B FusePatternIfConnected(A up_pattern,
   }
 }
 
-StmtPattern MergePatternImpl(const TrivialPattern& first,
-                             const ReduceTreePattern& second) {
+static StmtPattern MergePatternImpl(const TrivialPattern& first,
+                                    const ReduceTreePattern& second) {
   auto connect_ops = FindDownstreamOps(first.sink_op());
 
   auto old_childs = second.childs();
@@ -110,8 +110,8 @@ StmtPattern MergePatternImpl(const TrivialPattern& first,
       std::make_shared<FusionTracker>(first.tracker_, second.tracker_));
 }
 
-StmtPattern MergePatternImpl(const TrivialPattern& first,
-                             const ReduceTreePlusTrivialPattern& second) {
+static StmtPattern MergePatternImpl(
+    const TrivialPattern& first, const ReduceTreePlusTrivialPattern& second) {
   auto connect_ops = FindDownstreamOps(first.sink_op());
   return ReduceTreePlusTrivialPattern(
       FusePatternIfConnected(first, second.tree, connect_ops),
@@ -119,8 +119,8 @@ StmtPattern MergePatternImpl(const TrivialPattern& first,
       std::make_shared<FusionTracker>(first.tracker_, second.tracker_));
 }
 
-StmtPattern MergePatternImpl(const TrivialPattern& first,
-                             const AnchorPattern& second) {
+static StmtPattern MergePatternImpl(const TrivialPattern& first,
+                                    const AnchorPattern& second) {
   return AnchorPattern(
       UniqueConcatVector(GetOpsInPattern(first), GetOpsInPattern(second)),
       second.anchor(),
@@ -130,8 +130,8 @@ StmtPattern MergePatternImpl(const TrivialPattern& first,
 
 // RR & RT
 
-int InsertDownstreamIntoTree(const ReduceTreePattern& upstream,
-                             ReduceTreePattern& downstream) {  // NOLINT
+static int InsertDownstreamIntoTree(const ReduceTreePattern& upstream,
+                                    ReduceTreePattern& downstream) {  // NOLINT
   if (IsDirectUpstream(upstream.GetRootPattern().GetReduceOp(),
                        downstream.GetRootPattern().GetReduceOp())) {
     downstream.InsertChild(upstream);
@@ -144,8 +144,8 @@ int InsertDownstreamIntoTree(const ReduceTreePattern& upstream,
   return insert_num;
 }
 
-StmtPattern MergePatternImpl(const ReduceTreePattern& upstream,
-                             const ReduceTreePattern& downstream) {
+static StmtPattern MergePatternImpl(const ReduceTreePattern& upstream,
+                                    const ReduceTreePattern& downstream) {
   ReduceTreePattern result = ReduceTreePattern(
       downstream.childs(),
       downstream.GetRootPattern(),
@@ -156,8 +156,8 @@ StmtPattern MergePatternImpl(const ReduceTreePattern& upstream,
   return result;
 }
 
-StmtPattern MergePatternImpl(const ReduceTreePattern& first,
-                             const TrivialPattern& second) {
+static StmtPattern MergePatternImpl(const ReduceTreePattern& first,
+                                    const TrivialPattern& second) {
   return ReduceTreePlusTrivialPattern(
       first,
       second,
@@ -165,18 +165,18 @@ StmtPattern MergePatternImpl(const ReduceTreePattern& first,
 }
 
 // Anchor Fusion
-std::vector<ExprPromise> InitExprPromiseImpl(const TrivialPattern& pattern,
-                                             pir::Value anchor) {
+static std::vector<ExprPromise> InitExprPromiseImpl(
+    const TrivialPattern& pattern, pir::Value anchor) {
   return {ExprPromise(anchor, pattern.id())};
 }
 
-std::vector<ExprPromise> InitExprPromiseImpl(const ReducePattern& pattern,
-                                             pir::Value anchor) {
+static std::vector<ExprPromise> InitExprPromiseImpl(
+    const ReducePattern& pattern, pir::Value anchor) {
   return {ExprPromise(anchor, pattern.id())};
 }
 
-std::vector<ExprPromise> InitExprPromiseImpl(const ReduceTreePattern& pattern,
-                                             pir::Value anchor) {
+static std::vector<ExprPromise> InitExprPromiseImpl(
+    const ReduceTreePattern& pattern, pir::Value anchor) {
   // TODO(@wuzhanfei) this is temporary
   // now we do not support anchor fusion for reduce op,
   // so, this is ok currently. but need to be redesigned later
@@ -189,15 +189,15 @@ std::vector<ExprPromise> InitExprPromiseImpl(const PATTERN& pattern,
   PADDLE_THROW("Can not Init ExprPromise");
 }
 
-std::vector<ExprPromise> InitExprPromise(const StmtPattern& pattern,
-                                         pir::Value anchor) {
+static std::vector<ExprPromise> InitExprPromise(const StmtPattern& pattern,
+                                                pir::Value anchor) {
   return std::visit(
       [anchor](const auto& arg) { return InitExprPromiseImpl(arg, anchor); },
       pattern);
 }
 
-StmtPattern MergePatternImpl(const AnchorPattern& source,
-                             const AnchorPattern& dest) {
+static StmtPattern MergePatternImpl(const AnchorPattern& source,
+                                    const AnchorPattern& dest) {
   const auto& contents =
       UniqueConcatVector(GetOpsInPattern(source), GetOpsInPattern(dest));
   return AnchorPattern(
@@ -207,7 +207,7 @@ StmtPattern MergePatternImpl(const AnchorPattern& source,
       std::make_shared<FusionTracker>(source.tracker_, dest.tracker_));
 }
 
-TrivialPattern RecoverAnchorPatternToTrivial(
+static TrivialPattern RecoverAnchorPatternToTrivial(
     const AnchorPattern& anchor_pattern) {
   PADDLE_ENFORCE_EQ(anchor_pattern.anchor_state.promise.size(),
                     1,
@@ -222,12 +222,12 @@ TrivialPattern RecoverAnchorPatternToTrivial(
       std::make_shared<FusionTracker>(anchor_pattern.tracker_));
 }
 
-AnchorState GetAnchorState(const AnchorPattern& pattern) {
+static AnchorState GetAnchorState(const AnchorPattern& pattern) {
   return pattern.anchor_state;
 }
 
-AnchorState ApplyAnchorTransformRoute(const AnchorState& anchor_state,
-                                      const AnchorTransformRoute& route) {
+static AnchorState ApplyAnchorTransformRoute(
+    const AnchorState& anchor_state, const AnchorTransformRoute& route) {
   AnchorState result = anchor_state;
   for (auto promise : result.promise) {
     promise.update(route);
@@ -243,7 +243,7 @@ using LoopFramework = std::vector<symbol::DimExpr>;
 // std::optional will cause SegmentFault, TODO: fix this.
 using MaybeLoopFramework = LoopFramework;
 
-MaybeLoopFramework GetLoopFramework(const StmtPattern& pattern);
+static MaybeLoopFramework GetLoopFramework(const StmtPattern& pattern);
 
 static MaybeLoopFramework SqueezeLoopFramework(
     const MaybeLoopFramework& loop_framework) {
@@ -258,7 +258,8 @@ static MaybeLoopFramework SqueezeLoopFramework(
   return result;
 }
 
-bool IsLoopFrameworkEqual(const StmtPattern& lhs, const StmtPattern& rhs) {
+static bool IsLoopFrameworkEqual(const StmtPattern& lhs,
+                                 const StmtPattern& rhs) {
   auto lhs_loop = GetLoopFramework(lhs);
   auto rhs_loop = GetLoopFramework(rhs);
   VLOG(4) << "lhs loop range is:" << utils::Join(lhs_loop, ",");
@@ -336,12 +337,12 @@ struct LoopFrameworkVisitor {
   }
 };
 
-MaybeLoopFramework GetLoopFramework(const StmtPattern& pattern) {
+static MaybeLoopFramework GetLoopFramework(const StmtPattern& pattern) {
   return std::visit(LoopFrameworkVisitor(), pattern);
 }
 
-inline auto GetPaddingVector(const MaybeLoopFramework& first,
-                             const MaybeLoopFramework& second) {
+static inline auto GetPaddingVector(const MaybeLoopFramework& first,
+                                    const MaybeLoopFramework& second) {
   // two pointer to get the padding body.
   std::vector<int> padding_f;
   std::vector<int> padding_s;
@@ -379,8 +380,8 @@ inline auto GetPaddingVector(const MaybeLoopFramework& first,
   return std::tuple(padding_f, padding_s);
 }
 
-StmtPattern MergePatternImpl(const HorizontalFusionPattern& first,
-                             const HorizontalFusionPattern& second) {
+static StmtPattern MergePatternImpl(const HorizontalFusionPattern& first,
+                                    const HorizontalFusionPattern& second) {
   const auto& [f, s] =
       GetPaddingVector(GetLoopFramework(first), GetLoopFramework(second));
   typename HorizontalFusionPattern::PaddingStmtPattern pad_first = {first, f};
@@ -392,7 +393,8 @@ StmtPattern MergePatternImpl(const HorizontalFusionPattern& first,
 
 //
 
-StmtPattern MergePattern(const StmtPattern& first, const StmtPattern& second) {
+static StmtPattern MergePattern(const StmtPattern& first,
+                                const StmtPattern& second) {
   VLOG(4) << "MergePattern: " << GetPatternName(first) << " x "
           << GetPatternName(second);
   const auto PatternMatch = adt::match{
@@ -432,7 +434,7 @@ StmtPattern MergePattern(const StmtPattern& first, const StmtPattern& second) {
   return std::visit(PatternMatch, first, second);
 }
 
-void SetReturnInstr(const StmtPattern& s) {
+static void SetReturnInstr(const StmtPattern& s) {
   std::visit(
       [](const auto& impl) {
         impl.tracker_->append(std::make_shared<ReturnInstr>(impl.id()));
diff --git a/paddle/cinn/operator_fusion/pir_graph_analyzing/shardable_axes_base.cc b/paddle/cinn/operator_fusion/pir_graph_analyzing/shardable_axes_base.cc
index 394b99da488287..0af9f0f682a217 100644
--- a/paddle/cinn/operator_fusion/pir_graph_analyzing/shardable_axes_base.cc
+++ b/paddle/cinn/operator_fusion/pir_graph_analyzing/shardable_axes_base.cc
@@ -113,8 +113,8 @@ ShardableAxesSignature CreateSignatureForReduce(pir::Operation* reduce_op) {
   auto input_axes = CreateNewNamesWithRank(input_rank);
 
   const auto reduce_axis_idx = [&]() -> decltype(auto) {
-    const std::vector<size_t> axis_idx = GetReduceAxisIdx(reduce_op);
-    return std::unordered_set<size_t>(axis_idx.begin(), axis_idx.end());
+    const std::vector<int64_t> axis_idx = GetReduceAxisIdx(reduce_op);
+    return std::unordered_set<int64_t>(axis_idx.begin(), axis_idx.end());
   }();
   PADDLE_ENFORCE_NE(
       reduce_axis_idx.size(),
@@ -129,7 +129,7 @@ ShardableAxesSignature CreateSignatureForReduce(pir::Operation* reduce_op) {
       axes.emplace_back(ShardableAxesInfoManager::GetUniqueName());
       return axes;
     }
-    for (size_t i = 0; i < input_rank; i++) {
+    for (int64_t i = 0; i < input_rank; i++) {
       if (!reduce_axis_idx.count(i)) {
         axes.emplace_back(input_axes[i]);
       } else if (keep_dim) {
diff --git a/paddle/cinn/operator_fusion/utils.h b/paddle/cinn/operator_fusion/utils.h
index b035480cdbc2c8..5eab15070edc94 100644
--- a/paddle/cinn/operator_fusion/utils.h
+++ b/paddle/cinn/operator_fusion/utils.h
@@ -54,25 +54,20 @@ static size_t GetCompitableRank(pir::Value value) {
   size_t rank = GetRank(value);
   return rank == 0 ? 1 : rank;
 }
-
-static std::vector<size_t> GetReduceAxisIdx(pir::Operation* reduce_op) {
+static std::vector<int64_t> GetReduceAxisIdx(pir::Operation* reduce_op) {
   const size_t input_rank = GetCompitableRank(reduce_op->operand_source(0));
-  const auto& attr_val = reduce_op->attributes().at("dim");
+  const auto& attr_val = reduce_op->attributes().at("axis");
   CHECK(attr_val.isa<::pir::ArrayAttribute>());
   const auto& axis_attr = attr_val.dyn_cast<::pir::ArrayAttribute>();
   if (axis_attr.empty()) {
     // dim: [] means reduce_all.
-    std::vector<size_t> all_axis;
+    std::vector<int64_t> all_axis;
     for (int i = 0; i < input_rank; ++i) {
       all_axis.push_back(i);
     }
     return all_axis;
   }
-  std::vector<size_t> reduce_axis_idx;
-  if (input_rank == 0) {
-    VLOG(4) << "Reduce op has 0D Tensor input, return empty reduce_axis";
-    return reduce_axis_idx;
-  }
+  std::vector<int64_t> reduce_axis_idx;
   for (int i = 0; i < axis_attr.size(); ++i) {
     int64_t axis = axis_attr.at(i).dyn_cast<::pir::Int64Attribute>().data();
     if (axis < 0) {

From b712f70ce045b419ed707b2ed90156ce7a4e070e Mon Sep 17 00:00:00 2001
From: feifei-111 <2364819892@qq.com>
Date: Wed, 19 Jun 2024 09:15:22 +0000
Subject: [PATCH 84/99] update

---
 .../dialect/operator/transforms/lowering_pass/utils.cc     | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/paddle/cinn/hlir/dialect/operator/transforms/lowering_pass/utils.cc b/paddle/cinn/hlir/dialect/operator/transforms/lowering_pass/utils.cc
index 2a66a1df5d5b77..e4a635d24f313d 100644
--- a/paddle/cinn/hlir/dialect/operator/transforms/lowering_pass/utils.cc
+++ b/paddle/cinn/hlir/dialect/operator/transforms/lowering_pass/utils.cc
@@ -15,6 +15,7 @@
 #include "paddle/cinn/hlir/dialect/operator/transforms/lowering_pass/utils.h"
 
 #include "paddle/cinn/adt/generate_map_expr.h"
+#include "paddle/cinn/hlir/dialect/operator/ir/attribute_storage.h"
 #include "paddle/cinn/hlir/dialect/operator/ir/generate_shape_util.h"
 #include "paddle/cinn/hlir/dialect/operator/ir/op_attribute.h"
 #include "paddle/cinn/hlir/dialect/operator/transforms/lowering_pass/collect_sym_expr.h"
@@ -122,7 +123,11 @@ OpLoweringGroupPtr BuildOpLoweringGroup(pir::Operation* fusion_op_ptr) {
 
   const auto& fn_name = attr.fn_name;
   auto group = std::make_shared<OpLoweringGroup>(
-      ops, fn_name, fusion_op_ptr->attribute("fusion_tracker"));
+      ops,
+      fn_name,
+      fusion_op_ptr->attribute("fusion_tracker")
+          .dyn_cast<cinn::dialect::FusionTrackerPtrAttribute>()
+          .data());
 
   group_op_kind =
       static_cast<int>(attr.op_pattern_kind) > static_cast<int>(group_op_kind)

From 9ee5952ae0a04a509a7b6f9fcddd244745239dab Mon Sep 17 00:00:00 2001
From: feifei-111 <2364819892@qq.com>
Date: Thu, 20 Jun 2024 03:12:49 +0000
Subject: [PATCH 85/99] update

---
 paddle/cinn/operator_fusion/fusion_tracker/tracker.h | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/paddle/cinn/operator_fusion/fusion_tracker/tracker.h b/paddle/cinn/operator_fusion/fusion_tracker/tracker.h
index e9e64af38e389e..604709e5fc645b 100644
--- a/paddle/cinn/operator_fusion/fusion_tracker/tracker.h
+++ b/paddle/cinn/operator_fusion/fusion_tracker/tracker.h
@@ -19,6 +19,7 @@
 namespace cinn::fusion {
 
 enum InstructionType {
+  T_Base,
   T_Copy,
   T_Combine,
   T_Return,
@@ -31,8 +32,8 @@ enum InstructionType {
 };
 
 struct FusionInstruction {
-  virtual InstructionType type() const;
-  virtual std::string DebugStr() const;
+  virtual InstructionType type() const { return T_Base; }
+  virtual std::string DebugStr() const { return "BaseInstr"; }
 };
 
 struct CopyInstr : public FusionInstruction {

From 3f9f7d8a4424c1ef47ed10b96fec9507fb58050e Mon Sep 17 00:00:00 2001
From: feifei-111 <2364819892@qq.com>
Date: Thu, 20 Jun 2024 08:20:04 +0000
Subject: [PATCH 86/99] update

---
 paddle/cinn/hlir/framework/pir/trivial_op_impl.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/paddle/cinn/hlir/framework/pir/trivial_op_impl.h b/paddle/cinn/hlir/framework/pir/trivial_op_impl.h
index 2d883572d29e17..e40b51c1d2bcff 100644
--- a/paddle/cinn/hlir/framework/pir/trivial_op_impl.h
+++ b/paddle/cinn/hlir/framework/pir/trivial_op_impl.h
@@ -139,7 +139,7 @@ std::pair<TrivialOp, ReduceOp> SplitReduceOp(const ReduceOp& reduce_op);
 std::vector<FusibleOp> TransformReduceLoopRange(
     const ReduceOp& upstream,
     FusibleOp* downstream,
-    std::vector<size_t> fake_reduce_iter_idx);
+    const std::vector<size_t>& fake_reduce_iter_idx);
 
 template <typename T>
 std::vector<T> FilterWithFakeReduceIter(

From 17312387106ceb8a505170a5316cc9650bfcb49f Mon Sep 17 00:00:00 2001
From: feifei-111 <2364819892@qq.com>
Date: Fri, 21 Jun 2024 06:27:14 +0000
Subject: [PATCH 87/99] add_test

---
 test/ir/pir/cinn/test_anchor_fusion.py | 126 +++++++++++++++++++++++++
 1 file changed, 126 insertions(+)
 create mode 100644 test/ir/pir/cinn/test_anchor_fusion.py

diff --git a/test/ir/pir/cinn/test_anchor_fusion.py b/test/ir/pir/cinn/test_anchor_fusion.py
new file mode 100644
index 00000000000000..2b4758d69843ce
--- /dev/null
+++ b/test/ir/pir/cinn/test_anchor_fusion.py
@@ -0,0 +1,126 @@
+# Copyright (c) 2024 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.
+
+import os
+import unittest
+
+import numpy
+
+os.environ['FLAGS_cinn_new_group_scheduler'] = '1'
+os.environ['FLAGS_group_schedule_tiling_first'] = '1'
+os.environ['FLAGS_prim_all'] = 'true'
+os.environ['FLAGS_prim_enable_dynamic'] = 'true'
+os.environ['FLAGS_print_ir'] = '1'
+os.environ['FLAGS_enable_pir_api'] = '1'
+os.environ['FLAGS_use_cinn'] = '1'
+os.environ['FLAGS_cinn_bucket_compile'] = '1'
+os.environ['FLAGS_cinn_new_cluster_op_method'] = '1'
+os.environ['FLAGS_deny_cinn_ops'] = 'slice;'
+
+import paddle
+
+build_strategy = paddle.static.BuildStrategy()
+build_strategy.build_cinn_pass = True
+
+
+def generate_input_spec(rank_dtype_list):
+    input_spec = []
+    for rank, dtype in rank_dtype_list:
+        input_spec.append(
+            paddle.static.InputSpec(shape=[None] * rank, dtype=dtype)
+        )
+    return input_spec
+
+
+class TestAnchorFusion(unittest.TestCase):
+    def setUp(self):
+        pass
+
+    def tearDown(self):
+        pass
+
+    def compare_result(self, dy_compute, input_spec, data_init):
+        inputs = data_init()
+        dy_out = dy_compute(*inputs)
+        static_compute = paddle.jit.to_static(
+            full_graph=True,
+            build_strategy=build_strategy,
+            input_spec=input_spec,
+        )(dy_compute)
+        st_out = static_compute(*inputs)
+        for a, b in zip(
+            paddle.utils.flatten(dy_out), paddle.utils.flatten(st_out)
+        ):
+            numpy.testing.assert_allclose(a, b, atol=1e-5, rtol=1e-6)
+
+    def test_anchor_fusion_1(self):
+        def func(x):
+            x = x * 3
+            a = x + 1
+            b = x + 2
+            return a, b
+
+        def init():
+            x = paddle.rand((32, 32, 128))
+            return (x,)
+
+        print("feifeifei")
+        self.compare_result(func, None, init)
+
+    def test_anchor_fusion_2(self):
+        def func(x):
+            x = x * 2
+            a = x + 1
+            c = paddle.sum(a, axis=-1)
+            b = x + 2
+            return b, c
+
+        def init():
+            x = paddle.ones((32, 32, 128))
+            return (x,)
+
+        self.compare_result(func, None, init)
+
+    def test_anchor_fusion_3(self):
+        def func(x):
+            x = x * 2
+            a = x + 1
+            c = paddle.sum(a, axis=-1)
+            b = x + 2
+            d = paddle.sum(b, axis=-1)
+            return c, d
+
+        def init():
+            x = paddle.rand((32, 32, 128))
+            return (x,)
+
+        self.compare_result(func, None, init)
+
+    def test_anchor_fusion_4(self):
+        def func(x):
+            a = x + 1
+            b = x + 2
+            c = a * 2
+            d = a / 2
+            return b, c, d
+
+        def init():
+            x = paddle.rand((32, 32, 128))
+            return (x,)
+
+        self.compare_result(func, None, init)
+
+
+if __name__ == "__main__":
+    unittest.main()

From c03571b20f5ed8e7195961ba9f35730cbce00803 Mon Sep 17 00:00:00 2001
From: xiongkun <xiongkun03@baidu.com>
Date: Tue, 25 Jun 2024 11:20:29 +0000
Subject: [PATCH 88/99] fix

---
 .../transforms/cinn_group_cluster_pass.cc     | 19 +++++++++++++++++++
 .../hlir/framework/pir/op_lowering_group.h    | 14 ++++++++------
 .../cinn/operator_fusion/fusion_interface.cc  |  4 ++--
 .../fusion_tracker/interpreter.cc             |  9 ++++++++-
 .../fusion_tracker/interpreter.h              |  7 +++----
 .../operator_fusion/fusion_tracker/tracker.h  | 18 +++++++++++++++++-
 paddle/cinn/operator_fusion/pattern_graph.cc  |  3 ++-
 paddle/cinn/operator_fusion/pattern_node.h    |  8 ++++----
 paddle/cinn/operator_fusion/utils.h           |  7 ++++---
 9 files changed, 67 insertions(+), 22 deletions(-)

diff --git a/paddle/cinn/hlir/dialect/operator/transforms/cinn_group_cluster_pass.cc b/paddle/cinn/hlir/dialect/operator/transforms/cinn_group_cluster_pass.cc
index 55a8b592619222..0ba31206c7d653 100644
--- a/paddle/cinn/hlir/dialect/operator/transforms/cinn_group_cluster_pass.cc
+++ b/paddle/cinn/hlir/dialect/operator/transforms/cinn_group_cluster_pass.cc
@@ -34,6 +34,7 @@
 #include "paddle/cinn/hlir/dialect/operator/transforms/group_merge/op_with_group_merge_util.h"
 #include "paddle/cinn/hlir/framework/pir/utils.h"
 #include "paddle/cinn/operator_fusion/cluster_interface.h"
+#include "paddle/cinn/operator_fusion/fusion_tracker/tracker.h"
 #include "paddle/common/ddim.h"
 #include "paddle/common/flags.h"
 #include "paddle/fluid/pir/dialect/operator/ir/manual_op.h"
@@ -331,6 +332,22 @@ std::unordered_map<::pir::Value, size_t> BuildValueOrderByYieldOp(
   return all_output_values;
 }
 
+void UpdateTracker(std::vector<pir::Operation*> uniq_ops,
+                   fusion::FusionTrackerPtr tracker) {
+  std::map<pir::Operation*, int> op2idx;
+  for (int i = 0; i < uniq_ops.size(); ++i) {
+    op2idx[uniq_ops[i]] = i;
+  }
+  for (const auto& t : tracker->instructions_) {
+    if (t->type() == fusion::T_InitPattern) {
+      auto init_instr =
+          cinn::fusion::dynamic_cast_instr_with_err<fusion::InitPatternInstr>(
+              t);
+      init_instr->set_idx(op2idx[init_instr->op_]);
+    }
+  }
+}
+
 }  // namespace
 
 class CinnGroupClusterPattern
@@ -360,6 +377,8 @@ class CinnGroupClusterPattern
       VLOG(4) << "cluster node output size: " << output_values.size();
       auto uniq_ops = SortByOriginalOrderAndUniq(group_op, node.ops);
 
+      UpdateTracker(uniq_ops, node.tracker);
+
       auto new_group_op = ReplaceWithFusionOp(
           &rewriter, uniq_ops, node, output_values, &ir_mapping);
 
diff --git a/paddle/cinn/hlir/framework/pir/op_lowering_group.h b/paddle/cinn/hlir/framework/pir/op_lowering_group.h
index 5d2165956fdd90..b63263e51574f4 100644
--- a/paddle/cinn/hlir/framework/pir/op_lowering_group.h
+++ b/paddle/cinn/hlir/framework/pir/op_lowering_group.h
@@ -43,16 +43,18 @@ class OpLoweringGroup {
   OpLoweringGroup(const OpLoweringGroup&) = delete;
   OpLoweringGroup(OpLoweringGroup&&) = delete;
 
-  explicit OpLoweringGroup(const std::vector<::pir::Operation*>& group_ops,
-                           const std::string& fn_name,
-                           cinn::fusion::FusionTrackerPtr fusion_tracker_ptr)
+  explicit OpLoweringGroup(
+      const std::vector<::pir::Operation*>& group_ops,
+      const std::string& fn_name,
+      cinn::fusion::FusionTrackerPtr fusion_tracker_ptr = nullptr)
       : ops_(group_ops),
         fn_name_(fn_name),
         fusion_tracker_ptr(fusion_tracker_ptr) {}
 
-  explicit OpLoweringGroup(std::initializer_list<::pir::Operation*> group_ops,
-                           const std::string& fn_name,
-                           cinn::fusion::FusionTrackerPtr fusion_tracker_ptr)
+  explicit OpLoweringGroup(
+      std::initializer_list<::pir::Operation*> group_ops,
+      const std::string& fn_name,
+      cinn::fusion::FusionTrackerPtr fusion_tracker_ptr = nullptr)
       : ops_(group_ops),
         fn_name_(fn_name),
         fusion_tracker_ptr(fusion_tracker_ptr) {}
diff --git a/paddle/cinn/operator_fusion/fusion_interface.cc b/paddle/cinn/operator_fusion/fusion_interface.cc
index beda76c06a7a00..8fb423ba5fe410 100644
--- a/paddle/cinn/operator_fusion/fusion_interface.cc
+++ b/paddle/cinn/operator_fusion/fusion_interface.cc
@@ -25,14 +25,14 @@ std::vector<ir::Expr> OperationFusion(
     const std::vector<::pir::Operation*>& ops,
     const std::vector<ir::Expr>& op_compute_bodies,
     FusionTrackerPtr fusion_tracker_ptr) {
-  std::unordered_map<::pir::Operation*, FusibleOp> initialized_lowered_op;
+  std::vector<FusibleOp> initialized_lowered_op;
   for (int i = 0; i < ops.size(); i++) {
     auto fusible_op =
         cinn::hlir::framework::pir::trivial_fusion_detail::IsReduceBody(
             op_compute_bodies[i])
             ? FusibleOp(ReduceOp(op_compute_bodies[i]))
             : FusibleOp(TrivialOp(op_compute_bodies[i]));
-    initialized_lowered_op.emplace(std::make_pair(ops[i], fusible_op));
+    initialized_lowered_op.push_back(fusible_op);
   }
 
   auto interpreter =
diff --git a/paddle/cinn/operator_fusion/fusion_tracker/interpreter.cc b/paddle/cinn/operator_fusion/fusion_tracker/interpreter.cc
index bb64c4b7974f4c..d23dbe5bfda6ad 100644
--- a/paddle/cinn/operator_fusion/fusion_tracker/interpreter.cc
+++ b/paddle/cinn/operator_fusion/fusion_tracker/interpreter.cc
@@ -29,13 +29,19 @@ void RunCopyInstr(const std::shared_ptr<CopyInstr>& instr,
 void RunCombineInstr(const std::shared_ptr<CombineInstr>& instr,
                      FusionInterpreter* interpreter) {
   // TODO(@wuzhanfei)
+  ScopeElementPtr new_pattern = std::make_shared<ScopeElement>();
+  for (const auto& name : instr->names_) {
+    const auto& to_insert = interpreter->scope[name];
+    new_pattern->Extend(to_insert->fusion_ops);
+  }
+  interpreter->scope[instr->result_] = new_pattern;
 }
 
 void RunInitPatternInstr(const std::shared_ptr<InitPatternInstr>& instr,
                          FusionInterpreter* interpreter) {
   ScopeElementPtr new_pattern = std::make_shared<ScopeElement>();
   new_pattern->fusion_ops.emplace_back(
-      interpreter->initialized_lowered_op.at(instr->op_));
+      interpreter->initialized_lowered_op[(instr->get_idx())]);
   interpreter->scope[instr->result_] = new_pattern;
 }
 
@@ -167,6 +173,7 @@ std::vector<ir::Expr> FusionInterpreter::Run() {
         break;
       case T_Return:
         RunReturnInstr(dynamic_cast_instr_with_err<ReturnInstr>(instr), this);
+        break;
       default:
         PADDLE_THROW("Unsupported Fusion Instrution");
     }
diff --git a/paddle/cinn/operator_fusion/fusion_tracker/interpreter.h b/paddle/cinn/operator_fusion/fusion_tracker/interpreter.h
index 61a0a877e1b496..e1f79f6d881af3 100644
--- a/paddle/cinn/operator_fusion/fusion_tracker/interpreter.h
+++ b/paddle/cinn/operator_fusion/fusion_tracker/interpreter.h
@@ -34,13 +34,12 @@ using ScopeElementPtr = std::shared_ptr<ScopeElement>;
 
 struct FusionInterpreter {
   FusionInterpreter(const FusionTrackerPtr& tracker,
-                    const std::unordered_map<pir::Operation*, FusibleOp>&
-                        initialized_lowered_op)
-      : tracker(tracker), initialized_lowered_op(initialized_lowered_op) {
+                    const std::vector<FusibleOp>& init_fusible_op)
+      : tracker(tracker), initialized_lowered_op(init_fusible_op) {
     VLOG(4) << "Create FusionInterpreter, Tracker is:\n" << tracker->DebugStr();
   }
 
-  std::unordered_map<pir::Operation*, FusibleOp> initialized_lowered_op;
+  std::vector<FusibleOp> initialized_lowered_op;
   std::unordered_map<std::string, ScopeElementPtr> scope;
   FusionTrackerPtr tracker;
 
diff --git a/paddle/cinn/operator_fusion/fusion_tracker/tracker.h b/paddle/cinn/operator_fusion/fusion_tracker/tracker.h
index 604709e5fc645b..7fc0d9f5d336e7 100644
--- a/paddle/cinn/operator_fusion/fusion_tracker/tracker.h
+++ b/paddle/cinn/operator_fusion/fusion_tracker/tracker.h
@@ -77,14 +77,30 @@ struct ReturnInstr : public FusionInstruction {
 // struct RemovePatternInstr : public FusionInstruction {};
 
 struct InitPatternInstr : public FusionInstruction {
+ private:
+  // we can't just use operation* to identify a unique op because pass change
+  // the program.
+  int idx_in_fusion_op = -1;
+
+ public:
   InitPatternInstr(pir::Operation* op, const std::string& result)
       : op_(op), result_(result) {}
+  void set_idx(int idx) { idx_in_fusion_op = idx; }
+  int get_idx() const {
+    if (idx_in_fusion_op == -1) {
+      PADDLE_THROW("Not initialized.");
+    }
+    return idx_in_fusion_op;
+  }
   virtual InstructionType type() const { return T_InitPattern; }
   pir::Operation* op_;
   std::string result_;
 
   virtual std::string DebugStr() const {
-    return "InitPatternInstr || " + op_->name() + " => " + result_;
+    std::ostringstream ss;
+    ss << "InitPatternInstr || " + op_->name() + " => " + result_ + " index = ("
+       << idx_in_fusion_op << ")";
+    return ss.str();
   }
 };
 
diff --git a/paddle/cinn/operator_fusion/pattern_graph.cc b/paddle/cinn/operator_fusion/pattern_graph.cc
index f8b7e785a9fa6a..fa517f04db6c1e 100644
--- a/paddle/cinn/operator_fusion/pattern_graph.cc
+++ b/paddle/cinn/operator_fusion/pattern_graph.cc
@@ -69,9 +69,10 @@ std::vector<PatternNodePtr> PatternGraph::ClusterOps() {
 
 std::vector<PatternNodePtr> PatternGraph::ReturnFusionResults() {
   auto sorted_nodes = SortByTopoOrder();
-  for (auto node : sorted_nodes) {
+  for (const auto& node : sorted_nodes) {
     node->set_return();
   }
+  return sorted_nodes;
 }
 
 std::vector<PatternNodePtr> PatternGraph::SortByTopoOrder() {
diff --git a/paddle/cinn/operator_fusion/pattern_node.h b/paddle/cinn/operator_fusion/pattern_node.h
index d93ee069980f0a..661e0e972e808f 100644
--- a/paddle/cinn/operator_fusion/pattern_node.h
+++ b/paddle/cinn/operator_fusion/pattern_node.h
@@ -46,8 +46,8 @@ struct PatternNode {
 
   std::string DebugStr() const {
     std::stringstream ss;
-    ss << "Node: " << this << ", Pattern: " << GetPatternName(stmt_pattern_)
-       << "\n    -u>:  ";
+    ss << "Node: " << this << ", Pattern: " << GetPatternName(stmt_pattern())
+       << ", ID: " << GetPatternId(stmt_pattern()) << "\n    -u>:  ";
     for (const auto& u : upstream_) {
       ss << u << ", ";
     }
@@ -63,8 +63,8 @@ struct PatternNode {
   void set_stmt_pattern(const StmtPattern& pattern) { stmt_pattern_ = pattern; }
   const std::vector<PatternNodePtr>& upstream() const { return upstream_; }
   const std::vector<PatternNodePtr>& downstream() const { return downstream_; }
-  const std::string& name() const { return GetPatternName(stmt_pattern_); }
-  const std::string& id() const { return GetPatternId(stmt_pattern_); }
+  std::string name() const { return GetPatternName(stmt_pattern_); }
+  std::string id() const { return GetPatternId(stmt_pattern_); }
   void set_return() const { SetReturnInstr(stmt_pattern_); }
   void AddNodeToUpstream(PatternNodePtr node) { upstream_.push_back(node); }
   void AddNodeToDownstream(PatternNodePtr node) { downstream_.push_back(node); }
diff --git a/paddle/cinn/operator_fusion/utils.h b/paddle/cinn/operator_fusion/utils.h
index 5eab15070edc94..9f684548a61c13 100644
--- a/paddle/cinn/operator_fusion/utils.h
+++ b/paddle/cinn/operator_fusion/utils.h
@@ -87,8 +87,8 @@ static bool GetReduceOpKeepDims(pir::Operation* reduce_op) {
   return attr_val.dyn_cast<::pir::BoolAttribute>().data();
 }
 
-static std::optional<std::pair<pir::Value, pir::Value>>
-GetBroadcastOpInputOuputValue(pir::Operation* op);
+std::optional<std::pair<pir::Value, pir::Value>> GetBroadcastOpInputOuputValue(
+    pir::Operation* op);
 
 static std::vector<std::pair<size_t, size_t>> GetNonBroadCastDims(
     pir::Operation* op) {
@@ -125,7 +125,8 @@ static std::string OpsDebugStr(std::vector<pir::Operation*> ops) {
   pir::IrPrinter printer(ss);
   for (const auto* op : ops) {
     printer.PrintOperation(const_cast<pir::Operation*>(op));
-    ss << "\n";
+    ss << "(" << op << ")"
+       << "\n";
   }
   return ss.str();
 }

From 9ca34654c4019eef538d08ea74fa9f79d822d41e Mon Sep 17 00:00:00 2001
From: xiongkun <xiongkun03@baidu.com>
Date: Wed, 3 Jul 2024 09:04:19 +0000
Subject: [PATCH 89/99] fix

---
 .../fusion_tracker/expr_utils.h               |  9 ++++++
 .../fusion_tracker/interpreter.cc             |  6 ++--
 .../operator_fusion/fusion_tracker/tracker.h  |  7 +++--
 .../graph_transformer/operation.h             | 28 +++++++------------
 paddle/cinn/operator_fusion/pattern_node.h    |  3 ++
 test/ir/pir/cinn/test_anchor_fusion.py        |  5 ++--
 6 files changed, 33 insertions(+), 25 deletions(-)

diff --git a/paddle/cinn/operator_fusion/fusion_tracker/expr_utils.h b/paddle/cinn/operator_fusion/fusion_tracker/expr_utils.h
index cb4cf984089ec4..996811fca324ba 100644
--- a/paddle/cinn/operator_fusion/fusion_tracker/expr_utils.h
+++ b/paddle/cinn/operator_fusion/fusion_tracker/expr_utils.h
@@ -22,6 +22,15 @@ using ReduceOp = cinn::hlir::framework::pir::trivial_fusion_detail::ReduceOp;
 using FusibleOp = cinn::hlir::framework::pir::trivial_fusion_detail::FusibleOp;
 
 struct FusibleOp2Expr {
+  std::vector<ir::Expr> operator()(const TrivialOp& op) {
+    return {op.GetFuncBody()};
+  }
+  std::vector<ir::Expr> operator()(const ReduceOp& op) {
+    return {op.GetFuncBody()};
+  }
+};
+
+struct GetSplitedExprFromFusionOp {
   std::vector<ir::Expr> operator()(const TrivialOp& op) {
     return {op.GetFuncBody()};
   }
diff --git a/paddle/cinn/operator_fusion/fusion_tracker/interpreter.cc b/paddle/cinn/operator_fusion/fusion_tracker/interpreter.cc
index f18cfda297098a..29b292a9409f05 100644
--- a/paddle/cinn/operator_fusion/fusion_tracker/interpreter.cc
+++ b/paddle/cinn/operator_fusion/fusion_tracker/interpreter.cc
@@ -22,7 +22,7 @@ namespace cinn::fusion {
 void RunCopyInstr(const std::shared_ptr<CopyInstr>& instr,
                   FusionInterpreter* interpreter) {
   interpreter->scope[instr->new_name_] =
-      interpreter->scope[instr->origin_name_];
+      interpreter->scope.at(instr->origin_name_);
 }
 
 void RunCombineInstr(const std::shared_ptr<CombineInstr>& instr,
@@ -30,7 +30,7 @@ void RunCombineInstr(const std::shared_ptr<CombineInstr>& instr,
   // TODO(@wuzhanfei)
   ScopeElementPtr new_pattern = std::make_shared<ScopeElement>();
   for (const auto& name : instr->names_) {
-    const auto& to_insert = interpreter->scope[name];
+    const auto& to_insert = interpreter->scope.at(name);
     new_pattern->Extend(to_insert->fusion_ops);
   }
   interpreter->scope[instr->result_] = new_pattern;
@@ -142,7 +142,7 @@ void RunPaddingInstr(const std::shared_ptr<PaddingInstr>& instr,
 void RunReturnInstr(const std::shared_ptr<ReturnInstr>& instr,
                     FusionInterpreter* interpreter) {
   for (auto fusion_op : interpreter->scope[instr->target_]->fusion_ops) {
-    auto exprs = std::visit(FusibleOp2Expr(), fusion_op);
+    auto exprs = std::visit(GetSplitedExprFromFusionOp(), fusion_op);
     interpreter->ret_expr.insert(
         interpreter->ret_expr.end(), exprs.begin(), exprs.end());
   }
diff --git a/paddle/cinn/operator_fusion/fusion_tracker/tracker.h b/paddle/cinn/operator_fusion/fusion_tracker/tracker.h
index 0b61074774ac0e..f4dc44275d6416 100644
--- a/paddle/cinn/operator_fusion/fusion_tracker/tracker.h
+++ b/paddle/cinn/operator_fusion/fusion_tracker/tracker.h
@@ -81,10 +81,13 @@ struct InitPatternInstr : public FusionInstruction {
   // we can't just use operation* to identify a unique op because pass change
   // the program.
   int idx_in_fusion_op = -1;
+  std::string op_name;
 
  public:
   InitPatternInstr(pir::Operation* op, const std::string& result)
-      : op_(op), result_(result) {}
+      : op_(op), result_(result) {
+    op_name = op->name();
+  }
   void set_idx(int idx) { idx_in_fusion_op = idx; }
   int get_idx() const {
     if (idx_in_fusion_op == -1) {
@@ -98,7 +101,7 @@ struct InitPatternInstr : public FusionInstruction {
 
   virtual std::string DebugStr() const {
     std::ostringstream ss;
-    ss << "InitPatternInstr || " + op_->name() + " => " + result_ + " index = ("
+    ss << "InitPatternInstr || " + op_name + " => " + result_ + " index = ("
        << idx_in_fusion_op << ")";
     return ss.str();
   }
diff --git a/paddle/cinn/operator_fusion/graph_transformer/operation.h b/paddle/cinn/operator_fusion/graph_transformer/operation.h
index 938f9e51bf6c6a..0f13643308e29c 100644
--- a/paddle/cinn/operator_fusion/graph_transformer/operation.h
+++ b/paddle/cinn/operator_fusion/graph_transformer/operation.h
@@ -121,6 +121,7 @@ struct LiftReduceToReduceTreeOperation {
         {},
         reduce_pattern,
         std::make_shared<FusionTracker>(reduce_pattern.tracker_)));
+    VLOG(4) << "Make CopyInstr: " << origin_name << " -> " << node->id();
     node->AppendInstr(std::make_shared<CopyInstr>(origin_name, node->id()));
     return node;
   }
@@ -134,6 +135,7 @@ struct LiftToHorizontalFusionPatternOperation {
             node->stmt_pattern(), {})},
         std::make_shared<FusionTracker>(
             GetFusionTracker(node->stmt_pattern()))));
+    VLOG(4) << "Make CopyInstr: " << origin_name << " -> " << node->id();
     node->AppendInstr(std::make_shared<CopyInstr>(origin_name, node->id()));
     return node;
   }
@@ -157,6 +159,9 @@ struct LiftToAnchorPatternOperation {
         AnchorState(InitExprPromise(node->stmt_pattern(), anchor)),
         std::make_shared<FusionTracker>(
             GetFusionTracker(node->stmt_pattern()))));
+    node->AppendInstr(std::make_shared<CopyInstr>(origin_name, node->id()));
+    VLOG(4) << "LiftToAnchorPatternOperation: remain tracker: "
+            << GetFusionTracker(node->stmt_pattern())->DebugStr();
     return node;
   }
 };
@@ -194,15 +199,6 @@ struct FuseUpstreamAnchorOperation {
     graph->RemoveNode(upstream);
     graph->RemoveNode(downstream);
     merged_node->UpdateTracker();
-    // VLOG(4)
-    //     << "upstream anchor: "
-    //     << std::get<AnchorPattern>(upstream->stmt_pattern()).anchor().impl()
-    //     << ", downstream anchor: "
-    //     <<
-    //     std::get<AnchorPattern>(downstream->stmt_pattern()).anchor().impl()
-    //     << ", merged node anchor: "
-    //     <<
-    //     std::get<AnchorPattern>(merged_node->stmt_pattern()).anchor().impl();
     return merged_node;
   }
 };
@@ -241,15 +237,6 @@ struct FuseDownstreamAnchorOperation {
     graph->RemoveNode(upstream);
     graph->RemoveNode(downstream);
     merged_node->UpdateTracker();
-    // VLOG(4)
-    //     << "upstream anchor: "
-    //     << std::get<AnchorPattern>(upstream->stmt_pattern()).anchor().impl()
-    //     << ", downstream anchor: "
-    //     <<
-    //     std::get<AnchorPattern>(downstream->stmt_pattern()).anchor().impl()
-    //     << ", merged node anchor: "
-    //     <<
-    //     std::get<AnchorPattern>(merged_node->stmt_pattern()).anchor().impl();
     return merged_node;
   }
 };
@@ -257,10 +244,15 @@ struct FuseDownstreamAnchorOperation {
 struct SplitRecomputeOperation {
   void operator()(PatternGraph* graph, PatternNodePtr upstream) {
     auto origin_name = upstream->id();
+    VLOG(4) << "SplitRecomputeOperation: upstream tracker is: "
+            << GetFusionTracker(upstream->stmt_pattern())->DebugStr();
     upstream->set_stmt_pattern(RecoverAnchorPatternToTrivial(
         std::get<AnchorPattern>(upstream->stmt_pattern())));
+    VLOG(4) << "Make CopyInstr: " << origin_name << " -> " << upstream->id();
     upstream->AppendInstr(
         std::make_shared<CopyInstr>(origin_name, upstream->id()));
+    VLOG(4) << "After SplitRecomputeOperation: upstream tracker is: "
+            << GetFusionTracker(upstream->stmt_pattern())->DebugStr();
     MergeTrivialPatternOperation()(graph, upstream);
   }
 };
diff --git a/paddle/cinn/operator_fusion/pattern_node.h b/paddle/cinn/operator_fusion/pattern_node.h
index 661e0e972e808f..88fa24a37b9a47 100644
--- a/paddle/cinn/operator_fusion/pattern_node.h
+++ b/paddle/cinn/operator_fusion/pattern_node.h
@@ -55,6 +55,9 @@ struct PatternNode {
     for (const auto& d : downstream_) {
       ss << d << ", ";
     }
+    ss << "Ops in pattern: \n################" << std::endl;
+    ss << OpsDebugStr(GetOpsInPattern(this->stmt_pattern()));
+    ss << "################" << std::endl;
     return ss.str();
   }
 
diff --git a/test/ir/pir/cinn/test_anchor_fusion.py b/test/ir/pir/cinn/test_anchor_fusion.py
index 2b4758d69843ce..5d128cf2231d1c 100644
--- a/test/ir/pir/cinn/test_anchor_fusion.py
+++ b/test/ir/pir/cinn/test_anchor_fusion.py
@@ -109,8 +109,9 @@ def init():
 
     def test_anchor_fusion_4(self):
         def func(x):
-            a = x + 1
-            b = x + 2
+            m = x + 1
+            a = m + 1
+            b = m + 2
             c = a * 2
             d = a / 2
             return b, c, d

From 0d8c62ecbb3dab79b5afba6098ca618c9cadadbb Mon Sep 17 00:00:00 2001
From: huangjiyi <947613776@qq.com>
Date: Mon, 15 Jul 2024 01:44:02 +0000
Subject: [PATCH 90/99] fix

---
 paddle/cinn/operator_fusion/pattern.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/paddle/cinn/operator_fusion/pattern.h b/paddle/cinn/operator_fusion/pattern.h
index b378b6a3e326e1..ae080a46e4828f 100644
--- a/paddle/cinn/operator_fusion/pattern.h
+++ b/paddle/cinn/operator_fusion/pattern.h
@@ -101,7 +101,7 @@ struct ReduceTreePattern {
   std::vector<ReduceTreePattern>& childs() { return childs_; }
   void InsertChild(const ReduceTreePattern& child) { childs_.push_back(child); }
   std::vector<ReducePattern> FlattenReducePattern() const {
-    std::vector<ReducePattern> result;
+    std::vector<ReducePattern> result{root_};
     for (const auto& child : childs_) {
       result = ConcatVector(result, child.FlattenReducePattern());
     }

From 6164f3aa14ca4d8772aee6f4fdc0cb045b8ecfda Mon Sep 17 00:00:00 2001
From: huangjiyi <947613776@qq.com>
Date: Mon, 15 Jul 2024 11:25:35 +0000
Subject: [PATCH 91/99] fix

---
 .../operator_fusion/pir_graph_analyzing/anchor_transform.cc  | 5 +++--
 .../operator_fusion/pir_graph_analyzing/anchor_transform.h   | 3 ++-
 paddle/cinn/operator_fusion/policy/anchor_search_policy.cc   | 2 +-
 3 files changed, 6 insertions(+), 4 deletions(-)

diff --git a/paddle/cinn/operator_fusion/pir_graph_analyzing/anchor_transform.cc b/paddle/cinn/operator_fusion/pir_graph_analyzing/anchor_transform.cc
index ee7f328347798f..12073adbf3a5b5 100644
--- a/paddle/cinn/operator_fusion/pir_graph_analyzing/anchor_transform.cc
+++ b/paddle/cinn/operator_fusion/pir_graph_analyzing/anchor_transform.cc
@@ -115,12 +115,13 @@ AnchorTransform CreateAnchorTransform(const TransformInfo& info) {
   return result;
 }
 
-std::vector<AnchorTransform> PossibleTransform(pir::Value v) {
+std::vector<AnchorTransform> PossibleTransform(
+    pir::Value v, const std::unordered_set<pir::Operation*>& ops) {
   std::vector<AnchorTransform> result;
 
   // Transform to Upstream
   auto defining_op = v.defining_op();
-  if (defining_op != nullptr) {
+  if (defining_op != nullptr && ops.find(defining_op) != ops.end()) {
     size_t output_idx = GetResultIdx(v, defining_op);
     for (size_t i = 0; i < defining_op->num_operands(); ++i) {
       result.emplace_back(CreateAnchorTransform(
diff --git a/paddle/cinn/operator_fusion/pir_graph_analyzing/anchor_transform.h b/paddle/cinn/operator_fusion/pir_graph_analyzing/anchor_transform.h
index 8a2acb39f59795..685eb20374cc52 100644
--- a/paddle/cinn/operator_fusion/pir_graph_analyzing/anchor_transform.h
+++ b/paddle/cinn/operator_fusion/pir_graph_analyzing/anchor_transform.h
@@ -157,7 +157,8 @@ struct AnchorState {
 };
 
 AnchorTransform CreateAnchorTransform(const TransformInfo& info);
-std::vector<AnchorTransform> PossibleTransform(pir::Value v);
+std::vector<AnchorTransform> PossibleTransform(
+    pir::Value v, const std::unordered_set<pir::Operation*>& ops);
 TransformInfo GetTransformInfo(AnchorTransform trans);
 std::string DebugStrOfAnchorTransform(const AnchorTransform& trans);
 }  // namespace cinn::fusion
diff --git a/paddle/cinn/operator_fusion/policy/anchor_search_policy.cc b/paddle/cinn/operator_fusion/policy/anchor_search_policy.cc
index b7a216823130e3..c79eef1d994bef 100644
--- a/paddle/cinn/operator_fusion/policy/anchor_search_policy.cc
+++ b/paddle/cinn/operator_fusion/policy/anchor_search_policy.cc
@@ -31,7 +31,7 @@ std::optional<AnchorTransformRoute> SearchAnchorTransformRecursively(
     const std::unordered_set<pir::Operation*>& ops) {
   VLOG(4) << "[SearchAnchorTransformRecursively] Curent Route:\n"
           << DebugStrOfAnchorTransformRoute(*cur_route);
-  auto transforms = PossibleTransform(begin);
+  auto transforms = PossibleTransform(begin, ops);
   for (auto anchor_transform : transforms) {
     auto info = GetTransformInfo(anchor_transform);
     auto dst_value = info.DstValue();

From 486d511d54290c2248762440e9c51fc3f9f52078 Mon Sep 17 00:00:00 2001
From: huangjiyi <947613776@qq.com>
Date: Tue, 16 Jul 2024 08:31:53 +0000
Subject: [PATCH 92/99] fix reshape tmp

---
 .../graph_transformer/operation.h               | 17 ++++++++++-------
 1 file changed, 10 insertions(+), 7 deletions(-)

diff --git a/paddle/cinn/operator_fusion/graph_transformer/operation.h b/paddle/cinn/operator_fusion/graph_transformer/operation.h
index 0f13643308e29c..a52a6eb4941d91 100644
--- a/paddle/cinn/operator_fusion/graph_transformer/operation.h
+++ b/paddle/cinn/operator_fusion/graph_transformer/operation.h
@@ -145,13 +145,16 @@ struct LiftToAnchorPatternOperation {
   PatternNodePtr operator()(PatternGraph* graph, PatternNodePtr node) {
     auto origin_name = node->id();
     std::vector<pir::Operation*> ops = GetOpsInPattern(node->stmt_pattern());
-    // TODO(@wuzhanfei) move sink_op into pattern (currently, part of pattern
-    // type has sink and the others not) then, update logic here
-    PADDLE_ENFORCE_EQ(
-        node->sink_op()->num_results(),
-        1,
-        phi::errors::PreconditionNotMet(
-            "Op with multi output value can not lift to AnchorPattern"));
+    // TODO(huangjiyi): rm if condition after xshape removed in pd_op.reshape
+    if (node->sink_op()->name() != "pd_op.reshape") {
+      // TODO(@wuzhanfei) move sink_op into pattern (currently, part of pattern
+      // type has sink and the others not) then, update logic here
+      PADDLE_ENFORCE_EQ(
+          node->sink_op()->num_results(),
+          1,
+          phi::errors::PreconditionNotMet(
+              "Op with multi output value can not lift to AnchorPattern"));
+    }
     pir::Value anchor = node->sink_op()->result(0);
     node->set_stmt_pattern(AnchorPattern(
         ops,

From b781b3ed6205488a690bd440a2ff18158cc14456 Mon Sep 17 00:00:00 2001
From: huangjiyi <947613776@qq.com>
Date: Mon, 22 Jul 2024 04:19:22 +0000
Subject: [PATCH 93/99] fix test_graph

---
 paddle/cinn/operator_fusion/fusion_tracker/interpreter.cc | 1 -
 1 file changed, 1 deletion(-)

diff --git a/paddle/cinn/operator_fusion/fusion_tracker/interpreter.cc b/paddle/cinn/operator_fusion/fusion_tracker/interpreter.cc
index 29b292a9409f05..80fb45a955016d 100644
--- a/paddle/cinn/operator_fusion/fusion_tracker/interpreter.cc
+++ b/paddle/cinn/operator_fusion/fusion_tracker/interpreter.cc
@@ -89,7 +89,6 @@ void RunTmpTransformInstr(const std::shared_ptr<TmpTransformInstr>& instr,
 void RunTrivialLoopAlignInstr(
     const std::shared_ptr<TrivialLoopAlignInstr>& instr,
     FusionInterpreter* interpreter) {
-  PADDLE_ENFORCE_EQ(interpreter->scope[instr->upstream_]->fusion_ops.size(), 1);
   PADDLE_ENFORCE_EQ(interpreter->scope[instr->downstream_]->fusion_ops.size(),
                     1);
   auto upstream_op = std::get<ReduceOp>(

From f0d5004ebee4a9c7c9fe20c4b480bb43050ef86e Mon Sep 17 00:00:00 2001
From: huangjiyi <947613776@qq.com>
Date: Tue, 23 Jul 2024 08:56:07 +0000
Subject: [PATCH 94/99] fix test_sd_resnet_block

---
 .../operator_fusion/graph_transformer/matcher.h  | 13 ++++++++-----
 paddle/cinn/operator_fusion/pattern_fuser.h      | 13 +++++++++----
 paddle/cinn/operator_fusion/pattern_graph.cc     |  2 +-
 paddle/cinn/operator_fusion/pattern_node.h       |  9 ++++++++-
 .../pir_graph_analyzing/anchor_transform.cc      |  3 +++
 test/ir/pir/cinn/test_anchor_fusion.py           | 16 ++++++++++++++++
 6 files changed, 45 insertions(+), 11 deletions(-)

diff --git a/paddle/cinn/operator_fusion/graph_transformer/matcher.h b/paddle/cinn/operator_fusion/graph_transformer/matcher.h
index 5129ef13e065c7..1d21b9df9aaeb1 100644
--- a/paddle/cinn/operator_fusion/graph_transformer/matcher.h
+++ b/paddle/cinn/operator_fusion/graph_transformer/matcher.h
@@ -74,11 +74,14 @@ struct LiftToAnchorPatternMatcher {
   bool operator()(const PatternGraph& graph, const PatternNodePtr& node) {
     bool not_reduce_tree =
         !StmtPatternGraphMatcher<ReduceTreePattern>()(graph, node) &&
-        !StmtPatternGraphMatcher<ReduceTreePlusTrivialPattern>()(graph, node);
-    bool reduce_tree_with_single_reduce =
-        StmtPatternGraphMatcher<ReduceTreePattern>()(graph, node) &&
-        std::get<ReduceTreePattern>(node->stmt_pattern()).childs().size() == 0;
-    return not_reduce_tree || reduce_tree_with_single_reduce;
+        !StmtPatternGraphMatcher<ReduceTreePlusTrivialPattern>()(graph, node) &&
+        !StmtPatternGraphMatcher<ReducePattern>()(graph, node);
+    // TODO(huangjiyi): Support anchor value is reduce output.
+    // bool reduce_tree_with_single_reduce =
+    //     StmtPatternGraphMatcher<ReduceTreePattern>()(graph, node) &&
+    //     std::get<ReduceTreePattern>(node->stmt_pattern()).childs().size() ==
+    //     0;
+    return not_reduce_tree /* || reduce_tree_with_single_reduce */;
   }
 };
 
diff --git a/paddle/cinn/operator_fusion/pattern_fuser.h b/paddle/cinn/operator_fusion/pattern_fuser.h
index 24afa628b0ac79..4332a87bbd70df 100644
--- a/paddle/cinn/operator_fusion/pattern_fuser.h
+++ b/paddle/cinn/operator_fusion/pattern_fuser.h
@@ -464,8 +464,15 @@ struct LoopFrameworkVisitor {
   }
 
   MaybeLoopFramework operator()(const AnchorPattern& pattern) {
-    const auto& exprs = GetDimExprsFromValue(pattern.anchor());
-    return exprs;
+    const auto& loops = GetDimExprsFromValue(pattern.anchor());
+    auto anchor_op = pattern.anchor().defining_op();
+    if (GetOpPatternKind(anchor_op) == hlir::framework::kReduction) {
+      const auto& reduce_axes = GetReduceAxisIdx(anchor_op);
+      const auto& reduce_loops = GatherVector(
+          GetDimExprsFromValue(anchor_op->operand(0).source()), reduce_axes);
+      return ConcatVector(loops, reduce_loops);
+    }
+    return loops;
   }
 };
 
@@ -525,8 +532,6 @@ static StmtPattern MergePatternImpl(const HorizontalFusionPattern& first,
       std::make_shared<FusionTracker>(first.tracker_, second.tracker_));
 }
 
-//
-
 static StmtPattern MergePattern(const StmtPattern& first,
                                 const StmtPattern& second) {
   VLOG(4) << "MergePattern: " << GetPatternName(first) << " x "
diff --git a/paddle/cinn/operator_fusion/pattern_graph.cc b/paddle/cinn/operator_fusion/pattern_graph.cc
index 1f275945204695..b93967e809e58d 100644
--- a/paddle/cinn/operator_fusion/pattern_graph.cc
+++ b/paddle/cinn/operator_fusion/pattern_graph.cc
@@ -274,7 +274,7 @@ std::string PatternGraph::GraphInfo() const {
   std::stringstream ss;
   ss << "\n========= GraphInfo ===========";
   for (const auto& v : all_pattern_nodes_) {
-    ss << "\n" << v->DebugStr();
+    ss << v->DebugStr();
     ss << "\n    IsOutput: " << IsOutputNodeMatcher()(*this, v);
     ss << "\n    Loop Framework is: " << GetLoopFramework(v->stmt_pattern());
   }
diff --git a/paddle/cinn/operator_fusion/pattern_node.h b/paddle/cinn/operator_fusion/pattern_node.h
index 88fa24a37b9a47..2877a9527fcce9 100644
--- a/paddle/cinn/operator_fusion/pattern_node.h
+++ b/paddle/cinn/operator_fusion/pattern_node.h
@@ -55,7 +55,14 @@ struct PatternNode {
     for (const auto& d : downstream_) {
       ss << d << ", ";
     }
-    ss << "Ops in pattern: \n################" << std::endl;
+    pir::IrPrinter printer(ss);
+    if (GetPatternName(stmt_pattern_) == AnchorPattern::name()) {
+      ss << "\n anchor: ";
+      auto anchor_op =
+          std::get<AnchorPattern>(stmt_pattern_).anchor().defining_op();
+      printer.PrintOperation(const_cast<pir::Operation*>(anchor_op));
+    }
+    ss << "\nOps in pattern: \n################" << std::endl;
     ss << OpsDebugStr(GetOpsInPattern(this->stmt_pattern()));
     ss << "################" << std::endl;
     return ss.str();
diff --git a/paddle/cinn/operator_fusion/pir_graph_analyzing/anchor_transform.cc b/paddle/cinn/operator_fusion/pir_graph_analyzing/anchor_transform.cc
index 12073adbf3a5b5..e3e8e1ab679521 100644
--- a/paddle/cinn/operator_fusion/pir_graph_analyzing/anchor_transform.cc
+++ b/paddle/cinn/operator_fusion/pir_graph_analyzing/anchor_transform.cc
@@ -133,6 +133,9 @@ std::vector<AnchorTransform> PossibleTransform(
   for (auto consumer_it = v.use_begin(); consumer_it != v.use_end();
        ++consumer_it) {
     auto downstream_op = consumer_it->owner();
+    if (ops.find(downstream_op) == ops.end()) {
+      continue;
+    }
     size_t input_idx = GetOperandIdx(v, downstream_op);
     for (size_t i = 0; i < downstream_op->num_results(); i++) {
       result.emplace_back(CreateAnchorTransform(
diff --git a/test/ir/pir/cinn/test_anchor_fusion.py b/test/ir/pir/cinn/test_anchor_fusion.py
index 5d128cf2231d1c..a6befa4f5cc627 100644
--- a/test/ir/pir/cinn/test_anchor_fusion.py
+++ b/test/ir/pir/cinn/test_anchor_fusion.py
@@ -122,6 +122,22 @@ def init():
 
         self.compare_result(func, None, init)
 
+    def test_anchor_fusion_5(self):
+        #     R
+        #    / \
+        #   T   T
+        def func(x):
+            a = paddle.sum(x, axis=-1)
+            b = a - 3
+            c = a * 2
+            return b, c
+
+        def init():
+            x = paddle.rand((32, 32, 128))
+            return (x,)
+
+        self.compare_result(func, None, init)
+
 
 if __name__ == "__main__":
     unittest.main()

From 640fca7be1ae2da0498cb83730a1957f707c2974 Mon Sep 17 00:00:00 2001
From: huangjiyi <947613776@qq.com>
Date: Wed, 24 Jul 2024 08:26:51 +0000
Subject: [PATCH 95/99] fix shared tracker conflict

---
 .../transforms/cinn_group_cluster_pass.cc     |  3 +-
 .../operator_fusion/fusion_tracker/tracker.h  | 43 ++++++++++++++++++-
 paddle/cinn/operator_fusion/pattern.h         |  2 +-
 paddle/cinn/operator_fusion/pattern_graph.cc  |  4 +-
 test/ir/pir/cinn/test_anchor_fusion.py        | 19 ++++++++
 5 files changed, 65 insertions(+), 6 deletions(-)

diff --git a/paddle/cinn/hlir/dialect/operator/transforms/cinn_group_cluster_pass.cc b/paddle/cinn/hlir/dialect/operator/transforms/cinn_group_cluster_pass.cc
index 0ba31206c7d653..4c5d3882d4f377 100644
--- a/paddle/cinn/hlir/dialect/operator/transforms/cinn_group_cluster_pass.cc
+++ b/paddle/cinn/hlir/dialect/operator/transforms/cinn_group_cluster_pass.cc
@@ -282,7 +282,8 @@ std::vector<GroupClusterNode> GroupSplit(cinn::dialect::GroupOp group_op) {
       cluster_node.group_kind =
           cluster_node.group_kind > op_kind ? cluster_node.group_kind : op_kind;
     }
-    cluster_node.tracker = trackers[i];
+    // Deep copy trackers to avoid shared tracker conflict in different node
+    cluster_node.tracker = trackers[i]->Clone();
     output_cluster_nodes.push_back(cluster_node);
   }
   VLOG(4) << "Finished Creating Cluster Nodes!";
diff --git a/paddle/cinn/operator_fusion/fusion_tracker/tracker.h b/paddle/cinn/operator_fusion/fusion_tracker/tracker.h
index f4dc44275d6416..aa915b45ded62f 100644
--- a/paddle/cinn/operator_fusion/fusion_tracker/tracker.h
+++ b/paddle/cinn/operator_fusion/fusion_tracker/tracker.h
@@ -32,14 +32,21 @@ enum InstructionType {
 };
 
 struct FusionInstruction {
+  using FusionInstrPtr = std::shared_ptr<FusionInstruction>;
   virtual InstructionType type() const { return T_Base; }
   virtual std::string DebugStr() const { return "BaseInstr"; }
+  virtual FusionInstrPtr Clone() {
+    return std::make_shared<FusionInstruction>(*this);
+  }
 };
 
+using FusionInstrPtr = std::shared_ptr<FusionInstruction>;
+
 struct CopyInstr : public FusionInstruction {
   CopyInstr(const std::string& origin_name, const std::string& new_name)
       : origin_name_(origin_name), new_name_(new_name) {}
   virtual InstructionType type() const { return T_Copy; }
+  virtual FusionInstrPtr Clone() { return std::make_shared<CopyInstr>(*this); }
   std::string origin_name_;
   std::string new_name_;
 
@@ -52,6 +59,9 @@ struct CombineInstr : public FusionInstruction {
   CombineInstr(const std::vector<std::string>& names, const std::string& result)
       : names_(names), result_(result) {}
   virtual InstructionType type() const { return T_Combine; }
+  virtual FusionInstrPtr Clone() {
+    return std::make_shared<CombineInstr>(*this);
+  }
   std::vector<std::string> names_;
   std::string result_;
 
@@ -69,6 +79,9 @@ struct CombineInstr : public FusionInstruction {
 struct ReturnInstr : public FusionInstruction {
   explicit ReturnInstr(const std::string& target) : target_(target) {}
   virtual InstructionType type() const { return T_Return; }
+  virtual FusionInstrPtr Clone() {
+    return std::make_shared<ReturnInstr>(*this);
+  }
   std::string target_;
 
   virtual std::string DebugStr() const { return "ReturnInstr || " + target_; }
@@ -96,6 +109,9 @@ struct InitPatternInstr : public FusionInstruction {
     return idx_in_fusion_op;
   }
   virtual InstructionType type() const { return T_InitPattern; }
+  virtual FusionInstrPtr Clone() {
+    return std::make_shared<InitPatternInstr>(*this);
+  }
   pir::Operation* op_;
   std::string result_;
 
@@ -113,6 +129,9 @@ struct TrivialInlineInstr : public FusionInstruction {
                      const std::string& result)
       : upstream_(upstream), downstream_(downstream), result_(result) {}
   virtual InstructionType type() const { return T_TrivialInline; }
+  virtual FusionInstrPtr Clone() {
+    return std::make_shared<TrivialInlineInstr>(*this);
+  }
   std::string upstream_;
   std::string downstream_;
   std::string result_;
@@ -135,6 +154,9 @@ struct TmpTransformInstr : public FusionInstruction {
         out_upstream_(out_upstream),
         fake_reduce_iter_idx_(fake_reduce_iter_idx) {}
   InstructionType type() const override { return T_TmpTransform; }
+  virtual FusionInstrPtr Clone() {
+    return std::make_shared<TmpTransformInstr>(*this);
+  }
   std::string upstream_;
   std::string downstream_;
   std::string out_upstream_;
@@ -157,6 +179,9 @@ struct TrivialLoopAlignInstr : public FusionInstruction {
         result_(result),
         fake_reduce_iter_idx_(fake_reduce_iter_idx) {}
   virtual InstructionType type() const { return T_TrivialLoopAlign; }
+  virtual FusionInstrPtr Clone() {
+    return std::make_shared<TrivialLoopAlignInstr>(*this);
+  }
   std::string upstream_;
   std::string downstream_;
   std::string result_;
@@ -174,6 +199,9 @@ struct AnchorTransformInstr : public FusionInstruction {
                        const AnchorTransformRoute& transform_route)
       : target_(target), result_(result), transform_route_(transform_route) {}
   virtual InstructionType type() const { return T_AnchorTransform; }
+  virtual FusionInstrPtr Clone() {
+    return std::make_shared<AnchorTransformInstr>(*this);
+  }
   std::string target_;
   std::string result_;
   AnchorTransformRoute transform_route_;
@@ -189,6 +217,9 @@ struct PaddingInstr : public FusionInstruction {
                const std::vector<int>& padding_pos)
       : target_(target), result_(result), padding_pos_(padding_pos) {}
   virtual InstructionType type() const { return T_Padding; }
+  virtual FusionInstrPtr Clone() {
+    return std::make_shared<PaddingInstr>(*this);
+  }
   std::string target_;
   std::string result_;
   std::vector<int> padding_pos_;
@@ -198,8 +229,6 @@ struct PaddingInstr : public FusionInstruction {
   }
 };
 
-using FusionInstrPtr = std::shared_ptr<FusionInstruction>;
-
 template <typename T>
 std::shared_ptr<T> dynamic_cast_instr_with_err(FusionInstrPtr instr) {
   auto chile_instr = std::dynamic_pointer_cast<T>(instr);
@@ -218,6 +247,16 @@ struct FusionTracker {
     ExtendVector(&instructions_, down->instructions_);
   }
   void append(FusionInstrPtr instr) { instructions_.emplace_back(instr); }
+
+  FusionTrackerPtr Clone() {
+    auto new_tracker = std::make_shared<FusionTracker>();
+    std::vector<FusionInstrPtr> new_instructions;
+    for (auto instr : instructions_) {
+      new_tracker->append(instr->Clone());
+    }
+    return new_tracker;
+  }
+
   std::string DebugStr() const {
     std::stringstream ss;
     ss << "FusionTracker: \n";
diff --git a/paddle/cinn/operator_fusion/pattern.h b/paddle/cinn/operator_fusion/pattern.h
index ae080a46e4828f..d95ee026f6df9e 100644
--- a/paddle/cinn/operator_fusion/pattern.h
+++ b/paddle/cinn/operator_fusion/pattern.h
@@ -235,7 +235,7 @@ struct AnchorPattern {
   pir::Value anchor() const { return anchor_; }
   bool can_recompute() const {
     // Current Algorithm:
-    // An AnchorPattern can be recomputed iff:
+    // An AnchorPattern can be recomputed if:
     // 1. It didn't go through any pattern merging during prior fusions, which
     // means it only has one output_expr in anchor_state.
     // 2. It only contains trivial ops.
diff --git a/paddle/cinn/operator_fusion/pattern_graph.cc b/paddle/cinn/operator_fusion/pattern_graph.cc
index b93967e809e58d..64f26883c7a136 100644
--- a/paddle/cinn/operator_fusion/pattern_graph.cc
+++ b/paddle/cinn/operator_fusion/pattern_graph.cc
@@ -274,8 +274,8 @@ std::string PatternGraph::GraphInfo() const {
   std::stringstream ss;
   ss << "\n========= GraphInfo ===========";
   for (const auto& v : all_pattern_nodes_) {
-    ss << v->DebugStr();
-    ss << "\n    IsOutput: " << IsOutputNodeMatcher()(*this, v);
+    ss << "\n" << v->DebugStr();
+    ss << "    IsOutput: " << IsOutputNodeMatcher()(*this, v);
     ss << "\n    Loop Framework is: " << GetLoopFramework(v->stmt_pattern());
   }
   ss << "\n===============================";
diff --git a/test/ir/pir/cinn/test_anchor_fusion.py b/test/ir/pir/cinn/test_anchor_fusion.py
index a6befa4f5cc627..d3143392045a5a 100644
--- a/test/ir/pir/cinn/test_anchor_fusion.py
+++ b/test/ir/pir/cinn/test_anchor_fusion.py
@@ -138,6 +138,25 @@ def init():
 
         self.compare_result(func, None, init)
 
+    def test_anchor_fusion_6(self):
+        #      T
+        #     / \
+        #    B   R
+        #   /     \
+        #  T       T
+        def func(x):
+            a = x + 1
+            b = paddle.expand(a, [10, 32, 32, 128]) / 2
+            c = paddle.sum(a, axis=-1)
+            d = c * 3
+            return b, d
+
+        def init():
+            x = paddle.rand((32, 32, 128))
+            return (x,)
+
+        self.compare_result(func, None, init)
+
 
 if __name__ == "__main__":
     unittest.main()

From 63946aad32c20222f56f25c2ce783668480f1e4e Mon Sep 17 00:00:00 2001
From: huangjiyi <947613776@qq.com>
Date: Tue, 30 Jul 2024 06:52:29 +0000
Subject: [PATCH 96/99] revert fix reshape tmp

---
 .../graph_transformer/operation.h               | 17 +++++++----------
 1 file changed, 7 insertions(+), 10 deletions(-)

diff --git a/paddle/cinn/operator_fusion/graph_transformer/operation.h b/paddle/cinn/operator_fusion/graph_transformer/operation.h
index a52a6eb4941d91..0f13643308e29c 100644
--- a/paddle/cinn/operator_fusion/graph_transformer/operation.h
+++ b/paddle/cinn/operator_fusion/graph_transformer/operation.h
@@ -145,16 +145,13 @@ struct LiftToAnchorPatternOperation {
   PatternNodePtr operator()(PatternGraph* graph, PatternNodePtr node) {
     auto origin_name = node->id();
     std::vector<pir::Operation*> ops = GetOpsInPattern(node->stmt_pattern());
-    // TODO(huangjiyi): rm if condition after xshape removed in pd_op.reshape
-    if (node->sink_op()->name() != "pd_op.reshape") {
-      // TODO(@wuzhanfei) move sink_op into pattern (currently, part of pattern
-      // type has sink and the others not) then, update logic here
-      PADDLE_ENFORCE_EQ(
-          node->sink_op()->num_results(),
-          1,
-          phi::errors::PreconditionNotMet(
-              "Op with multi output value can not lift to AnchorPattern"));
-    }
+    // TODO(@wuzhanfei) move sink_op into pattern (currently, part of pattern
+    // type has sink and the others not) then, update logic here
+    PADDLE_ENFORCE_EQ(
+        node->sink_op()->num_results(),
+        1,
+        phi::errors::PreconditionNotMet(
+            "Op with multi output value can not lift to AnchorPattern"));
     pir::Value anchor = node->sink_op()->result(0);
     node->set_stmt_pattern(AnchorPattern(
         ops,

From cf4f9c4b2c56dc6c646f7e9a46f1283d2c66ab96 Mon Sep 17 00:00:00 2001
From: huangjiyi <947613776@qq.com>
Date: Wed, 31 Jul 2024 11:13:29 +0000
Subject: [PATCH 97/99] fix softmax

---
 .../hlir/framework/pir/trivial_op_impl.cc     | 25 ++++++++++++++++++-
 .../graph_transformer/matcher.h               | 20 +++++++++++----
 paddle/cinn/operator_fusion/pattern_fuser.h   |  4 ++-
 3 files changed, 42 insertions(+), 7 deletions(-)

diff --git a/paddle/cinn/hlir/framework/pir/trivial_op_impl.cc b/paddle/cinn/hlir/framework/pir/trivial_op_impl.cc
index 18b6939c8ab1e9..d9a96d65fa0395 100644
--- a/paddle/cinn/hlir/framework/pir/trivial_op_impl.cc
+++ b/paddle/cinn/hlir/framework/pir/trivial_op_impl.cc
@@ -15,6 +15,7 @@
 #include "paddle/cinn/hlir/framework/pir/trivial_op_impl.h"
 #include <variant>
 #include "paddle/cinn/operator_fusion/cluster_interface.h"
+#include "paddle/cinn/operator_fusion/fusion_tracker/expr_utils.h"
 #include "paddle/cinn/operator_fusion/pattern.h"
 
 #include "paddle/cinn/hlir/dialect/operator/ir/manual_op.h"
@@ -218,6 +219,19 @@ std::vector<ir::Var> GetReduceIters(const ReduceOp& op) {
   return AppendBound(reduce_iter_vars, _GetRootExpr(op));
 }
 
+std::vector<int> GetExpandVarPos(const ReduceOp& op) {
+  std::vector<ir::Var> all_iter_vars = GetAllForIters(_GetRootExpr(op));
+  VLOG(4) << "all_iter_vars: " << cinn::utils::Join(all_iter_vars, ", ");
+  std::vector<int> expand_pos;
+
+  for (int i = 0; i < all_iter_vars.size(); i++) {
+    if (all_iter_vars[i]->name.find("expand_var") == 0) {
+      expand_pos.push_back(i);
+    }
+  }
+  return expand_pos;
+}
+
 ir::Expr GetInitExpr(const ReduceOp& op) {
   const auto result =
       (ExprSetFinderUtils::ChildScheduleBlockRealizes *
@@ -504,7 +518,7 @@ void DebugPrintReduceVar(const FusibleOp& op) {
 }
 
 std::pair<TrivialOp, ReduceOp> SplitReduceOp(const ReduceOp& reduce_op) {
-  VLOG(4) << "DebugPrint Op Origin: ";
+  VLOG(4) << "Start SplitReduceOp";
   VLOG(4) << "DebugPrint Op Origin: " << _GetRootExpr(reduce_op);
   ir::Tensor reduce_out_tensor = GetOutputTensor(reduce_op);
   // substitude compute_body with a new init value.
@@ -559,6 +573,15 @@ std::pair<TrivialOp, ReduceOp> SplitReduceOp(const ReduceOp& reduce_op) {
                  ExprSetFinderUtils::Store2Value.GetSingle(new_reduce_body));
   const auto& result_reduce = ReduceOp(CreateExprWithNewComputeBody(
       reduce_op, ExprSetFinderUtils::Store2Value.GetSingle(new_reduce_body)));
+
+  auto expand_pos = GetExpandVarPos(reduce_op);
+  if (!expand_pos.empty()) {
+    auto pad_result_trivial = std::get<TrivialOp>(
+        cinn::fusion::DoPadding(result_trivial, expand_pos).back());
+    auto pad_result_reduce = std::get<ReduceOp>(
+        cinn::fusion::DoPadding(result_reduce, expand_pos).back());
+    return std::make_pair(pad_result_trivial, pad_result_reduce);
+  }
   VLOG(4) << "SplitReduceTransform End~";
   return std::make_pair(result_trivial, result_reduce);
 }
diff --git a/paddle/cinn/operator_fusion/graph_transformer/matcher.h b/paddle/cinn/operator_fusion/graph_transformer/matcher.h
index 1d21b9df9aaeb1..4382cc88d55bef 100644
--- a/paddle/cinn/operator_fusion/graph_transformer/matcher.h
+++ b/paddle/cinn/operator_fusion/graph_transformer/matcher.h
@@ -61,6 +61,7 @@ struct CanFuseReduceTreeAndTrivialMatcher {
            !node->downstream().empty() &&
            std::holds_alternative<TrivialPattern>(
                node->downstream().at(0)->stmt_pattern()) &&
+           node->downstream().at(0)->downstream().size() == 0 &&
            graph.policy_manager()
                .template GetPolicy<GeneralTopoPolicy>()
                ->CanFuse(node, node->downstream().at(0)) &&
@@ -242,10 +243,16 @@ struct HorizontalFusionConstrain {
     const auto& rhs_pattern =
         std::get<HorizontalFusionPattern>(rhs->stmt_pattern());
 
-    return graph.policy_manager().GetPolicy<GeneralTopoPolicy>()->CanFuse(
-               lhs, rhs) &&
-           IsLoopFrameworkEqual(lhs_pattern.padding_patterns_.back().pattern,
-                                rhs_pattern.padding_patterns_.back().pattern);
+    bool canfuse =
+        graph.policy_manager().GetPolicy<GeneralTopoPolicy>()->CanFuse(lhs,
+                                                                       rhs);
+    bool loop_equal =
+        IsLoopFrameworkEqual(lhs_pattern.padding_patterns_.back().pattern,
+                             rhs_pattern.padding_patterns_.back().pattern);
+    VLOG(4) << "HorizontalFusionConstrain: "
+            << "\ncanfuse: " << (canfuse ? "True" : "False")
+            << "\nloop_equal: " << (loop_equal ? "True" : "False");
+    return canfuse && loop_equal;
   }
 };
 
@@ -275,7 +282,9 @@ struct InputOutputMaximumConstrain {
     const auto& all_ops = GetAllOps(lhs, rhs);
     int input_number = GetInputValuesExceptMiddle(all_ops).size();
     int output_number = GetOutputValuesExceptMiddle(all_ops).size();
-    return input_number + output_number < MAX_INPUT_OUTPUT_NUMBER;
+    int res = input_number + output_number < MAX_INPUT_OUTPUT_NUMBER;
+    VLOG(4) << "InputOutputMaximumConstrain: " << res;
+    return res;
   }
 };
 
@@ -361,6 +370,7 @@ struct HorizontalCheckMiddleOutputVar {
     for (const auto& right_dims : right_dims_vec) {
       identical_dep &= IdenticalDepAll(graph, right_dims, left_dims_vec);
     }
+    VLOG(4) << "IdenticalDepAll: " << (identical_dep ? "True" : "False");
     return identical_dep;
   }
 };
diff --git a/paddle/cinn/operator_fusion/pattern_fuser.h b/paddle/cinn/operator_fusion/pattern_fuser.h
index b7d6e6000a7f72..921bd6b5beacef 100644
--- a/paddle/cinn/operator_fusion/pattern_fuser.h
+++ b/paddle/cinn/operator_fusion/pattern_fuser.h
@@ -113,10 +113,12 @@ static StmtPattern MergePatternImpl(const TrivialPattern& first,
 static StmtPattern MergePatternImpl(
     const TrivialPattern& first, const ReduceTreePlusTrivialPattern& second) {
   auto connect_ops = FindDownstreamOps(first.sink_op());
-  return ReduceTreePlusTrivialPattern(
+  auto result = ReduceTreePlusTrivialPattern(
       FusePatternIfConnected(first, second.tree, connect_ops),
       FusePatternIfConnected(first, second.sink_trivial, connect_ops),
       std::make_shared<FusionTracker>(first.tracker_, second.tracker_));
+  result.fake_reduce_iter_idx = second.fake_reduce_iter_idx;
+  return result;
 }
 
 static StmtPattern MergePatternImpl(const TrivialPattern& first,

From 0c7c52424d14e51f57a75ab51f916ed533ce9d67 Mon Sep 17 00:00:00 2001
From: huangjiyi <947613776@qq.com>
Date: Wed, 31 Jul 2024 11:16:39 +0000
Subject: [PATCH 98/99] fix

---
 .../graph_transformer/matcher.h               | 19 +++++--------------
 1 file changed, 5 insertions(+), 14 deletions(-)

diff --git a/paddle/cinn/operator_fusion/graph_transformer/matcher.h b/paddle/cinn/operator_fusion/graph_transformer/matcher.h
index 4382cc88d55bef..62fe2b9ea3d725 100644
--- a/paddle/cinn/operator_fusion/graph_transformer/matcher.h
+++ b/paddle/cinn/operator_fusion/graph_transformer/matcher.h
@@ -243,16 +243,10 @@ struct HorizontalFusionConstrain {
     const auto& rhs_pattern =
         std::get<HorizontalFusionPattern>(rhs->stmt_pattern());
 
-    bool canfuse =
-        graph.policy_manager().GetPolicy<GeneralTopoPolicy>()->CanFuse(lhs,
-                                                                       rhs);
-    bool loop_equal =
-        IsLoopFrameworkEqual(lhs_pattern.padding_patterns_.back().pattern,
-                             rhs_pattern.padding_patterns_.back().pattern);
-    VLOG(4) << "HorizontalFusionConstrain: "
-            << "\ncanfuse: " << (canfuse ? "True" : "False")
-            << "\nloop_equal: " << (loop_equal ? "True" : "False");
-    return canfuse && loop_equal;
+    return graph.policy_manager().GetPolicy<GeneralTopoPolicy>()->CanFuse(
+               lhs, rhs) &&
+           IsLoopFrameworkEqual(lhs_pattern.padding_patterns_.back().pattern,
+                                rhs_pattern.padding_patterns_.back().pattern);
   }
 };
 
@@ -282,9 +276,7 @@ struct InputOutputMaximumConstrain {
     const auto& all_ops = GetAllOps(lhs, rhs);
     int input_number = GetInputValuesExceptMiddle(all_ops).size();
     int output_number = GetOutputValuesExceptMiddle(all_ops).size();
-    int res = input_number + output_number < MAX_INPUT_OUTPUT_NUMBER;
-    VLOG(4) << "InputOutputMaximumConstrain: " << res;
-    return res;
+    return input_number + output_number < MAX_INPUT_OUTPUT_NUMBER;
   }
 };
 
@@ -370,7 +362,6 @@ struct HorizontalCheckMiddleOutputVar {
     for (const auto& right_dims : right_dims_vec) {
       identical_dep &= IdenticalDepAll(graph, right_dims, left_dims_vec);
     }
-    VLOG(4) << "IdenticalDepAll: " << (identical_dep ? "True" : "False");
     return identical_dep;
   }
 };

From 930f061a7f3f09f7bb7f6198a1c21f9b993eb020 Mon Sep 17 00:00:00 2001
From: huangjiyi <947613776@qq.com>
Date: Sun, 4 Aug 2024 06:33:29 +0000
Subject: [PATCH 99/99] fix test_sub_graph_23

---
 .../operator_fusion/graph_transformer/matcher.h | 17 +++++++++++++++++
 paddle/cinn/operator_fusion/pattern_graph.cc    |  6 ++++++
 2 files changed, 23 insertions(+)

diff --git a/paddle/cinn/operator_fusion/graph_transformer/matcher.h b/paddle/cinn/operator_fusion/graph_transformer/matcher.h
index 62fe2b9ea3d725..450a4c0e922078 100644
--- a/paddle/cinn/operator_fusion/graph_transformer/matcher.h
+++ b/paddle/cinn/operator_fusion/graph_transformer/matcher.h
@@ -151,6 +151,23 @@ struct HorizontalFusionMatcher {
   }
 };
 
+struct LEOneElementWiseDownstreamMatcher {
+  bool operator()(const PatternGraph& graph, const PatternNodePtr& node) {
+    size_t count = 0;
+    for (const auto& downsteram : node->downstream()) {
+      if (StmtPatternGraphMatcher<TrivialPattern>()(graph, downsteram)) {
+        auto ops = std::get<TrivialPattern>(downsteram->stmt_pattern()).ops();
+        bool is_elementwise =
+            std::all_of(ops.begin(), ops.end(), [](pir::Operation* op) {
+              return GetOpPatternKind(op) == hlir::framework::kElementWise;
+            });
+        count += is_elementwise;
+      }
+    }
+    return (count <= 1);
+  }
+};
+
 struct NonSinkNodeMatcher {
   bool operator()(const PatternGraph& graph, const PatternNodePtr& node) {
     return !node->downstream().empty();
diff --git a/paddle/cinn/operator_fusion/pattern_graph.cc b/paddle/cinn/operator_fusion/pattern_graph.cc
index 62fe1d65c1c2e1..f873e151f17430 100644
--- a/paddle/cinn/operator_fusion/pattern_graph.cc
+++ b/paddle/cinn/operator_fusion/pattern_graph.cc
@@ -133,6 +133,12 @@ void PatternGraph::SinkTrivialPattern() {
                        DownstreamSmallerThan<2>,
                        NonSinkNodeMatcher>,
                    MergeTrivialPatternOperation>(this);
+
+  GraphTransformer<NodePattern,
+                   And<StmtPatternGraphMatcher<TrivialPattern>,
+                       NonSinkNodeMatcher,
+                       LEOneElementWiseDownstreamMatcher>,
+                   MergeTrivialPatternOperation>(this);
 }
 
 void PatternGraph::ReduceLiftReduceTree() {