Mercurial > hg
view mercurial/dirstateutils/timestamp.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
author | Arun Kulshreshtha <akulshreshtha@janestreet.com> |
---|---|
date | Tue, 23 Aug 2022 17:31:27 -0400 |
parents | 6000f5b25c9b |
children | f4733654f144 |
line wrap: on
line source
# Copyright Mercurial Contributors # # This software may be used and distributed according to the terms of the # GNU General Public License version 2 or any later version. import functools import os import stat from .. import error rangemask = 0x7FFFFFFF @functools.total_ordering class timestamp(tuple): """ A Unix timestamp with optional nanoseconds precision, modulo 2**31 seconds. A 3-tuple containing: `truncated_seconds`: seconds since the Unix epoch, truncated to its lower 31 bits `subsecond_nanoseconds`: number of nanoseconds since `truncated_seconds`. When this is zero, the sub-second precision is considered unknown. `second_ambiguous`: whether this timestamp is still "reliable" (see `reliable_mtime_of`) if we drop its sub-second component. """ def __new__(cls, value): truncated_seconds, subsec_nanos, second_ambiguous = value value = (truncated_seconds & rangemask, subsec_nanos, second_ambiguous) return super(timestamp, cls).__new__(cls, value) def __eq__(self, other): raise error.ProgrammingError( 'timestamp should never be compared directly' ) def __gt__(self, other): raise error.ProgrammingError( 'timestamp should never be compared directly' ) def get_fs_now(vfs): """return a timestamp for "now" in the current vfs This will raise an exception if no temporary files could be created. """ tmpfd, tmpname = vfs.mkstemp() try: return mtime_of(os.fstat(tmpfd)) finally: os.close(tmpfd) vfs.unlink(tmpname) def zero(): """ Returns the `timestamp` at the Unix epoch. """ return tuple.__new__(timestamp, (0, 0)) def mtime_of(stat_result): """ Takes an `os.stat_result`-like object and returns a `timestamp` object for its modification time. """ try: # TODO: add this attribute to `osutil.stat` objects, # see `mercurial/cext/osutil.c`. # # This attribute is also not available on Python 2. nanos = stat_result.st_mtime_ns except AttributeError: # https://docs.python.org/2/library/os.html#os.stat_float_times # "For compatibility with older Python versions, # accessing stat_result as a tuple always returns integers." secs = stat_result[stat.ST_MTIME] subsec_nanos = 0 else: billion = int(1e9) secs = nanos // billion subsec_nanos = nanos % billion return timestamp((secs, subsec_nanos, False)) def reliable_mtime_of(stat_result, present_mtime): """Same as `mtime_of`, but return `None` or a `Timestamp` with `second_ambiguous` set if the date might be ambiguous. A modification time is reliable if it is older than "present_time" (or sufficiently in the future). Otherwise a concurrent modification might happens with the same mtime. """ file_mtime = mtime_of(stat_result) file_second = file_mtime[0] file_ns = file_mtime[1] boundary_second = present_mtime[0] boundary_ns = present_mtime[1] # If the mtime of the ambiguous file is younger (or equal) to the starting # point of the `status` walk, we cannot garantee that another, racy, write # will not happen right after with the same mtime and we cannot cache the # information. # # However if the mtime is far away in the future, this is likely some # mismatch between the current clock and previous file system operation. So # mtime more than one days in the future are considered fine. if boundary_second == file_second: if file_ns and boundary_ns: if file_ns < boundary_ns: return timestamp((file_second, file_ns, True)) return None elif boundary_second < file_second < (3600 * 24 + boundary_second): return None else: return file_mtime