【Error Message No. 27 No. 28 No.11 No.15 BUAA】rewrite error message (#66802)

crazyxiaoxi · web-flow · commit 1d6263c600d3 · 2024-08-02T10:14:39.000+08:00
* first try

* small errors

* longer
diff --git a/paddle/cinn/adt/get_sub_reshape_dim_ranges.cc b/paddle/cinn/adt/get_sub_reshape_dim_ranges.cc
@@ -37,8 +37,13 @@ GetSubReshapeDimRanges(const List<DimExpr>& lhs_dims,
   if (GetNumel(lhs_dims) != GetNumel(rhs_dims)) {
     return std::nullopt;
   }
-  CHECK(!lhs_dims->empty());
-  CHECK(!rhs_dims->empty());
+  PADDLE_ENFORCE_EQ(
+      !lhs_dims->empty(),
+      true,
+      phi::errors::InvalidArgument("Sorry,but lhs_dims is empty"));
+  PADDLE_ENFORCE_EQ(!rhs_dims->empty(),
+                    true,
+                    phi::errors::InvalidArgument("Sory,but rhs_dims is empty"));
   std::vector<std::pair<int, int>> lhs_ranges{};
   std::vector<std::pair<int, int>> rhs_ranges{};
   int lhs_start = 0;
@@ -51,7 +56,10 @@ GetSubReshapeDimRanges(const List<DimExpr>& lhs_dims,
     end = (end > dims->size() ? dims->size() : end);
     std::int64_t ret = 1;
     for (std::size_t i = 0; i < end; ++i) {
-      CHECK(dims->at(i).Has<std::int64_t>());
+      PADDLE_ENFORCE_EQ(
+          dims->at(i).Has<std::int64_t>(),
+          true,
+          phi::errors::InvalidArgument("dims->at(i) is not int64_t"));
       ret *= dims->at(i).Get<std::int64_t>();
     }
     return ret;
@@ -85,7 +93,11 @@ GetSubReshapeDimRanges(const List<DimExpr>& lhs_dims,
       PADDLE_THROW(::common::errors::Fatal("Dead code"));
     }
   }
-  CHECK(lhs_end == lhs_dims->size() && rhs_end == rhs_dims->size());
+  PADDLE_ENFORCE_EQ(lhs_end == lhs_dims->size() && rhs_end == rhs_dims->size(),
+                    true,
+                    phi::errors::InvalidArgument(
+                        "lhs_end is not equal to lhs_dims->size() and rhs_end "
+                        "is not equal to rhs_dims->size()"));
   if (lhs_start < lhs_end && rhs_start < rhs_end) {
     lhs_ranges.emplace_back(std::make_pair(lhs_start, lhs_end));
     rhs_ranges.emplace_back(std::make_pair(rhs_start, rhs_end));
diff --git a/paddle/cinn/adt/naive_op_equation_context.cc b/paddle/cinn/adt/naive_op_equation_context.cc
@@ -70,7 +70,9 @@ void GenerateOpEquationsImpl(const ::pir::Operation* op_node,
           "generate_equations");
   const hlir::framework::Operator* cinn_op = hlir::framework::Operator::Get(
       hlir::framework::pir::CompatibleInfo::OpName(*op_node));
-  CHECK(generate_equations.Find(cinn_op));
+  PADDLE_ENFORCE_EQ(generate_equations.Find(cinn_op),
+                    true,
+                    phi::errors::NotFound("generate_equations not found"));
   generate_equations[cinn_op](ctx);
 }
 
@@ -125,8 +127,14 @@ GetArgStaticDimT MakeGetterArgStaticDim(const List<Tensor>& tensors) {
   return [=](std::size_t tensor_idx,
              std::size_t dim_idx) -> std::optional<std::int64_t> {
     const auto& opt_expr = GetArgDim(tensors, tensor_idx, dim_idx);
-    CHECK(opt_expr.has_value());
-    CHECK(opt_expr.value().Has<std::int64_t>());
+    PADDLE_ENFORCE_EQ(
+        opt_expr.has_value(),
+        true,
+        phi::errors::InvalidArgument("Sorry,but opt_expr don't has value"));
+    PADDLE_ENFORCE_EQ(opt_expr.value().Has<std::int64_t>(),
+                      true,
+                      phi::errors::InvalidArgument(
+                          "Sorry,but opt_expr should has value int64_t"));
     return opt_expr.value().Get<std::int64_t>();
   };
 }
@@ -212,7 +220,10 @@ GenerateContext4LocalOpStmt(const List<OpStmt>& op_stmts) {
 
   for (const auto& op_stmt : *op_stmts) {
     const auto& ctx = MakeContextAndGenerateEquations(op_stmt);
-    CHECK(op_stmt2equation_ctx->emplace(op_stmt, ctx).second);
+    PADDLE_ENFORCE_EQ(
+        op_stmt2equation_ctx->emplace(op_stmt, ctx).second,
+        true,
+        phi::errors::InvalidArgument("op_stmt2equation_ctx insert failed"));
   }
 
   return [op_stmt2equation_ctx](const auto& op_stmt) {
diff --git a/paddle/cinn/common/cuda_test_helper.cc b/paddle/cinn/common/cuda_test_helper.cc
@@ -31,8 +31,14 @@ void CudaModuleTester::Compile(const ir::Module& m,
       backends::SplitDeviceAndHostModule(m);  // NOLINT
   auto& host_module = std::get<0>(_host_module_device_module_);
   auto& device_module = std::get<1>(_host_module_device_module_);
-  CHECK(!host_module.functions().empty());
-  CHECK(!device_module.functions().empty());
+  PADDLE_ENFORCE_EQ(host_module.functions().empty(),
+                    false,
+                    phi::errors::InvalidArgument(
+                        "host_module.functions() should not be empty"));
+  PADDLE_ENFORCE_EQ(device_module.functions().empty(),
+                    false,
+                    phi::errors::InvalidArgument(
+                        "device_module.functions() should not be empty"));
 
   backends::CodeGenCUDA_Dev codegen(DefaultHostTarget());
   auto source_code = codegen.Compile(device_module);
@@ -53,7 +59,10 @@ void CudaModuleTester::Compile(const ir::Module& m,
     std::string kernel_fn_name = fn->name;
     auto fn_kernel = reinterpret_cast<runtime::cuda::CUDAModule*>(cuda_module_)
                          ->GetFunction(0, kernel_fn_name);
-    CHECK(fn_kernel);
+    PADDLE_ENFORCE_EQ(
+        fn_kernel,
+        true,
+        phi::errors::InvalidArgument("%s should not be null", kernel_fn_name));
     kernel_handles_.push_back(fn_kernel);
 
     backends::GlobalSymbolRegistry::Global().RegisterFn(
@@ -68,7 +77,10 @@ void CudaModuleTester::Compile(const ir::Module& m,
 }
 
 void* CudaModuleTester::CreateDeviceBuffer(const cinn_buffer_t* host_buffer) {
-  CHECK(host_buffer->memory);
+  PADDLE_ENFORCE_EQ(
+      host_buffer->memory,
+      true,
+      phi::errors::InvalidArgument("host_buffer->memory should not be null"));
   int num_bytes = host_buffer->num_elements() * sizeof(float);
   CUdeviceptr data;
   cuMemAlloc(&data, num_bytes);
diff --git a/paddle/cinn/common/dim_expr_converter.cc b/paddle/cinn/common/dim_expr_converter.cc
@@ -86,7 +86,10 @@ struct DimExprToIrExprVisitor {
 
   ir::Expr operator()(const Max<DimExpr>& dim_expr) {
     const auto& [operands] = dim_expr;
-    CHECK(!operands->empty());
+    PADDLE_ENFORCE_EQ(
+        !operands->empty(),
+        true,
+        phi::errors::InvalidArgument("The value in dim_expr is empty"));
     ir::Expr max = ConvertToIrExpr(operands->at(0));
     for (std::size_t i = 1; i < operands->size(); ++i) {
       max = ir::Max::Make(max, ConvertToIrExpr(operands->at(i)));
@@ -96,7 +99,10 @@ struct DimExprToIrExprVisitor {
 
   ir::Expr operator()(const Min<DimExpr>& dim_expr) {
     const auto& [operands] = dim_expr;
-    CHECK(!operands->empty());
+    PADDLE_ENFORCE_EQ(
+        !operands->empty(),
+        true,
+        phi::errors::InvalidArgument("The value in dim_expr is empty"));
     ir::Expr min = ConvertToIrExpr(operands->at(0));
     for (std::size_t i = 1; i < operands->size(); ++i) {
       min = ir::Min::Make(min, ConvertToIrExpr(operands->at(i)));
@@ -107,7 +113,10 @@ struct DimExprToIrExprVisitor {
   // convert Broadcast to Max
   ir::Expr operator()(const Broadcast<DimExpr>& dim_expr) {
     const auto& [operands] = dim_expr;
-    CHECK(!operands->empty());
+    PADDLE_ENFORCE_EQ(
+        !operands->empty(),
+        true,
+        phi::errors::InvalidArgument("The value in dim_expr is empty"));
     ir::Expr max = ConvertToIrExpr(operands->at(0));
     for (std::size_t i = 1; i < operands->size(); ++i) {
       max = ir::Max::Make(max, ConvertToIrExpr(operands->at(i)));
@@ -129,7 +138,10 @@ struct DimExprConverterWithSymbolBindings::
       symbol_binding_map_;
 
   ir::Expr operator()(const std::string& dim_expr) override {
-    CHECK(symbol_binding_map_.count(dim_expr));
+    PADDLE_ENFORCE_EQ(symbol_binding_map_.count(dim_expr),
+                      true,
+                      phi::errors::InvalidArgument(
+                          "symbol_binding_map_ does not contain dim_expr"));
     auto symbol_binding = symbol_binding_map_[dim_expr];
     auto [input_idx, input_dim_idx] = std::visit(
         [](auto&& symbol_binding) -> std::pair<int64_t, int64_t> {
diff --git a/paddle/cinn/lang/lower_tensor_group.cc b/paddle/cinn/lang/lower_tensor_group.cc
@@ -97,11 +97,17 @@ std::vector<ir::LoweredFunc> LowerTensorGroup::operator()() {
         func_body, [](const Expr* x) { return x->As<ir::Store>(); });
     for (auto& expr : store_exprs) {
       auto* store_node = expr.As<ir::Store>();
-      CHECK(store_node);
+      PADDLE_ENFORCE_NOT_NULL(
+          store_node, phi::errors::InvalidArgument("store_node is nullptr"));
       auto* tensor = store_node->tensor.As<ir::_Tensor_>();
-      CHECK(tensor);
+      PADDLE_ENFORCE_NOT_NULL(
+          tensor,
+          phi::errors::InvalidArgument("Sorry,but store_node is nullptr"));
       VLOG(3) << "In store_exprs, its name is : " << tensor->name;
-      CHECK(tensor->buffer.defined());
+      PADDLE_ENFORCE_EQ(
+          tensor->buffer.defined(),
+          true,
+          phi::errors::InvalidArgument("tensor->buffer is nullptr"));
       if (tensor->buffer->memory_type != ir::MemoryType::Heap) {
         temp_tensor_names.insert(store_node->tensor.as_tensor_ref()->name);
       }
@@ -156,9 +162,15 @@ std::vector<ir::Argument> LowerTensorGroup::GenerateFunctionArgumentList(
   std::set<std::string> arg_names;
 
   for (auto& scalar : scalar_args_) {
-    CHECK(!arg_names.count(scalar->name));
+    PADDLE_ENFORCE_EQ(
+        !arg_names.count(scalar->name),
+        true,
+        phi::errors::InvalidArgument("arg_names.count(scalar->name) is true"));
     auto* scalar_node = scalar.As<ir::_Var_>();
-    CHECK(scalar_node->type().valid());
+    PADDLE_ENFORCE_EQ(
+        scalar_node->type().valid(),
+        true,
+        phi::errors::InvalidArgument("scalar_node->type().valid() is false"));
     arg_names.insert(scalar->name);
 
     args.emplace_back(scalar, ir::Argument::IO::kInput);
@@ -181,7 +193,10 @@ std::vector<ir::Argument> LowerTensorGroup::GenerateFunctionArgumentList(
           std::find_if(args.begin(), args.end(), [&](const ir::Argument& x) {
             return x.name() == tensor_node->buffer->name;
           });
-      CHECK(it != args.end());
+      PADDLE_ENFORCE_EQ(it != args.end(),
+                        true,
+                        phi::errors::InvalidArgument(
+                            "it which refers to first element should be end"));
       if (it->is_input()) {
         args.erase(it);
       } else if (it->is_output()) {
diff --git a/paddle/cinn/optim/trans_buffer_with_dynamic_shape.cc b/paddle/cinn/optim/trans_buffer_with_dynamic_shape.cc
@@ -58,13 +58,19 @@ struct Mutator : public ir::IRMutator<> {
           if (!e.is_constant()) {
             auto new_shape = ir::ir_utils::IRCopy(e);
             new_shape = analyzer.UpperBound(new_shape);
-            CHECK(new_shape.is_constant());
+            PADDLE_ENFORCE_EQ(
+                new_shape.is_constant(),
+                true,
+                phi::errors::InvalidArgument("new_shape is not constant"));
             e = new_shape;
           }
           if (!buf_e.is_constant()) {
             auto new_shape = ir::ir_utils::IRCopy(buf_e);
             new_shape = analyzer.UpperBound(new_shape);
-            CHECK(new_shape.is_constant());
+            PADDLE_ENFORCE_EQ(
+                new_shape.is_constant(),
+                true,
+                phi::errors::InvalidArgument("new_shape is not constant"));
             buf_e = new_shape;
           }
         }
@@ -78,7 +84,10 @@ struct Mutator : public ir::IRMutator<> {
           if (!e.is_constant()) {
             auto new_shape = ir::ir_utils::IRCopy(e);
             new_shape = analyzer.UpperBound(new_shape);
-            CHECK(new_shape.is_constant());
+            PADDLE_ENFORCE_EQ(
+                new_shape.is_constant(),
+                true,
+                phi::errors::InvalidArgument("new_shape is not constant"));
             e = new_shape;
           }
         }
@@ -87,7 +96,10 @@ struct Mutator : public ir::IRMutator<> {
       }
       if (buf->memory_type == ir::MemoryType::GPUShared) {
         buf_size = analyzer.UpperBound(buf_size);
-        CHECK(buf_size.is_constant());
+        PADDLE_ENFORCE_EQ(
+            buf_size.is_constant(),
+            true,
+            phi::errors::InvalidArgument("buf_size is not constant"));
         shared_mem_size_used_ += static_cast<size_t>(buf_size.get_constant()) *
                                  static_cast<size_t>(buf->dtype.bits()) / 8;
       }
@@ -115,9 +127,12 @@ void CudaTransBufferWithDynamicShape(ir::Expr* e) {
             common::DevInfoMgr<common::NVGPUArch>::GetDevInfo(0);
         if (cur_dev_info->IsValid()) {
           size_t max_shm_per_block = cur_dev_info->GetMaxSharedMemPerBlock();
-          CHECK(mutator.shared_mem_size_used_ <= max_shm_per_block)
-              << "The shared memory size used by current kernel "
-              << "is greater than the max shared memory per block";
+          PADDLE_ENFORCE_EQ(
+              (mutator.shared_mem_size_used_ <= max_shm_per_block),
+              true,
+              phi::errors::InvalidArgument(
+                  "The shared memory size used by current kernel is greater "
+                  "than the max shared memory per block"));
         }
 #endif
       },
