Changes to Polly enable interprocedural loop fusion on libquantum [WIP]

[grosser]

Summary

This should give a 2x - 2.5x speedup on libquantum.

Use maximal loop fusion

Enable Polly

Dump the isl ast structure

Allow more time in dependence info

Allow invariant load hoisting

Make scop detection slightly more permissive

lib/Analysis/DependenceInfo.cpp

 using namespace llvm;
 
 #define DEBUG_TYPE "polly-dependence"
 
 static cl::opt<int> OptComputeOut(
     "polly-dependences-computeout",
     cl::desc("Bound the dependence analysis by a maximal amount of "
              "computational steps (0 means no bound)"),
-    cl::Hidden, cl::init(500000), cl::ZeroOrMore, cl::cat(PollyCategory));
+    cl::Hidden, cl::init(0), cl::ZeroOrMore, cl::cat(PollyCategory));
 
 static cl::opt<bool> LegalityCheckDisabled(
     "disable-polly-legality", cl::desc("Disable polly legality check"),
     cl::Hidden, cl::init(false), cl::ZeroOrMore, cl::cat(PollyCategory));
 
 static cl::opt<bool>
     UseReductions("polly-dependences-use-reductions",
                   cl::desc("Exploit reductions in dependence analysis"),

lib/Analysis/ScopDetection.cpp

VerifyScops("polly-detect-verify",
                 cl::Hidden, cl::init(false), cl::ZeroOrMore,
                 cl::cat(PollyCategory));
 
 bool polly::PollyInvariantLoadHoisting;
 
 static cl::opt<bool, true> XPollyInvariantLoadHoisting(
     "polly-invariant-load-hoisting", cl::desc("Hoist invariant loads."),
     cl::location(PollyInvariantLoadHoisting), cl::Hidden, cl::ZeroOrMore,
-    cl::init(false), cl::cat(PollyCategory));
+    cl::init(true), cl::cat(PollyCategory));
 
 /// The minimal trip count under which loops are considered unprofitable.
 static const unsigned MIN_LOOP_TRIP_COUNT = 8;
 
 bool polly::PollyTrackFailures = false;
 bool polly::PollyDelinearize = false;
 StringRef polly::PollySkipFnAttr = "polly.skip.fn";
 
bool ScopDetection::isValidInstruction(Instruction &Inst,
                                        DetectionContext &Context) const {
   for (auto &Op : Inst.operands()) {
     auto *OpInst = dyn_cast<Instruction>(&Op);
 
     if (!OpInst)
       continue;
 
     if (isErrorBlock(*OpInst->getParent(), Context.CurRegion, LI, DT)) {
-      auto *PHI = dyn_cast<PHINode>(OpInst);
+      auto *PHI = dyn_cast<PHINode>(&Inst);
       if (PHI) {
         for (User *U : PHI->users()) {
           if (!isa<TerminatorInst>(U))
-            return false;
+            return true;
         }
       } else {
         return false;
       }
     }
   }
 
   if (isa<LandingPadInst>(&Inst) || isa<ResumeInst>(&Inst))

lib/CodeGen/IslAst.cpp

bool IslAstInfoWrapperPass::runOnScop(Scop &Scop) {
   if (D.getSharedIslCtx() != Scop.getSharedIslCtx()) {
     DEBUG(dbgs() << "Got dependence analysis for different SCoP/isl_ctx\n");
     Ast.reset();
     return false;
   }
 
   Ast.reset(new IslAstInfo(Scop, D));
 
-  DEBUG(printScop(dbgs(), Scop));
+  printScop(errs(), Scop);
   return false;
 }
 
 void IslAstInfoWrapperPass::getAnalysisUsage(AnalysisUsage &AU) const {
   // Get the Common analysis usage of ScopPasses.
   ScopPass::getAnalysisUsage(AU);
   AU.addRequiredTransitive<ScopInfoRegionPass>();
   AU.addRequired<DependenceInfo>();

lib/Support/RegisterPasses.cpp

 using namespace llvm;
 using namespace polly;
 
 cl::OptionCategory PollyCategory("Polly Options",
                                  "Configure the polly loop optimizer");
 
 static cl::opt<bool>
     PollyEnabled("polly", cl::desc("Enable the polly optimizer (only at -O3)"),
-                 cl::init(false), cl::ZeroOrMore, cl::cat(PollyCategory));
+                 cl::init(true), cl::ZeroOrMore, cl::cat(PollyCategory));
 
 static cl::opt<bool> PollyDetectOnly(
     "polly-only-scop-detection",
     cl::desc("Only run scop detection, but no other optimizations"),
     cl::init(false), cl::ZeroOrMore, cl::cat(PollyCategory));
 
 enum PassPositionChoice {
   POSITION_EARLY,

lib/Transform/ScheduleOptimizer.cpp

 
 static cl::opt<int> MaxCoefficient(
     "polly-opt-max-coefficient",
     cl::desc("The maximal coefficient allowed (-1 is unlimited)"), cl::Hidden,
     cl::init(20), cl::ZeroOrMore, cl::cat(PollyCategory));
 
 static cl::opt<std::string> FusionStrategy(
     "polly-opt-fusion", cl::desc("The fusion strategy to choose (min/max)"),
-    cl::Hidden, cl::init("min"), cl::ZeroOrMore, cl::cat(PollyCategory));
+    cl::Hidden, cl::init("max"), cl::ZeroOrMore, cl::cat(PollyCategory));
 
 static cl::opt<std::string>
     MaximizeBandDepth("polly-opt-maximize-bands",
                       cl::desc("Maximize the band depth (yes/no)"), cl::Hidden,
                       cl::init("yes"), cl::ZeroOrMore, cl::cat(PollyCategory));
 
 static cl::opt<std::string> OuterCoincidence(
     "polly-opt-outer-coincidence",