Small adjustment to run smoketests on buildbots.

tools/testing/perf_testing/create_graph.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 math
 try:
   from matplotlib.font_manager import FontProperties
@@ skipping 62 matching lines @@
   RunCmd(cmd)
   return time.time() - start
 
 def SyncAndBuild(failed_once=False):
   """Make sure we have the latest version of of the repo, and build it. We
   begin and end standing in DART_INSTALL_LOCATION.
   Args:
     failed_once True if we have attempted to build this once before, and we've
       failed, indicating the build is broken."""
   os.chdir(DART_INSTALL_LOCATION)
-  #Revert our newly built frogsh to prevent conflicts when we update
-  RunCmd(['svn', 'revert',  os.path.join(os.getcwd(), 'frog', 'frogsh')])
+  #Revert our newly built minfrog to prevent conflicts when we update
+  RunCmd(['svn', 'revert',  os.path.join(os.getcwd(), 'frog', 'minfrog')])
 
   RunCmd(['gclient', 'sync'])
   lines = RunCmd([os.path.join('.', 'tools', 'build.py'), '-m', 'release'])
   os.chdir('frog')
   lines += RunCmd([os.path.join('..', 'tools', 'build.py'), '-m', 
       'debug,release'])
   os.chdir('..')
   
   for line in lines:
     if 'BUILD FAILED' in lines:
@@ skipping 200 matching lines @@
     os.chdir(DART_INSTALL_LOCATION)
     EnsureOutputDirectory(self.result_folder_name)
     EnsureOutputDirectory(GRAPH_OUT_DIR)
     self.RunTests()
     os.chdir(os.path.join('tools', 'testing', 'perf_testing'))
     
     # TODO(efortuna): You will want to make this only use a subset of the files
     # eventually.
     files = os.listdir(self.result_folder_name)
 
+    for afile in files:
+      if not afile.startswith('.'):
+        self.ProcessFile(afile)
+
     if PERFBOT_MODE:
-      for afile in files:
-        if not afile.startswith('.'):
-          self.ProcessFile(afile)
-
       self.PlotResults('%s.png' % self.result_folder_name)
     self.Cleanup();
 
 class PerformanceTestRunner(TestRunner):
   """Super class for all performance testing."""
   def __init__(self, result_folder_name, platform_list, platform_type):
     super(PerformanceTestRunner, self).__init__(result_folder_name, 
         platform_list, GetVersions(), BENCHMARKS)
     self.platform_list = platform_list
     self.platform_type = platform_type
@@ skipping 115 matching lines @@
     line = ''
     i = 0
     revision_num = 0
     while '<div id="results">' not in line and i < len(lines):
       if 'Revision' in line:
         revision_num = int(line.split()[1])
       line = lines[i]
       i += 1
 
     if i >= len(lines) or revision_num == 0:
-      # Then this run did not complete. Ignore this tracefile.
+      # Then this run did not complete. Ignore this tracefile. or in the case of
+      # the smoke test, report an error.
+      if not PERFBOT_MODE:
+        print 'FAIL %s %s' % (browser, version)
+        os.remove(os.path.join(self.result_folder_name, afile))
       return
 
     line = lines[i]
     i += 1
     results = []
     if line.find('<br>') > -1:
       results = line.split('<br>')
     else:
       results = line.split('<br />')
     for result in results:
       name_and_score = result.split(':')
       if len(name_and_score) < 2: 
         break
       name = name_and_score[0].strip()
       score = name_and_score[1].strip()
       if version == V8:
         bench_dict = self.values_dict[browser][V8]
       else:
         bench_dict = self.values_dict[browser][FROG]
       bench_dict[name] += [float(score)]
       self.revision_dict[browser][version][name] += [revision_num]
 
     f.close()
-    self.CalculateGeometricMean(browser, version, revision_num)
+    if not PERFBOT_MODE:
+      print 'PASS'
+      os.remove(os.path.join(self.result_folder_name, afile))
+    else:
+      self.CalculateGeometricMean(browser, version, revision_num)
 
   def WriteHtml(self, delimiter, rev_nums, label_1, dict_1, label_2, dict_2, 
       cleanFile=False):
       #TODO(efortuna)
       pass
 
       
-  def Cleanup():
+  def Cleanup(self):
     # Kill the zombie chromedriver processes.
     RunCmd(['killall', 'chromedriver'])
 
 
 class BrowserCorrectnessTestRunner(TestRunner):
   def __init__(self, test_type, result_folder_name):
     super(BrowserCorrectnessTestRunner, self).__init__(result_folder_name,
         GetBrowsers(), [FROG], [CORRECTNESS])
     self.test_type = test_type
 
@@ skipping 42 matching lines @@
     f.close()
 
   def PlotResults(self, png_filename):
     first_time = True
     for browser in GetBrowsers():
       self.StyleAndSavePerfPlot('Percentage of language tests passing in '
           'different browsers', '% of tests passed', 8, 8, 'lower left', 
           png_filename, [browser], [FROG], [CORRECTNESS], first_time) 
       first_time = False
 
-  def Cleanup():
+  def Cleanup(self):
     # Kill the zombie chromedriver processes.
     RunCmd(['killall', 'chromedriver'])
 
 class CompileTimeAndSizeTestRunner(TestRunner):
-  """Run tests to determine how long frogsh takes to compile, and the compiled 
+  """Run tests to determine how long minfrog takes to compile, and the compiled 
   file output size of some benchmarking files."""
   def __init__(self, result_folder_name):
     super(CompileTimeAndSizeTestRunner, self).__init__(result_folder_name,
         [COMMAND_LINE], [FROG], ['Compiling on Dart VM', 'Bootstrapping',
-        'frogsh', 'swarm', 'total'])
+        'minfrog', 'swarm', 'total'])
     self.failure_threshold = {'Compiling on Dart VM' : 1, 'Bootstrapping' : .5, 
-        'frogsh' : 100, 'swarm' : 100, 'total' : 100}
+        'minfrog' : 100, 'swarm' : 100, 'total' : 100}
 
   def RunTests(self):
     os.chdir('frog')
     self.trace_file = os.path.join('..', 'tools', 'testing', 'perf_testing', 
         self.result_folder_name, self.result_folder_name + self.cur_time)
     
     self.AddSvnRevisionToTrace(self.trace_file)    
 
-    elapsed = TimeCmd([os.path.join('.', 'frog.py'),
-        '--vm_flags="--compile_all --enable_type_checks --enable_asserts"', 
-        '--', '--compile_all', '--enable_type_checks', '--out=frogsh', 
-        'frog.dart'])
-    RunCmd(['echo', '%f Compiling on Dart VM in checked mode in seconds' 
+    elapsed = TimeCmd([os.path.join('.', 'frog.py'), '--',
+        '--out=minfrog', 'minfrog.dart'])
+    RunCmd(['echo', '%f Compiling on Dart VM in production mode in seconds' 
         % elapsed], self.trace_file, append=True)
-    elapsed = TimeCmd([os.path.join('.', 'frogsh'), '--out=frogsh',
-        '--enable_type_checks', 'frog.dart', '--enable_type_checks', 
-        os.path.join('tests', 'hello.dart')])
+    elapsed = TimeCmd([os.path.join('.', 'minfrog'), '--out=minfrog',
+        '--warnings_as_errors', 'minfrog.dart', os.path.join('tests', 
+        'hello.dart')])
     if elapsed < self.failure_threshold['Bootstrapping']:
-      #frogsh didn't compile correctly. Stop testing now, because subsequent
+      #minfrog didn't compile correctly. Stop testing now, because subsequent
       #numbers will be meaningless.
       return
-    size = os.path.getsize('frogsh')
-    RunCmd(['echo', '%f Bootstrapping time in seconds in checked mode' % 
+    size = os.path.getsize('minfrog')
+    RunCmd(['echo', '%f Bootstrapping time in seconds in production mode' % 
         elapsed], self.trace_file, append=True)
-    RunCmd(['echo', '%d Generated checked frogsh size' % size],
+    RunCmd(['echo', '%d Generated checked minfrog size' % size],
         self.trace_file, append=True)
 
-    RunCmd([os.path.join('.', 'frogsh'), ' --out=swarm-result ',
+    RunCmd([os.path.join('.', 'minfrog'), ' --out=swarm-result ',
         '--compile-only', os.path.join('..', 'client', '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.
 
-    RunCmd([os.path.join('.', 'frogsh'), '--out=total-result',
+    RunCmd([os.path.join('.', 'minfrog'), '--out=total-result',
         '--compile-only', os.path.join('..', 'client', 'samples', 'total',
         'src', 'Total.dart')])
     total_size = 0
     try:
       total_size = os.path.getsize('total-result')
     except OSError:
       pass #If compilation failed, continue on running other tests.
 
     RunCmd(['echo', '%d Generated checked swarm size' % swarm_size], 
         self.trace_file, append=True) 
@@ skipping 30 matching lines @@
         self.revision_dict[COMMAND_LINE][FROG][metric] += [revision_num]
         # Fill 0 if compilation failed.
         if self.values_dict[COMMAND_LINE][FROG][metric][-1] < \
             self.failure_threshold[metric]:
           self.values_dict[COMMAND_LINE][FROG][metric] += [0]
           self.revision_dict[COMMAND_LINE][FROG][metric] += [revision_num]
 
     f.close()
 
   def PlotResults(self, png_filename):
-    self.StyleAndSavePerfPlot('Compiled frogsh Sizes', 
+    self.StyleAndSavePerfPlot('Compiled minfrog Sizes', 
         'Size (in bytes)', 10, 10, 'center', png_filename, [COMMAND_LINE],
-        [FROG], ['swarm', 'total', 'frogsh'])
-    self.WriteHtml('bar', self.revision_dict[COMMAND_LINE][FROG]['frogsh'], 
-        'frogsh size', self.values_dict[COMMAND_LINE][FROG]['frogsh'], '', [])
+        [FROG], ['swarm', 'total', 'minfrog'])
+    self.WriteHtml('bar', self.revision_dict[COMMAND_LINE][FROG]['minfrog'], 
+        'minfrog size', self.values_dict[COMMAND_LINE][FROG]['minfrog'], '', [])
 
     self.StyleAndSavePerfPlot('Time to compile and bootstrap', 
         'Seconds', 10, 10, 'center', '2' + png_filename, [COMMAND_LINE], [FROG],
         ['Bootstrapping', 'Compiling on Dart VM'])
     self.WriteHtml('baz',
         self.revision_dict[COMMAND_LINE][FROG]['Bootstrapping'], 
         'Bootstrapping', self.values_dict[COMMAND_LINE][FROG]['Bootstrapping'],
         'Compiling on Dart VM', 
         self.values_dict[COMMAND_LINE][FROG]['Compiling on Dart VM'])
 
@@ skipping 51 matching lines @@
       if HasNewCode():
         RunTestSequence(cl, size, language, perf)
       else:
         time.sleep(SLEEP_TIME)
   else:
     RunTestSequence(cl, size, language, perf)
 
 if __name__ == '__main__':
   main()