| # Copyright (c) 2011 The Chromium OS Authors. All rights reserved. |
| # Use of this source code is governed by a BSD-style license that can be |
| # found in the LICENSE file. |
| |
| """Functions called to preprocess perf data for regressions.""" |
| |
| import logging |
| import operator |
| |
| import dash_util |
| |
| # String resources. |
| from dash_strings import PREPROCESSED_TAG |
| from dash_strings import EMAIL_ALERT_DELTA_TABLE_SKELETON |
| from dash_strings import EMAIL_ALERT_DELTA_TABLE_ROW |
| |
| PREFIX_LEN = 9 |
| |
| class PreprocessFunctions(object): |
| """Class to contain and invoke preprocessing functions.""" |
| |
| def Invoke(self, function_name, params, keyvals, checks): |
| """Dispatch function and return True if failed.""" |
| if not hasattr(self, function_name): |
| logging.debug('Preprocessing function %s not found.', function_name) |
| return False |
| return getattr(self, function_name)(params, keyvals, checks) |
| |
| def _MakePreprocessedKey(self, key, seq=None): |
| """Helper to distinguish created preprocessing keys from regulars.""" |
| new_key = '%s%s' % (key, PREPROCESSED_TAG) |
| if seq: |
| new_key = '%s%s%s' % (seq, PREPROCESSED_TAG, new_key) |
| return new_key |
| |
| def _IsPreprocessedKey(self, key): |
| """Helper to decide if a key was produced by us.""" |
| key_len = len(key) |
| pp_len = len(PREPROCESSED_TAG) |
| return key[key_len-pp_len:] == PREPROCESSED_TAG, pp_len, key_len |
| |
| def _GetOriginalKeySeq(self, key): |
| """Helper to distinguish created preprocessing keys from regulars.""" |
| new_key = '' |
| seq = 0 |
| is_pp, pp_len, key_len = self._IsPreprocessedKey(key) |
| if is_pp: |
| new_key = key[:key_len-pp_len] |
| n = new_key.find(PREPROCESSED_TAG) |
| if n > -1: |
| seq = int(new_key[:n]) |
| new_key = new_key[n+pp_len:] |
| return new_key, seq |
| |
| def IsPreprocessedKey(self, key): |
| is_pp, _, _ = self._IsPreprocessedKey(key) |
| return is_pp |
| |
| def PreprocessorHTML(self, test_name, regressed_keys): |
| """Process preprocessed keys and related details into a summary.""" |
| # Preserve order using seq hints. |
| preprocessed_in_order = [] |
| preprocessed_details = {} |
| for test_key, regressed_stats in regressed_keys.iteritems(): |
| build_val = regressed_stats['build_mean'] |
| build_npoints = regressed_stats['build_samples'] |
| expected_val = regressed_stats['historical_mean'] |
| expected_npoints = regressed_stats['historical_samples'] |
| is_pp, _, _ = self._IsPreprocessedKey(test_key) |
| if is_pp: |
| orig_key, seq = self._GetOriginalKeySeq(test_key) |
| details_row = preprocessed_details.setdefault( |
| orig_key, [0.0, 0.0, 0.0, 0.0]) |
| details_row[0] = build_val |
| details_row[1] = expected_val |
| preprocessed_in_order.append((orig_key, seq)) |
| else: |
| details_row = preprocessed_details.setdefault( |
| test_key, [0.0, 0.0, 0.0, 0.0]) |
| details_row[2] = build_val |
| details_row[3] = expected_val |
| preprocessed_in_order.sort(key=operator.itemgetter(1)) |
| |
| # Build html. |
| converter = dash_util.HumanReadableFloat() |
| current_table = [] |
| table_list = [current_table] |
| previous_key = None |
| for one_key, seq in preprocessed_in_order: |
| if previous_key and (previous_key[:PREFIX_LEN] != one_key[:PREFIX_LEN]): |
| current_table = [] |
| table_list.append(current_table) |
| pp_build_val, pp_expected_val, build_val, expected_val = ( |
| preprocessed_details[one_key]) |
| current_table.append( |
| EMAIL_ALERT_DELTA_TABLE_ROW % { |
| 'key': one_key, |
| 'pp_latest': converter.Convert(pp_build_val), |
| 'pp_average': converter.Convert(pp_expected_val), |
| 'latest': converter.Convert(build_val), |
| 'average': converter.Convert(expected_val)}) |
| previous_key = one_key |
| |
| preprocessed_html = [] |
| for current_table in table_list: |
| preprocessed_html.append( |
| EMAIL_ALERT_DELTA_TABLE_SKELETON % { |
| 'test_name': test_name, |
| 'body': ''.join(current_table)}) |
| return preprocessed_html |
| |
| def GroupDeltas(self, params, keyvals, checks): |
| """Create new keyvals using deltas based on existing keyvals.""" |
| # Average the values for each checked key and build into a structure |
| # just like the existing keyvals. |
| stub_test_id = 0 |
| key_build_averages = {} |
| build_key_counts = {} |
| for one_key in checks: |
| key_build_averages[one_key] = {} |
| for build, values in keyvals[one_key].iteritems(): |
| key_set = build_key_counts.setdefault(build, set()) |
| key_set.add(one_key) |
| key_build_averages[one_key][build] = ( |
| [sum(values[0], 0.0) / len(values[0])], [stub_test_id]) |
| |
| # Figure out the relative order of the keys in increasing |
| # order of one build's average values. Use the build with the |
| # most keys as a reference. |
| high_water_build = None |
| high_water_count = 0 |
| for build, key_set in build_key_counts.iteritems(): |
| if len(key_set) > high_water_count: |
| high_water_count = len(key_set) |
| high_water_build = build |
| averages = [] |
| for one_key in checks: |
| if (not high_water_build or |
| not high_water_build in key_build_averages[one_key]): |
| logging.warning( |
| 'Key %s is missing build %s in GroupDeltas().', |
| one_key, high_water_build) |
| else: |
| averages.append(( |
| one_key, key_build_averages[one_key][high_water_build][0])) |
| averages.sort(key=operator.itemgetter(1)) |
| |
| # Generate the new keys that use deltas as values. |
| # Group them according to a prefix on each key. |
| prefix_groups = {} |
| for one_key, _ in averages: |
| key_list = prefix_groups.setdefault(one_key[:PREFIX_LEN], []) |
| key_list.append(one_key) |
| |
| i = 1 # For later sorting of the group by value. |
| delta_prefix_groups = prefix_groups.keys() |
| delta_prefix_groups.sort() |
| for one_key_group in delta_prefix_groups: |
| previous_key = None |
| for one_key in prefix_groups[one_key_group]: |
| new_key_name = self._MakePreprocessedKey(one_key, i) |
| # Add the new key to the checks. |
| checks[new_key_name] = checks[one_key] |
| |
| # Add the new key and data into keyvals. |
| if previous_key: |
| # Calculate the deltas of calculated averages. |
| for build in key_build_averages[one_key].iterkeys(): |
| if (build in key_build_averages[one_key] and |
| build in key_build_averages[previous_key]): |
| new_keyval = keyvals.setdefault(new_key_name, {}) |
| new_keyval[build] = ([ |
| key_build_averages[one_key][build][0][0] - |
| key_build_averages[previous_key][build][0][0]], |
| [stub_test_id]) |
| else: |
| # Copy the structure from the averages calculated. |
| keyvals[new_key_name] = key_build_averages[one_key] |
| previous_key = one_key |
| i += 1 |
