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

comparison mercurial/localrepo.py @ 17013:c8eda7bbdcab

strip: incrementally update the branchheads cache after a strip This function augments strip to incrementally update the branchheads cache rather than recompute it from scratch. This speeds up the performance of strip and rebase on repos with long history. The performance optimization only happens if the revisions stripped are all on the same branch and the parents of the stripped revisions are also on that same branch. This adds a few test cases, particularly one that reproduces the extra heads that mpm observed.

author	Joshua Redstone <joshua.redstone@fb.com>
date	Fri, 18 May 2012 12:45:47 -0700
parents	ea97744c4801
children	ad0d6c2b3279

comparison

equal deleted inserted replaced

-:ea97744c4801
+:c8eda7bbdcab
 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.rev())
+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, newrevs in newbranches.iteritems():
+for branch, newnodes in newbranches.iteritems():
-bheadrevs = [self.changelog.rev(node) for node in
+bheads = partial.setdefault(branch, [])
-partial.setdefault(branch, [])]
+# Remove candidate heads that no longer are in the repo (e.g., as
-bheadrevs.extend(newrevs)
+# the result of a strip that just happened).  Avoid using 'node in
-bheadrevs.sort()
+# self' here because that dives down into branchcache code somewhat
-# starting from tip means fewer passes over ancestors
+# recrusively.
-newrevs.sort()
+bheadrevs = [self.changelog.rev(node) for node in bheads
-while newrevs:
+if self.changelog.hasnode(node)]
-latest = newrevs.pop()
+newheadrevs = [self.changelog.rev(node) for node in newnodes
+if self.changelog.hasnode(node)]
+ctxisnew = bheadrevs and min(newheadrevs) > max(bheadrevs)
+# Remove duplicates - nodes that are in newheadrevs and are already
+# in bheadrevs.  This can happen if you strip a node whose parent
+# was already a head (because they're on different branches).
+bheadrevs = sorted(set(bheadrevs).union(newheadrevs))
+# Starting from tip means fewer passes over reachable.  If we know
+# the new candidates are not ancestors of existing heads, we don't
+# have to examine ancestors of existing heads
+if ctxisnew:
+iterrevs = sorted(newheadrevs)
+else:
+iterrevs = list(bheadrevs)
+# This loop prunes out two kinds of heads - heads that are
+# superceded by a head in newheadrevs, and newheadrevs that are not
+# heads because an existing head is their descendant.
+while iterrevs:
+latest = iterrevs.pop()
 if latest not in bheadrevs:
 continue
 ancestors = set(self.changelog.ancestors([latest],
 bheadrevs[0]))
 if ancestors:
 bheadrevs = [b for b in bheadrevs if b not in ancestors]
 partial[branch] = [self.changelog.node(rev) for rev in bheadrevs]
+# 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:
+nodes = [head for head in partial[branch]
+if self.changelog.hasnode(head)]
+if not nodes:
+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, newheadnodes=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 new heads that may have resulted
+from the destruction, you can set newheadnodes.  This will enable the
+code to update the branchheads cache, rather than having future code
+decide it's invalid and regenrating it from scratch.
+'''
+# If we have info, newheadnodes, on how to update the branch cache, do
+# it, Otherwise, since nodes were destroyed, the cache is stale and this
+# will be caught the next time it is read.
+if newheadnodes:
+tiprev = len(self) - 1
+ctxgen = (self[node] for node in newheadnodes
+if self.changelog.hasnode(node))
+self._updatebranchcache(self._branchcache, ctxgen)
+self._writebranchcache(self._branchcache, self.changelog.tip(),
+tiprev)
 # 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

comparison mercurial/localrepo.py @ 17013:c8eda7bbdcab