diff --git a/bootperf-bin/bootperf b/bootperf-bin/bootperf
deleted file mode 100755
index f01f160..0000000
--- a/bootperf-bin/bootperf
+++ /dev/null
@@ -1,245 +0,0 @@
-#!/bin/bash
-
-# 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.
-
-# Wrapper to run the platform_BootPerfServer autotest, and store the
-# results for later analysis by the 'showbootdata' script.
-#
-# NOTE: This script must be run from inside the chromeos build
-# chroot environment.
-#
-
-# --- BEGIN COMMON.SH BOILERPLATE ---
-# Load common CrOS utilities.  Inside the chroot this file is installed in
-# /usr/lib/crosutils.  Outside the chroot we find it relative to the script's
-# location.
-find_common_sh() {
-  local common_paths=(/usr/lib/crosutils "$(dirname "$(readlink -f "$0")")/..")
-  local path
-
-  SCRIPT_ROOT=
-  for path in "${common_paths[@]}"; do
-    if [ -r "${path}/common.sh" ]; then
-      SCRIPT_ROOT=${path}
-      break
-    fi
-  done
-}
-
-find_common_sh
-. "${SCRIPT_ROOT}/common.sh" || (echo "Unable to load common.sh" && exit 1)
-# --- END COMMON.SH BOILERPLATE ---
-
-# TODO(jrbarnette) The log files produced in this script will be
-# stored inside the chroot.  So, from outside the chroot, this
-# script doesn't work.  I don't know if this is easy to fix, but
-# you're welcome to try.  Let me know how it goes.  :-)
-assert_inside_chroot
-
-DEFINE_string output_dir "" "output directory for results" o
-DEFINE_string board "" "name of board we are testing"
-DEFINE_boolean keep_logs "$FLAGS_FALSE" "keep autotest results" k
-
-RUN_TEST="test_that"
-TEST='f:.*/platform_BootPerfServer/control'
-TMP_RESULTS="$(mktemp -d /tmp/bootperf.XXXXXX)"
-RESULTS_ROOT=results-1-experimental_BootPerfServer
-RESULTS_DIR=platform_BootPerfServer/results
-RESULTS_KEYVAL=$RESULTS_DIR/keyval
-RESULTS_SUMMARY_FILES=(
-  $RESULTS_DIR
-  keyval
-  platform_BootPerfServer/keyval
-  platform_BootPerfServer/platform_BootPerf/keyval
-  platform_BootPerfServer/platform_BootPerf/status
-  platform_BootPerfServer/status
-  platform_BootPerfServer/status.log
-  platform_BootPerfServer/sysinfo/cmdline
-  platform_BootPerfServer/sysinfo/cpuinfo
-  platform_BootPerfServer/sysinfo/modules
-  platform_BootPerfServer/sysinfo/uname
-  platform_BootPerfServer/sysinfo/version
-  status.log
-)
-
-# Structure of a results directory:
-#   $RUNDIR.$ITER/          - directory
-#       $RUNDIR_LOG             - file
-#       $RUNDIR_SUMMARY/        - directory
-#       $RUNDIR_ALL_RESULTS/    - optional directory
-#   $KEYVAL_SUMMARY/        - file
-# If you add any other content under the results directory, you'll
-# probably need to change extra_files(), below.
-RUNDIR=run
-RUNDIR_LOG=log.txt
-RUNDIR_SUMMARY=summary
-RUNDIR_ALL_RESULTS=logs
-KEYVAL_SUMMARY=results_keyval
-
-
-# Usage/help function.  This function is known to the shflags library,
-# and mustn't be renamed.
-flags_help() {
-  cat <<END_USAGE >&2
-usage: $(basename $0) [ <options> ] <ip-address> [ <count> ]
-Options:
-  --output_dir <directory>
-  --o <directory>       Specify output directory for results
-
-  --board <BOARDNAME>   name of board we are testing (e.g. daisy)
-
-  --[no]keep_logs
-  -k                    Keep [don't keep] autotest log files
-Summary:
-  Run the platform_BootPerfServer autotest, and store results in the
-  given destination directory.  The test target is specified by
-  <ip-address>.
-
-  By default, the test is run once; if <count> is given, the test is
-  run that many times.  Note that the platform_BootPerfServer test
-  reboots the target 10 times, so the total number of reboots will
-  be 10*<count>.
-
-  If the destination directory doesn't exist, it is created.  If the
-  destination directory already holds test results, additional
-  results are added in without overwriting earlier results.
-
-  If no destination is specified, the current directory is used,
-  provided that the directory is empty, or has been previously used
-  as a destination directory for this command.
-
-  By default, only a summary subset of the log files created by
-  autotest is preserved; with --keep_logs the (potentially large)
-  autotest logs are preserved with the test results.
-END_USAGE
-  return $FLAGS_TRUE
-}
-
-usage() {
-  if [ $# -gt 0 ]; then
-    error "$(basename $0): $*"
-    echo >&2
-  fi
-  flags_help
-  exit 1
-}
-
-# List any files in the current directory not created as output
-# from running this script.
-extra_files() {
-  ls | grep -v "^$RUNDIR[.]...\$" |
-       grep -v $KEYVAL_SUMMARY
-}
-
-# Main function to run the boot performance test.  Run the boot
-# performance test for the given count, putting output into the
-# current directory.
-#
-# Arguments are <ip-address> and <count> arguments, as for the main
-# command.
-#
-# We terminate test runs if "test_that" ever fails to produce the
-# results keyval file; generally this is the result of a serious
-# error (e.g. disk full) that won't go away if we just plow on.
-run_boot_test() {
-  local remote="$1"
-  local count="${2:-1}"
-
-  local iter=$(expr "$(echo $RUNDIR.???)" : '.*\(...\)')
-  if [ "$iter" != "???" ]; then
-      iter=$(echo $iter | awk '{printf "%03d\n", $1 + 1}')
-  else
-      iter=000
-  fi
-
-  i=0
-  while [ $i -lt $count ]; do
-    local iter_rundir=$RUNDIR.$iter
-    local logfile=$(pwd)/$iter_rundir/$RUNDIR_LOG
-    local summary_dir=$iter_rundir/$RUNDIR_SUMMARY
-    local all_results_dir=$iter_rundir/$RUNDIR_ALL_RESULTS
-
-    mkdir $iter_rundir
-    echo "$(date '+%T') - $logfile"
-
-    $RUN_TEST --results_dir="$TMP_RESULTS" \
-              "$remote" $BOARD $TEST >$logfile 2>&1
-    if [ ! -e "$TMP_RESULTS/$RESULTS_ROOT/$RESULTS_KEYVAL" ]; then
-      error "No results file; terminating test runs."
-      error "Check $logfile for output from the test run,"
-      error "and see $TMP_RESULTS for full test logs and output."
-      return
-    fi
-    mkdir $summary_dir
-    tar cf - -C $TMP_RESULTS/$RESULTS_ROOT "${RESULTS_SUMMARY_FILES[@]}" |
-      tar xf - -C $summary_dir
-    if [ $FLAGS_keep_logs -eq $FLAGS_TRUE ]; then
-      mv $TMP_RESULTS $all_results_dir
-      chmod 755 $all_results_dir
-    else
-      rm -rf $TMP_RESULTS
-    fi
-    i=$(expr $i + 1)
-    iter=$(echo $iter | awk '{printf "%03d\n", $1 + 1}')
-  done
-  date '+%T'
-  cat $RUNDIR.???/$RUNDIR_SUMMARY/$RESULTS_KEYVAL >$KEYVAL_SUMMARY
-}
-
-# Main routine - check validity of the (already parsed) command line
-# options.  'cd' to the results directory, if it was specified.  If
-# all the arguments checks pass, hand control to run_boot_test
-main() {
-  if [ $# -lt 1 ]; then
-      usage "Missing target host address"
-  elif [ $# -gt 2 ]; then
-      usage "Too many arguments"
-  fi
-
-  if [ -n "${FLAGS_board}" ]; then
-    BOARD="--board=${FLAGS_board}"
-  fi
-
-  if [ -n "${FLAGS_output_dir}" ]; then
-    if [ ! -d "${FLAGS_output_dir}" ]; then
-      if ! mkdir "${FLAGS_output_dir}"; then
-        usage "Unable to create ${FLAGS_output_dir}"
-      fi
-    fi
-    cd "${FLAGS_output_dir}" ||
-      usage "No permissions to chdir to ${FLAGS_output_dir}"
-  elif [ -n "$(extra_files)" ]; then
-    error "No results directory specified, and current directory"
-    error "contains contents other than run results."
-    error "You can override this error by using the --output_dir option"
-    usage
-  fi
-
-  # Check the count argument.
-  # N.B. the test [ "$2" -eq "$2" ] tests whether "$2" is valid as a
-  # number; when it fails it will also report a syntax error (which
-  # we suppress).
-  if [ -n "$2" ]; then
-    if ! [ "$2" -eq "$2" ] 2>/dev/null || [ "$2" -le 0 ]; then
-      usage "<count> argument must be a positive number"
-    fi
-  fi
-
-  run_boot_test "$@"
-}
-
-# shflags defines --help implicitly; if it's used on the command
-# line FLAGS will invoke flags_help, set FLAGS_help to TRUE, and
-# then return false.  To avoid printing help twice, we have to check
-# for that case here.
-if ! FLAGS "$@"; then
-  if [ ${FLAGS_help} -eq ${FLAGS_TRUE} ]; then
-    exit 0
-  else
-    usage
-  fi
-fi
-
-eval main "${FLAGS_ARGV}"
diff --git a/bootperf-bin/perfprinter.py b/bootperf-bin/perfprinter.py
deleted file mode 100644
index 4d33ddf..0000000
--- a/bootperf-bin/perfprinter.py
+++ /dev/null
@@ -1,71 +0,0 @@
-# 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.
-
-"""Routines for printing boot time performance test results."""
-
-import resultset
-
-
-def PrintRawData(reader, dirlist, keytype, keylist):
-  """Print 'bootperf' results in "raw data" format."""
-  for dir_ in dirlist:
-    results = reader(dir_)
-    keyset = results.KeySet(keytype)
-    for i in range(0, keyset.num_iterations):
-      if len(dirlist) > 1:
-        line = "%s %3d" % (results.name, i)
-      else:
-        line = "%3d" % i
-      if keylist is not None:
-        markers = keylist
-      else:
-        markers = keyset.markers
-      for stat in markers:
-        (_, v) = keyset.PrintableStatistic(keyset.RawData(stat)[i])
-        line += " %5s" % str(v)
-      print line
-
-
-def PrintStatisticsSummary(reader, dirlist, keytype, keylist):
-  """Print 'bootperf' results in "summary of averages" format."""
-  if (keytype == resultset.TestResultSet.BOOTTIME_KEYSET or
-      keytype == resultset.TestResultSet.FIRMWARE_KEYSET):
-    header = "%5s %3s  %5s %3s  %s" % (
-        "time", "s%", "dt", "s%", "event")
-    tformat = "%5s %2d%%  %5s %2d%%  %s"
-  else:
-    header = "%7s %3s  %7s %3s  %s" % (
-        "diskrd", "s%", "delta", "s%", "event")
-    tformat = "%7s %2d%%  %7s %2d%%  %s"
-  havedata = False
-  for dir_ in dirlist:
-    results = reader(dir_)
-    keyset = results.KeySet(keytype)
-    if keylist is not None:
-      markers = keylist
-    else:
-      markers = keyset.markers
-    if havedata:
-      print
-    if len(dirlist) > 1:
-      print "%s" % results.name,
-    print "(on %d cycles):" % keyset.num_iterations
-    print header
-    prevvalue = 0
-    prevstat = None
-    for stat in markers:
-      (valueavg, valuedev) = keyset.Statistics(stat)
-      valuepct = int(100 * valuedev / valueavg + 0.5)
-      if prevstat:
-        (deltaavg, deltadev) = keyset.DeltaStatistics(prevstat, stat)
-        deltapct = int(100 * deltadev / deltaavg + 0.5)
-      else:
-        deltapct = valuepct
-      (valstring, val_printed) = keyset.PrintableStatistic(valueavg)
-      delta = val_printed - prevvalue
-      (deltastring, _) = keyset.PrintableStatistic(delta)
-      print tformat % (valstring, valuepct, "+" + deltastring, deltapct, stat)
-      prevvalue = val_printed
-      prevstat = stat
-    havedata = True
diff --git a/bootperf-bin/resultsdir.py b/bootperf-bin/resultsdir.py
deleted file mode 100644
index 942a275..0000000
--- a/bootperf-bin/resultsdir.py
+++ /dev/null
@@ -1,68 +0,0 @@
-# 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.
-
-"""Routines for reading performance results from a directory.
-
-The directory should match the format created by the 'bootperf'
-script; see comments in that script for a summary of the layout.
-
-"""
-
-import fnmatch
-import os
-import re
-
-import resultset
-
-
-_PERF_KEYVAL_PATTERN = re.compile("(.*){perf}=(.*)\n")
-
-
-def _ReadKeyvalFile(results, file_):
-  """Read an autotest keyval file, and process the results.
-
-  The `file_` parameter is a file object with contents in autotest
-  perf keyval format:
-      <keyname>{perf}=<value>
-
-  Each iteration of the test is terminated with a single blank line,
-  including the last iteration.  Each iteration's results are added
-  to the `results` parameter, which should be an instance of
-  TestResultSet.
-
-  """
-  kvd = {}
-  for line in iter(file_):
-    if line == "\n":
-      results.AddIterationResults(kvd)
-      kvd = {}
-      continue
-    m = _PERF_KEYVAL_PATTERN.match(line)
-    if m is None:
-      continue
-    kvd[m.group(1)] = m.group(2)
-
-
-_RESULTS_PATH = "summary/platform_BootPerfServer/results/keyval"
-
-
-def ReadResultsDirectory(dir_):
-  """Process results from a 'bootperf' output directory.
-
-  The accumulated results are returned in a newly created
-  TestResultSet object.
-
-  """
-  res_set = resultset.TestResultSet(dir_)
-  dirlist = fnmatch.filter(os.listdir(dir_), "run.???")
-  dirlist.sort()
-  for rundir in dirlist:
-    keyval_path = os.path.join(dir_, rundir, _RESULTS_PATH)
-    try:
-      kvf = open(keyval_path)
-    except IOError:
-      continue
-    _ReadKeyvalFile(res_set, kvf)
-  res_set.FinalizeResults()
-  return res_set
diff --git a/bootperf-bin/resultset.py b/bootperf-bin/resultset.py
deleted file mode 100644
index 6e78e93..0000000
--- a/bootperf-bin/resultset.py
+++ /dev/null
@@ -1,260 +0,0 @@
-# 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)
diff --git a/bootperf-bin/showbootdata b/bootperf-bin/showbootdata
deleted file mode 100755
index 009698a..0000000
--- a/bootperf-bin/showbootdata
+++ /dev/null
@@ -1,158 +0,0 @@
-#!/usr/bin/python
-
-# 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.
-
-"""A command to display summary statistics from runs of 'bootperf'.
-
-Command line options allow selecting from one of three sets of
-performance statistics:  boot time statistics (selected by
---timestats) measure time spent since kernel startup; disk statistics
-(selected by --diskstats) measure total bytes read from the boot
-device since kernel startup; firmware time statistics (selected by
---firmware) measure time spent since CPU power on.
-
-The various statistics are recorded as cumulative time (or disk read)
-since kernel startup (or CPU power on), sampled when specific events
-occur during boot.  Events include such things as 'startup', the
-moment when the upstart 'startup' job begins running, and 'login',
-when the Chrome OS login screen is displayed.  By default, all
-recorded events are included in the output; command line options
-allow restricting the view to a selected subset of events.
-
-Separate command line options allow selecting from one of two
-different display modes.  When --averages is selected, the display
-shows the average value and sample standard deviation (as a percent
-of the average) for all selected events.  The --averages display
-also calculates the difference (in time or bytes) between adjacent
-events, and shows the average and sample standard deviation of the
-differences.
-
-The --rawdata display shows the raw data value associated with each
-event for each boot:  Each line of output represents the event values
-for one boot cycle.
-
-"""
-
-import sys
-import optparse
-
-import perfprinter
-import resultsdir
-import resultset
-
-
-_USAGE = "%prog [options] [results-directory ...]"
-_DESCRIPTION = """\
-Summarize boot time performance results.  The result directory
-arguments are directories previously specified as output for the
-'bootperf' script.
-"""
-
-
-def _SetupOptions():
-  optparser = optparse.OptionParser(usage=_USAGE, description=_DESCRIPTION)
-
-  optgroup = optparse.OptionGroup(
-      optparser, "Selecting boot time or disk statistics (choose one)")
-  optgroup.add_option(
-      "-t", "--timestats", action="store_true",
-      dest="use_timestats",
-      help="use statistics for time since kernel startup (default)")
-  optgroup.add_option(
-      "-d", "--diskstats", action="store_true",
-      dest="use_diskstats",
-      help="use statistics for bytes read since kernel startup")
-  optgroup.add_option(
-      "-f", "--firmwarestats", action="store_true",
-      dest="use_firmware",
-      help="use statistics for firmware startup times")
-  optparser.add_option_group(optgroup)
-  optparser.set_defaults(use_diskstats=False)
-  optparser.set_defaults(use_timestats=False)
-  optparser.set_defaults(use_firmware=False)
-
-  optgroup = optparse.OptionGroup(optparser, "Event selection")
-  optgroup.add_option(
-      "-e", "--event", action="append",
-      dest="eventnames",
-      help="restrict statistics to the comma-separated list of events")
-  optparser.add_option_group(optgroup)
-
-  optgroup = optparse.OptionGroup(
-      optparser, "Display mode selection (choose one)")
-  optgroup.add_option(
-      "-a", "--averages", action="store_true",
-      dest="print_averages",
-      help="display a summary of the averages of chosen statistics (default)")
-  optgroup.add_option(
-      "-r", "--rawdata", action="store_true",
-      dest="print_raw",
-      help="display raw data from all boot iterations")
-  optparser.add_option_group(optgroup)
-  optparser.set_defaults(print_averages=False)
-  optparser.set_defaults(print_raw=False)
-  return optparser
-
-
-def _ProcessDisplayOptions(options):
-  display_count = 0
-  if options.print_averages:
-    display_count += 1
-    printfunc = perfprinter.PrintStatisticsSummary
-  if options.print_raw:
-    display_count += 1
-    printfunc = perfprinter.PrintRawData
-  if display_count == 0:
-    printfunc = perfprinter.PrintStatisticsSummary
-  elif display_count > 1:
-    print >>sys.stderr, "Can't use -a and -r together.\n"
-    return None
-  return printfunc
-
-
-def _ProcessKeysetOptions(options):
-  keyset_count = 0
-  keyset_type = resultset.TestResultSet.BOOTTIME_KEYSET
-  if options.use_timestats:
-    keyset_count += 1
-    keyset_type = resultset.TestResultSet.BOOTTIME_KEYSET
-  if options.use_diskstats:
-    keyset_count += 1
-    keyset_type = resultset.TestResultSet.DISK_KEYSET
-  if options.use_firmware:
-    keyset_count += 1
-    keyset_type = resultset.TestResultSet.FIRMWARE_KEYSET
-  if keyset_count > 1:
-    print >>sys.stderr, "Can use only one of -t, -d, or -f.\n"
-    keyset_type = None
-  return keyset_type
-
-
-def _ProcessKeylistOptions(options):
-  if not options.eventnames:
-    return None
-  keylist = []
-  for kl in options.eventnames:
-    keylist.extend(kl.split(','))
-  return keylist
-
-
-def main(argv):
-  optparser = _SetupOptions()
-  (options, args) = optparser.parse_args(argv)
-  printfunc = _ProcessDisplayOptions(options)
-  keyset_type = _ProcessKeysetOptions(options)
-  keylist = _ProcessKeylistOptions(options)
-  if printfunc is None or keyset_type is None:
-    optparser.print_help()
-    sys.exit(1)
-  if not args:
-    args = ["."]
-  printfunc(resultsdir.ReadResultsDirectory,
-            args, keyset_type, keylist)
-
-
-if __name__ == "__main__":
-  main(sys.argv[1:])