update to use iter shift instead of itermark min for lowerbound

Author: wrongtest-intellif

include/tvm/arith/iter_affine_map.h

@@ -83,7 +83,7 @@ class IterMapExpr : public PrimExpr {
 };
 
 /*!
- * \brief Mark the source as an iterator in [min, extent).
+ * \brief Mark the source as an iterator in [0, extent).
  *
  *  IterMark is used to mark source expression as a valid
  *  iterator to make future analysis easy.
@@ -95,10 +95,6 @@ class IterMarkNode : public Object {
    *  a IterSumExpr or a Var.
    */
   PrimExpr source;
-  /*!
-   * \brief The min of the iteration.
-   */
-  PrimExpr min;
   /*!
    * \brief The extent of the iteration.
    */
@@ -107,19 +103,17 @@ class IterMarkNode : public Object {
   // overrides
   void VisitAttrs(tvm::AttrVisitor* v) {
     v->Visit("source", &source);
-    v->Visit("min", &min);
     v->Visit("extent", &extent);
   }
 
   bool SEqualReduce(const IterMarkNode* other, SEqualReducer equal) const {
     equal->MarkGraphNode();
-    return equal(source, other->source) && equal(extent, other->extent) && equal(min, other->min);
+    return equal(source, other->source) && equal(extent, other->extent);
   }
 
   void SHashReduce(SHashReducer hash_reduce) const {
     hash_reduce->MarkGraphNode();
     hash_reduce(source);
-    hash_reduce(min);
     hash_reduce(extent);
   }
 
@@ -138,10 +132,9 @@ class IterMark : public ObjectRef {
   /*!
    * \brief constructor.
    * \param source The source expression.
-   * \param min The min of the iterator.
    * \param extent The extent of the iterator.
    */
-  TVM_DLL IterMark(PrimExpr source, PrimExpr min, PrimExpr extent);
+  TVM_DLL IterMark(PrimExpr source, PrimExpr extent);
 
   TVM_DEFINE_OBJECT_REF_METHODS(IterMark, ObjectRef, IterMarkNode);
   TVM_DEFINE_OBJECT_REF_COW_METHOD(IterMarkNode);

python/tvm/arith/iter_affine_map.py

@@ -34,15 +34,12 @@ class IterMark(Object):
     source : PrimExpr.
         The source expression.
 
-    min_value : PrimExpr
-        The min of the iterator.
-
     extent : PrimExpr
         The extent of the iterator.
     """
 
-    def __init__(self, source, min_value, extent):
-        self.__init_handle_by_constructor__(_ffi_api.IterMark, source, min_value, extent)
+    def __init__(self, source, extent):
+        self.__init_handle_by_constructor__(_ffi_api.IterMark, source, extent)
 
 
 @tvm._ffi.register_object("arith.IterSplitExpr")

src/arith/int_set.cc

@@ -839,9 +839,9 @@ Optional<Array<IntSet>> EstimateRegionLowerBound(const Array<Range>& region,
     iter_sum_exprs = DetectIterMap(
         /*indices=*/affine_indices, /*input_iters=*/var_dom,
         /*predicate=*/predicate, /*require_bijective=*/false, analyzer, diag_ctx);
-    if (iter_sum_exprs.empty()) {
-      return NullOpt;
-    }
+  }
+  if (iter_sum_exprs.empty()) {
+    return NullOpt;
   }
   ICHECK_EQ(iter_sum_exprs.size(), ndim);
   Array<IntSet> result;
@@ -858,27 +858,12 @@ Optional<Array<IntSet>> EstimateRegionLowerBound(const Array<Range>& region,
     if (!analyzer->CanProve(range->extent >= split->scale)) {
       return NullOpt;
     }
-    if (is_zero(split->source->min)) {
-      // IterSplitExpr: (source // lower_factor) % extent * scale
-      // thus `(source // lower_factor) % extent` is within [0, extent - 1]
-      // Therefore, the range of `region[i]->min` is `base + [0, (extent - 1) * scale]`
-      const PrimExpr& base = sum_expr->base;
-      result.push_back(IntSet::FromMinExtent(
-          base, split->extent * split->scale + (range->extent - split->scale)));
-    } else {
-      // if mark_min is not zero, currently only process cases where
-      // `scale == 1` and `lower_factor == 1` and `extent >= mark_extent`
-      const IterMark& mark = split->source;
-      arith::Analyzer analyzer;
-      if (!analyzer.CanProveEqual(split->scale, 1) ||
-          !analyzer.CanProveEqual(split->lower_factor, 1) ||
-          !analyzer.CanProve(mark->extent - split->extent <= 0)) {
-        return NullOpt;
-      }
-      PrimExpr region_min = analyzer.Simplify(sum_expr->base + split->source->min, 3);
-      PrimExpr region_max = analyzer.Simplify(region_min + mark->extent - 1, 3);
-      result.push_back(IntSet::Interval(region_min, region_max));
-    }
+    const PrimExpr& base = sum_expr->base;
+    // IterSplitExpr: (source // lower_factor) % extent * scale
+    // where `(source // lower_factor) % extent` is within [0, extent - 1]
+    // Therefore, the range of `region[i]->min` is `base + [0, (extent - 1) * scale]`
+    result.push_back(
+        IntSet::FromMinExtent(base, split->extent * split->scale + (range->extent - split->scale)));
   }
   return result;
 }