fix (#63046)

shuaihehe · web-flow · commit bab4534cea63 · 2024-03-28T10:12:17.000+08:00
diff --git a/paddle/cinn/optim/compute_inline_expand.cc b/paddle/cinn/optim/compute_inline_expand.cc
@@ -113,7 +113,14 @@ struct TensorInlineExpandMutator : public ir::IRMutator<> {
           CHECK(tensor);
           // fix computeAt case
           auto shapes = tensor->shape;
-          CHECK_EQ(shapes.size(), node->indices.size());
+          PADDLE_ENFORCE_EQ(
+              shapes.size(),
+              node->indices.size(),
+              phi::errors::InvalidArgument(
+                  "The size of tensor shape and node indices is not equal,"
+                  "where tensor shape:%d but node indices:%d.",
+                  shapes.size(),
+                  node->indices.size()));
           for (int i = 0; i < shapes.size(); i++) {
             if (cinn::common::is_zero(shapes[i] - 1)) {
               node->indices[i] = Expr(0);
diff --git a/paddle/cinn/optim/map_extern_call.cc b/paddle/cinn/optim/map_extern_call.cc
@@ -65,7 +65,13 @@ void MapExternCall(Expr *e, Target target) {
 
     void DealWithCpuIntrinsics(ir::Call *node, Expr *expr) {
       if (kExternFp32CallsCPU.count(node->name)) {
-        CHECK_GE(node->read_args.size(), 1UL);
+        PADDLE_ENFORCE_GE(
+            node->read_args.size(),
+            1UL,
+            phi::errors::InvalidArgument(
+                "The size of node's read args is incorrect."
+                "Expected size is greater than or equal to 1, but receive %d.",
+                node->read_args.size()));
         CHECK(node->read_args.front().type().is_float())
             << "CPU extern call intrinsics only support float now! Please "
                "check.";
diff --git a/paddle/cinn/optim/remove_schedule_block.cc b/paddle/cinn/optim/remove_schedule_block.cc
@@ -35,7 +35,13 @@ struct ScheduleBlockRemover : public ir::IRMutator<Expr*> {
     CHECK(schedule_block);
     auto& iter_vars = schedule_block->iter_vars;
     Expr body = schedule_block->body;
-    CHECK_EQ(iter_vars.size(), iter_values.size());
+    PADDLE_ENFORCE_EQ(iter_vars.size(),
+                      iter_values.size(),
+                      phi::errors::InvalidArgument(
+                          "The size of iter vars and iter values is not equal,"
+                          "where iter vars:%d but iter values:%d.",
+                          iter_vars.size(),
+                          iter_values.size()));
     for (int i = 0; i < iter_vars.size(); i++) {
       optim::ReplaceVarWithExpr(&body, iter_vars[i], iter_values[i]);
     }
diff --git a/paddle/cinn/optim/replace_cross_thread_reduction.cc b/paddle/cinn/optim/replace_cross_thread_reduction.cc
@@ -48,7 +48,10 @@ struct CrossThreadReductionReplacer : public ir::IRMutator<> {
     const ir::ScheduleBlock* schedule_block =
         block_realize->schedule_block.As<ir::ScheduleBlock>();
 
-    CHECK_NOTNULL(schedule_block);
+    PADDLE_ENFORCE_NOT_NULL(
+        schedule_block,
+        phi::errors::PreconditionNotMet(
+            "The schedule block pointer in CanReplace must not be null."));
 
     if (block_realize->schedule_block.As<ir::ScheduleBlock>()->name.substr(
             0, 4) == "root") {
@@ -135,13 +138,22 @@ struct CrossThreadReductionReplacer : public ir::IRMutator<> {
 
     const ir::ScheduleBlock* schedule_block =
         expr->schedule_block.As<ir::ScheduleBlock>();
-    CHECK_NOTNULL(schedule_block);
+    PADDLE_ENFORCE_NOT_NULL(
+        schedule_block,
+        phi::errors::PreconditionNotMet(
+            "The schedule block pointer in Visit must not be null."));
     ir::Expr original_update_body = schedule_block->body;
     ir::Expr original_update_stmt;
     CHECK(original_update_body.As<ir::Block>() ||
           original_update_body.As<ir::Store>());
     if (original_update_body.As<ir::Block>()) {
-      CHECK_EQ(original_update_body.As<ir::Block>()->stmts.size(), 1);
+      PADDLE_ENFORCE_EQ(
+          original_update_body.As<ir::Block>()->stmts.size(),
+          1,
+          phi::errors::InvalidArgument(
+              "The size of stmts is incorrect."
+              "Expected size is 1, but receive %d.",
+              original_update_body.As<ir::Block>()->stmts.size()));
       original_update_stmt = original_update_body.As<ir::Block>()->stmts[0];
     } else if (original_update_body.As<ir::Store>()) {
       original_update_stmt = original_update_body;
diff --git a/paddle/cinn/optim/transform_gpu_forloop.cc b/paddle/cinn/optim/transform_gpu_forloop.cc
@@ -222,7 +222,13 @@ class ReplaceIndexToBindExpr : public ir::IRMutator<> {
         schedule_block_realize->schedule_block.As<ir::ScheduleBlock>()
             ->iter_vars;
 
-    CHECK_EQ(iter_values.size(), iter_vars.size());
+    PADDLE_ENFORCE_EQ(iter_values.size(),
+                      iter_vars.size(),
+                      phi::errors::InvalidArgument(
+                          "The size of iter values and iter vars is not equal,"
+                          "where iter values:%d but iter vars:%d.",
+                          iter_values.size(),
+                          iter_vars.size()));
     for (int idx = 0; idx < iter_values.size(); ++idx) {
       ReplaceVarWithExpr(&body, iter_vars[idx], iter_values[idx]);
     }
diff --git a/paddle/cinn/optim/transform_polyfor_to_for.cc b/paddle/cinn/optim/transform_polyfor_to_for.cc
@@ -99,13 +99,23 @@ struct PolyForWithSimpleConditionToForMutator : public ir::IRMutator<Expr*> {
       if (node->condition.As<ir::LE>()) {
         auto le = node->condition.As<ir::LE>();
         CHECK(le->a().As<ir::Sub>());
-        CHECK_EQ(le->b().As<ir::IntImm>()->value, 0UL);
+        PADDLE_ENFORCE_EQ(
+            le->b().As<ir::IntImm>()->value,
+            0UL,
+            phi::errors::InvalidArgument("The value of le is incorrect."
+                                         "Expected value is 0, but receive %d.",
+                                         le->b().As<ir::IntImm>()->value));
         auto sub = le->a().As<ir::Sub>();
         node->condition = ir::LE::Make(sub->a(), sub->b());
       } else if (node->condition.As<ir::LT>()) {
         auto lt = node->condition.As<ir::LT>();
         CHECK(lt->a().As<ir::Sub>());
-        CHECK_EQ(lt->b().As<ir::IntImm>()->value, 0UL);
+        PADDLE_ENFORCE_EQ(
+            lt->b().As<ir::IntImm>()->value,
+            0UL,
+            phi::errors::InvalidArgument("The value of lt is incorrect."
+                                         "Expected value is 0, but receive %d.",
+                                         lt->b().As<ir::IntImm>()->value));
         auto sub = lt->a().As<ir::Sub>();
         node->condition = ir::LT::Make(sub->a(), sub->b());
       } else {
diff --git a/paddle/cinn/optim/vectorize_loops.cc b/paddle/cinn/optim/vectorize_loops.cc
@@ -50,8 +50,11 @@ Expr Widen(Expr e, int lanes) {
     }
   }
 
-  CHECK_EQ(e.type().lanes(), 1)
-      << "Cannot broadcast lanes from " << e.type().lanes() << " to " << lanes;
+  PADDLE_ENFORCE_EQ(
+      e.type().lanes(),
+      1,
+      phi::errors::InvalidArgument(
+          "Cannot broadcast lanes from %d to %d.", e.type().lanes(), lanes));
   return ir::Broadcast::Make(e, lanes);
 }
 
@@ -742,7 +745,13 @@ struct VectorizeLoops_ : public IRMutator<Expr *> {
     if (forloop->is_vectorized()) {
       Context::info_rgt().Get<int>("vectorized_forloop_count")++;
 
-      CHECK_GT(forloop->vectorize_info().factor, 0);
+      PADDLE_ENFORCE_GT(
+          forloop->vectorize_info().factor,
+          0,
+          phi::errors::InvalidArgument(
+              "The value of factor in forloop's vectorize_info is incorrect."
+              "Expected value is larger than 0, but receive %d. ",
+              forloop->vectorize_info().factor));
 
       CHECK(is_zero(forloop->min));
       Expr for_extent = cinn::common::AutoSimplify(forloop->extent);
@@ -795,10 +804,14 @@ struct VectorizeLoops_ : public IRMutator<Expr *> {
       }
 
       int extent = extent_int->value;
-      CHECK_GT(extent, 0)
-          << "Loop over " << Expr(new_forloop->loop_var) << " has extent "
-          << new_forloop->extent
-          << ". Can only vectorize loops over a constant extent > 1";
+      PADDLE_ENFORCE_GT(
+          extent,
+          0,
+          phi::errors::InvalidArgument(
+              "Loop over %s has extent %d"
+              ". Can only vectorize loops over a constant extent > 1",
+              Expr(new_forloop->loop_var),
+              new_forloop->extent));
 
       VLOG(2) << "Vectorizing " << new_forloop->loop_var << " extent "
               << extent;
@@ -927,7 +940,12 @@ struct VectorizeLoops_ : public IRMutator<Expr *> {
   //! Split the forloop with size \p factor.
   //! @return The new forloop.
   Expr SplitForLoop(For *forloop, int factor) {
-    CHECK_GT(factor, 1);
+    PADDLE_ENFORCE_GT(factor,
+                      1,
+                      phi::errors::InvalidArgument(
+                          "The value of factor in SplitForLoop is incorrect."
+                          "Expected value is larger than 1, but receive %d. ",
+                          factor));
     auto *for_min_i = forloop->min.As<IntImm>();
     CHECK(forloop);
     if (!for_min_i) return Expr();
