# HG changeset patch # User Sune Foldager # Date 2011-05-18 21:26:26 # Node ID a8e3931e3fb57b8c0eb012b58156d9c109043396 # Parent a3b9f1bddab1c2cd0ea8ba8cf243aafa103afd3f revlog: linearize created changegroups in generaldelta revlogs This greatly improves the speed of the bundling process, and often reduces the bundle size considerably. (Although if the repository is already ordered, this has little effect on both time and bundle size.) For non-generaldelta clients, the reduced bundle size translates to a reduced repository size, similar to shrinking the revlogs (which uses the exact same algorithm). For generaldelta clients the difference is minor. When the new bundle format comes, reordering will not be necessary since we can then store the deltaparent relationsships directly. The eventual default behavior for clients and servers is presented in the table below, where "new" implies support for GD as well as the new bundle format: old client new client old server old bundle, no reorder old bundle, no reorder new server, non-GD old bundle, no reorder[1] old bundle, no reorder[2] new server, GD old bundle, reorder[3] new bundle, no reorder[4] [1] reordering is expensive on the server in this case, skip it [2] client can choose to do its own redelta here [3] reordering is needed because otherwise the pull does a lot of extra work on the server [4] reordering isn't needed because client can get deltabase in bundle format Currently, the default is to reorder on GD-servers, and not otherwise. A new setting, bundle.reorder, has been added to override the default reordering behavior. It can be set to either 'auto' (the default), or any true or false value as a standard boolean setting, to either force the reordering on or off regardless of generaldelta. Some timing data from a relatively branch test repository follows. All bundling is done with --all --type none options. Non-generaldelta, non-shrunk repo: ----------------------------------- Size: 276M Without reorder (default): Bundle time: 14.4 seconds Bundle size: 939M With reorder: Bundle time: 1 minute, 29.3 seconds Bundle size: 381M Generaldelta, non-shrunk repo: ----------------------------------- Size: 87M Without reorder: Bundle time: 2 minutes, 1.4 seconds Bundle size: 939M With reorder (default): Bundle time: 25.5 seconds Bundle size: 381M diff --git a/mercurial/localrepo.py b/mercurial/localrepo.py --- a/mercurial/localrepo.py +++ b/mercurial/localrepo.py @@ -1544,18 +1544,23 @@ class localrepository(repo.repository): return fstate[1][x] bundler = changegroup.bundle10(lookup) + reorder = self.ui.config('bundle', 'reorder', 'auto') + if reorder == 'auto': + reorder = None + else: + reorder = util.parsebool(reorder) def gengroup(): # Create a changenode group generator that will call our functions # back to lookup the owning changenode and collect information. - for chunk in cl.group(csets, bundler): + for chunk in cl.group(csets, bundler, reorder=reorder): yield chunk self.ui.progress(_('bundling'), None) # Create a generator for the manifestnodes that calls our lookup # and data collection functions back. count[0] = 0 - for chunk in mf.group(prune(mf, mfs), bundler): + for chunk in mf.group(prune(mf, mfs), bundler, reorder=reorder): yield chunk self.ui.progress(_('bundling'), None) @@ -1572,7 +1577,7 @@ class localrepository(repo.repository): first = True for chunk in filerevlog.group(prune(filerevlog, fstate[1]), - bundler): + bundler, reorder=reorder): if first: if chunk == bundler.close(): break @@ -1640,17 +1645,22 @@ class localrepository(repo.repository): return cl.node(revlog.linkrev(revlog.rev(x))) bundler = changegroup.bundle10(lookup) + reorder = self.ui.config('bundle', 'reorder', 'auto') + if reorder == 'auto': + reorder = None + else: + reorder = util.parsebool(reorder) def gengroup(): '''yield a sequence of changegroup chunks (strings)''' # construct a list of all changed files - for chunk in cl.group(nodes, bundler): + for chunk in cl.group(nodes, bundler, reorder=reorder): yield chunk self.ui.progress(_('bundling'), None) count[0] = 0 - for chunk in mf.group(gennodelst(mf), bundler): + for chunk in mf.group(gennodelst(mf), bundler, reorder=reorder): yield chunk self.ui.progress(_('bundling'), None) @@ -1661,7 +1671,8 @@ class localrepository(repo.repository): raise util.Abort(_("empty or missing revlog for %s") % fname) fstate[0] = fname first = True - for chunk in filerevlog.group(gennodelst(filerevlog), bundler): + for chunk in filerevlog.group(gennodelst(filerevlog), bundler, + reorder=reorder): if first: if chunk == bundler.close(): break diff --git a/mercurial/revlog.py b/mercurial/revlog.py --- a/mercurial/revlog.py +++ b/mercurial/revlog.py @@ -14,7 +14,7 @@ and O(changes) merge between branches. # import stuff from node for others to import from revlog from node import bin, hex, nullid, nullrev, short #@UnusedImport from i18n import _ -import ancestor, mdiff, parsers, error, util +import ancestor, mdiff, parsers, error, util, dagutil import struct, zlib, errno _pack = struct.pack @@ -1086,7 +1086,7 @@ class revlog(object): self._basecache = (curr, chainbase) return node - def group(self, nodelist, bundler): + def group(self, nodelist, bundler, reorder=None): """Calculate a delta group, yielding a sequence of changegroup chunks (strings). @@ -1098,7 +1098,14 @@ class revlog(object): changegroup starts with a full revision. """ - revs = sorted([self.rev(n) for n in nodelist]) + # for generaldelta revlogs, we linearize the revs; this will both be + # much quicker and generate a much smaller bundle + if (self._generaldelta and reorder is not False) or reorder: + dag = dagutil.revlogdag(self) + revs = set(self.rev(n) for n in nodelist) + revs = dag.linearize(revs) + else: + revs = sorted([self.rev(n) for n in nodelist]) # if we don't have any revisions touched by these changesets, bail if not revs: