return true;
isl::union_map Dependences = getDependences(TYPE_RAW | TYPE_WAW | TYPE_WAR);
- isl::space Space = S.getParamSpace();
- isl::union_map Schedule = isl::union_map::empty(Space);
+ isl::union_map Schedule = isl::union_map::empty(S.getIslCtx());
isl::space ScheduleSpace;
isl::union_map Dependences::getDependences(int Kinds) const {
assert(hasValidDependences() && "No valid dependences available");
isl::space Space = isl::manage_copy(RAW).get_space();
- isl::union_map Deps = Deps.empty(Space);
+ isl::union_map Deps = Deps.empty(Space.ctx());
if (Kinds & TYPE_RAW)
Deps = Deps.unite(isl::manage_copy(RAW));
MinMaxAccesses.reserve(AliasGroup.size());
isl::union_set Domains = scop->getDomains();
- isl::union_map Accesses = isl::union_map::empty(scop->getParamSpace());
+ isl::union_map Accesses = isl::union_map::empty(scop->getIslCtx());
for (MemoryAccess *MA : AliasGroup)
Accesses = Accesses.add_map(MA->getAccessRelation());
isl::union_map
Scop::getAccessesOfType(std::function<bool(MemoryAccess &)> Predicate) {
- isl::union_map Accesses = isl::union_map::empty(getParamSpace());
+ isl::union_map Accesses = isl::union_map::empty(getIslCtx());
for (ScopStmt &Stmt : *this) {
for (MemoryAccess *MA : Stmt) {
KillMemIds.push_back(isl::manage(SAI->getBasePtrId().release()));
}
- Info.TaggedMustKills = isl::union_map::empty(ParamSpace);
- Info.MustKills = isl::union_map::empty(ParamSpace);
+ Info.TaggedMustKills = isl::union_map::empty(ParamSpace.ctx());
+ Info.MustKills = isl::union_map::empty(ParamSpace.ctx());
// Initialising KillsSchedule to `isl_set_empty` creates an empty node in the
// schedule:
return false;
}
- auto ScheduleMap = isl::union_map::empty(S.getParamSpace());
+ auto ScheduleMap = isl::union_map::empty(S.getIslCtx());
for (ScopStmt &Stmt : S) {
if (NewSchedule.find(&Stmt) != NewSchedule.end())
ScheduleMap = ScheduleMap.add_map(NewSchedule[&Stmt]);
/// polyhedral compilation, ranging from dependence analysis over scheduling
/// to AST generation.
+// clang-format off
+
#ifndef ISL_CPP_CHECKED
#define ISL_CPP_CHECKED
inline isl::union_map domain_map() const;
inline isl::union_pw_multi_aff domain_map_union_pw_multi_aff() const;
inline isl::union_map domain_product(isl::union_map umap2) const;
- static inline isl::union_map empty(isl::space space);
static inline isl::union_map empty(isl::ctx ctx);
- static inline isl::union_map empty_space(isl::space space);
inline isl::union_map eq_at(isl::multi_union_pw_aff mupa) const;
inline isl::map extract_map(isl::space space) const;
inline isl::union_map factor_domain() const;
inline boolean contains(const isl::space &space) const;
inline isl::union_set detect_equalities() const;
inline isl_size dim(isl::dim type) const;
- static inline isl::union_set empty(isl::space space);
static inline isl::union_set empty(isl::ctx ctx);
- static inline isl::union_set empty_space(isl::space space);
inline isl::set extract_set(isl::space space) const;
inline stat foreach_point(const std::function<stat(point)> &fn) const;
inline stat foreach_set(const std::function<stat(set)> &fn) const;
return manage(res);
}
-isl::union_map union_map::empty(isl::space space)
-{
- auto res = isl_union_map_empty(space.release());
- return manage(res);
-}
-
isl::union_map union_map::empty(isl::ctx ctx)
{
auto res = isl_union_map_empty_ctx(ctx.release());
return manage(res);
}
-isl::union_map union_map::empty_space(isl::space space)
-{
- auto res = isl_union_map_empty_space(space.release());
- return manage(res);
-}
-
isl::union_map union_map::eq_at(isl::multi_union_pw_aff mupa) const
{
auto res = isl_union_map_eq_at_multi_union_pw_aff(copy(), mupa.release());
return res;
}
-isl::union_set union_set::empty(isl::space space)
-{
- auto res = isl_union_set_empty(space.release());
- return manage(res);
-}
-
isl::union_set union_set::empty(isl::ctx ctx)
{
auto res = isl_union_set_empty_ctx(ctx.release());
return manage(res);
}
-isl::union_set union_set::empty_space(isl::space space)
-{
- auto res = isl_union_set_empty_space(space.release());
- return manage(res);
-}
-
isl::set union_set::extract_set(isl::space space) const
{
auto res = isl_union_set_extract_set(get(), space.release());
}
isl::union_map polly::beforeScatter(isl::union_map UMap, bool Strict) {
- isl::union_map Result = isl::union_map::empty(UMap.get_space());
+ isl::union_map Result = isl::union_map::empty(UMap.ctx());
for (isl::map Map : UMap.get_map_list()) {
isl::map After = beforeScatter(Map, Strict);
}
isl::union_map polly::afterScatter(const isl::union_map &UMap, bool Strict) {
- isl::union_map Result = isl::union_map::empty(UMap.get_space());
+ isl::union_map Result = isl::union_map::empty(UMap.ctx());
for (isl::map Map : UMap.get_map_list()) {
isl::map After = afterScatter(Map, Strict);
Result = Result.add_map(After);
isl::union_map polly::makeIdentityMap(const isl::union_set &USet,
bool RestrictDomain) {
- isl::union_map Result = isl::union_map::empty(USet.get_space());
+ isl::union_map Result = isl::union_map::empty(USet.ctx());
for (isl::set Set : USet.get_set_list()) {
isl::map IdentityMap = makeIdentityMap(Set, RestrictDomain);
Result = Result.add_map(IdentityMap);
}
isl::union_map polly::reverseDomain(const isl::union_map &UMap) {
- isl::union_map Result = isl::union_map::empty(UMap.get_space());
+ isl::union_map Result = isl::union_map::empty(UMap.ctx());
for (isl::map Map : UMap.get_map_list()) {
auto Reversed = reverseDomain(std::move(Map));
Result = Result.add_map(Reversed);
}
isl::union_set polly::shiftDim(isl::union_set USet, int Pos, int Amount) {
- isl::union_set Result = isl::union_set::empty(USet.get_space());
+ isl::union_set Result = isl::union_set::empty(USet.ctx());
for (isl::set Set : USet.get_set_list()) {
isl::set Shifted = shiftDim(Set, Pos, Amount);
Result = Result.unite(Shifted);
isl::union_map polly::shiftDim(isl::union_map UMap, isl::dim Dim, int Pos,
int Amount) {
- isl::union_map Result = isl::union_map::empty(UMap.get_space());
+ isl::union_map Result = isl::union_map::empty(UMap.ctx());
for (isl::map Map : UMap.get_map_list()) {
isl::map Shifted = shiftDim(Map, Dim, Pos, Amount);
}
isl::union_map polly::distributeDomain(isl::union_map UMap) {
- isl::union_map Result = isl::union_map::empty(UMap.get_space());
+ isl::union_map Result = isl::union_map::empty(UMap.ctx());
for (isl::map Map : UMap.get_map_list()) {
auto Distributed = distributeDomain(Map);
Result = Result.add_map(Distributed);
///
/// @see expand(const isl::set)
static isl::union_set expand(const isl::union_set &USet) {
- isl::union_set Expanded = isl::union_set::empty(USet.get_space());
+ isl::union_set Expanded = isl::union_set::empty(USet.ctx());
for (isl::set Set : USet.get_set_list()) {
isl::set SetExpanded = expand(Set);
Expanded = Expanded.unite(SetExpanded);
simplify(WritesTarget);
// { DomainWrite[] }
- auto UniverseWritesDom = isl::union_set::empty(ParamSpace);
+ auto UniverseWritesDom = isl::union_set::empty(ParamSpace.ctx());
for (auto *MA : S->getPHIIncomings(SAI))
UniverseWritesDom = UniverseWritesDom.unite(getDomainFor(MA));
return UMap; /* isl_map_project_out would also reset the tuple, which should
have no effect on schedule ranges */
- auto Result = isl::union_map::empty(UMap.get_space());
+ auto Result = isl::union_map::empty(UMap.ctx());
for (isl::map Map : UMap.get_map_list()) {
auto Outprojected = Map.project_out(isl::dim::out, first, n);
Result = Result.add_map(Outprojected);
/// 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());
+ auto SingleUMap = isl::union_map::empty(UMap.ctx());
for (isl::map Map : UMap.get_map_list()) {
unsigned MapDims = Map.range_tuple_dim();
isl::map SingleMap = Map.project_out(isl::dim::out, 0, pos);
auto AllDomains = Schedule.domain();
auto AllDomainsToNull = isl::union_pw_multi_aff(AllDomains);
- auto NewSchedule = isl::union_map::empty(ParamSpace);
+ auto NewSchedule = isl::union_map::empty(ParamSpace.ctx());
auto Counter = isl::pw_aff(isl::local_space(ParamSpace.set_from_params()));
while (!ScatterSet.is_empty()) {
auto AccessDomainSet = MA->getAccessRelation().domain();
auto AccessDomainId = AccessDomainSet.get_tuple_id();
- isl::union_map MapDependences = isl::union_map::empty(S.getParamSpace());
+ isl::union_map MapDependences = isl::union_map::empty(S.getIslCtx());
for (isl::map Map : Dependences.get_map_list()) {
// Filter out Statement to Statement dependences.
auto Writes = S.getPHIIncomings(SAI);
// Get the domain where all the writes are writing to.
- auto WriteDomain = isl::union_set::empty(S.getParamSpace());
+ auto WriteDomain = isl::union_set::empty(S.getIslCtx());
for (auto Write : Writes) {
auto MapDeps = filterDependences(S, Dependences, Write);
int NumberWrites = 0;
for (ScopStmt &Stmt : S) {
- auto StmtReads = isl::union_map::empty(S.getParamSpace());
- auto StmtWrites = isl::union_map::empty(S.getParamSpace());
+ auto StmtReads = isl::union_map::empty(S.getIslCtx());
+ auto StmtWrites = isl::union_map::empty(S.getIslCtx());
for (MemoryAccess *MA : Stmt) {
// Check if the current MemoryAccess involved the current SAI.
isl::schedule visitLeaf(const isl::schedule_node &Leaf,
const isl::union_set &Domain,
isl::union_map &Extensions) {
- isl::ctx Ctx = Leaf.ctx();
- Extensions = isl::union_map::empty(isl::space::params_alloc(Ctx, 0));
+ Extensions = isl::union_map::empty(Leaf.ctx());
return isl::schedule::from_domain(Domain);
}
isl::schedule NewChild = visit(OldChild, Domain, NewChildExtensions);
// Add the extensions to the partial schedule.
- OuterExtensions = isl::union_map::empty(NewChildExtensions.get_space());
+ OuterExtensions = isl::union_map::empty(NewChildExtensions.ctx());
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()) {
void SimplifyImpl::removeOverwrites() {
for (auto &Stmt : *S) {
isl::set Domain = Stmt.getDomain();
- isl::union_map WillBeOverwritten =
- isl::union_map::empty(S->getParamSpace());
+ isl::union_map WillBeOverwritten = isl::union_map::empty(S->getIslCtx());
SmallVector<MemoryAccess *, 32> Accesses(getAccessesInOrder(Stmt));
// List of all eligible (for coalescing) writes of the future.
// { [Domain[] -> Element[]] -> [Value[] -> MemoryAccess[]] }
- isl::union_map FutureWrites = isl::union_map::empty(S->getParamSpace());
+ isl::union_map FutureWrites = isl::union_map::empty(S->getIslCtx());
// Iterate over accesses from the last to the first.
SmallVector<MemoryAccess *, 32> Accesses(getAccessesInOrder(Stmt));
TouchedAccesses.insert(MA);
}
isl::union_map NewFutureWrites =
- isl::union_map::empty(FutureWrites.get_space());
+ isl::union_map::empty(FutureWrites.ctx());
for (isl::map FutureWrite : FutureWrites.get_map_list()) {
MemoryAccess *MA = (MemoryAccess *)FutureWrite.get_space()
.range()
// List of element reads that still have the same value while iterating
// through the MemoryAccesses.
// { [Domain[] -> Element[]] -> Val[] }
- isl::union_map Known = isl::union_map::empty(S->getParamSpace());
+ isl::union_map Known = isl::union_map::empty(S->getIslCtx());
SmallVector<MemoryAccess *, 32> Accesses(getAccessesInOrder(Stmt));
for (MemoryAccess *MA : Accesses) {
}
isl::union_map polly::filterKnownValInst(const isl::union_map &UMap) {
- isl::union_map Result = isl::union_map::empty(UMap.get_space());
+ isl::union_map Result = isl::union_map::empty(UMap.ctx());
for (isl::map Map : UMap.get_map_list()) {
if (!isMapToUnknown(Map))
Result = Result.add_map(Map);
}
isl::union_set ZoneAlgorithm::makeEmptyUnionSet() const {
- return isl::union_set::empty(ParamSpace);
+ return isl::union_set::empty(ParamSpace.ctx());
}
isl::union_map ZoneAlgorithm::makeEmptyUnionMap() const {
- return isl::union_map::empty(ParamSpace);
+ return isl::union_map::empty(ParamSpace.ctx());
}
void ZoneAlgorithm::collectCompatibleElts() {
static isl::union_map normalizeValInst(isl::union_map Input,
const DenseSet<PHINode *> &ComputedPHIs,
isl::union_map NormalizeMap) {
- isl::union_map Result = isl::union_map::empty(Input.get_space());
+ isl::union_map Result = isl::union_map::empty(Input.ctx());
for (isl::map Map : Input.get_map_list()) {
isl::space Space = Map.get_space();
isl::space RangeSpace = Space.range();
/// Get the universes of all spaces in @p USet.
isl::union_set unionSpace(const isl::union_set &USet) {
- auto Result = isl::union_set::empty(USet.get_space());
+ auto Result = isl::union_set::empty(USet.ctx());
for (isl::set Set : USet.get_set_list()) {
isl::space Space = Set.get_space();
isl::set Universe = isl::set::universe(Space);
if (!OccupiedAndKnown.is_null()) {
assert(Known.is_null());
- Known = isl::union_map::empty(ParamSpace);
+ Known = isl::union_map::empty(ParamSpace.ctx());
if (Occupied.is_null())
Occupied = OccupiedAndKnown.domain();
}
if (Known.is_null()) { // By default, nothing is known.
- Known = isl::union_map::empty(ParamSpace);
+ Known = isl::union_map::empty(ParamSpace.ctx());
}
// Conditions that must hold when returning.
isl::union_map ProposedOccupiedAndKnown, isl::union_set ProposedUnused,
isl::union_map ProposedWritten) {
// Determine universe (set of all possible domains).
- auto Universe = isl::union_set::empty(isl::space::params_alloc(Ctx, 0));
+ auto Universe = isl::union_set::empty(Ctx);
if (!ExistingOccupiedAndKnown.is_null())
Universe = Universe.unite(ExistingOccupiedAndKnown.domain());
if (!ExistingUnused.is_null())