【Error Message No. 11 No. 14 No.15 No.28 BUAA】rewrite error message (#66841)

crazyxiaoxi · web-flow · commit dc19b5e611c9 · 2024-08-02T17:27:28.000+08:00
* first try

* fix

text

fix

Fix

fix conflict

fix conflict

fix
diff --git a/paddle/cinn/backends/llvm/codegen_llvm.h b/paddle/cinn/backends/llvm/codegen_llvm.h
@@ -72,17 +72,26 @@ class SymbolTable {
   }
 
   void Insert(const std::string &id, llvm::Value *value) {
-    CHECK(!scopes_.empty());
+    PADDLE_ENFORCE_EQ(
+        !scopes_.empty(),
+        true,
+        phi::errors::InvalidArgument("sorry, scopes_ can't be empty"));
     scopes_.back().emplace(id, value);
   }
 
   void Erase(const std::string &id) {
-    CHECK(!scopes_.empty());
+    PADDLE_ENFORCE_EQ(
+        !scopes_.empty(),
+        true,
+        phi::errors::InvalidArgument("sorry, scopes_ can't be empty"));
     scopes_.back().erase(id);
   }
 
   void PopScope() {
-    CHECK(!scopes_.empty());
+    PADDLE_ENFORCE_EQ(
+        !scopes_.empty(),
+        true,
+        phi::errors::InvalidArgument("sorry, scopes_ can't be empty"));
     scopes_.pop_back();
   }
 
diff --git a/paddle/cinn/backends/llvm/codegen_x86.cc b/paddle/cinn/backends/llvm/codegen_x86.cc
@@ -166,8 +166,11 @@ llvm::Value* CodeGenX86::Visit(const ir::For* op) {
     } else {
       Expr num_task = parallel_env_.num_task;
       Expr task_id = parallel_env_.task_id;
-      CHECK(!parallel_env_.in_parallel_loop)
-          << "Nested parallel loop is not supported, try to fuse them instead";
+      PADDLE_ENFORCE_EQ(
+          parallel_env_.in_parallel_loop,
+          false,
+          phi::errors::InvalidArgument("Nested parallel loop is not supported, "
+                                       "try to fuse them instead"));
       parallel_env_.in_parallel_loop = true;
       if (parallel_env_.stride_pattern) {
         auto new_for = ir::For::Make(op->loop_var,
@@ -178,7 +181,9 @@ llvm::Value* CodeGenX86::Visit(const ir::For* op) {
                                      op->body,
                                      op->vectorize_info());
         auto for_node = new_for.As<ir::For>();
-        CHECK(for_node);
+        PADDLE_ENFORCE_NOT_NULL(
+            for_node,
+            phi::errors::InvalidArgument("the node new_for can't be nullptr"));
         CreateSerialFor(for_node, num_task.as_int32());
       } else {
         Expr extent = op->extent;
@@ -193,7 +198,9 @@ llvm::Value* CodeGenX86::Visit(const ir::For* op) {
                                      op->body,
                                      op->vectorize_info());
         auto for_node = new_for.As<ir::For>();
-        CHECK(for_node);
+        PADDLE_ENFORCE_NOT_NULL(
+            for_node,
+            phi::errors::InvalidArgument("the node new_for can't be null"));
         CreateSerialFor(for_node);
       }
       parallel_env_.in_parallel_loop = false;
diff --git a/paddle/cinn/common/graph_utils.cc b/paddle/cinn/common/graph_utils.cc
@@ -179,9 +179,18 @@ void Graph::ClearUnlinkedNodes(
     absl::flat_hash_map<std::string, std::vector<int>> *shape_dict,
     absl::flat_hash_map<std::string, Type> *type_dict,
     absl::flat_hash_map<std::string, std::string> *layout_dict) {
-  CHECK(shape_dict);
-  CHECK(type_dict);
-  CHECK(layout_dict);
+  PADDLE_ENFORCE_NOT_NULL(
+      shape_dict,
+      phi::errors::InvalidArgument("The shpe_dict %s is null,please change",
+                                   shape_dict));
+  PADDLE_ENFORCE_NOT_NULL(
+      type_dict,
+      phi::errors::InvalidArgument("The type_dict %s is null,please change ",
+                                   type_dict));
+  PADDLE_ENFORCE_NOT_NULL(
+      layout_dict,
+      phi::errors::InvalidArgument("The layout_dict%s is null,please change",
+                                   layout_dict));
   for (auto it = nodes_.begin(); it < nodes_.end(); ++it) {
     auto node = *it;
     if (node->inlinks().empty() && node->outlinks().empty()) {
diff --git a/paddle/cinn/common/graph_utils.h b/paddle/cinn/common/graph_utils.h
@@ -85,7 +85,8 @@ class GraphNode : public Object {
   template <typename EdgeT = GraphEdge>
   std::tuple<EdgeT*, EdgeT*> LinkTo(GraphNode* other) {
     EdgeT *a, *b;
-    CHECK(other);
+    PADDLE_ENFORCE_NOT_NULL(
+        other, phi::errors::InvalidArgument("The input node is null."));
     PADDLE_ENFORCE_NE(
         other,
         this,
@@ -110,8 +111,11 @@ class GraphNode : public Object {
         break;
       }
     }
-    CHECK(a);
-    CHECK(b);
+    PADDLE_ENFORCE_NOT_NULL(
+        a, phi::errors::InvalidArgument("Sorry,but outlinks is nullptr"));
+    PADDLE_ENFORCE_NOT_NULL(
+        b,
+        phi::errors::InvalidArgument("Sorry, but other->inlinks_ is nullptr"));
     return std::make_tuple(a, b);
   }
 
diff --git a/paddle/cinn/operator_fusion/utils.h b/paddle/cinn/operator_fusion/utils.h
@@ -54,7 +54,10 @@ static size_t GetCompitableRank(pir::Value value) {
 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("axis");
-  CHECK(attr_val.isa<::pir::ArrayAttribute>());
+  PADDLE_ENFORCE_EQ(
+      attr_val.isa<::pir::ArrayAttribute>(),
+      true,
+      phi::errors::InvalidArgument("The axis attribute should be an array."));
   const auto& axis_attr = attr_val.dyn_cast<::pir::ArrayAttribute>();
   if (axis_attr.empty()) {
     // dim: [] means reduce_all.
@@ -93,7 +96,10 @@ static std::vector<int64_t> GetReduceAxisIdx(pir::Operation* reduce_op) {
 
 static bool GetReduceOpKeepDims(pir::Operation* reduce_op) {
   const auto& attr_val = reduce_op->attributes().at("keepdim");
-  CHECK(attr_val.isa<::pir::BoolAttribute>());
+  PADDLE_ENFORCE_EQ(
+      attr_val.isa<::pir::BoolAttribute>(),
+      true,
+      phi::errors::InvalidArgument("The keepdim attribute should be a bool."));
   return attr_val.dyn_cast<::pir::BoolAttribute>().data();
 }
 
@@ -117,7 +123,10 @@ GetBroadcastOpInputOuputValue(pir::Operation* op) {
     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();
+    PADDLE_ENFORCE_EQ(
+        false,
+        true,
+        phi::errors::Unimplemented("Unsupported broadcast op: %s", op->name()));
   }
   return std::nullopt;
 }
diff --git a/paddle/cinn/optim/ir_simplify.cc b/paddle/cinn/optim/ir_simplify.cc
@@ -196,11 +196,14 @@ struct SimplifyRampMutator : public ir::IRMutator<Expr*> {
   void Visit(const Ramp* op, Expr* expr) override {
     auto* node = expr->As<ir::Ramp>();
 
-    CHECK(cinn::common::IsPureMath(node->base))
-        << node->base << "is not a pure math!";
-    CHECK(cinn::common::IsPureMath(node->stride))
-        << node->stride << "is not a pure math!";
-
+    PADDLE_ENFORCE_EQ(
+        cinn::common::IsPureMath(node->base),
+        true,
+        phi::errors::InvalidArgument("node->base is not a pure math!"));
+    PADDLE_ENFORCE_EQ(
+        cinn::common::IsPureMath(node->stride),
+        true,
+        phi::errors::InvalidArgument("node->stride is not a pure math!"));
     PartialSimplify(&node->base);
     PartialSimplify(&node->stride);
   }
@@ -307,7 +310,9 @@ struct SimplifyBlocksMutator : public ir::IRMutator<> {
 
   void Visit(const ScheduleBlock* op, Expr* expr) override {
     auto* node = expr->As<ScheduleBlock>();
-    CHECK(node);
+    PADDLE_ENFORCE_NOT_NULL(node,
+                            phi::errors::InvalidArgument(
+                                "The node expr->As<ScheduleBlock>() is null"));
     for (auto& var : node->iter_vars) {
       if (var->lower_bound.defined()) {
         Visit(&var->lower_bound, &var->lower_bound);
diff --git a/paddle/cinn/optim/replace_cross_thread_reduction.cc b/paddle/cinn/optim/replace_cross_thread_reduction.cc
@@ -122,7 +122,8 @@ struct CrossThreadReductionReplacer : public ir::IRMutator<> {
   template <typename OpT>
   void ReplaceByContinuousReduceExternCall(ir::Expr* store, bool return_warp) {
     auto* node = store->As<ir::Store>()->value.As<OpT>();
-    CHECK(node);
+    PADDLE_ENFORCE_NOT_NULL(
+        node, phi::errors::InvalidArgument("The node must not be null."));
     auto& operand = node->b();
     std::string reduce_func_name = hlir::pe::CrossThreadReduceExternalFuncName(
         store->As<ir::Store>()->value, operand.template As<ir::Load>()->tensor);
@@ -141,7 +142,8 @@ struct CrossThreadReductionReplacer : public ir::IRMutator<> {
   template <typename OpT>
   void ReplaceByDiscreteReduceExternCall(ir::Expr* store) {
     auto* node = store->As<ir::Store>()->value.As<OpT>();
-    CHECK(node);
+    PADDLE_ENFORCE_NOT_NULL(
+        node, phi::errors::InvalidArgument("The node must not be null."));
     auto& operand = node->b();
     std::string reduce_func_name = hlir::pe::DiscreteReduceExternalFuncName(
         store->As<ir::Store>()->value, operand.template As<ir::Load>()->tensor);
@@ -211,8 +213,12 @@ struct CrossThreadReductionReplacer : public ir::IRMutator<> {
             "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>());
+    PADDLE_ENFORCE_EQ(original_update_body.As<ir::Block>() ||
+                          original_update_body.As<ir::Store>(),
+                      true,
+                      phi::errors::InvalidArgument(
+                          "The type of original_update_body is incorrect."
+                          "Expected type is Block or Store."));
     if (original_update_body.As<ir::Block>()) {
       PADDLE_ENFORCE_EQ(
           original_update_body.As<ir::Block>()->stmts.size(),
diff --git a/paddle/cinn/optim/schedule_block_dce.cc b/paddle/cinn/optim/schedule_block_dce.cc
@@ -38,8 +38,9 @@ struct ScheduleBlockDCE : public ir::IRMutator<Expr*> {
 
   void Visit(const ir::Block* op, Expr* expr) override {
     auto* node = expr->As<ir::Block>();
-    CHECK(node);
-
+    PADDLE_ENFORCE_NOT_NULL(
+        node,
+        phi::errors::InvalidArgument("Sorry, but expr->As node is nullptr"));
     for (auto& stmt : node->stmts) {
       IRMutator::Visit(&stmt, &stmt);
     }
@@ -65,7 +66,9 @@ struct ScheduleBlockDCE : public ir::IRMutator<Expr*> {
 
   void Visit(const ir::IfThenElse* op, Expr* expr) override {
     auto* node = expr->As<ir::IfThenElse>();
-    CHECK(node);
+    PADDLE_ENFORCE_NOT_NULL(
+        node,
+        phi::errors::InvalidArgument("Sorry, but node expr->As is nullptr"));
     IRMutator::Visit(&node->true_case, &node->true_case);
     if (node->false_case.defined()) {
       IRMutator::Visit(&node->false_case, &node->false_case);
@@ -77,7 +80,9 @@ struct ScheduleBlockDCE : public ir::IRMutator<Expr*> {
 
   void Visit(const ir::For* op, Expr* expr) override {
     auto* node = expr->As<ir::For>();
-    CHECK(node);
+    PADDLE_ENFORCE_NOT_NULL(
+        node,
+        phi::errors::InvalidArgument("Sorry, but node expr->As is nullptr"));
     IRMutator::Visit(&(node->body), &(node->body));
     if (IsEmptyBlock(op->body)) {
       *expr = ir::Block::Make({});
diff --git a/paddle/cinn/optim/transform_polyfor_to_for.cc b/paddle/cinn/optim/transform_polyfor_to_for.cc
@@ -98,7 +98,11 @@ struct PolyForWithSimpleConditionToForMutator : public ir::IRMutator<Expr*> {
     if (!can_extract_extent) {
       if (node->condition.As<ir::LE>()) {
         auto le = node->condition.As<ir::LE>();
-        CHECK(le->a().As<ir::Sub>());
+
+        PADDLE_ENFORCE_NOT_NULL(
+            le->a().As<ir::Sub>(),
+            phi::errors::InvalidArgument("The value of le is incorrect."
+                                         "Expected value is 0"));
         PADDLE_ENFORCE_EQ(le->b().As<ir::IntImm>()->value,
                           0UL,
                           ::common::errors::InvalidArgument(
@@ -109,7 +113,10 @@ struct PolyForWithSimpleConditionToForMutator : public ir::IRMutator<Expr*> {
         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>());
+        PADDLE_ENFORCE_NOT_NULL(
+            lt->a().As<ir::Sub>(),
+            phi::errors::InvalidArgument("The value of lt is incorrect."
+                                         "Expected value is 0"));
         PADDLE_ENFORCE_EQ(lt->b().As<ir::IntImm>()->value,
                           0UL,
                           ::common::errors::InvalidArgument(
@@ -131,7 +138,13 @@ struct PolyForWithSimpleConditionToForMutator : public ir::IRMutator<Expr*> {
     Expr rhs = lt_n ? lt_n->b() : PlusOneWithMinMax(le_n->b());
     rhs = cinn::common::AutoSimplify(rhs);
 
-    if (op->is_vectorized()) CHECK(op->vectorize_info().valid());
+    if (op->is_vectorized())
+      PADDLE_ENFORCE_EQ(
+          op->vectorize_info().valid(),
+          true,
+          phi::errors::InvalidArgument(
+              "The value of op->vectorize_info().valid() is incorrect."
+              "Expected value is true"));
 
     Expr new_for = ir::For::Make(op->iterator,
                                  op->init,
diff --git a/paddle/cinn/optim/var_mod_simplify.cc b/paddle/cinn/optim/var_mod_simplify.cc
@@ -51,8 +51,12 @@ struct ReplaceDivWithVarMutator : public ir::IRMutator<> {
     if (a.is_var() && b.is_constant()) {
       auto a_var = a.As<_Var_>();
       auto b_int = b.As<IntImm>();
-      CHECK(a_var);
-      CHECK(b_int);
+      PADDLE_ENFORCE_NOT_NULL(
+          a_var,
+          phi::errors::InvalidArgument("The node->operand(0) should be var"));
+      PADDLE_ENFORCE_NOT_NULL(
+          b_int,
+          phi::errors::InvalidArgument("The node->operand(1) should be int"));
       std::string var_name = a_var->name + "/" + std::to_string(b_int->value);
       div_var_map_[var_name] = ir::Div::Make(a, b);
       *expr = Var(var_name);
@@ -70,7 +74,9 @@ struct ReplaceVarWithDivMutator : public ir::IRMutator<> {
 
   void Visit(const _Var_* op, Expr* expr) override {
     auto* node = expr->As<_Var_>();
-    CHECK(node);
+    PADDLE_ENFORCE_NOT_NULL(
+        node,
+        phi::errors::InvalidArgument("Sorry, but the node expr is nullptr"));
     if (div_var_map_.count(node->name)) {
       *expr = div_var_map_[node->name];
     }
