use activeDomainPoints instead of activeDomainPointsNoMappingNoExtension

Now that activeDomainPoints no longer takes into account mapping filters,
there is no longer any need for a specialized
activeDomainPointsNoMappingNoExtension.

Author: Sven Verdoolaege

tc/core/polyhedral/cuda/mapped_scop.h

@@ -190,17 +190,13 @@ class MappedScop {
   // to the thread identifiers, where all branches in "tree"
   // are assumed to have been mapped to thread identifiers.
   // The result lives in a space of the form block[x, ...].
-  //
-  // Note: this function ignores statements introduced by extension nodes.
   isl::multi_union_pw_aff threadMappingSchedule(
       const detail::ScheduleTree* tree) const;
 
   // Extract a mapping from the domain elements active at "tree"
   // to the block identifiers, where all branches in "tree"
   // are assumed to have been mapped to block identifiers.
   // The result lives in a space of the form grid[x, ...].
-  //
-  // Note: this function ignores statements introduced by extension nodes.
   isl::multi_union_pw_aff blockMappingSchedule(
       const detail::ScheduleTree* tree) const;
 

tc/core/polyhedral/cuda/memory_promotion_heuristic.cc

@@ -296,9 +296,6 @@ bool promotionImprovesCoalescing(
 
 /*
  * Returns the union of all mapping filters to "MappingType" in "scop".
- *
- * Note: similarly to MappedScop::[thread|block]MappingSchedule, this function
- * does not take into account elements introduced by extension nodes.
  */
 template <typename MappingType>
 isl::union_set collectMappingsTo(const Scop& scop) {
@@ -310,8 +307,7 @@ isl::union_set collectMappingsTo(const Scop& scop) {
   auto mapping = isl::union_set::empty(domain.get_space());
   for (auto mf : mappingFilters) {
     auto filterNode = mf->elemAs<detail::ScheduleTreeElemMappingFilter>();
-    auto filter = filterNode->filter_.intersect(
-        activeDomainPointsNoMappingNoExtension(root, mf));
+    auto filter = filterNode->filter_.intersect(activeDomainPoints(root, mf));
     mapping = mapping.unite(filterNode->filter_);
   }
   return mapping;

tc/core/polyhedral/schedule_transforms.cc

@@ -180,18 +180,6 @@ isl::union_set activeDomainPointsBelow(
   return activeDomainPointsHelper(root, ancestors);
 }
 
-isl::union_set activeDomainPointsNoMappingNoExtension(
-    const detail::ScheduleTree* root,
-    const detail::ScheduleTree* tree) {
-  auto domain = root->elemAs<detail::ScheduleTreeElemDomain>()->domain_;
-  for (auto t : tree->ancestors(root)) {
-    if (auto f = t->elemAs<detail::ScheduleTreeElemFilter>()) {
-      domain = domain.intersect(f->filter_);
-    }
-  }
-  return domain;
-}
-
 vector<ScheduleTree*> collectScheduleTreesPath(
     std::function<ScheduleTree*(ScheduleTree*)> next,
     ScheduleTree* start) {
@@ -851,10 +839,6 @@ void orderAfter(ScheduleTree* root, ScheduleTree* tree, isl::union_set filter) {
  * to identifiers "ids", where all branches in "tree"
  * are assumed to have been mapped to these identifiers.
  * The result lives in a space of the form "tupleId"["ids"...].
- *
- * Note: this function only takes into account points that are present in the
- * root domain node.  Those introduced by extension nodes are ignored.  This
- * behavior can change in the future.
  */
 isl::multi_union_pw_aff extractDomainToIds(
     const detail::ScheduleTree* root,
@@ -884,14 +868,14 @@ isl::multi_union_pw_aff extractDomainToIds(
       continue;
     }
     auto nodeToIds = isl::multi_union_pw_aff(space, list);
-    auto active = activeDomainPointsNoMappingNoExtension(root, mapping);
+    auto active = activeDomainPoints(root, mapping);
     TC_CHECK(active.intersect(domainToIds.domain()).is_empty())
         << "conflicting mappings; are the filters in the tree disjoint?";
     nodeToIds = nodeToIds.intersect_domain(active);
     domainToIds = domainToIds.union_add(nodeToIds);
   }
 
-  auto active = activeDomainPointsNoMappingNoExtension(root, tree);
+  auto active = activeDomainPoints(root, tree);
   TC_CHECK(active.is_subset(domainToIds.domain()))
       << "not all domain points of\n"
       << active << "\nwere mapped to the required ids";

tc/core/polyhedral/schedule_transforms.h

@@ -326,15 +326,6 @@ isl::union_set activeDomainPointsBelow(
     const detail::ScheduleTree* root,
     const detail::ScheduleTree* node);
 
-// Get the set of domain points active below the given node without including
-// the points introduced by extension nodes and without treating mapping nodes
-// as filters.  A point is considered active at a schedule node "tree" if it is
-// present in the "root" domain node and was not filtered away on the path from
-// "root" to "tree".  The root must be a domain element.
-isl::union_set activeDomainPointsNoMappingNoExtension(
-    const detail::ScheduleTree* root,
-    const detail::ScheduleTree* tree);
-
 // Collect the outer block/thread identifier mappings
 // into a filter on the active domain elements.
 isl::union_set prefixMappingFilter(