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

uanu2002 · web-flow · commit 61ea9acdc3d2 · 2024-08-02T14:15:01.000+08:00
* fix error message

* fix ir_visitor

* fix commom::error
diff --git a/paddle/cinn/hlir/op/contrib/randint.cc b/paddle/cinn/hlir/op/contrib/randint.cc
@@ -40,6 +40,7 @@
 #include "paddle/cinn/lang/compute.h"
 #include "paddle/cinn/lang/packed_func.h"
 #include "paddle/cinn/poly/stage.h"
+#include "paddle/common/enforce.h"
 
 namespace cinn {
 namespace hlir {
@@ -56,7 +57,11 @@ std::shared_ptr<framework::OpStrategy> StrategyForRandInt(
     const Target &target) {
   framework::CINNCompute randint_compute(
       [=](lang::Args args, lang::RetValue *ret) {
-        CHECK(attrs.attr_store.count("shape"));
+        PADDLE_ENFORCE_GE(
+            attrs.attr_store.count("shape"),
+            1,
+            ::common::errors::NotFound("The attribute 'shape' is not found in "
+                                       "attr_store. Please ensure it is set."));
         ir::Tensor shape_tensor;
         std::string tensor_name = "randint_out";
         auto out = pe::Identity(shape_tensor, tensor_name).front();
diff --git a/paddle/cinn/hlir/op/contrib/triangular_solve.cc b/paddle/cinn/hlir/op/contrib/triangular_solve.cc
@@ -26,6 +26,7 @@
 #include "paddle/cinn/ir/ir_base.h"
 #include "paddle/cinn/ir/tensor.h"
 #include "paddle/cinn/lang/compute.h"
+#include "paddle/common/enforce.h"
 
 namespace cinn {
 namespace hlir {
@@ -42,8 +43,11 @@ std::shared_ptr<framework::OpStrategy> StrategyForTriangularSolve(
     const Target &target) {
   framework::CINNCompute triangular_solve_compute(
       [=](lang::Args args, lang::RetValue *ret) {
-        CHECK(!args.empty())
-            << "The input argument of triangular_solve is empty! Please check.";
+        PADDLE_ENFORCE_EQ(!args.empty(),
+                          true,
+                          ::common::errors::InvalidArgument(
+                              "The input argument of triangular_solve is "
+                              "empty. Please check the arguments."));
         CINNValuePack pack_args = args[0];
         PADDLE_ENFORCE_GE(
             pack_args.size(),
diff --git a/paddle/cinn/hlir/op/contrib/uniform_random.cc b/paddle/cinn/hlir/op/contrib/uniform_random.cc
@@ -40,6 +40,7 @@
 #include "paddle/cinn/lang/compute.h"
 #include "paddle/cinn/lang/packed_func.h"
 #include "paddle/cinn/poly/stage.h"
+#include "paddle/common/enforce.h"
 
 namespace cinn {
 namespace hlir {
@@ -56,7 +57,11 @@ std::shared_ptr<framework::OpStrategy> StrategyForUniformRandom(
     const Target &target) {
   framework::CINNCompute uniform_random_compute(
       [=](lang::Args args, lang::RetValue *ret) {
-        CHECK(attrs.attr_store.count("shape"));
+        PADDLE_ENFORCE_GE(
+            attrs.attr_store.count("shape"),
+            1,
+            ::common::errors::NotFound("The attribute 'shape' is not found in "
+                                       "attr_store. Please ensure it is set."));
         ir::Tensor shape_tensor;
         std::string tensor_name = "uniform_random_out";
         auto out = pe::Identity(shape_tensor, tensor_name).front();
diff --git a/paddle/cinn/hlir/pe/elementwise.cc b/paddle/cinn/hlir/pe/elementwise.cc
@@ -45,8 +45,11 @@ using lang::Compute;
 #define HLIR_MKL_IMP_UNARY_PE(name__, ex_name__)                           \
   std::vector<ir::Tensor> name__##MKL(const Tensor& A,                     \
                                       const std::string& output_name) {    \
-    CHECK(A->type().is_float())                                            \
-        << "type should be float or double but get " << A->type();         \
+    PADDLE_ENFORCE_EQ(A->type().is_float(),                                \
+                      true,                                                \
+                      ::common::errors::InvalidArgument(                   \
+                          "The type should be float or double. "           \
+                          "Please provide a valid type."));                \
     std::string fn_name =                                                  \
         "cinn_mkl_" #ex_name__ "_v_fp" + std::to_string(A->type().bits()); \
     auto call = Compute(                                                   \
diff --git a/paddle/cinn/hlir/pe/elementwise.h b/paddle/cinn/hlir/pe/elementwise.h
@@ -21,6 +21,7 @@
 #include "paddle/cinn/ir/ir.h"
 #include "paddle/cinn/lang/builtin.h"
 #include "paddle/cinn/lang/compute.h"
+#include "paddle/common/enforce.h"
 #include "paddle/pir/include/dialect/shape/utils/dim_expr.h"
 
 namespace cinn {
@@ -90,8 +91,11 @@ ir::Tensor AssignValue(
     const std::vector<T>& values,
     const cinn::common::Type& type = cinn::common::type_of<T>(),
     const std::string& output_name = "T_assign_value_out") {
-  CHECK(!values.empty())
-      << "The input of pe::AssignValue should not empty! Please check.";
+  PADDLE_ENFORCE_EQ(!values.empty(),
+                    true,
+                    ::common::errors::InvalidArgument(
+                        "The input of pe::AssignValue should not be empty. "
+                        "Please provide valid values."));
 
   auto out = lang::Compute(
       {ir::Expr(static_cast<int>(values.size()))},
diff --git a/paddle/cinn/ir/group_schedule/config/file_database.cc b/paddle/cinn/ir/group_schedule/config/file_database.cc
@@ -21,6 +21,7 @@
 #include <fstream>
 
 #include "paddle/cinn/utils/multi_threading.h"
+#include "paddle/common/enforce.h"
 
 PD_DECLARE_string(cinn_tile_config_filename_label);
 
@@ -180,7 +181,12 @@ void JsonStringToMessageOfTileConfig(
     group_schedule::config::proto::TileData tile_data;
     auto status = google::protobuf::util::JsonStringToMessage(json_lines[index],
                                                               &tile_data);
-    CHECK(status.ok()) << "Failed to parse JSON: " << json_lines[index];
+    PADDLE_ENFORCE_EQ(
+        status.ok(),
+        true,
+        ::common::errors::InvalidArgument(
+            "Failed to parse JSON: %s. Please check the JSON content.",
+            json_lines[index]));
     (*tile_database)[index] = tile_data;
   };
   utils::parallel_run(
diff --git a/paddle/cinn/ir/group_schedule/tactic/tile_tactic.cc b/paddle/cinn/ir/group_schedule/tactic/tile_tactic.cc
@@ -15,6 +15,7 @@
 #include "paddle/cinn/ir/group_schedule/tactic/tile_tactic.h"
 #include "paddle/cinn/common/target.h"
 #include "paddle/cinn/ir/ir.h"
+#include "paddle/common/enforce.h"
 
 namespace cinn {
 namespace ir {
@@ -120,8 +121,12 @@ void TileTactic::Init(ScheduleContext* context) {
 void TileTactic::Apply(ir::IRSchedule* sch, const std::string& block_id) {
   if (ir::IsReduceInitTensorName(block_id)) return;
   std::vector<ir::Expr> loops = sch->GetLoops(block_id);
-  CHECK(loops.size() == 1 || loops.size() == 2)
-      << "All loops must be unified as sp_loop or rb_loop.";
+  PADDLE_ENFORCE_EQ((loops.size() == 1 || loops.size() == 2),
+                    true,
+                    ::common::errors::InvalidArgument(
+                        "All loops must be unified as sp_loop or "
+                        "rb_loop. Current loop size: %d.",
+                        loops.size()));
   if (loops.size() == 2) {
     std::vector<ir::Expr> rb_factors;
     for (const auto& axis : context_->iter_space_info.rb_space) {
diff --git a/paddle/cinn/ir/intrinsic_ops.cc b/paddle/cinn/ir/intrinsic_ops.cc
@@ -157,7 +157,10 @@ Expr intrinsics::BuiltinIntrin::Make(const std::string& name,
   n->args.assign(args.begin(), args.end());
   n->id = id;
   n->arg_nums = arg_nums;
-  CHECK(!type.is_unk());
+  PADDLE_ENFORCE_EQ(!type.is_unk(),
+                    true,
+                    ::common::errors::InvalidArgument(
+                        "The type is unknown. Please provide a valid type."));
   n->type_ = type;
 
   return Expr(n);
diff --git a/paddle/cinn/ir/ir_visitor.h b/paddle/cinn/ir/ir_visitor.h
@@ -22,6 +22,7 @@
 #include "paddle/cinn/ir/lowered_func.h"
 #include "paddle/cinn/ir/tensor.h"
 #include "paddle/cinn/ir/utils/ir_nodes_collector.h"
+#include "paddle/common/enforce.h"
 
 namespace cinn {
 namespace ir {
@@ -39,7 +40,11 @@ class IRVisitorRequireReImpl {
   //! Visit a expression.
   // @{
   virtual RetTy Visit(const ir::Expr* expr, Args... args) {
-    CHECK(expr->defined());
+    PADDLE_ENFORCE_EQ(
+        expr->defined(),
+        true,
+        ::common::errors::Unavailable("The expression is not defined. Please "
+                                      "provide a valid expression."));
     switch (expr->node_type()) {
 #define __(op__)           \
   case ir::IrNodeTy::op__: \
diff --git a/paddle/cinn/ir/module.cc b/paddle/cinn/ir/module.cc
@@ -19,6 +19,7 @@
 #include "paddle/cinn/ir/ir_printer.h"
 #include "paddle/cinn/optim/ir_simplify.h"
 #include "paddle/cinn/optim/optimize.h"
+#include "paddle/common/enforce.h"
 
 namespace cinn {
 namespace ir {
@@ -59,8 +60,12 @@ std::optional<int> GetDataAlignment(common::Arch arch) {
 }
 
 void Module::Builder::AddBuffer(ir::Buffer buffer) {
-  CHECK(buffer->target.defined())
-      << "buffer [" << buffer->name << "]'s target is undefined";
+  PADDLE_ENFORCE_EQ(
+      buffer->target.defined(),
+      true,
+      ::common::errors::InvalidArgument(
+          "The target of buffer [%s] is undefined. Please define the target.",
+          buffer->name));
   if (std::find_if(
           module_->buffers.begin(), module_->buffers.end(), [&](const Expr &x) {
             return x.as_buffer()->name == buffer->name;
diff --git a/paddle/cinn/ir/registry.cc b/paddle/cinn/ir/registry.cc
@@ -16,6 +16,7 @@
 
 #include <map>
 #include <mutex>  // NOLINT
+#include "paddle/common/enforce.h"
 
 namespace cinn::ir {
 struct Registry::Manager {
@@ -50,8 +51,12 @@ Registry::Registry(const std::string &name) : name_(name) {}
   auto *manager = Registry::Manager::Global();
   std::lock_guard<std::mutex> lock(manager->mu);
   if (manager->functions.count(name)) {
-    CHECK(can_override) << "Global PackedFunc[" << name
-                        << "] is already exists";
+    PADDLE_ENFORCE_EQ(
+        can_override,
+        true,
+        ::common::errors::AlreadyExists(
+            "Global PackedFunc[%s] already exists and cannot be overridden.",
+            name));
   }
 
   auto *r = new Registry(name);
diff --git a/paddle/cinn/ir/schedule/impl/for_type.cc b/paddle/cinn/ir/schedule/impl/for_type.cc
@@ -56,7 +56,10 @@ void DyScheduleImpl::MutateForType(const Expr& loop,
 
   auto loop_copy = ir::ir_utils::IRCopy(loop, /* copy_buffer_node = */ false);
   auto* new_for_node = loop_copy.As<ir::For>();
-  CHECK(new_for_node);
+  PADDLE_ENFORCE_NOT_NULL(new_for_node,
+                          ::common::errors::InvalidArgument(
+                              "The newly created For node is null. "
+                              "Please ensure the loop_copy is valid."));
   new_for_node->set_for_type(for_type);
   if (new_for_node->is_vectorized()) {
     VectorizeInfo vec_info(0, factor);
diff --git a/paddle/cinn/ir/schedule/impl/reduction.cc b/paddle/cinn/ir/schedule/impl/reduction.cc
@@ -88,7 +88,12 @@ Expr DyScheduleImpl::FactorizeReduction(const Expr& rf_loop,
                                   ->schedule_block.As<ir::ScheduleBlock>()
                                   ->body;
   Expr original_update_stmt;
-  CHECK(original_update_body.As<Block>() || original_update_body.As<Store>());
+  PADDLE_ENFORCE_EQ(
+      (original_update_body.As<Block>() || original_update_body.As<Store>()),
+      true,
+      ::common::errors::InvalidArgument(
+          "The original update body must be either Block or Store. Current "
+          "type is invalid."));
   if (original_update_body.As<Block>()) {
     PADDLE_ENFORCE_EQ(original_update_body.As<Block>()->stmts.size(),
                       1,
diff --git a/paddle/cinn/poly/domain.cc b/paddle/cinn/poly/domain.cc
@@ -25,12 +25,17 @@
 #include "paddle/cinn/common/context.h"
 #include "paddle/cinn/ir/ir_visitor.h"
 #include "paddle/cinn/utils/string.h"
+#include "paddle/common/enforce.h"
 
 namespace cinn {
 namespace poly {
 
 std::string Domain::__str__() const {
-  CHECK(!id.empty()) << "domain's id is empty";
+  PADDLE_ENFORCE_EQ(
+      !id.empty(),
+      true,
+      ::common::errors::InvalidArgument(
+          "The domain's ID is empty. Please provide a valid ID."));
   std::vector<std::string> range_fields;
   std::transform(dims.begin(),
                  dims.end(),
diff --git a/paddle/cinn/poly/map.cc b/paddle/cinn/poly/map.cc
@@ -16,12 +16,17 @@
 
 #include "paddle/cinn/poly/isl_utils.h"
 #include "paddle/cinn/utils/functional.h"
+#include "paddle/common/enforce.h"
 
 namespace cinn {
 namespace poly {
 
 std::string Map::__str__() const {
-  CHECK(!domain_iterators_.empty());
+  PADDLE_ENFORCE_EQ(
+      !domain_iterators_.empty(),
+      true,
+      ::common::errors::InvalidArgument(
+          "The domain iterators are empty. Please provide valid iterators."));
 
   auto get_ids_repr = [](const std::vector<Iterator>& ids) {
     std::vector<std::string> fields;
diff --git a/paddle/cinn/poly/naive_scheduler.cc b/paddle/cinn/poly/naive_scheduler.cc
@@ -21,7 +21,10 @@ namespace poly {
 
 std::unique_ptr<Schedule> NaiveScheduler::BuildSchedule() {
   PartitionGroups();
-  CHECK(!groups_.empty());
+  PADDLE_ENFORCE_EQ(!groups_.empty(),
+                    true,
+                    ::common::errors::InvalidArgument(
+                        "The groups are empty. Please provide valid groups."));
 
   for (auto &group : groups_) {
     std::vector<Stage *> status;
diff --git a/paddle/cinn/poly/schedule.h b/paddle/cinn/poly/schedule.h
@@ -31,6 +31,7 @@
 #include "paddle/cinn/poly/isl_utils.h"
 #include "paddle/cinn/poly/map.h"
 #include "paddle/cinn/poly/stage.h"
+#include "paddle/common/enforce.h"
 
 namespace cinn {
 namespace poly {
@@ -46,7 +47,11 @@ struct TimeDim {
 
   TimeDim() = default;
   TimeDim(const std::string &dim, int time) : dim(dim), time(time) {
-    CHECK(!dim.empty());
+    PADDLE_ENFORCE_EQ(
+        !dim.empty(),
+        true,
+        ::common::errors::InvalidArgument(
+            "The dimension is empty. Please provide a valid dimension."));
   }
 };
 
