blob: 6e78e93044ab16d02fc8d47b9a74194f652412d2 [file] [log] [blame]
# 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)