[RFC] use templated isl types accessSubscriptsAreUnrolledLoops

Templated isl types require the user to specify the domain and range
universes of isl objects, allowing the compiler to check whether
it makes sense to combine pairs of objects.
This RFC only converts isPromotableToRegistersBelow and some related
functions to illustrate the effect.
The isPromotableToRegistersBelow was already applying operations
correctly, so the code itself did not require any changes.
However, one variable was reused to store different types
of intermediate result and this one had to be split up into
several variables because they now have different types.

Author: Sven Verdoolaege

tc/core/polyhedral/cuda/memory_promotion_heuristic.cc

@@ -298,11 +298,12 @@ struct Unrolled;
  * different references may have different values, but all of them remain
  * independent of non-unrolled loop iterators.
  */
+template <typename Outer>
 bool accessSubscriptsAreUnrolledLoops(
     const TensorReferenceGroup& group,
     const detail::ScheduleTree* root,
     const detail::ScheduleTree* scope,
-    isl::multi_union_pw_aff outerSchedule) {
+    isl::MultiUnionPwAff<Statement, Outer> outerSchedule) {
   using namespace detail;
 
   auto nodes = ScheduleTree::collect(scope);
@@ -319,14 +320,14 @@ bool accessSubscriptsAreUnrolledLoops(
     ancestors.push_back(leaf);
     auto subdomain = activeDomainPointsBelow(root, leaf);
 
-    auto unrolledDims = isl::union_pw_aff_list(leaf->ctx_, 1);
+    auto unrolledDims = isl::UnionPwAffListOn<Statement>(leaf->ctx_, 1);
     for (auto node : ancestors) {
-      auto band = node->as<detail::ScheduleTreeBand>();
+      auto band = node->template as<detail::ScheduleTreeBand>();
       if (!band) {
         continue;
       }
 
-      isl::multi_union_pw_aff schedule = band->mupa_;
+      auto schedule = band->mupa_;
       schedule = schedule.intersect_domain(subdomain);
       for (size_t i = 0, e = band->nMember(); i < e; ++i) {
         if (!band->unroll_[i]) {
@@ -336,21 +337,23 @@ bool accessSubscriptsAreUnrolledLoops(
       }
     }
 
-    auto space = subdomain.get_space().add_unnamed_tuple_ui<Unrolled>(
+    auto space = subdomain.get_space().template add_unnamed_tuple_ui<Unrolled>(
         unrolledDims.size());
-    auto unrolledDimsMupa = isl::multi_union_pw_aff(space, unrolledDims);
+    auto unrolledDimsMupa =
+        isl::MultiUnionPwAff<Statement, Unrolled>(space, unrolledDims);
 
     // It is possible that no loops are unrolled, in which case
     // unrolledDimsMupa is zero-dimensional and needs an explicit domain
     // to be convertible to a union_map.
     unrolledDimsMupa =
         unrolledDimsMupa.intersect_domain(group.originalAccesses().domain());
 
-    isl::union_map accesses = group.originalAccesses();
-    auto schedule = outerSchedule.flat_range_product(unrolledDimsMupa);
-    accesses = accesses.apply_domain(isl::union_map::from(schedule));
+    auto accesses = group.originalAccesses();
+    auto schedule = outerSchedule.range_product(unrolledDimsMupa);
+    auto scheduleMap = schedule.toUnionMap();
+    auto scheduledAccesses = accesses.apply_domain(scheduleMap);
 
-    if (!accesses.is_single_valued()) {
+    if (!scheduledAccesses.is_single_valued()) {
       return false;
     }
   }