[llvm-commits] CVS: llvm/include/llvm/Use.h Value.h
Chris Lattner
lattner at cs.uiuc.edu
Mon Jan 31 17:22:34 PST 2005
Changes in directory llvm/include/llvm:
Use.h updated: 1.10 -> 1.11
Value.h updated: 1.68 -> 1.69
---
Log message:
Switch from using an ilist for uses to using a custom doubly linked list.
This list does not provide the ability to go backwards in the list (its
more of an unordered collection, stored in the shape of a list).
This change means that use iterators are now only forward iterators, not
bidirectional.
This improves the memory usage of use lists from '5 + 4*#use' per value to
'1 + 4*#use'. While it would be better to reduce the multiplied factor,
I'm not smart enough to do so. This list also has slightly more efficient
operators for manipulating list nodes (a few less loads/stores), due to not
needing to be able to iterate backwards through the list.
This change reduces the memory footprint required to hold 176.gcc from
66.025M -> 57.687M, a 14% reduction. It also speeds up the compiler,
7.73% in the case of bytecode loading alone (release build loading 176.gcc).
---
Diffs of the changes: (+75 -109)
Use.h | 132 ++++++++++++++++++++++++----------------------------------------
Value.h | 52 +++++++++++--------------
2 files changed, 75 insertions(+), 109 deletions(-)
Index: llvm/include/llvm/Use.h
diff -u llvm/include/llvm/Use.h:1.10 llvm/include/llvm/Use.h:1.11
--- llvm/include/llvm/Use.h:1.10 Sat Jan 29 18:08:26 2005
+++ llvm/include/llvm/Use.h Mon Jan 31 19:21:51 2005
@@ -16,11 +16,11 @@
#ifndef LLVM_USE_H
#define LLVM_USE_H
-#include "llvm/ADT/ilist"
+#include "llvm/Support/Casting.h"
+#include "llvm/ADT/iterator"
namespace llvm {
-template<typename NodeTy> struct ilist_traits;
class Value;
class User;
@@ -62,43 +62,28 @@
Value *operator->() { return Val; }
const Value *operator->() const { return Val; }
+ Use *getNext() const { return Next; }
private:
- // NOTE!! The Next/Prev fields MUST stay at the start of this structure. The
- // end-token for the ilist is allocated as JUST the next/prev pair to reduce
- // memory usage instead of allocating an entire Use.
- struct NextPrevPtrs {
- Use *Next, *Prev;
- } UseLinks;
-
+ Use *Next, **Prev;
Value *Val;
User *U;
- friend struct ilist_traits<Use>;
-};
-template<>
-struct ilist_traits<Use> {
- static Use *getPrev(Use *N) { return N->UseLinks.Prev; }
- static Use *getNext(Use *N) { return N->UseLinks.Next; }
- static const Use *getPrev(const Use *N) { return N->UseLinks.Prev; }
- static const Use *getNext(const Use *N) { return N->UseLinks.Next; }
- static void setPrev(Use *N, Use *Prev) { N->UseLinks.Prev = Prev; }
- static void setNext(Use *N, Use *Next) { N->UseLinks.Next = Next; }
-
- /// createSentinel - this is used to create the end marker for the use list.
- /// Note that we only allocate a UseLinks structure, which is just enough to
- /// hold the next/prev pointers. This saves us 8 bytes of memory for every
- /// Value allocated.
- static Use *createSentinel() { return (Use*)new Use::NextPrevPtrs(); }
- static void destroySentinel(Use *S) { delete (Use::NextPrevPtrs*)S; }
-
- void addNodeToList(Use *NTy) {}
- void removeNodeFromList(Use *NTy) {}
- void transferNodesFromList(iplist<Use, ilist_traits> &L2,
- ilist_iterator<Use> first,
- ilist_iterator<Use> last) {}
-};
+ void addToList(Use **List) {
+ Next = *List;
+ if (Next) Next->Prev = &Next;
+ Prev = List;
+ *List = this;
+ }
+ void removeFromList() {
+ *Prev = Next;
+ if (Next) Next->Prev = Prev;
+ }
+ friend class Value;
+};
+// simplify_type - Allow clients to treat uses just like values when using
+// casting operators.
template<> struct simplify_type<Use> {
typedef Value* SimpleType;
static SimpleType getSimplifiedValue(const Use &Val) {
@@ -112,64 +97,49 @@
}
};
-struct UseListIteratorWrapper : public iplist<Use>::iterator {
- typedef iplist<Use>::iterator Super;
- UseListIteratorWrapper() {}
- UseListIteratorWrapper(const Super &RHS) : Super(RHS) {}
- UseListIteratorWrapper &operator=(const Super &RHS) {
- Super::operator=(RHS);
- return *this;
- }
- inline User *operator*() const;
- User *operator->() const { return operator*(); }
+template<typename UserTy> // UserTy == 'User' or 'const User'
+class value_use_iterator : public forward_iterator<UserTy*, ptrdiff_t> {
+ typedef forward_iterator<UserTy*, ptrdiff_t> super;
+ typedef value_use_iterator<UserTy> _Self;
+
+ Use *U;
+ value_use_iterator(Use *u) : U(u) {}
+ friend class Value;
+public:
+ typedef typename super::reference reference;
+ typedef typename super::pointer pointer;
- UseListIteratorWrapper operator--() { return Super::operator--(); }
- UseListIteratorWrapper operator++() { return Super::operator++(); }
+ value_use_iterator(const _Self &I) : U(I.U) {}
+ value_use_iterator() {}
- UseListIteratorWrapper operator--(int) { // postdecrement operators...
- UseListIteratorWrapper tmp = *this;
- --*this;
- return tmp;
- }
- UseListIteratorWrapper operator++(int) { // postincrement operators...
- UseListIteratorWrapper tmp = *this;
- ++*this;
- return tmp;
+ bool operator==(const _Self &x) const {
+ return U == x.U;
+ }
+ bool operator!=(const _Self &x) const {
+ return !operator==(x);
}
-};
-
-struct UseListConstIteratorWrapper : public iplist<Use>::const_iterator {
- typedef iplist<Use>::const_iterator Super;
- UseListConstIteratorWrapper() {}
- UseListConstIteratorWrapper(const Super &RHS) : Super(RHS) {}
-
- // Allow conversion from non-const to const iterators
- UseListConstIteratorWrapper(const UseListIteratorWrapper &RHS) : Super(RHS) {}
- UseListConstIteratorWrapper(const iplist<Use>::iterator &RHS) : Super(RHS) {}
- UseListConstIteratorWrapper &operator=(const Super &RHS) {
- Super::operator=(RHS);
- return *this;
+ // Iterator traversal: forward iteration only
+ _Self &operator++() { // Preincrement
+ assert(U && "Cannot increment end iterator!");
+ U = U->getNext();
+ return *this;
+ }
+ _Self operator++(int) { // Postincrement
+ _Self tmp = *this; ++*this; return tmp;
}
- inline const User *operator*() const;
- const User *operator->() const { return operator*(); }
+ // Retrieve a reference to the current SCC
+ UserTy *operator*() const {
+ assert(U && "Cannot increment end iterator!");
+ return U->getUser();
+ }
- UseListConstIteratorWrapper operator--() { return Super::operator--(); }
- UseListConstIteratorWrapper operator++() { return Super::operator++(); }
+ UserTy *operator->() const { return operator*(); }
- UseListConstIteratorWrapper operator--(int) { // postdecrement operators...
- UseListConstIteratorWrapper tmp = *this;
- --*this;
- return tmp;
- }
- UseListConstIteratorWrapper operator++(int) { // postincrement operators...
- UseListConstIteratorWrapper tmp = *this;
- ++*this;
- return tmp;
- }
+ Use &getUse() const { return *U; }
};
} // End llvm namespace
Index: llvm/include/llvm/Value.h
diff -u llvm/include/llvm/Value.h:1.68 llvm/include/llvm/Value.h:1.69
--- llvm/include/llvm/Value.h:1.68 Fri Jan 28 18:30:42 2005
+++ llvm/include/llvm/Value.h Mon Jan 31 19:21:51 2005
@@ -43,7 +43,7 @@
class Value {
unsigned SubclassID; // Subclass identifier (for isa/dyn_cast)
PATypeHolder Ty;
- iplist<Use> Uses;
+ Use *UseList;
std::string Name;
void operator=(const Value &); // Do not implement
@@ -86,33 +86,39 @@
//----------------------------------------------------------------------
// Methods for handling the vector of uses of this Value.
//
- typedef UseListIteratorWrapper use_iterator;
- typedef UseListConstIteratorWrapper use_const_iterator;
- typedef iplist<Use>::size_type size_type;
-
- size_type use_size() const { return Uses.size(); }
- bool use_empty() const { return Uses.empty(); }
- use_iterator use_begin() { return Uses.begin(); }
- use_const_iterator use_begin() const { return Uses.begin(); }
- use_iterator use_end() { return Uses.end(); }
- use_const_iterator use_end() const { return Uses.end(); }
- User *use_back() { return Uses.back().getUser(); }
- const User *use_back() const { return Uses.back().getUser(); }
+ typedef value_use_iterator<User> use_iterator;
+ typedef value_use_iterator<const User> use_const_iterator;
+
+ bool use_empty() const { return UseList == 0; }
+ use_iterator use_begin() { return use_iterator(UseList); }
+ use_const_iterator use_begin() const { return use_const_iterator(UseList); }
+ use_iterator use_end() { return use_iterator(0); }
+ use_const_iterator use_end() const { return use_const_iterator(0); }
+ User *use_back() { return *use_begin(); }
+ const User *use_back() const { return *use_begin(); }
/// hasOneUse - Return true if there is exactly one user of this value. This
/// is specialized because it is a common request and does not require
/// traversing the whole use list.
///
bool hasOneUse() const {
- iplist<Use>::const_iterator I = Uses.begin(), E = Uses.end();
+ use_const_iterator I = use_begin(), E = use_end();
if (I == E) return false;
return ++I == E;
}
+ /// hasNUses - Return true if this Value has exactly N users.
+ ///
+ bool hasNUses(unsigned N) const;
+
+ /// getNumUses - This method computes the number of uses of this Value. This
+ /// is a linear time operation. Use hasOneUse or hasNUses to check for
+ /// specific values.
+ unsigned getNumUses() const;
+
/// addUse/killUse - These two methods should only be used by the Use class.
///
- void addUse(Use &U) { Uses.push_back(&U); }
- void killUse(Use &U) { Uses.remove(&U); }
+ void addUse(Use &U) { U.addToList(&UseList); }
/// getValueType - Return an ID for the concrete type of this object. This is
/// used to implement the classof checks. This should not be used for any
@@ -157,16 +163,6 @@
return OS;
}
-
-inline User *UseListIteratorWrapper::operator*() const {
- return Super::operator*().getUser();
-}
-
-inline const User *UseListConstIteratorWrapper::operator*() const {
- return Super::operator*().getUser();
-}
-
-
void Use::init(Value *v, User *user) {
Val = v;
U = user;
@@ -174,11 +170,11 @@
}
Use::~Use() {
- if (Val) Val->killUse(*this);
+ if (Val) removeFromList();
}
void Use::set(Value *V) {
- if (Val) Val->killUse(*this);
+ if (Val) removeFromList();
Val = V;
if (V) V->addUse(*this);
}
More information about the llvm-commits
mailing list