Allow test_runner.py to run host perf tests without devices attached

build/android/pylib/local/device/local_device_perf_test_run.py

 # Copyright 2016 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 import io
 import json
 import logging
 import os
 import pickle
 import shutil
 import tempfile
 import threading
 import time
 import zipfile
 
 from devil.android import battery_utils
 from devil.android import device_errors
 from devil.android import device_list
 from devil.android import device_utils
 from devil.android import forwarder
 from devil.android.tools import device_recovery
 from devil.android.tools import device_status
 from devil.utils import cmd_helper
 from devil.utils import parallelizer
+from devil.utils import reraiser_thread
 from pylib import constants
 from pylib.base import base_test_result
 from pylib.constants import host_paths
 from pylib.local.device import local_device_environment
 from pylib.local.device import local_device_test_run
 
 
 class HeartBeat(object):
 
   def __init__(self, shard, wait_time=60*10):
@@ skipping 257 matching lines @@
 
 class HostTestShard(TestShard):
   def __init__(self, env, test_instance, tests, retries=3, timeout=None):
     super(HostTestShard, self).__init__(
         env, test_instance, tests, retries, timeout)
 
   @local_device_environment.handle_shard_failures
   def RunTestsOnShard(self):
     results = base_test_result.TestRunResults()
     for test in self._tests:
-      tries_left = self._retries
+      tries_left = self._retries + 1
       result_type = None
       while (result_type != base_test_result.ResultType.PASS
              and tries_left > 0):
         try:
           self._TestSetUp(test)
           result_type = self._RunSingleTest(test)
         finally:
           self._TestTearDown()
       results.AddResult(base_test_result.BaseTestResult(test, result_type))
     return results
@@ skipping 14 matching lines @@
   def __init__(self, env, test_instance):
     super(LocalDevicePerfTestRun, self).__init__(env, test_instance)
     self._devices = None
     self._env = env
     self._no_device_tests = {}
     self._test_buckets = []
     self._test_instance = test_instance
     self._timeout = None if test_instance.no_timeout else self._DEFAULT_TIMEOUT
 
   def SetUp(self):
-    self._devices = self._GetAllDevices(self._env.devices,
-                                        self._test_instance.known_devices_file)
-
     if os.path.exists(constants.PERF_OUTPUT_DIR):
       shutil.rmtree(constants.PERF_OUTPUT_DIR)
     os.makedirs(constants.PERF_OUTPUT_DIR)
 
   def TearDown(self):
     pass
 
   def _GetStepsFromDict(self):
     # From where this is called one of these two must be set.
     if self._test_instance.single_step:
@@ skipping 55 matching lines @@
       devices = active_devices
     return sorted(devices)
 
   #override
   def RunTests(self):
     # Affinitize the tests.
     self._SplitTestsByAffinity()
     if not self._test_buckets and not self._no_device_tests:
       raise local_device_test_run.NoTestsError()
 
-    def run_perf_tests(shard_id):
-      if shard_id is None:
-        s = HostTestShard(self._env, self._test_instance, self._no_device_tests,
-                          retries=3, timeout=self._timeout)
-      else:
-        if device_status.IsBlacklisted(
-             str(self._devices[shard_id]), self._env.blacklist):
-          logging.warning('Device %s is not active. Will not create shard %s.',
-                          str(self._devices[shard_id]), shard_id)
-          return None
-        s = DeviceTestShard(self._env, self._test_instance,
-                            self._devices[shard_id], shard_id,
-                            self._test_buckets[shard_id],
-                            retries=self._env.max_tries, timeout=self._timeout)
+    def run_no_devices_tests():
+      if not self._no_device_tests:
+        return []
+      s = HostTestShard(self._env, self._test_instance, self._no_device_tests,
+                        retries=3, timeout=self._timeout)
+      return [s.RunTestsOnShard()]
+
+    def device_shard_helper(shard_id):
+      if device_status.IsBlacklisted(
+           str(self._devices[shard_id]), self._env.blacklist):
+        logging.warning('Device %s is not active. Will not create shard %s.',
+                        str(self._devices[shard_id]), shard_id)
+        return None
+      s = DeviceTestShard(self._env, self._test_instance,
+                          self._devices[shard_id], shard_id,
+                          self._test_buckets[shard_id],
+                          retries=self._env.max_tries, timeout=self._timeout)
       return s.RunTestsOnShard()
 
-    device_indices = range(min(len(self._devices), len(self._test_buckets)))
-    if self._no_device_tests:
-      device_indices.append(None)
-    shards = parallelizer.Parallelizer(device_indices).pMap(run_perf_tests)
-    return [x for x in shards.pGet(self._timeout) if x is not None]
+    def run_devices_tests():
+      if not self._test_buckets:
+        return []
+      if self._devices is None:
+        self._devices = self._GetAllDevices(
+            self._env.devices, self._test_instance.known_devices_file)
+
+      device_indices = range(min(len(self._devices), len(self._test_buckets)))
+      shards = parallelizer.Parallelizer(device_indices).pMap(
+          device_shard_helper)
+      return [x for x in shards.pGet(self._timeout) if x is not None]
+
+    host_test_results, device_test_results = reraiser_thread.RunAsync(
+        [run_no_devices_tests, run_devices_tests])
+    return host_test_results + device_test_results
 
   # override
   def TestPackage(self):
     return 'perf'
 
   # override
   def _CreateShards(self, _tests):
     raise NotImplementedError
 
   # override
@@ skipping 51 matching lines @@
   # override
   def _RunTest(self, _device, _test):
     raise NotImplementedError
 
 
 class TestDictVersionError(Exception):
   pass
 
 class PerfTestRunGetStepsError(Exception):
   pass