PaddlePaddle
diff --git a/‎paddle/cinn/backends/codegen_c.cc
Copy file name to clipboard
+27-9Lines changed: 27 additions & 9 deletions b/‎paddle/cinn/backends/codegen_c.cc
Copy file name to clipboard
+27-9Lines changed: 27 additions & 9 deletions
diff --git a/‎paddle/cinn/backends/codegen_c_x86.cc
Copy file name to clipboard
+6-2Lines changed: 6 additions & 2 deletions b/‎paddle/cinn/backends/codegen_c_x86.cc
Copy file name to clipboard
+6-2Lines changed: 6 additions & 2 deletions
diff --git a/‎paddle/cinn/backends/codegen_c_x86.h
Copy file name to clipboard
+5-3Lines changed: 5 additions & 3 deletions b/‎paddle/cinn/backends/codegen_c_x86.h
Copy file name to clipboard
+5-3Lines changed: 5 additions & 3 deletions
diff --git a/‎paddle/cinn/backends/codegen_cuda_dev.cc
Copy file name to clipboard
+7-3Lines changed: 7 additions & 3 deletions b/‎paddle/cinn/backends/codegen_cuda_dev.cc
Copy file name to clipboard
+7-3Lines changed: 7 additions & 3 deletions
diff --git a/‎paddle/cinn/backends/codegen_cuda_host.cc
Copy file name to clipboard
+41-9Lines changed: 41 additions & 9 deletions b/‎paddle/cinn/backends/codegen_cuda_host.cc
Copy file name to clipboard
+41-9Lines changed: 41 additions & 9 deletions
diff --git a/‎paddle/cinn/backends/codegen_device_util.h
Copy file name to clipboard
+6-2Lines changed: 6 additions & 2 deletions b/‎paddle/cinn/backends/codegen_device_util.h
Copy file name to clipboard
+6-2Lines changed: 6 additions & 2 deletions
diff --git a/‎paddle/cinn/backends/function_prototype.cc
Copy file name to clipboard
+30-11Lines changed: 30 additions & 11 deletions b/‎paddle/cinn/backends/function_prototype.cc
Copy file name to clipboard
+30-11Lines changed: 30 additions & 11 deletions
@@ -26,7 +26,7 @@
 #include "paddle/cinn/runtime/cpu/thread_backend.h"
 #include "paddle/cinn/runtime/intrinsic.h"
 #include "paddle/cinn/utils/string.h"
-
+#include "paddle/common/enforce.h"
 //! Root of the builtin code.
 PD_DECLARE_string(cinn_x86_builtin_code_root);
 
@@ -205,7 +205,10 @@ void CodeGenC::Visit(const ir::For *op) {
     Expr num_task_var = Var("num_task");
     IrPrinter::Visit((op->extent + num_task_var - 1) / num_task_var);
     str_ += ";\n";
-    CHECK_EQ(min.as_int32(), 0);
+    PADDLE_ENFORCE_EQ(
+        min.as_int32(),
+        0,
+        phi::errors::InvalidArgument("The min of the for loop should be 0"));
     auto task_id = Var("task_id");
     auto n_per_task = Var("n_per_task");
     min = task_id * n_per_task;
@@ -370,7 +373,10 @@ void CodeGenC::PrintCallArgs(const ir::Call *op) {
 }
 
 void CodeGenC::PrintCall_buffer_malloc(const ir::Call *op) {
-  CHECK_EQ(op->read_args.size(), 2UL);
+  PADDLE_ENFORCE_EQ(
+      op->read_args.size(),
+      2UL,
+      phi::errors::InvalidArgument("The number of read_args should be 2"));
   str_ += op->name;
   str_ += "(";
   PrintCastExpr("void*", op->read_args[0]);
@@ -380,7 +386,10 @@ void CodeGenC::PrintCall_buffer_malloc(const ir::Call *op) {
 }
 
 void CodeGenC::PrintCall_cinn_pod_value_to_(const ir::Call *op) {
-  CHECK_EQ(op->read_args.size(), 1UL);
+  PADDLE_ENFORCE_EQ(
+      op->read_args.size(),
+      1UL,
+      phi::errors::InvalidArgument("The number of read_args should be 1"));
   str_ += op->name;
   str_ += "(";
   str_ += "&(";
@@ -390,7 +399,10 @@ void CodeGenC::PrintCall_cinn_pod_value_to_(const ir::Call *op) {
 }
 
 void CodeGenC::PrintCall_get_address(const ir::Call *op) {
-  CHECK_EQ(op->read_args.size(), 1UL);
+  PADDLE_ENFORCE_EQ(
+      op->read_args.size(),
+      1UL,
+      phi::errors::InvalidArgument("The number of read_args should be 1"));
   CHECK(op->write_args.empty());
   auto *read_var = op->read_args.front().as_var();
   auto *read_buf = op->read_args.front().as_buffer();
@@ -409,7 +421,10 @@ void CodeGenC::PrintCall_get_address(const ir::Call *op) {
 
 void CodeGenC::PrintCall_pod_values_to_array(const ir::Call *op) {
   CHECK(!op->read_args.empty());
-  CHECK_EQ(op->write_args.size(), 1UL);
+  PADDLE_ENFORCE_EQ(
+      op->write_args.size(),
+      1UL,
+      phi::errors::InvalidArgument("The number of write_args should be 1"));
   auto output_var = op->write_args.front().as_var_ref();
   CHECK(output_var.defined());
 
@@ -612,9 +627,12 @@ void CodeGenC::Visit(const ir::_LoweredFunc_ *op) {
 
   DoIndent();
 
-  CHECK_EQ(op->alloc_output_buffer_exprs.size(),
-           op->dealloc_output_buffer_exprs.size())
-      << "the count of allocation and deallocation expressions is not match";
+  PADDLE_ENFORCE_EQ(
+      op->alloc_output_buffer_exprs.size(),
+      op->dealloc_output_buffer_exprs.size(),
+      phi::errors::InvalidArgument(
+          "The count of allocation and deallocation expressions is not "
+          "match"));
 
   std::vector<Expr> new_body;
 
 
@@ -13,7 +13,7 @@
 // limitations under the License.
 
 #include "paddle/cinn/backends/codegen_c_x86.h"
-
+#include "paddle/common/enforce.h"
 namespace cinn {
 namespace backends {
 
@@ -53,7 +53,11 @@ void CodeGenCX86::Visit(const ir::Load *op) {
 }
 
 void CodeGenCX86::Visit(const ir::Broadcast *op) {
-  CHECK_GT(op->type().lanes(), 1);
+  PADDLE_ENFORCE_GT(
+      op->type().lanes(),
+      1,
+      phi::errors::InvalidArgument(
+          "The lanes of the broadcast op should be greater than 1."));
   int bits = op->type().bits() * op->type().lanes();
 
   if (SupportsAVX512() && bits == 512) {
 
@@ -18,7 +18,7 @@
 
 #include "paddle/cinn/backends/codegen_c.h"
 #include "paddle/cinn/ir/intrinsic_ops.h"
-
+#include "paddle/common/enforce.h"
 namespace cinn {
 namespace backends {
 
@@ -114,8 +114,10 @@ void CodeGenCX86::VisitBinaryOp(const Op *op,
                                 Expr a,
                                 Expr b,
                                 const std::string &op_repr) {
-  CHECK_EQ(a.type(), b.type()) << " a is : " << a << ", and b is : " << b
-                               << ". op_repr is : " << op_repr;
+  PADDLE_ENFORCE_EQ(
+      a.type(),
+      b.type(),
+      phi::errors::InvalidArgument("The type of a and b should be the same."));
 
   // scalar.
   if (a.type().lanes() == 1) {
 
@@ -26,8 +26,8 @@
 #include "paddle/cinn/ir/op/ir_operators.h"
 #include "paddle/cinn/ir/utils/ir_verify.h"
 #include "paddle/cinn/optim/ir_simplify.h"
+#include "paddle/common/enforce.h"
 #include "paddle/common/errors.h"
-
 namespace cinn {
 namespace backends {
 
@@ -122,7 +122,8 @@ std::vector<Expr> FilterDeallocTempBuffers(const std::vector<Expr> &frees) {
   std::vector<Expr> filtered;
   for (const Expr &free : frees) {
     const ir::Free *op = free.As<ir::Free>();
-    CHECK_NOTNULL(op);
+    PADDLE_ENFORCE_NOT_NULL(
+        op, phi::errors::InvalidArgument("Free is not a free node"));
     bool has_symbolic_constant = false;
     const ir::_Buffer_ *buffer = op->destination.As<ir::_Buffer_>();
     for (Expr shape : buffer->shape) {
@@ -305,7 +306,10 @@ std::string CodeGenCUDA_Dev::Compile(const ir::Module &module,
 void CodeGenCUDA_Dev::PrintIncludes() { str_ += GetSourceHeader(); }
 
 void CodeGenCUDA_Dev::PrintTempBufferCreation(const ir::Buffer &buffer) {
-  CHECK_NE(buffer->type(), Void());
+  PADDLE_ENFORCE_NE(
+      buffer->type(),
+      Void(),
+      phi::errors::InvalidArgument("buffer type should not be void"));
   // Calculate buffer size and determine if it contains a symbolic constant
   Expr buffer_size(1);
   for (int i = 0; i < buffer->shape.size(); i++) {
 
@@ -23,7 +23,7 @@
 #include "paddle/cinn/backends/extern_func_jit_register.h"
 #include "paddle/cinn/backends/llvm/llvm_util.h"
 #include "paddle/cinn/runtime/intrinsic.h"
-
+#include "paddle/common/enforce.h"
 namespace cinn {
 namespace backends {
 
@@ -65,10 +65,22 @@ llvm::Value* CodeGenCUDA_Host::LowerGPUKernelLauncher(
   llvm::Value* kernel_stream = nullptr;
   if (ll_function_args.size() == 3) {
     kernel_stream = ll_function_args[2];
-    CHECK_EQ(kernel_stream->getType(), ll_void_p_ty());  // void* stream
+    PADDLE_ENFORCE_EQ(
+        kernel_stream->getType(),
+        ll_void_p_ty(),
+        phi::errors::InvalidArgument(
+            "The type of kernel_stream should be void*"));  // void* stream
   }
-  CHECK_EQ(kernel_args->getType(), ll_void_p_ty());       // void* args
-  CHECK_EQ(kernel_args_count->getType(), ll_int32_ty());  // int32
+  PADDLE_ENFORCE_EQ(
+      kernel_args->getType(),
+      ll_void_p_ty(),
+      phi::errors::InvalidArgument(
+          "The type of kernel_args should be void*"));  // void* args
+  PADDLE_ENFORCE_EQ(
+      kernel_args_count->getType(),
+      ll_int32_ty(),
+      phi::errors::InvalidArgument(
+          "The type of kernel_args_count should be int32"));  // int32
 
   std::unordered_map<std::string, llvm::Value*> global_args = {
       {KERNEL_ARGS, kernel_args},
@@ -199,7 +211,11 @@ llvm::Value* CodeGenCUDA_Host::LowerHostFunc(const ir::_LoweredFunc_* func) {
   // @}
 
   // Set local scope table
-  CHECK_EQ(ll_function_args.size(), func->args.size());
+  PADDLE_ENFORCE_EQ(ll_function_args.size(),
+                    func->args.size(),
+                    phi::errors::InvalidArgument(
+                        "The number of arguments is not equal to the number of "
+                        "function arguments"));
   for (int i = 0; i < ll_function_args.size(); ++i) {
     SetVar(func->args[i].name(), ll_function_args[i]);
   }
@@ -224,7 +240,11 @@ llvm::Value* CodeGenCUDA_Host::LowerParseArgsValueCall(
     const ir::Call* call_ir) {
   auto ret_type = CinnTypeToLLVMType(Int(64), m_);
   std::vector<llvm::Type*> args_type;
-  CHECK_EQ(call_ir->read_args.size(), 2);
+  PADDLE_ENFORCE_EQ(
+      call_ir->read_args.size(),
+      2,
+      phi::errors::InvalidArgument(
+          "The number of arguments of ParseArgsValue should be 2"));
   CHECK(call_ir->read_args[0].is_var() &&
         call_ir->read_args[0].as_var()->type().is_cpp_handle());
   CHECK(call_ir->read_args[1].type().is_int(32));
@@ -251,10 +271,22 @@ llvm::Value* CodeGenCUDA_Host::LowerCUDAKernelCall(const ir::Call* call_ir) {
   llvm::Value* kernel_stream = nullptr;
   if (ll_function_args.size() == 3) {
     kernel_stream = ll_function_args[2];
-    CHECK_EQ(kernel_stream->getType(), ll_void_p_ty());  // void* stream
+    PADDLE_ENFORCE_EQ(
+        kernel_stream->getType(),
+        ll_void_p_ty(),
+        phi::errors::InvalidArgument(
+            "The type of kernel_stream should be void*"));  // void* stream
   }
-  CHECK_EQ(kernel_args->getType(), ll_void_p_ty());       // void* args
-  CHECK_EQ(kernel_args_count->getType(), ll_int32_ty());  // int32
+  PADDLE_ENFORCE_EQ(
+      kernel_args->getType(),
+      ll_void_p_ty(),
+      phi::errors::InvalidArgument(
+          "The type of kernel_args should be void*"));  // void* args
+  PADDLE_ENFORCE_EQ(
+      kernel_args_count->getType(),
+      ll_int32_ty(),
+      phi::errors::InvalidArgument(
+          "The type of kernel_args_count should be int32"));  // int32
 
   std::unordered_map<std::string, llvm::Value*> global_args = {
       {KERNEL_ARGS, kernel_args},
 
@@ -27,7 +27,7 @@
 #include "paddle/cinn/ir/ir_mutator.h"
 #include "paddle/cinn/ir/utils/ir_copy.h"
 #include "paddle/cinn/runtime/flags.h"
-
+#include "paddle/common/enforce.h"
 namespace cinn {
 namespace backends {
 
@@ -205,7 +205,11 @@ struct CollectBucketStrategyHostFunctionVisitor
     if (op->functions.size() == 1 && op->predicates.size() == 0) {
       expr->as_module()->predicates.push_back(ir::Expr(true));
     }
-    CHECK_EQ(op->functions.size(), op->predicates.size());
+    PADDLE_ENFORCE_EQ(
+        op->functions.size(),
+        op->predicates.size(),
+        phi::errors::InvalidArgument(
+            "The size of functions and predicates should be equal"));
     for (int i = 0; i < op->functions.size(); ++i) {
       ProcessLoweredFunc(op->functions[i], op->predicates[i]);
       if (i == 0) {
 
@@ -20,7 +20,7 @@
 
 #include "paddle/cinn/ir/tensor.h"
 #include "paddle/cinn/runtime/flags.h"
-
+#include "paddle/common/enforce.h"
 PD_DECLARE_bool(verbose_function_register);
 
 namespace cinn {
@@ -42,13 +42,22 @@ bool FunctionProto::Match(const ir::Call *op) const {
 }
 
 void FunctionProto::AssertMatch(const ir::Call *op) const {
-  CHECK_EQ(name, op->name);
-  CHECK_EQ(ret_type, op->type())
-      << "function proto " << name << " check failed";
-  CHECK_EQ(op->read_args.size(), readonly_arg_types.size())
-      << "function proto " << name << " check failed";
-  CHECK_EQ(op->write_args.size(), mutable_arg_types.size())
-      << "function proto " << name << " check failed";
+  PADDLE_ENFORCE_EQ(
+      name,
+      op->name,
+      phi::errors::InvalidArgument("function proto's op name check failed"));
+  PADDLE_ENFORCE_EQ(
+      ret_type,
+      op->type(),
+      phi::errors::InvalidArgument("function proto's op type check failed"));
+  PADDLE_ENFORCE_EQ(op->read_args.size(),
+                    readonly_arg_types.size(),
+                    phi::errors::InvalidArgument(
+                        "function proto's readonly arg types check failed"));
+  PADDLE_ENFORCE_EQ(op->write_args.size(),
+                    mutable_arg_types.size(),
+                    phi::errors::InvalidArgument(
+                        "function proto's mutable arg types check failed"));
 
   auto get_type = [](Expr u) {
     if (u.as_tensor() || u.as_buffer()) {
@@ -61,14 +70,21 @@ void FunctionProto::AssertMatch(const ir::Call *op) const {
     if (readonly_arg_types[i] == type_of<cinn_buffer_t *>()) {
       if (!op->read_args[i].as_tensor()) continue;
     } else {
-      CHECK_EQ(get_type(op->read_args[i]), readonly_arg_types[i]);
+      PADDLE_ENFORCE_EQ(
+          get_type(op->read_args[i]),
+          readonly_arg_types[i],
+          phi::errors::InvalidArgument(
+              "function proto's readonly arg types check failed"));
     }
   }
   for (int i = 0; i < op->write_args.size(); i++) {
     if (mutable_arg_types[i] == type_of<cinn_buffer_t *>()) {
       if (!op->write_args[i].as_tensor()) continue;
     } else {
-      CHECK_EQ(get_type(op->write_args[i]), mutable_arg_types[i]);
+      PADDLE_ENFORCE_EQ(get_type(op->write_args[i]),
+                        mutable_arg_types[i],
+                        phi::errors::InvalidArgument(
+                            "function proto's mutable arg types check failed"));
     }
   }
 }
@@ -86,7 +102,10 @@ void FunctionProto::CheckValid() {
 
 FunctionProto::shape_inference_t FunctionProto::ShapeFollowNthArgument(int n) {
   return [=](const std::vector<Expr> &args, int value_offset) {
-    CHECK_LT(n, args.size());
+    PADDLE_ENFORCE_LT(
+        n,
+        args.size(),
+        phi::errors::InvalidArgument("The argument index is out of range"));
     auto x = args[n].as_tensor();
     CHECK(x);
     return x->shape;