[Polly] Add various statistics.

[Meinersbur]

Summary

Add statistics about

• Which optimizations are applied
• Number of loops in Scops at various stages
• Number of scalar/singleton writes at various stages representative for false dependencies
• Number of parallel loops

[grosser]

lib/Analysis/ScopDetection.cpp

1241 ↗

(On Diff #112284)

Seems unrelated.

lib/CodeGen/CodeGeneration.cpp

60

typo

lib/CodeGen/IslAst.cpp

88

reduction

lib/Transform/Simplify.cpp

122

invocationS?

[Meinersbur]

• Fix warnings in NDEBUG builds.
• Add some more statistics.

include/polly/ScopInfo.h

DenseMap<const ScopArrayInfo *, SmallVector<MemoryAccess *, 4>>
       PHIIncomingAccs;
 
   /// Return the ID for a new Scop within a function
   static int getNextID(std::string ParentFunc);
 
   /// Scop constructor; invoked from ScopBuilder::buildScop.
   Scop(Region &R, ScalarEvolution &SE, LoopInfo &LI,
        ScopDetection::DetectionContext &DC, OptimizationRemarkEmitter &ORE);
+
+  /// Return the LoopInfo used for this Scop.
+  LoopInfo *getLI() const { return Affinator.getLI(); }
+
   //@}
 
   /// Initialize this ScopBuilder.
   void init(AliasAnalysis &AA, AssumptionCache &AC, DominatorTree &DT,
             LoopInfo &LI);
 
   /// Propagate domains that are known due to graph properties.
   ///
#endif
   MemoryAccess *getPHIRead(const ScopArrayInfo *SAI) const;
 
   /// Return all MemoryAccesses for all incoming statements of a PHINode,
   /// represented by a ScopArrayInfo.
   ArrayRef<MemoryAccess *> getPHIIncomings(const ScopArrayInfo *SAI) const;
 
   /// Return whether @p Inst has a use outside of this SCoP.
   bool isEscaping(Instruction *Inst);
+
+  struct ScopStatistics {
+    int NumAffineLoops = 0;
+    int NumBoxedLoops = 0;
+
+    int NumValueWrites = 0;
+    int NumValueWritesInLoops = 0;
+    int NumPHIWrites = 0;
+    int NumPHIWritesInLoops = 0;
+    int NumSingletonWrites = 0;
+    int NumSingletonWritesInLoops = 0;
+  };
+
+  /// Collect statistic about this SCoP.
+  ///
+  /// These are most commonly used for LLVM's static counters (Statistic.h) in
+  /// various places. If statistics are disabled, only zeros are returned to
+  /// avoid the overhead.
+  ScopStatistics getStatistics() const;
 };
 
 /// Print Scop scop to raw_ostream OS.
 raw_ostream &operator<<(raw_ostream &OS, const Scop &scop);
 
 /// The legacy pass manager's analysis pass to compute scop information
 ///        for a region.
 class ScopInfoRegionPass : public RegionPass {

include/polly/Simplify.h

 ///   - In block statements, the accesses are in order in which their
 ///     instructions are executed.
 ///   - In region statements, that order of execution is not predictable at
 ///     compile-time.
 /// - Implicit writes (BlockGenerator::generateScalarStores)
 ///   The order in which implicit writes are executed relative to each other is
 ///   undefined.
 llvm::SmallVector<MemoryAccess *, 32> getAccessesInOrder(ScopStmt &Stmt);
-llvm::Pass *createSimplifyPass();
+
+/// Create a Simplify pass
+///
+/// @param CallNo Disambiguates this instance for when there are multiple
+///               instances of this pass in the pass manager. It is used only to
+///               keep the statistics apart and has no influence on the
+///               simplification itself.
+///
+/// @return The Simplify pass.
+llvm::Pass *createSimplifyPass(int CallNo = 0);
 } // namespace polly
 
 namespace llvm {
 void initializeSimplifyPass(llvm::PassRegistry &);
 } // namespace llvm
 
 #endif /* POLLY_TRANSFORM_SIMPLIFY_H */

include/polly/Support/SCEVAffinator.h

public:
   void takeNonNegativeAssumption(PWACtx &PWAC);
 
   /// Interpret the PWA in @p PWAC as an unsigned value.
   void interpretAsUnsigned(__isl_keep PWACtx &PWAC, unsigned Width);
 
   /// Check an <nsw> AddRec for the loop @p L is cached.
   bool hasNSWAddRecForLoop(llvm::Loop *L) const;
 
+  /// Return the LoopInfo used by thi object.
+  llvm::LoopInfo *getLI() const { return &LI; }
+
 private:
   /// Key to identify cached expressions.
   using CacheKey = std::pair<const llvm::SCEV *, llvm::BasicBlock *>;
 
   /// Map to remembered cached expressions.
   llvm::DenseMap<CacheKey, PWACtx> CachedExpressions;
 
   Scop *S;

lib/Analysis/PruneUnprofitable.cpp

 using namespace llvm;
 
 namespace {
 
 STATISTIC(ScopsProcessed,
           "Number of SCoPs considered for unprofitability pruning");
 STATISTIC(ScopsPruned, "Number of pruned SCoPs because it they cannot be "
                        "optimized in a significant way");
+STATISTIC(ScopsSurvived, "Number of SCoPs after pruning");
+
+STATISTIC(NumPrunedLoops, "Number of pruned loops");
+STATISTIC(NumPrunedBoxedLoops, "Number of pruned boxed loops");
+STATISTIC(NumPrunedAffineLoops, "Number of pruned affine loops");
+
+STATISTIC(NumLoopsInScop, "Number of loops in scops after pruning");
+STATISTIC(NumBoxedLoops, "Number of boxed loops in SCoPs after pruning");
+STATISTIC(NumAffineLoops, "Number of affine loops in SCoPs after pruning");
 
 class PruneUnprofitable : public ScopPass {
 private:
   PruneUnprofitable(const PruneUnprofitable &) = delete;
   const PruneUnprofitable &operator=(const PruneUnprofitable &) = delete;
 
+  void updateStatistics(Scop &S, bool Pruned) {
+    auto ScopStats = S.getStatistics();
+    if (Pruned) {
+      ScopsPruned++;
+      NumPrunedLoops += ScopStats.NumAffineLoops + ScopStats.NumBoxedLoops;
+      NumPrunedBoxedLoops += ScopStats.NumBoxedLoops;
+      NumPrunedAffineLoops += ScopStats.NumAffineLoops;
+    } else {
+      ScopsSurvived++;
+      NumLoopsInScop += ScopStats.NumAffineLoops + ScopStats.NumBoxedLoops;
+      NumBoxedLoops += ScopStats.NumBoxedLoops;
+      NumAffineLoops += ScopStats.NumAffineLoops;
+    }
+  }
+
 public:
   static char ID;
   explicit PruneUnprofitable() : ScopPass(ID) {}
 
   virtual void getAnalysisUsage(AnalysisUsage &AU) const override {
     AU.addRequired<ScopInfoRegionPass>();
     AU.setPreservesAll();
   }
 
   virtual bool runOnScop(Scop &S) override {
     if (PollyProcessUnprofitable) {
       DEBUG(dbgs() << "NOTE: -polly-process-unprofitable active, won't prune "
                       "anything\n");
       return false;
     }
 
     ScopsProcessed++;
 
     if (!S.isProfitable(true)) {
       DEBUG(dbgs() << "SCoP pruned because it probably cannot be optimized in "
                       "a significant way\n");
-      ScopsPruned++;
       S.invalidate(PROFITABLE, DebugLoc());
+      updateStatistics(S, true);
+    } else {
+      updateStatistics(S, false);
     }
 
     return false;
   }
 };
 
 char PruneUnprofitable::ID;
 } // anonymous namespace
 
 Pass *polly::createPruneUnprofitablePass() { return new PruneUnprofitable(); }
 
 INITIALIZE_PASS_BEGIN(PruneUnprofitable, "polly-prune-unprofitable",
                       "Polly - Prune unprofitable SCoPs", false, false)
 INITIALIZE_PASS_END(PruneUnprofitable, "polly-prune-unprofitable",
                     "Polly - Prune unprofitable SCoPs", false, false)

lib/Analysis/ScopInfo.cpp

 STATISTIC(AssumptionsUnprofitable, "Number of unprofitable SCoPs.");
 STATISTIC(AssumptionsErrorBlock, "Number of error block assumptions taken.");
 STATISTIC(AssumptionsInfiniteLoop, "Number of bounded loop assumptions taken.");
 STATISTIC(AssumptionsInvariantLoad,
           "Number of invariant loads assumptions taken.");
 STATISTIC(AssumptionsDelinearization,
           "Number of delinearization assumptions taken.");
 
+STATISTIC(NumScops, "Number of feasible SCoPs after ScopInfo");
 STATISTIC(NumLoopsInScop, "Number of loops in scops");
+STATISTIC(NumBoxedLoops, "Number of boxed loops in SCoPs after ScopInfo");
+STATISTIC(NumAffineLoops, "Number of affine loops in SCoPs after ScopInfo");
+
 STATISTIC(NumScopsDepthOne, "Number of scops with maximal loop depth 1");
 STATISTIC(NumScopsDepthTwo, "Number of scops with maximal loop depth 2");
 STATISTIC(NumScopsDepthThree, "Number of scops with maximal loop depth 3");
 STATISTIC(NumScopsDepthFour, "Number of scops with maximal loop depth 4");
 STATISTIC(NumScopsDepthFive, "Number of scops with maximal loop depth 5");
 STATISTIC(NumScopsDepthLarger,
           "Number of scops with maximal loop depth 6 and larger");
 STATISTIC(MaxNumLoopsInScop, "Maximal number of loops in scops");
 
+STATISTIC(NumValueWrites, "Number of scalar value writes after ScopInfo");
+STATISTIC(
+    NumValueWritesInLoops,
+    "Number of scalar value writes nested in affine loops after ScopInfo");
+STATISTIC(NumPHIWrites, "Number of scalar phi writes after ScopInfo");
+STATISTIC(NumPHIWritesInLoops,
+          "Number of scalar phi writes nested in affine loops after ScopInfo");
+STATISTIC(NumSingletonWrites, "Number of singleton writes after ScopInfo");
+STATISTIC(NumSingletonWritesInLoops,
+          "Number of singleton writes nested in affine loops after ScopInfo");
+
 // The maximal number of basic sets we allow during domain construction to
 // be created. More complex scops will result in very high compile time and
 // are also unlikely to result in good code
 static int const MaxDisjunctsInDomain = 20;
 
 // The number of disjunct in the context after which we stop to add more
 // disjuncts. This parameter is there to avoid exponential growth in the
 // number of disjunct when adding non-convex sets to the context.
for (Use &Use : Inst->uses()) {
     // SCoP anymore.
     if (hasSingleExitEdge() && isa<PHINode>(Use.getUser()) &&
         isExit(cast<PHINode>(Use.getUser())->getParent()))
       return true;
   }
   return false;
 }
 
+Scop::ScopStatistics Scop::getStatistics() const {
+  ScopStatistics Result;
+#if !defined(NDEBUG) || defined(LLVM_ENABLE_STATS)
+  auto LoopStat = ScopDetection::countBeneficialLoops(&R, *SE, *getLI(), 0);
+
+  int NumTotalLoops = LoopStat.NumLoops;
+  Result.NumBoxedLoops = getBoxedLoops().size();
+  Result.NumAffineLoops = NumTotalLoops - Result.NumBoxedLoops;
+
+  for (const ScopStmt &Stmt : *this) {
+    isl::set Domain = Stmt.getDomain().intersect_params(getContext());
+    bool IsInLoop = Stmt.getNumIterators() >= 1;
+    for (MemoryAccess *MA : Stmt) {
+      if (!MA->isWrite())
+        continue;
+
+      if (MA->isLatestValueKind()) {
+        Result.NumValueWrites += 1;
+        if (IsInLoop)
+          Result.NumValueWritesInLoops += 1;
+      }
+
+      if (MA->isLatestAnyPHIKind()) {
+        Result.NumPHIWrites += 1;
+        if (IsInLoop)
+          Result.NumPHIWritesInLoops += 1;
+      }
+
+      isl::set AccSet =
+          MA->getAccessRelation().intersect_domain(Domain).range();
+      if (AccSet.is_singleton()) {
+        Result.NumSingletonWrites += 1;
+        if (IsInLoop)
+          Result.NumSingletonWritesInLoops += 1;
+      }
+    }
+  }
+#endif
+  return Result;
+}
+
 raw_ostream &polly::operator<<(raw_ostream &OS, const Scop &scop) {
   scop.print(OS, PollyPrintInstructions);
   return OS;
 }
 
 //===----------------------------------------------------------------------===//
 void ScopInfoRegionPass::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();
 }
 
-void updateLoopCountStatistic(ScopDetection::LoopStats Stats) {
+void updateLoopCountStatistic(ScopDetection::LoopStats Stats,
+                              Scop::ScopStatistics ScopStats) {
+  assert(Stats.NumLoops == ScopStats.NumAffineLoops + ScopStats.NumBoxedLoops);
+
+  NumScops++;
   NumLoopsInScop += Stats.NumLoops;
   MaxNumLoopsInScop =
       std::max(MaxNumLoopsInScop.getValue(), (unsigned)Stats.NumLoops);
 
   if (Stats.MaxDepth == 1)
     NumScopsDepthOne++;
   else if (Stats.MaxDepth == 2)
     NumScopsDepthTwo++;
   else if (Stats.MaxDepth == 3)
     NumScopsDepthThree++;
   else if (Stats.MaxDepth == 4)
     NumScopsDepthFour++;
   else if (Stats.MaxDepth == 5)
     NumScopsDepthFive++;
   else
     NumScopsDepthLarger++;
+
+  NumAffineLoops += ScopStats.NumAffineLoops;
+  NumBoxedLoops += ScopStats.NumBoxedLoops;
+
+  NumValueWrites += ScopStats.NumValueWrites;
+  NumValueWritesInLoops += ScopStats.NumValueWritesInLoops;
+  NumPHIWrites += ScopStats.NumPHIWrites;
+  NumPHIWritesInLoops += ScopStats.NumPHIWritesInLoops;
+  NumSingletonWrites += ScopStats.NumSingletonWrites;
+  NumSingletonWritesInLoops += ScopStats.NumSingletonWritesInLoops;
 }
 
 bool ScopInfoRegionPass::runOnRegion(Region *R, RGPassManager &RGM) {
   auto &SD = getAnalysis<ScopDetectionWrapperPass>().getSD();
 
   if (!SD.isMaxRegionInScop(*R))
     return false;
 
   Function *F = R->getEntry()->getParent();
   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);
 
   ScopBuilder SB(R, AC, AA, DL, DT, LI, SD, SE);
   S = SB.getScop(); // take ownership of scop object
 
+#if !defined(NDEBUG) || defined(LLVM_ENABLE_STATS)
   if (S) {
     ScopDetection::LoopStats Stats =
         ScopDetection::countBeneficialLoops(&S->getRegion(), SE, LI, 0);
-    updateLoopCountStatistic(Stats);
+    updateLoopCountStatistic(Stats, S->getStatistics());
   }
+#endif
 
   return false;
 }
 
 void ScopInfoRegionPass::print(raw_ostream &OS, const Module *) const {
   if (S)
     S->print(OS, PollyPrintInstructions);
   else
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;
+#if !defined(NDEBUG) || defined(LLVM_ENABLE_STATS)
     ScopDetection::LoopStats Stats =
         ScopDetection::countBeneficialLoops(&S->getRegion(), SE, LI, 0);
-    updateLoopCountStatistic(Stats);
+    updateLoopCountStatistic(Stats, S->getStatistics());
+#endif
     bool Inserted = RegionToScopMap.insert({R, std::move(S)}).second;
     assert(Inserted && "Building Scop for the same region twice!");
     (void)Inserted;
   }
 }
 
 bool ScopInfo::invalidate(Function &F, const PreservedAnalyses &PA,
                           FunctionAnalysisManager::Invalidator &Inv) {

lib/CodeGen/CodeGeneration.cpp

 
 bool polly::PerfMonitoring;
 static cl::opt<bool, true>
     XPerfMonitoring("polly-codegen-perf-monitoring",
                     cl::desc("Add run-time performance monitoring"), cl::Hidden,
                     cl::location(polly::PerfMonitoring), cl::init(false),
                     cl::ZeroOrMore, cl::cat(PollyCategory));
 
+STATISTIC(ScopsProcessed, "Number of SCoP processed");
+STATISTIC(CodegenedScops, "Number of successfully generated SCoPs");
+STATISTIC(CodegenedAffineLoops,
+          "Number of original affine loops in SCoPs that have been generated");
+STATISTIC(CodegenedBoxedLoops,
+          "Number of original boxed loops in SCoPs that have been generated");
+
 namespace polly {
 /// Mark a basic block unreachable.
 ///
 /// Marks the basic block @p Block unreachable by equipping it with an
 /// UnreachableInst.
 void markBlockUnreachable(BasicBlock &Block, PollyIRBuilder &Builder) {
   auto *OrigTerminator = Block.getTerminator();
   Builder.SetInsertPoint(OrigTerminator);

 
 static bool CodeGen(Scop &S, IslAstInfo &AI, LoopInfo &LI, DominatorTree &DT,
                     ScalarEvolution &SE, RegionInfo &RI) {
   // Check if we created an isl_ast root node, otherwise exit.
   isl_ast_node *AstRoot = AI.getAst();
   if (!AstRoot)
     return false;
 
+  // Collect statistics. Do it before we modify the IR to avoid having it any
+  // influence on the result.
+  auto ScopStats = S.getStatistics();
+  ScopsProcessed++;
+
   auto &DL = S.getFunction().getParent()->getDataLayout();
   Region *R = &S.getRegion();
   assert(!R->isTopLevelRegion() && "Top level regions are not supported");
 
   ScopAnnotator Annotator;
 
   simplifyRegion(R, &DT, &LI, &RI);
   assert(R->isSimple());
if (!NodeBuilder.preloadInvariantLoads()) {
     // Ideally we would just split the block during allocation of the new
     // arrays, but this would break the assumption that there are no blocks
     // between polly.start and polly.exiting (at this point).
     Builder.SetInsertPoint(StartBlock->getTerminator());
 
     NodeBuilder.create(AstRoot);
     NodeBuilder.finalize();
     fixRegionInfo(*EnteringBB->getParent(), *R->getParent(), RI);
+
+    CodegenedScops++;
+    CodegenedAffineLoops += ScopStats.NumAffineLoops;
+    CodegenedBoxedLoops += ScopStats.NumBoxedLoops;
   }
 
   Function *F = EnteringBB->getParent();
   verifyGeneratedFunction(S, *F, AI);
   for (auto *SubF : NodeBuilder.getParallelSubfunctions())
     verifyGeneratedFunction(S, *SubF, AI);
 
   // Mark the function such that we run additional cleanup passes on this

lib/CodeGen/IslAst.cpp

static cl::opt<bool> UseContext("polly-ast-use-context",
                                 cl::init(true), cl::ZeroOrMore,
                                 cl::cat(PollyCategory));
 
 static cl::opt<bool> DetectParallel("polly-ast-detect-parallel",
                                     cl::desc("Detect parallelism"), cl::Hidden,
                                     cl::init(false), cl::ZeroOrMore,
                                     cl::cat(PollyCategory));
 
+STATISTIC(ScopsProcessed, "Number of SCoPs processed");
+STATISTIC(ScopsBeneficial, "Number of beneficial SCoPs");
+STATISTIC(BeneficialAffineLoops, "Number of beneficial affine loops");
+STATISTIC(BeneficialBoxedLoops, "Number of beneficial boxed loops");
+
+STATISTIC(NumForLoops, "Number of for-loops");
+STATISTIC(NumParallel, "Number of parallel for-loops");
+STATISTIC(NumInnermostParallel, "Number of innermost parallel for-loops");
+STATISTIC(NumOutermostParallel, "Number of outermost parallel for-loops");
+STATISTIC(NumReductionParallel, "Number of reduction-parallel for-loops");
+STATISTIC(NumExecutedInParallel, "Number of for-loops executed in parallel");
+STATISTIC(NumIfConditions, "Number of if-conditions");
+
 namespace polly {
 /// Temporary information used when building the ast.
 struct AstBuildUserInfo {
   /// Construct and initialize the helper struct for AST creation.
   AstBuildUserInfo()
       : Deps(nullptr), InParallelFor(false), LastForNodeId(nullptr) {}
 
   /// The dependence information used for the parallelism check.
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;
 }
 
+/// Collect statistics for the syntax tree rooted at @p Ast.
+static void walkAstForStatistics(__isl_keep isl_ast_node *Ast) {
+  assert(Ast);
+  isl_ast_node_foreach_descendant_top_down(
+      Ast,
+      [](__isl_keep isl_ast_node *Node, void *User) -> isl_bool {
+        switch (isl_ast_node_get_type(Node)) {
+        case isl_ast_node_for:
+          NumForLoops++;
+          if (IslAstInfo::isParallel(Node))
+            NumParallel++;
+          if (IslAstInfo::isInnermostParallel(Node))
+            NumInnermostParallel++;
+          if (IslAstInfo::isOutermostParallel(Node))
+            NumOutermostParallel++;
+          if (IslAstInfo::isReductionParallel(Node))
+            NumReductionParallel++;
+          if (IslAstInfo::isExecutedInParallel(Node))
+            NumExecutedInParallel++;
+          break;
+
+        case isl_ast_node_if:
+          NumIfConditions++;
+          break;
+
+        default:
+          break;
+        }
+
+        // Continue traversing subtrees.
+        return isl_bool_true;
+      },
+      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;
 
   // We can not perform the dependence analysis and, consequently,
   // the parallel code generation in case the schedule tree contains
   // extension nodes.
   auto *ScheduleTree = S.getScheduleTree().release();
   PerformParallelTest =
       PerformParallelTest && !S.containsExtensionNode(ScheduleTree);
   isl_schedule_free(ScheduleTree);
 
   // Skip AST and code generation if there was no benefit achieved.
   if (!benefitsFromPolly(S, PerformParallelTest))
     return;
 
+  auto ScopStats = S.getStatistics();
+  ScopsBeneficial++;
+  BeneficialAffineLoops += ScopStats.NumAffineLoops;
+  BeneficialBoxedLoops += ScopStats.NumBoxedLoops;
+
   isl_ctx *Ctx = S.getIslCtx();
   isl_options_set_ast_build_atomic_upper_bound(Ctx, true);
   isl_options_set_ast_build_detect_min_max(Ctx, true);
   isl_ast_build *Build;
   AstBuildUserInfo BuildInfo;
 
   if (UseContext)
     Build = isl_ast_build_from_context(S.getContext().release());
if (PerformParallelTest) {
 
     Build = isl_ast_build_set_after_each_mark(Build, &astBuildAfterMark,
                                               &BuildInfo);
   }
 
   RunCondition = buildRunCondition(S, Build);
 
   Root = isl_ast_build_node_from_schedule(Build, S.getScheduleTree().release());
+  walkAstForStatistics(Root);
 
   isl_ast_build_free(Build);
 }
 
 IslAst IslAst::create(Scop &Scop, const Dependences &D) {
   IslAst Ast{Scop};
   Ast.init(D);
   return Ast;

 void IslAstInfoWrapperPass::releaseMemory() { Ast.reset(); }
 
 bool IslAstInfoWrapperPass::runOnScop(Scop &Scop) {
 
   // Skip SCoPs in case they're already handled by PPCGCodeGeneration.
   if (Scop.isToBeSkipped())
     return false;
 
+  ScopsProcessed++;
+
   const Dependences &D =
       getAnalysis<DependenceInfo>().getDependences(Dependences::AL_Statement);
 
   Ast.reset(new IslAstInfo(Scop, D));
 
   DEBUG(printScop(dbgs(), Scop));
   return false;
 }

lib/CodeGen/IslNodeBuilder.cpp

 
 using namespace polly;
 using namespace llvm;
 
 #define DEBUG_TYPE "polly-codegen"
 
 STATISTIC(VersionedScops, "Number of SCoPs that required versioning.");
 
+STATISTIC(SequentialLoops, "Number of generated sequential for-loops");
+STATISTIC(ParallelLoops, "Number of generated parallel for-loops");
+STATISTIC(VectorLoops, "Number of generated vector for-loops");
+STATISTIC(IfConditions, "Number of generated if-conditions");
+
 static cl::opt<bool> PollyGenerateRTCPrint(
     "polly-codegen-emit-rtc-print",
     cl::desc("Emit code that prints the runtime check result dynamically."),
     cl::Hidden, cl::init(false), cl::ZeroOrMore, cl::cat(PollyCategory));
 
 // If this option is set we always use the isl AST generator to regenerate
 // memory accesses. Without this option set we regenerate expressions using the
 // original SCEV expressions and only generate new expressions in case the
void IslNodeBuilder::createForVector(__isl_take isl_ast_node *For,
   }
 
   IDToValue.erase(IDToValue.find(IteratorID));
   isl_id_free(IteratorID);
   isl_union_map_free(Schedule);
 
   isl_ast_node_free(For);
   isl_ast_expr_free(Iterator);
+
+  VectorLoops++;
 }
 
 namespace {
 /// Restore the initial ordering of dimensions of the band node
 ///
 /// In case the band node represents all the dimensions of the iteration
 /// domain, recreate the band node to restore the initial ordering of the
 /// dimensions.
void IslNodeBuilder::createForSequential(__isl_take isl_ast_node *For,
 
   IDToValue.erase(IDToValue.find(IteratorID));
 
   Builder.SetInsertPoint(&ExitBlock->front());
 
   isl_ast_node_free(For);
   isl_ast_expr_free(Iterator);
   isl_id_free(IteratorID);
+
+  SequentialLoops++;
 }
 
 /// Remove the BBs contained in a (sub)function from the dominator tree.
 ///
 /// This function removes the basic blocks that are part of a subfunction from
 /// the dominator tree. Specifically, when generating code it may happen that at
 /// some point the code generation continues in a new sub-function (e.g., when
 /// generating OpenMP code). The basic blocks that are created in this
void IslNodeBuilder::createForParallel(__isl_take isl_ast_node *For) {
   removeSubFuncFromDomTree((*LoopBody).getParent()->getParent(), DT);
 
   for (const Loop *L : Loops)
     OutsideLoopIterations.erase(L);
 
   isl_ast_node_free(For);
   isl_ast_expr_free(Iterator);
   isl_id_free(IteratorID);
+
+  ParallelLoops++;
 }
 
 /// Return whether any of @p Node's statements contain partial accesses.
 ///
 /// Partial accesses are not supported by Polly's vector code generator.
 static bool hasPartialAccesses(__isl_take isl_ast_node *Node) {
   return isl_ast_node_foreach_descendant_top_down(
              Node,
void IslNodeBuilder::createIf(__isl_take isl_ast_node *If) {
   Builder.SetInsertPoint(&ElseBB->front());
 
   if (isl_ast_node_if_has_else(If))
     create(isl_ast_node_if_get_else(If));
 
   Builder.SetInsertPoint(&MergeBB->front());
 
   isl_ast_node_free(If);
+
+  IfConditions++;
 }
 
 __isl_give isl_id_to_ast_expr *
 IslNodeBuilder::createNewAccesses(ScopStmt *Stmt,
                                   __isl_keep isl_ast_node *Node) {
   isl_id_to_ast_expr *NewAccesses =
       isl_id_to_ast_expr_alloc(Stmt->getParent()->getIslCtx(), 0);
 

lib/Support/RegisterPasses.cpp

void registerPollyPasses(llvm::legacy::PassManagerBase &PM) {
   if (PollyOnlyPrinter)
     PM.add(polly::createDOTOnlyPrinterPass());
 
   PM.add(polly::createScopInfoRegionPassPass());
   if (EnablePolyhedralInfo)
     PM.add(polly::createPolyhedralInfoPass());
 
   if (EnableSimplify)
-    PM.add(polly::createSimplifyPass());
+    PM.add(polly::createSimplifyPass(0));
   if (EnableForwardOpTree)
     PM.add(polly::createForwardOpTreePass());
   if (EnableDeLICM)
     PM.add(polly::createDeLICMPass());
   if (EnableSimplify)
-    PM.add(polly::createSimplifyPass());
+    PM.add(polly::createSimplifyPass(1));
 
   if (ImportJScop)
     PM.add(polly::createJSONImporterPass());
 
   if (DeadCodeElim)
     PM.add(polly::createDeadCodeElimPass());
 
   if (FullyIndexedStaticExpansion)

lib/Transform/DeLICM.cpp

 STATISTIC(DeLICMOutOfQuota,
           "Analyses aborted because max_operations was reached");
 STATISTIC(DeLICMIncompatible, "Number of SCoPs incompatible for analysis");
 STATISTIC(MappedValueScalars, "Number of mapped Value scalars");
 STATISTIC(MappedPHIScalars, "Number of mapped PHI scalars");
 STATISTIC(TargetsMapped, "Number of stores used for at least one mapping");
 STATISTIC(DeLICMScopsModified, "Number of SCoPs optimized");
 
+STATISTIC(NumValueWrites, "Number of scalar value writes after DeLICM");
+STATISTIC(NumValueWritesInLoops,
+          "Number of scalar value writes nested in affine loops after DeLICM");
+STATISTIC(NumPHIWrites, "Number of scalar phi writes after DeLICM");
+STATISTIC(NumPHIWritesInLoops,
+          "Number of scalar phi writes nested in affine loops after DeLICM");
+STATISTIC(NumSingletonWrites, "Number of singleton writes after DeLICM");
+STATISTIC(NumSingletonWritesInLoops,
+          "Number of singleton writes nested in affine loops after DeLICM");
+
 isl::union_map computeReachingOverwrite(isl::union_map Schedule,
                                         isl::union_map Writes,
                                         bool InclPrevWrite,
                                         bool InclOverwrite) {
   return computeReachingWrite(Schedule, Writes, true, InclPrevWrite,
                               InclOverwrite);
 }
 
public:
   }
 
   virtual bool runOnScop(Scop &S) override {
     // Free resources for previous scop's computation, if not yet done.
     releaseMemory();
 
     collapseToUnused(S);
 
+    auto ScopStats = S.getStatistics();
+    NumValueWrites += ScopStats.NumValueWrites;
+    NumValueWritesInLoops += ScopStats.NumValueWritesInLoops;
+    NumPHIWrites += ScopStats.NumPHIWrites;
+    NumPHIWritesInLoops += ScopStats.NumPHIWritesInLoops;
+    NumSingletonWrites += ScopStats.NumSingletonWrites;
+    NumSingletonWritesInLoops += ScopStats.NumSingletonWritesInLoops;
+
     return false;
   }
 
   virtual void printScop(raw_ostream &OS, Scop &S) const override {
     if (!Impl)
       return;
     assert(Impl->getScop() == &S);
 

lib/Transform/ForwardOpTree.cpp

STATISTIC(TotalKnownLoadsForwarded,
           "Number of forwarded loads because their value was known");
 STATISTIC(TotalReadOnlyCopied, "Number of copied read-only accesses");
 STATISTIC(TotalForwardedTrees, "Number of forwarded operand trees");
 STATISTIC(TotalModifiedStmts,
           "Number of statements with at least one forwarded tree");
 
 STATISTIC(ScopsModified, "Number of SCoPs with at least one forwarded tree");
 
+STATISTIC(NumValueWrites, "Number of scalar value writes after OpTree");
+STATISTIC(NumValueWritesInLoops,
+          "Number of scalar value writes nested in affine loops after OpTree");
+STATISTIC(NumPHIWrites, "Number of scalar phi writes after OpTree");
+STATISTIC(NumPHIWritesInLoops,
+          "Number of scalar phi writes nested in affine loops after OpTree");
+STATISTIC(NumSingletonWrites, "Number of singleton writes after OpTree");
+STATISTIC(NumSingletonWritesInLoops,
+          "Number of singleton writes nested in affine loops after OpTree");
+
 namespace {
 
 /// The state of whether an operand tree was/can be forwarded.
 ///
 /// The items apply to an instructions and its operand tree with the instruction
 /// as the root element. If the value in question is not an instruction in the
 /// SCoP, it can be a leaf of an instruction's operand tree.
 enum ForwardingDecision {
virtual bool runOnScop(Scop &S) override {
     }
 
     DEBUG(dbgs() << "Forwarding operand trees...\n");
     Impl->forwardOperandTrees();
 
     DEBUG(dbgs() << "\nFinal Scop:\n");
     DEBUG(dbgs() << S);
 
+    // Update statistics
+    auto ScopStats = S.getStatistics();
+    NumValueWrites += ScopStats.NumValueWrites;
+    NumValueWritesInLoops += ScopStats.NumValueWritesInLoops;
+    NumPHIWrites += ScopStats.NumPHIWrites;
+    NumPHIWritesInLoops += ScopStats.NumPHIWritesInLoops;
+    NumSingletonWrites += ScopStats.NumSingletonWrites;
+    NumSingletonWritesInLoops += ScopStats.NumSingletonWritesInLoops;
+
     return false;
   }
 
   virtual void printScop(raw_ostream &OS, Scop &S) const override {
     if (!Impl)
       return;
 
     assert(Impl->getScop() == &S);

lib/Transform/ScheduleOptimizer.cpp

 
 static cl::opt<bool> OptimizedScops(
     "polly-optimized-scops",
     cl::desc("Polly - Dump polyhedral description of Scops optimized with "
              "the isl scheduling optimizer and the set of post-scheduling "
              "transformations is applied on the schedule tree"),
     cl::init(false), cl::ZeroOrMore, cl::cat(PollyCategory));
 
+STATISTIC(ScopsProcessed, "Number of scops processed");
+STATISTIC(ScopsRescheduled, "Number of scops rescheduled");
+STATISTIC(ScopsOptimized, "Number of scops optimized");
+
+STATISTIC(NumAffineLoopsOptimized, "Number of affine loops optimized");
+STATISTIC(NumBoxedLoopsOptimized, "Number of boxed loops optimized");
+
+#define THREE_STATISTICS(VARNAME, DESC)                                        \
+  static llvm::Statistic VARNAME[3] = {                                        \
+      {DEBUG_TYPE, #VARNAME "0", DESC " (original)", {0}, false},              \
+      {DEBUG_TYPE, #VARNAME "1", DESC " (after scheduler)", {0}, false},       \
+      {DEBUG_TYPE, #VARNAME "2", DESC " (after optimizer)", {0}, false}}
+
+THREE_STATISTICS(NumBands, "Number of bands");
+THREE_STATISTICS(NumBandMembers, "Number of band members");
+THREE_STATISTICS(NumCoincident, "Number of coincident band members");
+THREE_STATISTICS(NumPermutable, "Number of permutable bands");
+THREE_STATISTICS(NumFilters, "Number of filter nodes");
+THREE_STATISTICS(NumExtension, "Number of extension nodes");
+
+STATISTIC(FirstLevelTileOpts, "Number of first level tiling applied");
+STATISTIC(SecondLevelTileOpts, "Number of second level tiling applied");
+STATISTIC(RegisterTileOpts, "Number of register tiling applied");
+STATISTIC(PrevectOpts, "Number of strip-mining for prevectorization applied");
+STATISTIC(MatMulOpts,
+          "Number of matrix multiplication patterns detected and optimized");
+
 /// Create an isl::union_set, which describes the isolate option based on
 /// IsolateDomain.
 ///
 /// @param IsolateDomain An isl::set whose @p OutDimsNum last dimensions should
 ///                      belong to the current band node.
 /// @param OutDimsNum    A number of dimensions that should belong to
 ///                      the current band node.
 static isl::union_set getIsolateOptions(isl::set IsolateDomain,
isl::schedule_node ScheduleTreeOptimizer::prevectSchedBand(
   // we will have troubles to match it in the backend.
   Node = Node.band_set_ast_build_options(
       isl::union_set(Node.get_ctx(), "{ unroll[x]: 1 = 0 }"));
   Node = isl::manage(isl_schedule_node_band_sink(Node.release()));
   Node = Node.child(0);
   if (isl_schedule_node_get_type(Node.get()) == isl_schedule_node_leaf)
     Node = Node.parent();
   auto LoopMarker = isl::id::alloc(Node.get_ctx(), "SIMD", nullptr);
+  PrevectOpts++;
   return Node.insert_mark(LoopMarker);
 }
 
 isl::schedule_node ScheduleTreeOptimizer::tileNode(isl::schedule_node Node,
                                                    const char *Identifier,
                                                    ArrayRef<int> TileSizes,
                                                    int DefaultTileSize) {
   auto Space = isl::manage(isl_schedule_node_band_get_space(Node.get()));
bool ScheduleTreeOptimizer::isTileableBandNode(isl::schedule_node Node) {
   if (Dims <= 1)
     return false;
 
   return isSimpleInnermostBand(Node);
 }
 
 __isl_give isl::schedule_node
 ScheduleTreeOptimizer::standardBandOpts(isl::schedule_node Node, void *User) {
-  if (FirstLevelTiling)
+  if (FirstLevelTiling) {
     Node = tileNode(Node, "1st level tiling", FirstLevelTileSizes,
                     FirstLevelDefaultTileSize);
+    FirstLevelTileOpts++;
+  }
 
-  if (SecondLevelTiling)
+  if (SecondLevelTiling) {
     Node = tileNode(Node, "2nd level tiling", SecondLevelTileSizes,
                     SecondLevelDefaultTileSize);
+    SecondLevelTileOpts++;
+  }
 
-  if (RegisterTiling)
+  if (RegisterTiling) {
     Node =
         applyRegisterTiling(Node, RegisterTileSizes, RegisterDefaultTileSize);
+    RegisterTileOpts++;
+  }
 
   if (PollyVectorizerChoice == VECTORIZER_NONE)
     return Node;
 
   auto Space = isl::manage(isl_schedule_node_band_get_space(Node.get()));
   auto Dims = Space.dim(isl::dim::set);
 
   for (int i = Dims - 1; i >= 0; i--)
ScheduleTreeOptimizer::optimizeBand(__isl_take isl_schedule_node *Node,
   const OptimizerAdditionalInfoTy *OAI =
       static_cast<const OptimizerAdditionalInfoTy *>(User);
 
   MatMulInfoTy MMI;
   if (PMBasedOpts && User &&
       isMatrMultPattern(isl::manage(isl_schedule_node_copy(Node)), OAI->D,
                         MMI)) {
     DEBUG(dbgs() << "The matrix multiplication pattern was detected\n");
+    MatMulOpts++;
     return optimizeMatMulPattern(isl::manage(Node), OAI->TTI, MMI).release();
   }
 
   return standardBandOpts(isl::manage(Node), User).release();
 }
 
 isl::schedule
 ScheduleTreeOptimizer::optimizeSchedule(isl::schedule Schedule,

 
 private:
   isl_schedule *LastSchedule;
 };
 } // namespace
 
 char IslScheduleOptimizer::ID = 0;
 
+/// Collect statistics for the schedule tree.
+///
+/// @param Schedule The schedule tree to analyze. If not a schedule tree it is
+/// ignored.
+/// @param Version  The version of the schedule tree that is analyzed.
+///                 0 for the original schedule tree before any transformation.
+///                 1 for the schedule tree after isl's rescheduling.
+///                 2 for the schedule tree after optimizations are applied
+///                 (tiling, pattern matching)
+static void walkScheduleTreeForStatistics(isl::schedule Schedule, int Version) {
+  auto Root = Schedule.get_root();
+  if (!Root)
+    return;
+
+  Root.foreach_ancestor_top_down([Version](
+                                     isl::schedule_node Node) -> isl::stat {
+    switch (isl_schedule_node_get_type(Node.get())) {
+    case isl_schedule_node_band: {
+      NumBands[Version]++;
+      if (isl_schedule_node_band_get_permutable(Node.get()) == isl_bool_true)
+        NumPermutable[Version]++;
+
+      int CountMembers = isl_schedule_node_band_n_member(Node.get());
+      NumBandMembers[Version] += CountMembers;
+      for (int i = 0; i < CountMembers; i += 1) {
+        if (Node.band_member_get_coincident(i))
+          NumCoincident[Version]++;
+      }
+    } break;
+
+    case isl_schedule_node_filter:
+      NumFilters[Version]++;
+      break;
+
+    case isl_schedule_node_extension:
+      NumExtension[Version]++;
+      break;
+
+    default:
+      break;
+    }
+
+    return isl::stat::ok;
+  });
+}
+
 bool IslScheduleOptimizer::runOnScop(Scop &S) {
 
   // Skip SCoPs in case they're already optimised by PPCGCodeGeneration
   if (S.isToBeSkipped())
     return false;
 
   // Skip empty SCoPs but still allow code generation as it will delete the
   // loops present but not needed.
ProximityKinds =
         Dependences::TYPE_RAW | Dependences::TYPE_WAR | Dependences::TYPE_WAW;
   }
 
   isl::union_set Domain = S.getDomains();
 
   if (!Domain)
     return false;
 
+  ScopsProcessed++;
+  walkScheduleTreeForStatistics(S.getScheduleTree(), 0);
+
   isl::union_map Validity = give(D.getDependences(ValidityKinds));
   isl::union_map Proximity = give(D.getDependences(ProximityKinds));
 
   // Simplify the dependences by removing the constraints introduced by the
   // domains. This can speed up the scheduling time significantly, as large
   // constant coefficients will be removed from the dependences. The
   // introduction of some additional dependences reduces the possible
   // transformations, but in most cases, such transformation do not seem to be
bool IslScheduleOptimizer::runOnScop(Scop &S) {
 
   auto SC = isl::schedule_constraints::on_domain(Domain);
   SC = SC.set_proximity(Proximity);
   SC = SC.set_validity(Validity);
   SC = SC.set_coincidence(Validity);
   auto Schedule = SC.compute_schedule();
   isl_options_set_on_error(Ctx, OnErrorStatus);
 
+  walkScheduleTreeForStatistics(Schedule, 1);
+
   // In cases the scheduler is not able to optimize the code, we just do not
   // touch the schedule.
   if (!Schedule)
     return false;
 
+  ScopsRescheduled++;
+
   DEBUG({
     auto *P = isl_printer_to_str(Ctx);
     P = isl_printer_set_yaml_style(P, ISL_YAML_STYLE_BLOCK);
     P = isl_printer_print_schedule(P, Schedule.get());
     auto *str = isl_printer_get_str(P);
     dbgs() << "NewScheduleTree: \n" << str << "\n";
     free(str);
     isl_printer_free(P);
   });
 
   Function &F = S.getFunction();
   auto *TTI = &getAnalysis<TargetTransformInfoWrapperPass>().getTTI(F);
   const OptimizerAdditionalInfoTy OAI = {TTI, const_cast<Dependences *>(&D)};
   auto NewSchedule = ScheduleTreeOptimizer::optimizeSchedule(Schedule, &OAI);
+  walkScheduleTreeForStatistics(NewSchedule, 1);
 
   if (!ScheduleTreeOptimizer::isProfitableSchedule(S, NewSchedule))
     return false;
 
+  auto ScopStats = S.getStatistics();
+  ScopsOptimized++;
+  NumAffineLoopsOptimized += ScopStats.NumAffineLoops;
+  NumBoxedLoopsOptimized += ScopStats.NumBoxedLoops;
+
   S.setScheduleTree(NewSchedule.release());
   S.markAsOptimized();
 
   if (OptimizedScops)
     errs() << S;
 
   return false;
 }

lib/Transform/Simplify.cpp

 #include "llvm/Support/Debug.h"
 #define DEBUG_TYPE "polly-simplify"
 
 using namespace llvm;
 using namespace polly;
 
 namespace {
 
+#define TWO_STATISTICS(VARNAME, DESC)                                          \
+  static llvm::Statistic VARNAME[2] = {                                        \
+      {DEBUG_TYPE, #VARNAME "0", DESC " (first)", {0}, false},                 \
+      {DEBUG_TYPE, #VARNAME "1", DESC " (second)", {0}, false}}
+
 /// Number of max disjuncts we allow in removeOverwrites(). This is to avoid
 /// that the analysis of accesses in a statement is becoming too complex. Chosen
 /// to be relatively small because all the common cases should access only few
 /// array elements per statement.
 static int const SimplifyMaxDisjuncts = 4;
 
-STATISTIC(ScopsProcessed, "Number of SCoPs processed");
-STATISTIC(ScopsModified, "Number of SCoPs simplified");
+TWO_STATISTICS(ScopsProcessed, "Number of SCoPs processed");
+TWO_STATISTICS(ScopsModified, "Number of SCoPs simplified");
 
-STATISTIC(TotalOverwritesRemoved, "Number of removed overwritten writes");
-STATISTIC(TotalWritesCoalesced, "Number of writes coalesced with another");
-STATISTIC(TotalRedundantWritesRemoved,
+TWO_STATISTICS(TotalOverwritesRemoved, "Number of removed overwritten writes");
+TWO_STATISTICS(TotalWritesCoalesced, "Number of writes coalesced with another");
+TWO_STATISTICS(TotalRedundantWritesRemoved,
                "Number of writes of same value removed in any SCoP");
-STATISTIC(TotalEmptyPartialAccessesRemoved,
+TWO_STATISTICS(TotalEmptyPartialAccessesRemoved,
                "Number of empty partial accesses removed");
-STATISTIC(TotalDeadAccessesRemoved, "Number of dead accesses removed");
-STATISTIC(TotalDeadInstructionsRemoved,
+TWO_STATISTICS(TotalDeadAccessesRemoved, "Number of dead accesses removed");
+TWO_STATISTICS(TotalDeadInstructionsRemoved,
                "Number of unused instructions removed");
-STATISTIC(TotalStmtsRemoved, "Number of statements removed in any SCoP");
+TWO_STATISTICS(TotalStmtsRemoved, "Number of statements removed in any SCoP");
+
+TWO_STATISTICS(NumValueWrites, "Number of scalar value writes after Simplify");
+TWO_STATISTICS(
+    NumValueWritesInLoops,
+    "Number of scalar value writes nested in affine loops after Simplify");
+TWO_STATISTICS(NumPHIWrites,
+               "Number of scalar phi writes after the first simplification");
+TWO_STATISTICS(
+    NumPHIWritesInLoops,
+    "Number of scalar phi writes nested in affine loops after Simplify");
+TWO_STATISTICS(NumSingletonWrites, "Number of singleton writes after Simplify");
+TWO_STATISTICS(
+    NumSingletonWritesInLoops,
+    "Number of singleton writes nested in affine loops after Simplify");
 
 static bool isImplicitRead(MemoryAccess *MA) {
   return MA->isRead() && MA->isOriginalScalarKind();
 }
 
 static bool isExplicitAccess(MemoryAccess *MA) {
   return MA->isOriginalArrayKind();
 }
isl::union_map UResult =
       UMap.subtract(isl::map::universe(PrevMap.get_space()));
   UResult.add_map(Result);
 
   return UResult;
 }
 
 class Simplify : public ScopPass {
 private:
+  /// The number of invocation of Simplify to determine which statistics to
+  /// update.
+  int CallNo;
+
   /// The last/current SCoP that is/has been processed.
   Scop *S;
 
   /// Number of writes that are overwritten anyway.
   int OverwritesRemoved = 0;
 
   /// Number of combined writes.
   int WritesCoalesced = 0;
for (auto &Stmt : *S) {
         // If all of a write's elements are overwritten, remove it.
         isl::union_map AccRelUnion = AccRel;
         if (AccRelUnion.is_subset(WillBeOverwritten)) {
           DEBUG(dbgs() << "Removing " << MA
                        << " which will be overwritten anyway\n");
 
           Stmt.removeSingleMemoryAccess(MA);
           OverwritesRemoved++;
-          TotalOverwritesRemoved++;
+          TotalOverwritesRemoved[CallNo]++;
         }
 
         // Unconditional writes overwrite other values.
         if (MA->isMustWrite()) {
           // Avoid too complex isl sets. If necessary, throw away some of the
           // knowledge.
           WillBeOverwritten =
               underapproximatedAddMap(WillBeOverwritten, AccRel);
for (auto &Stmt : *S) {
 
             // Carry out the coalescing.
             Stmt.removeSingleMemoryAccess(MA);
             OtherMA->setNewAccessRelation(NewAccRel);
 
             // We removed MA, OtherMA takes its role.
             MA = OtherMA;
 
-            TotalWritesCoalesced++;
+            TotalWritesCoalesced[CallNo]++;
             WritesCoalesced++;
 
             // Don't look for more candidates.
             return isl::stat::error;
           });
         }
 
         // Two writes cannot be coalesced if there is another access (to some of
for (auto &Stmt : *S) {
             if (isl::union_map(AccRelStoredVal).is_subset(Known)) {
               DEBUG(dbgs() << "Cleanup of " << MA << ":\n");
               DEBUG(dbgs() << "      Scalar: " << *StoredVal << "\n");
               DEBUG(dbgs() << "      AccRel: " << AccRel << "\n");
 
               Stmt.removeSingleMemoryAccess(MA);
 
               RedundantWritesRemoved++;
-              TotalRedundantWritesRemoved++;
+              TotalRedundantWritesRemoved[CallNo]++;
             }
           }
         }
 
         // Update the know values set.
         if (MA->isRead()) {
           // Loaded values are the currently known values of the array element
           // it was loaded from.
private:
   /// Remove statements without side effects.
   void removeUnnecessaryStmts() {
     auto NumStmtsBefore = S->getSize();
     S->simplifySCoP(true);
     assert(NumStmtsBefore >= S->getSize());
     StmtsRemoved = NumStmtsBefore - S->getSize();
     DEBUG(dbgs() << "Removed " << StmtsRemoved << " (of " << NumStmtsBefore
                  << ") statements\n");
-    TotalStmtsRemoved += StmtsRemoved;
+    TotalStmtsRemoved[CallNo] += StmtsRemoved;
   }
 
   /// Remove accesses that have an empty domain.
   void removeEmptyPartialAccesses() {
     for (ScopStmt &Stmt : *S) {
       // Defer the actual removal to not invalidate iterators.
       SmallVector<MemoryAccess *, 8> DeferredRemove;
 
       for (MemoryAccess *MA : Stmt) {
         if (!MA->isWrite())
           continue;
 
         isl::map AccRel = MA->getAccessRelation();
         if (!AccRel.is_empty().is_true())
           continue;
 
         DEBUG(dbgs() << "Removing " << MA
                      << " because it's a partial access that never occurs\n");
         DeferredRemove.push_back(MA);
       }
 
       for (MemoryAccess *MA : DeferredRemove) {
         Stmt.removeSingleMemoryAccess(MA);
         EmptyPartialAccessesRemoved++;
-        TotalEmptyPartialAccessesRemoved++;
+        TotalEmptyPartialAccessesRemoved[CallNo]++;
       }
     }
   }
 
   /// Mark all reachable instructions and access, and sweep those that are not
   /// reachable.
   void markAndSweep(LoopInfo *LI) {
     DenseSet<MemoryAccess *> UsedMA;
void markAndSweep(LoopInfo *LI) {
     for (MemoryAccess *MA : AllMAs) {
       if (UsedMA.count(MA))
         continue;
       DEBUG(dbgs() << "Removing " << MA << " because its value is not used\n");
       ScopStmt *Stmt = MA->getStatement();
       Stmt->removeSingleMemoryAccess(MA);
 
       DeadAccessesRemoved++;
-      TotalDeadAccessesRemoved++;
+      TotalDeadAccessesRemoved[CallNo]++;
     }
 
     // Remove all non-reachable instructions.
     for (ScopStmt &Stmt : *S) {
       if (!Stmt.isBlockStmt())
         continue;
 
       SmallVector<Instruction *, 32> AllInsts(Stmt.insts_begin(),
                                               Stmt.insts_end());
       SmallVector<Instruction *, 32> RemainInsts;
 
       for (Instruction *Inst : AllInsts) {
         auto It = UsedInsts.find({&Stmt, Inst});
         if (It == UsedInsts.end()) {
           DEBUG(dbgs() << "Removing "; Inst->print(dbgs());
                 dbgs() << " because it is not used\n");
           DeadInstructionsRemoved++;
-          TotalDeadInstructionsRemoved++;
+          TotalDeadInstructionsRemoved[CallNo]++;
           continue;
         }
 
         RemainInsts.push_back(Inst);
 
         // If instructions appear multiple times, keep only the first.
         UsedInsts.erase(It);
       }
for (auto &Stmt : *S) {
       for (auto *MA : Stmt)
         MA->print(OS);
     }
     OS.indent(Indent) << "}\n";
   }
 
 public:
   static char ID;
-  explicit Simplify() : ScopPass(ID) {}
+  explicit Simplify(int CallNo = 0) : ScopPass(ID), CallNo(CallNo) {}
 
   virtual void getAnalysisUsage(AnalysisUsage &AU) const override {
     AU.addRequiredTransitive<ScopInfoRegionPass>();
     AU.addRequired<LoopInfoWrapperPass>();
     AU.setPreservesAll();
   }
 
   virtual bool runOnScop(Scop &S) override {
     // Reset statistics of last processed SCoP.
     releaseMemory();
     assert(!isModified());
 
     // Prepare processing of this SCoP.
     this->S = &S;
-    ScopsProcessed++;
+    ScopsProcessed[CallNo]++;
 
     DEBUG(dbgs() << "Removing partial writes that never happen...\n");
     removeEmptyPartialAccesses();
 
     DEBUG(dbgs() << "Removing overwrites...\n");
     removeOverwrites();
 
     DEBUG(dbgs() << "Coalesce partial writes...\n");
     coalesceWrites();
 
     DEBUG(dbgs() << "Removing redundant writes...\n");
     removeRedundantWrites();
 
     DEBUG(dbgs() << "Cleanup unused accesses...\n");
     LoopInfo *LI = &getAnalysis<LoopInfoWrapperPass>().getLoopInfo();
     markAndSweep(LI);
 
     DEBUG(dbgs() << "Removing statements without side effects...\n");
     removeUnnecessaryStmts();
 
     if (isModified())
-      ScopsModified++;
+      ScopsModified[CallNo]++;
     DEBUG(dbgs() << "\nFinal Scop:\n");
     DEBUG(dbgs() << S);
 
+    auto ScopStats = S.getStatistics();
+    NumValueWrites[CallNo] += ScopStats.NumValueWrites;
+    NumValueWritesInLoops[CallNo] += ScopStats.NumValueWritesInLoops;
+    NumPHIWrites[CallNo] += ScopStats.NumPHIWrites;
+    NumPHIWritesInLoops[CallNo] += ScopStats.NumPHIWritesInLoops;
+    NumSingletonWrites[CallNo] += ScopStats.NumSingletonWrites;
+    NumSingletonWritesInLoops[CallNo] += ScopStats.NumSingletonWritesInLoops;
+
     return false;
   }
 
   virtual void printScop(raw_ostream &OS, Scop &S) const override {
     assert(&S == this->S &&
            "Can only print analysis for the last processed SCoP");
     printStatistics(OS);
 
SmallVector<MemoryAccess *, 32> getAccessesInOrder(ScopStmt &Stmt) {
   for (MemoryAccess *MemAcc : Stmt)
     if (isImplicitWrite(MemAcc))
       Accesses.push_back(MemAcc);
 
   return Accesses;
 }
 } // namespace polly
 
-Pass *polly::createSimplifyPass() { return new Simplify(); }
+Pass *polly::createSimplifyPass(int CallNo) { return new Simplify(CallNo); }
 
 INITIALIZE_PASS_BEGIN(Simplify, "polly-simplify", "Polly - Simplify", false,
                       false)
 INITIALIZE_PASS_DEPENDENCY(LoopInfoWrapperPass)
 INITIALIZE_PASS_END(Simplify, "polly-simplify", "Polly - Simplify", false,
                     false)