[llvm-commits] [llvm] r49380 - in /llvm/branches/ggreif/use-diet: include/llvm/Use.h include/llvm/User.h lib/VMCore/Use.cpp
Gabor Greif
ggreif at gmail.com
Tue Apr 8 06:35:26 PDT 2008
Author: ggreif
Date: Tue Apr 8 08:35:24 2008
New Revision: 49380
URL: http://llvm.org/viewvc/llvm-project?rev=49380&view=rev
Log:
re-merge using <svn merge -r48837:49377 https://...> to pick up changes on the old branch
Added:
llvm/branches/ggreif/use-diet/lib/VMCore/Use.cpp
- copied unchanged from r49377, llvm/branches/ggreif/use-diet/lib/VMCore/Use.cpp
Modified:
llvm/branches/ggreif/use-diet/include/llvm/Use.h
llvm/branches/ggreif/use-diet/include/llvm/User.h
Modified: llvm/branches/ggreif/use-diet/include/llvm/Use.h
URL: http://llvm.org/viewvc/llvm-project/llvm/branches/ggreif/use-diet/include/llvm/Use.h?rev=49380&r1=49379&r2=49380&view=diff
==============================================================================
--- llvm/branches/ggreif/use-diet/include/llvm/Use.h (original)
+++ llvm/branches/ggreif/use-diet/include/llvm/Use.h Tue Apr 8 08:35:24 2008
@@ -41,7 +41,7 @@
if (Val) removeFromList();
}
- /// Default ctor - This leaves the Use completely unitialized. The only thing
+ /// Default ctor - This leaves the Use completely uninitialized. The only thing
/// that is valid to do with this use is to call the "init" method.
inline Use() : Val(0) {}
@@ -49,6 +49,8 @@
operator Value*() const { return Val; }
Value *get() const { return Val; }
User *getUser() const { return U; }
+ const Use* getImpliedUser() const;
+ void initTags(Use *Start, Use *Stop, ptrdiff_t Done = 0);
inline void set(Value *Val);
Modified: llvm/branches/ggreif/use-diet/include/llvm/User.h
URL: http://llvm.org/viewvc/llvm-project/llvm/branches/ggreif/use-diet/include/llvm/User.h?rev=49380&r1=49379&r2=49380&view=diff
==============================================================================
--- llvm/branches/ggreif/use-diet/include/llvm/User.h (original)
+++ llvm/branches/ggreif/use-diet/include/llvm/User.h Tue Apr 8 08:35:24 2008
@@ -23,6 +23,171 @@
namespace llvm {
+/*==============================================================================
+
+
+ -----------------------------------------------------------------
+ --- Interaction and relationship between User and Use objects ---
+ -----------------------------------------------------------------
+
+
+A subclass of User can choose between incorporating its Use objects
+or refer to them out-of-line by means of a pointer. A mixed variant
+(some Uses inline others hung off) is impractical and breaks the invariant
+that the Use objects belonging to the same User form a contiguous array.
+
+We have 2 different layouts in the User (sub)classes:
+
+Layout a)
+The Use object(s) are inside (resp. at fixed offset) of the User
+object and there are a fixed number of them.
+
+Layout b)
+The Use object(s) are referenced by a pointer to an
+array from the User object and there may be a variable
+number of them.
+
+Initially each layout will possess a direct pointer to the
+start of the array of Uses. Though not mandatory for layout a),
+we stick to this redundancy for the sake of simplicity.
+The User object will also store the number of Use objects it
+has. (Theoretically this information can also be calculated
+given the scheme presented below.)
+
+Special forms of allocation operators (operator new)
+will enforce the following memory layouts:
+
+
+# Layout a) will be modelled by prepending the User object
+# by the Use[] array.
+#
+# ...---.---.---.---.-------...
+# | V | V | V | V | User
+# '''---'---'---'---'-------'''
+
+
+# Layout b) will be modelled by pointing at the Use[] array.
+#
+# .-------...
+# | User
+# '-------'''
+# |
+# v
+# .---.---.---.---...
+# | V | V | V | V |
+# '---'---'---'---'''
+
+ (In the above figures 'V' stands for the Value* that
+ is stored in each Use object)
+
+
+Since the Use objects will be deprived of the direct pointer to
+their User objects, there must be a fast and exact method to
+recover it. This is accomplished by the following scheme:
+
+A bit-encoding in the 2 LSBits of the Use::Val will allow to find the
+start of the User object:
+
+00 --> binary digit 0
+01 --> binary digit 1
+10 --> stop and calc (s)
+11 --> full stop (S)
+
+Given a Use*, all we have to do is to walk till we get
+a stop and we either have a User immediately behind or
+we have to walk to the next stop picking up digits
+and calculating the offset:
+
+.---.---.---.---.---.---.---.---.---.---.---.---.---.---.---.---.----------------
+| 1 | s | 1 | 0 | 1 | 0 | s | 1 | 1 | 0 | s | 1 | 1 | s | 1 | S | User (or User*)
+'---'---'---'---'---'---'---'---'---'---'---'---'---'---'---'---'----------------
+ |+15 |+10 |+6 |+3 |+1
+ | | | | |__>
+ | | | |__________>
+ | | |______________________>
+ | |______________________________________>
+ |__________________________________________________________>
+
+
+Only the significant number of bits need to be stored between the
+stops, so that the worst case is 21 memory accesses when there are
+1000 Use objects.
+
+The following literate Haskell fragment demonstrates the concept:
+
+> import Test.QuickCheck
+>
+> digits :: Int -> [Char] -> [Char]
+> digits 0 acc = '0' : acc
+> digits 1 acc = '1' : acc
+> digits n acc = digits (n `div` 2) $ digits (n `mod` 2) acc
+>
+> dist :: Int -> [Char] -> [Char]
+> dist 0 [] = ['S']
+> dist 0 acc = acc
+> dist 1 acc = let r = dist 0 acc in 's' : digits (length r) r
+> dist n acc = dist (n - 1) $ dist 1 acc
+>
+> takeLast n ss = reverse $ take n $ reverse ss
+>
+> test = takeLast 40 $ dist 20 []
+>
+
+Printing <test> gives: "1s100000s11010s10100s1111s1010s110s11s1S"
+
+The reverse algorithm computes the
+length of the string just by examining
+a certain prefix:
+
+> pref :: [Char] -> Int
+> pref "S" = 1
+> pref ('s':rest) = decode 1 0 rest
+> pref (_:rest) = 1 + pref rest
+>
+> decode walk acc ('0':rest) = decode (walk + 1) (acc * 2) rest
+> decode walk acc ('1':rest) = decode (walk + 1) (acc * 2 + 1) rest
+> decode walk acc _ = walk + acc
+>
+
+Now, as expected, printing <pref test> gives 40.
+
+We can quickCheck this with following property:
+
+> testcase = dist 2000 []
+> testcaseLength = length testcase
+>
+> identityProp n = n > 0 && n <= testcaseLength ==> length arr == pref arr
+> where arr = takeLast n testcase
+
+As expected <quickCheck identityProp> gives:
+
+*Main> quickCheck identityProp
+OK, passed 100 tests.
+
+Let's be a bit more exhaustive:
+
+>
+> deepCheck p = check (defaultConfig { configMaxTest = 500 }) p
+>
+
+And here is the result of <deepCheck identityProp>:
+
+*Main> deepCheck identityProp
+OK, passed 500 tests.
+
+
+To maintain the invariant that the 2 LSBits of each Value* in Use
+never change after being set up, setters of Use::Val must re-tag the
+new Value* on every modification. Accordingly getters must strip the
+tag bits.
+
+For layout b) instead of the User we will find a pointer (with LSBit set).
+Following this pointer brings us to the User. A portable trick will ensure
+that the first bytes of User (if interpreted as a pointer) will never have
+the LSBit set.
+
+==============================================================================*/
+
class User : public Value {
User(const User &); // Do not implement
void *operator new(size_t); // Do not implement
More information about the llvm-commits
mailing list