do not include filter constraints in original accesses

Initial implementation of TensorReference instances was costructing
original access maps by intersecting the domain of scop-wise access
maps with the set of active domain points obtained by traversing the
tree.  This set can contain constraints coming from mapping filters,
which would have to be removed for further analyses.  Initial
implementation was gisting the domain of the access relation with itself
in an attempt to remove these constranits.  It does not work fully
because these constraints typically fix some input dimensions of a map
to parameters modulo constant, which triggers similar fixing of the
output dimensions related to the input dimensions.

When constructing TensorReferences, do not use the result of
intersecting the scop-wise access maps with active domain points.
Instead, only check if this intersection is not empty before adding the
original (unconstrained) access relation.  Whenever it is necessary in
shared memory promotion heuristic, pass the set of active domain points
and intersect access relations locally.

Author: ftynse

src/core/polyhedral/memory_promotion.cc

@@ -321,8 +321,11 @@ void addSingletonReferenceGroups(
   // access relations have a shape :: [D -> ref] -> O
   // use currying to isolate the D part before intersecting with the domain
   // Compute initial groups with single reference per group.
-  accesses = accesses.curry().intersect_domain(domain).uncurry();
   for (auto a : isl::UnionAsVector<isl::union_map>(accesses)) {
+    if (isl::union_map(a.curry()).intersect_domain(domain).is_empty()) {
+      continue;
+    }
+
     auto tensorId = a.get_tuple_id(isl::dim_type::out);
     addSingletonReferenceGroup(tensorGroups, tensorId, schedule, a, type);
   }

src/core/polyhedral/memory_promotion_heuristic.cc

@@ -278,7 +278,8 @@ size_t computeThreadIdxxScheduleDepth(
 bool isCoalesced(
     const ThreadIdxxScheduleDepthState& threadIdxxScheduleDepthState,
     const TensorReferenceGroup& group,
-    isl::union_map schedule) {
+    isl::union_map schedule,
+    isl::union_set activePoints) {
   auto originalAccesses = group.originalAccesses();
 
   for (auto accessMap : isl::UnionAsVector<isl::union_map>(originalAccesses)) {
@@ -288,7 +289,7 @@ bool isCoalesced(
           tensorSpace, tensorSpace.dim(isl::dim_type::set) - 1);
       auto domainUMap = isl::union_set(isl::set(access.domain()));
       int threadIdxxDepth = computeThreadIdxxScheduleDepth(
-          threadIdxxScheduleDepthState, domainUMap);
+          threadIdxxScheduleDepthState, domainUMap.intersect(activePoints));
       auto partialScheduleUMap =
           schedule.intersect_domain(domainUMap.universe());
       if (partialScheduleUMap.n_map() != 1) {
@@ -398,6 +399,7 @@ void promoteToSharedGreedy(
     auto groupMap = TensorReferenceGroup::accessedBySubtree(bandNode, scop);
     auto activeStmts = activeStatements(root, bandNode);
     auto partialSched = partialSchedule(root, bandNode);
+    auto activePoints = activeDomainPoints(root, bandNode);
 
     // Prepare groups for sorting, to have specified order necessary for
     // reproducibility and tests.
@@ -457,7 +459,11 @@ void promoteToSharedGreedy(
         // Do not promote if the group features no reuse and is accessed in a
         // coalesced way.
         if (!hasReuse(*group, fullSched, depth) &&
-            isCoalesced(threadIdxxScheduleDepthState, *group, fullSched)) {
+            isCoalesced(
+                threadIdxxScheduleDepthState,
+                *group,
+                fullSched,
+                activePoints)) {
           continue;
         }