【Error Message BUAA】add error description for few files (#66794)

Jeff114514 · web-flow · commit a1488552bf54 · 2024-08-02T10:02:50.000+08:00
* add msg

* Update ir_copy.cc

* Update schedule_block_graph.cc

* codestyle

* fix nullptr

* Update ir_replace.cc
diff --git a/paddle/cinn/common/cinn_value.cc b/paddle/cinn/common/cinn_value.cc
@@ -160,17 +160,26 @@ CINNValue::CINNValue(const std::string &value)
 }
 CINNValue::CINNValue(const Var &value)
     : cinn_pod_value_t(cinn_value_t(), TypeCode<Var>()) {
-  CHECK(value.defined());
+  PADDLE_ENFORCE_EQ(
+      value.defined(),
+      true,
+      ::common::errors::InvalidArgument("The input of Var is not defined."));
   shared_ = value;
 }
 CINNValue::CINNValue(const Expr &value)
     : cinn_pod_value_t(cinn_value_t(), TypeCode<Expr>()) {
-  CHECK(value.defined());
+  PADDLE_ENFORCE_EQ(
+      value.defined(),
+      true,
+      ::common::errors::InvalidArgument("The input of Expr is not defined."));
   shared_ = value;
 }
 CINNValue::CINNValue(const CINNValuePack &value)
     : cinn_pod_value_t(cinn_value_t(), TypeCode<CINNValuePack>()) {
-  CHECK(value.defined());
+  PADDLE_ENFORCE_EQ(value.defined(),
+                    true,
+                    ::common::errors::InvalidArgument(
+                        "The input of CINNValuePack is not defined."));
   shared_ = value;
 }
 
@@ -194,7 +203,11 @@ const CINNValue &_CINNValuePack_::operator[](int offset) const {
   return values_[offset];
 }
 void _CINNValuePack_::AddValue(const CINNValue &value) {
-  CHECK(value.defined());
+  PADDLE_ENFORCE_EQ(
+      value.defined(),
+      true,
+      ::common::errors::InvalidArgument("The CINNValue is not defined. Which "
+                                        "can't be added to CINNValuePack."));
   values_.push_back(value);
 }
 void _CINNValuePack_::Clear() { values_.clear(); }
diff --git a/paddle/cinn/common/common.h b/paddle/cinn/common/common.h
@@ -56,17 +56,56 @@ T& Reference(const T* x) {
 }
 
 static void CheckVarNameValid(const absl::string_view name) {
-  CHECK(!name.empty());
-  CHECK(name.find(' ') == std::string::npos &&   //
-        name.find('.') == std::string::npos &&   //
-        name.find('@') == std::string::npos &&   //
-        name.find('/') == std::string::npos &&   //
-        name.find('\t') == std::string::npos &&  //
-        name.find('\n') == std::string::npos &&  //
-        name.find('\r') == std::string::npos)
-      << "Some invalid character found";
-  CHECK(!cinn::common::IsAxisNameReserved(std::string(name)))
-      << "The name [" << name << "] is reserved for internal axis";
+  PADDLE_ENFORCE_EQ(name.empty(),
+                    false,
+                    ::common::errors::InvalidArgument(
+                        "Var name is empty. Please check your input"));
+  PADDLE_ENFORCE_EQ(
+      name.find(' '),
+      std::string::npos,
+      ::common::errors::InvalidArgument("Var name contains space. Received: "
+                                        "%s, which is invalid for var name.",
+                                        name));
+  PADDLE_ENFORCE_EQ(
+      name.find('.'),
+      std::string::npos,
+      ::common::errors::InvalidArgument(
+          "Var name contains dot. Received: %s, which is invalid for var name.",
+          name));
+  PADDLE_ENFORCE_EQ(
+      name.find('@'),
+      std::string::npos,
+      ::common::errors::InvalidArgument(
+          "Var name contains at. Received: %s, which is invalid for var name.",
+          name));
+  PADDLE_ENFORCE_EQ(
+      name.find('/'),
+      std::string::npos,
+      ::common::errors::InvalidArgument("Var name contains slash. Received: "
+                                        "%s, which is invalid for var name.",
+                                        name));
+  PADDLE_ENFORCE_EQ(
+      name.find('\t'),
+      std::string::npos,
+      ::common::errors::InvalidArgument(
+          "Var name contains tab. Received: %s, which is invalid for var name.",
+          name));
+  PADDLE_ENFORCE_EQ(
+      name.find('\n'),
+      std::string::npos,
+      ::common::errors::InvalidArgument("Var name contains newline. Received: "
+                                        "%s, which is invalid for var name.",
+                                        name));
+  PADDLE_ENFORCE_EQ(name.find('\r'),
+                    std::string::npos,
+                    ::common::errors::InvalidArgument(
+                        "Var name contains carriage return. Received: %s, "
+                        "which is invalid for var name.",
+                        name));
+  PADDLE_ENFORCE_EQ(cinn::common::IsAxisNameReserved(std::string(name)),
+                    false,
+                    ::common::errors::InvalidArgument(
+                        "The name [%s] is reserved for internal axis", name));
 }
 
 }  // namespace cinn
diff --git a/paddle/cinn/ir/schedule_block_graph.cc b/paddle/cinn/ir/schedule_block_graph.cc
@@ -22,8 +22,10 @@ namespace ir {
 
 ScheduleBlockNode::ScheduleBlockNode(Expr block, const IRSchedule& ir_sch)
     : ir_sch_(ir_sch) {
-  CHECK(block.As<ScheduleBlockRealize>())
-      << "Expr is not a ScheduleBlockRealize: " << block;
+  PADDLE_ENFORCE_NE(
+      block.As<ScheduleBlockRealize>(),
+      nullptr,
+      ::common::errors::InvalidArgument("Expr is not a ScheduleBlockRealize."));
   id_ = block.As<ScheduleBlockRealize>()
             ->schedule_block.As<ScheduleBlock>()
             ->name;
@@ -98,8 +100,10 @@ void ScheduleBlockGraph::Update(const IRSchedule& ir_sch) {
   std::vector<Expr> all_blocks = ir_sch.GetAllBlocks();
   Expr root_block = ir_sch.GetRootBlock(all_blocks[0]);
   for (Expr block : all_blocks) {
-    CHECK(block.As<ScheduleBlockRealize>())
-        << "Expr is not a ScheduleBlockRealize: " << block;
+    PADDLE_ENFORCE_NE(block.As<ScheduleBlockRealize>(),
+                      nullptr,
+                      ::common::errors::InvalidArgument(
+                          "Expr is not a ScheduleBlockRealize."));
     std::string id = block.As<ScheduleBlockRealize>()
                          ->schedule_block.As<ScheduleBlock>()
                          ->name;
@@ -113,14 +117,18 @@ void ScheduleBlockGraph::Update(const IRSchedule& ir_sch) {
 
     std::vector<Expr> producers = GetProducers(block, root_block);
     for (Expr producer : producers) {
-      CHECK(producer.As<ScheduleBlockRealize>())
-          << "Expr is not a ScheduleBlockRealize: " << producer;
+      PADDLE_ENFORCE_NE(producer.As<ScheduleBlockRealize>(),
+                        nullptr,
+                        ::common::errors::InvalidArgument(
+                            "Expr is not a ScheduleBlockRealize."));
       std::string producer_id = producer.As<ScheduleBlockRealize>()
                                     ->schedule_block.As<ScheduleBlock>()
                                     ->name;
       ScheduleBlockNode* producer_node = RetrieveNode(producer_id);
-      CHECK(producer_node) << "producer node: " << producer_id
-                           << " does not exist in the graph";
+      PADDLE_ENFORCE_NOT_NULL(
+          producer_node,
+          ::common::errors::InvalidArgument(
+              "producer node: %s does not exist in the graph", producer_id));
       producer_node->Controls(node);
       for (const std::string& upstream_node_id :
            producer_node->UpstreamNodes()) {
diff --git a/paddle/cinn/ir/utils/ir_copy.cc b/paddle/cinn/ir/utils/ir_copy.cc
@@ -346,8 +346,16 @@ struct IRCopyVisitor : public ir::IRVisitorRequireReImpl<Expr> {
   Expr Visit(const Broadcast* op) override {
     auto value = Visit(&op->value);
     int lanes = op->lanes;
-    CHECK(value.defined());
-    CHECK(value.type().valid());
+    PADDLE_ENFORCE_EQ(
+        value.defined(),
+        true,
+        phi::errors::InvalidArgument("Broadcasting value is not defined."));
+    PADDLE_ENFORCE_EQ(
+        value.type().valid(),
+        true,
+        phi::errors::InvalidArgument("Broadcasting value type is invalid. "
+                                     "Expected a valid type, but got: %s",
+                                     value.type()));
 
     auto* n = make_shared<Broadcast>();
     n->value = value;
@@ -358,8 +366,14 @@ struct IRCopyVisitor : public ir::IRVisitorRequireReImpl<Expr> {
   Expr Visit(const FracOp* op) override {
     auto a = Visit(&op->a());
     auto b = Visit(&op->b());
-    CHECK(a.defined());
-    CHECK(b.defined());
+    PADDLE_ENFORCE_EQ(a.defined(),
+                      true,
+                      phi::errors::InvalidArgument(
+                          "The first operand of FracOp is not defined."));
+    PADDLE_ENFORCE_EQ(b.defined(),
+                      true,
+                      phi::errors::InvalidArgument(
+                          "The second operand of FracOp is not defined."));
 
     auto* n = make_shared<FracOp>();
     n->a() = a;
@@ -409,7 +423,11 @@ struct IRCopyVisitor : public ir::IRVisitorRequireReImpl<Expr> {
     std::vector<Var> iter_vars;
     for (auto iter_var : op->iter_vars) {
       auto* var = iter_var.As<_Var_>();
-      CHECK(var);
+      PADDLE_ENFORCE_NE(
+          var,
+          nullptr,
+          phi::errors::InvalidArgument(
+              "ScheduleBlock iter_var is not a valid _Var_ type."));
       iter_vars.push_back(Visit(var));
     }
     std::vector<Expr> read_buffers;
diff --git a/paddle/cinn/ir/utils/ir_nodes_collector.cc b/paddle/cinn/ir/utils/ir_nodes_collector.cc
@@ -280,10 +280,14 @@ std::vector<std::string> CollectUndefinedVars(const Expr* e) {
     std::set<std::string> used_vars;
 
     void CollectVarDef(const std::string& var) {
-      CHECK(!defined_vars.count(var))
-          << "var " << var << " has been defined, please check";
-      CHECK(!used_vars.count(var))
-          << "var " << var << " is wrongly used before definition";
+      PADDLE_ENFORCE_EQ(defined_vars.count(var),
+                        false,
+                        phi::errors::InvalidArgument(
+                            "var %s has been defined, please check", var));
+      PADDLE_ENFORCE_EQ(used_vars.count(var),
+                        false,
+                        phi::errors::InvalidArgument(
+                            "var %s is wrongly used before definition", var));
       defined_vars.insert(var);
     }
 
@@ -302,7 +306,10 @@ std::vector<std::string> CollectUndefinedVars(const Expr* e) {
     void Visit(const ir::Let* op, const Expr* expr) override {
       Expr symbol = op->symbol;
       auto var = symbol.as_var_ref();
-      CHECK(var.defined());
+      PADDLE_ENFORCE_EQ(var.defined(),
+                        true,
+                        phi::errors::InvalidArgument(
+                            "var %s is not defined, please check.", var->name));
       CollectVarDef(var->name);
       auto* node = expr->As<ir::Let>();
       Visit(&node->body, &node->body);
diff --git a/paddle/cinn/ir/utils/ir_replace.cc b/paddle/cinn/ir/utils/ir_replace.cc
@@ -34,8 +34,10 @@ struct IrReplaceVarBroadcastMutator : ir::IRMutator<Expr*> {
 
   IrReplaceVarBroadcastMutator(ir::Expr from, Expr to)
       : from_(from), to_(to), from_repr_(GetStreamCnt(from)) {
-    CHECK(valid_nodetys.count(from->node_type()))
-        << "Not valid node type got " << from->node_type();
+    PADDLE_ENFORCE_EQ(valid_nodetys.count(from->node_type()),
+                      true,
+                      phi::errors::InvalidArgument("Not valid node type got %s",
+                                                   from->node_type()));
   }
   void operator()(Expr* expr) { ir::IRMutator<>::Visit(expr, expr); }
 
@@ -80,12 +82,18 @@ struct IrReplaceMutator : ir::IRMutator<Expr*> {
 }  // namespace
 
 void IrReplaceVarBroadcast(ir::Expr* expr, ir::Expr from, ir::Expr to) {
-  CHECK(expr);
+  PADDLE_ENFORCE_NE(
+      expr,
+      nullptr,
+      phi::errors::InvalidArgument("Input expr should not be nullptr"));
   IrReplaceVarBroadcastMutator(from, to)(expr);
 }
 
 void IrReplace(ir::Expr* expr, ir::Expr from, ir::Expr to) {
-  CHECK(expr);
+  PADDLE_ENFORCE_NE(
+      expr,
+      nullptr,
+      phi::errors::InvalidArgument("Input expr should not be nullptr"));
   IrReplaceMutator(from, to)(expr);
 }
 
