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 149 matching lines @@
     On Windows, we need to generate the absolute path within Python to avoid
     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}"""
+    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 value
+      bench_of_interest: optional filter parameters: which bench type is of
+          interest. If None, process them all.
+      config_of_interest: optional filter parameters: which config type is of
+          interest. If None, process them all.
+      time_of_interest: optional filter parameters: which timer type is of
+          interest. If None, process them all.
+      time_to_ignore: optional timer type to ignore
+
+    Returns:
+      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 label in line_data_dict.iterkeys():
+            if not label.bench.endswith('.skp') or label.time_type:
+                # filter out non-picture and non-walltime benches
+                continue
+            config = label.config
+            rev, val = line_data_dict[label][-1]
+            # This assumes that newest_revision is >= the revision of the last
+            # data point we have for each line.
+            if rev != newest_revision:
+                continue
+            data.append({'master': 'Skia', 'bot': bot,
+                         'test': config + '/' + label.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()