# perf.py - performance test routines

'''helper extension to measure performance

Configurations

==============

``perf``

--------

``all-timing``

    When set, additional statistic will be reported for each benchmark: best,

    worst, median average. If not set only the best timing is reported

    (default: off).

``presleep``

  number of second to wait before any group of run (default: 1)

``stub``

    When set, benchmark will only be run once, useful for testing (default: off)

'''

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

    hg,

    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

try:

    from mercurial import setdiscovery # since 1.9 (or cb98fed52495)

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)

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

    if setup is not None:

        setup()

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

# list of stop condition (elapsed time, minimal run count)

DEFAULTLIMITS = (

    (3.0, 100),

    (10.0, 3),

)

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

           limits=DEFAULTLIMITS):

    gc.collect()

    results = []

    begin = util.timer()

    count = 0

    keepgoing = True

    while keepgoing:

        if setup is not None:

            setup()

        with timeone() as item:

            r = func()

        count += 1

        results.append(item[0])

        cstop = util.timer()

        # Look for a stop condition.

        elapsed = cstop - begin

        for t, mincount in limits:

            if elapsed >= t and count >= mincount:

                keepgoing = False

                break

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

              displayall=displayall)

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