cos / mirrors / cros / chromiumos / platform / crostestutils / 769609b502582a617f9a949591159afbf0ecdac7 / . / bootperf-bin / resultset.py

# Copyright (c) 2010 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. | |

"""Classes and functions for managing platform_BootPerf results. | |

Results from the platform_BootPerf test in the ChromiumOS autotest | |

package are stored as performance 'keyvals', that is, a mapping | |

of names to numeric values. For each iteration of the test, one | |

set of keyvals is recorded. | |

This module currently tracks three kinds of keyval results: the boot | |

time results, the disk read results, and firmware time results. | |

These results are stored with keyval names such as | |

'seconds_kernel_to_login', 'rdbytes_kernel_to_login', and | |

'seconds_power_on_to_kernel'. These keyvals record an accumulated | |

total measured from a fixed time in the past, e.g. | |

'seconds_kernel_to_login' records the total seconds from kernel | |

startup to login screen ready. | |

The boot time keyval names all start with the prefix | |

'seconds_kernel_to_', and record time in seconds since kernel | |

startup. | |

The disk read keyval names all start with the prefix | |

'rdbytes_kernel_to_', and record bytes read from the boot device | |

since kernel startup. | |

The firmware keyval names all start with the prefix | |

'seconds_power_on_to_', and record time in seconds since CPU | |

power on. | |

""" | |

import math | |

def _ListStats(list_): | |

# Utility function - calculate the average and (sample) standard | |

# deviation of a list of numbers. Result is float, even if the | |

# input list is full of int's | |

sum_ = 0.0 | |

sumsq = 0.0 | |

for v in list_: | |

sum_ += v | |

sumsq += v * v | |

n = len(list_) | |

avg = sum_ / n | |

var = (sumsq - sum_ * avg) / (n - 1) | |

if var < 0.0: | |

var = 0.0 | |

dev = math.sqrt(var) | |

return (avg, dev) | |

def _DoCheck(dict_): | |

# Utility function - check the that all keyvals occur the same | |

# number of times. On success, return the number of occurrences; | |

# on failure return None | |

check = map(len, dict_.values()) | |

if not check: | |

return None | |

for i in range(1, len(check)): | |

if check[i] != check[i-1]: | |

return None | |

return check[0] | |

def _KeyDelta(dict_, key0, key1): | |

# Utility function - return a list of the vector difference between | |

# two keyvals. | |

return map(lambda a, b: b - a, dict_[key0], dict_[key1]) | |

class TestResultSet(object): | |

"""A set of boot time and disk usage result statistics. | |

Objects of this class consist of three sets of result statistics: | |

the boot time statistics, the disk statistics, and the firmware | |

time statistics. | |

Class TestResultsSet does not interpret or store keyval mappings | |

directly; iteration results are processed by attached _KeySet | |

objects, one for each of the three types of result keyval. The | |

_KeySet objects are kept in a dictionary; they can be obtained | |

by calling the KeySet with the name of the keyset desired. | |

Various methods on the KeySet objects will calculate statistics on | |

the results, and provide the raw data. | |

""" | |

# The names of the available KeySets, to be used as arguments to | |

# KeySet(). | |

BOOTTIME_KEYSET = "time" | |

DISK_KEYSET = "disk" | |

FIRMWARE_KEYSET = "firmware" | |

def __init__(self, name): | |

self.name = name | |

self._keysets = { | |

self.BOOTTIME_KEYSET : _TimeKeySet(), | |

self.DISK_KEYSET : _DiskKeySet(), | |

self.FIRMWARE_KEYSET : _FirmwareKeySet(), | |

} | |

def AddIterationResults(self, runkeys): | |

"""Add keyval results from a single iteration. | |

A TestResultSet is constructed by repeatedly calling | |

AddIterationResults(), iteration by iteration. Iteration | |

results are passed in as a dictionary mapping keyval attributes | |

to values. When all iteration results have been added, | |

FinalizeResults() makes the results available for analysis. | |

""" | |

for keyset in self._keysets.itervalues(): | |

keyset.AddIterationResults(runkeys) | |

def FinalizeResults(self): | |

"""Make results available for analysis. | |

A TestResultSet is constructed by repeatedly feeding it results, | |

iteration by iteration. Iteration results are passed in as a | |

dictionary mapping keyval attributes to values. When all iteration | |

results have been added, FinalizeResults() makes the results | |

available for analysis. | |

""" | |

for keyset in self._keysets.itervalues(): | |

keyset.FinalizeResults() | |

def KeySet(self, keytype): | |

"""Return the boot time statistics result set.""" | |

return self._keysets[keytype] | |

class _KeySet(object): | |

"""Container for a set of related statistics. | |

_KeySet is an abstract superclass for containing collections of | |

a related set of performance statistics. Statistics are stored | |

as a dictionary (`_keyvals`) mapping keyval names to lists of | |

values. The lists are indexed by the iteration number. | |

The mapped keyval names are shortened by stripping the prefix | |

that identifies the type of keyval (keyvals that don't start with | |

the proper prefix are ignored). So, for example, with boot time | |

keyvals, 'seconds_kernel_to_login' becomes 'login' (and | |

'rdbytes_kernel_to_login' is ignored). | |

A list of all valid keyval names is stored in the `markers` | |

instance variable. The list is sorted by the ordering of the | |

average of the corresponding values. Each iteration is required | |

to contain the same set of keyvals. This is enforced in | |

FinalizeResults() (see below). | |

""" | |

def __init__(self): | |

self._keyvals = {} | |

def AddIterationResults(self, runkeys): | |

"""Add results for one iteration.""" | |

for key, value in runkeys.iteritems(): | |

if not key.startswith(self.PREFIX): | |

continue | |

shortkey = key[len(self.PREFIX):] | |

keylist = self._keyvals.setdefault(shortkey, []) | |

keylist.append(self._ConvertVal(value)) | |

def FinalizeResults(self): | |

"""Finalize this object's results. | |

This method makes available the `markers` and `num_iterations` | |

instance variables. It also ensures that every keyval occurred | |

in every iteration by requiring that all keyvals have the same | |

number of data points. | |

""" | |

count = _DoCheck(self._keyvals) | |

if count is None: | |

self.num_iterations = 0 | |

self.markers = [] | |

return False | |

self.num_iterations = count | |

keylist = map(lambda k: (sum(self._keyvals[k]), k), | |

self._keyvals.keys()) | |

keylist.sort(key=lambda tp: tp[0]) | |

self.markers = map(lambda tp: tp[1], keylist) | |

return True | |

def RawData(self, key): | |

"""Return the list of values for the given marker key.""" | |

return self._keyvals[key] | |

def DeltaData(self, key0, key1): | |

"""Return vector difference of the values of the given keys.""" | |

return _KeyDelta(self._keyvals, key0, key1) | |

def Statistics(self, key): | |

"""Return the average and standard deviation of the key's values.""" | |

return _ListStats(self._keyvals[key]) | |

def DeltaStatistics(self, key0, key1): | |

"""Return the average and standard deviation of the differences | |

between two keys. | |

""" | |

return _ListStats(self.DeltaData(key0, key1)) | |

class _TimeKeySet(_KeySet): | |

"""Concrete subclass of _KeySet for boot time statistics.""" | |

PREFIX = 'seconds_kernel_to_' | |

# Time-based keyvals are reported in seconds and get converted to | |

# milliseconds | |

TIME_SCALE = 1000 | |

def _ConvertVal(self, value): | |

# We want to return the nearest exact integer here. round() | |

# returns a float, and int() truncates its results, so we have | |

# to combine them. | |

return int(round(self.TIME_SCALE * float(value))) | |

def PrintableStatistic(self, value): | |

v = int(round(value)) | |

return ("%d" % v, v) | |

class _FirmwareKeySet(_TimeKeySet): | |

"""Concrete subclass of _KeySet for firmware time statistics.""" | |

PREFIX = 'seconds_power_on_to_' | |

# Time-based keyvals are reported in seconds and get converted to | |

# milliseconds | |

TIME_SCALE = 1000 | |

class _DiskKeySet(_KeySet): | |

"""Concrete subclass of _KeySet for disk read statistics.""" | |

PREFIX = 'rdbytes_kernel_to_' | |

# Disk read keyvals are reported in bytes and get converted to | |

# MBytes (1 MByte = 1 million bytes, not 2**20) | |

DISK_SCALE = 1.0e-6 | |

def _ConvertVal(self, value): | |

return self.DISK_SCALE * float(value) | |

def PrintableStatistic(self, value): | |

v = round(value, 1) | |

return ("%.1fM" % v, v) |