Code Cleanup.

Removed inverted flag form MaximumSpanningTree, also do not handle so much
information to MaximumSpanningTree.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@80911 91177308-0d34-0410-b5e6-96231b3b80d8

diff --git a/lib/Transforms/Instrumentation/MaximumSpanningTree.cpp b/lib/Transforms/Instrumentation/MaximumSpanningTree.cpp
index ffd100e0533ab3ac538e029e47084a1c55395bd9..19c4a83f76bcfacc35edc2fcf71c92959822e5eb 100644 (file)
--- a/lib/Transforms/Instrumentation/MaximumSpanningTree.cpp
+++ b/lib/Transforms/Instrumentation/MaximumSpanningTree.cpp
@@ -14,8 +14,6 @@
 //===----------------------------------------------------------------------===//
 #define DEBUG_TYPE "maximum-spanning-tree"
 #include "MaximumSpanningTree.h"
-#include "llvm/Pass.h"
-#include "llvm/Analysis/Passes.h"
 #include "llvm/ADT/EquivalenceClasses.h"
 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/CFG.h"
@@ -64,12 +62,9 @@ static void inline printMSTEdge(ProfileInfo::EdgeWeight E,
 // MaximumSpanningTree() - Takes a function and returns a spanning tree
 // according to the currently active profiling information, the leaf edges are
 // NOT in the MST. MaximumSpanningTree uses the algorithm of Kruskal.
-MaximumSpanningTree::MaximumSpanningTree(Function *F, ProfileInfo *PI,
-                                         bool inverted = false) {
+MaximumSpanningTree::MaximumSpanningTree(std::vector<ProfileInfo::EdgeWeight>
+                                         &EdgeVector) {
 
-  // Copy edges to vector, sort them biggest first.
-  ProfileInfo::EdgeWeights ECs = PI->getEdgeWeights(F);
-  std::vector<ProfileInfo::EdgeWeight> EdgeVector(ECs.begin(), ECs.end());
   std::sort(EdgeVector.begin(), EdgeVector.end(), EdgeWeightCompare());
 
   // Create spanning tree, Forest contains a special data structure
@@ -92,12 +87,11 @@ MaximumSpanningTree::MaximumSpanningTree(Function *F, ProfileInfo *PI,
       Forest.unionSets(e.first, e.second);
       // So we know now that the edge is not already in a subtree (and not
       // (0,entry)), so we push the edge to the MST if it has some successors.
-      if (!inverted) { MST.push_back(e); }
+      MST.push_back(e);
       printMSTEdge(*bbi,"in MST");
     } else {
       // This edge is either (0,entry) or (BB,0) or would create a circle in a
       // subtree.
-      if (inverted) { MST.push_back(e); }
       printMSTEdge(*bbi,"*not* in MST");
     }
   }

diff --git a/lib/Transforms/Instrumentation/MaximumSpanningTree.h b/lib/Transforms/Instrumentation/MaximumSpanningTree.h
index 5ef8659fe2d733b4301f46ab9211ecdccc901214..2343985f23d43d7d8539d804c8645acfaf3aae79 100644 (file)
--- a/lib/Transforms/Instrumentation/MaximumSpanningTree.h
+++ b/lib/Transforms/Instrumentation/MaximumSpanningTree.h
@@ -37,7 +37,7 @@ namespace llvm {
     // special also all leaf edges of the MST are not included, this makes it
     // easier for the OptimalEdgeProfileInstrumentation to use this MST to do
     // an optimal profiling.
-    MaximumSpanningTree(Function *F, ProfileInfo *PI, bool invert);
+    MaximumSpanningTree(std::vector<ProfileInfo::EdgeWeight>&);
     virtual ~MaximumSpanningTree() {}
 
     virtual MaxSpanTree::iterator begin();

diff --git a/lib/Transforms/Instrumentation/OptimalEdgeProfiling.cpp b/lib/Transforms/Instrumentation/OptimalEdgeProfiling.cpp
index 0ba93338bc85a4929964a4fb3ad9d946ad1a212e..2c0642387235ffb683d2a5f8491498d53364623c 100644 (file)
--- a/lib/Transforms/Instrumentation/OptimalEdgeProfiling.cpp
+++ b/lib/Transforms/Instrumentation/OptimalEdgeProfiling.cpp
@@ -22,6 +22,7 @@
 #include "llvm/Support/Debug.h"
 #include "llvm/Transforms/Utils/BasicBlockUtils.h"
 #include "llvm/Transforms/Instrumentation.h"
+#include "llvm/ADT/DenseSet.h"
 #include "llvm/ADT/Statistic.h"
 #include "MaximumSpanningTree.h"
 #include <set>
@@ -32,7 +33,6 @@ STATISTIC(NumEdgesInserted, "The # of edges inserted.");
 namespace {
   class VISIBILITY_HIDDEN OptimalEdgeProfiler : public ModulePass {
     bool runOnModule(Module &M);
-    ProfileInfo *PI;
   public:
     static char ID; // Pass identification, replacement for typeid
     OptimalEdgeProfiler() : ModulePass(&ID) {}
@@ -128,8 +128,10 @@ bool OptimalEdgeProfiler::runOnModule(Module &M) {
     // The third parameter of MaximumSpanningTree() has the effect that not the
     // actual MST is returned but the edges _not_ in the MST.
 
-    PI = &getAnalysisID<ProfileInfo>(ProfileEstimatorPassID, *F);
-    MaximumSpanningTree MST = MaximumSpanningTree(&(*F), PI, true);
+    ProfileInfo::EdgeWeights ECs = 
+      getAnalysisID<ProfileInfo>(ProfileEstimatorPassID, *F).getEdgeWeights(F);
+    std::vector<ProfileInfo::EdgeWeight> EdgeVector(ECs.begin(), ECs.end());
+    MaximumSpanningTree MST = MaximumSpanningTree(EdgeVector);
 
     // Check if (0,entry) not in the MST. If not, instrument edge
     // (IncrementCounterInBlock()) and set the counter initially to zero, if
@@ -137,7 +139,7 @@ bool OptimalEdgeProfiler::runOnModule(Module &M) {
 
     BasicBlock *entry = &(F->getEntryBlock());
     ProfileInfo::Edge edge = ProfileInfo::getEdge(0,entry);
-    if (std::binary_search(MST.begin(), MST.end(), edge)) {
+    if (!std::binary_search(MST.begin(), MST.end(), edge)) {
       printEdgeCounter(edge,entry,i);
       IncrementCounterInBlock(entry, i, Counters); NumEdgesInserted++;
       Initializer[i++] = (zeroc);
@@ -147,7 +149,7 @@ bool OptimalEdgeProfiler::runOnModule(Module &M) {
 
     // InsertedBlocks contains all blocks that were inserted for splitting an
     // edge, this blocks do not have to be instrumented.
-    std::set<BasicBlock*> InsertedBlocks;
+    DenseSet<BasicBlock*> InsertedBlocks;
     for (Function::iterator BB = F->begin(), E = F->end(); BB != E; ++BB) {
       // Check if block was not inserted and thus does not have to be
       // instrumented.
@@ -160,7 +162,7 @@ bool OptimalEdgeProfiler::runOnModule(Module &M) {
       TerminatorInst *TI = BB->getTerminator();
       if (TI->getNumSuccessors() == 0) {
         ProfileInfo::Edge edge = ProfileInfo::getEdge(BB,0);
-        if (std::binary_search(MST.begin(), MST.end(), edge)) {
+        if (!std::binary_search(MST.begin(), MST.end(), edge)) {
           printEdgeCounter(edge,BB,i);
           IncrementCounterInBlock(BB, i, Counters); NumEdgesInserted++;
           Initializer[i++] = (zeroc);
@@ -171,12 +173,12 @@ bool OptimalEdgeProfiler::runOnModule(Module &M) {
       for (unsigned s = 0, e = TI->getNumSuccessors(); s != e; ++s) {
         BasicBlock *Succ = TI->getSuccessor(s);
         ProfileInfo::Edge edge = ProfileInfo::getEdge(BB,Succ);
-        if (std::binary_search(MST.begin(), MST.end(), edge)) {
+        if (!std::binary_search(MST.begin(), MST.end(), edge)) {
 
           // If the edge is critical, split it.
           bool wasInserted = SplitCriticalEdge(TI, s, this);
           Succ = TI->getSuccessor(s);
-          if(wasInserted)
+          if (wasInserted)
             InsertedBlocks.insert(Succ);
 
           // Okay, we are guaranteed that the edge is no longer critical.  If