Merge pull request #479 from facebookresearch/pr/cpp

avoid using functions that will not be added to mainline isl C++ interface

Author: skimo-openhub

tc/core/halide2isl.cc

@@ -264,15 +264,15 @@ isl::map extractAccess(
   // the allocation could be accessed.
   isl::set access = isl::set::universe(tensorSpace);
 
+  auto identity = isl::multi_aff::identity(tensorSpace.map_from_set());
   for (size_t i = 0; i < args.size(); i++) {
     // Then add one equality constraint per dimension to encode the
     // point in the allocation actually read/written for each point in
     // the iteration space. In the case of gathers or scatters, we may
     // have to leave some things unconstrained.
 
     // The coordinate written to in the range ...
-    auto rangePoint =
-        isl::pw_aff(isl::local_space(tensorSpace), isl::dim_type::set, i);
+    auto rangePoint = identity.get_aff(i);
     // ... equals the coordinate accessed as a function of the parameters.
     auto domainPoint = halide2isl::makeIslAffFromExpr(tensorSpace, args[i]);
     if (!domainPoint.is_null()) {
@@ -441,7 +441,7 @@ isl::schedule makeScheduleTreeHelper(
     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());
+    tupleSpace = tupleSpace.named_set_from_params_id(id, outer.size());
     IterationDomain iterationDomain;
     iterationDomain.paramSpace = set.get_space();
     iterationDomain.tuple = isl::multi_id(tupleSpace, outer);

tc/core/polyhedral/cuda/memory_promotion_heuristic.cc

@@ -206,15 +206,16 @@ bool hasReuseWithin(
  * dimensions unchanged.
  */
 isl::map makeNextElementMap(isl::space setSpace, unsigned dim) {
-  if (dim < 0 || dim >= setSpace.dim(isl::dim_type::set)) {
+  auto mapSpace = setSpace.map_from_set();
+  auto identityMA = isl::multi_aff::identity(mapSpace);
+
+  size_t size = identityMA.size();
+  if (dim < 0 || dim >= size) {
     std::stringstream ss;
-    ss << dim << "  is out of [0, " << setSpace.dim(isl::dim_type::set)
-       << ") range";
+    ss << dim << "  is out of [0, " << size << ") range";
     throw promotion::OutOfRangeException(ss.str());
   }
 
-  auto mapSpace = setSpace.map_from_set();
-  auto identityMA = isl::multi_aff::identity(mapSpace);
   auto aff = identityMA.get_aff(dim);
   identityMA = identityMA.set_aff(dim, aff + 1);
   return isl::map(identityMA);
@@ -266,6 +267,7 @@ bool promotionImprovesCoalescing(
     isl::union_map schedule) {
   auto originalAccesses = group.originalAccesses();
 
+  auto tensorDim = group.approximation.dim();
   auto markers = collectBranchMarkers(root, node);
   for (auto marker : markers) {
     auto mapping = findThreadMappingAncestor(root, marker);
@@ -280,8 +282,7 @@ bool promotionImprovesCoalescing(
     for (auto access : isl::UnionAsVector<isl::union_map>(scheduledAccesses)) {
       auto scheduleSpace = access.get_space().domain();
       auto tensorSpace = access.get_space().range();
-      auto elementToNext = makeNextElementMap(
-          tensorSpace, tensorSpace.dim(isl::dim_type::set) - 1);
+      auto elementToNext = makeNextElementMap(tensorSpace, tensorDim - 1);
       auto scheduleToNextX = makeNextElementMap(scheduleSpace, depth - 1);
       auto accessedByAdjacentX =
           scheduleToNextX.apply_domain(access).apply_range(access);

tc/core/polyhedral/memory_promotion.cc

@@ -77,14 +77,6 @@ ScopedFootprint outputRanges(isl::map access) {
   footprint.box = access.get_range_simple_fixed_box_hull();
   return footprint;
 }
-
-// Given a set space, construct a map space with the input as domain and
-// a range of the given size.
-isl::space add_range(isl::space space, unsigned dim) {
-  auto range = space.params().unnamed_set_from_params(dim);
-  return space.map_from_domain_and_range(range);
-}
-
 } // namespace
 
 // Access has the shape :: [S -> ref] -> O
@@ -119,14 +111,14 @@ isl::map TensorReferenceGroup::approximateScopedAccesses() const {
   auto scopedDomain = scopedAccesses().domain();
   auto space = approximation.box.get_space();
   auto accessed = isl::map::universe(space).intersect_domain(scopedDomain);
-  auto lspace = isl::local_space(accessed.get_space().range());
 
+  auto identity = isl::multi_aff::identity(space.range().map_from_set());
   for (size_t i = 0; i < approximation.dim(); ++i) {
     auto offset = approximation.lowerBound(i);
     auto stride = approximation.stride(i);
     auto strideOffset = approximation.strideOffset(i);
     auto size = approximation.size(i);
-    auto rhs = isl::aff(lspace, isl::dim_type::set, i);
+    auto rhs = identity.get_aff(i);
     auto lowerBound = offset * stride + strideOffset;
     auto upperBound = (offset + size) * stride + strideOffset;
     auto partial =
@@ -160,9 +152,9 @@ isl::set TensorReferenceGroup::promotedFootprint() const {
   }
 
   isl::set footprint = isl::set::universe(space);
-  auto lspace = isl::local_space(space);
+  auto identity = isl::multi_aff::identity(space.map_from_set());
   for (size_t i = 0, e = sizes.size(); i < e; ++i) {
-    auto aff = isl::aff(lspace, isl::dim_type::out, i);
+    auto aff = identity.get_aff(i);
     auto size = sizes.get_val(i);
     footprint =
         footprint & (isl::aff_set(aff) >= 0) & (isl::aff_set(aff) < size);
@@ -422,12 +414,13 @@ isl::set tensorElementsSet(const Scop& scop, isl::id tensorId) {
   space = space.named_set_from_params_id(tensorId, nDim);
 
   auto tensorElements = isl::set::universe(space);
+  auto identity = isl::multi_aff::identity(space.range().map_from_set());
   for (int i = 0; i < nDim; ++i) {
     auto minAff = halide2isl::makeIslAffFromExpr(
         space, halideParameter.min_constraint(i));
     auto extentAff = halide2isl::makeIslAffFromExpr(
         space, halideParameter.extent_constraint(i));
-    auto aff = isl::aff(isl::local_space(space), isl::dim_type::set, i);
+    auto aff = identity.get_aff(i);
     tensorElements = tensorElements & (minAff <= isl::aff_set(aff)) &
         (isl::aff_set(aff) < (minAff + extentAff));
   }
@@ -456,7 +449,7 @@ isl::multi_aff dropDummyTensorDimensions(
     }
   }
 
-  space = add_range(space, list.size());
+  space = addRange(space, list.size());
   return isl::multi_aff(space, list);
 }
 

tc/core/polyhedral/schedule_tree_elem.cc

@@ -159,7 +159,11 @@ void ScheduleTreeElemBand::drop(size_t pos, size_t n) {
   TC_CHECK_GE(nMember(), pos + n) << "range out of bounds";
   auto nBegin = nMember();
 
-  mupa_ = mupa_.drop_dims(isl::dim_type::set, pos, n);
+  auto list = mupa_.get_union_pw_aff_list();
+  auto space = mupa_.get_space().domain();
+  list = list.drop(pos, n);
+  space = addRange(space, list.size());
+  mupa_ = isl::multi_union_pw_aff(space, list);
 
   std::copy(
       coincident_.begin() + pos + n,

tc/core/polyhedral/unroll.cc

@@ -93,11 +93,14 @@ isl::val boundInstancesAndMarkUnroll(
   auto partial = band->mupa_;
   auto n = band->nMember();
 
+  auto list = partial.get_union_pw_aff_list();
+  auto space = partial.get_space().domain();
   for (int i = n - 1; i >= 0; --i) {
     auto member = partial.get_union_pw_aff(i);
     auto outerMap = prefix;
     if (i > 0) {
-      auto outer = partial.drop_dims(isl::dim_type::set, i, n - i);
+      list = list.drop(i, 1);
+      auto outer = isl::multi_union_pw_aff(addRange(space, list.size()), list);
       outerMap = outerMap.flat_range_product(isl::union_map::from(outer));
     }
     bound = bound.mul(relativeRange(outerMap, member));

tc/external/detail/islpp.h

@@ -280,11 +280,19 @@ inline bool operator!=(const isl::id& id1, const isl::id& id2) {
 ///////////////////////////////////////////////////////////////////////////////
 // Helper functions
 ///////////////////////////////////////////////////////////////////////////////
+
+// Given a set space, construct a map space with the input as domain and
+// a range of the given size.
+inline isl::space addRange(isl::space space, unsigned dim) {
+  auto range = space.params().unnamed_set_from_params(dim);
+  return space.map_from_domain_and_range(range);
+}
+
 // Given a space and a list of values, this returns the corresponding multi_val.
 template <typename T>
 isl::multi_val makeMultiVal(isl::space s, const std::vector<T>& vals) {
   isl::multi_val mv = isl::multi_val::zero(s);
-  TC_CHECK_EQ(vals.size(), s.dim(isl::dim_type::set));
+  TC_CHECK_EQ(vals.size(), static_cast<size_t>(mv.size()));
   for (size_t i = 0; i < vals.size(); ++i) {
     mv = mv.set_val(i, isl::val(s.get_ctx(), vals[i]));
   }

test/test_cuda_mapper.cc

@@ -535,11 +535,7 @@ TEST_F(PolyhedralMapperTest, Match1) {
 
   auto mscop = TileAndMapThreads(std::move(scop), {16, 16}, {32ul, 8ul});
   auto f = match(
-      band(sequence(
-          filter([](isl::union_set f) {
-            return f.get_space().dim(isl::dim_type::param) == 3;
-          }),
-          filter())),
+      band(sequence(filter([](isl::union_set f) { return true; }), filter())),
       schedule);
   EXPECT_EQ(1u, f.size());
 }