PaddlePaddle
diff --git a/‎paddle/cinn/hlir/pass/alterlayout.cc
Copy file name to clipboard
+62-16Lines changed: 62 additions & 16 deletions b/‎paddle/cinn/hlir/pass/alterlayout.cc
Copy file name to clipboard
+62-16Lines changed: 62 additions & 16 deletions
diff --git a/‎paddle/cinn/hlir/pass/check_fusion_accuracy_pass.cc
Copy file name to clipboard
+5-3Lines changed: 5 additions & 3 deletions b/‎paddle/cinn/hlir/pass/check_fusion_accuracy_pass.cc
Copy file name to clipboard
+5-3Lines changed: 5 additions & 3 deletions
diff --git a/‎paddle/cinn/hlir/pass/check_fusion_accuracy_pass_test.cc
Copy file name to clipboard
+81-17Lines changed: 81 additions & 17 deletions b/‎paddle/cinn/hlir/pass/check_fusion_accuracy_pass_test.cc
Copy file name to clipboard
+81-17Lines changed: 81 additions & 17 deletions
diff --git a/‎paddle/cinn/hlir/pass/constant_folding_pass_util.cc
Copy file name to clipboard
+5-2Lines changed: 5 additions & 2 deletions b/‎paddle/cinn/hlir/pass/constant_folding_pass_util.cc
Copy file name to clipboard
+5-2Lines changed: 5 additions & 2 deletions
@@ -20,7 +20,7 @@
 #include "paddle/cinn/hlir/pe/schedule.h"
 #include "paddle/cinn/ir/layout.h"
 #include "paddle/cinn/utils/string.h"
-
+#include "paddle/common/enforce.h"
 namespace cinn {
 namespace hlir {
 namespace pass {
@@ -119,10 +119,26 @@ std::vector<framework::shape_t> UpdateInferInfos(
   CHECK(!infertypes.empty()) << node->op()->name << " finds no infertype";
   CHECK(!inferlayouts.empty()) << node->op()->name << " finds no inferlayout";
   auto outlinks = node->outlinks_in_order();
-  CHECK_EQ(infershapes.size(), infertypes.size());
-  CHECK_EQ(inferlayouts.size(), 2U);
-  CHECK_EQ(infertypes.size(), inferlayouts[0].size());
-  CHECK_EQ(outlinks.size(), infershapes.size());
+  PADDLE_ENFORCE_EQ(
+      infershapes.size(),
+      infertypes.size(),
+      phi::errors::InvalidArgument(
+          "The size of infershapes and infertypes should be equal"));
+  PADDLE_ENFORCE_EQ(inferlayouts.size(),
+                    2U,
+                    phi::errors::InvalidArgument(
+                        "The size of inferlayouts should be 2, but got %d",
+                        inferlayouts.size()));
+  PADDLE_ENFORCE_EQ(
+      infertypes.size(),
+      inferlayouts[0].size(),
+      phi::errors::InvalidArgument(
+          "The size of infertypes and inferlayouts[0] should be equal"));
+  PADDLE_ENFORCE_EQ(
+      outlinks.size(),
+      infershapes.size(),
+      phi::errors::InvalidArgument(
+          "The size of outlinks and infershapes should be equal"));
 
   for (int i = 0; i < outlinks.size(); i++) {
     auto* sink = outlinks[i]->sink();
@@ -181,7 +197,11 @@ void AlterLayoutPass(Graph* graph) {
               node->attrs.attr_store.at("dilation"));
         }
         const auto& conv_inlinks = node->inlinks_in_order();
-        CHECK_EQ(conv_inlinks.size(), 2U) << "conv2d should have 2 inputs";
+        PADDLE_ENFORCE_EQ(conv_inlinks.size(),
+                          2U,
+                          phi::errors::InvalidArgument(
+                              "conv2d should have 2 inputs, but got %d",
+                              conv_inlinks.size()));
         std::vector<std::vector<int>> inputs_shape;
         for (auto& link : conv_inlinks) {
           auto* source = link->source();
@@ -231,8 +251,11 @@ void AlterLayoutPass(Graph* graph) {
             input_nodes.push_back(source);
           }
           // get new layout: ic_bn, oc_bn
-          CHECK_EQ(input_nodes.size(), 2U)
-              << "conv2d should have 2 input nodes";
+          PADDLE_ENFORCE_EQ(input_nodes.size(),
+                            2U,
+                            phi::errors::InvalidArgument(
+                                "conv2d should have 2 input nodes, but got %d",
+                                input_nodes.size()));
           auto* input_node = input_nodes[0];
           auto* weight_node = input_nodes[1];
           CHECK(shape_dict.count(input_node->id()))
@@ -347,8 +370,11 @@ void AlterLayoutPass(Graph* graph) {
             conv2d_NCHWc_inputtypes.push_back(trans_out_dtypes);
             conv2d_NCHWc_inputlayouts.push_back(dst_input_layout);
           } else {
-            CHECK_EQ(input_shape.size(), 5U)
-                << "conv2d_NCHWc op's input shape dim should be 5";
+            PADDLE_ENFORCE_EQ(
+                input_shape.size(),
+                5U,
+                phi::errors::InvalidArgument(
+                    "conv2d_NCHWc op's input shape dim should be 5"));
             conv2d_NCHWc_inputshapes.push_back(input_shape);
             conv2d_NCHWc_inputtypes.push_back(input_type);
             CHECK(layout_dict.count(input_node->id()))
@@ -395,8 +421,11 @@ void AlterLayoutPass(Graph* graph) {
             conv2d_NCHWc_inputtypes.push_back(trans_out_dtypes);
             conv2d_NCHWc_inputlayouts.push_back(dst_kernel_layout);
           } else {
-            CHECK_EQ(weight_shape.size(), 6U)
-                << weight_node->id() << " shape dim should be 6";
+            PADDLE_ENFORCE_EQ(
+                weight_shape.size(),
+                6U,
+                phi::errors::InvalidArgument(
+                    "conv2d_NCHWc op's weight shape dim should be 6"));
             conv2d_NCHWc_inputshapes.push_back(weight_shape);
             conv2d_NCHWc_inputtypes.push_back(weight_type);
             CHECK(layout_dict.count(weight_node->id()))
@@ -477,12 +506,29 @@ void AlterLayoutPass(Graph* graph) {
               input_shapes, input_layouts, node->attrs, graph->target_);
           // if input inferred layouts is different from original's, expand dims
           // or do transformation.
-          CHECK_EQ(inferlayouts.size(), 2U);
+          PADDLE_ENFORCE_EQ(
+              inferlayouts.size(),
+              2U,
+              phi::errors::InvalidArgument(
+                  "The size of inferlayouts should be 2, but got %d",
+                  inferlayouts.size()));
           auto new_input_layouts = inferlayouts[1];
           auto inlinks = node->inlinks_in_order();
-          CHECK_EQ(input_layouts.size(), inlinks.size());
-          CHECK_EQ(input_layouts.size(), new_input_layouts.size());
-          CHECK_EQ(input_layouts.size(), input_shapes.size());
+          PADDLE_ENFORCE_EQ(
+              input_layouts.size(),
+              inlinks.size(),
+              phi::errors::InvalidArgument(
+                  "The size of input_layouts and inlinks should be equal"));
+          PADDLE_ENFORCE_EQ(input_layouts.size(),
+                            new_input_layouts.size(),
+                            phi::errors::InvalidArgument(
+                                "The size of input_layouts and "
+                                "new_input_layouts should be equal"));
+          PADDLE_ENFORCE_EQ(
+              input_layouts.size(),
+              input_shapes.size(),
+              phi::errors::InvalidArgument("The size of input_layouts and "
+                                           "input_shapes should be equal"));
           bool reset_axis = false;
           for (int i = 0; i < inlinks.size(); i++) {
             if (input_layouts[i] != new_input_layouts[i]) {
 
@@ -27,7 +27,7 @@
 #include "paddle/cinn/hlir/framework/visualize_helper.h"
 #include "paddle/cinn/hlir/pass/fusion_helper_base.h"
 #include "paddle/cinn/runtime/custom_function.h"
-
+#include "paddle/common/enforce.h"
 namespace cinn::hlir::pass {
 
 using framework::Graph;
@@ -529,8 +529,10 @@ std::vector<Node*> CheckFusionAccuracyPass::TopologicalOrder(
     }
   }
 
-  CHECK_EQ(ordered_nodes.size(), nodes.size())
-      << "There has circle in group! Please check.";
+  PADDLE_ENFORCE_EQ(
+      ordered_nodes.size(),
+      nodes.size(),
+      phi::errors::InvalidArgument("There has circle in group! Please check."));
 
   return ordered_nodes;
 }
 
@@ -19,7 +19,7 @@
 
 #include "paddle/cinn/common/target.h"
 #include "paddle/cinn/frontend/decomposer/test_helper.h"
-
+#include "paddle/common/enforce.h"
 namespace cinn::frontend {
 
 using hlir::framework::Graph;
@@ -96,7 +96,11 @@ TEST(CheckFusionAccuracyPass, ElementWise_Fusion) {
   VLOG(1) << "After CheckFusionAccuracyPass:\n"
           << graph->DebugGroupedGraph(std::unordered_set<std::string>{});
 
-  CHECK_EQ(graph->fusion_groups.size(), group_size_after);
+  PADDLE_ENFORCE_EQ(graph->fusion_groups.size(),
+                    group_size_after,
+                    phi::errors::InvalidArgument(
+                        "The number of fusion groups is not equal to the "
+                        "number of groups after the pass."));
 
   RunTest(target, graph, {"A", "B", "C", "D"});
 }
@@ -134,7 +138,11 @@ TEST(CheckFusionAccuracyPass, ElementWise_Fusion_1) {
   VLOG(1) << "After CheckFusionAccuracyPass:\n"
           << graph->DebugGroupedGraph(std::unordered_set<std::string>{});
 
-  CHECK_EQ(graph->fusion_groups.size(), group_size_after);
+  PADDLE_ENFORCE_EQ(graph->fusion_groups.size(),
+                    group_size_after,
+                    phi::errors::InvalidArgument(
+                        "The number of fusion groups is not equal to the "
+                        "number of groups after the pass."));
 
   RunTest(target, graph, {"A", "B", "C", "D"});
 }
@@ -175,7 +183,11 @@ TEST(CheckFusionAccuracyPass, ElementWise_Fusion_2) {
   VLOG(1) << "After CheckFusionAccuracyPass:\n"
           << graph->DebugGroupedGraph(std::unordered_set<std::string>{});
 
-  CHECK_EQ(graph->fusion_groups.size(), group_size_after);
+  PADDLE_ENFORCE_EQ(graph->fusion_groups.size(),
+                    group_size_after,
+                    phi::errors::InvalidArgument(
+                        "The number of fusion groups is not equal to the "
+                        "number of groups after the pass."));
 
   RunTest(target, graph, {"A", "B", "C", "D", "E", "F"});
 }
@@ -216,7 +228,11 @@ TEST(CheckFusionAccuracyPass, ElementWise_Fusion_3) {
   VLOG(1) << "After CheckFusionAccuracyPass:\n"
           << graph->DebugGroupedGraph(std::unordered_set<std::string>{});
 
-  CHECK_EQ(graph->fusion_groups.size(), group_size_after);
+  PADDLE_ENFORCE_EQ(graph->fusion_groups.size(),
+                    group_size_after,
+                    phi::errors::InvalidArgument(
+                        "The number of fusion groups is not equal to the "
+                        "number of groups after the pass."));
 
   RunTest(target, graph, {"A", "B", "C", "D", "E", "F"});
 }
@@ -257,7 +273,11 @@ TEST(CheckFusionAccuracyPass, ElementWise_Fusion_4) {
   VLOG(1) << "After CheckFusionAccuracyPass:\n"
           << graph->DebugGroupedGraph(std::unordered_set<std::string>{});
 
-  CHECK_EQ(graph->fusion_groups.size(), group_size_after);
+  PADDLE_ENFORCE_EQ(graph->fusion_groups.size(),
+                    group_size_after,
+                    phi::errors::InvalidArgument(
+                        "The number of fusion groups is not equal to the "
+                        "number of groups after the pass."));
 
   RunTest(target, graph, {"A", "B", "C", "D", "E", "F"});
 }
@@ -291,7 +311,11 @@ TEST(CheckFusionAccuracyPass, ElementWise_Fusion_5) {
   VLOG(1) << "After CheckFusionAccuracyPass:\n"
           << graph->DebugGroupedGraph(std::unordered_set<std::string>{});
 
-  CHECK_EQ(graph->fusion_groups.size(), group_size_after);
+  PADDLE_ENFORCE_EQ(graph->fusion_groups.size(),
+                    group_size_after,
+                    phi::errors::InvalidArgument(
+                        "The number of fusion groups is not equal to the "
+                        "number of groups after the pass."));
 
   RunTest(target, graph, {"A", "B"});
 }
@@ -328,7 +352,11 @@ TEST(CheckFusionAccuracyPass, Broadcast_Test_0) {
   VLOG(1) << "After CheckFusionAccuracyPass:\n"
           << graph->DebugGroupedGraph(std::unordered_set<std::string>{});
 
-  CHECK_EQ(graph->fusion_groups.size(), group_size_after);
+  PADDLE_ENFORCE_EQ(graph->fusion_groups.size(),
+                    group_size_after,
+                    phi::errors::InvalidArgument(
+                        "The number of fusion groups is not equal to the "
+                        "number of groups after the pass."));
 
   RunTest(target, graph, {"A", "B", "C", "D"});
 }
@@ -365,7 +393,11 @@ TEST(CheckFusionAccuracyPass, Broadcast_Test_2) {
   VLOG(1) << "After CheckFusionAccuracyPass:\n"
           << graph->DebugGroupedGraph(std::unordered_set<std::string>{});
 
-  CHECK_EQ(graph->fusion_groups.size(), group_size_after);
+  PADDLE_ENFORCE_EQ(graph->fusion_groups.size(),
+                    group_size_after,
+                    phi::errors::InvalidArgument(
+                        "The number of fusion groups is not equal to the "
+                        "number of groups after the pass."));
 
   RunTest(target, graph, {"A", "B", "C", "D"});
 }
@@ -404,7 +436,11 @@ TEST(CheckFusionAccuracyPass, Broadcast_Test_4) {
   VLOG(1) << "After CheckFusionAccuracyPass:\n"
           << graph->DebugGroupedGraph(std::unordered_set<std::string>{});
 
-  CHECK_EQ(graph->fusion_groups.size(), group_size_after);
+  PADDLE_ENFORCE_EQ(graph->fusion_groups.size(),
+                    group_size_after,
+                    phi::errors::InvalidArgument(
+                        "The number of fusion groups is not equal to the "
+                        "number of groups after the pass."));
 
   RunTest(target, graph, {"A", "B", "C", "D", "E"});
 }
@@ -443,7 +479,11 @@ TEST(CheckFusionAccuracyPass, Broadcast_Test_5) {
   VLOG(1) << "After CheckFusionAccuracyPass:\n"
           << graph->DebugGroupedGraph(std::unordered_set<std::string>{});
 
-  CHECK_EQ(graph->fusion_groups.size(), group_size_after);
+  PADDLE_ENFORCE_EQ(graph->fusion_groups.size(),
+                    group_size_after,
+                    phi::errors::InvalidArgument(
+                        "The number of fusion groups is not equal to the "
+                        "number of groups after the pass."));
 
   RunTest(target, graph, {"A", "B", "C", "D", "E"});
 }
@@ -479,7 +519,11 @@ TEST(CheckFusionAccuracyPass, Reduce_Test_0) {
   VLOG(1) << "After CheckFusionAccuracyPass:\n"
           << graph->DebugGroupedGraph(std::unordered_set<std::string>{});
 
-  CHECK_EQ(graph->fusion_groups.size(), group_size_after);
+  PADDLE_ENFORCE_EQ(graph->fusion_groups.size(),
+                    group_size_after,
+                    phi::errors::InvalidArgument(
+                        "The number of fusion groups is not equal to the "
+                        "number of groups after the pass."));
 
   RunTest(target, graph, {"A", "B"});
 }
@@ -514,7 +558,11 @@ TEST(CheckFusionAccuracyPass, Reduce_Test_1) {
   VLOG(1) << "After CheckFusionAccuracyPass:\n"
           << graph->DebugGroupedGraph(std::unordered_set<std::string>{});
 
-  CHECK_EQ(graph->fusion_groups.size(), group_size_after);
+  PADDLE_ENFORCE_EQ(graph->fusion_groups.size(),
+                    group_size_after,
+                    phi::errors::InvalidArgument(
+                        "The number of fusion groups is not equal to the "
+                        "number of groups after the pass."));
 
   RunTest(target, graph, {"A", "B"});
 }
@@ -552,7 +600,11 @@ TEST(CheckFusionAccuracyPass, Reduce_Test_2) {
   VLOG(1) << "After CheckFusionAccuracyPass:\n"
           << graph->DebugGroupedGraph(std::unordered_set<std::string>{});
 
-  CHECK_EQ(graph->fusion_groups.size(), group_size_after);
+  PADDLE_ENFORCE_EQ(graph->fusion_groups.size(),
+                    group_size_after,
+                    phi::errors::InvalidArgument(
+                        "The number of fusion groups is not equal to the "
+                        "number of groups after the pass."));
 
   RunTest(target, graph, {"A", "B", "C"});
 }
@@ -590,7 +642,11 @@ TEST(CheckFusionAccuracyPass, Reduce_Test_3) {
   VLOG(1) << "After CheckFusionAccuracyPass:\n"
           << graph->DebugGroupedGraph(std::unordered_set<std::string>{});
 
-  CHECK_EQ(graph->fusion_groups.size(), group_size_after);
+  PADDLE_ENFORCE_EQ(graph->fusion_groups.size(),
+                    group_size_after,
+                    phi::errors::InvalidArgument(
+                        "The number of fusion groups is not equal to the "
+                        "number of groups after the pass."));
 
   RunTest(target, graph, {"A", "B", "C", "D"});
 }
@@ -629,7 +685,11 @@ TEST(CheckFusionAccuracyPass, Reduce_Test_4) {
   VLOG(1) << "After CheckFusionAccuracyPass:\n"
           << graph->DebugGroupedGraph(std::unordered_set<std::string>{});
 
-  CHECK_EQ(graph->fusion_groups.size(), group_size_after);
+  PADDLE_ENFORCE_EQ(graph->fusion_groups.size(),
+                    group_size_after,
+                    phi::errors::InvalidArgument(
+                        "The number of fusion groups is not equal to the "
+                        "number of groups after the pass."));
 
   RunTest(target, graph, {"A", "B", "C", "D"});
 }
@@ -665,7 +725,11 @@ TEST(CheckFusionAccuracyPass, Reduce_Test_5) {
   VLOG(1) << "After CheckFusionAccuracyPass:\n"
           << graph->DebugGroupedGraph(std::unordered_set<std::string>{});
 
-  CHECK_EQ(graph->fusion_groups.size(), group_size_after);
+  PADDLE_ENFORCE_EQ(graph->fusion_groups.size(),
+                    group_size_after,
+                    phi::errors::InvalidArgument(
+                        "The number of fusion groups is not equal to the "
+                        "number of groups after the pass."));
 
   RunTest(target, graph, {"A", "B"});
 }
 
@@ -21,7 +21,7 @@
 #include "paddle/cinn/hlir/op/op_util.h"
 #include "paddle/cinn/utils/functional.h"
 #include "paddle/cinn/utils/type_defs.h"
-
+#include "paddle/common/enforce.h"
 namespace cinn {
 namespace hlir {
 namespace pass {
@@ -238,7 +238,10 @@ void fold_expand_dims_fill_constant(const FusionHelperBase* helper,
   // [0, total_size-1]. check axes can't repeat.
   std::sort(axes.begin(), axes.end(), std::less<int>());
   for (int idx = 0; idx < axes_size - 1; ++idx) {
-    CHECK_NE(axes[idx], axes[idx + 1]);
+    PADDLE_ENFORCE_NE(axes[idx],
+                      axes[idx + 1],
+                      phi::errors::InvalidArgument(
+                          "The axes of expand_dims should not repeat."));
   }
   // insert 1 to new shape.
   std::vector<int> n_shape(total_size, 1);
Original file line number	Diff line number	Diff line change
`@@ -27,7 +27,7 @@`
`27`	`27`	`#include "paddle/cinn/hlir/framework/visualize_helper.h"`
`28`	`28`	`#include "paddle/cinn/hlir/pass/fusion_helper_base.h"`
`29`	`29`	`#include "paddle/cinn/runtime/custom_function.h"`
`30`		`-`
	`30`	`+#include "paddle/common/enforce.h"`
`31`	`31`	`namespace cinn::hlir::pass {`
`32`	`32`
`33`	`33`	`using framework::Graph;`
`@@ -529,8 +529,10 @@ std::vector<Node*> CheckFusionAccuracyPass::TopologicalOrder(`
`529`	`529`	`}`
`530`	`530`	`}`
`531`	`531`
`532`		`- CHECK_EQ(ordered_nodes.size(), nodes.size())`
`533`		`- << "There has circle in group! Please check.";`
	`532`	`+ PADDLE_ENFORCE_EQ(`
	`533`	`+ ordered_nodes.size(),`
	`534`	`+ nodes.size(),`
	`535`	`+ phi::errors::InvalidArgument("There has circle in group! Please check."));`
`534`	`536`
`535`	`537`	`return ordered_nodes;`
`536`	`538`	`}`