move warning on positive minimal mapping to MappedScop::map

tightenLaunchBounds logs a warning if the minimum of
the block or thread mapping is strictly positive
since it would be possible to shift the mapping over that
minimum and further tighten the bounds.
Given the current infrastructure of TC, it is fairly
unlikely that this would happen and especially for this to happen
consistently over the entire tree.
Furthermore, by the time tightenLaunchBounds is called
it is too late to change the mapping.
Move the warning to where the mapping is constructed and
where it could in principle still be adjusted.

Author: Sven Verdoolaege

tc/core/polyhedral/cuda/mapped_scop.cc

@@ -48,6 +48,26 @@ namespace polyhedral {
 
 namespace {
 
+/*
+ * Check if the minimum of any affine function in "list" is strictly
+ * positive on "domain" and, if so, print a warning.
+ * The functions in "list" are used for mapping to block/thread identifiers.
+ * If the minimum is strictly positive, then this means some
+ * identifiers do nothing in the corresponding subtree.
+ * Note that tightenLaunchBounds (if extended to consider
+ * the minimal value of the mapping) may not help much because
+ * those identifiers may get used in other parts of the tree.
+ * Furthermore, at that point it is too late to change the mapping.
+ */
+static void checkMinimum(isl::union_set domain, isl::union_pw_aff_list list) {
+  for (auto upa : list) {
+    upa = upa.intersect_domain(domain);
+    auto min = upa.min_val();
+    LOG_IF(WARNING, min.is_pos())
+        << "Opportunity for shifting mapping -> min:" << min;
+  }
+}
+
 template <typename ExceptionType>
 inline void throwIfHasPattern(
     ScheduleTreeMatcher matcher,
@@ -111,7 +131,8 @@ detail::ScheduleTree* MappedScop::map(
   TC_CHECK_LE(nToMap, extent.size()) << "dimension overflow";
 
   auto root = scop_->scheduleRoot();
-  auto domain = activeDomainPoints(root, tree).universe();
+  auto domain = activeDomainPoints(root, tree);
+  auto universe = domain.universe();
 
   std::vector<MappingTypeId> idList;
   auto affList = isl::union_pw_aff_list(list.get_ctx(), 0);
@@ -127,10 +148,12 @@ detail::ScheduleTree* MappedScop::map(
   for (size_t i = nToMap; i < extent.size(); ++i) {
     auto id = MappingTypeId::makeId(i);
     affList = affList.add(
-        isl::union_pw_aff(domain, isl::val::zero(domain.get_ctx())));
+        isl::union_pw_aff(universe, isl::val::zero(domain.get_ctx())));
     idList.emplace_back(id);
   }
 
+  checkMinimum(domain, affList);
+
   auto mapping = detail::ScheduleTree::makeMapping(idList, affList);
   tree = insertNodeAbove(root, tree, std::move(mapping))->child({0});
 

tc/core/polyhedral/cuda/tighten_launch_bounds.cc

@@ -84,10 +84,6 @@ size_t maxValue(const Scop& scop, const MappingIdType& id) {
     min = std::min(min, range.first);
     max = std::max(max, range.second);
   }
-  // Ignore min for now but there is a future possibility for shifting
-  LOG_IF(WARNING, min > 0)
-      << "Opportunity for tightening launch bounds with shifting -> min:"
-      << min;
   TC_CHECK(max < sizetMax) << "missing mapping to " << id << "\n" << *root;
   TC_CHECK(min < sizetMax) << "missing mapping to " << id << " type\n" << *root;
   // Inclusive range needs + 1 to translate to sizes