mach
author Tom Ritter <tom@mozilla.com>
Fri, 12 Jan 2018 13:36:04 -0600
changeset 399590 17bf5819b42fa3b656f2d3c565bc4fb0ca050066
parent 326849 1f85e7bfe97d54892bc08f3d5a80e9bab52f0189
child 490189 d5ef7a5e02a4d12e6349beb11a2cee666ea75b44
permissions -rwxr-xr-x
Bug 1429764 Do not call ReduceTimerPrecision twice for DOM Navigation timers r=bkelly,timhuang Bug 1429764 details a test failure that was asserting that the performance navigation timers were strictly increasing (or equal). fetchStart should have a timestamp before domainLookupStart. But it didn't. The problem is two-fold. This corrects the test and the issue by addressing one part of the problem, the second part of the problem needs to be written up in a new bug and addressed there. (That bug is not yet filed at writing, but see dependencies of 1429764 in the future to find it.) The second, and underlying, problem is that calling ReduceTimerPrecision with the same value multiple times may continually reduce it. Meaning that the first you call it with, say, .75, (and a precision of .20), it will be reduced to .6. The second time you call it (with .6), instead of staying at .6 it will be reduced to .4. This is because floats are fuzzy. Inside ReduceTimerPrecision we are multiplying a decimal by a decimal, so while floor(.6 / .20) should equal 3, sometimes it's actually 2.999... which gets floors to 2, gets multiplied again by .2, and which results in .4 If that's the underlying problem, the first, and surface, problem is - why are we calling ReduceTimerPrecision multiple times? We shouldn't be. That's what this patch fixes. TimeStampToDOMHighResOrFetchStart will return either TimeStampToDOMHighRes() or FetchStartHighRes(). FetchStartHighRes() internally calls TimeStampToDOMHighRes and then ReduceTimerPrecision - this is where (some of) the two reduction calls happen - because TimeStampToDOMHighRes itself calls ReduceTimerPrecision also. I remove the ReduceTimerPrecision from TimeStampToDOMHighRes. FetchStartHighRes will now only call ReduceTimerPrecision once, at the end of the return. But we have to fix places we call TimeStampToDOMHighResOrFetchStart, because the callers of that function also call ReduceTimerPrecision. So if TimeStampToDOMHighResOrFetchStart returned FetchStartHighRes, we'd be calling ReduceTimerPrecision twice for those callers. So inside first off, we remove the outer call to ReduceTimerPrecision. that surrounds the 5 or so callsites of TimeStampToDOMHighResOrFetchStart. Then inside of TimeStampToDOMHighResOrFetchStart we return either FetchStartHighRes (which is has already called ReduceTimerPrecision) or we call ReduceTimerPrecision with the value. Now. TimeStampToDOMHighRes was used in more places than just FetchStartHighRes - there were several other places where we were doing double rounding, and this fixed those as well. AsyncOpenHighRes, WorkerStartHighRes, DomainLookupEndHighRes, ConnectStartHighRes, SecureConnectionStartHighRes, ConnectEndHighRes, and ResponseEndHighRes. MozReview-Commit-ID: K5nHql135rb

#!/bin/sh
# This Source Code Form is subject to the terms of the Mozilla Public
# License, v. 2.0. If a copy of the MPL was not distributed with this
# file, You can obtain one at http://mozilla.org/MPL/2.0/.

# The beginning of this script is both valid shell and valid python,
# such that the script starts with the shell and is reexecuted with
# the right python.
'''which' python2.7 > /dev/null && exec python2.7 "$0" "$@" || exec python "$0" "$@"
'''

from __future__ import print_function, unicode_literals

import os
import sys

def ancestors(path):
    while path:
        yield path
        (path, child) = os.path.split(path)
        if child == "":
            break

def load_mach(dir_path, mach_path):
    import imp
    with open(mach_path, 'r') as fh:
        imp.load_module('mach_bootstrap', fh, mach_path,
                        ('.py', 'r', imp.PY_SOURCE))
    import mach_bootstrap
    return mach_bootstrap.bootstrap(dir_path)


def check_and_get_mach(dir_path):
    bootstrap_paths = (
        'build/mach_bootstrap.py',
        # test package bootstrap
        'tools/mach_bootstrap.py',
    )
    for bootstrap_path in bootstrap_paths:
        mach_path = os.path.join(dir_path, bootstrap_path)
        if os.path.isfile(mach_path):
            return load_mach(dir_path, mach_path)
    return None


def get_mach():
    # Check whether the current directory is within a mach src or obj dir.
    for dir_path in ancestors(os.getcwd()):
        # If we find a "config.status" and "mozinfo.json" file, we are in the objdir.
        config_status_path = os.path.join(dir_path, 'config.status')
        mozinfo_path = os.path.join(dir_path, 'mozinfo.json')
        if os.path.isfile(config_status_path) and os.path.isfile(mozinfo_path):
            import json
            info = json.load(open(mozinfo_path))
            if 'mozconfig' in info and 'MOZCONFIG' not in os.environ:
                # If the MOZCONFIG environment variable is not already set, set it
                # to the value from mozinfo.json.  This will tell the build system
                # to look for a config file at the path in $MOZCONFIG rather than
                # its default locations.
                #
                # Note: subprocess requires native strings in os.environ on Windows
                os.environ[b'MOZCONFIG'] = str(info['mozconfig'])

            if 'topsrcdir' in info:
                # Continue searching for mach_bootstrap in the source directory.
                dir_path = info['topsrcdir']

        mach = check_and_get_mach(dir_path)
        if mach:
            return mach

    # If we didn't find a source path by scanning for a mozinfo.json, check
    # whether the directory containing this script is a source directory. We
    # follow symlinks so mach can be run even if cwd is outside the srcdir.
    return check_and_get_mach(os.path.dirname(os.path.realpath(__file__)))

def main(args):
    mach = get_mach()
    if not mach:
        print('Could not run mach: No mach source directory found.')
        sys.exit(1)
    sys.exit(mach.run(args))


if __name__ == '__main__':
    main(sys.argv[1:])