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

  (by default, the first iteration is benchmarked)

``profiled-runs``

  list of iteration to profile (starting from 0)

``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

import contextlib

import functools

import gc

import os

import random

import shutil

import struct

import sys

import tempfile

import threading

import time

import mercurial.revlog

from mercurial import (

    changegroup,

    cmdutil,

    commands,

    copies,

    error,

    extensions,

    hg,

    mdiff,

    merge,

    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.utils import repoviewutil  # since 5.0

except ImportError:

    repoviewutil = None

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

try:

    from mercurial import profiling

except ImportError:

    profiling = None

try:

    from mercurial.revlogutils import constants as revlog_constants

    perf_rl_kind = (revlog_constants.KIND_OTHER, b'created-by-perf')

    def revlog(opener, *args, **kwargs):

        return mercurial.revlog.revlog(opener, perf_rl_kind, *args, **kwargs)

except (ImportError, AttributeError):

    perf_rl_kind = None

    def revlog(opener, *args, **kwargs):

        return mercurial.revlog.revlog(opener, *args, **kwargs)

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)

    _bytestr = pycompat.bytestr  # since 4.2 (or b70407bd84d5)

    _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 (NameError, ImportError, AttributeError):

    import inspect

    getargspec = inspect.getargspec

    _byteskwargs = identity

    _bytestr = str

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

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

        experimental=True,

    )

    configitem(

        b'perf',

        b'stub',

        default=mercurial.configitems.dynamicdefault,

        experimental=True,

    )

    configitem(

        b'perf',

        b'parentscount',

        default=mercurial.configitems.dynamicdefault,

        experimental=True,

    )

    configitem(

        b'perf',

        b'all-timing',

        default=mercurial.configitems.dynamicdefault,

        experimental=True,

    )

    configitem(

        b'perf',

        b'pre-run',

        default=mercurial.configitems.dynamicdefault,

    )

    configitem(

        b'perf',

        b'profile-benchmark',

        default=mercurial.configitems.dynamicdefault,

    )

    configitem(

        b'perf',

        b'profiled-runs',

        default=mercurial.configitems.dynamicdefault,

    )

    configitem(

        b'perf',

        b'run-limits',

        default=mercurial.configitems.dynamicdefault,

        experimental=True,

    )

except (ImportError, AttributeError):

    pass

except TypeError:

    # compatibility fix for a11fd395e83f

    # hg version: 5.2

    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,

    )

    configitem(

        b'perf',

        b'pre-run',

        default=mercurial.configitems.dynamicdefault,

    )

    configitem(

        b'perf',

        b'profiled-runs',

        default=mercurial.configitems.dynamicdefault,

    )

    configitem(

        b'perf',

        b'run-limits',

        default=mercurial.configitems.dynamicdefault,

    )

def getlen(ui):

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

        return lambda x: 1

    return len

class noop:

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

            """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", True)

    # ui.warnnoi18n was introduced in 5209fc94b982

    ui_warn = ui.warn

    # experimental config: perf.run-limits

    limitspec = ui.configlist(b"perf", b"run-limits", [])

    limits = []

    for item in limitspec:

        parts = item.split(b'-', 1)

        if len(parts) < 2:

            ui_warn(b'malformatted run limit entry, missing "-": %s\n' % item)

            continue

        try:

            time_limit = float(_sysstr(parts[0]))

        except ValueError as e:

            ui_warn(