Prepare v8 android perf runner for external startup data.

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 515 matching lines @@
 
   def PostExecution(self):
     perf = perf_control.PerfControl(self.device)
     perf.SetDefaultPerfMode()
     self.device.RunShellCommand(["rm", "-rf", AndroidPlatform.DEVICE_DIR])
 
   def _SendCommand(self, cmd):
     logging.info("adb -s %s %s" % (str(self.device), cmd))
     return self.adb.SendCommand(cmd, timeout_time=60)
 
-  def _PushFile(self, host_dir, file_name, target_rel="."):
+  def _PushFile(self, host_dir, file_name, target_rel=".", only_existing=True):

[vogelheim, 2015/02/24 13:31:25]

Maybe it's just me, but I was confused by the param name 'only_existing'. I had
initially read 'only_existing' as: push only if the file exists, and ignore if
it doesn't. But it actually means the opposite.

Maybe:
- must_exist=True
- or: skip_if_missing=False (and then invert the logic)

     file_on_host = os.path.join(host_dir, file_name)
     file_on_device_tmp = os.path.join(
         AndroidPlatform.DEVICE_DIR, "_tmp_", file_name)
     file_on_device = os.path.join(
         AndroidPlatform.DEVICE_DIR, target_rel, file_name)
     folder_on_device = os.path.dirname(file_on_device)
 
+    # Only attempt to push files that exist.
+    if not os.path.exists(file_on_host):
+      if only_existing:
+        logging.critical('Missing file on host: %s' % file_on_host)
+      return
+
     # Only push files not yet pushed in one execution.
     if file_on_host in self.pushed:
       return
     else:
       self.pushed.add(file_on_host)
 
     # Work-around for "text file busy" errors. Push the files to a temporary
     # location and then copy them with a shell command.
     output = self._SendCommand(
         "push %s %s" % (file_on_host, file_on_device_tmp))
     # Success looks like this: "3035 KB/s (12512056 bytes in 4.025s)".
     # Errors look like this: "failed to copy  ... ".
     if output and not re.search('^[0-9]', output.splitlines()[-1]):
       logging.critical('PUSH FAILED: ' + output)
     self._SendCommand("shell mkdir -p %s" % folder_on_device)
     self._SendCommand("shell cp %s %s" % (file_on_device_tmp, file_on_device))
 
   def PreTests(self, node, path):
     suite_dir = os.path.abspath(os.path.dirname(path))
     if node.path:
       bench_rel = os.path.normpath(os.path.join(*node.path))
       bench_abs = os.path.join(suite_dir, bench_rel)
     else:
       bench_rel = "."
       bench_abs = suite_dir
 
     self._PushFile(self.shell_dir, node.binary)
+
+    # Push external startup data. Backwards compatible for revisions where
+    # these files didn't exist.
+    self._PushFile(self.shell_dir, "natives_blob.bin", only_existing=False)
+    self._PushFile(self.shell_dir, "snapshot_blob.bin", only_existing=False)
+
     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()
@@ skipping 116 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:]))