Scop: separate may and must writes

Originally, TC did not support indirection on the LHS.  From the
polyhedral representation point of view, all writes were thus "must"
writes, that is the tensor elements were necessarily overwritten.  With
indirection, it is impossible to decide statically which elements will
be overwritten and which ones won't.  Therefore, we need to separately
consider "may" writes, i.e. the elements that may or may not be written
depending on some dynamic values, and "must" writes.

Introduce may/must write separation at the Scop level.  Treat all writes
as may writes, which is safe may lead to inefficient schedules.

Author: ftynse

tc/core/polyhedral/memory_promotion.cc

@@ -348,7 +348,7 @@ TensorGroups TensorReferenceGroup::accessedBySubtree(
   auto schedule = partialSchedule(scop.scheduleRoot(), tree);
 
   addSingletonReferenceGroups(
-      tensorGroups, scop.writes, domain, schedule, AccessType::Write);
+      tensorGroups, scop.mayWrites, domain, schedule, AccessType::Write);
   addSingletonReferenceGroups(
       tensorGroups, scop.reads, domain, schedule, AccessType::Read);
 

tc/core/polyhedral/scop.cc

@@ -61,7 +61,8 @@ ScopUPtr Scop::makeScop(
   auto tree = halide2isl::makeScheduleTree(paramSpace, components.stmt);
   scop->scheduleTreeUPtr = std::move(tree.tree);
   scop->reads = tree.reads;
-  scop->writes = tree.writes;
+  scop->mayWrites = tree.writes;
+  scop->mustWrites = isl::union_map::empty(scop->mayWrites.get_space());
   scop->halide.statements = std::move(tree.statements);
   scop->halide.accesses = std::move(tree.accesses);
   scop->halide.reductions = halide2isl::findReductions(components.stmt);
@@ -109,7 +110,8 @@ const isl::union_set Scop::domain() const {
 std::ostream& operator<<(std::ostream& os, const Scop& s) {
   os << "domain: " << s.domain() << "\n";
   os << "reads: " << s.reads << "\n";
-  os << "writes: " << s.writes << "\n";
+  os << "mayWrites: " << s.mayWrites << "\n";
+  os << "mustWrites: " << s.mustWrites << "\n";
   os << "schedule: " << *s.scheduleRoot() << "\n";
   os << "idx: { ";
   for (auto i : s.halide.idx) {
@@ -373,7 +375,7 @@ isl::schedule_constraints makeScheduleConstraints(
   auto schedule = toIslSchedule(scop.scheduleRoot());
   auto firstChildNode = scop.scheduleRoot()->child({0});
   auto reads = scop.reads.domain_factor_domain();
-  auto writes = scop.writes.domain_factor_domain();
+  auto writes = scop.mayWrites.domain_factor_domain();
 
   // RAW
   auto flowDeps = computeDependences(writes, reads, schedule);

tc/core/polyhedral/scop.h

@@ -66,7 +66,8 @@ struct Scop {
     res->globalParameterContext = scop.globalParameterContext;
     res->halide = scop.halide;
     res->reads = scop.reads;
-    res->writes = scop.writes;
+    res->mayWrites = scop.mayWrites;
+    res->mustWrites = scop.mustWrites;
     res->scheduleTreeUPtr =
         detail::ScheduleTree::makeScheduleTree(*scop.scheduleTreeUPtr);
     res->treeSyncUpdateMap = scop.treeSyncUpdateMap;
@@ -115,7 +116,8 @@ struct Scop {
   void specializeToContext() {
     domain() = domain().intersect_params(globalParameterContext);
     reads = reads.intersect_params(globalParameterContext);
-    writes = writes.intersect_params(globalParameterContext);
+    mayWrites = mayWrites.intersect_params(globalParameterContext);
+    mustWrites = mustWrites.intersect_params(globalParameterContext);
   }
 
   // Returns a set that specializes the named scop's subset of
@@ -442,8 +444,14 @@ struct Scop {
   // This globalParameterContext lives in a parameter space.
   isl::set globalParameterContext; // TODO: not too happy about this name
 
+  // Access relations.
+  // Elements in mayWrite may or may not be written by the execution, depending
+  // on some dynamic condition.  Those in mustWrites are always written.
+  // Thefore, mayWrites do not participate in transitively-covered dependence
+  // removal.
   isl::union_map reads;
-  isl::union_map writes;
+  isl::union_map mayWrites;
+  isl::union_map mustWrites;
 
  private:
   // By analogy with generalized functions, a ScheduleTree is a (piecewise