Mercurial > public > mercurial-scm > hg

comparison mercurial/revlog.py @ 29830:92ac2baaea86

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
revlog: use an LRU cache for delta chain bases Profiling using statprof revealed a hotspot during changegroup application calculating delta chain bases on generaldelta repos. Essentially, revlog._addrevision() was performing a lot of redundant work tracing the delta chain as part of determining when the chain distance was acceptable. This was most pronounced when adding revisions to manifests, which can have delta chains thousands of revisions long. There was a delta chain base cache on revlogs before, but it only captured a single revision. This was acceptable before generaldelta, when _addrevision would build deltas from the previous revision and thus we'd pretty much guarantee a cache hit when resolving the delta chain base on a subsequent _addrevision call. However, it isn't suitable for generaldelta because parent revisions aren't necessarily the last processed revision. This patch converts the delta chain base cache to an LRU dict cache. The cache can hold multiple entries, so generaldelta repos have a higher chance of getting a cache hit. The impact of this change when processing changegroup additions is significant. On a generaldelta conversion of the "mozilla-unified" repo (which contains heads of the main Firefox repositories in chronological order - this means there are lots of transitions between heads in revlog order), this change has the following impact when performing an `hg unbundle` of an uncompressed bundle of the repo: before: 5:42 CPU time after: 4:34 CPU time Most of this time is saved when applying the changelog and manifest revlogs: before: 2:30 CPU time after: 1:17 CPU time That nearly a 50% reduction in CPU time applying changesets and manifests! Applying a gzipped bundle of the same repo (effectively simulating a `hg clone` over HTTP) showed a similar speedup: before: 5:53 CPU time after: 4:46 CPU time Wall time improvements were basically the same as CPU time. I didn't measure explicitly, but it feels like most of the time is saved when processing manifests. This makes sense, as large manifests tend to have very long delta chains and thus benefit the most from this cache. So, this change effectively makes changegroup application (which is used by `hg unbundle`, `hg clone`, `hg pull`, `hg unshelve`, and various other commands) significantly faster when delta chains are long (which can happen on repos with large numbers of files and thus large manifests). In theory, this change can result in more memory utilization. However, we're caching a dict of ints. At most we have 200 ints + Python object overhead per revlog. And, the cache is really only populated when performing read-heavy operations, such as adding changegroups or scanning an individual revlog. For memory bloat to be an issue, we'd need to scan/read several revisions from several revlogs all while having active references to several revlogs. I don't think there are many operations that do this, so I don't think memory bloat from the cache will be an issue.
author Gregory Szorc <gregory.szorc@gmail.com>
date Mon, 22 Aug 2016 21:48:50 -0700
parents dae97049345b
children b5e5ddf48bd2
comparison
equal deleted inserted replaced
29829:dae97049345b 29830:92ac2baaea86
223 self.indexfile = indexfile 223 self.indexfile = indexfile
224 self.datafile = indexfile[:-2] + ".d" 224 self.datafile = indexfile[:-2] + ".d"
225 self.opener = opener 225 self.opener = opener
226 # 3-tuple of (node, rev, text) for a raw revision. 226 # 3-tuple of (node, rev, text) for a raw revision.
227 self._cache = None 227 self._cache = None
228 # 2-tuple of (rev, baserev) defining the base revision the delta chain 228 # Maps rev to chain base rev.
229 # begins at for a revision. 229 self._chainbasecache = util.lrucachedict(100)
230 self._basecache = None
231 # 2-tuple of (offset, data) of raw data from the revlog at an offset. 230 # 2-tuple of (offset, data) of raw data from the revlog at an offset.
232 self._chunkcache = (0, '') 231 self._chunkcache = (0, '')
233 # How much data to read and cache into the raw revlog data cache. 232 # How much data to read and cache into the raw revlog data cache.
234 self._chunkcachesize = 65536 233 self._chunkcachesize = 65536
235 self._maxchainlen = None 234 self._maxchainlen = None
338 except KeyError: 337 except KeyError:
339 return False 338 return False
340 339
341 def clearcaches(self): 340 def clearcaches(self):
342 self._cache = None 341 self._cache = None
343 self._basecache = None 342 self._chainbasecache.clear()
344 self._chunkcache = (0, '') 343 self._chunkcache = (0, '')
345 self._pcache = {} 344 self._pcache = {}
346 345
347 try: 346 try:
348 self._nodecache.clearcaches() 347 self._nodecache.clearcaches()
388 def end(self, rev): 387 def end(self, rev):
389 return self.start(rev) + self.length(rev) 388 return self.start(rev) + self.length(rev)
390 def length(self, rev): 389 def length(self, rev):
391 return self.index[rev][1] 390 return self.index[rev][1]
392 def chainbase(self, rev): 391 def chainbase(self, rev):
392 base = self._chainbasecache.get(rev)
393 if base is not None:
394 return base
395
393 index = self.index 396 index = self.index
394 base = index[rev][3] 397 base = index[rev][3]
395 while base != rev: 398 while base != rev:
396 rev = base 399 rev = base
397 base = index[rev][3] 400 base = index[rev][3]
401
402 self._chainbasecache[rev] = base
398 return base 403 return base
399 def chainlen(self, rev): 404 def chainlen(self, rev):
400 return self._chaininfo(rev)[0] 405 return self._chaininfo(rev)[0]
401 406
402 def _chaininfo(self, rev): 407 def _chaininfo(self, rev):
1428 fh = dfh 1433 fh = dfh
1429 ptext = self.revision(self.node(rev), _df=fh) 1434 ptext = self.revision(self.node(rev), _df=fh)
1430 delta = mdiff.textdiff(ptext, t) 1435 delta = mdiff.textdiff(ptext, t)
1431 data = self.compress(delta) 1436 data = self.compress(delta)
1432 l = len(data[1]) + len(data[0]) 1437 l = len(data[1]) + len(data[0])
1433 if basecache[0] == rev: 1438 chainbase = self.chainbase(rev)
1434 chainbase = basecache[1]
1435 else:
1436 chainbase = self.chainbase(rev)
1437 dist = l + offset - self.start(chainbase) 1439 dist = l + offset - self.start(chainbase)
1438 if self._generaldelta: 1440 if self._generaldelta:
1439 base = rev 1441 base = rev
1440 else: 1442 else:
1441 base = chainbase 1443 base = chainbase
1446 1448
1447 curr = len(self) 1449 curr = len(self)
1448 prev = curr - 1 1450 prev = curr - 1
1449 offset = self.end(prev) 1451 offset = self.end(prev)
1450 delta = None 1452 delta = None
1451 if self._basecache is None:
1452 self._basecache = (prev, self.chainbase(prev))
1453 basecache = self._basecache
1454 p1r, p2r = self.rev(p1), self.rev(p2) 1453 p1r, p2r = self.rev(p1), self.rev(p2)
1455 1454
1456 # full versions are inserted when the needed deltas 1455 # full versions are inserted when the needed deltas
1457 # become comparable to the uncompressed text 1456 # become comparable to the uncompressed text
1458 if text is None: 1457 if text is None:
1512 if alwayscache and text is None: 1511 if alwayscache and text is None:
1513 text = buildtext() 1512 text = buildtext()
1514 1513
1515 if type(text) == str: # only accept immutable objects 1514 if type(text) == str: # only accept immutable objects
1516 self._cache = (node, curr, text) 1515 self._cache = (node, curr, text)
1517 self._basecache = (curr, chainbase) 1516 self._chainbasecache[curr] = chainbase
1518 return node 1517 return node
1519 1518
1520 def _writeentry(self, transaction, ifh, dfh, entry, data, link, offset): 1519 def _writeentry(self, transaction, ifh, dfh, entry, data, link, offset):
1521 # Files opened in a+ mode have inconsistent behavior on various 1520 # Files opened in a+ mode have inconsistent behavior on various
1522 # platforms. Windows requires that a file positioning call be made 1521 # platforms. Windows requires that a file positioning call be made