Makes host driven tests use the common sharder.

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
 from pylib import constants
 from pylib import forwarder
 from pylib.utils import reraiser_thread
 from pylib.utils import watchdog_timer
 
 import base_test_result
 
 
 DEFAULT_TIMEOUT = 7 * 60  # seven minutes
+VALID_SHARDING_OPTIONS = ['distribute', 'duplicate']
 
 
 class _ThreadSafeCounter(object):
   """A threadsafe counter."""
 
   def __init__(self):
     self._lock = threading.Lock()
     self._value = 0
 
   def GetAndIncrement(self):
@@ skipping 147 matching lines @@
   try:
     index = threadsafe_counter.GetAndIncrement()
     logging.warning('Creating shard %s for device %s.', index, device)
     runner = runner_factory(device, index)
     runner.SetUp()
     out_runners.append(runner)
   except android_commands.errors.DeviceUnresponsiveError as e:
     logging.warning('Failed to create shard for %s: [%s]', device, e)
 
 
-def _RunAllTests(runners, tests, num_retries, timeout=None):
+def _RunAllTests(runners, tests, sharding, num_retries, timeout=None):
   """Run all tests using the given TestRunners.
 
   Args:
     runners: a list of TestRunner objects.
     tests: a list of Tests to run using the given TestRunners.
     num_retries: number of retries for a test.
     timeout: watchdog timeout in seconds, defaults to the default timeout.
+    sharding: a string to indicate whether we should distribute all tests as a
+        common pool to draw from, or duplicate all tests onto every test runner.
+        Must be either 'distribute' or 'duplicate'
 
   Returns:
     A tuple of (TestRunResults object, exit code)
   """
   logging.warning('Running %s tests with %s test runners.' %
                   (len(tests), len(runners)))
-  tests_collection = _TestCollection([_Test(t) for t in tests])
   results = []
   exit_code = 0
   watcher = watchdog_timer.WatchdogTimer(timeout)
+
+  if sharding == 'distribute':
+    shared_test_collection = _TestCollection([_Test(t) for t in tests])
+    GenerateTestCollection = lambda: shared_test_collection
+  elif sharding == 'duplicate':
+    GenerateTestCollection = lambda: _TestCollection([_Test(t) for t in tests])
+  else:
+    raise ValueError('Unknown sharding option %s. Options are: %s'
+                     % (sharding, VALID_SHARDING_OPTIONS))
+
+  # Use a lambda to get the test collection for each runner for cleanliness
   workers = reraiser_thread.ReraiserThreadGroup(
       [reraiser_thread.ReraiserThread(
           _RunTestsFromQueue,
-          [r, tests_collection, results, watcher, num_retries],
+          [r, GenerateTestCollection(), results, watcher, num_retries],
           name=r.device[-4:])
        for r in runners])
   run_results = base_test_result.TestRunResults()
   workers.StartAll()
 
   # Catch DeviceUnresponsiveErrors and set a warning exit code
   try:
     workers.JoinAll(watcher)
   except android_commands.errors.DeviceUnresponsiveError as e:
     logging.error(e)
@@ skipping 44 matching lines @@
   threads = reraiser_thread.ReraiserThreadGroup(
       [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,
-                     num_retries=2):
+                     num_retries=2,
+                     sharding='distribute'):

[craigdh, 2013/07/12 18:14:15]

The behavior is quite different, I think it would be better to expose two public
functions, something like: RunTestsDistributed() and RunTestsDuplicated().

Then you can put the divergent logic from lines 208-218 in those functions and
pass the lambda to a common implementation similar to the ShardAndRunTests you
have here, except with the lambda instead of the sharding string.

[gkanwar, 2013/07/12 18:22:41]

I was discussing this with Frank in the gdoc, and I think we decided it was
overcomplicating it to create the additional two functions. I would be happy to
go either way though. Frank?

[frankf, 2013/07/12 18:49:19]

I still think the semantics is confusing. Sharding is synonymous with
distributing. How about we call this class test_allocator.py and have two
functions:

ShardAndRunTests()
ReplicateAndRunTests()

On 2013/07/12 18:22:41, gkanwar wrote:

[gkanwar, 2013/07/12 18:52:04]

That sounds reasonable to me. Craig, does that sound good to you?

[craigdh, 2013/07/12 19:03:36]

I like the method names, but test_allocator.py is not as accurate as it could
be. How about test_dispatcher.py?

[gkanwar, 2013/07/12 19:22:32]

We already have a 'dispatch.py' under pylib now (this is where we get the
devices and call this method to do the actual distribution and running). Since
we're not using the terms 'distrbuted' vs. 'duplicated' now, perhaps we could
name this test_distribution.py or distribute.py? I would consider both sharding
and replication forms of test distribution.

   """Run all tests on attached devices, retrying tests that don't pass.
 
   Args:
     runner_factory: callable that takes a device and index and returns a
       TestRunner object.
     devices: list of attached device serial numbers as strings.
     tests: list of tests to run.
     build_type: either 'Debug' or 'Release'.
     test_timeout: watchdog timeout in seconds for running tests, defaults to the
       default timeout.
     setup_timeout: watchdog timeout in seconds for creating and cleaning up
       test runners, defaults to the default timeout.
     num_retries: number of retries for a test.
+    sharding: a string to indicate whether we should distribute all tests as a
+        common pool to draw from, or duplicate all tests onto every test runner.
+        Must be either 'distribute' or 'duplicate'
 
   Returns:
     A tuple of (base_test_result.TestRunResults object, exit code).
   """
+

[craigdh, 2013/07/12 18:14:15]

remove this new blank line

[gkanwar, 2013/07/12 18:22:41]

Will do.

   if not tests:
     logging.error('No tests to run.')
     return (base_test_result.TestRunResults(), constants.ERROR_EXIT_CODE)
 
   logging.info('Will run %d tests: %s', len(tests), str(tests))
   forwarder.Forwarder.KillHost(build_type)
   runners = _CreateRunners(runner_factory, devices, setup_timeout)
   try:
-    return _RunAllTests(runners, tests, num_retries, test_timeout)
+    return _RunAllTests(runners, tests, sharding, num_retries, 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)