PaddlePaddle
diff --git a/‎paddle/cinn/operator_fusion/fusion_tracker/expr_utils.cc
Copy file name to clipboard
-15Lines changed: 0 additions & 15 deletions b/‎paddle/cinn/operator_fusion/fusion_tracker/expr_utils.cc
Copy file name to clipboard
-15Lines changed: 0 additions & 15 deletions
diff --git a/‎paddle/cinn/operator_fusion/fusion_tracker/expr_utils.h
Copy file name to clipboard
-3Lines changed: 0 additions & 3 deletions b/‎paddle/cinn/operator_fusion/fusion_tracker/expr_utils.h
Copy file name to clipboard
-3Lines changed: 0 additions & 3 deletions
diff --git a/‎paddle/cinn/operator_fusion/fusion_tracker/interpreter.cc
Copy file name to clipboard
-12Lines changed: 0 additions & 12 deletions b/‎paddle/cinn/operator_fusion/fusion_tracker/interpreter.cc
Copy file name to clipboard
-12Lines changed: 0 additions & 12 deletions
diff --git a/‎paddle/cinn/operator_fusion/fusion_tracker/tracker.h
Copy file name to clipboard
-20Lines changed: 0 additions & 20 deletions b/‎paddle/cinn/operator_fusion/fusion_tracker/tracker.h
Copy file name to clipboard
-20Lines changed: 0 additions & 20 deletions
diff --git a/‎paddle/cinn/operator_fusion/graph_transformer/matcher.h
Copy file name to clipboard
-91Lines changed: 0 additions & 91 deletions b/‎paddle/cinn/operator_fusion/graph_transformer/matcher.h
Copy file name to clipboard
-91Lines changed: 0 additions & 91 deletions
diff --git a/‎paddle/cinn/operator_fusion/graph_transformer/operation.h
Copy file name to clipboard
-14Lines changed: 0 additions & 14 deletions b/‎paddle/cinn/operator_fusion/graph_transformer/operation.h
Copy file name to clipboard
-14Lines changed: 0 additions & 14 deletions
diff --git a/‎paddle/cinn/operator_fusion/pattern.h
Copy file name to clipboard
+8-57Lines changed: 8 additions & 57 deletions b/‎paddle/cinn/operator_fusion/pattern.h
Copy file name to clipboard
+8-57Lines changed: 8 additions & 57 deletions
@@ -232,19 +232,4 @@ ir::Expr UnSqueezeExpr(const ir::Expr& expr,
   return result;
 }
 
-std::vector<FusibleOp> DoPadding(const FusibleOp& fusion_op,
-                                 const std::vector<int>& padding_pos) {
-  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;
-}
-
 }  // namespace cinn::fusion
@@ -50,9 +50,6 @@ std::vector<ir::Expr> GetFusibleOpsExpr(std::vector<FusibleOp> fusion_ops);
 
 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);
-
 std::vector<ir::Tensor> GetOutputTensors(const ir::Expr& op_expr);
 
 }  // namespace cinn::fusion
@@ -184,15 +184,6 @@ void RunAxisTransformInstr(const std::shared_ptr<AxisTransformInstr>& instr,
   interpreter->scope[instr->target_] = 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) {
   using namespace cinn::hlir::framework::pir::trivial_fusion_detail;  // NOLINT
@@ -240,9 +231,6 @@ std::vector<ir::Expr> FusionInterpreter::Run() {
         RunTmpTransformInstr(
             dynamic_cast_instr_with_err<TmpTransformInstr>(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);
         break;
 
@@ -25,11 +25,9 @@ enum InstructionType {
   T_Return,
   T_InitPattern,
   T_TrivialInline,
-  T_ReshapeAlign,
   T_TmpTransform,
   T_TrivialLoopAlign,
   T_AxisTransform,
-  T_Padding
 };
 
 struct FusionInstruction {
@@ -216,24 +214,6 @@ struct AxisTransformInstr : public FusionInstruction {
   }
 };
 
-struct PaddingInstr : public FusionInstruction {
-  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() const { return T_Padding; }
-  virtual FusionInstrPtr Clone() {
-    return std::make_shared<PaddingInstr>(*this);
-  }
-  std::string target_;
-  std::string result_;
-  std::vector<int> padding_pos_;
-
-  virtual std::string DebugStr() const {
-    return "PaddingInstr || " + target_ + " => " + result_;
-  }
-};
-
 template <typename T>
 std::shared_ptr<T> dynamic_cast_instr_with_err(FusionInstrPtr instr) {
   auto chile_instr = std::dynamic_pointer_cast<T>(instr);
 
@@ -349,95 +349,4 @@ struct HorizontalFusionConstrain {
   }
 };
 
-struct HorizontalCheckMiddleOutputVar {
-  bool DontHaveMiddleVariable(const PatternGraph& graph,
-                              const PatternNodePtr& lhs,
-                              const PatternNodePtr& rhs) {
-    for (const auto& i : lhs->downstream()) {
-      if (i == rhs) return false;
-    }
-    for (const auto& i : lhs->upstream()) {
-      if (i == rhs) return false;
-    }
-    return true;
-  }
-
-  std::vector<ValueDim> SqueezedValueDim(const LoopValueDims& vdims) {
-    return FilterVector(vdims, [](const ValueDim& v) {
-      return !v.empty() && GetDimExprsFromValue(v.v_)[v.idx_] != 1;
-    });
-  }
-
-  bool IdenticalDep(const PatternGraph& graph,
-                    const LoopValueDims& lhs_dims,
-                    const LoopValueDims& rhs_dims) {
-    auto sp = graph.policy_manager().template GetPolicy<RelativeJudgePolicy>();
-    auto get_axes_from_valuedim = [&](const ValueDim& vdim) {
-      return (sp->GetAxesInfoManager()).GetAxes(vdim.v_).axis_names[vdim.idx_];
-    };
-    VLOG(4) << "origin lhs_dims.size() = " << lhs_dims.size();
-    VLOG(4) << "origin rhs_dims.size() = " << rhs_dims.size();
-    std::vector<ValueDim> lhs_squeeze_value_dim = SqueezedValueDim(lhs_dims);
-    std::vector<ValueDim> rhs_squeeze_value_dim = SqueezedValueDim(rhs_dims);
-
-    if (VLOG_IS_ON(4)) {
-      VLOG(4) << "lhs_squeeze_value_dim is : ";
-      for (int i = 0; i < lhs_squeeze_value_dim.size(); ++i) {
-        VLOG(4) << "    " << i << " = " << lhs_squeeze_value_dim[i].DebugStr();
-        VLOG(4) << "    "
-                << "shardable axes: "
-                << get_axes_from_valuedim(lhs_squeeze_value_dim[i]);
-      }
-      VLOG(4) << "lhs_squeeze_value_dim is : ";
-      if (VLOG_IS_ON(4)) {
-        for (int i = 0; i < rhs_squeeze_value_dim.size(); ++i) {
-          VLOG(4) << "    " << i << " = "
-                  << rhs_squeeze_value_dim[i].DebugStr();
-          VLOG(4) << "    "
-                  << "shardable axes: "
-                  << get_axes_from_valuedim(rhs_squeeze_value_dim[i]);
-        }
-      }
-    }
-
-    // compare non_one value dims of
-    PADDLE_ENFORCE_EQ(
-        lhs_squeeze_value_dim.size(),
-        rhs_squeeze_value_dim.size(),
-        ::common::errors::PreconditionNotMet(
-            "lhs squeezed dims is not equal to rhs squeezed dims"));
-    for (int i = 0; i < lhs_squeeze_value_dim.size(); ++i) {
-      if (get_axes_from_valuedim(lhs_squeeze_value_dim[i]) !=
-          get_axes_from_valuedim(rhs_squeeze_value_dim[i]))
-        return false;
-    }
-    return true;
-  }
-  bool IdenticalDepAll(const PatternGraph& graph,
-                       const LoopValueDims& rhs_dims,
-                       const std::vector<LoopValueDims> lhs_dims_vec) {
-    std::function<bool(const LoopValueDims)> is_identical_dep =
-        [&](const LoopValueDims out) {
-          return IdenticalDep(graph, rhs_dims, out);
-        };
-    return All(MapVector(lhs_dims_vec, is_identical_dep));
-  }
-  bool operator()(const PatternGraph& graph,
-                  const PatternNodePtr& lhs,
-                  const PatternNodePtr& rhs) {
-    // Middle Variable Must be ( id-dependent ) to support horizontal fusion.
-    if (DontHaveMiddleVariable(graph, lhs, rhs)) return true;
-    // TODO(huangjiyi): Support horizontal fusion for patterns with dependency
-    // relationship
-    // const auto& left_dims_vec = GetLoopValueDims(lhs->stmt_pattern());
-    // const auto& right_dims_vec = GetLoopValueDims(rhs->stmt_pattern());
-    // bool identical_dep = true;
-    // for (const auto& right_dims : right_dims_vec) {
-    // identical_dep &= IdenticalDepAll(graph, right_dims, left_dims_vec);
-    //}
-    // return identical_dep;
-    return false;
-  }
-};
-
 }  // namespace cinn::fusion
@@ -129,20 +129,6 @@ struct LiftReduceToReduceTreeOperation {
   }
 };
 
-struct LiftToHorizontalFusionPatternOperation {
-  PatternNodePtr operator()(PatternGraph* graph, PatternNodePtr node) {
-    auto origin_name = node->id();
-    node->set_stmt_pattern(HorizontalFusionPattern(
-        {typename HorizontalFusionPattern::PaddingStmtPattern(
-            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;
-  }
-};
-
 struct LiftToAnchorPatternOperation {
   PatternNodePtr operator()(PatternGraph* graph, PatternNodePtr node) {
     std::string origin_name = node->id();
 
@@ -207,20 +207,6 @@ struct AnchorPattern : public PatternBase {
   DEFINE_PATTERN_STATIC_ATTR(Anchor);
 };
 
-struct HorizontalFusionPattern : public PatternBase {
-  struct PaddingStmtPattern;
-  explicit HorizontalFusionPattern(
-      const std::vector<PaddingStmtPattern>& patterns,
-      const FusionTrackerPtr& tracker)
-      : PatternBase(UniqueId(), tracker), padding_patterns_(patterns) {}
-  DEFINE_PATTERN_STATIC_ATTR(Horizontal);
-
-  std::vector<PaddingStmtPattern> padding_patterns_;
-
-  std::vector<pir::Operation*> ops() const;
-  void update_tracker() const;
-};
-
 struct UnsupportedPattern : public PatternBase {
   explicit UnsupportedPattern(const std::vector<pir::Operation*>& ops,
                               const FusionTrackerPtr& tracker)
@@ -233,51 +219,8 @@ using StmtPattern = std::variant<TrivialPattern,
                                  ReduceTreePattern,
                                  ReduceTreePlusTrivialPattern,
                                  AnchorPattern,
-                                 HorizontalFusionPattern,
                                  UnsupportedPattern>;
 
-static std::string GetPatternId(const StmtPattern& s);
-static 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) {}
-};
-
-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];
-    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()));
-}
-
-inline 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;
-}
-
-static 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 PatternType GetPatternType(const StmtPattern& s) {
   return std::visit([](const auto& impl) { return impl.type(); }, s);
 }
@@ -336,4 +279,12 @@ static void PatternUpdateTracker(const StmtPattern& pattern) {
   return std::visit([](const auto& impl) { impl.update_tracker(); }, pattern);
 }
 
+static 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();
+}
+
 }  // namespace cinn::fusion