Mercurial > hg
view tests/drawdag.py @ 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 | 4e41b59633fa |
children | 9a813e4c8406 |
line wrap: on
line source
# drawdag.py - convert ASCII revision DAG to actual changesets # # Copyright 2016 Facebook, Inc. # # This software may be used and distributed according to the terms of the # GNU General Public License version 2 or any later version. """ create changesets from an ASCII graph for testing purpose. For example, given the following input:: c d |/ b | a 4 changesets and 4 local tags will be created. `hg log -G -T "{rev} {desc} (tag: {tags})"` will output:: o 3 d (tag: d tip) | | o 2 c (tag: c) |/ o 1 b (tag: b) | o 0 a (tag: a) For root nodes (nodes without parents) in the graph, they can be revsets pointing to existing nodes. The ASCII graph could also have disconnected components with same names referring to the same changeset. Therefore, given the repo having the 4 changesets (and tags) above, with the following ASCII graph as input:: foo bar bar foo | / | | ancestor(c,d) a baz The result (`hg log -G -T "{desc}"`) will look like:: o foo |\ +---o bar | | | | o | baz | / +---o d | | +---o c | | o | b |/ o a Note that if you take the above `hg log` output directly as input. It will work as expected - the result would be an isomorphic graph:: o foo |\ | | o d | |/ | | o c | |/ | | o bar | |/| | o | b | |/ o / baz / o a This is because 'o' is specially handled in the input: instead of using 'o' as the node name, the word to the right will be used. Some special comments could have side effects: - Create obsmarkers # replace: A -> B -> C -> D # chained 1 to 1 replacements # split: A -> B, C # 1 to many # prune: A, B, C # many to nothing """ from __future__ import absolute_import, print_function import collections import itertools import re from mercurial.i18n import _ from mercurial import ( context, error, node, obsolete, pycompat, registrar, scmutil, tags as tagsmod, ) cmdtable = {} command = registrar.command(cmdtable) _pipechars = b'\\/+-|' _nonpipechars = b''.join(pycompat.bytechr(i) for i in range(33, 127) if pycompat.bytechr(i) not in _pipechars) def _isname(ch): """char -> bool. return True if ch looks like part of a name, False otherwise""" return ch in _nonpipechars def _parseasciigraph(text): r"""str -> {str : [str]}. convert the ASCII graph to edges >>> import pprint >>> pprint.pprint({pycompat.sysstr(k): [pycompat.sysstr(vv) for vv in v] ... for k, v in _parseasciigraph(br''' ... G ... | ... I D C F # split: B -> E, F, G ... \ \| | # replace: C -> D -> H ... H B E # prune: F, I ... \|/ ... A ... ''').items()}) {'A': [], 'B': ['A'], 'C': ['B'], 'D': ['B'], 'E': ['A'], 'F': ['E'], 'G': ['F'], 'H': ['A'], 'I': ['H']} >>> pprint.pprint({pycompat.sysstr(k): [pycompat.sysstr(vv) for vv in v] ... for k, v in _parseasciigraph(br''' ... o foo ... |\ ... +---o bar ... | | | ... | o | baz ... | / ... +---o d ... | | ... +---o c ... | | ... o | b ... |/ ... o a ... ''').items()}) {'a': [], 'b': ['a'], 'bar': ['b', 'a'], 'baz': [], 'c': ['b'], 'd': ['b'], 'foo': ['baz', 'b']} """ lines = text.splitlines() edges = collections.defaultdict(list) # {node: []} def get(y, x): """(int, int) -> char. give a coordinate, return the char. return a space for anything out of range""" if x < 0 or y < 0: return b' ' try: return lines[y][x:x + 1] or b' ' except IndexError: return b' ' def getname(y, x): """(int, int) -> str. like get(y, x) but concatenate left and right parts. if name is an 'o', try to replace it to the right""" result = b'' for i in itertools.count(0): ch = get(y, x - i) if not _isname(ch): break result = ch + result for i in itertools.count(1): ch = get(y, x + i) if not _isname(ch): break result += ch if result == b'o': # special handling, find the name to the right result = b'' for i in itertools.count(2): ch = get(y, x + i) if ch == b' ' or ch in _pipechars: if result or x + i >= len(lines[y]): break else: result += ch return result or b'o' return result def parents(y, x): """(int, int) -> [str]. follow the ASCII edges at given position, return a list of parents""" visited = {(y, x)} visit = [] result = [] def follow(y, x, expected): """conditionally append (y, x) to visit array, if it's a char in excepted. 'o' in expected means an '_isname' test. if '-' (or '+') is not in excepted, and get(y, x) is '-' (or '+'), the next line (y + 1, x) will be checked instead.""" ch = get(y, x) if any(ch == c and c not in expected for c in (b'-', b'+')): y += 1 return follow(y + 1, x, expected) if ch in expected or (b'o' in expected and _isname(ch)): visit.append((y, x)) # -o- # starting point: # /|\ # follow '-' (horizontally), and '/|\' (to the bottom) follow(y + 1, x, b'|') follow(y + 1, x - 1, b'/') follow(y + 1, x + 1, b'\\') follow(y, x - 1, b'-') follow(y, x + 1, b'-') while visit: y, x = visit.pop() if (y, x) in visited: continue visited.add((y, x)) ch = get(y, x) if _isname(ch): result.append(getname(y, x)) continue elif ch == b'|': follow(y + 1, x, b'/|o') follow(y + 1, x - 1, b'/') follow(y + 1, x + 1, b'\\') elif ch == b'+': follow(y, x - 1, b'-') follow(y, x + 1, b'-') follow(y + 1, x - 1, b'/') follow(y + 1, x + 1, b'\\') follow(y + 1, x, b'|') elif ch == b'\\': follow(y + 1, x + 1, b'\\|o') elif ch == b'/': follow(y + 1, x - 1, b'/|o') elif ch == b'-': follow(y, x - 1, b'-+o') follow(y, x + 1, b'-+o') return result for y, line in enumerate(lines): for x, ch in enumerate(pycompat.bytestr(line)): if ch == b'#': # comment break if _isname(ch): edges[getname(y, x)] += parents(y, x) return dict(edges) class simplefilectx(object): def __init__(self, path, data): self._data = data self._path = path def data(self): return self._data def filenode(self): return None def path(self): return self._path def renamed(self): return None def flags(self): return b'' class simplecommitctx(context.committablectx): def __init__(self, repo, name, parentctxs, added): opts = { 'changes': scmutil.status([], list(added), [], [], [], [], []), 'date': b'0 0', 'extra': {b'branch': b'default'}, } super(simplecommitctx, self).__init__(self, name, **opts) self._repo = repo self._added = added self._parents = parentctxs while len(self._parents) < 2: self._parents.append(repo[node.nullid]) def filectx(self, key): return simplefilectx(key, self._added[key]) def commit(self): return self._repo.commitctx(self) def _walkgraph(edges): """yield node, parents in topologically order""" visible = set(edges.keys()) remaining = {} # {str: [str]} for k, vs in edges.items(): for v in vs: if v not in remaining: remaining[v] = [] remaining[k] = vs[:] while remaining: leafs = [k for k, v in remaining.items() if not v] if not leafs: raise error.Abort(_('the graph has cycles')) for leaf in sorted(leafs): if leaf in visible: yield leaf, edges[leaf] del remaining[leaf] for k, v in remaining.items(): if leaf in v: v.remove(leaf) def _getcomments(text): """ >>> [pycompat.sysstr(s) for s in _getcomments(br''' ... G ... | ... I D C F # split: B -> E, F, G ... \ \| | # replace: C -> D -> H ... H B E # prune: F, I ... \|/ ... A ... ''')] ['split: B -> E, F, G', 'replace: C -> D -> H', 'prune: F, I'] """ for line in text.splitlines(): if b' # ' not in line: continue yield line.split(b' # ', 1)[1].split(b' # ')[0].strip() @command(b'debugdrawdag', []) def debugdrawdag(ui, repo, **opts): """read an ASCII graph from stdin and create changesets The ASCII graph is like what :hg:`log -G` outputs, with each `o` replaced to the name of the node. The command will create dummy changesets and local tags with those names to make the dummy changesets easier to be referred to. If the name of a node is a single character 'o', It will be replaced by the word to the right. This makes it easier to reuse :hg:`log -G -T '{desc}'` outputs. For root (no parents) nodes, revset can be used to query existing repo. Note that the revset cannot have confusing characters which can be seen as the part of the graph edges, like `|/+-\`. """ text = ui.fin.read() # parse the graph and make sure len(parents) <= 2 for each node edges = _parseasciigraph(text) for k, v in edges.items(): if len(v) > 2: raise error.Abort(_('%s: too many parents: %s') % (k, b' '.join(v))) # parse comments to get extra file content instructions files = collections.defaultdict(dict) # {(name, path): content} comments = list(_getcomments(text)) filere = re.compile(br'^(\w+)/([\w/]+)\s*=\s*(.*)$', re.M) for name, path, content in filere.findall(b'\n'.join(comments)): content = content.replace(br'\n', b'\n').replace(br'\1', b'\1') files[name][path] = content committed = {None: node.nullid} # {name: node} # for leaf nodes, try to find existing nodes in repo for name, parents in edges.items(): if len(parents) == 0: try: committed[name] = scmutil.revsingle(repo, name) except error.RepoLookupError: pass # commit in topological order for name, parents in _walkgraph(edges): if name in committed: continue pctxs = [repo[committed[n]] for n in parents] pctxs.sort(key=lambda c: c.node()) added = {} if len(parents) > 1: # If it's a merge, take the files and contents from the parents for f in pctxs[1].manifest(): if f not in pctxs[0].manifest(): added[f] = pctxs[1][f].data() else: # If it's not a merge, add a single file added[name] = name # add extra file contents in comments for path, content in files.get(name, {}).items(): added[path] = content ctx = simplecommitctx(repo, name, pctxs, added) n = ctx.commit() committed[name] = n tagsmod.tag(repo, [name], n, message=None, user=None, date=None, local=True) # handle special comments with repo.wlock(), repo.lock(), repo.transaction(b'drawdag'): getctx = lambda x: repo.unfiltered()[committed[x.strip()]] for comment in comments: rels = [] # obsolete relationships args = comment.split(b':', 1) if len(args) <= 1: continue cmd = args[0].strip() arg = args[1].strip() if cmd in (b'replace', b'rebase', b'amend'): nodes = [getctx(m) for m in arg.split(b'->')] for i in range(len(nodes) - 1): rels.append((nodes[i], (nodes[i + 1],))) elif cmd in (b'split',): pre, succs = arg.split(b'->') succs = succs.split(b',') rels.append((getctx(pre), (getctx(s) for s in succs))) elif cmd in (b'prune',): for n in arg.split(b','): rels.append((getctx(n), ())) if rels: obsolete.createmarkers(repo, rels, date=(0, 0), operation=cmd)