# 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, error

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 perfdirstatefoldmap(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, followcopies=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)

    if len(repo.changelog) < 1000:

        raise error.Abort("repo needs 1000 commits for this test")

    repo = repo.unfiltered()

    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 perfctxfiles(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 perfrawfiles(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)

    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)