[BUAA][Error Message]优化了5个文件的报错信息 (#67255)

Wizard-ZP · web-flow · commit 5a6bfa6dbcbc · 2024-08-26T15:50:26.000+08:00
* 优化了5个文件的报错信息

* debug

* 加入了一个文件 去除了一个文件

* codestyle

* debug

* code style

* debug

* 加入了一个文件，去除了一个文件
diff --git a/paddle/cinn/adt/naive_op_equation_context.h b/paddle/cinn/adt/naive_op_equation_context.h
@@ -27,6 +27,7 @@
 #include "paddle/cinn/adt/map_expr.h"
 #include "paddle/cinn/adt/op_arg_pos.h"
 #include "paddle/cinn/adt/op_equation_context.h"
+#include "paddle/common/enforce.h"
 
 namespace cinn::adt::config {
 
@@ -85,7 +86,13 @@ class NaiveOpEquationContext final : public OpEquationContext {
   }
 
   void Equal(const IteratorTuple& lhs, const IteratorTuple& rhs) override {
-    CHECK(lhs->size() == rhs->size());
+    PADDLE_ENFORCE_EQ(
+        lhs->size(),
+        rhs->size(),
+        phi::errors::InvalidArgument("The sizes of lhs and rhs must be equal. "
+                                     "lhs size: %d, rhs size: %d",
+                                     lhs->size(),
+                                     rhs->size()));
     for (std::size_t i = 0; i < lhs->size(); ++i) {
       this->Equal(lhs->at(i), rhs->at(i));
     }
@@ -250,7 +257,10 @@ class NaiveOpEquationContext final : public OpEquationContext {
       vec->push_back(DimTuple{});
       for (std::size_t j = 0; j < tensors_ranks.at(i); ++j) {
         const auto& opt_expr = GetSymbolicInDim_(i, j);
-        CHECK(opt_expr.has_value());
+        PADDLE_ENFORCE_EQ(opt_expr.has_value(),
+                          true,
+                          phi::errors::InvalidArgument(
+                              "The optional expression must have a value."));
         vec->at(i)->emplace_back(opt_expr.value());
       }
     }
@@ -262,15 +272,27 @@ class NaiveOpEquationContext final : public OpEquationContext {
       vec->push_back(DimTuple{});
       for (std::size_t j = 0; j < tensors_ranks.at(i); ++j) {
         const auto& opt_expr = GetSymbolicOutDim_(i, j);
-        CHECK(opt_expr.has_value());
+        PADDLE_ENFORCE_EQ(opt_expr.has_value(),
+                          true,
+                          phi::errors::InvalidArgument(
+                              "The optional expression must have a value at "
+                              "tensor index %d and dimension index %d.",
+                              i,
+                              j));
         vec->at(i)->emplace_back(opt_expr.value());
       }
     }
   }
 
   Index IndexDot(const IteratorTuple& iterator_tuple,
                  const DimTuple& dim_tuple) {
-    CHECK(iterator_tuple->size() == dim_tuple->size());
+    PADDLE_ENFORCE_EQ(iterator_tuple->size(),
+                      dim_tuple->size(),
+                      phi::errors::InvalidArgument(
+                          "The sizes of iterator_tuple and dim_tuple must be "
+                          "equal. iterator_tuple size: %d, dim_tuple size: %d",
+                          iterator_tuple->size(),
+                          dim_tuple->size()));
     Index index{UniqueId::New()};
     equations_->emplace_back(
         adt::IndexDot<List<DimExpr>, tOut<Index>, tIn<List<Iterator>>>{
@@ -318,8 +340,11 @@ class NaiveOpEquationContext final : public OpEquationContext {
 
   const utils::Attribute& GetAttribute(const std::string& name) const {
     const auto& iter = attr_map_type_.find(name);
-    CHECK(iter != attr_map_type_.end())
-        << "Can't find Attribute with this name";
+    PADDLE_ENFORCE_EQ(
+        iter != attr_map_type_.end(),
+        true,
+        phi::errors::InvalidArgument("Can't find Attribute with this name: %s",
+                                     name.c_str()));
     return iter->second;
   }
 
diff --git a/paddle/cinn/auto_schedule/search_space/auto_gen_rule/auto_inline.cc b/paddle/cinn/auto_schedule/search_space/auto_gen_rule/auto_inline.cc
@@ -31,6 +31,7 @@
 #include "paddle/cinn/ir/schedule/ir_schedule_util.h"
 #include "paddle/cinn/ir/utils/ir_copy.h"
 #include "paddle/cinn/ir/utils/ir_nodes_collector.h"
+#include "paddle/common/enforce.h"
 
 namespace cinn {
 namespace auto_schedule {
@@ -196,15 +197,26 @@ RuleApplyType AutoInline::Init(ir::IRSchedule* ir_schedule) {
 }
 
 void AutoInline::Apply(int index) {
-  CHECK(ir_schedule_ != nullptr) << "Run AutoInline::Apply without Init";
-  CHECK(num_applicable_ > 0 &&
-        apply_indices_and_type_.size() == num_applicable_)
-      << "AutoInline::Apply pre-condition doesn't meet";
-  CHECK(index >= 0 && num_applicable_ > index)
-      << "Invalid index for AutoInline::Apply, the index needs 0 <= index && "
-         "index < NumberApplicable(), "
-      << "Currently index = " << index
-      << ",  NumberApplicable() = " << num_applicable_;
+  PADDLE_ENFORCE_EQ(
+      ir_schedule_ != nullptr,
+      true,
+      phi::errors::InvalidArgument("Run AutoInline::Apply without Init"));
+
+  PADDLE_ENFORCE_EQ(
+      num_applicable_ > 0 && apply_indices_and_type_.size() == num_applicable_,
+      true,
+      phi::errors::InvalidArgument(
+          "AutoInline::Apply pre-condition doesn't meet"));
+
+  PADDLE_ENFORCE_EQ(
+      index >= 0 && num_applicable_ > index,
+      true,
+      phi::errors::InvalidArgument(
+          "Invalid index for AutoInline::Apply, the index needs 0 <= index && "
+          "index < NumberApplicable(), "
+          "Currently index = %d, NumberApplicable() = %d",
+          index,
+          num_applicable_));
 
   int apply_index = apply_indices_and_type_[index].first;
   Apply(ir_schedule_, all_block_realizes_[apply_index]);
@@ -217,7 +229,10 @@ RuleApplyType AutoInline::AnalyseApplyType(
     SearchState state, const std::string& block_name) const {
   Expr block_expr = state->ir_schedule.GetBlock(block_name);
   auto* block_realize = block_expr.As<ir::ScheduleBlockRealize>();
-  CHECK(block_realize) << "stmt is not a ScheduleBlockRealize:" << block_expr;
+  PADDLE_ENFORCE_NOT_NULL(
+      block_realize,
+      phi::errors::InvalidArgument("stmt is not a ScheduleBlockRealize: %s",
+                                   block_expr));
 
   AnalyzeScheduleBlockReadWriteBuffer(
       block_realize->schedule_block.As<ir::ScheduleBlock>());
@@ -239,7 +254,10 @@ std::vector<SearchState> AutoInline::ApplyOnBlock(
 
 void AutoInline::Apply(ir::IRSchedule* ir_schedule, ir::Expr& block_expr) {
   auto* block_realize = block_expr.As<ir::ScheduleBlockRealize>();
-  CHECK(block_realize) << "stmt is not a ScheduleBlockRealize:" << block_expr;
+  PADDLE_ENFORCE_NOT_NULL(
+      block_realize,
+      phi::errors::InvalidArgument("stmt is not a ScheduleBlockRealize: %s",
+                                   block_expr));
 
   AnalyzeScheduleBlockReadWriteBuffer(
       block_realize->schedule_block.As<ir::ScheduleBlock>());
diff --git a/paddle/fluid/framework/downpour_lite_worker.cc b/paddle/fluid/framework/downpour_lite_worker.cc
@@ -13,6 +13,7 @@ See the License for the specific language governing permissions and
 limitations under the License. */
 
 #if defined(PADDLE_WITH_PSCORE)
+#include "paddle/common/enforce.h"
 #include "paddle/fluid/framework/device_worker.h"
 #include "paddle/fluid/framework/fleet/metrics.h"
 #include "paddle/fluid/operators/isfinite_op.h"
@@ -203,22 +204,33 @@ void DownpourLiteWorker::CopyDenseVars() {
     VLOG(3) << "copy dense var from " << src_var_name << " to "
             << dest_var_name;
     Variable* src_var = thread_scope_->FindVar(src_var_name);
-    CHECK(src_var != nullptr) << src_var_name << " not found";  // NOLINT
+    PADDLE_ENFORCE_EQ(src_var != nullptr,
+                      true,
+                      phi::errors::NotFound("%s not found", src_var_name));
     phi::DenseTensor* src_tensor = src_var->GetMutable<phi::DenseTensor>();
-    CHECK(src_tensor != nullptr)
-        << src_var_name << " tensor is null";  // NOLINT
+    PADDLE_ENFORCE_EQ(
+        src_tensor != nullptr,
+        true,
+        phi::errors::InvalidArgument("%s tensor is null", src_var_name));
     float* src_data = src_tensor->data<float>();
 
     Variable* dest_var = thread_scope_->FindVar(dest_var_name);
-    CHECK(dest_var != nullptr) << dest_var_name << " not found";  // NOLINT
+    PADDLE_ENFORCE_EQ(dest_var != nullptr,
+                      true,
+                      phi::errors::NotFound("%s not found", dest_var_name));
     phi::DenseTensor* dest_tensor = dest_var->GetMutable<phi::DenseTensor>();
-    CHECK(dest_tensor != nullptr)
-        << dest_var_name << " tensor is null";  // NOLINT
+    PADDLE_ENFORCE_EQ(
+        dest_tensor != nullptr,
+        true,
+        phi::errors::InvalidArgument("%s tensor is null", dest_var_name));
     float* dest_data = dest_tensor->data<float>();
 
-    CHECK(src_tensor->numel() == dest_tensor->numel())
-        << "tensor numel not equal," << src_tensor->numel() << " vs "
-        << dest_tensor->numel();
+    PADDLE_ENFORCE_EQ(
+        src_tensor->numel(),
+        dest_tensor->numel(),
+        phi::errors::InvalidArgument("tensor numel not equal, %d vs %d",
+                                     src_tensor->numel(),
+                                     dest_tensor->numel()));
     for (int i = 0; i < src_tensor->numel(); i++) {
       dest_data[i] = src_data[i];
     }
diff --git a/paddle/fluid/framework/io/shell.cc b/paddle/fluid/framework/io/shell.cc
@@ -16,6 +16,7 @@
 #define GLOG_NO_ABBREVIATED_SEVERITIES  // msvc conflict logging with windows.h
 #include "paddle/fluid/framework/io/shell.h"
 
+#include "paddle/common/enforce.h"
 #include "paddle/fluid/platform/enforce.h"
 #include "paddle/fluid/platform/timer.h"
 
diff --git a/paddle/fluid/operators/collective/global_scatter_op.cc b/paddle/fluid/operators/collective/global_scatter_op.cc
@@ -14,6 +14,8 @@ limitations under the License. */
 
 #include "paddle/fluid/operators/collective/global_scatter_op.h"
 
+#include "paddle/common/enforce.h"
+
 namespace paddle::operators {
 
 class GlobalScatterOp : public framework::OperatorWithKernel {
