The Tor Browser: tools/performance/diff-talos.py@97036ab72558 (annotated)

tools/performance/diff-talos.py@97036ab72558 (annotated)

tools/performance/diff-talos.py

Tue, 06 Jan 2015 21:39:09 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Tue, 06 Jan 2015 21:39:09 +0100
branch: TOR_BUG_9701
changeset 8: 97036ab72558
permissions: -rwxr-xr-x

Conditionally force memory storage according to privacy.thirdparty.isolate;
This solves Tor bug #9701, complying with disk avoidance documented in
https://www.torproject.org/projects/torbrowser/design/#disk-avoidance.

 #!/usr/bin/env python
 # This Source Code Form is subject to the terms of the Mozilla Public
 # License, v. 2.0. If a copy of the MPL was not distributed with this
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 """
 This is a simple script that does one thing only: compare talos runs from
 two revisions. It is intended to check which of two try runs is best or if
 a try improves over the m-c or m-i revision in branches from.
 A big design goal is to avoid bit rot and to assert when bit rot is detected.
 The set of tests we run is a moving target. When possible this script
 should work with any test set, but in parts where it has to hard code
 information, it should try to assert that it is valid so that changes
 are detected and it is fixed earlier.
 """
 import json
 import urllib2
 import math
 import sys
 from optparse import OptionParser
 # FIXME: currently we assert that we know all the benchmarks just so
 # we are sure to maintain the bigger_is_better set updated. Is there a better
 # way to find/compute it?
 bigger_is_better = frozenset(('v8_7', 'dromaeo_dom', 'dromaeo_css'))
 smaller_is_better = frozenset(('tdhtmlr_paint', 'tp5n_main_rss_paint',
                                'ts_paint', 'tp5n_paint', 'tsvgr_opacity',
                                'a11yr_paint', 'kraken',
                                'tdhtmlr_nochrome_paint',
                                'tspaint_places_generated_med', 'tpaint',
                                'tp5n_shutdown_paint', 'tsvgr',
                                'tp5n_pbytes_paint', 'tscrollr_paint',
                                'tspaint_places_generated_max',
                                'tp5n_responsiveness_paint',
                                'sunspider', 'tp5n_xres_paint', 'num_ctors',
                                'tresize', 'trobopan', 'tcheckerboard',
                                'tcheck3', 'tcheck2', 'tprovider',
                                'tp5n_modlistbytes_paint',
                                'trace_malloc_maxheap', 'tp4m_nochrome',
                                'trace_malloc_leaks', 'tp4m_main_rss_nochrome',
                                'tp4m_shutdown_nochrome', 'tdhtml_nochrome',
                                'ts_shutdown', 'tp5n_%cpu_paint',
                                'trace_malloc_allocs', 'ts',
                                'tsvg_nochrome', 'tp5n_content_rss_paint',
                                'tp5n_main_startup_fileio_paint',
                                'tp5n_nonmain_normal_netio_paint',
                                'tp5n_nonmain_startup_fileio_paint',
                                'tp5n_main_normal_fileio_paint',
                                'tp5n_nonmain_normal_fileio_paint',
                                'tp5n_main_startup_netio_paint',
                                'tp5n_main_normal_netio_paint',
                                'tp5n_main_shutdown_netio_paint',
                                'tp5n_main_shutdown_fileio_paint'))
 all_benchmarks = smaller_is_better | bigger_is_better
 assert len(smaller_is_better & bigger_is_better) == 0
 def get_raw_data_for_revisions(revisions):
     """Loads data for the revisions, returns an array with one element for each
     revision."""
     selectors = ["revision=%s" % revision for revision in revisions]
     selector = '&'.join(selectors)
     url = "http://graphs.mozilla.org/api/test/runs/revisions?%s" % selector
     url_stream = urllib2.urlopen(url)
     data = json.load(url_stream)
     assert frozenset(data.keys()) == frozenset(('stat', 'revisions'))
     assert data['stat'] == 'ok'
     rev_data = data['revisions']
     assert frozenset(rev_data.keys()) == frozenset(revisions)
     return [rev_data[r] for r in revisions]
 def mean(values):
     return float(sum(values))/len(values)
 def c4(n):
     n = float(n)
     numerator = math.gamma(n/2)*math.sqrt(2/(n-1))
     denominator = math.gamma((n-1)/2)
     return numerator/denominator
 def unbiased_standard_deviation(values):
     n = len(values)
     if n == 1:
         return None
     acc = 0
     avg = mean(values)
     for i in values:
         dist = i - avg
         acc += dist * dist
     return math.sqrt(acc/(n-1))/c4(n)
 class BenchmarkResult:
     """ Stores the summary (mean and standard deviation) of a set of talus
     runs on the same revision and OS."""
     def __init__(self, avg, std):
         self.avg = avg
         self.std = std
     def __str__(self):
         t = "%s," % self.avg
         return "(%-13s %s)" % (t, self.std)
 # FIXME: This function computes the statistics of multiple runs of talos on a
 # single revision. Should it also support computing statistics over runs of
 # different revisions assuming the revisions are equivalent from a performance
 # perspective?
 def digest_revision_data(data):
     ret = {}
     benchmarks = frozenset(data.keys())
     # assert that all the benchmarks are known. If they are not,
     # smaller_is_better or bigger_is_better needs to be updated depending on
     # the benchmark type.
     assert all_benchmarks.issuperset(benchmarks), \
         "%s not found in all_benchmarks" % ','.join((benchmarks - all_benchmarks))
     for benchmark in benchmarks:
         benchmark_data = data[benchmark]
         expected_keys = frozenset(("test_runs", "name", "id"))
         assert frozenset(benchmark_data.keys()) == expected_keys
         test_runs = benchmark_data["test_runs"]
         operating_systems = test_runs.keys()
         results = {}
         for os in operating_systems:
             os_runs = test_runs[os]
             values = []
             for os_run in os_runs:
                 # there are 4 fields: test run id, build id, timestamp,
                 # mean value
                 assert len(os_run) == 4
                 values.append(os_run[3])
             avg = mean(values)
             std = unbiased_standard_deviation(values)
             results[os] = BenchmarkResult(avg, std)
         ret[benchmark] = results
     return ret
 def get_data_for_revisions(revisions):
     raw_data = get_raw_data_for_revisions(revisions)
     return [digest_revision_data(x) for x in raw_data]
 def overlaps(a, b):
     return a[1] >= b[0] and b[1] >= a[0]
 def is_significant(old, new):
     # conservative hack: if we don't know, say it is significant.
     if old.std is None or new.std is None:
         return True
     # use a 2 standard deviation interval, which is about 95% confidence.
     old_interval = [old.avg - old.std, old.avg + old.std]
     new_interval = [new.avg - new.std, new.avg + new.std]
     return not overlaps(old_interval, new_interval)
 def compute_difference(benchmark, old, new):
     if benchmark in bigger_is_better:
         new, old = old, new
     if new.avg >= old.avg:
         return "%1.4fx worse" % (new.avg/old.avg)
     else:
         return "%1.4fx better" % (old.avg/new.avg)
 #FIXME: the printing could use a table class that computes the sizes of the
 # cells instead of the current hard coded values.
 def print_data_comparison(datav):
     assert len(datav) == 2
     old_data = datav[0]
     new_data = datav[1]
     old_benchmarks = frozenset(old_data.keys())
     new_benchmarks = frozenset(new_data.keys())
     benchmarks = old_benchmarks.intersection(new_benchmarks)
     for benchmark in sorted(benchmarks):
         print benchmark
         old_benchmark_data = old_data[benchmark]
         new_benchmark_data = new_data[benchmark]
         old_operating_systems = frozenset(old_benchmark_data.keys())
         new_operating_systems = frozenset(new_benchmark_data.keys())
         operating_systems = old_operating_systems.intersection(new_operating_systems)
         for os in sorted(operating_systems):
             old_os_data = old_benchmark_data[os]
             new_os_data = new_benchmark_data[os]
             if not is_significant(old_os_data, new_os_data):
                 continue
             diff = compute_difference(benchmark, old_os_data, new_os_data)
             print '%-33s | %-30s -> %-30s %s' % \
                 (os, old_os_data, new_os_data, diff)
         print
 def main():
     parser = OptionParser(usage='Usage: %prog old_revision new_revision')
     options, args = parser.parse_args()
     if len(args) != 2:
         parser.print_help()
         sys.exit(1)
     print_data_comparison(get_data_for_revisions(args))
 if __name__ == '__main__':
     main()

The Tor Browser / annotate

tools/performance/diff-talos.py@97036ab72558 (annotated)

tools/performance/diff-talos.py