PaddlePaddle
diff --git a/‎paddle/cinn/adt/equation_util.h
Copy file name to clipboard
+8-8Lines changed: 8 additions & 8 deletions b/‎paddle/cinn/adt/equation_util.h
Copy file name to clipboard
+8-8Lines changed: 8 additions & 8 deletions
diff --git a/‎paddle/cinn/adt/m_ir.cc
Copy file name to clipboard
+2-2Lines changed: 2 additions & 2 deletions b/‎paddle/cinn/adt/m_ir.cc
Copy file name to clipboard
+2-2Lines changed: 2 additions & 2 deletions
diff --git a/‎paddle/cinn/adt/naive_op_equation_context.h
Copy file name to clipboard
+12-12Lines changed: 12 additions & 12 deletions b/‎paddle/cinn/adt/naive_op_equation_context.h
Copy file name to clipboard
+12-12Lines changed: 12 additions & 12 deletions
diff --git a/‎paddle/cinn/adt/partition_op_stmts.cc
Copy file name to clipboard
+12-11Lines changed: 12 additions & 11 deletions b/‎paddle/cinn/adt/partition_op_stmts.cc
Copy file name to clipboard
+12-11Lines changed: 12 additions & 11 deletions
diff --git a/‎paddle/cinn/adt/simplify_value.cc
Copy file name to clipboard
+15-15Lines changed: 15 additions & 15 deletions b/‎paddle/cinn/adt/simplify_value.cc
Copy file name to clipboard
+15-15Lines changed: 15 additions & 15 deletions
diff --git a/‎paddle/cinn/auto_schedule/search_space/auto_gen_rule/auto_inline.cc
Copy file name to clipboard
+7-7Lines changed: 7 additions & 7 deletions b/‎paddle/cinn/auto_schedule/search_space/auto_gen_rule/auto_inline.cc
Copy file name to clipboard
+7-7Lines changed: 7 additions & 7 deletions
@@ -75,18 +75,18 @@ EquationGraphTopoWalker<VT, FT> GetSubgraph(
       };
   const auto& VisitInputVariables =
       [graph, IsSelected](FT function, const std::function<void(VT)>& Visit) {
-        PADDLE_ENFORCE_EQ(
-            IsSelected(function),
-            true,
-            phi::errors::PreconditionNotMet("The function must be selected."));
+        PADDLE_ENFORCE_EQ(IsSelected(function),
+                          true,
+                          ::common::errors::PreconditionNotMet(
+                              "The function must be selected."));
         graph.VisitInputVariables(function, Visit);
       };
   const auto& VisitOutputVariables =
       [graph, IsSelected](FT function, const std::function<void(VT)>& Visit) {
-        PADDLE_ENFORCE_EQ(
-            IsSelected(function),
-            true,
-            phi::errors::PreconditionNotMet("The function must be selected."));
+        PADDLE_ENFORCE_EQ(IsSelected(function),
+                          true,
+                          ::common::errors::PreconditionNotMet(
+                              "The function must be selected."));
         graph.VisitOutputVariables(function, Visit);
       };
   return EquationGraphTopoWalker<VT, FT>(
 
@@ -178,8 +178,8 @@ std::unordered_map<Index, LoopIterators> GenerateAnchorIndex2LoopIterators(
     PADDLE_ENFORCE_EQ(
         anchor_index2loop_iters.emplace(anchor_index, anchor_loop_iters).second,
         true,
-        phi::errors::AlreadyExists("The anchor index has already "
-                                   "been associated with loop iters."));
+        ::common::errors::AlreadyExists("The anchor index has already "
+                                        "been associated with loop iters."));
   }
   return anchor_index2loop_iters;
 }
 
@@ -86,13 +86,13 @@ class NaiveOpEquationContext final : public OpEquationContext {
   }
 
   void Equal(const IteratorTuple& lhs, const IteratorTuple& rhs) override {
-    PADDLE_ENFORCE_EQ(
-        lhs->size(),
-        rhs->size(),
-        phi::errors::InvalidArgument("The sizes of lhs and rhs must be equal. "
-                                     "lhs size: %d, rhs size: %d",
-                                     lhs->size(),
-                                     rhs->size()));
+    PADDLE_ENFORCE_EQ(lhs->size(),
+                      rhs->size(),
+                      ::common::errors::InvalidArgument(
+                          "The sizes of lhs and rhs must be equal. "
+                          "lhs size: %d, rhs size: %d",
+                          lhs->size(),
+                          rhs->size()));
     for (std::size_t i = 0; i < lhs->size(); ++i) {
       this->Equal(lhs->at(i), rhs->at(i));
     }
@@ -259,7 +259,7 @@ class NaiveOpEquationContext final : public OpEquationContext {
         const auto& opt_expr = GetSymbolicInDim_(i, j);
         PADDLE_ENFORCE_EQ(opt_expr.has_value(),
                           true,
-                          phi::errors::InvalidArgument(
+                          ::common::errors::InvalidArgument(
                               "The optional expression must have a value."));
         vec->at(i)->emplace_back(opt_expr.value());
       }
@@ -274,7 +274,7 @@ class NaiveOpEquationContext final : public OpEquationContext {
         const auto& opt_expr = GetSymbolicOutDim_(i, j);
         PADDLE_ENFORCE_EQ(opt_expr.has_value(),
                           true,
-                          phi::errors::InvalidArgument(
+                          ::common::errors::InvalidArgument(
                               "The optional expression must have a value at "
                               "tensor index %d and dimension index %d.",
                               i,
@@ -288,7 +288,7 @@ class NaiveOpEquationContext final : public OpEquationContext {
                  const DimTuple& dim_tuple) {
     PADDLE_ENFORCE_EQ(iterator_tuple->size(),
                       dim_tuple->size(),
-                      phi::errors::InvalidArgument(
+                      ::common::errors::InvalidArgument(
                           "The sizes of iterator_tuple and dim_tuple must be "
                           "equal. iterator_tuple size: %d, dim_tuple size: %d",
                           iterator_tuple->size(),
@@ -343,8 +343,8 @@ class NaiveOpEquationContext final : public OpEquationContext {
     PADDLE_ENFORCE_EQ(
         iter != attr_map_type_.end(),
         true,
-        phi::errors::InvalidArgument("Can't find Attribute with this name: %s",
-                                     name.c_str()));
+        ::common::errors::InvalidArgument(
+            "Can't find Attribute with this name: %s", name.c_str()));
     return iter->second;
   }
 
 
@@ -60,7 +60,7 @@ std::pair<std::optional<OpStmt>, List<OpStmt>> FindVisitedOpStmts(
     if (valid) {
       PADDLE_ENFORCE_EQ(opt_anchor_op_stmt.has_value(),
                         false,
-                        phi::errors::InvalidArgument(
+                        ::common::errors::InvalidArgument(
                             "The opt_anchor_op_stmt must not have a value."));
       opt_anchor_op_stmt = op_stmt;
     }
@@ -137,7 +137,7 @@ void MakeGetters4Indexes(
         PADDLE_ENFORCE_EQ(
             index2as_output->emplace(index, as_output).second,
             true,
-            phi::errors::InvalidArgument(
+            ::common::errors::InvalidArgument(
                 "Failed to emplace the new element into index2as_output."));
       };
 
@@ -153,7 +153,7 @@ void MakeGetters4Indexes(
         direction_equation_generator->OutMsgIndex4InMsgIndex(index);
     PADDLE_ENFORCE_EQ(out_msg_index.has_value(),
                       true,
-                      phi::errors::InvalidArgument(
+                      ::common::errors::InvalidArgument(
                           "The out_msg_index must not have a value."));
     return out_msg_index.value();
   };
@@ -200,7 +200,7 @@ void VisitProducerConsumerPair(const std::vector<Index>& tensor_indexes,
                                const DoEachT& DoEach) {
   PADDLE_ENFORCE_EQ(tensor_indexes.empty(),
                     false,
-                    phi::errors::InvalidArgument(
+                    ::common::errors::InvalidArgument(
                         "The tensor_indexes container must not be empty."));
   if (AsOutput4Index(tensor_indexes.at(0)).value()) {  // Write first
     auto producer = tensor_indexes.at(0);
@@ -215,7 +215,7 @@ void VisitProducerConsumerPair(const std::vector<Index>& tensor_indexes,
       PADDLE_ENFORCE_EQ(
           AsOutput4Index(tensor_index).value(),
           false,
-          phi::errors::InvalidArgument(
+          ::common::errors::InvalidArgument(
               "The value returned by AsOutput4Index(tensor_index).value() must "
               "be false."));
     }
@@ -317,8 +317,9 @@ void UpdateAnchorIndex2AnchorGroup(
       anchor_index2igroup_spec->emplace(igroup_spec.anchor_index, igroup_spec)
           .second,
       true,
-      phi::errors::InvalidArgument("Failed to emplace the element into the "
-                                   "map. The key might already exist."));
+      ::common::errors::InvalidArgument(
+          "Failed to emplace the element into the "
+          "map. The key might already exist."));
 }
 
 void EraseCandidateAnchorIndexes(
@@ -345,7 +346,7 @@ std::unordered_map<AnchorIndex, AnchorGroup> PartitionOpStmtsIntoAnchorGroups(
         direction_equation_generator) {
   PADDLE_ENFORCE_EQ(op_stmts->empty(),
                     false,
-                    phi::errors::InvalidArgument(
+                    ::common::errors::InvalidArgument(
                         "The op_stmts container must not be empty."));
   std::unordered_map<AnchorIndex, AnchorGroup> anchor_index2igroup_spec{};
 
@@ -380,7 +381,7 @@ std::unordered_map<AnchorIndex, AnchorGroup> PartitionOpStmtsIntoAnchorGroups(
     }
     PADDLE_ENFORCE_EQ(opt_anchor_op_stmt.has_value(),
                       true,
-                      phi::errors::InvalidArgument(
+                      ::common::errors::InvalidArgument(
                           "The opt_anchor_op_stmt must not have a value."));
     all_visited_op_stmts.insert(visited_op_stmts->begin(),
                                 visited_op_stmts->end());
@@ -447,7 +448,7 @@ void CheckEquationSolvable(const AnchorGroup& igroup_spec,
   AggregateAnchorGroupOpStmt(igroup_spec, [&](const auto& op_stmt) {
     PADDLE_ENFORCE_EQ(IsOpSolved(op_stmt),
                       true,
-                      phi::errors::InvalidArgument(
+                      ::common::errors::InvalidArgument(
                           "The operation statement must be solved."));
     return tBreak<bool>{false};
   });
@@ -461,7 +462,7 @@ std::function<std::size_t(const OpStmt&)> MakeGetterOrderValue4OpStmt(
     PADDLE_ENFORCE_EQ(
         op_stmt2order_value->emplace(op_stmts->at(idx), idx).second,
         true,
-        phi::errors::InvalidArgument(
+        ::common::errors::InvalidArgument(
             "Failed to emplace the element into op_stmt2order_value. The key "
             "might already exist."));
   }
 
@@ -112,10 +112,10 @@ struct SimplifyDotUndot {
         pre_index_undot = index_undot_value;
       }
     }
-    PADDLE_ENFORCE_EQ(
-        pre_index_undot.has_value(),
-        true,
-        phi::errors::InvalidArgument("pre_index_undot should not be null"));
+    PADDLE_ENFORCE_EQ(pre_index_undot.has_value(),
+                      true,
+                      ::common::errors::InvalidArgument(
+                          "pre_index_undot should not be null"));
     const auto& [index_value, undot_dims] =
         pre_index_undot.value()
             .Get<IndexUnDotValue<Value, List<DimExpr>>>()
@@ -200,11 +200,11 @@ struct SimplifyGcdShape {
     const auto& dot_dim_values = dot_dims;
     PADDLE_ENFORCE_EQ(IsConstantListAllPositiveInt64(undot_dim_values),
                       true,
-                      phi::errors::InvalidArgument(
+                      ::common::errors::InvalidArgument(
                           "The undot_dim_values should be all positive int64"));
     PADDLE_ENFORCE_EQ(IsConstantListAllPositiveInt64(dot_dim_values),
                       true,
-                      phi::errors::InvalidArgument(
+                      ::common::errors::InvalidArgument(
                           "The dot_dim_values should be all positive int64"));
     const auto& sub_reshape_dim_ranges =
         GetSubReshapeDimRanges(undot_dim_values, dot_dim_values);
@@ -332,7 +332,7 @@ struct SimplifyDotDot {
       PADDLE_ENFORCE_EQ(
           dim.Has<std::int64_t>(),
           true,
-          phi::errors::InvalidArgument("dim should have std::int64_t"));
+          ::common::errors::InvalidArgument("dim should have std::int64_t"));
       ret *= dim.Get<std::int64_t>();
     }
     return ret;
@@ -411,10 +411,10 @@ struct SymbolicDim_SimplifyDotUndot {
         pre_index_undot = index_undot_value;
       }
     }
-    PADDLE_ENFORCE_EQ(
-        pre_index_undot.has_value(),
-        true,
-        phi::errors::InvalidArgument("pre_index_undot should not be null"));
+    PADDLE_ENFORCE_EQ(pre_index_undot.has_value(),
+                      true,
+                      ::common::errors::InvalidArgument(
+                          "pre_index_undot should not be null"));
     const auto& [index_value, undot_dims] =
         pre_index_undot.value()
             .Get<IndexUnDotValue<Value, List<DimExpr>>>()
@@ -461,10 +461,10 @@ struct SymbolicDim_SimplifyDotUndot_DimExpr {
         pre_index_undot = index_undot_value;
       }
     }
-    PADDLE_ENFORCE_EQ(
-        pre_index_undot.has_value(),
-        true,
-        phi::errors::InvalidArgument("pre_index_undot should not be null"));
+    PADDLE_ENFORCE_EQ(pre_index_undot.has_value(),
+                      true,
+                      ::common::errors::InvalidArgument(
+                          "pre_index_undot should not be null"));
     const auto& [index_value, undot_dims] =
         pre_index_undot.value()
             .Get<IndexUnDotValue<Value, List<DimExpr>>>()
 
@@ -200,18 +200,18 @@ void AutoInline::Apply(int index) {
   PADDLE_ENFORCE_EQ(
       ir_schedule_ != nullptr,
       true,
-      phi::errors::InvalidArgument("Run AutoInline::Apply without Init"));
+      ::common::errors::InvalidArgument("Run AutoInline::Apply without Init"));
 
   PADDLE_ENFORCE_EQ(
       num_applicable_ > 0 && apply_indices_and_type_.size() == num_applicable_,
       true,
-      phi::errors::InvalidArgument(
+      ::common::errors::InvalidArgument(
           "AutoInline::Apply pre-condition doesn't meet"));
 
   PADDLE_ENFORCE_EQ(
       index >= 0 && num_applicable_ > index,
       true,
-      phi::errors::InvalidArgument(
+      ::common::errors::InvalidArgument(
           "Invalid index for AutoInline::Apply, the index needs 0 <= index && "
           "index < NumberApplicable(), "
           "Currently index = %d, NumberApplicable() = %d",
@@ -231,8 +231,8 @@ RuleApplyType AutoInline::AnalyseApplyType(
   auto* block_realize = block_expr.As<ir::ScheduleBlockRealize>();
   PADDLE_ENFORCE_NOT_NULL(
       block_realize,
-      phi::errors::InvalidArgument("stmt is not a ScheduleBlockRealize: %s",
-                                   block_expr));
+      ::common::errors::InvalidArgument(
+          "stmt is not a ScheduleBlockRealize: %s", block_expr));
 
   AnalyzeScheduleBlockReadWriteBuffer(
       block_realize->schedule_block.As<ir::ScheduleBlock>());
@@ -256,8 +256,8 @@ void AutoInline::Apply(ir::IRSchedule* ir_schedule, ir::Expr& block_expr) {
   auto* block_realize = block_expr.As<ir::ScheduleBlockRealize>();
   PADDLE_ENFORCE_NOT_NULL(
       block_realize,
-      phi::errors::InvalidArgument("stmt is not a ScheduleBlockRealize: %s",
-                                   block_expr));
+      ::common::errors::InvalidArgument(
+          "stmt is not a ScheduleBlockRealize: %s", block_expr));
 
   AnalyzeScheduleBlockReadWriteBuffer(
       block_realize->schedule_block.As<ir::ScheduleBlock>());
Original file line number	Diff line number	Diff line change
`@@ -178,8 +178,8 @@ std::unordered_map<Index, LoopIterators> GenerateAnchorIndex2LoopIterators(`
`178`	`178`	`PADDLE_ENFORCE_EQ(`
`179`	`179`	`anchor_index2loop_iters.emplace(anchor_index, anchor_loop_iters).second,`
`180`	`180`	`true,`
`181`		`- phi::errors::AlreadyExists("The anchor index has already "`
`182`		`- "been associated with loop iters."));`
	`181`	`+ ::common::errors::AlreadyExists("The anchor index has already "`
	`182`	`+ "been associated with loop iters."));`
`183`	`183`	`}`
`184`	`184`	`return anchor_index2loop_iters;`
`185`	`185`	`}`