[PATCH 2 of 2] revlog: linearize created changegroups in generaldelta revlogs

[Sune Foldager]

# HG changeset patch
# User Sune Foldager <cryo at cyanite.org>
# Date 1305727158 -7200
# Node ID 36bb2e5488d2cdc8ac33a16f6809a300abd0aafc
# Parent  d05bc567f5368ac6ee1bd3f27a7746200906759f
revlog: linearize created changegroups in generaldelta revlogs

This greatly improves the speed of the bundling process, and reduces the
bundle size considerably in general. 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 greatly
reduced repository size, similar to shrinking the revlogs. For generaldelta
clients the difference is minor.

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 -r d05bc567f536 -r 36bb2e5488d2 mercurial/localrepo.py
--- a/mercurial/localrepo.py	Wed May 18 15:59:14 2011 +0200
+++ b/mercurial/localrepo.py	Wed May 18 15:59:18 2011 +0200
@@ -1544,18 +1544,23 @@
                 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 @@
                 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 @@
                 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 @@
                     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 -r d05bc567f536 -r 36bb2e5488d2 mercurial/revlog.py
--- a/mercurial/revlog.py	Wed May 18 15:59:14 2011 +0200
+++ b/mercurial/revlog.py	Wed May 18 15:59:18 2011 +0200
@@ -14,7 +14,7 @@
 # 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 @@
         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 @@
         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: