Add Android platform to performance runner.

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 79 matching lines @@
   ]
 }
 
 Path pieces are concatenated. D8 is always run with the suite's path as cwd.
 
 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 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"^RESULT ([^:]+): ([^=]+)= ([^ ]+) ([^ ]*)$")
 RESULT_STDDEV_RE = re.compile(r"^\{([^\}]+)\}$")
 RESULT_LIST_RE = re.compile(r"^\[([^\]]+)\]$")
 
 
+def LoadAndroidBuildTools(path):  # pragma: no cover
+  assert os.path.exists(path)
+  sys.path.insert(0, path)
+
+  from pylib.device import device_utils  # pylint: disable=F0401
+  from pylib.device import device_errors  # pylint: disable=F0401
+  from pylib.perf import cache_control  # pylint: disable=F0401
+  from pylib.perf import perf_control  # pylint: disable=F0401
+  import pylib.android_commands  # pylint: disable=F0401
+  global cache_control
+  global device_errors
+  global device_utils
+  global perf_control
+  global pylib
+
 
 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)))
 
 
@@ skipping 66 matching lines @@
     self.graphs = parent.graphs[:] + [suite["name"]]
     self.flags = parent.flags[:] + suite.get("flags", [])
     self.test_flags = parent.test_flags[:] + suite.get("test_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.timeout = suite.get("timeout", parent.timeout)
+    self.timeout = suite.get("timeout_%s" % arch, self.timeout)
     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"])
@@ skipping 57 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):
+    suffix = ["--"] + self.test_flags if self.test_flags else []
+    return self.flags + [self.main] + suffix
+
   def GetCommand(self, shell_dir):
     # TODO(machenbach): This requires +.exe if run on windows.
-    suffix = ["--"] + self.test_flags if self.test_flags else []
-    return (
-      [os.path.join(shell_dir, self.binary)] +
-      self.flags +
-      [self.main] +
-      suffix
-    )
+    return [os.path.join(shell_dir, self.binary)] + self.GetCommandFlags()
 
   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 92 matching lines @@
     raise Exception("Invalid suite configuration.")
 
 
 def BuildGraphs(suite, arch, parent=None):
   """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", ["ia32", "x64"]):
+  if arch not in suite.get("archs", SUPPORTED_ARCHS):
     return None
 
   graph = MakeGraph(suite, arch, parent)
   for subsuite in suite.get("tests", []):
     BuildGraphs(subsuite, arch, graph)
   parent.AppendChild(graph)
   return graph
 
 
 def FlattenRunnables(node):
@@ skipping 14 matching lines @@
   @staticmethod
   def GetPlatform(options):
     if options.arch.startswith("android"):
       return AndroidPlatform(options)
     else:
       return DesktopPlatform(options)
 
 
 class DesktopPlatform(Platform):
   def __init__(self, options):
-    workspace = os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))
+    self.shell_dir = options.shell_dir
 
-    if options.buildbot:
-      self.shell_dir = os.path.join(workspace, options.outdir, "Release")
-    else:
-      self.shell_dir = os.path.join(workspace, options.outdir,
-                                    "%s.release" % options.arch)
-
-  def PrepareExecution(self):
+  def PreExecution(self):
     pass
 
-  def PrepareTests(self, runnable, path):
+  def PostExecution(self):
+    pass
+
+  def PreTests(self, runnable, path):
     runnable.ChangeCWD(path)
 
   def Run(self, runnable, count):
     output = commands.Execute(runnable.GetCommand(self.shell_dir),
                               timeout=runnable.timeout)
     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
 
 
-# TODO(machenbach): Implement android platform.
-class AndroidPlatform(Platform):
+class AndroidPlatform(Platform):  # pragma: no cover
+  DEVICE_DIR = "/data/local/tmp/v8/"
+
   def __init__(self, options):
-    pass
+    self.shell_dir = options.shell_dir
+    LoadAndroidBuildTools(options.android_build_tools)
+
+    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)
+    self.device = device_utils.DeviceUtils(adb_wrapper)
+    self.adb = adb_wrapper.Adb()
+
+  def PreExecution(self):
+    perf = perf_control.PerfControl(self.device)
+    perf.SetHighPerfMode()
+
+  def PostExecution(self):
+    perf = perf_control.PerfControl(self.device)
+    perf.SetDefaultPerfMode()
+    self.device.RunShellCommand(
+        ["rm", "-rf", "*"],
+        cwd=AndroidPlatform.DEVICE_DIR,
+    )
+
+  def _PushFile(self, host_dir, file_name):
+    file_on_host = os.path.join(host_dir, file_name)
+    file_on_device = AndroidPlatform.DEVICE_DIR + file_name
+    logging.info("adb push %s %s" % (file_on_host, file_on_device))
+    self.adb.Push(file_on_host, file_on_device)
+
+  def PreTests(self, runnable, path):
+    suite_dir = os.path.abspath(os.path.dirname(path))
+    bench_dir = os.path.join(suite_dir,
+                             os.path.normpath(os.path.join(*runnable.path)))
+
+    self._PushFile(self.shell_dir, runnable.binary)
+    self._PushFile(bench_dir, runnable.main)
+    for resource in runnable.resources:
+      self._PushFile(bench_dir, resource)
+
+  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()
+    try:
+      output = self.device.RunShellCommand(
+          cmd,
+          cwd=AndroidPlatform.DEVICE_DIR,
+          timeout=runnable.timeout,
+          retries=0,
+      )
+      stdout = "\n".join(output)
+      print ">>> Stdout (#%d):" % (count + 1)
+      print stdout
+    except device_errors.CommandTimeoutError:
+      print ">>> Test timed out after %ss." % runnable.timeout
+      stdout = ""
+    return stdout
 
 
 # TODO: Implement results_processor.
 def Main(args):
+  logging.getLogger().setLevel(logging.INFO)
   parser = optparse.OptionParser()
   parser.add_option("--android-build-tools",
                     help="Path to chromium's build/android.")
   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")
@@ skipping 21 matching lines @@
       bool(options.android_build_tools)):  # pragma: no cover
     print ("Android architectures imply setting --android-build-tools and the "
            "other way around.")
     return 1
 
   if (options.device and not
       options.arch.startswith("android")):  # pragma: no cover
     print "Specifying a device requires an Android architecture to be used."
     return 1
 
+  workspace = os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))
+
+  if options.buildbot:
+    options.shell_dir = os.path.join(workspace, options.outdir, "Release")
+  else:
+    options.shell_dir = os.path.join(workspace, options.outdir,
+                                     "%s.release" % options.arch)
+
   platform = Platform.GetPlatform(options)
-  platform.PrepareExecution()
+  platform.PreExecution()
 
   results = 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])
 
     for runnable in FlattenRunnables(BuildGraphs(suite, options.arch)):
       print ">>> Running suite: %s" % "/".join(runnable.graphs)
-      platform.PrepareTests(runnable, path)
+      platform.PreTests(runnable, path)
 
       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)
 
       # Let runnable iterate over all runs and handle output.
       results += runnable.Run(Runner)
 
+  platform.PostExecution()
+
   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:]))