Codes for writing bench data to appengine datastore.

bench/bench_graph_svg.py

 '''
 Created on May 16, 2011
 
 @author: bungeman
 '''
+import bench_util
+import getopt
+import httplib
+import itertools
+import json
+import os
+import re
 import sys
-import getopt
-import re
-import os
-import bench_util
-import json
+import urllib
+import urllib2
 import xml.sax.saxutils
 
 # We throw out any measurement outside this range, and log a warning.
 MIN_REASONABLE_TIME = 0
 MAX_REASONABLE_TIME = 99999
 
 # Constants for prefixes in output title used in buildbot.
 TITLE_PREAMBLE = 'Bench_Performance_for_Skia_'
 TITLE_PREAMBLE_LENGTH = len(TITLE_PREAMBLE)
 
+# Number of data points to send to appengine at once.
+DATA_POINT_BATCHSIZE = 100
+
+def grouper(n, iterable):
+    """Groups list into list of lists for a given size. See itertools doc:
+      http://docs.python.org/2/library/itertools.html#module-itertools
+    """
+    args = [iter(iterable)] * n
+    return [[n for n in t if n] for t in itertools.izip_longest(*args)]
+
+
 def usage():
     """Prints simple usage information."""
-    
+
+    print '-a <url> the url to use for adding bench values to app engine app.'
+    print '   Example: "https://skiadash.appspot.com/add_point".'
+    print '   If not set, will skip this step.'
     print '-b <bench> the bench to show.'
     print '-c <config> the config to show (GPU, 8888, 565, etc).'
     print '-d <dir> a directory containing bench_r<revision>_<scalar> files.'
     print '-e <file> file containing expected bench values/ranges.'
     print '   Will raise exception if actual bench values are out of range.'
     print '   See bench_expectations.txt for data format and examples.'
     print '-f <revision>[:<revision>] the revisions to use for fitting.'
     print '   Negative <revision> is taken as offset from most recent revision.'
     print '-i <time> the time to ignore (w, c, g, etc).'
     print '   The flag is ignored when -t is set; otherwise we plot all the'
@@ skipping 150 matching lines @@
     the operating system's 260-character pathname limit, including chdirs."""
     abs_path = get_abs_path(output_path)
     sys.stdout = open(abs_path, 'w')
 
 def create_lines(revision_data_points, settings
                , bench_of_interest, config_of_interest, time_of_interest
                , time_to_ignore):
     """Convert revision data into a dictionary of line data.
     
     ({int:[BenchDataPoints]}, {str:str}, str?, str?, str?)
-        -> {Label:[(x,y)] | [n].x <= [n+1].x}"""
+        -> {Label:[(x,y)] | [n].x <= [n+1].x}
+    INPUT parameters of the function are:

[bungeman-skia, 2013/03/06 19:26:57]

If you're going to make this verbose, at least do it like the python style
guide.

[epoger, 2013/03/07 16:56:46]

Now, now, bungeman.  Let he who has documented in accordance with the python
style guide cast the first stone.  It's not clear to me why "terse and not in
accordance" is preferable to "verbose and not in accordance".

Having said that... yes, benchen, please use the docstring format as in
https://www.corp.google.com/eng/doc/pyguide.xml#Comments , like so...

"""Converts revision data into a dictionary of line data.

Args:
  revision_data_points: a dictionary with integer keys (revision #) and a list
      of bench data points as values
  settings: a dictionary of setting names to values
...

[benchen, 2013/03/07 17:13:27]

Done.

+    1. a dictionary with integer keys (revision #) and a list of bench data
+    points as values
+    2. a dictionary of setting names to value
+    3-5. optional filter parameters: which bench, config, or timer type is of
+    interest.  For each one, if None, process them all.
+    6. optional timer type to ignore
+
+    OUTPUT is a dictionary of this form:
+    keys = Label objects
+    values = a list of (x, y) tuples sorted such that x values increase
+    monotonically
+    """
     revisions = revision_data_points.keys()
     revisions.sort()
     lines = {} # {Label:[(x,y)] | x[n] <= x[n+1]}
     for revision in revisions:
         for point in revision_data_points[revision]:
             if (bench_of_interest is not None and
                 not bench_of_interest == point.bench):
                 continue
             
             if (config_of_interest is not None and
@@ skipping 73 matching lines @@
         max_up_slope = max(max_up_slope, min_slope)
         min_down_slope = min(min_down_slope, min_slope)
     
     return (max_up_slope, min_down_slope)
 
 def main():
     """Parses command line and writes output."""
     
     try:
         opts, _ = getopt.getopt(sys.argv[1:]
-                                 , "b:c:d:e:f:i:l:m:o:r:s:t:x:y:"
+                                 , "a:b:c:d:e:f:i:l:m:o:r:s:t:x:y:"
                                  , "default-setting=")
     except getopt.GetoptError, err:
         print str(err) 
         usage()
         sys.exit(2)
     
     directory = None
     config_of_interest = None
     bench_of_interest = None
     time_of_interest = None
     time_to_ignore = None
     bench_expectations = {}
+    appengine_url = None  # used for adding data to appengine datastore
     rep = None  # bench representation algorithm
     revision_range = '0:'
     regression_range = '0:'
     latest_revision = None
     requested_height = None
     requested_width = None
     title = 'Bench graph'
     settings = {}
     default_settings = {}
 
@@ skipping 51 matching lines @@
                 # Skip benches without value for latest revision.
                 continue
             this_min, this_max = expectations[bench_platform_key]
             if this_bench_value < this_min or this_bench_value > this_max:
                 exceptions.append('Bench %s value %s out of range [%s, %s].' %
                     (bench_platform_key, this_bench_value, this_min, this_max))
         if exceptions:
             raise Exception('Bench values out of range:\n' +
                             '\n'.join(exceptions))
 
+    def write_to_appengine(line_data_dict, url, newest_revision, bot):
+        """Writes latest bench values to appengine datastore.
+          line_data_dict: dictionary from create_lines.
+          url: the appengine url used to send bench values to write
+          newest_revision: the latest revision that this script reads
+          bot: the bot platform the bench is run on
+        """
+        data = []
+        for line in line_data_dict:
+            if not line.bench.endswith('.skp') or line.time_type:
+                # filter out non-picture and non-walltime benches
+                continue
+            config = line.config
+            rev, val = line_data_dict[line][-1]
+            if rev != newest_revision:
+                continue
+            data.append({'master': 'Skia', 'bot': bot,
+                         'test': config + '/' + line.bench.replace('.skp', ''),
+                         'revision': rev, 'value': val, 'error': 0})
+        for curr_data in grouper(DATA_POINT_BATCHSIZE, data):
+            req = urllib2.Request(appengine_url,
+                urllib.urlencode({'data': json.dumps(curr_data)}))
+            try:
+              urllib2.urlopen(req)
+            except urllib2.HTTPError, e:
+                sys.stderr.write("HTTPError for JSON data %s: %s\n" % (
+                    data, e))
+            except urllib2.URLError, e:
+                sys.stderr.write("URLError for JSON data %s: %s\n" % (
+                    data, e))
+            except httplib.HTTPException, e:
+                sys.stderr.write("HTTPException for JSON data %s: %s\n" % (
+                    data, e))
+
     try:
         for option, value in opts:
-            if option == "-b":
+            if option == "-a":
+                appengine_url = value
+            elif option == "-b":
                 bench_of_interest = value
             elif option == "-c":
                 config_of_interest = value
             elif option == "-d":
                 directory = value
             elif option == "-e":
                 read_expectations(bench_expectations, value)
             elif option == "-f":
                 regression_range = value
             elif option == "-i":
@@ skipping 28 matching lines @@
         sys.exit(2)
 
     if time_of_interest:
         time_to_ignore = None
 
     # The title flag (-l) provided in buildbot slave is in the format
     # Bench_Performance_for_Skia_<platform>, and we want to extract <platform>
     # for use in platform_and_alg to track matching benches later. If title flag
     # is not in this format, there may be no matching benches in the file
     # provided by the expectation_file flag (-e).
+    bot = title  # To store the platform as bot name
     platform_and_alg = title
     if platform_and_alg.startswith(TITLE_PREAMBLE):
-        platform_and_alg = (
-            platform_and_alg[TITLE_PREAMBLE_LENGTH:] + '-' + rep)
+        bot = platform_and_alg[TITLE_PREAMBLE_LENGTH:]
+        platform_and_alg = bot + '-' + rep
     title += ' [representation: %s]' % rep
 
     latest_revision = get_latest_revision(directory)
     oldest_revision, newest_revision = parse_range(revision_range)
     oldest_regression, newest_regression = parse_range(regression_range)
 
     unfiltered_revision_data_points = parse_dir(directory
                                    , default_settings
                                    , oldest_revision
                                    , newest_revision
@@ skipping 16 matching lines @@
                    , time_of_interest
                    , time_to_ignore)
 
     regressions = create_regressions(lines
                                    , oldest_regression
                                    , newest_regression)
 
     output_xhtml(lines, oldest_revision, newest_revision, ignored_revision_data_points,
                  regressions, requested_width, requested_height, title)
 
+    if appengine_url:
+        write_to_appengine(lines, appengine_url, newest_revision, bot)
+
     check_expectations(lines, bench_expectations, newest_revision,
                        platform_and_alg)
 
 def qa(out):
     """Stringify input and quote as an xml attribute."""
     return xml.sax.saxutils.quoteattr(str(out))
 def qe(out):
     """Stringify input and escape as xml data."""
     return xml.sax.saxutils.escape(str(out))
 
@@ skipping 481 matching lines @@
     print '<a id="rev_link" xlink:href="" target="_top">'
     print '<text id="revision" x="0" y=%s style="' % qa(font_size*2)
     print 'font-size: %s; ' % qe(font_size)
     print 'stroke: #0000dd; text-decoration: underline; '
     print '"> </text></a>'
 
     print '</svg>'
 
 if __name__ == "__main__":
     main()