[Android] Thread names reflect the device serial number they are associated with.

build/android/pylib/base/shard.py

 # Copyright (c) 2013 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.
 
 """Implements test sharding logic."""
 
 import logging
 import threading
 
 from pylib import android_commands
@@ skipping 187 matching lines @@
   Returns:
     A TestRunResults object.
   """
   logging.warning('****Running %s tests with %s test runners.' %
                   (len(tests), len(runners)))
   tests_collection = _TestCollection([_Test(t) for t in tests])
   results = []
   watcher = watchdog_timer.WatchdogTimer(timeout)
   workers = reraiser_thread.ReraiserThreadGroup(
       [reraiser_thread.ReraiserThread(_RunTestsFromQueue,
-                                      [r, tests_collection, results, watcher])
+                                      [r, tests_collection, results, watcher],
+                                      name=r.device[-4:])
        for r in runners])
   workers.StartAll()
   workers.JoinAll(watcher)
   run_results = base_test_result.TestRunResults()
   for r in results:
     run_results.AddTestRunResults(r)
   return run_results
 
 
 def _CreateRunners(runner_factory, devices, timeout=None):
   """Creates a test runner for each device and calls SetUp() in parallel.
 
   Note: if a device is unresponsive the corresponding TestRunner will not be
     included in the returned list.
 
   Args:
     runner_factory: callable that takes a device and index and returns a
       TestRunner object.
     devices: list of device serial numbers as strings.
     timeout: watchdog timeout in seconds, defaults to the default timeout.
 
   Returns:
     A list of TestRunner objects.
   """
   logging.warning('****Creating %s test runners.' % len(devices))
   runners = []
   counter = _ThreadSafeCounter()
   threads = reraiser_thread.ReraiserThreadGroup(
-      [reraiser_thread.ReraiserThread(_SetUp, [runner_factory, d, runners,
-                                               counter])
+      [reraiser_thread.ReraiserThread(_SetUp,
+                                      [runner_factory, d, runners, counter],
+                                      name=d[-4:])
        for d in devices])
   threads.StartAll()
   threads.JoinAll(watchdog_timer.WatchdogTimer(timeout))
   return runners
 
 
 def _TearDownRunners(runners, timeout=None):
   """Calls TearDown() for each test runner in parallel.
   Args:
     runners: a list of TestRunner objects.
     timeout: watchdog timeout in seconds, defaults to the default timeout.
   """
   threads = reraiser_thread.ReraiserThreadGroup(
-      [reraiser_thread.ReraiserThread(runner.TearDown)
-       for runner in runners])
+      [reraiser_thread.ReraiserThread(r.TearDown, name=r.device[-4:])
+       for r in runners])
   threads.StartAll()
   threads.JoinAll(watchdog_timer.WatchdogTimer(timeout))
 
 
 def ShardAndRunTests(runner_factory, devices, tests, build_type='Debug',
                      test_timeout=DEFAULT_TIMEOUT,
                      setup_timeout=DEFAULT_TIMEOUT):
   """Run all tests on attached devices, retrying tests that don't pass.
 
   Args:
@@ skipping 14 matching lines @@
   runners = _CreateRunners(runner_factory, devices, setup_timeout)
   try:
     return _RunAllTests(runners, tests, test_timeout)
   finally:
     try:
       _TearDownRunners(runners, setup_timeout)
     except android_commands.errors.DeviceUnresponsiveError as e:
       logging.warning('****Device unresponsive during TearDown: [%s]', e)
     finally:
       forwarder.Forwarder.KillHost(build_type)