Let benchmark runner add summary traces.

tools/run_benchmarks.py

 #!/usr/bin/env python
 # Copyright 2014 the V8 project authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 """
 Performance runner for d8.
 
 Call e.g. with tools/run-benchmarks.py --arch ia32 some_suite.json
 
@@ skipping 74 matching lines @@
      "path": ["navier_stokes"],
      "main": "run.js",
      "results_regexp": "^NavierStokes: (.+)$"}
   ]
 }
 
 Path pieces are concatenated. D8 is always run with the suite's path as cwd.
 """
 
 import json
+import math
 import optparse
 import os
 import re
 import sys
 
 from testrunner.local import commands
 from testrunner.local import utils
 
 ARCH_GUESS = utils.DefaultArch()
 SUPPORTED_ARCHS = ["android_arm",
                    "android_arm64",
                    "android_ia32",
                    "arm",
                    "ia32",
                    "mips",
                    "mipsel",
                    "nacl_ia32",
                    "nacl_x64",
                    "x64",
                    "arm64"]
 
 GENERIC_RESULTS_RE = re.compile(
     r"^Trace\(([^\)]+)\), Result\(([^\)]+)\), StdDev\(([^\)]+)\)$")
 
+
+def GeometricMean(values):
+  """Returns the geometric mean of a list of values.
+
+  The mean is calculated using log to avoid overflow.
+  """
+  values = map(float, values)
+  return str(math.exp(sum(map(math.log, values)) / len(values)))
+
+
 class Results(object):
   """Place holder for result traces."""
   def __init__(self, traces=None, errors=None):
     self.traces = traces or []
     self.errors = errors or []
 
   def ToDict(self):
     return {"traces": self.traces, "errors": self.errors}
 
   def WriteToFile(self, file_name):
@@ skipping 24 matching lines @@
     super(DefaultSentinel, self).__init__()
     self.binary = "d8"
     self.run_count = 10
     self.path = []
     self.graphs = []
     self.flags = []
     self.resources = []
     self.results_regexp = None
     self.stddev_regexp = None
     self.units = "score"
+    self.total = False
 
 
 class Graph(Node):
   """Represents a benchmark suite definition.
 
   Can either be a leaf or an inner node that provides default values.
   """
   def __init__(self, suite, parent, arch):
     super(Graph, self).__init__()
     self._suite = suite
 
     assert isinstance(suite.get("path", []), list)
     assert isinstance(suite["name"], basestring)
     assert isinstance(suite.get("flags", []), list)
     assert isinstance(suite.get("resources", []), list)
 
     # Accumulated values.
     self.path = parent.path[:] + suite.get("path", [])
     self.graphs = parent.graphs[:] + [suite["name"]]
     self.flags = parent.flags[:] + suite.get("flags", [])
     self.resources = parent.resources[:] + suite.get("resources", [])
 
     # Descrete values (with parent defaults).
     self.binary = suite.get("binary", parent.binary)
     self.run_count = suite.get("run_count", parent.run_count)
     self.run_count = suite.get("run_count_%s" % arch, self.run_count)
     self.units = suite.get("units", parent.units)
+    self.total = suite.get("total", parent.total)
 
     # A regular expression for results. If the parent graph provides a
     # regexp and the current suite has none, a string place holder for the
     # suite name is expected.
     # TODO(machenbach): Currently that makes only sense for the leaf level.
     # Multiple place holders for multiple levels are not supported.
     if parent.results_regexp:
       regexp_default = parent.results_regexp % re.escape(suite["name"])
     else:
       regexp_default = None
@@ skipping 69 matching lines @@
       self.flags +
       self.resources +
       [self.main]
     )
 
   def Run(self, runner):
     """Iterates over several runs and handles the output for all traces."""
     for stdout in runner():
       for trace in self._children:
         trace.ConsumeOutput(stdout)
-    return reduce(lambda r, t: r + t.GetResults(), self._children, Results())
+    res = reduce(lambda r, t: r + t.GetResults(), self._children, Results())
 
+    if not res.traces or not self.total:
+      return res
+
+    # Assume all traces have the same structure.
+    if len(set(map(lambda t: len(t["results"]), res.traces))) != 1:
+      res.errors.append("Not all traces have the same number of results.")
+      return res
+
+    # Calculate the geometric means for all traces. Above we made sure that
+    # there is at least one trace and that the number of results is the same
+    # for each trace.
+    n_results = len(res.traces[0]["results"])
+    total_results = [GeometricMean(t["results"][i] for t in res.traces)
+                     for i in range(0, n_results)]
+    res.traces.append({
+      "graphs": self.graphs + ["Total"],
+      "units": res.traces[0]["units"],
+      "results": total_results,
+      "stddev": "",
+    })
+    return res
 
 class RunnableTrace(Trace, Runnable):
   """Represents a runnable benchmark suite definition that is a leaf."""
   def __init__(self, suite, parent, arch):
     super(RunnableTrace, self).__init__(suite, parent, arch)
 
   def Run(self, runner):
     """Iterates over several runs and handles the output."""
     for stdout in runner():
       self.ConsumeOutput(stdout)
@@ skipping 154 matching lines @@
 
   if options.json_test_results:
     results.WriteToFile(options.json_test_results)
   else:  # pragma: no cover
     print results
 
   return min(1, len(results.errors))
 
 if __name__ == "__main__":  # pragma: no cover
   sys.exit(Main(sys.argv[1:]))