perf.py
578 lines
| 16.5 KiB
| text/x-python
|
PythonLexer
/ contrib / perf.py
|
r7366 | # perf.py - performance test routines | ||
|
r8873 | '''helper extension to measure performance''' | ||
|
r7366 | |||
|
r19322 | from mercurial import cmdutil, scmutil, util, commands, obsolete | ||
|
r18877 | from mercurial import repoview, branchmap, merge, copies | ||
|
r7366 | import time, os, sys | ||
|
r23171 | import functools | ||
|
r7366 | |||
|
r25494 | formatteropts = commands.formatteropts | ||
|
r18237 | cmdtable = {} | ||
command = cmdutil.command(cmdtable) | ||||
|
r23171 | def gettimer(ui, opts=None): | ||
"""return a timer function and formatter: (timer, formatter) | ||||
This functions exist to gather the creation of formatter in a single | ||||
place instead of duplicating it in all performance command.""" | ||||
|
r23788 | |||
# enforce an idle period before execution to counteract power management | ||||
|
r25850 | # experimental config: perf.presleep | ||
|
r23788 | time.sleep(ui.configint("perf", "presleep", 1)) | ||
|
r23171 | if opts is None: | ||
opts = {} | ||||
# redirect all to stderr | ||||
ui = ui.copy() | ||||
ui.fout = ui.ferr | ||||
# get a formatter | ||||
fm = ui.formatter('perf', opts) | ||||
return functools.partial(_timer, fm), fm | ||||
def _timer(fm, func, title=None): | ||||
|
r7366 | results = [] | ||
begin = time.time() | ||||
count = 0 | ||||
|
r14494 | while True: | ||
|
r7366 | ostart = os.times() | ||
cstart = time.time() | ||||
r = func() | ||||
cstop = time.time() | ||||
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 | |||
|
r25494 | @command('perfwalk', formatteropts) | ||
def perfwalk(ui, repo, *pats, **opts): | ||||
timer, fm = gettimer(ui, opts) | ||||
|
r7366 | try: | ||
|
r14671 | m = scmutil.match(repo[None], pats, {}) | ||
|
r10176 | timer(lambda: len(list(repo.dirstate.walk(m, [], True, False)))) | ||
|
r16689 | except Exception: | ||
|
r7366 | try: | ||
|
r14671 | m = scmutil.match(repo[None], pats, {}) | ||
|
r10282 | timer(lambda: len([b for a, b, c in repo.dirstate.statwalk([], m)])) | ||
|
r16689 | except Exception: | ||
|
r7366 | timer(lambda: len(list(cmdutil.walk(repo, pats, {})))) | ||
|
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)))) | ||||
|
r25494 | timer, fm = gettimer(ui, **opts) | ||
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]) | ||
|
r23537 | timer(lambda: scmutil.addremove(repo, matcher, "", dry_run=True)) | ||
|
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) | ||
|
r7366 | def t(): | ||
|
r23878 | repo.changelog = mercurial.changelog.changelog(repo.svfs) | ||
repo.manifest = mercurial.manifest.manifest(repo.svfs) | ||||
|
r9146 | repo._tags = None | ||
|
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 | |||
|
r25494 | @command('perfdirs', formatteropts) | ||
def perfdirs(ui, repo, **opts): | ||||
timer, fm = gettimer(ui, opts) | ||||
|
r18845 | dirstate = repo.dirstate | ||
'a' in dirstate | ||||
def d(): | ||||
dirstate.dirs() | ||||
del dirstate._dirs | ||||
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(): | ||||
"a" in repo.dirstate._dirs | ||||
del repo.dirstate._dirs | ||||
timer(d) | ||||
|
r23171 | fm.end() | ||
|
r7366 | |||
|
r25494 | @command('perfdirstatefoldmap', formatteropts) | ||
def perffilefoldmap(ui, repo, **opts): | ||||
timer, fm = gettimer(ui, opts) | ||||
|
r22780 | dirstate = repo.dirstate | ||
'a' in dirstate | ||||
def d(): | ||||
|
r24607 | dirstate._filefoldmap.get('a') | ||
del dirstate._filefoldmap | ||||
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(): | ||||
dirstate._dirfoldmap.get('a') | ||||
del dirstate._dirfoldmap | ||||
|
r22780 | del dirstate._dirs | ||
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 | ||||
merge.calculateupdates(repo, wctx, rctx, ancestor, False, False, False, | ||||
acceptremote=True) | ||||
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 | |||
|
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(): | ||
|
r19711 | repo.manifest._mancache.clear() | ||
repo.manifest._cache = None | ||||
|
r19378 | repo.manifest.read(t) | ||
|
r7366 | timer(d) | ||
|
r23171 | fm.end() | ||
|
r7366 | |||
|
r25494 | @command('perfchangeset', formatteropts) | ||
def perfchangeset(ui, repo, rev, **opts): | ||||
timer, fm = gettimer(ui, opts) | ||||
|
r16262 | n = repo[rev].node() | ||
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() | ||
|
r7366 | def d(): | ||
|
r23878 | cl = mercurial.revlog.revlog(repo.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(): | ||||
os.system("HGRCPATH= %s version -q > /dev/null" % cmd) | ||||
timer(d) | ||||
|
r23171 | fm.end() | ||
|
r7366 | |||
|
r25494 | @command('perfparents', formatteropts) | ||
def perfparents(ui, repo, **opts): | ||||
timer, fm = gettimer(ui, opts) | ||||
|
r7366 | nl = [repo.changelog.node(i) for i in xrange(1000)] | ||
def d(): | ||||
for n in nl: | ||||
repo.changelog.parents(n) | ||||
timer(d) | ||||
|
r23171 | fm.end() | ||
|
r7366 | |||
|
r25494 | @command('perfctxfiles', formatteropts) | ||
def perfparents(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) | ||
def perfparents(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) | ||||
@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 | ||||
n = repo[rev].node() | ||||
|
r23878 | cl = mercurial.revlog.revlog(repo.svfs, "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) | ||
|
r9932 | def perflog(ui, repo, **opts): | ||
|
r25494 | timer, fm = gettimer(ui, opts) | ||
|
r7872 | ui.pushbuffer() | ||
|
r9932 | timer(lambda: commands.log(ui, repo, rev=[], date='', user='', | ||
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 | |||
|
r25494 | @command('perftemplating', formatteropts) | ||
def perftemplating(ui, repo, **opts): | ||||
timer, fm = gettimer(ui, opts) | ||||
|
r7872 | ui.pushbuffer() | ||
timer(lambda: commands.log(ui, repo, rev=[], date='', user='', | ||||
template='{date|shortdate} [{rev}:{node|short}]' | ||||
' {author|person}: {desc|firstline}\n')) | ||||
ui.popbuffer() | ||||
|
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() | ||
def d(): | ||||
s.fncache._dirty = True | ||||
s.fncache.write() | ||||
timer(d) | ||||
|
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 | |||
|
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 | |||
|
r18237 | @command('perfrevlog', | ||
|
r25494 | [('d', 'dist', 100, 'distance between the revisions')] + formatteropts, | ||
|
r18237 | "[INDEXFILE]") | ||
|
r11694 | def perfrevlog(ui, repo, file_, **opts): | ||
|
r25494 | timer, fm = gettimer(ui, opts) | ||
|
r11694 | from mercurial import revlog | ||
dist = opts['dist'] | ||||
def d(): | ||||
r = revlog.revlog(lambda fn: open(fn, 'rb'), file_) | ||||
for x in xrange(0, len(r), dist): | ||||
r.revision(r.node(x)) | ||||
timer(d) | ||||
|
r23171 | fm.end() | ||
|
r11694 | |||
|
r18239 | @command('perfrevset', | ||
|
r25494 | [('C', 'clear', False, 'clear volatile cache between each call.')] | ||
+ formatteropts, "REVSET") | ||||
def perfrevset(ui, repo, expr, clear=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() | ||||
|
r20846 | for r in repo.revs(expr): pass | ||
|
r18062 | timer(d) | ||
|
r23171 | fm.end() | ||
|
r18240 | |||
|
r25494 | @command('perfvolatilesets', formatteropts) | ||
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() | ||||
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() | ||||
|
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'), | ||||
|
r25494 | ] + formatteropts) | ||
def perfbranchmap(ui, repo, full=False, **opts): | ||||
|
r18304 | """benchmark the update of a branchmap | ||
This benchmarks the full repo.branchmap() call with read and write disabled | ||||
""" | ||||
|
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(): | ||||
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) | ||||
allfilters = [] | ||||
while possiblefilters: | ||||
for name in possiblefilters: | ||||
|
r20032 | subset = branchmap.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() | ||||
# add unfiltered | ||||
allfilters.append(None) | ||||
oldread = branchmap.read | ||||
oldwrite = branchmap.branchcache.write | ||||
try: | ||||
branchmap.read = lambda repo: None | ||||
branchmap.write = lambda repo: None | ||||
for name in allfilters: | ||||
timer(getbranchmap(name), title=str(name)) | ||||
finally: | ||||
branchmap.read = oldread | ||||
branchmap.branchcache.write = oldwrite | ||||
|
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) | ||||
|
r23878 | timer(lambda: len(obsolete.obsstore(repo.svfs))) | ||
|
r23485 | fm.end() | ||