Optimize calls to get the Users for a a points-to vertex.

The call to Value->users() is quite expensive.  Because the result
should not change between executions, we can cache the results for each
Vertex of the points-to graph.  This has a significant performance
improvement.

This change also modifies the n^2 loop to be n^2/2 as described in the
comments -- the inner loop was previously starting at the beginning of
the map instead of at the next item in the map, and we can avoid looking
up in the map by using the appropriate iterators.  These changes did not
significantly impact performance, however the resulting code is more
concise.

Author: ddiepo-pjr

include/phasar/PhasarLLVM/Pointer/LLVMPointsToGraph.h

@@ -77,6 +77,10 @@ class PointsToGraph {
     VertexProperties() = default;
     VertexProperties(const llvm::Value *v);
     std::string getValueAsString() const;
+
+    // Fetching the users for V is expensive, so we cache the result.
+    mutable std::vector<const llvm::User*> users;
+    std::vector<const llvm::User*> getUsers() const;
   };
 
   /**
@@ -91,7 +95,7 @@ class PointsToGraph {
   };
 
   /// Data structure for holding the points-to graph.
-  typedef boost::adjacency_list<boost::setS, boost::vecS, boost::undirectedS,
+  typedef boost::adjacency_list<boost::vecS, boost::vecS, boost::undirectedS,
                                 VertexProperties, EdgeProperties>
       graph_t;
 

lib/PhasarLLVM/Pointer/LLVMPointsToGraph.cpp

@@ -123,6 +123,16 @@ std::string PointsToGraph::VertexProperties::getValueAsString() const {
   return llvmIRToString(V);
 }
 
+std::vector<const llvm::User*>
+PointsToGraph::VertexProperties::getUsers() const {
+  if (!users.empty() || V == nullptr) {
+    return users;
+  }
+  auto allUsers = V->users();
+  users.insert(users.end(), allUsers.begin(), allUsers.end());
+  return users;
+}
+
 PointsToGraph::EdgeProperties::EdgeProperties(const llvm::Value *V) : V(V) {}
 
 std::string PointsToGraph::EdgeProperties::getValueAsString() const {
@@ -189,43 +199,31 @@ PointsToGraph::PointsToGraph(llvm::Function *F, llvm::AAResults &AA) {
   INC_COUNTER("GS Pointer", Pointers.size(), PAMM_SEVERITY_LEVEL::Core);
 
   // make vertices for all pointers
-  for (auto Pointer : Pointers) {
-    ValueVertexMap[Pointer] = boost::add_vertex(VertexProperties(Pointer), PAG);
+  for (auto P : Pointers) {
+    ValueVertexMap[P] = boost::add_vertex(VertexProperties(P), PAG);
   }
   // iterate over the worklist, and run the full (n^2)/2 disambiguations
-  for (llvm::SetVector<llvm::Value *>::iterator I1 = Pointers.begin(),
-                                                E = Pointers.end();
-       I1 != E; ++I1) {
-    uint64_t I1Size = llvm::MemoryLocation::UnknownSize;
+  const auto mapEnd = ValueVertexMap.end();
+  for (auto I1 = ValueVertexMap.begin(); I1 != mapEnd; ++I1) {
     llvm::Type *I1ElTy =
-        llvm::cast<llvm::PointerType>((*I1)->getType())->getElementType();
-    if (I1ElTy->isSized()) {
-      I1Size = DL.getTypeStoreSize(I1ElTy);
-    }
-    for (llvm::SetVector<llvm::Value *>::iterator I2 = Pointers.begin();
-         I2 != I1; ++I2) {
-      uint64_t I2Size = llvm::MemoryLocation::UnknownSize;
+        llvm::cast<llvm::PointerType>(I1->first->getType())->getElementType();
+    const uint64_t I1Size = I1ElTy->isSized() ? DL.getTypeStoreSize(I1ElTy)
+        : llvm::MemoryLocation::UnknownSize;
+    for (auto I2 = std::next(I1); I2 != mapEnd; ++I2) {
       llvm::Type *I2ElTy =
-          llvm::cast<llvm::PointerType>((*I2)->getType())->getElementType();
-      if (I2ElTy->isSized()) {
-        I2Size = DL.getTypeStoreSize(I2ElTy);
-      }
-      switch (AA.alias(llvm::MemoryLocation(*I1, I1Size),
-                       llvm::MemoryLocation(*I2, I2Size))) {
+          llvm::cast<llvm::PointerType>(I2->first->getType())->getElementType();
+      const uint64_t I2Size = I2ElTy->isSized() ? DL.getTypeStoreSize(I2ElTy)
+          : llvm::MemoryLocation::UnknownSize;
+
+      switch (AA.alias(I1->first, I1Size, I2->first, I2Size)) {
       case llvm::NoAlias:
-        // NoAlias
-        break;
-      case llvm::MayAlias:
-        boost::add_edge(ValueVertexMap[*I1], ValueVertexMap[*I2], PAG);
-        break;
-      case llvm::PartialAlias:
-        boost::add_edge(ValueVertexMap[*I1], ValueVertexMap[*I2], PAG);
         break;
+      case llvm::MayAlias: // no break
+      case llvm::PartialAlias: // no break
       case llvm::MustAlias:
-        boost::add_edge(ValueVertexMap[*I1], ValueVertexMap[*I2], PAG);
+        boost::add_edge(I1->second, I2->second, PAG);
         break;
       default:
-        // do nothing
         break;
       }
     }
@@ -235,10 +233,9 @@ PointsToGraph::PointsToGraph(llvm::Function *F, llvm::AAResults &AA) {
 vector<pair<unsigned, const llvm::Value *>>
 PointsToGraph::getPointersEscapingThroughParams() {
   vector<pair<unsigned, const llvm::Value *>> escaping_pointers;
-  for (pair<vertex_iterator, vertex_iterator> vp = boost::vertices(PAG);
-       vp.first != vp.second; ++vp.first) {
+  for (auto vertexIter : boost::make_iterator_range(boost::vertices(PAG))) {
     if (const llvm::Argument *arg =
-            llvm::dyn_cast<llvm::Argument>(PAG[*vp.first].V)) {
+            llvm::dyn_cast<llvm::Argument>(PAG[vertexIter].V)) {
       escaping_pointers.push_back(make_pair(arg->getArgNo(), arg));
     }
   }
@@ -248,11 +245,11 @@ PointsToGraph::getPointersEscapingThroughParams() {
 vector<const llvm::Value *>
 PointsToGraph::getPointersEscapingThroughReturns() const {
   vector<const llvm::Value *> escaping_pointers;
-  for (pair<vertex_iterator, vertex_iterator> vp = boost::vertices(PAG);
-       vp.first != vp.second; ++vp.first) {
-    for (auto user : PAG[*vp.first].V->users()) {
+  for (auto vertexIter : boost::make_iterator_range(boost::vertices(PAG))) {
+    auto& vertex = PAG[vertexIter];
+    for (const auto user : vertex.getUsers()) {
       if (llvm::isa<llvm::ReturnInst>(user)) {
-        escaping_pointers.push_back(PAG[*vp.first].V);
+        escaping_pointers.push_back(vertex.V);
       }
     }
   }
@@ -263,12 +260,12 @@ vector<const llvm::Value *>
 PointsToGraph::getPointersEscapingThroughReturnsForFunction(
     const llvm::Function *F) const {
   vector<const llvm::Value *> escaping_pointers;
-  for (pair<vertex_iterator, vertex_iterator> vp = boost::vertices(PAG);
-       vp.first != vp.second; ++vp.first) {
-    for (auto user : PAG[*vp.first].V->users()) {
+  for (auto vertexIter : boost::make_iterator_range(boost::vertices(PAG))) {
+    auto& vertex = PAG[vertexIter];
+    for (const auto user : vertex.getUsers()) {
       if (auto R = llvm::dyn_cast<llvm::ReturnInst>(user)) {
         if (R->getFunction() == F)
-          escaping_pointers.push_back(PAG[*vp.first].V);
+          escaping_pointers.push_back(vertex.V);
       }
     }
   }
@@ -289,9 +286,8 @@ set<const llvm::Value *> PointsToGraph::getReachableAllocationSites(
 }
 
 bool PointsToGraph::containsValue(llvm::Value *V) {
-  pair<vertex_iterator, vertex_iterator> vp;
-  for (vp = boost::vertices(PAG); vp.first != vp.second; ++vp.first)
-    if (PAG[*vp.first].V == V)
+  for (auto vertexIter : boost::make_iterator_range(boost::vertices(PAG)))
+    if (PAG[vertexIter].V == V)
       return true;
   return false;
 }