rename ScheduleTreeElemMappingFilter to ScheduleTreeElemMapping

Sven Verdoolaege · Sven Verdoolaege · commit 3273fc8eefb4 · 2018-06-15T15:01:09.000+02:00
Since a ScheduleTreeElemMappingFilter is no longer
a ScheduleTreeElemFilter, it doesn't need to be called a filter anymore.
diff --git a/tc/core/polyhedral/cuda/mapped_scop.cc b/tc/core/polyhedral/cuda/mapped_scop.cc
@@ -65,7 +65,7 @@ void validate(const detail::ScheduleTree* root) {
       filter(
           [](isl::union_set uset) { return !uset || uset.is_empty(); }, any()),
       root);
-  throwIfHasPattern<EmptyMappingFilterException>(
+  throwIfHasPattern<EmptyMappingException>(
       mapping_filter(
           [](isl::union_set uset) { return !uset || uset.is_empty(); }, any()),
       root);
@@ -130,7 +130,7 @@ detail::ScheduleTree* MappedScop::map(
     idList.emplace_back(id);
   }
 
-  auto mapping = detail::ScheduleTree::makeMappingFilter(idList, affList);
+  auto mapping = detail::ScheduleTree::makeMapping(idList, affList);
   tree = insertNodeAbove(root, tree, std::move(mapping))->child({0});
 
   return tree;
diff --git a/tc/core/polyhedral/cuda/memory_promotion_heuristic.cc b/tc/core/polyhedral/cuda/memory_promotion_heuristic.cc
@@ -232,7 +232,7 @@ const detail::ScheduleTree* findThreadMappingAncestor(
   auto ancestors = node->ancestors(root);
   ancestors = functional::Filter(isMappingTo<mapping::ThreadId>, ancestors);
   if (ancestors.size() < 1) {
-    throw promotion::PromotionLogicError("missing MappingFilter");
+    throw promotion::PromotionLogicError("missing Mapping");
   }
   return ancestors[0];
 }
@@ -301,12 +301,12 @@ template <typename MappingType>
 isl::union_set collectMappingsTo(const Scop& scop) {
   auto root = scop.scheduleRoot();
   auto domain = scop.domain();
-  auto mappingFilters = detail::ScheduleTree::collect(
-      root, detail::ScheduleTreeType::MappingFilter);
+  auto mappingFilters =
+      detail::ScheduleTree::collect(root, detail::ScheduleTreeType::Mapping);
   mappingFilters = functional::Filter(isMappingTo<MappingType>, mappingFilters);
   auto mapping = isl::union_set::empty(domain.get_space());
   for (auto mf : mappingFilters) {
-    auto filterNode = mf->elemAs<detail::ScheduleTreeElemMappingFilter>();
+    auto filterNode = mf->elemAs<detail::ScheduleTreeElemMapping>();
     auto filter = filterNode->filter_.intersect(activeDomainPoints(root, mf));
     mapping = mapping.unite(filterNode->filter_);
   }
diff --git a/tc/core/polyhedral/cuda/tighten_launch_bounds.cc b/tc/core/polyhedral/cuda/tighten_launch_bounds.cc
@@ -74,10 +74,10 @@ size_t maxValue(const Scop& scop, const MappingIdType& id) {
   size_t sizetMax = std::numeric_limits<size_t>::max();
   size_t max = 0;
   size_t min = sizetMax;
-  auto filters = root->collect(root, ScheduleTreeType::MappingFilter);
+  auto filters = root->collect(root, ScheduleTreeType::Mapping);
   filters = functional::Filter(isMappingTo<MappingIdType>, filters);
   for (auto p : filters) {
-    auto mappingNode = p->elemAs<ScheduleTreeElemMappingFilter>();
+    auto mappingNode = p->elemAs<ScheduleTreeElemMapping>();
     auto active = activeDomainPoints(root, p).intersect_params(params);
     active = active.intersect(mappingNode->filter_);
     auto range = rangeOfMappingParameter(active.params(), id);
diff --git a/tc/core/polyhedral/exceptions.h b/tc/core/polyhedral/exceptions.h
@@ -25,8 +25,8 @@ struct EmptyFilterException : public std::runtime_error {
   explicit EmptyFilterException(const std::string& s) : std::runtime_error(s) {}
 };
 
-struct EmptyMappingFilterException : public std::runtime_error {
-  explicit EmptyMappingFilterException(const std::string& s)
+struct EmptyMappingException : public std::runtime_error {
+  explicit EmptyMappingException(const std::string& s)
       : std::runtime_error(s) {}
 };
 
diff --git a/tc/core/polyhedral/schedule_isl_conversion.cc b/tc/core/polyhedral/schedule_isl_conversion.cc
@@ -180,7 +180,7 @@ isl::schedule_node insert(isl::schedule_node node, const ScheduleTree* st) {
     node = node.insert_context(context->context_);
   } else if (auto filter = st->elemAs<ScheduleTreeElemFilter>()) {
     node = node.insert_filter(filter->filter_);
-  } else if (auto filter = st->elemAs<ScheduleTreeElemMappingFilter>()) {
+  } else if (auto filter = st->elemAs<ScheduleTreeElemMapping>()) {
     node = node.insert_filter(filter->filter_);
   } else if (
       st->elemAs<ScheduleTreeElemSet>() ||
diff --git a/tc/core/polyhedral/schedule_print.cc b/tc/core/polyhedral/schedule_print.cc
@@ -122,7 +122,7 @@ std::ostream& operator<<(std::ostream& os, detail::ScheduleTreeType nt) {
     os << "extension";
   } else if (nt == detail::ScheduleTreeType::Filter) {
     os << "filter";
-  } else if (nt == detail::ScheduleTreeType::MappingFilter) {
+  } else if (nt == detail::ScheduleTreeType::Mapping) {
     os << "mapping_filter";
   } else if (nt == detail::ScheduleTreeType::Sequence) {
     os << "sequence";
@@ -200,7 +200,7 @@ std::ostream& ScheduleTreeElemFilter::write(std::ostream& os) const {
   return os;
 }
 
-std::ostream& ScheduleTreeElemMappingFilter::write(std::ostream& os) const {
+std::ostream& ScheduleTreeElemMapping::write(std::ostream& os) const {
   WS w;
   os << w.tab() << "mapping_filter(ids(";
   for (auto& kvp : mapping) {
diff --git a/tc/core/polyhedral/schedule_transforms.cc b/tc/core/polyhedral/schedule_transforms.cc
@@ -113,10 +113,10 @@ isl::union_set applyFilter(isl::union_set domain, const ScheduleTree* node) {
 }
 
 /*
- * If "node" is a mapping filter, then intersect "domain" with that filter.
+ * If "node" is a mapping, then intersect "domain" with its filter.
  */
 isl::union_set applyMapping(isl::union_set domain, const ScheduleTree* node) {
-  if (auto filterElem = node->elemAs<ScheduleTreeElemMappingFilter>()) {
+  if (auto filterElem = node->elemAs<ScheduleTreeElemMapping>()) {
     return domain.intersect(filterElem->filter_);
   }
   return domain;
@@ -736,7 +736,7 @@ namespace {
 void gist(ScheduleTree* tree, isl::union_set context) {
   if (auto bandElem = tree->elemAs<ScheduleTreeElemBand>()) {
     bandElem->mupa_ = bandElem->mupa_.gist(context);
-  } else if (auto filterElem = tree->elemAs<ScheduleTreeElemMappingFilter>()) {
+  } else if (auto filterElem = tree->elemAs<ScheduleTreeElemMapping>()) {
     filterElem->filter_ = filterElem->filter_.gist(context);
   } else if (auto filterElem = tree->elemAs<ScheduleTreeElemFilter>()) {
     filterElem->filter_ = filterElem->filter_.gist(context);
@@ -855,8 +855,8 @@ isl::multi_union_pw_aff extractDomainToIds(
   auto zero = isl::multi_val::zero(space);
   auto domainToIds = isl::multi_union_pw_aff(empty, zero);
 
-  for (auto mapping : tree->collect(tree, ScheduleTreeType::MappingFilter)) {
-    auto mappingNode = mapping->elemAs<ScheduleTreeElemMappingFilter>();
+  for (auto mapping : tree->collect(tree, ScheduleTreeType::Mapping)) {
+    auto mappingNode = mapping->elemAs<ScheduleTreeElemMapping>();
     auto list = isl::union_pw_aff_list(tree->ctx_, ids.size());
     for (auto id : ids) {
       if (mappingNode->mapping.count(id) == 0) {
diff --git a/tc/core/polyhedral/schedule_transforms.h b/tc/core/polyhedral/schedule_transforms.h
@@ -348,7 +348,7 @@ template <typename MappingType>
 bool isMappingTo(const detail::ScheduleTree* tree) {
   using namespace detail;
 
-  if (auto filterNode = tree->elemAs<ScheduleTreeElemMappingFilter>()) {
+  if (auto filterNode = tree->elemAs<ScheduleTreeElemMapping>()) {
     for (auto& kvp : filterNode->mapping) {
       if (kvp.first.is<MappingType>()) {
         return true;
diff --git a/tc/core/polyhedral/schedule_tree-inl.h b/tc/core/polyhedral/schedule_tree-inl.h
@@ -21,13 +21,13 @@ namespace tc {
 namespace polyhedral {
 namespace detail {
 template <typename MappingIdType>
-inline ScheduleTreeUPtr ScheduleTree::makeMappingFilter(
+inline ScheduleTreeUPtr ScheduleTree::makeMapping(
     const std::vector<MappingIdType>& mappedIds,
     isl::union_pw_aff_list mappedAffs,
     std::vector<ScheduleTreeUPtr>&& children) {
   TC_CHECK_EQ(mappedIds.size(), static_cast<size_t>(mappedAffs.n()))
       << "expected as many mapped ids as affs";
-  ScheduleTreeElemMappingFilter::Mapping mapping;
+  ScheduleTreeElemMapping::Mapping mapping;
   for (size_t i = 0, n = mappedAffs.n(); i < n; ++i) {
     mapping.emplace(mappedIds.at(i), mappedAffs.get(i));
   }
@@ -36,9 +36,9 @@ inline ScheduleTreeUPtr ScheduleTree::makeMappingFilter(
       << "some id is used more than once in the mapping";
   auto ctx = mappedIds[0].get_ctx();
   ScheduleTreeUPtr res(new ScheduleTree(ctx));
-  res->elem_ = std::unique_ptr<ScheduleTreeElemMappingFilter>(
-      new ScheduleTreeElemMappingFilter(mapping));
-  res->type_ = ScheduleTreeType::MappingFilter;
+  res->elem_ = std::unique_ptr<ScheduleTreeElemMapping>(
+      new ScheduleTreeElemMapping(mapping));
+  res->type_ = ScheduleTreeType::Mapping;
   res->appendChildren(std::move(children));
   return res;
 }
diff --git a/tc/core/polyhedral/schedule_tree.h b/tc/core/polyhedral/schedule_tree.h
@@ -272,7 +272,7 @@ struct ScheduleTree {
       std::vector<ScheduleTreeUPtr>&& children = {});
 
   template <typename MappingIdType>
-  static inline ScheduleTreeUPtr makeMappingFilter(
+  static inline ScheduleTreeUPtr makeMapping(
       const std::vector<MappingIdType>& mappedIds,
       isl::union_pw_aff_list mappedAffs,
       std::vector<ScheduleTreeUPtr>&& children = {});
@@ -312,12 +312,12 @@ struct ScheduleTree {
   }
 
   template <typename MappingIdType, typename... Args>
-  static inline ScheduleTreeUPtr makeMappingFilter(
+  static inline ScheduleTreeUPtr makeMapping(
       isl::union_set filter,
       const std::unordered_set<MappingIdType, typename MappingIdType::Hash>&
           mappingIds,
       Args&&... args) {
-    return makeMappingFilter(
+    return makeMapping(
         filter,
         mappingIds,
         vectorFromArgs<ScheduleTreeUPtr>(std::forward<Args>(args)...));
diff --git a/tc/core/polyhedral/schedule_tree_elem.cc b/tc/core/polyhedral/schedule_tree_elem.cc
@@ -111,7 +111,7 @@ std::unique_ptr<ScheduleTreeElemBase> ScheduleTreeElemBase::make(
   ELEM_MAKE_CASE(ScheduleTreeElemDomain)
   ELEM_MAKE_CASE(ScheduleTreeElemExtension)
   ELEM_MAKE_CASE(ScheduleTreeElemFilter)
-  ELEM_MAKE_CASE(ScheduleTreeElemMappingFilter)
+  ELEM_MAKE_CASE(ScheduleTreeElemMapping)
   ELEM_MAKE_CASE(ScheduleTreeElemSequence)
   ELEM_MAKE_CASE(ScheduleTreeElemSet)
   ELEM_MAKE_CASE(ScheduleTreeElemThreadSpecificMarker)
@@ -256,8 +256,8 @@ bool ScheduleTreeElemFilter::operator==(
   return res;
 }
 
-bool ScheduleTreeElemMappingFilter::operator==(
-    const ScheduleTreeElemMappingFilter& other) const {
+bool ScheduleTreeElemMapping::operator==(
+    const ScheduleTreeElemMapping& other) const {
   auto res = filter_.is_equal(other.filter_);
   return res;
 }
@@ -288,7 +288,7 @@ bool elemEquals(
   ELEM_EQUALS_CASE(ScheduleTreeElemDomain)
   ELEM_EQUALS_CASE(ScheduleTreeElemExtension)
   ELEM_EQUALS_CASE(ScheduleTreeElemFilter)
-  ELEM_EQUALS_CASE(ScheduleTreeElemMappingFilter)
+  ELEM_EQUALS_CASE(ScheduleTreeElemMapping)
   ELEM_EQUALS_CASE(ScheduleTreeElemSequence)
   ELEM_EQUALS_CASE(ScheduleTreeElemSet)
   else {
diff --git a/tc/core/polyhedral/schedule_tree_elem.h b/tc/core/polyhedral/schedule_tree_elem.h
@@ -38,7 +38,7 @@ enum class ScheduleTreeType {
   Filter,
   Sequence,
   Set,
-  MappingFilter,
+  Mapping,
   ThreadSpecificMarker,
   Any,
 };
@@ -131,17 +131,17 @@ struct ScheduleTreeElemFilter : public ScheduleTreeElemBase {
   }
 };
 
-struct ScheduleTreeElemMappingFilter : public ScheduleTreeElemBase {
+struct ScheduleTreeElemMapping : public ScheduleTreeElemBase {
   using Mapping = std::unordered_map<
       mapping::MappingId,
       isl::union_pw_aff,
       typename mapping::MappingId::Hash>;
   static constexpr detail::ScheduleTreeType NodeType =
-      detail::ScheduleTreeType::MappingFilter;
-  ScheduleTreeElemMappingFilter() = delete;
-  ScheduleTreeElemMappingFilter(const ScheduleTreeElemMappingFilter& eb)
+      detail::ScheduleTreeType::Mapping;
+  ScheduleTreeElemMapping() = delete;
+  ScheduleTreeElemMapping(const ScheduleTreeElemMapping& eb)
       : mapping(eb.mapping), filter_(eb.filter_) {}
-  ScheduleTreeElemMappingFilter(const Mapping& mapping)
+  ScheduleTreeElemMapping(const Mapping& mapping)
       : mapping(mapping), filter_(isl::union_set()) {
     TC_CHECK_GT(mapping.size(), 0u) << "empty mapping filter";
 
@@ -159,9 +159,9 @@ struct ScheduleTreeElemMappingFilter : public ScheduleTreeElemBase {
       filter_ = filter_.intersect(upa.zero_union_set());
     }
   }
-  virtual ~ScheduleTreeElemMappingFilter() override {}
-  bool operator==(const ScheduleTreeElemMappingFilter& other) const;
-  bool operator!=(const ScheduleTreeElemMappingFilter& other) const {
+  virtual ~ScheduleTreeElemMapping() override {}
+  bool operator==(const ScheduleTreeElemMapping& other) const;
+  bool operator!=(const ScheduleTreeElemMapping& other) const {
     return !(*this == other);
   }
   virtual std::ostream& write(std::ostream& os) const override;
diff --git a/tc/core/polyhedral/schedule_tree_matcher-inl.h b/tc/core/polyhedral/schedule_tree_matcher-inl.h
@@ -111,10 +111,10 @@ template <typename... Args>
 inline ScheduleTreeMatcher mapping_filter(
     std::function<bool(isl::union_set)> propertyMatcher,
     Args... children) {
-  ScheduleTreeMatcher m(detail::ScheduleTreeType::MappingFilter, children...);
+  ScheduleTreeMatcher m(detail::ScheduleTreeType::Mapping, children...);
   m.propertyMatcher_ = [propertyMatcher](const detail::ScheduleTree* tree) {
     return propertyMatcher(
-        tree->elemAs<detail::ScheduleTreeElemMappingFilter>()->filter_);
+        tree->elemAs<detail::ScheduleTreeElemMapping>()->filter_);
   };
   return m;
 }
@@ -123,7 +123,7 @@ template <typename... Args>
 inline ScheduleTreeMatcher mapping_filter(
     std::function<bool(const detail::ScheduleTree* tree)> propertyMatcher,
     Args... children) {
-  ScheduleTreeMatcher m(detail::ScheduleTreeType::MappingFilter, children...);
+  ScheduleTreeMatcher m(detail::ScheduleTreeType::Mapping, children...);
   m.propertyMatcher_ = propertyMatcher;
   return m;
 }
@@ -138,11 +138,11 @@ template <
         std::is_same<First, ScheduleTreeMatcher>::value>::type>
 inline ScheduleTreeMatcher mapping_filter(First first, Args... children) {
   return ScheduleTreeMatcher(
-      detail::ScheduleTreeType::MappingFilter, first, children...);
+      detail::ScheduleTreeType::Mapping, first, children...);
 }
 
 inline ScheduleTreeMatcher mapping_filter() {
-  return ScheduleTreeMatcher(detail::ScheduleTreeType::MappingFilter);
+  return ScheduleTreeMatcher(detail::ScheduleTreeType::Mapping);
 }
 
 template <typename... Args>
diff --git a/test/cuda/test_tc_mapper_bugs.cc b/test/cuda/test_tc_mapper_bugs.cc
@@ -632,7 +632,7 @@ TEST_F(TMM_128_1024_1024, TooStrictPrecisionAfterTuner) {
   Check(options);
 }
 
-// This exercises a former MappingFilter leaf with a union_set of > 1 spaces
+// This exercises a former Mapping leaf with a union_set of > 1 spaces
 TEST_F(TMM_128_1024_1024, Tightening) {
   Init();
   auto options = tc::CudaMappingOptions::makeNaiveMappingOptions()
diff --git a/test/test_cuda_mapper.cc b/test/test_cuda_mapper.cc
@@ -1099,7 +1099,7 @@ def fun(float(N) I) -> (O) {
  * Check that isolating the update statements does not introduce
  * an empty mapping filter.
  */
-TEST_F(PolyhedralMapperTest, EmptyMappingFilter) {
+TEST_F(PolyhedralMapperTest, EmptyMapping) {
   constexpr static auto tc = R"TC(
   def var_2D_1D(float(N, K) I, float(N) mean) -> (var)
   {
