mercurial-scm/hg-stable: mercurial/localrepo.py comparison

comparison mercurial/localrepo.py @ 16716:0311a6abd38a

localrepo: strip now incrementally updates the branchheads cache Destroying history via strip used to invalidate the branchheads cache, causing it to be regenerated the next time it is read. This is expensive in large repos. This change converts strip to pass info to localrepo.destroyed() to enable to it to incrementally update the cache, improving the performance of strip and other operations that depend on it (e.g., rebase). This change also strengthens a bit the integrity checking of the branchheads cache when it is read, by rejecting the cache if it has nodes in it that no longer exist.

author	Joshua Redstone <joshua.redstone@fb.com>
date	Fri, 11 May 2012 10:35:54 -0700
parents	f8dee1a8f844
children	e7bf09acd410

comparison

equal deleted inserted replaced

-:1e24da6fcd67
+:0311a6abd38a
 for l in lines:
 if not l:
 continue
 node, label = l.split(" ", 1)
 label = encoding.tolocal(label.strip())
+if not node in self:
+raise ValueError('invalidating branch cache because node '+
+'%s does not exist' % node)
 partial.setdefault(label, []).append(bin(node))
 except KeyboardInterrupt:
 raise
 except Exception, inst:
 if self.ui.debugflag:
 f.close()
 except (IOError, OSError):
 pass
 def _updatebranchcache(self, partial, ctxgen):
+"""Given a branchhead cache, partial, that may have extra nodes or be
+missing heads, and a generator of nodes that are at least a superset of
+heads missing, this function updates partial to be correct.
+"""
 # collect new branch entries
 newbranches = {}
 for c in ctxgen:
 newbranches.setdefault(c.branch(), []).append(c.node())
 # if older branchheads are reachable from new ones, they aren't
 # really branchheads. Note checking parents is insufficient:
 # 1 (branch a) -> 2 (branch b) -> 3 (branch a)
 for branch, newnodes in newbranches.iteritems():
 bheads = partial.setdefault(branch, [])
 bheads.extend(newnodes)
-if len(bheads) <= 1:
+# Remove duplicates - nodes that are in newnodes and are already in
-continue
+# bheads.  This can happen if you strip a node and its parent was
-bheads = sorted(bheads, key=lambda x: self[x].rev())
+# already a head (because they're on different branches).
-# starting from tip means fewer passes over reachable
+bheads = set(bheads)
-while newnodes:
-latest = newnodes.pop()
+# Remove candidate heads that no longer are in the repo (e.g., as
-if latest not in bheads:
+# the result of a strip that just happened).
-continue
+# avoid using 'bhead in self' here because that dives down into
-minbhnode = self[bheads[0]].node()
+# branchcache code somewhat recrusively.
-reachable = self.changelog.reachable(latest, minbhnode)
+bheads = [bhead for bhead in bheads \
-reachable.remove(latest)
+if self.changelog.hasnode(bhead)]
-if reachable:
+if len(bheads) > 1:
-bheads = [b for b in bheads if b not in reachable]
+bheads = sorted(bheads, key=lambda x: self[x].rev())
+# starting from tip means fewer passes over reachable
+while newnodes:
+latest = newnodes.pop()
+if latest not in bheads:
+continue
+minbhnode = self[bheads[0]].node()
+reachable = self.changelog.reachable(latest, minbhnode)
+reachable.remove(latest)
+if reachable:
+bheads = [b for b in bheads if b not in reachable]
 partial[branch] = bheads
+# There may be branches that cease to exist when the last commit in the
+# branch was stripped.  This code filters them out.  Note that the
+# branch that ceased to exist may not be in newbranches because
+# newbranches is the set of candidate heads, which when you strip the
+# last commit in a branch will be the parent branch.
+for branch in partial.keys():
+nodes = [head for head in partial[branch] \
+if self.changelog.hasnode(head)]
+if len(nodes) < 1:
+del partial[branch]
 def lookup(self, key):
 return self[key].node()
 def lookupbranch(self, key, remote=None):
 ui.status(_('working directory now based on '
 'revisions %d and %d\n') % parents)
 else:
 ui.status(_('working directory now based on '
 'revision %d\n') % parents)
+# TODO: if we know which new heads may result from this rollback, pass
+# them to destroy(), which will prevent the branchhead cache from being
+# invalidated.
 self.destroyed()
 return 0
 def invalidatecaches(self):
 def delcache(name):
 finally:
 if tr:
 tr.release()
 lock.release()
-def destroyed(self):
+def destroyed(self, newheadrevs=None):
 '''Inform the repository that nodes have been destroyed.
 Intended for use by strip and rollback, so there's a common
-place for anything that has to be done after destroying history.'''
+place for anything that has to be done after destroying history.
-# XXX it might be nice if we could take the list of destroyed
-# nodes, but I don't see an easy way for rollback() to do that
+If you know the branchheadcache was uptodate before nodes were removed
+and you also know the set of candidate set of new heads that may have
+resulted from the destruction, you can set newheadrevs.  This will
+enable the code to update the branchheads cache, rather than having
+future code decide it's invalid and regenrating it.
+'''
+if newheadrevs:
+tiprev = len(self) - 1
+ctxgen = (self[rev] for rev in newheadrevs)
+self._updatebranchcache(self._branchcache, ctxgen)
+self._writebranchcache(self._branchcache, self.changelog.tip(),
+tiprev)
+else:
+# No info to update the cache.  If nodes were destroyed, the cache
+# is stale and this will be caught the next time it is read.
+pass
 # Ensure the persistent tag cache is updated.  Doing it now
 # means that the tag cache only has to worry about destroyed
 # heads immediately after a strip/rollback.  That in turn
 # guarantees that "cachetip == currenttip" (comparing both rev

Mercurial > public > mercurial-scm > hg-stable

comparison mercurial/localrepo.py @ 16716:0311a6abd38a