Add Dartium to browser_perf tests

tools/testing/perf_testing/run_perf_tests.py

 #!/usr/bin/python
 
 # Copyright (c) 2011, 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 getpass
 import math
 try:
@@ skipping 366 matching lines @@
   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):
+  def add_svn_revision_to_trace(self, outfile, browser = None):
     """Add the svn version number to the provided tracefile."""
     def search_for_revision(svn_info_command):
       p = subprocess.Popen(svn_info_command, stdout = subprocess.PIPE,
                            stderr = subprocess.STDOUT, shell =
                            self.test.test_runner.has_shell)
       output, _ = p.communicate()
       for line in output.split('\n'):
         if 'Revision' in line:
           self.test.test_runner.run_cmd(['echo', line.strip()], outfile)
           return True
       return False
 
-    if not search_for_revision(['svn', 'info']):
+    def get_dartium_revision():
+      version_file_name = os.path.join(DART_INSTALL_LOCATION, '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)

[Emily Fortuna, 2012/04/16 19:22:15]

Do you want to print out a slightly different output here to distinguish between
dartium revisions and our repo revisions?

+    elif not search_for_revision(['svn', 'info']):
       if not search_for_revision(['git', 'svn', 'info']):
         self.test.test_runner.run_cmd(['echo', 'Revision: unknown'], outfile)
 
 
 class Processor(object):
   """The base level vistor class that processes tests. It contains convenience 
   methods that many File Processor objects use. Any class that would like to be
   a ProcessorVisitor must implement the process_file() method."""
 
   def __init__(self, test):
     self.test = test
 
   def prepare(self):
     """Perform any initial setup required before the test is run."""
     pass
 
   def calculate_geometric_mean(self, platform, variant, svn_revision):
     """Calculate the aggregate geometric mean for JS and frog benchmark sets,
     given two benchmark dictionaries."""
     geo_mean = 0
     for benchmark in self.test.values_list:
-      geo_mean += math.log(self.test.values_dict[platform][variant][benchmark][
-          len(self.test.values_dict[platform][variant][benchmark]) - 1])
+      try:
+        geo_mean += math.log(self.test.values_dict[platform][variant][benchmark][

[Emily Fortuna, 2012/04/16 19:22:15]

Also, why add the try/pass? If you're getting an error, that's indicative that
we're not processing the files correctly. I did notice -- in my "FileProcessor"
objects, I deal with error handling -- if the trace is incomplete, but I have
some data, I fill in the remaining ones with 0 (or whatever is appropriate). You
may want to add similar failure resistance in the Dromaeo FileProcessors.

[vsm, 2012/04/16 20:41:08]

Ahh, I meant to clean this up.  Because we're skipping the platform=dartium,
variant=js combo, this fails.

I can keep track of valid combo and check here.  WDYT?

On 2012/04/16 19:22:15, Emily Fortuna wrote:

[Emily Fortuna, 2012/04/16 20:50:17]

That can work.

[vsm, 2012/04/16 22:02:58]

Done. PTAL.

On 2012/04/16 20:50:17, Emily Fortuna wrote:

+            len(self.test.values_dict[platform][variant][benchmark]) - 1])
+      except IndexError:
+        pass
 
     self.test.values_dict[platform][variant]['Geo-Mean'] += \
         [math.pow(math.e, geo_mean / len(self.test.values_list))]
     self.test.revision_dict[platform][variant]['Geo-Mean'] += [svn_revision]
 
 
 class Grapher(object):
   """The base level visitor class that generates graphs for data. It contains 
   convenience methods that many Grapher objects use. Any class that would like
   to be a GrapherVisitor must implement the plot_results() method."""
@@ skipping 213 matching lines @@
               [revision_num]
           self.test.values_dict['commandline']['frog'][benchmark] += \
               [frog_value]
       f.close()
 
       self.calculate_geometric_mean('commandline', 'frog', revision_num)
       self.calculate_geometric_mean('commandline', 'js', revision_num)
 
 
 class BrowserTester(Tester):
-  # TODO(vsm): Add Dartium.
   @staticmethod
   def get_browsers():
-    browsers = ['ff', 'chrome']
+    browsers = ['dartium', 'ff', 'chrome']
+    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_drt.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.Popen(get_dartium, shell=has_shell)
     return browsers
 
 
 class CommonBrowserTest(RuntimePerformanceTest):
   """Runs this basic performance tests (Benchpress, some V8 benchmarks) in the
   browser."""
 
   def __init__(self, test_runner):
     """Args:
       test_runner: Reference to the object that notifies us when to run."""
@@ skipping 21 matching lines @@
       os.chdir('frog')
       self.test.test_runner.run_cmd(['python', os.path.join('benchmarks', 
                                      'make_web_benchmarks.py')])
       os.chdir('..')
 
       for browser in BrowserTester.get_browsers():
         for version in self.test.versions:
           self.test.trace_file = os.path.join(
               '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)
+          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):
@@ skipping 135 matching lines @@
       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_frog_tests.py'])
       os.chdir(current_path)
 
       versions = DromaeoTester.get_dromaeo_versions()
 
       for browser in BrowserTester.get_browsers():
         for version_name in versions:
+          if browser == 'dartium' and version_name == 'js':
+            # TODO(vsm): This avoids a bug in 32-bit Chrome (dartium)
+            # running JS dromaeo.
+            continue
           version = DromaeoTest.DromaeoPerfTester.get_dromaeo_url_query(
-              version_name)
+              browser, version_name)
           self.test.trace_file = os.path.join(
               '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)
+          self.add_svn_revision_to_trace(self.test.trace_file, browser)
           file_path = os.path.join(os.getcwd(), dromaeo_path,
               'index-js.html?%s' % version)
           self.test.test_runner.run_cmd(
               ['python', os.path.join('tools', 'testing', 'run_selenium.py'),
                '--out', file_path, '--browser', browser,
                '--timeout', '600', '--mode', 'dromaeo'], self.test.trace_file,
                append=True)
 
     @staticmethod
-    def get_dromaeo_url_query(version):
+    def get_dromaeo_url_query(browser, version):
+      if browser == 'dartium':
+        version = version.replace('frog', 'dart')
       version = version.replace('_','&')
       tags = DromaeoTester.get_valid_dromaeo_tags()
       return '|'.join([ '%s&%s' % (version, tag) for tag in tags])
 
 
   class DromaeoFileProcessor(Processor):
     def process_file(self, afile):
       """Comb through the html to find the performance results."""
       parts = afile.split('-')
       browser = parts[2]
@@ skipping 331 matching lines @@
     while True:
       if runner.has_new_code():
         runner.run_test_sequence()
       else:
         time.sleep(200)
   else:
     runner.run_test_sequence()
 
 if __name__ == '__main__':
   main()