【Error Message BUAA No.35】fix error message (#66718)

uanu2002 · web-flow · commit 05381c91dced · 2024-07-31T10:14:51.000+08:00
* fix error message

* fix arrange_storage_tactic.cc

* fix arrange_storage_tactic.cc
diff --git a/paddle/cinn/adt/schedule_mesh.cc b/paddle/cinn/adt/schedule_mesh.cc
@@ -385,22 +385,39 @@ ScheduleMesh MeshReshape(const ScheduleMesh& sched_mesh,
   const auto& origin_shape = GetOutputDimValues(sched_mesh);
   std::int64_t origin_numel = 1;
   for (const auto& dim : *origin_shape) {
-    CHECK(dim.Has<std::int64_t>());
+    PADDLE_ENFORCE_EQ(
+        dim.Has<std::int64_t>(),
+        true,
+        phi::errors::InvalidArgument(
+            "Each dimension in 'origin_shape' must have an int64_t value."));
     origin_numel *= dim.Get<std::int64_t>();
   }
 
   std::int64_t numel = 1;
   bool dynamic_shape = false;
   for (const auto& dim : shape) {
     if (dim < 0) {
-      CHECK(dim == -1 && !dynamic_shape);
+      PADDLE_ENFORCE_EQ(
+          dim == -1 && !dynamic_shape,
+          true,
+          phi::errors::InvalidArgument("Negative dimension in 'shape' must be "
+                                       "-1 to represent dynamic shape. "
+                                       "But received: %d",
+                                       dim));
       dynamic_shape = true;
     } else {
       numel *= dim;
     }
   }
-
-  CHECK(dynamic_shape || numel == origin_numel);
+  PADDLE_ENFORCE_EQ(dynamic_shape || numel == origin_numel,
+                    true,
+                    phi::errors::InvalidArgument(
+                        "The total number of elements must match between "
+                        "'shape' and 'origin_shape' "
+                        "unless there is a dynamic shape. "
+                        "But received: numel = %d, origin_numel = %d",
+                        numel,
+                        origin_numel));
   List<LoopSize> reshape_to{};
   for (const auto& dim : shape) {
     if (dim < 0) {
@@ -465,7 +482,13 @@ ScheduleMesh MeshPaddingRoundUp(
       continue;
     }
     std::int64_t align_size = align_sizes.at(i).value();
-    CHECK(shape->at(i).Has<std::int64_t>());
+    PADDLE_ENFORCE_EQ(
+        shape->at(i).Has<std::int64_t>(),
+        true,
+        phi::errors::InvalidArgument(
+            "Each dimension in 'shape' must have an int64_t value. "
+            "But the dimension at index %d does not.",
+            i));
     std::int64_t dim = shape->at(i).Get<std::int64_t>();
     std::int64_t padding_size =
         (dim + align_size - 1) / align_size * align_size;
diff --git a/paddle/cinn/backends/nvrtc/nvrtc_util.cc b/paddle/cinn/backends/nvrtc/nvrtc_util.cc
@@ -212,15 +212,25 @@ std::string Compiler::CompileWithNvcc(const std::string& cuda_c) {
   // read dir source
   std::string dir = "./source";
   if (access(dir.c_str(), 0) == -1) {
-    CHECK(mkdir(dir.c_str(), 7) != -1) << "Fail to mkdir " << dir;
+    PADDLE_ENFORCE_NE(
+        mkdir(dir.c_str(), 7),
+        -1,
+        phi::errors::PermissionDenied(
+            "Failed to create directory %s. Please check the permissions.",
+            dir.c_str()));
   }
 
   // get unique prefix name
   prefix_name_ = dir + "/" + cinn::common::UniqName("rtc_tmp");
 
   auto cuda_c_file = prefix_name_ + ".cu";
   std::ofstream ofs(cuda_c_file, std::ios::out);
-  CHECK(ofs.is_open()) << "Fail to open file " << cuda_c_file;
+  PADDLE_ENFORCE_EQ(ofs.is_open(),
+                    true,
+                    phi::errors::Unavailable(
+                        "Failed to open file %s. Please check if the file path "
+                        "is correct and the file is accessible.",
+                        cuda_c_file.c_str()));
   ofs << cuda_c;
   ofs.close();
 
@@ -252,7 +262,12 @@ void Compiler::CompileToPtx() {
   options += " " + prefix_name_ + ".cu";
 
   VLOG(2) << "Nvcc Compile Options : " << options;
-  CHECK(system(options.c_str()) == 0) << options;
+  PADDLE_ENFORCE_EQ(
+      system(options.c_str()),
+      0,
+      phi::errors::InvalidArgument("Failed to execute command: %s. Please "
+                                   "check the command and try again.",
+                                   options.c_str()));
 }
 
 void Compiler::CompileToCubin() {
@@ -263,7 +278,12 @@ void Compiler::CompileToCubin() {
   options += " " + prefix_name_ + ".ptx";
 
   VLOG(2) << "Nvcc Compile Options : " << options;
-  CHECK(system(options.c_str()) == 0) << options;
+  PADDLE_ENFORCE_EQ(
+      system(options.c_str()),
+      0,
+      phi::errors::InvalidArgument("Failed to execute command: %s. Please "
+                                   "check the command and try again.",
+                                   options.c_str()));
 }
 
 std::string Compiler::GetDeviceArch() {
@@ -284,7 +304,12 @@ std::string Compiler::ReadFile(const std::string& file_name,
                                std::ios_base::openmode mode) {
   // open cubin file
   std::ifstream ifs(file_name, mode);
-  CHECK(ifs.is_open()) << "Fail to open file " << file_name;
+  PADDLE_ENFORCE_EQ(ifs.is_open(),
+                    true,
+                    phi::errors::Unavailable(
+                        "Failed to open file %s. Please check if the file path "
+                        "is correct and the file is accessible.",
+                        file_name.c_str()));
   ifs.seekg(std::ios::end);
   auto len = ifs.tellg();
   ifs.seekg(0);
diff --git a/paddle/cinn/ir/group_schedule/tactic/arrange_storage_tactic.cc b/paddle/cinn/ir/group_schedule/tactic/arrange_storage_tactic.cc
@@ -64,7 +64,11 @@ struct FixedCudaIterVarName {
 
 std::optional<bool> IsSubCudaAxisSpace(const CudaAxisSpace& lhs,
                                        const CudaAxisSpace& rhs) {
-  CHECK(lhs.type == rhs.type);
+  PADDLE_ENFORCE_EQ(
+      lhs.type,
+      rhs.type,
+      phi::errors::InvalidArgument(
+          "The type of 'lhs' must be equal to the type of 'rhs'. "));
   std::optional<bool> prove_sub_x = lhs.x.ProveSubSet(rhs.x);
   std::optional<bool> prove_sub_y = lhs.y.ProveSubSet(rhs.y);
   std::optional<bool> prove_sub_z = lhs.z.ProveSubSet(rhs.z);
@@ -157,8 +161,16 @@ IntSet Evaluate(Expr expr,
     } else if (var->is_symbolic_constant) {
       continue;
     } else {
-      CHECK(var->lower_bound.defined());
-      CHECK(var->upper_bound.defined());
+      PADDLE_ENFORCE_EQ(
+          var->lower_bound.defined(),
+          true,
+          phi::errors::InvalidArgument(
+              "The 'lower_bound' of the variable must be defined."));
+      PADDLE_ENFORCE_EQ(
+          var->upper_bound.defined(),
+          true,
+          phi::errors::InvalidArgument(
+              "The 'upper_bound' of the variable must be defined."));
       optim::ReplaceVarWithExpr(&copy_for_lower_bound, var, var->lower_bound);
       optim::ReplaceVarWithExpr(&copy_for_upper_bound, var, var->upper_bound);
     }
@@ -261,8 +273,14 @@ std::optional<CudaAxisType> AnalyzeCrossType(const VarToForMap& var2for_map,
                                              Expr load,
                                              Expr store_block,
                                              Expr load_block) {
-  CHECK(store_block.As<ir::ScheduleBlockRealize>());
-  CHECK(load_block.As<ir::ScheduleBlockRealize>());
+  PADDLE_ENFORCE_NOT_NULL(
+      store_block.As<ir::ScheduleBlockRealize>(),
+      phi::errors::InvalidArgument(
+          "The 'store_block' must be of type 'ir::ScheduleBlockRealize'."));
+  PADDLE_ENFORCE_NOT_NULL(
+      load_block.As<ir::ScheduleBlockRealize>(),
+      phi::errors::InvalidArgument(
+          "The 'load_block' must be of type 'ir::ScheduleBlockRealize'."));
   std::string store_block_name = store_block.As<ir::ScheduleBlockRealize>()
                                      ->schedule_block.As<ir::ScheduleBlock>()
                                      ->name;
diff --git a/paddle/cinn/ir/operation.cc b/paddle/cinn/ir/operation.cc
@@ -94,27 +94,37 @@ const char *CallOp::__func_type__ = "call_op";
 
 const std::string &CallOp::target() const {
   auto *call = call_expr.As<ir::Call>();
-  CHECK(call);
+  PADDLE_ENFORCE_NOT_NULL(call,
+                          phi::errors::InvalidArgument(
+                              "The 'call_expr' must be of type 'ir::Call'."));
   return call->name;
 }
 std::vector<Expr> &CallOp::write_args() {
   auto *call = call_expr.As<ir::Call>();
-  CHECK(call);
+  PADDLE_ENFORCE_NOT_NULL(call,
+                          phi::errors::InvalidArgument(
+                              "The 'call_expr' must be of type 'ir::Call'."));
   return call->write_args;
 }
 std::vector<Expr> &CallOp::read_args() {
   auto *call = call_expr.As<ir::Call>();
-  CHECK(call);
+  PADDLE_ENFORCE_NOT_NULL(call,
+                          phi::errors::InvalidArgument(
+                              "The 'call_expr' must be of type 'ir::Call'."));
   return call->read_args;
 }
 const std::vector<Expr> &CallOp::write_args() const {
   auto *call = call_expr.As<ir::Call>();
-  CHECK(call);
+  PADDLE_ENFORCE_NOT_NULL(call,
+                          phi::errors::InvalidArgument(
+                              "The 'call_expr' must be of type 'ir::Call'."));
   return call->write_args;
 }
 const std::vector<Expr> &CallOp::read_args() const {
   auto *call = call_expr.As<ir::Call>();
-  CHECK(call);
+  PADDLE_ENFORCE_NOT_NULL(call,
+                          phi::errors::InvalidArgument(
+                              "The 'call_expr' must be of type 'ir::Call'."));
   return call->read_args;
 }
 std::vector<Expr> CallOp::args() const {
diff --git a/paddle/cinn/poly/isl_utils.cc b/paddle/cinn/poly/isl_utils.cc
@@ -84,7 +84,11 @@ void isl_set_dim_names(isl::set *set, const std::vector<std::string> &names) {
 }
 
 isl::union_map isl_maps_to_union_map(const std::vector<isl::map> &maps) {
-  CHECK(!maps.empty());
+  PADDLE_ENFORCE_EQ(
+      !maps.empty(),
+      true,
+      phi::errors::InvalidArgument("The input vector of isl::map is empty. "
+                                   "Please ensure the vector is not empty."));
   isl::union_map umap =
       isl::manage(isl_union_map_from_map(maps.front().copy()));
   for (int i = 1; i < maps.size(); i++) {
@@ -94,7 +98,11 @@ isl::union_map isl_maps_to_union_map(const std::vector<isl::map> &maps) {
 }
 
 isl::union_set isl_sets_to_union_set(const std::vector<isl::set> &sets) {
-  CHECK(!sets.empty());
+  PADDLE_ENFORCE_EQ(
+      !sets.empty(),
+      true,
+      phi::errors::InvalidArgument("The input vector of isl::set is empty. "
+                                   "Please ensure the vector is not empty."));
   isl::union_set uset =
       isl::manage(isl_union_set_from_set(sets.front().copy()));
   for (int i = 1; i < sets.size(); i++) {
@@ -105,7 +113,11 @@ isl::union_set isl_sets_to_union_set(const std::vector<isl::set> &sets) {
 
 std::string isl_map_get_statement_repr(__isl_keep isl_map *map,
                                        isl_dim_type type) {
-  CHECK(map);
+  PADDLE_ENFORCE_NOT_NULL(
+      map,
+      phi::errors::InvalidArgument(
+          "The input isl_map is null. "
+          "Please ensure the map is properly initialized."));
   auto tuple_name = isl_map_get_tuple_name(map, type);
   std::vector<std::string> dims;
 
@@ -304,7 +316,11 @@ isl_set *isl_simplify(isl_set __isl_take *set) {
 }
 
 isl::union_set isl_union_set_from_sets(llvm::ArrayRef<isl::set> sets) {
-  CHECK(!sets.empty());
+  PADDLE_ENFORCE_EQ(
+      !sets.empty(),
+      true,
+      phi::errors::InvalidArgument("The input ArrayRef of isl::set is empty. "
+                                   "Please ensure the ArrayRef is not empty."));
   isl::union_set res = isl::manage(isl_union_set_from_set(sets.front().copy()));
   for (int i = 1; i < sets.size(); i++) {
     res = isl::manage(isl_union_set_add_set(res.release(), sets[i].copy()));
@@ -337,8 +353,14 @@ std::tuple<isl::val, isl::val> isl_set_get_axis_range_by_name(
 }
 
 std::tuple<isl::val, isl::val> isl_set_get_axis_range(isl_set *set, int pos) {
-  CHECK(isl_set_dim_is_bounded(set, isl_dim_set, pos))
-      << "an unbound cannot get range, " << isl_set_to_str(set);
+  PADDLE_ENFORCE_EQ(
+      isl_set_dim_is_bounded(set, isl_dim_set, pos),
+      true,
+      phi::errors::InvalidArgument(
+          "The dimension at position %d of the isl_set is not bounded. "
+          "An unbounded dimension cannot get range. Please check the set: %s",
+          pos,
+          isl_set_to_str(set)));
 
   std::vector<std::string> from_iters;
   std::string target_axis_name;
@@ -393,7 +415,11 @@ bool isl_set_axis_has_noparam_constant_bound(isl_set __isl_keep *set, int pos) {
             // ignore
           }
 
-          CHECK(aff);
+          PADDLE_ENFORCE_NOT_NULL(
+              aff,
+              phi::errors::InvalidArgument(
+                  "The isl_aff is null. "
+                  "Please ensure the isl_aff is properly initialized."));
           auto &is_param_involved = *reinterpret_cast<bool *>(user);
           if (is_param_involved) return isl_stat_ok;
 
