Make run-benchmark script supports 'config' key in test plan.
[WebKit-https.git] / Tools / Scripts / webkitpy / benchmark_runner / benchmark_results.py
1 # Copyright (C) 2015 Apple Inc. All rights reserved.
2 #
3 # Redistribution and use in source and binary forms, with or without
4 # modification, are permitted provided that the following conditions
5 # are met:
6 # 1.  Redistributions of source code must retain the above copyright
7 #     notice, this list of conditions and the following disclaimer.
8 # 2.  Redistributions in binary form must reproduce the above copyright
9 #     notice, this list of conditions and the following disclaimer in the
10 #     documentation and/or other materials provided with the distribution.
11 #
12 # THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' AND ANY
13 # EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
14 # WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
15 # DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS BE LIABLE FOR ANY
16 # DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
17 # (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
18 # LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
19 # ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
20 # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
21 # SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
22
23 import json
24 import math
25 import re
26
27
28 class BenchmarkResults(object):
29
30     aggregators = {
31         'Total': (lambda values: sum(values)),
32         'Arithmetic': (lambda values: sum(values) / len(values)),
33         'Geometric': (lambda values: math.exp(sum(map(math.log, values)) / len(values))),
34     }
35     metric_to_unit = {
36         'FrameRate': 'fps',
37         'Runs': '/s',
38         'Time': 'ms',
39         'Duration': 'ms',
40         'Malloc': 'B',
41         'Heap': 'B',
42         'Allocations': 'B',
43         'Score': 'pt',
44     }
45     SI_prefixes = ['n', 'u', 'm', '', 'K', 'M', 'G', 'T', 'P', 'E']
46
47     def __init__(self, results):
48         self._lint_results(results)
49         self._results = self._aggregate_results(results)
50
51     def format(self, scale_unit=True):
52         return self._format_tests(self._results, scale_unit)
53
54     @classmethod
55     def _format_tests(cls, tests, scale_unit, indent=''):
56         output = ''
57         config_name = 'current'
58         for test_name in sorted(tests.keys()):
59             is_first = True
60             test = tests[test_name]
61             metrics = test.get('metrics', {})
62             for metric_name in sorted(metrics.keys()):
63                 metric = metrics[metric_name]
64                 for aggregator_name in sorted(metric.keys()):
65                     output += indent
66                     if is_first:
67                         output += test_name
68                         is_first = False
69                     else:
70                         output += ' ' * len(test_name)
71                     output += ':' + metric_name + ':'
72                     if aggregator_name:
73                         output += aggregator_name + ':'
74                     output += ' ' + cls._format_values(metric_name, metric[aggregator_name][config_name], scale_unit) + '\n'
75             if 'tests' in test:
76                 output += cls._format_tests(test['tests'], scale_unit, indent=(indent + ' ' * len(test_name)))
77         return output
78
79     @classmethod
80     def _format_values(cls, metric_name, values, scale_unit=True):
81         values = map(float, values)
82         total = sum(values)
83         mean = total / len(values)
84         square_sum = sum(map(lambda x: x * x, values))
85         sample_count = len(values)
86
87         # With sum and sum of squares, we can compute the sample standard deviation in O(1).
88         # See https://rniwa.com/2012-11-10/sample-standard-deviation-in-terms-of-sum-and-square-sum-of-samples/
89         if sample_count <= 1:
90             sample_stdev = 0
91         else:
92             # Be careful about round-off error when sample_stdev is 0.
93             sample_stdev = math.sqrt(max(0, square_sum / (sample_count - 1) - total * total / (sample_count - 1) / sample_count))
94
95         unit = cls._unit_from_metric(metric_name)
96
97         if not scale_unit:
98             return ('{mean:.3f}{unit} stdev={delta:.1%}').format(mean=mean, delta=sample_stdev / mean, unit=unit)
99
100         if unit == 'ms':
101             unit = 's'
102             mean = float(mean) / 1000
103             sample_stdev /= 1000
104
105         base = 1024 if unit == 'B' else 1000
106         value_sig_fig = 1 - math.floor(math.log10(sample_stdev / mean)) if sample_stdev else 3
107         SI_magnitude = math.floor(math.log(mean, base))
108
109         scaled_mean = mean * math.pow(base, -SI_magnitude)
110         SI_prefix = cls.SI_prefixes[int(SI_magnitude) + 3]
111
112         non_floating_digits = 1 + math.floor(math.log10(scaled_mean))
113         floating_points_count = max(0, value_sig_fig - non_floating_digits)
114         return ('{mean:.' + str(int(floating_points_count)) + 'f}{prefix}{unit} stdev={delta:.1%}').format(
115             mean=scaled_mean, delta=sample_stdev / mean, prefix=SI_prefix, unit=unit)
116
117     @classmethod
118     def _unit_from_metric(cls, metric_name):
119         # FIXME: Detect unknown mettric names
120         suffix = re.match(r'.*?([A-z][a-z]+|FrameRate)$', metric_name)
121         return cls.metric_to_unit[suffix.group(1)]
122
123     @classmethod
124     def _aggregate_results(cls, tests):
125         results = {}
126         for test_name, test in tests.iteritems():
127             results[test_name] = cls._aggregate_results_for_test(test)
128         return results
129
130     @classmethod
131     def _aggregate_results_for_test(cls, test):
132         subtest_results = cls._aggregate_results(test['tests']) if 'tests' in test else {}
133         results = {}
134         for metric_name, metric in test.get('metrics', {}).iteritems():
135             if not isinstance(metric, list):
136                 results[metric_name] = {None: {}}
137                 for config_name, values in metric.iteritems():
138                     results[metric_name][None][config_name] = cls._flatten_list(values)
139                 continue
140
141             aggregator_list = metric
142             results[metric_name] = {}
143             for aggregator in aggregator_list:
144                 values_by_config_iteration = cls._subtest_values_by_config_iteration(subtest_results, metric_name, aggregator)
145                 for config_name, values_by_iteration in values_by_config_iteration.iteritems():
146                     results[metric_name].setdefault(aggregator, {})
147                     results[metric_name][aggregator][config_name] = [cls._aggregate_values(aggregator, values) for values in values_by_iteration]
148
149         return {'metrics': results, 'tests': subtest_results}
150
151     @classmethod
152     def _flatten_list(cls, nested_list):
153         flattened_list = []
154         for item in nested_list:
155             if isinstance(item, list):
156                 flattened_list += cls._flatten_list(item)
157             else:
158                 flattened_list.append(item)
159         return flattened_list
160
161     @classmethod
162     def _subtest_values_by_config_iteration(cls, subtest_results, metric_name, aggregator):
163         values_by_config_iteration = {}
164         for subtest_name, subtest in subtest_results.iteritems():
165             results_for_metric = subtest['metrics'].get(metric_name, {})
166             results_for_aggregator = results_for_metric.get(aggregator, results_for_metric.get(None, {}))
167             for config_name, values in results_for_aggregator.iteritems():
168                 values_by_config_iteration.setdefault(config_name, [[] for _ in values])
169                 for iteration, value in enumerate(values):
170                     values_by_config_iteration[config_name][iteration].append(value)
171         return values_by_config_iteration
172
173     @classmethod
174     def _aggregate_values(cls, aggregator, values):
175         return cls.aggregators[aggregator](values)
176
177     @classmethod
178     def _lint_results(cls, tests):
179         cls._lint_subtest_results(tests, None)
180         return True
181
182     @classmethod
183     def _lint_subtest_results(cls, subtests, parent_needing_aggregation):
184         iteration_groups_by_config = {}
185         for test_name, test in subtests.iteritems():
186             needs_aggregation = False
187
188             if 'metrics' not in test and 'tests' not in test:
189                 raise TypeError('"%s" does not contain metrics or tests' % test_name)
190
191             if 'metrics' in test:
192                 metrics = test['metrics']
193                 if not isinstance(metrics, dict):
194                     raise TypeError('The metrics in "%s" is not a dictionary' % test_name)
195                 for metric_name, metric in metrics.iteritems():
196                     if isinstance(metric, list):
197                         cls._lint_aggregator_list(test_name, metric_name, metric)
198                         needs_aggregation = True
199                     elif isinstance(metric, dict):
200                         cls._lint_configuration(test_name, metric_name, metric, parent_needing_aggregation, iteration_groups_by_config)
201                     else:
202                         raise TypeError('"%s" metric of "%s" was not an aggregator list or a dictionary of configurations: %s' % (metric_name, test_name, str(metric)))
203
204             if 'tests' in test:
205                 cls._lint_subtest_results(test['tests'], test_name if needs_aggregation else None)
206             elif needs_aggregation:
207                 raise TypeError('"%s" requires aggregation but "SomeTest" has no subtests' % (test_name))
208         return iteration_groups_by_config
209
210     @classmethod
211     def _lint_aggregator_list(cls, test_name, metric_name, aggregator_list):
212         if len(aggregator_list) != len(set(aggregator_list)):
213             raise TypeError('"%s" metric of "%s" had invalid aggregator list: %s' % (metric_name, test_name, json.dumps(aggregator_list)))
214         if not aggregator_list:
215             raise TypeError('The aggregator list is empty in "%s" metric of "%s"' % (metric_name, test_name))
216         for aggregator_name in aggregator_list:
217             if cls._is_numeric(aggregator_name):
218                 raise TypeError('"%s" metric of "%s" is not wrapped by a configuration; e.g. "current"' % (metric_name, test_name))
219             if aggregator_name not in cls.aggregators:
220                 raise TypeError('"%s" metric of "%s" uses unknown aggregator: %s' % (metric_name, test_name, aggregator_name))
221
222     @classmethod
223     def _lint_configuration(cls, test_name, metric_name, configurations, parent_needing_aggregation, iteration_groups_by_config):
224         # FIXME: Check that config_name is always "current".
225         for config_name, values in configurations.iteritems():
226             nested_list_count = [isinstance(value, list) for value in values].count(True)
227             if nested_list_count not in [0, len(values)]:
228                 raise TypeError('"%s" metric of "%s" had malformed values: %s' % (metric_name, test_name, json.dumps(values)))
229
230             if nested_list_count:
231                 value_shape = []
232                 for value_group in values:
233                     value_shape.append(len(value_group))
234                     cls._lint_values(test_name, metric_name, value_group)
235             else:
236                 value_shape = len(values)
237                 cls._lint_values(test_name, metric_name, values)
238
239             iteration_groups_by_config.setdefault(metric_name, {}).setdefault(config_name, value_shape)
240             if parent_needing_aggregation and value_shape != iteration_groups_by_config[metric_name][config_name]:
241                 raise TypeError('"%s" metric of "%s" had a mismatching subtest values' % (metric_name, parent_needing_aggregation))
242
243     @classmethod
244     def _lint_values(cls, test_name, metric_name, values):
245         if any([not cls._is_numeric(value) for value in values]):
246             raise TypeError('"%s" metric of "%s" contains non-numeric value: %s' % (metric_name, test_name, json.dumps(values)))
247
248     @classmethod
249     def _is_numeric(cls, value):
250         return isinstance(value, int) or isinstance(value, float)