[RFC] use templated isl types Body

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/body.h

@@ -17,6 +17,7 @@
 
 #include <iostream>
 
+#include "tc/core/polyhedral/domain_types.h"
 #include "tc/external/isl.h"
 
 namespace tc {
@@ -26,11 +27,13 @@ namespace polyhedral {
 struct Body {
   Body() = default;
   Body(isl::space paramSpace) {
-    reductions = writes = reads = isl::union_map::empty(paramSpace);
+    auto empty = isl::union_map::empty(paramSpace);
+    writes = reads = isl::UnionMap<isl::Pair<Statement, Tag>, Tensor>(empty);
+    reductions = isl::UnionMap<Statement, Reduction>(empty);
   }
 
   // Specialize to the given context.
-  void specialize(isl::set context) {
+  void specialize(isl::Set<> context) {
     reads = reads.intersect_params(context);
     writes = writes.intersect_params(context);
     reductions = reductions.intersect_params(context);
@@ -39,7 +42,7 @@ struct Body {
   // Union maps describing the reads and writes done. Uses the ids in
   // the schedule tree to denote the containing Stmt, and tags each
   // access with a unique reference id of the form __tc_ref_N.
-  isl::union_map reads, writes;
+  isl::UnionMap<isl::Pair<Statement, Tag>, Tensor> reads, writes;
 
   // A function on reduction update statement instances that partitions them
   // into individual reductions, where each reduction consists of
@@ -73,7 +76,7 @@ struct Body {
   // That is, in the example above, it would just be
   //
   //	{ S[i] -> R[] : 0 <= i < 4 }
-  isl::union_map reductions;
+  isl::UnionMap<Statement, Reduction> reductions;
 };
 
 std::ostream& operator<<(std::ostream& os, const Body& body);

tc/core/polyhedral/reduction_matcher.cc

@@ -54,16 +54,18 @@ bool isSupportedReductionUpdateId(isl::id id, const Scop& scop) {
 
 } // namespace
 
-isl::UnionSet<Statement> reductionUpdates(isl::union_set domain, const Scop& scop) {
+isl::UnionSet<Statement> reductionUpdates(
+    isl::UnionSet<Statement> domain,
+    const Scop& scop) {
   domain = scop.body.reductions.intersect_domain(domain).domain();
-  auto update = isl::union_set::empty(domain.get_space());
-  domain.foreach_set([&update, &scop](isl::set set) {
+  auto update = isl::UnionSet<Statement>::empty(domain.get_space());
+  domain.foreach_set([&update, &scop](isl::Set<Statement> set) {
     auto setId = set.get_tuple_id();
     if (isSupportedReductionUpdateId(setId, scop)) {
       update = update.unite(set);
     }
   });
-  return isl::UnionSet<Statement>(update);
+  return update;
 }
 
 } // namespace polyhedral

tc/core/polyhedral/schedule_tree_matcher.h

@@ -28,7 +28,9 @@ namespace polyhedral {
 
 // Return the union of the reduction update statements
 // that appear in "domain".
-isl::UnionSet<Statement> reductionUpdates(isl::union_set domain, const Scop& scop);
+isl::UnionSet<Statement> reductionUpdates(
+    isl::UnionSet<Statement> domain,
+    const Scop& scop);
 
 // Does "prefix" partition "domain" into individual reductions?
 // In particular, do the elements of "domain" access a single tensor