# perf.py - performance test routines

'''helper extension to measure performance

Configurations

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

``perf``

--------

``all-timing``

    When set, additional statistics 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 runs (default: 1)

``pre-run``

  number of run to perform before starting measurement.

``profile-benchmark``

  Enable profiling for the benchmarked section.

  (The first iteration is benchmarked)

``run-limits``

  Control the number of runs each benchmark will perform. The option value

  should be a list of `<time>-<numberofrun>` pairs. After each run the

  conditions are considered in order with the following logic:

      If benchmark has been running for <time> seconds, and we have performed

      <numberofrun> iterations, stop the benchmark,

  The default value is: `3.0-100, 10.0-3`

``stub``

    When set, benchmarks 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:

except ImportError:

    pass

try:

except ImportError:

    pass

try:

except ImportError:

    registrar = None

try:

except ImportError:

    pass

try:

except ImportError:

    repoviewutil = None

try:

except ImportError:

    pass

try:

except ImportError:

    pass

try:

    from mercurial import profiling

except ImportError:

    profiling = None

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)

    if pycompat.ispy3:

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

    else:

        _maxint = sys.maxint

except (NameError, ImportError, AttributeError):

    import inspect

    getargspec = inspect.getargspec

    _byteskwargs = identity

    _bytestr = str

    _xrange = xrange

try:

    # 4.7+

    queue = pycompat.queue.Queue

except (NameError, AttributeError, ImportError):

    # <4.7.

    try:

        queue = pycompat.queue

    except (NameError, AttributeError, ImportError):

        import Queue as 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)

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

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)

        default=mercurial.configitems.dynamicdefault,

        experimental=True,

    )

        default=mercurial.configitems.dynamicdefault,

        experimental=True,

    )

        default=mercurial.configitems.dynamicdefault,

        experimental=True,

    )

        default=mercurial.configitems.dynamicdefault,

        experimental=True,

    )

        default=mercurial.configitems.dynamicdefault,

    )

        default=mercurial.configitems.dynamicdefault,

        experimental=True,

    )

except (ImportError, AttributeError):

    pass

except TypeError:

    # compatibility fix for a11fd395e83f

    # hg version: 5.2

    )

    )

        default=mercurial.configitems.dynamicdefault,

    )

    )

def getlen(ui):

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

        return lambda x: 1

    return len

class noop(object):

    """dummy context manager"""

    def __enter__(self):

        pass

    def __exit__(self, *args):

        pass

NOOPCTX = noop()

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