[Polly][DependenceInfo] Simplify use of StmtSchedule's domain [NFC]

[bollu]

Summary

Once a StmtSchedule is created, only its domain is used anywhere within
DependenceInfo::calculateDependences. So, we choose to return the
wrapped domain of the union_map rather than the entire union_map.

However, we still build the union_map first within collectInfo(). It is
cleaner to first build the entire union_map and then pull the domain out in
one shot, rather than repeatedly extracting the domain in bits and pieces
from accdom.

[Meinersbur]

Nice simplification.

lib/Analysis/DependenceInfo.cpp

117 ↗

(On Diff #89229)

The domain of a schedule is a statement's domain. That is, StmtDomain instead of StmtScheduleDomain is enough.

Or something more specific: TaggedDomain

303 ↗

(On Diff #89229)

Here as well just StmtDomain.

[grosser]

Siddharth does not yet have commit rights. You might need to commit this for him.

@Siddharth, please ask Chris Lattner for commit rights [1]. You will work a lot on Polly over the next time. You will certainly need them.

[1] http://llvm.org/docs/DeveloperPolicy.html#obtaining-commit-access

polly/trunk/lib/Analysis/DependenceInfo.cpp

static __isl_give isl_map *tag(__isl_take isl_map *Relation, MemoryAccess *MA,
   // No need to tag at the statement level.
   return Relation;
 }
 
 /// Collect information about the SCoP @p S.
 static void collectInfo(Scop &S, isl_union_map **Read, isl_union_map **Write,
                         isl_union_map **MayWrite,
                         isl_union_map **ReductionTagMap,
-                        isl_union_map **StmtSchedule,
+                        isl_union_set **StmtScheduleDomain,
                         Dependences::AnalysisLevel Level) {
   isl_space *Space = S.getParamSpace();
   *Read = isl_union_map_empty(isl_space_copy(Space));
   *Write = isl_union_map_empty(isl_space_copy(Space));
   *MayWrite = isl_union_map_empty(isl_space_copy(Space));
   *ReductionTagMap = isl_union_map_empty(isl_space_copy(Space));
-  *StmtSchedule = isl_union_map_empty(Space);
+  isl_union_map *StmtSchedule = isl_union_map_empty(Space);
 
   SmallPtrSet<const ScopArrayInfo *, 8> ReductionArrays;
   if (UseReductions)
     for (ScopStmt &Stmt : S)
       for (MemoryAccess *MA : Stmt)
         if (MA->isReductionLike())
           ReductionArrays.insert(MA->getScopArrayInfo());
 
for (MemoryAccess *MA : Stmt) {
       } else {
         accdom = tag(accdom, MA, Level);
         if (Level > Dependences::AL_Statement) {
           auto *StmtScheduleMap = Stmt.getSchedule();
           assert(StmtScheduleMap &&
                  "Schedules that contain extension nodes require special "
                  "handling.");
           isl_map *Schedule = tag(StmtScheduleMap, MA, Level);
-          *StmtSchedule = isl_union_map_add_map(*StmtSchedule, Schedule);
+          StmtSchedule = isl_union_map_add_map(StmtSchedule, Schedule);
         }
       }
 
       if (MA->isRead())
         *Read = isl_union_map_add_map(*Read, accdom);
       else
         *Write = isl_union_map_add_map(*Write, accdom);
     }
 
     if (!ReductionArrays.empty() && Level == Dependences::AL_Statement)
-      *StmtSchedule = isl_union_map_add_map(*StmtSchedule, Stmt.getSchedule());
+      StmtSchedule = isl_union_map_add_map(StmtSchedule, Stmt.getSchedule());
   }
 
-  *StmtSchedule =
-      isl_union_map_intersect_params(*StmtSchedule, S.getAssumedContext());
+  StmtSchedule =
+      isl_union_map_intersect_params(StmtSchedule, S.getAssumedContext());
+  *StmtScheduleDomain = isl_union_map_domain(StmtSchedule);
 
   *ReductionTagMap = isl_union_map_coalesce(*ReductionTagMap);
   *Read = isl_union_map_coalesce(*Read);
   *Write = isl_union_map_coalesce(*Write);
   *MayWrite = isl_union_map_coalesce(*MayWrite);
 }
 
 /// Fix all dimension of @p Zero to 0 and add it to @p user
static __isl_give isl_union_flow *buildFlow(__isl_keep isl_union_map *Snk,
   auto Flow = isl_union_access_info_compute_flow(AI);
   DEBUG(if (!Flow) dbgs() << "last error: "
                           << isl_ctx_last_error(isl_schedule_get_ctx(Schedule))
                           << '\n';);
   return Flow;
 }
 
 void Dependences::calculateDependences(Scop &S) {
-  isl_union_map *Read, *Write, *MayWrite, *ReductionTagMap, *StmtSchedule;
+  isl_union_map *Read, *Write, *MayWrite, *ReductionTagMap;
   isl_schedule *Schedule;
+  isl_union_set *StmtScheduleDomain;
 
   DEBUG(dbgs() << "Scop: \n" << S << "\n");
 
-  collectInfo(S, &Read, &Write, &MayWrite, &ReductionTagMap, &StmtSchedule,
-              Level);
+  collectInfo(S, &Read, &Write, &MayWrite, &ReductionTagMap,
+              &StmtScheduleDomain, Level);
 
   bool HasReductions = !isl_union_map_is_empty(ReductionTagMap);
 
   DEBUG(dbgs() << "Read: " << Read << '\n';
         dbgs() << "Write: " << Write << '\n';
         dbgs() << "MayWrite: " << MayWrite << '\n';
         dbgs() << "ReductionTagMap: " << ReductionTagMap << '\n';
-        dbgs() << "StmtSchedule: " << StmtSchedule << '\n';);
+        dbgs() << "StmtScheduleDomain: " << StmtScheduleDomain << '\n';);
 
   Schedule = S.getScheduleTree();
 
   if (!HasReductions) {
     isl_union_map_free(ReductionTagMap);
     // Tag the schedule tree if we want fine-grain dependence info
     if (Level > AL_Statement) {
-      auto TaggedDom = isl_union_map_domain((isl_union_map_copy(StmtSchedule)));
-      auto TaggedMap = isl_union_set_unwrap(TaggedDom);
+      auto TaggedMap =
+          isl_union_set_unwrap(isl_union_set_copy(StmtScheduleDomain));
       auto Tags = isl_union_map_domain_map_union_pw_multi_aff(TaggedMap);
       Schedule = isl_schedule_pullback_union_pw_multi_aff(Schedule, Tags);
     }
   } else {
     isl_union_set *IdentityDom;
     isl_union_map *IdentityMap;
     isl_union_pw_multi_aff *ReductionTags, *IdentityTags, *Tags;
 
     // Extract Reduction tags from the combined access domains in the given
     // SCoP. The result is a map that maps each tagged element in the domain to
     // the memory location it accesses. ReductionTags = {[Stmt[i] ->
     // Array[f(i)]] -> Stmt[i] }
     ReductionTags =
         isl_union_map_domain_map_union_pw_multi_aff(ReductionTagMap);
 
     // Compute an identity map from each statement in domain to itself.
     // IdentityTags = { [Stmt[i] -> Stmt[i] }
-    IdentityDom = isl_union_map_domain(isl_union_map_copy(StmtSchedule));
-    IdentityMap = isl_union_set_identity(IdentityDom);
+    IdentityMap =
+        isl_union_set_identity(isl_union_set_copy(StmtScheduleDomain));
     IdentityTags = isl_union_pw_multi_aff_from_union_map(IdentityMap);
 
     Tags = isl_union_pw_multi_aff_union_add(ReductionTags, IdentityTags);
 
     // By pulling back Tags from Schedule, we have a schedule tree that can
     // be used to compute normal dependences, as well as 'tagged' reduction
     // dependences.
     Schedule = isl_schedule_pullback_union_pw_multi_aff(Schedule, Tags);
if (isl_ctx_last_error(IslCtx.get()) == isl_error_quota) {
     RAW = WAW = WAR = nullptr;
     isl_ctx_reset_error(IslCtx.get());
   }
 
   // Drop out early, as the remaining computations are only needed for
   // reduction dependences or dependences that are finer than statement
   // level dependences.
   if (!HasReductions && Level == AL_Statement) {
-    TC_RED = isl_union_map_empty(isl_union_map_get_space(StmtSchedule));
-    isl_union_map_free(StmtSchedule);
+    TC_RED = isl_union_map_empty(isl_union_set_get_space(StmtScheduleDomain));
+    isl_union_set_free(StmtScheduleDomain);
     return;
   }
 
   isl_union_map *STMT_RAW, *STMT_WAW, *STMT_WAR;
   STMT_RAW = isl_union_map_intersect_domain(
-      isl_union_map_copy(RAW),
-      isl_union_map_domain(isl_union_map_copy(StmtSchedule)));
+      isl_union_map_copy(RAW), isl_union_set_copy(StmtScheduleDomain));
   STMT_WAW = isl_union_map_intersect_domain(
-      isl_union_map_copy(WAW),
-      isl_union_map_domain(isl_union_map_copy(StmtSchedule)));
+      isl_union_map_copy(WAW), isl_union_set_copy(StmtScheduleDomain));
   STMT_WAR = isl_union_map_intersect_domain(isl_union_map_copy(WAR),
-                                            isl_union_map_domain(StmtSchedule));
+                                            StmtScheduleDomain);
   DEBUG({
     dbgs() << "Wrapped Dependences:\n";
     dump();
     dbgs() << "\n";
   });
 
   // To handle reduction dependences we proceed as follows:
   // 1) Aggregate all possible reduction dependences, namely all self