This is an archive of the discontinued Mercurial Phabricator instance.

Differential D9872

command-namespace: use `::` are the command separator
ClosedPublic

Authored by marmoute on Jan 25 2021, 9:36 PM.

Details

Reviewers
None
Group Reviewers
hg-reviewers
Commits
rHGd8ad391e10f5: command-namespace: use `::` are the command separator
rHGfabd8207adc3: command-namespace: use `::` are the command separator
Summary

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.

Diff Detail

Repository
rHG Mercurial
Branch
default
Lint
No Linters Available
Unit
No Unit Test Coverage

Event Timeline

marmoute created this revision.Jan 25 2021, 9:36 PM
pulkit added a subscriber: pulkit.Jan 26 2021, 3:06 PM

Sorry, but it hit me now that can subcommands support be a better option here?

marmoute added a comment.Jan 26 2021, 3:08 PM
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.

marmoute added a commit: rHGfabd8207adc3: command-namespace: use `::` are the command separator.Jan 26 2021, 5:21 PM
This revision was not accepted when it landed; it landed in state Needs Review.
Closed by commit rHGfabd8207adc3: command-namespace: use `::` are the command separator (authored by marmoute). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

PathPackages
Mcontrib/perf.py (124 lines)
Mtests/test-contrib-perf.t (126 lines)

Diff 25254

contrib/perf.py

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):

tests/test-contrib-perf.t

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