# perf.py - performance test routines

'''helper extension to measure performance'''

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

from __future__ import absolute_import

import functools

import os

import random

import sys

import time

from mercurial import (

    branchmap,

    cmdutil,

    commands,

    copies,

    error,

    extensions,

    mdiff,

    merge,

    obsolete,

    repoview,

    revlog,

    scmutil,

    util,

)

# for "historical portability":

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

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

revlogopts = getattr(commands, "debugrevlogopts", [

        ('c', 'changelog', False, ('open changelog')),

        ('m', 'manifest', False, ('open manifest')),

        ('', 'dir', False, ('open directory manifest')),

        ])

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)