[Polly][Isl] Use isl::set::tuple_dim, isl::map::domain_tuple_dim and isl::map::range_tuple_dim. NFC

[patacca]

Summary

This is part of an effort to reduce the differences between the custom C++ bindings used right now by polly in lib/External/isl/include/isl/isl-noxceptions.h and the official isl C++ interface.

Changes made:

• Use isl::set::tuple_dim instead of isl::set::dim and isl::set::n_dim
• Use isl::map::domain_tuple_dim instead of isl::map::dim
• Use isl::map::range_tuple_dim instead of isl::map::dim
• isl-noexceptions.h has been generated by this https://github.com/patacca/isl/commit/45576e1b4260f91946e4cf819485f57bd2ed5490

Note that not all the usage of isl::{set,map}::dim where replaced

[Meinersbur]

The patch includes changes to isl_map.c. It looks like that you cherry-picked a change from isl to include here. Please don't diverge the isl sources from upstream.

Usually we commit changes to isl itself separately. Use the script update-isl.sh for this. You can commit it separately without review, but ensure that you ran check-polly beforehand and add any additional files that were added in the isl repository. See rG842314b5f078b5c63df1d7e271fc6fad8461d44f as an example. Alternatively, ask me to make such a commit.

polly/lib/Analysis/ScopInfo.cpp

256

[nit] Change look unrelated

[patacca]

Rebase to main and revert the unrelated change (using auto instead of isl::set)

[Meinersbur]

LGTM

polly/lib/Analysis/ScopInfo.cpp

256

[nit] Unrelated change still present

[patacca]

Revert all the unrelated changes

polly/lib/Analysis/DependenceInfo.cpp

static void collectInfo(Scop &S, isl_union_map *&Read,
   ReductionTagMap = isl_union_map_coalesce(ReductionTagMap);
   Read = isl_union_map_coalesce(Read);
   MustWrite = isl_union_map_coalesce(MustWrite);
   MayWrite = isl_union_map_coalesce(MayWrite);
 }
 
 /// Fix all dimension of @p Zero to 0 and add it to @p user
 static void fixSetToZero(isl::set Zero, isl::union_set *User) {
-  for (auto i : seq<isl_size>(0, Zero.dim(isl::dim::set)))
+  for (auto i : seq<isl_size>(0, Zero.tuple_dim()))
     Zero = Zero.fix_si(isl::dim::set, i, 0);
   *User = User->add_set(Zero);
 }
 
 /// Compute the privatization dependences for a given dependency @p Map
 ///
 /// Privatization dependences are widened original dependences which originate
 /// or end in a reduction access. To compute them we apply the transitive close

polly/lib/Analysis/ScopBuilder.cpp

 /// This map maps from SetSpace -> SetSpace where the dimensions @p Dim
 /// is incremented by one and all other dimensions are equal, e.g.,
 ///             [i0, i1, i2, i3] -> [i0, i1, i2 + 1, i3]
 ///
 /// if @p Dim is 2 and @p SetSpace has 4 dimensions.
 static isl::map createNextIterationMap(isl::space SetSpace, unsigned Dim) {
   isl::space MapSpace = SetSpace.map_from_set();
   isl::map NextIterationMap = isl::map::universe(MapSpace);
-  for (auto u : seq<isl_size>(0, NextIterationMap.dim(isl::dim::in)))
+  for (auto u : seq<isl_size>(0, NextIterationMap.domain_tuple_dim()))
     if (u != (isl_size)Dim)
       NextIterationMap =
           NextIterationMap.equate(isl::dim::in, u, isl::dim::out, u);
   isl::constraint C =
       isl::constraint::alloc_equality(isl::local_space(MapSpace));
   C = C.set_constant_si(1);
   C = C.set_coefficient_si(isl::dim::in, Dim, 1);
   C = C.set_coefficient_si(isl::dim::out, Dim, -1);

 }
 
 /// Compute the (un)bounded parts of @p S wrt. to dimension @p Dim.
 ///
 /// @returns A separation of @p S into first an unbounded then a bounded subset,
 ///          both with regards to the dimension @p Dim.
 static std::pair<isl::set, isl::set> partitionSetParts(isl::set S,
                                                        unsigned Dim) {
-  for (unsigned u = 0, e = S.n_dim(); u < e; u++)
+  for (unsigned u = 0, e = S.tuple_dim(); u < e; u++)
     S = S.lower_bound_si(isl::dim::set, u, 0);
 
-  unsigned NumDimsS = S.n_dim();
+  unsigned NumDimsS = S.tuple_dim();
   isl::set OnlyDimS = S;
 
   // Remove dimensions that are greater than Dim as they are not interesting.
   assert(NumDimsS >= Dim + 1);
   OnlyDimS = OnlyDimS.project_out(isl::dim::set, Dim + 1, NumDimsS - Dim - 1);
 
   // Create artificial parametric upper bounds for dimensions smaller than Dim
   // as we are not interested in them.
if (OldDepth == NewDepth) {
     auto &R = scop->getRegion();
     (void)R;
     assert(NewL->getParentLoop() == OldL ||
            ((!OldL || !R.contains(OldL)) && R.contains(NewL)));
     Dom = Dom.add_dims(isl::dim::set, 1);
   } else {
     assert(OldDepth > NewDepth);
     int Diff = OldDepth - NewDepth;
-    int NumDim = Dom.n_dim();
+    int NumDim = Dom.tuple_dim();
     assert(NumDim >= Diff);
     Dom = Dom.project_out(isl::dim::set, NumDim - Diff, Diff);
   }
 
   return Dom;
 }
 
 /// Compute the isl representation for the SCEV @p E in this BB.
for (auto *RN : RTraversal) {
 
     if (isa<UnreachableInst>(TI))
       continue;
 
     if (!scop->isDomainDefined(BB))
       continue;
     isl::set Domain = scop->getDomainConditions(BB);
 
-    scop->updateMaxLoopDepth(isl_set_n_dim(Domain.get()));
+    scop->updateMaxLoopDepth(Domain.tuple_dim());
 
     auto *BBLoop = getRegionNodeLoop(RN, LI);
     // Propagate the domain from BB directly to blocks that have a superset
     // domain, at the moment only region exit nodes of regions that start in BB.
     propagateDomainConstraintsToRegionExit(BB, BBLoop, FinishedExitBlocks,
                                            InvalidDomainMap);
 
     // If all successors of BB have been set a domain through the propagation

 static isl::multi_union_pw_aff mapToDimension(isl::union_set USet, int N) {
   assert(N >= 0);
   assert(!USet.is_null());
   assert(!USet.is_empty());
 
   auto Result = isl::union_pw_multi_aff::empty(USet.get_space());
 
   for (isl::set S : USet.get_set_list()) {
-    int Dim = S.dim(isl::dim::set);
+    int Dim = S.tuple_dim();
     auto PMA = isl::pw_multi_aff::project_out_map(S.get_space(), isl::dim::set,
                                                   N, Dim - N);
     if (N > 1)
       PMA = PMA.drop_dims(isl::dim::out, 0, N - 1);
 
     Result = Result.add_pw_multi_aff(PMA);
   }
 
for (auto Array : scop->arrays()) {
 
     if (!Accessed.contains(Space))
       continue;
 
     isl::set Elements = Accessed.extract_set(Space);
     isl::map Transform = isl::map::universe(Array->getSpace().map_from_set());
 
     std::vector<int> Int;
-    int Dims = Elements.dim(isl::dim::set);
+    int Dims = Elements.tuple_dim();
     for (int i = 0; i < Dims; i++) {
       isl::set DimOnly = isl::set(Elements).project_out(isl::dim::set, 0, i);
       DimOnly = DimOnly.project_out(isl::dim::set, 1, Dims - i - 1);
       DimOnly = DimOnly.lower_bound_si(isl::dim::set, 0, 0);
 
       isl::basic_set DimHull = DimOnly.affine_hull();
 
       if (i == Dims - 1) {
if (LimitReached)
       break;
   }
 
   return !LimitReached;
 }
 
 static isl::set getAccessDomain(MemoryAccess *MA) {
   isl::set Domain = MA->getStatement()->getDomain();
-  Domain = Domain.project_out(isl::dim::set, 0, Domain.n_dim());
+  Domain = Domain.project_out(isl::dim::set, 0, Domain.tuple_dim());
   return Domain.reset_tuple_id();
 }
 
 bool ScopBuilder::buildAliasChecks() {
   if (!PollyUseRuntimeAliasChecks)
     return true;
 
   if (buildAliasGroups()) {

polly/lib/Analysis/ScopInfo.cpp

ScopArrayInfo::ScopArrayInfo(Value *BasePtr, Type *ElementType, isl::ctx Ctx,
   BasePtrOriginSAI = identifyBasePtrOriginSAI(S, BasePtr);
   if (BasePtrOriginSAI)
     const_cast<ScopArrayInfo *>(BasePtrOriginSAI)->addDerivedSAI(this);
 }
 
 ScopArrayInfo::~ScopArrayInfo() = default;
 
 isl::space ScopArrayInfo::getSpace() const {
-  auto Space = isl::space(Id.get_ctx(), 0, getNumberOfDimensions());
+  isl::space Space = isl::space(Id.get_ctx(), 0, getNumberOfDimensions());
   Space = Space.set_tuple_id(isl::dim::set, Id);
   return Space;
 }
 
 bool ScopArrayInfo::isReadOnly() {
   isl::union_set WriteSet = S.getWrites().range();
   isl::space Space = getSpace();
   WriteSet = WriteSet.extract_set(Space);

 //   getEqualAndLarger(set[i0, i1, ..., iX]):
 //
 //   set[i0, i1, ..., iX] -> set[o0, o1, ..., oX]
 //     : i0 = o0, i1 = o1, ..., i(X-1) = o(X-1), iX < oX
 //
 static isl::map getEqualAndLarger(isl::space SetDomain) {
   isl::space Space = SetDomain.map_from_set();
   isl::map Map = isl::map::universe(Space);
-  unsigned lastDimension = Map.dim(isl::dim::in) - 1;
+  unsigned lastDimension = Map.domain_tuple_dim() - 1;
 
   // Set all but the last dimension to be equal for the input and output
   //
   //   input[i0, i1, ..., iX] -> output[o0, o1, ..., oX]
   //     : i0 = o0, i1 = o1, ..., i(X-1) = o(X-1)
   for (unsigned i = 0; i < lastDimension; ++i)
     Map = Map.equate(isl::dim::in, i, isl::dim::out, i);
 

 }
 
 bool MemoryAccess::isStrideX(isl::map Schedule, int StrideWidth) const {
   isl::set Stride, StrideX;
   bool IsStrideX;
 
   Stride = getStride(Schedule);
   StrideX = isl::set::universe(Stride.get_space());
-  for (auto i : seq<isl_size>(0, StrideX.dim(isl::dim::set) - 1))
+  for (auto i : seq<isl_size>(0, StrideX.tuple_dim() - 1))
     StrideX = StrideX.fix_si(isl::dim::set, i, 0);
-  StrideX = StrideX.fix_si(isl::dim::set, StrideX.dim(isl::dim::set) - 1,
-                           StrideWidth);
+  StrideX = StrideX.fix_si(isl::dim::set, StrideX.tuple_dim() - 1, StrideWidth);
   IsStrideX = Stride.is_subset(StrideX);
 
   return IsStrideX;
 }
 
 bool MemoryAccess::isStrideZero(isl::map Schedule) const {
   return isStrideX(Schedule, 0);
 }

polly/lib/CodeGen/PPCGCodeGeneration.cpp

if (gpu_array_is_scalar(Array))
     return nullptr;
 
   isl::ast_build Build = isl::ast_build::from_context(S.getContext());
 
   isl::set Min = isl::manage_copy(Array->extent).lexmin();
 
   isl::set ZeroSet = isl::set::universe(Min.get_space());
 
-  for (long i = 0, n = Min.dim(isl::dim::set); i < n; i++)
+  for (long i = 0, n = Min.tuple_dim(); i < n; i++)
     ZeroSet = ZeroSet.fix_si(isl::dim::set, i, 0);
 
   if (Min.is_subset(ZeroSet)) {
     return nullptr;
   }
 
   isl::ast_expr Result = isl::ast_expr::from_val(isl::val(Min.get_ctx(), 0));
 
-  for (long i = 0, n = Min.dim(isl::dim::set); i < n; i++) {
+  for (long i = 0, n = Min.tuple_dim(); i < n; i++) {
     if (i > 0) {
       isl::pw_aff Bound_I =
           isl::manage(isl_multi_pw_aff_get_pw_aff(Array->bound, i - 1));
       isl::ast_expr BExpr = Build.expr_from(Bound_I);
       Result = Result.mul(BExpr);
     }
     isl::pw_aff DimMin = Min.dim_min(i);
     isl::ast_expr MExpr = Build.expr_from(DimMin);
void getAnalysisUsage(AnalysisUsage &AU) const override {
     // FIXME: We do not yet add regions for the newly generated code to the
     //        region tree.
   }
 };
 } // namespace
 
 char PPCGCodeGeneration::ID = 1;
 
 Pass *polly::createPPCGCodeGenerationPass(GPUArch Arch, GPURuntime Runtime) {
   PPCGCodeGeneration *generator = new PPCGCodeGeneration();
   generator->Runtime = Runtime;
   generator->Architecture = Arch;
   return generator;
 }
 
 INITIALIZE_PASS_BEGIN(PPCGCodeGeneration, "polly-codegen-ppcg",
                       "Polly - Apply PPCG translation to SCOP", false, false)
 INITIALIZE_PASS_DEPENDENCY(DependenceInfo);
 INITIALIZE_PASS_DEPENDENCY(DominatorTreeWrapperPass);
 INITIALIZE_PASS_DEPENDENCY(LoopInfoWrapperPass);
 INITIALIZE_PASS_DEPENDENCY(RegionInfoPass);
 INITIALIZE_PASS_DEPENDENCY(ScalarEvolutionWrapperPass);
 INITIALIZE_PASS_DEPENDENCY(ScopDetectionWrapperPass);
 INITIALIZE_PASS_END(PPCGCodeGeneration, "polly-codegen-ppcg",
                     "Polly - Apply PPCG translation to SCOP", false, false)

polly/lib/External/isl/include/isl/isl-noexceptions.h

 #include <isl/fixed_box.h>
 #include <isl/constraint.h>
 #include <isl/polynomial.h>
 #include <isl/mat.h>
 #include <isl/fixed_box.h>
 #include <stdio.h>
 #include <stdlib.h>
 
 #include <functional>
 #include <string>
 
 namespace isl {
 inline namespace noexceptions {
 
 #define ISLPP_STRINGIZE_(X) #X
 #define ISLPP_STRINGIZE(X) ISLPP_STRINGIZE_(X)
 
public:
   inline pw_aff dim_max(int pos) const;
   inline pw_aff dim_min(int pos) const;
   inline set domain() const;
   inline map domain_factor_domain() const;
   inline map domain_factor_range() const;
   inline boolean domain_is_wrapping() const;
   inline map domain_map() const;
   inline map domain_product(map map2) const;
+  inline isl_size domain_tuple_dim() const;
   inline map drop_constraints_involving_dims(isl::dim type, unsigned int first, unsigned int n) const;
   inline map drop_constraints_not_involving_dims(isl::dim type, unsigned int first, unsigned int n) const;
   inline map drop_unused_params() const;
   inline map eliminate(isl::dim type, unsigned int first, unsigned int n) const;
   static inline map empty(space space);
   inline map eq_at(multi_pw_aff mpa) const;
   inline map equate(isl::dim type1, int pos1, isl::dim type2, int pos2) const;
   inline map factor_domain() const;
public:
   inline set range() const;
   inline map range_curry() const;
   inline map range_factor_domain() const;
   inline map range_factor_range() const;
   inline boolean range_is_wrapping() const;
   inline map range_map() const;
   inline map range_product(map map2) const;
   inline map range_reverse() const;
+  inline isl_size range_tuple_dim() const;
   inline map remove_dims(isl::dim type, unsigned int first, unsigned int n) const;
   inline map remove_divs() const;
   inline map remove_divs_involving_dims(isl::dim type, unsigned int first, unsigned int n) const;
   inline map remove_redundancies() const;
   inline map remove_unknown_divs() const;
   inline map reset_tuple_id(isl::dim type) const;
   inline map reset_user() const;
   inline map reverse() const;
public:
   inline set set_tuple_name(const std::string &s) const;
   inline basic_set simple_hull() const;
   inline int size() const;
   inline basic_set solutions() const;
   inline set split_dims(isl::dim type, unsigned int first, unsigned int n) const;
   inline set subtract(set set2) const;
   inline set sum(set set2) const;
   inline map translation() const;
+  inline isl_size tuple_dim() const;
   inline set unbind_params(multi_id tuple) const;
   inline map unbind_params_insert_domain(multi_id domain) const;
   inline set unite(set set2) const;
   static inline set universe(space space);
   inline basic_set unshifted_simple_hull() const;
   inline basic_set unshifted_simple_hull_from_set_list(set_list list) const;
   inline map unwrap() const;
   inline set upper_bound(multi_pw_aff upper) const;

 }
 
 map map::domain_product(map map2) const
 {
   auto res = isl_map_domain_product(copy(), map2.release());
   return manage(res);
 }
 
+isl_size map::domain_tuple_dim() const
+{
+  auto res = isl_map_domain_tuple_dim(get());
+  return res;
+}
+
 map map::drop_constraints_involving_dims(isl::dim type, unsigned int first, unsigned int n) const
 {
   auto res = isl_map_drop_constraints_involving_dims(copy(), static_cast<enum isl_dim_type>(type), first, n);
   return manage(res);
 }
 
 map map::drop_constraints_not_involving_dims(isl::dim type, unsigned int first, unsigned int n) const
 {

 }
 
 map map::range_reverse() const
 {
   auto res = isl_map_range_reverse(copy());
   return manage(res);
 }
 
+isl_size map::range_tuple_dim() const
+{
+  auto res = isl_map_range_tuple_dim(get());
+  return res;
+}
+
 map map::remove_dims(isl::dim type, unsigned int first, unsigned int n) const
 {
   auto res = isl_map_remove_dims(copy(), static_cast<enum isl_dim_type>(type), first, n);
   return manage(res);
 }
 
 map map::remove_divs() const
 {

 }
 
 map set::translation() const
 {
   auto res = isl_set_translation(copy());
   return manage(res);
 }
 
+isl_size set::tuple_dim() const
+{
+  auto res = isl_set_tuple_dim(get());
+  return res;
+}
+
 set set::unbind_params(multi_id tuple) const
 {
   auto res = isl_set_unbind_params(copy(), tuple.release());
   return manage(res);
 }
 
 map set::unbind_params_insert_domain(multi_id domain) const
 {

polly/lib/External/isl/include/isl/map.h

 #if defined(__cplusplus)
 extern "C" {
 #endif
 
 isl_size isl_basic_map_total_dim(__isl_keep const isl_basic_map *bmap);
 isl_size isl_basic_map_dim(__isl_keep isl_basic_map *bmap,
         enum isl_dim_type type);
 
+__isl_export
+isl_size isl_map_domain_tuple_dim(__isl_keep isl_map *map);
+__isl_export
+isl_size isl_map_range_tuple_dim(__isl_keep isl_map *map);
 isl_size isl_map_dim(__isl_keep isl_map *map, enum isl_dim_type type);
 
 isl_ctx *isl_basic_map_get_ctx(__isl_keep isl_basic_map *bmap);
 isl_ctx *isl_map_get_ctx(__isl_keep isl_map *map);
 __isl_give isl_space *isl_basic_map_get_space(__isl_keep isl_basic_map *bmap);
 __isl_export
 __isl_give isl_space *isl_map_get_space(__isl_keep isl_map *map);
 

polly/lib/External/isl/include/isl/set.h

 isl_size isl_basic_set_n_dim(__isl_keep isl_basic_set *bset);
 isl_size isl_basic_set_n_param(__isl_keep isl_basic_set *bset);
 isl_size isl_basic_set_total_dim(__isl_keep const isl_basic_set *bset);
 isl_size isl_basic_set_dim(__isl_keep isl_basic_set *bset,
         enum isl_dim_type type);
 
 isl_size isl_set_n_dim(__isl_keep isl_set *set);
 isl_size isl_set_n_param(__isl_keep isl_set *set);
+__isl_export
+isl_size isl_set_tuple_dim(__isl_keep isl_set *set);
 isl_size isl_set_dim(__isl_keep isl_set *set, enum isl_dim_type type);
 
 isl_ctx *isl_basic_set_get_ctx(__isl_keep isl_basic_set *bset);
 isl_ctx *isl_set_get_ctx(__isl_keep isl_set *set);
 __isl_give isl_space *isl_basic_set_get_space(__isl_keep isl_basic_set *bset);
 __isl_export
 __isl_give isl_space *isl_set_get_space(__isl_keep isl_set *set);
 __isl_give isl_set *isl_set_reset_space(__isl_take isl_set *set,

polly/lib/External/isl/isl_map.c

__isl_keep isl_space *isl_set_peek_space(__isl_keep isl_set *set)
   return isl_map_peek_space(set_to_map(set));
 }
 
 isl_size isl_map_dim(__isl_keep isl_map *map, enum isl_dim_type type)
 {
   return isl_space_dim(isl_map_peek_space(map), type);
 }
 
+/* Return the dimensionality of the domain (tuple) of the map.
+ */
+isl_size isl_map_domain_tuple_dim(__isl_keep isl_map *map)
+{
+  return isl_map_dim(map, isl_dim_in);
+}
+
+/* Return the dimensionality of the range (tuple) of the map.
+ */
+isl_size isl_map_range_tuple_dim(__isl_keep isl_map *map)
+{
+  return isl_map_dim(map, isl_dim_out);
+}
+
 isl_size isl_set_dim(__isl_keep isl_set *set, enum isl_dim_type type)
 {
   return isl_map_dim(set_to_map(set), type);
 }
 
+/* Return the dimensionality of the (tuple of the) set.
+ */
+isl_size isl_set_tuple_dim(__isl_keep isl_set *set)
+{
+  return isl_set_dim(set, isl_dim_set);
+}
+
 /* Return the position of the variables of the given type
  * within the sequence of variables of "bmap".
  */
 isl_size isl_basic_map_var_offset(__isl_keep isl_basic_map *bmap,
   enum isl_dim_type type)
 {
   isl_space *space;
 

polly/lib/Support/ISLTools.cpp

 }
 
 isl_size polly::getNumScatterDims(const isl::union_map &Schedule) {
   isl_size Dims = 0;
   for (isl::map Map : Schedule.get_map_list()) {
     if (Map.is_null())
       continue;
 
-    Dims = std::max(Dims, Map.dim(isl::dim::out));
+    Dims = std::max(Dims, Map.range_tuple_dim());
   }
   return Dims;
 }
 
 isl::space polly::getScatterSpace(const isl::union_map &Schedule) {
   if (Schedule.is_null())
     return {};
   unsigned Dims = getNumScatterDims(Schedule);
isl::union_map polly::reverseDomain(const isl::union_map &UMap) {
   for (isl::map Map : UMap.get_map_list()) {
     auto Reversed = reverseDomain(std::move(Map));
     Result = Result.add_map(Reversed);
   }
   return Result;
 }
 
 isl::set polly::shiftDim(isl::set Set, int Pos, int Amount) {
-  int NumDims = Set.dim(isl::dim::set);
+  int NumDims = Set.tuple_dim();
   if (Pos < 0)
     Pos = NumDims + Pos;
   assert(Pos < NumDims && "Dimension index must be in range");
   isl::space Space = Set.get_space();
   Space = Space.map_from_domain_and_range(Space);
   isl::multi_aff Translator = makeShiftDimAff(Space, Pos, Amount);
   isl::map TranslatorMap = isl::map::from_multi_aff(Translator);
   return Set.apply(TranslatorMap);

polly/lib/Transform/FlattenAlgo.cpp

 
 /// Whether a dimension of a set is bounded (lower and upper) by a constant,
 /// i.e. there are two constants Min and Max, such that every value x of the
 /// chosen dimensions is Min <= x <= Max.
 bool isDimBoundedByConstant(isl::set Set, unsigned dim) {
   auto ParamDims = Set.dim(isl::dim::param);
   Set = Set.project_out(isl::dim::param, 0, ParamDims);
   Set = Set.project_out(isl::dim::set, 0, dim);
-  auto SetDims = Set.dim(isl::dim::set);
+  auto SetDims = Set.tuple_dim();
   Set = Set.project_out(isl::dim::set, 1, SetDims - 1);
   return bool(Set.is_bounded());
 }
 
 /// Whether a dimension of a set is (lower and upper) bounded by a constant or
 /// parameters, i.e. there are two expressions Min_p and Max_p of the parameters
 /// p, such that every value x of the chosen dimensions is
 /// Min_p <= x <= Max_p.
 bool isDimBoundedByParameter(isl::set Set, unsigned dim) {
   Set = Set.project_out(isl::dim::set, 0, dim);
-  auto SetDims = Set.dim(isl::dim::set);
+  auto SetDims = Set.tuple_dim();
   Set = Set.project_out(isl::dim::set, 1, SetDims - 1);
   return bool(Set.is_bounded());
 }
 
 /// Whether BMap's first out-dimension is not a constant.
 bool isVariableDim(const isl::basic_map &BMap) {
   auto FixedVal = BMap.plain_get_val_if_fixed(isl::dim::out, 0);
   return FixedVal.is_null() || FixedVal.is_nan();

 /// different. We return the maximum number in this case. However, a different
 /// number of dimensions is not supported by the other code in this file.
 isl_size scheduleScatterDims(const isl::union_map &Schedule) {
   isl_size Dims = 0;
   for (isl::map Map : Schedule.get_map_list()) {
     if (Map.is_null())
       continue;
 
-    Dims = std::max(Dims, Map.dim(isl::dim::out));
+    Dims = std::max(Dims, Map.range_tuple_dim());
   }
   return Dims;
 }
 
 /// Return the @p pos' range dimension, converted to an isl_union_pw_aff.
 isl::union_pw_aff scheduleExtractDimAff(isl::union_map UMap, unsigned pos) {
   auto SingleUMap = isl::union_map::empty(UMap.get_space());
   for (isl::map Map : UMap.get_map_list()) {
-    unsigned MapDims = Map.dim(isl::dim::out);
+    unsigned MapDims = Map.range_tuple_dim();
     isl::map SingleMap = Map.project_out(isl::dim::out, 0, pos);
     SingleMap = SingleMap.project_out(isl::dim::out, 1, MapDims - pos - 1);
     SingleUMap = SingleUMap.add_map(SingleMap);
   };
 
   auto UAff = isl::union_pw_multi_aff(SingleUMap);
   auto FirstMAff = isl::multi_union_pw_aff(UAff);
   return FirstMAff.get_union_pw_aff(0);

 /// as "Offset + X - l_X(i)" to the new schedule, then add "u_X(i) - l_X(i) + 1"
 /// to Offset and remove all i-instances from the old schedule. Repeat with the
 /// remaining lowest value i' until there are no instances in the old schedule
 /// left.
 /// The example schedule would be transformed to:
 ///   { Stmt_X[] -> [X - l_X, ...]; Stmt_B -> [l_X - u_X + 1 + Y - l_Y, ...] }
 isl::union_map tryFlattenSequence(isl::union_map Schedule) {
   auto IslCtx = Schedule.get_ctx();
-  auto ScatterSet = isl::set(Schedule.range());
+  isl::set ScatterSet = isl::set(Schedule.range());
 
   auto ParamSpace = Schedule.get_space().params();
-  auto Dims = ScatterSet.dim(isl::dim::set);
+  auto Dims = ScatterSet.tuple_dim();
   assert(Dims >= 2);
 
   // Would cause an infinite loop.
   if (!isDimBoundedByConstant(ScatterSet, 0)) {
     LLVM_DEBUG(dbgs() << "Abort; dimension is not of fixed size\n");
     return {};
   }
 

 ///   { Stmt[i] -> [i * (u_X() - l_X() + 1), ...] }
 isl::union_map tryFlattenLoop(isl::union_map Schedule) {
   assert(scheduleScatterDims(Schedule) >= 2);
 
   auto Remaining = scheduleProjectOut(Schedule, 0, 1);
   auto SubSchedule = flattenSchedule(Remaining);
   auto SubDims = scheduleScatterDims(SubSchedule);
 
-  auto SubExtent = isl::set(SubSchedule.range());
+  isl::set SubExtent = isl::set(SubSchedule.range());
   auto SubExtentDims = SubExtent.dim(isl::dim::param);
   SubExtent = SubExtent.project_out(isl::dim::param, 0, SubExtentDims);
   SubExtent = SubExtent.project_out(isl::dim::set, 1, SubDims - 1);
 
   if (!isDimBoundedByConstant(SubExtent, 0)) {
     LLVM_DEBUG(dbgs() << "Abort; dimension not bounded by constant\n");
     return {};
   }

polly/lib/Transform/MatmulOptimizer.cpp

 /// @param  MMI             Parameters of the matrix multiplication operands.
 /// @return                 True in case the corresponding SCoP statement
 ///                         represents matrix multiplication and false,
 ///                         otherwise.
 static bool containsOnlyMatrMultAcc(isl::map PartialSchedule,
                                     MatMulInfoTy &MMI) {
   auto InputDimId = PartialSchedule.get_tuple_id(isl::dim::in);
   auto *Stmt = static_cast<ScopStmt *>(InputDimId.get_user());
-  isl_size OutDimNum = PartialSchedule.dim(isl::dim::out);
+  isl_size OutDimNum = PartialSchedule.range_tuple_dim();
   assert(OutDimNum > 2 && "In case of the matrix multiplication the loop nest "
                           "and, consequently, the corresponding scheduling "
                           "functions have at least three dimensions.");
   auto MapI =
       permuteDimensions(PartialSchedule, isl::dim::out, MMI.i, OutDimNum - 1);
   auto MapJ =
       permuteDimensions(PartialSchedule, isl::dim::out, MMI.j, OutDimNum - 1);
   auto MapK =
AccRelPackedB =
       AccRelPackedB.set_tuple_id(isl::dim::out, PackedB->getBasePtrId());
 
   // Create the copy statement and redirect access.
   ScopStmt *CopyStmt = S->addScopStmt(AccRelB, AccRelPackedB, Domain);
   MMI.B->setNewAccessRelation(AccRelPackedB);
 
   // Insert into the schedule tree.
   isl::map ExtMap = MapOldIndVar.project_out(
-      isl::dim::out, 2, MapOldIndVar.dim(isl::dim::out) - 2);
+      isl::dim::out, 2, MapOldIndVar.range_tuple_dim() - 2);
   ExtMap = ExtMap.reverse();
   ExtMap = ExtMap.fix_si(isl::dim::out, MMI.i, 0);
   ExtMap = ExtMap.intersect_range(Domain);
   ExtMap = ExtMap.set_tuple_id(isl::dim::out, CopyStmt->getDomainId());
   return createExtensionNode(Node, ExtMap);
 }
 
 static isl::schedule_node optimizePackedA(isl::schedule_node Node, ScopStmt *,

 /// @see ScheduleTreeOptimizer::createMacroKernel
 /// @see getMacroKernelParams
 static isl::map
 getInductionVariablesSubstitution(isl::schedule_node Node,
                                   MicroKernelParamsTy MicroKernelParams,
                                   MacroKernelParamsTy MacroKernelParams) {
   auto Child = Node.child(0);
   auto UnMapOldIndVar = Child.get_prefix_schedule_union_map();
-  auto MapOldIndVar = isl::map::from_union_map(UnMapOldIndVar);
-  if (MapOldIndVar.dim(isl::dim::out) > 9)
+  isl::map MapOldIndVar = isl::map::from_union_map(UnMapOldIndVar);
+  if (MapOldIndVar.range_tuple_dim() > 9)
     return MapOldIndVar.project_out(isl::dim::out, 0,
-                                    MapOldIndVar.dim(isl::dim::out) - 9);
+                                    MapOldIndVar.range_tuple_dim() - 9);
   return MapOldIndVar;
 }
 
 /// Isolate a set of partial tile prefixes and unroll the isolated part.
 ///
 /// The set should ensure that it contains only partial tile prefixes that have
 /// exactly Mr x Nr iterations of the two innermost loops produced by
 /// the optimization of the matrix multiplication. Mr and Nr are parameters of
 /// the micro-kernel.
 ///
 /// In case of parametric bounds, this helps to auto-vectorize the unrolled
 /// innermost loops, using the SLP vectorizer.
 ///
 /// @param Node              The schedule node to be modified.
 /// @param MicroKernelParams Parameters of the micro-kernel
 ///                          to be taken into account.
 /// @return The modified isl_schedule_node.
 static isl::schedule_node
 isolateAndUnrollMatMulInnerLoops(isl::schedule_node Node,
                                  struct MicroKernelParamsTy MicroKernelParams) {
   isl::schedule_node Child = Node.get_child(0);
   isl::union_map UnMapOldIndVar = Child.get_prefix_schedule_relation();
   isl::set Prefix = isl::map::from_union_map(UnMapOldIndVar).range();
-  isl_size Dims = Prefix.dim(isl::dim::set);
+  isl_size Dims = Prefix.tuple_dim();
   Prefix = Prefix.project_out(isl::dim::set, Dims - 1, 1);
   Prefix = getPartialTilePrefixes(Prefix, MicroKernelParams.Nr);
   Prefix = getPartialTilePrefixes(Prefix, MicroKernelParams.Mr);
 
   isl::union_set IsolateOption =
       getIsolateOptions(Prefix.add_dims(isl::dim::set, 3), 3);
   isl::ctx Ctx = Node.get_ctx();
   auto Options = IsolateOption.unite(getDimOptions(Ctx, "unroll"));

 static isl::schedule_node
 getBandNodeWithOriginDimOrder(isl::schedule_node Node) {
   assert(isl_schedule_node_get_type(Node.get()) == isl_schedule_node_band);
   if (isl_schedule_node_get_type(Node.child(0).get()) != isl_schedule_node_leaf)
     return Node;
   auto Domain = Node.get_universe_domain();
   assert(isl_union_set_n_set(Domain.get()) == 1);
   if (Node.get_schedule_depth() != 0 ||
-      (isl::set(Domain).dim(isl::dim::set) !=
+      (isl::set(Domain).tuple_dim() !=
        isl_schedule_node_band_n_member(Node.get())))
     return Node;
   Node = isl::manage(isl_schedule_node_delete(Node.copy()));
   auto PartialSchedulePwAff = Domain.identity_union_pw_multi_aff();
   auto PartialScheduleMultiPwAff =
       isl::multi_union_pw_aff(PartialSchedulePwAff);
   PartialScheduleMultiPwAff =
       PartialScheduleMultiPwAff.reset_tuple_id(isl::dim::set);

polly/lib/Transform/MaximalStaticExpansion.cpp

 #ifndef NDEBUG
 /// Whether a dimension of a set is bounded (lower and upper) by a constant,
 /// i.e. there are two constants Min and Max, such that every value x of the
 /// chosen dimensions is Min <= x <= Max.
 static bool isDimBoundedByConstant(isl::set Set, unsigned dim) {
   auto ParamDims = Set.dim(isl::dim::param);
   Set = Set.project_out(isl::dim::param, 0, ParamDims);
   Set = Set.project_out(isl::dim::set, 0, dim);
-  auto SetDims = Set.dim(isl::dim::set);
+  auto SetDims = Set.tuple_dim();
   Set = Set.project_out(isl::dim::set, 1, SetDims - 1);
   return bool(Set.is_bounded());
 }
 #endif
 
 char MaximalStaticExpander::ID = 0;
 
 isl::union_map MaximalStaticExpander::filterDependences(
for (auto MA : Accesses) {
 
     // Set the new access relation.
     MA->setNewAccessRelation(NewAccessMap);
   }
 }
 
 ScopArrayInfo *MaximalStaticExpander::expandAccess(Scop &S, MemoryAccess *MA) {
   // Get the current AM.
-  auto CurrentAccessMap = MA->getAccessRelation();
+  isl::map CurrentAccessMap = MA->getAccessRelation();
 
-  unsigned in_dimensions = CurrentAccessMap.dim(isl::dim::in);
+  unsigned in_dimensions = CurrentAccessMap.domain_tuple_dim();
 
   // Get domain from the current AM.
   auto Domain = CurrentAccessMap.domain();
 
   // Create a new AM from the domain.
   auto NewAccessMap = isl::map::from_domain(Domain);
 
   // Add dimensions to the new AM according to the current in_dim.

polly/lib/Transform/ScheduleTreeTransform.cpp

isl::schedule visitBand(const isl::schedule_node &OldNode,
     isl::union_map NewChildExtensions;
     isl::schedule NewChild = visit(OldChild, Domain, NewChildExtensions);
 
     // Add the extensions to the partial schedule.
     OuterExtensions = isl::union_map::empty(NewChildExtensions.get_space());
     isl::union_map NewPartialSchedMap = isl::union_map::from(PartialSched);
     unsigned BandDims = isl_schedule_node_band_n_member(OldNode.get());
     for (isl::map Ext : NewChildExtensions.get_map_list()) {
-      unsigned ExtDims = Ext.dim(isl::dim::in);
+      unsigned ExtDims = Ext.domain_tuple_dim();
       assert(ExtDims >= BandDims);
       unsigned OuterDims = ExtDims - BandDims;
 
       isl::map BandSched =
           Ext.project_out(isl::dim::in, 0, OuterDims).reverse();
       NewPartialSchedMap = NewPartialSchedMap.unite(BandSched);
 
       // There might be more outer bands that have to schedule the extensions.
static isl::basic_set isDivisibleBySet(isl::ctx &Ctx, long Factor,
   return Modulo.domain();
 }
 
 /// Make the last dimension of Set to take values from 0 to VectorWidth - 1.
 ///
 /// @param Set         A set, which should be modified.
 /// @param VectorWidth A parameter, which determines the constraint.
 static isl::set addExtentConstraints(isl::set Set, int VectorWidth) {
-  unsigned Dims = Set.dim(isl::dim::set);
+  unsigned Dims = Set.tuple_dim();
   isl::space Space = Set.get_space();
   isl::local_space LocalSpace = isl::local_space(Space);
   isl::constraint ExtConstr = isl::constraint::alloc_inequality(LocalSpace);
   ExtConstr = ExtConstr.set_constant_si(0);
   ExtConstr = ExtConstr.set_coefficient_si(isl::dim::set, Dims - 1, 1);
   Set = Set.add_constraint(ExtConstr);
   ExtConstr = isl::constraint::alloc_inequality(LocalSpace);
   ExtConstr = ExtConstr.set_constant_si(VectorWidth - 1);
isl::schedule polly::applyPartialUnroll(isl::schedule_node BandToUnroll,
   if (!NewBandId.is_null())
     NewLoop = insertMark(NewLoop, NewBandId);
 
   return NewLoop.get_schedule();
 }
 
 isl::set polly::getPartialTilePrefixes(isl::set ScheduleRange,
                                        int VectorWidth) {
-  isl_size Dims = ScheduleRange.dim(isl::dim::set);
+  isl_size Dims = ScheduleRange.tuple_dim();
   isl::set LoopPrefixes =
       ScheduleRange.drop_constraints_involving_dims(isl::dim::set, Dims - 1, 1);
   auto ExtentPrefixes = addExtentConstraints(LoopPrefixes, VectorWidth);
   isl::set BadPrefixes = ExtentPrefixes.subtract(ScheduleRange);
   BadPrefixes = BadPrefixes.project_out(isl::dim::set, Dims - 1, 1);
   LoopPrefixes = LoopPrefixes.project_out(isl::dim::set, Dims - 1, 1);
   return LoopPrefixes.subtract(BadPrefixes);
 }
 
 isl::union_set polly::getIsolateOptions(isl::set IsolateDomain,
                                         isl_size OutDimsNum) {
-  isl_size Dims = IsolateDomain.dim(isl::dim::set);
+  isl_size Dims = IsolateDomain.tuple_dim();
   assert(OutDimsNum <= Dims &&
          "The isl::set IsolateDomain is used to describe the range of schedule "
          "dimensions values, which should be isolated. Consequently, the "
          "number of its dimensions should be greater than or equal to the "
          "number of the schedule dimensions.");
   isl::map IsolateRelation = isl::map::from_domain(IsolateDomain);
   IsolateRelation = IsolateRelation.move_dims(isl::dim::out, 0, isl::dim::in,
                                               Dims - OutDimsNum, OutDimsNum);

polly/lib/Transform/ZoneAlgo.cpp

isl::map ZoneAlgorithm::getDefToTarget(ScopStmt *DefStmt,
   //   { DefStmt[i] -> TargetStmt[i,j] }
   //
   // In practice, this should cover the majority of cases.
   if (Result.is_null() && S->isOriginalSchedule() &&
       isInsideLoop(DefStmt->getSurroundingLoop(),
                    TargetStmt->getSurroundingLoop())) {
     isl::set DefDomain = getDomainFor(DefStmt);
     isl::set TargetDomain = getDomainFor(TargetStmt);
-    assert(DefDomain.dim(isl::dim::set) <= TargetDomain.dim(isl::dim::set));
+    assert(DefDomain.tuple_dim() <= TargetDomain.tuple_dim());
 
     Result = isl::map::from_domain_and_range(DefDomain, TargetDomain);
-    for (unsigned i = 0, DefDims = DefDomain.dim(isl::dim::set); i < DefDims;
-         i += 1)
+    for (unsigned i = 0, DefDims = DefDomain.tuple_dim(); i < DefDims; i += 1)
       Result = Result.equate(isl::dim::in, i, isl::dim::out, i);
   }
 
   if (Result.is_null()) {
     // { DomainDef[] -> DomainTarget[] }
     Result = computeUseToDefFlowDependency(TargetStmt, DefStmt).reverse();
     simplify(Result);
   }