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

import os

import random

import struct

import sys

import time

from mercurial import (

    changegroup,

    cmdutil,

    commands,

    copies,

    error,

    extensions,

    mdiff,

    merge,

    revlog,

    util,

)

# for "historical portability":

# try to import modules separately (in dict order), and ignore

# failure, because these aren't available with early Mercurial

try:

    from mercurial import branchmap # since 2.5 (or bcee63733aad)

except ImportError:

    pass

try:

    from mercurial import obsolete # since 2.3 (or ad0d6c2b3279)

except ImportError:

    pass

try:

    from mercurial import registrar # since 3.7 (or 37d50250b696)

    dir(registrar) # forcibly load it

except ImportError:

    registrar = None

try:

    from mercurial import repoview # since 2.5 (or 3a6ddacb7198)

except ImportError:

    pass

try:

    from mercurial import scmutil # since 1.9 (or 8b252e826c68)

except ImportError:

    pass

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

# define util.timer forcibly, because util.timer has been available

# since ae5d60bb70c9

if safehasattr(time, 'perf_counter'):

    util.timer = time.perf_counter

elif os.name == 'nt':

    util.timer = time.clock

else:

    util.timer = time.time

# for "historical portability":

# use locally defined empty option list, if formatteropts isn't

# available, because commands.formatteropts has been available since

# 3.2 (or 7a7eed5176a4), even though formatting itself has been

# available since 2.2 (or ae5f92e154d3)

formatteropts = getattr(cmdutil, "formatteropts",

                        getattr(commands, "formatteropts", []))

# 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(cmdutil, "debugrevlogopts",

                     getattr(commands, "debugrevlogopts", [

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

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

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

        ]))

cmdtable = {}

# for "historical portability":

# define parsealiases locally, because cmdutil.parsealiases has been

# available since 1.5 (or 6252852b4332)

def parsealiases(cmd):

    return cmd.lstrip("^").split("|")

if safehasattr(registrar, 'command'):

    command = registrar.command(cmdtable)

elif safehasattr(cmdutil, 'command'):

    import inspect

    command = cmdutil.command(cmdtable)

    if 'norepo' not in inspect.getargspec(command)[0]:

        # for "historical portability":

        # wrap original cmdutil.command, because "norepo" option has

        # been available since 3.1 (or 75a96326cecb)

        _command = command

        def command(name, options=(), synopsis=None, norepo=False):

            if norepo:

                commands.norepo += ' %s' % ' '.join(parsealiases(name))

            return _command(name, list(options), synopsis)

else:

    # for "historical portability":

    # define "@command" annotation locally, because cmdutil.command

    # has been available since 1.9 (or 2daa5179e73f)

    def command(name, options=(), synopsis=None, norepo=False):

        def decorator(func):

            if synopsis:

                cmdtable[name] = func, list(options), synopsis

            else:

                cmdtable[name] = func, list(options)

            if norepo:

                commands.norepo += ' %s' % ' '.join(parsealiases(name))

            return func

        return decorator

try:

    configtable = {}

    configitem('perf', 'stub',

    )

except (ImportError, AttributeError):

    pass

def getlen(ui):

        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(getint(ui, "perf", "presleep", 1))

    if opts is None:

        opts = {}

    # redirect all to stderr unless buffer api is in use

    if not ui._buffers:

        ui = ui.copy()

        uifout = safeattrsetter(ui, 'fout', ignoremissing=True)

        if uifout:

            # for "historical portability":

            # ui.fout/ferr have been available since 1.9 (or 4e1ccd4c2b6d)

            uifout.set(ui.ferr)

    # get a formatter

    uiformatter = getattr(ui, 'formatter', None)

    if uiformatter:

        fm = uiformatter('perf', opts)

    else:

        # for "historical portability":

        # define formatter locally, because ui.formatter has been

        # available since 2.2 (or ae5f92e154d3)

        from mercurial import node

        class defaultformatter(object):

            """Minimized composition of baseformatter and plainformatter

            """

            def __init__(self, ui, topic, opts):

                self._ui = ui

                if ui.debugflag:

                    self.hexfunc = node.hex

                else:

                    self.hexfunc = node.short

            def __nonzero__(self):

                return False

            __bool__ = __nonzero__

            def startitem(self):

                pass

            def data(self, **data):

                pass

            def write(self, fields, deftext, *fielddata, **opts):

                self._ui.write(deftext % fielddata, **opts)

            def condwrite(self, cond, fields, deftext, *fielddata, **opts):

                if cond:

                    self._ui.write(deftext % fielddata, **opts)

            def plain(self, text, **opts):

                self._ui.write(text, **opts)

            def end(self):

                pass

        fm = defaultformatter(ui, 'perf', opts)

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

    # experimental config: 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):

    gc.collect()

    results = []

    begin = util.timer()

    count = 0

    while True:

        ostart = os.times()

        cstart = util.timer()

        r = func()

        cstop = util.timer()

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

# utilities for historical portability

def getint(ui, section, name, default):

    # for "historical portability":

    # ui.configint has been available since 1.9 (or fa2b596db182)

    v = ui.config(section, name, None)

    if v is None:

        return default

    try:

        return int(v)

    except ValueError:

        raise error.ConfigError(("%s.%s is not an integer ('%s')")

                                % (section, name, v))

def safeattrsetter(obj, name, ignoremissing=False):

    """Ensure that 'obj' has 'name' attribute before subsequent setattr

    This function is aborted, if 'obj' doesn't have 'name' attribute

    at runtime. This avoids overlooking removal of an attribute, which

    breaks assumption of performance measurement, in the future.

    This function returns the object to (1) assign a new value, and

    (2) restore an original value to the attribute.

    If 'ignoremissing' is true, missing 'name' attribute doesn't cause

    abortion, and this function returns None. This is useful to

    examine an attribute, which isn't ensured in all Mercurial

    versions.

    """

    if not util.safehasattr(obj, name):

        if ignoremissing:

            return None

        raise error.Abort(("missing attribute %s of %s might break assumption"

                           " of performance measurement") % (name, obj))

    origvalue = getattr(obj, name)

    class attrutil(object):

        def set(self, newvalue):

            setattr(obj, name, newvalue)

        def restore(self):

            setattr(obj, name, origvalue)

    return attrutil()

# utilities to examine each internal API changes

def getbranchmapsubsettable():

    # for "historical portability":

    # subsettable is defined in:

    # - branchmap since 2.9 (or 175c6fd8cacc)

    # - repoview since 2.5 (or 59a9f18d4587)

    for mod in (branchmap, repoview):

        subsettable = getattr(mod, 'subsettable', None)

        if subsettable:

            return subsettable

    # bisecting in bcee63733aad::59a9f18d4587 can reach here (both

    # branchmap and repoview modules exist, but subsettable attribute

    # doesn't)

    raise error.Abort(("perfbranchmap not available with this Mercurial"),

                      hint="use 2.5 or later")

def getsvfs(repo):

    """Return appropriate object to access files under .hg/store

    """

    # for "historical portability":

    # repo.svfs has been available since 2.3 (or 7034365089bf)

    svfs = getattr(repo, 'svfs', None)

    if svfs:

        return svfs

    else:

        return getattr(repo, 'sopener')

def getvfs(repo):

    """Return appropriate object to access files under .hg

    """

    # for "historical portability":

    # repo.vfs has been available since 2.3 (or 7034365089bf)

    vfs = getattr(repo, 'vfs', None)

    if vfs:

        return vfs

    else:

        return getattr(repo, 'opener')

def repocleartagscachefunc(repo):

    """Return the function to clear tags cache according to repo internal API

    """

    if util.safehasattr(repo, '_tagscache'): # since 2.0 (or 9dca7653b525)

        # in this case, setattr(repo, '_tagscache', None) or so isn't

        # correct way to clear tags cache, because existing code paths

        # expect _tagscache to be a structured object.

        def clearcache():

            # _tagscache has been filteredpropertycache since 2.5 (or

            # 98c867ac1330), and delattr() can't work in such case

            if '_tagscache' in vars(repo):

                del repo.__dict__['_tagscache']

        return clearcache

    repotags = safeattrsetter(repo, '_tags', ignoremissing=True)

    if repotags: # since 1.4 (or 5614a628d173)

        return lambda : repotags.set(None)

    repotagscache = safeattrsetter(repo, 'tagscache', ignoremissing=True)

    if repotagscache: # since 0.6 (or d7df759d0e97)

        return lambda : repotagscache.set(None)

    # Mercurial earlier than 0.6 (or d7df759d0e97) logically reaches

    # this point, but it isn't so problematic, because:

    # - repo.tags of such Mercurial isn't "callable", and repo.tags()

    #   in perftags() causes failure soon

    # - perf.py itself has been available since 1.1 (or eb240755386d)

    raise error.Abort(("tags API of this hg command is unknown"))

# utilities to clear cache

def clearfilecache(repo, attrname):

    unfi = repo.unfiltered()

    if attrname in vars(unfi):

        delattr(unfi, attrname)

    unfi._filecache.pop(attrname, None)

# perf commands

@command('perfwalk', formatteropts)

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

    timer, fm = gettimer(ui, opts)

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

    timer(lambda: len(list(repo.dirstate.walk(m, subrepos=[], unknown=True,

                                              ignored=False))))

    fm.end()