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

from mercurial import mdiff

import time, os, sys

import random

import functools

formatteropts = commands.formatteropts

revlogopts = commands.debugrevlogopts

cmdtable = {}

command = cmdutil.command(cmdtable)

def getlen(ui):

    if ui.configbool("perf", "stub"):

        return lambda x: 1

    return len

def gettimer(ui, opts=None):

    """return a timer function and formatter: (timer, formatter)

    This function exists to gather the creation of formatter in a single

    place instead of duplicating it in all performance commands."""

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

    # stub function, runs code only once instead of in a loop

    # experimental config: perf.stub

    if ui.configbool("perf", "stub"):

        return functools.partial(stub_timer, fm), fm

    return functools.partial(_timer, fm), fm

def stub_timer(fm, func, title=None):

    func()

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,

                               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.clearcaches()

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

        if os.name != 'nt':

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

        else:

            os.environ['HGRCPATH'] = ''

            os.system("%s version -q > NUL" % cmd)

    timer(d)

    fm.end()

@command('perfparents', formatteropts)

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

    timer, fm = gettimer(ui, opts)

    # control the number of commits perfparents iterates over

    # experimental config: perf.parentscount

    count = ui.configint("perf", "parentscount", 1000)

    if len(repo.changelog) < count:

        raise error.Abort("repo needs %d commits for this test" % count)

    repo = repo.unfiltered()

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

    def d():

        for n in nl:

            repo.changelog.parents(n)

    timer(d)

    fm.end()

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