Squash array_algebra commits after master_array_algebra

lowerer_impl: fix some striding bugs

Fixes some formulaic errors in generated striding code along with a test
that revealed them.

WIP trying to fix lattice construction

Add in some changes to iteration lattice construction

Add in locator check as well

Add in iteration lattice construction changes for intersectLattices() as well

Fix iteration lattice comparison (to sort points first) and check for empty points when unionLattices and intersectLattices are called

Author: rohany

src/lower/lowerer_impl.cpp

@@ -3917,7 +3917,7 @@ Expr LowererImpl::searchForEndOfWindowPosition(Iterator iterator, ir::Expr start
 Stmt LowererImpl::upperBoundGuardForWindowPosition(Iterator iterator, ir::Expr access) {
   taco_iassert(iterator.isWindowed());
   return ir::IfThenElse::make(
-    ir::Gte::make(access, ir::Sub::make(iterator.getWindowUpperBound(), iterator.getWindowLowerBound())),
+    ir::Gte::make(access, ir::Div::make(ir::Sub::make(iterator.getWindowUpperBound(), iterator.getWindowLowerBound()), iterator.getStride())),
     ir::Break::make()
   );
 }
@@ -3936,7 +3936,7 @@ Stmt LowererImpl::strideBoundsGuard(Iterator iterator, ir::Expr access, bool inc
   }
   // The guard makes sure that the coordinate being accessed is along the stride.
   return ir::IfThenElse::make(
-      ir::Neq::make(ir::Rem::make(access, iterator.getStride()), ir::Literal::make(0)),
+      ir::Neq::make(ir::Rem::make(ir::Sub::make(access, iterator.getWindowLowerBound()), iterator.getStride()), ir::Literal::make(0)),
       cont
   );
 }
@@ -3948,7 +3948,7 @@ Expr LowererImpl::projectWindowedPositionToCanonicalSpace(Iterator iterator, ir:
 
 
 Expr LowererImpl::projectCanonicalSpaceToWindowedPosition(Iterator iterator, ir::Expr expr) {
-  return ir::Mul::make(ir::Add::make(expr, iterator.getWindowLowerBound()), iterator.getStride());
+  return ir::Add::make(ir::Mul::make(expr, iterator.getStride()), iterator.getWindowLowerBound());
 }
 
 }

src/lower/merge_lattice.cpp

@@ -545,11 +545,53 @@ class MergeLatticeBuilder : public IndexNotationVisitorStrict, public IterationA
     bool locateLeft = locateFromLeft(left, right);
 
     // Append all combinations of a and b merge points
-    for (auto& leftPoint : left.points()) {
-      for (auto& rightPoint : right.points()) {
-        points.push_back(intersectPoints(leftPoint, rightPoint, locateLeft));
+    struct pointSort {
+      bool operator()(const MergePoint& a, const MergePoint& b) {
+        size_t left_size  = a.iterators().size() + a.locators().size();
+        size_t right_size = b.iterators().size() + b.locators().size();
+        return left_size > right_size;
+      }
+    } pointSorter;
+
+    // Append all combinations of the merge points of a and b
+    auto sorted_apoint = left.points();
+    auto sorted_bpoint = right.points();
+    std::sort(sorted_apoint.begin(), sorted_apoint.end(), pointSorter);
+    std::sort(sorted_bpoint.begin(), sorted_bpoint.end(), pointSorter);
+
+    set<Iterator> apoint_root_set;
+    if (!sorted_apoint.empty())
+      apoint_root_set = sorted_apoint.begin()->tensorRegion();
+
+    set<Iterator>bpoint_root_set;
+    if (!sorted_bpoint.empty())
+      bpoint_root_set = sorted_bpoint.begin()->tensorRegion();
+
+
+    for (auto& apoint : sorted_apoint) {
+      for (auto& bpoint : sorted_bpoint) {
+        bool hasIntersection = true;
+
+        auto apoint_set = apoint.tensorRegion();
+        auto bpoint_set = bpoint.tensorRegion();
+
+        for (auto& it : apoint_set) {
+          if (!std::count(bpoint_set.begin(), bpoint_set.end(), it) &&
+              std::count(bpoint_root_set.begin(), bpoint_root_set.end(), it)) {
+            hasIntersection = false;
+          }
+        }
+        for (auto& it : bpoint_set) {
+          if (!std::count(apoint_set.begin(), apoint_set.end(), it) &&
+              std::count(apoint_root_set.begin(), apoint_root_set.end(), it)) {
+            hasIntersection = false;
+          }
+        }
+        if (hasIntersection)
+          points.push_back(intersectPoints(apoint, bpoint, locateLeft));
       }
     }
+    std::sort(points.begin(), points.end(), pointSorter);
 
     // Correctness: ensures that points produced on BOTH the left and the
     //              right lattices are produced in the final intersection.
@@ -561,7 +603,7 @@ class MergeLatticeBuilder : public IndexNotationVisitorStrict, public IterationA
     //              points and resolves conflicts arising between omitters and
     //              producers
      points = removeDuplicatedTensorRegions(points, true);
-
+     
     // Optimization: Removed a subLattice of points if the entire subLattice is
     //               made of only omitters
     // points = removeUnnecessaryOmitterPoints(points);
@@ -581,10 +623,49 @@ class MergeLatticeBuilder : public IndexNotationVisitorStrict, public IterationA
   {
     vector<MergePoint> points;
 
+    struct pointSort {
+      bool operator()(const MergePoint& a, const MergePoint& b) {
+        size_t left_size  = a.iterators().size() + a.locators().size();
+        size_t right_size = b.iterators().size() + b.locators().size();
+        return left_size > right_size;
+      }
+    } pointSorter;
+
     // Append all combinations of the merge points of a and b
-    for (auto& apoint : left.points()) {
-      for (auto& bpoint : right.points()) {
-        points.push_back(unionPoints(apoint, bpoint));
+    auto sorted_apoint = left.points();
+    auto sorted_bpoint = right.points();
+    std::sort(sorted_apoint.begin(), sorted_apoint.end(), pointSorter);
+    std::sort(sorted_bpoint.begin(), sorted_bpoint.end(), pointSorter);
+
+    set<Iterator> apoint_root_set;
+    if (!sorted_apoint.empty())
+      apoint_root_set = sorted_apoint.begin()->tensorRegion();
+
+    set<Iterator>bpoint_root_set;
+    if (!sorted_bpoint.empty())
+      bpoint_root_set = sorted_bpoint.begin()->tensorRegion();
+
+    for (auto& apoint : sorted_apoint) {
+      for (auto& bpoint : sorted_bpoint) {
+        bool hasIntersection = true;
+
+        auto apoint_set = apoint.tensorRegion();
+        auto bpoint_set = bpoint.tensorRegion();
+
+        for (auto& it : apoint_set) {
+          if (!std::count(bpoint_set.begin(), bpoint_set.end(), it) &&
+              std::count(bpoint_root_set.begin(), bpoint_root_set.end(), it)) {
+            hasIntersection = false;
+          }
+        }
+        for (auto& it : bpoint_set) {
+          if (!std::count(apoint_set.begin(), apoint_set.end(), it) &&
+              std::count(apoint_root_set.begin(), apoint_root_set.end(), it)) {
+            hasIntersection = false;
+          }
+        }
+        if (hasIntersection)
+          points.push_back(unionPoints(apoint, bpoint));
       }
     }
 
@@ -594,22 +675,13 @@ class MergeLatticeBuilder : public IndexNotationVisitorStrict, public IterationA
     // Append the merge points of b
     util::append(points, right.points());
 
-    struct pointSort {
-      bool operator()(const MergePoint& a, const MergePoint& b) {
-        size_t left_size  = a.iterators().size() + a.locators().size();
-        size_t right_size = b.iterators().size() + b.locators().size();
-        return left_size > right_size;
-      }
-    } pointSorter;
-
     std::sort(points.begin(), points.end(), pointSorter);
 
     // Correctness: This ensures that points omitted on BOTH the left and the
     //              right lattices are omitted in the Union. Needed since some
     //              subpoints may produce leading to erroneous producer regions
     points = correctPointTypesAfterUnion(left.points(), right.points(), points);
 
-
     // Correctness: Deduplicate regions that are described by multiple lattice
     //              points and resolves conflicts arising between omitters and
     //              producers
@@ -675,6 +747,7 @@ class MergeLatticeBuilder : public IndexNotationVisitorStrict, public IterationA
    */
   static MergePoint unionPoints(MergePoint left, MergePoint right)
   {
+
     vector<Iterator> iterators= combine(left.iterators(),right.iterators());
     vector<Iterator> locaters = combine(left.locators(), right.locators());
     vector<Iterator> results  = combine(left.results(),  right.results());
@@ -788,6 +861,21 @@ class MergeLatticeBuilder : public IndexNotationVisitorStrict, public IterationA
     return deduplicates;
   }
 
+  static vector<Iterator>
+  removeDimensionIterators(const vector<Iterator>& iterators)
+  {
+    vector<Iterator> result;
+
+    // Remove all but one of the dense iterators, which are all the same.
+    for (auto& iterator : iterators) {
+      if (!iterator.isDimensionIterator()) {
+        result.push_back(iterator);
+      }
+    }
+    return result;
+  }
+
+
   static vector<MergePoint>
   flipPoints(const vector<MergePoint>& points) {
     vector<MergePoint> flippedPoints;
@@ -1123,8 +1211,18 @@ ostream& operator<<(ostream& os, const MergeLattice& ml) {
 }
 
 bool operator==(const MergeLattice& a, const MergeLattice& b) {
-  auto& apoints = a.points();
-  auto& bpoints = b.points();
+  auto apoints = a.points();
+  auto bpoints = b.points();
+  struct pointSort {
+    bool operator()(const MergePoint& a, const MergePoint& b) {
+      size_t left_size  = a.iterators().size() + a.locators().size();
+      size_t right_size = b.iterators().size() + b.locators().size();
+      return left_size > right_size;
+    }
+  } pointSorter;
+
+  std::sort(apoints.begin(), apoints.end(), pointSorter);
+  std::sort(bpoints.begin(), bpoints.end(), pointSorter);
   if (apoints.size() != bpoints.size()) {
     return false;
   }

test/tests-windowing.cpp

@@ -433,6 +433,16 @@ TEST_P(stride, windowing) {
   c(i, j) = a(i(0, 10, 5), j(0, 10, 5)) * b(i(0, 10, 5), j(0, 10, 5));
   c.evaluate();
   ASSERT_TRUE(equals(c, expectedMul)) << c << endl << expectedMul << endl;
+
+  // Test a strided assignment where the stride doesn't start at 0.
+  c(i, j) = a(i(1, 5, 2), j(2, 6, 2));
+  c.evaluate();
+  Tensor<int> expectedAssign2("expectedAssign2", {2, 2}, {Dense, Dense});
+  expectedAssign2.insert({0, 0}, 3); expectedAssign2.insert({0, 1}, 5);
+  expectedAssign2.insert({1, 0}, 5); expectedAssign2.insert({1, 1}, 7);
+  expectedAssign2.pack();
+  ASSERT_TRUE(equals(c, expectedAssign2)) << c << endl << expectedAssign2 << endl;
+
 }
 INSTANTIATE_TEST_CASE_P(
     windowing,