Revert "【CINN】Set index for IrNode (#70208)" (#70427)

* Revert "【CINN】Set index for IrNode (#70208)"

This reverts commit 46b17db.

* fix conflict

* fix conflict

Author: liuruyan

paddle/cinn/common/axis.cc

@@ -68,8 +68,7 @@ std::string axis_name(int level) {
 std::vector<ir::Var> GenDefaultAxis(int naxis) {
   std::vector<ir::Var> axis;
   for (int i = 0; i < naxis; i++) {
-    Var ax(cinn::common::axis_name(i));
-    axis.emplace_back(ax.set_index(true));
+    axis.emplace_back(cinn::common::axis_name(i));
     PADDLE_ENFORCE_EQ(axis.back()->type().valid(),
                       true,
                       ::common::errors::InvalidArgument(
@@ -84,7 +83,7 @@ std::vector<ir::Expr> GenDefaultAxisAsExpr(int naxis) {
   auto vars = GenDefaultAxis(naxis);
   std::vector<Expr> res;
   for (auto& v : vars) {
-    res.push_back(Expr(v.set_index(true)));
+    res.push_back(Expr(v));
   }
   return res;
 }

paddle/cinn/common/cas.cc

@@ -36,7 +36,6 @@ using namespace ir;  // NOLINT
 Expr AutoSimplify(
     const Expr& u,
     const absl::flat_hash_map<std::string, CasInterval>& var_intervals) {
-  bool is_index = u.is_index();
   VLOG(7) << "Begin AutoSimplify: " << u;
   Expr copied = ir::ir_utils::IRCopy(u);
   if (copied.type().is_float()) {
@@ -57,7 +56,7 @@ Expr AutoSimplify(
   copied = CasSimplify(copied, s_var_intervals);
   copied = detail::ConvertCasToCinn(copied);
   VLOG(7) << "End AutoSimplify " << copied;
-  return is_index ? copied.set_index(true) : copied;
+  return copied;
 }
 
 int gcd(int a, int b) {
@@ -626,6 +625,7 @@ Expr CasSimplifyMutator::SimplifySum(Expr u) {
   if (!temp.As<Sum>()) return temp;
 
   operands = temp.As<Sum>()->operands();
+
   auto args = SimplifySumRec(operands);
   if (args.empty()) return make_const(u.type(), 0);
   if (args.size() == 1) return args[0];
@@ -1654,9 +1654,6 @@ Expr ConvertCinnToCAS(Expr expr) {
     void operator()(Expr* expr) { Visit(expr); }
     void Visit(Expr* expr) { ir::IRMutator<>::Visit(expr, expr); }
 
-    // Because indice of `Load` is simplify by IndexExpr, we just skip it.
-    void Visit(const Load* op, Expr* expr) override { return; }
-
    private:
     void Visit(const Add* op, Expr* expr) override {
       auto a = op->a();

paddle/cinn/common/const_fold.h

@@ -107,29 +107,5 @@ inline std::optional<ir::Expr> TryConstFold<ir::Mod>(ir::Expr a, ir::Expr b) {
   return std::nullopt;
 }
 
-template <>
-inline std::optional<ir::Expr> TryConstFold<ir::Min>(ir::Expr a, ir::Expr b) {
-  const ir::IntImm* pa = a.As<ir::IntImm>();
-  const ir::IntImm* pb = b.As<ir::IntImm>();
-  const auto& rtype = a.type();
-  if (pa && pb) {
-    int64_t res = std::min(pa->value, pb->value);
-    return cinn::common::make_shared<ir::IntImm>(rtype, res);
-  }
-  return std::nullopt;
-}
-
-template <>
-inline std::optional<ir::Expr> TryConstFold<ir::Max>(ir::Expr a, ir::Expr b) {
-  const ir::IntImm* pa = a.As<ir::IntImm>();
-  const ir::IntImm* pb = b.As<ir::IntImm>();
-  const auto& rtype = a.type();
-  if (pa && pb) {
-    int64_t res = std::max(pa->value, pb->value);
-    return cinn::common::make_shared<ir::IntImm>(rtype, res);
-  }
-  return std::nullopt;
-}
-
 }  // namespace common
 }  // namespace cinn

paddle/cinn/common/dim_expr_converter.cc

@@ -37,7 +37,7 @@ struct DimExprToIrExprVisitor {
                             dim_expr,
                             /* is_reduce  = */ false,
                             /* is_symbolic_constant = */ true);
-    return x.set_index(true);
+    return x;
   }
 
   ir::Expr operator()(const Negative<DimExpr>& dim_expr) {

paddle/cinn/common/ir_util.cc

@@ -197,9 +197,6 @@ Expr IndiceToAbsOffset(const std::vector<Expr> &shape,
             i,
             shape[i].type()));
 
-    // if(VerifyIndex(shape[i]))shape[i].set_index(true);
-    // if(VerifyIndex(indices[i]))indices[i].set_index(true);
-
     Expr indice_cast = indices[i];
     optim::SimplifyCast(&indice_cast);
     res = RampRelatedAdd(RampRelatedMul(res, shape[i]), indice_cast);
@@ -478,11 +475,10 @@ bool ComparePriority(const ir::IndexExpr &lhs, const ir::IndexExpr &rhs) {
     if (auto rhsVar = rhs.As<ir::_Var_>())
       return std::make_tuple(lhsVar->name.length(), lhsVar->name) <=
              std::make_tuple(rhsVar->name.length(), rhsVar->name);
-
   auto lhsLen = lhs.length();
   auto rhsLen = rhs.length();
   if (lhsLen < rhsLen) return false;
-  // Add < Mul < Div < Mod < Min < Max < Load.
+  // Add < Mul < Div < Mod.
   else if (lhsLen == rhsLen)
     return lhs.node_type() <= rhs.node_type();
   else
@@ -513,10 +509,6 @@ bool IsSumPartialBySymbol(const ir::IndexExpr &expr,
       return IsSumPartialBySymbol(expr.operand(0), symbol);
     }
     case ir::IrNodeTy::Mod:
-    case ir::IrNodeTy::Min:
-    case ir::IrNodeTy::Max:
-    case ir::IrNodeTy::Load:
-    case ir::IrNodeTy::Cast:
       return false;
     default:
       PADDLE_THROW(::common::errors::InvalidArgument(
@@ -594,11 +586,6 @@ bool IsDivisiblieBySymbol(const ir::IndexExpr &expr,
       if (ty != expr.node_type()) return false;
       return IsDivisiblieBySymbol(expr.operand(0), symbol, expr.node_type());
     }
-    case ir::IrNodeTy::Min:
-    case ir::IrNodeTy::Max:
-    case ir::IrNodeTy::Load:
-    case ir::IrNodeTy::Cast:
-      return false;
     default:
       PADDLE_THROW(::common::errors::InvalidArgument(
           "Unsupported type of expr in IsDivisiblieBySymbol which is: %s",

paddle/cinn/common/ir_util.h

@@ -339,13 +339,5 @@ bool ProveDivisible(const ir::IndexExpr &lhs, const ir::IndexExpr &rhs);
 bool IsNegatedIndexExpr(const ir::IndexExpr &candidate,
                         ir::IndexExpr &expr);  // NOLINT
 
-/*!
- * \brief Judge type of `expr` is valid type of `IndexExpr` or not.
- * \param expr The expression to be checked.
- * \return A boolean value indicating whether the type of `expr` is valid
- * IndexExpr type.
- */
-bool VerifyIndex(const ir::Expr &expr);
-
 }  // namespace common
 }  // namespace cinn

paddle/cinn/common/iter_simplify.cc

@@ -61,6 +61,7 @@ ir::IndexExpr IterMapToExprNormalizer::ConvertIterSplit(ir::IterSplit* expr) {
     Visit(&(mark->source), &(mark->source));
     source = mark->source;
   }
+
   // quick branch
   if (IsZero(expr->scale) || IsOne(expr->extent))
     return ir::Zero(expr->extent.type());
@@ -88,7 +89,7 @@ void IterMapRewriter::Visit(const ir::_Var_* op, Expr* expr) {
 void IterMapRewriter::Visit(const ir::Add* op, Expr* expr) {
   auto a = op->a();
   auto b = op->b();
-  VLOG(10) << "in visit add: " << a << " " << b;
+
   Visit(&a);
   Visit(&b);
 
@@ -102,6 +103,7 @@ void IterMapRewriter::Visit(const ir::Add* op, Expr* expr) {
 
   Expr ret = ir::ir_utils::IRCopy(ToIterSum(a));
   ir::IterSum* ret_sum = ret.As<ir::IterSum>();
+
   if (auto b_sum = b.As<ir::IterSum>()) {
     AddToLhs(ret_sum, *b_sum, 1);
   } else if (auto b_split = b.As<ir::IterSplit>()) {
@@ -110,13 +112,12 @@ void IterMapRewriter::Visit(const ir::Add* op, Expr* expr) {
     ret_sum->base = ret_sum->base + b.as_index();
   }
   *expr = ret;
-  VLOG(10) << "out visit add";
 }
 
 void IterMapRewriter::Visit(const ir::Sub* op, Expr* expr) {
   auto a = op->a();
   auto b = op->b();
-  VLOG(10) << "in visit sub: " << a << " " << b;
+
   Visit(&a);
   Visit(&b);
 
@@ -138,13 +139,12 @@ void IterMapRewriter::Visit(const ir::Sub* op, Expr* expr) {
   }
 
   *expr = ret;
-  VLOG(10) << "out visit sub";
 }
 
 void IterMapRewriter::Visit(const ir::Mul* op, Expr* expr) {
   auto a = op->a();
   auto b = op->b();
-  VLOG(10) << "in visit mul: " << a << " " << b;
+
   Visit(&a);
   Visit(&b);
 
@@ -176,14 +176,12 @@ void IterMapRewriter::Visit(const ir::Mul* op, Expr* expr) {
   }
 
   *expr = ret;
-  VLOG(10) << "out visit mul";
 }
 
 void IterMapRewriter::Visit(const ir::Div* op, Expr* expr) {
   auto a = op->a();
   auto b = op->b();
 
-  VLOG(10) << "in visit div: " << a << " " << b;
   Visit(&a);
   Visit(&b);
 
@@ -199,19 +197,21 @@ void IterMapRewriter::Visit(const ir::Div* op, Expr* expr) {
         "Division of iter and iter is not supported"));
     return;
   }
+
   auto ret = ir::ir_utils::IRCopy(a);
+
   auto preprocessed = PreprocessDividend(ret);
   auto preprocessed_sum = preprocessed.As<ir::IterSum>();
 
   ret = SplitDivConst(preprocessed_sum->args[0], preprocessed_sum->base, b);
+
   *expr = ret;
-  VLOG(10) << "out visit div";
 }
 
 void IterMapRewriter::Visit(const ir::Mod* op, Expr* expr) {
   auto a = op->a();
   auto b = op->b();
-  VLOG(10) << "in visit mod: " << a << " " << b;
+
   Visit(&a);
   Visit(&b);
 
@@ -236,7 +236,6 @@ void IterMapRewriter::Visit(const ir::Mod* op, Expr* expr) {
   ret = SplitModConst(preprocessed_sum->args[0], preprocessed_sum->base, b);
 
   *expr = ret;
-  VLOG(10) << "out visit mod";
 }
 
 Expr IterMapRewriter::PreprocessDividend(const Expr& dividend) {
@@ -472,6 +471,7 @@ std::optional<Expr> IterMapRewriter::TryFuse(const Expr& expr) {
       return opt.value();
     }
   }
+
   // Select iter with smallest scale as base iter.
   std::vector<bool> visited(iter_sum->args.size(), false);
   int base_index = FindBaseSplit(*iter_sum, visited, Expr(), -1);
@@ -484,6 +484,7 @@ std::optional<Expr> IterMapRewriter::TryFuse(const Expr& expr) {
   ir::IndexExpr expected_scale = base_scale;
   int first_possible_unit_extent_pos =
       FindFirstPossibleUnitExtentIndex(*iter_sum);
+
   // Find iter with same scale as expected_scale and update expected_scale.
   // e.g. i * 32 + j * 8 + k * 1, Extent(i, j, k) = 2, 4, 8.
   // first base_index = 2, expected_scale = 1. means select k as base iter.
@@ -492,7 +493,7 @@ std::optional<Expr> IterMapRewriter::TryFuse(const Expr& expr) {
   // finally matched_pos = 0, expected_scale = 32 * 2 = 64. means match i.
   // if match failed, indicates that expr is illegal and cannot be merged.
   for (size_t i = 0; i < iter_sum->args.size(); ++i) {
-    ir::IndexExpr matched_scale;
+    ir::IndexExpr matched_scale{nullptr};
     int matched_pos =
         i == 0 ? base_index
                : FindSplitWithExactScale(*iter_sum,

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

@@ -182,7 +182,6 @@ void SubstitudeTargetExprWithDestExpr(const ir::Expr& source,
   VLOG(4) << "SubstitideExpr Start";
   VLOG(5) << "Substitide Body : " << *body;
   ir::Expr new_dest = dest;
-  optim::Simplify(&new_dest);
   if (source.type() != dest.type()) {
     VLOG(4) << "Cast the dest" << dest << " to type" << source.type();
     new_dest = ir::Cast::Make(source.type(), dest);

paddle/cinn/ir/buffer.cc

@@ -94,15 +94,6 @@ Buffer _Buffer_::Make(Var data,
   node->offset_factor = offset_factor;
   node->target = target;
   node->dtype = dtype;
-
-  std::for_each(node->shape.begin(), node->shape.end(), [](Expr &indice) {
-    indice = indice.set_index(true).as_index().Normalize();
-  });
-  std::for_each(node->strides.begin(), node->strides.end(), [](Expr &indice) {
-    indice = indice.set_index(true).as_index().Normalize();
-  });
-  elem_offset.set_index(true);
-
   return Buffer(node);
 }
 
@@ -111,9 +102,6 @@ Buffer _Buffer_::Make(const std::string &name, const std::vector<Expr> &shape) {
   node->name = name;
   node->shape = shape;
   node->dtype = Void();
-  std::for_each(node->shape.begin(), node->shape.end(), [](Expr &indice) {
-    indice = indice.set_index(true).as_index().Normalize();
-  });
   return Buffer(node);
 }
 
@@ -137,9 +125,6 @@ void _Buffer_::BindTo(const _Tensor_ *tensor) {
           "tensor's shape is properly initialized and not empty."));
 
   shape = tensor->shape;
-  std::for_each(shape.begin(), shape.end(), [](Expr &indice) {
-    indice = indice.set_index(true).as_index().Normalize();
-  });
   binded_tensors_names_.insert(tensor->name);
 }
 void _Buffer_::Unbind(const _Tensor_ *tensor) {
@@ -207,9 +192,6 @@ Expr _BufferRange_::Make(const Expr &buffer, const std::vector<Var> &ranges) {
   auto node = make_shared<_BufferRange_>();
   node->buffer = buffer;
   node->ranges = ranges;
-  std::for_each(node->ranges.begin(), node->ranges.end(), [](Var &v) {
-    v.set_index(true);
-  });
   return Expr(node);
 }
 void _BufferRange_::Verify() const {
@@ -223,9 +205,6 @@ Expr _BufferRange_::Copy() const {
   auto node = make_shared<_BufferRange_>();
   node->buffer = buffer;
   node->ranges = ranges;
-  std::for_each(node->ranges.begin(), node->ranges.end(), [](Var &v) {
-    v.set_index(true);
-  });
   node->set_type(type());
   return Expr(node);
 }
@@ -265,9 +244,6 @@ BufferRange &BufferRange::operator=(const _BufferRange_ *x) {
   auto node = make_shared<_BufferRange_>();
   node->buffer = x->buffer;
   node->ranges = x->ranges;
-  std::for_each(node->ranges.begin(), node->ranges.end(), [](Var &v) {
-    v.set_index(true);
-  });
   node->set_type(x->type());
   *this = BufferRange(node);
   return *this;

paddle/cinn/ir/dim.cc

@@ -33,8 +33,6 @@ Dim _Dim_::Make(const std::string& name, const symbol::DimExpr& sym_dim) {
   n->name = name;
   n->sym_dim = sym_dim;
   n->dim_expr = common::DimExprConverter().ConvertToIrExpr(sym_dim);
-
-  n->dim_expr.set_index(true);
   n->set_type(n->dim_expr.type());
   return Dim(n);
 }