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
 syncing, building, and running a performance test. If the change is
 suspected to occur as a result of WebKit/V8 changes, the script will
 further bisect changes to those depots and attempt to narrow down the revision
 range.
 
 Example usage using SVN revisions:
 
-./tools/bisect-perf-regression.py -c\
+./tools/bisect_perf_regression.py -c\
   "out/Release/performance_ui_tests --gtest_filter=ShutdownTest.SimpleUserQuit"\
   -g 168222 -b 168232 -m shutdown/simple-user-quit
 
 Be aware that if you're using the git workflow and specify an SVN revision,
 the script will attempt to find the git SHA1 where SVN changes up to that
 revision were merged in.
 
 Example usage using git hashes:
 
-./tools/bisect-perf-regression.py -c\
+./tools/bisect_perf_regression.py -c\
   "out/Release/performance_ui_tests --gtest_filter=ShutdownTest.SimpleUserQuit"\
   -g 1f6e67861535121c5c819c16a666f2436c207e7b\
   -b b732f23b4f81c382db0b23b9035f3dadc7d925bb\
   -m shutdown/simple-user-quit
 """
 
 import copy
 import datetime
 import errno
 import hashlib
 import math
 import optparse
 import os
 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'))
+sys.path.append(os.path.join(
+    os.path.dirname(__file__), os.path.pardir, '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.
+
 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 743 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
+
+    # The src directory here is NOT the src/ directory for the repository
+    # where the bisect script is running from. Instead, it's the src/ directory
+    # inside the bisect/ directory which is created before running.
     self.src_cwd = os.getcwd()
     self.cros_cwd = os.path.join(os.getcwd(), '..', 'cros')
     self.depot_cwd = {}
     self.cleanup_commands = []
     self.warnings = []
     self.builder = builder.Builder.FromOpts(opts)
 
-    for d in DEPOT_NAMES:
+    for depot 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:])
+      self.depot_cwd[depot] = os.path.join(
+          self.src_cwd, DEPOT_DEPS_NAME[depot]['src'][4:])
 
   def PerformCleanup(self):
     """Performs cleanup when script is finished."""
     os.chdir(self.src_cwd)
     for c in self.cleanup_commands:
       if c[0] == 'mv':
         shutil.move(c[1], c[2])
       else:
         assert False, 'Invalid cleanup command.'
 
@@ skipping 144 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,
-                                                      depot_data_src[4:])
+            self.depot_cwd[depot_name] = os.path.join(
+                self.src_cwd, 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:
             results[depot_name] = None
@@ skipping 455 matching lines @@
   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.
+    """Return a possibly modified test command depending on the revision.
+
+    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. The 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()
       commit_position = self.source_control.GetCommitPosition(revision,
                                                               cwd=self.src_cwd)
       if not commit_position:
         return command_to_run
       cmd_re = re.compile('--browser=(?P<browser_type>\S+)')
@@ skipping 691 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)
       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())