[Polly][NewPM] Port ScopInfo to the new PassManager

[philip.pfaffe]

Summary

This patch ports ScopInfo to the new PassManager.

The port is based on the ScopInfoWrapperPass, which allows this pass to become an entry point for the Scop{Pass,Analysis}Manager to come.

[grosser]

Hi Philip,

this looks technically correct, assuming we want to go this route. As noted earlier, there is a risk that we may invalidate some of the analysis results when code generating, hence I have some concerns here. However, as already pointed out in earlier discussions on this topic, as this code path is independent of all our existing functionality this might indeed be a great opportunity to explore a different approach of scheduling passes without risking to regress existing functionality. Assuming we can add a test case for this, I would be glad to see this patch upstream!

[grosser]

This patch looks good to me. I understand, we can currently not have execution test coverage. I suggest to commit this exceptionally without test cases to at least get compile time test coverage and to also facilitate further testing with the pass manager plugins.

[philip.pfaffe]

Landed in rL303056.

include/polly/PolyhedralInfo.h

 
 namespace llvm {
 class Loop;
 } // namespace llvm
 
 namespace polly {
 
 class Scop;
-class ScopInfoWrapperPass;
+class ScopInfo;
 class DependenceInfoWrapperPass;
 
 class PolyhedralInfo : public llvm::FunctionPass {
 public:
   static char ID; // Pass identification, replacement for typeid
 
   /// Construct a new PolyhedralInfo pass.
   PolyhedralInfo() : FunctionPass(ID) {}
private:
   /// @param MinDepDistPtr If not nullptr, the minimal dependence distance will
   ///                      be returned at the address of that pointer
   ///
   /// @return  Returns true if loop is parallel or vectorizable, false
   ///          otherwise.
   bool checkParallel(llvm::Loop *L,
                      __isl_give isl_pw_aff **MinDepDistPtr = nullptr) const;
 
-  ScopInfoWrapperPass *SI;
+  ScopInfo *SI;
   DependenceInfoWrapperPass *DI;
 };
 
 } // end namespace polly
 
 namespace llvm {
 class PassRegistry;
 void initializePolyhedralInfoPass(llvm::PassRegistry &);
 } // namespace llvm
 
 #endif

include/polly/ScopInfo.h

public:
 
   void releaseMemory() override { S.reset(); }
 
   void print(raw_ostream &O, const Module *M = nullptr) const override;
 
   void getAnalysisUsage(AnalysisUsage &AU) const override;
 };
 
-//===----------------------------------------------------------------------===//
-/// The legacy pass manager's analysis pass to compute scop information
-///        for the whole function.
-///
-/// This pass will maintain a map of the maximal region within a scop to its
-/// scop object for all the feasible scops present in a function.
-/// This pass is an alternative to the ScopInfoRegionPass in order to avoid a
-/// region pass manager.
-class ScopInfoWrapperPass : public FunctionPass {
-
+class ScopInfo {
 public:
   using RegionToScopMapTy = DenseMap<Region *, std::unique_ptr<Scop>>;
   using iterator = RegionToScopMapTy::iterator;
   using const_iterator = RegionToScopMapTy::const_iterator;
 
 private:
   /// A map of Region to its Scop object containing
   ///        Polly IR of static control part
   RegionToScopMapTy RegionToScopMap;
 
 public:
-  static char ID; // Pass identification, replacement for typeid
-
-  ScopInfoWrapperPass() : FunctionPass(ID) {}
-  ~ScopInfoWrapperPass() {}
+  ScopInfo(const DataLayout &DL, ScopDetection &SD, ScalarEvolution &SE,
+           LoopInfo &LI, AliasAnalysis &AA, DominatorTree &DT,
+           AssumptionCache &AC);
 
   /// Get the Scop object for the given Region
   ///
   /// @return If the given region is the maximal region within a scop, return
   ///         the scop object. If the given region is a subregion, return a
   ///         nullptr. Top level region containing the entry block of a function
   ///         is not considered in the scop creation.
   Scop *getScop(Region *R) const {
     auto MapIt = RegionToScopMap.find(R);
     if (MapIt != RegionToScopMap.end())
       return MapIt->second.get();
     return nullptr;
   }
 
   iterator begin() { return RegionToScopMap.begin(); }
   iterator end() { return RegionToScopMap.end(); }
   const_iterator begin() const { return RegionToScopMap.begin(); }
   const_iterator end() const { return RegionToScopMap.end(); }
+};
+
+struct ScopInfoAnalysis : public AnalysisInfoMixin<ScopInfoAnalysis> {
+  static AnalysisKey Key;
+  using Result = ScopInfo;
+  Result run(Function &, FunctionAnalysisManager &);
+};
+
+struct ScopInfoPrinterPass : public PassInfoMixin<ScopInfoPrinterPass> {
+  ScopInfoPrinterPass(raw_ostream &O) : Stream(O) {}
+  PreservedAnalyses run(Function &, FunctionAnalysisManager &);
+  raw_ostream &Stream;
+};
+
+//===----------------------------------------------------------------------===//
+/// The legacy pass manager's analysis pass to compute scop information
+///        for the whole function.
+///
+/// This pass will maintain a map of the maximal region within a scop to its
+/// scop object for all the feasible scops present in a function.
+/// This pass is an alternative to the ScopInfoRegionPass in order to avoid a
+/// region pass manager.
+class ScopInfoWrapperPass : public FunctionPass {
+  std::unique_ptr<ScopInfo> Result;
+
+public:
+  ScopInfoWrapperPass() : FunctionPass(ID) {}
+  ~ScopInfoWrapperPass() = default;
+
+  static char ID; // Pass identification, replacement for typeid
+
+  ScopInfo *getSI() { return Result.get(); }
+  const ScopInfo *getSI() const { return Result.get(); }
 
   /// Calculate all the polyhedral scops for a given function.
   bool runOnFunction(Function &F) override;
 
-  void releaseMemory() override { RegionToScopMap.clear(); }
+  void releaseMemory() override { Result.reset(); }
 
   void print(raw_ostream &O, const Module *M = nullptr) const override;
 
   void getAnalysisUsage(AnalysisUsage &AU) const override;
 };
 
 } // end namespace polly
 
 namespace llvm {
 class PassRegistry;
 void initializeScopInfoRegionPassPass(llvm::PassRegistry &);
 void initializeScopInfoWrapperPassPass(llvm::PassRegistry &);
 } // namespace llvm
 
 #endif

lib/Analysis/DependenceInfo.cpp

const Dependences &DependenceInfoWrapperPass::recomputeDependences(
     Scop *S, Dependences::AnalysisLevel Level) {
   std::unique_ptr<Dependences> D(new Dependences(S->getSharedIslCtx(), Level));
   D->calculateDependences(*S);
   auto Inserted = ScopToDepsMap.insert(std::make_pair(S, std::move(D)));
   return *Inserted.first->second;
 }
 
 bool DependenceInfoWrapperPass::runOnFunction(Function &F) {
-  auto &SI = getAnalysis<ScopInfoWrapperPass>();
+  auto &SI = *getAnalysis<ScopInfoWrapperPass>().getSI();
   for (auto &It : SI) {
     assert(It.second && "Invalid SCoP object!");
     recomputeDependences(It.second.get(), Dependences::AL_Access);
   }
   return false;
 }
 
 void DependenceInfoWrapperPass::print(raw_ostream &OS, const Module *M) const {

lib/Analysis/PolyhedralInfo.cpp

void PolyhedralInfo::getAnalysisUsage(AnalysisUsage &AU) const {
   AU.addRequiredTransitive<DependenceInfoWrapperPass>();
   AU.addRequired<LoopInfoWrapperPass>();
   AU.addRequiredTransitive<ScopInfoWrapperPass>();
   AU.setPreservesAll();
 }
 
 bool PolyhedralInfo::runOnFunction(Function &F) {
   DI = &getAnalysis<DependenceInfoWrapperPass>();
-  SI = &getAnalysis<ScopInfoWrapperPass>();
+  SI = getAnalysis<ScopInfoWrapperPass>().getSI();
   return false;
 }
 
 void PolyhedralInfo::print(raw_ostream &OS, const Module *) const {
   auto &LI = getAnalysis<LoopInfoWrapperPass>().getLoopInfo();
   for (auto *TopLevelLoop : LI) {
     for (auto *L : depth_first(TopLevelLoop)) {
       OS.indent(2) << L->getHeader()->getName() << ":\t";

lib/Analysis/ScopInfo.cpp

 // The pass creates a polyhedral description of the Scops detected by the Scop
 // detection derived from their LLVM-IR code.
 //
 // This representation is shared among several tools in the polyhedral
 // community, which are e.g. Cloog, Pluto, Loopo, Graphite.
 //
 //===----------------------------------------------------------------------===//
 
-#include "polly/ScopInfo.h"
 #include "polly/LinkAllPasses.h"
 #include "polly/Options.h"
 #include "polly/ScopBuilder.h"
+#include "polly/ScopInfo.h"
 #include "polly/Support/GICHelper.h"
 #include "polly/Support/SCEVValidator.h"
 #include "polly/Support/ScopHelper.h"
 #include "llvm/ADT/DepthFirstIterator.h"
 #include "llvm/ADT/MapVector.h"
 #include "llvm/ADT/PostOrderIterator.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SetVector.h"

 INITIALIZE_PASS_DEPENDENCY(ScalarEvolutionWrapperPass);
 INITIALIZE_PASS_DEPENDENCY(ScopDetectionWrapperPass);
 INITIALIZE_PASS_DEPENDENCY(DominatorTreeWrapperPass);
 INITIALIZE_PASS_END(ScopInfoRegionPass, "polly-scops",
                     "Polly - Create polyhedral description of Scops", false,
                     false)
 
 //===----------------------------------------------------------------------===//
+ScopInfo::ScopInfo(const DataLayout &DL, ScopDetection &SD, ScalarEvolution &SE,
+                   LoopInfo &LI, AliasAnalysis &AA, DominatorTree &DT,
+                   AssumptionCache &AC) {
+  /// Create polyhedral descripton of scops for all the valid regions of a
+  /// function.
+  for (auto &It : SD) {
+    Region *R = const_cast<Region *>(It);
+    if (!SD.isMaxRegionInScop(*R))
+      continue;
+
+    ScopBuilder SB(R, AC, AA, DL, DT, LI, SD, SE);
+    std::unique_ptr<Scop> S = SB.getScop();
+    if (!S)
+      continue;
+    bool Inserted = RegionToScopMap.insert({R, std::move(S)}).second;
+    assert(Inserted && "Building Scop for the same region twice!");
+    (void)Inserted;
+  }
+}
+
+AnalysisKey ScopInfoAnalysis::Key;
+
+ScopInfoAnalysis::Result ScopInfoAnalysis::run(Function &F,
+                                               FunctionAnalysisManager &FAM) {
+  auto &SD = FAM.getResult<ScopAnalysis>(F);
+  auto &SE = FAM.getResult<ScalarEvolutionAnalysis>(F);
+  auto &LI = FAM.getResult<LoopAnalysis>(F);
+  auto &AA = FAM.getResult<AAManager>(F);
+  auto &DT = FAM.getResult<DominatorTreeAnalysis>(F);
+  auto &AC = FAM.getResult<AssumptionAnalysis>(F);
+  auto &DL = F.getParent()->getDataLayout();
+  return {DL, SD, SE, LI, AA, DT, AC};
+}
+
+PreservedAnalyses ScopInfoPrinterPass::run(Function &F,
+                                           FunctionAnalysisManager &FAM) {
+  auto &SI = FAM.getResult<ScopInfoAnalysis>(F);
+  for (auto &It : SI) {
+    if (It.second)
+      It.second->print(Stream);
+    else
+      Stream << "Invalid Scop!\n";
+  }
+  return PreservedAnalyses::all();
+}
+
 void ScopInfoWrapperPass::getAnalysisUsage(AnalysisUsage &AU) const {
   AU.addRequired<LoopInfoWrapperPass>();
   AU.addRequired<RegionInfoPass>();
   AU.addRequired<DominatorTreeWrapperPass>();
   AU.addRequiredTransitive<ScalarEvolutionWrapperPass>();
   AU.addRequiredTransitive<ScopDetectionWrapperPass>();
   AU.addRequired<AAResultsWrapperPass>();
   AU.addRequired<AssumptionCacheTracker>();
   AU.setPreservesAll();
 }
 
 bool ScopInfoWrapperPass::runOnFunction(Function &F) {
   auto &SD = getAnalysis<ScopDetectionWrapperPass>().getSD();
-
   auto &SE = getAnalysis<ScalarEvolutionWrapperPass>().getSE();
   auto &LI = getAnalysis<LoopInfoWrapperPass>().getLoopInfo();
   auto &AA = getAnalysis<AAResultsWrapperPass>().getAAResults();
   auto const &DL = F.getParent()->getDataLayout();
   auto &DT = getAnalysis<DominatorTreeWrapperPass>().getDomTree();
   auto &AC = getAnalysis<AssumptionCacheTracker>().getAssumptionCache(F);
 
-  /// Create polyhedral descripton of scops for all the valid regions of a
-  /// function.
-  for (auto &It : SD) {
-    Region *R = const_cast<Region *>(It);
-    if (!SD.isMaxRegionInScop(*R))
-      continue;
-
-    ScopBuilder SB(R, AC, AA, DL, DT, LI, SD, SE);
-    std::unique_ptr<Scop> S = SB.getScop();
-    if (!S)
-      continue;
-    bool Inserted =
-        RegionToScopMap.insert(std::make_pair(R, std::move(S))).second;
-    assert(Inserted && "Building Scop for the same region twice!");
-    (void)Inserted;
-  }
+  Result.reset(new ScopInfo{DL, SD, SE, LI, AA, DT, AC});
   return false;
 }
 
 void ScopInfoWrapperPass::print(raw_ostream &OS, const Module *) const {
-  for (auto &It : RegionToScopMap) {
+  for (auto &It : *Result) {
     if (It.second)
       It.second->print(OS);
     else
       OS << "Invalid Scop!\n";
   }
 }
 
 char ScopInfoWrapperPass::ID = 0;