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

tools/auto_bisect/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.
 
 """Performance Test Bisect Tool
 
 This script bisects a series of changelists using binary search. It starts at
 a bad revision where a performance metric has regressed, and asks for a last
 known-good revision. It will then binary search across this revision range by
@@ skipping 31 matching lines @@
 import re
 import shlex
 import shutil
 import StringIO
 import sys
 import time
 import zipfile
 
 sys.path.append(os.path.join(os.path.dirname(__file__), 'telemetry'))
 
-from auto_bisect import bisect_utils
-from auto_bisect import builder
-from auto_bisect import math_utils
-from auto_bisect import request_build
-from auto_bisect import source_control as source_control_module
-from auto_bisect import ttest
+import bisect_utils
+import builder
+import math_utils
+import request_build
+import source_control as source_control_module
+import ttest
 from telemetry.util import cloud_storage
 
 # Below is the map of "depot" names to information about each depot. Each depot
 # is a repository, and in the process of bisecting, revision ranges in these
 # repositories may also be bisected.
 #
 # Each depot information dictionary may contain:
 #   src: Path to the working directory.
 #   recurse: True if this repository will get bisected.
 #   depends: A list of other repositories that are actually part of the same
@@ skipping 75 matching lines @@
         'svn': 'http://skia.googlecode.com/svn/trunk/gyp',
         'depends': None,
         'from': ['chromium'],
         'viewvc': 'https://code.google.com/p/skia/source/detail?r=',
         'deps_var': 'None'
     }
 }
 
 DEPOT_NAMES = DEPOT_DEPS_NAME.keys()
 
+# The script is in chromium/src/tools/auto_bisect. Throughout this script,
+# we use paths to other things in the chromium/src repository.
+SRC_DIR = os.path.join(os.path.dirname(__file__),
+                       os.path.pardir,
+                       os.path.pardir)
+
 CROS_CHROMEOS_PATTERN = 'chromeos-base/chromeos-chrome'
 
 # Possible return values from BisectPerformanceMetrics.RunTest.
 BUILD_RESULT_SUCCEED = 0
 BUILD_RESULT_FAIL = 1
 BUILD_RESULT_SKIPPED = 2
 
 # Maximum time in seconds to wait after posting build request to the try server.
 # TODO: Change these values based on the actual time taken by buildbots on
 # the try server.
@@ skipping 744 matching lines @@
   revisions to narrow down where performance regressions may have occurred.
 
   The main entry-point is the Run method.
   """
 
   def __init__(self, source_control, opts):
     super(BisectPerformanceMetrics, self).__init__()
 
     self.opts = opts
     self.source_control = source_control
-    self.src_cwd = os.getcwd()
-    self.cros_cwd = os.path.join(os.getcwd(), '..', 'cros')
+    self.cros_cwd = os.path.join(SRC_DIR, 'tools', 'cros')
     self.depot_cwd = {}
     self.cleanup_commands = []
     self.warnings = []
     self.builder = builder.Builder.FromOpts(opts)
 
     for d in DEPOT_NAMES:
       # The working directory of each depot is just the path to the depot, but
       # since we're already in 'src', we can skip that part.
 
       self.depot_cwd[d] = os.path.join(
-          self.src_cwd, DEPOT_DEPS_NAME[d]['src'][4:])
+          SRC_DIR, DEPOT_DEPS_NAME[d]['src'][4:])
 
   def PerformCleanup(self):
     """Performs cleanup when script is finished."""
-    os.chdir(self.src_cwd)
+    os.chdir(SRC_DIR)
     for c in self.cleanup_commands:
       if c[0] == 'mv':
         shutil.move(c[1], c[2])
       else:
         assert False, 'Invalid cleanup command.'
 
   def GetRevisionList(self, depot, bad_revision, good_revision):
     """Retrieves a list of all the commits between the bad revision and
     last known good revision."""
 
@@ skipping 140 matching lines @@
       results = {}
       for depot_name, depot_data in DEPOT_DEPS_NAME.iteritems():
         if (depot_data.get('platform') and
             depot_data.get('platform') != os.name):
           continue
 
         if (depot_data.get('recurse') and depot in depot_data.get('from')):
           depot_data_src = depot_data.get('src') or depot_data.get('src_old')
           src_dir = deps_data.get(depot_data_src)
           if src_dir:
-            self.depot_cwd[depot_name] = os.path.join(self.src_cwd,
+            self.depot_cwd[depot_name] = os.path.join(SRC_DIR,
                                                       depot_data_src[4:])
             re_results = rxp.search(src_dir)
             if re_results:
               results[depot_name] = re_results.group('revision')
             else:
               warning_text = ('Could not parse revision for %s while bisecting '
                               '%s' % (depot_name, depot))
               if not warning_text in self.warnings:
                 self.warnings.append(warning_text)
           else:
@@ skipping 86 matching lines @@
     """Backs up or restores build output directory based on restore argument.
 
     Args:
       restore: Indicates whether to restore or backup. Default is False(Backup)
       build_type: Target build type ('Release', 'Debug', 'Release_x64' etc.)
 
     Returns:
       Path to backup or restored location as string. otherwise None if it fails.
     """
     build_dir = os.path.abspath(
-        builder.GetBuildOutputDirectory(self.opts, self.src_cwd))
+        builder.GetBuildOutputDirectory(self.opts, SRC_DIR))
     source_dir = os.path.join(build_dir, build_type)
     destination_dir = os.path.join(build_dir, '%s.bak' % build_type)
     if restore:
       source_dir, destination_dir = destination_dir, source_dir
     if os.path.exists(source_dir):
       RmTreeAndMkDir(destination_dir, skip_makedir=True)
       shutil.move(source_dir, destination_dir)
       return destination_dir
     return None
 
@@ skipping 43 matching lines @@
     if patch:
       # Get the SHA of the DEPS changes patch.
       patch_sha = GetSHA1HexDigest(patch)
 
       # Update the DEPS changes patch with a patch to create a new file named
       # 'DEPS.sha' and add patch_sha evaluated above to it.
       patch = '%s\n%s' % (patch, DEPS_SHA_PATCH % {'deps_sha': patch_sha})
 
     # Get Build output directory
     abs_build_dir = os.path.abspath(
-        builder.GetBuildOutputDirectory(self.opts, self.src_cwd))
+        builder.GetBuildOutputDirectory(self.opts, SRC_DIR))
 
     fetch_build_func = lambda: self.GetBuildArchiveForRevision(
       revision, self.opts.gs_bucket, self.opts.target_arch,
       patch_sha, abs_build_dir)
 
     # Downloaded archive file path, downloads build archive for given revision.
     downloaded_file = fetch_build_func()
 
     # When build archive doesn't exists, post a build request to tryserver
     # and wait for the build to be produced.
@@ skipping 202 matching lines @@
   def CreateDEPSPatch(self, depot, revision):
     """Modifies DEPS and returns diff as text.
 
     Args:
       depot: Current depot being bisected.
       revision: A git hash revision of the dependency repository.
 
     Returns:
       A tuple with git hash of chromium revision and DEPS patch text.
     """
-    deps_file_path = os.path.join(self.src_cwd, bisect_utils.FILE_DEPS)
+    deps_file_path = os.path.join(SRC_DIR, bisect_utils.FILE_DEPS)
     if not os.path.exists(deps_file_path):
       raise RuntimeError('DEPS file does not exists.[%s]' % deps_file_path)
     # Get current chromium revision (git hash).
     cmd = ['rev-parse', 'HEAD']
     chromium_sha = bisect_utils.CheckRunGit(cmd).strip()
     if not chromium_sha:
       raise RuntimeError('Failed to determine Chromium revision for %s' %
                          revision)
     if ('chromium' in DEPOT_DEPS_NAME[depot]['from'] or
         'v8' in DEPOT_DEPS_NAME[depot]['from']):
       # Checkout DEPS file for the current chromium revision.
       if self.source_control.CheckoutFileAtRevision(
-          bisect_utils.FILE_DEPS, chromium_sha, cwd=self.src_cwd):
+          bisect_utils.FILE_DEPS, chromium_sha, cwd=SRC_DIR):
         if self.UpdateDeps(revision, depot, deps_file_path):
           diff_command = [
               'diff',
               '--src-prefix=src/',
               '--dst-prefix=src/',
               '--no-ext-diff',
                bisect_utils.FILE_DEPS,
           ]
-          diff_text = bisect_utils.CheckRunGit(diff_command, cwd=self.src_cwd)
+          diff_text = bisect_utils.CheckRunGit(diff_command, cwd=SRC_DIR)
           return (chromium_sha, ChangeBackslashToSlashInPatch(diff_text))
         else:
           raise RuntimeError(
               'Failed to update DEPS file for chromium: [%s]' % chromium_sha)
       else:
         raise RuntimeError(
             'DEPS checkout Failed for chromium revision : [%s]' % chromium_sha)
     return (None, None)
 
   def BuildCurrentRevision(self, depot, revision=None):
     """Builds chrome and performance_ui_tests on the current revision.
 
     Returns:
       True if the build was successful.
     """
     if self.opts.debug_ignore_build:
       return True
 
     build_success = False
     cwd = os.getcwd()
-    os.chdir(self.src_cwd)
+    os.chdir(SRC_DIR)
     # Fetch build archive for the given revision from the cloud storage when
     # the storage bucket is passed.
     if self.IsDownloadable(depot) and revision:
       deps_patch = None
       if depot != 'chromium':
         # Create a DEPS patch with new revision for dependency repository.
         revision, deps_patch = self.CreateDEPSPatch(depot, revision)
       if self.DownloadCurrentBuild(revision, patch=deps_patch):
         if deps_patch:
           # Reverts the changes to DEPS file.
           self.source_control.CheckoutFileAtRevision(
-              bisect_utils.FILE_DEPS, revision, cwd=self.src_cwd)
+              bisect_utils.FILE_DEPS, revision, cwd=SRC_DIR)
         build_success = True
     else:
       # These codes are executed when bisect bots builds binaries locally.
       build_success = self.builder.Build(depot, self.opts)
     os.chdir(cwd)
     return build_success
 
   def RunGClientHooks(self):
     """Runs gclient with runhooks command.
 
     Returns:
       True if gclient reports no errors.
     """
     if self.opts.debug_ignore_build:
       return True
-    return not bisect_utils.RunGClient(['runhooks'], cwd=self.src_cwd)
+    return not bisect_utils.RunGClient(['runhooks'], cwd=SRC_DIR)
 
   def _IsBisectModeUsingMetric(self):
     return self.opts.bisect_mode in [BISECT_MODE_MEAN, BISECT_MODE_STD_DEV]
 
   def _IsBisectModeReturnCode(self):
     return self.opts.bisect_mode in [BISECT_MODE_RETURN_CODE]
 
   def _IsBisectModeStandardDeviation(self):
     return self.opts.bisect_mode in [BISECT_MODE_STD_DEV]
 
   def GetCompatibleCommand(self, command_to_run, revision, depot):
     # Prior to crrev.com/274857 *only* android-chromium-testshell
     # Then until crrev.com/276628 *both* (android-chromium-testshell and
     # android-chrome-shell) work. After that rev 276628 *only*
     # android-chrome-shell works. bisect-perf-regression.py script should
     # handle these cases and set appropriate browser type based on revision.
     if self.opts.target_platform in ['android']:
       # When its a third_party depot, get the chromium revision.
       if depot != 'chromium':
         revision = bisect_utils.CheckRunGit(
-            ['rev-parse', 'HEAD'], cwd=self.src_cwd).strip()
+            ['rev-parse', 'HEAD'], cwd=SRC_DIR).strip()
       commit_position = self.source_control.GetCommitPosition(revision,
-                                                              cwd=self.src_cwd)
+                                                              cwd=SRC_DIR)
       if not commit_position:
         return command_to_run
       cmd_re = re.compile('--browser=(?P<browser_type>\S+)')
       matches = cmd_re.search(command_to_run)
       if bisect_utils.IsStringInt(commit_position) and matches:
         cmd_browser = matches.group('browser_type')
         if commit_position <= 274857 and cmd_browser == 'android-chrome-shell':
           return command_to_run.replace(cmd_browser,
                                         'android-chromium-testshell')
         elif (commit_position >= 276628 and
@@ skipping 60 matching lines @@
       current_args = copy.copy(args)
       if is_telemetry:
         if i == 0 and reset_on_first_run:
           current_args.append('--reset-results')
         elif i == self.opts.repeat_test_count - 1 and upload_on_last_run:
           current_args.append('--upload-results')
         if results_label:
           current_args.append('--results-label=%s' % results_label)
       try:
         output, return_code = bisect_utils.RunProcessAndRetrieveOutput(
-            current_args, cwd=self.src_cwd)
+            current_args, cwd=SRC_DIR)
       except OSError, e:
         if e.errno == errno.ENOENT:
           err_text  = ('Something went wrong running the performance test. '
                        'Please review the command line:\n\n')
           if 'src/' in ' '.join(args):
             err_text += ('Check that you haven\'t accidentally specified a '
                          'path with src/ in the command.\n\n')
           err_text += ' '.join(args)
           err_text += '\n'
 
@@ skipping 106 matching lines @@
       num_resolved = len(revisions_to_sync)
       num_needed = len(DEPOT_DEPS_NAME[depot]['depends'])
 
       self.ChangeToDepotWorkingDirectory(depot)
 
       if not ((num_resolved - 1) == num_needed):
         return None
 
     return revisions_to_sync
 
-  def PerformPreBuildCleanup(self):
+  @staticmethod
+  def PerformPreBuildCleanup():
     """Performs cleanup between runs."""
     print 'Cleaning up between runs.'
     print
 
     # Leaving these .pyc files around between runs may disrupt some perf tests.
-    for (path, _, files) in os.walk(self.src_cwd):
+    for (path, _, files) in os.walk(SRC_DIR):
       for cur_file in files:
         if cur_file.endswith('.pyc'):
           path_to_file = os.path.join(path, cur_file)
           os.remove(path_to_file)
 
   def PerformCrosChrootCleanup(self):
     """Deletes the chroot.
 
     Returns:
       True if successful.
@@ skipping 23 matching lines @@
 
     Args:
       depot: Depot name.
 
     Returns:
       True if successful.
     """
     if depot == 'chromium' or depot == 'android-chrome':
       # Removes third_party/libjingle. At some point, libjingle was causing
       # issues syncing when using the git workflow (crbug.com/266324).
-      os.chdir(self.src_cwd)
+      os.chdir(SRC_DIR)
       if not bisect_utils.RemoveThirdPartyDirectory('libjingle'):
         return False
       # Removes third_party/skia. At some point, skia was causing
       # issues syncing when using the git workflow (crbug.com/377951).
       if not bisect_utils.RemoveThirdPartyDirectory('skia'):
         return False
     elif depot == 'cros':
       return self.PerformCrosChrootCleanup()
     return True
 
   def _RunPostSync(self, depot):
     """Performs any work after syncing.
 
     Args:
       depot: Depot name.
 
     Returns:
       True if successful.
     """
     if self.opts.target_platform == 'android':
       if not builder.SetupAndroidBuildEnvironment(self.opts,
-          path_to_src=self.src_cwd):
+          path_to_src=SRC_DIR):
         return False
 
     if depot == 'cros':
       return self.CreateCrosChroot()
     else:
       return self.RunGClientHooks()
     return True
 
   def ShouldSkipRevision(self, depot, revision):
     """Checks whether a particular revision can be safely skipped.
@@ skipping 144 matching lines @@
       dist_to_bad_value = abs(current_value['std_dev'] -
           known_bad_value['std_dev'])
     else:
       dist_to_good_value = abs(current_value['mean'] - known_good_value['mean'])
       dist_to_bad_value = abs(current_value['mean'] - known_bad_value['mean'])
 
     return dist_to_good_value < dist_to_bad_value
 
   def _GetDepotDirectory(self, depot_name):
     if depot_name == 'chromium':
-      return self.src_cwd
+      return SRC_DIR
     elif depot_name == 'cros':
       return self.cros_cwd
     elif depot_name in DEPOT_NAMES:
       return self.depot_cwd[depot_name]
     else:
       assert False, ('Unknown depot [ %s ] encountered. Possibly a new one '
                      'was added without proper support?' % depot_name)
 
   def ChangeToDepotWorkingDirectory(self, depot_name):
     """Given a depot, changes to the appropriate working directory.
@@ skipping 76 matching lines @@
       A list containing the revisions between |start_revision| and
       |end_revision| inclusive.
     """
     # Change into working directory of external library to run
     # subsequent commands.
     self.ChangeToDepotWorkingDirectory(current_depot)
 
     # V8 (and possibly others) is merged in periodically. Bisecting
     # this directory directly won't give much good info.
     if DEPOT_DEPS_NAME[current_depot].has_key('custom_deps'):
-      config_path = os.path.join(self.src_cwd, '..')
+      config_path = os.path.join(SRC_DIR, '..')
       if bisect_utils.RunGClientAndCreateConfig(self.opts,
           DEPOT_DEPS_NAME[current_depot]['custom_deps'], cwd=config_path):
         return []
       if bisect_utils.RunGClient(
-          ['sync', '--revision', previous_revision], cwd=self.src_cwd):
+          ['sync', '--revision', previous_revision], cwd=SRC_DIR):
         return []
 
     if current_depot == 'v8_bleeding_edge':
       self.ChangeToDepotWorkingDirectory('chromium')
 
       shutil.move('v8', 'v8.bak')
       shutil.move('v8_bleeding_edge', 'v8')
 
       self.cleanup_commands.append(['mv', 'v8', 'v8_bleeding_edge'])
       self.cleanup_commands.append(['mv', 'v8.bak', 'v8'])
 
-      self.depot_cwd['v8_bleeding_edge'] = os.path.join(self.src_cwd, 'v8')
-      self.depot_cwd['v8'] = os.path.join(self.src_cwd, 'v8.bak')
+      self.depot_cwd['v8_bleeding_edge'] = os.path.join(SRC_DIR, 'v8')
+      self.depot_cwd['v8'] = os.path.join(SRC_DIR, 'v8.bak')
 
       self.ChangeToDepotWorkingDirectory(current_depot)
 
     depot_revision_list = self.GetRevisionList(current_depot,
                                                end_revision,
                                                start_revision)
 
     self.ChangeToDepotWorkingDirectory('chromium')
 
     return depot_revision_list
@@ skipping 124 matching lines @@
 
     Args:
       good_revision: Known good revision.
       bad_revision: Known bad revision.
 
     Returns:
       A dictionary indicating the result. If revision is not bisectable,
       this will contain the field "error", otherwise None.
     """
     if self.opts.target_platform == 'android':
-      revision_to_check = self.source_control.GetCommitPosition(good_revision)
+      good_revision = self.source_control.GetCommitPosition(good_revision)

[qyearsley, 2014/09/11 16:38:38]

revision_to_check was not referenced. Pylint caught this.

       if (bisect_utils.IsStringInt(good_revision)
           and good_revision < 265549):
         return {'error': (
             'Bisect cannot continue for the given revision range.\n'
             'It is impossible to bisect Android regressions '
             'prior to r265549, which allows the bisect bot to '
             'rely on Telemetry to do apk installation of the most recently '
             'built local ChromeShell(refer to crbug.com/385324).\n'
             'Please try bisecting revisions greater than or equal to r265549.')}
 
@@ skipping 1100 matching lines @@
       # bugs. If you change this, please update the perf dashboard as well.
       bisect_utils.OutputAnnotationStepStart('Results')
     print 'Error: %s' % e.message
     if opts.output_buildbot_annotations:
       bisect_utils.OutputAnnotationStepClosed()
   return 1
 
 
 if __name__ == '__main__':
   sys.exit(main())