[test] Make perf runner able to pass extra flags to d8.

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 292 matching lines @@
 
   def ChangeCWD(self, suite_path):
     """Changes the cwd to to path defined in the current graph.
 
     The tests are supposed to be relative to the suite configuration.
     """
     suite_dir = os.path.abspath(os.path.dirname(suite_path))
     bench_dir = os.path.normpath(os.path.join(*self.path))
     os.chdir(os.path.join(suite_dir, bench_dir))
 
-  def GetCommandFlags(self):
+  def GetCommandFlags(self, extra_flags=None):
     suffix = ["--"] + self.test_flags if self.test_flags else []
-    return self.flags + [self.main] + suffix
+    return self.flags + (extra_flags or []) + [self.main] + suffix
 
-  def GetCommand(self, shell_dir):
+  def GetCommand(self, shell_dir, extra_flags=None):
     # TODO(machenbach): This requires +.exe if run on windows.
-    return [os.path.join(shell_dir, self.binary)] + self.GetCommandFlags()
+    cmd = [os.path.join(shell_dir, self.binary)]
+    return cmd + self.GetCommandFlags(extra_flags=extra_flags)

[kjellander_chromium, 2015/05/13 13:23:55]

Do you have to pass them into GetCommandFlags because they need to be in a
position before [self.main] + suffix ?

Otherwise it would be easier to just append them to the result of
GetCommandFlags.

[Michael Achenbach, 2015/05/13 13:49:43]

Yes they have to come before suffix as it contains a --. Everything after the --
is not passed to d8 but to the javascript file.

 
   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)
     res = reduce(lambda r, t: r + t.GetResults(), self._children, Results())
 
     if not res.traces or not self.total:
       return res
@@ skipping 137 matching lines @@
   def GetPlatform(options):
     if options.arch.startswith("android"):
       return AndroidPlatform(options)
     else:
       return DesktopPlatform(options)
 
 
 class DesktopPlatform(Platform):
   def __init__(self, options):
     self.shell_dir = options.shell_dir
+    self.extra_flags = options.extra_flags.split()

[kjellander_chromium, 2015/05/13 13:23:55]

Move this whole constructor to Platform class to reduce code duplication.

[Michael Achenbach, 2015/05/13 13:49:43]

Will do. Followup coming...

 
   def PreExecution(self):
     pass
 
   def PostExecution(self):
     pass
 
   def PreTests(self, node, path):
     if isinstance(node, Runnable):
       node.ChangeCWD(path)
 
   def Run(self, runnable, count):
     try:
-      output = commands.Execute(runnable.GetCommand(self.shell_dir),
-                                timeout=runnable.timeout)
+      output = commands.Execute(
+          runnable.GetCommand(self.shell_dir, self.extra_flags),
+          timeout=runnable.timeout,
+      )
     except OSError as e:
       print ">>> OSError (#%d):" % (count + 1)
       print e
       return ""
     print ">>> Stdout (#%d):" % (count + 1)
     print output.stdout
     if output.stderr:  # pragma: no cover
       # Print stderr for debugging.
       print ">>> Stderr (#%d):" % (count + 1)
       print output.stderr
     if output.timed_out:
       print ">>> Test timed out after %ss." % runnable.timeout
     return output.stdout
 
 
 class AndroidPlatform(Platform):  # pragma: no cover
   DEVICE_DIR = "/data/local/tmp/v8/"
 
   def __init__(self, options):
     self.shell_dir = options.shell_dir
+    self.extra_flags = options.extra_flags.split()
     LoadAndroidBuildTools(options.android_build_tools)

[kjellander_chromium, 2015/05/13 13:23:55]

Then this would just invoke the superclass constructor + the
LoadAndroidBuildTools call.

 
     if not options.device:
       # Detect attached device if not specified.
       devices = pylib.android_commands.GetAttachedDevices(
           hardware=True, emulator=False, offline=False)
       assert devices and len(devices) == 1, (
           "None or multiple devices detected. Please specify the device on "
           "the command-line with --device")
       options.device = devices[0]
     adb_wrapper = pylib.android_commands.AndroidCommands(options.device)
@@ skipping 66 matching lines @@
 
     if isinstance(node, Runnable):
       self._PushFile(bench_abs, node.main, bench_rel)
     for resource in node.resources:
       self._PushFile(bench_abs, resource, bench_rel)
 
   def Run(self, runnable, count):
     cache = cache_control.CacheControl(self.device)
     cache.DropRamCaches()
     binary_on_device = AndroidPlatform.DEVICE_DIR + runnable.binary
-    cmd = [binary_on_device] + runnable.GetCommandFlags()
+    cmd = [binary_on_device] + runnable.GetCommandFlags(self.extra_flags)
 
     # Relative path to benchmark directory.
     if runnable.path:
       bench_rel = os.path.normpath(os.path.join(*runnable.path))
     else:
       bench_rel = "."
 
     try:
       output = self.device.RunShellCommand(
           cmd,
@@ skipping 19 matching lines @@
   parser.add_option("--arch",
                     help=("The architecture to run tests for, "
                           "'auto' or 'native' for auto-detect"),
                     default="x64")
   parser.add_option("--buildbot",
                     help="Adapt to path structure used on buildbots",
                     default=False, action="store_true")
   parser.add_option("--device",
                     help="The device ID to run Android tests on. If not given "
                          "it will be autodetected.")
+  parser.add_option("--extra-flags",
+                    help="Additional flags to pass to the test executable",
+                    default="")
   parser.add_option("--json-test-results",
                     help="Path to a file for storing json results.")
   parser.add_option("--outdir", help="Base directory with compile output",
                     default="out")
   (options, args) = parser.parse_args(args)
 
   if len(args) == 0:  # pragma: no cover
     parser.print_help()
     return 1
 
@@ skipping 67 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:]))