diff --git a/crosperf/benchmark.py b/crosperf/benchmark.py
index a75bd8e..bc7f1fa 100644
--- a/crosperf/benchmark.py
+++ b/crosperf/benchmark.py
@@ -21,3 +21,4 @@
     self.iterations = iterations
     self.outlier_range = outlier_range
     self.perf_args = perf_args
+    self.iteration_adjusted = False
diff --git a/crosperf/benchmark_run.py b/crosperf/benchmark_run.py
index 7579b6c..dc83793 100644
--- a/crosperf/benchmark_run.py
+++ b/crosperf/benchmark_run.py
@@ -4,16 +4,16 @@
 
 import datetime
 import os
-import re
 import threading
 import time
 import traceback
 
+from utils import command_executer
+from utils import timeline
+
 from autotest_runner import AutotestRunner
 from results_cache import Result
 from results_cache import ResultsCache
-from utils import command_executer
-from utils import logger
 
 STATUS_FAILED = "FAILED"
 STATUS_SUCCEEDED = "SUCCEEDED"
@@ -24,53 +24,50 @@
 
 
 class BenchmarkRun(threading.Thread):
-  def __init__(self, name, benchmark_name, autotest_name, autotest_args,
-               label_name, chromeos_root, chromeos_image, board, iteration,
-               cache_conditions, outlier_range, perf_args,
+  def __init__(self, name, benchmark,
+               label,
+               iteration,
+               cache_conditions,
                machine_manager,
                logger_to_use):
     threading.Thread.__init__(self)
     self.name = name
     self._logger = logger_to_use
-    self.benchmark_name = benchmark_name
-    self.autotest_name = autotest_name
-    self.label_name = label_name
-    self.chromeos_root = chromeos_root
-    self.chromeos_image = os.path.expanduser(chromeos_image)
-    self.board = board
+    self.benchmark = benchmark
     self.iteration = iteration
+    self.label = label
     self.result = None
     self.terminated = False
     self.retval = None
-    self.status = STATUS_PENDING
     self.run_completed = False
-    self.outlier_range = outlier_range
-    self.perf_args = perf_args
     self.machine_manager = machine_manager
     self.cache = ResultsCache()
     self.autotest_runner = AutotestRunner(self._logger)
     self.machine = None
-    self.full_name = self.autotest_name
     self.cache_conditions = cache_conditions
     self.runs_complete = 0
     self.cache_hit = False
     self.failure_reason = ""
-    self.autotest_args = "%s %s" % (autotest_args, self._GetExtraAutotestArgs())
+    self.autotest_args = "%s %s" % (benchmark.autotest_args,
+                                    self._GetExtraAutotestArgs())
     self._ce = command_executer.GetCommandExecuter(self._logger)
+    self.timeline = timeline.Timeline()
+    self.timeline.Record(STATUS_PENDING)
 
   def run(self):
     try:
       # Just use the first machine for running the cached version,
       # without locking it.
-      self.cache.Init(self.chromeos_image,
-                      self.chromeos_root,
-                      self.autotest_name,
+      self.cache.Init(self.label.chromeos_image,
+                      self.label.chromeos_root,
+                      self.benchmark.autotest_name,
                       self.iteration,
                       self.autotest_args,
                       self.machine_manager,
-                      self.board,
+                      self.label.board,
                       self.cache_conditions,
                       self._logger,
+                      self.label
                      )
 
       self.result = self.cache.ReadResult()
@@ -78,10 +75,12 @@
 
       if self.result:
         self._logger.LogOutput("%s: Cache hit." % self.name)
-        self._logger.LogOutput(self.result.out + "\n" + self.result.err)
+        self._logger.LogOutput(self.result.out, print_to_console=False)
+        self._logger.LogError(self.result.err, print_to_console=False)
+
       else:
         self._logger.LogOutput("%s: No cache hit." % self.name)
-        self.status = STATUS_WAITING
+        self.timeline.Record(STATUS_WAITING)
         # Try to acquire a machine now.
         self.machine = self.AcquireMachine()
         self.cache.remote = self.machine.name
@@ -92,17 +91,17 @@
         return
 
       if not self.result.retval:
-        self.status = STATUS_SUCCEEDED
+        self.timeline.Record(STATUS_SUCCEEDED)
       else:
-        if self.status != STATUS_FAILED:
-          self.status = STATUS_FAILED
+        if self.timeline.GetLastEvent() != STATUS_FAILED:
           self.failure_reason = "Return value of autotest was non-zero."
+          self.timeline.Record(STATUS_FAILED)
 
     except Exception, e:
       self._logger.LogError("Benchmark run: '%s' failed: %s" % (self.name, e))
       traceback.print_exc()
-      if self.status != STATUS_FAILED:
-        self.status = STATUS_FAILED
+      if self.timeline.GetLastEvent() != STATUS_FAILED:
+        self.timeline.Record(STATUS_FAILED)
         self.failure_reason = str(e)
     finally:
       if self.machine:
@@ -113,15 +112,17 @@
   def Terminate(self):
     self.terminated = True
     self.autotest_runner.Terminate()
-    if self.status != STATUS_FAILED:
-      self.status = STATUS_FAILED
+    if self.timeline.GetLastEvent() != STATUS_FAILED:
+      self.timeline.Record(STATUS_FAILED)
       self.failure_reason = "Thread terminated."
 
   def AcquireMachine(self):
     while True:
       if self.terminated:
         raise Exception("Thread terminated while trying to acquire machine.")
-      machine = self.machine_manager.AcquireMachine(self.chromeos_image)
+      machine = self.machine_manager.AcquireMachine(self.label.chromeos_image,
+                                                    self.label)
+
       if machine:
         self._logger.LogOutput("%s: Machine %s acquired at %s" %
                                (self.name,
@@ -134,8 +135,8 @@
     return machine
 
   def _GetExtraAutotestArgs(self):
-    if self.perf_args:
-      perf_args_list = self.perf_args.split(" ")
+    if self.benchmark.perf_args:
+      perf_args_list = self.benchmark.perf_args.split(" ")
       perf_args_list = [perf_args_list[0]] + ["-a"] + perf_args_list[1:]
       perf_args = " ".join(perf_args_list)
       if not perf_args_list[0] in ["record", "stat"]:
@@ -148,24 +149,47 @@
       return ""
 
   def RunTest(self, machine):
-    self.status = STATUS_IMAGING
+    self.timeline.Record(STATUS_IMAGING)
     self.machine_manager.ImageMachine(machine,
-                                      self.chromeos_image,
-                                      self.board)
-    self.status = "%s %s" % (STATUS_RUNNING, self.autotest_name)
+                                      self.label)
+    self.timeline.Record(STATUS_RUNNING)
     [retval, out, err] = self.autotest_runner.Run(machine.name,
-                                                  self.chromeos_root,
-                                                  self.board,
-                                                  self.autotest_name,
+                                                  self.label.chromeos_root,
+                                                  self.label.board,
+                                                  self.benchmark.autotest_name,
                                                   self.autotest_args)
     self.run_completed = True
 
     return Result.CreateFromRun(self._logger,
-                                self.chromeos_root,
-                                self.board,
+                                self.label.chromeos_root,
+                                self.label.board,
+                                self.label.name,
                                 out,
                                 err,
                                 retval)
 
   def SetCacheConditions(self, cache_conditions):
     self.cache_conditions = cache_conditions
+
+
+class MockBenchmarkRun(BenchmarkRun):
+  """Inherited from BenchmarkRun, just overide RunTest for testing."""
+
+  def RunTest(self, machine):
+    """Remove Result.CreateFromRun for testing."""
+    self.timeline.Record(STATUS_IMAGING)
+    self.machine_manager.ImageMachine(machine,
+                                      self.label)
+    self.timeline.Record(STATUS_RUNNING)
+    [retval, out, err] = self.autotest_runner.Run(machine.name,
+                                                  self.label.chromeos_root,
+                                                  self.label.board,
+                                                  self.benchmark.autotest_name,
+                                                  self.autotest_args)
+    self.run_completed = True
+    rr = Result("Results placed in /tmp/test", "", 0)
+    rr.out = out
+    rr.err = err
+    rr.retval = retval
+    return rr
+
diff --git a/crosperf/benchmark_run_unittest.py b/crosperf/benchmark_run_unittest.py
index c4c3fdf..c4670c9 100755
--- a/crosperf/benchmark_run_unittest.py
+++ b/crosperf/benchmark_run_unittest.py
@@ -1,38 +1,42 @@
 #!/usr/bin/python
 
-# 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.
+# Copyright 2011 Google Inc. All Rights Reserved.
+
+"""Testing of benchmark_run."""
 
 import unittest
+
+from utils import logger
+
 from autotest_runner import MockAutotestRunner
-from benchmark_run import BenchmarkRun
+from benchmark_run import MockBenchmarkRun
+from label import MockLabel
+from benchmark import Benchmark
 from machine_manager import MockMachineManager
 from results_cache import MockResultsCache
-from utils import logger
 
 
 class BenchmarkRunTest(unittest.TestCase):
   def testDryRun(self):
-    m = MockMachineManager()
+    my_label = MockLabel("test1", "image1", "/tmp/test_benchmark_run",
+                         "x86-alex", "chromeos-alex1", "")
+    m = MockMachineManager("/tmp/chromeos_root")
     m.AddMachine("chromeos-alex1")
-    b = BenchmarkRun("test run",
-                     "PageCycler",
-                     "PageCycler",
-                     "",
-                     "image1",
-                     "/tmp/test",
-                     "/tmp/test/image",
-                     "x86-alex",
-                     1,
-                     [],
-                     0.2,
-                     "",
-                     "none",
-                     m,
-                     MockResultsCache(),
-                     MockAutotestRunner(),
-                     logger.GetLogger())
+    bench = Benchmark("PageCyler",
+                      "Pyautoperf",
+                      "",
+                      1,
+                      0.2,
+                      "")
+    b = MockBenchmarkRun("test run",
+                         bench,
+                         my_label,
+                         1,
+                         [],
+                         m,
+                         logger.GetLogger())
+    b.cache = MockResultsCache()
+    b.autotest_runner = MockAutotestRunner()
     b.start()
 
 
diff --git a/crosperf/crosperf b/crosperf/crosperf
index 286bf25..904a172 100755
--- a/crosperf/crosperf
+++ b/crosperf/crosperf
@@ -1,2 +1,2 @@
 #!/bin/bash
-PYTHONPATH=$PYTHONPATH:$(dirname $0)/.. python $(dirname $0)/crosperf.py "$@"
+PYTHONPATH=$(dirname $0)/..:$PYTHONPATH python $(dirname $0)/crosperf.py "$@"
diff --git a/crosperf/crosperf.py b/crosperf/crosperf.py
index 2469933..cfb48d7 100755
--- a/crosperf/crosperf.py
+++ b/crosperf/crosperf.py
@@ -16,6 +16,7 @@
 from settings_factory import GlobalSettings
 from utils import logger
 
+import test_flag
 
 l = logger.GetLogger()
 
@@ -77,6 +78,9 @@
     parser.error("Invalid number arguments.")
 
   working_directory = os.getcwd()
+  if options.dry_run:
+    test_flag.SetTestMode(True)
+
   experiment_file = ExperimentFile(open(experiment_filename, "rb"),
                                    option_settings)
   if not experiment_file.GetGlobalSettings().GetField("name"):
diff --git a/crosperf/default_remotes b/crosperf/default_remotes
new file mode 100644
index 0000000..5efaebc
--- /dev/null
+++ b/crosperf/default_remotes
@@ -0,0 +1,5 @@
+x86-zgb  : chromeos1-rack3-host4.cros chromeos1-rack3-host5.cros chromeos1-rack3-host6.cros
+x86-alex : chromeos2-row1-rack4-host7.cros chromeos2-row1-rack4-host8.cros chromeos2-row1-rack4-host9.cros
+lumpy    : chromeos2-row2-rack4-host10.cros chromeos2-row2-rack4-host11.cros chromeos2-row2-rack4-host12.cros
+stumpy   : chromeos2-row3-rack7-host1.cros chromeos2-row3-rack7-host2.cros chromeos2-row3-rack7-host3.cros
+
diff --git a/crosperf/experiment.py b/crosperf/experiment.py
index 7b48344..e9dc3d0 100644
--- a/crosperf/experiment.py
+++ b/crosperf/experiment.py
@@ -2,15 +2,20 @@
 
 # Copyright 2011 Google Inc. All Rights Reserved.
 
+"""The experiment setting module."""
+
 import os
 import time
+
+from utils import logger
+
 from autotest_runner import AutotestRunner
 from benchmark_run import BenchmarkRun
 from machine_manager import MachineManager
+from machine_manager import MockMachineManager
 from results_cache import ResultsCache
 from results_report import HTMLResultsReport
-from utils import logger
-from utils.file_utils import FileUtils
+import test_flag
 
 
 class Experiment(object):
@@ -33,6 +38,7 @@
     self.labels = labels
     self.benchmarks = benchmarks
     self.num_complete = 0
+    self.num_run_complete = 0
 
     # We need one chromeos_root to run the benchmarks in, but it doesn't
     # matter where it is, unless the ABIs are different.
@@ -44,13 +50,17 @@
       raise Exception("No chromeos_root given and could not determine one from "
                       "the image path.")
 
-    self.machine_manager = MachineManager(chromeos_root)
+    if test_flag.GetTestMode():
+      self.machine_manager = MockMachineManager(chromeos_root)
+    else:
+      self.machine_manager = MachineManager(chromeos_root)
     self.l = logger.GetLogger()
 
     for machine in remote:
       self.machine_manager.AddMachine(machine)
-    self.machine_manager.ComputeCommonCheckSum()
-    self.machine_manager.ComputeCommonCheckSumString()
+    for label in labels:
+      self.machine_manager.ComputeCommonCheckSum(label)
+      self.machine_manager.ComputeCommonCheckSumString(label)
 
     self.start_time = None
     self.benchmark_runs = self._GenerateBenchmarkRuns()
@@ -69,17 +79,10 @@
                                         "run.%s" % (full_name),
                                         True)
           benchmark_run = BenchmarkRun(benchmark_run_name,
-                                       benchmark.name,
-                                       benchmark.autotest_name,
-                                       benchmark.autotest_args,
-                                       label.name,
-                                       label.chromeos_root,
-                                       label.chromeos_image,
-                                       label.board,
+                                       benchmark,
+                                       label,
                                        iteration,
                                        self.cache_conditions,
-                                       benchmark.outlier_range,
-                                       benchmark.perf_args,
                                        self.machine_manager,
                                        logger_to_use)
 
@@ -102,6 +105,8 @@
           t.join(0)
         if not t.isAlive():
           self.num_complete += 1
+          if not t.cache_hit:
+            self.num_run_complete += 1
           self.active_threads.remove(t)
       return False
     return True
diff --git a/crosperf/experiment_factory.py b/crosperf/experiment_factory.py
index 5c21179..bd3076d 100644
--- a/crosperf/experiment_factory.py
+++ b/crosperf/experiment_factory.py
@@ -1,11 +1,17 @@
 #!/usr/bin/python
 
 # Copyright 2011 Google Inc. All Rights Reserved.
+"""A module to generate experments."""
+
+import os
+import socket
 
 from benchmark import Benchmark
 from experiment import Experiment
 from label import Label
+from label import MockLabel
 from results_cache import CacheConditions
+import test_flag
 
 
 class ExperimentFactory(object):
@@ -32,7 +38,9 @@
       cache_conditions.append(CacheConditions.RUN_SUCCEEDED)
     if global_settings.GetField("rerun"):
       cache_conditions.append(CacheConditions.FALSE)
-    if global_settings.GetField("exact_remote"):
+    if global_settings.GetField("same_machine"):
+      cache_conditions.append(CacheConditions.SAME_MACHINE_MATCH)
+    if global_settings.GetField("same_specs"):
       cache_conditions.append(CacheConditions.MACHINES_MATCH)
 
     # Construct benchmarks.
@@ -54,20 +62,61 @@
     # Construct labels.
     labels = []
     all_label_settings = experiment_file.GetSettings("label")
+    all_remote = list(remote)
     for label_settings in all_label_settings:
       label_name = label_settings.name
       image = label_settings.GetField("chromeos_image")
       chromeos_root = label_settings.GetField("chromeos_root")
       board = label_settings.GetField("board")
-      label = Label(label_name, image, chromeos_root, board)
+      my_remote = label_settings.GetField("remote")
+    # TODO(yunlian): We should consolidate code in machine_manager.py
+    # to derermine whether we are running from within google or not
+      if ("corp.google.com" in socket.gethostname() and
+          (not my_remote
+           or my_remote == remote
+           and global_settings.GetField("board") != board)):
+        my_remote = self.GetDefaultRemotes(board)
+      if global_settings.GetField("same_machine") and len(my_remote) > 1:
+        raise Exception("Only one remote is allowed when same_machine "
+                        "is turned on")
+      all_remote += my_remote
+      image_args = label_settings.GetField("image_args")
+      if test_flag.GetTestMode():
+        label = MockLabel(label_name, image, chromeos_root, board, my_remote,
+                          image_args)
+      else:
+        label = Label(label_name, image, chromeos_root, board, my_remote,
+                      image_args)
       labels.append(label)
 
     email = global_settings.GetField("email")
-
-    experiment = Experiment(experiment_name, remote, rerun_if_failed,
+    all_remote = list(set(all_remote))
+    experiment = Experiment(experiment_name, all_remote, rerun_if_failed,
                             working_directory, chromeos_root,
                             cache_conditions, labels, benchmarks,
                             experiment_file.Canonicalize(),
                             email)
 
     return experiment
+
+  def GetDefaultRemotes(self, board):
+    default_remotes_file = os.path.join(os.path.dirname(__file__),
+                                        "default_remotes")
+    try:
+      with open(default_remotes_file) as f:
+        for line in f:
+          key, v = line.split(":")
+          if key.strip() == board:
+            remotes = v.strip().split(" ")
+            if remotes:
+              return remotes
+            else:
+              raise Exception("There is not remote for {0}".format(board))
+    except IOError:
+      raise Exception("IOError while reading file {0}"
+                      .format(default_remotes_file))
+    else:
+      raise Exception("There is not remote for {0}".format(board))
+
+
+
diff --git a/crosperf/experiment_factory_unittest.py b/crosperf/experiment_factory_unittest.py
index e91295d..fa94351 100755
--- a/crosperf/experiment_factory_unittest.py
+++ b/crosperf/experiment_factory_unittest.py
@@ -4,10 +4,12 @@
 
 import StringIO
 import unittest
-from experiment_factory import ExperimentFactory
-from experiment_file import ExperimentFile
+
 from utils.file_utils import FileUtils
 
+from experiment_factory import ExperimentFactory
+from experiment_file import ExperimentFile
+import test_flag
 
 EXPERIMENT_FILE_1 = """
   board: x86-alex
@@ -47,4 +49,5 @@
 
 if __name__ == "__main__":
   FileUtils.Configure(True)
+  test_flag.SetTestMode(True)
   unittest.main()
diff --git a/crosperf/experiment_file_unittest.py b/crosperf/experiment_file_unittest.py
index 67da11e..d08c7eb 100755
--- a/crosperf/experiment_file_unittest.py
+++ b/crosperf/experiment_file_unittest.py
@@ -11,7 +11,7 @@
 EXPERIMENT_FILE_1 = """
   board: x86-alex
   remote: chromeos-alex3
-
+  perf_args: record -a -e cycles
   benchmark: PageCycler {
     iterations: 3
   }
@@ -21,6 +21,8 @@
   }
 
   image2 {
+    board: lumpy
+    remote: chromeos-lumpy1
     chromeos_image: /usr/local/google/cros_image2.bin
   }
   """
@@ -70,7 +72,8 @@
     experiment_file = ExperimentFile(input_file)
     global_settings = experiment_file.GetGlobalSettings()
     self.assertEqual(global_settings.GetField("remote"), ["chromeos-alex3"])
-
+    self.assertEqual(global_settings.GetField("perf_args"),
+                     "record -a -e cycles")
     benchmark_settings = experiment_file.GetSettings("benchmark")
     self.assertEqual(len(benchmark_settings), 1)
     self.assertEqual(benchmark_settings[0].name, "PageCycler")
@@ -82,6 +85,8 @@
     self.assertEqual(label_settings[0].GetField("board"), "x86-alex")
     self.assertEqual(label_settings[0].GetField("chromeos_image"),
                      "/usr/local/google/cros_image1.bin")
+    self.assertEqual(label_settings[1].GetField("remote"), ["chromeos-lumpy1"])
+    self.assertEqual(label_settings[0].GetField("remote"), ["chromeos-alex3"])
 
   def testOverrideSetting(self):
     input_file = StringIO.StringIO(EXPERIMENT_FILE_2)
diff --git a/crosperf/experiment_runner.py b/crosperf/experiment_runner.py
index 4219c43..b905bbd 100644
--- a/crosperf/experiment_runner.py
+++ b/crosperf/experiment_runner.py
@@ -2,19 +2,24 @@
 
 # Copyright 2011 Google Inc. All Rights Reserved.
 
+"""The experiment runner module."""
 import getpass
 import os
 import time
-from experiment_status import ExperimentStatus
-from results_report import HTMLResultsReport
-from results_report import TextResultsReport
+
 from utils import command_executer
 from utils import logger
 from utils.email_sender import EmailSender
 from utils.file_utils import FileUtils
 
+from experiment_status import ExperimentStatus
+from results_report import HTMLResultsReport
+from results_report import TextResultsReport
+
 
 class ExperimentRunner(object):
+  """ExperimentRunner Class."""
+
   STATUS_TIME_DELAY = 30
   THREAD_MONITOR_DELAY = 2
 
@@ -95,6 +100,7 @@
         benchmark_run_path = os.path.join(results_directory,
                                           benchmark_run_name)
         benchmark_run.result.CopyResultsTo(benchmark_run_path)
+        benchmark_run.result.CleanUp()
 
   def Run(self):
     self._Run(self._experiment)
@@ -105,6 +111,8 @@
 
 
 class MockExperimentRunner(ExperimentRunner):
+  """Mocked ExperimentRunner for testing."""
+
   def __init__(self, experiment):
     super(MockExperimentRunner, self).__init__(experiment)
 
diff --git a/crosperf/experiment_status.py b/crosperf/experiment_status.py
index ddf3f54..3a27066 100644
--- a/crosperf/experiment_status.py
+++ b/crosperf/experiment_status.py
@@ -2,14 +2,20 @@
 
 # Copyright 2011 Google Inc. All Rights Reserved.
 
+"""The class to show the banner."""
+
 import datetime
 import time
 
 
 class ExperimentStatus(object):
+  """The status class."""
+
   def __init__(self, experiment):
     self.experiment = experiment
     self.num_total = len(self.experiment.benchmark_runs)
+    self.completed = 0
+    self.new_job_start_time = time.time()
 
   def _GetProgressBar(self, num_complete, num_total):
     ret = "Done: %s%%" % int(100.0 * num_complete / num_total)
@@ -23,14 +29,23 @@
     return ret
 
   def GetProgressString(self):
+    """Get the elapsed_time, ETA."""
     current_time = time.time()
     if self.experiment.start_time:
       elapsed_time = current_time - self.experiment.start_time
     else:
       elapsed_time = 0
     try:
-      eta_seconds = (float(self.num_total - self.experiment.num_complete) *
-                     elapsed_time / self.experiment.num_complete)
+      if self.completed != self.experiment.num_complete:
+        self.completed = self.experiment.num_complete
+        self.new_job_start_time = current_time
+      time_completed_jobs = (elapsed_time -
+                             (current_time - self.new_job_start_time))
+      eta_seconds = (float(self.num_total - self.experiment.num_complete -1) *
+                     time_completed_jobs / self.experiment.num_run_complete
+                     + (time_completed_jobs / self.experiment.num_run_complete
+                        - (current_time - self.new_job_start_time)))
+
       eta_seconds = int(eta_seconds)
       eta = datetime.timedelta(seconds=eta_seconds)
     except ZeroDivisionError:
@@ -45,11 +60,12 @@
     return "\n".join(strings)
 
   def GetStatusString(self):
+    """Get the status string of all the benchmark_runs."""
     status_bins = {}
     for benchmark_run in self.experiment.benchmark_runs:
-      if benchmark_run.status not in status_bins:
-        status_bins[benchmark_run.status] = []
-      status_bins[benchmark_run.status].append(benchmark_run)
+      if benchmark_run.timeline.GetLastEvent() not in status_bins:
+        status_bins[benchmark_run.timeline.GetLastEvent()] = []
+      status_bins[benchmark_run.timeline.GetLastEvent()].append(benchmark_run)
 
     status_strings = []
     for key, val in status_bins.items():
@@ -64,6 +80,9 @@
 
   def _GetNamesAndIterations(self, benchmark_runs):
     strings = []
+    t = time.time()
     for benchmark_run in benchmark_runs:
-      strings.append("'%s'" % benchmark_run.name)
+      t_last = benchmark_run.timeline.GetLastEventTime()
+      elapsed = str(datetime.timedelta(seconds=int(t-t_last)))
+      strings.append("'{0}' {1}".format(benchmark_run.name, elapsed))
     return " %s (%s)" % (len(strings), ", ".join(strings))
diff --git a/crosperf/label.py b/crosperf/label.py
index 3b6fb80..64ce352 100644
--- a/crosperf/label.py
+++ b/crosperf/label.py
@@ -2,14 +2,24 @@
 
 # Copyright 2011 Google Inc. All Rights Reserved.
 
+"""The label of benchamrks."""
+
+import os
 from utils.file_utils import FileUtils
 
 
 class Label(object):
-  def __init__(self, name, chromeos_image, chromeos_root, board):
+  def __init__(self, name, chromeos_image, chromeos_root, board, remote,
+               image_args):
+    # Expand ~
+    chromeos_root = os.path.expanduser(chromeos_root)
+    chromeos_image = os.path.expanduser(chromeos_image)
+
     self.name = name
     self.chromeos_image = chromeos_image
     self.board = board
+    self.remote = remote
+    self.image_args = image_args
 
     if not chromeos_root:
       chromeos_root = FileUtils().ChromeOSRootFromImage(chromeos_image)
@@ -24,3 +34,17 @@
                         % (name, chromeos_root))
 
     self.chromeos_root = chromeos_root
+
+
+class MockLabel(object):
+  def __init__(self, name, chromeos_image, chromeos_root, board, remote,
+               image_args):
+    self.name = name
+    self.chromeos_image = chromeos_image
+    self.board = board
+    self.remote = remote
+    if not chromeos_root:
+      self.chromeos_root = "/tmp/chromeos_root"
+    else:
+      self.chromeos_root = chromeos_root
+    self.image_args = image_args
diff --git a/crosperf/machine_manager.py b/crosperf/machine_manager.py
index 8562e92..9eb9bcd 100644
--- a/crosperf/machine_manager.py
+++ b/crosperf/machine_manager.py
@@ -1,16 +1,23 @@
+#!/usr/bin/python
+#
+# Copyright 2012 Google Inc. All Rights Reserved.
+
 import hashlib
 import image_chromeos
 import lock_machine
 import math
 import os.path
+import re
 import sys
 import threading
 import time
-from image_checksummer import ImageChecksummer
+
 from utils import command_executer
 from utils import logger
 from utils.file_utils import FileUtils
 
+from image_checksummer import ImageChecksummer
+
 CHECKSUM_FILE = "/usr/local/osimage_checksum_file"
 
 
@@ -26,7 +33,9 @@
     self._GetMemoryInfo()
     self._GetCPUInfo()
     self._ComputeMachineChecksumString()
-    self._ComputeMachineChecksum()
+    self._GetMachineID()
+    self.machine_checksum = self._GetMD5Checksum(self.checksum_string)
+    self.machine_id_checksum = self._GetMD5Checksum(self.machine_id)
 
   def _ParseMemoryInfo(self):
     line = self.meminfo.splitlines()[0]
@@ -60,7 +69,7 @@
     self.phys_kbytes = phys_kbytes
 
   def _GetMemoryInfo(self):
-    #TODO yunlian: when the machine in rebooting, it will not return 
+    #TODO yunlian: when the machine in rebooting, it will not return
     #meminfo, the assert does not catch it either
     ce = command_executer.GetCommandExecuter()
     command = "cat /proc/meminfo"
@@ -94,11 +103,22 @@
         self.checksum_string += line
     self.checksum_string += " " + str(self.phys_kbytes)
 
-  def _ComputeMachineChecksum(self):
-    if self.checksum_string:
-      self.machine_checksum = hashlib.md5(self.checksum_string).hexdigest()
+  def _GetMD5Checksum(self, ss):
+    if ss:
+      return hashlib.md5(ss).hexdigest()
     else:
-      self.machine_checksum = ""
+      return ""
+
+  def _GetMachineID(self):
+    ce = command_executer.GetCommandExecuter()
+    command = "ifconfig"
+    ret, if_out, _ = ce.CrosRunCommand(
+        command, return_output=True,
+        machine=self.name, chromeos_root=self.chromeos_root)
+    b = if_out.splitlines()
+    a = [l for l in b if "lan" in l]
+    self.machine_id = a[0]
+    assert ret == 0, "Could not get machine_id from machine: %s" % self.name
 
   def __str__(self):
     l = []
@@ -118,52 +138,55 @@
     self.image_lock = threading.Lock()
     self.num_reimages = 0
     self.chromeos_root = None
-    if os.path.isdir(lock_machine.FileLock.LOCKS_DIR):
+    self.machine_checksum = {}
+    self.machine_checksum_string = {}
+
+    if os.path.isdir(lock_machine.Machine.LOCKS_DIR):
       self.no_lock = False
     else:
       self.no_lock = True
-    self.initialized = False
+    self._initialized_machines = []
     self.chromeos_root = chromeos_root
 
-  def ImageMachine(self, machine, chromeos_image, board=None):
-    checksum = ImageChecksummer().Checksum(chromeos_image)
+  def ImageMachine(self, machine, label):
+    checksum = ImageChecksummer().Checksum(label.chromeos_image)
     if machine.checksum == checksum:
       return
-    chromeos_root = FileUtils().ChromeOSRootFromImage(chromeos_image)
+    chromeos_root = label.chromeos_root
     if not chromeos_root:
       chromeos_root = self.chromeos_root
-    image_args = [image_chromeos.__file__,
-                  "--chromeos_root=%s" % chromeos_root,
-                  "--image=%s" % chromeos_image,
-                  "--remote=%s" % machine.name]
-    if board:
-      image_args.append("--board=%s" % board)
+    image_chromeos_args = [image_chromeos.__file__,
+                           "--chromeos_root=%s" % chromeos_root,
+                           "--image=%s" % label.chromeos_image,
+                           "--image_args=%s" % label.image_args,
+                           "--remote=%s" % machine.name]
+    if label.board:
+      image_chromeos_args.append("--board=%s" % label.board)
 
     # Currently can't image two machines at once.
     # So have to serialized on this lock.
     ce = command_executer.GetCommandExecuter()
     with self.image_lock:
-      retval = ce.RunCommand(" ".join(["python"] + image_args))
-      self.num_reimages += 1
+      retval = ce.RunCommand(" ".join(["python"] + image_chromeos_args))
       if retval:
         raise Exception("Could not image machine: '%s'." % machine.name)
+      else:
+        self.num_reimages += 1
       machine.checksum = checksum
-      machine.image = chromeos_image
+      machine.image = label.chromeos_image
 
     return retval
 
-  def ComputeCommonCheckSum(self):
-    self.machine_checksum = ""
-    for machine in self.GetMachines():
+  def ComputeCommonCheckSum(self, label):
+    for machine in self.GetMachines(label):
       if machine.machine_checksum:
-        self.machine_checksum = machine.machine_checksum
+        self.machine_checksum[label.name] = machine.machine_checksum
         break
 
-  def ComputeCommonCheckSumString(self):
-    self.machine_checksum_string = ""
-    for machine in self.GetMachines():
+  def ComputeCommonCheckSumString(self, label):
+    for machine in self.GetMachines(label):
       if machine.checksum_string:
-        self.machine_checksum_string = machine.checksum_string
+        self.machine_checksum_string[label.name] = machine.checksum_string
         break
 
   def _TryToLockMachine(self, cros_machine):
@@ -198,28 +221,28 @@
                            machine_name)
       self._all_machines.append(cm)
 
-  def AreAllMachineSame(self):
-    checksums = [m.machine_checksum for m in self.GetMachines()]
+  def AreAllMachineSame(self, label):
+    checksums = [m.machine_checksum for m in self.GetMachines(label)]
     return len(set(checksums)) == 1
 
-  def AcquireMachine(self, chromeos_image):
+  def AcquireMachine(self, chromeos_image, label):
     image_checksum = ImageChecksummer().Checksum(chromeos_image)
+    machines = self.GetMachines(label)
     with self._lock:
       # Lazily external lock machines
-      if not self.initialized:
-        for m in self._all_machines:
-          self._TryToLockMachine(m)
-        self.initialized = True
-        for m in self._all_machines:
-          m.released_time = time.time()
 
-      if not self.AreAllMachineSame():
+      for m in machines:
+        if m not in self._initialized_machines:
+          self._initialized_machines.append(m)
+          self._TryToLockMachine(m)
+          m.released_time = time.time()
+      if not self.AreAllMachineSame(label):
         logger.GetLogger().LogFatal("-- not all the machine are identical")
-      if not self._machines:
+      if not self.GetAvailableMachines(label):
         machine_names = []
-        for machine in self._all_machines:
+        for machine in machines:
           machine_names.append(machine.name)
-        logger.GetLogger().LogFatal("Could not acquire any of the"
+        logger.GetLogger().LogFatal("Could not acquire any of the "
                                   "following machines: '%s'"
                                   % ", ".join(machine_names))
 
@@ -227,12 +250,14 @@
 ###        if (m.locked and time.time() - m.released_time < 10 and
 ###            m.checksum == image_checksum):
 ###          return None
-      for m in [machine for machine in self._machines if not machine.locked]:
+      for m in [machine for machine in self.GetAvailableMachines(label)
+                if not machine.locked]:
         if m.checksum == image_checksum:
           m.locked = True
           m.autotest_run = threading.current_thread()
           return m
-      for m in [machine for machine in self._machines if not machine.locked]:
+      for m in [machine for machine in self.GetAvailableMachines(label)
+                if not machine.locked]:
         if not m.checksum:
           m.locked = True
           m.autotest_run = threading.current_thread()
@@ -243,15 +268,23 @@
       # the number of re-images.
       # TODO(asharif): If we centralize the thread-scheduler, we wont need this
       # code and can implement minimal reimaging code more cleanly.
-      for m in [machine for machine in self._machines if not machine.locked]:
+      for m in [machine for machine in self.GetAvailableMachines(label)
+                if not machine.locked]:
         if time.time() - m.released_time > 20:
           m.locked = True
           m.autotest_run = threading.current_thread()
           return m
     return None
 
-  def GetMachines(self):
-    return self._all_machines
+  def GetAvailableMachines(self, label=None):
+    if not label:
+      return self._machines
+    return [m for m in self._machines if m.name in label.remote]
+
+  def GetMachines(self, label=None):
+    if not label:
+      return self._all_machines
+    return [m for m in self._all_machines if m.name in label.remote]
 
   def ReleaseMachine(self, machine):
     with self._lock:
@@ -289,7 +322,7 @@
       for m in self._machines:
         if m.autotest_run:
           autotest_name = m.autotest_run.name
-          autotest_status = m.autotest_run.status
+          autotest_status = m.autotest_run.timeline.GetLastEvent()
         else:
           autotest_name = ""
           autotest_status = ""
@@ -305,26 +338,73 @@
         table.append(machine_string)
       return "Machine Status:\n%s" % "\n".join(table)
 
+  def GetAllCPUInfo(self, labels):
+    """Get cpuinfo for labels, merge them if their cpuinfo are the same."""
+    dic = {}
+    for label in labels:
+      for machine in self._all_machines:
+        if machine.name in label.remote:
+          if machine.cpuinfo not in dic:
+            dic[machine.cpuinfo] = [label.name]
+          else:
+            dic[machine.cpuinfo].append(label.name)
+          break
+    output = ""
+    for key, v in dic.items():
+      output += " ".join(v)
+      output += "\n-------------------\n"
+      output += key
+      output += "\n\n\n"
+    return output
 
-class MockMachineManager(object):
-  def __init__(self):
-    self.machines = []
 
-  def ImageMachine(self, machine_name, chromeos_image, board=None):
-    return 0
+class MockCrosMachine(CrosMachine):
+  def __init__(self, name, chromeos_root):
+    self.name = name
+    self.image = None
+    self.checksum = None
+    self.locked = False
+    self.released_time = time.time()
+    self.autotest_run = None
+    self.chromeos_root = chromeos_root
+    self.checksum_string = re.sub("\d", "", name)
+    #In test, we assume "lumpy1", "lumpy2" are the same machine.
+    self.machine_checksum =  self._GetMD5Checksum(self.checksum_string)
+
+
+class MockMachineManager(MachineManager):
+
+  def __init__(self, chromeos_root):
+    super(MockMachineManager, self).__init__(chromeos_root)
+
+  def _TryToLockMachine(self, cros_machine):
+    self._machines.append(cros_machine)
+    cros_machine.checksum = ""
 
   def AddMachine(self, machine_name):
-    self.machines.append(CrosMachine(machine_name))
+    with self._lock:
+      for m in self._all_machines:
+        assert m.name != machine_name, "Tried to double-add %s" % machine_name
+      cm = MockCrosMachine(machine_name, self.chromeos_root)
+      assert cm.machine_checksum, ("Could not find checksum for machine %s" %
+                                   machine_name)
+      self._all_machines.append(cm)
 
-  def AcquireMachine(self, chromeos_image):
-    for machine in self.machines:
+  def AcquireMachine(self, chromeos_image, label):
+    for machine in self._all_machines:
       if not machine.locked:
         machine.locked = True
         return machine
     return None
 
+  def ImageMachine(self, machine_name, label):
+    return 0
+
   def ReleaseMachine(self, machine):
     machine.locked = False
 
-  def GetMachines(self):
-    return self.machines
+  def GetMachines(self, label):
+    return self._all_machines
+
+  def GetAvailableMachines(self, label):
+    return self._all_machines
diff --git a/crosperf/machine_manager_unittest.py b/crosperf/machine_manager_unittest.py
new file mode 100755
index 0000000..98baf45
--- /dev/null
+++ b/crosperf/machine_manager_unittest.py
@@ -0,0 +1,65 @@
+#!/usr/bin/python
+
+# Copyright 2012 Google Inc. All Rights Reserved.
+
+"""Unittest for machine_manager."""
+import unittest
+
+import label
+import machine_manager
+
+
+class MyMachineManager(machine_manager.MachineManager):
+
+  def __init__(self, chromeos_root):
+    super(MyMachineManager, self).__init__(chromeos_root)
+
+  def _TryToLockMachine(self, cros_machine):
+    self._machines.append(cros_machine)
+    cros_machine.checksum = ""
+
+  def AddMachine(self, machine_name):
+    with self._lock:
+      for m in self._all_machines:
+        assert m.name != machine_name, "Tried to double-add %s" % machine_name
+      cm = machine_manager.MockCrosMachine(machine_name, self.chromeos_root)
+      assert cm.machine_checksum, ("Could not find checksum for machine %s" %
+                                   machine_name)
+      self._all_machines.append(cm)
+
+CHROMEOS_ROOT = "/tmp/chromeos-root"
+MACHINE_NAMES = ["lumpy1", "lumpy2", "lumpy3", "daisy1", "daisy2"]
+LABEL_LUMPY = label.MockLabel("lumpy", "image", CHROMEOS_ROOT, "lumpy",
+                              ["lumpy1", "lumpy2", "lumpy3", "lumpy4"], "")
+LABEL_MIX = label.MockLabel("mix", "image", CHROMEOS_ROOT, "mix",
+                            ["daisy1", "daisy2", "lumpy3", "lumpy4"], "")
+
+
+class MachineManagerTest(unittest.TestCase):
+
+  def testAreAllMachineSame(self):
+    manager = MyMachineManager(CHROMEOS_ROOT)
+    for m in MACHINE_NAMES:
+      manager.AddMachine(m)
+    self.assertEqual(manager.AreAllMachineSame(LABEL_LUMPY), True)
+    self.assertEqual(manager.AreAllMachineSame(LABEL_MIX), False)
+
+  def testGetMachines(self):
+    manager = MyMachineManager(CHROMEOS_ROOT)
+    for m in MACHINE_NAMES:
+      manager.AddMachine(m)
+    names = [m.name for m in manager.GetMachines(LABEL_LUMPY)]
+    self.assertEqual(names, ["lumpy1", "lumpy2", "lumpy3"])
+
+  def testGetAvailableMachines(self):
+    manager = MyMachineManager(CHROMEOS_ROOT)
+    for m in MACHINE_NAMES:
+      manager.AddMachine(m)
+    for m in manager._all_machines:
+      if int(m.name[-1]) % 2:
+        manager._TryToLockMachine(m)
+    names = [m.name for m in manager.GetAvailableMachines(LABEL_LUMPY)]
+    self.assertEqual(names, ["lumpy1", "lumpy3"])
+
+if __name__ == "__main__":
+  unittest.main()
diff --git a/crosperf/perf_table.py b/crosperf/perf_table.py
new file mode 100644
index 0000000..b3387ea
--- /dev/null
+++ b/crosperf/perf_table.py
@@ -0,0 +1,58 @@
+#!/usr/bin/python
+#
+# Copyright 2012 Google Inc. All Rights Reserved.
+"""Parse perf report data for tabulator."""
+
+import os
+
+from utils import perf_diff
+
+def ParsePerfReport(perf_file):
+  """It should return a dict."""
+
+  return {"cycles": {"foo": 10, "bar": 20},
+          "cache_miss": {"foo": 20, "bar": 10}}
+
+
+class PerfTable(object):
+  """The class to generate dicts for tabulator."""
+
+  def __init__(self, experiment, label_names):
+    self._experiment = experiment
+    self._label_names = label_names
+    self.perf_data = {}
+    self.GenerateData()
+    # {benchmark:{perf_event1:[[{func1:number, func2:number},
+    #                           {func1: number, func2: number}]], ...},
+    #  benchmark2:...}
+
+  def GenerateData(self):
+    for label in self._label_names:
+      for benchmark in self._experiment.benchmarks:
+        for i in range(1, benchmark.iterations+1):
+          dir_name = label + benchmark.name + str(i)
+          dir_name = filter(str.isalnum, dir_name)
+          perf_file = os.path.join(self._experiment.results_directory,
+                                   dir_name,
+                                   "perf.data.report.0")
+          self.ReadPerfReport(perf_file, label, benchmark.name, i - 1)
+
+  def ReadPerfReport(self, perf_file, label, benchmark_name, iteration):
+    """Add the data from one run to the dict."""
+    if not os.path.isfile(perf_file):
+      return
+    perf_of_run = perf_diff.GetPerfDictFromReport(perf_file)
+    if benchmark_name not in self.perf_data:
+      self.perf_data[benchmark_name] = {}
+      for event in perf_of_run:
+        self.perf_data[benchmark_name][event] = []
+    ben_data = self.perf_data[benchmark_name]
+
+    label_index = self._label_names.index(label)
+    for event in ben_data:
+      while len(ben_data[event]) <= label_index:
+        ben_data[event].append([])
+      data_for_label = ben_data[event][label_index]
+      while len(data_for_label) <= iteration:
+        data_for_label.append({})
+      data_for_label[iteration] = perf_of_run[event]
diff --git a/crosperf/results_cache.py b/crosperf/results_cache.py
index 1c33e72..c060096 100644
--- a/crosperf/results_cache.py
+++ b/crosperf/results_cache.py
@@ -11,7 +11,6 @@
 import tempfile
 
 from utils import command_executer
-from utils import logger
 from utils import misc
 
 from image_checksummer import ImageChecksummer
@@ -28,11 +27,13 @@
   what the key of the cache is. For runs with perf, it stores perf.data,
   perf.report, etc. The key generation is handled by the ResultsCache class.
   """
-  def __init__(self, chromeos_root, logger):
+
+  def __init__(self, chromeos_root, logger, label_name):
     self._chromeos_root = chromeos_root
     self._logger = logger
     self._ce = command_executer.GetCommandExecuter(self._logger)
     self._temp_dir = None
+    self.label_name = label_name
 
   def _CopyFilesTo(self, dest_dir, files_to_copy):
     file_index = 0
@@ -63,7 +64,7 @@
     command = ("python %s --no-color --csv %s" %
                (generate_test_report,
                 self.results_dir))
-    [ret, out, err] = self._ce.RunCommand(command, return_output=True)
+    [_, out, _] = self._ce.RunCommand(command, return_output=True)
     keyvals_dict = {}
     for line in out.splitlines():
       tokens = re.split("=|,", line)
@@ -76,7 +77,7 @@
     return keyvals_dict
 
   def _GetResultsDir(self):
-    mo = re.search("Results placed in (\S+)", self.out)
+    mo = re.search(r"Results placed in (\S+)", self.out)
     if mo:
       result = mo.group(1)
       return result
@@ -85,7 +86,7 @@
   def _FindFilesInResultsDir(self, find_args):
     command = "find %s %s" % (self.results_dir,
                               find_args)
-    ret, out, err = self._ce.RunCommand(command, return_output=True)
+    ret, out, _ = self._ce.RunCommand(command, return_output=True)
     if ret:
       raise Exception("Could not run find command!")
     return out
@@ -108,23 +109,22 @@
         raise Exception("Perf report file already exists: %s" %
                         perf_report_file)
       chroot_perf_report_file = misc.GetInsideChrootPath(self._chromeos_root,
-                                                   perf_report_file)
+                                                         perf_report_file)
       command = ("/usr/sbin/perf report "
                  "-n "
                  "--symfs /build/%s "
                  "--vmlinux /build/%s/usr/lib/debug/boot/vmlinux "
                  "--kallsyms /build/%s/boot/System.map-* "
                  "-i %s --stdio "
-                 "| head -n1000 "
-                 "| tee %s" %
+                 "> %s" %
                  (self._board,
                   self._board,
                   self._board,
                   chroot_perf_data_file,
                   chroot_perf_report_file))
-      ret, out, err = self._ce.ChrootRunCommand(self._chromeos_root,
-                                                command,
-                                                return_output=True)
+      self._ce.ChrootRunCommand(self._chromeos_root,
+                                command)
+
       # Add a keyval to the dictionary for the events captured.
       perf_report_files.append(
           misc.GetOutsideChrootPath(self._chromeos_root,
@@ -136,7 +136,7 @@
     for perf_report_file in self.perf_report_files:
       with open(perf_report_file, "r") as f:
         report_contents = f.read()
-        for group in re.findall("Events: (\S+) (\S+)", report_contents):
+        for group in re.findall(r"Events: (\S+) (\S+)", report_contents):
           num_events = group[0]
           event_name = group[1]
           key = "perf_%s_%s" % (report_id, event_name)
@@ -188,14 +188,12 @@
     self.perf_data_files = self._GetPerfDataFiles()
     self.perf_report_files = self._GetPerfReportFiles()
     self._ProcessResults()
-    self.CleanUp()
 
   def CleanUp(self):
     if self._temp_dir:
       command = "rm -rf %s" % self._temp_dir
       self._ce.RunCommand(command)
 
-
   def StoreToCacheDir(self, cache_dir, machine_manager):
     # Create the dir if it doesn't exist.
     command = "mkdir -p %s" % cache_dir
@@ -221,17 +219,18 @@
     # TODO(asharif): Make machine_manager a singleton, and don't pass it into
     # this function.
     with open(os.path.join(cache_dir, MACHINE_FILE), "w") as f:
-      f.write(machine_manager.machine_checksum_string)
+      f.write(machine_manager.machine_checksum_string[self.label_name])
 
   @classmethod
-  def CreateFromRun(cls, logger, chromeos_root, board, out, err, retval):
-    result = cls(chromeos_root, logger)
+  def CreateFromRun(cls, logger, chromeos_root, board, label_name,
+                    out, err, retval):
+    result = cls(chromeos_root, logger, label_name)
     result._PopulateFromRun(board, out, err, retval)
     return result
 
   @classmethod
-  def CreateFromCacheHit(cls, chromeos_root, logger, cache_dir):
-    result = cls(chromeos_root, logger)
+  def CreateFromCacheHit(cls, chromeos_root, logger, cache_dir, label_name):
+    result = cls(chromeos_root, logger, label_name)
     try:
       result._PopulateFromCacheDir(cache_dir)
     except Exception as e:
@@ -260,17 +259,21 @@
   # Cache hit if the image path matches the cached image path.
   IMAGE_PATH_MATCH = 5
 
+  # Cache hit if the uuid of hard disk mataches the cached one
+
+  SAME_MACHINE_MATCH = 6
+
 
 class ResultsCache(object):
   """ This class manages the key of the cached runs without worrying about what
   is exactly stored (value). The value generation is handled by the Results
   class.
   """
-  CACHE_VERSION = 5
+  CACHE_VERSION = 6
 
   def Init(self, chromeos_image, chromeos_root, autotest_name, iteration,
            autotest_args, machine_manager, board, cache_conditions,
-           logger_to_use):
+           logger_to_use, label):
     self.chromeos_image = chromeos_image
     self.chromeos_root = chromeos_root
     self.autotest_name = autotest_name
@@ -281,6 +284,7 @@
     self.machine_manager = machine_manager
     self._logger = logger_to_use
     self._ce = command_executer.GetCommandExecuter(self._logger)
+    self.label = label
 
   def _GetCacheDirForRead(self):
     glob_path = self._FormCacheDir(self._GetCacheKeyList(True))
@@ -288,9 +292,6 @@
 
     if matching_dirs:
       # Cache file found.
-      if len(matching_dirs) > 1:
-        self._logger.LogError("Multiple compatible cache files: %s." %
-                              " ".join(matching_dirs))
       return matching_dirs[0]
     else:
       return None
@@ -308,7 +309,7 @@
     if read and CacheConditions.MACHINES_MATCH not in self.cache_conditions:
       machine_checksum = "*"
     else:
-      machine_checksum = self.machine_manager.machine_checksum
+      machine_checksum = self.machine_manager.machine_checksum[self.label.name]
     if read and CacheConditions.CHECKSUMS_MATCH not in self.cache_conditions:
       checksum = "*"
     else:
@@ -319,13 +320,22 @@
     else:
       image_path_checksum = hashlib.md5(self.chromeos_image).hexdigest()
 
+    if read and CacheConditions.SAME_MACHINE_MATCH not in self.cache_conditions:
+      machine_id_checksum = "*"
+    else:
+      for machine in self.machine_manager.GetMachines(self.label):
+        if machine.name == self.label.remote[0]:
+          machine_id_checksum = machine.machine_id_checksum
+          break
+
     autotest_args_checksum = hashlib.md5(
-                             "".join(self.autotest_args)).hexdigest()
+        "".join(self.autotest_args)).hexdigest()
     return (image_path_checksum,
             self.autotest_name, str(self.iteration),
             autotest_args_checksum,
             checksum,
             machine_checksum,
+            machine_id_checksum,
             str(self.CACHE_VERSION))
 
   def ReadResult(self):
@@ -342,7 +352,7 @@
     self._logger.LogOutput("Trying to read from cache dir: %s" % cache_dir)
 
     result = Result.CreateFromCacheHit(self.chromeos_root,
-                                       self._logger, cache_dir)
+                                       self._logger, cache_dir, self.label.name)
 
     if not result:
       return None
@@ -358,12 +368,20 @@
     result.StoreToCacheDir(cache_dir, self.machine_manager)
 
 
-class MockResultsCache(object):
+class MockResultsCache(ResultsCache):
   def Init(self, *args):
     pass
 
   def ReadResult(self):
-    return Result("Results placed in /tmp/test", "", 0)
+    return None
 
   def StoreResult(self, result):
     pass
+
+
+class MockResult(Result):
+  def _PopulateFromRun(self, out, err, retval):
+    self.out = out
+    self.err = err
+    self.retval = retval
+
diff --git a/crosperf/results_organizer.py b/crosperf/results_organizer.py
index 0071387..810186b 100644
--- a/crosperf/results_organizer.py
+++ b/crosperf/results_organizer.py
@@ -1,6 +1,8 @@
 #!/usr/bin/python
 
 # Copyright 2012 Google Inc. All Rights Reserved.
+"""Parse data from benchmark_runs for tabulator."""
+import re
 
 
 class ResultOrganizer(object):
@@ -18,18 +20,22 @@
     ]}.
   """
 
-  def __init__(self, benchmark_runs, labels):
+  def __init__(self, benchmark_runs, labels, benchmarks=None):
     self.result = {}
     self.labels = []
+    self.prog = re.compile(r"(\w+)\{(\d+)\}")
+    self.benchmarks = benchmarks
+    if not self.benchmarks:
+      self.benchmarks = []
     for label in labels:
       self.labels.append(label.name)
     for benchmark_run in benchmark_runs:
-      benchmark_name = benchmark_run.benchmark_name
+      benchmark_name = benchmark_run.benchmark.name
       if benchmark_name not in self.result:
         self.result[benchmark_name] = []
         while len(self.result[benchmark_name]) < len(labels):
           self.result[benchmark_name].append([])
-      label_index = self.labels.index(benchmark_run.label_name)
+      label_index = self.labels.index(benchmark_run.label.name)
       cur_table = self.result[benchmark_name][label_index]
       index = benchmark_run.iteration - 1
       while index >= len(cur_table):
@@ -40,3 +46,50 @@
       for autotest_key in benchmark_run.result.keyvals:
         result_value = benchmark_run.result.keyvals[autotest_key]
         cur_dict[autotest_key] = result_value
+    self._DuplicatePass()
+
+  def _DuplicatePass(self):
+    for bench, data in self.result.items():
+      max_dup = self._GetMaxDup(data)
+      if not max_dup:
+        continue
+      for label in data:
+        index = data.index(label)
+        data[index] = self._GetNonDupLabel(max_dup, label)
+      self._AdjustIteration(max_dup, bench)
+
+  def _GetMaxDup(self, data):
+    """Find the maximum i inside ABCD{i}."""
+    max_dup = 0
+    for label in data:
+      for run in label:
+        for key in run:
+          if re.match(self.prog, key):
+            max_dup = max(max_dup,
+                          int(re.search(self.prog, key).group(2)))
+    return max_dup
+
+  def _GetNonDupLabel(self, max_dup, label):
+    """Create new list for the runs of the same label."""
+    new_label = []
+    for run in label:
+      start_index = len(new_label)
+      new_label.append(dict(run))
+      for i in range(max_dup):
+        new_label.append({})
+      new_run = new_label[start_index]
+      for key, value in new_run.items():
+        if re.match(self.prog, key):
+          new_key = re.search(self.prog, key).group(1)
+          index = int(re.search(self.prog, key).group(2))
+          new_label[start_index+index][new_key] = str(value)
+          del new_run[key]
+    return new_label
+
+  def _AdjustIteration(self, max_dup, bench):
+    """Adjust the interation numbers if the have keys like ABCD{i}."""
+    for benchmark in self.benchmarks:
+      if benchmark.name == bench:
+        if not benchmark.iteration_adjusted:
+          benchmark.iteration_adjusted = True
+          benchmark.iterations *= (max_dup +1)
diff --git a/crosperf/results_report.py b/crosperf/results_report.py
index b591370..f743413 100644
--- a/crosperf/results_report.py
+++ b/crosperf/results_report.py
@@ -2,12 +2,13 @@
 
 # Copyright 2011 Google Inc. All Rights Reserved.
 
-import math
-from column_chart import ColumnChart
-from results_sorter import ResultSorter
-from results_organizer import ResultOrganizer
 from utils.tabulator import *
 
+from column_chart import ColumnChart
+from results_organizer import ResultOrganizer
+from perf_table import PerfTable
+
+
 class ResultsReport(object):
   MAX_COLOR_CODE = 255
 
@@ -26,7 +27,7 @@
       labels[benchmark_run.label_name].append(benchmark_run)
     return labels
 
-  def GetFullTables(self):
+  def GetFullTables(self, perf=False):
     columns = [Column(NonEmptyCountResult(),
                       Format(),
                       "Completed"),
@@ -41,23 +42,30 @@
                Column(StdResult(),
                       Format())
               ]
-    return self._GetTables(self.labels, self.benchmark_runs, columns)
+    if not perf:
+      return self._GetTables(self.labels, self.benchmark_runs, columns)
+    return self. _GetPerfTables(self.labels, columns)
 
-  def GetSummaryTables(self):
-    columns = [Column(AmeanResult(),
+  def GetSummaryTables(self, perf=False):
+    columns = [Column(NonEmptyCountResult(),
+                      Format(),
+                      "Completed"),
+               Column(AmeanResult(),
                       Format()),
                Column(StdResult(),
                       Format(), "StdDev"),
                Column(CoeffVarResult(),
-                      CoeffVarFormat(), "Mean/StdDev"),
+                      CoeffVarFormat(), "StdDev/Mean"),
                Column(GmeanRatioResult(),
                       RatioFormat(), "GmeanSpeedup"),
                Column(GmeanRatioResult(),
                       ColorBoxFormat(), " "),
-               Column(StatsSignificant(),
-                      Format(), "p-value")
+               Column(PValueResult(),
+                      PValueFormat(), "p-value")
               ]
-    return self._GetTables(self.labels, self.benchmark_runs, columns)
+    if not perf:
+      return self._GetTables(self.labels, self.benchmark_runs, columns)
+    return self. _GetPerfTables(self.labels, columns)
 
   def _ParseColumn(self, columns, iteration):
     new_column = []
@@ -78,9 +86,17 @@
           return False
     return True
 
+  def _GetTableHeader(self, benchmark):
+    benchmark_info = ("Benchmark:  {0};  Iterations: {1}"
+                      .format(benchmark.name, benchmark.iterations))
+    cell = Cell()
+    cell.string_value = benchmark_info
+    cell.header = True
+    return  [[cell]]
+
   def _GetTables(self, labels, benchmark_runs, columns):
     tables = []
-    ro = ResultOrganizer(benchmark_runs, labels)
+    ro = ResultOrganizer(benchmark_runs, labels, self.benchmarks)
     result = ro.result
     label_name = ro.labels
     for item in result:
@@ -88,11 +104,7 @@
       for benchmark in self.benchmarks:
         if benchmark.name == item:
           break
-      benchmark_info = ("Benchmark:  {0};  Iterations: {1}"
-                         .format(benchmark.name, benchmark.iterations))
-      cell = Cell()
-      cell.string_value = benchmark_info
-      ben_table = [[cell]]
+      ben_table = self._GetTableHeader(benchmark)
 
       if  self._AreAllRunsEmpty(runs):
         cell = Cell()
@@ -109,8 +121,41 @@
       tables.append(cell_table)
     return tables
 
+  def _GetPerfTables(self, labels, columns):
+    tables = []
+    label_names = [label.name for label in labels]
+    p_table = PerfTable(self.experiment, label_names)
+
+    if not p_table.perf_data:
+      return tables
+
+    for benchmark in p_table.perf_data:
+      ben = None
+      for ben in self.benchmarks:
+        if ben.name == benchmark:
+          break
+
+      ben_table = self._GetTableHeader(ben)
+      tables.append(ben_table)
+      benchmark_data = p_table.perf_data[benchmark]
+      table = []
+      for event in benchmark_data:
+        tg = TableGenerator(benchmark_data[event], label_names)
+        table = tg.GetTable()
+        parsed_columns = self._ParseColumn(columns, ben.iterations)
+        tf = TableFormatter(table, parsed_columns)
+        tf.GenerateCellTable()
+        tf.AddColumnName()
+        tf.AddLabelName()
+        tf.AddHeader(str(event))
+        table = tf.GetCellTable(headers=False)
+        tables.append(table)
+    return tables
+
   def PrintTables(self, tables, out_to):
     output = ""
+    if not tables:
+      return output
     for table in tables:
       if out_to == "HTML":
         tp = TablePrinter(table, TablePrinter.HTML)
@@ -126,6 +171,8 @@
         pass
       output += tp.Print()
     return output
+
+
 class TextResultsReport(ResultsReport):
   TEXT = """
 ===========================================
@@ -137,10 +184,30 @@
 -------------------------------------------
 %s
 
+
+Number re-images: %s
+
 -------------------------------------------
+Benchmark Run Status
+-------------------------------------------
+%s
+
+
+-------------------------------------------
+Perf Data
+-------------------------------------------
+%s
+
+
+
 Experiment File
 -------------------------------------------
 %s
+
+
+CPUInfo
+-------------------------------------------
+%s
 ===========================================
 """
 
@@ -148,17 +215,46 @@
     super(TextResultsReport, self).__init__(experiment)
     self.email = email
 
+  def GetStatusTable(self):
+    """Generate the status table by the tabulator."""
+    table = [["", ""]]
+    columns = [Column(LiteralResult(iteration=0), Format(), "Status"),
+               Column(LiteralResult(iteration=1), Format(), "Failing Reason")]
+
+    for benchmark_run in self.benchmark_runs:
+      status = [benchmark_run.name, [benchmark_run.timeline.GetLastEvent(),
+                                     benchmark_run.failure_reason]]
+      table.append(status)
+    tf = TableFormatter(table, columns)
+    cell_table = tf.GetCellTable()
+    return [cell_table]
+
   def GetReport(self):
+    """Generate the report for email and console."""
+    status_table = self.GetStatusTable()
     summary_table = self.GetSummaryTables()
     full_table = self.GetFullTables()
+    perf_table = self.GetSummaryTables(perf=True)
+    if not perf_table:
+      perf_table = None
     if not self.email:
       return self.TEXT % (self.experiment.name,
                           self.PrintTables(summary_table, "CONSOLE"),
-                          self.experiment.experiment_file)
+                          self.experiment.machine_manager.num_reimages,
+                          self.PrintTables(status_table, "CONSOLE"),
+                          self.PrintTables(perf_table, "CONSOLE"),
+                          self.experiment.experiment_file,
+                          self.experiment.machine_manager.GetAllCPUInfo(
+                              self.experiment.labels))
 
     return self.TEXT % (self.experiment.name,
                         self.PrintTables(summary_table, "EMAIL"),
-                        self.experiment.experiment_file)
+                        self.experiment.machine_manager.num_reimages,
+                        self.PrintTables(status_table, "EMAIL"),
+                        self.PrintTables(perf_table, "EMAIL"),
+                        self.experiment.experiment_file,
+                        self.experiment.machine_manager.GetAllCPUInfo(
+                            self.experiment.labels))
 
 
 class HTMLResultsReport(ResultsReport):
@@ -243,6 +339,7 @@
       google.setOnLoadCallback(init);
       function init() {
         switchTab('summary', 'html');
+        %s
         switchTab('full', 'html');
         drawTable();
       }
@@ -268,6 +365,7 @@
       </div>
       %s
     </div>
+    %s
     <div class='results-section'>
       <div class='results-section-title'>Charts</div>
       <div class='results-section-content'>%s</div>
@@ -291,6 +389,18 @@
 </html>
 """
 
+  PERF_HTML = """
+    <div class='results-section'>
+      <div class='results-section-title'>Perf Table</div>
+      <div class='results-section-content'>
+        <div id='perf-html'>%s</div>
+        <div id='perf-text'><pre>%s</pre></div>
+        <div id='perf-tsv'><pre>%s</pre></div>
+      </div>
+      %s
+    </div>
+"""
+
   def __init__(self, experiment):
     super(HTMLResultsReport, self).__init__(experiment)
 
@@ -313,11 +423,26 @@
 
     summary_table = self.GetSummaryTables()
     full_table = self.GetFullTables()
-    return self.HTML % (chart_javascript,
+    perf_table = self.GetSummaryTables(perf=True)
+    if perf_table:
+      perf_html = self.PERF_HTML % (
+          self.PrintTables(perf_table, "HTML"),
+          self.PrintTables(perf_table, "PLAIN"),
+          self.PrintTables(perf_table, "TSV"),
+          self._GetTabMenuHTML("perf")
+          )
+      perf_init = "switchTab('perf', 'html');"
+    else:
+      perf_html = ""
+      perf_init = ""
+
+    return self.HTML % (perf_init,
+                        chart_javascript,
                         self.PrintTables(summary_table, "HTML"),
                         self.PrintTables(summary_table, "PLAIN"),
                         self.PrintTables(summary_table, "TSV"),
                         self._GetTabMenuHTML("summary"),
+                        perf_html,
                         chart_divs,
                         self.PrintTables(full_table, "HTML"),
                         self.PrintTables(full_table, "PLAIN"),
diff --git a/crosperf/settings_factory.py b/crosperf/settings_factory.py
index 782f0dd..11fa4b4 100644
--- a/crosperf/settings_factory.py
+++ b/crosperf/settings_factory.py
@@ -1,9 +1,9 @@
 #!/usr/bin/python
 
 # Copyright 2011 Google Inc. All Rights Reserved.
+"""Setting files for global, benchmark and labels."""
 
 from field import BooleanField
-from field import EnumField
 from field import FloatField
 from field import IntegerField
 from field import ListField
@@ -46,6 +46,13 @@
                             "chromeos_image."))
     self.AddField(TextField("board", required=True, description="The target "
                             "board for running experiments on, e.g. x86-alex."))
+    self.AddField(ListField("remote", description=
+                            "A comma-separated list of ip's of chromeos"
+                            "devices to run experiments on."))
+    self.AddField(TextField("image_args", required=False,
+                            default="",
+                            description="Extra arguments to pass to "
+                            "image_chromeos.py."))
 
 
 class GlobalSettings(Settings):
@@ -56,20 +63,24 @@
                             "identifier."))
     self.AddField(TextField("board", description="The target "
                             "board for running experiments on, e.g. x86-alex."))
-    self.AddField(ListField("remote", required=True,
+    self.AddField(ListField("remote",
                             description="A comma-separated list of ip's of "
                             "chromeos devices to run experiments on."))
     self.AddField(BooleanField("rerun_if_failed", description="Whether to "
                                "re-run failed autotest runs or not.",
                                default=False))
     self.AddField(ListField("email", description="Space-seperated"
-                               "list of email addresses to send email to."))
+                            "list of email addresses to send email to."))
     self.AddField(BooleanField("rerun", description="Whether to ignore the "
                                "cache and for autotests to be re-run.",
                                default=False))
-    self.AddField(BooleanField("exact_remote", default=True,
+    self.AddField(BooleanField("same_specs", default=True,
                                description="Ensure cached runs are run on the "
-                               "same device that is specified as a remote."))
+                               "same kind of devices which are specified as a "
+                               "remote."))
+    self.AddField(BooleanField("same_machine", default=False,
+                               description="Ensure cached runs are run on the "
+                               "exact the same remote"))
     self.AddField(IntegerField("iterations", default=1,
                                description="Number of iterations to run all "
                                "autotests."))
diff --git a/crosperf/test_flag.py b/crosperf/test_flag.py
new file mode 100644
index 0000000..613138b
--- /dev/null
+++ b/crosperf/test_flag.py
@@ -0,0 +1,16 @@
+#!/usr/bin/python
+#
+# Copyright 2011 Google Inc. All Rights Reserved.
+
+"""A global variable for testing."""
+
+
+_is_test = [False]
+
+
+def SetTestMode(flag):
+  _is_test[0] = flag
+
+
+def GetTestMode():
+  return  _is_test[0]
diff --git a/image_chromeos.py b/image_chromeos.py
index 380a94f..30b29a4 100755
--- a/image_chromeos.py
+++ b/image_chromeos.py
@@ -1,4 +1,4 @@
-#!/usr/bin/python2.6
+#!/usr/bin/python
 #
 # Copyright 2011 Google Inc. All Rights Reserved.
 
@@ -9,7 +9,6 @@
 
 __author__ = "asharif@google.com (Ahmad Sharif)"
 
-import fcntl
 import filecmp
 import glob
 import optparse
@@ -18,13 +17,15 @@
 import shutil
 import sys
 import tempfile
+import time
+
 from utils import command_executer
 from utils import logger
 from utils import misc
 from utils.file_utils import FileUtils
 
 checksum_file = "/usr/local/osimage_checksum_file"
-lock_file = "/tmp/lock_image_chromeos"
+lock_file = "/tmp/image_chromeos_lock/image_chromeos_lock"
 
 def Usage(parser, message):
   print "ERROR: " + message
@@ -32,17 +33,9 @@
   sys.exit(0)
 
 
-def Main(argv):
+def DoImage(argv):
   """Build ChromeOS."""
-  #Get lock for the host
-  f = open(lock_file, "w+a")
-  try:
-    fcntl.lockf(f, fcntl.LOCK_EX|fcntl.LOCK_NB)
-  except IOError:
-    f.close()
-    print ("You can not run two instances of image_chromes at the same time."
-           "\nTry again. Exiting ....")
-    exit(0)
+
   # Common initializations
   cmd_executer = command_executer.GetCommandExecuter()
   l = logger.GetLogger()
@@ -61,8 +54,8 @@
                     default=False,
                     help="Force an image even if it is non-test.")
   parser.add_option("-a",
-                    "--image_to_live_args",
-                    dest="image_to_live_args")
+                    "--image_args",
+                    dest="image_args")
 
 
   options = parser.parse_args(argv[1:])[0]
@@ -132,21 +125,40 @@
                                 chromeos_root=options.chromeos_root,
                                 machine=options.remote)
 
-    command = (options.chromeos_root +
-               "/src/scripts/image_to_live.sh --remote=" +
-               options.remote +
-               " --image=" + located_image)
-    if options.image_to_live_args:
-      command += " %s" % options.image_to_live_args
+    real_src_dir = os.path.join(os.path.realpath(options.chromeos_root),
+                                "src")
+    if located_image.find(real_src_dir) != 0:
+      raise Exception("Located image: %s not in chromeos_root: %s" %
+                      (located_image, options.chromeos_root))
+    chroot_image = os.path.join(
+        "..",
+        located_image[len(real_src_dir):].lstrip("/"))
+    cros_image_to_target_args = ["--remote=%s" % options.remote,
+                                 "--board=%s" % board,
+                                 "--from=%s" % os.path.dirname(chroot_image),
+                                 "--image-name=%s" %
+                                 os.path.basename(located_image)]
 
-    retval = cmd_executer.RunCommand(command)
+    command = ("./bin/cros_image_to_target.py %s" %
+               " ".join(cros_image_to_target_args))
+    if options.image_args:
+      command += " %s" % options.image_args
 
+    # Workaround for crosbug.com/35684.
+    os.chmod(misc.GetChromeOSKeyFile(options.chromeos_root), 0600)
+    retval = cmd_executer.ChrootRunCommand(options.chromeos_root,
+                                           command)
     if found == False:
       temp_dir = os.path.dirname(located_image)
       l.LogOutput("Deleting temp image dir: %s" % temp_dir)
       shutil.rmtree(temp_dir)
 
     logger.GetLogger().LogFatalIf(retval, "Image command failed")
+
+    # Unfortunately cros_image_to_target.py sometimes returns early when the
+    # machine isn't fully up yet.
+    retval = EnsureMachineUp(options.chromeos_root, options.remote)
+
     command = "echo %s > %s && chmod -w %s" % (image_checksum, checksum_file,
                                                checksum_file)
     retval = cmd_executer.CrosRunCommand(command,
@@ -161,9 +173,6 @@
                                   "Image verification failed!")
   else:
     l.LogOutput("Checksums match. Skipping reimage")
-
-  fcntl.lockf(f, fcntl.LOCK_UN)
-  f.close()
   return retval
 
 
@@ -260,6 +269,34 @@
     return False
 
 
+def EnsureMachineUp(chromeos_root, remote):
+  l = logger.GetLogger()
+  cmd_executer = command_executer.GetCommandExecuter()
+  timeout = 600
+  magic = "abcdefghijklmnopqrstuvwxyz"
+  command = "echo %s" % magic
+  start_time = time.time()
+  while True:
+    current_time = time.time()
+    if current_time - start_time > timeout:
+      l.LogError("Timeout of %ss reached. Machine still not up. Aborting." %
+                 timeout)
+      return False
+    retval = cmd_executer.CrosRunCommand(command,
+                                         chromeos_root=chromeos_root,
+                                         machine=remote)
+    if not retval:
+      return True
+
+
+def Main(argv):
+  misc.AcquireLock(lock_file)
+  try:
+    return DoImage(argv)
+  finally:
+    misc.ReleaseLock(lock_file)
+
+
 if __name__ == "__main__":
   retval = Main(sys.argv)
   sys.exit(retval)
diff --git a/lock_machine.py b/lock_machine.py
index c5f9809..0f948c3 100755
--- a/lock_machine.py
+++ b/lock_machine.py
@@ -1,10 +1,8 @@
-#!/usr/bin/python2.6
+#!/usr/bin/python
 #
 # Copyright 2010 Google Inc. All Rights Reserved.
 
-"""Script to lock/unlock machines.
-
-"""
+"""Script to lock/unlock machines."""
 
 __author__ = "asharif@google.com (Ahmad Sharif)"
 
@@ -12,14 +10,31 @@
 import fcntl
 import getpass
 import glob
+import json
 import optparse
 import os
-import pickle
 import socket
 import sys
 import time
+
 from utils import logger
 
+LOCK_SUFFIX = "_check_lock_liveness"
+
+
+def FileCheckName(name):
+  return name + LOCK_SUFFIX
+
+
+def OpenLiveCheck(file_name):
+  with FileCreationMask(0000):
+    fd = open(file_name, "a+w")
+  try:
+    fcntl.lockf(fd, fcntl.LOCK_EX | fcntl.LOCK_NB)
+  except IOError:
+    raise
+  return fd
+
 
 class FileCreationMask(object):
   def __init__(self, mask):
@@ -33,12 +48,23 @@
 
 
 class LockDescription(object):
-  def __init__(self):
-    self.owner = ""
-    self.exclusive = False
-    self.counter = 0
-    self.time = 0
-    self.reason = ""
+  """The description of the lock."""
+
+  def __init__(self, desc=None):
+    try:
+      self.owner = desc["owner"]
+      self.exclusive = desc["exclusive"]
+      self.counter = desc["counter"]
+      self.time = desc["time"]
+      self.reason = desc["reason"]
+      self.auto = desc["auto"]
+    except (KeyError, TypeError):
+      self.owner = ""
+      self.exclusive = False
+      self.counter = 0
+      self.time = 0
+      self.reason = ""
+      self.auto = False
 
   def IsLocked(self):
     return self.counter or self.exclusive
@@ -48,23 +74,26 @@
                      "Exclusive: %s" % self.exclusive,
                      "Counter: %s" % self.counter,
                      "Time: %s" % self.time,
-                     "Reason: %s" % self.reason])
+                     "Reason: %s" % self.reason,
+                     "Auto: %s" % self.auto])
 
 
 class FileLock(object):
-  LOCKS_DIR = "/home/mobiletc-prebuild/locks"
+  """File lock operation class."""
+  FILE_OPS = []
 
   def __init__(self, lock_filename):
-    assert os.path.isdir(self.LOCKS_DIR), (
-        "Locks dir: %s doesn't exist!" % self.LOCKS_DIR)
-    self._filepath = os.path.join(self.LOCKS_DIR, lock_filename)
+    self._filepath = lock_filename
+    lock_dir = os.path.dirname(lock_filename)
+    assert os.path.isdir(lock_dir), (
+        "Locks dir: %s doesn't exist!" % lock_dir)
     self._file = None
 
   @classmethod
   def AsString(cls, file_locks):
-    stringify_fmt = "%-30s %-15s %-4s %-4s %-15s %-40s"
+    stringify_fmt = "%-30s %-15s %-4s %-4s %-15s %-40s %-4s"
     header = stringify_fmt % ("machine", "owner", "excl", "ctr",
-                              "elapsed", "reason")
+                              "elapsed", "reason", "auto")
     lock_strings = []
     for file_lock in file_locks:
 
@@ -77,15 +106,20 @@
                            file_lock._description.exclusive,
                            file_lock._description.counter,
                            elapsed_time,
-                           file_lock._description.reason))
+                           file_lock._description.reason,
+                           file_lock._description.auto))
     table = "\n".join(lock_strings)
     return "\n".join([header, table])
 
   @classmethod
-  def ListLock(cls, pattern):
-    full_pattern = os.path.join(cls.LOCKS_DIR, pattern)
+  def ListLock(cls, pattern, locks_dir):
+    if not locks_dir:
+      locks_dir = Machine.LOCKS_DIR
+    full_pattern = os.path.join(locks_dir, pattern)
     file_locks = []
     for lock_filename in glob.glob(full_pattern):
+      if LOCK_SUFFIX in lock_filename:
+        continue
       file_lock = FileLock(lock_filename)
       with file_lock as lock:
         if lock.IsLocked():
@@ -102,9 +136,26 @@
           raise IOError("flock(%s, LOCK_EX) failed!" % self._filepath)
 
         try:
-          self._description = pickle.load(self._file)
-        except (EOFError, pickle.PickleError):
-          self._description = LockDescription()
+          desc = json.load(self._file)
+        except (EOFError, ValueError):
+          desc = None
+        self._description = LockDescription(desc)
+
+        if self._description.exclusive and self._description.auto:
+          locked_byself = False
+          for fd in self.FILE_OPS:
+            if fd.name == FileCheckName(self._filepath):
+              locked_byself = True
+              break
+          if not locked_byself:
+            try:
+              fp = OpenLiveCheck(FileCheckName(self._filepath))
+            except IOError:
+              pass
+            else:
+              self._description = LockDescription()
+              fcntl.lockf(fp, fcntl.LOCK_UN)
+              fp.close()
         return self._description
       # Check this differently?
       except IOError as ex:
@@ -113,7 +164,7 @@
 
   def __exit__(self, type, value, traceback):
     self._file.truncate(0)
-    self._file.write(pickle.dumps(self._description))
+    self._file.write(json.dumps(self._description.__dict__, skipkeys=True))
     self._file.close()
 
   def __str__(self):
@@ -121,12 +172,14 @@
 
 
 class Lock(object):
-  def __init__(self, to_lock):
-    self._to_lock = to_lock
+  def __init__(self, lock_file, auto=True):
+    self._to_lock = os.path.basename(lock_file)
+    self._lock_file = lock_file
     self._logger = logger.GetLogger()
+    self._auto = auto
 
   def NonBlockingLock(self, exclusive, reason=""):
-    with FileLock(self._to_lock) as lock:
+    with FileLock(self._lock_file) as lock:
       if lock.exclusive:
         self._logger.LogError(
             "Exclusive lock already acquired by %s. Reason: %s" %
@@ -137,17 +190,22 @@
         if lock.counter:
           self._logger.LogError("Shared lock already acquired")
           return False
+        lock_file_check = FileCheckName(self._lock_file)
+        fd = OpenLiveCheck(lock_file_check)
+        FileLock.FILE_OPS.append(fd)
+
         lock.exclusive = True
         lock.reason = reason
         lock.owner = getpass.getuser()
         lock.time = time.time()
+        lock.auto = self._auto
       else:
         lock.counter += 1
     self._logger.LogOutput("Successfully locked: %s" % self._to_lock)
     return True
 
   def Unlock(self, exclusive, force=False):
-    with FileLock(self._to_lock) as lock:
+    with FileLock(self._lock_file) as lock:
       if not lock.IsLocked():
         self._logger.LogError("Can't unlock unlocked machine!")
         return False
@@ -161,28 +219,61 @@
           self._logger.LogError("%s can't unlock lock owned by: %s" %
                                 (getpass.getuser(), lock.owner))
           return False
+        if lock.auto != self._auto:
+          self._logger.LogError("Can't unlock lock with different -a"
+                                " parameter.")
+          return False
         lock.exclusive = False
         lock.reason = ""
         lock.owner = ""
+
+        if self._auto:
+          del_list = [i for i in FileLock.FILE_OPS
+                      if i.name == FileCheckName(self._lock_file)]
+          for i in del_list:
+            FileLock.FILE_OPS.remove(i)
+          for f in del_list:
+            fcntl.lockf(f, fcntl.LOCK_UN)
+            f.close()
+          del del_list
+          os.remove(FileCheckName(self._lock_file))
+
       else:
         lock.counter -= 1
     return True
 
 
 class Machine(object):
-  def __init__(self, name):
+  LOCKS_DIR = "/home/mobiletc-prebuild/locks"
+
+  def __init__(self, name, locks_dir=LOCKS_DIR, auto=True):
     self._name = name
+    self._auto = auto
     try:
       self._full_name = socket.gethostbyaddr(name)[0]
     except socket.error:
       self._full_name = self._name
+    self._full_name = os.path.join(locks_dir, self._full_name)
 
   def Lock(self, exclusive=False, reason=""):
-    lock = Lock(self._full_name)
+    lock = Lock(self._full_name, self._auto)
     return lock.NonBlockingLock(exclusive, reason)
 
+  def TryLock(self, timeout=300, exclusive=False, reason=""):
+    locked = False
+    sleep = timeout / 10
+    while True:
+      locked = self.Lock(exclusive, reason)
+      if locked or not timeout >= 0:
+        break
+      print "Lock not acquired for {0}, wait {1} seconds ...".format(
+          self._name, sleep)
+      time.sleep(sleep)
+      timeout -= sleep
+    return locked
+
   def Unlock(self, exclusive=False, ignore_ownership=False):
-    lock = Lock(self._full_name)
+    lock = Lock(self._full_name, self._auto)
     return lock.Unlock(exclusive, ignore_ownership)
 
 
@@ -218,9 +309,16 @@
                     action="store_true",
                     default=False,
                     help="Use this for a shared (non-exclusive) lock.")
+  parser.add_option("-d",
+                    "--dir",
+                    dest="locks_dir",
+                    action="store",
+                    default=Machine.LOCKS_DIR,
+                    help="Use this to set different locks_dir")
 
   options, args = parser.parse_args(argv)
 
+  options.locks_dir = os.path.abspath(options.locks_dir)
   exclusive = not options.shared
 
   if not options.list_locks and len(args) != 2:
@@ -229,12 +327,12 @@
     return 1
 
   if len(args) > 1:
-    machine = Machine(args[1])
+    machine = Machine(args[1], options.locks_dir, auto=False)
   else:
     machine = None
 
   if options.list_locks:
-    FileLock.ListLock("*")
+    FileLock.ListLock("*", options.locks_dir)
     retval = True
   elif options.unlock:
     retval = machine.Unlock(exclusive, options.ignore_ownership)
diff --git a/utils/command_executer.py b/utils/command_executer.py
index 54c9c35..3edb626 100644
--- a/utils/command_executer.py
+++ b/utils/command_executer.py
@@ -80,7 +80,8 @@
     while len(pipes):
       fds = select.select(pipes, [], [], 0.1)
       if command_terminator and command_terminator.IsTerminated():
-        self.RunCommand("sudo kill -9 " + str(p.pid))
+        self.RunCommand("sudo kill -9 " + str(p.pid),
+                        print_to_console=print_to_console)
         wait = p.wait()
         self.logger.LogError("Command was terminated!", print_to_console)
         if return_output:
@@ -119,7 +120,8 @@
              % command_timeout)
         self.logger.LogWarning(m, print_to_console)
         self.RunCommand("kill %d || sudo kill %d || sudo kill -9 %d" %
-                        (p.pid, p.pid, p.pid))
+                        (p.pid, p.pid, p.pid),
+                        print_to_console=print_to_console)
         break
 
       if out == err == "":
@@ -172,12 +174,17 @@
 
     # Write all commands to a file.
     command_file = self.WriteToTempShFile(cmd)
-    self.CopyFiles(command_file, command_file,
-                   dest_machine=machine,
-                   command_terminator=command_terminator,
-                   chromeos_root=chromeos_root,
-                   dest_cros=True,
-                   recursive=False)
+    retval = self.CopyFiles(command_file, command_file,
+                            dest_machine=machine,
+                            command_terminator=command_terminator,
+                            chromeos_root=chromeos_root,
+                            dest_cros=True,
+                            recursive=False,
+                            print_to_console=print_to_console)
+    if retval:
+      self.logger.LogError("Could not run remote command on machine."
+                           " Is the machine up?")
+      return retval
 
     command = self.RemoteAccessInitCommand(chromeos_root, machine)
     command += "\nremote_sh bash %s" % command_file
@@ -185,7 +192,8 @@
     retval = self.RunCommand(command, return_output,
                              command_terminator=command_terminator,
                              command_timeout=command_timeout,
-                             terminated_timeout=terminated_timeout)
+                             terminated_timeout=terminated_timeout,
+                             print_to_console=print_to_console)
     if return_output:
       connect_signature = ("Initiating first contact with remote host\n" +
                            "Connection OK\n")
@@ -200,7 +208,8 @@
   def ChrootRunCommand(self, chromeos_root, command, return_output=False,
                        command_terminator=None, command_timeout=None,
                        terminated_timeout=10,
-                       print_to_console=True):
+                       print_to_console=True,
+                       cros_sdk_options=""):
     self.logger.LogCmd(command, print_to_console)
 
     handle, command_file = tempfile.mkstemp(dir=os.path.join(chromeos_root,
@@ -213,12 +222,13 @@
 
     os.chmod(command_file, 0777)
 
-    command = "cd %s; cros_sdk -- ./%s" % (chromeos_root,
-                                           os.path.basename(command_file))
+    command = "cd %s; cros_sdk %s -- ./%s" % (chromeos_root, cros_sdk_options,
+                                              os.path.basename(command_file))
     ret = self.RunCommand(command, return_output,
                           command_terminator=command_terminator,
                           command_timeout=command_timeout,
-                          terminated_timeout=terminated_timeout)
+                          terminated_timeout=terminated_timeout,
+                          print_to_console=print_to_console)
     os.remove(command_file)
     return ret
 
@@ -232,7 +242,8 @@
   def CopyFiles(self, src, dest, src_machine=None, dest_machine=None,
                 src_user=None, dest_user=None, recursive=True,
                 command_terminator=None,
-                chromeos_root=None, src_cros=False, dest_cros=False):
+                chromeos_root=None, src_cros=False, dest_cros=False,
+                print_to_console=True):
     src = os.path.expanduser(src)
     dest = os.path.expanduser(dest)
 
@@ -262,13 +273,15 @@
         return self.RunCommand(command,
                                machine=src_machine,
                                username=src_user,
-                               command_terminator=command_terminator)
+                               command_terminator=command_terminator,
+                               print_to_console=print_to_console)
       else:
         command += rsync_prefix + "root@%s:%s %s" % (src_machine, src, dest)
         return self.RunCommand(command,
                                machine=dest_machine,
                                username=dest_user,
-                               command_terminator=command_terminator)
+                               command_terminator=command_terminator,
+                               print_to_console=print_to_console)
 
 
     if dest_machine == src_machine:
@@ -285,7 +298,8 @@
     return self.RunCommand(command,
                            machine=dest_machine,
                            username=dest_user,
-                           command_terminator=command_terminator)
+                           command_terminator=command_terminator,
+                           print_to_console=print_to_console)
 
 
 class MockCommandExecuter(CommandExecuter):
diff --git a/utils/logger.py b/utils/logger.py
index a8f0a6f..faad966 100644
--- a/utils/logger.py
+++ b/utils/logger.py
@@ -7,8 +7,11 @@
 import sys
 import traceback
 
-# Local modules
-import misc
+#TODO(yunlian@google.com): Use GetRoot from misc
+def GetRoot(scr_name):
+  """Break up pathname into (dir+name)."""
+  abs_path = os.path.abspath(scr_name)
+  return (os.path.dirname(abs_path), os.path.basename(abs_path))
 
 
 class Logger(object):
@@ -168,7 +171,7 @@
   """Initialize a global logger. To be called only once."""
   global main_logger
   assert not main_logger, "The logger has already been initialized"
-  rootdir, basefilename = misc.GetRoot(script_name)
+  rootdir, basefilename = GetRoot(script_name)
   main_logger = Logger(rootdir, basefilename, print_console)
 
 
diff --git a/utils/misc.py b/utils/misc.py
index cb9acbf..4062251 100644
--- a/utils/misc.py
+++ b/utils/misc.py
@@ -1,4 +1,4 @@
-#!/usr/bin/python2.6
+#!/usr/bin/python
 #
 # Copyright 2010 Google Inc. All Rights Reserved.
 
@@ -9,12 +9,18 @@
 from contextlib import contextmanager
 import os
 import re
+import shutil
+import sys
+import time
+
+import lock_machine
 
 import command_executer
 import logger
 
 
 def GetChromeOSVersionFromLSBVersion(lsb_version):
+  """Get Chromeos version from Lsb version."""
   ce = command_executer.GetCommandExecuter()
   command = "git ls-remote http://git.chromium.org/chromiumos/manifest.git"
   ret, out, _ = ce.RunCommand(command, return_output=True,
@@ -22,7 +28,7 @@
   assert ret == 0, "Command %s failed" % command
   lower = []
   for line in out.splitlines():
-    mo = re.search("refs/heads/release-R(\d+)-(\d+)\.B", line)
+    mo = re.search(r"refs/heads/release-R(\d+)-(\d+)\.B", line)
     if mo:
       revision = int(mo.group(1))
       build = int(mo.group(2))
@@ -42,12 +48,13 @@
   return string
 
 
-def UnitToNumber(string, base=1000):
+def UnitToNumber(unit_num, base=1000):
+  """Convert a number with unit to float."""
   unit_dict = {"kilo": base,
                "mega": base**2,
                "giga": base**3}
-  string = string.lower()
-  mo = re.search("(\d*)(.+)?", string)
+  unit_num = unit_num.lower()
+  mo = re.search(r"(\d*)(.+)?", unit_num)
   number = mo.group(1)
   unit = mo.group(2)
   if not unit:
@@ -57,15 +64,15 @@
       return float(number) * v
   raise Exception("Unit: %s not found in byte: %s!" %
                   (unit,
-                   string))
+                   unit_num))
 
 
 def GetFilenameFromString(string):
   return ApplySubs(string,
-                   ("/", "__"),
-                   ("\s", "_"),
-                   ("[\^\$=\"\\\?]", ""),
-                   )
+                   (r"/", "__"),
+                   (r"\s", "_"),
+                   (r"[\^\$=\"\\\?]", ""),
+                  )
 
 
 def GetRoot(scr_name):
@@ -74,6 +81,15 @@
   return (os.path.dirname(abs_path), os.path.basename(abs_path))
 
 
+def GetChromeOSKeyFile(chromeos_root):
+  return os.path.join(chromeos_root,
+                      "src",
+                      "scripts",
+                      "mod_for_test_scripts",
+                      "ssh_keys",
+                      "testing_rsa")
+
+
 def GetChrootPath(chromeos_root):
   return os.path.join(chromeos_root,
                       "chroot")
@@ -101,7 +117,7 @@
   return ApplySubs(str(commands),
                    ("&&", "&&\n"),
                    (";", ";\n"),
-                   ("\n+\s*", "\n"))
+                   (r"\n+\s*", "\n"))
 
 
 def GetImageDir(chromeos_root, board):
@@ -145,6 +161,7 @@
 
 def GetSetupBoardCommand(board, gcc_version=None, binutils_version=None,
                          usepkg=None, force=None):
+  """Get setup_board command."""
   options = []
 
   if gcc_version:
@@ -171,6 +188,7 @@
 
 
 def GetCtargetFromBoard(board, chromeos_root):
+  """Get Ctarget from board."""
   base_board = board.split("_")[0]
   command = ("source "
              "../platform/dev/toolchain_utils.sh; get_ctarget_from_board %s" %
@@ -187,7 +205,7 @@
 
 
 def StripANSIEscapeSequences(string):
-  string = re.sub("\x1b\[[0-9]*[a-zA-Z]", "", string)
+  string = re.sub(r"\x1b\[[0-9]*[a-zA-Z]", "", string)
   return string
 
 
@@ -200,6 +218,7 @@
 
 
 def MergeEnvStringWithDict(env_string, env_dict, prepend=True):
+  """Merge env string with dict."""
   if not env_string.strip():
     return GetEnvStringFromDict(env_dict)
   override_env_list = []
@@ -226,8 +245,67 @@
   return out.splitlines()
 
 
+def AcquireLock(lock_file, timeout=1200):
+  """Acquire a lock with timeout."""
+  start_time = time.time()
+  locked = False
+  abs_path = os.path.abspath(lock_file)
+  dir_path = os.path.dirname(abs_path)
+  sleep_time = min(10, timeout/10.0)
+  if not os.path.exists(dir_path):
+    try:
+      os.makedirs(dir_path)
+    except OSError:
+      print "Cannot create dir {0}, exiting...".format(dir_path)
+      exit(0)
+  while True:
+    locked = (lock_machine.Lock(lock_file).NonBlockingLock(True, sys.argv[0]))
+    if locked:
+      break
+    time.sleep(sleep_time)
+    if time.time() - start_time > timeout:
+      logger.GetLogger().LogWarning(
+          "Could not acquire lock on this file: {0} within {1} seconds."
+          "Manually remove the file if you think the lock is stale"
+          .format(abs_path, timeout))
+      break
+  return locked
+
+
+def ReleaseLock(lock_file):
+  lock_file = os.path.abspath(lock_file)
+  ret = lock_machine.Lock(lock_file).Unlock(True)
+  assert ret, ("Could not unlock {0},"
+               "Please remove it manually".format(lock_file))
+
+
+def IsFloat(text):
+  if text is None:
+    return False
+  try:
+    float(text)
+    return True
+  except ValueError:
+    return False
+
+def RemoveChromeBrowserObjectFiles(chromeos_root, board):
+  """ Remove any object files from all the posible locations """
+  out_dir = os.path.join(
+      GetChrootPath(chromeos_root),
+      "var/cache/chromeos-chrome/chrome-src/src/out_%s" % board)
+  if os.path.exists(out_dir):
+    shutil.rmtree(out_dir)
+    logger.GetLogger().LogCmd("rm -rf %s" % out_dir)
+  out_dir = os.path.join(
+      GetChrootPath(chromeos_root),
+      "var/cache/chromeos-chrome/chrome-src-internal/src/out_%s" % board)
+  if os.path.exists(out_dir):
+    shutil.rmtree(out_dir)
+    logger.GetLogger().LogCmd("rm -rf %s" % out_dir)
+
 @contextmanager
 def WorkingDirectory(new_dir):
+  """Get the working directory."""
   old_dir = os.getcwd()
   if old_dir != new_dir:
     msg = "cd %s" % new_dir
diff --git a/utils/perf_diff.py b/utils/perf_diff.py
new file mode 100755
index 0000000..cfe90a9
--- /dev/null
+++ b/utils/perf_diff.py
@@ -0,0 +1,318 @@
+#!/usr/bin/python
+# Copyright 2012 Google Inc. All Rights Reserved.
+
+"""One-line documentation for perf_diff module.
+
+A detailed description of perf_diff.
+"""
+
+__author__ = "asharif@google.com (Ahmad Sharif)"
+
+import optparse
+import re
+import sys
+
+import misc
+import tabulator
+
+
+def GetPerfDictFromReport(report_file, num_functions=5):
+  output = {}
+  perf_report = PerfReport(report_file)
+  for k, v in perf_report.sections.items():
+    if k not in output:
+      output[k] = {}
+    for function in v.functions[:num_functions]:
+      out_key = "%s" % (function.name)
+      output[k][out_key] = function.count
+  return output
+
+
+def _SortDictionaryByValue(d):
+  l = [(k, v) for (k, v) in d.iteritems()]
+
+  def GetFloat(x):
+    if misc.IsFloat(x):
+      return float(x)
+    else:
+      return x
+
+  sorted_l = sorted(l,
+                    key=lambda x: GetFloat(x[1]))
+  sorted_l.reverse()
+  return [f[0] for f in sorted_l]
+
+
+class Tabulator(object):
+  def __init__(self, all_dicts):
+    self._all_dicts = all_dicts
+
+  def PrintTable(self):
+    for dicts in self._all_dicts:
+      self.PrintTableHelper(dicts)
+
+  def PrintTableHelper(self, dicts):
+    """Transfrom dicts to tables."""
+    fields = {}
+    for d in dicts:
+      for f in d.keys():
+        if f not in fields:
+          fields[f] = d[f]
+        else:
+          fields[f] = max(fields[f], d[f])
+    table = []
+    header = ["name"]
+    for i in range(len(dicts)):
+      header.append(i)
+
+    table.append(header)
+
+    sorted_fields = _SortDictionaryByValue(fields)
+
+    for f in sorted_fields:
+      row = [f]
+      for d in dicts:
+        if f in d:
+          row.append(d[f])
+        else:
+          row.append("0")
+      table.append(row)
+
+    print tabulator.GetSimpleTable(table)
+
+
+class Function(object):
+  def __init__(self):
+    self.count = 0
+    self.name = ""
+
+
+class Section(object):
+  def __init__(self, contents):
+    self.raw_contents = contents
+    self._ParseSection()
+
+  def _ParseSection(self):
+    matches = re.findall(r"Events: (\w+)\s+(.*)", self.raw_contents)
+    assert len(matches) <= 1, "More than one event found in 1 section"
+    if not matches:
+      return
+    match = matches[0]
+    self.name = match[1]
+    self.count = misc.UnitToNumber(match[0])
+
+    self.functions = []
+    for line in self.raw_contents.splitlines():
+      if not line.strip():
+        continue
+      if "%" not in line:
+        continue
+      if not line.startswith("#"):
+        fields = [f for f in line.split(" ") if f]
+        function = Function()
+        function.count = int(fields[1])
+        function.name = " ".join(fields[2:])
+        self.functions.append(function)
+
+
+class PerfReport(object):
+  """Get report from raw report."""
+
+  def __init__(self, perf_file):
+    self.perf_file = perf_file
+    self._ReadFile()
+    self.sections = {}
+    self.metadata = {}
+    self._section_contents = []
+    self._section_header = ""
+    self._SplitSections()
+    self._ParseSections()
+    self._ParseSectionHeader()
+
+  def _ParseSectionHeader(self):
+    """Parse a header of a perf report file."""
+    # The "captured on" field is inaccurate - this actually refers to when the
+    # report was generated, not when the data was captured.
+    for line in self._section_header.splitlines():
+      line = line[2:]
+      if ":" in line:
+        key, val = line.strip().split(":", 1)
+        key = key.strip()
+        val = val.strip()
+        self.metadata[key] = val
+
+  def _ReadFile(self):
+    self._perf_contents = open(self.perf_file).read()
+
+  def _ParseSections(self):
+    self.event_counts = {}
+    self.sections = {}
+    for section_content in self._section_contents:
+      section = Section(section_content)
+      section.name = self._GetHumanReadableName(section.name)
+      self.sections[section.name] = section
+
+  # TODO(asharif): Do this better.
+  def _GetHumanReadableName(self, section_name):
+    if not "raw" in section_name:
+      return section_name
+    raw_number = section_name.strip().split(" ")[-1]
+    for line in self._section_header.splitlines():
+      if raw_number in line:
+        name = line.strip().split(" ")[5]
+        return name
+
+  def _SplitSections(self):
+    self._section_contents = []
+    indices = [m.start() for m in re.finditer("Events:", self._perf_contents)]
+    indices.append(len(self._perf_contents))
+    for i in range(len(indices) - 1):
+      section_content = self._perf_contents[indices[i]:indices[i+1]]
+      self._section_contents.append(section_content)
+    self._section_header = ""
+    if indices:
+      self._section_header = self._perf_contents[0:indices[0]]
+
+
+class PerfDiffer(object):
+  """Perf differ class."""
+
+  def __init__(self, reports, num_symbols, common_only):
+    self._reports = reports
+    self._num_symbols = num_symbols
+    self._common_only = common_only
+    self._common_function_names = {}
+
+  def DoDiff(self):
+    """The function that does the diff."""
+    section_names = self._FindAllSections()
+
+    filename_dicts = []
+    summary_dicts = []
+    for report in self._reports:
+      d = {}
+      filename_dicts.append({"file": report.perf_file})
+      for section_name in section_names:
+        if section_name in report.sections:
+          d[section_name] = report.sections[section_name].count
+      summary_dicts.append(d)
+
+    all_dicts = [filename_dicts, summary_dicts]
+
+    for section_name in section_names:
+      function_names = self._GetTopFunctions(section_name,
+                                             self._num_symbols)
+      self._FindCommonFunctions(section_name)
+      dicts = []
+      for report in self._reports:
+        d = {}
+        if section_name in report.sections:
+          section = report.sections[section_name]
+
+          # Get a common scaling factor for this report.
+          common_scaling_factor = self._GetCommonScalingFactor(section)
+
+          for function in section.functions:
+            if function.name in function_names:
+              key = "%s %s" % (section.name, function.name)
+              d[key] = function.count
+              # Compute a factor to scale the function count by in common_only
+              # mode.
+              if self._common_only and (
+                  function.name in self._common_function_names[section.name]):
+                d[key + " scaled"] = common_scaling_factor * function.count
+        dicts.append(d)
+
+      all_dicts.append(dicts)
+
+    mytabulator = Tabulator(all_dicts)
+    mytabulator.PrintTable()
+
+  def _FindAllSections(self):
+    sections = {}
+    for report in self._reports:
+      for section in report.sections.values():
+        if section.name not in sections:
+          sections[section.name] = section.count
+        else:
+          sections[section.name] = max(sections[section.name],
+                                       section.count)
+    return _SortDictionaryByValue(sections)
+
+  def _GetCommonScalingFactor(self, section):
+    unique_count = self._GetCount(
+        section,
+        lambda x: x in self._common_function_names[section.name])
+    return 100.0/unique_count
+
+  def _GetCount(self, section, filter_fun=None):
+    total_count = 0
+    for function in section.functions:
+      if not filter_fun or filter_fun(function.name):
+        total_count += int(function.count)
+    return total_count
+
+  def _FindCommonFunctions(self, section_name):
+    function_names_list = []
+    for report in self._reports:
+      if section_name in report.sections:
+        section = report.sections[section_name]
+        function_names = [f.name for f in section.functions]
+        function_names_list.append(function_names)
+
+    self._common_function_names[section_name] = (
+        reduce(set.intersection, map(set, function_names_list)))
+
+  def _GetTopFunctions(self, section_name, num_functions):
+    all_functions = {}
+    for report in self._reports:
+      if section_name in report.sections:
+        section = report.sections[section_name]
+        for f in section.functions[:num_functions]:
+          if f.name in all_functions:
+            all_functions[f.name] = max(all_functions[f.name], f.count)
+          else:
+            all_functions[f.name] = f.count
+    # FIXME(asharif): Don't really need to sort these...
+    return _SortDictionaryByValue(all_functions)
+
+  def _GetFunctionsDict(self, section, function_names):
+    d = {}
+    for function in section.functions:
+      if function.name in function_names:
+        d[function.name] = function.count
+    return d
+
+
+def Main(argv):
+  """The entry of the main."""
+  parser = optparse.OptionParser()
+  parser.add_option("-n",
+                    "--num_symbols",
+                    dest="num_symbols",
+                    default="5",
+                    help="The number of symbols to show.")
+  parser.add_option("-c",
+                    "--common_only",
+                    dest="common_only",
+                    action="store_true",
+                    default=False,
+                    help="Diff common symbols only.")
+
+  options, args = parser.parse_args(argv)
+
+  try:
+    reports = []
+    for report in args[1:]:
+      report = PerfReport(report)
+      reports.append(report)
+    pd = PerfDiffer(reports, int(options.num_symbols), options.common_only)
+    pd.DoDiff()
+  finally:
+    pass
+
+  return 0
+
+
+if __name__ == "__main__":
+  sys.exit(Main(sys.argv))
diff --git a/utils/pstat.py b/utils/pstat.py
new file mode 100644
index 0000000..dae681e
--- /dev/null
+++ b/utils/pstat.py
@@ -0,0 +1,1068 @@
+# Copyright (c) 1999-2007 Gary Strangman; All Rights Reserved.
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+# 
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+# 
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+#
+# Comments and/or additions are welcome (send e-mail to:
+# strang@nmr.mgh.harvard.edu).
+# 
+"""
+pstat.py module
+
+#################################################
+#######  Written by:  Gary Strangman  ###########
+#######  Last modified:  Dec 18, 2007 ###########
+#################################################
+
+This module provides some useful list and array manipulation routines
+modeled after those found in the |Stat package by Gary Perlman, plus a
+number of other useful list/file manipulation functions.  The list-based
+functions include:
+
+      abut (source,*args)
+      simpleabut (source, addon)
+      colex (listoflists,cnums)
+      collapse (listoflists,keepcols,collapsecols,fcn1=None,fcn2=None,cfcn=None)
+      dm (listoflists,criterion)
+      flat (l)
+      linexand (listoflists,columnlist,valuelist)
+      linexor (listoflists,columnlist,valuelist)
+      linedelimited (inlist,delimiter)
+      lineincols (inlist,colsize) 
+      lineincustcols (inlist,colsizes)
+      list2string (inlist)
+      makelol(inlist)
+      makestr(x)
+      printcc (lst,extra=2)
+      printincols (listoflists,colsize)
+      pl (listoflists)
+      printl(listoflists)
+      replace (lst,oldval,newval)
+      recode (inlist,listmap,cols='all')
+      remap (listoflists,criterion)
+      roundlist (inlist,num_digits_to_round_floats_to)
+      sortby(listoflists,sortcols)
+      unique (inlist)
+      duplicates(inlist)
+      writedelimited (listoflists, delimiter, file, writetype='w')
+
+Some of these functions have alternate versions which are defined only if
+Numeric (NumPy) can be imported.  These functions are generally named as
+above, with an 'a' prefix.
+
+      aabut (source, *args)
+      acolex (a,indices,axis=1)
+      acollapse (a,keepcols,collapsecols,sterr=0,ns=0)
+      adm (a,criterion)
+      alinexand (a,columnlist,valuelist)
+      alinexor (a,columnlist,valuelist)
+      areplace (a,oldval,newval)
+      arecode (a,listmap,col='all')
+      arowcompare (row1, row2)
+      arowsame (row1, row2)
+      asortrows(a,axis=0)
+      aunique(inarray)
+      aduplicates(inarray)
+
+Currently, the code is all but completely un-optimized.  In many cases, the
+array versions of functions amount simply to aliases to built-in array
+functions/methods.  Their inclusion here is for function name consistency.
+"""
+
+## CHANGE LOG:
+## ==========
+## 07-11-26 ... edited to work with numpy
+## 01-11-15 ... changed list2string() to accept a delimiter
+## 01-06-29 ... converted exec()'s to eval()'s to make compatible with Py2.1
+## 01-05-31 ... added duplicates() and aduplicates() functions
+## 00-12-28 ... license made GPL, docstring and import requirements
+## 99-11-01 ... changed version to 0.3
+## 99-08-30 ... removed get, getstrings, put, aget, aput (into io.py)
+## 03/27/99 ... added areplace function, made replace fcn recursive
+## 12/31/98 ... added writefc function for ouput to fixed column sizes
+## 12/07/98 ... fixed import problem (failed on collapse() fcn)
+##              added __version__ variable (now 0.2)
+## 12/05/98 ... updated doc-strings
+##              added features to collapse() function
+##              added flat() function for lists
+##              fixed a broken asortrows() 
+## 11/16/98 ... fixed minor bug in aput for 1D arrays
+##
+## 11/08/98 ... fixed aput to output large arrays correctly
+
+import stats  # required 3rd party module
+import string, copy
+from types import *
+
+__version__ = 0.4
+
+###===========================  LIST FUNCTIONS  ==========================
+###
+### Here are the list functions, DEFINED FOR ALL SYSTEMS.
+### Array functions (for NumPy-enabled computers) appear below.
+###
+
+def abut (source,*args):
+    """
+Like the |Stat abut command.  It concatenates two lists side-by-side
+and returns the result.  '2D' lists are also accomodated for either argument
+(source or addon).  CAUTION:  If one list is shorter, it will be repeated
+until it is as long as the longest list.  If this behavior is not desired,
+use pstat.simpleabut().
+
+Usage:   abut(source, args)   where args=any # of lists
+Returns: a list of lists as long as the LONGEST list past, source on the
+         'left', lists in <args> attached consecutively on the 'right'
+"""
+
+    if type(source) not in [ListType,TupleType]:
+        source = [source]
+    for addon in args:
+        if type(addon) not in [ListType,TupleType]:
+            addon = [addon]
+        if len(addon) < len(source):                # is source list longer?
+            if len(source) % len(addon) == 0:        # are they integer multiples?
+                repeats = len(source)/len(addon)    # repeat addon n times
+                origadd = copy.deepcopy(addon)
+                for i in range(repeats-1):
+                    addon = addon + origadd
+            else:
+                repeats = len(source)/len(addon)+1  # repeat addon x times,
+                origadd = copy.deepcopy(addon)      #    x is NOT an integer
+                for i in range(repeats-1):
+                    addon = addon + origadd
+                    addon = addon[0:len(source)]
+        elif len(source) < len(addon):                # is addon list longer?
+            if len(addon) % len(source) == 0:        # are they integer multiples?
+                repeats = len(addon)/len(source)    # repeat source n times
+                origsour = copy.deepcopy(source)
+                for i in range(repeats-1):
+                    source = source + origsour
+            else:
+                repeats = len(addon)/len(source)+1  # repeat source x times,
+                origsour = copy.deepcopy(source)    #   x is NOT an integer
+                for i in range(repeats-1):
+                    source = source + origsour
+                source = source[0:len(addon)]
+
+        source = simpleabut(source,addon)
+    return source
+
+
+def simpleabut (source, addon):
+    """
+Concatenates two lists as columns and returns the result.  '2D' lists
+are also accomodated for either argument (source or addon).  This DOES NOT
+repeat either list to make the 2 lists of equal length.  Beware of list pairs
+with different lengths ... the resulting list will be the length of the
+FIRST list passed.
+
+Usage:   simpleabut(source,addon)  where source, addon=list (or list-of-lists)
+Returns: a list of lists as long as source, with source on the 'left' and
+                 addon on the 'right'
+"""
+    if type(source) not in [ListType,TupleType]:
+        source = [source]
+    if type(addon) not in [ListType,TupleType]:
+        addon = [addon]
+    minlen = min(len(source),len(addon))
+    list = copy.deepcopy(source)                # start abut process
+    if type(source[0]) not in [ListType,TupleType]:
+        if type(addon[0]) not in [ListType,TupleType]:
+            for i in range(minlen):
+                list[i] = [source[i]] + [addon[i]]        # source/addon = column
+        else:
+            for i in range(minlen):
+                list[i] = [source[i]] + addon[i]        # addon=list-of-lists
+    else:
+        if type(addon[0]) not in [ListType,TupleType]:
+            for i in range(minlen):
+                list[i] = source[i] + [addon[i]]        # source=list-of-lists
+        else:
+            for i in range(minlen):
+                list[i] = source[i] + addon[i]        # source/addon = list-of-lists
+    source = list
+    return source
+
+
+def colex (listoflists,cnums):
+    """
+Extracts from listoflists the columns specified in the list 'cnums'
+(cnums can be an integer, a sequence of integers, or a string-expression that
+corresponds to a slice operation on the variable x ... e.g., 'x[3:]' will colex
+columns 3 onward from the listoflists).
+
+Usage:   colex (listoflists,cnums)
+Returns: a list-of-lists corresponding to the columns from listoflists
+         specified by cnums, in the order the column numbers appear in cnums
+"""
+    global index
+    column = 0
+    if type(cnums) in [ListType,TupleType]:   # if multiple columns to get
+        index = cnums[0]
+        column = map(lambda x: x[index], listoflists)
+        for col in cnums[1:]:
+            index = col
+            column = abut(column,map(lambda x: x[index], listoflists))
+    elif type(cnums) == StringType:              # if an 'x[3:]' type expr.
+        evalstring = 'map(lambda x: x'+cnums+', listoflists)'
+        column = eval(evalstring)
+    else:                                     # else it's just 1 col to get
+        index = cnums
+        column = map(lambda x: x[index], listoflists)
+    return column
+
+
+def collapse (listoflists,keepcols,collapsecols,fcn1=None,fcn2=None,cfcn=None):
+     """
+Averages data in collapsecol, keeping all unique items in keepcols
+(using unique, which keeps unique LISTS of column numbers), retaining the
+unique sets of values in keepcols, the mean for each.  Setting fcn1
+and/or fcn2 to point to a function rather than None (e.g., stats.sterr, len)
+will append those results (e.g., the sterr, N) after each calculated mean.
+cfcn is the collapse function to apply (defaults to mean, defined here in the
+pstat module to avoid circular imports with stats.py, but harmonicmean or
+others could be passed).
+
+Usage:    collapse (listoflists,keepcols,collapsecols,fcn1=None,fcn2=None,cfcn=None)
+Returns: a list of lists with all unique permutations of entries appearing in
+     columns ("conditions") specified by keepcols, abutted with the result of
+     cfcn (if cfcn=None, defaults to the mean) of each column specified by
+     collapsecols.
+"""
+     def collmean (inlist):
+         s = 0
+         for item in inlist:
+             s = s + item
+         return s/float(len(inlist))
+
+     if type(keepcols) not in [ListType,TupleType]:
+         keepcols = [keepcols]
+     if type(collapsecols) not in [ListType,TupleType]:
+         collapsecols = [collapsecols]
+     if cfcn == None:
+         cfcn = collmean
+     if keepcols == []:
+         means = [0]*len(collapsecols)
+         for i in range(len(collapsecols)):
+             avgcol = colex(listoflists,collapsecols[i])
+             means[i] = cfcn(avgcol)
+             if fcn1:
+                 try:
+                     test = fcn1(avgcol)
+                 except:
+                     test = 'N/A'
+                     means[i] = [means[i], test]
+             if fcn2:
+                 try:
+                     test = fcn2(avgcol)
+                 except:
+                     test = 'N/A'
+                 try:
+                     means[i] = means[i] + [len(avgcol)]
+                 except TypeError:
+                     means[i] = [means[i],len(avgcol)]
+         return means
+     else:
+         values = colex(listoflists,keepcols)
+         uniques = unique(values)
+         uniques.sort()
+         newlist = []
+         if type(keepcols) not in [ListType,TupleType]:  keepcols = [keepcols]
+         for item in uniques:
+             if type(item) not in [ListType,TupleType]:  item =[item]
+             tmprows = linexand(listoflists,keepcols,item)
+             for col in collapsecols:
+                 avgcol = colex(tmprows,col)
+                 item.append(cfcn(avgcol))
+                 if fcn1 <> None:
+                     try:
+                         test = fcn1(avgcol)
+                     except:
+                         test = 'N/A'
+                     item.append(test)
+                 if fcn2 <> None:
+                     try:
+                         test = fcn2(avgcol)
+                     except:
+                         test = 'N/A'
+                     item.append(test)
+                 newlist.append(item)
+         return newlist
+
+
+def dm (listoflists,criterion):
+    """
+Returns rows from the passed list of lists that meet the criteria in
+the passed criterion expression (a string as a function of x; e.g., 'x[3]>=9'
+will return all rows where the 4th column>=9 and "x[2]=='N'" will return rows
+with column 2 equal to the string 'N').
+
+Usage:   dm (listoflists, criterion)
+Returns: rows from listoflists that meet the specified criterion.
+"""
+    function = 'filter(lambda x: '+criterion+',listoflists)'
+    lines = eval(function)
+    return lines
+
+
+def flat(l):
+    """
+Returns the flattened version of a '2D' list.  List-correlate to the a.ravel()()
+method of NumPy arrays.
+
+Usage:    flat(l)
+"""
+    newl = []
+    for i in range(len(l)):
+        for j in range(len(l[i])):
+            newl.append(l[i][j])
+    return newl
+
+
+def linexand (listoflists,columnlist,valuelist):
+    """
+Returns the rows of a list of lists where col (from columnlist) = val
+(from valuelist) for EVERY pair of values (columnlist[i],valuelists[i]).
+len(columnlist) must equal len(valuelist).
+
+Usage:   linexand (listoflists,columnlist,valuelist)
+Returns: the rows of listoflists where columnlist[i]=valuelist[i] for ALL i
+"""
+    if type(columnlist) not in [ListType,TupleType]:
+        columnlist = [columnlist]
+    if type(valuelist) not in [ListType,TupleType]:
+        valuelist = [valuelist]
+    criterion = ''
+    for i in range(len(columnlist)):
+        if type(valuelist[i])==StringType:
+            critval = '\'' + valuelist[i] + '\''
+        else:
+            critval = str(valuelist[i])
+        criterion = criterion + ' x['+str(columnlist[i])+']=='+critval+' and'
+    criterion = criterion[0:-3]         # remove the "and" after the last crit
+    function = 'filter(lambda x: '+criterion+',listoflists)'
+    lines = eval(function)
+    return lines
+
+
+def linexor (listoflists,columnlist,valuelist):
+    """
+Returns the rows of a list of lists where col (from columnlist) = val
+(from valuelist) for ANY pair of values (colunmlist[i],valuelist[i[).
+One value is required for each column in columnlist.  If only one value
+exists for columnlist but multiple values appear in valuelist, the
+valuelist values are all assumed to pertain to the same column.
+
+Usage:   linexor (listoflists,columnlist,valuelist)
+Returns: the rows of listoflists where columnlist[i]=valuelist[i] for ANY i
+"""
+    if type(columnlist) not in [ListType,TupleType]:
+        columnlist = [columnlist]
+    if type(valuelist) not in [ListType,TupleType]:
+        valuelist = [valuelist]
+    criterion = ''
+    if len(columnlist) == 1 and len(valuelist) > 1:
+        columnlist = columnlist*len(valuelist)
+    for i in range(len(columnlist)):          # build an exec string
+        if type(valuelist[i])==StringType:
+            critval = '\'' + valuelist[i] + '\''
+        else:
+            critval = str(valuelist[i])
+        criterion = criterion + ' x['+str(columnlist[i])+']=='+critval+' or'
+    criterion = criterion[0:-2]         # remove the "or" after the last crit
+    function = 'filter(lambda x: '+criterion+',listoflists)'
+    lines = eval(function)
+    return lines
+
+
+def linedelimited (inlist,delimiter):
+    """
+Returns a string composed of elements in inlist, with each element
+separated by 'delimiter.'  Used by function writedelimited.  Use '\t'
+for tab-delimiting.
+
+Usage:   linedelimited (inlist,delimiter)
+"""
+    outstr = ''
+    for item in inlist:
+        if type(item) <> StringType:
+            item = str(item)
+        outstr = outstr + item + delimiter
+    outstr = outstr[0:-1]
+    return outstr
+
+
+def lineincols (inlist,colsize):
+    """
+Returns a string composed of elements in inlist, with each element
+right-aligned in columns of (fixed) colsize.
+
+Usage:   lineincols (inlist,colsize)   where colsize is an integer
+"""
+    outstr = ''
+    for item in inlist:
+        if type(item) <> StringType:
+            item = str(item)
+        size = len(item)
+        if size <= colsize:
+            for i in range(colsize-size):
+                outstr = outstr + ' '
+            outstr = outstr + item
+        else:
+            outstr = outstr + item[0:colsize+1]
+    return outstr
+
+
+def lineincustcols (inlist,colsizes):
+    """
+Returns a string composed of elements in inlist, with each element
+right-aligned in a column of width specified by a sequence colsizes.  The
+length of colsizes must be greater than or equal to the number of columns
+in inlist.
+
+Usage:   lineincustcols (inlist,colsizes)
+Returns: formatted string created from inlist
+"""
+    outstr = ''
+    for i in range(len(inlist)):
+        if type(inlist[i]) <> StringType:
+            item = str(inlist[i])
+        else:
+            item = inlist[i]
+        size = len(item)
+        if size <= colsizes[i]:
+            for j in range(colsizes[i]-size):
+                outstr = outstr + ' '
+            outstr = outstr + item
+        else:
+            outstr = outstr + item[0:colsizes[i]+1]
+    return outstr
+
+
+def list2string (inlist,delimit=' '):
+    """
+Converts a 1D list to a single long string for file output, using
+the string.join function.
+
+Usage:   list2string (inlist,delimit=' ')
+Returns: the string created from inlist
+"""
+    stringlist = map(makestr,inlist)
+    return string.join(stringlist,delimit)
+
+
+def makelol(inlist):
+    """
+Converts a 1D list to a 2D list (i.e., a list-of-lists).  Useful when you
+want to use put() to write a 1D list one item per line in the file.
+
+Usage:   makelol(inlist)
+Returns: if l = [1,2,'hi'] then returns [[1],[2],['hi']] etc.
+"""
+    x = []
+    for item in inlist:
+        x.append([item])
+    return x
+
+
+def makestr (x):
+    if type(x) <> StringType:
+        x = str(x)
+    return x
+
+
+def printcc (lst,extra=2):
+    """
+Prints a list of lists in columns, customized by the max size of items
+within the columns (max size of items in col, plus 'extra' number of spaces).
+Use 'dashes' or '\\n' in the list-of-lists to print dashes or blank lines,
+respectively.
+
+Usage:   printcc (lst,extra=2)
+Returns: None
+"""
+    if type(lst[0]) not in [ListType,TupleType]:
+        lst = [lst]
+    rowstokill = []
+    list2print = copy.deepcopy(lst)
+    for i in range(len(lst)):
+        if lst[i] == ['\n'] or lst[i]=='\n' or lst[i]=='dashes' or lst[i]=='' or lst[i]==['']:
+            rowstokill = rowstokill + [i]
+    rowstokill.reverse()   # delete blank rows from the end
+    for row in rowstokill:
+        del list2print[row]
+    maxsize = [0]*len(list2print[0])
+    for col in range(len(list2print[0])):
+        items = colex(list2print,col)
+        items = map(makestr,items)
+        maxsize[col] = max(map(len,items)) + extra
+    for row in lst:
+        if row == ['\n'] or row == '\n' or row == '' or row == ['']:
+            print
+        elif row == ['dashes'] or row == 'dashes':
+            dashes = [0]*len(maxsize)
+            for j in range(len(maxsize)):
+                dashes[j] = '-'*(maxsize[j]-2)
+            print lineincustcols(dashes,maxsize)
+        else:
+            print lineincustcols(row,maxsize)
+    return None
+
+
+def printincols (listoflists,colsize):
+    """
+Prints a list of lists in columns of (fixed) colsize width, where
+colsize is an integer.
+
+Usage:   printincols (listoflists,colsize)
+Returns: None
+"""
+    for row in listoflists:
+        print lineincols(row,colsize)
+    return None
+
+
+def pl (listoflists):
+    """
+Prints a list of lists, 1 list (row) at a time.
+
+Usage:   pl(listoflists)
+Returns: None
+"""
+    for row in listoflists:
+        if row[-1] == '\n':
+            print row,
+        else:
+            print row
+    return None
+
+
+def printl(listoflists):
+    """Alias for pl."""
+    pl(listoflists)
+    return
+
+
+def replace (inlst,oldval,newval):
+    """
+Replaces all occurrences of 'oldval' with 'newval', recursively.
+
+Usage:   replace (inlst,oldval,newval)
+"""
+    lst = inlst*1
+    for i in range(len(lst)):
+        if type(lst[i]) not in [ListType,TupleType]:
+            if lst[i]==oldval: lst[i]=newval
+        else:
+            lst[i] = replace(lst[i],oldval,newval)
+    return lst
+
+
+def recode (inlist,listmap,cols=None):
+    """
+Changes the values in a list to a new set of values (useful when
+you need to recode data from (e.g.) strings to numbers.  cols defaults
+to None (meaning all columns are recoded).
+
+Usage:   recode (inlist,listmap,cols=None)  cols=recode cols, listmap=2D list
+Returns: inlist with the appropriate values replaced with new ones
+"""
+    lst = copy.deepcopy(inlist)
+    if cols != None:
+        if type(cols) not in [ListType,TupleType]:
+            cols = [cols]
+        for col in cols:
+            for row in range(len(lst)):
+                try:
+                    idx = colex(listmap,0).index(lst[row][col])
+                    lst[row][col] = listmap[idx][1]
+                except ValueError:
+                    pass
+    else:
+        for row in range(len(lst)):
+            for col in range(len(lst)):
+                try:
+                    idx = colex(listmap,0).index(lst[row][col])
+                    lst[row][col] = listmap[idx][1]
+                except ValueError:
+                    pass
+    return lst
+
+
+def remap (listoflists,criterion):
+    """
+Remaps values in a given column of a 2D list (listoflists).  This requires
+a criterion as a function of 'x' so that the result of the following is
+returned ... map(lambda x: 'criterion',listoflists).  
+
+Usage:   remap(listoflists,criterion)    criterion=string
+Returns: remapped version of listoflists
+"""
+    function = 'map(lambda x: '+criterion+',listoflists)'
+    lines = eval(function)
+    return lines
+
+
+def roundlist (inlist,digits):
+    """
+Goes through each element in a 1D or 2D inlist, and applies the following
+function to all elements of FloatType ... round(element,digits).
+
+Usage:   roundlist(inlist,digits)
+Returns: list with rounded floats
+"""
+    if type(inlist[0]) in [IntType, FloatType]:
+        inlist = [inlist]
+    l = inlist*1
+    for i in range(len(l)):
+        for j in range(len(l[i])):
+            if type(l[i][j])==FloatType:
+                l[i][j] = round(l[i][j],digits)
+    return l
+
+
+def sortby(listoflists,sortcols):
+    """
+Sorts a list of lists on the column(s) specified in the sequence
+sortcols.
+
+Usage:   sortby(listoflists,sortcols)
+Returns: sorted list, unchanged column ordering
+"""
+    newlist = abut(colex(listoflists,sortcols),listoflists)
+    newlist.sort()
+    try:
+        numcols = len(sortcols)
+    except TypeError:
+        numcols = 1
+    crit = '[' + str(numcols) + ':]'
+    newlist = colex(newlist,crit)
+    return newlist
+
+
+def unique (inlist):
+    """
+Returns all unique items in the passed list.  If the a list-of-lists
+is passed, unique LISTS are found (i.e., items in the first dimension are
+compared).
+
+Usage:   unique (inlist)
+Returns: the unique elements (or rows) in inlist
+"""
+    uniques = []
+    for item in inlist:
+        if item not in uniques:
+            uniques.append(item)
+    return uniques
+
+def duplicates(inlist):
+    """
+Returns duplicate items in the FIRST dimension of the passed list.
+
+Usage:   duplicates (inlist)
+"""
+    dups = []
+    for i in range(len(inlist)):
+        if inlist[i] in inlist[i+1:]:
+            dups.append(inlist[i])
+    return dups
+
+
+def nonrepeats(inlist):
+    """
+Returns items that are NOT duplicated in the first dim of the passed list.
+
+Usage:   nonrepeats (inlist)
+"""
+    nonrepeats = []
+    for i in range(len(inlist)):
+        if inlist.count(inlist[i]) == 1:
+            nonrepeats.append(inlist[i])
+    return nonrepeats
+
+
+#===================   PSTAT ARRAY FUNCTIONS  =====================
+#===================   PSTAT ARRAY FUNCTIONS  =====================
+#===================   PSTAT ARRAY FUNCTIONS  =====================
+#===================   PSTAT ARRAY FUNCTIONS  =====================
+#===================   PSTAT ARRAY FUNCTIONS  =====================
+#===================   PSTAT ARRAY FUNCTIONS  =====================
+#===================   PSTAT ARRAY FUNCTIONS  =====================
+#===================   PSTAT ARRAY FUNCTIONS  =====================
+#===================   PSTAT ARRAY FUNCTIONS  =====================
+#===================   PSTAT ARRAY FUNCTIONS  =====================
+#===================   PSTAT ARRAY FUNCTIONS  =====================
+#===================   PSTAT ARRAY FUNCTIONS  =====================
+#===================   PSTAT ARRAY FUNCTIONS  =====================
+#===================   PSTAT ARRAY FUNCTIONS  =====================
+#===================   PSTAT ARRAY FUNCTIONS  =====================
+#===================   PSTAT ARRAY FUNCTIONS  =====================
+
+try:                         # DEFINE THESE *ONLY* IF numpy IS AVAILABLE
+ import numpy as N
+
+ def aabut (source, *args):
+    """
+Like the |Stat abut command.  It concatenates two arrays column-wise
+and returns the result.  CAUTION:  If one array is shorter, it will be
+repeated until it is as long as the other.
+
+Usage:   aabut (source, args)    where args=any # of arrays
+Returns: an array as long as the LONGEST array past, source appearing on the
+         'left', arrays in <args> attached on the 'right'.
+"""
+    if len(source.shape)==1:
+        width = 1
+        source = N.resize(source,[source.shape[0],width])
+    else:
+        width = source.shape[1]
+    for addon in args:
+        if len(addon.shape)==1:
+            width = 1
+            addon = N.resize(addon,[source.shape[0],width])
+        else:
+            width = source.shape[1]
+        if len(addon) < len(source):
+            addon = N.resize(addon,[source.shape[0],addon.shape[1]])
+        elif len(source) < len(addon):
+            source = N.resize(source,[addon.shape[0],source.shape[1]])
+        source = N.concatenate((source,addon),1)
+    return source
+
+
+ def acolex (a,indices,axis=1):
+    """
+Extracts specified indices (a list) from passed array, along passed
+axis (column extraction is default).  BEWARE: A 1D array is presumed to be a
+column-array (and that the whole array will be returned as a column).
+
+Usage:   acolex (a,indices,axis=1)
+Returns: the columns of a specified by indices
+"""
+    if type(indices) not in [ListType,TupleType,N.ndarray]:
+        indices = [indices]
+    if len(N.shape(a)) == 1:
+        cols = N.resize(a,[a.shape[0],1])
+    else:
+#        print a[:3]
+        cols = N.take(a,indices,axis)
+#        print cols[:3]
+    return cols
+
+
+ def acollapse (a,keepcols,collapsecols,fcn1=None,fcn2=None,cfcn=None):
+    """
+Averages data in collapsecol, keeping all unique items in keepcols
+(using unique, which keeps unique LISTS of column numbers), retaining
+the unique sets of values in keepcols, the mean for each.  If stderror or
+N of the mean are desired, set either or both parameters to 1.
+
+Usage:   acollapse (a,keepcols,collapsecols,fcn1=None,fcn2=None,cfcn=None)
+Returns: unique 'conditions' specified by the contents of columns specified
+         by keepcols, abutted with the mean(s) of column(s) specified by
+         collapsecols
+"""
+    def acollmean (inarray):
+        return N.sum(N.ravel(inarray))
+
+    if type(keepcols) not in [ListType,TupleType,N.ndarray]:
+        keepcols = [keepcols]
+    if type(collapsecols) not in [ListType,TupleType,N.ndarray]:
+        collapsecols = [collapsecols]
+
+    if cfcn == None:
+        cfcn = acollmean
+    if keepcols == []:
+        avgcol = acolex(a,collapsecols)
+        means = N.sum(avgcol)/float(len(avgcol))
+        if fcn1<>None:
+            try:
+                test = fcn1(avgcol)
+            except:
+                test = N.array(['N/A']*len(means))
+            means = aabut(means,test)
+        if fcn2<>None:
+            try:
+                test = fcn2(avgcol)
+            except:
+                test = N.array(['N/A']*len(means))
+            means = aabut(means,test)
+        return means
+    else:
+        if type(keepcols) not in [ListType,TupleType,N.ndarray]:
+            keepcols = [keepcols]
+        values = colex(a,keepcols)   # so that "item" can be appended (below)
+        uniques = unique(values)  # get a LIST, so .sort keeps rows intact
+        uniques.sort()
+        newlist = []
+        for item in uniques:
+            if type(item) not in [ListType,TupleType,N.ndarray]:
+                item =[item]
+            tmprows = alinexand(a,keepcols,item)
+            for col in collapsecols:
+                avgcol = acolex(tmprows,col)
+                item.append(acollmean(avgcol))
+                if fcn1<>None:
+                    try:
+                        test = fcn1(avgcol)
+                    except:
+                        test = 'N/A'
+                    item.append(test)
+                if fcn2<>None:
+                    try:
+                        test = fcn2(avgcol)
+                    except:
+                        test = 'N/A'
+                    item.append(test)
+                newlist.append(item)
+        try:
+            new_a = N.array(newlist)
+        except TypeError:
+            new_a = N.array(newlist,'O')
+        return new_a
+
+
+ def adm (a,criterion):
+    """
+Returns rows from the passed list of lists that meet the criteria in
+the passed criterion expression (a string as a function of x).
+
+Usage:   adm (a,criterion)   where criterion is like 'x[2]==37'
+"""
+    function = 'filter(lambda x: '+criterion+',a)'
+    lines = eval(function)
+    try:
+        lines = N.array(lines)
+    except:
+        lines = N.array(lines,dtype='O')
+    return lines
+
+
+ def isstring(x):
+    if type(x)==StringType:
+        return 1
+    else:
+        return 0
+
+
+ def alinexand (a,columnlist,valuelist):
+    """
+Returns the rows of an array where col (from columnlist) = val
+(from valuelist).  One value is required for each column in columnlist.
+
+Usage:   alinexand (a,columnlist,valuelist)
+Returns: the rows of a where columnlist[i]=valuelist[i] for ALL i
+"""
+    if type(columnlist) not in [ListType,TupleType,N.ndarray]:
+        columnlist = [columnlist]
+    if type(valuelist) not in [ListType,TupleType,N.ndarray]:
+        valuelist = [valuelist]
+    criterion = ''
+    for i in range(len(columnlist)):
+        if type(valuelist[i])==StringType:
+            critval = '\'' + valuelist[i] + '\''
+        else:
+            critval = str(valuelist[i])
+        criterion = criterion + ' x['+str(columnlist[i])+']=='+critval+' and'
+    criterion = criterion[0:-3]         # remove the "and" after the last crit
+    return adm(a,criterion)
+
+
+ def alinexor (a,columnlist,valuelist):
+    """
+Returns the rows of an array where col (from columnlist) = val (from
+valuelist).  One value is required for each column in columnlist.
+The exception is if either columnlist or valuelist has only 1 value,
+in which case that item will be expanded to match the length of the
+other list.
+
+Usage:   alinexor (a,columnlist,valuelist)
+Returns: the rows of a where columnlist[i]=valuelist[i] for ANY i
+"""
+    if type(columnlist) not in [ListType,TupleType,N.ndarray]:
+        columnlist = [columnlist]
+    if type(valuelist) not in [ListType,TupleType,N.ndarray]:
+        valuelist = [valuelist]
+    criterion = ''
+    if len(columnlist) == 1 and len(valuelist) > 1:
+        columnlist = columnlist*len(valuelist)
+    elif len(valuelist) == 1 and len(columnlist) > 1:
+        valuelist = valuelist*len(columnlist)
+    for i in range(len(columnlist)):
+        if type(valuelist[i])==StringType:
+            critval = '\'' + valuelist[i] + '\''
+        else:
+            critval = str(valuelist[i])
+        criterion = criterion + ' x['+str(columnlist[i])+']=='+critval+' or'
+    criterion = criterion[0:-2]         # remove the "or" after the last crit
+    return adm(a,criterion)
+
+
+ def areplace (a,oldval,newval):
+    """
+Replaces all occurrences of oldval with newval in array a.
+
+Usage:   areplace(a,oldval,newval)
+"""
+    return N.where(a==oldval,newval,a)
+
+
+ def arecode (a,listmap,col='all'):
+    """
+Remaps the values in an array to a new set of values (useful when
+you need to recode data from (e.g.) strings to numbers as most stats
+packages require.  Can work on SINGLE columns, or 'all' columns at once.
+@@@BROKEN 2007-11-26
+
+Usage:   arecode (a,listmap,col='all')
+Returns: a version of array a where listmap[i][0] = (instead) listmap[i][1]
+"""
+    ashape = a.shape
+    if col == 'all':
+        work = a.ravel()
+    else:
+        work = acolex(a,col)
+        work = work.ravel()
+    for pair in listmap:
+        if type(pair[1]) == StringType or work.dtype.char=='O' or a.dtype.char=='O':
+            work = N.array(work,dtype='O')
+            a = N.array(a,dtype='O')
+            for i in range(len(work)):
+                if work[i]==pair[0]:
+                    work[i] = pair[1]
+            if col == 'all':
+                return N.reshape(work,ashape)
+            else:
+                return N.concatenate([a[:,0:col],work[:,N.newaxis],a[:,col+1:]],1)
+        else:   # must be a non-Object type array and replacement
+            work = N.where(work==pair[0],pair[1],work)
+            return N.concatenate([a[:,0:col],work[:,N.newaxis],a[:,col+1:]],1)
+
+
+ def arowcompare(row1, row2):
+    """
+Compares two rows from an array, regardless of whether it is an
+array of numbers or of python objects (which requires the cmp function).
+@@@PURPOSE? 2007-11-26
+
+Usage:   arowcompare(row1,row2)
+Returns: an array of equal length containing 1s where the two rows had
+         identical elements and 0 otherwise
+"""
+    return 
+    if row1.dtype.char=='O' or row2.dtype=='O':
+        cmpvect = N.logical_not(abs(N.array(map(cmp,row1,row2)))) # cmp fcn gives -1,0,1
+    else:
+        cmpvect = N.equal(row1,row2)
+    return cmpvect
+
+
+ def arowsame(row1, row2):
+    """
+Compares two rows from an array, regardless of whether it is an
+array of numbers or of python objects (which requires the cmp function).
+
+Usage:   arowsame(row1,row2)
+Returns: 1 if the two rows are identical, 0 otherwise.
+"""
+    cmpval = N.alltrue(arowcompare(row1,row2))
+    return cmpval
+
+
+ def asortrows(a,axis=0):
+    """
+Sorts an array "by rows".  This differs from the Numeric.sort() function,
+which sorts elements WITHIN the given axis.  Instead, this function keeps
+the elements along the given axis intact, but shifts them 'up or down'
+relative to one another.
+
+Usage:   asortrows(a,axis=0)
+Returns: sorted version of a
+"""
+    return N.sort(a,axis=axis,kind='mergesort')
+
+
+ def aunique(inarray):
+    """
+Returns unique items in the FIRST dimension of the passed array. Only
+works on arrays NOT including string items.
+
+Usage:   aunique (inarray)
+"""
+    uniques = N.array([inarray[0]])
+    if len(uniques.shape) == 1:            # IF IT'S A 1D ARRAY
+        for item in inarray[1:]:
+            if N.add.reduce(N.equal(uniques,item).ravel()) == 0:
+                try:
+                    uniques = N.concatenate([uniques,N.array[N.newaxis,:]])
+                except TypeError:
+                    uniques = N.concatenate([uniques,N.array([item])])
+    else:                                  # IT MUST BE A 2+D ARRAY
+        if inarray.dtype.char != 'O':  # not an Object array
+            for item in inarray[1:]:
+                if not N.sum(N.alltrue(N.equal(uniques,item),1)):
+                    try:
+                        uniques = N.concatenate( [uniques,item[N.newaxis,:]] )
+                    except TypeError:    # the item to add isn't a list
+                        uniques = N.concatenate([uniques,N.array([item])])
+                else:
+                    pass  # this item is already in the uniques array
+        else:   # must be an Object array, alltrue/equal functions don't work
+            for item in inarray[1:]:
+                newflag = 1
+                for unq in uniques:  # NOTE: cmp --> 0=same, -1=<, 1=>
+                    test = N.sum(abs(N.array(map(cmp,item,unq))))
+                    if test == 0:   # if item identical to any 1 row in uniques
+                        newflag = 0 # then not a novel item to add
+                        break
+                if newflag == 1:
+                    try:
+                        uniques = N.concatenate( [uniques,item[N.newaxis,:]] )
+                    except TypeError:    # the item to add isn't a list
+                        uniques = N.concatenate([uniques,N.array([item])])
+    return uniques
+
+
+ def aduplicates(inarray):
+    """
+Returns duplicate items in the FIRST dimension of the passed array. Only
+works on arrays NOT including string items.
+
+Usage:   aunique (inarray)
+"""
+    inarray = N.array(inarray)
+    if len(inarray.shape) == 1:            # IF IT'S A 1D ARRAY
+        dups = []
+        inarray = inarray.tolist()
+        for i in range(len(inarray)):
+            if inarray[i] in inarray[i+1:]:
+                dups.append(inarray[i])
+        dups = aunique(dups)
+    else:                                  # IT MUST BE A 2+D ARRAY
+        dups = []
+        aslist = inarray.tolist()
+        for i in range(len(aslist)):
+            if aslist[i] in aslist[i+1:]:
+                dups.append(aslist[i])
+        dups = unique(dups)
+        dups = N.array(dups)
+    return dups
+
+except ImportError:    # IF NUMERIC ISN'T AVAILABLE, SKIP ALL arrayfuncs
+ pass
diff --git a/utils/tabulator.py b/utils/tabulator.py
index 3c6b183..ed83a04 100644
--- a/utils/tabulator.py
+++ b/utils/tabulator.py
@@ -5,20 +5,14 @@
 import getpass
 import math
 import numpy
+
 import colortrans
 from email_sender import EmailSender
-
-
-def _IsFloat(v):
-  try:
-    float(v)
-    return True
-  except ValueError:
-    return False
+import misc
 
 
 def _AllFloat(values):
-  return all([_IsFloat(v) for v in values])
+  return all([misc.IsFloat(v) for v in values])
 
 
 def _GetFloats(values):
@@ -45,10 +39,11 @@
 
   MISSING_VALUE = "x"
 
-  def __init__(self, d, l, sort=SORT_BY_KEYS):
+  def __init__(self, d, l, sort=SORT_BY_KEYS, key_name="keys"):
     self._runs = d
     self._labels = l
     self._sort = sort
+    self._key_name = key_name
 
   def _AggregateKeys(self):
     keys = set([])
@@ -116,7 +111,7 @@
       module.
     """
     keys = self._GetKeys()
-    header = ["keys"] + self._labels
+    header = [self._key_name] + self._labels
     table = [header]
     for k in keys:
       row = [k]
@@ -164,7 +159,13 @@
   def _GetGmean(self, values):
     if not values:
       return float("nan")
-    return (reduce(lambda x, y: x*y, values))**(1.0/len(values))
+    if any([v < 0 for v in values]):
+      return float ("nan")
+    if any([v == 0 for v in values]):
+      return 0.0
+    log_list = [math.log(v) for v in values]
+    gmean_log = sum(log_list)/len(log_list)
+    return math.exp(gmean_log)
 
   def Compute(self, cell, values, baseline_values):
     """Compute the result given a list of values and baseline values.
@@ -221,6 +222,19 @@
 class NonEmptyCountResult(Result):
   def Compute(self, cell, values, baseline_values):
     cell.value = len(_StripNone(values))
+    if not baseline_values:
+      return
+    base_value = len(_StripNone(baseline_values))
+    if cell.value == base_value:
+      return
+    f = ColorBoxFormat()
+    len_values = len(values)
+    len_baseline_values = len(baseline_values)
+    tmp_cell = Cell()
+    tmp_cell.value= 1.0 + (float(cell.value - base_value) /
+                         (max(len_values, len_baseline_values)))
+    f.Compute(tmp_cell)
+    cell.bgcolor = tmp_cell.bgcolor
 
 
 class StringMeanResult(Result):
@@ -273,7 +287,7 @@
 
 class CoeffVarResult(NumericalResult):
   def _ComputeFloat(self, cell, values, baseline_values):
-    noise = numpy.std(values)/numpy.mean(values)
+    noise = numpy.abs(numpy.std(values)/numpy.mean(values))
     cell.value = noise
 
 
@@ -297,7 +311,7 @@
       cell.value = "?"
 
 
-class StatsSignificant(ComparisonResult):
+class PValueResult(ComparisonResult):
   def _ComputeFloat(self, cell, values, baseline_values):
     if len(values) < 2 or len(baseline_values) < 2:
       cell.value = float("nan")
@@ -308,6 +322,7 @@
   def _ComputeString(self, cell, values, baseline_values):
     return float("nan")
 
+
 class KeyAwareComparisonResult(ComparisonResult):
   def _IsLowerBetter(self, key):
     lower_is_better_keys = ["milliseconds", "ms", "seconds", "KB",
@@ -442,6 +457,19 @@
     return ret
 
 
+class PValueFormat(Format):
+  def _ComputeFloat(self, cell):
+    cell.string_value = "%0.2f" % float(cell.value)
+    if float(cell.value) < 0.05:
+      cell.bgcolor = self._GetColor(cell.value,
+                                  Color(255, 255, 0, 0),
+                                  Color(255, 255, 255, 0),
+                                  Color(255, 255, 255, 0),
+                                  mid_value=0.05,
+                                  power=1)
+      cell.bgcolor_row = True
+
+
 class StorageFormat(Format):
   """Format the cell as a storage number.
 
@@ -549,6 +577,7 @@
     colspan: Set the colspan of the cell in the HTML table, this is used for
     table headers. Default value is 1.
     name: the test name of the cell.
+    header: Whether this is a header in html.
   """
 
   def __init__(self):
@@ -564,6 +593,7 @@
     self.width = None
     self.colspan = 1
     self.name = None
+    self.header = False
 
   def __str__(self):
     l = []
@@ -614,7 +644,7 @@
     self._table_columns = []
     self._out_table = []
 
-  def _GenerateCellTable(self):
+  def GenerateCellTable(self):
     row_index = 0
 
     for row in self._table[1:]:
@@ -645,13 +675,15 @@
       self._out_table.append(out_row)
       row_index += 1
 
-    # TODO(asharif): refactor this.
-    # Now generate header
+  def AddColumnName(self):
+    """Generate Column name at the top of table."""
     key = Cell()
+    key.header = True
     key.string_value = "Keys"
     header = [key]
     for column in self._table_columns:
       cell = Cell()
+      cell.header = True
       if column.name:
         cell.string_value = column.name
       else:
@@ -665,22 +697,37 @@
 
     self._out_table = [header] + self._out_table
 
+  def AddHeader(self, s):
+    """Put additional string on the top of the table."""
+    cell = Cell()
+    cell.header = True
+    cell.string_value = str(s)
+    header = [cell]
+    colspan = max(1, max(len(row) for row in self._table))
+    cell.colspan = colspan
+    self._out_table = [header] + self._out_table
+
+  def AddLabelName(self):
+    """Put label on the top of the table."""
     top_header = []
-    colspan = 0
-    for column in self._columns:
-      if not column.result.NeedsBaseline():
-        colspan += 1
+    base_colspan = len([c for c in self._columns
+                        if not c.result.NeedsBaseline()])
+    compare_colspan = len(self._columns)
+    # The label is organized as follows
+    # "keys" label_base, label_comparison1, label_comparison2
+    # The first cell has colspan 1, the second is base_colspan
+    # The others are compare_colspan
     for label in self._table[0]:
       cell = Cell()
+      cell.header = True
       cell.string_value = str(label)
-      if cell.string_value != "keys":
-        cell.colspan = colspan
+      if top_header:
+        cell.colspan = base_colspan
+      if len(top_header) > 1:
+        cell.colspan = compare_colspan
       top_header.append(cell)
-
     self._out_table = [top_header] + self._out_table
 
-    return self._out_table
-
   def _PrintOutTable(self):
     o = ""
     for row in self._out_table:
@@ -689,18 +736,25 @@
       o += "\n"
     print o
 
-  def GetCellTable(self):
+  def GetCellTable(self, headers=True):
     """Function to return a table of cells.
 
     The table (list of lists) is converted into a table of cells by this
     function.
+    Args:
+      headers: A boolean saying whether we want default headers
 
     Returns:
       A table of cells with each cell having the properties and string values as
       requiested by the columns passed in the constructor.
     """
     # Generate the cell table, creating a list of dynamic columns on the fly.
-    return self._GenerateCellTable()
+    if not self._out_table:
+      self.GenerateCellTable()
+    if headers:
+      self.AddColumnName()
+      self.AddLabelName()
+    return self._out_table
 
 
 class TablePrinter(object):
@@ -726,16 +780,22 @@
           assert cell.color, "Cell color not set but color_row set!"
           assert not row_style.color, "Multiple row_style.colors found!"
           row_style.color = cell.color
+        if cell.bgcolor_row:
+          assert cell.bgcolor, "Cell bgcolor not set but bgcolor_row set!"
+          assert not row_style.bgcolor, "Multiple row_style.bgcolors found!"
+          row_style.bgcolor = cell.bgcolor
       self._row_styles.append(row_style)
 
     self._column_styles = []
     if len(self._table) < 2:
       return
-    for i in range(len(self._table[1])):
+
+    for i in range(max(len(row) for row in self._table)):
       column_style = Cell()
-      for row in self._table[1:]:
-        column_style.width = max(column_style.width,
-                                 len(row[i].string_value))
+      for row in self._table:
+        if not any([cell.colspan != 1 for cell in row]):
+          column_style.width = max(column_style.width,
+                                   len(row[i].string_value))
       self._column_styles.append(column_style)
 
   def _GetBGColorFix(self, color):
@@ -746,7 +806,7 @@
       suffix = "\033[0m"
     elif self._output_type in [self.EMAIL, self.HTML]:
       rgb = color.GetRGB()
-      prefix = ("<FONT style=\"BACKGROUND-COLOR:#{0}\" color =#{0}>"
+      prefix = ("<FONT style=\"BACKGROUND-COLOR:#{0}\">"
                 .format(rgb))
       suffix = "</FONT>"
     elif self._output_type in [self.PLAIN, self.TSV]:
@@ -780,26 +840,15 @@
 
   def _GetCellValue(self, i, j):
     cell = self._table[i][j]
-    color = None
     out = cell.string_value
-    if self._row_styles[i].color:
-      color = self._row_styles[i].color
-    elif cell.color:
-      color = cell.color
-
-    if self._row_styles[i].bgcolor:
-      bgcolor = self._row_styles[i].bgcolor
-    else:
-      bgcolor = cell.bgcolor
-
     raw_width = len(out)
 
-    if color:
-      p, s = self._GetColorFix(color)
+    if cell.color:
+      p, s = self._GetColorFix(cell.color)
       out = "%s%s%s" % (p, out, s)
 
-    if bgcolor:
-      p, s = self._GetBGColorFix(bgcolor)
+    if cell.bgcolor:
+      p, s = self._GetBGColorFix(cell.bgcolor)
       out = "%s%s%s" % (p, out, s)
 
     if self._output_type in [self.PLAIN, self.CONSOLE, self.EMAIL]:
@@ -812,14 +861,17 @@
           width = len(cell.string_value)
       if cell.colspan > 1:
         width = 0
+        start = 0
+        for k in range(j):
+          start += self._table[i][k].colspan
         for k in range(cell.colspan):
-          width += self._column_styles[1 + (j-1) * cell.colspan + k].width
+          width += self._column_styles[start + k].width
       if width > raw_width:
         padding = ("%" + str(width - raw_width) + "s") % ""
         out = padding + out
 
     if self._output_type == self.HTML:
-      if i < 2:
+      if cell.header:
         tag = "th"
       else:
         tag = "td"
@@ -831,7 +883,7 @@
     if self._output_type in [self.CONSOLE, self.PLAIN, self.EMAIL]:
       return " "
     if self._output_type == self.HTML:
-      return "&nbsp;"
+      return ""
     if self._output_type == self.TSV:
       return "\t"
 
@@ -858,9 +910,17 @@
     o += self._GetPrefix()
     for i in range(len(self._table)):
       row = self._table[i]
+      # Apply row color and bgcolor.
+      p = s = bgp = bgs = ""
+      if self._row_styles[i].bgcolor:
+        bgp, bgs = self._GetBGColorFix(self._row_styles[i].bgcolor)
+      if self._row_styles[i].color:
+        p, s = self._GetColorFix(self._row_styles[i].color)
+      o += p + bgp
       for j in range(len(row)):
         out = self._GetCellValue(i, j)
         o += out + self._GetHorizontalSeparator()
+      o += s + bgs
       o += self._GetVerticalSeparator()
     o += self._GetSuffix()
     return o
@@ -925,6 +985,8 @@
                     RatioFormat()),
              Column(GmeanRatioResult(),
                     RatioFormat()),
+             Column(PValueResult(),
+                    PValueFormat()),
             ]
   tf = TableFormatter(table, columns)
   cell_table = tf.GetCellTable()
@@ -952,6 +1014,17 @@
   print t
   email = GetComplexTable(runs, labels, TablePrinter.EMAIL)
 
+  runs = [
+      [
+          {"k1": "1",}, {"k1": "1.1"}, {"k1": "1.2"},
+          ],
+      [
+          {"k1": "5",}, {"k1": "5.1"}, {"k1": "5.2"},
+          ],
+      ]
+  t = GetComplexTable(runs, labels, TablePrinter.CONSOLE)
+  print t
+
   simple_table = [
       ["binary", "b1", "b2", "b3"],
       ["size", 100, 105, 108],
@@ -961,7 +1034,7 @@
       ]
   t = GetSimpleTable(simple_table)
   print t
-  email += GetSimpleTable(simple_table, TablePrinter.PLAIN)
+  email += GetSimpleTable(simple_table, TablePrinter.HTML)
   email_to = [getpass.getuser()]
   email = "<pre style='font-size: 13px'>%s</pre>" % email
   EmailSender().SendEmail(email_to, "SimpleTableTest", email, msg_type="html")
diff --git a/utils/tabulator_test.py b/utils/tabulator_test.py
index e1892b0..54b455d 100644
--- a/utils/tabulator_test.py
+++ b/utils/tabulator_test.py
@@ -2,7 +2,7 @@
 
 """Tests for misc."""
 
-__author__ = 'asharif@google.com (Ahmad Sharif)'
+__author__ = "asharif@google.com (Ahmad Sharif)"
 
 # System modules
 import unittest
@@ -61,6 +61,11 @@
     c3.Round()
     self.assertTrue(c3.r == 127)
 
+  def testGmean(self):
+    a = [1.0e+308] * 3
+    b = tabulator.Result()._GetGmean(a)
+    self.assertTrue(b >= 0.99e+308 and b <= 1.01e+308)
+
   def testTableGenerator(self):
     runs = [[{"k1": "10", "k2": "12"},
              {"k1": "13", "k2": "14", "k3": "15"}],
@@ -91,6 +96,40 @@
     table = tf.GetCellTable()
     self.assertTrue(table)
 
+  def testColspan(self):
+    simple_table = [
+        ["binary", "b1", "b2", "b3"],
+        ["size", 100, 105, 108],
+        ["rodata", 100, 80, 70],
+        ["data", 100, 100, 100],
+        ["debug", 100, 140, 60],
+        ]
+    columns = [
+        tabulator.Column(tabulator.AmeanResult(),
+                         tabulator.Format()),
+        tabulator.Column(tabulator.MinResult(),
+                         tabulator.Format()),
+        tabulator.Column(tabulator.AmeanRatioResult(),
+                         tabulator.PercentFormat()),
+        tabulator.Column(tabulator.AmeanRatioResult(),
+                         tabulator.ColorBoxFormat()),
+        ]
+    our_table = [simple_table[0]]
+    for row in simple_table[1:]:
+      our_row = [row[0]]
+      for v in row[1:]:
+        our_row.append([v])
+      our_table.append(our_row)
 
-if __name__ == '__main__':
+    tf = tabulator.TableFormatter(our_table, columns)
+    cell_table = tf.GetCellTable()
+    self.assertTrue(cell_table[0][0].colspan == 1)
+    self.assertTrue(cell_table[0][1].colspan == 2)
+    self.assertTrue(cell_table[0][2].colspan == 4)
+    self.assertTrue(cell_table[0][3].colspan == 4)
+    for row in cell_table[1:]:
+      for cell in row:
+        self.assertTrue(cell.colspan == 1)
+
+if __name__ == "__main__":
   unittest.main()
diff --git a/utils/timeline.py b/utils/timeline.py
new file mode 100644
index 0000000..fa75ba0
--- /dev/null
+++ b/utils/timeline.py
@@ -0,0 +1,51 @@
+#!/usr/bin/python2.6
+#
+# Copyright 2012 Google Inc. All Rights Reserved.
+#
+
+"""Tools for recording and reporting timeline of benchmark_run."""
+
+__author__ = 'yunlian@google.com (Yunlian Jiang)'
+
+import time
+
+
+class Event(object):
+  def __init__(self, name='', cur_time=0):
+    self.name = name
+    self.timestamp = cur_time
+
+
+class Timeline(object):
+  """Use a dict to store the timeline."""
+
+  def __init__(self):
+    self.events = []
+
+  def Record(self, event):
+    for e in self.events:
+      assert e.name != event, ('The event {0} is already recorded.'
+                               .format(event))
+    cur_event = Event(name=event, cur_time=time.time())
+    self.events.append(cur_event)
+
+  def GetEvents(self):
+    return([e.name for e in self.events])
+
+  def GetEventDict(self):
+    tl = {}
+    for e in self.events:
+      tl[e.name] = e.timestamp
+    return tl
+
+  def GetEventTime(self, event):
+    for e in self.events:
+      if e.name == event:
+        return e.timestamp
+    raise IndexError, 'The event {0} is not recorded'.format(event)
+
+  def GetLastEventTime(self):
+    return self.events[-1].timestamp
+
+  def GetLastEvent(self):
+    return self.events[-1].name
diff --git a/utils/timeline_test.py b/utils/timeline_test.py
new file mode 100644
index 0000000..1f4d178
--- /dev/null
+++ b/utils/timeline_test.py
@@ -0,0 +1,54 @@
+# Copyright 2012 Google Inc. All Rights Reserved.
+
+"""Tests for time_line.py."""
+
+__author__ = 'yunlian@google.com (Yunlian Jiang)'
+
+import time
+import unittest
+
+import timeline
+
+
+class TimeLineTest(unittest.TestCase):
+
+  def testRecord(self):
+    tl = timeline.Timeline()
+    tl.Record('A')
+    t = time.time()
+    t1 = tl.events[0].timestamp
+    self.assertEqual(int(t1-t), 0)
+    self.assertRaises(AssertionError, tl.Record, 'A')
+
+  def testGetEvents(self):
+    tl = timeline.Timeline()
+    tl.Record('A')
+    e = tl.GetEvents()
+    self.assertEqual(e, ['A'])
+    tl.Record('B')
+    e = tl.GetEvents()
+    self.assertEqual(e, ['A', 'B'])
+
+  def testGetEventTime(self):
+    tl = timeline.Timeline()
+    tl.Record('A')
+    t = time.time()
+    t1 = tl.GetEventTime('A')
+    self.assertEqual(int(t1-t), 0)
+    self.assertRaises(IndexError, tl.GetEventTime, 'B')
+
+  def testGetLastEventTime(self):
+    tl = timeline.Timeline()
+    self.assertRaises(IndexError, tl.GetLastEventTime)
+    tl.Record('A')
+    t = time.time()
+    t1 = tl.GetLastEventTime()
+    self.assertEqual(int(t1-t), 0)
+    time.sleep(2)
+    tl.Record('B')
+    t = time.time()
+    t1 = tl.GetLastEventTime()
+    self.assertEqual(int(t1-t), 0)
+
+if __name__ == '__main__':
+  unittest.main()