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

import functools

import gc

import os

import random

import shutil

import struct

import sys

import tempfile

import threading

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

def identity(a):

    return a

try:

    from mercurial import pycompat

    getargspec = pycompat.getargspec  # added to module after 4.5

    _byteskwargs = pycompat.byteskwargs  # since 4.1 (or fbc3f73dc802)

    _sysstr = pycompat.sysstr         # since 4.0 (or 2219f4f82ede)

    _xrange = pycompat.xrange         # since 4.8 (or 7eba8f83129b)

    fsencode = pycompat.fsencode      # since 3.9 (or f4a5e0e86a7e)

    if pycompat.ispy3:

        _maxint = sys.maxsize  # per py3 docs for replacing maxint

    else:

        _maxint = sys.maxint

except (ImportError, AttributeError):

    import inspect

    getargspec = inspect.getargspec

    _byteskwargs = identity

    fsencode = identity               # no py3 support

    _maxint = sys.maxint              # no py3 support

    _sysstr = lambda x: x             # no py3 support

    _xrange = xrange

try:

    # 4.7+

    queue = pycompat.queue.Queue

except (AttributeError, ImportError):

    # <4.7.

    try:

        queue = pycompat.queue

    except (AttributeError, ImportError):

        queue = util.queue

try:

    from mercurial import logcmdutil

    makelogtemplater = logcmdutil.maketemplater

except (AttributeError, ImportError):

    try:

        makelogtemplater = cmdutil.makelogtemplater

    except (AttributeError, ImportError):

        makelogtemplater = None

# 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, _sysstr(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 == b'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", [

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

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

        (b'', b'dir', False, (b'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.split(b"|")

if safehasattr(registrar, 'command'):

    command = registrar.command(cmdtable)

elif safehasattr(cmdutil, 'command'):

    command = cmdutil.command(cmdtable)

    if b'norepo' not in getargspec(command).args:

        # 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 += b' %s' % b' '.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 += b' %s' % b' '.join(parsealiases(name))

            return func

        return decorator

try:

    import mercurial.registrar

    import mercurial.configitems

    configtable = {}

    configitem = mercurial.registrar.configitem(configtable)

    configitem(b'perf', b'presleep',

        default=mercurial.configitems.dynamicdefault,

    )

    configitem(b'perf', b'stub',

        default=mercurial.configitems.dynamicdefault,

    )

    configitem(b'perf', b'parentscount',

        default=mercurial.configitems.dynamicdefault,

    )

    configitem(b'perf', b'all-timing',

        default=mercurial.configitems.dynamicdefault,

    )

except (ImportError, AttributeError):

    pass

def getlen(ui):

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

        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, b"perf", b"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, b'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(b'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, b'perf', opts)

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

    # experimental config: perf.stub

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

        return functools.partial(stub_timer, fm), fm

    # experimental config: perf.all-timing

    displayall = ui.configbool(b"perf", b"all-timing", False)

    return functools.partial(_timer, fm, displayall=displayall), fm

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

    func()

@contextlib.contextmanager

def timeone():

    r = []

    ostart = os.times()

    cstart = util.timer()

    yield r

    cstop = util.timer()

    ostop = os.times()

    a, b = ostart, ostop

    r.append((cstop - cstart, b[0] - a[0], b[1]-a[1]))

def _timer(fm, func, setup=None, title=None, displayall=False):

    gc.collect()

    results = []

    begin = util.timer()

    count = 0

    while True:

        if setup is not None:

            setup()

        with timeone() as item:

            r = func()

        count += 1

        results.append(item[0])

        cstop = util.timer()

        if cstop - begin > 3 and count >= 100:

            break

        if cstop - begin > 10 and count >= 3:

            break

    formatone(fm, results, title=title, result=r,

              displayall=displayall)

def formatone(fm, timings, title=None, result=None, displayall=False):

    count = len(timings)

    fm.startitem()

    if title:

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

    if result:

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

    def display(role, entry):

        prefix = b''

        if role != b'best':

            prefix = b'%s.' % role

        fm.plain(b'!')

        fm.write(prefix + b'wall', b' wall %f', entry[0])

        fm.write(prefix + b'comb', b' comb %f', entry[1] + entry[2])

        fm.write(prefix + b'user', b' user %f', entry[1])

        fm.write(prefix + b'sys',  b' sys %f', entry[2])

        fm.write(prefix + b'count',  b' (%s of %%d)' % role, count)

        fm.plain(b'\n')

    timings.sort()

    min_val = timings[0]

    display(b'best', min_val)

    if displayall:

        max_val = timings[-1]

        display(b'max', max_val)

        avg = tuple([sum(x) / count for x in zip(*timings)])

        display(b'avg', avg)

        median = timings[len(timings) // 2]

        display(b'median', median)

# 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((b"%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((b"missing attribute %s of %s might break assumption"

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

    origvalue = getattr(obj, _sysstr(name))