D6430: rust-discovery: using from Python code

[gracinet (Georges Racinet)]

gracinet created this revision.
Herald added a subscriber: mercurial-devel.
Herald added a reviewer: hg-reviewers.

REVISION SUMMARY
  As previously done in other topics, the Rust version is used if it's been
  built.
  
  The version fully in Rust of the partialdiscovery class has the performance
  advantage over the Python version (actually using the Rust MissingAncestor) if
  the undecided set is big enough. Otherwise no sampling occurs, and the
  discovery is reasonably fast anyway.
  
  Note: it's hard to predict the size of the initial undecided set, it can
  depend on the kind of topological changes between the local and remote graphs.
  The point of the Rust version is to make the bad cases acceptable.
  
  More specifically, the performance advantages are:
  
  - faster sampling, especially takefullsample()
  - much faster addmissings() in almost all cases (see commit message in grandparent of the present changeset)
  - no conversion cost of the undecided set at the interface between Rust and Python
  
  Measurements with big undecided sets
  ------------------------------------
  
  For an extreme example, discovery between mozilla-try and mozilla-unified
  (over one million undecided revisions, same case as in https://phab.mercurial-scm.org/rHGdbd0fcca6dfca3b0b90ee7c1af30b0a0765e5ea5), we
  get roughly a x3 better performance:
  
  Growing sample size (5%): time goes down from 210 to 72 seconds.
  Constant sample size: time down from 1853 to 659 seconds.
  
  Measurements with small undecided sets
  --------------------------------------
  
  In cases the undecided set is small enough than no sampling occurs,
  the Rust version has a disadvantage at init if `targetheads` is really big
  (some time is lost in the translation to Rust data structures),
  and that is compensated by the faster `addmissings()`.
  
  On a private repository with over one million commits, we still get a minor
  improvement, of 6.8%:
  
    Before ! wall 0.593585 comb 0.590000 user 0.550000 sys 0.040000 (median of 50)
    After  ! wall 0.553035 comb 0.550000 user 0.520000 sys 0.030000 (median of 50)
  
  What's interesting in that case is the first addinfo() at 180ms for Rust and
  233ms for Python+C, mostly due to add_missings and the children cache
  computation being done in less than 0.2ms on the Rust side vs over 40ms on the
  Python side.
  
  The worst case we have on hand is with mozilla-try, prepared with
  discovery-helper.sh for 10 heads and depth 10, time goes up 2.2% on the median.
  In this case `targetheads` is really huge with 165842 server heads.
  
    Before ! wall 0.823884 comb 0.810000 user 0.790000 sys 0.020000 (median of 50)
    After  ! wall 0.842607 comb 0.840000 user 0.800000 sys 0.040000 (median of 50)
  
  If that would be considered a problem, more adjustments can be made, which are
  prematurate at this stage: cooking special variants of methods of the inner
  MissingAncestors object, retrieving local heads directly from Rust to avoid
  the cost of conversion. Effort would probably be better spent at this point
  improving the surroundings if needed.
  
  Here's another data point with a smaller repository, pypy, where performance
  is almost identical
  
  Before ! wall 0.015121 comb 0.030000 user 0.020000 sys 0.010000 (median of 186)
   After  ! wall 0.015009 comb 0.010000 user 0.010000 sys 0.000000 (median of 184)

REPOSITORY
  rHG Mercurial

REVISION DETAIL
  https://phab.mercurial-scm.org/D6430

AFFECTED FILES
  mercurial/setdiscovery.py

CHANGE DETAILS

diff --git a/mercurial/setdiscovery.py b/mercurial/setdiscovery.py
--- a/mercurial/setdiscovery.py
+++ b/mercurial/setdiscovery.py
@@ -46,6 +46,11 @@
 import random
 
 from .i18n import _
+try:
+    from .rustext import discovery as rustdisco
+except ImportError:
+    rustdisco = None
+
 from .node import (
     nullid,
     nullrev,
@@ -388,8 +393,11 @@
     # full blown discovery
 
     randomize = ui.configbool('devel', 'discovery.randomize')
-    disco = partialdiscovery(local, ownheads, randomize=randomize)
-
+    if rustdisco is not None:
+        disco = rustdisco.PartialDiscovery(local.changelog.index, ownheads,
+                                           randomize=randomize)
+    else:
+        disco = partialdiscovery(local, ownheads, randomize=randomize)
     # treat remote heads (and maybe own heads) as a first implicit sample
     # response
     disco.addcommons(knownsrvheads)



To: gracinet, #hg-reviewers
Cc: mercurial-devel