[Polly] [Refactor] Move isl_ctx into Scop.

[etherzhhb]

Summary

This patch makes the ScopInfo carry less context, and makes it easier for the new PassManager change.

[jdoerfert]

I think this is not what we want. Globals are always bad when we think about parallel execution of passes. While we still have a global map flying around that nobody cares to remove we... we should not introduce new globals that will break the assumption that non-connected parts of the module can be compiled concurrently. As an alternative I would suggest to move the isl_ctx into the Scop class and let it deal correctly with deallocating all derived objects once it (the Scop) is deleted.

[etherzhhb]

In D17241#352224, @jdoerfert wrote:

I think this is not what we want. Globals are always bad when we think about parallel execution of passes. While we still have a global map flying around that nobody cares to remove we... we should not introduce new globals that will break the assumption that non-connected parts of the module can be compiled concurrently. As an alternative I would suggest to move the isl_ctx into the Scop class and let it deal correctly with deallocating all derived objects once it (the Scop) is deleted.

I agree that we should move the isl_ctx to Scop.

[etherzhhb]

I have no opinion whether we should share isl_ctx across SCoPs or should make it becomes SCoP local, because I have no idea what context does it carry and how it is used.

I think make it becomes SCoP local is a good idea since the SCoPs are independent.

However, this patch does *NOT* work, and I get the following stack dump:

#6 0x00007ffff6a01528 abort /build/glibc-3Vu5mt/glibc-2.19/stdlib/abort.c:91:0
#7 0x00007ffff6581856 isl_handle_error /home/ether/work/llvm/tools/polly/lib/External/isl/isl_ctx.c:93:0
#8 0x00007ffff6581d35 isl_ctx_free /home/ether/work/llvm/tools/polly/lib/External/isl/isl_ctx.c:243:0
#9 0x00007ffff648a95c polly::Scop::~Scop() /home/ether/work/llvm/tools/polly/lib/Analysis/ScopInfo.cpp:2777:0
#10 0x00007ffff64a650a std::default_delete<polly::Scop>::operator()(polly::Scop*) const /usr/include/c++/4.9/bits/unique_ptr.h:76:0
#11 0x00007ffff649e6db std::unique_ptr<polly::Scop, std::default_delete<polly::Scop> >::reset(polly::Scop*) /usr/include/c++/4.9/bits/unique_ptr.h:345:0
#12 0x00007ffff6490b85 polly::ScopInfo::clear() /home/ether/work/llvm/tools/polly/lib/Analysis/ScopInfo.cpp:4157:0
#13 0x00007ffff64951de polly::ScopInfo::releaseMemory() /home/ether/work/llvm/tools/polly/include/polly/ScopInfo.h:2223:0
#14 0x000000000169a1dc llvm::PMDataManager::freePass(llvm::Pass*, llvm::StringRef, llvm::PassDebuggingString) /home/ether/work/llvm/lib/IR/LegacyPassManager.cpp:976:0
#15 0x000000000169a0ee llvm::PMDataManager::removeDeadPasses(llvm::Pass*, llvm::StringRef, llvm::PassDebuggingString) /home/ether/work/llvm/lib/IR/LegacyPassManager.cpp:964:0
#16 0x000000000119d602 llvm::RGPassManager::runOnFunction(llvm::Function&) /home/ether/work/llvm/lib/Analysis/RegionPass.cpp:130:0
#17 0x000000000169c75e llvm::FPPassManager::runOnFunction(llvm::Function&) /home/ether/work/llvm/lib/IR/LegacyPassManager.cpp:1550:0
#18 0x000000000169c8f1 llvm::FPPassManager::runOnModule(llvm::Module&) /home/ether/work/llvm/lib/IR/LegacyPassManager.cpp:1571:0
#19 0x000000000169cc7d (anonymous namespace)::MPPassManager::runOnModule(llvm::Module&) /home/ether/work/llvm/lib/IR/LegacyPassManager.cpp:1627:0
#20 0x000000000169d373 llvm::legacy::PassManagerImpl::run(llvm::Module&) /home/ether/work/llvm/lib/IR/LegacyPassManager.cpp:1730:0
#21 0x000000000169d5b3 llvm::legacy::PassManager::run(llvm::Module&) /home/ether/work/llvm/lib/IR/LegacyPassManager.cpp:1762:0
#22 0x0000000000de12b5 main /home/ether/work/llvm/tools/opt/opt.cpp:631:0

I free the IslCtx by "isl_ctx_free(IslCtx)" at the end of the destructor and get the above error. I don't know why this happens, any hit?

[etherzhhb]

Update diff

[jdoerfert]

lib/Analysis/ScopInfo.cpp

2800 ↗

(On Diff #47911)

You have to free all isl_objects that were created with this Ctx first. Missing are at least:

• The ScopArrayInfoObjects
• The Statements
  • The MemoryAccesses

Maybe even more.

Stmts.clear();            // Takes care of all Statement objects
AccFuncMap.clear();       //  ... " " ........ MemoryAccesses objects
ScopArrayInfoMap.clear(); //  ... " " ........ ScopArrayInfo objects

Did that catch all?

[etherzhhb]

I know what happened, let me fix that

[etherzhhb]

lib/Analysis/ScopInfo.cpp

2800 ↗

(On Diff #47911)

We also need to make sure we delete the context after we delete Dependences and IslAst, which also create isl objects with the context.

I am going to use a shared_ptr to manage that.

[etherzhhb]

In order to make sure that we delete the isl context after all isl objects are delete, we introduce shared_ptrs to manage the life time of the context. We are going to distribute the shared_ptr to Dependences/IslNode which also create isl objects form the context. By doing this, we make sure the context is delete when we delete the last objects that create isl object from the context.

[jdoerfert]

LGTM. But I am not sure about the shared pointer, so I would appreciate somebody else looking at the patch.

[grosser]

Hi ether,

I think moving the isl_ctx into the scop is good, but similarly to Johannes I do not yet understand the use of the shared-ptr. All isl objects take plain pointers, so the shared pointer itself goes very quickly out-of-scope. My feeling is that this very same change should work already without shared pointers. If it does not, then we likely have a memory issue that is just be covered by shared pointers. ether: when not using shared pointers, which element is freed only after we try to free the isl_ctx?

[etherzhhb]

Currently, we build isl object in ScopInfo, DependencyInfo and IslAst.

We must free all isl objects before we free the ctx. And I try to use the reference counter from shared_ptr to figure out the time to free the isl ctx.

Suppose we free ScopInfo, DependencyInfo, IslAst in order:

If we only run ScopInfo, we should free ctx when we free the corresponding Scop.

If we only run ScopInfo and DependencyInfo, we should free ctx when we free the corresponding Dependences.

If we only run ScopInfo, DependencyInfo and IslAst, we should free ctx when we free the corresponding IslAst.

And if ScopInfo, DependencyInfo, IslAst are not free in order, it become a total mess ....

Using the reference counter from the shared_ptr can solve this problem: Everytime we destruct a shared_ptr, the shared_ptr will decrease the reference counter. If the reference counter is decreased to 0, the current analysis result we are destructing are the last one that hold isl objects -- and there are no isl object left, which mean it is safe to free the isl context.

A better solution may be provide a "isl_free_ctx_if_ref_is_zero" function which do not actually free the context until all isl objs are released?

Or we can try to make an SCoP to remember all the created ISL objects, and only free isl objs in the SCoP info?

[llvm-commits]

And if ScopInfo, DependencyInfo, IslAst are not free in order, it become a total mess ....

The pass manager should free IslAst, DependencyInfo, ... before ScopInfo
because they have a dependence on the ScopInfo results. Am I wrong?

• signature.asc219 BDownload
• msg-3247-509.txt162 BDownload

[etherzhhb]

In D17241#352759, @llvm-commits wrote:

And if ScopInfo, DependencyInfo, IslAst are not free in order, it become a total mess ....

The pass manager should free IslAst, DependencyInfo, ... before ScopInfo
because they have a dependence on the ScopInfo results. Am I wrong?

Sorry I am not precise enough. It should be Scop (the result of ScopInfo), Dependences (the result of DependenceInfo) and IslAst (the result of IslAstInfo).

Let me do some experiments to confirm the order with the debug-pass option.

[etherzhhb]

Actually we free ScopInfo before other scop analyses:
/home/ether/work/llvm_build/bin/opt -load /home/ether/work/llvm_build/lib/LLVMPolly.so -polly-ast -polly-dependences -polly-ast-detect-parallel -analyze /home/ether/work/llvm/tools/polly/test/Isl/Ast/dependence_distance_constant.ll --debug-pass=Executions

[2016-02-15 16:19:24.577937000] 0x380e7c0 Freeing Pass 'Polly - Create polyhedral description of Scops' on Region 'for.cond => for.end8'...
[2016-02-15 16:19:24.578081000] 0x380e7c0 Freeing Pass 'Polly - Generate an AST from the SCoP (isl)' on Region 'for.cond => for.end8'...
[2016-02-15 16:19:24.578174000] 0x380e7c0 Freeing Pass 'Polly - Calculate dependences' on Region 'for.cond => for.end8'...

[etherzhhb]

lib/External/isl/include/isl/ctx.h

164 ↗

(On Diff #48024)

feel free to suggest a better name

[Meinersbur]

We don't modify the source in External/isl. For any change there, we have to ask Sven Verdoolaege to include it into the mainline isl. In the context of isl only this makes less sense. One would want to have a proper memory management instead of disabling the memory leak detection feature.

Because of missing alternatives, I'd vote for the shared_ptr solution.

include/polly/ScopInfo.h

1282 ↗

(On Diff #48024)

The comment still mentions shared_ptr.

[grosser]

I am a little worried about both of these changes. Will we still be warned if we forgot to release a pointer or are will we just stop to free isl_ctx due to the wrong order of freeing items.

Also, I am surprised why this works today without any troubles? For whatever reason today it seems to be ensured that we free everything else before the ScopInfo pass has been freed. Eithers observation of the different pass order somehow suggests that this should not be the case, but it still magically works. Do you understand why this currently works despite the pass freeing being reversed?

[etherzhhb]

In D17241#353522, @grosser wrote:

I am a little worried about both of these changes. Will we still be warned if we forgot to release a pointer or are will we just stop to free isl_ctx due to the wrong order of freeing items.

Without shared_ptr, there will be no warning.
With the shared_ptr, we the program abort if we do not free all isl objects.

Also, I am surprised why this works today without any troubles? For whatever reason today it seems to be ensured that we free everything else before the ScopInfo pass has been freed.

Originally, we only free the isl ctx when we destruct/delete the ScopInfo pass itself. With this patch, we free the isl ctx when we destruct/delete the Scop (the analysis result of ScopInfo), in the releaseMemory function of ScopInfo ().

A single ScopInfo pass will produce multiple Scop, we call releaseMemory of the same ScopInfo multiple times, and only delete ScopInfo pass itself once. That is the different. I think the message "Freeing Pass 'Polly - Generate an AST from the SCoP (isl)' on Region 'for.cond => for.end8'" is generated when we call releaseMemory, instead of deleting the pass.

Eithers observation of the different pass order somehow suggests that this should not be the case, but it still magically works. Do you understand why this currently works despite the pass freeing being reversed?

Explained above.

[grosser]

Thanks ether for explaining these things in detail. It seems indeed to be the case that we free passes in a rather unpredictable order. If this is the case, the shared pointer approach seems OK and I now convinced myself that it works and does not prevent us from loosing the ability to understand if we leak memory.

However, if we could understand why this freeing behavior is so unpredictable that would be nice.

Best,
Tobias

[etherzhhb]

They are deleted by "removeDeadPasses".

And the dead passes are collected by "collectLastUses".

Where the last users -- the passes that are going to be freed, are stored in a SmallPtrSet. (See line 569 of LegacyPassManager.cpp).

A SmallPtrSet is not an ordered container, as a result, there is no guarantee on the order we are going to free the dead passes.

[etherzhhb]

another approach is to make all isl objects under Scop's control, and let Scop free them all.

[grosser]

I see. I still would expect that there is an order in which passes are
freed, but if this is not the case let's go with the shared pointer. I
do not see how we can allocate all objects under scop's control. That
seems to be even more complicated.

Best,
Tobias

[etherzhhb]

Use shared_ptr again.

After we move isl_ctx into Scop, we need to make sure the isl_ctx
 is free after all isl objects are freed. This is no straightforward
 because we create isl objects in multiple analyses, and the PassManager
 make no guarantee on the order of freeing those passes.

 To solve this problem, we distribute the same isl_ctx to all analyses
 that create isl objects with shared_ptrs that share the same reference
 conter. The idea is to use the reference counter to capture the last
 pass that are being freed, and free the isl_ctx at that time.

[grosser]

LGTM.

Besides one unrelated whitespace change and a couple of typos in the commit message.

Best,
Tobias

lib/Analysis/ScopInfo.cpp

115 ↗

(On Diff #48186)

Unrelated withspace change.

polly/trunk/include/polly/DependenceInfo.h

struct Dependences {
   void dump() const;
 
   /// @brief Allow the DependenceInfo access to private members and methods.
   ///
   /// To restict access to the internal state only the DependenceInfo class
   /// is able to call or modify a dependences struct.
   friend class DependenceInfo;
 
-private:
-  /// @brief Create an empty dependences struct.
-  Dependences()
-      : RAW(nullptr), WAR(nullptr), WAW(nullptr), RED(nullptr),
-        TC_RED(nullptr) {}
-
   /// @brief Destructor that will free internal objects.
   ~Dependences() { releaseMemory(); }
 
+private:
+  /// @brief Create an empty dependences struct.
+  explicit Dependences(const std::shared_ptr<isl_ctx> &IslCtx)
+      : RAW(nullptr), WAR(nullptr), WAW(nullptr), RED(nullptr), TC_RED(nullptr),
+        IslCtx(IslCtx) {}
+
   /// @brief Calculate and add at the privatization dependences.
   void addPrivatizationDependences();
 
   /// @brief Calculate the dependences for a certain SCoP @p S.
   void calculateDependences(Scop &S);
 
   /// @brief Set the reduction dependences for @p MA to @p Deps.
   void setReductionDependences(MemoryAccess *MA, __isl_take isl_map *Deps);
private:
   /// @brief The special reduction dependences.
   isl_union_map *RED;
 
   /// @brief The (reverse) transitive closure of reduction dependences.
   isl_union_map *TC_RED;
 
   /// @brief Mapping from memory accesses to their reduction dependences.
   ReductionDependencesMapTy ReductionDependences;
+
+  /// Isl context from the SCoP.
+  std::shared_ptr<isl_ctx> IslCtx;
 };
 
 class DependenceInfo : public ScopPass {
 public:
   static char ID;
 
   /// @brief Construct a new DependenceInfo pass.
   DependenceInfo() : ScopPass(ID) {}
 
   /// @brief Return the dependence information for the current SCoP.
-  const Dependences &getDependences() { return D; }
+  const Dependences &getDependences() { return *D; }
 
   /// @brief Recompute dependences from schedule and memory accesses.
   void recomputeDependences();
 
   /// @brief Compute the dependence information for the SCoP @p S.
   bool runOnScop(Scop &S) override;
 
   /// @brief Print the dependences for the given SCoP to @p OS.
-  void printScop(raw_ostream &OS, Scop &) const override { D.print(OS); }
+  void printScop(raw_ostream &OS, Scop &) const override { D->print(OS); }
 
   /// @brief Release the internal memory.
-  void releaseMemory() override { D.releaseMemory(); }
+  void releaseMemory() override { D.reset(); }
 
   /// @brief Register all analyses and transformation required.
   void getAnalysisUsage(AnalysisUsage &AU) const override;
 
 private:
   Scop *S;
 
   /// @brief Dependences struct for the current SCoP.
-  Dependences D;
+  std::auto_ptr<Dependences> D;
 };
 
 } // End polly namespace.
 
 namespace llvm {
 class PassRegistry;
 void initializeDependenceInfoPass(llvm::PassRegistry &);
 }
 
 #endif

polly/trunk/include/polly/ScopInfo.h

private:
   typedef SmallVector<const SCEV *, 8> ParamVecType;
   ParamVecType Parameters;
 
   /// The isl_ids that are used to represent the parameters
   typedef std::map<const SCEV *, int> ParamIdType;
   ParamIdType ParameterIds;
 
   /// Isl context.
-  isl_ctx *IslCtx;
+  ///
+  /// We need a shared_ptr with reference counter to delete the context when all
+  /// isl objects are deleted. We will distribute the shared_ptr to all objects
+  /// that use the context to create isl objects, and increase the reference
+  /// counter. By doing this, we guarantee that the context is deleted when we
+  /// delete the last object that creates isl objects with the context.
+  std::shared_ptr<isl_ctx> IslCtx;
 
   /// @brief A map from basic blocks to SCoP statements.
   DenseMap<BasicBlock *, ScopStmt *> StmtMap;
 
   /// @brief A map from basic blocks to their domains.
   DenseMap<BasicBlock *, isl_set *> DomainMap;
 
   /// Constraints on parameters.
private:
   /// @brief Mapping from invariant loads to the representing invariant load of
   ///        their equivalence class.
   ValueToValueMap InvEquivClassVMap;
 
   /// @brief List of invariant accesses.
   InvariantEquivClassesTy InvariantEquivClasses;
 
   /// @brief Scop constructor; invoked from ScopInfo::buildScop.
-  Scop(Region &R, ScalarEvolution &SE, isl_ctx *ctx, unsigned MaxLoopDepth);
+  Scop(Region &R, ScalarEvolution &SE, unsigned MaxLoopDepth);
 
   /// @brief Get or create the access function set in a BasicBlock
   AccFuncSetType &getOrCreateAccessFunctions(const BasicBlock *BB) {
     return AccFuncMap[BB];
   }
   //@}
 
   /// @brief Initialize this ScopInfo .
public:
   /// @brief Print the ScopStmt to stderr.
   void dump() const;
 
   /// @brief Get the isl context of this static control part.
   ///
   /// @return The isl context of this static control part.
   isl_ctx *getIslCtx() const;
 
+  /// @brief Directly return the shared_ptr of the context.
+  const std::shared_ptr<isl_ctx> &getSharedIslCtx() const { return IslCtx; }
+
   /// @brief Compute the isl representation for the SCEV @p
   ///
   /// @param BB An (optional) basic block in which the isl_pw_aff is computed.
   ///           SCEVs known to not reference any loops in the SCoP can be
   ///           passed without a @p BB.
   __isl_give isl_pw_aff *getPwAff(const SCEV *E, BasicBlock *BB = nullptr);
 
   /// @brief Return the non-loop carried conditions on the domain of @p Stmt.
class ScopInfo : public RegionPass {
   /// @biref Valid Regions for Scop
   ScopDetection *SD;
 
   /// @brief The ScalarEvolution to help building Scop.
   ScalarEvolution *SE;
 
   // The Scop
   std::unique_ptr<Scop> scop;
-  isl_ctx *ctx;
 
   // Clear the context.
   void clear();
 
   // Build the SCoP for Region @p R.
   void buildScop(Region &R, AssumptionCache &AC);
 
   /// @brief Try to build a multi-dimensional fixed sized MemoryAccess from

polly/trunk/lib/Analysis/DependenceInfo.cpp

if (!isl_union_map_is_empty(ScheduleMap)) {
       isl_union_map_free(ScheduleMap);
     }
   }
 
   Read = isl_union_map_coalesce(Read);
   Write = isl_union_map_coalesce(Write);
   MayWrite = isl_union_map_coalesce(MayWrite);
 
-  long MaxOpsOld = isl_ctx_get_max_operations(S.getIslCtx());
+  long MaxOpsOld = isl_ctx_get_max_operations(IslCtx.get());
   if (OptComputeOut)
-    isl_ctx_set_max_operations(S.getIslCtx(), OptComputeOut);
-  isl_options_set_on_error(S.getIslCtx(), ISL_ON_ERROR_CONTINUE);
+    isl_ctx_set_max_operations(IslCtx.get(), OptComputeOut);
+  isl_options_set_on_error(IslCtx.get(), ISL_ON_ERROR_CONTINUE);
 
   DEBUG(dbgs() << "Read: " << Read << "\n";
         dbgs() << "Write: " << Write << "\n";
         dbgs() << "MayWrite: " << MayWrite << "\n");
 
   RAW = WAW = WAR = RED = nullptr;
 
   if (OptAnalysisType == VALUE_BASED_ANALYSIS) {
void Dependences::calculateDependences(Scop &S) {
   isl_union_map_free(MayWrite);
   isl_union_map_free(Write);
   isl_union_map_free(Read);
 
   RAW = isl_union_map_coalesce(RAW);
   WAW = isl_union_map_coalesce(WAW);
   WAR = isl_union_map_coalesce(WAR);
 
-  if (isl_ctx_last_error(S.getIslCtx()) == isl_error_quota) {
+  if (isl_ctx_last_error(IslCtx.get()) == isl_error_quota) {
     isl_union_map_free(RAW);
     isl_union_map_free(WAW);
     isl_union_map_free(WAR);
     RAW = WAW = WAR = nullptr;
-    isl_ctx_reset_error(S.getIslCtx());
+    isl_ctx_reset_error(IslCtx.get());
   }
-  isl_options_set_on_error(S.getIslCtx(), ISL_ON_ERROR_ABORT);
-  isl_ctx_reset_operations(S.getIslCtx());
-  isl_ctx_set_max_operations(S.getIslCtx(), MaxOpsOld);
+  isl_options_set_on_error(IslCtx.get(), ISL_ON_ERROR_ABORT);
+  isl_ctx_reset_operations(IslCtx.get());
+  isl_ctx_set_max_operations(IslCtx.get(), MaxOpsOld);
 
   isl_union_map *STMT_RAW, *STMT_WAW, *STMT_WAR;
   STMT_RAW = isl_union_map_intersect_domain(
       isl_union_map_copy(RAW),
       isl_union_map_domain(isl_union_map_copy(StmtSchedule)));
   STMT_WAW = isl_union_map_intersect_domain(
       isl_union_map_copy(WAW),
       isl_union_map_domain(isl_union_map_copy(StmtSchedule)));

 
 void Dependences::setReductionDependences(MemoryAccess *MA, isl_map *D) {
   assert(ReductionDependences.count(MA) == 0 &&
          "Reduction dependences set twice!");
   ReductionDependences[MA] = D;
 }
 
 void DependenceInfo::recomputeDependences() {
-  releaseMemory();
-  D.calculateDependences(*S);
+  D.reset(new Dependences(S->getSharedIslCtx()));
+  D->calculateDependences(*S);
 }
 
 bool DependenceInfo::runOnScop(Scop &ScopVar) {
   S = &ScopVar;
   recomputeDependences();
   return false;
 }
 

polly/trunk/lib/Analysis/ScopInfo.cpp

for (auto &Assumption : AC.assumptions()) {
     Context = isl_set_intersect(Context, AssumptionCtx);
   }
 }
 
 void Scop::addUserContext() {
   if (UserContextStr.empty())
     return;
 
-  isl_set *UserContext = isl_set_read_from_str(IslCtx, UserContextStr.c_str());
+  isl_set *UserContext =
+      isl_set_read_from_str(getIslCtx(), UserContextStr.c_str());
   isl_space *Space = getParamSpace();
   if (isl_space_dim(Space, isl_dim_param) !=
       isl_set_dim(UserContext, isl_dim_param)) {
     auto SpaceStr = isl_space_to_str(Space);
     errs() << "Error: the context provided in -polly-context has not the same "
            << "number of dimensions than the computed context. Due to this "
            << "mismatch, the -polly-context option is ignored. Please provide "
            << "the context in the parameter space: " << SpaceStr << ".\n";
for (LoadInst *LInst : RIL) {
 
     ClassRep = LInst;
     InvariantEquivClasses.emplace_back(PointerSCEV, MemoryAccessList(), nullptr,
                                        Ty);
   }
 }
 
 void Scop::buildContext() {
-  isl_space *Space = isl_space_params_alloc(IslCtx, 0);
+  isl_space *Space = isl_space_params_alloc(getIslCtx(), 0);
   Context = isl_set_universe(isl_space_copy(Space));
   AssumedContext = isl_set_universe(Space);
 }
 
 void Scop::addParameterBounds() {
   for (const auto &ParamID : ParameterIds) {
     int dim = ParamID.second;
 
     ConstantRange SRange = SE->getSignedRange(ParamID.first);
 
     Context = addRangeBoundsToSet(Context, SRange, dim, isl_dim_param);
   }
 }
 
 void Scop::realignParams() {
   // Add all parameters into a common model.
-  isl_space *Space = isl_space_params_alloc(IslCtx, ParameterIds.size());
+  isl_space *Space = isl_space_params_alloc(getIslCtx(), ParameterIds.size());
 
   for (const auto &ParamID : ParameterIds) {
     const SCEV *Parameter = ParamID.first;
     isl_id *id = getIdForParam(Parameter);
     Space = isl_space_set_dim_id(Space, isl_dim_param, ParamID.second, id);
   }
 
   // Align the parameters of all data structures to the model.
if (MaxLD == 0)
     return 1;
 
   assert(MinLD >= 1 && "Minimal loop depth should be at least one");
   assert(MaxLD >= MinLD &&
          "Maximal loop depth was smaller than mininaml loop depth?");
   return MaxLD - MinLD + 1;
 }
 
-Scop::Scop(Region &R, ScalarEvolution &ScalarEvolution, isl_ctx *Context,
-           unsigned MaxLoopDepth)
+Scop::Scop(Region &R, ScalarEvolution &ScalarEvolution, unsigned MaxLoopDepth)
     : SE(&ScalarEvolution), R(R), IsOptimized(false),
       HasSingleExitEdge(R.getExitingBlock()), HasErrorBlock(false),
-      MaxLoopDepth(MaxLoopDepth), IslCtx(Context), Context(nullptr),
-      Affinator(this), AssumedContext(nullptr), BoundaryContext(nullptr),
-      Schedule(nullptr) {
+      MaxLoopDepth(MaxLoopDepth), IslCtx(isl_ctx_alloc(), isl_ctx_free),
+      Context(nullptr), Affinator(this), AssumedContext(nullptr),
+      BoundaryContext(nullptr), Schedule(nullptr) {
+  isl_options_set_on_error(getIslCtx(), ISL_ON_ERROR_ABORT);
   buildContext();
 }
 
 void Scop::init(AliasAnalysis &AA, AssumptionCache &AC, ScopDetection &SD,
                 DominatorTree &DT, LoopInfo &LI) {
   addUserAssumptions(AC, DT, LI);
   buildInvariantEquivalenceClasses(SD);
 
for (MinMaxVectorPairTy &MinMaxAccessPair : MinMaxAliasGroups) {
     for (MinMaxAccessTy &MMA : MinMaxAccessPair.second) {
       isl_pw_multi_aff_free(MMA.first);
       isl_pw_multi_aff_free(MMA.second);
     }
   }
 
   for (const auto &IAClass : InvariantEquivClasses)
     isl_set_free(std::get<2>(IAClass));
+
+  // Explicitly release all Scop objects and the underlying isl objects before
+  // we relase the isl context.
+  Stmts.clear();
+  ScopArrayInfoMap.clear();
+  AccFuncMap.clear();
 }
 
 void Scop::updateAccessDimensionality() {
   for (auto &Stmt : *this)
     for (auto &Access : Stmt)
       Access->updateDimensionality();
 }
 
void Scop::print(raw_ostream &OS) const {
   printContext(OS.indent(4));
   printArrayInfo(OS.indent(4));
   printAliasAssumptions(OS);
   printStatements(OS.indent(4));
 }
 
 void Scop::dump() const { print(dbgs()); }
 
-isl_ctx *Scop::getIslCtx() const { return IslCtx; }
+isl_ctx *Scop::getIslCtx() const { return IslCtx.get(); }
 
 __isl_give isl_pw_aff *Scop::getPwAff(const SCEV *E, BasicBlock *BB) {
   return Affinator.getPwAff(E, BB);
 }
 
 __isl_give isl_union_set *Scop::getDomains() const {
   isl_union_set *Domain = isl_union_set_empty(getParamSpace());
 

 void ScopInfo::addPHIReadAccess(PHINode *PHI) {
   addMemoryAccess(PHI->getParent(), PHI, MemoryAccess::READ, PHI, 1, true, PHI,
                   ArrayRef<const SCEV *>(), ArrayRef<const SCEV *>(),
                   ScopArrayInfo::MK_PHI);
 }
 
 void ScopInfo::buildScop(Region &R, AssumptionCache &AC) {
   unsigned MaxLoopDepth = getMaxLoopDepthInRegion(R, *LI, *SD);
-  scop.reset(new Scop(R, *SE, ctx, MaxLoopDepth));
+  scop.reset(new Scop(R, *SE, MaxLoopDepth));
 
   buildStmts(R, R);
   buildAccessFunctions(R, R, *SD->getInsnToMemAccMap(&R));
 
   // In case the region does not have an exiting block we will later (during
   // code generation) split the exit block. This will move potential PHI nodes
   // from the current exit block into the new region exiting block. Hence, PHI
   // nodes that are at this point not part of the region will be.
void ScopInfo::print(raw_ostream &OS, const Module *) const {
   }
 
   scop->print(OS);
 }
 
 void ScopInfo::clear() { scop.reset(); }
 
 //===----------------------------------------------------------------------===//
-ScopInfo::ScopInfo() : RegionPass(ID) {
-  ctx = isl_ctx_alloc();
-  isl_options_set_on_error(ctx, ISL_ON_ERROR_ABORT);
-}
+ScopInfo::ScopInfo() : RegionPass(ID) {}
 
-ScopInfo::~ScopInfo() {
-  clear();
-  isl_ctx_free(ctx);
-}
+ScopInfo::~ScopInfo() { clear(); }
 
 void ScopInfo::getAnalysisUsage(AnalysisUsage &AU) const {
   AU.addRequired<LoopInfoWrapperPass>();
   AU.addRequired<RegionInfoPass>();
   AU.addRequired<DominatorTreeWrapperPass>();
   AU.addRequiredTransitive<ScalarEvolutionWrapperPass>();
   AU.addRequiredTransitive<ScopDetection>();
   AU.addRequired<AAResultsWrapperPass>();

polly/trunk/lib/CodeGen/IslAst.cpp

public:
 
   /// @brief Get the run-time conditions for the Scop.
   __isl_give isl_ast_expr *getRunCondition();
 
 private:
   Scop *S;
   isl_ast_node *Root;
   isl_ast_expr *RunCondition;
+  std::shared_ptr<isl_ctx> Ctx;
 
   IslAst(Scop *Scop);
   void init(const Dependences &D);
 
   void buildRunCondition(__isl_keep isl_ast_build *Build);
 };
 } // End namespace polly.
 
static bool benefitsFromPolly(Scop *Scop, bool PerformParallelTest) {
   if (!PerformParallelTest && !Scop->isOptimized() &&
       Scop->getAliasGroups().empty())
     return false;
 
   // The default assumption is that Polly improves the code.
   return true;
 }
 
-IslAst::IslAst(Scop *Scop) : S(Scop), Root(nullptr), RunCondition(nullptr) {}
+IslAst::IslAst(Scop *Scop)
+    : S(Scop), Root(nullptr), RunCondition(nullptr),
+      Ctx(Scop->getSharedIslCtx()) {}
 
 void IslAst::init(const Dependences &D) {
   bool PerformParallelTest = PollyParallel || DetectParallel ||
                              PollyVectorizerChoice != VECTORIZER_NONE;
 
   // Skip AST and code generation if there was no benefit achieved.
   if (!benefitsFromPolly(S, PerformParallelTest))
     return;