Move bisect-perf-regression.py into auto_bisect directory.

tools/run-bisect-perf-regression.py

 #!/usr/bin/env python
 # Copyright (c) 2013 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 """Run Performance Test Bisect Tool
 
-This script is used by a try bot to run the src/tools/bisect-perf-regression.py
-script with the parameters specified in src/tools/auto_bisect/bisect.cfg.
-It will check out a copy of the depot in a subdirectory 'bisect' of the working
-directory provided, and run the bisect-perf-regression.py script there.
+This script is used by a try bot to run the bisect script with the parameters
+specified in the bisect config file. It checks out a copy of the depot in
+a subdirectory 'bisect' of the working directory provided, annd runs the
+bisect scrip there.
 """
 
-import imp
 import optparse
 import os
 import platform
 import subprocess
 import sys
 import traceback
 
+from auto_bisect import bisect_perf_regression
 from auto_bisect import bisect_utils
 from auto_bisect import math_utils
 
-bisect = imp.load_source('bisect-perf-regression',
-    os.path.join(os.path.abspath(os.path.dirname(sys.argv[0])),
-        'bisect-perf-regression.py'))
-
-
 CROS_BOARD_ENV = 'BISECT_CROS_BOARD'
 CROS_IP_ENV = 'BISECT_CROS_IP'
 
-# Default config file paths, relative to this script.
-BISECT_REGRESSION_CONFIG = os.path.join('auto_bisect', 'bisect.cfg')
-RUN_TEST_CONFIG = 'run-perf-test.cfg'
-WEBKIT_RUN_TEST_CONFIG = os.path.join(
-    '..', 'third_party', 'WebKit', 'Tools', 'run-perf-test.cfg')
+SCRIPT_DIR = os.path.dirname(__file__)
+SRC_DIR = os.path.join(SCRIPT_DIR, os.path.pardir)
+BISECT_CONFIG_PATH = os.path.join(SCRIPT_DIR, 'auto_bisect', 'bisect.cfg')
+RUN_TEST_CONFIG_PATH = os.path.join(SCRIPT_DIR, 'run-perf-test.cfg')
+WEBKIT_RUN_TEST_CONFIG_PATH = os.path.join(
+    SRC_DIR, 'third_party', 'WebKit', 'Tools', 'run-perf-test.cfg')
+BISECT_SCRIPT_DIR = os.path.join(SCRIPT_DIR, 'auto_bisect')
 
 
 class Goma(object):
 
   def __init__(self, path_to_goma):
     self._abs_path_to_goma = None
     self._abs_path_to_goma_file = None
     if not path_to_goma:
       return
     self._abs_path_to_goma = os.path.abspath(path_to_goma)
@@ skipping 175 matching lines @@
       raise RuntimeError('CrOS build selected, but BISECT_CROS_IP or'
           'BISECT_CROS_BOARD undefined.')
   elif 'android' in config['command']:
     if 'android-chrome-shell' in config['command']:
       opts_dict['target_platform'] = 'android'
     elif 'android-chrome' in config['command']:
       opts_dict['target_platform'] = 'android-chrome'
     else:
       opts_dict['target_platform'] = 'android'
 
-  return bisect.BisectOptions.FromDict(opts_dict)
+  return bisect_perf_regression.BisectOptions.FromDict(opts_dict)
 
 
-def _RunPerformanceTest(config, path_to_file):
+def _RunPerformanceTest(config):
   """Runs a performance test with and without the current patch.
 
   Args:
     config: Contents of the config file, a dictionary.
-    path_to_file: Path to the bisect-perf-regression.py script.
 
   Attempts to build and run the current revision with and without the
   current patch, with the parameters passed in.
   """
   # Bisect script expects to be run from the src directory
-  os.chdir(os.path.join(path_to_file, '..'))
+  os.chdir(SRC_DIR)
 
   bisect_utils.OutputAnnotationStepStart('Building With Patch')
 
   opts = _CreateBisectOptionsFromConfig(config)
-  b = bisect.BisectPerformanceMetrics(None, opts)
+  b = bisect_perf_regression.BisectPerformanceMetrics(None, opts)
 
   if bisect_utils.RunGClient(['runhooks']):
     raise RuntimeError('Failed to run gclient runhooks')
 
   if not b.BuildCurrentRevision('chromium'):
     raise RuntimeError('Patched version failed to build.')
 
   bisect_utils.OutputAnnotationStepClosed()
   bisect_utils.OutputAnnotationStepStart('Running With Patch')
 
@@ skipping 69 matching lines @@
     print ' %s %s %s' % ('No Patch'.center(10, ' '),
         ('%.02f' % results_without_patch[0]['mean']).center(20, ' '),
         ('%.02f' % results_without_patch[0]['std_err']).center(20, ' '))
     if cloud_file_link:
       bisect_utils.OutputAnnotationStepLink('HTML Results', cloud_file_link)
     bisect_utils.OutputAnnotationStepClosed()
   elif cloud_file_link:
     bisect_utils.OutputAnnotationStepLink('HTML Results', cloud_file_link)
 
 
-def _SetupAndRunPerformanceTest(config, path_to_file, path_to_goma):
+def _SetupAndRunPerformanceTest(config, path_to_goma):
   """Attempts to build and run the current revision with and without the
   current patch, with the parameters passed in.
 
   Args:
     config: The config read from run-perf-test.cfg.
-    path_to_file: Path to the bisect-perf-regression.py script.
     path_to_goma: Path to goma directory.
 
   Returns:
-    The exit code of bisect-perf-regression.py: 0 on success, otherwise 1.
+    An exit code: 0 on success, otherwise 1.
   """
   if platform.release() == 'XP':
     print 'Windows XP is not supported for perf try jobs because it lacks '
     print 'goma support. Please refer to crbug.com/330900.'
     return 1
   try:
     with Goma(path_to_goma) as _:
       config['use_goma'] = bool(path_to_goma)
       if config['use_goma']:
         config['goma_dir'] = os.path.abspath(path_to_goma)
-      _RunPerformanceTest(config, path_to_file)
+      _RunPerformanceTest(config)
     return 0
   except RuntimeError, e:
     bisect_utils.OutputAnnotationStepClosed()
     _OutputFailedResults('Error: %s' % e.message)
     return 1
 
 
 def _RunBisectionScript(
-    config, working_directory, path_to_file, path_to_goma, path_to_extra_src,
-    dry_run):
-  """Attempts to execute bisect-perf-regression.py with the given parameters.
+    config, working_directory, path_to_goma, path_to_extra_src, dry_run):
+  """Attempts to execute the bisect script with the given parameters.
 
   Args:
     config: A dict containing the parameters to pass to the script.
-    working_directory: A working directory to provide to the
-      bisect-perf-regression.py script, where it will store it's own copy of
-      the depot.
-    path_to_file: Path to the bisect-perf-regression.py script.
+    working_directory: A working directory to provide to the bisect script,
+      where it will store it's own copy of the depot.
     path_to_goma: Path to goma directory.
     path_to_extra_src: Path to extra source file.
     dry_run: Do a dry run, skipping sync, build, and performance testing steps.
 
   Returns:
     An exit status code: 0 on success, otherwise 1.
   """
   _PrintConfigStep(config)
 
-  cmd = ['python', os.path.join(path_to_file, 'bisect-perf-regression.py'),
+  cmd = ['python', os.path.join(BISECT_SCRIPT_DIR, 'bisect_perf_regression.py'),
          '-c', config['command'],
          '-g', config['good_revision'],
          '-b', config['bad_revision'],
          '-m', config['metric'],
          '--working_directory', working_directory,
          '--output_buildbot_annotations']
 
   if config.get('metric'):
     cmd.extend(['-m', config['metric']])
 
@@ skipping 60 matching lines @@
 
   if dry_run:
     cmd.extend(['--debug_ignore_build', '--debug_ignore_sync',
         '--debug_ignore_perf_test'])
   cmd = [str(c) for c in cmd]
 
   with Goma(path_to_goma) as _:
     return_code = subprocess.call(cmd)
 
   if return_code:
-    print ('Error: bisect-perf-regression.py returned with error %d\n'
+    print ('Error: bisect_perf_regression.py returned with error %d\n'
            % return_code)
 
   return return_code
 
 
 def _PrintConfigStep(config):
   """Prints out the given config, along with Buildbot annotations."""
   bisect_utils.OutputAnnotationStepStart('Config')
   print
   for k, v in config.iteritems():
@@ skipping 35 matching lines @@
   return parser
 
 
 def main():
   """Entry point for run-bisect-perf-regression.py.
 
   Reads the config file, and then tries to either bisect a regression or
   just run a performance test, depending on the particular config parameters
   specified in the config file.
   """
-
   parser = _OptionParser()
   opts, _ = parser.parse_args()
 
-  current_dir = os.path.abspath(os.path.dirname(sys.argv[0]))
-
   # Use the default config file path unless one was specified.
-  config_path = os.path.join(current_dir, BISECT_REGRESSION_CONFIG)
+  config_path = BISECT_CONFIG_PATH
   if opts.path_to_config:
     config_path = opts.path_to_config
   config = _LoadConfigFile(config_path)
 
   # Check if the config is valid for running bisect job.
   config_is_valid = _ValidateBisectConfigFile(config)
 
   if config and config_is_valid:
     if not opts.working_directory:
       print 'Error: missing required parameter: --working_directory\n'
       parser.print_help()
       return 1
 
     return _RunBisectionScript(
-        config, opts.working_directory, current_dir,
-        opts.path_to_goma, opts.extra_src, opts.dry_run)
+        config, opts.working_directory, opts.path_to_goma, opts.extra_src,
+        opts.dry_run)
 
   # If it wasn't valid for running a bisect, then maybe the user wanted
   # to run a perf test instead of a bisect job. Try reading any possible
   # perf test config files.
-  perf_cfg_files = [RUN_TEST_CONFIG, WEBKIT_RUN_TEST_CONFIG]
+  perf_cfg_files = [RUN_TEST_CONFIG_PATH, WEBKIT_RUN_TEST_CONFIG_PATH]
   for current_perf_cfg_file in perf_cfg_files:
     if opts.path_to_config:
       path_to_perf_cfg = opts.path_to_config
     else:
       path_to_perf_cfg = os.path.join(
           os.path.abspath(os.path.dirname(sys.argv[0])),
           current_perf_cfg_file)
 
     config = _LoadConfigFile(path_to_perf_cfg)
     config_is_valid = _ValidatePerfConfigFile(config)
 
     if config and config_is_valid:
-      return _SetupAndRunPerformanceTest(
-          config, current_dir, opts.path_to_goma)
+      return _SetupAndRunPerformanceTest(config, opts.path_to_goma)
 
   print ('Error: Could not load config file. Double check your changes to '
-         'auto_bisect/bisect.cfg or run-perf-test.cfg for syntax '
-         'errors.\n')
+         'auto_bisect/bisect.cfg or run-perf-test.cfg for syntax errors.\n')
   return 1
 
 
 if __name__ == '__main__':
   sys.exit(main())