[CINN] Fixed dynamic arange symbolic values extraction. (#74412)

* [CINN] Fix cinn_op.generate_op attribute storing useless dim_expr

* [CINN] Removed unnecessary VLOGs

* [CINN] Simplify dynamic arange logic and fix bugs.

Author: Enigmatisms

paddle/cinn/hlir/framework/pir/op_lowering_impl.cc

@@ -667,79 +667,6 @@ std::vector<ir::LoweredFunc> OpLowererImpl::DoOpLower(
   return funcs;
 }
 
-/**
- * This function converts pir::Value::defining_op for ir::Tensor::operation
- * Normally, ir::Tensor::operation will only be used to record the name
- * of the compiler-generated var name, which is useless. However, operation
- * has Attributes field, so can be used to record the op info.
- */
-ir::PlaceholderOp* TensorOperationRecording(const ::pir::Value& value) {
-  // TODO(heqianyue): I think this is kinda ugly, since we should manually
-  // specify the rules to convert all the op (and their attribute), yet current
-  // implementation works and can be quickly written.
-  const ::pir::Operation* define_op = value.defining_op();
-  ir::PlaceholderOp* res = nullptr;
-  if (!define_op) return res;
-  res = cinn::common::make_shared<ir::PlaceholderOp>();
-  res->name = define_op->name();
-  // we filter some of the ops, and only record the **needed** attributes
-  if (define_op->name() == "pd_op.full") {
-    auto dtype = define_op->attribute("dtype")
-                     .dyn_cast<paddle::dialect::DataTypeAttribute>()
-                     .data();
-    phi::Scalar data = define_op->attribute("value")
-                           .dyn_cast<paddle::dialect::ScalarAttribute>()
-                           .data();
-    ir::Expr value;
-#define DEFINE_CASE(TypeFlag, Type)    \
-  case phi::DataType::TypeFlag:        \
-    value = ir::Expr(data.to<Type>()); \
-    break;
-    switch (dtype) {
-      DEFINE_CASE(FLOAT32, float)
-      DEFINE_CASE(FLOAT64, double)
-      DEFINE_CASE(INT32, int)
-      DEFINE_CASE(BFLOAT16, float)
-      value->set_type(cinn::common::BFloat16());
-      break;
-      DEFINE_CASE(FLOAT16, float)
-      value->set_type(cinn::common::Float16());
-      break;
-      default:
-        value = ir::Expr(data.to<int64_t>());
-    }
-#undef DEFINE_CASE
-    res->attrs.emplace("value", value);
-  } else if (define_op->name() == "cinn_op.generate_shape") {
-    // pir::Attribute --> symbol::DimExpr --> ir::Expr
-
-    auto ir_dim_expr = [&]() {
-      auto dim_expr_attr = define_op->attribute("output_dim_exprs");
-      auto dim_exprs = dialect::ConvertAttributeToDimExprs(dim_expr_attr);
-
-      PADDLE_ENFORCE_EQ(
-          dim_exprs.has_value(),
-          true,
-          ::common::errors::PreconditionNotMet(
-              "Required success to execute convert attribute to dim exprs."));
-
-      auto expr_vec = dim_exprs.value();
-      PADDLE_ENFORCE_EQ(
-          expr_vec.empty(),
-          false,
-          ::common::errors::PreconditionNotMet(
-              "Generate shape op can not yield empty symbolic shape."));
-      // only the first dim_expr matters for ArangeOp
-      return common::DimExprConverter().ConvertToIrExpr(expr_vec[0]);
-    }();
-    res->attrs.emplace("value", ir_dim_expr);
-  } else {
-    VLOG(6) << "Tensor defining op recording: not currently supported op.";
-    return nullptr;
-  }
-  return res;
-}
-
 ir::Tensor OpLowererImpl::GetTensor(const OpLoweringGroupPtr& group,
                                     const ::pir::Value& value) {
   auto type_info = value.type().dyn_cast<paddle::dialect::DenseTensorType>();
@@ -778,9 +705,6 @@ ir::Tensor OpLowererImpl::GetTensor(const OpLoweringGroupPtr& group,
       tensor->set_value(*tensor_value);
     }
   }
-  if (auto op_ptr = TensorOperationRecording(value)) {
-    tensor->operation = ir::FunctionRef(op_ptr);
-  }
   return tensor;
 }
 

paddle/cinn/hlir/framework/pir/op_lowering_util.cc

@@ -180,8 +180,8 @@ std::unordered_set<::pir::Operation*> GetMasters(
 }
 
 bool IsConstOp(const ::pir::Operation* op) {
-  static std::unordered_set<std::string> const_op_type = {
-      "const_scalar", "fill_constant", "arange"};
+  static std::unordered_set<std::string> const_op_type = {"const_scalar",
+                                                          "fill_constant"};
   return const_op_type.count(CompatibleInfo::OpName(*op));
 }
 

paddle/cinn/hlir/op/elementwise.cc

@@ -1257,16 +1257,12 @@ std::shared_ptr<framework::OpStrategy> StrategyForArangeSymbolic(
     const Target &target) {
   bool all_static = true;
   for (int i = 0; i < 3; i++) {
-    auto op_node = inputs[i]->operation->as<ir::PlaceholderOp>();
-    PADDLE_ENFORCE_NE(
-        op_node,
-        nullptr,
-        ::common::errors::PreconditionNotMet(
-            "The defining op of the input tensor is not set! Please check."));
-    if (op_node->name == "cinn_op.generate_shape") {
-      all_static = false;
-      break;
-    }
+    if (!inputs[i]->value().has_value()) continue;
+    auto input_val = inputs[i]->value().value();
+    if (input_val.empty()) continue;
+    if (input_val[0].is_constant()) continue;
+    all_static = false;
+    break;
   }
   auto attr_store = attrs.attr_store;
   auto dtype =
@@ -1341,15 +1337,22 @@ std::shared_ptr<framework::OpStrategy> StrategyForArangeSymbolic(
                                             "bfloat16 or float16."));
     }
 #undef EXPR_FROM_ATTR
-  } else {  // has dynamic shape, some of the operands come from
-            // cinn_op.generate_shape
-    // in op_lowering_impl.cc, tensor op recorder unified the attribute name
-    start = Expr(
-        inputs[0]->operation->as<ir::PlaceholderOp>()->attrs.at("value").ptr());
-    step = Expr(
-        inputs[2]->operation->as<ir::PlaceholderOp>()->attrs.at("value").ptr());
-    Expr end = Expr(
-        inputs[1]->operation->as<ir::PlaceholderOp>()->attrs.at("value").ptr());
+  } else {
+    for (int i = 0; i < 3; i++) {
+      PADDLE_ENFORCE_EQ(
+          inputs[i]->value().has_value(),
+          true,
+          ::common::errors::InvalidArgument(
+              "The input tensor of dynamic arange should have valid values."));
+      PADDLE_ENFORCE_NE(
+          inputs[i]->value().value().empty(),
+          true,
+          ::common::errors::InvalidArgument(
+              "The tensor value of dynamic arange should not be empty."));
+    }
+    start = inputs[0]->value().value()[0];
+    step = inputs[2]->value().value()[0];
+    Expr end = inputs[1]->value().value()[0];
     auto IrAbs = [=](Expr ir) -> Expr {
       return ir::Call::Make(step.type(), "abs", {ir}, {}, ir::CallType::Extern);
     };