【BUAA】【Error Message】fix error message (#66881)

uanu2002 · web-flow · commit e6ebdc44f3d8 · 2024-08-07T10:38:22.000+08:00
* fix error message

* add include

* fix phi

* fix

* fix

* restore democi
diff --git a/paddle/cinn/adt/print_utils/print_schedule_descriptor.cc b/paddle/cinn/adt/print_utils/print_schedule_descriptor.cc
@@ -35,7 +35,10 @@ std::string ToTxtString(const LoopDescriptor& loop_descriptor) {
               *string += vectorize.iter_var_name();
             },
             [&](const Unroll& unroll) { *string += unroll.iter_var_name(); }};
-  CHECK(loop_size.Has<std::int64_t>());
+  PADDLE_ENFORCE_EQ(loop_size.Has<std::int64_t>(),
+                    true,
+                    ::common::errors::InvalidArgument(
+                        "The loop_size should have type int64_t."));
   *string += "=0.." + std::to_string(loop_size.Get<std::int64_t>());
   return ret;
 }
diff --git a/paddle/cinn/adt/print_utils/print_schedule_descriptor.h b/paddle/cinn/adt/print_utils/print_schedule_descriptor.h
@@ -15,7 +15,7 @@
 #pragma once
 
 #include <string>
-
+#include "paddle/common/enforce.h"
 namespace cinn::adt {
 
 class LoopDescriptor;
diff --git a/paddle/cinn/utils/functional.cc b/paddle/cinn/utils/functional.cc
@@ -23,18 +23,27 @@ std::vector<int> GetPositiveAxes(const std::vector<int>& axes, int rank) {
   std::vector<int> new_axes(axes.size());
   for (int i = 0; i < axes.size(); ++i) {
     int axis = axes[i] + (axes[i] < 0 ? rank : 0);
-    CHECK(axis >= 0 && (rank == 0 || axis < rank))
-        << "The axis should in [" << -rank << ", " << rank << "), but axes["
-        << i << "]=" << axes[i] << " not.";
+    PADDLE_ENFORCE_EQ(
+        axis >= 0 && (rank == 0 || axis < rank),
+        true,
+        ::common::errors::InvalidArgument(
+            "The axis should be in [%d, %d), but axes[%d]=%d is not.",
+            -rank,
+            rank,
+            i,
+            axes[i]));
     new_axes[i] = axis;
   }
   return new_axes;
 }
 
 int GetPositiveAxes(int axis, int rank) {
   int dim = axis + (axis < 0 ? rank : 0);
-  CHECK(dim >= 0 && dim < rank)
-      << "The axis should in [0, " << rank << "), but axis=" << axis << " not.";
+  PADDLE_ENFORCE_EQ(
+      dim >= 0 && dim < rank,
+      true,
+      ::common::errors::InvalidArgument(
+          "The axis should be in [0, %d), but axis=%d is not.", rank, axis));
   return dim;
 }
 
diff --git a/paddle/cinn/utils/functional.h b/paddle/cinn/utils/functional.h
@@ -22,7 +22,7 @@
 #include <type_traits>
 #include <utility>
 #include <vector>
-
+#include "paddle/common/enforce.h"
 namespace cinn {
 namespace utils {
 
diff --git a/paddle/cinn/utils/random_engine.cc b/paddle/cinn/utils/random_engine.cc
@@ -21,8 +21,11 @@ namespace utils {
 int SampleUniformInt(int min,
                      int max,
                      LinearRandomEngine::StateType* rand_seed) {
-  CHECK(min < max) << "Input value error: min(" << min
-                   << ") must be less than max(" << max << ")";
+  PADDLE_ENFORCE_EQ(
+      min < max,
+      true,
+      ::common::errors::InvalidArgument(
+          "Input value error: min(%d) must be less than max(%d)", min, max));
   if (min + 1 == max) {
     return min;
   }
@@ -36,8 +39,11 @@ int SampleUniformInt(int min,
 double SampleUniformDouble(double min,
                            double max,
                            LinearRandomEngine::StateType* rand_seed) {
-  CHECK(min < max) << "Input value error: min(" << min
-                   << ") must be less than max(" << max << ")";
+  PADDLE_ENFORCE_EQ(
+      min < max,
+      true,
+      ::common::errors::InvalidArgument(
+          "Input value error: min(%f) must be less than max(%f)", min, max));
   LinearRandomEngine engine(rand_seed);
   std::uniform_real_distribution<> dist(min, max);
   return dist(engine);
diff --git a/paddle/fluid/distributed/ps/table/common_graph_table.cc b/paddle/fluid/distributed/ps/table/common_graph_table.cc
@@ -3524,10 +3524,17 @@ int32_t GraphTable::Initialize(const GraphParameter &graph) {
   nodeid_to_edgeids_.resize(node_type_str_to_node_types_idx.size());
   for (auto &obj : edge_to_id) {
     size_t pos = obj.first.find("2");
-    CHECK(pos != std::string::npos);
+    PADDLE_ENFORCE_EQ((pos != std::string::npos),
+                      true,
+                      common::errors::InvalidArgument(
+                          "The string does not contain the character '2'."));
     std::string nodetype = obj.first.substr(0, pos);
     auto it = node_type_str_to_node_types_idx.find(nodetype);
-    CHECK(it != node_type_str_to_node_types_idx.end());
+    PADDLE_ENFORCE_EQ(
+        (it != node_type_str_to_node_types_idx.end()),
+        true,
+        common::errors::InvalidArgument(
+            "Node type not found in node_type_str_to_node_types_idx."));
     nodeid_to_edgeids_[it->second].push_back(obj.second);
     VLOG(0) << "add edge [" << obj.first << "=" << obj.second << "] to ["
             << nodetype << "=" << it->second << "]";
diff --git a/paddle/fluid/distributed/ps/table/common_graph_table.h b/paddle/fluid/distributed/ps/table/common_graph_table.h
@@ -38,6 +38,7 @@
 #include <utility>
 #include <vector>
 
+#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/graph/class_macro.h"
diff --git a/paddle/fluid/distributed/ps/table/memory_sparse_geo_table.cc b/paddle/fluid/distributed/ps/table/memory_sparse_geo_table.cc
@@ -17,7 +17,10 @@
 namespace paddle::distributed {
 
 int32_t MemorySparseGeoTable::Pull(TableContext& context) {
-  CHECK(context.value_type == Sparse);
+  PADDLE_ENFORCE_EQ(context.value_type == Sparse,
+                    true,
+                    common::errors::InvalidArgument(
+                        "The value_type of context must be Sparse."));
   if (context.pull_context.geo_pull_keys != nullptr) {
     return PullGeoParam(context.trainer_id,
                         context.pull_context.geo_pull_values,
@@ -29,7 +32,10 @@ int32_t MemorySparseGeoTable::Pull(TableContext& context) {
 }
 
 int32_t MemorySparseGeoTable::Push(TableContext& context) {
-  CHECK(context.value_type == Sparse);
+  PADDLE_ENFORCE_EQ(context.value_type == Sparse,
+                    true,
+                    common::errors::InvalidArgument(
+                        "The value_type of context must be Sparse."));
   if (!context.push_context.is_param) {
     return PushSparse(
         context.push_context.keys, context.push_context.values, context.num);
diff --git a/paddle/fluid/distributed/ps/table/memory_sparse_geo_table.h b/paddle/fluid/distributed/ps/table/memory_sparse_geo_table.h
@@ -24,6 +24,7 @@
 #include <utility>
 #include <vector>
 
+#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/feature_value.h"
diff --git a/paddle/fluid/framework/fleet/heter_ps/gpu_graph_utils.h b/paddle/fluid/framework/fleet/heter_ps/gpu_graph_utils.h
@@ -21,6 +21,7 @@
 #include <algorithm>
 #include <random>
 #include <vector>
+#include "paddle/common/enforce.h"
 #include "paddle/common/flags.h"
 #include "paddle/fluid/platform/enforce.h"
 
@@ -66,11 +67,16 @@ inline std::vector<int> shuffle_int_vector(int n) {
   return ret;
 }
 
-#define CUDA_CHECK(cmd)                                                       \
-  do {                                                                        \
-    cudaError_t e = cmd;                                                      \
-    CHECK(e == cudaSuccess) << "Cuda failure " << __FILE__ << ":" << __LINE__ \
-                            << " " << cudaGetErrorString(e) << std::endl;     \
+#define CUDA_CHECK(cmd)                                            \
+  do {                                                             \
+    cudaError_t e = cmd;                                           \
+    PADDLE_ENFORCE_EQ(                                             \
+        e == cudaSuccess,                                          \
+        true,                                                      \
+        common::errors::InvalidArgument("CUDA error at %s:%s: %s", \
+                                        __FILE__,                  \
+                                        __LINE__,                  \
+                                        cudaGetErrorString(e)));   \
   } while (0)
 
 class CudaDeviceRestorer {
diff --git a/paddle/fluid/inference/analysis/passes/memory_optimize_pass.cc b/paddle/fluid/inference/analysis/passes/memory_optimize_pass.cc
@@ -141,15 +141,23 @@ void MemoryOptimizePass::CollectVarMemorySize(
                                         "fetch",
                                         "share_data"};
     for (auto* tmp : node->inputs) {
-      CHECK(tmp->IsOp());
+      PADDLE_ENFORCE_EQ(tmp->IsOp(),
+                        true,
+                        common::errors::InvalidArgument(
+                            "Expected a node to be an operation, but the given "
+                            "node is not an operation."));
       std::string op_type = tmp->Op()->Type();
       if (std::find(invalid_op.begin(), invalid_op.end(), op_type) !=
           invalid_op.end()) {
         return false;
       }
     }
     for (auto* tmp : node->outputs) {
-      CHECK(tmp->IsOp());
+      PADDLE_ENFORCE_EQ(tmp->IsOp(),
+                        true,
+                        common::errors::InvalidArgument(
+                            "Expected a node to be an operation, but the given "
+                            "node is not an operation."));
       std::string op_type = tmp->Op()->Type();
       if (std::find(invalid_op.begin(), invalid_op.end(), op_type) !=
           invalid_op.end()) {
diff --git a/paddle/fluid/inference/analysis/passes/memory_optimize_pass.h b/paddle/fluid/inference/analysis/passes/memory_optimize_pass.h
@@ -17,6 +17,7 @@
 #include <unordered_map>
 #include <utility>
 
+#include "paddle/common/enforce.h"
 #include "paddle/fluid/inference/analysis/analysis_pass.h"
 
 namespace paddle {
