【Error Message BUAA No.35】fix error message (#66869)

uanu2002 · web-flow · commit 1cff689bfefc · 2024-08-02T10:03:37.000+08:00
* fix error message

* fix factorize_reduction.h

* fix error message

* add import
diff --git a/paddle/cinn/backends/llvm/llvm_util.cc b/paddle/cinn/backends/llvm/llvm_util.cc
@@ -92,10 +92,14 @@ llvm::Type *CinnTypeToLLVMType(cinn::common::Type type,
   } else if (type.is_string()) {
     ir_type = arr;
   } else if (type.is_customized_type()) {
-    CHECK(!type.customized_type().empty());
+    PADDLE_ENFORCE_EQ(!type.customized_type().empty(),
+                      true,
+                      phi::errors::InvalidArgument(
+                          "Customized type name should not be empty."));
     ir_type = m->getTypeByName("struct." + type.customized_type());
   }
-  CHECK(ir_type) << "LLVM can't convert type: " << type;
+  PADDLE_ENFORCE_NOT_NULL(
+      ir_type, phi::errors::InvalidArgument("LLVM can't convert type."));
 
   // C array / vector.
   if (type.lanes() > 1) {
diff --git a/paddle/cinn/backends/llvm/llvm_util.h b/paddle/cinn/backends/llvm/llvm_util.h
@@ -30,6 +30,7 @@
 #include <utility>
 
 #include "paddle/cinn/common/type.h"
+#include "paddle/common/enforce.h"
 
 namespace cinn {
 namespace backends {
diff --git a/paddle/cinn/common/cas.h b/paddle/cinn/common/cas.h
@@ -63,8 +63,14 @@ struct CasInterval {
             << "].";
 
     if (expr_l.is_constant() && expr_r.is_constant()) {
-      CHECK(expr_l->type().is_integer());
-      CHECK(expr_r->type().is_integer());
+      PADDLE_ENFORCE_EQ(
+          expr_l->type().is_integer(),
+          true,
+          phi::errors::InvalidArgument("Expected expr_l to be an integer."));
+      PADDLE_ENFORCE_EQ(
+          expr_r->type().is_integer(),
+          true,
+          phi::errors::InvalidArgument("Expected expr_r to be an integer."));
       l = expr_l.as_int64();
       r = expr_r.as_int64();
       return;
diff --git a/paddle/cinn/ir/schedule/factorize_reduction.h b/paddle/cinn/ir/schedule/factorize_reduction.h
@@ -310,7 +310,11 @@ class RFBlockCreater : public ReduceBlockCreater {
       new_iter_values_.push_back(original_iter_value);
       return;
     }
-    CHECK(original_iter_var->is_reduce_axis);
+    PADDLE_ENFORCE_EQ(
+        original_iter_var->is_reduce_axis,
+        true,
+        phi::errors::InvalidArgument(
+            "The original_iter_var is expected to be a reduce axis."));
 
     // This iter is a reduction iter and touches the rfactor loop. So we try to
     // create a new iter for each loop var that appear in the original iter
@@ -444,12 +448,15 @@ class RBBlockCreater : public ReduceBlockCreater {
     std::string original_store_name =
         original_update_stmt_.As<ir::Store>()->tensor.as_tensor()->name;
 
-#define REPLACE_RF_TENSOR(Op)                                    \
-  if (new_store_body.As<Op>()) {                                 \
-    auto* node = new_store_body.As<Op>();                        \
-    CHECK(node);                                                 \
-    auto& operand = node->b();                                   \
-    operand = Load::Make(rf_tensor_, rf_tensor_access_indices_); \
+#define REPLACE_RF_TENSOR(Op)                                               \
+  if (new_store_body.As<Op>()) {                                            \
+    auto* node = new_store_body.As<Op>();                                   \
+    PADDLE_ENFORCE_NOT_NULL(                                                \
+        node,                                                               \
+        phi::errors::InvalidArgument("The conversion of new_store_body to " \
+                                     "Op* failed, node is nullptr."));      \
+    auto& operand = node->b();                                              \
+    operand = Load::Make(rf_tensor_, rf_tensor_access_indices_);            \
   }
 
     REPLACE_RF_TENSOR(Add)
diff --git a/paddle/cinn/lang/builtin.cc b/paddle/cinn/lang/builtin.cc
@@ -30,7 +30,11 @@ using cinn::common::bfloat16;
 using cinn::common::float16;
 
 Expr logic_and(const std::vector<Expr>& conds) {
-  CHECK(!conds.empty());
+  PADDLE_ENFORCE_EQ(
+      !conds.empty(),
+      true,
+      phi::errors::InvalidArgument(
+          "The input conditions vector for logic_and should not be empty."));
   auto start = ir::And::Make(conds[0], conds[1]);
   for (int i = 2; i < conds.size(); i++) {
     start = ir::And::Make(start, conds[i]);
@@ -39,7 +43,11 @@ Expr logic_and(const std::vector<Expr>& conds) {
 }
 
 Expr logic_or(const std::vector<Expr>& conds) {
-  CHECK(!conds.empty());
+  PADDLE_ENFORCE_EQ(
+      !conds.empty(),
+      true,
+      phi::errors::InvalidArgument(
+          "The input conditions vector for logic_or should not be empty."));
   auto start = ir::Or::Make(conds[0], conds[1]);
   for (int i = 2; i < conds.size(); i++) {
     start = ir::Or::Make(start, conds[i]);
diff --git a/paddle/cinn/lang/builtin.h b/paddle/cinn/lang/builtin.h
@@ -19,6 +19,7 @@
 #include "paddle/cinn/common/ir_util.h"
 #include "paddle/cinn/ir/ir.h"
 #include "paddle/cinn/ir/op/ir_operators.h"
+#include "paddle/common/enforce.h"
 
 namespace cinn {
 namespace lang {
diff --git a/paddle/cinn/lang/compute.cc b/paddle/cinn/lang/compute.cc
@@ -199,8 +199,11 @@ ir::Tensor Compute(const std::vector<Expr> &domain,
 
   // check reduce_axis not include the reserved axis name
   for (auto &ra : reduce_axis) {
-    CHECK(!cinn::common::IsAxisNameReserved(ra->name))
-        << "reduce axis [" << ra->name << "]'s name is reserved";
+    PADDLE_ENFORCE_EQ(
+        !cinn::common::IsAxisNameReserved(ra->name),
+        true,
+        phi::errors::InvalidArgument("Reduce axis [%s]'s name is reserved.",
+                                     ra->name.c_str()));
   }
 
   VLOG(3) << "tensor " << name
@@ -254,10 +257,12 @@ Expr CallExtern(const std::string &func_name,
                 const std::map<std::string, attr_t> &attrs) {
   auto *proto =
       backends::ExternFunctionProtoRegistry::Global().Lookup(func_name);
-  CHECK(proto)
-      << "No extern function prototype " << func_name << " found\n"
-      << "existing records are:\n"
-      << backends::ExternFunctionProtoRegistry::Global().debug_string();
+  PADDLE_ENFORCE_NOT_NULL(
+      proto,
+      phi::errors::InvalidArgument(
+          "No extern function prototype %s found\nExisting records are:\n%s",
+          func_name,
+          backends::ExternFunctionProtoRegistry::Global().debug_string()));
 
   auto call = ir::Call::Make(proto->ret_type,
                              func_name,
diff --git a/paddle/cinn/lang/compute.h b/paddle/cinn/lang/compute.h
@@ -25,7 +25,7 @@
 #include "paddle/cinn/ir/op/ir_operators.h"
 #include "paddle/cinn/lang/placeholder.h"
 #include "paddle/cinn/poly/schedule.h"
-
+#include "paddle/common/enforce.h"
 namespace cinn {
 namespace lang {
 
diff --git a/paddle/cinn/operator_fusion/policy/relative_judge_policy.cc b/paddle/cinn/operator_fusion/policy/relative_judge_policy.cc
@@ -190,7 +190,12 @@ pir::Operation* FindUserOp(const std::vector<pir::Operation*>& candidates,
       results.emplace_back(*iter);
     }
   }
-  CHECK(results.size() == 1) << "Zero Or Multi User Op Found In Candidates!";
+  PADDLE_ENFORCE_EQ(results.size(),
+                    1,
+                    phi::errors::InvalidArgument(
+                        "Zero or multiple user operations found in candidates! "
+                        "Expected exactly one, but found %d.",
+                        results.size()));
   return results.front();
 }
 
@@ -298,8 +303,6 @@ std::vector<size_t> RelativeJudgePolicy<T>::GetFakeReduceIterIdx(
       GetValueUsage(downstream->sink_op()->result(0), 0),
       upstream_non_reduce_dims);
 
-  // CHECK(upstream_reduce_dims.size() == trivial_reorder_dims.size() ||
-  // trivial_reorder_dims.size() == 0);
   std::unordered_set<DimUsage, DimUsageHash> visited_dims;
   std::vector<size_t> result;
   for (auto& reduce_dim : upstream_reduce_dims) {
diff --git a/paddle/cinn/optim/lower_function_call_bind_vars.cc b/paddle/cinn/optim/lower_function_call_bind_vars.cc
@@ -42,8 +42,11 @@ struct LowerFunctionCallBindVarsMutator : public ir::IRMutator<> {
           m_->functions.begin(), m_->functions.end(), [&](const Expr& x) {
             return x.as_lowered_func()->name == target;
           });
-      CHECK(it != m_->functions.end())
-          << "The called function [" << target << "] is not exist";
+      PADDLE_ENFORCE_NE(
+          it,
+          m_->functions.end(),
+          phi::errors::NotFound("The called function [%s] does not exist.",
+                                target));
 
       std::vector<Expr> extra_var_args;
 
@@ -70,7 +73,9 @@ struct LowerFunctionCallBindVarsMutator : public ir::IRMutator<> {
 }  // namespace
 
 void LowerFunctionCallBindVars(Expr* m) {
-  CHECK(m->as_module());
+  PADDLE_ENFORCE_NOT_NULL(
+      m->as_module(),
+      phi::errors::InvalidArgument("The provided expression is not a module."));
   LowerFunctionCallBindVarsMutator()(m);
 }
 
diff --git a/paddle/cinn/optim/lower_function_call_bind_vars.h b/paddle/cinn/optim/lower_function_call_bind_vars.h
@@ -16,6 +16,7 @@
 
 #include "paddle/cinn/ir/ir.h"
 #include "paddle/cinn/ir/module.h"
+#include "paddle/common/enforce.h"
 
 namespace cinn {
 namespace optim {
diff --git a/paddle/cinn/optim/map_extern_call.cc b/paddle/cinn/optim/map_extern_call.cc
@@ -53,9 +53,11 @@ void DealWithCpuIntrinsics(ir::Call *node, Expr *expr) {
             "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.";
+    PADDLE_ENFORCE_EQ(
+        node->read_args.front().type().is_float(),
+        true,
+        phi::errors::InvalidArgument("CPU extern call intrinsics only support "
+                                     "float now! Please check."));
     if (node->read_args.front().type().is_float(32)) {
       auto out_type = node->type();
       *expr = lang::CallExtern(node->name + "f", node->read_args);
@@ -122,7 +124,11 @@ void MapExternCall(Expr *e, Target target) {
 
     void Visit(const ir::Call *op, Expr *expr) override {
       auto *node = expr->As<ir::Call>();
-      CHECK(node);
+      PADDLE_ENFORCE_NOT_NULL(
+          node,
+          phi::errors::InvalidArgument(
+              "The expression could not be cast to ir::Call. Please check the "
+              "expression type."));
       OptimizeConstantPow(node);
       DealWithIntrinsics(target.arch, node, expr);
     }
diff --git a/paddle/cinn/optim/map_extern_call.h b/paddle/cinn/optim/map_extern_call.h
@@ -18,7 +18,7 @@
 #include <string>
 
 #include "paddle/cinn/ir/ir.h"
-
+#include "paddle/common/enforce.h"
 namespace cinn {
 namespace optim {
 
diff --git a/paddle/cinn/optim/remove_schedule_block.cc b/paddle/cinn/optim/remove_schedule_block.cc
@@ -29,10 +29,18 @@ struct ScheduleBlockRemover : public ir::IRMutator<Expr*> {
 
   void Visit(const ir::ScheduleBlockRealize* op, Expr* expr) override {
     auto* node = expr->As<ir::ScheduleBlockRealize>();
-    CHECK(node);
+    PADDLE_ENFORCE_NOT_NULL(
+        node,
+        phi::errors::InvalidArgument(
+            "The expression could not be cast to ir::ScheduleBlockRealize. "
+            "Please check the expression type."));
     auto& iter_values = node->iter_values;
     auto* schedule_block = node->schedule_block.As<ir::ScheduleBlock>();
-    CHECK(schedule_block);
+    PADDLE_ENFORCE_NOT_NULL(
+        schedule_block,
+        phi::errors::InvalidArgument(
+            "The schedule block could not be cast to ir::ScheduleBlock. Please "
+            "check the schedule block type."));
     auto& iter_vars = schedule_block->iter_vars;
     Expr body = schedule_block->body;
     PADDLE_ENFORCE_EQ(iter_vars.size(),
diff --git a/paddle/cinn/optim/remove_schedule_block.h b/paddle/cinn/optim/remove_schedule_block.h
@@ -20,7 +20,7 @@
 
 #include "paddle/cinn/common/common.h"
 #include "paddle/cinn/ir/ir.h"
-
+#include "paddle/common/enforce.h"
 namespace cinn {
 namespace optim {
 
diff --git a/paddle/cinn/optim/resize_buffer.cc b/paddle/cinn/optim/resize_buffer.cc
@@ -35,7 +35,11 @@ class AnalyzeLoopVarRange : public ir::IRMutator<> {
   void operator()(ir::Expr* expr) { ir::IRMutator<>::Visit(expr, expr); }
 
   void Visit(const ir::IfThenElse* op, Expr* expr) override {
-    CHECK(expr->As<ir::IfThenElse>());
+    PADDLE_ENFORCE_NOT_NULL(
+        expr->As<ir::IfThenElse>(),
+        phi::errors::InvalidArgument(
+            "The expression could not be cast to ir::IfThenElse. Please check "
+            "the expression type."));
 
     const ir::IfThenElse* if_ir = expr->As<ir::IfThenElse>();
     const ir::LT* less_than_ir = if_ir->condition.As<ir::LT>();
@@ -53,7 +57,10 @@ class AnalyzeLoopVarRange : public ir::IRMutator<> {
 
   // Visit for and collect extent
   void Visit(const ir::For* op, Expr* expr) override {
-    CHECK(expr->As<ir::For>());
+    PADDLE_ENFORCE_NOT_NULL(expr->As<ir::For>(),
+                            phi::errors::InvalidArgument(
+                                "The expression could not be cast to ir::For. "
+                                "Please check the expression type."));
     ir::For* for_ir = expr->As<ir::For>();
     std::string var_name = for_ir->loop_var->name;
     Expr extent = for_ir->extent;
diff --git a/paddle/cinn/optim/resize_buffer.h b/paddle/cinn/optim/resize_buffer.h
@@ -16,6 +16,7 @@
 #include <string>
 
 #include "paddle/cinn/ir/ir.h"
+#include "paddle/common/enforce.h"
 
 namespace cinn {
 namespace optim {
diff --git a/paddle/cinn/pybind/ir/ir_context.h b/paddle/cinn/pybind/ir/ir_context.h
@@ -66,7 +66,8 @@ class IRContext {
   template <typename TIRContextNode>
   const TIRContextNode* As() const {
     static_assert(std::is_base_of<IRContextNode, TIRContextNode>());
-    CHECK(data_.get()) << "IrContext holds null";
+    PADDLE_ENFORCE_NOT_NULL(
+        data_.get(), phi::errors::InvalidArgument("IrContext holds null"));
     auto* ctx_node = data_.get()->safe_as<TIRContextNode>();
     if (!ctx_node) {
       std::stringstream err_msg;
@@ -79,7 +80,8 @@ class IRContext {
   }
   template <typename TIRContextNode>
   TIRContextNode* As() {
-    CHECK(data_.get()) << "IrContext holds null";
+    PADDLE_ENFORCE_NOT_NULL(
+        data_.get(), phi::errors::InvalidArgument("IrContext holds null"));
     auto* ctx_node = data_.get()->safe_as<TIRContextNode>();
     if (!ctx_node) {
       std::stringstream ss;
diff --git a/paddle/fluid/distributed/ps/table/memory_dense_table.cc b/paddle/fluid/distributed/ps/table/memory_dense_table.cc
@@ -129,13 +129,19 @@ int32_t MemoryDenseTable::SetGlobalLR(float *lr) {
 }
 
 int32_t MemoryDenseTable::Pull(TableContext &context) {
-  CHECK(context.value_type == Dense);
+  PADDLE_ENFORCE_EQ(
+      context.value_type,
+      Dense,
+      phi::errors::InvalidArgument("Context value type must be 'Dense'."));
   float *pull_values = context.pull_context.values;
   return PullDense(pull_values, context.num);
 }
 
 int32_t MemoryDenseTable::Push(TableContext &context) {
-  CHECK(context.value_type == Dense);
+  PADDLE_ENFORCE_EQ(
+      context.value_type,
+      Dense,
+      phi::errors::InvalidArgument("Context value type must be 'Dense'."));
   if (context.push_context.values != nullptr) {
     if (!context.push_context.is_param) {
       return PushDense(context.push_context.values, context.num);
@@ -272,9 +278,12 @@ int32_t MemoryDenseTable::Load(const std::string &path,
           }
           size_t str_len =
               paddle::string::str_to_float(line_data.data(), data_buff_ptr);
-          CHECK(str_len == param_col_ids_.size())
-              << "expect " << param_col_ids_.size() << " float, but got "
-              << str_len;
+          PADDLE_ENFORCE_EQ(
+              str_len,
+              param_col_ids_.size(),
+              phi::errors::InvalidArgument("Expected %d floats, but got %d.",
+                                           param_col_ids_.size(),
+                                           str_len));
           for (size_t col_idx = 0; col_idx < str_len; ++col_idx) {
             if (param_col_ids_[col_idx] < 0) {
               continue;
diff --git a/paddle/fluid/distributed/ps/table/memory_dense_table.h b/paddle/fluid/distributed/ps/table/memory_dense_table.h
@@ -21,12 +21,12 @@
 #include <string>
 
 #include "Eigen/Dense"
+#include "paddle/common/enforce.h"
 #include "paddle/fluid/distributed/ps/table/accessor.h"
 #include "paddle/fluid/distributed/ps/table/common_table.h"
 #include "paddle/fluid/distributed/ps/table/depends/dense.h"
 #include "paddle/fluid/distributed/ps/table/depends/initializers.h"
 #include "paddle/utils/string/string_helper.h"
-
 namespace paddle {
 namespace distributed {
 
