【Error Message No. 28-33 BUAA】modify error messages (#66536)

Guanhuachen2003 · web-flow · commit 8990a884731f · 2024-07-26T15:53:43.000+08:00
* Update autograd_meta_test.cc

* Update inlined_vector_test.cc

* Update small_vector_test.cc

* Update transfer_layout_pass.cc

* Update transfer_layout_pass.cc

* Update grad_tensor_holder_test.cc

* Update transfer_layout_pass.cc

* Update transfer_layout_pass.cc

* Update transfer_layout_pass.cc

* Update small_vector_test.cc
diff --git a/paddle/fluid/framework/ir/transfer_layout_pass.cc b/paddle/fluid/framework/ir/transfer_layout_pass.cc
@@ -49,7 +49,10 @@ void InsertLayoutTransOp(ir::Graph *graph,
       desc.SetAttr("dst_layout", static_cast<int>(to_layout));
       desc.Flush();
     };
-    CHECK_NOTNULL(block_desc);
+    PADDLE_ENFORCE_NOT_NULL(
+        block_desc,
+        phi::errors::PreconditionNotMet(
+            "BlockDesc should not be null when inserting layout transfer op."));
     if (cache->count(prev_node) == 0) {
       framework::OpDesc op_desc(block_desc);
       update_op_desc(op_desc, in_var_name, out_var_name);
@@ -155,7 +158,12 @@ void TransferLayoutPass::ApplyImpl(ir::Graph *graph) const {
     for (const auto &filter_name : filter_names) {
       auto *filter_var = scope->FindLocalVar(filter_name);
       const auto &filter_tensor = filter_var->Get<phi::DenseTensor>();
-      CHECK_EQ(filter_tensor.dims().size() == 4UL, true);
+      PADDLE_ENFORCE_EQ(
+          filter_tensor.dims().size(),
+          4UL,
+          phi::errors::InvalidArgument(
+              "The 'Filter' tensor should have 4 dimensions, but received %d.",
+              filter_tensor.dims().size()));
       int oc = static_cast<int>(filter_tensor.dims()[0]);
       int ic = static_cast<int>(filter_tensor.dims()[1]);
       bool cudnn_can_support =
@@ -178,7 +186,10 @@ void TransferLayoutPass::ApplyImpl(ir::Graph *graph) const {
   };
 
   for (auto *op_node : op_nodes) {
-    CHECK_EQ(op_node->IsOp(), true);
+    PADDLE_ENFORCE_EQ(op_node->IsOp(),
+                      true,
+                      phi::errors::InvalidArgument(
+                          "The node should be an operation, but it's not."));
     // some common check.
     if (op_node->Op()->Type() != target_op_type) {
       continue;
@@ -202,7 +213,10 @@ void TransferLayoutPass::ApplyImpl(ir::Graph *graph) const {
 
   // The target operators that share weights either run nhwc or not at all.
   for (auto *op_node : op_nodes) {
-    CHECK_EQ(op_node->IsOp(), true);
+    PADDLE_ENFORCE_EQ(op_node->IsOp(),
+                      true,
+                      phi::errors::InvalidArgument(
+                          "The node should be an operation, but it's not."));
     if (valid_ops.count(op_node)) {
       auto filter_names = op_node->Op()->Input("Filter");
       for (const auto &filter_name : filter_names) {
@@ -221,7 +235,10 @@ void TransferLayoutPass::ApplyImpl(ir::Graph *graph) const {
 
   // Insert transfer_layout op
   for (auto *op_node : op_nodes) {
-    CHECK_EQ(op_node->IsOp(), true);
+    PADDLE_ENFORCE_EQ(op_node->IsOp(),
+                      true,
+                      phi::errors::InvalidArgument(
+                          "The node should be an operation, but it's not."));
 
     if (valid_ops.count(op_node)) {
       auto *op_desc = op_node->Op();
@@ -258,7 +275,11 @@ void TransferLayoutPass::ApplyImpl(ir::Graph *graph) const {
 
         auto op_inputs = op_node->inputs;
         for (auto *in_var_node : op_inputs) {
-          CHECK_EQ(in_var_node->IsVar(), true);
+          PADDLE_ENFORCE_EQ(
+              in_var_node->IsVar(),
+              true,
+              phi::errors::InvalidArgument(
+                  "The node should be a variable, but it's not."));
           if (in_var_node->Var()->Persistable() &&
               in_var_node->Var()->Name() == filter_name) {
             auto from_shape = in_var_node->Var()->GetShape();
@@ -271,7 +292,11 @@ void TransferLayoutPass::ApplyImpl(ir::Graph *graph) const {
       // transfer outputs
       auto op_outputs = op_node->outputs;
       for (auto *out_var_node : op_outputs) {
-        CHECK_EQ(out_var_node->IsVar(), true);
+        PADDLE_ENFORCE_EQ(out_var_node->IsVar(),
+                          true,
+                          phi::errors::InvalidArgument(
+                              "The node should be a variable, but it's not."));
+
         if (out_var_node->Var()->Persistable()) continue;
 
         auto from_shape = out_var_node->Var()->GetShape();
@@ -283,7 +308,10 @@ void TransferLayoutPass::ApplyImpl(ir::Graph *graph) const {
       // Insert transfer_layout for intermidiate var.
       auto op_inputs = op_node->inputs;
       for (auto *in_var_node : op_inputs) {
-        CHECK_EQ(in_var_node->IsVar(), true);
+        PADDLE_ENFORCE_EQ(in_var_node->IsVar(),
+                          true,
+                          phi::errors::InvalidArgument(
+                              "The node should be a variable, but it's not."));
 
         if (in_var_node->Var()->Persistable()) continue;
         if (vars_shape_nhwc.count(in_var_node)) continue;
@@ -299,7 +327,10 @@ void TransferLayoutPass::ApplyImpl(ir::Graph *graph) const {
     } else {
       auto op_inputs = op_node->inputs;
       for (auto *in_var_node : op_inputs) {
-        CHECK_EQ(in_var_node->IsVar(), true);
+        PADDLE_ENFORCE_EQ(in_var_node->IsVar(),
+                          true,
+                          phi::errors::InvalidArgument(
+                              "The node should be a variable, but it's not."));
 
         if (vars_shape_nhwc.count(in_var_node)) {
           InsertLayoutTransOp(graph,
diff --git a/test/cpp/eager/data_structure_tests/autograd_meta_test.cc b/test/cpp/eager/data_structure_tests/autograd_meta_test.cc
@@ -26,8 +26,18 @@ TEST(AutogradMeta, Constructor) {
   auto auto_grad = std::make_shared<egr::AutogradMeta>();
   et1.set_autograd_meta(auto_grad);
   auto* tmp_auto = static_cast<egr::AutogradMeta*>(et1.get_autograd_meta());
-  CHECK_EQ(tmp_auto->OutRankInfo().first, size_t(0));
-  CHECK_EQ(tmp_auto->OutRankInfo().second, size_t(0));
+  PADDLE_ENFORCE_EQ(
+      tmp_auto->OutRankInfo().first,
+      size_t(0),
+      phi::errors::InvalidArgument(
+          "The first element of OutRankInfo should be 0, but received %d.",
+          tmp_auto->OutRankInfo().first));
+  PADDLE_ENFORCE_EQ(
+      tmp_auto->OutRankInfo().second,
+      size_t(0),
+      phi::errors::InvalidArgument(
+          "The second element of OutRankInfo should be 0, but received %d.",
+          tmp_auto->OutRankInfo().second));
   CHECK(tmp_auto->IsInitialized() == false);
 }
 
@@ -52,8 +62,18 @@ TEST(AutogradMeta, MemberFunction) {
   VLOG(6) << "Test Mutable Grad";
   auto impl_ptr =
       std::dynamic_pointer_cast<phi::DenseTensor>(tmp_auto->Grad().impl());
-  CHECK_EQ(impl_ptr->data<float>()[0], 5.0f);
-  CHECK_EQ(impl_ptr->data<float>()[1], 10.0f);
+  PADDLE_ENFORCE_EQ(
+      impl_ptr->data<float>()[0],
+      5.0f,
+      phi::errors::InvalidArgument(
+          "The first element of grad tensor should be 5.0, but received %f.",
+          impl_ptr->data<float>()[0]));
+  PADDLE_ENFORCE_EQ(
+      impl_ptr->data<float>()[1],
+      10.0f,
+      phi::errors::InvalidArgument(
+          "The second element of grad tensor should be 10.0, but received %f.",
+          impl_ptr->data<float>()[1]));
   VLOG(6) << "Test IsInitialized";
   CHECK(tmp_auto->IsInitialized() == false);
   VLOG(6) << "Test GradNodeSetter Getter";
@@ -63,16 +83,45 @@ TEST(AutogradMeta, MemberFunction) {
   auto tmp_grad_node = tmp_auto->GetMutableGradNode();
   std::dynamic_pointer_cast<eager_test::GradTestNode>(tmp_grad_node)->val_ =
       5.0;
-  CHECK_EQ(dynamic_cast<eager_test::GradTestNode*>(tmp_auto->GradNode())->val_,
-           5.0);
+  PADDLE_ENFORCE_EQ(
+      dynamic_cast<eager_test::GradTestNode*>(tmp_auto->GradNode())->val_,
+      5.0,
+      phi::errors::InvalidArgument(
+          "The value of GradTestNode should be 5.0, but received %f.",
+          dynamic_cast<eager_test::GradTestNode*>(tmp_auto->GradNode())->val_));
   VLOG(6) << "Test rank Setter Getter";
-  CHECK_EQ(tmp_auto->OutRankInfo().first, size_t(0));
-  CHECK_EQ(tmp_auto->OutRankInfo().second, size_t(0));
+  PADDLE_ENFORCE_EQ(
+      tmp_auto->OutRankInfo().first,
+      size_t(0),
+      phi::errors::InvalidArgument(
+          "The first element of OutRankInfo should be 0, but received %d.",
+          tmp_auto->OutRankInfo().first));
+  PADDLE_ENFORCE_EQ(
+      tmp_auto->OutRankInfo().second,
+      size_t(0),
+      phi::errors::InvalidArgument(
+          "The second element of OutRankInfo should be 0, but received %d.",
+          tmp_auto->OutRankInfo().second));
   tmp_auto->SetSingleOutRankWithSlot(2, 3);
-  CHECK_EQ(tmp_auto->OutRankInfo().first, size_t(2));
-  CHECK_EQ(tmp_auto->OutRankInfo().second, size_t(3));
+  PADDLE_ENFORCE_EQ(
+      tmp_auto->OutRankInfo().first,
+      size_t(2),
+      phi::errors::InvalidArgument(
+          "The first element of OutRankInfo should be 2, but received %d.",
+          tmp_auto->OutRankInfo().first));
+  PADDLE_ENFORCE_EQ(
+      tmp_auto->OutRankInfo().second,
+      size_t(3),
+      phi::errors::InvalidArgument(
+          "The second element of OutRankInfo should be 3, but received %d.",
+          tmp_auto->OutRankInfo().second));
   VLOG(6) << "Test stop gradient Setter Getter";
-  CHECK_EQ(tmp_auto->NumericStopGradient(), -1);
+  PADDLE_ENFORCE_EQ(
+      tmp_auto->NumericStopGradient(),
+      -1,
+      phi::errors::InvalidArgument(
+          "The NumericStopGradient value should be -1, but received %d.",
+          tmp_auto->NumericStopGradient()));
   tmp_auto->SetStopGradient(true);
   CHECK(tmp_auto->StopGradient() == true);
   VLOG(6) << "Test Persistable Setter Getter";
diff --git a/test/cpp/eager/data_structure_tests/grad_tensor_holder_test.cc b/test/cpp/eager/data_structure_tests/grad_tensor_holder_test.cc
@@ -84,9 +84,23 @@ TEST(GradTensorHolder, Interfaces) {
 
   // Buffers()
   const auto& buffers = grad_tensor_holder.Buffers();
-  CHECK_EQ(static_cast<int>(buffers.size()), 2);
-  CHECK_EQ(static_cast<int>(buffers[0].size()), 1);
-  CHECK_EQ(static_cast<int>(buffers[1].size()), 1);
+  PADDLE_ENFORCE_EQ(static_cast<int>(buffers.size()),
+                    2,
+                    phi::errors::InvalidArgument(
+                        "The size of buffers should be 2, but received %d.",
+                        static_cast<int>(buffers.size())));
+  PADDLE_ENFORCE_EQ(
+      static_cast<int>(buffers[0].size()),
+      1,
+      phi::errors::InvalidArgument(
+          "The size of the first buffer should be 1, but received %d.",
+          static_cast<int>(buffers[0].size())));
+  PADDLE_ENFORCE_EQ(
+      static_cast<int>(buffers[1].size()),
+      1,
+      phi::errors::InvalidArgument(
+          "The size of the second buffer should be 1, but received %d.",
+          static_cast<int>(buffers[1].size())));
 
   // operator[]
   const auto& holder_et0 = grad_tensor_holder[0][0];
@@ -99,8 +113,18 @@ TEST(GradTensorHolder, Interfaces) {
       std::dynamic_pointer_cast<phi::DenseTensor>(holder_et1.impl())
           ->data<float>();
 
-  CHECK_EQ(holder_et0_ptr[0], 1.0f);
-  CHECK_EQ(holder_et1_ptr[0], 30.0f);
+  PADDLE_ENFORCE_EQ(
+      holder_et0_ptr[0],
+      1.0f,
+      phi::errors::InvalidArgument(
+          "The value of holder_et0_ptr[0] should be 1.0f, but received %f.",
+          holder_et0_ptr[0]));
+  PADDLE_ENFORCE_EQ(
+      holder_et1_ptr[0],
+      30.0f,
+      phi::errors::InvalidArgument(
+          "The value of holder_et1_ptr[0] should be 30.0f, but received %f.",
+          holder_et1_ptr[0]));
 }
 
 TEST(GradTensorHolder, SelectedRowsMergeAdd) {
@@ -147,9 +171,23 @@ TEST(GradTensorHolder, SelectedRowsMergeAdd) {
 
   // Buffers()
   const auto& buffers = grad_tensor_holder.Buffers();
-  CHECK_EQ(static_cast<int>(buffers.size()), 2);
-  CHECK_EQ(static_cast<int>(buffers[0].size()), 1);
-  CHECK_EQ(static_cast<int>(buffers[1].size()), 1);
+  PADDLE_ENFORCE_EQ(static_cast<int>(buffers.size()),
+                    2,
+                    phi::errors::InvalidArgument(
+                        "The size of buffers should be 2, but received %d.",
+                        static_cast<int>(buffers.size())));
+  PADDLE_ENFORCE_EQ(
+      static_cast<int>(buffers[0].size()),
+      1,
+      phi::errors::InvalidArgument(
+          "The size of the first buffer should be 1, but received %d.",
+          static_cast<int>(buffers[0].size())));
+  PADDLE_ENFORCE_EQ(
+      static_cast<int>(buffers[1].size()),
+      1,
+      phi::errors::InvalidArgument(
+          "The size of the second buffer should be 1, but received %d.",
+          static_cast<int>(buffers[1].size())));
 
   // operator[]
   const auto& holder_et0 = grad_tensor_holder[0][0];
diff --git a/test/cpp/fluid/framework/inlined_vector_test.cc b/test/cpp/fluid/framework/inlined_vector_test.cc
@@ -46,26 +46,79 @@ void InlinedVectorCheck(size_t n) {
     std_vec.emplace_back(value);
     vec.emplace_back(value);
 
-    CHECK_EQ(std_vec.size(), vec.size());
-    CHECK_EQ(std_vec.back(), vec.back());
-
-    CHECK_EQ(vec.back(), value);
+    PADDLE_ENFORCE_EQ(std_vec.size(),
+                      vec.size(),
+                      phi::errors::InvalidArgument(
+                          "The sizes of std_vec and vec should be equal, but "
+                          "received std_vec.size() = %d and vec.size() = %d.",
+                          std_vec.size(),
+                          vec.size()));
+    PADDLE_ENFORCE_EQ(
+        std_vec.back(),
+        vec.back(),
+        phi::errors::InvalidArgument(
+            "The last elements of std_vec and vec should be equal, but "
+            "received std_vec.back() = %d and vec.back() = %d.",
+            std_vec.back(),
+            vec.back()));
+
+    PADDLE_ENFORCE_EQ(vec.back(),
+                      value,
+                      phi::errors::InvalidArgument(
+                          "The last element of vec should be equal to value, "
+                          "but received vec.back() = %d and value = %d.",
+                          vec.back(),
+                          value));
   }
 
   bool is_equal = (std_vec == ToStdVector(vec));
 
-  CHECK_EQ(is_equal, true);
+  PADDLE_ENFORCE_EQ(
+      is_equal,
+      true,
+      phi::errors::InvalidArgument(
+          "The std_vec and vec should be equal, but they are not."));
 
   for (size_t i = 0; i < n; ++i) {
-    CHECK_EQ(std_vec.size(), vec.size());
-    CHECK_EQ(std_vec.back(), vec.back());
+    PADDLE_ENFORCE_EQ(std_vec.size(),
+                      vec.size(),
+                      phi::errors::InvalidArgument(
+                          "The sizes of std_vec and vec should be equal, but "
+                          "received std_vec.size() = %d and vec.size() = %d.",
+                          std_vec.size(),
+                          vec.size()));
+    PADDLE_ENFORCE_EQ(
+        std_vec.back(),
+        vec.back(),
+        phi::errors::InvalidArgument(
+            "The last elements of std_vec and vec should be equal, but "
+            "received std_vec.back() = %d and vec.back() = %d.",
+            std_vec.back(),
+            vec.back()));
     std_vec.pop_back();
     vec.pop_back();
-    CHECK_EQ(std_vec.size(), vec.size());
+    PADDLE_ENFORCE_EQ(std_vec.size(),
+                      vec.size(),
+                      phi::errors::InvalidArgument(
+                          "The sizes of std_vec and vec should be equal, but "
+                          "received std_vec.size() = %d and vec.size() = %d.",
+                          std_vec.size(),
+                          vec.size()));
   }
 
-  CHECK_EQ(std_vec.size(), static_cast<size_t>(0));
-  CHECK_EQ(vec.size(), static_cast<size_t>(0));
+  PADDLE_ENFORCE_EQ(std_vec.size(),
+                    vec.size(),
+                    phi::errors::InvalidArgument(
+                        "The sizes of std_vec and vec should be equal, but "
+                        "received std_vec.size() = %d and vec.size() = %d.",
+                        std_vec.size(),
+                        vec.size()));
+  PADDLE_ENFORCE_EQ(
+      vec.size(),
+      static_cast<size_t>(0),
+      phi::errors::InvalidArgument(
+          "The size of vec should be 0, but received vec.size() = %d.",
+          vec.size()));
 }
 
 TEST(inlined_vector, inlined_vector) {
diff --git a/test/cpp/utils/small_vector_test.cc b/test/cpp/utils/small_vector_test.cc
