# perf.py - performance test routines

'''helper extension to measure performance'''

from mercurial import cmdutil, scmutil, util, commands, obsolete

from mercurial import repoview, branchmap, merge, copies

import time, os, sys

import functools

formatteropts = commands.formatteropts

cmdtable = {}

command = cmdutil.command(cmdtable)

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."""

    # enforce an idle period before execution to counteract power management

    # experimental config: perf.presleep

    time.sleep(ui.configint("perf", "presleep", 1))

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

    results = []

    begin = time.time()

    count = 0

    while True:

        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

    fm.startitem()

    if title:

        fm.write('title', '! %s\n', title)

    if r:

        fm.write('result', '! result: %s\n', r)

    m = min(results)

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

@command('perfwalk', formatteropts)

def perfwalk(ui, repo, *pats, **opts):

    timer, fm = gettimer(ui, opts)

    try:

        m = scmutil.match(repo[None], pats, {})

        timer(lambda: len(list(repo.dirstate.walk(m, [], True, False))))

    except Exception:

        try:

            m = scmutil.match(repo[None], pats, {})

            timer(lambda: len([b for a, b, c in repo.dirstate.statwalk([], m)]))

        except Exception:

            timer(lambda: len(list(cmdutil.walk(repo, pats, {}))))

    fm.end()

@command('perfannotate', formatteropts)

def perfannotate(ui, repo, f, **opts):

    timer, fm = gettimer(ui, opts)

    fc = repo['.'][f]

    timer(lambda: len(fc.annotate(True)))

    fm.end()

@command('perfstatus',

         [('u', 'unknown', False,

           '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']))))

    fm.end()

@command('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])

        timer(lambda: scmutil.addremove(repo, matcher, "", dry_run=True))

    finally:

        repo.ui.quiet = oldquiet

        fm.end()

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

@command('perfheads', formatteropts)

def perfheads(ui, repo, **opts):

    timer, fm = gettimer(ui, opts)

    cl = repo.changelog

    def d():

        len(cl.headrevs())

        clearcaches(cl)

    timer(d)

    fm.end()

@command('perftags', formatteropts)

def perftags(ui, repo, **opts):

    import mercurial.changelog

    import mercurial.manifest

    timer, fm = gettimer(ui, opts)

    def t():

        repo.changelog = mercurial.changelog.changelog(repo.svfs)

        repo.manifest = mercurial.manifest.manifest(repo.svfs)

        repo._tags = None

        return len(repo.tags())

    timer(t)

    fm.end()

@command('perfancestors', formatteropts)

def perfancestors(ui, repo, **opts):

    timer, fm = gettimer(ui, opts)

    heads = repo.changelog.headrevs()

    def d():

        for a in repo.changelog.ancestors(heads):

            pass

    timer(d)

    fm.end()

@command('perfancestorset', formatteropts)

def perfancestorset(ui, repo, revset, **opts):

    timer, fm = gettimer(ui, opts)

    revs = repo.revs(revset)

    heads = repo.changelog.headrevs()

    def d():

        s = repo.changelog.ancestors(heads)

        for rev in revs:

            rev in s

    timer(d)

    fm.end()

@command('perfdirs', formatteropts)

def perfdirs(ui, repo, **opts):

    timer, fm = gettimer(ui, opts)

    dirstate = repo.dirstate

    'a' in dirstate

    def d():

        dirstate.dirs()

        del dirstate._dirs

    timer(d)

    fm.end()

@command('perfdirstate', formatteropts)

def perfdirstate(ui, repo, **opts):

    timer, fm = gettimer(ui, opts)

    "a" in repo.dirstate

    def d():

        repo.dirstate.invalidate()

        "a" in repo.dirstate

    timer(d)

    fm.end()

@command('perfdirstatedirs', formatteropts)

def perfdirstatedirs(ui, repo, **opts):

    timer, fm = gettimer(ui, opts)

    "a" in repo.dirstate

    def d():

        "a" in repo.dirstate._dirs

        del repo.dirstate._dirs

    timer(d)

    fm.end()

@command('perfdirstatefoldmap', formatteropts)

def perffilefoldmap(ui, repo, **opts):

    timer, fm = gettimer(ui, opts)

    dirstate = repo.dirstate

    'a' in dirstate

    def d():

        dirstate._filefoldmap.get('a')

        del dirstate._filefoldmap

    timer(d)

    fm.end()

@command('perfdirfoldmap', formatteropts)

def perfdirfoldmap(ui, repo, **opts):

    timer, fm = gettimer(ui, opts)

    dirstate = repo.dirstate

    'a' in dirstate

    def d():

        dirstate._dirfoldmap.get('a')

        del dirstate._dirfoldmap

        del dirstate._dirs

    timer(d)

    fm.end()

@command('perfdirstatewrite', formatteropts)

def perfdirstatewrite(ui, repo, **opts):

    timer, fm = gettimer(ui, opts)

    ds = repo.dirstate

    "a" in ds

    def d():

        ds._dirty = True

        ds.write(repo.currenttransaction())

    timer(d)

    fm.end()

@command('perfmergecalculate',

         [('r', 'rev', '.', 'rev to merge against')] + formatteropts)

def perfmergecalculate(ui, repo, rev, **opts):

    timer, fm = gettimer(ui, opts)

    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)

    fm.end()

@command('perfpathcopies', [], "REV REV")

def perfpathcopies(ui, repo, rev1, rev2, **opts):

    timer, fm = gettimer(ui, opts)

    ctx1 = scmutil.revsingle(repo, rev1, rev1)

    ctx2 = scmutil.revsingle(repo, rev2, rev2)

    def d():

        copies.pathcopies(ctx1, ctx2)

    timer(d)

    fm.end()

@command('perfmanifest', [], 'REV')

def perfmanifest(ui, repo, rev, **opts):

    timer, fm = gettimer(ui, opts)

    ctx = scmutil.revsingle(repo, rev, rev)

    t = ctx.manifestnode()

    def d():

        repo.manifest._mancache.clear()

        repo.manifest._cache = None

        repo.manifest.read(t)

    timer(d)

    fm.end()

@command('perfchangeset', formatteropts)

def perfchangeset(ui, repo, rev, **opts):

    timer, fm = gettimer(ui, opts)

    n = repo[rev].node()

    def d():

        repo.changelog.read(n)

        #repo.changelog._cache = None

    timer(d)

    fm.end()

@command('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()

    def d():

        cl = mercurial.revlog.revlog(repo.svfs, "00changelog.i")

        cl.rev(n)

    timer(d)

    fm.end()

@command('perfstartup', formatteropts)

def perfstartup(ui, repo, **opts):

    timer, fm = gettimer(ui, opts)

    cmd = sys.argv[0]

    def d():

        os.system("HGRCPATH= %s version -q > /dev/null" % cmd)

    timer(d)

    fm.end()

@command('perfparents', formatteropts)

def perfparents(ui, repo, **opts):

    timer, fm = gettimer(ui, opts)

    nl = [repo.changelog.node(i) for i in xrange(1000)]

    def d():

        for n in nl:

            repo.changelog.parents(n)

    timer(d)

    fm.end()

@command('perfctxfiles', formatteropts)

def perfparents(ui, repo, x, **opts):

    x = int(x)

    timer, fm = gettimer(ui, opts)

    def d():

        len(repo[x].files())

    timer(d)

    fm.end()

@command('perfrawfiles', formatteropts)

def perfparents(ui, repo, x, **opts):

    x = int(x)

    timer, fm = gettimer(ui, opts)

    cl = repo.changelog

    def d():

        len(cl.read(x)[3])

    timer(d)

    fm.end()

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

    timer(lambda: len(repo.lookup(rev)))

    fm.end()

@command('perfrevrange', formatteropts)

def perfrevrange(ui, repo, *specs, **opts):

    timer, fm = gettimer(ui, opts)

    revrange = scmutil.revrange

    timer(lambda: len(revrange(repo, specs)))

    fm.end()

@command('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 = repo[rev].node()

    cl = mercurial.revlog.revlog(repo.svfs, "00changelog.i")

    def d():

        cl.rev(n)