D4422: contrib: byteify perf.py file
pulkit (Pulkit Goyal)
phabricator at mercurial-scm.org
Thu Aug 30 08:07:44 EDT 2018
This revision was automatically updated to reflect the committed changes.
Closed by commit rHG438f3932a432: contrib: byteify perf.py file (authored by pulkit, committed by ).
REPOSITORY
rHG Mercurial
CHANGES SINCE LAST UPDATE
https://phab.mercurial-scm.org/D4422?vs=10667&id=10673
REVISION DETAIL
https://phab.mercurial-scm.org/D4422
AFFECTED FILES
contrib/perf.py
CHANGE DETAILS
diff --git a/contrib/perf.py b/contrib/perf.py
--- a/contrib/perf.py
+++ b/contrib/perf.py
@@ -103,7 +103,7 @@
# since ae5d60bb70c9
if safehasattr(time, 'perf_counter'):
util.timer = time.perf_counter
-elif os.name == 'nt':
+elif os.name == b'nt':
util.timer = time.clock
else:
util.timer = time.time
@@ -123,31 +123,31 @@
# since 1.9 (or a79fea6b3e77).
revlogopts = getattr(cmdutil, "debugrevlogopts",
getattr(commands, "debugrevlogopts", [
- ('c', 'changelog', False, ('open changelog')),
- ('m', 'manifest', False, ('open manifest')),
- ('', 'dir', False, ('open directory manifest')),
+ (b'c', b'changelog', False, (b'open changelog')),
+ (b'm', b'manifest', False, (b'open manifest')),
+ (b'', b'dir', False, (b'open directory manifest')),
]))
cmdtable = {}
# for "historical portability":
# define parsealiases locally, because cmdutil.parsealiases has been
# available since 1.5 (or 6252852b4332)
def parsealiases(cmd):
- return cmd.lstrip("^").split("|")
+ return cmd.lstrip(b"^").split(b"|")
if safehasattr(registrar, 'command'):
command = registrar.command(cmdtable)
elif safehasattr(cmdutil, 'command'):
command = cmdutil.command(cmdtable)
- if 'norepo' not in getargspec(command).args:
+ if b'norepo' not in getargspec(command).args:
# for "historical portability":
# wrap original cmdutil.command, because "norepo" option has
# been available since 3.1 (or 75a96326cecb)
_command = command
def command(name, options=(), synopsis=None, norepo=False):
if norepo:
- commands.norepo += ' %s' % ' '.join(parsealiases(name))
+ commands.norepo += b' %s' % b' '.join(parsealiases(name))
return _command(name, list(options), synopsis)
else:
# for "historical portability":
@@ -160,32 +160,32 @@
else:
cmdtable[name] = func, list(options)
if norepo:
- commands.norepo += ' %s' % ' '.join(parsealiases(name))
+ commands.norepo += b' %s' % b' '.join(parsealiases(name))
return func
return decorator
try:
import mercurial.registrar
import mercurial.configitems
configtable = {}
configitem = mercurial.registrar.configitem(configtable)
- configitem('perf', 'presleep',
+ configitem(b'perf', b'presleep',
default=mercurial.configitems.dynamicdefault,
)
- configitem('perf', 'stub',
+ configitem(b'perf', b'stub',
default=mercurial.configitems.dynamicdefault,
)
- configitem('perf', 'parentscount',
+ configitem(b'perf', b'parentscount',
default=mercurial.configitems.dynamicdefault,
)
- configitem('perf', 'all-timing',
+ configitem(b'perf', b'all-timing',
default=mercurial.configitems.dynamicdefault,
)
except (ImportError, AttributeError):
pass
def getlen(ui):
- if ui.configbool("perf", "stub", False):
+ if ui.configbool(b"perf", b"stub", False):
return lambda x: 1
return len
@@ -197,23 +197,23 @@
# enforce an idle period before execution to counteract power management
# experimental config: perf.presleep
- time.sleep(getint(ui, "perf", "presleep", 1))
+ time.sleep(getint(ui, b"perf", b"presleep", 1))
if opts is None:
opts = {}
# redirect all to stderr unless buffer api is in use
if not ui._buffers:
ui = ui.copy()
- uifout = safeattrsetter(ui, 'fout', ignoremissing=True)
+ uifout = safeattrsetter(ui, b'fout', ignoremissing=True)
if uifout:
# for "historical portability":
# ui.fout/ferr have been available since 1.9 (or 4e1ccd4c2b6d)
uifout.set(ui.ferr)
# get a formatter
uiformatter = getattr(ui, 'formatter', None)
if uiformatter:
- fm = uiformatter('perf', opts)
+ fm = uiformatter(b'perf', opts)
else:
# for "historical portability":
# define formatter locally, because ui.formatter has been
@@ -244,15 +244,15 @@
self._ui.write(text, **opts)
def end(self):
pass
- fm = defaultformatter(ui, 'perf', opts)
+ fm = defaultformatter(ui, b'perf', opts)
# stub function, runs code only once instead of in a loop
# experimental config: perf.stub
- if ui.configbool("perf", "stub", False):
+ if ui.configbool(b"perf", b"stub", False):
return functools.partial(stub_timer, fm), fm
# experimental config: perf.all-timing
- displayall = ui.configbool("perf", "all-timing", False)
+ displayall = ui.configbool(b"perf", b"all-timing", False)
return functools.partial(_timer, fm, displayall=displayall), fm
def stub_timer(fm, func, title=None):
@@ -280,30 +280,30 @@
fm.startitem()
if title:
- fm.write('title', '! %s\n', title)
+ fm.write(b'title', b'! %s\n', title)
if r:
- fm.write('result', '! result: %s\n', r)
+ fm.write(b'result', b'! result: %s\n', r)
def display(role, entry):
- prefix = ''
- if role != 'best':
- prefix = '%s.' % role
- fm.plain('!')
- fm.write(prefix + 'wall', ' wall %f', entry[0])
- fm.write(prefix + 'comb', ' comb %f', entry[1] + entry[2])
- fm.write(prefix + 'user', ' user %f', entry[1])
- fm.write(prefix + 'sys', ' sys %f', entry[2])
- fm.write(prefix + 'count', ' (%s of %d)', role, count)
- fm.plain('\n')
+ prefix = b''
+ if role != b'best':
+ prefix = b'%s.' % role
+ fm.plain(b'!')
+ fm.write(prefix + b'wall', b' wall %f', entry[0])
+ fm.write(prefix + b'comb', b' comb %f', entry[1] + entry[2])
+ fm.write(prefix + b'user', b' user %f', entry[1])
+ fm.write(prefix + b'sys', b' sys %f', entry[2])
+ fm.write(prefix + b'count', b' (%s of %d)', role, count)
+ fm.plain(b'\n')
results.sort()
min_val = results[0]
- display('best', min_val)
+ display(b'best', min_val)
if displayall:
max_val = results[-1]
- display('max', max_val)
+ display(b'max', max_val)
avg = tuple([sum(x) / count for x in zip(*results)])
- display('avg', avg)
+ display(b'avg', avg)
median = results[len(results) // 2]
- display('median', median)
+ display(b'median', median)
# utilities for historical portability
@@ -316,7 +316,7 @@
try:
return int(v)
except ValueError:
- raise error.ConfigError(("%s.%s is not an integer ('%s')")
+ raise error.ConfigError((b"%s.%s is not an integer ('%s')")
% (section, name, v))
def safeattrsetter(obj, name, ignoremissing=False):
@@ -337,8 +337,8 @@
if not util.safehasattr(obj, name):
if ignoremissing:
return None
- raise error.Abort(("missing attribute %s of %s might break assumption"
- " of performance measurement") % (name, obj))
+ raise error.Abort((b"missing attribute %s of %s might break assumption"
+ b" of performance measurement") % (name, obj))
origvalue = getattr(obj, name)
class attrutil(object):
@@ -364,8 +364,8 @@
# bisecting in bcee63733aad::59a9f18d4587 can reach here (both
# branchmap and repoview modules exist, but subsettable attribute
# doesn't)
- raise error.Abort(("perfbranchmap not available with this Mercurial"),
- hint="use 2.5 or later")
+ raise error.Abort((b"perfbranchmap not available with this Mercurial"),
+ hint=b"use 2.5 or later")
def getsvfs(repo):
"""Return appropriate object to access files under .hg/store
@@ -392,31 +392,31 @@
def repocleartagscachefunc(repo):
"""Return the function to clear tags cache according to repo internal API
"""
- if util.safehasattr(repo, '_tagscache'): # since 2.0 (or 9dca7653b525)
+ if util.safehasattr(repo, b'_tagscache'): # since 2.0 (or 9dca7653b525)
# in this case, setattr(repo, '_tagscache', None) or so isn't
# correct way to clear tags cache, because existing code paths
# expect _tagscache to be a structured object.
def clearcache():
# _tagscache has been filteredpropertycache since 2.5 (or
# 98c867ac1330), and delattr() can't work in such case
- if '_tagscache' in vars(repo):
- del repo.__dict__['_tagscache']
+ if b'_tagscache' in vars(repo):
+ del repo.__dict__[b'_tagscache']
return clearcache
- repotags = safeattrsetter(repo, '_tags', ignoremissing=True)
+ repotags = safeattrsetter(repo, b'_tags', ignoremissing=True)
if repotags: # since 1.4 (or 5614a628d173)
return lambda : repotags.set(None)
- repotagscache = safeattrsetter(repo, 'tagscache', ignoremissing=True)
+ repotagscache = safeattrsetter(repo, b'tagscache', ignoremissing=True)
if repotagscache: # since 0.6 (or d7df759d0e97)
return lambda : repotagscache.set(None)
# Mercurial earlier than 0.6 (or d7df759d0e97) logically reaches
# this point, but it isn't so problematic, because:
# - repo.tags of such Mercurial isn't "callable", and repo.tags()
# in perftags() causes failure soon
# - perf.py itself has been available since 1.1 (or eb240755386d)
- raise error.Abort(("tags API of this hg command is unknown"))
+ raise error.Abort((b"tags API of this hg command is unknown"))
# utilities to clear cache
@@ -428,55 +428,55 @@
# perf commands
- at command('perfwalk', formatteropts)
+ at command(b'perfwalk', formatteropts)
def perfwalk(ui, repo, *pats, **opts):
timer, fm = gettimer(ui, opts)
m = scmutil.match(repo[None], pats, {})
timer(lambda: len(list(repo.dirstate.walk(m, subrepos=[], unknown=True,
ignored=False))))
fm.end()
- at command('perfannotate', formatteropts)
+ at command(b'perfannotate', formatteropts)
def perfannotate(ui, repo, f, **opts):
timer, fm = gettimer(ui, opts)
- fc = repo['.'][f]
+ fc = repo[b'.'][f]
timer(lambda: len(fc.annotate(True)))
fm.end()
- at command('perfstatus',
- [('u', 'unknown', False,
- 'ask status to look for unknown files')] + formatteropts)
+ at command(b'perfstatus',
+ [(b'u', b'unknown', False,
+ b'ask status to look for unknown files')] + formatteropts)
def perfstatus(ui, repo, **opts):
#m = match.always(repo.root, repo.getcwd())
#timer(lambda: sum(map(len, repo.dirstate.status(m, [], False, False,
# False))))
timer, fm = gettimer(ui, opts)
- timer(lambda: sum(map(len, repo.status(unknown=opts['unknown']))))
+ timer(lambda: sum(map(len, repo.status(unknown=opts[b'unknown']))))
fm.end()
- at command('perfaddremove', formatteropts)
+ at command(b'perfaddremove', formatteropts)
def perfaddremove(ui, repo, **opts):
timer, fm = gettimer(ui, opts)
try:
oldquiet = repo.ui.quiet
repo.ui.quiet = True
matcher = scmutil.match(repo[None])
- opts['dry_run'] = True
- timer(lambda: scmutil.addremove(repo, matcher, "", opts))
+ opts[b'dry_run'] = True
+ timer(lambda: scmutil.addremove(repo, matcher, b"", opts))
finally:
repo.ui.quiet = oldquiet
fm.end()
def clearcaches(cl):
# behave somewhat consistently across internal API changes
- if util.safehasattr(cl, 'clearcaches'):
+ if util.safehasattr(cl, b'clearcaches'):
cl.clearcaches()
- elif util.safehasattr(cl, '_nodecache'):
+ elif util.safehasattr(cl, b'_nodecache'):
from mercurial.node import nullid, nullrev
cl._nodecache = {nullid: nullrev}
cl._nodepos = None
- at command('perfheads', formatteropts)
+ at command(b'perfheads', formatteropts)
def perfheads(ui, repo, **opts):
timer, fm = gettimer(ui, opts)
cl = repo.changelog
@@ -486,7 +486,7 @@
timer(d)
fm.end()
- at command('perftags', formatteropts)
+ at command(b'perftags', formatteropts)
def perftags(ui, repo, **opts):
import mercurial.changelog
import mercurial.manifest
@@ -501,7 +501,7 @@
timer(t)
fm.end()
- at command('perfancestors', formatteropts)
+ at command(b'perfancestors', formatteropts)
def perfancestors(ui, repo, **opts):
timer, fm = gettimer(ui, opts)
heads = repo.changelog.headrevs()
@@ -511,7 +511,7 @@
timer(d)
fm.end()
- at command('perfancestorset', formatteropts)
+ at command(b'perfancestorset', formatteropts)
def perfancestorset(ui, repo, revset, **opts):
timer, fm = gettimer(ui, opts)
revs = repo.revs(revset)
@@ -523,17 +523,17 @@
timer(d)
fm.end()
- at command('perfbookmarks', formatteropts)
+ at command(b'perfbookmarks', formatteropts)
def perfbookmarks(ui, repo, **opts):
"""benchmark parsing bookmarks from disk to memory"""
timer, fm = gettimer(ui, opts)
def d():
- clearfilecache(repo, '_bookmarks')
+ clearfilecache(repo, b'_bookmarks')
repo._bookmarks
timer(d)
fm.end()
- at command('perfbundleread', formatteropts, 'BUNDLE')
+ at command(b'perfbundleread', formatteropts, b'BUNDLE')
def perfbundleread(ui, repo, bundlepath, **opts):
"""Benchmark reading of bundle files.
@@ -548,24 +548,24 @@
def makebench(fn):
def run():
- with open(bundlepath, 'rb') as fh:
+ with open(bundlepath, b'rb') as fh:
bundle = exchange.readbundle(ui, fh, bundlepath)
fn(bundle)
return run
def makereadnbytes(size):
def run():
- with open(bundlepath, 'rb') as fh:
+ with open(bundlepath, b'rb') as fh:
bundle = exchange.readbundle(ui, fh, bundlepath)
while bundle.read(size):
pass
return run
def makestdioread(size):
def run():
- with open(bundlepath, 'rb') as fh:
+ with open(bundlepath, b'rb') as fh:
while fh.read(size):
pass
@@ -601,58 +601,58 @@
def makepartreadnbytes(size):
def run():
- with open(bundlepath, 'rb') as fh:
+ with open(bundlepath, b'rb') as fh:
bundle = exchange.readbundle(ui, fh, bundlepath)
for part in bundle.iterparts():
while part.read(size):
pass
return run
benches = [
- (makestdioread(8192), 'read(8k)'),
- (makestdioread(16384), 'read(16k)'),
- (makestdioread(32768), 'read(32k)'),
- (makestdioread(131072), 'read(128k)'),
+ (makestdioread(8192), b'read(8k)'),
+ (makestdioread(16384), b'read(16k)'),
+ (makestdioread(32768), b'read(32k)'),
+ (makestdioread(131072), b'read(128k)'),
]
- with open(bundlepath, 'rb') as fh:
+ with open(bundlepath, b'rb') as fh:
bundle = exchange.readbundle(ui, fh, bundlepath)
if isinstance(bundle, changegroup.cg1unpacker):
benches.extend([
- (makebench(deltaiter), 'cg1 deltaiter()'),
- (makebench(iterchunks), 'cg1 getchunks()'),
- (makereadnbytes(8192), 'cg1 read(8k)'),
- (makereadnbytes(16384), 'cg1 read(16k)'),
- (makereadnbytes(32768), 'cg1 read(32k)'),
- (makereadnbytes(131072), 'cg1 read(128k)'),
+ (makebench(deltaiter), b'cg1 deltaiter()'),
+ (makebench(iterchunks), b'cg1 getchunks()'),
+ (makereadnbytes(8192), b'cg1 read(8k)'),
+ (makereadnbytes(16384), b'cg1 read(16k)'),
+ (makereadnbytes(32768), b'cg1 read(32k)'),
+ (makereadnbytes(131072), b'cg1 read(128k)'),
])
elif isinstance(bundle, bundle2.unbundle20):
benches.extend([
- (makebench(forwardchunks), 'bundle2 forwardchunks()'),
- (makebench(iterparts), 'bundle2 iterparts()'),
- (makebench(iterpartsseekable), 'bundle2 iterparts() seekable'),
- (makebench(seek), 'bundle2 part seek()'),
- (makepartreadnbytes(8192), 'bundle2 part read(8k)'),
- (makepartreadnbytes(16384), 'bundle2 part read(16k)'),
- (makepartreadnbytes(32768), 'bundle2 part read(32k)'),
- (makepartreadnbytes(131072), 'bundle2 part read(128k)'),
+ (makebench(forwardchunks), b'bundle2 forwardchunks()'),
+ (makebench(iterparts), b'bundle2 iterparts()'),
+ (makebench(iterpartsseekable), b'bundle2 iterparts() seekable'),
+ (makebench(seek), b'bundle2 part seek()'),
+ (makepartreadnbytes(8192), b'bundle2 part read(8k)'),
+ (makepartreadnbytes(16384), b'bundle2 part read(16k)'),
+ (makepartreadnbytes(32768), b'bundle2 part read(32k)'),
+ (makepartreadnbytes(131072), b'bundle2 part read(128k)'),
])
elif isinstance(bundle, streamclone.streamcloneapplier):
- raise error.Abort('stream clone bundles not supported')
+ raise error.Abort(b'stream clone bundles not supported')
else:
- raise error.Abort('unhandled bundle type: %s' % type(bundle))
+ raise error.Abort(b'unhandled bundle type: %s' % type(bundle))
for fn, title in benches:
timer, fm = gettimer(ui, opts)
timer(fn, title=title)
fm.end()
- at command('perfchangegroupchangelog', formatteropts +
- [('', 'version', '02', 'changegroup version'),
- ('r', 'rev', '', 'revisions to add to changegroup')])
-def perfchangegroupchangelog(ui, repo, version='02', rev=None, **opts):
+ at command(b'perfchangegroupchangelog', formatteropts +
+ [(b'', b'version', b'02', b'changegroup version'),
+ (b'r', b'rev', b'', b'revisions to add to changegroup')])
+def perfchangegroupchangelog(ui, repo, version=b'02', rev=None, **opts):
"""Benchmark producing a changelog group for a changegroup.
This measures the time spent processing the changelog during a
@@ -663,7 +663,7 @@
By default, all revisions are added to the changegroup.
"""
cl = repo.changelog
- nodes = [cl.lookup(r) for r in repo.revs(rev or 'all()')]
+ nodes = [cl.lookup(r) for r in repo.revs(rev or b'all()')]
bundler = changegroup.getbundler(version, repo)
def d():
@@ -674,78 +674,78 @@
timer, fm = gettimer(ui, opts)
# Terminal printing can interfere with timing. So disable it.
- with ui.configoverride({('progress', 'disable'): True}):
+ with ui.configoverride({(b'progress', b'disable'): True}):
timer(d)
fm.end()
- at command('perfdirs', formatteropts)
+ at command(b'perfdirs', formatteropts)
def perfdirs(ui, repo, **opts):
timer, fm = gettimer(ui, opts)
dirstate = repo.dirstate
- 'a' in dirstate
+ b'a' in dirstate
def d():
- dirstate.hasdir('a')
+ dirstate.hasdir(b'a')
del dirstate._map._dirs
timer(d)
fm.end()
- at command('perfdirstate', formatteropts)
+ at command(b'perfdirstate', formatteropts)
def perfdirstate(ui, repo, **opts):
timer, fm = gettimer(ui, opts)
- "a" in repo.dirstate
+ b"a" in repo.dirstate
def d():
repo.dirstate.invalidate()
- "a" in repo.dirstate
+ b"a" in repo.dirstate
timer(d)
fm.end()
- at command('perfdirstatedirs', formatteropts)
+ at command(b'perfdirstatedirs', formatteropts)
def perfdirstatedirs(ui, repo, **opts):
timer, fm = gettimer(ui, opts)
- "a" in repo.dirstate
+ b"a" in repo.dirstate
def d():
- repo.dirstate.hasdir("a")
+ repo.dirstate.hasdir(b"a")
del repo.dirstate._map._dirs
timer(d)
fm.end()
- at command('perfdirstatefoldmap', formatteropts)
+ at command(b'perfdirstatefoldmap', formatteropts)
def perfdirstatefoldmap(ui, repo, **opts):
timer, fm = gettimer(ui, opts)
dirstate = repo.dirstate
- 'a' in dirstate
+ b'a' in dirstate
def d():
- dirstate._map.filefoldmap.get('a')
+ dirstate._map.filefoldmap.get(b'a')
del dirstate._map.filefoldmap
timer(d)
fm.end()
- at command('perfdirfoldmap', formatteropts)
+ at command(b'perfdirfoldmap', formatteropts)
def perfdirfoldmap(ui, repo, **opts):
timer, fm = gettimer(ui, opts)
dirstate = repo.dirstate
- 'a' in dirstate
+ b'a' in dirstate
def d():
- dirstate._map.dirfoldmap.get('a')
+ dirstate._map.dirfoldmap.get(b'a')
del dirstate._map.dirfoldmap
del dirstate._map._dirs
timer(d)
fm.end()
- at command('perfdirstatewrite', formatteropts)
+ at command(b'perfdirstatewrite', formatteropts)
def perfdirstatewrite(ui, repo, **opts):
timer, fm = gettimer(ui, opts)
ds = repo.dirstate
- "a" in ds
+ b"a" in ds
def d():
ds._dirty = True
ds.write(repo.currenttransaction())
timer(d)
fm.end()
- at command('perfmergecalculate',
- [('r', 'rev', '.', 'rev to merge against')] + formatteropts)
+ at command(b'perfmergecalculate',
+ [(b'r', b'rev', b'.', b'rev to merge against')] + formatteropts)
def perfmergecalculate(ui, repo, rev, **opts):
timer, fm = gettimer(ui, opts)
wctx = repo[None]
@@ -762,7 +762,7 @@
timer(d)
fm.end()
- at command('perfpathcopies', [], "REV REV")
+ at command(b'perfpathcopies', [], b"REV REV")
def perfpathcopies(ui, repo, rev1, rev2, **opts):
timer, fm = gettimer(ui, opts)
ctx1 = scmutil.revsingle(repo, rev1, rev1)
@@ -772,26 +772,26 @@
timer(d)
fm.end()
- at command('perfphases',
- [('', 'full', False, 'include file reading time too'),
- ], "")
+ at command(b'perfphases',
+ [(b'', b'full', False, b'include file reading time too'),
+ ], b"")
def perfphases(ui, repo, **opts):
"""benchmark phasesets computation"""
timer, fm = gettimer(ui, opts)
_phases = repo._phasecache
- full = opts.get('full')
+ full = opts.get(b'full')
def d():
phases = _phases
if full:
- clearfilecache(repo, '_phasecache')
+ clearfilecache(repo, b'_phasecache')
phases = repo._phasecache
phases.invalidate()
phases.loadphaserevs(repo)
timer(d)
fm.end()
- at command('perfphasesremote',
- [], "[DEST]")
+ at command(b'perfphasesremote',
+ [], b"[DEST]")
def perfphasesremote(ui, repo, dest=None, **opts):
"""benchmark time needed to analyse phases of the remote server"""
from mercurial.node import (
@@ -804,14 +804,14 @@
)
timer, fm = gettimer(ui, opts)
- path = ui.paths.getpath(dest, default=('default-push', 'default'))
+ path = ui.paths.getpath(dest, default=(b'default-push', b'default'))
if not path:
- raise error.Abort(('default repository not configured!'),
- hint=("see 'hg help config.paths'"))
+ raise error.Abort((b'default repository not configured!'),
+ hint=(b"see 'hg help config.paths'"))
dest = path.pushloc or path.loc
- branches = (path.branch, opts.get('branch') or [])
- ui.status(('analysing phase of %s\n') % util.hidepassword(dest))
- revs, checkout = hg.addbranchrevs(repo, repo, branches, opts.get('rev'))
+ branches = (path.branch, opts.get(b'branch') or [])
+ ui.status((b'analysing phase of %s\n') % util.hidepassword(dest))
+ revs, checkout = hg.addbranchrevs(repo, repo, branches, opts.get(b'rev'))
other = hg.peer(repo, opts, dest)
# easier to perform discovery through the operation
@@ -821,36 +821,36 @@
remotesubset = op.fallbackheads
with other.commandexecutor() as e:
- remotephases = e.callcommand('listkeys',
- {'namespace': 'phases'}).result()
+ remotephases = e.callcommand(b'listkeys',
+ {b'namespace': b'phases'}).result()
del other
- publishing = remotephases.get('publishing', False)
+ publishing = remotephases.get(b'publishing', False)
if publishing:
- ui.status(('publishing: yes\n'))
+ ui.status((b'publishing: yes\n'))
else:
- ui.status(('publishing: no\n'))
+ ui.status((b'publishing: no\n'))
nodemap = repo.changelog.nodemap
nonpublishroots = 0
for nhex, phase in remotephases.iteritems():
- if nhex == 'publishing': # ignore data related to publish option
+ if nhex == b'publishing': # ignore data related to publish option
continue
node = bin(nhex)
if node in nodemap and int(phase):
nonpublishroots += 1
- ui.status(('number of roots: %d\n') % len(remotephases))
- ui.status(('number of known non public roots: %d\n') % nonpublishroots)
+ ui.status((b'number of roots: %d\n') % len(remotephases))
+ ui.status((b'number of known non public roots: %d\n') % nonpublishroots)
def d():
phases.remotephasessummary(repo,
remotesubset,
remotephases)
timer(d)
fm.end()
- at command('perfmanifest',[
- ('m', 'manifest-rev', False, 'Look up a manifest node revision'),
- ('', 'clear-disk', False, 'clear on-disk caches too'),
- ], 'REV|NODE')
+ at command(b'perfmanifest',[
+ (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'REV|NODE')
def perfmanifest(ui, repo, rev, manifest_rev=False, clear_disk=False, **opts):
"""benchmark the time to read a manifest from disk and return a usable
dict-like object
@@ -869,20 +869,20 @@
try:
rev = int(rev)
- if util.safehasattr(repo.manifestlog, 'getstorage'):
+ if util.safehasattr(repo.manifestlog, b'getstorage'):
t = repo.manifestlog.getstorage(b'').node(rev)
else:
t = repo.manifestlog._revlog.lookup(rev)
except ValueError:
- raise error.Abort('manifest revision must be integer or full '
- 'node')
+ raise error.Abort(b'manifest revision must be integer or full '
+ b'node')
def d():
repo.manifestlog.clearcaches(clear_persisted_data=clear_disk)
repo.manifestlog[t].read()
timer(d)
fm.end()
- at command('perfchangeset', formatteropts)
+ at command(b'perfchangeset', formatteropts)
def perfchangeset(ui, repo, rev, **opts):
timer, fm = gettimer(ui, opts)
n = scmutil.revsingle(repo, rev).node()
@@ -892,58 +892,58 @@
timer(d)
fm.end()
- at command('perfindex', formatteropts)
+ at command(b'perfindex', formatteropts)
def perfindex(ui, repo, **opts):
import mercurial.revlog
timer, fm = gettimer(ui, opts)
mercurial.revlog._prereadsize = 2**24 # disable lazy parser in old hg
- n = repo["tip"].node()
+ n = repo[b"tip"].node()
svfs = getsvfs(repo)
def d():
- cl = mercurial.revlog.revlog(svfs, "00changelog.i")
+ cl = mercurial.revlog.revlog(svfs, b"00changelog.i")
cl.rev(n)
timer(d)
fm.end()
- at command('perfstartup', formatteropts)
+ at command(b'perfstartup', formatteropts)
def perfstartup(ui, repo, **opts):
timer, fm = gettimer(ui, opts)
cmd = sys.argv[0]
def d():
- if os.name != 'nt':
- os.system("HGRCPATH= %s version -q > /dev/null" % cmd)
+ if os.name != b'nt':
+ os.system(b"HGRCPATH= %s version -q > /dev/null" % cmd)
else:
- os.environ['HGRCPATH'] = ' '
- os.system("%s version -q > NUL" % cmd)
+ os.environ[b'HGRCPATH'] = b' '
+ os.system(b"%s version -q > NUL" % cmd)
timer(d)
fm.end()
- at command('perfparents', formatteropts)
+ at command(b'perfparents', formatteropts)
def perfparents(ui, repo, **opts):
timer, fm = gettimer(ui, opts)
# control the number of commits perfparents iterates over
# experimental config: perf.parentscount
- count = getint(ui, "perf", "parentscount", 1000)
+ count = getint(ui, b"perf", b"parentscount", 1000)
if len(repo.changelog) < count:
- raise error.Abort("repo needs %d commits for this test" % count)
+ raise error.Abort(b"repo needs %d commits for this test" % count)
repo = repo.unfiltered()
nl = [repo.changelog.node(i) for i in xrange(count)]
def d():
for n in nl:
repo.changelog.parents(n)
timer(d)
fm.end()
- at command('perfctxfiles', formatteropts)
+ at command(b'perfctxfiles', formatteropts)
def perfctxfiles(ui, repo, x, **opts):
x = int(x)
timer, fm = gettimer(ui, opts)
def d():
len(repo[x].files())
timer(d)
fm.end()
- at command('perfrawfiles', formatteropts)
+ at command(b'perfrawfiles', formatteropts)
def perfrawfiles(ui, repo, x, **opts):
x = int(x)
timer, fm = gettimer(ui, opts)
@@ -953,21 +953,21 @@
timer(d)
fm.end()
- at command('perflookup', formatteropts)
+ at command(b'perflookup', formatteropts)
def perflookup(ui, repo, rev, **opts):
timer, fm = gettimer(ui, opts)
timer(lambda: len(repo.lookup(rev)))
fm.end()
- at command('perflinelogedits',
- [('n', 'edits', 10000, 'number of edits'),
- ('', 'max-hunk-lines', 10, 'max lines in a hunk'),
- ], norepo=True)
+ at command(b'perflinelogedits',
+ [(b'n', b'edits', 10000, b'number of edits'),
+ (b'', b'max-hunk-lines', 10, b'max lines in a hunk'),
+ ], norepo=True)
def perflinelogedits(ui, **opts):
from mercurial import linelog
- edits = opts['edits']
- maxhunklines = opts['max_hunk_lines']
+ edits = opts[b'edits']
+ maxhunklines = opts[b'max_hunk_lines']
maxb1 = 100000
random.seed(0)
@@ -991,39 +991,40 @@
timer(d)
fm.end()
- at command('perfrevrange', formatteropts)
+ at command(b'perfrevrange', formatteropts)
def perfrevrange(ui, repo, *specs, **opts):
timer, fm = gettimer(ui, opts)
revrange = scmutil.revrange
timer(lambda: len(revrange(repo, specs)))
fm.end()
- at command('perfnodelookup', formatteropts)
+ at command(b'perfnodelookup', formatteropts)
def perfnodelookup(ui, repo, rev, **opts):
timer, fm = gettimer(ui, opts)
import mercurial.revlog
mercurial.revlog._prereadsize = 2**24 # disable lazy parser in old hg
n = scmutil.revsingle(repo, rev).node()
- cl = mercurial.revlog.revlog(getsvfs(repo), "00changelog.i")
+ cl = mercurial.revlog.revlog(getsvfs(repo), b"00changelog.i")
def d():
cl.rev(n)
clearcaches(cl)
timer(d)
fm.end()
- at command('perflog',
- [('', 'rename', False, 'ask log to follow renames')] + formatteropts)
+ at command(b'perflog',
+ [(b'', b'rename', False, b'ask log to follow renames')
+ ] + formatteropts)
def perflog(ui, repo, rev=None, **opts):
if rev is None:
rev=[]
timer, fm = gettimer(ui, opts)
ui.pushbuffer()
- timer(lambda: commands.log(ui, repo, rev=rev, date='', user='',
- copies=opts.get('rename')))
+ timer(lambda: commands.log(ui, repo, rev=rev, date=b'', user=b'',
+ copies=opts.get(b'rename')))
ui.popbuffer()
fm.end()
- at command('perfmoonwalk', formatteropts)
+ at command(b'perfmoonwalk', formatteropts)
def perfmoonwalk(ui, repo, **opts):
"""benchmark walking the changelog backwards
@@ -1037,25 +1038,25 @@
timer(moonwalk)
fm.end()
- at command('perftemplating',
- [('r', 'rev', [], 'revisions to run the template on'),
- ] + formatteropts)
+ at command(b'perftemplating',
+ [(b'r', b'rev', [], b'revisions to run the template on'),
+ ] + formatteropts)
def perftemplating(ui, repo, testedtemplate=None, **opts):
"""test the rendering time of a given template"""
if makelogtemplater is None:
- raise error.Abort(("perftemplating not available with this Mercurial"),
- hint="use 4.3 or later")
+ raise error.Abort((b"perftemplating not available with this Mercurial"),
+ hint=b"use 4.3 or later")
nullui = ui.copy()
- nullui.fout = open(os.devnull, 'wb')
+ nullui.fout = open(os.devnull, b'wb')
nullui.disablepager()
- revs = opts.get('rev')
+ revs = opts.get(b'rev')
if not revs:
- revs = ['all()']
+ revs = [b'all()']
revs = list(scmutil.revrange(repo, revs))
- defaulttemplate = ('{date|shortdate} [{rev}:{node|short}]'
- ' {author|person}: {desc|firstline}\n')
+ defaulttemplate = (b'{date|shortdate} [{rev}:{node|short}]'
+ b' {author|person}: {desc|firstline}\n')
if testedtemplate is None:
testedtemplate = defaulttemplate
displayer = makelogtemplater(nullui, repo, testedtemplate)
@@ -1069,38 +1070,38 @@
timer(format)
fm.end()
- at command('perfcca', formatteropts)
+ at command(b'perfcca', formatteropts)
def perfcca(ui, repo, **opts):
timer, fm = gettimer(ui, opts)
timer(lambda: scmutil.casecollisionauditor(ui, False, repo.dirstate))
fm.end()
- at command('perffncacheload', formatteropts)
+ at command(b'perffncacheload', formatteropts)
def perffncacheload(ui, repo, **opts):
timer, fm = gettimer(ui, opts)
s = repo.store
def d():
s.fncache._load()
timer(d)
fm.end()
- at command('perffncachewrite', formatteropts)
+ at command(b'perffncachewrite', formatteropts)
def perffncachewrite(ui, repo, **opts):
timer, fm = gettimer(ui, opts)
s = repo.store
lock = repo.lock()
s.fncache._load()
- tr = repo.transaction('perffncachewrite')
- tr.addbackup('fncache')
+ tr = repo.transaction(b'perffncachewrite')
+ tr.addbackup(b'fncache')
def d():
s.fncache._dirty = True
s.fncache.write(tr)
timer(d)
tr.close()
lock.release()
fm.end()
- at command('perffncacheencode', formatteropts)
+ at command(b'perffncacheencode', formatteropts)
def perffncacheencode(ui, repo, **opts):
timer, fm = gettimer(ui, opts)
s = repo.store
@@ -1130,22 +1131,22 @@
def _manifestrevision(repo, mnode):
ml = repo.manifestlog
- if util.safehasattr(ml, 'getstorage'):
+ if util.safehasattr(ml, b'getstorage'):
store = ml.getstorage(b'')
else:
store = ml._revlog
return store.revision(mnode)
- at command('perfbdiff', revlogopts + formatteropts + [
- ('', 'count', 1, 'number of revisions to test (when using --startrev)'),
- ('', 'alldata', False, 'test bdiffs for all associated revisions'),
- ('', 'threads', 0, 'number of thread to use (disable with 0)'),
- ('', 'blocks', False, 'test computing diffs into blocks'),
- ('', 'xdiff', False, 'use xdiff algorithm'),
+ at command(b'perfbdiff', revlogopts + formatteropts + [
+ (b'', b'count', 1, b'number of revisions to test (when using --startrev)'),
+ (b'', b'alldata', False, b'test bdiffs for all associated revisions'),
+ (b'', b'threads', 0, b'number of thread to use (disable with 0)'),
+ (b'', b'blocks', False, b'test computing diffs into blocks'),
+ (b'', b'xdiff', False, b'use xdiff algorithm'),
],
- '-c|-m|FILE REV')
+ b'-c|-m|FILE REV')
def perfbdiff(ui, repo, file_, rev=None, count=None, threads=0, **opts):
"""benchmark a bdiff between revisions
@@ -1160,26 +1161,26 @@
"""
opts = pycompat.byteskwargs(opts)
- if opts['xdiff'] and not opts['blocks']:
- raise error.CommandError('perfbdiff', '--xdiff requires --blocks')
+ if opts[b'xdiff'] and not opts[b'blocks']:
+ raise error.CommandError(b'perfbdiff', b'--xdiff requires --blocks')
- if opts['alldata']:
- opts['changelog'] = True
+ if opts[b'alldata']:
+ opts[b'changelog'] = True
- if opts.get('changelog') or opts.get('manifest'):
+ if opts.get(b'changelog') or opts.get(b'manifest'):
file_, rev = None, file_
elif rev is None:
- raise error.CommandError('perfbdiff', 'invalid arguments')
+ raise error.CommandError(b'perfbdiff', b'invalid arguments')
- blocks = opts['blocks']
- xdiff = opts['xdiff']
+ blocks = opts[b'blocks']
+ xdiff = opts[b'xdiff']
textpairs = []
- r = cmdutil.openrevlog(repo, 'perfbdiff', file_, opts)
+ r = cmdutil.openrevlog(repo, b'perfbdiff', file_, opts)
startrev = r.rev(r.lookup(rev))
for rev in range(startrev, min(startrev + count, len(r) - 1)):
- if opts['alldata']:
+ if opts[b'alldata']:
# Load revisions associated with changeset.
ctx = repo[rev]
mtext = _manifestrevision(repo, ctx.manifestnode())
@@ -1238,10 +1239,10 @@
with ready:
ready.notify_all()
- at command('perfunidiff', revlogopts + formatteropts + [
- ('', 'count', 1, 'number of revisions to test (when using --startrev)'),
- ('', 'alldata', False, 'test unidiffs for all associated revisions'),
- ], '-c|-m|FILE REV')
+ at command(b'perfunidiff', revlogopts + formatteropts + [
+ (b'', b'count', 1, b'number of revisions to test (when using --startrev)'),
+ (b'', b'alldata', False, b'test unidiffs for all associated revisions'),
+ ], b'-c|-m|FILE REV')
def perfunidiff(ui, repo, file_, rev=None, count=None, **opts):
"""benchmark a unified diff between revisions
@@ -1257,21 +1258,21 @@
measure diffs for all changes related to that changeset (manifest
and filelogs).
"""
- if opts['alldata']:
- opts['changelog'] = True
+ if opts[b'alldata']:
+ opts[b'changelog'] = True
- if opts.get('changelog') or opts.get('manifest'):
+ if opts.get(b'changelog') or opts.get(b'manifest'):
file_, rev = None, file_
elif rev is None:
- raise error.CommandError('perfunidiff', 'invalid arguments')
+ raise error.CommandError(b'perfunidiff', b'invalid arguments')
textpairs = []
- r = cmdutil.openrevlog(repo, 'perfunidiff', file_, opts)
+ r = cmdutil.openrevlog(repo, b'perfunidiff', file_, opts)
startrev = r.rev(r.lookup(rev))
for rev in range(startrev, min(startrev + count, len(r) - 1)):
- if opts['alldata']:
+ if opts[b'alldata']:
# Load revisions associated with changeset.
ctx = repo[rev]
mtext = _manifestrevision(repo, ctx.manifestnode())
@@ -1295,57 +1296,57 @@
for left, right in textpairs:
# The date strings don't matter, so we pass empty strings.
headerlines, hunks = mdiff.unidiff(
- left, '', right, '', 'left', 'right', binary=False)
+ left, b'', right, b'', b'left', b'right', binary=False)
# consume iterators in roughly the way patch.py does
b'\n'.join(headerlines)
b''.join(sum((list(hlines) for hrange, hlines in hunks), []))
timer, fm = gettimer(ui, opts)
timer(d)
fm.end()
- at command('perfdiffwd', formatteropts)
+ at command(b'perfdiffwd', formatteropts)
def perfdiffwd(ui, repo, **opts):
"""Profile diff of working directory changes"""
timer, fm = gettimer(ui, opts)
options = {
- 'w': 'ignore_all_space',
- 'b': 'ignore_space_change',
- 'B': 'ignore_blank_lines',
+ b'w': b'ignore_all_space',
+ b'b': b'ignore_space_change',
+ b'B': b'ignore_blank_lines',
}
- for diffopt in ('', 'w', 'b', 'B', 'wB'):
- opts = dict((options[c], '1') for c in diffopt)
+ for diffopt in (b'', b'w', b'b', b'B', b'wB'):
+ opts = dict((options[c], b'1') for c in diffopt)
def d():
ui.pushbuffer()
commands.diff(ui, repo, **opts)
ui.popbuffer()
- title = 'diffopts: %s' % (diffopt and ('-' + diffopt) or 'none')
+ title = b'diffopts: %s' % (diffopt and (b'-' + diffopt) or b'none')
timer(d, title)
fm.end()
- at command('perfrevlogindex', revlogopts + formatteropts,
- '-c|-m|FILE')
+ at command(b'perfrevlogindex', revlogopts + formatteropts,
+ b'-c|-m|FILE')
def perfrevlogindex(ui, repo, file_=None, **opts):
"""Benchmark operations against a revlog index.
This tests constructing a revlog instance, reading index data,
parsing index data, and performing various operations related to
index data.
"""
- rl = cmdutil.openrevlog(repo, 'perfrevlogindex', file_, opts)
+ rl = cmdutil.openrevlog(repo, b'perfrevlogindex', file_, opts)
opener = getattr(rl, 'opener') # trick linter
indexfile = rl.indexfile
data = opener.read(indexfile)
- header = struct.unpack('>I', data[0:4])[0]
+ header = struct.unpack(b'>I', data[0:4])[0]
version = header & 0xFFFF
if version == 1:
revlogio = revlog.revlogio()
inline = header & (1 << 16)
else:
- raise error.Abort(('unsupported revlog version: %d') % version)
+ raise error.Abort((b'unsupported revlog version: %d') % version)
rllen = len(rl)
@@ -1405,45 +1406,45 @@
pass
benches = [
- (constructor, 'revlog constructor'),
- (read, 'read'),
- (parseindex, 'create index object'),
- (lambda: getentry(0), 'retrieve index entry for rev 0'),
- (lambda: resolvenode('a' * 20), 'look up missing node'),
- (lambda: resolvenode(node0), 'look up node at rev 0'),
- (lambda: resolvenode(node25), 'look up node at 1/4 len'),
- (lambda: resolvenode(node50), 'look up node at 1/2 len'),
- (lambda: resolvenode(node75), 'look up node at 3/4 len'),
- (lambda: resolvenode(node100), 'look up node at tip'),
+ (constructor, b'revlog constructor'),
+ (read, b'read'),
+ (parseindex, b'create index object'),
+ (lambda: getentry(0), b'retrieve index entry for rev 0'),
+ (lambda: resolvenode(b'a' * 20), b'look up missing node'),
+ (lambda: resolvenode(node0), b'look up node at rev 0'),
+ (lambda: resolvenode(node25), b'look up node at 1/4 len'),
+ (lambda: resolvenode(node50), b'look up node at 1/2 len'),
+ (lambda: resolvenode(node75), b'look up node at 3/4 len'),
+ (lambda: resolvenode(node100), b'look up node at tip'),
# 2x variation is to measure caching impact.
(lambda: resolvenodes(allnodes),
- 'look up all nodes (forward)'),
+ b'look up all nodes (forward)'),
(lambda: resolvenodes(allnodes, 2),
- 'look up all nodes 2x (forward)'),
+ b'look up all nodes 2x (forward)'),
(lambda: resolvenodes(allnodesrev),
- 'look up all nodes (reverse)'),
+ b'look up all nodes (reverse)'),
(lambda: resolvenodes(allnodesrev, 2),
- 'look up all nodes 2x (reverse)'),
+ b'look up all nodes 2x (reverse)'),
(lambda: getentries(allrevs),
- 'retrieve all index entries (forward)'),
+ b'retrieve all index entries (forward)'),
(lambda: getentries(allrevs, 2),
- 'retrieve all index entries 2x (forward)'),
+ b'retrieve all index entries 2x (forward)'),
(lambda: getentries(allrevsrev),
- 'retrieve all index entries (reverse)'),
+ b'retrieve all index entries (reverse)'),
(lambda: getentries(allrevsrev, 2),
- 'retrieve all index entries 2x (reverse)'),
+ b'retrieve all index entries 2x (reverse)'),
]
for fn, title in benches:
timer, fm = gettimer(ui, opts)
timer(fn, title=title)
fm.end()
- at command('perfrevlogrevisions', revlogopts + formatteropts +
- [('d', 'dist', 100, 'distance between the revisions'),
- ('s', 'startrev', 0, 'revision to start reading at'),
- ('', 'reverse', False, 'read in reverse')],
- '-c|-m|FILE')
+ at command(b'perfrevlogrevisions', revlogopts + formatteropts +
+ [(b'd', b'dist', 100, b'distance between the revisions'),
+ (b's', b'startrev', 0, b'revision to start reading at'),
+ (b'', b'reverse', False, b'read in reverse')],
+ b'-c|-m|FILE')
def perfrevlogrevisions(ui, repo, file_=None, startrev=0, reverse=False,
**opts):
"""Benchmark reading a series of revisions from a revlog.
@@ -1453,15 +1454,15 @@
The start revision can be defined via ``-s/--startrev``.
"""
- rl = cmdutil.openrevlog(repo, 'perfrevlogrevisions', file_, opts)
+ rl = cmdutil.openrevlog(repo, b'perfrevlogrevisions', file_, opts)
rllen = getlen(ui)(rl)
def d():
rl.clearcaches()
beginrev = startrev
endrev = rllen
- dist = opts['dist']
+ dist = opts[b'dist']
if reverse:
beginrev, endrev = endrev, beginrev
@@ -1476,10 +1477,10 @@
timer(d)
fm.end()
- at command('perfrevlogchunks', revlogopts + formatteropts +
- [('e', 'engines', '', 'compression engines to use'),
- ('s', 'startrev', 0, 'revision to start at')],
- '-c|-m|FILE')
+ at command(b'perfrevlogchunks', revlogopts + formatteropts +
+ [(b'e', b'engines', b'', b'compression engines to use'),
+ (b's', b'startrev', 0, b'revision to start at')],
+ b'-c|-m|FILE')
def perfrevlogchunks(ui, repo, file_=None, engines=None, startrev=0, **opts):
"""Benchmark operations on revlog chunks.
@@ -1492,7 +1493,7 @@
For measurements of higher-level operations like resolving revisions,
see ``perfrevlogrevisions`` and ``perfrevlogrevision``.
"""
- rl = cmdutil.openrevlog(repo, 'perfrevlogchunks', file_, opts)
+ rl = cmdutil.openrevlog(repo, b'perfrevlogchunks', file_, opts)
# _chunkraw was renamed to _getsegmentforrevs.
try:
@@ -1502,19 +1503,19 @@
# Verify engines argument.
if engines:
- engines = set(e.strip() for e in engines.split(','))
+ engines = set(e.strip() for e in engines.split(b','))
for engine in engines:
try:
util.compressionengines[engine]
except KeyError:
- raise error.Abort('unknown compression engine: %s' % engine)
+ raise error.Abort(b'unknown compression engine: %s' % engine)
else:
engines = []
for e in util.compengines:
engine = util.compengines[e]
try:
if engine.available():
- engine.revlogcompressor().compress('dummy')
+ engine.revlogcompressor().compress(b'dummy')
engines.append(e)
except NotImplementedError:
pass
@@ -1574,27 +1575,27 @@
rl._compressor = oldcompressor
benches = [
- (lambda: doread(), 'read'),
- (lambda: doreadcachedfh(), 'read w/ reused fd'),
- (lambda: doreadbatch(), 'read batch'),
- (lambda: doreadbatchcachedfh(), 'read batch w/ reused fd'),
- (lambda: dochunk(), 'chunk'),
- (lambda: dochunkbatch(), 'chunk batch'),
+ (lambda: doread(), b'read'),
+ (lambda: doreadcachedfh(), b'read w/ reused fd'),
+ (lambda: doreadbatch(), b'read batch'),
+ (lambda: doreadbatchcachedfh(), b'read batch w/ reused fd'),
+ (lambda: dochunk(), b'chunk'),
+ (lambda: dochunkbatch(), b'chunk batch'),
]
for engine in sorted(engines):
compressor = util.compengines[engine].revlogcompressor()
benches.append((functools.partial(docompress, compressor),
- 'compress w/ %s' % engine))
+ b'compress w/ %s' % engine))
for fn, title in benches:
timer, fm = gettimer(ui, opts)
timer(fn, title=title)
fm.end()
- at command('perfrevlogrevision', revlogopts + formatteropts +
- [('', 'cache', False, 'use caches instead of clearing')],
- '-c|-m|FILE REV')
+ at command(b'perfrevlogrevision', revlogopts + formatteropts +
+ [(b'', b'cache', False, b'use caches instead of clearing')],
+ b'-c|-m|FILE REV')
def perfrevlogrevision(ui, repo, file_, rev=None, cache=None, **opts):
"""Benchmark obtaining a revlog revision.
@@ -1608,12 +1609,12 @@
This command measures the time spent in each of these phases.
"""
- if opts.get('changelog') or opts.get('manifest'):
+ if opts.get(b'changelog') or opts.get(b'manifest'):
file_, rev = None, file_
elif rev is None:
- raise error.CommandError('perfrevlogrevision', 'invalid arguments')
+ raise error.CommandError(b'perfrevlogrevision', b'invalid arguments')
- r = cmdutil.openrevlog(repo, 'perfrevlogrevision', file_, opts)
+ r = cmdutil.openrevlog(repo, b'perfrevlogrevision', file_, opts)
# _chunkraw was renamed to _getsegmentforrevs.
try:
@@ -1688,24 +1689,24 @@
text = mdiff.patches(text, bins)
benches = [
- (lambda: dorevision(), 'full'),
- (lambda: dodeltachain(rev), 'deltachain'),
- (lambda: doread(chain), 'read'),
- (lambda: dorawchunks(data, chain), 'rawchunks'),
- (lambda: dodecompress(rawchunks), 'decompress'),
- (lambda: dopatch(text, bins), 'patch'),
- (lambda: dohash(text), 'hash'),
+ (lambda: dorevision(), b'full'),
+ (lambda: dodeltachain(rev), b'deltachain'),
+ (lambda: doread(chain), b'read'),
+ (lambda: dorawchunks(data, chain), b'rawchunks'),
+ (lambda: dodecompress(rawchunks), b'decompress'),
+ (lambda: dopatch(text, bins), b'patch'),
+ (lambda: dohash(text), b'hash'),
]
for fn, title in benches:
timer, fm = gettimer(ui, opts)
timer(fn, title=title)
fm.end()
- at command('perfrevset',
- [('C', 'clear', False, 'clear volatile cache between each call.'),
- ('', 'contexts', False, 'obtain changectx for each revision')]
- + formatteropts, "REVSET")
+ at command(b'perfrevset',
+ [(b'C', b'clear', False, b'clear volatile cache between each call.'),
+ (b'', b'contexts', False, b'obtain changectx for each revision')]
+ + formatteropts, b"REVSET")
def perfrevset(ui, repo, expr, clear=False, contexts=False, **opts):
"""benchmark the execution time of a revset
@@ -1723,9 +1724,9 @@
timer(d)
fm.end()
- at command('perfvolatilesets',
- [('', 'clear-obsstore', False, 'drop obsstore between each call.'),
- ] + formatteropts)
+ at command(b'perfvolatilesets',
+ [(b'', b'clear-obsstore', False, b'drop obsstore between each call.'),
+ ] + formatteropts)
def perfvolatilesets(ui, repo, *names, **opts):
"""benchmark the computation of various volatile set
@@ -1736,8 +1737,8 @@
def getobs(name):
def d():
repo.invalidatevolatilesets()
- if opts['clear_obsstore']:
- clearfilecache(repo, 'obsstore')
+ if opts[b'clear_obsstore']:
+ clearfilecache(repo, b'obsstore')
obsolete.getrevs(repo, name)
return d
@@ -1751,8 +1752,8 @@
def getfiltered(name):
def d():
repo.invalidatevolatilesets()
- if opts['clear_obsstore']:
- clearfilecache(repo, 'obsstore')
+ if opts[b'clear_obsstore']:
+ clearfilecache(repo, b'obsstore')
repoview.filterrevs(repo, name)
return d
@@ -1764,19 +1765,19 @@
timer(getfiltered(name), title=name)
fm.end()
- at command('perfbranchmap',
- [('f', 'full', False,
- 'Includes build time of subset'),
- ('', 'clear-revbranch', False,
- 'purge the revbranch cache between computation'),
- ] + formatteropts)
+ at command(b'perfbranchmap',
+ [(b'f', b'full', False,
+ b'Includes build time of subset'),
+ (b'', b'clear-revbranch', False,
+ b'purge the revbranch cache between computation'),
+ ] + formatteropts)
def perfbranchmap(ui, repo, *filternames, **opts):
"""benchmark the update of a branchmap
This benchmarks the full repo.branchmap() call with read and write disabled
"""
- full = opts.get("full", False)
- clear_revbranch = opts.get("clear_revbranch", False)
+ full = opts.get(b"full", False)
+ clear_revbranch = opts.get(b"clear_revbranch", False)
timer, fm = gettimer(ui, opts)
def getbranchmap(filtername):
"""generate a benchmark function for the filtername"""
@@ -1805,59 +1806,59 @@
if subset not in possiblefilters:
break
else:
- assert False, 'subset cycle %s!' % possiblefilters
+ assert False, b'subset cycle %s!' % possiblefilters
allfilters.append(name)
possiblefilters.remove(name)
# warm the cache
if not full:
for name in allfilters:
repo.filtered(name).branchmap()
- if not filternames or 'unfiltered' in filternames:
+ if not filternames or b'unfiltered' in filternames:
# add unfiltered
allfilters.append(None)
- branchcacheread = safeattrsetter(branchmap, 'read')
- branchcachewrite = safeattrsetter(branchmap.branchcache, 'write')
+ branchcacheread = safeattrsetter(branchmap, b'read')
+ branchcachewrite = safeattrsetter(branchmap.branchcache, b'write')
branchcacheread.set(lambda repo: None)
branchcachewrite.set(lambda bc, repo: None)
try:
for name in allfilters:
printname = name
if name is None:
- printname = 'unfiltered'
+ printname = b'unfiltered'
timer(getbranchmap(name), title=str(printname))
finally:
branchcacheread.restore()
branchcachewrite.restore()
fm.end()
- at command('perfbranchmapload', [
- ('f', 'filter', '', 'Specify repoview filter'),
- ('', 'list', False, 'List brachmap filter caches'),
+ at command(b'perfbranchmapload', [
+ (b'f', b'filter', b'', b'Specify repoview filter'),
+ (b'', b'list', False, b'List brachmap filter caches'),
] + formatteropts)
-def perfbranchmapread(ui, repo, filter='', list=False, **opts):
+def perfbranchmapread(ui, repo, filter=b'', list=False, **opts):
"""benchmark reading the branchmap"""
if list:
for name, kind, st in repo.cachevfs.readdir(stat=True):
- if name.startswith('branch2'):
- filtername = name.partition('-')[2] or 'unfiltered'
- ui.status('%s - %s\n'
+ if name.startswith(b'branch2'):
+ filtername = name.partition(b'-')[2] or b'unfiltered'
+ ui.status(b'%s - %s\n'
% (filtername, util.bytecount(st.st_size)))
return
if filter:
repo = repoview.repoview(repo, filter)
else:
repo = repo.unfiltered()
# try once without timer, the filter may not be cached
if branchmap.read(repo) is None:
- raise error.Abort('No brachmap cached for %s repo'
- % (filter or 'unfiltered'))
+ raise error.Abort(b'No brachmap cached for %s repo'
+ % (filter or b'unfiltered'))
timer, fm = gettimer(ui, opts)
timer(lambda: branchmap.read(repo) and None)
fm.end()
- at command('perfloadmarkers')
+ at command(b'perfloadmarkers')
def perfloadmarkers(ui, repo):
"""benchmark the time to parse the on-disk markers for a repo
@@ -1867,12 +1868,12 @@
timer(lambda: len(obsolete.obsstore(svfs)))
fm.end()
- at command('perflrucachedict', formatteropts +
- [('', 'size', 4, 'size of cache'),
- ('', 'gets', 10000, 'number of key lookups'),
- ('', 'sets', 10000, 'number of key sets'),
- ('', 'mixed', 10000, 'number of mixed mode operations'),
- ('', 'mixedgetfreq', 50, 'frequency of get vs set ops in mixed mode')],
+ at command(b'perflrucachedict', formatteropts +
+ [(b'', b'size', 4, b'size of cache'),
+ (b'', b'gets', 10000, b'number of key lookups'),
+ (b'', b'sets', 10000, b'number of key sets'),
+ (b'', b'mixed', 10000, b'number of mixed mode operations'),
+ (b'', b'mixedgetfreq', 50, b'frequency of get vs set ops in mixed mode')],
norepo=True)
def perflrucache(ui, size=4, gets=10000, sets=10000, mixed=10000,
mixedgetfreq=50, **opts):
@@ -1932,39 +1933,39 @@
d[v] = v
benches = [
- (doinit, 'init'),
- (dogets, 'gets'),
- (dosets, 'sets'),
- (domixed, 'mixed')
+ (doinit, b'init'),
+ (dogets, b'gets'),
+ (dosets, b'sets'),
+ (domixed, b'mixed')
]
for fn, title in benches:
timer, fm = gettimer(ui, opts)
timer(fn, title=title)
fm.end()
- at command('perfwrite', formatteropts)
+ at command(b'perfwrite', formatteropts)
def perfwrite(ui, repo, **opts):
"""microbenchmark ui.write
"""
timer, fm = gettimer(ui, opts)
def write():
for i in range(100000):
- ui.write(('Testing write performance\n'))
+ ui.write((b'Testing write performance\n'))
timer(write)
fm.end()
def uisetup(ui):
- if (util.safehasattr(cmdutil, 'openrevlog') and
- not util.safehasattr(commands, 'debugrevlogopts')):
+ if (util.safehasattr(cmdutil, b'openrevlog') and
+ not util.safehasattr(commands, b'debugrevlogopts')):
# for "historical portability":
# In this case, Mercurial should be 1.9 (or a79fea6b3e77) -
# 3.7 (or 5606f7d0d063). Therefore, '--dir' option for
# openrevlog() should cause failure, because it has been
# available since 3.5 (or 49c583ca48c4).
def openrevlog(orig, repo, cmd, file_, opts):
- if opts.get('dir') and not util.safehasattr(repo, 'dirlog'):
- raise error.Abort("This version doesn't support --dir option",
- hint="use 3.5 or later")
+ if opts.get(b'dir') and not util.safehasattr(repo, b'dirlog'):
+ raise error.Abort(b"This version doesn't support --dir option",
+ hint=b"use 3.5 or later")
return orig(repo, cmd, file_, opts)
- extensions.wrapfunction(cmdutil, 'openrevlog', openrevlog)
+ extensions.wrapfunction(cmdutil, b'openrevlog', openrevlog)
To: pulkit, #hg-reviewers
Cc: mjpieters, mercurial-devel
More information about the Mercurial-devel
mailing list