优化了5个文件的报错信息 (#67325)

Wizard-ZP · web-flow · commit a33778e6d637 · 2024-08-16T14:58:45.000+08:00
diff --git a/paddle/cinn/common/integer_set.cc b/paddle/cinn/common/integer_set.cc
@@ -19,6 +19,7 @@
 #include "paddle/cinn/ir/op/ir_operators.h"
 #include "paddle/cinn/ir/utils/ir_copy.h"
 #include "paddle/cinn/optim/replace_var_with_expr.h"
+#include "paddle/common/enforce.h"
 
 namespace cinn {
 namespace common {
@@ -199,10 +200,23 @@ std::optional<bool> SymbolicExprAnalyzer::ProveLT(const ir::Expr& lhs,
 // and rhs must be a var
 std::optional<bool> SymbolicExprAnalyzer::ProveDivisible(
     const ir::Expr& lhs, const ir::Expr& rhs) const {
-  CHECK(rhs.is_var()) << "Rhs in ProveDivisible must be a var temporarily!\n";
-  CHECK(lhs.defined());
-  CHECK(rhs.defined());
-  CHECK(cinn::common::IsPureMath(lhs));
+  PADDLE_ENFORCE_EQ(rhs.is_var(),
+                    true,
+                    phi::errors::InvalidArgument(
+                        "Rhs in ProveDivisible must be a var temporarily!\n"));
+  PADDLE_ENFORCE_EQ(
+      lhs.defined(),
+      true,
+      phi::errors::InvalidArgument("Lhs in ProveDivisible must be defined."));
+  PADDLE_ENFORCE_EQ(
+      rhs.defined(),
+      true,
+      phi::errors::InvalidArgument("Rhs in ProveDivisible must be defined."));
+  PADDLE_ENFORCE_EQ(
+      cinn::common::IsPureMath(lhs),
+      true,
+      phi::errors::InvalidArgument(
+          "Lhs in ProveDivisible must be a pure math expression."));
 
   ir::Expr lhs_copy = ir::ir_utils::IRCopy(lhs);
   if (cinn::common::is_zero(lhs_copy)) return true;
@@ -245,7 +259,10 @@ std::optional<bool> SymbolicExprAnalyzer::ProveDivisible(
     case cinn::ir::IrNodeTy::Sum:
       res = true;
       ops = lhs.As<ir::Sum>()->operands();
-      CHECK(!ops.empty());
+      PADDLE_ENFORCE_NE(ops.empty(),
+                        true,
+                        phi::errors::InvalidArgument(
+                            "Operands in Sum node should not be empty."));
       std::for_each(ops.begin(), ops.end(), [&](const ir::Expr& expr) {
         res = OptionalAnd(res, this->ProveDivisible(expr, rhs));
       });
@@ -254,7 +271,10 @@ std::optional<bool> SymbolicExprAnalyzer::ProveDivisible(
     case cinn::ir::IrNodeTy::Product:
       res = false;
       ops = lhs.As<ir::Product>()->operands();
-      CHECK(!ops.empty());
+      PADDLE_ENFORCE_NE(ops.empty(),
+                        true,
+                        phi::errors::InvalidArgument(
+                            "Operands in Sum node should not be empty."));
       std::for_each(ops.begin(), ops.end(), [&](const ir::Expr& expr) {
         res = OptionalOr(res, this->ProveDivisible(expr, rhs));
         if (res.has_value() && res.value()) return;
diff --git a/paddle/cinn/common/ir_util.cc b/paddle/cinn/common/ir_util.cc
@@ -90,8 +90,11 @@ Expr RampRelatedAdd(ir::Broadcast *broadcast, Expr other) {
 }
 // ramp + ramp
 Expr RampRelatedAdd(ir::Ramp *ramp, ir::Ramp *other) {
-  CHECK(ramp);
-  CHECK(other);
+  PADDLE_ENFORCE_NOT_NULL(
+      ramp, phi::errors::InvalidArgument("Ramp pointer should not be null."));
+  PADDLE_ENFORCE_NOT_NULL(
+      other,
+      phi::errors::InvalidArgument("Other ramp pointer should not be null."));
   if (ramp->lanes == other->lanes) {
     Expr base_add = cinn::common::AutoSimplify(ramp->base + other->base);
     Expr stride_add = cinn::common::AutoSimplify(ramp->stride + other->stride);
@@ -181,10 +184,14 @@ Expr IndiceToAbsOffset(const std::vector<Expr> &shape,
   Expr res;
   ir::TryElevateInt32ToInt64(shape);
   for (int i = 0; i < shape.size(); i++) {
-    CHECK(shape[i].type() == Int(64) || shape[i].type() == Int(32))
-        << "The shape data type currently supports only int32 or int64, but "
-           "the current data type of shape["
-        << i << "] is " << shape[i].type();
+    PADDLE_ENFORCE_EQ(
+        shape[i].type() == Int(64) || shape[i].type() == Int(32),
+        true,
+        ::common::errors::InvalidArgument(
+            "The shape data type currently supports only int32 or int64, but "
+            "the current data type of shape[{}] is {}",
+            i,
+            shape[i].type()));
     Expr indice_prod = indices[i];
     optim::SimplifyCast(&indice_prod);
     for (int j = i + 1; j < shape.size(); j++) {
@@ -271,7 +278,10 @@ Expr select(Expr cond, Expr true_value, Expr false_value) {
 }
 
 Expr and_all(const std::vector<Expr> &conds) {
-  CHECK(!conds.empty());
+  PADDLE_ENFORCE_NE(conds.empty(),
+                    true,
+                    phi::errors::InvalidArgument(
+                        "The conditions vector should not be empty."));
   Expr res = conds.front();
   for (int i = 1; i < conds.size(); i++) {
     res = ir::And::Make(res, conds[i]);
@@ -280,7 +290,10 @@ Expr and_all(const std::vector<Expr> &conds) {
 }
 
 Expr or_all(const std::vector<Expr> &conds) {
-  CHECK(!conds.empty());
+  PADDLE_ENFORCE_NE(conds.empty(),
+                    true,
+                    phi::errors::InvalidArgument(
+                        "The conditions vector should not be empty."));
   Expr res = conds.front();
   for (int i = 1; i < conds.size(); i++) {
     res = ir::Or::Make(res, conds[i]);
@@ -396,7 +409,10 @@ std::vector<std::string> GatherItersToTensorProducer(
 
     void Visit(const ir::Store *op, Expr *expr) {
       if (op->tensor.as_tensor()->name == target_tensor_name) {
-        CHECK(iters.empty());
+        PADDLE_ENFORCE_EQ(iters.empty(),
+                          true,
+                          phi::errors::InvalidArgument(
+                              "The iterators vector should be empty."));
         for (auto &e : for_stack) {
           auto *for_n = e->As<ir::For>();
           auto *polyfor_n = e->As<ir::PolyFor>();
diff --git a/paddle/cinn/ir/layout.cc b/paddle/cinn/ir/layout.cc
@@ -19,19 +19,30 @@ namespace ir {
 
 void Layout::Verify() {
   {
-    CHECK(!name_.empty());
-    CHECK(!axes_.empty());
+    PADDLE_ENFORCE_NE(
+        name_.empty(),
+        true,
+        phi::errors::InvalidArgument("The name should not be empty."));
+    PADDLE_ENFORCE_NE(
+        axes_.empty(),
+        true,
+        phi::errors::InvalidArgument("The axes should not be empty."));
     axis_names_ = "";
     for (auto& axis : axes_) {
       PADDLE_ENFORCE_EQ(
           axis->name.size(),
           1U,
           ::common::errors::InvalidArgument("axis name size must be 1"));
       auto axis_name = axis->name[0];
-      CHECK((axis_name >= 'A' && axis_name <= 'Z') ||
-            (axis_name >= 'a' && axis_name <= 'z'));
-      CHECK(axis_names_.find(axis_name) == axis_names_.npos)
-          << axis_name << " has already exsit.";
+      PADDLE_ENFORCE_EQ(
+          (axis_name >= 'A' && axis_name <= 'Z') ||
+              (axis_name >= 'a' && axis_name <= 'z'),
+          true,
+          phi::errors::InvalidArgument("Axis name must be a letter."));
+      PADDLE_ENFORCE_EQ(
+          axis_names_.find(axis_name) == axis_names_.npos,
+          true,
+          phi::errors::InvalidArgument("{} has already existed.", axis_name));
       axis_names_ += axis_name;
     }
     int offset = 'A' - 'a';
@@ -42,14 +53,20 @@ void Layout::Verify() {
           ::common::errors::InvalidArgument("axis name size must be 1"));
       auto axis_name = axis->name[0];
       if (axis_name >= 'a' && axis_name <= 'z') {
-        CHECK(axis_names_.find(axis_name + offset) != axis_names_.npos)
-            << "sub-axis " << axis_name << " finds no primal axis";
+        PADDLE_ENFORCE_NE(
+            axis_names_.find(axis_name + offset) == axis_names_.npos,
+            true,
+            phi::errors::InvalidArgument("sub-axis {} finds no primal axis",
+                                         axis_name));
       }
     }
   }
 }
 Layout::Layout(const std::string& name) {
-  CHECK(!name.empty());
+  PADDLE_ENFORCE_NE(
+      name.empty(),
+      true,
+      phi::errors::InvalidArgument("The name should not be empty."));
   int factor = 0;
   std::vector<Var> axes;
   for (char c : name) {
diff --git a/paddle/fluid/distributed/ps/table/sparse_sgd_rule.cc b/paddle/fluid/distributed/ps/table/sparse_sgd_rule.cc
@@ -18,6 +18,8 @@
 
 #include "paddle/common/flags.h"
 
+#include "paddle/common/enforce.h"
+
 PD_DEFINE_bool(enable_show_scale_gradient, true, "enable show scale gradient");
 
 namespace paddle::distributed {
@@ -32,9 +34,11 @@ void SparseNaiveSGDRule::LoadConfig(const SparseCommonSGDRuleParameter &param,
     _min_bound = -std::numeric_limits<float>::max();
     _max_bound = std::numeric_limits<float>::max();
   } else {
-    CHECK(naive_param.weight_bounds_size() >= 2)
-        << "invalid repeated size for weight_bounds:"
-        << naive_param.weight_bounds_size();
+    PADDLE_ENFORCE_GE(naive_param.weight_bounds_size(),
+                      2,
+                      phi::errors::InvalidArgument(
+                          "invalid repeated size for weight_bounds: %d",
+                          naive_param.weight_bounds_size()));
     _min_bound = naive_param.weight_bounds(0);
     _max_bound = naive_param.weight_bounds(1);
   }
@@ -79,9 +83,11 @@ void SparseAdaGradSGDRule::LoadConfig(const SparseCommonSGDRuleParameter &param,
     _min_bound = -std::numeric_limits<float>::max();
     _max_bound = std::numeric_limits<float>::max();
   } else {
-    CHECK(adagrad_param.weight_bounds_size() >= 2)
-        << "invalid repeated size for weight_bounds:"
-        << adagrad_param.weight_bounds_size();
+    PADDLE_ENFORCE_GE(adagrad_param.weight_bounds_size(),
+                      2,
+                      phi::errors::InvalidArgument(
+                          "invalid repeated size for weight_bounds: %d",
+                          adagrad_param.weight_bounds_size()));
     _min_bound = adagrad_param.weight_bounds(0);
     _max_bound = adagrad_param.weight_bounds(1);
   }
@@ -136,9 +142,11 @@ void StdAdaGradSGDRule::LoadConfig(const SparseCommonSGDRuleParameter &param,
     _min_bound = -std::numeric_limits<float>::max();
     _max_bound = std::numeric_limits<float>::max();
   } else {
-    CHECK(adagrad_param.weight_bounds_size() >= 2)
-        << "invalid repeated size for weight_bounds:"
-        << adagrad_param.weight_bounds_size();
+    PADDLE_ENFORCE_GE(adagrad_param.weight_bounds_size(),
+                      2,
+                      phi::errors::InvalidArgument(
+                          "invalid repeated size for weight_bounds: %d",
+                          adagrad_param.weight_bounds_size()));
     _min_bound = adagrad_param.weight_bounds(0);
     _max_bound = adagrad_param.weight_bounds(1);
   }
@@ -190,9 +198,11 @@ void SparseAdamSGDRule::LoadConfig(const SparseCommonSGDRuleParameter &param,
     _min_bound = -std::numeric_limits<float>::max();
     _max_bound = std::numeric_limits<float>::max();
   } else {
-    CHECK(adam_param.weight_bounds_size() >= 2)
-        << "invalid repeated size for weight_bounds:"
-        << adam_param.weight_bounds_size();
+    PADDLE_ENFORCE_GE(adam_param.weight_bounds_size(),
+                      2,
+                      phi::errors::InvalidArgument(
+                          "invalid repeated size for weight_bounds: %d",
+                          adam_param.weight_bounds_size()));
     _min_bound = adam_param.weight_bounds(0);
     _max_bound = adam_param.weight_bounds(1);
   }
@@ -264,9 +274,11 @@ void SparseSharedAdamSGDRule::LoadConfig(
     _min_bound = -std::numeric_limits<float>::max();
     _max_bound = std::numeric_limits<float>::max();
   } else {
-    CHECK(adam_param.weight_bounds_size() >= 2)
-        << "invalid repeated size for weight_bounds:"
-        << adam_param.weight_bounds_size();
+    PADDLE_ENFORCE_GE(adam_param.weight_bounds_size(),
+                      2,
+                      phi::errors::InvalidArgument(
+                          "invalid repeated size for weight_bounds: %d",
+                          adam_param.weight_bounds_size()));
     _min_bound = adam_param.weight_bounds(0);
     _max_bound = adam_param.weight_bounds(1);
   }
@@ -346,9 +358,11 @@ void SparseAdaGradV2SGDRule::LoadConfig(
     _min_bound = -std::numeric_limits<float>::max();
     _max_bound = std::numeric_limits<float>::max();
   } else {
-    CHECK(adagrad_param.weight_bounds_size() >= 2)
-        << "invalid repeated size for weight_bounds:"
-        << adagrad_param.weight_bounds_size();
+    PADDLE_ENFORCE_GE(adagrad_param.weight_bounds_size(),
+                      2,
+                      phi::errors::InvalidArgument(
+                          "invalid repeated size for weight_bounds: %d",
+                          adagrad_param.weight_bounds_size()));
     _min_bound = adagrad_param.weight_bounds(0);
     _max_bound = adagrad_param.weight_bounds(1);
   }
diff --git a/paddle/fluid/inference/tensorrt/plugin/custom_generic_plugin.cu b/paddle/fluid/inference/tensorrt/plugin/custom_generic_plugin.cu
@@ -13,6 +13,7 @@
 // limitations under the License.
 
 #include "paddle/fluid/inference/tensorrt/plugin/custom_generic_plugin.h"
+#include "paddle/common/enforce.h"
 #include "paddle/fluid/framework/framework.pb.h"
 #include "paddle/fluid/framework/op_kernel_type.h"
 #include "paddle/fluid/framework/phi_utils.h"
@@ -392,7 +393,13 @@ nvinfer1::DimsExprs CustomGenericPlugin::getOutputDimensions(
     const nvinfer1::DimsExprs* inputs,
     int nb_inputs,
     nvinfer1::IExprBuilder& expr_builder) TRT_NOEXCEPT {
-  CHECK(output_index < getNbOutputs());
+  PADDLE_ENFORCE_LT(
+      output_index,
+      getNbOutputs(),
+      phi::errors::InvalidArgument(
+          "Output index (%d) must be less than the number of outputs (%d).",
+          output_index,
+          getNbOutputs()));
   auto& op_meta_info_map = OpMetaInfoMap::Instance();
   const auto& meta_info_map = op_meta_info_map.GetMap();
   auto& op_info = meta_info_map.at(op_desc_.Type()).front();
@@ -453,8 +460,21 @@ void CustomGenericPlugin::configurePlugin(
     int nb_inputs,
     const nvinfer1::DynamicPluginTensorDesc* out,
     int nb_outputs) TRT_NOEXCEPT {
-  CHECK(nb_inputs == getNbInputs());
-  CHECK(nb_outputs == getNbOutputs());
+  PADDLE_ENFORCE_EQ(
+      nb_inputs,
+      getNbInputs(),
+      phi::errors::InvalidArgument("Number of inputs (%d) does not match the "
+                                   "expected number of inputs (%d).",
+                                   nb_inputs,
+                                   getNbInputs()));
+
+  PADDLE_ENFORCE_EQ(
+      nb_outputs,
+      getNbOutputs(),
+      phi::errors::InvalidArgument("Number of outputs (%d) does not match the "
+                                   "expected number of outputs (%d).",
+                                   nb_outputs,
+                                   getNbOutputs()));
 }
 
 // Shutdown the layer. This is called when the engine is destroyed
@@ -491,13 +511,21 @@ int CustomGenericPlugin::enqueue(const nvinfer1::PluginTensorDesc* input_desc,
     } else if (proto_type == GenerateCustomGenericPluginDataType::PLUGIN_BOOL) {
       return {phi::DataType::BOOL, sizeof(bool)};
     } else {
-      CHECK(false) << "precision is not supported";
+      PADDLE_ENFORCE_EQ(
+          false,
+          true,
+          phi::errors::InvalidArgument("Precision is not supported."));
     }
   };
 
   nvinfer1::DataType data_type = input_desc[0].type;
-  CHECK((data_type == nvinfer1::DataType::kFLOAT) ||
-        (data_type == nvinfer1::DataType::kHALF));
+  PADDLE_ENFORCE_EQ(
+      (data_type == nvinfer1::DataType::kFLOAT) ||
+          (data_type == nvinfer1::DataType::kHALF),
+      true,
+      phi::errors::InvalidArgument("The data type must be either kFLOAT or "
+                                   "kHALF, but received data type %d.",
+                                   static_cast<int>(data_type)));
 
   paddle::CustomOpKernelContext kernel_ctx;
   // input
