[tools] Flexible perf runner path.

tools/run_perf.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-perf.py --arch ia32 some_suite.json
 
@@ skipping 332 matching lines @@
   """Represents a node in the suite tree structure."""
   def __init__(self, *args):
     self._children = []
 
   def AppendChild(self, child):
     self._children.append(child)
 
 
 class DefaultSentinel(Node):
   """Fake parent node with all default values."""
-  def __init__(self):
+  def __init__(self, binary = "d8"):
     super(DefaultSentinel, self).__init__()
-    self.binary = "d8"
+    self.binary = binary
     self.run_count = 10
     self.timeout = 60
     self.path = []
     self.graphs = []
     self.flags = []
     self.test_flags = []
     self.resources = []
     self.results_regexp = None
     self.stddev_regexp = None
     self.units = "score"
@@ skipping 170 matching lines @@
     # This is a generic suite definition. It is either a runnable executable
     # or has a main js file.
     return RunnableGenericConfig(suite, parent, arch)
   elif suite.get("tests"):
     # This is neither a leaf nor a runnable.
     return GraphConfig(suite, parent, arch)
   else:  # pragma: no cover
     raise Exception("Invalid suite configuration.")
 
 
-def BuildGraphConfigs(suite, arch, parent=None):
+def BuildGraphConfigs(suite, arch, parent):
   """Builds a tree structure of graph objects that corresponds to the suite
   configuration.
   """
-  parent = parent or DefaultSentinel()
 
   # TODO(machenbach): Implement notion of cpu type?
   if arch not in suite.get("archs", SUPPORTED_ARCHS):
     return None
 
   graph = MakeGraphConfig(suite, arch, parent)
   for subsuite in suite.get("tests", []):
     BuildGraphConfigs(subsuite, arch, graph)
   parent.AppendChild(graph)
   return graph
@@ skipping 245 matching lines @@
                     default="")
   parser.add_option("--json-test-results",
                     help="Path to a file for storing json results.")
   parser.add_option("--json-test-results-no-patch",
                     help="Path to a file for storing json results from run "
                          "without patch.")
   parser.add_option("--outdir", help="Base directory with compile output",
                     default="out")
   parser.add_option("--outdir-no-patch",
                     help="Base directory with compile output without patch")
+  parser.add_option("--binary-override-path",
+                    help="JavaScript engine binary. By default, d8 under "
+                    "architecture-specific build dir. "
+                    "Not supported in conjunction with outdir-no-patch.")
+
   (options, args) = parser.parse_args(args)
 
   if len(args) == 0:  # pragma: no cover
     parser.print_help()
     return 1
 
   if options.arch in ["auto", "native"]:  # pragma: no cover
     options.arch = ARCH_GUESS
 
   if not options.arch in SUPPORTED_ARCHS:  # pragma: no cover
@@ skipping 10 matching lines @@
           "patch must be specified.")
     return 1
 
   workspace = os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))
 
   if options.buildbot:
     build_config = "Release"
   else:
     build_config = "%s.release" % options.arch
 
-  options.shell_dir = os.path.join(workspace, options.outdir, build_config)
+  if options.binary_override_path == None:
+    options.shell_dir = os.path.join(workspace, options.outdir, build_config)
+    default_binary_name = "d8"
+  else:
+    if not os.path.isfile(options.binary_override_path):
+      print "binary-override-path must be a file name"
+      return 1
+    if options.outdir_no_patch:
+      print "specify either binary-override-path or outdir-no-patch"
+      return 1
+    options.shell_dir = os.path.dirname(options.binary_override_path)
+    default_binary_name = os.path.basename(options.binary_override_path)
 
   if options.outdir_no_patch:
     options.shell_dir_no_patch = os.path.join(
         workspace, options.outdir_no_patch, build_config)
   else:
     options.shell_dir_no_patch = None
 
   platform = Platform.GetPlatform(options)
 
   results = Results()
   results_no_patch = Results()
   for path in args:
     path = os.path.abspath(path)
 
     if not os.path.exists(path):  # pragma: no cover
       results.errors.append("Configuration file %s does not exist." % path)
       continue
 
     with open(path) as f:
       suite = json.loads(f.read())
 
     # If no name is given, default to the file name without .json.
     suite.setdefault("name", os.path.splitext(os.path.basename(path))[0])
 
     # Setup things common to one test suite.
     platform.PreExecution()
 
     # Build the graph/trace tree structure.
-    root = BuildGraphConfigs(suite, options.arch)
+    default_parent = DefaultSentinel(default_binary_name)
+    root = BuildGraphConfigs(suite, options.arch, default_parent)
 
     # Callback to be called on each node on traversal.
     def NodeCB(node):
       platform.PreTests(node, path)
 
     # Traverse graph/trace tree and interate over all runnables.
     for runnable in FlattenRunnables(root, NodeCB):
       print ">>> Running suite: %s" % "/".join(runnable.graphs)
 
       def Runner():
@@ skipping 17 matching lines @@
 
   if options.json_test_results_no_patch:
     results_no_patch.WriteToFile(options.json_test_results_no_patch)
   else:  # pragma: no cover
     print results_no_patch
 
   return min(1, len(results.errors))
 
 if __name__ == "__main__":  # pragma: no cover
   sys.exit(Main(sys.argv[1:]))