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 46 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['stacked'] = True
+      if 'default_stacking_order' not in new_line:

[dennis_jeffrey, 2012/09/05 17:34:12]

should we change the name to something shorter like "stack_order"?  We'll just
assume that's the default and can be overridden elsewhere if needed.

[Dai Mikurube (NOT FULLTIME), 2012/09/06 05:30:10]

Renamed:
'stacked' => 'stack'
'default_stacking_order' => 'stack_order'

+        new_line['default_stacking_order'] = []
+      if description not in new_line['default_stacking_order']:
+        new_line['default_stacking_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(str, 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,

[dennis_jeffrey, 2012/09/05 17:34:12]

Note: there are actually 2 ways in which perf results are outputted in this
file:

1) By calling pyauto_utils.PrintPerfResult.  This prints the results to stdout
using a specially-formatted output line.  These output lines are what are parsed
in the live Chrome Endure bots running on the chromium.pyauto waterfall, and
those results get written into text files that are displayed by the live chrome
endure graphs.

2) By calling self._OutputPerfForStandaloneGraphing.  These results are directly
written to text data files to be displayed on local perf graphs only (not on the
live Chrome Endure graphs).

Currently, the changes in this file handle (2) but not (1).  We'll need to also
figure out how best to modify the format of the specially-formatted output lines
to output information about graphs that should be stacked.  Note also that the
code that actually parses these stdout lines and creates the data files for the
live Chrome Endure graphs is also not checked in yet, but that will have to be
modified along with the changes here to get the stacked graphs to work on the
live graphs.  So, I will work on checking in that other code that parses the
stdout of the live Chrome Endure bots to display on the live graphs.  It's just
a python script that runs every 2 hours on my local machine to update the data
that's displayed on the live chrome endure graphs.

[Dai Mikurube (NOT FULLTIME), 2012/09/06 05:30:10]

Thanks for your effort to commit the "RESULT" parsing code!  I was wondering
about that.

For now, I added a TODO in _OutputPerfGraphValue.

[cmp_google, 2012/09/14 04:32:36]

Dennis and Dai, please let me know if/when there's something to review re: the
change to the master-parsing code to handle the endure and also the stacked
graphs.  I'm interested to see how that code would change to support this (and
of course to maintain backwards compatibility with the previous format). 
Thanks.

[Dai Mikurube (NOT FULLTIME), 2012/09/14 10:19:07]

Ah, ok, I'll Cc: you for such changes!

[dennis_jeffrey, 2012/09/14 16:33:31]

Yes, actually I was planning to make you our main point of contact (and code
reviewer) once we start modifying the master parsing code and the original
chrome perf graphing code.

-                            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 19 matching lines @@
         sys.stdout.flush()
     else:
       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()