Dump data for stacked graphs in Chrome Endure.

chrome/test/functional/perf.py

 #!/usr/bin/env python
 # Copyright (c) 2012 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 """Basic pyauto performance tests.
 
 For tests that need to be run for multiple iterations (e.g., so that average
 and standard deviation values can be reported), the default number of iterations
 run for each of these tests is specified by |_DEFAULT_NUM_ITERATIONS|.
@@ skipping 238 matching lines @@
       times, in milliseconds as a float.
     """
     assert callable(python_command)
     def RunCommand():
       for _ in range(num_invocations):
         python_command()
     timer = timeit.Timer(stmt=RunCommand)
     return timer.timeit(number=1) * 1000  # Convert seconds to milliseconds.
 
   def _OutputPerfForStandaloneGraphing(self, graph_name, description, value,
-                                       units, units_x):
+                                       units, units_x, is_stacked):
     """Outputs perf measurement data to a local folder to be graphed.
 
     This function only applies to Chrome desktop, and assumes that environment
     variable 'LOCAL_PERF_DIR' has been specified and refers to a valid directory
     on the local machine.
 
     Args:
       graph_name: A string name for the graph associated with this performance
           value.
       description: A string description of the performance value.  Should not
           include spaces.
       value: Either a single numeric value representing a performance
           measurement, or else a list of (x, y) tuples representing one or more
           long-running performance measurements, where 'x' is an x-axis value
           (such as an iteration number) and 'y' is the corresponding performance
           measurement.  If a list of tuples is given, then the |units_x|
           argument must also be specified.
       units: A string representing the units of the performance measurement(s).
           Should not include spaces.
       units_x: A string representing the units of the x-axis values associated
           with the performance measurements, such as 'iteration' if the x values
           are iteration numbers.  If this argument is specified, then the
           |value| argument must be a list of (x, y) tuples.
+      is_stacked: True to draw a "stacked" graph.  First-come values are
+          stacked at bottom by default.
     """
     revision_num_file = os.path.join(self._local_perf_dir, 'last_revision.dat')
     if os.path.exists(revision_num_file):
       with open(revision_num_file) as f:
         revision = int(f.read())
     else:
       revision = 0
 
     if not self._seen_graph_lines:
       # We're about to output data for a new test run.
@@ skipping 47 matching lines @@
         if not description in new_line['traces']:
           new_line['traces'][description] = []
       for x_value, y_value in value:
         new_line['traces'][description].append([str(x_value), str(y_value)])
     else:
       new_line = {
         'rev': revision,
         'traces': { description: [str(value), str(0.0)] }
       }
 
+    if is_stacked:
+      new_line['stack'] = True
+      if 'stack_order' not in new_line:
+        new_line['stack_order'] = []
+      if description not in new_line['stack_order']:
+        new_line['stack_order'].append(description)
+
     if seen_key in self._seen_graph_lines:
       # Update results for the most recent revision.
       existing_lines[0] = new_line
     else:
       # New results for a new revision.
       existing_lines.insert(0, new_line)
       self._seen_graph_lines[seen_key] = True
 
     existing_lines = map(simplejson.dumps, existing_lines)
     with open(data_file, 'w') as f:
       f.write('\n'.join(existing_lines))
     os.chmod(data_file, 0755)
 
     with open(revision_num_file, 'w') as f:
       f.write(str(revision))
 
   def _OutputPerfGraphValue(self, description, value, units,
-                            graph_name, units_x=None):
+                            graph_name, units_x=None, is_stacked=False):
     """Outputs a performance value to have it graphed on the performance bots.
 
     The output format differs, depending on whether the current platform is
     Chrome desktop or ChromeOS.
 
     For ChromeOS, the performance bots have a 30-character limit on the length
     of the key associated with a performance value.  A key on ChromeOS is
     considered to be of the form "units_description" (for example,
     "milliseconds_NewTabPage"), and is created from the |units| and
     |description| passed as input to this function.  Any characters beyond the
@@ skipping 10 matching lines @@
           corresponding performance measurement.  If a list of tuples is given,
           the |units_x| argument must also be specified.
       units: A string representing the units of the performance measurement(s).
           Should not include spaces.
       graph_name: A string name for the graph associated with this performance
           value.  Only used on Chrome desktop.
       units_x: A string representing the units of the x-axis values associated
           with the performance measurements, such as 'iteration' if the x values
           are iteration numbers.  If this argument is specified, then the
           |value| argument must be a list of (x, y) tuples.
+      is_stacked: True to draw a "stacked" graph.  First-come values are
+          stacked at bottom by default.
     """
     if (isinstance(value, list) and value[0] is not None and
         isinstance(value[0], tuple)):
       assert units_x
     if units_x:
       assert isinstance(value, list)
 
     if self.IsChromeOS():
       # ChromeOS results don't support lists.
       if (isinstance(value, list) and value[0] is not None and
@@ skipping 11 matching lines @@
         perf_key = '%s_%s' % (units, description)
         if len(perf_key) > 30:
           logging.warning('The description "%s" will be truncated to "%s" '
                           '(length 30) when added to the autotest database.',
                           perf_key, perf_key[:30])
         print '\n%s(\'%s\', %f)%s' % (self._PERF_OUTPUT_MARKER_PRE,
                                         perf_key, value,
                                         self._PERF_OUTPUT_MARKER_POST)
         sys.stdout.flush()
     else:
+      # TODO(dmikurube): Support stacked graphs in PrintPerfResult.
+      # See http://crbug.com/122119.
       if units_x:
         pyauto_utils.PrintPerfResult(graph_name, description, value,
                                      units + ' ' + units_x)
       else:
         pyauto_utils.PrintPerfResult(graph_name, description, value, units)
 
       if self._local_perf_dir:
         self._OutputPerfForStandaloneGraphing(
-            graph_name, description, value, units, units_x)
+            graph_name, description, value, units, units_x, is_stacked)
 
   def _OutputEventForStandaloneGraphing(self, description, event_list):
     """Outputs event information to a local folder to be graphed.
 
     See function _OutputEventGraphValue below for a description of an event.
 
     This function only applies to Chrome Endure tests running on Chrome desktop,
     and assumes that environment variable 'LOCAL_PERF_DIR' has been specified
     and refers to a valid directory on the local machine.
 
@@ skipping 2206 matching lines @@
     """Identifies the port number to which the server is currently bound.
 
     Returns:
       The numeric port number to which the server is currently bound.
     """
     return self._server.server_address[1]
 
 
 if __name__ == '__main__':
   pyauto_functional.Main()