PaddlePaddle
diff --git a/‎paddle/cinn/hlir/op/broadcast.cc
Copy file name to clipboard
+35-43Lines changed: 35 additions & 43 deletions b/‎paddle/cinn/hlir/op/broadcast.cc
Copy file name to clipboard
+35-43Lines changed: 35 additions & 43 deletions
diff --git a/‎paddle/cinn/hlir/op/contrib/gather_nd.cc
Copy file name to clipboard
+27-40Lines changed: 27 additions & 40 deletions b/‎paddle/cinn/hlir/op/contrib/gather_nd.cc
Copy file name to clipboard
+27-40Lines changed: 27 additions & 40 deletions
diff --git a/‎paddle/cinn/hlir/op/contrib/logical_right_shift.cc
Copy file name to clipboard
+2-6Lines changed: 2 additions & 6 deletions b/‎paddle/cinn/hlir/op/contrib/logical_right_shift.cc
Copy file name to clipboard
+2-6Lines changed: 2 additions & 6 deletions
diff --git a/‎paddle/cinn/hlir/op/contrib/lookup_table.cc
Copy file name to clipboard
+3-5Lines changed: 3 additions & 5 deletions b/‎paddle/cinn/hlir/op/contrib/lookup_table.cc
Copy file name to clipboard
+3-5Lines changed: 3 additions & 5 deletions
diff --git a/‎paddle/cinn/hlir/op/contrib/one_hot.cc
Copy file name to clipboard
100755100644
+2-6Lines changed: 2 additions & 6 deletions b/‎paddle/cinn/hlir/op/contrib/one_hot.cc
Copy file name to clipboard
100755100644
+2-6Lines changed: 2 additions & 6 deletions
diff --git a/‎paddle/cinn/hlir/op/contrib/reciprocal.cc
Copy file name to clipboard
+5-11Lines changed: 5 additions & 11 deletions b/‎paddle/cinn/hlir/op/contrib/reciprocal.cc
Copy file name to clipboard
+5-11Lines changed: 5 additions & 11 deletions
diff --git a/‎paddle/cinn/hlir/op/contrib/resize.cc
Copy file name to clipboard
+2-5Lines changed: 2 additions & 5 deletions b/‎paddle/cinn/hlir/op/contrib/resize.cc
Copy file name to clipboard
+2-5Lines changed: 2 additions & 5 deletions
@@ -60,37 +60,34 @@ std::shared_ptr<OpStrategy> StrategyForBroadcast(
                           const ir::Tensor &B,
                           const std::string &output_name,
                           const Expr &axis)) {
-  framework::CINNCompute binary_compute([=](lang::Args args,
-                                            lang::RetValue *ret) {
-    CHECK(!args.empty()) << "The input argument of " << op_name
-                         << " compute is empty! Please check.";
-    CINNValuePack pack_args = args[0];
-    CHECK_GE(pack_args.size(), 2U)
-        << "at least 2 input tensors for " << op_name << " compute";
-    std::string tensor_name = UniqName(op_name + "_Out");
-    if (FLAGS_cinn_ir_schedule) {
-      CHECK_GE(pack_args.size(), 3U) << op_name << " 's input is not enough!";
-      CHECK(pack_args[2].is_string());
-      tensor_name = pack_args[2].operator std::string();
-    }
-    Expr A_expr = pack_args[0];
-    Expr B_expr = pack_args[1];
-    CHECK(A_expr.as_tensor());
-    CHECK(B_expr.as_tensor());
-    ir::Tensor A = A_expr.as_tensor_ref();
-    ir::Tensor B = B_expr.as_tensor_ref();
-    Expr axis;
-    bool trans_a;
-    for (auto &iter : attrs.attr_store) {
-      if (iter.first == "axis") {
-        axis = Expr(absl::get<int>(iter.second));
-        break;
-      }
-    }
-    auto out = pe_func(A, B, tensor_name, axis);
-    auto stages = CreateStages({A, B, out});
-    *ret = CINNValuePack{{CINNValue(Expr(out.get())), CINNValue(stages)}};
-  });
+  framework::CINNCompute binary_compute(
+      [=](lang::Args args, lang::RetValue *ret) {
+        CHECK(!args.empty()) << "The input argument of " << op_name
+                             << " compute is empty! Please check.";
+        CINNValuePack pack_args = args[0];
+        CHECK_GE(pack_args.size(), 2U)
+            << "at least 2 input tensors for " << op_name << " compute";
+        CHECK_GE(pack_args.size(), 3U) << op_name << " 's input is not enough!";
+        CHECK(pack_args[2].is_string());
+        std::string tensor_name = pack_args[2].operator std::string();
+        Expr A_expr = pack_args[0];
+        Expr B_expr = pack_args[1];
+        CHECK(A_expr.as_tensor());
+        CHECK(B_expr.as_tensor());
+        ir::Tensor A = A_expr.as_tensor_ref();
+        ir::Tensor B = B_expr.as_tensor_ref();
+        Expr axis;
+        bool trans_a;
+        for (auto &iter : attrs.attr_store) {
+          if (iter.first == "axis") {
+            axis = Expr(absl::get<int>(iter.second));
+            break;
+          }
+        }
+        auto out = pe_func(A, B, tensor_name, axis);
+        auto stages = CreateStages({A, B, out});
+        *ret = CINNValuePack{{CINNValue(Expr(out.get())), CINNValue(stages)}};
+      });
 
   auto strategy = std::make_shared<framework::OpStrategy>();
   strategy->AddImpl(binary_compute,
@@ -198,12 +195,10 @@ std::shared_ptr<OpStrategy> StrategyForBroadcastTo(
     CINNValuePack pack_args = args[0];
     CHECK(!pack_args.empty())
         << "The input tensors of broadcast_to compute is empty! Please check.";
-    std::string tensor_name = UniqName("broadcast_to_Out");
-    if (FLAGS_cinn_ir_schedule) {
-      CHECK_GE(pack_args.size(), 2U);
-      CHECK(pack_args[1].is_string());
-      tensor_name = pack_args[1].operator std::string();
-    }
+    CHECK_GE(pack_args.size(), 2U);
+    CHECK(pack_args[1].is_string());
+    std::string tensor_name = pack_args[1].operator std::string();
+
     Expr A_expr = pack_args[0];
     CHECK(A_expr.as_tensor());
     ir::Tensor A = A_expr.as_tensor_ref();
@@ -323,12 +318,9 @@ std::shared_ptr<OpStrategy> StrategyForIsClose(
         CINNValuePack pack_args = args[0];
         int input_size = pack_args.size();
 
-        std::string tensor_name = UniqName("IsClose_output");
-        if (FLAGS_cinn_ir_schedule) {
-          // the last pack argument is the output tensor name
-          tensor_name = pack_args.back().operator std::string();
-          --input_size;
-        }
+        // the last pack argument is the output tensor name
+        std::string tensor_name = pack_args.back().operator std::string();
+        --input_size;
         CHECK_EQ(input_size, 2)
             << "The input number of isclose should be 2, but here "
             << input_size << "! Please check.";
 
@@ -114,11 +114,8 @@ std::shared_ptr<framework::OpStrategy> StrategyForGatherNd(
         VLOG(3) << "x shape: " << utils::Join(tensor_x->shape, ", ")
                 << ", index shape: " << utils::Join(tensor_index->shape, ", ")
                 << ", output_shapes: " << utils::Join(output_shapes[0], ", ");
-        std::string tensor_name = UniqName("GatherNd_out");
-        if (FLAGS_cinn_ir_schedule) {
-          CHECK_EQ(pack_args.size(), 3U);
-          tensor_name = pack_args[2].operator std::string();
-        }
+        CHECK_EQ(pack_args.size(), 3U);
+        std::string tensor_name = pack_args[2].operator std::string();
         ir::Tensor out = GatherNd(tensor_x, tensor_index, tensor_name);
         std::vector<CINNValue> res;
         stages->InsertLazily(out);
@@ -131,44 +128,34 @@ std::shared_ptr<framework::OpStrategy> StrategyForGatherNd(
 
   framework::CINNSchedule gather_nd_schedule([=](lang::Args args,
                                                  lang::RetValue *ret) {
-    if (FLAGS_cinn_ir_schedule) {
-      CHECK(!args.empty()) << "The input argument of gather_nd_schedule is "
-                              "empty! Please check.\n";
-      common::CINNValuePack arg_pack = args[0];
-      std::vector<Expr> vec_ast;
-      for (int i = 0; i < arg_pack.size(); i++) {
-        if (arg_pack[i].is_expr()) {
-          Expr temp = arg_pack[i];
-          vec_ast.emplace_back(temp);
-        }
+    CHECK(!args.empty()) << "The input argument of gather_nd_schedule is "
+                            "empty! Please check.\n";
+    common::CINNValuePack arg_pack = args[0];
+    std::vector<Expr> vec_ast;
+    for (int i = 0; i < arg_pack.size(); i++) {
+      if (arg_pack[i].is_expr()) {
+        Expr temp = arg_pack[i];
+        vec_ast.emplace_back(temp);
       }
-      CHECK(!vec_ast.empty());
-      ir::ModuleExpr mod_expr(vec_ast);
-      ir::IRSchedule ir_sch(mod_expr);
-      ir_sch.MergeExprs();
-      int64_t prod_size = std::accumulate(output_shapes[0].begin(),
-                                          output_shapes[0].end(),
-                                          1,
-                                          std::multiplies<int>());
-      if (prod_size > 1) {
-        if (target.arch == Target::Arch::NVGPU) {
-          pe::IRCudaScheduleInjective(ir_sch, output_shapes.front(), target);
-        } else if (target.arch == Target::Arch::X86) {
-          pe::IRScheduleInjectiveCPU(
-              ir_sch, output_shapes.front(), target, true);
-        }
+    }
+    CHECK(!vec_ast.empty());
+    ir::ModuleExpr mod_expr(vec_ast);
+    ir::IRSchedule ir_sch(mod_expr);
+    ir_sch.MergeExprs();
+    int64_t prod_size = std::accumulate(output_shapes[0].begin(),
+                                        output_shapes[0].end(),
+                                        1,
+                                        std::multiplies<int>());
+    if (prod_size > 1) {
+      if (target.arch == Target::Arch::NVGPU) {
+        pe::IRCudaScheduleInjective(ir_sch, output_shapes.front(), target);
+      } else if (target.arch == Target::Arch::X86) {
+        pe::IRScheduleInjectiveCPU(ir_sch, output_shapes.front(), target, true);
       }
-      std::vector<common::CINNValue> res{
-          common::CINNValue(ir_sch.GetModule().GetExprs().at(0))};
-      *ret = common::CINNValuePack{res};
-    } else {
-      CHECK(!args.empty()) << "The input argument of gather_nd_schedule is "
-                              "empty! Please check.\n";
-      CINNValuePack arg_pack = args[0];
-      Expr out = arg_pack[0];
-      CHECK(out.as_tensor());
-      *ret = arg_pack;
     }
+    std::vector<common::CINNValue> res{
+        common::CINNValue(ir_sch.GetModule().GetExprs().at(0))};
+    *ret = common::CINNValuePack{res};
   });
 
   auto strategy = std::make_shared<framework::OpStrategy>();
 
@@ -105,12 +105,8 @@ std::shared_ptr<OpStrategy> StrategyForLogicalRightShift(
         ir::Tensor A = A_expr.as_tensor_ref();
         ir::Tensor B = B_expr.as_tensor_ref();
 
-        std::string tensor_name = UniqName("T_LogicalRightShift_out");
-
-        if (FLAGS_cinn_ir_schedule) {
-          CHECK_EQ(pack_args.size(), 3U);
-          tensor_name = pack_args[2].operator std::string();
-        }
+        CHECK_EQ(pack_args.size(), 3U);
+        std::string tensor_name = pack_args[2].operator std::string();
 
         auto out = LogicalRightShift(A, B, target, tensor_name);
         auto stages = CreateStages({out});
 
@@ -106,11 +106,9 @@ std::shared_ptr<framework::OpStrategy> StrategyForLookupTable(
     VLOG(3) << "A shape: " << utils::Join(tensor_A->shape, ", ")
             << ", B shape: " << utils::Join(tensor_B->shape, ", ")
             << ", output_shapes: " << utils::Join(output_shapes[0], ", ");
-    std::string tensor_name = UniqName("LookupTable_out");
-    if (FLAGS_cinn_ir_schedule) {
-      CHECK_EQ(pack_args.size(), 3U);
-      tensor_name = pack_args[2].operator std::string();
-    }
+    CHECK_EQ(pack_args.size(), 3U);
+    std::string tensor_name = pack_args[2].operator std::string();
+
     ir::Tensor out = LookupTable(tensor_A, tensor_B, padding_idx, tensor_name);
     std::vector<CINNValue> res;
     stages->InsertLazily(out);
 
@@ -194,12 +194,8 @@ std::shared_ptr<framework::OpStrategy> StrategyForOneHot(
     ir::Tensor on_value = on_value_expr.as_tensor_ref();
     ir::Tensor off_value = off_value_expr.as_tensor_ref();
 
-    std::string tensor_name = common::UniqName("T_OneHot_out");
-
-    if (FLAGS_cinn_ir_schedule) {
-      CHECK_EQ(pack_args.size(), 4U);
-      tensor_name = pack_args[3].operator std::string();
-    }
+    CHECK_EQ(pack_args.size(), 4U);
+    std::string tensor_name = pack_args[3].operator std::string();
 
     ir::Tensor out = OneHot(indices,
                             on_value,
 
@@ -94,13 +94,9 @@ std::shared_ptr<OpStrategy> StrategyForReciprocal(
         CHECK(!pack_args.empty())
             << "at least one input tensor for " << op_name << " compute\n";
 
-        std::string tensor_name = UniqName("Reciprocal_out");
-
-        if (FLAGS_cinn_ir_schedule) {
-          CHECK_EQ(pack_args.size(), 2);
-          CHECK(pack_args[1].is_string());
-          tensor_name = pack_args[1].operator std::string();
-        }
+        CHECK_EQ(pack_args.size(), 2);
+        CHECK(pack_args[1].is_string());
+        std::string tensor_name = pack_args[1].operator std::string();
 
         Expr A = pack_args[0];
         CHECK(A.as_tensor());
@@ -110,10 +106,8 @@ std::shared_ptr<OpStrategy> StrategyForReciprocal(
         VLOG(3) << "A shape: " << utils::Join(tensor_A->shape, ", ")
                 << ", output_shapes: " << utils::Join(output_shapes[0], ", ");
 
-        if (FLAGS_cinn_ir_schedule) {
-          CHECK_EQ(pack_args.size(), 2U);
-          tensor_name = pack_args[1].operator std::string();
-        }
+        CHECK_EQ(pack_args.size(), 2U);
+        tensor_name = pack_args[1].operator std::string();
 
         ir::Tensor out = Reciprocal(tensor_A, tensor_name);
         std::vector<CINNValue> res;
 
@@ -207,12 +207,9 @@ std::shared_ptr<framework::OpStrategy> StrategyForResize(
     auto tensor_A = A.as_tensor_ref();
     VLOG(3) << "A shape: " << utils::Join(tensor_A->shape, ", ")
             << ", output_shapes: " << utils::Join(output_shapes[0], ", ");
-    std::string tensor_name = common::UniqName("T_Resize_out");
 
-    if (FLAGS_cinn_ir_schedule) {
-      CHECK_EQ(pack_args.size(), 2U);
-      tensor_name = pack_args[1].operator std::string();
-    }
+    CHECK_EQ(pack_args.size(), 2U);
+    std::string tensor_name = pack_args[1].operator std::string();
 
     ir::Tensor out = Resize(tensor_A, target, out_shape, mode, tensor_name);