Initial version with unique_ptr PointsToSets (a bit slower than before)

fabianbs96 · fabianbs96 · commit 96b29fe8dedd · 2021-09-02T15:00:53.000+02:00
diff --git a/include/phasar/DB/ProjectIRDB.h b/include/phasar/DB/ProjectIRDB.h
@@ -172,6 +172,8 @@ class ProjectIRDB {
     return IDInstructionMapping.size();
   }
 
+  [[nodiscard]] std::size_t getNumGlobals() const;
+
   [[nodiscard]] llvm::Instruction *getInstruction(std::size_t Id);
 
   [[nodiscard]] static std::size_t getInstructionID(const llvm::Instruction *I);
diff --git a/include/phasar/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/IDEInstInteractionAnalysis.h b/include/phasar/PhasarLLVM/DataFlowSolver/IfdsIde/Problems/IDEInstInteractionAnalysis.h
@@ -255,7 +255,7 @@ class IDEInstInteractionAnalysisT
         //
         struct IIAFlowFunction : FlowFunction<d_t, container_type> {
           const llvm::LoadInst *Load;
-          LLVMPointsToInfo::PointsToSetPtrTy PTS;
+          LLVMPointsToInfo::AllocationSiteSetPtrTy PTS;
 
           IIAFlowFunction(IDEInstInteractionAnalysisT &Problem,
                           const llvm::LoadInst *Load)
@@ -300,8 +300,8 @@ class IDEInstInteractionAnalysisT
         //
         struct IIAFlowFunction : FlowFunction<d_t, container_type> {
           const llvm::StoreInst *Store;
-          LLVMPointsToInfo::PointsToSetPtrTy ValuePTS;
-          LLVMPointsToInfo::PointsToSetPtrTy PointerPTS;
+          LLVMPointsToInfo::AllocationSiteSetPtrTy ValuePTS;
+          LLVMPointsToInfo::AllocationSiteSetPtrTy PointerPTS;
 
           IIAFlowFunction(IDEInstInteractionAnalysisT &Problem,
                           const llvm::StoreInst *Store)
@@ -311,7 +311,7 @@ class IDEInstInteractionAnalysisT
                         Store->getValueOperand(),
                         Problem.OnlyConsiderLocalAliases);
                   } else {
-                    return std::make_shared<LLVMPointsToInfo::PointsToSetTy>(
+                    return std::make_unique<LLVMPointsToInfo::PointsToSetTy>(
                         LLVMPointsToInfo::PointsToSetTy{
                             Store->getValueOperand()});
                   }
diff --git a/include/phasar/PhasarLLVM/Pointer/LLVMPointsToGraph.h b/include/phasar/PhasarLLVM/Pointer/LLVMPointsToGraph.h
@@ -24,6 +24,7 @@
 #include "phasar/Config/Configuration.h"
 #include "phasar/PhasarLLVM/Pointer/LLVMBasedPointsToAnalysis.h"
 #include "phasar/PhasarLLVM/Pointer/LLVMPointsToInfo.h"
+#include "phasar/PhasarLLVM/Pointer/PointsToSetOwner.h"
 
 namespace llvm {
 class Value;
@@ -106,6 +107,8 @@ class LLVMPointsToGraph : public LLVMPointsToInfo {
   /// Keep track of what has already been merged into this points-to graph.
   std::unordered_set<const llvm::Function *> AnalyzedFunctions;
   LLVMBasedPointsToAnalysis PTA;
+  PointsToSetOwner<PointsToSetTy> Owner;
+  std::unordered_map<const llvm::Value *, PointsToSetTy *> Cache;
 
   // void mergeGraph(const LLVMPointsToGraph &Other);
 
@@ -140,7 +143,7 @@ class LLVMPointsToGraph : public LLVMPointsToInfo {
   getPointsToSet(const llvm::Value *V,
                  const llvm::Instruction *I = nullptr) override;
 
-  PointsToSetPtrTy
+  AllocationSiteSetPtrTy
   getReachableAllocationSites(const llvm::Value *V, bool IntraProcOnly = false,
                               const llvm::Instruction *I = nullptr) override;
 
diff --git a/include/phasar/PhasarLLVM/Pointer/LLVMPointsToInfo.h b/include/phasar/PhasarLLVM/Pointer/LLVMPointsToInfo.h
@@ -23,6 +23,7 @@ namespace psr {
 class LLVMPointsToInfo
     : public PointsToInfo<const llvm::Value *, const llvm::Instruction *> {
 public:
+  using PointsToInfo::AllocationSiteSetPtrTy;
   using PointsToInfo::PointsToSetPtrTy;
   using PointsToInfo::PointsToSetTy;
 
diff --git a/include/phasar/PhasarLLVM/Pointer/LLVMPointsToSet.h b/include/phasar/PhasarLLVM/Pointer/LLVMPointsToSet.h
@@ -21,6 +21,7 @@
 
 #include "phasar/PhasarLLVM/Pointer/LLVMBasedPointsToAnalysis.h"
 #include "phasar/PhasarLLVM/Pointer/LLVMPointsToInfo.h"
+#include "phasar/PhasarLLVM/Pointer/PointsToSetOwner.h"
 
 #include "llvm/ADT/DenseSet.h"
 #include "llvm/Support/FormatVariadic.h"
@@ -39,12 +40,12 @@ namespace psr {
 
 class LLVMPointsToSet : public LLVMPointsToInfo {
 private:
-  using PointsToSetMap =
-      std::unordered_map<const llvm::Value *, PointsToSetPtrTy>;
+  using PointsToSetMap = llvm::DenseMap<const llvm::Value *, PointsToSetTy *>;
 
   LLVMBasedPointsToAnalysis PTA;
   llvm::DenseSet<const llvm::Function *> AnalyzedFunctions;
 
+  PointsToSetOwner<PointsToSetTy> Owner;
   PointsToSetMap PointsToSets;
 
   void computeValuesPointsToSet(const llvm::Value *V);
@@ -55,8 +56,7 @@ class LLVMPointsToSet : public LLVMPointsToInfo {
 
   void mergePointsToSets(const llvm::Value *V1, const llvm::Value *V2);
 
-  PointsToSetPtrTy mergePointsToSets(const PointsToSetPtrTy &PTS1,
-                                     const PointsToSetPtrTy &PTS2);
+  PointsToSetTy *mergePointsToSets(PointsToSetTy *PTS1, PointsToSetTy *PTS2);
 
   bool interIsReachableAllocationSiteTy(const llvm::Value *V,
                                         const llvm::Value *P);
@@ -104,7 +104,7 @@ class LLVMPointsToSet : public LLVMPointsToInfo {
   getPointsToSet(const llvm::Value *V,
                  const llvm::Instruction *I = nullptr) override;
 
-  [[nodiscard]] PointsToSetPtrTy
+  [[nodiscard]] AllocationSiteSetPtrTy
   getReachableAllocationSites(const llvm::Value *V, bool IntraProcOnly = false,
                               const llvm::Instruction *I = nullptr) override;
 
diff --git a/include/phasar/PhasarLLVM/Pointer/PointsToInfo.h b/include/phasar/PhasarLLVM/Pointer/PointsToInfo.h
@@ -43,7 +43,8 @@ std::ostream &operator<<(std::ostream &os, const PointerAnalysisType &PA);
 template <typename V, typename N> class PointsToInfo {
 public:
   using PointsToSetTy = llvm::DenseSet<V>;
-  using PointsToSetPtrTy = std::shared_ptr<PointsToSetTy>;
+  using PointsToSetPtrTy = const PointsToSetTy *;
+  using AllocationSiteSetPtrTy = std::unique_ptr<PointsToSetTy>;
 
   virtual ~PointsToInfo() = default;
 
@@ -55,7 +56,7 @@ template <typename V, typename N> class PointsToInfo {
 
   virtual PointsToSetPtrTy getPointsToSet(V V1, N I = N{}) = 0;
 
-  virtual PointsToSetPtrTy
+  virtual AllocationSiteSetPtrTy
   getReachableAllocationSites(V V1, bool IntraProcOnly = false, N I = N{}) = 0;
 
   // Checks if V2 is a reachable allocation in the points to set of V1.
diff --git a/include/phasar/PhasarLLVM/Pointer/PointsToSetOwner.h b/include/phasar/PhasarLLVM/Pointer/PointsToSetOwner.h
@@ -0,0 +1,55 @@
+/******************************************************************************
+ * Copyright (c) 2021 Philipp Schubert.
+ * All rights reserved. This program and the accompanying materials are made
+ * available under the terms of LICENSE.txt.
+ *
+ * Contributors:
+ *     Fabian Schiebel, Philipp Schubert and others
+ *****************************************************************************/
+
+#ifndef PHASAR_PHASARLLVM_POINTER_POINTSTOSETOWNER_H_
+#define PHASAR_PHASARLLVM_POINTER_POINTSTOSETOWNER_H_
+
+#include "llvm/ADT/DenseMap.h"
+#include <memory>
+#include <vector>
+
+namespace psr {
+template <typename PointsToSetTy> class PointsToSetOwner {
+public:
+  explicit PointsToSetOwner() = default;
+  explicit PointsToSetOwner(size_t InitialCapacity) {
+    Owner.reserve(InitialCapacity);
+    OwnedPTS.reserve(InitialCapacity);
+  }
+
+  PointsToSetTy *acquire() {
+    Owner.push_back(std::make_unique<PointsToSetTy>());
+    OwnedPTS[Owner.back().get()] = Owner.size() - 1;
+    return Owner.back().get();
+  }
+  void release(PointsToSetTy *PTS) {
+    if (Owner.empty()) {
+      return;
+    }
+
+    assert(Owner.size() == OwnedPTS.size());
+
+    if (auto It = OwnedPTS.find(PTS); It != OwnedPTS.end()) {
+      auto Idx = It->second;
+
+      OwnedPTS[Owner.back().get()] = Idx;
+      OwnedPTS.erase(PTS);
+
+      std::swap(Owner[Idx], Owner.back());
+      Owner.pop_back();
+    }
+  }
+
+private:
+  std::vector<std::unique_ptr<PointsToSetTy>> Owner;
+  llvm::DenseMap<PointsToSetTy *, size_t> OwnedPTS;
+};
+} // namespace psr
+
+#endif // PHASAR_PHASARLLVM_POINTER_POINTSTOSETOWNER_H_
diff --git a/lib/DB/ProjectIRDB.cpp b/lib/DB/ProjectIRDB.cpp
@@ -231,6 +231,14 @@ llvm::Module *ProjectIRDB::getModule(const std::string &ModuleName) {
   return nullptr;
 }
 
+std::size_t ProjectIRDB::getNumGlobals() const {
+  std::size_t Ret = 0;
+  for (const auto &[File, Module] : Modules) {
+    Ret += Module->global_size();
+  }
+  return Ret;
+}
+
 llvm::Instruction *ProjectIRDB::getInstruction(std::size_t Id) {
   if (IDInstructionMapping.count(Id)) {
     return IDInstructionMapping[Id];
diff --git a/lib/PhasarLLVM/Pointer/LLVMPointsToGraph.cpp b/lib/PhasarLLVM/Pointer/LLVMPointsToGraph.cpp
@@ -267,9 +267,9 @@ AliasResult LLVMPointsToGraph::alias(const llvm::Value *V1,
 auto LLVMPointsToGraph::getReachableAllocationSites(const llvm::Value *V,
                                                     bool IntraProcOnly,
                                                     const llvm::Instruction *I)
-    -> PointsToSetPtrTy {
+    -> AllocationSiteSetPtrTy {
   computePointsToGraph(V);
-  auto AllocSites = std::make_shared<PointsToSetTy>();
+  auto AllocSites = std::make_unique<PointsToSetTy>();
   AllocationSiteDFSVisitor AllocVis(*AllocSites, {});
   vector<boost::default_color_type> ColorMap(boost::num_vertices(PAG));
   boost::depth_first_visit(
@@ -378,7 +378,7 @@ auto LLVMPointsToGraph::getPointsToSet(const llvm::Value *V,
   PAMM_GET_INSTANCE;
   INC_COUNTER("[Calls] getPointsToSet", 1, PAMM_SEVERITY_LEVEL::Full);
   START_TIMER("PointsTo-Set Computation", PAMM_SEVERITY_LEVEL::Full);
-  auto *VF = retrieveFunction(V);
+  const auto *VF = retrieveFunction(V);
   computePointsToGraph(VF);
   // check if the graph contains a corresponding vertex
   set<vertex_t> ReachableVertices;
@@ -388,7 +388,16 @@ auto LLVMPointsToGraph::getPointsToSet(const llvm::Value *V,
       PAG, ValueVertexMap.at(V), Vis,
       boost::make_iterator_property_map(
           ColorMap.begin(), boost::get(boost::vertex_index, PAG), ColorMap[0]));
-  auto ResultSet = std::make_shared<PointsToSetTy>();
+  auto *ResultSet = [this, V] {
+    auto &Ret = Cache[V];
+
+    if (!Ret) {
+      Ret = Owner.acquire();
+    }
+
+    return Ret;
+  }();
+
   for (auto Vertex : ReachableVertices) {
     ResultSet->insert(PAG[Vertex].V);
   }
diff --git a/lib/PhasarLLVM/Pointer/LLVMPointsToSet.cpp b/lib/PhasarLLVM/Pointer/LLVMPointsToSet.cpp
@@ -51,7 +51,7 @@ namespace psr {
 
 LLVMPointsToSet::LLVMPointsToSet(ProjectIRDB &IRDB, bool UseLazyEvaluation,
                                  PointerAnalysisType PATy)
-    : PTA(IRDB, UseLazyEvaluation, PATy) {
+    : PTA(IRDB, UseLazyEvaluation, PATy), Owner(IRDB.getNumGlobals()) {
   for (llvm::Module *M : IRDB.getAllModules()) {
     // compute points-to information for all globals
 
@@ -122,7 +122,8 @@ auto LLVMPointsToSet::addSingletonPointsToSet(const llvm::Value *V)
   auto &PTS = PointsToSets[V];
 
   if (!PTS) {
-    PTS = std::make_shared<PointsToSetTy>(PointsToSetTy{V});
+    PTS = Owner.acquire();
+    PTS->insert(V);
   }
 
   assert(PTS->count(V));
@@ -144,9 +145,9 @@ void LLVMPointsToSet::mergePointsToSets(const llvm::Value *V1,
   mergePointsToSets(SearchV1->second, SearchV2->second);
 }
 
-auto LLVMPointsToSet::mergePointsToSets(const PointsToSetPtrTy &PTS1,
-                                        const PointsToSetPtrTy &PTS2)
-    -> PointsToSetPtrTy {
+auto LLVMPointsToSet::mergePointsToSets(PointsToSetTy *PTS1,
+                                        PointsToSetTy *PTS2)
+    -> PointsToSetTy * {
   if (PTS1 == PTS2) {
     return PTS1;
   }
@@ -167,12 +168,11 @@ auto LLVMPointsToSet::mergePointsToSets(const PointsToSetPtrTy &PTS1,
   }
 
   // add smaller set to larger one and get rid of the smaller set
-  // LargerSet->merge(*SmallerSet);
   LargerSet->reserve(LargerSet->size() + SmallerSet->size());
   LargerSet->insert(SmallerSet->begin(), SmallerSet->end());
-  SmallerSet->clear();
 
-  // assert(SmallerSet->empty() && "Expect the points-to-sets to be disjoint");
+  SmallerSet->clear();
+  Owner.release(SmallerSet);
 
   return LargerSet;
 }
@@ -474,8 +474,8 @@ LLVMPointsToSet::alias(const llvm::Value *V1, const llvm::Value *V2,
 }
 
 auto LLVMPointsToSet::getEmptyPointsToSet() -> PointsToSetPtrTy {
-  static auto EmptySet = std::make_shared<PointsToSetTy>();
-  return EmptySet;
+  static PointsToSetTy EmptySet{};
+  return &EmptySet;
 }
 
 auto LLVMPointsToSet::getPointsToSet(
@@ -497,13 +497,16 @@ auto LLVMPointsToSet::getPointsToSet(
 
 auto LLVMPointsToSet::getReachableAllocationSites(
     const llvm::Value *V, bool IntraProcOnly,
-    [[maybe_unused]] const llvm::Instruction *I) -> PointsToSetPtrTy {
+    [[maybe_unused]] const llvm::Instruction *I) -> AllocationSiteSetPtrTy {
+
+  auto AllocSites = std::make_unique<PointsToSetTy>();
+
   // if V is not a (interesting) pointer we can return an empty set
   if (!isInterestingPointer(V)) {
-    return getEmptyPointsToSet();
+    return AllocSites;
   }
   computeValuesPointsToSet(V);
-  auto AllocSites = std::make_shared<PointsToSetTy>();
+
   const auto PTS = PointsToSets[V];
   // consider the full inter-procedural points-to/alias information
   if (!IntraProcOnly) {
@@ -587,7 +590,9 @@ void LLVMPointsToSet::mergeWith(const PointsToInfo &PTI) {
     // if none of the pointers of a set of other is known in this, we need to
     // perform a copy
     if (!FoundElemPtr) {
-      PointsToSets.insert({KeyPtr, std::make_shared<PointsToSetTy>(*Set)});
+      auto *PTS = Owner.acquire();
+      *PTS = *Set;
+      PointsToSets.try_emplace(KeyPtr, PTS);
     }
   }
 }

Original file line number	Diff line number	Diff line change
`@@ -172,6 +172,8 @@ class ProjectIRDB {`
`172`	`172`	`return IDInstructionMapping.size();`
`173`	`173`	`}`
`174`	`174`
	`175`	`+ [[nodiscard]] std::size_t getNumGlobals() const;`
	`176`	`+`
`175`	`177`	`[[nodiscard]] llvm::Instruction *getInstruction(std::size_t Id);`
`176`	`178`
`177`	`179`	`[[nodiscard]] static std::size_t getInstructionID(const llvm::Instruction *I);`