mercurial-crew-with-dirclash: mercurial/revlog.py comparison

comparison mercurial/revlog.py @ 1677:11d12bd6e1dc

cleanup of revlog.group when repository is local revlog.group cached every chunk from the revlog, the behaviour was needed to minimize the roundtrip with old-http. The patch export the information that the repository is local or not from the repository object down to the revlog. Then it uses the workaround for old-http only if the repository is non-local. The memory used server side when pulling goes down to less than 30Mo maximum whereas without the patch more than 160Mo was used when cloning the linux kernel repository. The time used by cloning is roughly the same (although some caching could be implemented if needed): before 110.25user 20.90system 2:52.00elapsed 76%CPU (0avgtext+0avgdata 0maxresident)k 0inputs+0outputs (0major+708707minor)pagefaults 0swaps after 112.85user 22.98system 2:50.66elapsed 79%CPU (0avgtext+0avgdata 0maxresident)k 0inputs+0outputs (0major+862862minor)pagefaults 0swaps

author	Benoit Boissinot <benoit.boissinot@ens-lyon.org>
date	Thu, 08 Dec 2005 15:12:02 +0100
parents	59b3639df0a9
children	b345cc4c22c0

comparison

equal deleted inserted replaced

-:63799b01985c
+:11d12bd6e1dc
 Both pieces of the revlog are written to in an append-only
 fashion, which means we never need to rewrite a file to insert or
 remove data, and can use some simple techniques to avoid the need
 for locking while reading.
 """
-def __init__(self, opener, indexfile, datafile):
+def __init__(self, opener, indexfile, datafile, local=True):
 """
 create a revlog object
 opener is a function that abstracts the file opening operation
 and can be used to implement COW semantics or the like.
 """
 self.indexfile = indexfile
 self.datafile = datafile
 self.opener = opener
 self.cache = None
+self.local = local # XXX only needed because statichttp
 try:
 i = self.opener(self.indexfile).read()
 except IOError, inst:
 if inst.errno != errno.ENOENT:
 gy = y.next()
 else:
 #print "next x"
 gx = x.next()
-def group(self, nodelist, lookup, infocollect = None):
+def group(self, nodelist, lookup, infocollect=None):
 """calculate a delta group
 Given a list of changeset revs, return a set of deltas and
 metadata corresponding to nodes. the first delta is
 parent(nodes[0]) -> nodes[0] the receiver is guaranteed to
 have this parent as it has all history before these
 changesets. parent is parent[0]
 """
 revs = [self.rev(n) for n in nodelist]
-needed = dict.fromkeys(revs, 1)
 # if we don't have any revisions touched by these changesets, bail
 if not revs:
 yield struct.pack(">l", 0)
 return
 # add the parent of the first rev
 p = self.parents(self.node(revs[0]))[0]
 revs.insert(0, self.rev(p))
-# for each delta that isn't contiguous in the log, we need to
+if self.local:
-# reconstruct the base, reconstruct the result, and then
+mm = self.opener(self.datafile)
-# calculate the delta. We also need to do this where we've
+def chunk(r):
-# stored a full version and not a delta
+o = self.start(r)
-for i in xrange(0, len(revs) - 1):
+l = self.length(r)
-a, b = revs[i], revs[i + 1]
+mm.seek(o)
-if a + 1 != b or self.base(b) == b:
+return decompress(mm.read(l))
-for j in xrange(self.base(a), a + 1):
+else:
-needed[j] = 1
+# XXX: statichttp workaround
-for j in xrange(self.base(b), b + 1):
+needed = dict.fromkeys(revs[1:], 1)
-needed[j] = 1
+# for each delta that isn't contiguous in the log, we need to
+# reconstruct the base, reconstruct the result, and then
-# calculate spans to retrieve from datafile
+# calculate the delta. We also need to do this where we've
-needed = needed.keys()
+# stored a full version and not a delta
-needed.sort()
+for i in xrange(0, len(revs) - 1):
-spans = []
+a, b = revs[i], revs[i + 1]
-oo = -1
+if a + 1 != b or self.base(b) == b:
-ol = 0
+for j in xrange(self.base(a), a + 1):
-for n in needed:
+needed[j] = 1
-if n < 0: continue
+for j in xrange(self.base(b), b + 1):
-o = self.start(n)
+needed[j] = 1
-l = self.length(n)
-if oo + ol == o: # can we merge with the previous?
+# calculate spans to retrieve from datafile
-nl = spans[-1][2]
+needed = needed.keys()
-nl.append((n, l))
+needed.sort()
-ol += l
+spans = []
-spans[-1] = (oo, ol, nl)
+oo = -1
-else:
+ol = 0
-oo = o
+for n in needed:
-ol = l
+if n < 0: continue
-spans.append((oo, ol, [(n, l)]))
+o = self.start(n)
+l = self.length(n)
-# read spans in, divide up chunks
+if oo + ol == o: # can we merge with the previous?
-chunks = {}
+nl = spans[-1][2]
-for span in spans:
+nl.append((n, l))
-# we reopen the file for each span to make http happy for now
+ol += l
-f = self.opener(self.datafile)
+spans[-1] = (oo, ol, nl)
-f.seek(span[0])
+else:
-data = f.read(span[1])
+oo = o
+ol = l
-# divide up the span
+spans.append((oo, ol, [(n, l)]))
-pos = 0
-for r, l in span[2]:
+# read spans in, divide up chunks
-chunks[r] = decompress(data[pos: pos + l])
+chunks = {}
-pos += l
+for span in spans:
+# we reopen the file for each span to make http happy for now
+f = self.opener(self.datafile)
+f.seek(span[0])
+data = f.read(span[1])
+# divide up the span
+pos = 0
+for r, l in span[2]:
+chunks[r] = decompress(data[pos: pos + l])
+pos += l
+def chunk(r):
+return chunks[r]
 # helper to reconstruct intermediate versions
 def construct(text, base, rev):
-bins = [chunks[r] for r in xrange(base + 1, rev + 1)]
+bins = [chunk(r) for r in xrange(base + 1, rev + 1)]
 return mdiff.patches(text, bins)
 # build deltas
-deltas = []
 for d in xrange(0, len(revs) - 1):
 a, b = revs[d], revs[d + 1]
 n = self.node(b)
 if infocollect is not None:
 # do we need to construct a new delta?
 if a + 1 != b or self.base(b) == b:
 if a >= 0:
 base = self.base(a)
-ta = chunks[self.base(a)]
+ta = chunk(self.base(a))
 ta = construct(ta, base, a)
 else:
 ta = ""
 base = self.base(b)
 if a > base:
 base = a
 tb = ta
 else:
-tb = chunks[self.base(b)]
+tb = chunk(self.base(b))
 tb = construct(tb, base, b)
 d = self.diff(ta, tb)
 else:
-d = chunks[b]
+d = chunk(b)
 p = self.parents(n)
 meta = n + p[0] + p[1] + lookup(n)
 l = struct.pack(">l", len(meta) + len(d) + 4)
 yield l

Mercurial > hg > mercurial-crew-with-dirclash

comparison mercurial/revlog.py @ 1677:11d12bd6e1dc