[llvm-commits] CVS: llvm/lib/Bytecode/Writer/SlotCalculator.cpp SlotCalculator.h

[Chris Lattner]

Changes in directory llvm/lib/Bytecode/Writer:

SlotCalculator.cpp updated: 1.104 -> 1.105
SlotCalculator.h updated: 1.44 -> 1.45
---
Log message:

Make the ModuleLevel datastructure more sane.  When a function-local value
is inserted into the table, it remembers that the value needs to be popped
off.  This makes purgeFunction much faster, speeding up bcwriting of 447.dealII
from 6.8->4.6s (47%).


---
Diffs of the changes:  (+19 -33)

 SlotCalculator.cpp |   41 ++++++++++++++++++-----------------------
 SlotCalculator.h   |   11 +----------
 2 files changed, 19 insertions(+), 33 deletions(-)


Index: llvm/lib/Bytecode/Writer/SlotCalculator.cpp
diff -u llvm/lib/Bytecode/Writer/SlotCalculator.cpp:1.104 llvm/lib/Bytecode/Writer/SlotCalculator.cpp:1.105
--- llvm/lib/Bytecode/Writer/SlotCalculator.cpp:1.104	Fri Feb  9 23:54:33 2007
+++ llvm/lib/Bytecode/Writer/SlotCalculator.cpp	Sat Feb 10 00:09:41 2007
@@ -64,7 +64,6 @@
 
 SlotCalculator::SlotCalculator(const Module *M) {
   assert(M);
-  ModuleTypeLevel = 0;
   TheModule = M;
 
   insertPrimitives();
@@ -182,11 +181,8 @@
   }
 
     
-  // Compute the ModuleLevel entries.
-  ModuleLevel.resize(getNumPlanes());
-  for (unsigned i = 0, e = getNumPlanes(); i != e; ++i)
-    ModuleLevel[i] = getPlane(i).size();
-  ModuleTypeLevel = Types.size();
+  // Initialize the ModuleLevel entries.
+  ModuleLevel.resize(getNumPlanes(), -1);
     
   SC_DEBUG("end processModule!\n");
 }
@@ -222,9 +218,6 @@
       // Do not index the characters that make up constant strings.  We emit
       // constant strings as special entities that don't require their
       // individual characters to be emitted.
-      assert(ModuleLevel.empty() &&
-             "How can a constant string be directly accessed in a function?");
-      // Otherwise, this IS a string: remember it.
       if (!C->isNullValue())
         ConstantStrings.push_back(cast<ConstantArray>(C));
     } else {
@@ -313,16 +306,16 @@
   
   // Next, remove values from existing type planes
   for (unsigned i = 0; i != NumModuleTypes; ++i) {
-    // Size of plane before function came
-    unsigned ModuleLev = getModuleLevel(i);
-    assert(int(ModuleLev) >= 0 && "BAD!");
+    // If this type is not used by this function, ignore it.
+    int ModuleLev = ModuleLevel[i];
+    if (ModuleLev == -1) continue;
     
+    ModuleLevel[i] = -1;  // Reset for next function.
+
+    // Pop all function-local values in this type-plane off of Table.
     TypePlane &Plane = getPlane(i);
-    
-    assert(ModuleLev <= Plane.size() && "module levels higher than elements?");
-    while (Plane.size() != ModuleLev) {
-      assert(!isa<GlobalValue>(Plane.back()) &&
-             "Functions cannot define globals!");
+    assert(ModuleLev < Plane.size() && "module levels higher than elements?");
+    for (unsigned i = ModuleLev, e = Plane.size(); i != e; ++i) {
       NodeMap.erase(Plane.back());       // Erase from nodemap
       Plane.pop_back();                  // Shrink plane
     }
@@ -333,12 +326,8 @@
     TypePlane &Plane = Table.back();
     SC_DEBUG("Removing Plane " << (Table.size()-1) << " of size "
              << Plane.size() << "\n");
-    while (Plane.size()) {
-      assert(!isa<GlobalValue>(Plane.back()) &&
-             "Functions cannot define globals!");
-      NodeMap.erase(Plane.back());   // Erase from nodemap
-      Plane.pop_back();              // Shrink plane
-    }
+    for (unsigned i = 0, e = Plane.size(); i != e; ++i)
+      NodeMap.erase(Plane[i]);   // Erase from nodemap
     
     Table.pop_back();                // Nuke the plane, we don't like it.
   }
@@ -357,6 +346,12 @@
   if (Table.size() <= TyPlane)    // Make sure we have the type plane allocated.
     Table.resize(TyPlane+1, TypePlane());
   
+  // If this is the first value noticed of this type within this function,
+  // remember the module level for this type plane in ModuleLevel.  This reminds
+  // us to remove the values in purgeFunction and tells us how many to remove.
+  if (TyPlane < ModuleLevel.size() && ModuleLevel[TyPlane] == -1)
+    ModuleLevel[TyPlane] = Table[TyPlane].size();
+  
   // If this is the first value to get inserted into the type plane, make sure
   // to insert the implicit null value.
   if (Table[TyPlane].empty()) {


Index: llvm/lib/Bytecode/Writer/SlotCalculator.h
diff -u llvm/lib/Bytecode/Writer/SlotCalculator.h:1.44 llvm/lib/Bytecode/Writer/SlotCalculator.h:1.45
--- llvm/lib/Bytecode/Writer/SlotCalculator.h:1.44	Fri Feb  9 23:45:09 2007
+++ llvm/lib/Bytecode/Writer/SlotCalculator.h	Sat Feb 10 00:09:41 2007
@@ -54,7 +54,7 @@
   /// ModuleLevel - Used to keep track of which values belong to the module,
   /// and which values belong to the currently incorporated function.
   ///
-  std::vector<unsigned> ModuleLevel;
+  std::vector<int> ModuleLevel;
   unsigned ModuleTypeLevel;
 
   SlotCalculator(const SlotCalculator &);  // DO NOT IMPLEMENT
@@ -80,15 +80,6 @@
   inline unsigned getNumPlanes() const { return Table.size(); }
   inline unsigned getNumTypes() const { return Types.size(); }
 
-  inline unsigned getModuleLevel(unsigned Plane) const {
-    return Plane < ModuleLevel.size() ? ModuleLevel[Plane] : 0;
-  }
-
-  /// Returns the number of types in the type list that are at module level
-  inline unsigned getModuleTypeLevel() const {
-    return ModuleTypeLevel;
-  }
-
   TypePlane &getPlane(unsigned Plane) {
     // Okay we are just returning an entry out of the main Table.  Make sure the
     // plane exists and return it.