perf.py
1803 lines
| 55.9 KiB
| text/x-python
|
PythonLexer
/ contrib / perf.py
|
r7366 | # perf.py - performance test routines | ||
|
r8873 | '''helper extension to measure performance''' | ||
|
r7366 | |||
|
r29493 | # "historical portability" policy of perf.py: | ||
# | ||||
# We have to do: | ||||
# - make perf.py "loadable" with as wide Mercurial version as possible | ||||
# This doesn't mean that perf commands work correctly with that Mercurial. | ||||
# BTW, perf.py itself has been available since 1.1 (or eb240755386d). | ||||
# - make historical perf command work correctly with as wide Mercurial | ||||
# version as possible | ||||
# | ||||
# We have to do, if possible with reasonable cost: | ||||
# - make recent perf command for historical feature work correctly | ||||
# with early Mercurial | ||||
# | ||||
# We don't have to do: | ||||
# - make perf command for recent feature work correctly with early | ||||
# Mercurial | ||||
|
r28561 | from __future__ import absolute_import | ||
import functools | ||||
|
r31397 | import gc | ||
|
r28561 | import os | ||
|
r27286 | import random | ||
|
r32532 | import struct | ||
|
r28561 | import sys | ||
|
r35617 | import threading | ||
|
r28561 | import time | ||
from mercurial import ( | ||||
|
r30018 | changegroup, | ||
|
r28561 | cmdutil, | ||
commands, | ||||
copies, | ||||
error, | ||||
|
r29495 | extensions, | ||
|
r28561 | mdiff, | ||
merge, | ||||
|
r32532 | revlog, | ||
|
r28561 | util, | ||
) | ||||
|
r7366 | |||
|
r29494 | # for "historical portability": | ||
|
r29567 | # try to import modules separately (in dict order), and ignore | ||
# failure, because these aren't available with early Mercurial | ||||
try: | ||||
from mercurial import branchmap # since 2.5 (or bcee63733aad) | ||||
except ImportError: | ||||
pass | ||||
try: | ||||
from mercurial import obsolete # since 2.3 (or ad0d6c2b3279) | ||||
except ImportError: | ||||
pass | ||||
try: | ||||
|
r32337 | from mercurial import registrar # since 3.7 (or 37d50250b696) | ||
dir(registrar) # forcibly load it | ||||
except ImportError: | ||||
registrar = None | ||||
try: | ||||
|
r29567 | from mercurial import repoview # since 2.5 (or 3a6ddacb7198) | ||
except ImportError: | ||||
pass | ||||
try: | ||||
from mercurial import scmutil # since 1.9 (or 8b252e826c68) | ||||
except ImportError: | ||||
pass | ||||
|
r36196 | try: | ||
from mercurial import pycompat | ||||
getargspec = pycompat.getargspec # added to module after 4.5 | ||||
except (ImportError, AttributeError): | ||||
import inspect | ||||
getargspec = inspect.getargspec | ||||
|
r29567 | |||
|
r37863 | try: | ||
# 4.7+ | ||||
queue = pycompat.queue.Queue | ||||
except (AttributeError, ImportError): | ||||
# <4.7. | ||||
try: | ||||
queue = pycompat.queue | ||||
except (AttributeError, ImportError): | ||||
queue = util.queue | ||||
|
r38276 | try: | ||
from mercurial import logcmdutil | ||||
makelogtemplater = logcmdutil.maketemplater | ||||
except (AttributeError, ImportError): | ||||
try: | ||||
makelogtemplater = cmdutil.makelogtemplater | ||||
except (AttributeError, ImportError): | ||||
makelogtemplater = None | ||||
|
r29567 | # for "historical portability": | ||
|
r29494 | # define util.safehasattr forcibly, because util.safehasattr has been | ||
# available since 1.9.3 (or 94b200a11cf7) | ||||
_undefined = object() | ||||
def safehasattr(thing, attr): | ||||
return getattr(thing, attr, _undefined) is not _undefined | ||||
setattr(util, 'safehasattr', safehasattr) | ||||
|
r29496 | # for "historical portability": | ||
|
r31823 | # define util.timer forcibly, because util.timer has been available | ||
# since ae5d60bb70c9 | ||||
if safehasattr(time, 'perf_counter'): | ||||
util.timer = time.perf_counter | ||||
elif os.name == 'nt': | ||||
util.timer = time.clock | ||||
else: | ||||
util.timer = time.time | ||||
# for "historical portability": | ||||
|
r29496 | # use locally defined empty option list, if formatteropts isn't | ||
# available, because commands.formatteropts has been available since | ||||
# 3.2 (or 7a7eed5176a4), even though formatting itself has been | ||||
# available since 2.2 (or ae5f92e154d3) | ||||
|
r32375 | formatteropts = getattr(cmdutil, "formatteropts", | ||
getattr(commands, "formatteropts", [])) | ||||
|
r29495 | |||
# for "historical portability": | ||||
# use locally defined option list, if debugrevlogopts isn't available, | ||||
# because commands.debugrevlogopts has been available since 3.7 (or | ||||
# 5606f7d0d063), even though cmdutil.openrevlog() has been available | ||||
# since 1.9 (or a79fea6b3e77). | ||||
|
r32375 | revlogopts = getattr(cmdutil, "debugrevlogopts", | ||
getattr(commands, "debugrevlogopts", [ | ||||
|
r29495 | ('c', 'changelog', False, ('open changelog')), | ||
('m', 'manifest', False, ('open manifest')), | ||||
('', 'dir', False, ('open directory manifest')), | ||||
|
r32375 | ])) | ||
|
r25494 | |||
|
r18237 | cmdtable = {} | ||
|
r29497 | |||
# for "historical portability": | ||||
# define parsealiases locally, because cmdutil.parsealiases has been | ||||
# available since 1.5 (or 6252852b4332) | ||||
def parsealiases(cmd): | ||||
return cmd.lstrip("^").split("|") | ||||
|
r32337 | if safehasattr(registrar, 'command'): | ||
command = registrar.command(cmdtable) | ||||
elif safehasattr(cmdutil, 'command'): | ||||
|
r29497 | command = cmdutil.command(cmdtable) | ||
|
r36196 | if 'norepo' not in getargspec(command).args: | ||
|
r29497 | # 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)) | ||||
return _command(name, list(options), synopsis) | ||||
else: | ||||
# for "historical portability": | ||||
# define "@command" annotation locally, because cmdutil.command | ||||
# has been available since 1.9 (or 2daa5179e73f) | ||||
def command(name, options=(), synopsis=None, norepo=False): | ||||
def decorator(func): | ||||
if synopsis: | ||||
cmdtable[name] = func, list(options), synopsis | ||||
else: | ||||
cmdtable[name] = func, list(options) | ||||
if norepo: | ||||
commands.norepo += ' %s' % ' '.join(parsealiases(name)) | ||||
return func | ||||
return decorator | ||||
|
r18237 | |||
|
r34495 | try: | ||
|
r34750 | import mercurial.registrar | ||
import mercurial.configitems | ||||
|
r34495 | configtable = {} | ||
|
r34750 | configitem = mercurial.registrar.configitem(configtable) | ||
configitem('perf', 'presleep', | ||||
default=mercurial.configitems.dynamicdefault, | ||||
) | ||||
|
r34495 | configitem('perf', 'stub', | ||
|
r34750 | default=mercurial.configitems.dynamicdefault, | ||
|
r34495 | ) | ||
|
r34751 | configitem('perf', 'parentscount', | ||
default=mercurial.configitems.dynamicdefault, | ||||
) | ||||
|
r34495 | except (ImportError, AttributeError): | ||
pass | ||||
|
r27307 | def getlen(ui): | ||
|
r34750 | if ui.configbool("perf", "stub", False): | ||
|
r27307 | return lambda x: 1 | ||
return len | ||||
|
r23171 | def gettimer(ui, opts=None): | ||
"""return a timer function and formatter: (timer, formatter) | ||||
|
r27303 | This function exists to gather the creation of formatter in a single | ||
place instead of duplicating it in all performance commands.""" | ||||
|
r23788 | |||
# enforce an idle period before execution to counteract power management | ||||
|
r25850 | # experimental config: perf.presleep | ||
|
r30149 | time.sleep(getint(ui, "perf", "presleep", 1)) | ||
|
r23788 | |||
|
r23171 | if opts is None: | ||
opts = {} | ||||
|
r30405 | # redirect all to stderr unless buffer api is in use | ||
if not ui._buffers: | ||||
ui = ui.copy() | ||||
uifout = safeattrsetter(ui, 'fout', ignoremissing=True) | ||||
if uifout: | ||||
# for "historical portability": | ||||
# ui.fout/ferr have been available since 1.9 (or 4e1ccd4c2b6d) | ||||
uifout.set(ui.ferr) | ||||
|
r30147 | |||
|
r23171 | # get a formatter | ||
|
r30147 | uiformatter = getattr(ui, 'formatter', None) | ||
if uiformatter: | ||||
fm = uiformatter('perf', opts) | ||||
else: | ||||
# for "historical portability": | ||||
# define formatter locally, because ui.formatter has been | ||||
# available since 2.2 (or ae5f92e154d3) | ||||
from mercurial import node | ||||
class defaultformatter(object): | ||||
"""Minimized composition of baseformatter and plainformatter | ||||
""" | ||||
def __init__(self, ui, topic, opts): | ||||
self._ui = ui | ||||
if ui.debugflag: | ||||
self.hexfunc = node.hex | ||||
else: | ||||
self.hexfunc = node.short | ||||
def __nonzero__(self): | ||||
return False | ||||
|
r31476 | __bool__ = __nonzero__ | ||
|
r30147 | def startitem(self): | ||
pass | ||||
def data(self, **data): | ||||
pass | ||||
def write(self, fields, deftext, *fielddata, **opts): | ||||
self._ui.write(deftext % fielddata, **opts) | ||||
def condwrite(self, cond, fields, deftext, *fielddata, **opts): | ||||
if cond: | ||||
self._ui.write(deftext % fielddata, **opts) | ||||
def plain(self, text, **opts): | ||||
self._ui.write(text, **opts) | ||||
def end(self): | ||||
pass | ||||
fm = defaultformatter(ui, 'perf', opts) | ||||
|
r27304 | # stub function, runs code only once instead of in a loop | ||
# experimental config: perf.stub | ||||
|
r34750 | if ui.configbool("perf", "stub", False): | ||
|
r27304 | return functools.partial(stub_timer, fm), fm | ||
|
r23171 | return functools.partial(_timer, fm), fm | ||
|
r27304 | def stub_timer(fm, func, title=None): | ||
func() | ||||
|
r23171 | def _timer(fm, func, title=None): | ||
|
r31397 | gc.collect() | ||
|
r7366 | results = [] | ||
|
r30975 | begin = util.timer() | ||
|
r7366 | count = 0 | ||
|
r14494 | while True: | ||
|
r7366 | ostart = os.times() | ||
|
r30975 | cstart = util.timer() | ||
|
r7366 | r = func() | ||
|
r30975 | cstop = util.timer() | ||
|
r7366 | ostop = os.times() | ||
count += 1 | ||||
a, b = ostart, ostop | ||||
results.append((cstop - cstart, b[0] - a[0], b[1]-a[1])) | ||||
if cstop - begin > 3 and count >= 100: | ||||
break | ||||
if cstop - begin > 10 and count >= 3: | ||||
break | ||||
|
r23171 | |||
fm.startitem() | ||||
|
r9826 | if title: | ||
|
r23171 | fm.write('title', '! %s\n', title) | ||
|
r7366 | if r: | ||
|
r23171 | fm.write('result', '! result: %s\n', r) | ||
|
r7366 | m = min(results) | ||
|
r23171 | fm.plain('!') | ||
fm.write('wall', ' wall %f', m[0]) | ||||
fm.write('comb', ' comb %f', m[1] + m[2]) | ||||
fm.write('user', ' user %f', m[1]) | ||||
fm.write('sys', ' sys %f', m[2]) | ||||
fm.write('count', ' (best of %d)', count) | ||||
fm.plain('\n') | ||||
|
r7366 | |||
|
r30143 | # utilities for historical portability | ||
|
r30149 | def getint(ui, section, name, default): | ||
# for "historical portability": | ||||
# ui.configint has been available since 1.9 (or fa2b596db182) | ||||
v = ui.config(section, name, None) | ||||
if v is None: | ||||
return default | ||||
try: | ||||
return int(v) | ||||
except ValueError: | ||||
raise error.ConfigError(("%s.%s is not an integer ('%s')") | ||||
% (section, name, v)) | ||||
|
r30143 | def safeattrsetter(obj, name, ignoremissing=False): | ||
"""Ensure that 'obj' has 'name' attribute before subsequent setattr | ||||
This function is aborted, if 'obj' doesn't have 'name' attribute | ||||
at runtime. This avoids overlooking removal of an attribute, which | ||||
breaks assumption of performance measurement, in the future. | ||||
This function returns the object to (1) assign a new value, and | ||||
(2) restore an original value to the attribute. | ||||
If 'ignoremissing' is true, missing 'name' attribute doesn't cause | ||||
abortion, and this function returns None. This is useful to | ||||
examine an attribute, which isn't ensured in all Mercurial | ||||
versions. | ||||
""" | ||||
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)) | ||||
origvalue = getattr(obj, name) | ||||
class attrutil(object): | ||||
def set(self, newvalue): | ||||
setattr(obj, name, newvalue) | ||||
def restore(self): | ||||
setattr(obj, name, origvalue) | ||||
return attrutil() | ||||
|
r30144 | # utilities to examine each internal API changes | ||
def getbranchmapsubsettable(): | ||||
# for "historical portability": | ||||
# subsettable is defined in: | ||||
# - branchmap since 2.9 (or 175c6fd8cacc) | ||||
# - repoview since 2.5 (or 59a9f18d4587) | ||||
for mod in (branchmap, repoview): | ||||
subsettable = getattr(mod, 'subsettable', None) | ||||
if subsettable: | ||||
return subsettable | ||||
# 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") | ||||
|
r30146 | def getsvfs(repo): | ||
"""Return appropriate object to access files under .hg/store | ||||
""" | ||||
# for "historical portability": | ||||
# repo.svfs has been available since 2.3 (or 7034365089bf) | ||||
svfs = getattr(repo, 'svfs', None) | ||||
if svfs: | ||||
return svfs | ||||
else: | ||||
return getattr(repo, 'sopener') | ||||
def getvfs(repo): | ||||
"""Return appropriate object to access files under .hg | ||||
""" | ||||
# for "historical portability": | ||||
# repo.vfs has been available since 2.3 (or 7034365089bf) | ||||
vfs = getattr(repo, 'vfs', None) | ||||
if vfs: | ||||
return vfs | ||||
else: | ||||
return getattr(repo, 'opener') | ||||
|
r30150 | 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) | ||||
# 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'] | ||||
return clearcache | ||||
repotags = safeattrsetter(repo, '_tags', ignoremissing=True) | ||||
if repotags: # since 1.4 (or 5614a628d173) | ||||
return lambda : repotags.set(None) | ||||
repotagscache = safeattrsetter(repo, '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")) | ||||
r32731 | # utilities to clear cache | |||
def clearfilecache(repo, attrname): | ||||
unfi = repo.unfiltered() | ||||
if attrname in vars(unfi): | ||||
delattr(unfi, attrname) | ||||
unfi._filecache.pop(attrname, None) | ||||
|
r30143 | # perf commands | ||
|
r25494 | @command('perfwalk', formatteropts) | ||
def perfwalk(ui, repo, *pats, **opts): | ||||
timer, fm = gettimer(ui, opts) | ||||
|
r34343 | m = scmutil.match(repo[None], pats, {}) | ||
|
r34344 | timer(lambda: len(list(repo.dirstate.walk(m, subrepos=[], unknown=True, | ||
ignored=False)))) | ||||
|
r23171 | fm.end() | ||
|
r7366 | |||
|
r25494 | @command('perfannotate', formatteropts) | ||
def perfannotate(ui, repo, f, **opts): | ||||
timer, fm = gettimer(ui, opts) | ||||
|
r19292 | fc = repo['.'][f] | ||
timer(lambda: len(fc.annotate(True))) | ||||
|
r23171 | fm.end() | ||
|
r19292 | |||
|
r18237 | @command('perfstatus', | ||
[('u', 'unknown', False, | ||||
|
r25494 | 'ask status to look for unknown files')] + formatteropts) | ||
|
r18033 | def perfstatus(ui, repo, **opts): | ||
|
r7366 | #m = match.always(repo.root, repo.getcwd()) | ||
|
r16683 | #timer(lambda: sum(map(len, repo.dirstate.status(m, [], False, False, | ||
# False)))) | ||||
|
r27017 | timer, fm = gettimer(ui, opts) | ||
|
r25494 | timer(lambda: sum(map(len, repo.status(unknown=opts['unknown'])))) | ||
|
r23171 | fm.end() | ||
|
r7366 | |||
|
r25494 | @command('perfaddremove', formatteropts) | ||
def perfaddremove(ui, repo, **opts): | ||||
timer, fm = gettimer(ui, opts) | ||||
|
r18871 | try: | ||
oldquiet = repo.ui.quiet | ||||
repo.ui.quiet = True | ||||
|
r23533 | matcher = scmutil.match(repo[None]) | ||
|
r37286 | opts['dry_run'] = True | ||
timer(lambda: scmutil.addremove(repo, matcher, "", opts)) | ||||
|
r18871 | finally: | ||
repo.ui.quiet = oldquiet | ||||
|
r23171 | fm.end() | ||
|
r18871 | |||
|
r16785 | def clearcaches(cl): | ||
# behave somewhat consistently across internal API changes | ||||
if util.safehasattr(cl, 'clearcaches'): | ||||
cl.clearcaches() | ||||
elif util.safehasattr(cl, '_nodecache'): | ||||
from mercurial.node import nullid, nullrev | ||||
cl._nodecache = {nullid: nullrev} | ||||
cl._nodepos = None | ||||
|
r25494 | @command('perfheads', formatteropts) | ||
def perfheads(ui, repo, **opts): | ||||
timer, fm = gettimer(ui, opts) | ||||
|
r16785 | cl = repo.changelog | ||
def d(): | ||||
len(cl.headrevs()) | ||||
clearcaches(cl) | ||||
timer(d) | ||||
|
r23171 | fm.end() | ||
|
r7366 | |||
|
r25494 | @command('perftags', formatteropts) | ||
def perftags(ui, repo, **opts): | ||||
|
r19786 | import mercurial.changelog | ||
import mercurial.manifest | ||||
|
r25494 | timer, fm = gettimer(ui, opts) | ||
|
r30146 | svfs = getsvfs(repo) | ||
|
r30150 | repocleartagscache = repocleartagscachefunc(repo) | ||
|
r7366 | def t(): | ||
|
r30146 | repo.changelog = mercurial.changelog.changelog(svfs) | ||
|
r30219 | repo.manifestlog = mercurial.manifest.manifestlog(svfs, repo) | ||
|
r30150 | repocleartagscache() | ||
|
r7366 | return len(repo.tags()) | ||
timer(t) | ||||
|
r23171 | fm.end() | ||
|
r7366 | |||
|
r25494 | @command('perfancestors', formatteropts) | ||
def perfancestors(ui, repo, **opts): | ||||
timer, fm = gettimer(ui, opts) | ||||
|
r16802 | heads = repo.changelog.headrevs() | ||
def d(): | ||||
|
r16866 | for a in repo.changelog.ancestors(heads): | ||
|
r16802 | pass | ||
timer(d) | ||||
|
r23171 | fm.end() | ||
|
r16802 | |||
|
r25494 | @command('perfancestorset', formatteropts) | ||
def perfancestorset(ui, repo, revset, **opts): | ||||
timer, fm = gettimer(ui, opts) | ||||
|
r18080 | revs = repo.revs(revset) | ||
heads = repo.changelog.headrevs() | ||||
def d(): | ||||
|
r18091 | s = repo.changelog.ancestors(heads) | ||
|
r18080 | for rev in revs: | ||
rev in s | ||||
timer(d) | ||||
|
r23171 | fm.end() | ||
|
r18080 | |||
r32733 | @command('perfbookmarks', formatteropts) | |||
def perfbookmarks(ui, repo, **opts): | ||||
"""benchmark parsing bookmarks from disk to memory""" | ||||
timer, fm = gettimer(ui, opts) | ||||
def d(): | ||||
clearfilecache(repo, '_bookmarks') | ||||
repo._bookmarks | ||||
timer(d) | ||||
fm.end() | ||||
|
r35108 | @command('perfbundleread', formatteropts, 'BUNDLE') | ||
def perfbundleread(ui, repo, bundlepath, **opts): | ||||
"""Benchmark reading of bundle files. | ||||
This command is meant to isolate the I/O part of bundle reading as | ||||
much as possible. | ||||
""" | ||||
from mercurial import ( | ||||
bundle2, | ||||
exchange, | ||||
streamclone, | ||||
) | ||||
def makebench(fn): | ||||
def run(): | ||||
with open(bundlepath, 'rb') as fh: | ||||
bundle = exchange.readbundle(ui, fh, bundlepath) | ||||
fn(bundle) | ||||
return run | ||||
def makereadnbytes(size): | ||||
def run(): | ||||
with open(bundlepath, '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: | ||||
while fh.read(size): | ||||
pass | ||||
return run | ||||
# bundle1 | ||||
def deltaiter(bundle): | ||||
for delta in bundle.deltaiter(): | ||||
pass | ||||
def iterchunks(bundle): | ||||
for chunk in bundle.getchunks(): | ||||
pass | ||||
# bundle2 | ||||
def forwardchunks(bundle): | ||||
for chunk in bundle._forwardchunks(): | ||||
pass | ||||
def iterparts(bundle): | ||||
for part in bundle.iterparts(): | ||||
pass | ||||
|
r35113 | def iterpartsseekable(bundle): | ||
for part in bundle.iterparts(seekable=True): | ||||
pass | ||||
|
r35108 | def seek(bundle): | ||
|
r35113 | for part in bundle.iterparts(seekable=True): | ||
|
r35108 | part.seek(0, os.SEEK_END) | ||
def makepartreadnbytes(size): | ||||
def run(): | ||||
with open(bundlepath, '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)'), | ||||
] | ||||
with open(bundlepath, '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)'), | ||||
]) | ||||
elif isinstance(bundle, bundle2.unbundle20): | ||||
benches.extend([ | ||||
(makebench(forwardchunks), 'bundle2 forwardchunks()'), | ||||
(makebench(iterparts), 'bundle2 iterparts()'), | ||||
|
r35113 | (makebench(iterpartsseekable), 'bundle2 iterparts() seekable'), | ||
|
r35108 | (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)'), | ||||
]) | ||||
elif isinstance(bundle, streamclone.streamcloneapplier): | ||||
raise error.Abort('stream clone bundles not supported') | ||||
else: | ||||
raise error.Abort('unhandled bundle type: %s' % type(bundle)) | ||||
for fn, title in benches: | ||||
timer, fm = gettimer(ui, opts) | ||||
timer(fn, title=title) | ||||
fm.end() | ||||
|
r30018 | @command('perfchangegroupchangelog', formatteropts + | ||
[('', 'version', '02', 'changegroup version'), | ||||
('r', 'rev', '', 'revisions to add to changegroup')]) | ||||
def perfchangegroupchangelog(ui, repo, version='02', rev=None, **opts): | ||||
"""Benchmark producing a changelog group for a changegroup. | ||||
This measures the time spent processing the changelog during a | ||||
bundle operation. This occurs during `hg bundle` and on a server | ||||
processing a `getbundle` wire protocol request (handles clones | ||||
and pull requests). | ||||
By default, all revisions are added to the changegroup. | ||||
""" | ||||
cl = repo.changelog | ||||
revs = [cl.lookup(r) for r in repo.revs(rev or 'all()')] | ||||
bundler = changegroup.getbundler(version, repo) | ||||
def lookup(node): | ||||
# The real bundler reads the revision in order to access the | ||||
# manifest node and files list. Do that here. | ||||
cl.read(node) | ||||
return node | ||||
def d(): | ||||
for chunk in bundler.group(revs, cl, lookup): | ||||
pass | ||||
timer, fm = gettimer(ui, opts) | ||||
timer(d) | ||||
fm.end() | ||||
|
r25494 | @command('perfdirs', formatteropts) | ||
def perfdirs(ui, repo, **opts): | ||||
timer, fm = gettimer(ui, opts) | ||||
|
r18845 | dirstate = repo.dirstate | ||
'a' in dirstate | ||||
def d(): | ||||
|
r35083 | dirstate.hasdir('a') | ||
del dirstate._map._dirs | ||||
|
r18845 | timer(d) | ||
|
r23171 | fm.end() | ||
|
r18845 | |||
|
r25494 | @command('perfdirstate', formatteropts) | ||
def perfdirstate(ui, repo, **opts): | ||||
timer, fm = gettimer(ui, opts) | ||||
|
r7366 | "a" in repo.dirstate | ||
def d(): | ||||
repo.dirstate.invalidate() | ||||
"a" in repo.dirstate | ||||
timer(d) | ||||
|
r23171 | fm.end() | ||
|
r7366 | |||
|
r25494 | @command('perfdirstatedirs', formatteropts) | ||
def perfdirstatedirs(ui, repo, **opts): | ||||
timer, fm = gettimer(ui, opts) | ||||
|
r7366 | "a" in repo.dirstate | ||
def d(): | ||||
|
r35083 | repo.dirstate.hasdir("a") | ||
del repo.dirstate._map._dirs | ||||
|
r7366 | timer(d) | ||
|
r23171 | fm.end() | ||
|
r7366 | |||
|
r25494 | @command('perfdirstatefoldmap', formatteropts) | ||
|
r27095 | def perfdirstatefoldmap(ui, repo, **opts): | ||
|
r25494 | timer, fm = gettimer(ui, opts) | ||
|
r22780 | dirstate = repo.dirstate | ||
'a' in dirstate | ||||
def d(): | ||||
|
r34677 | dirstate._map.filefoldmap.get('a') | ||
del dirstate._map.filefoldmap | ||||
|
r24607 | timer(d) | ||
fm.end() | ||||
|
r25494 | @command('perfdirfoldmap', formatteropts) | ||
def perfdirfoldmap(ui, repo, **opts): | ||||
timer, fm = gettimer(ui, opts) | ||||
|
r24607 | dirstate = repo.dirstate | ||
'a' in dirstate | ||||
def d(): | ||||
|
r34679 | dirstate._map.dirfoldmap.get('a') | ||
del dirstate._map.dirfoldmap | ||||
|
r35083 | del dirstate._map._dirs | ||
|
r22780 | timer(d) | ||
|
r23171 | fm.end() | ||
|
r22780 | |||
|
r25494 | @command('perfdirstatewrite', formatteropts) | ||
def perfdirstatewrite(ui, repo, **opts): | ||||
timer, fm = gettimer(ui, opts) | ||||
|
r16788 | ds = repo.dirstate | ||
"a" in ds | ||||
def d(): | ||||
ds._dirty = True | ||||
|
r26748 | ds.write(repo.currenttransaction()) | ||
|
r16788 | timer(d) | ||
|
r23171 | fm.end() | ||
|
r16788 | |||
|
r18817 | @command('perfmergecalculate', | ||
|
r25494 | [('r', 'rev', '.', 'rev to merge against')] + formatteropts) | ||
def perfmergecalculate(ui, repo, rev, **opts): | ||||
timer, fm = gettimer(ui, opts) | ||||
|
r18817 | wctx = repo[None] | ||
rctx = scmutil.revsingle(repo, rev, rev) | ||||
ancestor = wctx.ancestor(rctx) | ||||
# we don't want working dir files to be stat'd in the benchmark, so prime | ||||
# that cache | ||||
wctx.dirty() | ||||
def d(): | ||||
# acceptremote is True because we don't want prompts in the middle of | ||||
# our benchmark | ||||
|
r27098 | merge.calculateupdates(repo, wctx, rctx, [ancestor], False, False, | ||
|
r27345 | acceptremote=True, followcopies=True) | ||
|
r18817 | timer(d) | ||
|
r23171 | fm.end() | ||
|
r18817 | |||
|
r18877 | @command('perfpathcopies', [], "REV REV") | ||
|
r25494 | def perfpathcopies(ui, repo, rev1, rev2, **opts): | ||
timer, fm = gettimer(ui, opts) | ||||
|
r18877 | ctx1 = scmutil.revsingle(repo, rev1, rev1) | ||
ctx2 = scmutil.revsingle(repo, rev2, rev2) | ||||
def d(): | ||||
copies.pathcopies(ctx1, ctx2) | ||||
timer(d) | ||||
|
r23171 | fm.end() | ||
|
r18877 | |||
r32732 | @command('perfphases', | |||
[('', 'full', False, 'include file reading time too'), | ||||
], "") | ||||
r32467 | def perfphases(ui, repo, **opts): | |||
"""benchmark phasesets computation""" | ||||
timer, fm = gettimer(ui, opts) | ||||
r32732 | _phases = repo._phasecache | |||
full = opts.get('full') | ||||
r32467 | def d(): | |||
r32732 | phases = _phases | |||
if full: | ||||
clearfilecache(repo, '_phasecache') | ||||
phases = repo._phasecache | ||||
r32467 | phases.invalidate() | |||
phases.loadphaserevs(repo) | ||||
timer(d) | ||||
fm.end() | ||||
|
r19712 | @command('perfmanifest', [], 'REV') | ||
|
r25494 | def perfmanifest(ui, repo, rev, **opts): | ||
timer, fm = gettimer(ui, opts) | ||||
|
r19712 | ctx = scmutil.revsingle(repo, rev, rev) | ||
t = ctx.manifestnode() | ||||
|
r7366 | def d(): | ||
|
r30370 | repo.manifestlog.clearcaches() | ||
|
r30369 | repo.manifestlog[t].read() | ||
|
r7366 | timer(d) | ||
|
r23171 | fm.end() | ||
|
r7366 | |||
|
r25494 | @command('perfchangeset', formatteropts) | ||
def perfchangeset(ui, repo, rev, **opts): | ||||
timer, fm = gettimer(ui, opts) | ||||
|
r37373 | n = scmutil.revsingle(repo, rev).node() | ||
|
r16262 | def d(): | ||
|
r19378 | repo.changelog.read(n) | ||
|
r16266 | #repo.changelog._cache = None | ||
|
r16262 | timer(d) | ||
|
r23171 | fm.end() | ||
|
r16262 | |||
|
r25494 | @command('perfindex', formatteropts) | ||
def perfindex(ui, repo, **opts): | ||||
|
r13255 | import mercurial.revlog | ||
|
r25494 | timer, fm = gettimer(ui, opts) | ||
|
r13277 | mercurial.revlog._prereadsize = 2**24 # disable lazy parser in old hg | ||
|
r13254 | n = repo["tip"].node() | ||
|
r30146 | svfs = getsvfs(repo) | ||
|
r7366 | def d(): | ||
|
r30146 | cl = mercurial.revlog.revlog(svfs, "00changelog.i") | ||
|
r16260 | cl.rev(n) | ||
|
r7366 | timer(d) | ||
|
r23171 | fm.end() | ||
|
r7366 | |||
|
r25494 | @command('perfstartup', formatteropts) | ||
def perfstartup(ui, repo, **opts): | ||||
timer, fm = gettimer(ui, opts) | ||||
|
r7366 | cmd = sys.argv[0] | ||
def d(): | ||||
|
r27382 | if os.name != 'nt': | ||
os.system("HGRCPATH= %s version -q > /dev/null" % cmd) | ||||
else: | ||||
|
r32888 | os.environ['HGRCPATH'] = ' ' | ||
|
r27382 | os.system("%s version -q > NUL" % cmd) | ||
|
r7366 | timer(d) | ||
|
r23171 | fm.end() | ||
|
r7366 | |||
|
r25494 | @command('perfparents', formatteropts) | ||
def perfparents(ui, repo, **opts): | ||||
timer, fm = gettimer(ui, opts) | ||||
|
r27305 | # control the number of commits perfparents iterates over | ||
# experimental config: perf.parentscount | ||||
|
r30149 | count = getint(ui, "perf", "parentscount", 1000) | ||
|
r27305 | if len(repo.changelog) < count: | ||
raise error.Abort("repo needs %d commits for this test" % count) | ||||
|
r27100 | repo = repo.unfiltered() | ||
|
r27305 | nl = [repo.changelog.node(i) for i in xrange(count)] | ||
|
r7366 | def d(): | ||
for n in nl: | ||||
repo.changelog.parents(n) | ||||
timer(d) | ||||
|
r23171 | fm.end() | ||
|
r7366 | |||
|
r25494 | @command('perfctxfiles', formatteropts) | ||
|
r27095 | def perfctxfiles(ui, repo, x, **opts): | ||
|
r24349 | x = int(x) | ||
|
r25494 | timer, fm = gettimer(ui, opts) | ||
|
r24349 | def d(): | ||
len(repo[x].files()) | ||||
timer(d) | ||||
fm.end() | ||||
|
r25494 | @command('perfrawfiles', formatteropts) | ||
|
r27095 | def perfrawfiles(ui, repo, x, **opts): | ||
|
r24349 | x = int(x) | ||
|
r25494 | timer, fm = gettimer(ui, opts) | ||
|
r24349 | cl = repo.changelog | ||
def d(): | ||||
len(cl.read(x)[3]) | ||||
timer(d) | ||||
fm.end() | ||||
|
r25494 | @command('perflookup', formatteropts) | ||
def perflookup(ui, repo, rev, **opts): | ||||
timer, fm = gettimer(ui, opts) | ||||
|
r7366 | timer(lambda: len(repo.lookup(rev))) | ||
|
r23171 | fm.end() | ||
|
r7366 | |||
|
r25494 | @command('perfrevrange', formatteropts) | ||
def perfrevrange(ui, repo, *specs, **opts): | ||||
timer, fm = gettimer(ui, opts) | ||||
|
r16858 | revrange = scmutil.revrange | ||
timer(lambda: len(revrange(repo, specs))) | ||||
|
r23171 | fm.end() | ||
|
r16858 | |||
|
r25494 | @command('perfnodelookup', formatteropts) | ||
def perfnodelookup(ui, repo, rev, **opts): | ||||
timer, fm = gettimer(ui, opts) | ||||
|
r16309 | import mercurial.revlog | ||
mercurial.revlog._prereadsize = 2**24 # disable lazy parser in old hg | ||||
|
r37373 | n = scmutil.revsingle(repo, rev).node() | ||
|
r30146 | cl = mercurial.revlog.revlog(getsvfs(repo), "00changelog.i") | ||
|
r16414 | def d(): | ||
cl.rev(n) | ||||
|
r16785 | clearcaches(cl) | ||
|
r16414 | timer(d) | ||
|
r23171 | fm.end() | ||
|
r16414 | |||
|
r18237 | @command('perflog', | ||
|
r25494 | [('', 'rename', False, 'ask log to follow renames')] + formatteropts) | ||
|
r27306 | def perflog(ui, repo, rev=None, **opts): | ||
if rev is None: | ||||
rev=[] | ||||
|
r25494 | timer, fm = gettimer(ui, opts) | ||
|
r7872 | ui.pushbuffer() | ||
|
r27306 | timer(lambda: commands.log(ui, repo, rev=rev, date='', user='', | ||
|
r9932 | copies=opts.get('rename'))) | ||
|
r7872 | ui.popbuffer() | ||
|
r23171 | fm.end() | ||
|
r7872 | |||
|
r25494 | @command('perfmoonwalk', formatteropts) | ||
def perfmoonwalk(ui, repo, **opts): | ||||
|
r20178 | """benchmark walking the changelog backwards | ||
This also loads the changelog data for each revision in the changelog. | ||||
""" | ||||
|
r25494 | timer, fm = gettimer(ui, opts) | ||
|
r20178 | def moonwalk(): | ||
for i in xrange(len(repo), -1, -1): | ||||
ctx = repo[i] | ||||
ctx.branch() # read changelog data (in addition to the index) | ||||
timer(moonwalk) | ||||
|
r23171 | fm.end() | ||
|
r20178 | |||
|
r38275 | @command('perftemplating', | ||
[('r', 'rev', [], 'revisions to run the template on'), | ||||
] + formatteropts) | ||||
|
r38277 | def perftemplating(ui, repo, testedtemplate=None, **opts): | ||
"""test the rendering time of a given template""" | ||||
|
r38276 | if makelogtemplater is None: | ||
|
r38292 | raise error.Abort(("perftemplating not available with this Mercurial"), | ||
hint="use 4.3 or later") | ||||
|
r38276 | |||
|
r38274 | nullui = ui.copy() | ||
nullui.fout = open(os.devnull, 'wb') | ||||
nullui.disablepager() | ||||
|
r38275 | revs = opts.get('rev') | ||
|
r38276 | if not revs: | ||
revs = ['all()'] | ||||
revs = list(scmutil.revrange(repo, revs)) | ||||
|
r38277 | defaulttemplate = ('{date|shortdate} [{rev}:{node|short}]' | ||
' {author|person}: {desc|firstline}\n') | ||||
if testedtemplate is None: | ||||
testedtemplate = defaulttemplate | ||||
displayer = makelogtemplater(nullui, repo, testedtemplate) | ||||
|
r38273 | def format(): | ||
|
r38276 | for r in revs: | ||
ctx = repo[r] | ||||
displayer.show(ctx) | ||||
displayer.flush(ctx) | ||||
|
r38273 | |||
|
r25494 | timer, fm = gettimer(ui, opts) | ||
|
r38273 | timer(format) | ||
|
r23171 | fm.end() | ||
|
r7872 | |||
|
r25494 | @command('perfcca', formatteropts) | ||
def perfcca(ui, repo, **opts): | ||||
timer, fm = gettimer(ui, opts) | ||||
|
r17216 | timer(lambda: scmutil.casecollisionauditor(ui, False, repo.dirstate)) | ||
|
r23171 | fm.end() | ||
|
r16386 | |||
|
r25494 | @command('perffncacheload', formatteropts) | ||
def perffncacheload(ui, repo, **opts): | ||||
timer, fm = gettimer(ui, opts) | ||||
|
r17780 | s = repo.store | ||
|
r16403 | def d(): | ||
s.fncache._load() | ||||
timer(d) | ||||
|
r23171 | fm.end() | ||
|
r16403 | |||
|
r25494 | @command('perffncachewrite', formatteropts) | ||
def perffncachewrite(ui, repo, **opts): | ||||
timer, fm = gettimer(ui, opts) | ||||
|
r17780 | s = repo.store | ||
|
r16403 | s.fncache._load() | ||
|
r27097 | lock = repo.lock() | ||
tr = repo.transaction('perffncachewrite') | ||||
|
r16403 | def d(): | ||
s.fncache._dirty = True | ||||
|
r27097 | s.fncache.write(tr) | ||
|
r16403 | timer(d) | ||
|
r30069 | tr.close() | ||
|
r27097 | lock.release() | ||
|
r23171 | fm.end() | ||
|
r16403 | |||
|
r25494 | @command('perffncacheencode', formatteropts) | ||
def perffncacheencode(ui, repo, **opts): | ||||
timer, fm = gettimer(ui, opts) | ||||
|
r17780 | s = repo.store | ||
|
r17553 | s.fncache._load() | ||
def d(): | ||||
for p in s.fncache.entries: | ||||
s.encode(p) | ||||
timer(d) | ||||
|
r23171 | fm.end() | ||
|
r17553 | |||
|
r36784 | def _bdiffworker(q, blocks, xdiff, ready, done): | ||
|
r35617 | while not done.is_set(): | ||
pair = q.get() | ||||
while pair is not None: | ||||
|
r36784 | if xdiff: | ||
mdiff.bdiff.xdiffblocks(*pair) | ||||
elif blocks: | ||||
mdiff.bdiff.blocks(*pair) | ||||
else: | ||||
mdiff.textdiff(*pair) | ||||
|
r35617 | q.task_done() | ||
pair = q.get() | ||||
q.task_done() # for the None one | ||||
with ready: | ||||
ready.wait() | ||||
|
r30336 | @command('perfbdiff', revlogopts + formatteropts + [ | ||
|
r30337 | ('', 'count', 1, 'number of revisions to test (when using --startrev)'), | ||
|
r35617 | ('', 'alldata', False, 'test bdiffs for all associated revisions'), | ||
('', 'threads', 0, 'number of thread to use (disable with 0)'), | ||||
|
r36784 | ('', 'blocks', False, 'test computing diffs into blocks'), | ||
('', 'xdiff', False, 'use xdiff algorithm'), | ||||
|
r35617 | ], | ||
|
r30336 | '-c|-m|FILE REV') | ||
|
r35617 | def perfbdiff(ui, repo, file_, rev=None, count=None, threads=0, **opts): | ||
|
r30336 | """benchmark a bdiff between revisions | ||
By default, benchmark a bdiff between its delta parent and itself. | ||||
With ``--count``, benchmark bdiffs between delta parents and self for N | ||||
revisions starting at the specified revision. | ||||
|
r30337 | |||
With ``--alldata``, assume the requested revision is a changeset and | ||||
measure bdiffs for all changes related to that changeset (manifest | ||||
and filelogs). | ||||
|
r30336 | """ | ||
|
r36784 | opts = pycompat.byteskwargs(opts) | ||
if opts['xdiff'] and not opts['blocks']: | ||||
raise error.CommandError('perfbdiff', '--xdiff requires --blocks') | ||||
|
r30337 | if opts['alldata']: | ||
opts['changelog'] = True | ||||
|
r30307 | if opts.get('changelog') or opts.get('manifest'): | ||
file_, rev = None, file_ | ||||
elif rev is None: | ||||
raise error.CommandError('perfbdiff', 'invalid arguments') | ||||
|
r36784 | blocks = opts['blocks'] | ||
xdiff = opts['xdiff'] | ||||
|
r30335 | textpairs = [] | ||
|
r30307 | r = cmdutil.openrevlog(repo, 'perfbdiff', file_, opts) | ||
|
r30336 | startrev = r.rev(r.lookup(rev)) | ||
for rev in range(startrev, min(startrev + count, len(r) - 1)): | ||||
|
r30337 | if opts['alldata']: | ||
# Load revisions associated with changeset. | ||||
ctx = repo[rev] | ||||
|
r30426 | mtext = repo.manifestlog._revlog.revision(ctx.manifestnode()) | ||
|
r30337 | for pctx in ctx.parents(): | ||
|
r30426 | pman = repo.manifestlog._revlog.revision(pctx.manifestnode()) | ||
|
r30337 | textpairs.append((pman, mtext)) | ||
# Load filelog revisions by iterating manifest delta. | ||||
man = ctx.manifest() | ||||
pman = ctx.p1().manifest() | ||||
for filename, change in pman.diff(man).items(): | ||||
fctx = repo.file(filename) | ||||
f1 = fctx.revision(change[0][0] or -1) | ||||
f2 = fctx.revision(change[1][0] or -1) | ||||
textpairs.append((f1, f2)) | ||||
else: | ||||
dp = r.deltaparent(rev) | ||||
textpairs.append((r.revision(dp), r.revision(rev))) | ||||
|
r30307 | |||
|
r35617 | withthreads = threads > 0 | ||
if not withthreads: | ||||
def d(): | ||||
for pair in textpairs: | ||||
|
r36784 | if xdiff: | ||
mdiff.bdiff.xdiffblocks(*pair) | ||||
elif blocks: | ||||
mdiff.bdiff.blocks(*pair) | ||||
else: | ||||
mdiff.textdiff(*pair) | ||||
|
r35617 | else: | ||
|
r37863 | q = queue() | ||
|
r35617 | for i in xrange(threads): | ||
q.put(None) | ||||
ready = threading.Condition() | ||||
done = threading.Event() | ||||
for i in xrange(threads): | ||||
|
r36784 | threading.Thread(target=_bdiffworker, | ||
args=(q, blocks, xdiff, ready, done)).start() | ||||
|
r35617 | q.join() | ||
def d(): | ||||
for pair in textpairs: | ||||
q.put(pair) | ||||
for i in xrange(threads): | ||||
q.put(None) | ||||
with ready: | ||||
ready.notify_all() | ||||
q.join() | ||||
|
r30307 | timer, fm = gettimer(ui, opts) | ||
timer(d) | ||||
fm.end() | ||||
|
r35617 | if withthreads: | ||
done.set() | ||||
for i in xrange(threads): | ||||
q.put(None) | ||||
with ready: | ||||
ready.notify_all() | ||||
|
r35879 | @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') | ||||
def perfunidiff(ui, repo, file_, rev=None, count=None, **opts): | ||||
"""benchmark a unified diff between revisions | ||||
This doesn't include any copy tracing - it's just a unified diff | ||||
of the texts. | ||||
By default, benchmark a diff between its delta parent and itself. | ||||
With ``--count``, benchmark diffs between delta parents and self for N | ||||
revisions starting at the specified revision. | ||||
With ``--alldata``, assume the requested revision is a changeset and | ||||
measure diffs for all changes related to that changeset (manifest | ||||
and filelogs). | ||||
""" | ||||
if opts['alldata']: | ||||
opts['changelog'] = True | ||||
if opts.get('changelog') or opts.get('manifest'): | ||||
file_, rev = None, file_ | ||||
elif rev is None: | ||||
raise error.CommandError('perfunidiff', 'invalid arguments') | ||||
textpairs = [] | ||||
r = cmdutil.openrevlog(repo, 'perfunidiff', file_, opts) | ||||
startrev = r.rev(r.lookup(rev)) | ||||
for rev in range(startrev, min(startrev + count, len(r) - 1)): | ||||
if opts['alldata']: | ||||
# Load revisions associated with changeset. | ||||
ctx = repo[rev] | ||||
mtext = repo.manifestlog._revlog.revision(ctx.manifestnode()) | ||||
for pctx in ctx.parents(): | ||||
pman = repo.manifestlog._revlog.revision(pctx.manifestnode()) | ||||
textpairs.append((pman, mtext)) | ||||
# Load filelog revisions by iterating manifest delta. | ||||
man = ctx.manifest() | ||||
pman = ctx.p1().manifest() | ||||
for filename, change in pman.diff(man).items(): | ||||
fctx = repo.file(filename) | ||||
f1 = fctx.revision(change[0][0] or -1) | ||||
f2 = fctx.revision(change[1][0] or -1) | ||||
textpairs.append((f1, f2)) | ||||
else: | ||||
dp = r.deltaparent(rev) | ||||
textpairs.append((r.revision(dp), r.revision(rev))) | ||||
def d(): | ||||
for left, right in textpairs: | ||||
# The date strings don't matter, so we pass empty strings. | ||||
headerlines, hunks = mdiff.unidiff( | ||||
|
r35969 | left, '', right, '', 'left', 'right', binary=False) | ||
|
r35879 | # 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() | ||||
|
r25494 | @command('perfdiffwd', formatteropts) | ||
def perfdiffwd(ui, repo, **opts): | ||||
|
r9826 | """Profile diff of working directory changes""" | ||
|
r25494 | timer, fm = gettimer(ui, opts) | ||
|
r9826 | options = { | ||
'w': 'ignore_all_space', | ||||
'b': 'ignore_space_change', | ||||
'B': 'ignore_blank_lines', | ||||
} | ||||
for diffopt in ('', 'w', 'b', 'B', 'wB'): | ||||
opts = dict((options[c], '1') for c in diffopt) | ||||
def d(): | ||||
ui.pushbuffer() | ||||
commands.diff(ui, repo, **opts) | ||||
ui.popbuffer() | ||||
title = 'diffopts: %s' % (diffopt and ('-' + diffopt) or 'none') | ||||
timer(d, title) | ||||
|
r23171 | fm.end() | ||
|
r9826 | |||
|
r32532 | @command('perfrevlogindex', revlogopts + formatteropts, | ||
'-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) | ||||
opener = getattr(rl, 'opener') # trick linter | ||||
indexfile = rl.indexfile | ||||
data = opener.read(indexfile) | ||||
header = struct.unpack('>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) | ||||
rllen = len(rl) | ||||
node0 = rl.node(0) | ||||
node25 = rl.node(rllen // 4) | ||||
node50 = rl.node(rllen // 2) | ||||
node75 = rl.node(rllen // 4 * 3) | ||||
node100 = rl.node(rllen - 1) | ||||
allrevs = range(rllen) | ||||
allrevsrev = list(reversed(allrevs)) | ||||
allnodes = [rl.node(rev) for rev in range(rllen)] | ||||
allnodesrev = list(reversed(allnodes)) | ||||
def constructor(): | ||||
revlog.revlog(opener, indexfile) | ||||
def read(): | ||||
with opener(indexfile) as fh: | ||||
fh.read() | ||||
def parseindex(): | ||||
revlogio.parseindex(data, inline) | ||||
def getentry(revornode): | ||||
index = revlogio.parseindex(data, inline)[0] | ||||
index[revornode] | ||||
def getentries(revs, count=1): | ||||
index = revlogio.parseindex(data, inline)[0] | ||||
for i in range(count): | ||||
for rev in revs: | ||||
index[rev] | ||||
def resolvenode(node): | ||||
nodemap = revlogio.parseindex(data, inline)[1] | ||||
# This only works for the C code. | ||||
if nodemap is None: | ||||
return | ||||
try: | ||||
nodemap[node] | ||||
except error.RevlogError: | ||||
pass | ||||
def resolvenodes(nodes, count=1): | ||||
nodemap = revlogio.parseindex(data, inline)[1] | ||||
if nodemap is None: | ||||
return | ||||
for i in range(count): | ||||
for node in nodes: | ||||
try: | ||||
nodemap[node] | ||||
except error.RevlogError: | ||||
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'), | ||||
# 2x variation is to measure caching impact. | ||||
(lambda: resolvenodes(allnodes), | ||||
'look up all nodes (forward)'), | ||||
(lambda: resolvenodes(allnodes, 2), | ||||
'look up all nodes 2x (forward)'), | ||||
(lambda: resolvenodes(allnodesrev), | ||||
'look up all nodes (reverse)'), | ||||
(lambda: resolvenodes(allnodesrev, 2), | ||||
'look up all nodes 2x (reverse)'), | ||||
(lambda: getentries(allrevs), | ||||
'retrieve all index entries (forward)'), | ||||
(lambda: getentries(allrevs, 2), | ||||
'retrieve all index entries 2x (forward)'), | ||||
(lambda: getentries(allrevsrev), | ||||
'retrieve all index entries (reverse)'), | ||||
(lambda: getentries(allrevsrev, 2), | ||||
'retrieve all index entries 2x (reverse)'), | ||||
] | ||||
for fn, title in benches: | ||||
timer, fm = gettimer(ui, opts) | ||||
timer(fn, title=title) | ||||
fm.end() | ||||
|
r32531 | @command('perfrevlogrevisions', revlogopts + formatteropts + | ||
|
r27493 | [('d', 'dist', 100, 'distance between the revisions'), | ||
|
r30017 | ('s', 'startrev', 0, 'revision to start reading at'), | ||
('', 'reverse', False, 'read in reverse')], | ||||
|
r27492 | '-c|-m|FILE') | ||
|
r32531 | def perfrevlogrevisions(ui, repo, file_=None, startrev=0, reverse=False, | ||
**opts): | ||||
|
r27492 | """Benchmark reading a series of revisions from a revlog. | ||
By default, we read every ``-d/--dist`` revision from 0 to tip of | ||||
the specified revlog. | ||||
|
r27493 | |||
The start revision can be defined via ``-s/--startrev``. | ||||
|
r27492 | """ | ||
|
r32531 | rl = cmdutil.openrevlog(repo, 'perfrevlogrevisions', file_, opts) | ||
|
r32227 | rllen = getlen(ui)(rl) | ||
|
r30017 | |||
|
r11694 | def d(): | ||
|
r32227 | rl.clearcaches() | ||
|
r30017 | |||
|
r32219 | beginrev = startrev | ||
|
r32227 | endrev = rllen | ||
|
r30017 | dist = opts['dist'] | ||
if reverse: | ||||
|
r32219 | beginrev, endrev = endrev, beginrev | ||
|
r30017 | dist = -1 * dist | ||
|
r32219 | for x in xrange(beginrev, endrev, dist): | ||
|
r32297 | # Old revisions don't support passing int. | ||
n = rl.node(x) | ||||
rl.revision(n) | ||||
|
r11694 | |||
|
r32220 | timer, fm = gettimer(ui, opts) | ||
|
r11694 | timer(d) | ||
|
r23171 | fm.end() | ||
|
r11694 | |||
|
r30451 | @command('perfrevlogchunks', revlogopts + formatteropts + | ||
|
r30796 | [('e', 'engines', '', 'compression engines to use'), | ||
('s', 'startrev', 0, 'revision to start at')], | ||||
|
r30451 | '-c|-m|FILE') | ||
|
r30796 | def perfrevlogchunks(ui, repo, file_=None, engines=None, startrev=0, **opts): | ||
|
r30451 | """Benchmark operations on revlog chunks. | ||
Logically, each revlog is a collection of fulltext revisions. However, | ||||
stored within each revlog are "chunks" of possibly compressed data. This | ||||
data needs to be read and decompressed or compressed and written. | ||||
This command measures the time it takes to read+decompress and recompress | ||||
chunks in a revlog. It effectively isolates I/O and compression performance. | ||||
For measurements of higher-level operations like resolving revisions, | ||||
|
r32531 | see ``perfrevlogrevisions`` and ``perfrevlogrevision``. | ||
|
r30451 | """ | ||
rl = cmdutil.openrevlog(repo, 'perfrevlogchunks', file_, opts) | ||||
|
r32224 | |||
# _chunkraw was renamed to _getsegmentforrevs. | ||||
try: | ||||
segmentforrevs = rl._getsegmentforrevs | ||||
except AttributeError: | ||||
segmentforrevs = rl._chunkraw | ||||
|
r30796 | |||
# Verify engines argument. | ||||
if engines: | ||||
engines = set(e.strip() for e in engines.split(',')) | ||||
for engine in engines: | ||||
try: | ||||
util.compressionengines[engine] | ||||
except KeyError: | ||||
raise error.Abort('unknown compression engine: %s' % engine) | ||||
else: | ||||
engines = [] | ||||
for e in util.compengines: | ||||
engine = util.compengines[e] | ||||
try: | ||||
if engine.available(): | ||||
engine.revlogcompressor().compress('dummy') | ||||
engines.append(e) | ||||
except NotImplementedError: | ||||
pass | ||||
|
r30451 | revs = list(rl.revs(startrev, len(rl) - 1)) | ||
def rlfh(rl): | ||||
if rl._inline: | ||||
return getsvfs(repo)(rl.indexfile) | ||||
else: | ||||
return getsvfs(repo)(rl.datafile) | ||||
def doread(): | ||||
rl.clearcaches() | ||||
for rev in revs: | ||||
|
r32223 | segmentforrevs(rev, rev) | ||
|
r30451 | |||
def doreadcachedfh(): | ||||
rl.clearcaches() | ||||
fh = rlfh(rl) | ||||
for rev in revs: | ||||
|
r32223 | segmentforrevs(rev, rev, df=fh) | ||
|
r30451 | |||
def doreadbatch(): | ||||
rl.clearcaches() | ||||
|
r32223 | segmentforrevs(revs[0], revs[-1]) | ||
|
r30451 | |||
def doreadbatchcachedfh(): | ||||
rl.clearcaches() | ||||
fh = rlfh(rl) | ||||
|
r32223 | segmentforrevs(revs[0], revs[-1], df=fh) | ||
|
r30451 | |||
def dochunk(): | ||||
rl.clearcaches() | ||||
fh = rlfh(rl) | ||||
for rev in revs: | ||||
rl._chunk(rev, df=fh) | ||||
chunks = [None] | ||||
def dochunkbatch(): | ||||
rl.clearcaches() | ||||
fh = rlfh(rl) | ||||
# Save chunks as a side-effect. | ||||
chunks[0] = rl._chunks(revs, df=fh) | ||||
|
r30796 | def docompress(compressor): | ||
|
r30451 | rl.clearcaches() | ||
|
r30796 | |||
try: | ||||
# Swap in the requested compression engine. | ||||
oldcompressor = rl._compressor | ||||
rl._compressor = compressor | ||||
for chunk in chunks[0]: | ||||
rl.compress(chunk) | ||||
finally: | ||||
rl._compressor = oldcompressor | ||||
|
r30451 | |||
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'), | ||||
] | ||||
|
r30796 | for engine in sorted(engines): | ||
compressor = util.compengines[engine].revlogcompressor() | ||||
benches.append((functools.partial(docompress, compressor), | ||||
'compress w/ %s' % engine)) | ||||
|
r30451 | for fn, title in benches: | ||
timer, fm = gettimer(ui, opts) | ||||
timer(fn, title=title) | ||||
fm.end() | ||||
|
r27470 | @command('perfrevlogrevision', revlogopts + formatteropts + | ||
[('', 'cache', False, 'use caches instead of clearing')], | ||||
'-c|-m|FILE REV') | ||||
def perfrevlogrevision(ui, repo, file_, rev=None, cache=None, **opts): | ||||
"""Benchmark obtaining a revlog revision. | ||||
Obtaining a revlog revision consists of roughly the following steps: | ||||
1. Compute the delta chain | ||||
2. Obtain the raw chunks for that delta chain | ||||
3. Decompress each raw chunk | ||||
4. Apply binary patches to obtain fulltext | ||||
5. Verify hash of fulltext | ||||
This command measures the time spent in each of these phases. | ||||
""" | ||||
if opts.get('changelog') or opts.get('manifest'): | ||||
file_, rev = None, file_ | ||||
elif rev is None: | ||||
raise error.CommandError('perfrevlogrevision', 'invalid arguments') | ||||
r = cmdutil.openrevlog(repo, 'perfrevlogrevision', file_, opts) | ||||
|
r32224 | |||
# _chunkraw was renamed to _getsegmentforrevs. | ||||
try: | ||||
segmentforrevs = r._getsegmentforrevs | ||||
except AttributeError: | ||||
segmentforrevs = r._chunkraw | ||||
|
r27470 | node = r.lookup(rev) | ||
rev = r.rev(node) | ||||
|
r30882 | def getrawchunks(data, chain): | ||
start = r.start | ||||
length = r.length | ||||
inline = r._inline | ||||
iosize = r._io.size | ||||
buffer = util.buffer | ||||
offset = start(chain[0]) | ||||
chunks = [] | ||||
ladd = chunks.append | ||||
for rev in chain: | ||||
chunkstart = start(rev) | ||||
if inline: | ||||
chunkstart += (rev + 1) * iosize | ||||
chunklength = length(rev) | ||||
ladd(buffer(data, chunkstart - offset, chunklength)) | ||||
return chunks | ||||
|
r27470 | def dodeltachain(rev): | ||
if not cache: | ||||
r.clearcaches() | ||||
r._deltachain(rev) | ||||
def doread(chain): | ||||
if not cache: | ||||
r.clearcaches() | ||||
|
r32223 | segmentforrevs(chain[0], chain[-1]) | ||
|
r27470 | |||
|
r30882 | def dorawchunks(data, chain): | ||
|
r27470 | if not cache: | ||
r.clearcaches() | ||||
|
r30882 | getrawchunks(data, chain) | ||
|
r27470 | |||
|
r30882 | def dodecompress(chunks): | ||
decomp = r.decompress | ||||
for chunk in chunks: | ||||
decomp(chunk) | ||||
|
r27470 | |||
def dopatch(text, bins): | ||||
if not cache: | ||||
r.clearcaches() | ||||
mdiff.patches(text, bins) | ||||
def dohash(text): | ||||
if not cache: | ||||
r.clearcaches() | ||||
|
r30584 | r.checkhash(text, node, rev=rev) | ||
|
r27470 | |||
def dorevision(): | ||||
if not cache: | ||||
r.clearcaches() | ||||
r.revision(node) | ||||
chain = r._deltachain(rev)[0] | ||||
|
r32223 | data = segmentforrevs(chain[0], chain[-1])[1] | ||
|
r30882 | rawchunks = getrawchunks(data, chain) | ||
|
r27470 | bins = r._chunks(chain) | ||
text = str(bins[0]) | ||||
bins = bins[1:] | ||||
text = mdiff.patches(text, bins) | ||||
benches = [ | ||||
(lambda: dorevision(), 'full'), | ||||
(lambda: dodeltachain(rev), 'deltachain'), | ||||
(lambda: doread(chain), 'read'), | ||||
|
r30882 | (lambda: dorawchunks(data, chain), 'rawchunks'), | ||
(lambda: dodecompress(rawchunks), 'decompress'), | ||||
|
r27470 | (lambda: dopatch(text, bins), 'patch'), | ||
(lambda: dohash(text), 'hash'), | ||||
] | ||||
for fn, title in benches: | ||||
timer, fm = gettimer(ui, opts) | ||||
timer(fn, title=title) | ||||
fm.end() | ||||
|
r18239 | @command('perfrevset', | ||
|
r27072 | [('C', 'clear', False, 'clear volatile cache between each call.'), | ||
('', 'contexts', False, 'obtain changectx for each revision')] | ||||
|
r25494 | + formatteropts, "REVSET") | ||
|
r27072 | def perfrevset(ui, repo, expr, clear=False, contexts=False, **opts): | ||
|
r18239 | """benchmark the execution time of a revset | ||
|
r18644 | Use the --clean option if need to evaluate the impact of build volatile | ||
|
r18239 | revisions set cache on the revset execution. Volatile cache hold filtered | ||
and obsolete related cache.""" | ||||
|
r25494 | timer, fm = gettimer(ui, opts) | ||
|
r18062 | def d(): | ||
|
r18239 | if clear: | ||
repo.invalidatevolatilesets() | ||||
|
r27072 | if contexts: | ||
for ctx in repo.set(expr): pass | ||||
else: | ||||
for r in repo.revs(expr): pass | ||||
|
r18062 | timer(d) | ||
|
r23171 | fm.end() | ||
|
r18240 | |||
r32389 | @command('perfvolatilesets', | |||
[('', 'clear-obsstore', False, 'drop obsstore between each call.'), | ||||
] + formatteropts) | ||||
|
r25494 | def perfvolatilesets(ui, repo, *names, **opts): | ||
|
r18240 | """benchmark the computation of various volatile set | ||
Volatile set computes element related to filtering and obsolescence.""" | ||||
|
r25494 | timer, fm = gettimer(ui, opts) | ||
|
r18240 | repo = repo.unfiltered() | ||
def getobs(name): | ||||
def d(): | ||||
repo.invalidatevolatilesets() | ||||
r32389 | if opts['clear_obsstore']: | |||
r32731 | clearfilecache(repo, 'obsstore') | |||
|
r18240 | obsolete.getrevs(repo, name) | ||
return d | ||||
|
r18241 | allobs = sorted(obsolete.cachefuncs) | ||
if names: | ||||
allobs = [n for n in allobs if n in names] | ||||
for name in allobs: | ||||
|
r18240 | timer(getobs(name), title=name) | ||
def getfiltered(name): | ||||
def d(): | ||||
repo.invalidatevolatilesets() | ||||
r32389 | if opts['clear_obsstore']: | |||
r32731 | clearfilecache(repo, 'obsstore') | |||
|
r20205 | repoview.filterrevs(repo, name) | ||
|
r18240 | return d | ||
|
r18241 | allfilter = sorted(repoview.filtertable) | ||
if names: | ||||
allfilter = [n for n in allfilter if n in names] | ||||
for name in allfilter: | ||||
|
r18240 | timer(getfiltered(name), title=name) | ||
|
r23171 | fm.end() | ||
|
r18304 | |||
@command('perfbranchmap', | ||||
[('f', 'full', False, | ||||
'Includes build time of subset'), | ||||
r32710 | ('', 'clear-revbranch', False, | |||
'purge the revbranch cache between computation'), | ||||
|
r25494 | ] + formatteropts) | ||
|
r36380 | def perfbranchmap(ui, repo, *filternames, **opts): | ||
|
r18304 | """benchmark the update of a branchmap | ||
This benchmarks the full repo.branchmap() call with read and write disabled | ||||
""" | ||||
|
r36380 | full = opts.get("full", False) | ||
clear_revbranch = opts.get("clear_revbranch", False) | ||||
|
r25494 | timer, fm = gettimer(ui, opts) | ||
|
r18304 | def getbranchmap(filtername): | ||
"""generate a benchmark function for the filtername""" | ||||
if filtername is None: | ||||
view = repo | ||||
else: | ||||
view = repo.filtered(filtername) | ||||
def d(): | ||||
r32710 | if clear_revbranch: | |||
repo.revbranchcache()._clear() | ||||
|
r18304 | if full: | ||
view._branchcaches.clear() | ||||
else: | ||||
view._branchcaches.pop(filtername, None) | ||||
view.branchmap() | ||||
return d | ||||
# add filter in smaller subset to bigger subset | ||||
possiblefilters = set(repoview.filtertable) | ||||
|
r36380 | if filternames: | ||
possiblefilters &= set(filternames) | ||||
|
r30144 | subsettable = getbranchmapsubsettable() | ||
|
r18304 | allfilters = [] | ||
while possiblefilters: | ||||
for name in possiblefilters: | ||||
|
r30144 | subset = subsettable.get(name) | ||
|
r18304 | if subset not in possiblefilters: | ||
break | ||||
else: | ||||
assert False, 'subset cycle %s!' % possiblefilters | ||||
allfilters.append(name) | ||||
possiblefilters.remove(name) | ||||
# warm the cache | ||||
if not full: | ||||
for name in allfilters: | ||||
repo.filtered(name).branchmap() | ||||
|
r36380 | if not filternames or 'unfiltered' in filternames: | ||
# add unfiltered | ||||
allfilters.append(None) | ||||
|
r30145 | |||
branchcacheread = safeattrsetter(branchmap, 'read') | ||||
branchcachewrite = safeattrsetter(branchmap.branchcache, 'write') | ||||
branchcacheread.set(lambda repo: None) | ||||
branchcachewrite.set(lambda bc, repo: None) | ||||
|
r18304 | try: | ||
for name in allfilters: | ||||
|
r36379 | printname = name | ||
if name is None: | ||||
printname = 'unfiltered' | ||||
timer(getbranchmap(name), title=str(printname)) | ||||
|
r18304 | finally: | ||
|
r30145 | branchcacheread.restore() | ||
branchcachewrite.restore() | ||||
|
r23171 | fm.end() | ||
|
r23485 | |||
@command('perfloadmarkers') | ||||
def perfloadmarkers(ui, repo): | ||||
"""benchmark the time to parse the on-disk markers for a repo | ||||
Result is the number of markers in the repo.""" | ||||
timer, fm = gettimer(ui) | ||||
|
r30146 | svfs = getsvfs(repo) | ||
timer(lambda: len(obsolete.obsstore(svfs))) | ||||
|
r23485 | fm.end() | ||
|
r27286 | |||
@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')], | ||||
norepo=True) | ||||
def perflrucache(ui, size=4, gets=10000, sets=10000, mixed=10000, | ||||
mixedgetfreq=50, **opts): | ||||
def doinit(): | ||||
for i in xrange(10000): | ||||
util.lrucachedict(size) | ||||
values = [] | ||||
for i in xrange(size): | ||||
values.append(random.randint(0, sys.maxint)) | ||||
# Get mode fills the cache and tests raw lookup performance with no | ||||
# eviction. | ||||
getseq = [] | ||||
for i in xrange(gets): | ||||
getseq.append(random.choice(values)) | ||||
def dogets(): | ||||
d = util.lrucachedict(size) | ||||
for v in values: | ||||
d[v] = v | ||||
for key in getseq: | ||||
value = d[key] | ||||
value # silence pyflakes warning | ||||
# Set mode tests insertion speed with cache eviction. | ||||
setseq = [] | ||||
for i in xrange(sets): | ||||
setseq.append(random.randint(0, sys.maxint)) | ||||
def dosets(): | ||||
d = util.lrucachedict(size) | ||||
for v in setseq: | ||||
d[v] = v | ||||
# Mixed mode randomly performs gets and sets with eviction. | ||||
mixedops = [] | ||||
for i in xrange(mixed): | ||||
r = random.randint(0, 100) | ||||
if r < mixedgetfreq: | ||||
op = 0 | ||||
else: | ||||
op = 1 | ||||
mixedops.append((op, random.randint(0, size * 2))) | ||||
def domixed(): | ||||
d = util.lrucachedict(size) | ||||
for op, v in mixedops: | ||||
if op == 0: | ||||
try: | ||||
d[v] | ||||
except KeyError: | ||||
pass | ||||
else: | ||||
d[v] = v | ||||
benches = [ | ||||
(doinit, 'init'), | ||||
(dogets, 'gets'), | ||||
(dosets, 'sets'), | ||||
(domixed, 'mixed') | ||||
] | ||||
for fn, title in benches: | ||||
timer, fm = gettimer(ui, opts) | ||||
timer(fn, title=title) | ||||
fm.end() | ||||
|
r29495 | |||
|
r30977 | @command('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')) | ||||
timer(write) | ||||
fm.end() | ||||
|
r29495 | def uisetup(ui): | ||
if (util.safehasattr(cmdutil, 'openrevlog') and | ||||
not util.safehasattr(commands, '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") | ||||
return orig(repo, cmd, file_, opts) | ||||
extensions.wrapfunction(cmdutil, 'openrevlog', openrevlog) | ||||