Update script to switch through revision history successfully.

tools/testing/perf_testing/run_perf_tests.py

 #!/usr/bin/python
 
 # Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 # for details. All rights reserved. Use of this source code is governed by a
 # BSD-style license that can be found in the LICENSE file.
 
 import datetime
 import math             
 import optparse
 import os
 from os.path import dirname, abspath
 import pickle
 import platform
 import re
 import shutil
 import stat
 import subprocess
 import sys
 import time
 
 TOOLS_PATH = os.path.join(dirname(dirname(dirname(abspath(__file__)))))
-DART_INSTALL_LOCATION = abspath(os.path.join(dirname(abspath(__file__)),
-                                             '..', '..', '..'))
+TOP_LEVEL_DIR = abspath(os.path.join(dirname(abspath(__file__)), '..', '..',
+                                             '..'))
+DART_REPO_LOC = abspath(os.path.join(dirname(abspath(__file__)), '..', '..',
+                                             '..', '..', '..',
+                                             'dart_checkout_for_perf_testing',
+                                             'dart'))
 sys.path.append(TOOLS_PATH)
-sys.path.append(os.path.join(DART_INSTALL_LOCATION, 'internal', 'tests'))
+sys.path.append(os.path.join(TOP_LEVEL_DIR, 'internal', 'tests'))
 import post_results
 import utils
 
 """This script runs to track performance and size progress of
 different svn revisions. It tests to see if there a newer version of the code on
 the server, and will sync and run the performance tests if so."""
 class TestRunner(object):
 
   def __init__(self):
     self.verbose = False
@@ skipping 34 matching lines @@
       print stderr
     return output, stderr
 
   def time_cmd(self, cmd):
     """Determine the amount of (real) time it takes to execute a given 
     command."""
     start = time.time()
     self.run_cmd(cmd)
     return time.time() - start
 
+  def clear_out_unversioned_files(self):
+    """Remove all files that are unversioned by svn."""
+    if os.path.exists(DART_REPO_LOC):
+      os.chdir(DART_REPO_LOC)
+      results, _ = self.run_cmd(['svn', 'st'])
+      for line in results.split('\n'):
+        if line.startswith('?'):
+          to_remove = line.split()[1]
+          if os.path.isdir(to_remove):
+            shutil.rmtree(to_remove)#, ignore_errors=True)
+          else:
+            os.remove(to_remove)
+
   def sync_and_build(self, suites, revision_num=''):
     """Make sure we have the latest version of of the repo, and build it. We
-    begin and end standing in DART_INSTALL_LOCATION.
+    begin and end standing in DART_REPO_LOC.
 
     Args:
       suites: The set of suites that we wish to build.
 
     Returns:
       err_code = 1 if there was a problem building."""
-    os.chdir(DART_INSTALL_LOCATION)
-    
+    os.chdir(dirname(DART_REPO_LOC))
+    self.clear_out_unversioned_files()
     if revision_num == '':
       self.run_cmd(['gclient', 'sync'])
     else:
       self.run_cmd(['gclient', 'sync', '-r', revision_num, '-t'])
+    
+    shutil.copytree(os.path.join(TOP_LEVEL_DIR, 'internal'),
+                    os.path.join(DART_REPO_LOC, 'internal'))
+    shutil.copy(os.path.join(TOP_LEVEL_DIR, 'tools', 'get_archive.py'),
+                    os.path.join(DART_REPO_LOC, 'tools', 'get_archive.py'))
 
     if revision_num == '':
       revision_num = search_for_revision(['svn', 'info'])
       if revision_num == -1:
         revision_num = search_for_revision(['git', 'svn', 'info'])
-    _, stderr = self.run_cmd(['python', os.path.join(DART_INSTALL_LOCATION,
-        'tools', 'get_archive.py'), 'sdk', '-r', revision_num])
-    if 'InvalidUriError' in stderr:
-      return 1
+
+    get_archive_path = os.path.join(DART_REPO_LOC, 'tools', 'get_archive.py')
+    if os.path.exists(get_archive_path):
+      cmd = ['python', get_archive_path, 'sdk']
+      if revision_num != -1:
+        cmd += ['-r', revision_num]
+      _, stderr = self.run_cmd(cmd)
+    if not os.path.exists(get_archive_path) or 'InvalidUriError' in stderr:
+      # Couldn't find the SDK on Google Storage. Build it locally.
+
+      # On Windows, the output directory is marked as "Read Only," which causes
+      # an error to be thrown when we use shutil.rmtree. This helper function
+      # changes the permissions so we can still delete the directory.
+      def on_rm_error(func, path, exc_info):
+        if os.path.exists(path):
+          os.chmod(path, stat.S_IWRITE)
+          os.unlink(path)
+      # TODO(efortuna): Currently always building ia32 architecture because we 
+      # don't have test statistics for what's passing on x64. Eliminate arch 
+      # specification when we have tests running on x64, too.
+      shutil.rmtree(os.path.join(os.getcwd(),
+                    utils.GetBuildRoot(utils.GuessOS(), 'release', 'ia32')),
+                    onerror=on_rm_error)
+      lines = self.run_cmd([os.path.join('.', 'tools', 'build.py'), '-m', 
+                            'release', '--arch=ia32', 'create_sdk'])
+
+      for line in lines:
+        if 'BUILD FAILED' in lines:
+          # Someone checked in a broken build! Stop trying to make it work
+          # and wait to try again.
+          print 'Broken Build'
+          return 1
     return 0
 
   def ensure_output_directory(self, dir_name):
     """Test that the listed directory name exists, and if not, create one for
     our output to be placed.
 
     Args:
       dir_name: the directory we will create if it does not exist."""
-    dir_path = os.path.join(DART_INSTALL_LOCATION, 'tools', 
+    dir_path = os.path.join(TOP_LEVEL_DIR, 'tools', 
                             'testing', 'perf_testing', dir_name)
     if not os.path.exists(dir_path):
       os.makedirs(dir_path)
       print 'Creating output directory ', dir_path
 
   def has_new_code(self):
     """Tests if there are any newer versions of files on the server."""
-    os.chdir(DART_INSTALL_LOCATION)
+    os.chdir(DART_REPO_LOC)
     # Pass 'p' in if we have a new certificate for the svn server, we want to
     # (p)ermanently accept it.
     results, _ = self.run_cmd(['svn', 'st', '-u'], std_in='p\r\n')
     for line in results:
       if '*' in line:
         return True
     return False
     
   def get_os_directory(self):
     """Specifies the name of the directory for the testing build of dart, which
     has yet a different naming convention from utils.getBuildRoot(...)."""
     if platform.system() == 'Windows':
       return 'windows'
     elif platform.system() == 'Darwin':
       return 'macos'
     else:
       return 'linux'
 
   def parse_args(self):
     parser = optparse.OptionParser()
     parser.add_option('--suites', '-s', dest='suites', help='Run the specified '
                       'comma-separated test suites from set: %s' % \
                       ','.join(TestBuilder.available_suite_names()), 
                       action='store', default=None)
     parser.add_option('--forever', '-f', dest='continuous', help='Run this scri'
                       'pt forever, always checking for the next svn checkin',
                       action='store_true', default=False)
+    parser.add_option('--incremental', '-i', dest='incremental',
+                      help='Start an an early revision and work your way '
+                      'forward through CLs sequentially', action='store_true',
+                      default=False)
     parser.add_option('--nobuild', '-n', dest='no_build', action='store_true',
                       help='Do not sync with the repository and do not '
                       'rebuild.', default=False)
     parser.add_option('--noupload', '-u', dest='no_upload', action='store_true',
                       help='Do not post the results of the run.', default=False)
     parser.add_option('--notest', '-t', dest='no_test', action='store_true',
                       help='Do not run the tests.', default=False)
     parser.add_option('--verbose', '-v', dest='verbose', help='Print extra '
                       'debug output', action='store_true', default=False)
 
     args, ignored = parser.parse_args()
 
     if not args.suites:
       suites = TestBuilder.available_suite_names()
     else:
       suites = []
       suitelist = args.suites.split(',')
       for name in suitelist:
         if name in TestBuilder.available_suite_names():
           suites.append(name)
         else:
           print ('Error: Invalid suite %s not in ' % name) + \
               '%s' % ','.join(TestBuilder.available_suite_names())
           sys.exit(1)
     self.suite_names = suites
     self.no_build = args.no_build
     self.no_upload = args.no_upload
     self.no_test = args.no_test
     self.verbose = args.verbose
-    return args.continuous
+    return args.continuous, args.incremental
 
   def run_test_sequence(self, revision_num='', num_reruns=1):
     """Run the set of commands to (possibly) build, run, and post the results
     of our tests. Returns 0 on a successful run, 1 if we fail to post results or
     the run failed, -1 if the build is broken.
     """
     suites = []
     success = True
+    if not self.no_build and self.sync_and_build(suites, revision_num) == 1:
+      return -1 # The build is broken.
+    
     for name in self.suite_names:
       for run in range(num_reruns):
         suites += [TestBuilder.make_test(name, self)]
 
-    if not self.no_build and self.sync_and_build(suites, revision_num) == 1:
-      return -1 # The build is broken.
-
     for test in suites:
       success = success and test.run()
     if success:
       return 0
     else:
       return 1
 
 
 class Test(object):
   """The base class to provide shared code for different tests we will run and
@@ skipping 51 matching lines @@
     """
     return True
 
   def run(self):
     """Run the benchmarks/tests from the command line and plot the
     results.
     """
     for visitor in [self.tester, self.file_processor]:
       visitor.prepare()
     
-    os.chdir(DART_INSTALL_LOCATION)
+    os.chdir(TOP_LEVEL_DIR)
     self.test_runner.ensure_output_directory(self.result_folder_name)
     self.test_runner.ensure_output_directory(os.path.join(
         'old', self.result_folder_name))
+    os.chdir(DART_REPO_LOC)
     if not self.test_runner.no_test:
       self.tester.run_tests()
 
-    os.chdir(os.path.join('tools', 'testing', 'perf_testing'))
-
-    for afile in os.listdir(os.path.join('old', self.result_folder_name)):
-      if not afile.startswith('.'):
-        self.file_processor.process_file(afile, False)
+    os.chdir(os.path.join(TOP_LEVEL_DIR, 'tools', 'testing', 'perf_testing'))
 
     files = os.listdir(self.result_folder_name)
     post_success = True
+    os.chdir(TOP_LEVEL_DIR)
     for afile in files:
       if not afile.startswith('.'):
         should_move_file = self.file_processor.process_file(afile, True)
         if should_move_file:
           shutil.move(os.path.join(self.result_folder_name, afile),
                       os.path.join('old', self.result_folder_name, afile))
         else:
           post_success = False
 
     return post_success
 
 
 class Tester(object):
   """The base level visitor class that runs tests. It contains convenience 
   methods that many Tester objects use. Any class that would like to be a
   TesterVisitor must implement the run_tests() method."""
 
   def __init__(self, test):
     self.test = test
 
   def prepare(self):
     """Perform any initial setup required before the test is run."""
     pass
 
   def add_svn_revision_to_trace(self, outfile, browser = None):
     """Add the svn version number to the provided tracefile."""
     def get_dartium_revision():
-      version_file_name = os.path.join(DART_INSTALL_LOCATION, 'client', 'tests',
+      version_file_name = os.path.join(TOP_LEVEL_DIR, 'client', 'tests',
                                        'dartium', 'LAST_VERSION')
       version_file = open(version_file_name, 'r')
       version = version_file.read().split('.')[-2]
       version_file.close()
       return version
 
     if browser and browser == 'dartium':
       revision = get_dartium_revision()
       self.test.test_runner.run_cmd(['echo', 'Revision: ' + revision], outfile)
     else:
@@ skipping 19 matching lines @@
     """Perform any initial setup required before the test is run."""
     pass
 
   def open_trace_file(self, afile, not_yet_uploaded):
     """Find the correct location for the trace file, and open it.
     Args: 
       afile: The tracefile name.
       not_yet_uploaded: True if this file is to be found in a directory that
          contains un-uploaded data.
     Returns: A file object corresponding to the given file name."""
-    file_path = os.path.join(self.test.result_folder_name, afile)
+    file_path = os.path.join(TOP_LEVEL_DIR, self.test.result_folder_name, afile)
     if not not_yet_uploaded:
       file_path = os.path.join('old', file_path)
     return open(file_path)
 
   def report_results(self, benchmark_name, score, platform, variant, 
                      revision_number, metric):
     """Store the results of the benchmark run.
     Args:
       benchmark_name: The name of the individual benchmark.
       score: The numerical value of this benchmark.
@@ skipping 65 matching lines @@
     if add_dartium:
       browsers += ['dartium']
     has_shell = False
     if platform.system() == 'Darwin':
       browsers += ['safari']
     if platform.system() == 'Windows':
       browsers += ['ie']
       has_shell = True
     if 'dartium' in browsers:
       # Fetch it if necessary.
-      get_dartium = ['python',
-                     os.path.join(DART_INSTALL_LOCATION, 'tools',
+      get_dartium = ['python', os.path.join(DART_REPO_LOC, 'tools',
                      'get_archive.py'), 'dartium']
       # TODO(vsm): It's inconvenient that run_cmd isn't in scope here.
       # Perhaps there is a better place to put that or this.
       subprocess.call(get_dartium, stdout=sys.stdout, stderr=sys.stderr,
                       shell=has_shell)
     return browsers
 
 
 class CommonBrowserTest(RuntimePerformanceTest):
   """Runs this basic performance tests (Benchpress, some V8 benchmarks) in the
@@ skipping 16 matching lines @@
   @staticmethod
   def get_standalone_benchmarks():
     return ['Mandelbrot', 'DeltaBlue', 'Richards', 'NBody', 'BinaryTrees',
     'Fannkuch', 'Meteor', 'BubbleSort', 'Fibonacci', 'Loop', 'Permute',
     'Queens', 'QuickSort', 'Recurse', 'Sieve', 'Sum', 'Tak', 'Takl', 'Towers',
     'TreeSort']
 
   class CommonBrowserTester(BrowserTester):
     def run_tests(self):
       """Run a performance test in the browser."""
+      os.chdir(DART_REPO_LOC)
       self.test.test_runner.run_cmd([
           'python', os.path.join('internal', 'browserBenchmarks',
           'make_web_benchmarks.py')])
 
       for browser in self.test.platform_list:
         for version in self.test.versions:
           if not self.test.is_valid_combination(browser, version):
             continue
-          self.test.trace_file = os.path.join(
+          self.test.trace_file = os.path.join(TOP_LEVEL_DIR,
               'tools', 'testing', 'perf_testing', self.test.result_folder_name,
               'perf-%s-%s-%s' % (self.test.cur_time, browser, version))
           self.add_svn_revision_to_trace(self.test.trace_file, browser)
           file_path = os.path.join(
               os.getcwd(), 'internal', 'browserBenchmarks',
               'benchmark_page_%s.html' % version)
           self.test.test_runner.run_cmd(
               ['python', os.path.join('tools', 'testing', 'run_selenium.py'),
               '--out', file_path, '--browser', browser,
               '--timeout', '600', '--mode', 'perf'], self.test.trace_file, 
               append=True)
 
   class CommonBrowserFileProcessor(Processor):
 
     def process_file(self, afile, should_post_file):
       """Comb through the html to find the performance results.
       Returns: True if we successfully posted our data to storage and/or we can
           delete the trace file."""
-      os.chdir(os.path.join(DART_INSTALL_LOCATION, 'tools',
+      os.chdir(os.path.join(TOP_LEVEL_DIR, 'tools',
                             'testing', 'perf_testing'))
       parts = afile.split('-')
       browser = parts[2]
       version = parts[3]
       f = self.open_trace_file(afile, should_post_file)
       lines = f.readlines()
       line = ''
       i = 0
       revision_num = 0
       while '<div id="results">' not in line and i < len(lines):
@@ skipping 99 matching lines @@
   def get_dromaeo_benchmarks():
     valid = DromaeoTester.get_valid_dromaeo_tags()
     benchmarks = reduce(lambda l1,l2: l1+l2,
                         [tests for (tag, tests) in
                          DromaeoTester.DROMAEO_BENCHMARKS.values() 
                          if tag in valid])
     return map(DromaeoTester.legalize_filename, benchmarks)
 
   @staticmethod
   def get_dromaeo_versions():
-    return ['js', 'frog_dom', 'frog_html', 'dart2js_dom', 'dart2js_html']
+    # TODO(vsm): why is the js version closing early?
+    return ['dart2js_dom', 'dart2js_html'] 
+    #return ['js', 'dart2js_dom', 'dart2js_html']
 
 
 class DromaeoTest(RuntimePerformanceTest):
   """Runs Dromaeo tests, in the browser."""
   def __init__(self, test_runner):
     super(DromaeoTest, self).__init__(
         self.name(),
         BrowserTester.get_browsers(),
         'browser',
         DromaeoTester.get_dromaeo_versions(), 
@@ skipping 20 matching lines @@
     def move_chrome_driver_if_needed(self, browser):
       """Move the appropriate version of ChromeDriver onto the path. 
       TODO(efortuna): This is a total hack because the latest version of Chrome
       (Dartium builds) requires a different version of ChromeDriver, that is
       incompatible with the release or beta Chrome and vice versa. Remove these
       shenanigans once we're back to both versions of Chrome using the same
       version of ChromeDriver. IMPORTANT NOTE: This assumes your chromedriver is
       in the default location (inside depot_tools).
       """
       current_dir = os.getcwd()
-      os.chdir(DART_INSTALL_LOCATION)
       self.test.test_runner.run_cmd(['python', os.path.join(
           'tools', 'get_archive.py'), 'chromedriver'])
       path = os.environ['PATH'].split(os.pathsep)
-      orig_chromedriver_path = os.path.join('tools', 'testing',
+      orig_chromedriver_path = os.path.join(DART_REPO_LOC, 'tools', 'testing',
                                             'orig-chromedriver')
-      dartium_chromedriver_path = os.path.join('tools', 'testing',
+      dartium_chromedriver_path = os.path.join(DART_REPO_LOC, 'tools',
+                                               'testing',
                                                'dartium-chromedriver')
       extension = ''
       if platform.system() == 'Windows':
         extension = '.exe'
 
       def move_chromedriver(depot_tools, copy_to_depot_tools_dir=True,
                             from_path=None):
         if from_path:
           from_dir = from_path + extension
         else:
@@ skipping 32 matching lines @@
 
       # Build tests.
       dromaeo_path = os.path.join('samples', 'third_party', 'dromaeo')
       current_path = os.getcwd()
       os.chdir(dromaeo_path)
       self.test.test_runner.run_cmd(['python', 'generate_dart2js_tests.py'])
       os.chdir(current_path)
 
       versions = DromaeoTester.get_dromaeo_versions()
 
-      for browser in filter(lambda x: x != 'ie', BrowserTester.get_browsers()):
+      for browser in BrowserTester.get_browsers():
         self.move_chrome_driver_if_needed(browser)
         for version_name in versions:
           if not self.test.is_valid_combination(browser, version_name):
             continue
           version = DromaeoTest.DromaeoPerfTester.get_dromaeo_url_query(
               browser, version_name)
-          self.test.trace_file = os.path.join(
+          self.test.trace_file = os.path.join(TOP_LEVEL_DIR,
               'tools', 'testing', 'perf_testing', self.test.result_folder_name,
               'dromaeo-%s-%s-%s' % (self.test.cur_time, browser, version_name))
           self.add_svn_revision_to_trace(self.test.trace_file, browser)
           file_path = '"%s"' % os.path.join(os.getcwd(), dromaeo_path,
               'index-js.html?%s' % version)
           if platform.system() == 'Windows':
             file_path = file_path.replace('&', '^&')
             file_path = file_path.replace('?', '^?')
             file_path = file_path.replace('|', '^|')
           self.test.test_runner.run_cmd(
@@ skipping 81 matching lines @@
   class DromaeoSizeTester(DromaeoTester):
     def run_tests(self):
       # Build tests.
       dromaeo_path = os.path.join('samples', 'third_party', 'dromaeo')
       current_path = os.getcwd()
       os.chdir(dromaeo_path)
       self.test.test_runner.run_cmd(
           ['python', os.path.join('generate_dart2js_tests.py')])
       os.chdir(current_path)
 
-      self.test.trace_file = os.path.join(
+      self.test.trace_file = os.path.join(TOP_LEVEL_DIR,
           'tools', 'testing', 'perf_testing', self.test.result_folder_name,
           self.test.result_folder_name + self.test.cur_time)
       self.add_svn_revision_to_trace(self.test.trace_file)
 
       variants = [
           ('frog_dom', ''),
           ('frog_html', '-html'),
           ('frog_htmlidiomatic', '-htmlidiomatic')]
 
       test_path = os.path.join(dromaeo_path, 'tests')
@@ skipping 40 matching lines @@
             self.test.trace_file, append=True)
 
 
   class DromaeoSizeProcessor(Processor):
     def process_file(self, afile, should_post_file):
       """Pull all the relevant information out of a given tracefile.
 
       Args:
         afile: is the filename string we will be processing.
       Returns: True if we successfully posted our data to storage."""
-      os.chdir(os.path.join(DART_INSTALL_LOCATION, 'tools',
+      os.chdir(os.path.join(TOP_LEVEL_DIR, 'tools',
           'testing', 'perf_testing'))
       f = self.open_trace_file(afile, should_post_file)
       tabulate_data = False
       revision_num = 0
       revision_pattern = r'Revision: (\d+)'
       result_pattern = r'Size \((\w+), ([a-zA-Z0-9-]+)\): (\d+)'
 
       upload_success = True
       for line in f.readlines():
         rev = re.match(revision_pattern, line.strip())
@@ skipping 29 matching lines @@
 
 class CompileTimeAndSizeTest(Test):
   """Run tests to determine how long frogc takes to compile, and the compiled
   file output size of some benchmarking files.
   Note: This test is now 'deprecated' since frog is no longer in the sdk. We
   just return the last numbers found for frog."""
   def __init__(self, test_runner):
     """Reference to the test_runner object that notifies us when to begin
     testing."""
     super(CompileTimeAndSizeTest, self).__init__(
-        self.name(), ['commandline'], ['frog'], ['swarm', 'total'],
+        self.name(), ['commandline'], ['dart2js'], ['swarm'],
         test_runner, self.CompileTester(self),
         self.CompileProcessor(self))
     self.dart_compiler = os.path.join(
-        DART_INSTALL_LOCATION, utils.GetBuildRoot(utils.GuessOS(),
-        'release', 'ia32'), 'dart-sdk', 'bin', 'frogc')
+        DART_REPO_LOC, utils.GetBuildRoot(utils.GuessOS(),
+        'release', 'ia32'), 'dart-sdk', 'bin', 'dart2js')
     _suffix = ''
     if platform.system() == 'Windows':
       _suffix = '.exe'
-    self.dart_vm = os.path.join(
-        DART_INSTALL_LOCATION, utils.GetBuildRoot(utils.GuessOS(), 
-        'release', 'ia32'), 'dart-sdk', 'bin','dart' + _suffix)
-    self.failure_threshold = {'swarm' : 100, 'total' : 100}
+    self.failure_threshold = {'swarm' : 100}
 
   @staticmethod
   def name():
     return 'time-size'
 
   class CompileTester(Tester):
     def run_tests(self):
-      os.chdir('frog')
-      self.test.trace_file = os.path.join(
-          '..', 'tools', 'testing', 'perf_testing', 
+      self.test.trace_file = os.path.join(TOP_LEVEL_DIR,
+          'tools', 'testing', 'perf_testing', 
           self.test.result_folder_name,
           self.test.result_folder_name + self.test.cur_time)
 
       self.add_svn_revision_to_trace(self.test.trace_file)
 
+      self.test.test_runner.run_cmd(
+          ['./xcodebuild/ReleaseIA32/dart-sdk/dart2js', '-c', '-o',
+           'swarm-result', os.path.join('samples', 'swarm', 'swarm.dart')])
       swarm_size = 0
       try:
         swarm_size = os.path.getsize('swarm-result')
       except OSError:
         pass #If compilation failed, continue on running other tests.
 
-      total_size = 0
-      try:
-        total_size = os.path.getsize('total-result')
-      except OSError:
-        pass #If compilation failed, continue on running other tests.
-
       self.test.test_runner.run_cmd(
           ['echo', '%d Generated checked swarm size' % swarm_size],
           self.test.trace_file, append=True)
 
-      self.test.test_runner.run_cmd(
-          ['echo', '%d Generated checked total size' % total_size],
-          self.test.trace_file, append=True)
-    
-      os.chdir('..')
-
-
   class CompileProcessor(Processor):
-
     def process_file(self, afile, should_post_file):
       """Pull all the relevant information out of a given tracefile.
 
       Args:
         afile: is the filename string we will be processing.
       Returns: True if we successfully posted our data to storage."""
-      os.chdir(os.path.join(DART_INSTALL_LOCATION, 'tools',
+      os.chdir(os.path.join(TOP_LEVEL_DIR, 'tools',
           'testing', 'perf_testing'))
       f = self.open_trace_file(afile, should_post_file)
       tabulate_data = False
       revision_num = 0
       upload_success = True
       for line in f.readlines():
         tokens = line.split()
         if 'Revision' in line:
           revision_num = int(line.split()[1])
         else:
           for metric in self.test.values_list:
             if metric in line:
               num = tokens[0]
               if num.find('.') == -1:
                 num = int(num)
               else:
                 num = float(num)
-              self.test.values_dict['commandline']['frog'][metric] += [num]
-              self.test.revision_dict['commandline']['frog'][metric] += \
+              self.test.values_dict['commandline']['dart2js'][metric] += [num]
+              self.test.revision_dict['commandline']['dart2js'][metric] += \
                   [revision_num]
               score_type = self.get_score_type(metric)
               if not self.test.test_runner.no_upload and should_post_file:
                 if num < self.test.failure_threshold[metric]:
                   num = 0
                 upload_success = upload_success and self.report_results(
-                    metric, num, 'commandline', 'frog', revision_num,
+                    metric, num, 'commandline', 'dart2js', revision_num,
                     score_type)
               else:
                 upload_success = False
       if revision_num != 0:
         for metric in self.test.values_list:
           try:
-            self.test.revision_dict['commandline']['frog'][metric].pop()
-            self.test.revision_dict['commandline']['frog'][metric] += \
+            self.test.revision_dict['commandline']['dart2js'][metric].pop()
+            self.test.revision_dict['commandline']['dart2js'][metric] += \
                 [revision_num]
             # Fill in 0 if compilation failed.
-            if self.test.values_dict['commandline']['frog'][metric][-1] < \
+            if self.test.values_dict['commandline']['dart2js'][metric][-1] < \
                 self.test.failure_threshold[metric]:
-              self.test.values_dict['commandline']['frog'][metric] += [0]
-              self.test.revision_dict['commandline']['frog'][metric] += \
+              self.test.values_dict['commandline']['dart2js'][metric] += [0]
+              self.test.revision_dict['commandline']['dart2js'][metric] += \
                   [revision_num]
           except IndexError:
             # We tried to pop from an empty list. This happens if the first
             # trace file we encounter is incomplete.
             pass
 
       f.close()
       return upload_success
 
     def get_score_type(self, metric):
@@ skipping 28 matching lines @@
   """Update the set of CLs that do not need additional performance runs.
   Args:
   revision_num: an additional number to be added to the 'done set'
   """
   filename = os.path.join(dirname(abspath(__file__)), 'cached_results.txt')
   if not os.path.exists(filename):
     f = open(filename, 'w')
     results = set()
     pickle.dump(results, f)
     f.close()
-  f = open(filename, '+r')
+  f = open(filename, 'r+')
   result_set = pickle.load(f)
   if revision_num:
     f.seek(0)
     result_set.add(revision_num)
     pickle.dump(result_set, f)
   f.close()
   return result_set
 
 def main():
   runner = TestRunner()
-  continuous = runner.parse_args()
+  continuous, incremental = runner.parse_args()
+
+  if not os.path.exists(DART_REPO_LOC):
+    os.mkdir(dirname(DART_REPO_LOC))
+    os.chdir(dirname(DART_REPO_LOC))
+    p = subprocess.Popen('gclient config https://dart.googlecode.com/svn/' +
+                         'branches/bleeding_edge/deps/all.deps',
+                         stdout=subprocess.PIPE, stderr=subprocess.PIPE,
+                         shell=True)
+    p.communicate()
   if continuous:
     while True:
       results_set = update_set_of_done_cls()
       if runner.has_new_code():
         runner.run_test_sequence()
       else:
         # Try to get up to 10 runs of each CL, starting with the most recent CL
         # that does not yet have 10 runs. But only perform a set of extra runs
         # at most 10 at a time (get all the extra runs for one CL) before
         # checking to see if new code has been checked in.
@@ skipping 15 matching lines @@
                 a_test.file_processor.get_score_type(benchmark_name))
             if number_of_results < 10 and number_of_results >= 0:
               run = runner.run_test_sequence(revision_num=str(revision_num),
                   num_reruns=(10-number_of_results))
               if run == 0:
                 has_run_extra = True
                 results_set = update_set_of_done_cls(revision_num)
           revision_num -= 1
         # No more extra back-runs to do (for now). Wait for new code.
         time.sleep(200)
+  elif incremental:
+    # This is a temporary measure to backfill old revisions.
+    # TODO(efortuna): Clean this up -- don't hard code numbers, make user
+    # specifiable.
+    revision_num = 9000
+    while revision_num < 10600:
+      run = runner.run_test_sequence(revision_num=str(revision_num),
+          num_reruns=10)
+      revision_num += 1
   else:
     runner.run_test_sequence()
 
 if __name__ == '__main__':
   main()