Don't let safari run too far in the past.

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 random
 import re
 import shutil
 import stat
 import subprocess
 import sys
 import time
 
 TOOLS_PATH = os.path.join(dirname(dirname(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'))
+# The earliest stored version of Dartium. Don't try to test earlier than this.
+EARLIEST_REVISION = 4285
 sys.path.append(TOOLS_PATH)
 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):
 
@@ skipping 298 matching lines @@
           self.revision_dict[platform][f][val] = []             
           self.values_dict[platform][f][val] = []               
         for extra_metric in extra_metrics:              
           self.revision_dict[platform][f][extra_metric] = []            
           self.values_dict[platform][f][extra_metric] = []
 
   def is_valid_combination(self, platform, variant):
     """Check whether data should be captured for this platform/variant
     combination.
     """
+    # TODO(vsm): This avoids a bug in 32-bit Chrome (dartium)
+    # running JS dromaeo.
+    if platform == 'dartium' and variant == 'js':
+      return False
+    if platform == 'safari' and variant == 'dart2js' and \

[sra1, 2012/08/18 02:59:02]

Preferred Python style is to use parentheses to make expression incomplete at
line end:

if (platform == 'safari' and variant == 'dart2js' and
    int(self.test_runner.current_revision_num) < 10193):

+        int(self.test_runner.current_revision_num) < 10193:
+      # In revision 10193 we fixed a bug that allows Safari 6 to run dart2js
+      # code. Since we can't change the Safari version on the machine, we're
+      # just not running
+      # for this case.
+      return False
     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(TOP_LEVEL_DIR)
@@ skipping 348 matching lines @@
         'browser',
         DromaeoTester.get_dromaeo_versions(), 
         DromaeoTester.get_dromaeo_benchmarks(), test_runner,
         self.DromaeoPerfTester(self),
         self.DromaeoFileProcessor(self))
 
   @staticmethod
   def name():
     return 'dromaeo'
 
-  def is_valid_combination(self, browser, version):
-    # TODO(vsm): This avoids a bug in 32-bit Chrome (dartium)
-    # running JS dromaeo.
-    if browser == 'dartium' and version == 'js':
-      return False
-    # dart:dom has been removed from Dartium.
-    if browser == 'dartium' and 'dom' in version:
-      return False
-    return True
-
-
   class DromaeoPerfTester(DromaeoTester):
     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).
       """
@@ skipping 26 matching lines @@
         if not os.path.exists(os.path.dirname(to_dir)):
           os.makedirs(os.path.dirname(to_dir))
         shutil.copyfile(from_dir, to_dir)
 
       for loc in path:
         if 'depot_tools' in loc:
           if browser == 'chrome':
             if os.path.exists(orig_chromedriver_path):
               move_chromedriver(loc)
           elif browser == 'dartium':
-            if not os.path.exists(dartium_chromedriver_path):
+            if self.test.test_runner.current_revision_num < 7823:
+              # 7823 is the first recorded version we have of a different
+              # chromedriver. If before that, just use the regular chromedriver.
+              self.test.test_runner.run_cmd(os.path.join(
+                  TOP_LEVEL_DIR, 'tools', 'testing', 'webdriver_test_setup.py'),
+                  '-f', '-s', '-p')
+            elif not os.path.exists(dartium_chromedriver_path):
               self.test.test_runner.get_archive('chromedriver')
             # Move original chromedriver for storage.
             if not os.path.exists(orig_chromedriver_path):
               move_chromedriver(loc, copy_to_depot_tools_dir=False)
-            # Copy Dartium chromedriver into depot_tools
-            move_chromedriver(loc, from_path=os.path.join(
-                              dartium_chromedriver_path, 'chromedriver'))
+            if self.test.test_runner.current_revision_num >= 7823:

[sra1, 2012/08/18 02:59:02]

Since you mention 7823 twice, make it a constant, or at least a local variable
that looks like a constant.

+              # Copy Dartium chromedriver into depot_tools
+              move_chromedriver(loc, from_path=os.path.join(
+                                dartium_chromedriver_path, 'chromedriver'))
       os.chdir(current_dir)
 
     def run_tests(self):
       """Run dromaeo in the browser."""
       
       self.test.test_runner.get_archive('dartium')
 
       # Build tests.
       dromaeo_path = os.path.join('samples', 'third_party', 'dromaeo')
       current_path = os.getcwd()
@@ skipping 181 matching lines @@
 
   if random.choice([True, False]):
     # Select a random CL number, with greater likelihood of selecting a CL in
     # the more recent history than the distant past (using a simplified weighted
     # bucket algorithm). If that CL has less than 10 runs, run additional. If it
     # already has 10 runs, look for another CL number that is not yet have all
     # of its additional runs (do this up to 15 times).
     tries = 0
     # Select which "thousands bucket" we're going to run additional tests for.
     bucket_size = 1000
-    thousands_list = range(1, int(revision_num)/bucket_size + 1)
+    thousands_list = range(EARLIEST_REVISION/bucket_size,
+                           int(revision_num)/bucket_size + 1)
     weighted_total = sum(thousands_list)
     generated_random_number = random.randint(0, weighted_total - 1)
     for i in list(reversed(thousands_list)):
       thousands = thousands_list[i - 1]
       weighted_total -= thousands_list[i - 1]
       if weighted_total <= generated_random_number:
         break
     while tries < 15 and not has_run_extra:
       # Now select a particular revision in that bucket.
       if thousands == int(revision_num)/bucket_size:
         max_range = 1 + revision_num % bucket_size
       else:
         max_range = bucket_size
       rev = thousands * bucket_size + random.randrange(0, max_range)
       if rev not in results_set:
         has_run_extra = try_to_run_additional(rev)
       tries += 1
 
   if not has_run_extra:
     # 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 2 at a time before checking to see if new code has been
     # checked in.
-    while revision_num > 0 and not has_run_extra:
+    while revision_num > EARLIEST_REVISION and not has_run_extra:
       if revision_num not in results_set:
         has_run_extra = try_to_run_additional(revision_num)
       revision_num -= 1
   if not has_run_extra:
     # No more extra back-runs to do (for now). Wait for new code.
     time.sleep(200)
   return results_set
 
 def main():
   runner = TestRunner()
@@ skipping 12 matching lines @@
       results_set = update_set_of_done_cls()
       if runner.has_interesting_code():
         runner.run_test_sequence()
       else:
         results_set = fill_in_back_history(results_set, runner)
   else:
     runner.run_test_sequence()
 
 if __name__ == '__main__':
   main()