view mercurial/diffhelper.py @ 49442:816236523765

bisect: avoid adding irrelevant revisions to bisect state

When adding new revisions to the bisect state, it only makes sense to add
information about revisions that are under consideration (i.e., those that are
topologically between the known good and bad revisions). However, if the user
passes in a revset (e.g., '!merge()' to exclude merge commits), hg will resolve
the revset first and add all matching revisions to the bisect state (which in
this case would likely be the majority of revisions in the repo). To avoid this,
revisions should only be added to the bisect state if they are between the good
and bad revisions (and therefore relevant to the bisection).

--

Here are the results of some performance tests using the `mozilla-central` repo
(since it is one of the largest freely-available hg repositories in the wild).
These tests compare the performance of a locally-built `hg` before and after
application of this series. Note that `--noupdate` is passed to avoid including
update time (which should not vary across cases).

Setup (run between each test):
  $ hg bisect --reset
  $ hg bisect --noupdate --bad 56c3ad4bde5c70714b784ccf15d099e0df0f5bde
  $ hg bisect --noupdate --good 57426696adaf08298af3027fa77486fee0633b13

Test using a revset that returns a very large number of revisions:
  $ time hg bisect --noupdate --skip '!merge()' > /dev/null

Before:
  real    0m9.398s
  user    0m9.233s
  sys     0m0.120s

After:
  real    0m1.513s
  user    0m1.425s
  sys     0m0.052s

Test using a revset that is expensive to compute:
  $ time hg bisect --noupdate --skip 'desc("Bug")' > /dev/null

Before:
  real    0m49.853s
  user    0m49.580s
  sys     0m0.243s

After:
  real    0m4.120s
  user    0m4.036s
  sys     0m0.048s

# diffhelper.py - helper routines for patch
#
# Copyright 2009 Olivia Mackall <[e-mail]> and others
#
# This software may be used and distributed according to the terms of the
# GNU General Public License version 2 or any later version.


from .i18n import _

from . import (
    error,
)

MISSING_NEWLINE_MARKER = b'\\ No newline at end of file\n'


def addlines(fp, hunk, lena, lenb, a, b):
    """Read lines from fp into the hunk

    The hunk is parsed into two arrays, a and b. a gets the old state of
    the text, b gets the new state. The control char from the hunk is saved
    when inserting into a, but not b (for performance while deleting files.)
    """
    while True:
        todoa = lena - len(a)
        todob = lenb - len(b)
        num = max(todoa, todob)
        if num == 0:
            break
        for i in range(num):
            s = fp.readline()
            if not s:
                raise error.ParseError(_(b'incomplete hunk'))
            if s == MISSING_NEWLINE_MARKER:
                fixnewline(hunk, a, b)
                continue
            if s == b'\n' or s == b'\r\n':
                # Some patches may be missing the control char
                # on empty lines. Supply a leading space.
                s = b' ' + s
            hunk.append(s)
            if s.startswith(b'+'):
                b.append(s[1:])
            elif s.startswith(b'-'):
                a.append(s)
            else:
                b.append(s[1:])
                a.append(s)


def fixnewline(hunk, a, b):
    """Fix up the last lines of a and b when the patch has no newline at EOF"""
    l = hunk[-1]
    # tolerate CRLF in last line
    if l.endswith(b'\r\n'):
        hline = l[:-2]
    else:
        hline = l[:-1]

    if hline.startswith((b' ', b'+')):
        b[-1] = hline[1:]
    if hline.startswith((b' ', b'-')):
        a[-1] = hline
    hunk[-1] = hline


def testhunk(a, b, bstart):
    """Compare the lines in a with the lines in b

    a is assumed to have a control char at the start of each line, this char
    is ignored in the compare.
    """
    alen = len(a)
    blen = len(b)
    if alen > blen - bstart or bstart < 0:
        return False
    for i in range(alen):
        if a[i][1:] != b[i + bstart]:
            return False
    return True