[Polly] Use Isl c++ for InvalidDomainMap

[grosser]

Hi Nandini,

thank you for working on this! If you get memory leaks, I suggest to try to try to reduce the size of the patch. Can you e.g. only translate the InvalidDomainMap? If this works, we can then gradually add more changes?

[nandini12396]

In D35308#806933, @grosser wrote:

Hi Nandini,

thank you for working on this! If you get memory leaks, I suggest to try to try to reduce the size of the patch. Can you e.g. only translate the InvalidDomainMap? If this works, we can then gradually add more changes?

Sure. I will remove the unnecessary changes.

[grosser]

Mark this as requesting changes to make sure this does not appear as "requiring review" just yet.

[grosser]

Hi Nandini,

thanks for the update. The patch is almost perfect. Just two minor corrections needed. It seems we are lacking some good documentation of get(), copy(), and release(). I will write it down for you in a second. Meanwhile, can you update your patch and see if it is working with the proposed changes.

lib/Analysis/ScopInfo.cpp

2777 ↗

(On Diff #106757)

Use copy() here.

2817 ↗

(On Diff #106757)

Use copy() here.

[nandini12396]

Hello Sir,

thank you! It did work indeed!!

[nandini12396]

I understood the documentation from https://reviews.llvm.org/D30325#686684. From what I understood, get() is used to obtain a raw pointer that can be passed but that does not have to be consumed.

[grosser]

Right, now the InvalidDomain is indeed consumed. Which is why using get() is not right. Does this make sense? Is there something specific we can or should explain better?

lib/Analysis/ScopInfo.cpp

2783 ↗

(On Diff #106757)

InvalidDomain is consumed here.

2785 ↗

(On Diff #106757)

InvalidDomain is consumed here.

[nandini12396]

Addressed mistakes, as suggested by Tobias Sir.

[grosser]

Hi Nandini,

this works now. Thanks a lot! I committed the change for you!

There are two good directions to proceed:

1. Take other (small) chunks of code and translate them to C++
2. Copy/Import and Improve the C++ bindings documentation that you referenced here and add it into our SPINX documentation.

[nandini12396]

In D35308#810522, @grosser wrote:

Hi Nandini,

this works now. Thanks a lot! I committed the change for you!

There are two good directions to proceed:

1. Take other (small) chunks of code and translate them to C++
2. Copy/Import and Improve the C++ bindings documentation that you referenced here and add it into our SPINX documentation.

Sure, thank you so much. I think I understood what I misunderstood.

[grosser]

OK, can you share (and maybe document) what you misunderstood? Others likely make similar mistakes, so it is good to have this documented and explained.

[nandini12396]

In D35308#810529, @grosser wrote:

OK, can you share (and maybe document) what you misunderstood? Others likely make similar mistakes, so it is good to have this documented and explained.

Just that, get() is used to obtain a raw pointer that can be passed to but must not be consumed.

[grosser]

OK. Then we should highlight this in *bold* at an obvious place of our documentation.

[nandini12396]

In D35308#810531, @grosser wrote:

OK. Then we should highlight this in *bold* at an obvious place of our documentation.

sure.

polly/trunk/include/polly/ScopInfo.h

private:
   /// @param BBLoop             The innermost affine loop surrounding @p BB.
   /// @param FinishedExitBlocks Set of region exits the domain was set for.
   /// @param LI                 The LoopInfo for the current function.
   /// @param InvalidDomainMap   BB to InvalidDomain map for the BB of current
   ///                           region.
   void propagateDomainConstraintsToRegionExit(
       BasicBlock *BB, Loop *BBLoop,
       SmallPtrSetImpl<BasicBlock *> &FinishedExitBlocks, LoopInfo &LI,
-      DenseMap<BasicBlock *, __isl_keep isl_set *> &InvalidDomainMap);
+      DenseMap<BasicBlock *, isl::set> &InvalidDomainMap);
 
   /// Compute the union of predecessor domains for @p BB.
   ///
   /// To compute the union of all domains of predecessors of @p BB this
   /// function applies similar reasoning on the CFG structure as described for
   ///   @see propagateDomainConstraintsToRegionExit
   ///
   /// @param BB     The block for which the predecessor domains are collected.
private:
   /// @param L                The loop to process.
   /// @param LI               The LoopInfo for the current function.
   /// @param InvalidDomainMap BB to InvalidDomain map for the BB of current
   ///                         region.
   ///
   /// @returns True if there was no problem and false otherwise.
   bool addLoopBoundsToHeaderDomain(
       Loop *L, LoopInfo &LI,
-      DenseMap<BasicBlock *, __isl_keep isl_set *> &InvalidDomainMap);
+      DenseMap<BasicBlock *, isl::set> &InvalidDomainMap);
 
   /// Compute the branching constraints for each basic block in @p R.
   ///
   /// @param R                The region we currently build branching conditions
   ///                         for.
   /// @param DT               The DominatorTree for the current function.
   /// @param LI               The LoopInfo for the current function.
   /// @param InvalidDomainMap BB to InvalidDomain map for the BB of current
   ///                         region.
   ///
   /// @returns True if there was no problem and false otherwise.
   bool buildDomainsWithBranchConstraints(
       Region *R, DominatorTree &DT, LoopInfo &LI,
-      DenseMap<BasicBlock *, __isl_keep isl_set *> &InvalidDomainMap);
+      DenseMap<BasicBlock *, isl::set> &InvalidDomainMap);
 
   /// Propagate the domain constraints through the region @p R.
   ///
   /// @param R                The region we currently build branching conditions
   /// for.
   /// @param DT               The DominatorTree for the current function.
   /// @param LI               The LoopInfo for the current function.
   /// @param InvalidDomainMap BB to InvalidDomain map for the BB of current
   ///                         region.
   ///
   /// @returns True if there was no problem and false otherwise.
   bool propagateDomainConstraints(
       Region *R, DominatorTree &DT, LoopInfo &LI,
-      DenseMap<BasicBlock *, __isl_keep isl_set *> &InvalidDomainMap);
+      DenseMap<BasicBlock *, isl::set> &InvalidDomainMap);
 
   /// Propagate invalid domains of statements through @p R.
   ///
   /// This method will propagate invalid statement domains through @p R and at
   /// the same time add error block domains to them. Additionally, the domains
   /// of error statements and those only reachable via error statements will be
   /// replaced by an empty set. Later those will be removed completely.
   ///
   /// @param R                The currently traversed region.
   /// @param DT               The DominatorTree for the current function.
   /// @param LI               The LoopInfo for the current function.
   /// @param InvalidDomainMap BB to InvalidDomain map for the BB of current
   ///                         region.
   //
   /// @returns True if there was no problem and false otherwise.
   bool propagateInvalidStmtDomains(
       Region *R, DominatorTree &DT, LoopInfo &LI,
-      DenseMap<BasicBlock *, __isl_keep isl_set *> &InvalidDomainMap);
+      DenseMap<BasicBlock *, isl::set> &InvalidDomainMap);
 
   /// Compute the domain for each basic block in @p R.
   ///
   /// @param R                The region we currently traverse.
   /// @param DT               The DominatorTree for the current function.
   /// @param LI               The LoopInfo for the current function.
   /// @param InvalidDomainMap BB to InvalidDomain map for the BB of current
   ///                         region.
   ///
   /// @returns True if there was no problem and false otherwise.
-  bool
-  buildDomains(Region *R, DominatorTree &DT, LoopInfo &LI,
-               DenseMap<BasicBlock *, __isl_keep isl_set *> &InvalidDomainMap);
+  bool buildDomains(Region *R, DominatorTree &DT, LoopInfo &LI,
+                    DenseMap<BasicBlock *, isl::set> &InvalidDomainMap);
 
   /// Add parameter constraints to @p C that imply a non-empty domain.
   __isl_give isl_set *addNonEmptyDomainConstraints(__isl_take isl_set *C) const;
 
   /// Return the access for the base ptr of @p MA if any.
   MemoryAccess *lookupBasePtrAccess(MemoryAccess *MA);
 
   /// Check if the base ptr of @p MA is in the SCoP but not hoistable.
private:
 
   /// Create an id for @p Param and store it in the ParameterIds map.
   void createParameterId(const SCEV *Param);
 
   /// Build the Context of the Scop.
   void buildContext();
 
   /// Add user provided parameter constraints to context (source code).
-  void addUserAssumptions(
-      AssumptionCache &AC, DominatorTree &DT, LoopInfo &LI,
-      DenseMap<BasicBlock *, __isl_keep isl_set *> &InvalidDomainMap);
+  void addUserAssumptions(AssumptionCache &AC, DominatorTree &DT, LoopInfo &LI,
+                          DenseMap<BasicBlock *, isl::set> &InvalidDomainMap);
 
   /// Add user provided parameter constraints to context (command line).
   void addUserContext();
 
   /// Add the bounds of the parameters to the context.
   void addParameterBounds();
 
   /// Simplify the assumed and invalid context.

polly/trunk/lib/Analysis/ScopBuilder.cpp

for (auto GlobalReadPair : GlobalReads) {
     for (auto *BP : ArrayBasePointers)
       addArrayAccess(GlobalReadStmt, MemAccInst(GlobalRead), MemoryAccess::READ,
                      BP, BP->getType(), false, {AF}, {nullptr}, GlobalRead);
   }
 
   scop->buildInvariantEquivalenceClasses();
 
   /// A map from basic blocks to their invalid domains.
-  DenseMap<BasicBlock *, isl_set *> InvalidDomainMap;
+  DenseMap<BasicBlock *, isl::set> InvalidDomainMap;
 
-  if (!scop->buildDomains(&R, DT, LI, InvalidDomainMap)) {
-    for (auto It : InvalidDomainMap)
-      isl_set_free(It.second);
+  if (!scop->buildDomains(&R, DT, LI, InvalidDomainMap))
     return;
-  }
 
   scop->addUserAssumptions(AC, DT, LI, InvalidDomainMap);
 
   // Initialize the invalid domain.
   for (ScopStmt &Stmt : scop->Stmts)
     if (Stmt.isBlockStmt())
-      Stmt.setInvalidDomain(
-          isl_set_copy(InvalidDomainMap[Stmt.getEntryBlock()]));
+      Stmt.setInvalidDomain(InvalidDomainMap[Stmt.getEntryBlock()].copy());
     else
       Stmt.setInvalidDomain(
-          isl_set_copy(InvalidDomainMap[getRegionNodeBasicBlock(
-              Stmt.getRegion()->getNode())]));
-
-  for (auto It : InvalidDomainMap)
-    isl_set_free(It.second);
+          InvalidDomainMap[getRegionNodeBasicBlock(Stmt.getRegion()->getNode())]
+              .copy());
 
   // Remove empty statements.
   // Exit early in case there are no executable statements left in this scop.
   scop->simplifySCoP(false);
   if (scop->isEmpty())
     return;
 
   // The ScopStmts now have enough information to initialize themselves.

polly/trunk/lib/Analysis/ScopInfo.cpp

 /// @param InvalidDomainMap A map of BB to their invalid domains.
 /// @param E                The SCEV that should be translated.
 /// @param NonNegative      Flag to indicate the @p E has to be non-negative.
 ///
 /// Note that this function will also adjust the invalid context accordingly.
 
 __isl_give isl_pw_aff *
 getPwAff(Scop &S, BasicBlock *BB,
-         DenseMap<BasicBlock *, __isl_keep isl_set *> &InvalidDomainMap,
-         const SCEV *E, bool NonNegative = false) {
+         DenseMap<BasicBlock *, isl::set> &InvalidDomainMap, const SCEV *E,
+         bool NonNegative = false) {
   PWACtx PWAC = S.getPwAff(E, BB, NonNegative);
-  InvalidDomainMap[BB] = isl_set_union(InvalidDomainMap[BB], PWAC.second);
+  InvalidDomainMap[BB] = InvalidDomainMap[BB].unite(isl::manage(PWAC.second));
   return PWAC.first;
 }
 
 /// Build the conditions sets for the switch @p SI in the @p Domain.
 ///
 /// This will fill @p ConditionSets with the conditions under which control
 /// will be moved from @p SI to its successors. Hence, @p ConditionSets will
 /// have as many elements as @p SI has successors.
-static bool buildConditionSets(
-    Scop &S, BasicBlock *BB, SwitchInst *SI, Loop *L,
+static bool
+buildConditionSets(Scop &S, BasicBlock *BB, SwitchInst *SI, Loop *L,
                    __isl_keep isl_set *Domain,
-    DenseMap<BasicBlock *, __isl_keep isl_set *> &InvalidDomainMap,
+                   DenseMap<BasicBlock *, isl::set> &InvalidDomainMap,
                    SmallVectorImpl<__isl_give isl_set *> &ConditionSets) {
 
   Value *Condition = getConditionFromTerminator(SI);
   assert(Condition && "No condition for switch");
 
   ScalarEvolution &SE = *S.getSE();
   isl_pw_aff *LHS, *RHS;
   LHS = getPwAff(S, BB, InvalidDomainMap, SE.getSCEVAtScope(Condition, L));
 

 /// Build the conditions sets for the branch condition @p Condition in
 /// the @p Domain.
 ///
 /// This will fill @p ConditionSets with the conditions under which control
 /// will be moved from @p TI to its successors. Hence, @p ConditionSets will
 /// have as many elements as @p TI has successors. If @p TI is nullptr the
 /// context under which @p Condition is true/false will be returned as the
 /// new elements of @p ConditionSets.
-static bool buildConditionSets(
-    Scop &S, BasicBlock *BB, Value *Condition, TerminatorInst *TI, Loop *L,
-    __isl_keep isl_set *Domain,
-    DenseMap<BasicBlock *, __isl_keep isl_set *> &InvalidDomainMap,
+static bool
+buildConditionSets(Scop &S, BasicBlock *BB, Value *Condition,
+                   TerminatorInst *TI, Loop *L, __isl_keep isl_set *Domain,
+                   DenseMap<BasicBlock *, isl::set> &InvalidDomainMap,
                    SmallVectorImpl<__isl_give isl_set *> &ConditionSets) {
 
   isl_set *ConsequenceCondSet = nullptr;
   if (auto *CCond = dyn_cast<ConstantInt>(Condition)) {
     if (CCond->isZero())
       ConsequenceCondSet = isl_set_empty(isl_set_get_space(Domain));
     else
       ConsequenceCondSet = isl_set_universe(isl_set_get_space(Domain));
   } else if (BinaryOperator *BinOp = dyn_cast<BinaryOperator>(Condition)) {
buildConditionSets(Scop &S, BasicBlock *BB, Value *Condition,
   return true;
 }
 
 /// Build the conditions sets for the terminator @p TI in the @p Domain.
 ///
 /// This will fill @p ConditionSets with the conditions under which control
 /// will be moved from @p TI to its successors. Hence, @p ConditionSets will
 /// have as many elements as @p TI has successors.
-static bool buildConditionSets(
-    Scop &S, BasicBlock *BB, TerminatorInst *TI, Loop *L,
+static bool
+buildConditionSets(Scop &S, BasicBlock *BB, TerminatorInst *TI, Loop *L,
                    __isl_keep isl_set *Domain,
-    DenseMap<BasicBlock *, __isl_keep isl_set *> &InvalidDomainMap,
+                   DenseMap<BasicBlock *, isl::set> &InvalidDomainMap,
                    SmallVectorImpl<__isl_give isl_set *> &ConditionSets) {
 
   if (SwitchInst *SI = dyn_cast<SwitchInst>(TI))
     return buildConditionSets(S, BB, SI, L, Domain, InvalidDomainMap,
                               ConditionSets);
 
   assert(isa<BranchInst>(TI) && "Terminator was neither branch nor switch.");
 
   if (TI->getNumSuccessors() == 1) {

 }
 
 bool Scop::isDominatedBy(const DominatorTree &DT, BasicBlock *BB) const {
   return DT.dominates(BB, getEntry());
 }
 
 void Scop::addUserAssumptions(
     AssumptionCache &AC, DominatorTree &DT, LoopInfo &LI,
-    DenseMap<BasicBlock *, __isl_keep isl_set *> &InvalidDomainMap) {
+    DenseMap<BasicBlock *, isl::set> &InvalidDomainMap) {
   auto &F = getFunction();
   for (auto &Assumption : AC.assumptions()) {
     auto *CI = dyn_cast_or_null<CallInst>(Assumption);
     if (!CI || CI->getNumArgOperands() != 1)
       continue;
 
     bool InScop = contains(CI);
     if (!InScop && !isDominatedBy(DT, CI->getParent()))
__isl_give isl_set *Scop::getDomainConditions(BasicBlock *BB) const {
 
   auto &RI = *R.getRegionInfo();
   auto *BBR = RI.getRegionFor(BB);
   while (BBR->getEntry() == BB)
     BBR = BBR->getParent();
   return getDomainConditions(BBR->getEntry());
 }
 
-bool Scop::buildDomains(
-    Region *R, DominatorTree &DT, LoopInfo &LI,
-    DenseMap<BasicBlock *, __isl_keep isl_set *> &InvalidDomainMap) {
+bool Scop::buildDomains(Region *R, DominatorTree &DT, LoopInfo &LI,
+                        DenseMap<BasicBlock *, isl::set> &InvalidDomainMap) {
 
   bool IsOnlyNonAffineRegion = isNonAffineSubRegion(R);
   auto *EntryBB = R->getEntry();
   auto *L = IsOnlyNonAffineRegion ? nullptr : LI.getLoopFor(EntryBB);
   int LD = getRelativeLoopDepth(L);
   auto *S = isl_set_universe(isl_space_set_alloc(getIslCtx(), 0, LD + 1));
 
   while (LD-- >= 0) {
     S = addDomainDimId(S, LD + 1, L);
     L = L->getParentLoop();
   }
 
-  InvalidDomainMap[EntryBB] = isl_set_empty(isl_set_get_space(S));
+  InvalidDomainMap[EntryBB] = isl::manage(isl_set_empty(isl_set_get_space(S)));
   DomainMap[EntryBB] = S;
 
   if (IsOnlyNonAffineRegion)
     return !containsErrorBlock(R->getNode(), *R, LI, DT);
 
   if (!buildDomainsWithBranchConstraints(R, DT, LI, InvalidDomainMap))
     return false;
 
if (OldDepth == NewDepth) {
     Dom = isl_set_project_out(Dom, isl_dim_set, NumDim - Diff, Diff);
   }
 
   return Dom;
 }
 
 bool Scop::propagateInvalidStmtDomains(
     Region *R, DominatorTree &DT, LoopInfo &LI,
-    DenseMap<BasicBlock *, __isl_keep isl_set *> &InvalidDomainMap) {
+    DenseMap<BasicBlock *, isl::set> &InvalidDomainMap) {
 
   ReversePostOrderTraversal<Region *> RTraversal(R);
   for (auto *RN : RTraversal) {
 
     // Recurse for affine subregions but go on for basic blocks and non-affine
     // subregions.
     if (RN->isSubRegion()) {
       Region *SubRegion = RN->getNodeAs<Region>();
       if (!isNonAffineSubRegion(SubRegion)) {
         propagateInvalidStmtDomains(SubRegion, DT, LI, InvalidDomainMap);
         continue;
       }
     }
 
     bool ContainsErrorBlock = containsErrorBlock(RN, getRegion(), LI, DT);
     BasicBlock *BB = getRegionNodeBasicBlock(RN);
     isl_set *&Domain = DomainMap[BB];
     assert(Domain && "Cannot propagate a nullptr");
 
-    auto *InvalidDomain = InvalidDomainMap[BB];
+    auto *InvalidDomain = InvalidDomainMap[BB].copy();
 
     bool IsInvalidBlock =
         ContainsErrorBlock || isl_set_is_subset(Domain, InvalidDomain);
 
     if (!IsInvalidBlock) {
       InvalidDomain = isl_set_intersect(InvalidDomain, isl_set_copy(Domain));
     } else {
       isl_set_free(InvalidDomain);
       InvalidDomain = Domain;
       isl_set *DomPar = isl_set_params(isl_set_copy(Domain));
       recordAssumption(ERRORBLOCK, DomPar, BB->getTerminator()->getDebugLoc(),
                        AS_RESTRICTION);
       Domain = nullptr;
     }
 
     if (isl_set_is_empty(InvalidDomain)) {
-      InvalidDomainMap[BB] = InvalidDomain;
+      InvalidDomainMap[BB] = isl::manage(InvalidDomain);
       continue;
     }
 
     auto *BBLoop = getRegionNodeLoop(RN, LI);
     auto *TI = BB->getTerminator();
     unsigned NumSuccs = RN->isSubRegion() ? 1 : TI->getNumSuccessors();
     for (unsigned u = 0; u < NumSuccs; u++) {
       auto *SuccBB = getRegionNodeSuccessor(RN, TI, u);
 
       // Skip successors outside the SCoP.
       if (!contains(SuccBB))
         continue;
 
       // Skip backedges.
       if (DT.dominates(SuccBB, BB))
         continue;
 
       Loop *SuccBBLoop = getFirstNonBoxedLoopFor(SuccBB, LI, getBoxedLoops());
 
       auto *AdjustedInvalidDomain = adjustDomainDimensions(
           *this, isl_set_copy(InvalidDomain), BBLoop, SuccBBLoop);
 
-      auto *SuccInvalidDomain = InvalidDomainMap[SuccBB];
+      auto *SuccInvalidDomain = InvalidDomainMap[SuccBB].copy();
       SuccInvalidDomain =
           isl_set_union(SuccInvalidDomain, AdjustedInvalidDomain);
       SuccInvalidDomain = isl_set_coalesce(SuccInvalidDomain);
       unsigned NumConjucts = isl_set_n_basic_set(SuccInvalidDomain);
 
-      InvalidDomainMap[SuccBB] = SuccInvalidDomain;
+      InvalidDomainMap[SuccBB] = isl::manage(SuccInvalidDomain);
 
       // Check if the maximal number of domain disjunctions was reached.
       // In case this happens we will bail.
       if (NumConjucts < MaxDisjunctsInDomain)
         continue;
 
       isl_set_free(InvalidDomain);
       InvalidDomainMap.erase(BB);
       invalidate(COMPLEXITY, TI->getDebugLoc());
       return false;
     }
 
-    InvalidDomainMap[BB] = InvalidDomain;
+    InvalidDomainMap[BB] = isl::manage(InvalidDomain);
   }
 
   return true;
 }
 
 void Scop::propagateDomainConstraintsToRegionExit(
     BasicBlock *BB, Loop *BBLoop,
     SmallPtrSetImpl<BasicBlock *> &FinishedExitBlocks, LoopInfo &LI,
-    DenseMap<BasicBlock *, __isl_keep isl_set *> &InvalidDomainMap) {
+    DenseMap<BasicBlock *, isl::set> &InvalidDomainMap) {
 
   // Check if the block @p BB is the entry of a region. If so we propagate it's
   // domain to the exit block of the region. Otherwise we are done.
   auto *RI = R.getRegionInfo();
   auto *BBReg = RI ? RI->getRegionFor(BB) : nullptr;
   auto *ExitBB = BBReg ? BBReg->getExit() : nullptr;
   if (!BBReg || BBReg->getEntry() != BB || !contains(ExitBB))
     return;
void Scop::propagateDomainConstraintsToRegionExit(
   auto *&ExitDomain = DomainMap[ExitBB];
 
   // If the exit domain is not yet created we set it otherwise we "add" the
   // current domain.
   ExitDomain =
       ExitDomain ? isl_set_union(AdjustedDomain, ExitDomain) : AdjustedDomain;
 
   // Initialize the invalid domain.
-  auto IDIt = InvalidDomainMap.find(ExitBB);
-  if (IDIt != InvalidDomainMap.end())
-    isl_set_free(IDIt->getSecond());
-  InvalidDomainMap[ExitBB] = isl_set_empty(isl_set_get_space(ExitDomain));
+  InvalidDomainMap[ExitBB] =
+      isl::manage(isl_set_empty(isl_set_get_space(ExitDomain)));
 
   FinishedExitBlocks.insert(ExitBB);
 }
 
 bool Scop::buildDomainsWithBranchConstraints(
     Region *R, DominatorTree &DT, LoopInfo &LI,
-    DenseMap<BasicBlock *, __isl_keep isl_set *> &InvalidDomainMap) {
+    DenseMap<BasicBlock *, isl::set> &InvalidDomainMap) {
 
   // To create the domain for each block in R we iterate over all blocks and
   // subregions in R and propagate the conditions under which the current region
   // element is executed. To this end we iterate in reverse post order over R as
   // it ensures that we first visit all predecessors of a region node (either a
   // basic block or a subregion) before we visit the region node itself.
   // Initially, only the domain for the SCoP region entry block is set and from
   // there we propagate the current domain to all successors, however we add the
for (unsigned u = 0, e = ConditionSets.size(); u < e; u++) {
       // case there are multiple paths (without loop back edges) to the
       // successor block.
       isl_set *&SuccDomain = DomainMap[SuccBB];
 
       if (SuccDomain) {
         SuccDomain = isl_set_coalesce(isl_set_union(SuccDomain, CondSet));
       } else {
         // Initialize the invalid domain.
-        auto IDIt = InvalidDomainMap.find(SuccBB);
-        if (IDIt != InvalidDomainMap.end())
-          isl_set_free(IDIt->getSecond());
-        InvalidDomainMap[SuccBB] = isl_set_empty(isl_set_get_space(CondSet));
+        InvalidDomainMap[SuccBB] =
+            isl::manage(isl_set_empty(isl_set_get_space(CondSet)));
         SuccDomain = CondSet;
       }
 
       SuccDomain = isl_set_detect_equalities(SuccDomain);
 
       // Check if the maximal number of domain disjunctions was reached.
       // In case this happens we will clean up and bail.
       if (isl_set_n_basic_set(SuccDomain) < MaxDisjunctsInDomain)
for (auto *PredBB : predecessors(BB)) {
     PredDom = isl_set_union(PredDom, PredBBDom);
   }
 
   return PredDom;
 }
 
 bool Scop::propagateDomainConstraints(
     Region *R, DominatorTree &DT, LoopInfo &LI,
-    DenseMap<BasicBlock *, __isl_keep isl_set *> &InvalidDomainMap) {
+    DenseMap<BasicBlock *, isl::set> &InvalidDomainMap) {
   // Iterate over the region R and propagate the domain constrains from the
   // predecessors to the current node. In contrast to the
   // buildDomainsWithBranchConstraints function, this one will pull the domain
   // information from the predecessors instead of pushing it to the successors.
   // Additionally, we assume the domains to be already present in the domain
   // map here. However, we iterate again in reverse post order so we know all
   // predecessors have been visited before a block or non-affine subregion is
   // visited.
createNextIterationMap(__isl_take isl_space *SetSpace, unsigned Dim) {
   C = isl_constraint_set_constant_si(C, 1);
   C = isl_constraint_set_coefficient_si(C, isl_dim_in, Dim, 1);
   C = isl_constraint_set_coefficient_si(C, isl_dim_out, Dim, -1);
   NextIterationMap = isl_map_add_constraint(NextIterationMap, C);
   return NextIterationMap;
 }
 
 bool Scop::addLoopBoundsToHeaderDomain(
-    Loop *L, LoopInfo &LI,
-    DenseMap<BasicBlock *, __isl_keep isl_set *> &InvalidDomainMap) {
+    Loop *L, LoopInfo &LI, DenseMap<BasicBlock *, isl::set> &InvalidDomainMap) {
   int LoopDepth = getRelativeLoopDepth(L);
   assert(LoopDepth >= 0 && "Loop in region should have at least depth one");
 
   BasicBlock *HeaderBB = L->getHeader();
   assert(DomainMap.count(HeaderBB));
   isl_set *&HeaderBBDom = DomainMap[HeaderBB];
 
   isl_map *NextIterationMap =