Merge branch 'develop' of https://github.com/PaddlePaddle/Paddle into cinn_3_3

Author: Luohongzhige

CMakeLists.txt

@@ -65,6 +65,7 @@ option(WITH_SHARED_PHI "Compile PaddlePaddle with SHARED LIB of PHI" ON)
 option(CINN_WITH_CUDNN "Compile CINN with CUDNN support" ON)
 option(WITH_PIP_CUDA_LIBRARIES
        "Paddle uses the CUDA library provided by NVIDIA" OFF)
+option(WITH_PIP_TENSORRT "Paddle uses the tensorrt provided by NVIDIA" OFF)
 option(WITH_NIGHTLY_BUILD
        "Compile nightly paddle whl package of the develop branch" OFF)
 option(WITH_CPP_TEST "Compile PaddlePaddle skip cpp test" ON)

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;
   }
 

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>());