[test] Add an option to the perf runner to support running with the internal profiler.

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 84 matching lines @@
 The test flags are passed to the js test file after '--'.
 """
 
 from collections import OrderedDict
 import json
 import logging
 import math
 import optparse
 import os
 import re
+import subprocess
 import sys
 
 from testrunner.local import commands
 from testrunner.local import utils
 
 ARCH_GUESS = utils.DefaultArch()
 SUPPORTED_ARCHS = ["arm",
                    "ia32",
                    "mips",
                    "mipsel",
@@ skipping 333 matching lines @@
     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, extra_flags=None):
     suffix = ["--"] + self.test_flags if self.test_flags else []
     return self.flags + (extra_flags or []) + [self.main] + suffix
 
-  def GetCommand(self, shell_dir, extra_flags=None):
+  def GetCommand(self, shell_dir, extra_flags=None, profiler_run=False):
     # TODO(machenbach): This requires +.exe if run on windows.
     cmd = [os.path.join(shell_dir, self.binary)]
+    if self.binary == 'd8' and profiler_run:
+      cmd = cmd + ["--prof"]
+    else:
+      print "Profiler supported only on a benchmark run with d8"
     return cmd + self.GetCommandFlags(extra_flags=extra_flags)
 
   def Run(self, runner, trybot):
     """Iterates over several runs and handles the output for all traces."""
     stdout_with_patch, stdout_no_patch = Unzip(runner())
     return (
         AccumulateResults(
             self.graphs,
             self._children,
             iter_output=stdout_with_patch,
@@ skipping 105 matching lines @@
     self.shell_dir_no_patch = options.shell_dir_no_patch
     self.extra_flags = options.extra_flags.split()
 
   @staticmethod
   def GetPlatform(options):
     if options.android_build_tools:
       return AndroidPlatform(options)
     else:
       return DesktopPlatform(options)
 
-  def _Run(self, runnable, count, no_patch=False):
+  def _Run(self, runnable, count, no_patch=False, profiler_run=False):
     raise NotImplementedError()  # pragma: no cover
 
-  def Run(self, runnable, count):
+  def Run(self, runnable, count, profiler_run=False):
     """Execute the benchmark's main file.
 
     If options.shell_dir_no_patch is specified, the benchmark is run once with
     and once without patch.
     Args:
       runnable: A Runnable benchmark instance.
       count: The number of this (repeated) run.
     Returns: A tuple with the benchmark outputs with and without patch. The
              latter will be None if options.shell_dir_no_patch was not
              specified.
     """
-    stdout = self._Run(runnable, count, no_patch=False)
+    stdout = self._Run(runnable, count, no_patch=False,
+                       profiler_run=profiler_run)
     if self.shell_dir_no_patch:
-      return stdout, self._Run(runnable, count, no_patch=True)
+      return stdout, self._Run(runnable, count, no_patch=True,
+                               profiler_run=profiler_run)
     else:
       return stdout, None
 
 
 class DesktopPlatform(Platform):
   def __init__(self, options):
     super(DesktopPlatform, self).__init__(options)
 
   def PreExecution(self):
     pass
 
   def PostExecution(self):
     pass
 
   def PreTests(self, node, path):
     if isinstance(node, RunnableConfig):
       node.ChangeCWD(path)
 
-  def _Run(self, runnable, count, no_patch=False):
+  def _Run(self, runnable, count, no_patch=False, profiler_run=False):
     suffix = ' - without patch' if no_patch else ''
     shell_dir = self.shell_dir_no_patch if no_patch else self.shell_dir
     title = ">>> %%s (#%d)%s:" % ((count + 1), suffix)
     try:
       output = commands.Execute(
-          runnable.GetCommand(shell_dir, self.extra_flags),
+          runnable.GetCommand(shell_dir, self.extra_flags,
+                              profiler_run=profiler_run),
           timeout=runnable.timeout,
       )
     except OSError as e:  # pragma: no cover
       print title % "OSError"
       print e
       return ""
     print title % "Stdout"
     print output.stdout
     if output.stderr:  # pragma: no cover
       # Print stderr for debugging.
       print title % "Stderr"
       print output.stderr
     if output.timed_out:
       print ">>> Test timed out after %ss." % runnable.timeout
+    if profiler_run:

[Michael Achenbach, 2015/09/10 07:49:44]

Suggestion: Could you maybe just use the existing extra_flags list? I.e. make
'--prof' a flag that triggers the additional logic below. The condition here
could be rewritten as:
if '--prof' in self.extra_flags:
  ...

The tool could be started with:
run_perf --extra-flags="--prof --other-flag1 ..."

The check for the d8 executable above in line 459 could be made in a similar
way, e.g.:
extra_flags = extra_flags or []
if self.binary != 'd8' and '--prof' in self.extra_flags:
  # Warn about wrong usage.

[gdeepti1, 2015/09/11 08:22:33]

Currently passing in the --profiler flag to run_perf alters the original output
by printing additional summary from the tick_processor. Output below: 
EmbenchenBox2d(RunTime): 11392 ms.

Statistical profiling result from v8.log, (10723 ticks, 0 unaccounted, 0
excluded).

 [Summary]:
   ticks  total  nonlib   name
  10153   94.7%   94.9%  JavaScript
    549    5.1%    5.1%  C++
     40    0.4%    0.4%  GC
     21    0.2%          Shared libraries

My initial approach was to pass in the --prof as a part of extra flags, but as
it was modifying the output in a way passing the --prof flag to d8 does not do I
was not sure if it was the right approach. Just to confirm - it is ok to
overload the --prof flag to run and print the output of the tick processor as
well? 

[Michael Achenbach, 2015/09/11 09:13:02]

Hmm - not sure if I understand. I don't wanna imply any code changes in v8/d8.
Everything there should remain as it is. You should also keep the code below
that does the printing (i.e. line 663). I would just not guard it by an extra
flag "if profiler_run", but by deducing the same thing from the extra_flags,
i.e. "if '--prof' in self.extra_flags".

I.e. when you run "d8 --prof" it does not run the tick-processor, but if you
test d8 through run_perf.py with --extra-flags="--prof", it will run with --prof
_and_ the run_perf script will call the tick processor and print.

[gdeepti1, 2015/09/11 20:05:57]

Thanks for clarifying, simplified to use --extra-flags instead of an explicit
--profiler flag. 

+      if utils.GuessOS() == "linux":
+        tick_tools = os.path.abspath(os.path.join(shell_dir, "..", "..",
+                                                  "tools",
+                                                  "linux-tick-processor"))
+      elif utils.GuessOS() == "macos":
+        tick_tools = os.path.abspath(os.path.join(shell_dir, "..", "..",
+                                                  "tools",
+                                                  "mac-tick-processor"))
+      else:
+        print "Profiler option currently supported on Linux and Mac OS."
+      prof_cmd = tick_tools + " --only-summary"
+      subprocess.check_call(prof_cmd, shell=True)
     return output.stdout
 
 
 class AndroidPlatform(Platform):  # pragma: no cover
   DEVICE_DIR = "/data/local/tmp/v8/"
 
   def __init__(self, options):
     super(AndroidPlatform, self).__init__(options)
     LoadAndroidBuildTools(options.android_build_tools)
 
@@ skipping 140 matching lines @@
                     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("--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")
+                    help="Base directory with compile output without patch"),
+  parser.add_option("--profiler",
+                    help="Run with the profiler and print the summary "
+                    "for each run",
+                    default=False, action="store_true")
   (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 54 matching lines @@
 
     # Traverse graph/trace tree and interate over all runnables.
     for runnable in FlattenRunnables(root, NodeCB):
       print ">>> Running suite: %s" % "/".join(runnable.graphs)
 
       def Runner():
         """Output generator that reruns several times."""
         for i in xrange(0, max(1, runnable.run_count)):
           # TODO(machenbach): Allow timeout per arch like with run_count per
           # arch.
-          yield platform.Run(runnable, i)
+          yield platform.Run(runnable, i, options.profiler)
 
       # Let runnable iterate over all runs and handle output.
       result, result_no_patch = runnable.Run(
           Runner, trybot=options.shell_dir_no_patch)
       results += result
       results_no_patch += result_no_patch
     platform.PostExecution()
 
   if options.json_test_results:
     results.WriteToFile(options.json_test_results)
   else:  # pragma: no cover
     print results
 
   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:]))