IterationDomain: store outer loop iterators in an isl::multi_id

In an upcoming commit, affine expressions in terms
of the outer loop iterators will first be constructed
on top of a parameter space and then converted
to an affine expression on top of the iteration domain.
The isl::multi_id is needed in this conversion.
It will also be used inside makeScheduleTreeHelper
to construct the iteration domain.

Author: Sven Verdoolaege

tc/core/halide2isl.cc

@@ -338,7 +338,7 @@ extractAccesses(isl::set domain, const Stmt& s, AccessMap* accesses) {
  * recursively descending over the Stmt.
  * "s" is the current position in the recursive descent.
  * "set" describes the bounds on the outer loop iterators.
- * "outer" contains the names of the outer loop iterators
+ * "outer" contains the identifiers of the outer loop iterators
  * from outermost to innermost.
  * Return the schedule corresponding to the subtree at "s".
  *
@@ -353,7 +353,7 @@ extractAccesses(isl::set domain, const Stmt& s, AccessMap* accesses) {
 isl::schedule makeScheduleTreeHelper(
     const Stmt& s,
     isl::set set,
-    std::vector<std::string>& outer,
+    isl::id_list outer,
     isl::union_map* reads,
     isl::union_map* writes,
     AccessMap* accesses,
@@ -394,8 +394,7 @@ isl::schedule makeScheduleTreeHelper(
     }
 
     // Recursively descend.
-    auto outerNext = outer;
-    outerNext.push_back(op->name);
+    auto outerNext = outer.add(isl::id(set.get_ctx(), op->name));
     auto body = makeScheduleTreeHelper(
         op->body, set, outerNext, reads, writes, accesses, statements, domains);
 
@@ -438,8 +437,10 @@ isl::schedule makeScheduleTreeHelper(
     size_t stmtIndex = statements->size();
     isl::id id(set.get_ctx(), kStatementLabel + std::to_string(stmtIndex));
     statements->emplace(id, op);
+    auto tupleSpace = isl::space(set.get_ctx(), 0);
+    tupleSpace = tupleSpace.named_set_from_params_id(id, outer.n());
     IterationDomain iterationDomain;
-    iterationDomain.iterators = outer;
+    iterationDomain.tuple = isl::multi_id(tupleSpace, outer);
     domains->emplace(id, iterationDomain);
     isl::set domain = set.set_tuple_id(id);
     schedule = isl::schedule::from_domain(domain);
@@ -462,7 +463,7 @@ ScheduleTreeAndAccesses makeScheduleTree(isl::space paramSpace, const Stmt& s) {
   result.writes = result.reads = isl::union_map::empty(paramSpace);
 
   // Walk the IR building a schedule tree
-  std::vector<std::string> outer;
+  isl::id_list outer(paramSpace.get_ctx(), 0);
   auto schedule = makeScheduleTreeHelper(
       s,
       isl::set::universe(paramSpace),

tc/core/halide2isl.h

@@ -58,8 +58,10 @@ isl::aff makeIslAffFromExpr(isl::space space, const Halide::Expr& e);
 
 // Iteration domain information associated to a statement identifier.
 struct IterationDomain {
-  // The outer loop iterators, from outermost to innermost.
-  std::vector<std::string> iterators;
+  // The identifier tuple corresponding to the iteration domain.
+  // The identifiers in the tuple are the outer loop iterators,
+  // from outermost to innermost.
+  isl::multi_id tuple;
 };
 
 typedef std::unordered_map<isl::id, IterationDomain, isl::IslIdIslHash>

tc/core/polyhedral/codegen_llvm.cc

@@ -637,11 +637,11 @@ isl::ast_node collectIteratorMaps(
   auto stmtId = expr.get_arg(0).as<isl::ast_expr_id>().get_id();
   TC_CHECK_EQ(0u, iteratorMaps.count(stmtId)) << "entry exists: " << stmtId;
   auto iteratorMap = isl::pw_multi_aff(scheduleMap.reverse());
-  auto iterators = scop.halide.domains.at(stmtId).iterators;
+  auto tuple = scop.halide.domains.at(stmtId).tuple;
   auto& stmtIteratorMap = iteratorMaps[stmtId];
-  for (size_t i = 0; i < iterators.size(); ++i) {
+  for (int i = 0; i < tuple.size(); ++i) {
     auto expr = build.expr_from(iteratorMap.get_pw_aff(i));
-    stmtIteratorMap.emplace(iterators[i], expr);
+    stmtIteratorMap.emplace(tuple.get_id(i).get_name(), expr);
   }
   auto& subscripts = stmtSubscripts[stmtId];
   auto provide =

tc/core/polyhedral/scop.cc

@@ -507,14 +507,12 @@ isl::aff Scop::makeIslAffFromStmtExpr(
     isl::id stmtId,
     isl::space paramSpace,
     const Halide::Expr& e) const {
-  auto ctx = stmtId.get_ctx();
-  auto iterators = halide.domains.at(stmtId).iterators;
-  auto space = paramSpace.named_set_from_params_id(stmtId, iterators.size());
+  auto tuple = halide.domains.at(stmtId).tuple;
+  auto space = paramSpace.named_set_from_params_id(stmtId, tuple.size());
   // Set the names of the set dimensions of "space" for use
   // by halide2isl::makeIslAffFromExpr.
-  for (size_t i = 0; i < iterators.size(); ++i) {
-    isl::id id(ctx, iterators[i]);
-    space = space.set_dim_id(isl::dim_type::set, i, id);
+  for (int i = 0; i < tuple.size(); ++i) {
+    space = space.set_dim_id(isl::dim_type::set, i, tuple.get_id(i));
   }
   return halide2isl::makeIslAffFromExpr(space, e);
 }