[GSoC 2016] [Polly] [WIP] Simplify AccFuncMap to vector<> AccessFunctions

[gareevroman]

Summary

getAccessFunctions() is dead code and the 'BB' argument of getOrCreateAccessFunctions() is not used. This patch deletes getAccessFunctions and transforms AccFuncMap into a std::vector<std::unique_ptr<MemoryAccess>> AccessFunctions.

polly/trunk/include/polly/ScopInfo.h

 /// Maps from a loop to the affine function expressing its backedge taken count.
 /// The backedge taken count already enough to express iteration domain as we
 /// only allow loops with canonical induction variable.
 /// A canonical induction variable is:
 /// an integer recurrence that starts at 0 and increments by one each time
 /// through the loop.
 typedef std::map<const Loop *, const SCEV *> LoopBoundMapType;
 
-typedef std::deque<MemoryAccess> AccFuncSetType;
-typedef std::map<const BasicBlock *, AccFuncSetType> AccFuncMapType;
+typedef std::vector<std::unique_ptr<MemoryAccess>> AccFuncVector;
 
 /// @brief A class to store information about arrays in the SCoP.
 ///
 /// Objects are accessible via the ScoP, MemoryAccess or the id associated with
 /// the MemoryAccess access function.
 ///
 class ScopArrayInfo {
 public:
private:
   Scop(const Scop &) = delete;
   const Scop &operator=(const Scop &) = delete;
 
   ScalarEvolution *SE;
 
   /// The underlying Region.
   Region &R;
 
-  // Access function of statements (currently BasicBlocks) .
+  // Access functions of the SCoP.
   //
   // This owns all the MemoryAccess objects of the Scop created in this pass.
-  AccFuncMapType AccFuncMap;
+  AccFuncVector AccessFunctions;
 
   /// Flag to indicate that the scheduler actually optimized the SCoP.
   bool IsOptimized;
 
   /// @brief True if the underlying region has a single exiting block.
   bool HasSingleExitEdge;
 
   /// @brief Flag to remember if the SCoP contained an error block or not.
private:
 
   /// @brief List of invariant accesses.
   InvariantEquivClassesTy InvariantEquivClasses;
 
   /// @brief Scop constructor; invoked from ScopBuilder::buildScop.
   Scop(Region &R, ScalarEvolution &SE, LoopInfo &LI,
        ScopDetection::DetectionContext &DC);
 
-  /// @brief Get or create the access function set in a BasicBlock
-  AccFuncSetType &getOrCreateAccessFunctions(const BasicBlock *BB) {
-    return AccFuncMap[BB];
+  /// @brief Add the access function to all MemoryAccess objects of the Scop
+  ///        created in this pass.
+  void addAccessFunction(MemoryAccess *Access) {
+    AccessFunctions.emplace_back(Access);
   }
   //@}
 
   /// @brief Initialize this ScopBuilder.
   void init(AliasAnalysis &AA, AssumptionCache &AC, DominatorTree &DT,
             LoopInfo &LI);
 
   /// @brief Propagate domains that are known due to graph properties.
private:
   void printAliasAssumptions(raw_ostream &OS) const;
   //@}
 
   friend class ScopBuilder;
 
 public:
   ~Scop();
 
-  /// @brief Get all access functions in a BasicBlock
-  ///
-  /// @param  BB The BasicBlock that containing the access functions.
-  ///
-  /// @return All access functions in BB
-  ///
-  AccFuncSetType *getAccessFunctions(const BasicBlock *BB) {
-    AccFuncMapType::iterator at = AccFuncMap.find(BB);
-    return at != AccFuncMap.end() ? &(at->second) : 0;
-  }
-
   ScalarEvolution *getSE() const;
 
   /// @brief Get the count of parameters used in this Scop.
   ///
   /// @return The count of parameters used in this Scop.
   size_t getNumParams() const { return Parameters.size(); }
 
   /// @brief Take a list of parameters and add the new ones to the scop.

polly/trunk/lib/Analysis/ScopBuilder.cpp

MemoryAccess *ScopBuilder::addMemoryAccess(
     ScopArrayInfo::MemoryKind Kind) {
   ScopStmt *Stmt = scop->getStmtFor(BB);
 
   // Do not create a memory access for anything not in the SCoP. It would be
   // ignored anyway.
   if (!Stmt)
     return nullptr;
 
-  AccFuncSetType &AccList = scop->getOrCreateAccessFunctions(BB);
   Value *BaseAddr = BaseAddress;
   std::string BaseName = getIslCompatibleName("MemRef_", BaseAddr, "");
 
   bool isKnownMustAccess = false;
 
   // Accesses in single-basic block statements are always excuted.
   if (Stmt->isBlockStmt())
     isKnownMustAccess = true;
MemoryAccess *ScopBuilder::addMemoryAccess(
   // after exiting the statement. Therefore they are guaranteed execute and
   // overwrite the old value.
   if (Kind == ScopArrayInfo::MK_PHI || Kind == ScopArrayInfo::MK_ExitPHI)
     isKnownMustAccess = true;
 
   if (!isKnownMustAccess && AccType == MemoryAccess::MUST_WRITE)
     AccType = MemoryAccess::MAY_WRITE;
 
-  AccList.emplace_back(Stmt, Inst, AccType, BaseAddress, ElementType, Affine,
+  auto *Access =
+      new MemoryAccess(Stmt, Inst, AccType, BaseAddress, ElementType, Affine,
                        Subscripts, Sizes, AccessValue, Kind, BaseName);
-  Stmt->addAccess(&AccList.back());
-  return &AccList.back();
+
+  scop->addAccessFunction(Access);
+  Stmt->addAccess(Access);
+  return Access;
 }
 
 void ScopBuilder::addArrayAccess(
     MemAccInst MemAccInst, MemoryAccess::AccessType AccType, Value *BaseAddress,
     Type *ElementType, bool IsAffine, ArrayRef<const SCEV *> Subscripts,
     ArrayRef<const SCEV *> Sizes, Value *AccessValue) {
   ArrayBasePointers.insert(BaseAddress);
   addMemoryAccess(MemAccInst->getParent(), MemAccInst, AccType, BaseAddress,

polly/trunk/lib/Analysis/ScopInfo.cpp

for (const auto &IAClass : InvariantEquivClasses)
     isl_set_free(IAClass.ExecutionContext);
 
   // Explicitly release all Scop objects and the underlying isl objects before
   // we relase the isl context.
   Stmts.clear();
   ScopArrayInfoSet.clear();
   ScopArrayInfoMap.clear();
   ScopArrayNameMap.clear();
-  AccFuncMap.clear();
+  AccessFunctions.clear();
 }
 
 void Scop::updateAccessDimensionality() {
   // Check all array accesses for each base pointer and find a (virtual) element
   // size for the base pointer that divides all access functions.
   for (auto &Stmt : *this)
     for (auto *Access : Stmt) {
       if (!Access->isArrayKind())