| hg-reviewers |
This was discussed on the mailing list / phab and :: got a couple of positive
feedback.
I dediced to not introduce automatic folding of ::, I feel like it make sense
for -, but I like the expliciteness of ::.
So I am adding alias for backward compatibility.
| Automatic diff as part of commit; lint not applicable. |
| Automatic diff as part of commit; unit tests not applicable. |
In D9872#149610, @pulkit wrote:Sorry, but it hit me now that can subcommands support be a better option here?
No, the intended usecase for namespace is for widly unrelated command (but for their namespace). I am just starting with perf because it is a de-factor already existing namespace.
| Path | Packages | |||
|---|---|---|---|---|
| M | contrib/perf.py (124 lines) | |||
| M | tests/test-contrib-perf.t (126 lines) |
| object.__setattr__(repo, '_clcachekey', None) | object.__setattr__(repo, '_clcachekey', None) | ||||
| object.__setattr__(repo, '_clcache', None) | object.__setattr__(repo, '_clcache', None) | ||||
| clearfilecache(repo.unfiltered(), 'changelog') | clearfilecache(repo.unfiltered(), 'changelog') | ||||
| # perf commands | # perf commands | ||||
| @command(b'perf--walk', formatteropts) | @command(b'perf::walk|perfwalk', formatteropts) | ||||
| def perfwalk(ui, repo, *pats, **opts): | def perfwalk(ui, repo, *pats, **opts): | ||||
| opts = _byteskwargs(opts) | opts = _byteskwargs(opts) | ||||
| timer, fm = gettimer(ui, opts) | timer, fm = gettimer(ui, opts) | ||||
| m = scmutil.match(repo[None], pats, {}) | m = scmutil.match(repo[None], pats, {}) | ||||
| timer( | timer( | ||||
| lambda: len( | lambda: len( | ||||
| list( | list( | ||||
| repo.dirstate.walk(m, subrepos=[], unknown=True, ignored=False) | repo.dirstate.walk(m, subrepos=[], unknown=True, ignored=False) | ||||
| ) | ) | ||||
| ) | ) | ||||
| ) | ) | ||||
| fm.end() | fm.end() | ||||
| @command(b'perf--annotate', formatteropts) | @command(b'perf::annotate|perfannotate', formatteropts) | ||||
| def perfannotate(ui, repo, f, **opts): | def perfannotate(ui, repo, f, **opts): | ||||
| opts = _byteskwargs(opts) | opts = _byteskwargs(opts) | ||||
| timer, fm = gettimer(ui, opts) | timer, fm = gettimer(ui, opts) | ||||
| fc = repo[b'.'][f] | fc = repo[b'.'][f] | ||||
| timer(lambda: len(fc.annotate(True))) | timer(lambda: len(fc.annotate(True))) | ||||
| fm.end() | fm.end() | ||||
| @command( | @command( | ||||
| b'perf--status', | b'perf::status|perfstatus', | ||||
| [ | [ | ||||
| (b'u', b'unknown', False, b'ask status to look for unknown files'), | (b'u', b'unknown', False, b'ask status to look for unknown files'), | ||||
| (b'', b'dirstate', False, b'benchmark the internal dirstate call'), | (b'', b'dirstate', False, b'benchmark the internal dirstate call'), | ||||
| ] | ] | ||||
| + formatteropts, | + formatteropts, | ||||
| ) | ) | ||||
| def perfstatus(ui, repo, **opts): | def perfstatus(ui, repo, **opts): | ||||
| """benchmark the performance of a single status call | """benchmark the performance of a single status call | ||||
| sum(map(bool, s)) | sum(map(bool, s)) | ||||
| timer(status_dirstate) | timer(status_dirstate) | ||||
| else: | else: | ||||
| timer(lambda: sum(map(len, repo.status(unknown=opts[b'unknown'])))) | timer(lambda: sum(map(len, repo.status(unknown=opts[b'unknown'])))) | ||||
| fm.end() | fm.end() | ||||
| @command(b'perf--addremove', formatteropts) | @command(b'perf::addremove|perfaddremove', formatteropts) | ||||
| def perfaddremove(ui, repo, **opts): | def perfaddremove(ui, repo, **opts): | ||||
| opts = _byteskwargs(opts) | opts = _byteskwargs(opts) | ||||
| timer, fm = gettimer(ui, opts) | timer, fm = gettimer(ui, opts) | ||||
| try: | try: | ||||
| oldquiet = repo.ui.quiet | oldquiet = repo.ui.quiet | ||||
| repo.ui.quiet = True | repo.ui.quiet = True | ||||
| matcher = scmutil.match(repo[None]) | matcher = scmutil.match(repo[None]) | ||||
| opts[b'dry_run'] = True | opts[b'dry_run'] = True | ||||
| elif util.safehasattr(cl, b'_nodecache'): | elif util.safehasattr(cl, b'_nodecache'): | ||||
| # <= hg-5.2 | # <= hg-5.2 | ||||
| from mercurial.node import nullid, nullrev | from mercurial.node import nullid, nullrev | ||||
| cl._nodecache = {nullid: nullrev} | cl._nodecache = {nullid: nullrev} | ||||
| cl._nodepos = None | cl._nodepos = None | ||||
| @command(b'perf--heads', formatteropts) | @command(b'perf::heads|perfheads', formatteropts) | ||||
| def perfheads(ui, repo, **opts): | def perfheads(ui, repo, **opts): | ||||
| """benchmark the computation of a changelog heads""" | """benchmark the computation of a changelog heads""" | ||||
| opts = _byteskwargs(opts) | opts = _byteskwargs(opts) | ||||
| timer, fm = gettimer(ui, opts) | timer, fm = gettimer(ui, opts) | ||||
| cl = repo.changelog | cl = repo.changelog | ||||
| def s(): | def s(): | ||||
| clearcaches(cl) | clearcaches(cl) | ||||
| def d(): | def d(): | ||||
| len(cl.headrevs()) | len(cl.headrevs()) | ||||
| timer(d, setup=s) | timer(d, setup=s) | ||||
| fm.end() | fm.end() | ||||
| @command( | @command( | ||||
| b'perf--tags', | b'perf::tags|perftags', | ||||
| formatteropts | formatteropts | ||||
| + [ | + [ | ||||
| (b'', b'clear-revlogs', False, b'refresh changelog and manifest'), | (b'', b'clear-revlogs', False, b'refresh changelog and manifest'), | ||||
| ], | ], | ||||
| ) | ) | ||||
| def perftags(ui, repo, **opts): | def perftags(ui, repo, **opts): | ||||
| opts = _byteskwargs(opts) | opts = _byteskwargs(opts) | ||||
| timer, fm = gettimer(ui, opts) | timer, fm = gettimer(ui, opts) | ||||
| repocleartagscache = repocleartagscachefunc(repo) | repocleartagscache = repocleartagscachefunc(repo) | ||||
| clearrevlogs = opts[b'clear_revlogs'] | clearrevlogs = opts[b'clear_revlogs'] | ||||
| def s(): | def s(): | ||||
| if clearrevlogs: | if clearrevlogs: | ||||
| clearchangelog(repo) | clearchangelog(repo) | ||||
| clearfilecache(repo.unfiltered(), 'manifest') | clearfilecache(repo.unfiltered(), 'manifest') | ||||
| repocleartagscache() | repocleartagscache() | ||||
| def t(): | def t(): | ||||
| return len(repo.tags()) | return len(repo.tags()) | ||||
| timer(t, setup=s) | timer(t, setup=s) | ||||
| fm.end() | fm.end() | ||||
| @command(b'perf--ancestors', formatteropts) | @command(b'perf::ancestors|perfancestors', formatteropts) | ||||
| def perfancestors(ui, repo, **opts): | def perfancestors(ui, repo, **opts): | ||||
| opts = _byteskwargs(opts) | opts = _byteskwargs(opts) | ||||
| timer, fm = gettimer(ui, opts) | timer, fm = gettimer(ui, opts) | ||||
| heads = repo.changelog.headrevs() | heads = repo.changelog.headrevs() | ||||
| def d(): | def d(): | ||||
| for a in repo.changelog.ancestors(heads): | for a in repo.changelog.ancestors(heads): | ||||
| pass | pass | ||||
| timer(d) | timer(d) | ||||
| fm.end() | fm.end() | ||||
| @command(b'perf--ancestorset', formatteropts) | @command(b'perf::ancestorset|perfancestorset', formatteropts) | ||||
| def perfancestorset(ui, repo, revset, **opts): | def perfancestorset(ui, repo, revset, **opts): | ||||
| opts = _byteskwargs(opts) | opts = _byteskwargs(opts) | ||||
| timer, fm = gettimer(ui, opts) | timer, fm = gettimer(ui, opts) | ||||
| revs = repo.revs(revset) | revs = repo.revs(revset) | ||||
| heads = repo.changelog.headrevs() | heads = repo.changelog.headrevs() | ||||
| def d(): | def d(): | ||||
| s = repo.changelog.ancestors(heads) | s = repo.changelog.ancestors(heads) | ||||
| for rev in revs: | for rev in revs: | ||||
| rev in s | rev in s | ||||
| timer(d) | timer(d) | ||||
| fm.end() | fm.end() | ||||
| @command(b'perf--discovery', formatteropts, b'PATH') | @command(b'perf::discovery|perfdiscovery', formatteropts, b'PATH') | ||||
| def perfdiscovery(ui, repo, path, **opts): | def perfdiscovery(ui, repo, path, **opts): | ||||
| """benchmark discovery between local repo and the peer at given path""" | """benchmark discovery between local repo and the peer at given path""" | ||||
| repos = [repo, None] | repos = [repo, None] | ||||
| timer, fm = gettimer(ui, opts) | timer, fm = gettimer(ui, opts) | ||||
| path = ui.expandpath(path) | path = ui.expandpath(path) | ||||
| def s(): | def s(): | ||||
| repos[1] = hg.peer(ui, opts, path) | repos[1] = hg.peer(ui, opts, path) | ||||
| def d(): | def d(): | ||||
| setdiscovery.findcommonheads(ui, *repos) | setdiscovery.findcommonheads(ui, *repos) | ||||
| timer(d, setup=s) | timer(d, setup=s) | ||||
| fm.end() | fm.end() | ||||
| @command( | @command( | ||||
| b'perf--bookmarks', | b'perf::bookmarks|perfbookmarks', | ||||
| formatteropts | formatteropts | ||||
| + [ | + [ | ||||
| (b'', b'clear-revlogs', False, b'refresh changelog and manifest'), | (b'', b'clear-revlogs', False, b'refresh changelog and manifest'), | ||||
| ], | ], | ||||
| ) | ) | ||||
| def perfbookmarks(ui, repo, **opts): | def perfbookmarks(ui, repo, **opts): | ||||
| """benchmark parsing bookmarks from disk to memory""" | """benchmark parsing bookmarks from disk to memory""" | ||||
| opts = _byteskwargs(opts) | opts = _byteskwargs(opts) | ||||
| timer, fm = gettimer(ui, opts) | timer, fm = gettimer(ui, opts) | ||||
| clearrevlogs = opts[b'clear_revlogs'] | clearrevlogs = opts[b'clear_revlogs'] | ||||
| def s(): | def s(): | ||||
| if clearrevlogs: | if clearrevlogs: | ||||
| clearchangelog(repo) | clearchangelog(repo) | ||||
| clearfilecache(repo, b'_bookmarks') | clearfilecache(repo, b'_bookmarks') | ||||
| def d(): | def d(): | ||||
| repo._bookmarks | repo._bookmarks | ||||
| timer(d, setup=s) | timer(d, setup=s) | ||||
| fm.end() | fm.end() | ||||
| @command(b'perf--bundleread', formatteropts, b'BUNDLE') | @command(b'perf::bundleread|perfbundleread', formatteropts, b'BUNDLE') | ||||
| def perfbundleread(ui, repo, bundlepath, **opts): | def perfbundleread(ui, repo, bundlepath, **opts): | ||||
| """Benchmark reading of bundle files. | """Benchmark reading of bundle files. | ||||
| This command is meant to isolate the I/O part of bundle reading as | This command is meant to isolate the I/O part of bundle reading as | ||||
| much as possible. | much as possible. | ||||
| """ | """ | ||||
| from mercurial import ( | from mercurial import ( | ||||
| bundle2, | bundle2, | ||||
| for fn, title in benches: | for fn, title in benches: | ||||
| timer, fm = gettimer(ui, opts) | timer, fm = gettimer(ui, opts) | ||||
| timer(fn, title=title) | timer(fn, title=title) | ||||
| fm.end() | fm.end() | ||||
| @command( | @command( | ||||
| b'perf--changegroupchangelog', | b'perf::changegroupchangelog|perfchangegroupchangelog', | ||||
| formatteropts | formatteropts | ||||
| + [ | + [ | ||||
| (b'', b'cgversion', b'02', b'changegroup version'), | (b'', b'cgversion', b'02', b'changegroup version'), | ||||
| (b'r', b'rev', b'', b'revisions to add to changegroup'), | (b'r', b'rev', b'', b'revisions to add to changegroup'), | ||||
| ], | ], | ||||
| ) | ) | ||||
| def perfchangegroupchangelog(ui, repo, cgversion=b'02', rev=None, **opts): | def perfchangegroupchangelog(ui, repo, cgversion=b'02', rev=None, **opts): | ||||
| """Benchmark producing a changelog group for a changegroup. | """Benchmark producing a changelog group for a changegroup. | ||||
| # Terminal printing can interfere with timing. So disable it. | # Terminal printing can interfere with timing. So disable it. | ||||
| with ui.configoverride({(b'progress', b'disable'): True}): | with ui.configoverride({(b'progress', b'disable'): True}): | ||||
| timer(d) | timer(d) | ||||
| fm.end() | fm.end() | ||||
| @command(b'perf--dirs', formatteropts) | @command(b'perf::dirs|perfdirs', formatteropts) | ||||
| def perfdirs(ui, repo, **opts): | def perfdirs(ui, repo, **opts): | ||||
| opts = _byteskwargs(opts) | opts = _byteskwargs(opts) | ||||
| timer, fm = gettimer(ui, opts) | timer, fm = gettimer(ui, opts) | ||||
| dirstate = repo.dirstate | dirstate = repo.dirstate | ||||
| b'a' in dirstate | b'a' in dirstate | ||||
| def d(): | def d(): | ||||
| dirstate.hasdir(b'a') | dirstate.hasdir(b'a') | ||||
| del dirstate._map._dirs | del dirstate._map._dirs | ||||
| timer(d) | timer(d) | ||||
| fm.end() | fm.end() | ||||
| @command( | @command( | ||||
| b'perf--dirstate', | b'perf::dirstate|perfdirstate', | ||||
| [ | [ | ||||
| ( | ( | ||||
| b'', | b'', | ||||
| b'iteration', | b'iteration', | ||||
| None, | None, | ||||
| b'benchmark a full iteration for the dirstate', | b'benchmark a full iteration for the dirstate', | ||||
| ), | ), | ||||
| ( | ( | ||||
| def d(): | def d(): | ||||
| b"a" in repo.dirstate | b"a" in repo.dirstate | ||||
| timer(d, setup=setup) | timer(d, setup=setup) | ||||
| fm.end() | fm.end() | ||||
| @command(b'perf--dirstatedirs', formatteropts) | @command(b'perf::dirstatedirs|perfdirstatedirs', formatteropts) | ||||
| def perfdirstatedirs(ui, repo, **opts): | def perfdirstatedirs(ui, repo, **opts): | ||||
| """benchmap a 'dirstate.hasdir' call from an empty `dirs` cache""" | """benchmap a 'dirstate.hasdir' call from an empty `dirs` cache""" | ||||
| opts = _byteskwargs(opts) | opts = _byteskwargs(opts) | ||||
| timer, fm = gettimer(ui, opts) | timer, fm = gettimer(ui, opts) | ||||
| repo.dirstate.hasdir(b"a") | repo.dirstate.hasdir(b"a") | ||||
| def setup(): | def setup(): | ||||
| del repo.dirstate._map._dirs | del repo.dirstate._map._dirs | ||||
| def d(): | def d(): | ||||
| repo.dirstate.hasdir(b"a") | repo.dirstate.hasdir(b"a") | ||||
| timer(d, setup=setup) | timer(d, setup=setup) | ||||
| fm.end() | fm.end() | ||||
| @command(b'perf--dirstatefoldmap', formatteropts) | @command(b'perf::dirstatefoldmap|perfdirstatefoldmap', formatteropts) | ||||
| def perfdirstatefoldmap(ui, repo, **opts): | def perfdirstatefoldmap(ui, repo, **opts): | ||||
| """benchmap a `dirstate._map.filefoldmap.get()` request | """benchmap a `dirstate._map.filefoldmap.get()` request | ||||
| The dirstate filefoldmap cache is dropped between every request. | The dirstate filefoldmap cache is dropped between every request. | ||||
| """ | """ | ||||
| opts = _byteskwargs(opts) | opts = _byteskwargs(opts) | ||||
| timer, fm = gettimer(ui, opts) | timer, fm = gettimer(ui, opts) | ||||
| dirstate = repo.dirstate | dirstate = repo.dirstate | ||||
| dirstate._map.filefoldmap.get(b'a') | dirstate._map.filefoldmap.get(b'a') | ||||
| def setup(): | def setup(): | ||||
| del dirstate._map.filefoldmap | del dirstate._map.filefoldmap | ||||
| def d(): | def d(): | ||||
| dirstate._map.filefoldmap.get(b'a') | dirstate._map.filefoldmap.get(b'a') | ||||
| timer(d, setup=setup) | timer(d, setup=setup) | ||||
| fm.end() | fm.end() | ||||
| @command(b'perf--dirfoldmap', formatteropts) | @command(b'perf::dirfoldmap|perfdirfoldmap', formatteropts) | ||||
| def perfdirfoldmap(ui, repo, **opts): | def perfdirfoldmap(ui, repo, **opts): | ||||
| """benchmap a `dirstate._map.dirfoldmap.get()` request | """benchmap a `dirstate._map.dirfoldmap.get()` request | ||||
| The dirstate dirfoldmap cache is dropped between every request. | The dirstate dirfoldmap cache is dropped between every request. | ||||
| """ | """ | ||||
| opts = _byteskwargs(opts) | opts = _byteskwargs(opts) | ||||
| timer, fm = gettimer(ui, opts) | timer, fm = gettimer(ui, opts) | ||||
| dirstate = repo.dirstate | dirstate = repo.dirstate | ||||
| dirstate._map.dirfoldmap.get(b'a') | dirstate._map.dirfoldmap.get(b'a') | ||||
| def setup(): | def setup(): | ||||
| del dirstate._map.dirfoldmap | del dirstate._map.dirfoldmap | ||||
| del dirstate._map._dirs | del dirstate._map._dirs | ||||
| def d(): | def d(): | ||||
| dirstate._map.dirfoldmap.get(b'a') | dirstate._map.dirfoldmap.get(b'a') | ||||
| timer(d, setup=setup) | timer(d, setup=setup) | ||||
| fm.end() | fm.end() | ||||
| @command(b'perf--dirstatewrite', formatteropts) | @command(b'perf::dirstatewrite|perfdirstatewrite', formatteropts) | ||||
| def perfdirstatewrite(ui, repo, **opts): | def perfdirstatewrite(ui, repo, **opts): | ||||
| """benchmap the time it take to write a dirstate on disk""" | """benchmap the time it take to write a dirstate on disk""" | ||||
| opts = _byteskwargs(opts) | opts = _byteskwargs(opts) | ||||
| timer, fm = gettimer(ui, opts) | timer, fm = gettimer(ui, opts) | ||||
| ds = repo.dirstate | ds = repo.dirstate | ||||
| b"a" in ds | b"a" in ds | ||||
| def setup(): | def setup(): | ||||
| fromrev = scmutil.revsingle(repo, opts[b'base']) | fromrev = scmutil.revsingle(repo, opts[b'base']) | ||||
| ancestor = repo[fromrev] | ancestor = repo[fromrev] | ||||
| else: | else: | ||||
| ancestor = wctx.ancestor(rctx) | ancestor = wctx.ancestor(rctx) | ||||
| return (wctx, rctx, ancestor) | return (wctx, rctx, ancestor) | ||||
| @command( | @command( | ||||
| b'perf--mergecalculate', | b'perf::mergecalculate|perfmergecalculate', | ||||
| [ | [ | ||||
| (b'r', b'rev', b'.', b'rev to merge against'), | (b'r', b'rev', b'.', b'rev to merge against'), | ||||
| (b'', b'from', b'', b'rev to merge from'), | (b'', b'from', b'', b'rev to merge from'), | ||||
| (b'', b'base', b'', b'the revision to use as base'), | (b'', b'base', b'', b'the revision to use as base'), | ||||
| ] | ] | ||||
| + formatteropts, | + formatteropts, | ||||
| ) | ) | ||||
| def perfmergecalculate(ui, repo, **opts): | def perfmergecalculate(ui, repo, **opts): | ||||
| followcopies=True, | followcopies=True, | ||||
| ) | ) | ||||
| timer(d) | timer(d) | ||||
| fm.end() | fm.end() | ||||
| @command( | @command( | ||||
| b'perf--mergecopies', | b'perf::mergecopies|perfmergecopies', | ||||
| [ | [ | ||||
| (b'r', b'rev', b'.', b'rev to merge against'), | (b'r', b'rev', b'.', b'rev to merge against'), | ||||
| (b'', b'from', b'', b'rev to merge from'), | (b'', b'from', b'', b'rev to merge from'), | ||||
| (b'', b'base', b'', b'the revision to use as base'), | (b'', b'base', b'', b'the revision to use as base'), | ||||
| ] | ] | ||||
| + formatteropts, | + formatteropts, | ||||
| ) | ) | ||||
| def perfmergecopies(ui, repo, **opts): | def perfmergecopies(ui, repo, **opts): | ||||
| """measure runtime of `copies.mergecopies`""" | """measure runtime of `copies.mergecopies`""" | ||||
| opts = _byteskwargs(opts) | opts = _byteskwargs(opts) | ||||
| timer, fm = gettimer(ui, opts) | timer, fm = gettimer(ui, opts) | ||||
| wctx, rctx, ancestor = _getmergerevs(repo, opts) | wctx, rctx, ancestor = _getmergerevs(repo, opts) | ||||
| def d(): | def d(): | ||||
| # acceptremote is True because we don't want prompts in the middle of | # acceptremote is True because we don't want prompts in the middle of | ||||
| # our benchmark | # our benchmark | ||||
| copies.mergecopies(repo, wctx, rctx, ancestor) | copies.mergecopies(repo, wctx, rctx, ancestor) | ||||
| timer(d) | timer(d) | ||||
| fm.end() | fm.end() | ||||
| @command(b'perf--pathcopies', [], b"REV REV") | @command(b'perf::pathcopies|perfpathcopies', [], b"REV REV") | ||||
| def perfpathcopies(ui, repo, rev1, rev2, **opts): | def perfpathcopies(ui, repo, rev1, rev2, **opts): | ||||
| """benchmark the copy tracing logic""" | """benchmark the copy tracing logic""" | ||||
| opts = _byteskwargs(opts) | opts = _byteskwargs(opts) | ||||
| timer, fm = gettimer(ui, opts) | timer, fm = gettimer(ui, opts) | ||||
| ctx1 = scmutil.revsingle(repo, rev1, rev1) | ctx1 = scmutil.revsingle(repo, rev1, rev1) | ||||
| ctx2 = scmutil.revsingle(repo, rev2, rev2) | ctx2 = scmutil.revsingle(repo, rev2, rev2) | ||||
| def d(): | def d(): | ||||
| copies.pathcopies(ctx1, ctx2) | copies.pathcopies(ctx1, ctx2) | ||||
| timer(d) | timer(d) | ||||
| fm.end() | fm.end() | ||||
| @command( | @command( | ||||
| b'perf--phases', | b'perf::phases|perfphases', | ||||
| [ | [ | ||||
| (b'', b'full', False, b'include file reading time too'), | (b'', b'full', False, b'include file reading time too'), | ||||
| ], | ], | ||||
| b"", | b"", | ||||
| ) | ) | ||||
| def perfphases(ui, repo, **opts): | def perfphases(ui, repo, **opts): | ||||
| """benchmark phasesets computation""" | """benchmark phasesets computation""" | ||||
| opts = _byteskwargs(opts) | opts = _byteskwargs(opts) | ||||
| timer, fm = gettimer(ui, opts) | timer, fm = gettimer(ui, opts) | ||||
| _phases = repo._phasecache | _phases = repo._phasecache | ||||
| full = opts.get(b'full') | full = opts.get(b'full') | ||||
| def d(): | def d(): | ||||
| phases = _phases | phases = _phases | ||||
| if full: | if full: | ||||
| clearfilecache(repo, b'_phasecache') | clearfilecache(repo, b'_phasecache') | ||||
| phases = repo._phasecache | phases = repo._phasecache | ||||
| phases.invalidate() | phases.invalidate() | ||||
| phases.loadphaserevs(repo) | phases.loadphaserevs(repo) | ||||
| timer(d) | timer(d) | ||||
| fm.end() | fm.end() | ||||
| @command(b'perf--phasesremote', [], b"[DEST]") | @command(b'perf::phasesremote|perfphasesremote', [], b"[DEST]") | ||||
| def perfphasesremote(ui, repo, dest=None, **opts): | def perfphasesremote(ui, repo, dest=None, **opts): | ||||
| """benchmark time needed to analyse phases of the remote server""" | """benchmark time needed to analyse phases of the remote server""" | ||||
| from mercurial.node import bin | from mercurial.node import bin | ||||
| from mercurial import ( | from mercurial import ( | ||||
| exchange, | exchange, | ||||
| hg, | hg, | ||||
| phases, | phases, | ||||
| ) | ) | ||||
| def d(): | def d(): | ||||
| phases.remotephasessummary(repo, remotesubset, remotephases) | phases.remotephasessummary(repo, remotesubset, remotephases) | ||||
| timer(d) | timer(d) | ||||
| fm.end() | fm.end() | ||||
| @command( | @command( | ||||
| b'perf--manifest', | b'perf::manifest|perfmanifest', | ||||
| [ | [ | ||||
| (b'm', b'manifest-rev', False, b'Look up a manifest node revision'), | (b'm', b'manifest-rev', False, b'Look up a manifest node revision'), | ||||
| (b'', b'clear-disk', False, b'clear on-disk caches too'), | (b'', b'clear-disk', False, b'clear on-disk caches too'), | ||||
| ] | ] | ||||
| + formatteropts, | + formatteropts, | ||||
| b'REV|NODE', | b'REV|NODE', | ||||
| ) | ) | ||||
| def perfmanifest(ui, repo, rev, manifest_rev=False, clear_disk=False, **opts): | def perfmanifest(ui, repo, rev, manifest_rev=False, clear_disk=False, **opts): | ||||
| def d(): | def d(): | ||||
| repo.manifestlog.clearcaches(clear_persisted_data=clear_disk) | repo.manifestlog.clearcaches(clear_persisted_data=clear_disk) | ||||
| repo.manifestlog[t].read() | repo.manifestlog[t].read() | ||||
| timer(d) | timer(d) | ||||
| fm.end() | fm.end() | ||||
| @command(b'perf--changeset', formatteropts) | @command(b'perf::changeset|perfchangeset', formatteropts) | ||||
| def perfchangeset(ui, repo, rev, **opts): | def perfchangeset(ui, repo, rev, **opts): | ||||
| opts = _byteskwargs(opts) | opts = _byteskwargs(opts) | ||||
| timer, fm = gettimer(ui, opts) | timer, fm = gettimer(ui, opts) | ||||
| n = scmutil.revsingle(repo, rev).node() | n = scmutil.revsingle(repo, rev).node() | ||||
| def d(): | def d(): | ||||
| repo.changelog.read(n) | repo.changelog.read(n) | ||||
| # repo.changelog._cache = None | # repo.changelog._cache = None | ||||
| timer(d) | timer(d) | ||||
| fm.end() | fm.end() | ||||
| @command(b'perf--ignore', formatteropts) | @command(b'perf::ignore|perfignore', formatteropts) | ||||
| def perfignore(ui, repo, **opts): | def perfignore(ui, repo, **opts): | ||||
| """benchmark operation related to computing ignore""" | """benchmark operation related to computing ignore""" | ||||
| opts = _byteskwargs(opts) | opts = _byteskwargs(opts) | ||||
| timer, fm = gettimer(ui, opts) | timer, fm = gettimer(ui, opts) | ||||
| dirstate = repo.dirstate | dirstate = repo.dirstate | ||||
| def setupone(): | def setupone(): | ||||
| dirstate.invalidate() | dirstate.invalidate() | ||||
| clearfilecache(dirstate, b'_ignore') | clearfilecache(dirstate, b'_ignore') | ||||
| def runone(): | def runone(): | ||||
| dirstate._ignore | dirstate._ignore | ||||
| timer(runone, setup=setupone, title=b"load") | timer(runone, setup=setupone, title=b"load") | ||||
| fm.end() | fm.end() | ||||
| @command( | @command( | ||||
| b'perf--index', | b'perf::index|perfindex', | ||||
| [ | [ | ||||
| (b'', b'rev', [], b'revision to be looked up (default tip)'), | (b'', b'rev', [], b'revision to be looked up (default tip)'), | ||||
| (b'', b'no-lookup', None, b'do not revision lookup post creation'), | (b'', b'no-lookup', None, b'do not revision lookup post creation'), | ||||
| ] | ] | ||||
| + formatteropts, | + formatteropts, | ||||
| ) | ) | ||||
| def perfindex(ui, repo, **opts): | def perfindex(ui, repo, **opts): | ||||
| """benchmark index creation time followed by a lookup | """benchmark index creation time followed by a lookup | ||||
| for n in nodes: | for n in nodes: | ||||
| cl.rev(n) | cl.rev(n) | ||||
| timer(d, setup=setup) | timer(d, setup=setup) | ||||
| fm.end() | fm.end() | ||||
| @command( | @command( | ||||
| b'perf--nodemap', | b'perf::nodemap|perfnodemap', | ||||
| [ | [ | ||||
| (b'', b'rev', [], b'revision to be looked up (default tip)'), | (b'', b'rev', [], b'revision to be looked up (default tip)'), | ||||
| (b'', b'clear-caches', True, b'clear revlog cache between calls'), | (b'', b'clear-caches', True, b'clear revlog cache between calls'), | ||||
| ] | ] | ||||
| + formatteropts, | + formatteropts, | ||||
| ) | ) | ||||
| def perfnodemap(ui, repo, **opts): | def perfnodemap(ui, repo, **opts): | ||||
| """benchmark the time necessary to look up revision from a cold nodemap | """benchmark the time necessary to look up revision from a cold nodemap | ||||
| else: | else: | ||||
| setnodeget() | setnodeget() | ||||
| d() # prewarm the data structure | d() # prewarm the data structure | ||||
| timer(d, setup=setup) | timer(d, setup=setup) | ||||
| fm.end() | fm.end() | ||||
| @command(b'perf--startup', formatteropts) | @command(b'perf::startup|perfstartup', formatteropts) | ||||
| def perfstartup(ui, repo, **opts): | def perfstartup(ui, repo, **opts): | ||||
| opts = _byteskwargs(opts) | opts = _byteskwargs(opts) | ||||
| timer, fm = gettimer(ui, opts) | timer, fm = gettimer(ui, opts) | ||||
| def d(): | def d(): | ||||
| if os.name != 'nt': | if os.name != 'nt': | ||||
| os.system( | os.system( | ||||
| b"HGRCPATH= %s version -q > /dev/null" % fsencode(sys.argv[0]) | b"HGRCPATH= %s version -q > /dev/null" % fsencode(sys.argv[0]) | ||||
| ) | ) | ||||
| else: | else: | ||||
| os.environ['HGRCPATH'] = r' ' | os.environ['HGRCPATH'] = r' ' | ||||
| os.system("%s version -q > NUL" % sys.argv[0]) | os.system("%s version -q > NUL" % sys.argv[0]) | ||||
| timer(d) | timer(d) | ||||
| fm.end() | fm.end() | ||||
| @command(b'perf--parents', formatteropts) | @command(b'perf::parents|perfparents', formatteropts) | ||||
| def perfparents(ui, repo, **opts): | def perfparents(ui, repo, **opts): | ||||
| """benchmark the time necessary to fetch one changeset's parents. | """benchmark the time necessary to fetch one changeset's parents. | ||||
| The fetch is done using the `node identifier`, traversing all object layers | The fetch is done using the `node identifier`, traversing all object layers | ||||
| from the repository object. The first N revisions will be used for this | from the repository object. The first N revisions will be used for this | ||||
| benchmark. N is controlled by the ``perf.parentscount`` config option | benchmark. N is controlled by the ``perf.parentscount`` config option | ||||
| (default: 1000). | (default: 1000). | ||||
| """ | """ | ||||
| def d(): | def d(): | ||||
| for n in nl: | for n in nl: | ||||
| repo.changelog.parents(n) | repo.changelog.parents(n) | ||||
| timer(d) | timer(d) | ||||
| fm.end() | fm.end() | ||||
| @command(b'perf--ctxfiles', formatteropts) | @command(b'perf::ctxfiles|perfctxfiles', formatteropts) | ||||
| def perfctxfiles(ui, repo, x, **opts): | def perfctxfiles(ui, repo, x, **opts): | ||||
| opts = _byteskwargs(opts) | opts = _byteskwargs(opts) | ||||
| x = int(x) | x = int(x) | ||||
| timer, fm = gettimer(ui, opts) | timer, fm = gettimer(ui, opts) | ||||
| def d(): | def d(): | ||||
| len(repo[x].files()) | len(repo[x].files()) | ||||
| timer(d) | timer(d) | ||||
| fm.end() | fm.end() | ||||
| @command(b'perf--rawfiles', formatteropts) | @command(b'perf::rawfiles|perfrawfiles', formatteropts) | ||||
| def perfrawfiles(ui, repo, x, **opts): | def perfrawfiles(ui, repo, x, **opts): | ||||
| opts = _byteskwargs(opts) | opts = _byteskwargs(opts) | ||||
| x = int(x) | x = int(x) | ||||
| timer, fm = gettimer(ui, opts) | timer, fm = gettimer(ui, opts) | ||||
| cl = repo.changelog | cl = repo.changelog | ||||
| def d(): | def d(): | ||||
| len(cl.read(x)[3]) | len(cl.read(x)[3]) | ||||
| timer(d) | timer(d) | ||||
| fm.end() | fm.end() | ||||
| @command(b'perf--lookup', formatteropts) | @command(b'perf::lookup|perflookup', formatteropts) | ||||
| def perflookup(ui, repo, rev, **opts): | def perflookup(ui, repo, rev, **opts): | ||||
| opts = _byteskwargs(opts) | opts = _byteskwargs(opts) | ||||
| timer, fm = gettimer(ui, opts) | timer, fm = gettimer(ui, opts) | ||||
| timer(lambda: len(repo.lookup(rev))) | timer(lambda: len(repo.lookup(rev))) | ||||
| fm.end() | fm.end() | ||||
| @command( | @command( | ||||
| b'perf--linelogedits', | b'perf::linelogedits|perflinelogedits', | ||||
| [ | [ | ||||
| (b'n', b'edits', 10000, b'number of edits'), | (b'n', b'edits', 10000, b'number of edits'), | ||||
| (b'', b'max-hunk-lines', 10, b'max lines in a hunk'), | (b'', b'max-hunk-lines', 10, b'max lines in a hunk'), | ||||
| ], | ], | ||||
| norepo=True, | norepo=True, | ||||
| ) | ) | ||||
| def perflinelogedits(ui, **opts): | def perflinelogedits(ui, **opts): | ||||
| from mercurial import linelog | from mercurial import linelog | ||||
| for args in arglist: | for args in arglist: | ||||
| ll.replacelines(*args) | ll.replacelines(*args) | ||||
| timer, fm = gettimer(ui, opts) | timer, fm = gettimer(ui, opts) | ||||
| timer(d) | timer(d) | ||||
| fm.end() | fm.end() | ||||
| @command(b'perf--revrange', formatteropts) | @command(b'perf::revrange|perfrevrange', formatteropts) | ||||
| def perfrevrange(ui, repo, *specs, **opts): | def perfrevrange(ui, repo, *specs, **opts): | ||||
| opts = _byteskwargs(opts) | opts = _byteskwargs(opts) | ||||
| timer, fm = gettimer(ui, opts) | timer, fm = gettimer(ui, opts) | ||||
| revrange = scmutil.revrange | revrange = scmutil.revrange | ||||
| timer(lambda: len(revrange(repo, specs))) | timer(lambda: len(revrange(repo, specs))) | ||||
| fm.end() | fm.end() | ||||
| @command(b'perf--nodelookup', formatteropts) | @command(b'perf::nodelookup|perfnodelookup', formatteropts) | ||||
| def perfnodelookup(ui, repo, rev, **opts): | def perfnodelookup(ui, repo, rev, **opts): | ||||
| opts = _byteskwargs(opts) | opts = _byteskwargs(opts) | ||||
| timer, fm = gettimer(ui, opts) | timer, fm = gettimer(ui, opts) | ||||
| import mercurial.revlog | import mercurial.revlog | ||||
| mercurial.revlog._prereadsize = 2 ** 24 # disable lazy parser in old hg | mercurial.revlog._prereadsize = 2 ** 24 # disable lazy parser in old hg | ||||
| n = scmutil.revsingle(repo, rev).node() | n = scmutil.revsingle(repo, rev).node() | ||||
| cl = mercurial.revlog.revlog(getsvfs(repo), b"00changelog.i") | cl = mercurial.revlog.revlog(getsvfs(repo), b"00changelog.i") | ||||
| def d(): | def d(): | ||||
| cl.rev(n) | cl.rev(n) | ||||
| clearcaches(cl) | clearcaches(cl) | ||||
| timer(d) | timer(d) | ||||
| fm.end() | fm.end() | ||||
| @command( | @command( | ||||
| b'perf--log', | b'perf::log|perflog', | ||||
| [(b'', b'rename', False, b'ask log to follow renames')] + formatteropts, | [(b'', b'rename', False, b'ask log to follow renames')] + formatteropts, | ||||
| ) | ) | ||||
| def perflog(ui, repo, rev=None, **opts): | def perflog(ui, repo, rev=None, **opts): | ||||
| opts = _byteskwargs(opts) | opts = _byteskwargs(opts) | ||||
| if rev is None: | if rev is None: | ||||
| rev = [] | rev = [] | ||||
| timer, fm = gettimer(ui, opts) | timer, fm = gettimer(ui, opts) | ||||
| ui.pushbuffer() | ui.pushbuffer() | ||||
| timer( | timer( | ||||
| lambda: commands.log( | lambda: commands.log( | ||||
| ui, repo, rev=rev, date=b'', user=b'', copies=opts.get(b'rename') | ui, repo, rev=rev, date=b'', user=b'', copies=opts.get(b'rename') | ||||
| ) | ) | ||||
| ) | ) | ||||
| ui.popbuffer() | ui.popbuffer() | ||||
| fm.end() | fm.end() | ||||
| @command(b'perf--moonwalk', formatteropts) | @command(b'perf::moonwalk|perfmoonwalk', formatteropts) | ||||
| def perfmoonwalk(ui, repo, **opts): | def perfmoonwalk(ui, repo, **opts): | ||||
| """benchmark walking the changelog backwards | """benchmark walking the changelog backwards | ||||
| This also loads the changelog data for each revision in the changelog. | This also loads the changelog data for each revision in the changelog. | ||||
| """ | """ | ||||
| opts = _byteskwargs(opts) | opts = _byteskwargs(opts) | ||||
| timer, fm = gettimer(ui, opts) | timer, fm = gettimer(ui, opts) | ||||
| def moonwalk(): | def moonwalk(): | ||||
| for i in repo.changelog.revs(start=(len(repo) - 1), stop=-1): | for i in repo.changelog.revs(start=(len(repo) - 1), stop=-1): | ||||
| ctx = repo[i] | ctx = repo[i] | ||||
| ctx.branch() # read changelog data (in addition to the index) | ctx.branch() # read changelog data (in addition to the index) | ||||
| timer(moonwalk) | timer(moonwalk) | ||||
| fm.end() | fm.end() | ||||
| @command( | @command( | ||||
| b'perf--templating', | b'perf::templating|perftemplating', | ||||
| [ | [ | ||||
| (b'r', b'rev', [], b'revisions to run the template on'), | (b'r', b'rev', [], b'revisions to run the template on'), | ||||
| ] | ] | ||||
| + formatteropts, | + formatteropts, | ||||
| ) | ) | ||||
| def perftemplating(ui, repo, testedtemplate=None, **opts): | def perftemplating(ui, repo, testedtemplate=None, **opts): | ||||
| """test the rendering time of a given template""" | """test the rendering time of a given template""" | ||||
| if makelogtemplater is None: | if makelogtemplater is None: | ||||
| 'max', | 'max', | ||||
| ] | ] | ||||
| for l in lines: | for l in lines: | ||||
| fm.plain('%s: %s\n' % (l, stats[l])) | fm.plain('%s: %s\n' % (l, stats[l])) | ||||
| fm.end() | fm.end() | ||||
| @command( | @command( | ||||
| b'perf--helper-mergecopies', | b'perf::helper-mergecopies|perfhelper-mergecopies', | ||||
| formatteropts | formatteropts | ||||
| + [ | + [ | ||||
| (b'r', b'revs', [], b'restrict search to these revisions'), | (b'r', b'revs', [], b'restrict search to these revisions'), | ||||
| (b'', b'timing', False, b'provides extra data (costly)'), | (b'', b'timing', False, b'provides extra data (costly)'), | ||||
| (b'', b'stats', False, b'provides statistic about the measured data'), | (b'', b'stats', False, b'provides statistic about the measured data'), | ||||
| ], | ], | ||||
| ) | ) | ||||
| def perfhelpermergecopies(ui, repo, revs=[], **opts): | def perfhelpermergecopies(ui, repo, revs=[], **opts): | ||||
| ) | ) | ||||
| entries.append(('totalnbrenames', 'total number of renames')) | entries.append(('totalnbrenames', 'total number of renames')) | ||||
| entries.append(('parenttime', 'time for one parent')) | entries.append(('parenttime', 'time for one parent')) | ||||
| entries.append(('totaltime', 'time for both parents')) | entries.append(('totaltime', 'time for both parents')) | ||||
| _displaystats(ui, opts, entries, alldata) | _displaystats(ui, opts, entries, alldata) | ||||
| @command( | @command( | ||||
| b'perf--helper-pathcopies', | b'perf::helper-pathcopies|perfhelper-pathcopies', | ||||
| formatteropts | formatteropts | ||||
| + [ | + [ | ||||
| (b'r', b'revs', [], b'restrict search to these revisions'), | (b'r', b'revs', [], b'restrict search to these revisions'), | ||||
| (b'', b'timing', False, b'provides extra data (costly)'), | (b'', b'timing', False, b'provides extra data (costly)'), | ||||
| (b'', b'stats', False, b'provides statistic about the measured data'), | (b'', b'stats', False, b'provides statistic about the measured data'), | ||||
| ], | ], | ||||
| ) | ) | ||||
| def perfhelperpathcopies(ui, repo, revs=[], **opts): | def perfhelperpathcopies(ui, repo, revs=[], **opts): | ||||
| ('nbmissingfiles', 'number of missing files at head'), | ('nbmissingfiles', 'number of missing files at head'), | ||||
| ] | ] | ||||
| if dotiming: | if dotiming: | ||||
| entries.append(('nbrenames', 'renamed files')) | entries.append(('nbrenames', 'renamed files')) | ||||
| entries.append(('time', 'time')) | entries.append(('time', 'time')) | ||||
| _displaystats(ui, opts, entries, alldata) | _displaystats(ui, opts, entries, alldata) | ||||
| @command(b'perf--cca', formatteropts) | @command(b'perf::cca|perfcca', formatteropts) | ||||
| def perfcca(ui, repo, **opts): | def perfcca(ui, repo, **opts): | ||||
| opts = _byteskwargs(opts) | opts = _byteskwargs(opts) | ||||
| timer, fm = gettimer(ui, opts) | timer, fm = gettimer(ui, opts) | ||||
| timer(lambda: scmutil.casecollisionauditor(ui, False, repo.dirstate)) | timer(lambda: scmutil.casecollisionauditor(ui, False, repo.dirstate)) | ||||
| fm.end() | fm.end() | ||||
| @command(b'perf--fncacheload', formatteropts) | @command(b'perf::fncacheload|perffncacheload', formatteropts) | ||||
| def perffncacheload(ui, repo, **opts): | def perffncacheload(ui, repo, **opts): | ||||
| opts = _byteskwargs(opts) | opts = _byteskwargs(opts) | ||||
| timer, fm = gettimer(ui, opts) | timer, fm = gettimer(ui, opts) | ||||
| s = repo.store | s = repo.store | ||||
| def d(): | def d(): | ||||
| s.fncache._load() | s.fncache._load() | ||||
| timer(d) | timer(d) | ||||
| fm.end() | fm.end() | ||||
| @command(b'perf--fncachewrite', formatteropts) | @command(b'perf::fncachewrite|perffncachewrite', formatteropts) | ||||
| def perffncachewrite(ui, repo, **opts): | def perffncachewrite(ui, repo, **opts): | ||||
| opts = _byteskwargs(opts) | opts = _byteskwargs(opts) | ||||
| timer, fm = gettimer(ui, opts) | timer, fm = gettimer(ui, opts) | ||||
| s = repo.store | s = repo.store | ||||
| lock = repo.lock() | lock = repo.lock() | ||||
| s.fncache._load() | s.fncache._load() | ||||
| tr = repo.transaction(b'perffncachewrite') | tr = repo.transaction(b'perffncachewrite') | ||||
| tr.addbackup(b'fncache') | tr.addbackup(b'fncache') | ||||
| def d(): | def d(): | ||||
| s.fncache._dirty = True | s.fncache._dirty = True | ||||
| s.fncache.write(tr) | s.fncache.write(tr) | ||||
| timer(d) | timer(d) | ||||
| tr.close() | tr.close() | ||||
| lock.release() | lock.release() | ||||
| fm.end() | fm.end() | ||||
| @command(b'perf--fncacheencode', formatteropts) | @command(b'perf::fncacheencode|perffncacheencode', formatteropts) | ||||
| def perffncacheencode(ui, repo, **opts): | def perffncacheencode(ui, repo, **opts): | ||||
| opts = _byteskwargs(opts) | opts = _byteskwargs(opts) | ||||
| timer, fm = gettimer(ui, opts) | timer, fm = gettimer(ui, opts) | ||||
| s = repo.store | s = repo.store | ||||
| s.fncache._load() | s.fncache._load() | ||||
| def d(): | def d(): | ||||
| for p in s.fncache.entries: | for p in s.fncache.entries: | ||||
| store = ml.getstorage(b'') | store = ml.getstorage(b'') | ||||
| else: | else: | ||||
| store = ml._revlog | store = ml._revlog | ||||
| return store.revision(mnode) | return store.revision(mnode) | ||||
| @command( | @command( | ||||
| b'perf--bdiff', | b'perf::bdiff|perfbdiff', | ||||
| revlogopts | revlogopts | ||||
| + formatteropts | + formatteropts | ||||
| + [ | + [ | ||||
| ( | ( | ||||
| b'', | b'', | ||||
| b'count', | b'count', | ||||
| 1, | 1, | ||||
| b'number of revisions to test (when using --startrev)', | b'number of revisions to test (when using --startrev)', | ||||
| done.set() | done.set() | ||||
| for i in _xrange(threads): | for i in _xrange(threads): | ||||
| q.put(None) | q.put(None) | ||||
| with ready: | with ready: | ||||
| ready.notify_all() | ready.notify_all() | ||||
| @command( | @command( | ||||
| b'perf--unidiff', | b'perf::unidiff|perfunidiff', | ||||
| revlogopts | revlogopts | ||||
| + formatteropts | + formatteropts | ||||
| + [ | + [ | ||||
| ( | ( | ||||
| b'', | b'', | ||||
| b'count', | b'count', | ||||
| 1, | 1, | ||||
| b'number of revisions to test (when using --startrev)', | b'number of revisions to test (when using --startrev)', | ||||
| b'\n'.join(headerlines) | b'\n'.join(headerlines) | ||||
| b''.join(sum((list(hlines) for hrange, hlines in hunks), [])) | b''.join(sum((list(hlines) for hrange, hlines in hunks), [])) | ||||
| timer, fm = gettimer(ui, opts) | timer, fm = gettimer(ui, opts) | ||||
| timer(d) | timer(d) | ||||
| fm.end() | fm.end() | ||||
| @command(b'perf--diffwd', formatteropts) | @command(b'perf::diffwd|perfdiffwd', formatteropts) | ||||
| def perfdiffwd(ui, repo, **opts): | def perfdiffwd(ui, repo, **opts): | ||||
| """Profile diff of working directory changes""" | """Profile diff of working directory changes""" | ||||
| opts = _byteskwargs(opts) | opts = _byteskwargs(opts) | ||||
| timer, fm = gettimer(ui, opts) | timer, fm = gettimer(ui, opts) | ||||
| options = { | options = { | ||||
| 'w': 'ignore_all_space', | 'w': 'ignore_all_space', | ||||
| 'b': 'ignore_space_change', | 'b': 'ignore_space_change', | ||||
| 'B': 'ignore_blank_lines', | 'B': 'ignore_blank_lines', | ||||
| } | } | ||||
| for diffopt in ('', 'w', 'b', 'B', 'wB'): | for diffopt in ('', 'w', 'b', 'B', 'wB'): | ||||
| opts = {options[c]: b'1' for c in diffopt} | opts = {options[c]: b'1' for c in diffopt} | ||||
| def d(): | def d(): | ||||
| ui.pushbuffer() | ui.pushbuffer() | ||||
| commands.diff(ui, repo, **opts) | commands.diff(ui, repo, **opts) | ||||
| ui.popbuffer() | ui.popbuffer() | ||||
| diffopt = diffopt.encode('ascii') | diffopt = diffopt.encode('ascii') | ||||
| title = b'diffopts: %s' % (diffopt and (b'-' + diffopt) or b'none') | title = b'diffopts: %s' % (diffopt and (b'-' + diffopt) or b'none') | ||||
| timer(d, title=title) | timer(d, title=title) | ||||
| fm.end() | fm.end() | ||||
| @command(b'perf--revlogindex', revlogopts + formatteropts, b'-c|-m|FILE') | @command(b'perf::revlogindex|perfrevlogindex', revlogopts + formatteropts, b'-c|-m|FILE') | ||||
| def perfrevlogindex(ui, repo, file_=None, **opts): | def perfrevlogindex(ui, repo, file_=None, **opts): | ||||
| """Benchmark operations against a revlog index. | """Benchmark operations against a revlog index. | ||||
| This tests constructing a revlog instance, reading index data, | This tests constructing a revlog instance, reading index data, | ||||
| parsing index data, and performing various operations related to | parsing index data, and performing various operations related to | ||||
| index data. | index data. | ||||
| """ | """ | ||||
| for fn, title in benches: | for fn, title in benches: | ||||
| timer, fm = gettimer(ui, opts) | timer, fm = gettimer(ui, opts) | ||||
| timer(fn, title=title) | timer(fn, title=title) | ||||
| fm.end() | fm.end() | ||||
| @command( | @command( | ||||
| b'perf--revlogrevisions', | b'perf::revlogrevisions|perfrevlogrevisions', | ||||
| revlogopts | revlogopts | ||||
| + formatteropts | + formatteropts | ||||
| + [ | + [ | ||||
| (b'd', b'dist', 100, b'distance between the revisions'), | (b'd', b'dist', 100, b'distance between the revisions'), | ||||
| (b's', b'startrev', 0, b'revision to start reading at'), | (b's', b'startrev', 0, b'revision to start reading at'), | ||||
| (b'', b'reverse', False, b'read in reverse'), | (b'', b'reverse', False, b'read in reverse'), | ||||
| ], | ], | ||||
| b'-c|-m|FILE', | b'-c|-m|FILE', | ||||
| rl.revision(n) | rl.revision(n) | ||||
| timer, fm = gettimer(ui, opts) | timer, fm = gettimer(ui, opts) | ||||
| timer(d) | timer(d) | ||||
| fm.end() | fm.end() | ||||
| @command( | @command( | ||||
| b'perf--revlogwrite', | b'perf::revlogwrite|perfrevlogwrite', | ||||
| revlogopts | revlogopts | ||||
| + formatteropts | + formatteropts | ||||
| + [ | + [ | ||||
| (b's', b'startrev', 1000, b'revision to start writing at'), | (b's', b'startrev', 1000, b'revision to start writing at'), | ||||
| (b'', b'stoprev', -1, b'last revision to write'), | (b'', b'stoprev', -1, b'last revision to write'), | ||||
| (b'', b'count', 3, b'number of passes to perform'), | (b'', b'count', 3, b'number of passes to perform'), | ||||
| (b'', b'details', False, b'print timing for every revisions tested'), | (b'', b'details', False, b'print timing for every revisions tested'), | ||||
| (b'', b'source', b'full', b'the kind of data feed in the revlog'), | (b'', b'source', b'full', b'the kind of data feed in the revlog'), | ||||
| dest.revision(len(dest) - 1) | dest.revision(len(dest) - 1) | ||||
| yield dest | yield dest | ||||
| del dest, vfs | del dest, vfs | ||||
| finally: | finally: | ||||
| shutil.rmtree(tmpdir, True) | shutil.rmtree(tmpdir, True) | ||||
| @command( | @command( | ||||
| b'perf--revlogchunks', | b'perf::revlogchunks|perfrevlogchunks', | ||||
| revlogopts | revlogopts | ||||
| + formatteropts | + formatteropts | ||||
| + [ | + [ | ||||
| (b'e', b'engines', b'', b'compression engines to use'), | (b'e', b'engines', b'', b'compression engines to use'), | ||||
| (b's', b'startrev', 0, b'revision to start at'), | (b's', b'startrev', 0, b'revision to start at'), | ||||
| ], | ], | ||||
| b'-c|-m|FILE', | b'-c|-m|FILE', | ||||
| ) | ) | ||||
| for fn, title in benches: | for fn, title in benches: | ||||
| timer, fm = gettimer(ui, opts) | timer, fm = gettimer(ui, opts) | ||||
| timer(fn, title=title) | timer(fn, title=title) | ||||
| fm.end() | fm.end() | ||||
| @command( | @command( | ||||
| b'perf--revlogrevision', | b'perf::revlogrevision|perfrevlogrevision', | ||||
| revlogopts | revlogopts | ||||
| + formatteropts | + formatteropts | ||||
| + [(b'', b'cache', False, b'use caches instead of clearing')], | + [(b'', b'cache', False, b'use caches instead of clearing')], | ||||
| b'-c|-m|FILE REV', | b'-c|-m|FILE REV', | ||||
| ) | ) | ||||
| def perfrevlogrevision(ui, repo, file_, rev=None, cache=None, **opts): | def perfrevlogrevision(ui, repo, file_, rev=None, cache=None, **opts): | ||||
| """Benchmark obtaining a revlog revision. | """Benchmark obtaining a revlog revision. | ||||
| timer, fm = gettimer(ui, opts) | timer, fm = gettimer(ui, opts) | ||||
| for fn, title in benches: | for fn, title in benches: | ||||
| timer(fn, title=title) | timer(fn, title=title) | ||||
| fm.end() | fm.end() | ||||
| @command( | @command( | ||||
| b'perf--revset', | b'perf::revset|perfrevset', | ||||
| [ | [ | ||||
| (b'C', b'clear', False, b'clear volatile cache between each call.'), | (b'C', b'clear', False, b'clear volatile cache between each call.'), | ||||
| (b'', b'contexts', False, b'obtain changectx for each revision'), | (b'', b'contexts', False, b'obtain changectx for each revision'), | ||||
| ] | ] | ||||
| + formatteropts, | + formatteropts, | ||||
| b"REVSET", | b"REVSET", | ||||
| ) | ) | ||||
| def perfrevset(ui, repo, expr, clear=False, contexts=False, **opts): | def perfrevset(ui, repo, expr, clear=False, contexts=False, **opts): | ||||
| for r in repo.revs(expr): | for r in repo.revs(expr): | ||||
| pass | pass | ||||
| timer(d) | timer(d) | ||||
| fm.end() | fm.end() | ||||
| @command( | @command( | ||||
| b'perf--volatilesets', | b'perf::volatilesets|perfvolatilesets', | ||||
| [ | [ | ||||
| (b'', b'clear-obsstore', False, b'drop obsstore between each call.'), | (b'', b'clear-obsstore', False, b'drop obsstore between each call.'), | ||||
| ] | ] | ||||
| + formatteropts, | + formatteropts, | ||||
| ) | ) | ||||
| def perfvolatilesets(ui, repo, *names, **opts): | def perfvolatilesets(ui, repo, *names, **opts): | ||||
| """benchmark the computation of various volatile set | """benchmark the computation of various volatile set | ||||
| allfilter = [n for n in allfilter if n in names] | allfilter = [n for n in allfilter if n in names] | ||||
| for name in allfilter: | for name in allfilter: | ||||
| timer(getfiltered(name), title=name) | timer(getfiltered(name), title=name) | ||||
| fm.end() | fm.end() | ||||
| @command( | @command( | ||||
| b'perf--branchmap', | b'perf::branchmap|perfbranchmap', | ||||
| [ | [ | ||||
| (b'f', b'full', False, b'Includes build time of subset'), | (b'f', b'full', False, b'Includes build time of subset'), | ||||
| ( | ( | ||||
| b'', | b'', | ||||
| b'clear-revbranch', | b'clear-revbranch', | ||||
| False, | False, | ||||
| b'purge the revbranch cache between computation', | b'purge the revbranch cache between computation', | ||||
| ), | ), | ||||
| timer(getbranchmap(name), title=printname) | timer(getbranchmap(name), title=printname) | ||||
| finally: | finally: | ||||
| branchcacheread.restore() | branchcacheread.restore() | ||||
| branchcachewrite.restore() | branchcachewrite.restore() | ||||
| fm.end() | fm.end() | ||||
| @command( | @command( | ||||
| b'perf--branchmapupdate', | b'perf::branchmapupdate|perfbranchmapupdate', | ||||
| [ | [ | ||||
| (b'', b'base', [], b'subset of revision to start from'), | (b'', b'base', [], b'subset of revision to start from'), | ||||
| (b'', b'target', [], b'subset of revision to end with'), | (b'', b'target', [], b'subset of revision to end with'), | ||||
| (b'', b'clear-caches', False, b'clear cache between each runs'), | (b'', b'clear-caches', False, b'clear cache between each runs'), | ||||
| ] | ] | ||||
| + formatteropts, | + formatteropts, | ||||
| ) | ) | ||||
| def perfbranchmapupdate(ui, repo, base=(), target=(), **opts): | def perfbranchmapupdate(ui, repo, base=(), target=(), **opts): | ||||
| timer(bench, setup=setup) | timer(bench, setup=setup) | ||||
| fm.end() | fm.end() | ||||
| finally: | finally: | ||||
| repoview.filtertable.pop(b'__perf_branchmap_update_base', None) | repoview.filtertable.pop(b'__perf_branchmap_update_base', None) | ||||
| repoview.filtertable.pop(b'__perf_branchmap_update_target', None) | repoview.filtertable.pop(b'__perf_branchmap_update_target', None) | ||||
| @command( | @command( | ||||
| b'perf--branchmapload', | b'perf::branchmapload|perfbranchmapload', | ||||
| [ | [ | ||||
| (b'f', b'filter', b'', b'Specify repoview filter'), | (b'f', b'filter', b'', b'Specify repoview filter'), | ||||
| (b'', b'list', False, b'List brachmap filter caches'), | (b'', b'list', False, b'List brachmap filter caches'), | ||||
| (b'', b'clear-revlogs', False, b'refresh changelog and manifest'), | (b'', b'clear-revlogs', False, b'refresh changelog and manifest'), | ||||
| ] | ] | ||||
| + formatteropts, | + formatteropts, | ||||
| ) | ) | ||||
| def perfbranchmapload(ui, repo, filter=b'', list=False, **opts): | def perfbranchmapload(ui, repo, filter=b'', list=False, **opts): | ||||
| def bench(): | def bench(): | ||||
| fromfile(repo) | fromfile(repo) | ||||
| timer(bench, setup=setup) | timer(bench, setup=setup) | ||||
| fm.end() | fm.end() | ||||
| @command(b'perf--loadmarkers') | @command(b'perf::loadmarkers|perfloadmarkers') | ||||
| def perfloadmarkers(ui, repo): | def perfloadmarkers(ui, repo): | ||||
| """benchmark the time to parse the on-disk markers for a repo | """benchmark the time to parse the on-disk markers for a repo | ||||
| Result is the number of markers in the repo.""" | Result is the number of markers in the repo.""" | ||||
| timer, fm = gettimer(ui) | timer, fm = gettimer(ui) | ||||
| svfs = getsvfs(repo) | svfs = getsvfs(repo) | ||||
| timer(lambda: len(obsolete.obsstore(svfs))) | timer(lambda: len(obsolete.obsstore(svfs))) | ||||
| fm.end() | fm.end() | ||||
| @command( | @command( | ||||
| b'perf--lrucachedict', | b'perf::lrucachedict|perflrucachedict', | ||||
| formatteropts | formatteropts | ||||
| + [ | + [ | ||||
| (b'', b'costlimit', 0, b'maximum total cost of items in cache'), | (b'', b'costlimit', 0, b'maximum total cost of items in cache'), | ||||
| (b'', b'mincost', 0, b'smallest cost of items in cache'), | (b'', b'mincost', 0, b'smallest cost of items in cache'), | ||||
| (b'', b'maxcost', 100, b'maximum cost of items in cache'), | (b'', b'maxcost', 100, b'maximum cost of items in cache'), | ||||
| (b'', b'size', 4, b'size of cache'), | (b'', b'size', 4, b'size of cache'), | ||||
| (b'', b'gets', 10000, b'number of key lookups'), | (b'', b'gets', 10000, b'number of key lookups'), | ||||
| (b'', b'sets', 10000, b'number of key sets'), | (b'', b'sets', 10000, b'number of key sets'), | ||||
| for fn, title in benches: | for fn, title in benches: | ||||
| timer, fm = gettimer(ui, opts) | timer, fm = gettimer(ui, opts) | ||||
| timer(fn, title=title) | timer(fn, title=title) | ||||
| fm.end() | fm.end() | ||||
| @command( | @command( | ||||
| b'perf--write', | b'perf::write|perfwrite', | ||||
| formatteropts | formatteropts | ||||
| + [ | + [ | ||||
| (b'', b'write-method', b'write', b'ui write method'), | (b'', b'write-method', b'write', b'ui write method'), | ||||
| (b'', b'nlines', 100, b'number of lines'), | (b'', b'nlines', 100, b'number of lines'), | ||||
| (b'', b'nitems', 100, b'number of items (per line)'), | (b'', b'nitems', 100, b'number of items (per line)'), | ||||
| (b'', b'item', b'x', b'item that is written'), | (b'', b'item', b'x', b'item that is written'), | ||||
| (b'', b'batch-line', None, b'pass whole line to write method at once'), | (b'', b'batch-line', None, b'pass whole line to write method at once'), | ||||
| (b'', b'flush-line', None, b'flush after each line'), | (b'', b'flush-line', None, b'flush after each line'), | ||||
| hint=b"use 3.5 or later", | hint=b"use 3.5 or later", | ||||
| ) | ) | ||||
| return orig(repo, cmd, file_, opts) | return orig(repo, cmd, file_, opts) | ||||
| extensions.wrapfunction(cmdutil, b'openrevlog', openrevlog) | extensions.wrapfunction(cmdutil, b'openrevlog', openrevlog) | ||||
| @command( | @command( | ||||
| b'perf--progress', | b'perf::progress|perfprogress', | ||||
| formatteropts | formatteropts | ||||
| + [ | + [ | ||||
| (b'', b'topic', b'topic', b'topic for progress messages'), | (b'', b'topic', b'topic', b'topic for progress messages'), | ||||
| (b'c', b'total', 1000000, b'total value we are progressing to'), | (b'c', b'total', 1000000, b'total value we are progressing to'), | ||||
| ], | ], | ||||
| norepo=True, | norepo=True, | ||||
| ) | ) | ||||
| def perfprogress(ui, topic=None, total=None, **opts): | def perfprogress(ui, topic=None, total=None, **opts): | ||||
| The default value is: '3.0-100, 10.0-3' | The default value is: '3.0-100, 10.0-3' | ||||
| "stub" | "stub" | ||||
| When set, benchmarks will only be run once, useful for testing (default: | When set, benchmarks will only be run once, useful for testing (default: | ||||
| off) | off) | ||||
| list of commands: | list of commands: | ||||
| perf--addremove | perf::addremove | ||||
| (no help text available) | (no help text available) | ||||
| perf--ancestors | perf::ancestors | ||||
| (no help text available) | (no help text available) | ||||
| perf--ancestorset | perf::ancestorset | ||||
| (no help text available) | (no help text available) | ||||
| perf--annotate | perf::annotate | ||||
| (no help text available) | (no help text available) | ||||
| perf--bdiff benchmark a bdiff between revisions | perf::bdiff benchmark a bdiff between revisions | ||||
| perf--bookmarks | perf::bookmarks | ||||
| benchmark parsing bookmarks from disk to memory | benchmark parsing bookmarks from disk to memory | ||||
| perf--branchmap | perf::branchmap | ||||
| benchmark the update of a branchmap | benchmark the update of a branchmap | ||||
| perf--branchmapload | perf::branchmapload | ||||
| benchmark reading the branchmap | benchmark reading the branchmap | ||||
| perf--branchmapupdate | perf::branchmapupdate | ||||
| benchmark branchmap update from for <base> revs to <target> | benchmark branchmap update from for <base> revs to <target> | ||||
| revs | revs | ||||
| perf--bundleread | perf::bundleread | ||||
| Benchmark reading of bundle files. | Benchmark reading of bundle files. | ||||
| perf--cca (no help text available) | perf::cca (no help text available) | ||||
| perf--changegroupchangelog | perf::changegroupchangelog | ||||
| Benchmark producing a changelog group for a changegroup. | Benchmark producing a changelog group for a changegroup. | ||||
| perf--changeset | perf::changeset | ||||
| (no help text available) | (no help text available) | ||||
| perf--ctxfiles | perf::ctxfiles | ||||
| (no help text available) | (no help text available) | ||||
| perf--diffwd Profile diff of working directory changes | perf::diffwd Profile diff of working directory changes | ||||
| perf--dirfoldmap | perf::dirfoldmap | ||||
| benchmap a 'dirstate._map.dirfoldmap.get()' request | benchmap a 'dirstate._map.dirfoldmap.get()' request | ||||
| perf--dirs (no help text available) | perf::dirs (no help text available) | ||||
| perf--dirstate | perf::dirstate | ||||
| benchmap the time of various distate operations | benchmap the time of various distate operations | ||||
| perf--dirstatedirs | perf::dirstatedirs | ||||
| benchmap a 'dirstate.hasdir' call from an empty 'dirs' cache | benchmap a 'dirstate.hasdir' call from an empty 'dirs' cache | ||||
| perf--dirstatefoldmap | perf::dirstatefoldmap | ||||
| benchmap a 'dirstate._map.filefoldmap.get()' request | benchmap a 'dirstate._map.filefoldmap.get()' request | ||||
| perf--dirstatewrite | perf::dirstatewrite | ||||
| benchmap the time it take to write a dirstate on disk | benchmap the time it take to write a dirstate on disk | ||||
| perf--discovery | perf::discovery | ||||
| benchmark discovery between local repo and the peer at given | benchmark discovery between local repo and the peer at given | ||||
| path | path | ||||
| perf--fncacheencode | perf::fncacheencode | ||||
| (no help text available) | (no help text available) | ||||
| perf--fncacheload | perf::fncacheload | ||||
| (no help text available) | (no help text available) | ||||
| perf--fncachewrite | perf::fncachewrite | ||||
| (no help text available) | (no help text available) | ||||
| perf--heads benchmark the computation of a changelog heads | perf::heads benchmark the computation of a changelog heads | ||||
| perf--helper-mergecopies | perf::helper-mergecopies | ||||
| find statistics about potential parameters for | find statistics about potential parameters for | ||||
| 'perfmergecopies' | 'perfmergecopies' | ||||
| perf--helper-pathcopies | perf::helper-pathcopies | ||||
| find statistic about potential parameters for the | find statistic about potential parameters for the | ||||
| 'perftracecopies' | 'perftracecopies' | ||||
| perf--ignore benchmark operation related to computing ignore | perf::ignore benchmark operation related to computing ignore | ||||
| perf--index benchmark index creation time followed by a lookup | perf::index benchmark index creation time followed by a lookup | ||||
| perf--linelogedits | perf::linelogedits | ||||
| (no help text available) | (no help text available) | ||||
| perf--loadmarkers | perf::loadmarkers | ||||
| benchmark the time to parse the on-disk markers for a repo | benchmark the time to parse the on-disk markers for a repo | ||||
| perf--log (no help text available) | perf::log (no help text available) | ||||
| perf--lookup (no help text available) | perf::lookup (no help text available) | ||||
| perf--lrucachedict | perf::lrucachedict | ||||
| (no help text available) | (no help text available) | ||||
| perf--manifest | perf::manifest | ||||
| benchmark the time to read a manifest from disk and return a | benchmark the time to read a manifest from disk and return a | ||||
| usable | usable | ||||
| perf--mergecalculate | perf::mergecalculate | ||||
| (no help text available) | (no help text available) | ||||
| perf--mergecopies | perf::mergecopies | ||||
| measure runtime of 'copies.mergecopies' | measure runtime of 'copies.mergecopies' | ||||
| perf--moonwalk | perf::moonwalk | ||||
| benchmark walking the changelog backwards | benchmark walking the changelog backwards | ||||
| perf--nodelookup | perf::nodelookup | ||||
| (no help text available) | (no help text available) | ||||
| perf--nodemap | perf::nodemap | ||||
| benchmark the time necessary to look up revision from a cold | benchmark the time necessary to look up revision from a cold | ||||
| nodemap | nodemap | ||||
| perf--parents | perf::parents | ||||
| benchmark the time necessary to fetch one changeset's parents. | benchmark the time necessary to fetch one changeset's parents. | ||||
| perf--pathcopies | perf::pathcopies | ||||
| benchmark the copy tracing logic | benchmark the copy tracing logic | ||||
| perf--phases benchmark phasesets computation | perf::phases benchmark phasesets computation | ||||
| perf--phasesremote | perf::phasesremote | ||||
| benchmark time needed to analyse phases of the remote server | benchmark time needed to analyse phases of the remote server | ||||
| perf--progress | perf::progress | ||||
| printing of progress bars | printing of progress bars | ||||
| perf--rawfiles | perf::rawfiles | ||||
| (no help text available) | (no help text available) | ||||
| perf--revlogchunks | perf::revlogchunks | ||||
| Benchmark operations on revlog chunks. | Benchmark operations on revlog chunks. | ||||
| perf--revlogindex | perf::revlogindex | ||||
| Benchmark operations against a revlog index. | Benchmark operations against a revlog index. | ||||
| perf--revlogrevision | perf::revlogrevision | ||||
| Benchmark obtaining a revlog revision. | Benchmark obtaining a revlog revision. | ||||
| perf--revlogrevisions | perf::revlogrevisions | ||||
| Benchmark reading a series of revisions from a revlog. | Benchmark reading a series of revisions from a revlog. | ||||
| perf--revlogwrite | perf::revlogwrite | ||||
| Benchmark writing a series of revisions to a revlog. | Benchmark writing a series of revisions to a revlog. | ||||
| perf--revrange | perf::revrange | ||||
| (no help text available) | (no help text available) | ||||
| perf--revset benchmark the execution time of a revset | perf::revset benchmark the execution time of a revset | ||||
| perf--startup | perf::startup | ||||
| (no help text available) | (no help text available) | ||||
| perf--status benchmark the performance of a single status call | perf::status benchmark the performance of a single status call | ||||
| perf--tags (no help text available) | perf::tags (no help text available) | ||||
| perf--templating | perf::templating | ||||
| test the rendering time of a given template | test the rendering time of a given template | ||||
| perf--unidiff | perf::unidiff | ||||
| benchmark a unified diff between revisions | benchmark a unified diff between revisions | ||||
| perf--volatilesets | perf::volatilesets | ||||
| benchmark the computation of various volatile set | benchmark the computation of various volatile set | ||||
| perf--walk (no help text available) | perf::walk (no help text available) | ||||
| perf--write microbenchmark ui.write (and others) | perf::write microbenchmark ui.write (and others) | ||||
| (use 'hg help -v perf' to show built-in aliases and global options) | (use 'hg help -v perf' to show built-in aliases and global options) | ||||
| $ hg help perfaddremove | $ hg help perfaddremove | ||||
| hg perf--addremove | hg perf::addremove | ||||
| aliases: perfaddremove | aliases: perfaddremove | ||||
| (no help text available) | (no help text available) | ||||
| options: | options: | ||||
| -T --template TEMPLATE display with template | -T --template TEMPLATE display with template | ||||