Optimize pushing files in android perf test 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 415 matching lines @@
   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):
+def FlattenRunnables(node, node_cb):
   """Generator that traverses the tree structure and iterates over all
   runnables.
   """
+  node_cb(node)
   if isinstance(node, Runnable):
     yield node
   elif isinstance(node, Node):
     for child in node._children:
-      for result in FlattenRunnables(child):
+      for result in FlattenRunnables(child, node_cb):
         yield result
   else:  # pragma: no cover
     raise Exception("Invalid suite configuration.")
 
 
 class Platform(object):
   @staticmethod
   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
 
   def PreExecution(self):
     pass
 
   def PostExecution(self):
     pass
 
-  def PreTests(self, runnable, path):
-    runnable.ChangeCWD(path)
+  def PreTests(self, node, path):
+    if isinstance(node, Runnable):
+      node.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
@@ skipping 18 matching lines @@
           "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()
 
+    # Remember what we have already pushed to the device.
+    self.pushed = set()
+
   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
+
+    # Only push files not yet pushed in one execution.
+    if file_on_host in self.pushed:
+      return
+    else:
+      self.pushed.add(file_on_host)
+
     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):
+  def PreTests(self, node, 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)))
+                             os.path.normpath(os.path.join(*node.path)))
 
-    self._PushFile(self.shell_dir, runnable.binary)
-    self._PushFile(bench_dir, runnable.main)
-    for resource in runnable.resources:
+    self._PushFile(self.shell_dir, node.binary)
+    if isinstance(node, Runnable):
+      self._PushFile(bench_dir, node.main)
+    for resource in node.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,
@@ skipping 56 matching lines @@
 
   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.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)):
+    # Setup things common to one test suite.
+    platform.PreExecution()
+
+    # Build the graph/trace tree structure.
+    root = BuildGraphs(suite, options.arch)
+
+    # 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)
-      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()
+    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:]))