PaddlePaddle
diff --git a/‎paddle/cinn/adt/generate_map_expr.cc
Copy file name to clipboard
+27-8Lines changed: 27 additions & 8 deletions b/‎paddle/cinn/adt/generate_map_expr.cc
Copy file name to clipboard
+27-8Lines changed: 27 additions & 8 deletions
diff --git a/‎paddle/cinn/adt/inline_translator.h
Copy file name to clipboard
+28-7Lines changed: 28 additions & 7 deletions b/‎paddle/cinn/adt/inline_translator.h
Copy file name to clipboard
+28-7Lines changed: 28 additions & 7 deletions
diff --git a/‎paddle/cinn/hlir/op/contrib/argmax.cc
Copy file name to clipboard
+51-34Lines changed: 51 additions & 34 deletions b/‎paddle/cinn/hlir/op/contrib/argmax.cc
Copy file name to clipboard
+51-34Lines changed: 51 additions & 34 deletions
diff --git a/‎paddle/cinn/hlir/op/contrib/argmin.cc
Copy file name to clipboard
+44-26Lines changed: 44 additions & 26 deletions b/‎paddle/cinn/hlir/op/contrib/argmin.cc
Copy file name to clipboard
+44-26Lines changed: 44 additions & 26 deletions
@@ -170,7 +170,11 @@ hlir::framework::OpPatternKind GetOpPatternKind(const ::pir::Operation* node) {
 bool CollectRewrittenReductionOpStmts(const OpStmt& op_stmt,
                                       List<OpStmt>* ret) {
   const auto& [op, inputs, outputs] = op_stmt.tuple();
-  CHECK(op.Has<const ::pir::Operation*>());
+  PADDLE_ENFORCE_EQ(
+      op.Has<const ::pir::Operation*>(),
+      true,
+      phi::errors::InvalidArgument(
+          "The op should have a value of type ::pir::Operation*"));
   if (GetOpPatternKind(op.Get<const ::pir::Operation*>()) ==
       hlir::framework::OpPatternKind::kReduction) {
     tReduceInit<const ::pir::Operation*> init_op{
@@ -234,7 +238,10 @@ std::vector<std::shared_ptr<IGroup>> GenerateIGroups(
   std::vector<std::shared_ptr<IGroup>> ret{};
 
   List<OpStmt> op_stmts = MakeOpStmts(group);
-  CHECK(!op_stmts->empty());
+  PADDLE_ENFORCE_EQ(
+      !op_stmts->empty(),
+      true,
+      phi::errors::InvalidArgument("The op_stmts should not be empty"));
 
   PartitionIGroupOpStmts(op_stmts, [&](const auto& igroup_spec) {
     ret.push_back(MakeIGroup(igroup_spec));
@@ -271,9 +278,12 @@ std::unordered_map<Variable, const Value> MakeSdIterator2Iterator(
   std::unordered_map<Variable, const Value> ret{};
 
   for (std::size_t i = 0; i < igroup.loop_iterators()->size(); ++i) {
-    CHECK(ret.emplace(igroup.loop_iterators()->at(i),
-                      igroup.loop_iterators()->at(i))
-              .second);
+    PADDLE_ENFORCE_EQ(
+        ret.emplace(igroup.loop_iterators()->at(i),
+                    igroup.loop_iterators()->at(i))
+            .second,
+        true,
+        phi::errors::InvalidArgument("The loop iterator should be unique"));
   }
 
   return ret;
@@ -334,7 +344,10 @@ LoopDescriptor4IterVarT MakeGetterLoopDescriptor4IterVar(
   using Cache = std::unordered_map<Iterator, LoopDescriptor>;
   const auto& sd_iter2sd = std::make_shared<Cache>();
   for (std::size_t i = 0; i < loop_iters->size(); ++i) {
-    CHECK(sd_iter2sd->emplace(loop_iters->at(i), sd->at(i)).second);
+    PADDLE_ENFORCE_EQ(
+        sd_iter2sd->emplace(loop_iters->at(i), sd->at(i)).second,
+        true,
+        phi::errors::InvalidArgument("The loop iterator should be unique"));
   }
   return [sd_iter2sd](const auto& sd_iter) { return sd_iter2sd->at(sd_iter); };
 }
@@ -343,7 +356,10 @@ TreeMerger<Stmt> MakeTreeMerger(const MapIr& map_ir) {
   using Cache = std::unordered_map<OpStmt, LoopIterators>;
   auto cache = std::make_shared<Cache>();
   for (const auto& op_stmt : *(map_ir.op_stmts())) {
-    CHECK(cache->emplace(op_stmt, map_ir.loop_iterators()).second);
+    PADDLE_ENFORCE_EQ(
+        cache->emplace(op_stmt, map_ir.loop_iterators()).second,
+        true,
+        phi::errors::InvalidArgument("The op_stmt should be unique"));
   }
 
   TreeMerger<Stmt> tree_merger{};
@@ -365,7 +381,10 @@ MapStmt<Stmt> MakeMapStmt(const MapIrList& map_irs) {
       1UL,
       ::common::errors::InvalidArgument(
           "The size of stmts should be 1, but got %d.", stmts->size()));
-  CHECK(stmts->at(0).Has<MapStmt<Stmt>>());
+  PADDLE_ENFORCE_EQ(stmts->at(0).Has<MapStmt<Stmt>>(),
+                    true,
+                    phi::errors::InvalidArgument(
+                        "The stmts should have a value of type MapStmt<Stmt>"));
   return stmts->at(0).Get<MapStmt<Stmt>>();
 }
 
 
@@ -33,7 +33,10 @@ struct InlineTranslator final {
   using DstTree = Tree<MapT, DstLeaf>;
 
   static DstTree Call(const SrcTree& src_tree) {
-    CHECK((src_tree.template Has<MapT<SrcTree>>()));
+    PADDLE_ENFORCE_EQ((src_tree.template Has<MapT<SrcTree>>()),
+                      true,
+                      phi::errors::InvalidArgument(
+                          "src_tree.template should have <MapT<SrcTree>>()"));
     const MapT<DstTree> dst_tree =
         CallMap(src_tree.template Get<MapT<SrcTree>>());
 
@@ -97,7 +100,10 @@ struct InlineTranslator final {
     const auto& arg = op_call_children->at(arg_index);
     const auto& arg_leaf = arg.template Get<Load<TensorT>>();
     const auto& [arg_tensor] = arg_leaf.tuple();
-    CHECK(producer_tensor == arg_tensor);
+    PADDLE_ENFORCE_EQ(producer_tensor == arg_tensor,
+                      true,
+                      phi::errors::InvalidArgument(
+                          "producer_tensor should be equal to arg_tensor"));
     List<OpExpr> ret{};
     ret->assign(op_call_children->begin(), op_call_children->end());
     ret->at(arg_index) = producer_tree;
@@ -108,12 +114,20 @@ struct InlineTranslator final {
   static void CheckConsumerPosIsLoadTensor(const DstLeaf& consumer,
                                            int arg_index) {
     const auto& [tensor, consumer_tree] = consumer.tuple();
-    CHECK((consumer_tree.template Has<OpCallT<OpExpr>>()));
+    PADDLE_ENFORCE_EQ(
+        (consumer_tree.template Has<OpCallT<OpExpr>>()),
+        true,
+        phi::errors::InvalidArgument(
+            "consumer_tree.template should have <OpCallT<OpExpr>>()"));
     const auto& op_call = consumer_tree.template Get<OpCallT<OpExpr>>();
     const auto& op_call_children =
         InlineTranslatorTrait<OpCallT>::GetTreeInnerNodeChildren(op_call);
     const auto& op_call_child = op_call_children->at(arg_index);
-    CHECK((op_call_child.template Has<Load<TensorT>>()));
+    PADDLE_ENFORCE_EQ(
+        (op_call_child.template Has<Load<TensorT>>()),
+        true,
+        phi::errors::InvalidArgument(
+            "op_call_child.template should have <Load<TensorT>>()"));
   }
 
   template <typename DoEachT>
@@ -163,8 +177,12 @@ struct InlineTranslator final {
     std::unordered_map<int, DstLeaf> index2dst_leaf{};
     // Init dst leaves
     for (int i = 0; i < size; ++i) {
-      CHECK(index2dst_leaf.emplace(i, NaiveTranslateLeaf(*std::next(begin, i)))
-                .second);
+      PADDLE_ENFORCE_EQ(
+          index2dst_leaf.emplace(i, NaiveTranslateLeaf(*std::next(begin, i)))
+              .second,
+          true,
+          phi::errors::InvalidArgument(
+              "index2dst_leaf.emplace should return true"));
     }
     // Inline dst leaves
     for (int producer_i = 0; producer_i < size; ++producer_i) {
@@ -195,7 +213,10 @@ struct InlineTranslator final {
   // using SrcLeaf = Store<TensorT, OpCallT<Load<TensorT>>>;
   // using DstLeaf = Store<TensorT, OpExpr>;
   static DstLeaf NaiveTranslateLeaf(const SrcTree& src_tree) {
-    CHECK(src_tree.template Has<SrcLeaf>());
+    PADDLE_ENFORCE_EQ(src_tree.template Has<SrcLeaf>(),
+                      true,
+                      phi::errors::InvalidArgument(
+                          "src_tree.template should have <SrcLeaf>()"));
     const auto& [tensor, op_call] = src_tree.template Get<SrcLeaf>().tuple();
     const List<Load<TensorT>>& src_loads =
         InlineTranslatorTrait<OpCallT>::GetTreeInnerNodeChildren(op_call);
 
@@ -70,8 +70,10 @@ std::vector<ir::Tensor> Argmax(const Tensor &in_tensor,
 
   std::vector<Expr> output_shape;
   for (int i = 0; i < shape.size(); ++i) {
-    CHECK(shape[i].is_constant())
-        << "Input tensor's shape should be constant value.";
+    PADDLE_ENFORCE_EQ(shape[i].is_constant(),
+                      true,
+                      phi::errors::InvalidArgument(
+                          "Input tensor's shape should be constant value."));
     if (pos_axis == i) {
       if (keep_dims) {
         output_shape.push_back(Expr(1));
@@ -119,40 +121,51 @@ std::shared_ptr<framework::OpStrategy> StrategyForArgmax(
     keep_dims = absl::get<bool>(attrs.attr_store.at("keep_dim"));
   }
 
-  framework::CINNCompute argmax_compute(
-      [=](lang::Args args, lang::RetValue *ret) {
-        CHECK(!args.empty())
-            << "The input argument of argmax compute is empty! Please check.";
-        cinn::common::CINNValuePack pack_args = args[0];
-        std::string tensor_name = UniqName("Argmax_out");
-        PADDLE_ENFORCE_GE(
-            pack_args.size(),
-            1U,
-            phi::errors::InvalidArgument(
-                "There should be 1 input args for argmax compute"));
-        Expr in_expr = pack_args[0];
-        CHECK(in_expr.as_tensor());
-        Tensor in_tensor = in_expr.as_tensor_ref();
-        PADDLE_ENFORCE_EQ(
-            pack_args.size(),
-            2U,
-            phi::errors::InvalidArgument(
-                "The input argument of argmax compute must be 2."));
-        CHECK(pack_args[1].is_string());
-        tensor_name = pack_args[1].operator std::string();
-        std::vector<ir::Tensor> out_tensor =
-            Argmax(in_tensor, target, axis, keep_dims, tensor_name);
-
-        std::vector<CINNValue> cinn_values{CINNValue(out_tensor[0]),
-                                           CINNValue(out_tensor[1]),
-                                           CINNValue(out_tensor[2])};
-        *ret = cinn::common::CINNValuePack{cinn_values};
-      });
+  framework::CINNCompute argmax_compute([=](lang::Args args,
+                                            lang::RetValue *ret) {
+    PADDLE_ENFORCE_EQ(
+        !args.empty(),
+        true,
+        phi::errors::InvalidArgument(
+            "The input argument of argmax compute is empty! Please check."));
+    cinn::common::CINNValuePack pack_args = args[0];
+    std::string tensor_name = UniqName("Argmax_out");
+    PADDLE_ENFORCE_GE(pack_args.size(),
+                      1U,
+                      phi::errors::InvalidArgument(
+                          "There should be 1 input args for argmax compute"));
+    Expr in_expr = pack_args[0];
+    PADDLE_ENFORCE_NOT_NULL(
+        in_expr.as_tensor(),
+        phi::errors::InvalidArgument(
+            "The input argument of argmax compute is null."));
+    Tensor in_tensor = in_expr.as_tensor_ref();
+    PADDLE_ENFORCE_EQ(pack_args.size(),
+                      2U,
+                      phi::errors::InvalidArgument(
+                          "The input argument of argmax compute must be 2."));
+    PADDLE_ENFORCE_EQ(
+        pack_args[1].is_string(),
+        true,
+        phi::errors::InvalidArgument(
+            "The input argument of argmax compute must be string."));
+    tensor_name = pack_args[1].operator std::string();
+    std::vector<ir::Tensor> out_tensor =
+        Argmax(in_tensor, target, axis, keep_dims, tensor_name);
+
+    std::vector<CINNValue> cinn_values{CINNValue(out_tensor[0]),
+                                       CINNValue(out_tensor[1]),
+                                       CINNValue(out_tensor[2])};
+    *ret = cinn::common::CINNValuePack{cinn_values};
+  });
 
   framework::CINNSchedule argmax_schedule([=](lang::Args args,
                                               lang::RetValue *ret) {
-    CHECK(!args.empty())
-        << "The input argument of argmax_schedule is empty! Please check.\n";
+    PADDLE_ENFORCE_EQ(
+        !args.empty(),
+        true,
+        phi::errors::InvalidArgument(
+            "The input argument of argmax_schedule is empty! Please check."));
     cinn::common::CINNValuePack arg_pack = args[0];
     std::vector<Expr> vec_ast;
     for (int i = 0; i < arg_pack.size(); i++) {
@@ -161,7 +174,11 @@ std::shared_ptr<framework::OpStrategy> StrategyForArgmax(
         vec_ast.emplace_back(temp);
       }
     }
-    CHECK(!vec_ast.empty());
+    PADDLE_ENFORCE_EQ(
+        !vec_ast.empty(),
+        true,
+        phi::errors::InvalidArgument(
+            "The input argument of argmax_schedule is empty! Please check."));
     ir::ModuleExpr mod_expr(vec_ast);
     ir::IRSchedule ir_sch(mod_expr);
     ir_sch.MergeExprs();
 
@@ -62,8 +62,10 @@ std::vector<Tensor> Argmin(const Tensor &in_tensor,
 
   std::vector<Expr> output_shape;
   for (int i = 0; i < shape.size(); ++i) {
-    CHECK(shape[i].is_constant())
-        << "Input tensor's shape should be constant value.";
+    PADDLE_ENFORCE_EQ(shape[i].is_constant(),
+                      true,
+                      phi::errors::InvalidArgument(
+                          "Input tensor's shape should be constant value."));
     if (pos_axis == i) {
       if (keep_dims) {
         output_shape.push_back(Expr(1));
@@ -109,32 +111,44 @@ std::shared_ptr<framework::OpStrategy> StrategyForArgmin(
     keep_dims = absl::get<bool>(attrs.attr_store.at("keep_dim"));
   }
 
-  framework::CINNCompute argmin_compute(
-      [=](lang::Args args, lang::RetValue *ret) {
-        CHECK(!args.empty())
-            << "The input argument of argmin compute is empty! Please check.";
-        cinn::common::CINNValuePack pack_args = args[0];
-        CHECK_GE(pack_args.size(), 1U)
-            << "There should be 1 input args for argmax compute";
-        Expr in_expr = pack_args[0];
-        CHECK(in_expr.as_tensor());
-        Tensor in_tensor = in_expr.as_tensor_ref();
-        CHECK_EQ(pack_args.size(), 2U);
-        CHECK(pack_args[1].is_string());
-        std::string tensor_name = pack_args[1].operator std::string();
-        auto out_tensor =
-            Argmin(in_tensor, target, axis, keep_dims, tensor_name);
-
-        std::vector<CINNValue> cinn_values{CINNValue(out_tensor[0]),
-                                           CINNValue(out_tensor[1]),
-                                           CINNValue(out_tensor[2])};
-        *ret = cinn::common::CINNValuePack{cinn_values};
-      });
+  framework::CINNCompute argmin_compute([=](lang::Args args,
+                                            lang::RetValue *ret) {
+    PADDLE_ENFORCE_EQ(
+        !args.empty(),
+        true,
+        phi::errors::InvalidArgument(
+            "The input argument of argmin compute is empty! Please check."));
+    cinn::common::CINNValuePack pack_args = args[0];
+    CHECK_GE(pack_args.size(), 1U)
+        << "There should be 1 input args for argmax compute";
+    Expr in_expr = pack_args[0];
+    PADDLE_ENFORCE_NOT_NULL(
+        in_expr.as_tensor(),
+        phi::errors::InvalidArgument(
+            "The input argument of argmin compute is not tensor."));
+    Tensor in_tensor = in_expr.as_tensor_ref();
+    CHECK_EQ(pack_args.size(), 2U);
+    PADDLE_ENFORCE_EQ(
+        pack_args[1].is_string(),
+        true,
+        phi::errors::InvalidArgument(
+            "The input argument of argmin compute is not string."));
+    std::string tensor_name = pack_args[1].operator std::string();
+    auto out_tensor = Argmin(in_tensor, target, axis, keep_dims, tensor_name);
+
+    std::vector<CINNValue> cinn_values{CINNValue(out_tensor[0]),
+                                       CINNValue(out_tensor[1]),
+                                       CINNValue(out_tensor[2])};
+    *ret = cinn::common::CINNValuePack{cinn_values};
+  });
 
   framework::CINNSchedule argmin_schedule([=](lang::Args args,
                                               lang::RetValue *ret) {
-    CHECK(!args.empty())
-        << "The input argument of arange_schedule is empty! Please check.\n";
+    PADDLE_ENFORCE_EQ(
+        !args.empty(),
+        true,
+        phi::errors::InvalidArgument(
+            "The input argument of argmin schedule is empty! Please check."));
     cinn::common::CINNValuePack arg_pack = args[0];
     std::vector<Expr> vec_ast;
     for (int i = 0; i < arg_pack.size(); i++) {
@@ -143,7 +157,11 @@ std::shared_ptr<framework::OpStrategy> StrategyForArgmin(
         vec_ast.emplace_back(temp);
       }
     }
-    CHECK(!vec_ast.empty());
+    PADDLE_ENFORCE_EQ(
+        !vec_ast.empty(),
+        true,
+        phi::errors::InvalidArgument(
+            "The input argument of argmin schedule is empty! Please check."));
     ir::ModuleExpr mod_expr(vec_ast);
     ir::IRSchedule ir_sch(mod_expr);
     ir_sch.MergeExprs();