Fix typo and build v8.

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
 from matplotlib.font_manager import FontProperties
@@ skipping 117 matching lines @@
   # google.com/storage/?arg=dart-dump-render-tree#dart-dump-render-tree%2Fsdk
   # eventually.
   # 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 = run_cmd([os.path.join('.', 'tools', 'build.py'), '-m', 'release',
       '--arch=ia32', 'create_sdk'])
+  lines = run_cmd([os.path.join('.', 'tools', 'build.py'), '-m', 'release',
+      '--arch=ia32', 'dart2js']) #Built only for the v8 target for CL tests.
 
   for line in lines:
     if 'BUILD FAILED' in lines:
       # Someone checked in a broken build! Just stop trying to make it work
       # and wait to try again.
       print 'Broken Build'
       return 1
   return 0
 
 def ensure_output_directory(dir_name):
@@ skipping 36 matching lines @@
 def get_os_directory():
   """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 upload_to_app_engine(username, password, suite_names):
+def upload_to_app_engine(suite_names):
   """Upload our results to our appengine server.
   Arguments:
-    username: App Engine username for uploading data to dartperf.googleplex.com
-    password: App Engine password
     suite_names: Directories to upload data from (should match suite names)
   """
   # TODO(efortuna): This is the most basic way to get the data up
   # for others to view. Revisit this once we're serving nicer graphs (Google
   # Chart Tools) and from multiple perfbots and once we're in a position to
   # organize the data in a useful manner(!!).
   os.chdir(os.path.join(DART_INSTALL_LOCATION, 'tools', 'testing',
       'perf_testing'))
   for data in suite_names:
     path = os.path.join('appengine', 'static', 'data', data, utils.GuessOS())
@@ skipping 24 matching lines @@
   shutil.rmtree(os.path.join('appengine', 'static', 'graphs'),
       ignore_errors=True)
   shutil.copytree('graphs', os.path.join('appengine', 'static', 'graphs'))
   shutil.copyfile('index.html', os.path.join('appengine', 'static',
       'index.html'))
   shutil.copyfile('dromaeo.html', os.path.join('appengine', 'static',
       'dromaeo.html'))
   shutil.copyfile('data.html', os.path.join('appengine', 'static',
       'data.html'))
   p = subprocess.Popen([os.path.join('..', '..', '..', 'third_party',
-      'appengine-python', 'appcfg.py'), 'update',
+      'appengine-python', 'appcfg.py'), '--oauth2', 'update',
       'appengine/'], shell=HAS_SHELL, stdin=subprocess.PIPE)
-  p.stdin.write(username + '\n')
-  p.stdin.write(password + '\n')
   p.communicate()
 
 
 class TestRunner(object):
   """The base class to provide shared code for different tests we will run and
   graph."""
 
   def __init__(self, result_folder_name, platform_list, variants,
                values_list):
     """Args:
@@ skipping 285 matching lines @@
       else:
         bench_dict = self.values_dict[browser][FROG]
       bench_dict[name] += [float(score)]
       self.revision_dict[browser][version][name] += [revision_num]
 
     f.close()
     self.calculate_geometric_mean(browser, version, revision_num)
 
 
 # TODO(vsm): This should not be hardcoded here if possible.
+DROMAEO_BENCHMARKS = {
+    'attr': ('attributes', [
+        'getAttribute',
+        'element.property',
+        'setAttribute',
+        'element.property = value']),
+    'modify': ('modify', [
+        'createElement',
+        'createTextNode',
+        'innerHTML',
+        'cloneNode',
+        'appendChild',
+        'insertBefore']),
+    'query': ('query', [
+        'getElementById',
+        'getElementById (not in document)',
+        'getElementsByTagName(div)',
+        'getElementsByTagName(p)',
+        'getElementsByTagName(a)',
+        'getElementsByTagName(*)',
+        'getElementsByTagName (not in document)',
+        'getElementsByName',
+        'getElementsByName (not in document)']),
+    'traverse': ('traverse', [
+        'firstChild',
+        'lastChild',
+        'nextSibling',
+        'previousSibling',
+        'childNodes'])
+}
+
+# TODO(vsm): This is a hack to skip breaking tests.  Triage this
+# failure properly.  The modify suite fails on 32-bit chrome on
+# the mac.
+def get_valid_dromaeo_tags():
+  tags = [tag for (tag, _) in DROMAEO_BENCHMARKS.values()]
+  if platform.system() == 'Darwin':
+    tags.remove('modify')
+  return tags
+
 def get_dromaeo_benchmarks():
-  return map(lambda str: str.replace(' ', '_'),
-    ['getAttribute', 'element.property', 'setAttribute',
-     'element.property = value', 'createElement', 'createTextNode',
-     'innerHTML', 'cloneNode', 'appendChild', 'insertBefore',
-     'getElementById', 'getElementById (not in document)',
-     'getElementsByTagName(div)', 'getElementsByTagName(p)',
-     'getElementsByTagName(a)', 'getElementsByTagName(*)',
-     'getElementsByTagName (not in document)', 'getElementsByName',
-     'getElementsByName (not in document)', 'firstChild', 'lastChild',
-     'nextSibling', 'previousSibling', 'childNodes'])
-
+  valid = get_valid_dromaeo_tags()
+  benchmarks = reduce(lambda l1,l2: l1+l2,
+                      [tests for (tag, tests) in
+                       DROMAEO_BENCHMARKS.values() if tag in valid])
+  return map(lambda str: str.replace(' ', '_'), benchmarks)
 
 def get_dromaeo_versions():
   return ['js', 'frog_dom', 'frog_html']
 
+def get_dromaeo_url_query(version):
+  version = version.replace('_','&')
+  tags = get_valid_dromaeo_tags()
+  return '|'.join([ '%s&%s' % (version, tag) for tag in tags])
+
 class DromaeoTest(PerformanceTest):
   """Runs Dromaeo tests, in the browser."""
   def __init__(self):
     super(DromaeoTest, self).__init__(
         DROMAEO, get_browsers(), 'browser',
         get_dromaeo_versions(), get_dromaeo_benchmarks())
 
   def run_tests(self):
     """Run dromaeo in the browser."""
 
     # Build tests.
     dromaeo_path = os.path.join('samples', 'third_party', 'dromaeo')
     current_path = os.getcwd()
     os.chdir(dromaeo_path)
     run_cmd(['python', 'generate_frog_tests.py'])
     os.chdir(current_path)
 
     versions = get_dromaeo_versions()
 
     for browser in get_browsers():
       for version_name in versions:
-        version = version_name.replace('_','&')
+        version = get_dromaeo_url_query(version_name)
         self.trace_file = os.path.join('tools', 'testing', 'perf_testing',
             self.result_folder_name,
             'dromaeo-%s-%s-%s' % (self.cur_time, browser, version_name))
         self.add_svn_revision_to_trace(self.trace_file)
         file_path = os.path.join(os.getcwd(), dromaeo_path,
             'index-js.html?%s' % version)
         run_cmd(['python', os.path.join('tools', 'testing', 'run_selenium.py'),
                  '--out', file_path, '--browser', browser,
                  '--timeout', '200', '--mode', 'dromaeo'], self.trace_file,
                 append=True)
@@ skipping 27 matching lines @@
           if results:
             for result in results:
               r = re.match(result_pattern, result)
               name = r.group(1).strip(':').replace(' ', '_')
               score = float(r.group(2))
               bench_dict[name] += [float(score)]
               self.revision_dict[browser][version][name] += [revision_num]
 
     f.close()
     self.calculate_geometric_mean(browser, version, revision_num)
-
+  

[vsm, 2012/04/06 03:53:42]

Extraneous whitespace?

 
 class DromaeoSizeTest(TestRunner):
   """Run tests to determine the compiled file output size of Dromaeo."""
   def __init__(self):
     super(DromaeoSizeTest, self).__init__(
         DROMAEO_SIZE,
         ['browser'], ['dart', 'frog_dom', 'frog_html', 'frog_htmlidiomatic'],
-        ['attr', 'modify', 'query', 'traverse'])
+        DROMAEO_BENCHMARKS.keys())
 
   def run_tests(self):
     # Build tests.
     dromaeo_path = os.path.join('samples', 'third_party', 'dromaeo')
     current_path = os.getcwd()
     os.chdir(dromaeo_path)
     run_cmd(['python', os.path.join('generate_frog_tests.py')])
     os.chdir(current_path)
 
     self.trace_file = os.path.join('tools', 'testing', 'perf_testing',
         self.result_folder_name, self.result_folder_name + self.cur_time)
     self.add_svn_revision_to_trace(self.trace_file)
 
     variants = [
         ('frog_dom', ''),
         ('frog_html', '-html'),
         ('frog_htmlidiomatic', '-htmlidiomatic')]
 
     test_path = os.path.join(dromaeo_path, 'tests')
     frog_path = os.path.join(test_path, 'frog')
     total_size = {}
     for (variant, _) in variants:
       total_size[variant] = 0
     total_dart_size = 0
-    for suite in ['attr', 'modify', 'query', 'traverse']:
+    for suite in DROMAEO_BENCHMARKS.keys():
       dart_size = 0
       try:
         dart_size = os.path.getsize(os.path.join(test_path,
                                                  'dom-%s.dart' % suite))
       except OSError:
         pass #If compilation failed, continue on running other tests.
 
       total_dart_size += dart_size
       run_cmd(['echo', 'Size (dart, %s): %s' % (suite, str(dart_size))],
               self.trace_file, append=True)
@@ skipping 53 matching lines @@
         self.values_dict['browser'][variant][metric] += [num]
         self.revision_dict['browser'][variant][metric] += [revision_num]
 
     f.close()
 
   def plot_results(self, png_filename):
     self.style_and_save_perf_plot(
         'Compiled Dromaeo Sizes',
         'Size (in bytes)', 10, 10, 'lower left', png_filename,
         ['browser'], ['dart', 'frog_dom', 'frog_html', 'frog_htmlidiomatic'],
-        ['attr', 'modify', 'query', 'traverse'])
+        DROMAEO_BENCHMARKS.keys())
 
     self.style_and_save_perf_plot(
         'Compiled Dromaeo Sizes',
         'Size (in bytes)', 10, 10, 'lower left', '2' + png_filename,
         ['browser'], ['dart', 'frog_dom', 'frog_html', 'frog_htmlidiomatic'],
         [GEO_MEAN])
 
 
 
 class CompileTimeAndSizeTest(TestRunner):
@@ skipping 113 matching lines @@
 def parse_args():
   parser = optparse.OptionParser()
   # TODO(vsm): Change to a list to scale.
   parser.add_option('--suites', '-s', dest='suites',
       help='Run the specified comma-separated test suites from set: %s' % \
                       ','.join(SUITES.keys()),
       action='store', default=None)
   parser.add_option('--forever', '-f', dest='continuous',
       help='Run this script forever, always checking for the next svn '
       'checkin', action='store_true', default=False)
+  parser.add_option('--graph-only', '-g', dest='graph_only', default=False,
+      help='Do not run tests, only regenerate graphs', action='store_true')
+  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('--upload', '-u', dest='upload',
+      help='Upload data to app engine (will require authentication).', 
+      action='store_true', default=False)
   parser.add_option('--verbose', '-v', dest='verbose',
       help='Print extra debug output', 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('--graph-only', '-g', dest='graph_only', default=False,
-      help='Do not run tests, only regenerate graphs', action='store_true')
-  parser.add_option('--user', '-u', dest='username',
-      help='Username for submitting new data to App Engine', default='')
 
   args, ignored = parser.parse_args()
-  password = ''
-  if args.username != '':
-    password = getpass.getpass("App Engine Password: ")
-  else:
-    print 'Warning: performance data will not be uploaded to App Engine' + \
-        ' if you do not provide a username.'
 
   if not args.suites:
     suites = SUITES.values()
   else:
     suites = []
     suitelist = args.suites.split(',')
     for name in suitelist:
       if name in SUITES:
         suites.append(SUITES[name])
       else:
         print 'Error: Invalid suite %s not in %s' % (name,
                                                      ','.join(SUITES.keys()))
         sys.exit(1)
   return (suites, args.continuous, args.verbose, args.no_build,
-          args.graph_only, args.username, password)
+          args.graph_only, args.upload)
 
-def run_test_sequence(suites, no_build, graph_only,
-                      username, password):
+def run_test_sequence(suites, no_build, graph_only, upload):
   # The buildbot already builds and syncs to a specific revision. Don't fight
   # with it or replicate work.
   if (not no_build or not graph_only) and sync_and_build() == 1:
     return # The build is broken.
 
   for test in suites:
     test().run(graph_only)
 
-  if username != '':
-    upload_to_app_engine(username, password, SUITES.keys())
+  if upload:
+    upload_to_app_engine(SUITES.keys())
 
 def main():
   global VERBOSE
-  (suites, continuous, verbose, no_build, graph_only,
-   username, password) = parse_args()
+  (suites, continuous, verbose, no_build, graph_only, upload) = parse_args()
   VERBOSE = verbose
   if continuous:
     while True:
       if has_new_code():
-        run_test_sequence(suites, no_build, graph_only,
-                          username, password)
+        run_test_sequence(suites, no_build, graph_only, upload)
       else:
         time.sleep(SLEEP_TIME)
   else:
-    run_test_sequence(suites, no_build, graph_only,
-                      username, password)
+    run_test_sequence(suites, no_build, graph_only, upload)
 
 if __name__ == '__main__':
   main()