【Error Message No. 35 BUAA】gather_nd.cc & one_hot.cc & dot_lang.cc (#66857)

BHmingyang · web-flow · commit 233b584cf416 · 2024-08-01T16:16:45.000+08:00
* rewrite some warning messages

* add .h files
diff --git a/paddle/cinn/hlir/op/contrib/gather_nd.cc b/paddle/cinn/hlir/op/contrib/gather_nd.cc
@@ -136,18 +136,31 @@ std::shared_ptr<framework::OpStrategy> StrategyForGatherNd(
 
   framework::CINNCompute gather_nd_compute([=](lang::Args args,
                                                lang::RetValue *ret) {
-    CHECK(!args.empty()) << "The input arguments of " << op_name
-                         << " compute is empty! Please check.\n";
+    PADDLE_ENFORCE_NE(
+        args.empty(),
+        true,
+        phi::errors::InvalidArgument(
+            "The input argument of %s compute is empty! Please check.",
+            op_name));
     CINNValuePack pack_args = args[0];
     PADDLE_ENFORCE_GE(
         pack_args.size(),
         2U,
         phi::errors::InvalidArgument("2 input tensors for compute\n"));
     Expr x = pack_args[0];
     Expr index = pack_args[1];
-    CHECK(x.as_tensor());
-    CHECK(index.as_tensor());
-    CHECK(!output_shapes.empty());
+    PADDLE_ENFORCE_NOT_NULL(x.as_tensor(),
+                            phi::errors::InvalidArgument(
+                                "Required x must be a tensor. Please check."));
+    PADDLE_ENFORCE_NOT_NULL(
+        index.as_tensor(),
+        phi::errors::InvalidArgument(
+            "Required index must be a tensor. Please check."));
+    PADDLE_ENFORCE_NE(
+        output_shapes.empty(),
+        true,
+        phi::errors::InvalidArgument(
+            "The output shape of gather_nd is empty! Please check."));
     auto tensor_x = x.as_tensor_ref();
     auto tensor_index = index.as_tensor_ref();
     VLOG(3) << "x shape: " << utils::Join(tensor_x->shape, ", ")
@@ -161,8 +174,11 @@ std::shared_ptr<framework::OpStrategy> StrategyForGatherNd(
     ir::Tensor out = GatherNd(tensor_x, tensor_index, tensor_name);
     std::vector<CINNValue> res;
     res.push_back(CINNValue(out));
-    CHECK(!out_type.empty())
-        << "Output type of " << op_name << " is empty! Please check.\n";
+    PADDLE_ENFORCE_NE(
+        out_type.empty(),
+        true,
+        phi::errors::InvalidArgument(
+            "The output type of gather_nd is empty! Please check."));
     *ret = CINNValuePack{res};
   });
 
@@ -229,18 +245,31 @@ std::shared_ptr<framework::OpStrategy> StrategyForGatherNdSymbolic(
 
   framework::CINNCompute gather_nd_compute([=](lang::Args args,
                                                lang::RetValue *ret) {
-    CHECK(!args.empty()) << "The input arguments of " << op_name
-                         << " compute is empty! Please check.\n";
+    PADDLE_ENFORCE_NE(
+        args.empty(),
+        true,
+        phi::errors::InvalidArgument(
+            "The input argument of %s compute is empty! Please check.",
+            op_name));
     CINNValuePack pack_args = args[0];
     PADDLE_ENFORCE_GE(
         pack_args.size(),
         2U,
         phi::errors::InvalidArgument("2 input tensors for compute\n"));
     Expr x = pack_args[0];
     Expr index = pack_args[1];
-    CHECK(x.as_tensor());
-    CHECK(index.as_tensor());
-    CHECK(!output_shapes.empty());
+    PADDLE_ENFORCE_NOT_NULL(x.as_tensor(),
+                            phi::errors::InvalidArgument(
+                                "Required x must be a tensor. Please check."));
+    PADDLE_ENFORCE_NOT_NULL(
+        index.as_tensor(),
+        phi::errors::InvalidArgument(
+            "Required index must be a tensor. Please check."));
+    PADDLE_ENFORCE_NE(
+        output_shapes.empty(),
+        true,
+        phi::errors::InvalidArgument(
+            "The output shape of gather_nd is empty! Please check."));
     auto tensor_x = x.as_tensor_ref();
     auto tensor_index = index.as_tensor_ref();
     VLOG(3) << "x shape: " << utils::Join(tensor_x->shape, ", ")
@@ -254,8 +283,11 @@ std::shared_ptr<framework::OpStrategy> StrategyForGatherNdSymbolic(
     ir::Tensor out = GatherNdSymbolic(tensor_x, tensor_index, tensor_name);
     std::vector<CINNValue> res;
     res.push_back(CINNValue(out));
-    CHECK(!out_type.empty())
-        << "Output type of " << op_name << " is empty! Please check.\n";
+    PADDLE_ENFORCE_NE(
+        out_type.empty(),
+        true,
+        phi::errors::InvalidArgument(
+            "The output type of gather_nd is empty! Please check."));
     *ret = CINNValuePack{res};
   });
 
diff --git a/paddle/cinn/hlir/op/contrib/one_hot.cc b/paddle/cinn/hlir/op/contrib/one_hot.cc
@@ -49,16 +49,34 @@ ir::Tensor OneHot(const ir::Tensor& indices,
                   const Type& dtype,
                   const std::string& output_name) {
   int ndim = static_cast<int>(indices->shape.size());
-  CHECK(axis == -1 || (0 <= axis && axis <= ndim))
-      << "one_hot only accepts `axis` in [-1, data.ndim]"
-      << ", but got axis = " << axis << ", and data.ndim = " << ndim;
-  CHECK(depth > 0) << "one_hot only accepts `depth > 0`"
-                   << ", but got depth = " << depth;
-
-  CHECK(on_value->shape.size() == 1U && on_value->shape[0].as_int32() == 1U)
-      << "The shape of on_value must be [1]";
-  CHECK(off_value->shape.size() == 1U && off_value->shape[0].as_int32() == 1U)
-      << "The shape of off_value must be [1]";
+  PADDLE_ENFORCE_EQ(axis == -1 || (0 <= axis && axis <= ndim),
+                    true,
+                    phi::errors::InvalidArgument(
+                        "The one_hot op only accepts `axis` in [-1, "
+                        "data.ndim], but got axis = %d, and data.ndim = %d",
+                        axis,
+                        ndim));
+  PADDLE_ENFORCE_EQ(
+      depth > 0,
+      true,
+      phi::errors::InvalidArgument(
+          "The one_hot op only accepts `depth` > 0, but got depth = %d.",
+          depth));
+
+  PADDLE_ENFORCE_EQ(
+      on_value->shape.size() == 1U && on_value->shape[0].as_int32() == 1U,
+      true,
+      phi::errors::InvalidArgument("The shape of on_value must be [1], but got "
+                                   "shape = %d, and shape[0] = %d.",
+                                   on_value->shape.size(),
+                                   on_value->shape[0].as_int32()));
+  PADDLE_ENFORCE_EQ(
+      off_value->shape.size() == 1U && off_value->shape[0].as_int32() == 1U,
+      true,
+      phi::errors::InvalidArgument("The shape of off_value must be [1], but "
+                                   "got shape = %d, and shape[0] = %d.",
+                                   off_value->shape.size(),
+                                   off_value->shape[0].as_int32()));
 
   int true_axis = (axis == -1) ? ndim : axis;
   std::vector<Expr> new_shape;
@@ -117,29 +135,55 @@ std::shared_ptr<framework::OpStrategy> StrategyForOneHot(
     }
   }
 
-  CHECK(depth > 0) << "one_hot only accepts `depth > 0`"
-                   << ", but got depth = " << depth;
+  PADDLE_ENFORCE_EQ(
+      depth > 0,
+      true,
+      phi::errors::InvalidArgument(
+          "The one_hot op only accepts `depth` > 0, but got depth = %d.",
+          depth));
 
   framework::CINNCompute one_hot_compute([=](lang::Args args,
                                              lang::RetValue* ret) {
-    CHECK(!args.empty())
-        << "The input argument of one_hot compute is empty! Please check.\n";
+    PADDLE_ENFORCE_NE(
+        args.empty(),
+        true,
+        phi::errors::InvalidArgument(
+            "The input argument of one_hot compute is empty! Please check."));
     cinn::common::CINNValuePack pack_args = args[0];
-    CHECK(!pack_args.empty())
-        << "at least one input tensor for transpose compute\n";
-    CHECK_GE(pack_args.size(), 3U);
+    PADDLE_ENFORCE_NE(
+        pack_args.empty(),
+        true,
+        phi::errors::InvalidArgument(
+            "The input tensors for one_hot compute is empty! Please check."));
+    PADDLE_ENFORCE_GE(pack_args.size(),
+                      3U,
+                      phi::errors::InvalidArgument(
+                          "At least 3 input tensors for one_hot compute\n"));
     Expr indices_expr = pack_args[0];
     Expr on_value_expr = pack_args[1];
     Expr off_value_expr = pack_args[2];
-    CHECK(indices_expr.as_tensor());
-    CHECK(on_value_expr.as_tensor());
-    CHECK(off_value_expr.as_tensor());
+    PADDLE_ENFORCE_NOT_NULL(
+        indices_expr.as_tensor(),
+        phi::errors::InvalidArgument(
+            "Required indixes must be a tensor. Please check."));
+    PADDLE_ENFORCE_NOT_NULL(
+        on_value_expr.as_tensor(),
+        phi::errors::InvalidArgument(
+            "Required on_value must be a tensor. Please check."));
+    PADDLE_ENFORCE_NOT_NULL(
+        off_value_expr.as_tensor(),
+        phi::errors::InvalidArgument(
+            "Required off_value must be a tensor. Please check."));
 
     ir::Tensor indices = indices_expr.as_tensor_ref();
     ir::Tensor on_value = on_value_expr.as_tensor_ref();
     ir::Tensor off_value = off_value_expr.as_tensor_ref();
 
-    CHECK_EQ(pack_args.size(), 4U);
+    PADDLE_ENFORCE_EQ(
+        pack_args.size(),
+        4U,
+        phi::errors::InvalidArgument(
+            "The number of input tensors for one_hot compute should be 4."));
     std::string tensor_name = pack_args[3].operator std::string();
 
     ir::Tensor out = OneHot(indices,
diff --git a/paddle/cinn/utils/dot_lang.cc b/paddle/cinn/utils/dot_lang.cc
@@ -17,6 +17,7 @@
 #include <glog/logging.h>
 
 #include <sstream>
+#include "paddle/common/enforce.h"
 
 namespace cinn {
 namespace utils {
@@ -46,7 +47,10 @@ DotNode::DotNode(const std::string& name,
 
 std::string DotNode::repr() const {
   std::stringstream ss;
-  CHECK(!name.empty());
+  PADDLE_ENFORCE_NE(name.empty(),
+                    true,
+                    phi::errors::InvalidArgument(
+                        "The name of DotNode is empty! Please check."));
   ss << id_;
   if (attrs.empty()) {
     ss << "[label=" << '"' << name << '"' << "]";
@@ -72,8 +76,14 @@ DotCluster::DotCluster(const std::string& name,
 
 std::string DotEdge::repr() const {
   std::stringstream ss;
-  CHECK(!source.empty());
-  CHECK(!target.empty());
+  PADDLE_ENFORCE_NE(source.empty(),
+                    true,
+                    phi::errors::InvalidArgument(
+                        "The source of DotEdge is empty! Please check."));
+  PADDLE_ENFORCE_NE(target.empty(),
+                    true,
+                    phi::errors::InvalidArgument(
+                        "The target of DotEdge is empty! Please check."));
   ss << source << "->" << target;
   for (size_t i = 0; i < attrs.size(); i++) {
     if (i == 0) {
@@ -91,36 +101,54 @@ void DotLang::AddNode(const std::string& id,
                       std::string cluster_id,
                       bool allow_duplicate) {
   if (!allow_duplicate) {
-    CHECK(!nodes_.count(id)) << "duplicate Node '" << id << "'";
+    PADDLE_ENFORCE_EQ(
+        !nodes_.count(id),
+        true,
+        phi::errors::InvalidArgument("Duplicate Node %s, please check.", id));
   }
   if (!nodes_.count(id)) {
     if (label.empty()) {
       label = id;
     }
     nodes_.emplace(id, DotNode{label, attrs, cluster_id});
     if (!cluster_id.empty()) {
-      CHECK(clusters_.count(cluster_id)) << "Cluster '" << cluster_id << "'"
-                                         << " is not existed";
+      PADDLE_ENFORCE_GE(clusters_.count(cluster_id),
+                        1,
+                        phi::errors::InvalidArgument(
+                            "Cluster %s is not existed.", cluster_id));
       clusters_[cluster_id].Insert(&nodes_[id]);
     }
   }
 }
 
 void DotLang::AddCluster(const std::string& id,
                          const std::vector<DotAttr>& attrs) {
-  CHECK(!clusters_.count(id)) << "duplicate Cluster '" << id << "'";
+  PADDLE_ENFORCE_EQ(
+      !clusters_.count(id),
+      true,
+      phi::errors::InvalidArgument("Duplicate Cluster %s, please check.", id));
   clusters_.emplace(id, DotCluster{id, attrs});
 }
 
 void DotLang::AddEdge(const std::string& source,
                       const std::string& target,
                       const std::vector<DotAttr>& attrs) {
-  CHECK(!source.empty());
-  CHECK(!target.empty());
-  CHECK(nodes_.find(source) != nodes_.end())
-      << "Call AddNode to add " << source << " to dot first";
-  CHECK(nodes_.find(target) != nodes_.end())
-      << "Call AddNode to add " << target << " to dot first";
+  PADDLE_ENFORCE_NE(source.empty(),
+                    true,
+                    phi::errors::InvalidArgument(
+                        "The source of AddEdge is empty! Please check."));
+  PADDLE_ENFORCE_NE(target.empty(),
+                    true,
+                    phi::errors::InvalidArgument(
+                        "The target of AddEdge is empty! Please check."));
+  PADDLE_ENFORCE_EQ(nodes_.find(source) != nodes_.end(),
+                    true,
+                    phi::errors::InvalidArgument(
+                        "Call AddNote to add %s to dot first.", source));
+  PADDLE_ENFORCE_EQ(nodes_.find(target) != nodes_.end(),
+                    true,
+                    phi::errors::InvalidArgument(
+                        "Call AddNote to add %s to dot first.", target));
   auto sid = nodes_.at(source).id();
   auto tid = nodes_.at(target).id();
   edges_.emplace_back(sid, tid, attrs);
