[Instrumentation Test Speed] Install apks in parallel with concurrent_adb enabled

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

 # Copyright 2015 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 logging
 import os
 import posixpath
 import re
 import time
 
 from devil.android import device_errors
 from devil.android import flag_changer
 from devil.android.sdk import shared_prefs
 from devil.utils import reraiser_thread
 from pylib import valgrind_tools
 from pylib.android import logdog_logcat_monitor
 from pylib.base import base_test_result
 from pylib.instrumentation import instrumentation_test_instance
 from pylib.local.device import local_device_environment
 from pylib.local.device import local_device_test_run
 from pylib.utils import logdog_helper
 from py_trace_event import trace_event
 from py_utils import contextlib_ext
 import tombstones
 
+from multiprocessing.pool import ThreadPool
+
 _TAG = 'test_runner_py'
 
 TIMEOUT_ANNOTATIONS = [
   ('Manual', 10 * 60 * 60),
   ('IntegrationTest', 30 * 60),
   ('External', 10 * 60),
   ('EnormousTest', 10 * 60),
   ('LargeTest', 5 * 60),
   ('MediumTest', 3 * 60),
   ('SmallTest', 1 * 60),
@@ skipping 32 matching lines @@
   #override
   def TestPackage(self):
     return self._test_instance.suite
 
   #override
   def SetUp(self):
     @local_device_environment.handle_shard_failures_with(
         self._env.BlacklistDevice)
     @trace_event.traced
     def individual_device_set_up(dev, host_device_tuples):
+      def single_apk_install(apk_permission_pair):
+        apk = apk_permission_pair[0]
+        permissions = apk_permission_pair[1]
+        dev.Install(apk, permissions=permissions)
+
+      def single_incremental_apk_install(dev_apk_script_array):
+        dev = dev_apk_script_array[0]
+        apk = dev_apk_script_array[1]
+        incremental_install_script = dev_apk_script_array[2]
+        local_device_test_run.IncrementalInstall(
+                dev, apk, incremental_install_script)
+
+      def single_apk_install_helper(array):
+        if len(array) == 2:
+          single_apk_install(array)
+        elif len(array) == 3:
+          single_incremental_apk_install(array)
+        else:
+          raise Exception('incorrect input array')
+
+      @trace_event.traced
       def install_apk():
+        apk_resource_array = []
         if self._test_instance.apk_under_test:
           if self._test_instance.apk_under_test_incremental_install_script:
-            local_device_test_run.IncrementalInstall(
+            apk_resource_array.append([
                 dev,
                 self._test_instance.apk_under_test,
-                self._test_instance.apk_under_test_incremental_install_script)
+                self._test_instance.apk_under_test_incremental_install_script])
           else:
             permissions = self._test_instance.apk_under_test.GetPermissions()
-            dev.Install(self._test_instance.apk_under_test,
-                        permissions=permissions)
+            apk_resource_array.append(
+                [self._test_instance.apk_under_test, permissions])
 
         if self._test_instance.test_apk_incremental_install_script:
-          local_device_test_run.IncrementalInstall(
+          apk_resource_array.append([
               dev,
               self._test_instance.test_apk,
-              self._test_instance.test_apk_incremental_install_script)
+              self._test_instance.test_apk_incremental_install_script])
         else:
           permissions = self._test_instance.test_apk.GetPermissions()
-          dev.Install(self._test_instance.test_apk, permissions=permissions)
+          apk_resource_array.append(
+              [self._test_instance.test_apk, permissions])
 
         for apk in self._test_instance.additional_apks:
-          dev.Install(apk)
+          apk_resource_array.append([apk, None])
+
+        if self._env.concurrent_adb:
+          pool = ThreadPool(processes=len(apk_resource_array))

[jbudorick, 2017/04/01 00:58:19]

Instead of using a ThreadPool, split apk installation into multiple steps...

+          pool.map(single_apk_install_helper, apk_resource_array)
+        else:
+          for apk_resource in apk_resource_array:
+            single_apk_install_helper(apk_resource)
 
         # Set debug app in order to enable reading command line flags on user
         # builds
         if self._test_instance.flags:
           if not self._test_instance.package_info:
             logging.error("Couldn't set debug app: no package info")
           elif not self._test_instance.package_info.package:
             logging.error("Couldn't set debug app: no package defined")
           else:
             dev.RunShellCommand(['am', 'set-debug-app', '--persistent',
@@ skipping 47 matching lines @@
             logging.error("Couldn't set flags: no cmdline_file")
           else:
             self._CreateFlagChangerIfNeeded(dev)
             logging.debug('Attempting to set flags: %r',
                           self._test_instance.flags)
             self._flag_changers[str(dev)].AddFlags(self._test_instance.flags)
 
         valgrind_tools.SetChromeTimeoutScale(
             dev, self._test_instance.timeout_scale)
 
       steps = (install_apk, edit_shared_prefs, push_test_data,

[jbudorick, 2017/04/01 00:58:19]

... and then add the steps here.

                create_flag_changer)
       if self._env.concurrent_adb:
         reraiser_thread.RunAsync(steps)
       else:
         for step in steps:
           step()
       if self._test_instance.store_tombstones:
         tombstones.ClearAllTombstones(dev)
 
     self._env.parallel_devices.pMap(
@@ skipping 252 matching lines @@
       if k in annotations:
         timeout = v
         break
     else:
       logging.warning('Using default 1 minute timeout for %s', test_name)
       timeout = 60
 
     timeout *= cls._GetTimeoutScaleFromAnnotations(annotations)
 
     return timeout