【Error Message No. 35 BUAA】change some warning messages (#66628)

BHmingyang · web-flow · commit b40f10e9439e · 2024-07-29T10:57:08.000+08:00
* change some warning messages

* fix some typos

* add .h file
diff --git a/paddle/cinn/hlir/op/contrib/bitcast_convert.cc b/paddle/cinn/hlir/op/contrib/bitcast_convert.cc
@@ -59,22 +59,24 @@ std::shared_ptr<framework::OpStrategy> StrategyForBitcastConvert(
     const Target &target) {
   std::string op_name("bitcast_convert");
 
-  framework::CINNCompute bitcast_convert_compute(
-      [=](lang::Args args, lang::RetValue *ret) {
-        CHECK(!args.empty()) << "The input argument of " << op_name
-                             << " compute is empty! Please check.";
-        CINNValuePack pack_args = args[0];
-        CHECK_GE(pack_args.size(), 1U)
-            << "1 input tensor for " << op_name << " compute";
-        std::string tensor_name = UniqName(op_name + "_Out");
-        Expr A_expr = pack_args[0];
-        CHECK(A_expr.as_tensor());
-        ir::Tensor A = A_expr.as_tensor_ref();
-        auto out = BitcastConvert(A, out_type[0], tensor_name);
-        std::vector<CINNValue> res;
-        res.push_back(CINNValue(out));
-        *ret = CINNValuePack{res};
-      });
+  framework::CINNCompute bitcast_convert_compute([=](lang::Args args,
+                                                     lang::RetValue *ret) {
+    CHECK(!args.empty()) << "The input argument of " << op_name
+                         << " compute is empty! Please check.";
+    CINNValuePack pack_args = args[0];
+    PADDLE_ENFORCE_GE(pack_args.size(),
+                      1U,
+                      phi::errors::InvalidArgument(
+                          "The size of pack_args should be greater than 0 . "));
+    std::string tensor_name = UniqName(op_name + "_Out");
+    Expr A_expr = pack_args[0];
+    CHECK(A_expr.as_tensor());
+    ir::Tensor A = A_expr.as_tensor_ref();
+    auto out = BitcastConvert(A, out_type[0], tensor_name);
+    std::vector<CINNValue> res;
+    res.push_back(CINNValue(out));
+    *ret = CINNValuePack{res};
+  });
 
   auto strategy = std::make_shared<framework::OpStrategy>();
   strategy->AddImpl(bitcast_convert_compute,
diff --git a/paddle/cinn/operator_fusion/backend/pattern_fuser.cc b/paddle/cinn/operator_fusion/backend/pattern_fuser.cc
@@ -354,7 +354,11 @@ std::vector<ir::Expr> TopoSort(const std::vector<ir::Expr>& op_exprs) {
       }
     }
   }
-  CHECK_EQ(result.size(), op_exprs.size());
+  PADDLE_ENFORCE_EQ(
+      result.size(),
+      op_exprs.size(),
+      phi::errors::InvalidArgument(
+          "Required result.size() should be equal to op_exprs.size(). "));
   std::vector<ir::Expr> sorted_result;
   for (const auto& op : result) {
     sorted_result.push_back(*op);
diff --git a/paddle/cinn/operator_fusion/group_cluster.h b/paddle/cinn/operator_fusion/group_cluster.h
@@ -32,7 +32,10 @@ inline std::vector<fusion::PatternNodePtr<T>> ClusterOps(
   std::function<pir::Operation*(fusion::PatternContent<T>)> func =
       [](const fusion::PatternContent<T>& content) { return content.op; };
   const auto& origin_ops = fusion::MapVector(contents, func);
-  CHECK_GT(origin_ops.size(), 0);
+  PADDLE_ENFORCE_GT(origin_ops.size(),
+                    0,
+                    phi::errors::InvalidArgument(
+                        "The size of origin_ops should be greater than 0. "));
   VLOG(4) << "Start Cluster Ops!";
   VLOG(4) << "Input Group with size " << origin_ops.size() << " :\n"
           << fusion::OpsDebugStr(origin_ops);
diff --git a/paddle/cinn/optim/eliminate_common_factor_of_local_index.cc b/paddle/cinn/optim/eliminate_common_factor_of_local_index.cc
@@ -230,9 +230,12 @@ template <typename Op>
 std::vector<ir::Expr> CalculateIndexCommonFactor(
     const std::string& local_var,
     const std::vector<std::vector<ir::Expr>>& indexes) {
-  CHECK_GE(indexes.size(), 2)
-      << "We should guarantee indexes.size() >= 2, because local variable "
-      << local_var << " should at least load and store once.";
+  PADDLE_ENFORCE_GE(
+      indexes.size(),
+      2,
+      phi::errors::InvalidArgument(
+          "We should guarantee indexes.size() >= 2, because local variable "
+          "should at least load and store once. "));
   for (std::size_t i = 1; i < indexes.size(); ++i) {
     // NOTE(Hongyu Jia): Ideally, we can guarantee the size of indexes are equal
     // under flags FLAGS_cinn_new_group_scheduler=1 and
diff --git a/paddle/fluid/framework/operator.cc b/paddle/fluid/framework/operator.cc
@@ -1288,7 +1288,11 @@ struct OperatorWithKernel::CacheImpl {
     bool ret{false};
     if (last_ddims_.empty() || tensors_.empty()) ret = true;
     if (!ret) {
-      CHECK_EQ(last_ddims_.size(), tensors_.size());
+      PADDLE_ENFORCE_EQ(
+          last_ddims_.size(),
+          tensors_.size(),
+          phi::errors::InvalidArgument(
+              "The size of last_ddims_ should be equal to tensors_. "));
       for (size_t i = 0; i < last_ddims_.size(); ++i) {
         if (tensors_[i]->dims() != last_ddims_[i]) {
           ret = true;
diff --git a/paddle/fluid/inference/analysis/passes/memory_optimize_pass.cc b/paddle/fluid/inference/analysis/passes/memory_optimize_pass.cc
@@ -92,7 +92,10 @@ void MemoryOptimizePass::CollectLifeCycle(
 
           auto in_shape = node->Var()->GetShape();
           for (auto i : in_shape) {
-            CHECK_GE(i, 0);
+            PADDLE_ENFORCE_GE(i,
+                              0,
+                              phi::errors::InvalidArgument(
+                                  "The shape of node shouldn't be negative. "));
           }
           auto var_bytes = std::accumulate(in_shape.begin(),
                                            in_shape.end(),
diff --git a/paddle/fluid/inference/api/analysis_predictor.cc b/paddle/fluid/inference/api/analysis_predictor.cc
@@ -1636,8 +1636,11 @@ void AnalysisPredictor::MkldnnPostReset() {
           static_cast<phi::OneDNNContext *>(
               (&phi::DeviceContextPool::Instance())->Get(phi::CPUPlace()))
               ->GetShapeBlobSize();
-      CHECK_LE(shape_blob_size,
-               static_cast<size_t>(config_.mkldnn_cache_capacity_));
+      PADDLE_ENFORCE_LE(shape_blob_size,
+                        static_cast<size_t>(config_.mkldnn_cache_capacity_),
+                        phi::errors::InvalidArgument(
+                            "Required shape_blob_size should be less than or "
+                            "equal to config_.mkldnn_cache_capacity_. "));
     }
     // We cannot reset to the default cache settings
     // as there maybe CopyToCPU method used and oneDNN
diff --git a/test/cpp/fluid/math/beam_search_test.cc b/test/cpp/fluid/math/beam_search_test.cc
@@ -44,8 +44,16 @@ void PrepareCPUTensors(phi::DenseTensor* ids,
   std::vector<float> scores_vec_data(
       {0.6f, 0.3f, 0.5f, 0.2f, 0.3f, 0.1f, 0.9f, 0.5f, 0.1f, 0.7f, 0.5f, 0.1f});
 
-  CHECK_EQ(static_cast<size_t>(ids->numel()), ids_vec_data.size());
-  CHECK_EQ(static_cast<size_t>(ids->numel()), scores_vec_data.size());
+  PADDLE_ENFORCE_EQ(
+      static_cast<size_t>(ids->numel()),
+      ids_vec_data.size(),
+      phi::errors::InvalidArgument(
+          "Required ids->numel() should be equal to ids_vec_data.size(). "));
+  PADDLE_ENFORCE_EQ(
+      static_cast<size_t>(ids->numel()),
+      scores_vec_data.size(),
+      phi::errors::InvalidArgument(
+          "Required ids->numel() should be equal to scores_vec_data.size(). "));
 
   for (int i = 0; i < ids->numel(); i++) {
     ids_data[i] = ids_vec_data[i];
diff --git a/test/cpp/fluid/mkldnn/test_onednn_cpu_quantize_pass.cc b/test/cpp/fluid/mkldnn/test_onednn_cpu_quantize_pass.cc
@@ -100,12 +100,17 @@ TEST(cpuQuantizePass, ConvReLU6) {
   int fused_conv2d_num = 0;
   for (auto* node : graph->Nodes()) {
     if (node->IsOp() && node->Op() && node->Op()->Type() == "fused_conv2d") {
-      CHECK_EQ(node->Op()->GetAttrIfExists<float>("fuse_beta"), 6)
-          << "Attr fuse_beta must equal to 6.";
+      PADDLE_ENFORCE_EQ(
+          node->Op()->GetAttrIfExists<float>("fuse_beta"),
+          6,
+          phi::errors::InvalidArgument("Attr fuse_beta must equal to 6. "));
       fused_conv2d_num++;
     }
   }
-  CHECK_GT(fused_conv2d_num, 0) << "Graph must contain fused_conv2d";
+  PADDLE_ENFORCE_GT(
+      fused_conv2d_num,
+      0,
+      phi::errors::InvalidArgument("Graph must contain fused_conv2d. "));
 }
 
 }  // namespace pass
diff --git a/test/cpp/inference/api/analyzer_lexical_analysis_gru_tester.cc b/test/cpp/inference/api/analyzer_lexical_analysis_gru_tester.cc
@@ -281,8 +281,12 @@ TEST(Analyzer_lexical_test, Analyzer_lexical_analysis) {
     std::vector<double> acc_analysis(3);
     acc_analysis = Lexical_Test(input_slots_all, &outputs, &analysis_cfg, true);
     for (size_t i = 0; i < acc_analysis.size(); i++) {
-      CHECK_LE(std::abs(acc_ref[i] - acc_analysis[i]),
-               FLAGS_quantized_accuracy);
+      PADDLE_ENFORCE_LE(
+          std::abs(acc_ref[i] - acc_analysis[i]),
+          FLAGS_quantized_accuracy,
+          phi::errors::InvalidArgument(
+              "Required abs(acc_ref[i] - acc_analysis[i]) should be less than "
+              "or euqal to FLAGS_quantized_accuracy. "));
     }
   }
 }
diff --git a/test/cpp/inference/api/analyzer_transformer_tester_helper.h b/test/cpp/inference/api/analyzer_transformer_tester_helper.h
@@ -74,7 +74,10 @@ struct DataRecord {
       num_lines++;
       std::vector<std::string> data;
       split(line, ',', &data);
-      CHECK_EQ(data.size(), static_cast<size_t>(8));
+      PADDLE_ENFORCE_EQ(data.size(),
+                        static_cast<size_t>(8),
+                        phi::errors::InvalidArgument(
+                            "The size of data should be euqal to 8. "));
       // load src_word
       std::vector<int64_t> src_word_data;
       split_to_int64(data[0], ' ', &src_word_data);
diff --git a/test/cpp/inference/api/api_tester.cc b/test/cpp/inference/api/api_tester.cc
@@ -20,6 +20,7 @@ limitations under the License. */
 
 #include "paddle/fluid/inference/api/paddle_analysis_config.h"
 #include "paddle/fluid/inference/api/paddle_api.h"
+#include "paddle/fluid/platform/enforce.h"
 
 namespace paddle {
 
@@ -97,7 +98,10 @@ TEST(paddle_inference_api, AnalysisConfigCopyCtor) {
 
   auto passes = cfg2.pass_builder()->AllPasses();
   for (auto const &ps : passes) {
-    CHECK_NE(ps, delete_pass);
+    PADDLE_ENFORCE_NE(ps,
+                      delete_pass,
+                      phi::errors::InvalidArgument(
+                          "Required ps shouldn't be euqal to delete_pass. "));
   }
 }
 
diff --git a/test/cpp/inference/api/paddle_infer_api_errors_tester.cc b/test/cpp/inference/api/paddle_infer_api_errors_tester.cc
@@ -43,7 +43,11 @@ TEST(Status, pd_exception) {
   CHECK(!status.ok());
   CHECK(status == status);
   CHECK(!(status != status));
-  CHECK_EQ(status.code(), phi::ErrorCode::INVALID_ARGUMENT + 1);
+  PADDLE_ENFORCE_EQ(
+      status.code(),
+      phi::ErrorCode::INVALID_ARGUMENT + 1,
+      phi::errors::InvalidArgument(
+          "Required status.code() should be equal to INVALID_ARGUMENT + 1. "));
   LOG(INFO) << status.error_message();
 }
 

Original file line number	Diff line number	Diff line change
`@@ -354,7 +354,11 @@ std::vector<ir::Expr> TopoSort(const std::vector<ir::Expr>& op_exprs) {`
`354`	`354`	`}`
`355`	`355`	`}`
`356`	`356`	`}`
`357`		`- CHECK_EQ(result.size(), op_exprs.size());`
	`357`	`+ PADDLE_ENFORCE_EQ(`
	`358`	`+ result.size(),`
	`359`	`+ op_exprs.size(),`
	`360`	`+ phi::errors::InvalidArgument(`
	`361`	`+ "Required result.size() should be equal to op_exprs.size(). "));`
`358`	`362`	`std::vector<ir::Expr> sorted_result;`
`359`	`363`	`for (const auto& op : result) {`
`360`	`364`	`sorted_result.push_back(*op);`
Original file line number	Diff line number	Diff line change
`@@ -281,8 +281,12 @@ TEST(Analyzer_lexical_test, Analyzer_lexical_analysis) {`
`281`	`281`	`std::vector<double> acc_analysis(3);`
`282`	`282`	`acc_analysis = Lexical_Test(input_slots_all, &outputs, &analysis_cfg, true);`
`283`	`283`	`for (size_t i = 0; i < acc_analysis.size(); i++) {`
`284`		`- CHECK_LE(std::abs(acc_ref[i] - acc_analysis[i]),`
`285`		`- FLAGS_quantized_accuracy);`
	`284`	`+ PADDLE_ENFORCE_LE(`
	`285`	`+ std::abs(acc_ref[i] - acc_analysis[i]),`
	`286`	`+ FLAGS_quantized_accuracy,`
	`287`	`+ phi::errors::InvalidArgument(`
	`288`	`+ "Required abs(acc_ref[i] - acc_analysis[i]) should be less than "`
	`289`	`+ "or euqal to FLAGS_quantized_accuracy. "));`
`286`	`290`	`}`
`287`	`291`	`}`
`288`	`292`	`}`