changeset 38732:be4984261611

merge: mark file gets as not thread safe (issue5933) In default installs, this has the effect of disabling the thread-based worker on Windows when manifesting files in the working directory. My measurements have shown that with revlog-based repositories, Mercurial spends a lot of CPU time in revlog code resolving file data. This ends up incurring a lot of context switching across threads and slows down `hg update` operations when going from an empty working directory to the tip of the repo. On mozilla-unified (246,351 files) on an i7-6700K (4+4 CPUs): before: 487s wall after: 360s wall (equivalent to worker.enabled=false) cpus=2: 379s wall Even with only 2 threads, the thread pool is still slower. The introduction of the thread-based worker (02b36e860e0b) states that it resulted in a "~50%" speedup for `hg sparse --enable-profile` and `hg sparse --disable-profile`. This disagrees with my measurement above. I theorize a few reasons for this: 1) Removal of files from the working directory is I/O - not CPU - bound and should benefit from a thread pool (unless I/O is insanely fast and the GIL release is near instantaneous). So tests like `hg sparse --enable-profile` may exercise deletion throughput and aren't good benchmarks for worker tasks that are CPU heavy. 2) The patch was authored by someone at Facebook. The results were likely measured against a repository using remotefilelog. And I believe that revision retrieval during working directory updates with remotefilelog will often use a remote store, thus being I/O and not CPU bound. This probably resulted in an overstated performance gain. Since there appears to be a need to enable the thread-based worker with some stores, I've made the flagging of file gets as thread safe configurable. I've made it experimental because I don't want to formalize a boolean flag for this option and because this attribute is best captured against the store implementation. But we don't have a proper store API for this yet. I'd rather cross this bridge later. It is possible there are revlog-based repositories that do benefit from a thread-based worker. I didn't do very comprehensive testing. If there are, we may want to devise a more proper algorithm for whether to use the thread-based worker, including possibly config options to limit the number of threads to use. But until I see evidence that justifies complexity, simplicity wins. Differential Revision: https://phab.mercurial-scm.org/D3963
author Gregory Szorc <gregory.szorc@gmail.com>
date Wed, 18 Jul 2018 09:49:34 -0700
parents ef3838a47503
children c2586a6e5884
files mercurial/configitems.py mercurial/merge.py
diffstat 2 files changed, 8 insertions(+), 2 deletions(-) [+]
line wrap: on
line diff
--- a/mercurial/configitems.py	Wed Jul 18 09:46:45 2018 -0700
+++ b/mercurial/configitems.py	Wed Jul 18 09:49:34 2018 -0700
@@ -623,6 +623,9 @@
 coreconfigitem('experimental', 'web.api.debugreflect',
     default=False,
 )
+coreconfigitem('experimental', 'worker.wdir-get-thread-safe',
+    default=False,
+)
 coreconfigitem('experimental', 'xdiff',
     default=False,
 )
--- a/mercurial/merge.py	Wed Jul 18 09:46:45 2018 -0700
+++ b/mercurial/merge.py	Wed Jul 18 09:49:34 2018 -0700
@@ -1637,9 +1637,12 @@
             wctx[f0].remove()
         progress.increment(item=f)
 
-    # get in parallel
+    # get in parallel.
+    threadsafe = repo.ui.configbool('experimental',
+                                    'worker.wdir-get-thread-safe')
     prog = worker.worker(repo.ui, cost, batchget, (repo, mctx, wctx),
-                         actions[ACTION_GET])
+                         actions[ACTION_GET],
+                         threadsafe=threadsafe)
     for i, item in prog:
         progress.increment(step=i, item=item)
     updated = len(actions[ACTION_GET])