performance tests should be able to measure runs/sec rather than time
[WebKit-https.git] / Tools / Scripts / webkitpy / performance_tests / perftest.py
1 #!/usr/bin/env python
2 # Copyright (C) 2012 Google Inc. All rights reserved.
3 #
4 # Redistribution and use in source and binary forms, with or without
5 # modification, are permitted provided that the following conditions are
6 # met:
7 #
8 #     * Redistributions of source code must retain the above copyright
9 # notice, this list of conditions and the following disclaimer.
10 #     * Redistributions in binary form must reproduce the above
11 # copyright notice, this list of conditions and the following disclaimer
12 # in the documentation and/or other materials provided with the
13 # distribution.
14 #     * Neither the name of Google Inc. nor the names of its
15 # contributors may be used to endorse or promote products derived from
16 # this software without specific prior written permission.
17 #
18 # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19 # "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20 # LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
21 # A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
22 # OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
23 # SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
24 # LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
25 # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
26 # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27 # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
28 # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29
30
31 import logging
32 import math
33 import re
34
35 from webkitpy.layout_tests.port.driver import DriverInput
36
37
38 _log = logging.getLogger(__name__)
39
40
41 class PerfTest(object):
42     def __init__(self, test_name, path_or_url):
43         self._test_name = test_name
44         self._path_or_url = path_or_url
45
46     def test_name(self):
47         return self._test_name
48
49     def path_or_url(self):
50         return self._path_or_url
51
52     def run(self, driver, timeout_ms):
53         output = driver.run_test(DriverInput(self.path_or_url(), timeout_ms, None, False))
54         if self.run_failed(output):
55             return None
56         return self.parse_output(output)
57
58     def run_failed(self, output):
59         if output.text == None or output.error:
60             pass
61         elif output.timeout:
62             _log.error('timeout: %s' % self.test_name())
63         elif output.crash:
64             _log.error('crash: %s' % self.test_name())
65         else:
66             return False
67
68         if output.error:
69             _log.error('error: %s\n%s' % (self.test_name(), output.error))
70
71         return True
72
73     _lines_to_ignore_in_parser_result = [
74         re.compile(r'^Running \d+ times$'),
75         re.compile(r'^Ignoring warm-up '),
76         re.compile(r'^Info:'),
77         re.compile(r'^\d+(.\d+)?(\s*(runs\/s|ms))?$'),
78         # Following are for handle existing test like Dromaeo
79         re.compile(re.escape("""main frame - has 1 onunload handler(s)""")),
80         re.compile(re.escape("""frame "<!--framePath //<!--frame0-->-->" - has 1 onunload handler(s)""")),
81         re.compile(re.escape("""frame "<!--framePath //<!--frame0-->/<!--frame0-->-->" - has 1 onunload handler(s)"""))]
82
83     _statistics_keys = ['avg', 'median', 'stdev', 'min', 'max']
84
85     def _should_ignore_line_in_parser_test_result(self, line):
86         if not line:
87             return True
88         for regex in self._lines_to_ignore_in_parser_result:
89             if regex.search(line):
90                 return True
91         return False
92
93     def parse_output(self, output):
94         got_a_result = False
95         test_failed = False
96         results = {}
97         score_regex = re.compile(r'^(?P<key>' + r'|'.join(self._statistics_keys) + r')\s+(?P<value>[0-9\.]+)\s*(?P<unit>.*)')
98         unit = "ms"
99
100         for line in re.split('\n', output.text):
101             score = score_regex.match(line)
102             if score:
103                 results[score.group('key')] = float(score.group('value'))
104                 if score.group('unit'):
105                     unit = score.group('unit')
106                 continue
107
108             if not self._should_ignore_line_in_parser_test_result(line):
109                 test_failed = True
110                 _log.error(line)
111
112         if test_failed or set(self._statistics_keys) != set(results.keys()):
113             return None
114
115         results['unit'] = unit
116
117         test_name = re.sub(r'\.\w+$', '', self._test_name)
118         self.output_statistics(test_name, results)
119
120         return {test_name: results}
121
122     def output_statistics(self, test_name, results):
123         unit = results['unit']
124         _log.info('RESULT %s= %s %s' % (test_name.replace('/', ': '), results['avg'], unit))
125         _log.info(', '.join(['%s= %s %s' % (key, results[key], unit) for key in self._statistics_keys[1:]]))
126
127
128 class ChromiumStylePerfTest(PerfTest):
129     _chromium_style_result_regex = re.compile(r'^RESULT\s+(?P<name>[^=]+)\s*=\s+(?P<value>\d+(\.\d+)?)\s*(?P<unit>\w+)$')
130
131     def __init__(self, test_name, path_or_url):
132         super(ChromiumStylePerfTest, self).__init__(test_name, path_or_url)
133
134     def parse_output(self, output):
135         test_failed = False
136         got_a_result = False
137         results = {}
138         for line in re.split('\n', output.text):
139             resultLine = ChromiumStylePerfTest._chromium_style_result_regex.match(line)
140             if resultLine:
141                 # FIXME: Store the unit
142                 results[self.test_name() + ':' + resultLine.group('name').replace(' ', '')] = float(resultLine.group('value'))
143                 _log.info(line)
144             elif not len(line) == 0:
145                 test_failed = True
146                 _log.error(line)
147         return results if results and not test_failed else None
148
149
150 class PageLoadingPerfTest(PerfTest):
151     def __init__(self, test_name, path_or_url):
152         super(PageLoadingPerfTest, self).__init__(test_name, path_or_url)
153
154     def run(self, driver, timeout_ms):
155         test_times = []
156
157         for i in range(0, 20):
158             output = driver.run_test(DriverInput(self.path_or_url(), timeout_ms, None, False))
159             if self.run_failed(output):
160                 return None
161             if i == 0:
162                 continue
163             test_times.append(output.test_time * 1000)
164
165         test_times = sorted(test_times)
166
167         # Compute the mean and variance using a numerically stable algorithm.
168         squareSum = 0
169         mean = 0
170         valueSum = sum(test_times)
171         for i, time in enumerate(test_times):
172             delta = time - mean
173             sweep = i + 1.0
174             mean += delta / sweep
175             squareSum += delta * delta * (i / sweep)
176
177         middle = int(len(test_times) / 2)
178         results = {'avg': mean,
179             'min': min(test_times),
180             'max': max(test_times),
181             'median': test_times[middle] if len(test_times) % 2 else (test_times[middle - 1] + test_times[middle]) / 2,
182             'stdev': math.sqrt(squareSum),
183             'unit': 'ms'}
184         self.output_statistics(self.test_name(), results)
185         return {self.test_name(): results}
186
187
188 class PerfTestFactory(object):
189
190     _pattern_map = [
191         (re.compile('^inspector/'), ChromiumStylePerfTest),
192         (re.compile('^PageLoad/'), PageLoadingPerfTest),
193     ]
194
195     @classmethod
196     def create_perf_test(cls, test_name, path):
197         for (pattern, test_class) in cls._pattern_map:
198             if pattern.match(test_name):
199                 return test_class(test_name, path)
200         return PerfTest(test_name, path)