If V8 revisions aren't mappable to bleeding_edge, try to search for one that is

tools/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 260 matching lines @@
     command: A list containing the command and args to execute.
 
   Returns:
     The return code of the call.
   """
   # On Windows, use shell=True to get PATH interpretation.
   shell = IsWindows()
   return subprocess.call(command, shell=shell)
 
 
-def RunProcessAndRetrieveOutput(command):
+def RunProcessAndRetrieveOutput(command, cwd=None):
   """Run an arbitrary command, returning its output and return code. Since
   output is collected via communicate(), there will be no output until the
   call terminates. If you need output while the program runs (ie. so
   that the buildbot doesn't terminate the script), consider RunProcess().
 
   Args:
     command: A list containing the command and args to execute.
-    print_output: Optional parameter to write output to stdout as it's
-        being collected.
 
   Returns:
     A tuple of the output and return code.
   """
   # On Windows, use shell=True to get PATH interpretation.
   shell = IsWindows()
-  proc = subprocess.Popen(command,
-                          shell=shell,
-                          stdout=subprocess.PIPE)
+  proc = subprocess.Popen(command, shell=shell, stdout=subprocess.PIPE, cwd=cwd)
 
   (output, _) = proc.communicate()
 
   return (output, proc.returncode)
 
 
-def RunGit(command):
+def RunGit(command, cwd=None):
   """Run a git subcommand, returning its output and return code.
 
   Args:
     command: A list containing the args to git.
 
   Returns:
     A tuple of the output and return code.
   """
   command = ['git'] + command
 
-  return RunProcessAndRetrieveOutput(command)
+  return RunProcessAndRetrieveOutput(command, cwd=cwd)
 
 
-def CheckRunGit(command):
+def CheckRunGit(command, cwd=None):
   """Run a git subcommand, returning its output and return code. Asserts if
   the return code of the call is non-zero.
 
   Args:
     command: A list containing the args to git.
 
   Returns:
     A tuple of the output and return code.
   """
-  (output, return_code) = RunGit(command)
+  (output, return_code) = RunGit(command, cwd=cwd)
 
   assert not return_code, 'An error occurred while running'\
                           ' "git %s"' % ' '.join(command)
   return output
 
 
 def SetBuildSystemDefault(build_system):
   """Sets up any environment variables needed to build with the specified build
   system.
 
@@ skipping 369 matching lines @@
 
     if not sync_client:
       results = RunGit(['checkout', revision])[1]
     elif sync_client == 'gclient':
       results = self.SyncToRevisionWithGClient(revision)
     elif sync_client == 'repo':
       results = self.SyncToRevisionWithRepo(revision)
 
     return not results
 
-  def ResolveToRevision(self, revision_to_check, depot, search):
+  def ResolveToRevision(self, revision_to_check, depot, search, cwd=None):
     """If an SVN revision is supplied, try to resolve it to a git SHA1.
 
     Args:
       revision_to_check: The user supplied revision string that may need to be
         resolved to a git SHA1.
       depot: The depot the revision_to_check is from.
       search: The number of changelists to try if the first fails to resolve
         to a git hash. If the value is negative, the function will search
         backwards chronologically, otherwise it will search forward.
 
@@ skipping 15 matching lines @@
       if search > 0:
         search_range = xrange(svn_revision, svn_revision + search, 1)
       else:
         search_range = xrange(svn_revision, svn_revision + search, -1)
 
       for i in search_range:
         svn_pattern = 'git-svn-id: %s@%d' % (depot_svn, i)
         cmd = ['log', '--format=%H', '-1', '--grep', svn_pattern,
                'origin/master']
 
-        (log_output, return_code) = RunGit(cmd)
+        (log_output, return_code) = RunGit(cmd, cwd=cwd)
 
         assert not return_code, 'An error occurred while running'\
                                 ' "git %s"' % ' '.join(cmd)
 
         if not return_code:
           log_output = log_output.strip()
 
           if log_output:
             git_revision = log_output
 
             break
 
       return git_revision
     else:
       if IsStringInt(revision_to_check):
         return int(revision_to_check)
       else:
         cwd = os.getcwd()
         os.chdir(os.path.join(os.getcwd(), 'src', 'third_party',
             'chromiumos-overlay'))
         pattern = CROS_VERSION_PATTERN % revision_to_check
         cmd = ['log', '--format=%ct', '-1', '--grep', pattern]
 
         git_revision = None
 
-        log_output = CheckRunGit(cmd)
+        log_output = CheckRunGit(cmd, cwd=cwd)
         if log_output:
           git_revision = log_output
           git_revision = int(log_output.strip())
         os.chdir(cwd)
 
         return git_revision
 
   def IsInProperBranch(self):
     """Confirms they're in the master branch for performing the bisection.
     This is needed or gclient will fail to sync properly.
@@ skipping 20 matching lines @@
     cmd = ['svn', 'find-rev', revision]
 
     output = CheckRunGit(cmd)
     svn_revision = output.strip()
 
     if IsStringInt(svn_revision):
       return int(svn_revision)
 
     return None
 
-  def QueryRevisionInfo(self, revision):
+  def QueryRevisionInfo(self, revision, cwd=None):
     """Gathers information on a particular revision, such as author's name,
     email, subject, and date.
 
     Args:
       revision: Revision you want to gather information on.
     Returns:
       A dict in the following format:
       {
         'author': %s,
         'email': %s,
         'date': %s,
         'subject': %s,
         'body': %s,
       }
     """
     commit_info = {}
 
     formats = ['%cN', '%cE', '%s', '%cD', '%b']
     targets = ['author', 'email', 'subject', 'date', 'body']
 
     for i in xrange(len(formats)):
       cmd = ['log', '--format=%s' % formats[i], '-1', revision]
-      output = CheckRunGit(cmd)
+      output = CheckRunGit(cmd, cwd=cwd)
       commit_info[targets[i]] = output.rstrip()
 
     return commit_info
 
   def CheckoutFileAtRevision(self, file_name, revision):
     """Performs a checkout on a file at the given revision.
 
     Returns:
       True if successful.
     """
@@ skipping 92 matching lines @@
 
       revision_work_list = list(set(
           [int(o) for o in output.split('\n') if IsStringInt(o)]))
       revision_work_list = sorted(revision_work_list, reverse=True)
     else:
       revision_work_list = self.source_control.GetRevisionList(bad_revision,
                                                                good_revision)
 
     return revision_work_list
 
+  def _GetV8BleedingEdgeFromV8TrunkIfMappable(self, revision):
+    svn_revision = self.source_control.SVNFindRev(revision)
+
+    if IsStringInt(svn_revision):
+      # V8 is tricky to bisect, in that there are only a few instances when
+      # we can dive into bleeding_edge and get back a meaningful result.
+      # Try to detect a V8 "business as usual" case, which is when:
+      #  1. trunk revision N has description "Version X.Y.Z"
+      #  2. bleeding_edge revision (N-1) has description "Prepare push to
+      #     trunk. Now working on X.Y.(Z+1)."
+      v8_dir = self._GetDepotDirectory('v8')
+      v8_bleeding_edge_dir = self._GetDepotDirectory('v8_bleeding_edge')
+
+      revision_info = self.source_control.QueryRevisionInfo(revision,
+          cwd=v8_dir)
+
+      version_re = re.compile("Version (?P<values>[0-9,.]+)")
+
+      regex_results = version_re.search(revision_info['subject'])
+
+      if regex_results:
+        version = regex_results.group('values')
+
+        git_revision = self.source_control.ResolveToRevision(
+            int(svn_revision) - 1, 'v8_bleeding_edge', -1,
+            cwd=v8_bleeding_edge_dir)
+
+        if git_revision:
+          revision_info = self.source_control.QueryRevisionInfo(git_revision,
+              cwd=v8_bleeding_edge_dir)
+
+          if 'Prepare push to trunk' in revision_info['subject']:
+            return git_revision
+    return None
+
+  def _GetNearestV8BleedingEdgeFromTrunk(self, revision, search_forward=True):
+    cwd = self._GetDepotDirectory('v8')
+    cmd = ['log', '--format=%ct', '-1', revision]
+    output = CheckRunGit(cmd, cwd=cwd)
+    commit_time = int(output)
+    commits = []
+
+    if search_forward:
+      cmd = ['log', '--format=%H', '-10', '--after=%d' % commit_time,
+          'origin/master']
+      output = CheckRunGit(cmd, cwd=cwd)
+      output = output.split()
+      commits = output
+      commits = reversed(commits)
+    else:
+      cmd = ['log', '--format=%H', '-10', '--before=%d' % commit_time,
+          'origin/master']
+      output = CheckRunGit(cmd, cwd=cwd)
+      output = output.split()
+      commits = output
+
+    bleeding_edge_revision = None
+
+    for c in commits:
+      bleeding_edge_revision = self._GetV8BleedingEdgeFromV8TrunkIfMappable(c)
+      if bleeding_edge_revision:
+        break
+
+    return bleeding_edge_revision
+
   def Get3rdPartyRevisionsFromCurrentRevision(self, depot, revision):
     """Parses the DEPS file to determine WebKit/v8/etc... versions.
 
     Returns:
       A dict in the format {depot:revision} if successful, otherwise None.
     """
 
     cwd = os.getcwd()
     self.ChangeToDepotWorkingDirectory(depot)
 
@@ skipping 65 matching lines @@
 
           cwd = os.getcwd()
           self.ChangeToDepotWorkingDirectory('chromium')
           return_code = CheckRunGit(['log', '-1', '--format=%H',
               '--author=chrome-release@google.com', '--grep=to %s' % version,
               'origin/master'])
           os.chdir(cwd)
 
           results['chromium'] = output.strip()
     elif depot == 'v8':
+      # We can't try to map the trunk revision to bleeding edge yet, because
+      # we don't know which direction to try to search in. Have to wait until
+      # the bisect has narrowed the results down to 2 v8 rolls.
       results['v8_bleeding_edge'] = None
 
-      svn_revision = self.source_control.SVNFindRev(revision)
-
-      if IsStringInt(svn_revision):
-        # V8 is tricky to bisect, in that there are only a few instances when
-        # we can dive into bleeding_edge and get back a meaningful result.
-        # Try to detect a V8 "business as usual" case, which is when:
-        #  1. trunk revision N has description "Version X.Y.Z"
-        #  2. bleeding_edge revision (N-1) has description "Prepare push to
-        #     trunk. Now working on X.Y.(Z+1)."
-        self.ChangeToDepotWorkingDirectory(depot)
-
-        revision_info = self.source_control.QueryRevisionInfo(revision)
-
-        version_re = re.compile("Version (?P<values>[0-9,.]+)")
-
-        regex_results = version_re.search(revision_info['subject'])
-
-        if regex_results:
-          version = regex_results.group('values')
-
-          self.ChangeToDepotWorkingDirectory('v8_bleeding_edge')
-
-          git_revision = self.source_control.ResolveToRevision(
-              int(svn_revision) - 1, 'v8_bleeding_edge', -1)
-
-          if git_revision:
-            revision_info = self.source_control.QueryRevisionInfo(git_revision)
-
-            if 'Prepare push to trunk' in revision_info['subject']:
-              results['v8_bleeding_edge'] = git_revision
-
     return results
 
   def BuildCurrentRevision(self, depot):
     """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
@@ skipping 513 matching lines @@
 
     Returns:
       True if the current_value is closer to the known_good_value than the
       known_bad_value.
     """
     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
+    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.
 
     Args:
       depot_name: The name of the depot (see DEPOT_NAMES).
     """
-    if depot_name == 'chromium':
-      os.chdir(self.src_cwd)
-    elif depot_name == 'cros':
-      os.chdir(self.cros_cwd)
-    elif depot_name in DEPOT_NAMES:
-      os.chdir(self.depot_cwd[depot_name])
-    else:
-      assert False, 'Unknown depot [ %s ] encountered. Possibly a new one'\
-                    ' was added without proper support?' %\
-                    (depot_name,)
+    os.chdir(self._GetDepotDirectory(depot_name))
 
-  def FindNextDepotToBisect(self, current_revision, min_revision_data,
-      max_revision_data):
+  def _FillInV8BleedingEdgeInfo(self, min_revision_data, max_revision_data):
+    r1 = self._GetNearestV8BleedingEdgeFromTrunk(min_revision_data['revision'],
+        search_forward=True)
+    r2 = self._GetNearestV8BleedingEdgeFromTrunk(max_revision_data['revision'],
+        search_forward=False)
+    min_revision_data['external']['v8_bleeding_edge'] = r1
+    max_revision_data['external']['v8_bleeding_edge'] = r2
+
+    if (not self._GetV8BleedingEdgeFromV8TrunkIfMappable(
+            min_revision_data['revision']) or
+        not self._GetV8BleedingEdgeFromV8TrunkIfMappable(
+            max_revision_data['revision'])):
+      self.warnings.append('Trunk revisions in V8 did not map directly to '
+          'bleeding_edge. Attempted to expand the range to find V8 rolls which '
+          'did map directly to bleeding_edge revisions, but results might not '
+          'be valid.')
+
+  def _FindNextDepotToBisect(self, current_depot, current_revision,
+      min_revision_data, max_revision_data):
     """Given the state of the bisect, decides which depot the script should
     dive into next (if any).
 
     Args:
+      current_depot: Current depot being bisected.
       current_revision: Current revision synced to.
       min_revision_data: Data about the earliest revision in the bisect range.
       max_revision_data: Data about the latest revision in the bisect range.
 
     Returns:
       The depot to bisect next, or None.
     """
     external_depot = None
-    for current_depot in DEPOT_NAMES:
-      if DEPOT_DEPS_NAME[current_depot].has_key('platform'):
-        if DEPOT_DEPS_NAME[current_depot]['platform'] != os.name:
+    for next_depot in DEPOT_NAMES:
+      if DEPOT_DEPS_NAME[next_depot].has_key('platform'):
+        if DEPOT_DEPS_NAME[next_depot]['platform'] != os.name:
           continue
 
-      if not (DEPOT_DEPS_NAME[current_depot]["recurse"] and
-          DEPOT_DEPS_NAME[current_depot]['from'] ==
+      if not (DEPOT_DEPS_NAME[next_depot]["recurse"] and
+          DEPOT_DEPS_NAME[next_depot]['from'] ==
           min_revision_data['depot']):
         continue
 
-      if (min_revision_data['external'][current_depot] ==
-          max_revision_data['external'][current_depot]):
+      if current_depot == 'v8':
+        # We grab the bleeding_edge info here rather than earlier because we
+        # finally have the revision range. From that we can search forwards and
+        # backwards to try to match trunk revisions to bleeding_edge.
+        self._FillInV8BleedingEdgeInfo(min_revision_data, max_revision_data)
+
+      if (min_revision_data['external'][next_depot] ==
+          max_revision_data['external'][next_depot]):
         continue
 
-      if (min_revision_data['external'][current_depot] and
-          max_revision_data['external'][current_depot]):
-        external_depot = current_depot
+      if (min_revision_data['external'][next_depot] and
+          max_revision_data['external'][next_depot]):
+        external_depot = next_depot
         break
 
     return external_depot
 
   def PrepareToBisectOnDepot(self,
                              current_depot,
                              end_revision,
                              start_revision,
                              previous_depot,
                              previous_revision):
@@ skipping 379 matching lines @@
         if max_revision - min_revision <= 1:
           current_depot = min_revision_data['depot']
           if min_revision_data['passed'] == '?':
             next_revision_index = min_revision
           elif max_revision_data['passed'] == '?':
             next_revision_index = max_revision
           elif current_depot in ['cros', 'chromium', 'v8']:
             previous_revision = revision_list[min_revision]
             # If there were changes to any of the external libraries we track,
             # should bisect the changes there as well.
-            external_depot = self.FindNextDepotToBisect(
+            external_depot = self._FindNextDepotToBisect(current_depot,
                 previous_revision, min_revision_data, max_revision_data)
 
             # If there was no change in any of the external depots, the search
             # is over.
             if not external_depot:
               if current_depot == 'v8':
                 self.warnings.append('Unfortunately, V8 bisection couldn\'t '
                     'continue any further. The script can only bisect into '
                     'V8\'s bleeding_edge repository if both the current and '
                     'previous revisions in trunk map directly to revisions in '
@@ skipping 778 matching lines @@
       # The perf dashboard scrapes the "results" step in order to comment on
       # 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())