Adding gather_stats (based on bisect-builds.py) to gather benchmarking

tools/bisect-builds.py

 #!/usr/bin/env python
 # Copyright (c) 2012 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.
 
 """Snapshot Build Bisect Tool
 
 This script bisects a snapshot archive using binary search. It starts at
 a bad revision (it will try to guess HEAD) and asks for a last known-good
 revision. It will then binary search across this revision range by downloading,
@@ skipping 164 matching lines @@
       # trailing slash to just have a number.
       revisions = []
       for prefix in all_prefixes:
         revnum = prefix.text[prefix_len:-1]
         try:
           revnum = int(revnum)
           revisions.append(revnum)
         except ValueError:
           pass
       return (revisions, next_marker)
-      
+
     # Fetch the first list of revisions.
     (revisions, next_marker) = _FetchAndParse(self.GetListingURL())
 
     # If the result list was truncated, refetch with the next marker. Do this
     # until an entire directory listing is done.
     while next_marker:
       next_url = self.GetListingURL(next_marker)
       (new_revisions, next_marker) = _FetchAndParse(next_url)
       revisions.extend(new_revisions)
     return revisions
@@ skipping 93 matching lines @@
 
   download_url = context.GetDownloadURL(rev)
   try:
     urllib.urlretrieve(download_url, filename, ReportHook)
     if progress_event and progress_event.isSet():
       print
   except RuntimeError, e:
     pass
 
 
-def RunRevision(context, revision, zipfile, profile, num_runs, args):
-  """Given a zipped revision, unzip it and run the test."""
+def RunRevision(context, revision, zipfile, num_runs, exec_args, outdir=None):
+  """Given a zipped revision, unzip it and run the test.
+  @param context A PathContext instance.
+  @param revision The Chromium revision number/tag to run.
+  @param zipfile Path to a zip file containing the Chromium revision.
+  @param num_runs Number of times to run the given Chromium revision.
+  @param exec_args Function which takes in the path of the unzipped Chromium
+                    revision and returns the full command to execute Chromium.
+  @param outdir Path to save output to. If specified, stdout will be saved at
+                    outdir/<revision>_<iteration>.out and stderr will be saved
+                    at outdir/<revision>_<iteration>.err. If left as None, the
+                    output is not saved.
+  """
   print "Trying revision %s..." % str(revision)
 
-  # Create a temp directory and unzip the revision into it.
-  cwd = os.getcwd()
   tempdir = tempfile.mkdtemp(prefix='bisect_tmp')
   UnzipFilenameToDir(zipfile, tempdir)
-  os.chdir(tempdir)
+  testargs = exec_args(os.path.join(tempdir, context.GetLaunchPath()))
 
-  # Run the build as many times as specified.
-  testargs = [context.GetLaunchPath(), '--user-data-dir=%s' % profile] + args
   # The sandbox must be run as root on Official Chrome, so bypass it.
   if context.is_official and (context.platform == 'linux' or
       context.platform == 'linux64'):
     testargs.append('--no-sandbox')
 
+  # Run the build as many times as specified.
   for i in range(0, num_runs):
     subproc = subprocess.Popen(testargs,
                                bufsize=-1,
                                stdout=subprocess.PIPE,
                                stderr=subprocess.PIPE)
     (stdout, stderr) = subproc.communicate()
 
-  os.chdir(cwd)
+    if outdir is not None:
+      if not os.path.isdir(outdir):
+        os.mkdir(outdir)
+
+      fout = open(os.path.join(outdir, '%s_%s.out' % (str(revision), str(i))),
+                  'w')
+      fout.write(stdout)
+      fout.close()
+      ferr = open(os.path.join(outdir, '%s_%s.err' % (str(revision), str(i))),
+                  'w')
+      ferr.write(stderr)
+      ferr.close()
+
   try:
     shutil.rmtree(tempdir, True)
   except Exception, e:
     pass
 
   return (subproc.returncode, stdout, stderr)
 
 
 def AskIsGoodBuild(rev, official_builds, status, stdout, stderr):
   """Ask the user whether build |rev| is good or bad."""
@@ skipping 130 matching lines @@
       down_fetch.Start()
 
     up_pivot = int((bad - pivot) / 2) + pivot
     up_fetch = None
     if up_pivot != pivot and up_pivot != bad:
       up_rev = revlist[up_pivot]
       up_fetch = DownloadJob(context, 'up_fetch', up_rev,
                              _GetDownloadPath(up_rev))
       up_fetch.Start()
 
+    def execute_args(chrome_path):
+      return [chrome_path, '--user-data-dir=%s' % profile] + try_args
+
     # Run test on the pivot revision.
     status = None
     stdout = None
     stderr = None
     try:
       (status, stdout, stderr) = RunRevision(context,
                                              rev,
                                              zipfile,
-                                             profile,
                                              num_runs,
-                                             try_args)
+                                             execute_args)
     except Exception, e:
       print >>sys.stderr, e
+
     os.unlink(zipfile)
     zipfile = None
 
     # Call the evaluate function to see if the current revision is good or bad.
     # On that basis, kill one of the background downloads and complete the
     # other, as described in the comments above.
     try:
       answer = evaluate(rev, official_builds, status, stdout, stderr)
       if answer == 'g':
         good = pivot
@@ skipping 174 matching lines @@
     print '  ' + WEBKIT_CHANGELOG_URL % (first_known_bad_webkit_rev,
                                          last_known_good_webkit_rev)
   print 'CHANGELOG URL:'
   if opts.official_builds:
     print OFFICIAL_CHANGELOG_URL % (last_known_good_rev, first_known_bad_rev)
   else:
     print '  ' + CHANGELOG_URL % (last_known_good_rev, first_known_bad_rev)
 
 if __name__ == '__main__':
   sys.exit(main())