<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN"
"http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head><meta http-equiv="content-type" content="text/html; charset=utf-8" />
<title>[176830] trunk/Tools</title>
</head>
<body>
<style type="text/css"><!--
#msg dl.meta { border: 1px #006 solid; background: #369; padding: 6px; color: #fff; }
#msg dl.meta dt { float: left; width: 6em; font-weight: bold; }
#msg dt:after { content:':';}
#msg dl, #msg dt, #msg ul, #msg li, #header, #footer, #logmsg { font-family: verdana,arial,helvetica,sans-serif; font-size: 10pt; }
#msg dl a { font-weight: bold}
#msg dl a:link { color:#fc3; }
#msg dl a:active { color:#ff0; }
#msg dl a:visited { color:#cc6; }
h3 { font-family: verdana,arial,helvetica,sans-serif; font-size: 10pt; font-weight: bold; }
#msg pre { overflow: auto; background: #ffc; border: 1px #fa0 solid; padding: 6px; }
#logmsg { background: #ffc; border: 1px #fa0 solid; padding: 1em 1em 0 1em; }
#logmsg p, #logmsg pre, #logmsg blockquote { margin: 0 0 1em 0; }
#logmsg p, #logmsg li, #logmsg dt, #logmsg dd { line-height: 14pt; }
#logmsg h1, #logmsg h2, #logmsg h3, #logmsg h4, #logmsg h5, #logmsg h6 { margin: .5em 0; }
#logmsg h1:first-child, #logmsg h2:first-child, #logmsg h3:first-child, #logmsg h4:first-child, #logmsg h5:first-child, #logmsg h6:first-child { margin-top: 0; }
#logmsg ul, #logmsg ol { padding: 0; list-style-position: inside; margin: 0 0 0 1em; }
#logmsg ul { text-indent: -1em; padding-left: 1em; }#logmsg ol { text-indent: -1.5em; padding-left: 1.5em; }
#logmsg > ul, #logmsg > ol { margin: 0 0 1em 0; }
#logmsg pre { background: #eee; padding: 1em; }
#logmsg blockquote { border: 1px solid #fa0; border-left-width: 10px; padding: 1em 1em 0 1em; background: white;}
#logmsg dl { margin: 0; }
#logmsg dt { font-weight: bold; }
#logmsg dd { margin: 0; padding: 0 0 0.5em 0; }
#logmsg dd:before { content:'\00bb';}
#logmsg table { border-spacing: 0px; border-collapse: collapse; border-top: 4px solid #fa0; border-bottom: 1px solid #fa0; background: #fff; }
#logmsg table th { text-align: left; font-weight: normal; padding: 0.2em 0.5em; border-top: 1px dotted #fa0; }
#logmsg table td { text-align: right; border-top: 1px dotted #fa0; padding: 0.2em 0.5em; }
#logmsg table thead th { text-align: center; border-bottom: 1px solid #fa0; }
#logmsg table th.Corner { text-align: left; }
#logmsg hr { border: none 0; border-top: 2px dashed #fa0; height: 1px; }
#header, #footer { color: #fff; background: #636; border: 1px #300 solid; padding: 6px; }
#patch { width: 100%; }
#patch h4 {font-family: verdana,arial,helvetica,sans-serif;font-size:10pt;padding:8px;background:#369;color:#fff;margin:0;}
#patch .propset h4, #patch .binary h4 {margin:0;}
#patch pre {padding:0;line-height:1.2em;margin:0;}
#patch .diff {width:100%;background:#eee;padding: 0 0 10px 0;overflow:auto;}
#patch .propset .diff, #patch .binary .diff {padding:10px 0;}
#patch span {display:block;padding:0 10px;}
#patch .modfile, #patch .addfile, #patch .delfile, #patch .propset, #patch .binary, #patch .copfile {border:1px solid #ccc;margin:10px 0;}
#patch ins {background:#dfd;text-decoration:none;display:block;padding:0 10px;}
#patch del {background:#fdd;text-decoration:none;display:block;padding:0 10px;}
#patch .lines, .info {color:#888;background:#fff;}
--></style>
<div id="msg">
<dl class="meta">
<dt>Revision</dt> <dd><a href="http://trac.webkit.org/projects/webkit/changeset/176830">176830</a></dd>
<dt>Author</dt> <dd>ap@apple.com</dd>
<dt>Date</dt> <dd>2014-12-04 17:37:02 -0800 (Thu, 04 Dec 2014)</dd>
</dl>
<h3>Log Message</h3>
<pre>Run http tests parallel
https://bugs.webkit.org/show_bug.cgi?id=138958
Reviewed by Daniel Bates.
Remove the concept of "locked shard". Now http tests are just like any other tests.
We start HTTP and WebSocket servers at the start if we need them, and terminate them
when done with all the tests (not when the last http test runs, which is unnecessarily
unpredictable).
This makes debug tests run in 8 minutes and 12 seconds on my Mac Pro. Without the
patch, they used to take over 15 minutes.
As part of the fix, we no longer pass the number of servers to Apache. I don't
think that these parameters did what we wanted them to do; Apache handles the load
just fine without them.
The change applies to all platforms. I fixed everything I could find on Mac, and
Ossy told me that he's been running http tests in parallel for a long time. If
there is increased instability for some ports, it will need to be fixed - there is
generally nothing special about http tests at this point, and most code is
cross-platform in WebKit2.
* Scripts/webkitpy/layout_tests/controllers/layout_test_runner.py:
(LayoutTestRunner.__init__):
(LayoutTestRunner.run_tests):
(LayoutTestRunner.start_servers_with_lock):
(LayoutTestRunner._handle_started_test):
(Worker.handle):
(Sharder.__init__):
(Sharder.shard_tests):
(Sharder._shard_every_file):
(Sharder._shard_by_directory):
(LayoutTestRunner._handle_finished_test_list): Deleted.
(LayoutTestRunner._handle_finished_test_list.find): Deleted.
(Sharder._shard_in_two): Deleted.
(Sharder): Deleted.
(Sharder._resize_shards): Deleted.
(Sharder._resize_shards.divide_and_round_up): Deleted.
(Sharder._resize_shards.extract_and_flatten): Deleted.
(Sharder._resize_shards.split_at): Deleted.
* Scripts/webkitpy/layout_tests/controllers/layout_test_runner_unittest.py:
(FakePrinter.print_workers_and_shards):
(LayoutTestRunnerTests.test_servers_started.start_http_server):
(LayoutTestRunnerTests.test_servers_started):
(SharderTests.get_shards):
(SharderTests.test_shard_by_dir):
(SharderTests.test_shard_every_file):
(SharderTests): Deleted.
(SharderTests.test_shard_in_two): Deleted.
(SharderTests.test_shard_in_two_has_no_locked_shards): Deleted.
(SharderTests.test_shard_in_two_has_no_unlocked_shards): Deleted.
(SharderTests.test_multiple_locked_shards): Deleted.
* Scripts/webkitpy/layout_tests/controllers/manager_unittest.py:
(ManagerTest.test_needs_servers.get_manager):
(ManagerTest.integration_test_needs_servers.get_manager):
(ManagerTest.test_look_for_new_crash_logs.get_manager):
(ManagerTest):
* Scripts/webkitpy/layout_tests/run_webkit_tests.py:
(_set_up_derived_options):
* Scripts/webkitpy/layout_tests/run_webkit_tests_integrationtest.py:
(RunTest.test_batch_size):
(RunTest.test_max_locked_shards): Deleted.
* Scripts/webkitpy/layout_tests/servers/apache_http_server.py:
(LayoutTestApacheHttpd.__init__):
* Scripts/webkitpy/layout_tests/servers/apache_http_server_unittest.py:
(TestLayoutTestApacheHttpd.test_start_cmd):
* Scripts/webkitpy/layout_tests/servers/http_server.py:
(Lighttpd.__init__):
* Scripts/webkitpy/layout_tests/servers/http_server_base.py:
(HttpServerBase.__init__):
* Scripts/webkitpy/layout_tests/views/printing.py:
(Printer.print_workers_and_shards):
* Scripts/webkitpy/port/base.py:
(Port.default_child_processes):
(Port.to.start_http_server):
(Port.default_max_locked_shards): Deleted.
* Scripts/webkitpy/port/port_testcase.py:
(PortTestCase.make_port):
(PortTestCase.test_default_max_locked_shards): Deleted.
* Scripts/webkitpy/port/test.py:
(TestPort.start_http_server):</pre>
<h3>Modified Paths</h3>
<ul>
<li><a href="#trunkToolsChangeLog">trunk/Tools/ChangeLog</a></li>
<li><a href="#trunkToolsScriptswebkitpylayout_testscontrollerslayout_test_runnerpy">trunk/Tools/Scripts/webkitpy/layout_tests/controllers/layout_test_runner.py</a></li>
<li><a href="#trunkToolsScriptswebkitpylayout_testscontrollerslayout_test_runner_unittestpy">trunk/Tools/Scripts/webkitpy/layout_tests/controllers/layout_test_runner_unittest.py</a></li>
<li><a href="#trunkToolsScriptswebkitpylayout_testscontrollersmanager_unittestpy">trunk/Tools/Scripts/webkitpy/layout_tests/controllers/manager_unittest.py</a></li>
<li><a href="#trunkToolsScriptswebkitpylayout_testsrun_webkit_testspy">trunk/Tools/Scripts/webkitpy/layout_tests/run_webkit_tests.py</a></li>
<li><a href="#trunkToolsScriptswebkitpylayout_testsrun_webkit_tests_integrationtestpy">trunk/Tools/Scripts/webkitpy/layout_tests/run_webkit_tests_integrationtest.py</a></li>
<li><a href="#trunkToolsScriptswebkitpylayout_testsserversapache_http_serverpy">trunk/Tools/Scripts/webkitpy/layout_tests/servers/apache_http_server.py</a></li>
<li><a href="#trunkToolsScriptswebkitpylayout_testsserversapache_http_server_unittestpy">trunk/Tools/Scripts/webkitpy/layout_tests/servers/apache_http_server_unittest.py</a></li>
<li><a href="#trunkToolsScriptswebkitpylayout_testsservershttp_serverpy">trunk/Tools/Scripts/webkitpy/layout_tests/servers/http_server.py</a></li>
<li><a href="#trunkToolsScriptswebkitpylayout_testsservershttp_server_basepy">trunk/Tools/Scripts/webkitpy/layout_tests/servers/http_server_base.py</a></li>
<li><a href="#trunkToolsScriptswebkitpylayout_testsviewsprintingpy">trunk/Tools/Scripts/webkitpy/layout_tests/views/printing.py</a></li>
<li><a href="#trunkToolsScriptswebkitpyportbasepy">trunk/Tools/Scripts/webkitpy/port/base.py</a></li>
<li><a href="#trunkToolsScriptswebkitpyportport_testcasepy">trunk/Tools/Scripts/webkitpy/port/port_testcase.py</a></li>
<li><a href="#trunkToolsScriptswebkitpyporttestpy">trunk/Tools/Scripts/webkitpy/port/test.py</a></li>
</ul>
</div>
<div id="patch">
<h3>Diff</h3>
<a id="trunkToolsChangeLog"></a>
<div class="modfile"><h4>Modified: trunk/Tools/ChangeLog (176829 => 176830)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Tools/ChangeLog 2014-12-05 01:23:51 UTC (rev 176829)
+++ trunk/Tools/ChangeLog 2014-12-05 01:37:02 UTC (rev 176830)
</span><span class="lines">@@ -1,5 +1,90 @@
</span><span class="cx"> 2014-12-04 Alexey Proskuryakov <ap@apple.com>
</span><span class="cx">
</span><ins>+ Run http tests parallel
+ https://bugs.webkit.org/show_bug.cgi?id=138958
+
+ Reviewed by Daniel Bates.
+
+ Remove the concept of "locked shard". Now http tests are just like any other tests.
+ We start HTTP and WebSocket servers at the start if we need them, and terminate them
+ when done with all the tests (not when the last http test runs, which is unnecessarily
+ unpredictable).
+
+ This makes debug tests run in 8 minutes and 12 seconds on my Mac Pro. Without the
+ patch, they used to take over 15 minutes.
+
+ As part of the fix, we no longer pass the number of servers to Apache. I don't
+ think that these parameters did what we wanted them to do; Apache handles the load
+ just fine without them.
+
+ The change applies to all platforms. I fixed everything I could find on Mac, and
+ Ossy told me that he's been running http tests in parallel for a long time. If
+ there is increased instability for some ports, it will need to be fixed - there is
+ generally nothing special about http tests at this point, and most code is
+ cross-platform in WebKit2.
+
+ * Scripts/webkitpy/layout_tests/controllers/layout_test_runner.py:
+ (LayoutTestRunner.__init__):
+ (LayoutTestRunner.run_tests):
+ (LayoutTestRunner.start_servers_with_lock):
+ (LayoutTestRunner._handle_started_test):
+ (Worker.handle):
+ (Sharder.__init__):
+ (Sharder.shard_tests):
+ (Sharder._shard_every_file):
+ (Sharder._shard_by_directory):
+ (LayoutTestRunner._handle_finished_test_list): Deleted.
+ (LayoutTestRunner._handle_finished_test_list.find): Deleted.
+ (Sharder._shard_in_two): Deleted.
+ (Sharder): Deleted.
+ (Sharder._resize_shards): Deleted.
+ (Sharder._resize_shards.divide_and_round_up): Deleted.
+ (Sharder._resize_shards.extract_and_flatten): Deleted.
+ (Sharder._resize_shards.split_at): Deleted.
+ * Scripts/webkitpy/layout_tests/controllers/layout_test_runner_unittest.py:
+ (FakePrinter.print_workers_and_shards):
+ (LayoutTestRunnerTests.test_servers_started.start_http_server):
+ (LayoutTestRunnerTests.test_servers_started):
+ (SharderTests.get_shards):
+ (SharderTests.test_shard_by_dir):
+ (SharderTests.test_shard_every_file):
+ (SharderTests): Deleted.
+ (SharderTests.test_shard_in_two): Deleted.
+ (SharderTests.test_shard_in_two_has_no_locked_shards): Deleted.
+ (SharderTests.test_shard_in_two_has_no_unlocked_shards): Deleted.
+ (SharderTests.test_multiple_locked_shards): Deleted.
+ * Scripts/webkitpy/layout_tests/controllers/manager_unittest.py:
+ (ManagerTest.test_needs_servers.get_manager):
+ (ManagerTest.integration_test_needs_servers.get_manager):
+ (ManagerTest.test_look_for_new_crash_logs.get_manager):
+ (ManagerTest):
+ * Scripts/webkitpy/layout_tests/run_webkit_tests.py:
+ (_set_up_derived_options):
+ * Scripts/webkitpy/layout_tests/run_webkit_tests_integrationtest.py:
+ (RunTest.test_batch_size):
+ (RunTest.test_max_locked_shards): Deleted.
+ * Scripts/webkitpy/layout_tests/servers/apache_http_server.py:
+ (LayoutTestApacheHttpd.__init__):
+ * Scripts/webkitpy/layout_tests/servers/apache_http_server_unittest.py:
+ (TestLayoutTestApacheHttpd.test_start_cmd):
+ * Scripts/webkitpy/layout_tests/servers/http_server.py:
+ (Lighttpd.__init__):
+ * Scripts/webkitpy/layout_tests/servers/http_server_base.py:
+ (HttpServerBase.__init__):
+ * Scripts/webkitpy/layout_tests/views/printing.py:
+ (Printer.print_workers_and_shards):
+ * Scripts/webkitpy/port/base.py:
+ (Port.default_child_processes):
+ (Port.to.start_http_server):
+ (Port.default_max_locked_shards): Deleted.
+ * Scripts/webkitpy/port/port_testcase.py:
+ (PortTestCase.make_port):
+ (PortTestCase.test_default_max_locked_shards): Deleted.
+ * Scripts/webkitpy/port/test.py:
+ (TestPort.start_http_server):
+
+2014-12-04 Alexey Proskuryakov <ap@apple.com>
+
</ins><span class="cx"> Don't lock perf tests in run-webkit-tests
</span><span class="cx"> https://bugs.webkit.org/show_bug.cgi?id=139264
</span><span class="cx">
</span></span></pre></div>
<a id="trunkToolsScriptswebkitpylayout_testscontrollerslayout_test_runnerpy"></a>
<div class="modfile"><h4>Modified: trunk/Tools/Scripts/webkitpy/layout_tests/controllers/layout_test_runner.py (176829 => 176830)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Tools/Scripts/webkitpy/layout_tests/controllers/layout_test_runner.py 2014-12-05 01:23:51 UTC (rev 176829)
+++ trunk/Tools/Scripts/webkitpy/layout_tests/controllers/layout_test_runner.py 2014-12-05 01:37:02 UTC (rev 176830)
</span><span class="lines">@@ -67,7 +67,7 @@
</span><span class="cx"> self._printer = printer
</span><span class="cx"> self._results_directory = results_directory
</span><span class="cx"> self._test_is_slow = test_is_slow_fn
</span><del>- self._sharder = Sharder(self._port.split_test, self._options.max_locked_shards)
</del><ins>+ self._sharder = Sharder(self._port.split_test)
</ins><span class="cx"> self._filesystem = self._port.host.filesystem
</span><span class="cx">
</span><span class="cx"> self._expectations = None
</span><span class="lines">@@ -77,7 +77,6 @@
</span><span class="cx"> self._retrying = False
</span><span class="cx">
</span><span class="cx"> self._current_run_results = None
</span><del>- self._remaining_locked_shards = []
</del><span class="cx"> self._has_http_lock = False
</span><span class="cx">
</span><span class="cx"> def run_tests(self, expectations, test_inputs, tests_to_skip, num_workers, needs_http, needs_websockets, retrying):
</span><span class="lines">@@ -90,7 +89,6 @@
</span><span class="cx"> # FIXME: rename all variables to test_run_results or some such ...
</span><span class="cx"> run_results = TestRunResults(self._expectations, len(test_inputs) + len(tests_to_skip))
</span><span class="cx"> self._current_run_results = run_results
</span><del>- self._remaining_locked_shards = []
</del><span class="cx"> self._has_http_lock = False
</span><span class="cx"> self._printer.num_tests = len(test_inputs)
</span><span class="cx"> self._printer.num_started = 0
</span><span class="lines">@@ -104,23 +102,13 @@
</span><span class="cx"> run_results.add(result, expected=True, test_is_slow=self._test_is_slow(test_name))
</span><span class="cx">
</span><span class="cx"> self._printer.write_update('Sharding tests ...')
</span><del>- locked_shards, unlocked_shards = self._sharder.shard_tests(test_inputs, int(self._options.child_processes), self._options.fully_parallel)
</del><ins>+ all_shards = self._sharder.shard_tests(test_inputs, int(self._options.child_processes), self._options.fully_parallel)
</ins><span class="cx">
</span><del>- # FIXME: We don't have a good way to coordinate the workers so that
- # they don't try to run the shards that need a lock if we don't actually
- # have the lock. The easiest solution at the moment is to grab the
- # lock at the beginning of the run, and then run all of the locked
- # shards first. This minimizes the time spent holding the lock, but
- # means that we won't be running tests while we're waiting for the lock.
- # If this becomes a problem in practice we'll need to change this.
</del><ins>+ if self._needs_http and self._options.http:
+ self.start_servers_with_lock()
</ins><span class="cx">
</span><del>- all_shards = locked_shards + unlocked_shards
- self._remaining_locked_shards = locked_shards
- if locked_shards and self._options.http:
- self.start_servers_with_lock(2 * min(num_workers, len(locked_shards)))
-
</del><span class="cx"> num_workers = min(num_workers, len(all_shards))
</span><del>- self._printer.print_workers_and_shards(num_workers, len(all_shards), len(locked_shards))
</del><ins>+ self._printer.print_workers_and_shards(num_workers, len(all_shards))
</ins><span class="cx">
</span><span class="cx"> if self._options.dry_run:
</span><span class="cx"> return run_results
</span><span class="lines">@@ -197,12 +185,12 @@
</span><span class="cx">
</span><span class="cx"> self._interrupt_if_at_failure_limits(run_results)
</span><span class="cx">
</span><del>- def start_servers_with_lock(self, number_of_servers):
</del><ins>+ def start_servers_with_lock(self):
</ins><span class="cx"> self._printer.write_update('Acquiring http lock ...')
</span><span class="cx"> self._port.acquire_http_lock()
</span><span class="cx"> if self._needs_http:
</span><span class="cx"> self._printer.write_update('Starting HTTP server ...')
</span><del>- self._port.start_http_server(number_of_servers=number_of_servers)
</del><ins>+ self._port.start_http_server()
</ins><span class="cx"> if self._needs_websockets:
</span><span class="cx"> self._printer.write_update('Starting WebSocket server ...')
</span><span class="cx"> self._port.start_websocket_server()
</span><span class="lines">@@ -229,19 +217,6 @@
</span><span class="cx"> def _handle_started_test(self, worker_name, test_input, test_timeout_sec):
</span><span class="cx"> self._printer.print_started_test(test_input.test_name)
</span><span class="cx">
</span><del>- def _handle_finished_test_list(self, worker_name, list_name):
- def find(name, test_lists):
- for i in range(len(test_lists)):
- if test_lists[i].name == name:
- return i
- return -1
-
- index = find(list_name, self._remaining_locked_shards)
- if index >= 0:
- self._remaining_locked_shards.pop(index)
- if not self._remaining_locked_shards:
- self.stop_servers_with_lock()
-
</del><span class="cx"> def _handle_finished_test(self, worker_name, result, log_messages=[]):
</span><span class="cx"> self._update_summary_with_result(self._current_run_results, result)
</span><span class="cx">
</span><span class="lines">@@ -281,7 +256,6 @@
</span><span class="cx"> assert name == 'test_list'
</span><span class="cx"> for test_input in test_inputs:
</span><span class="cx"> self._run_test(test_input, test_list_name)
</span><del>- self._caller.post('finished_test_list', test_list_name)
</del><span class="cx">
</span><span class="cx"> def _update_test_input(self, test_input):
</span><span class="cx"> if test_input.reference_files is None:
</span><span class="lines">@@ -452,9 +426,8 @@
</span><span class="cx">
</span><span class="cx">
</span><span class="cx"> class Sharder(object):
</span><del>- def __init__(self, test_split_fn, max_locked_shards):
</del><ins>+ def __init__(self, test_split_fn):
</ins><span class="cx"> self._split = test_split_fn
</span><del>- self._max_locked_shards = max_locked_shards
</del><span class="cx">
</span><span class="cx"> def shard_tests(self, test_inputs, num_workers, fully_parallel):
</span><span class="cx"> """Groups tests into batches.
</span><span class="lines">@@ -462,64 +435,37 @@
</span><span class="cx"> continue to run together as most cross-tests dependencies tend to
</span><span class="cx"> occur within the same directory.
</span><span class="cx"> Return:
</span><del>- Two list of TestShards. The first contains tests that must only be
- run under the server lock, the second can be run whenever.
</del><ins>+ A list of TestShards.
</ins><span class="cx"> """
</span><span class="cx">
</span><span class="cx"> # FIXME: Move all of the sharding logic out of manager into its
</span><span class="cx"> # own class or module. Consider grouping it with the chunking logic
</span><span class="cx"> # in prepare_lists as well.
</span><span class="cx"> if num_workers == 1:
</span><del>- return self._shard_in_two(test_inputs)
</del><ins>+ return [TestShard('all_tests', test_inputs)]
</ins><span class="cx"> elif fully_parallel:
</span><span class="cx"> return self._shard_every_file(test_inputs)
</span><span class="cx"> return self._shard_by_directory(test_inputs, num_workers)
</span><span class="cx">
</span><del>- def _shard_in_two(self, test_inputs):
- """Returns two lists of shards, one with all the tests requiring a lock and one with the rest.
-
- This is used when there's only one worker, to minimize the per-shard overhead."""
- locked_inputs = []
- unlocked_inputs = []
- for test_input in test_inputs:
- if test_input.needs_servers:
- locked_inputs.append(test_input)
- else:
- unlocked_inputs.append(test_input)
-
- locked_shards = []
- unlocked_shards = []
- if locked_inputs:
- locked_shards = [TestShard('locked_tests', locked_inputs)]
- if unlocked_inputs:
- unlocked_shards = [TestShard('unlocked_tests', unlocked_inputs)]
-
- return locked_shards, unlocked_shards
-
</del><span class="cx"> def _shard_every_file(self, test_inputs):
</span><del>- """Returns two lists of shards, each shard containing a single test file.
</del><ins>+ """Returns a list of shards, each shard containing a single test file.
</ins><span class="cx">
</span><span class="cx"> This mode gets maximal parallelism at the cost of much higher flakiness."""
</span><del>- locked_shards = []
- unlocked_shards = []
</del><ins>+ shards = []
</ins><span class="cx"> for test_input in test_inputs:
</span><span class="cx"> # Note that we use a '.' for the shard name; the name doesn't really
</span><span class="cx"> # matter, and the only other meaningful value would be the filename,
</span><span class="cx"> # which would be really redundant.
</span><del>- if test_input.needs_servers:
- locked_shards.append(TestShard('.', [test_input]))
- else:
- unlocked_shards.append(TestShard('.', [test_input]))
</del><ins>+ shards.append(TestShard('.', [test_input]))
</ins><span class="cx">
</span><del>- return locked_shards, unlocked_shards
</del><ins>+ return shards
</ins><span class="cx">
</span><span class="cx"> def _shard_by_directory(self, test_inputs, num_workers):
</span><del>- """Returns two lists of shards, each shard containing all the files in a directory.
</del><ins>+ """Returns a lists of shards, each shard containing all the files in a directory.
</ins><span class="cx">
</span><span class="cx"> This is the default mode, and gets as much parallelism as we can while
</span><span class="cx"> minimizing flakiness caused by inter-test dependencies."""
</span><del>- locked_shards = []
- unlocked_shards = []
</del><ins>+ shards = []
</ins><span class="cx"> tests_by_dir = {}
</span><span class="cx"> # FIXME: Given that the tests are already sorted by directory,
</span><span class="cx"> # we can probably rewrite this to be clearer and faster.
</span><span class="lines">@@ -530,53 +476,9 @@
</span><span class="cx">
</span><span class="cx"> for directory, test_inputs in tests_by_dir.iteritems():
</span><span class="cx"> shard = TestShard(directory, test_inputs)
</span><del>- if test_inputs[0].needs_servers:
- locked_shards.append(shard)
- else:
- unlocked_shards.append(shard)
</del><ins>+ shards.append(shard)
</ins><span class="cx">
</span><span class="cx"> # Sort the shards by directory name.
</span><del>- locked_shards.sort(key=lambda shard: shard.name)
- unlocked_shards.sort(key=lambda shard: shard.name)
</del><ins>+ shards.sort(key=lambda shard: shard.name)
</ins><span class="cx">
</span><del>- # Put a ceiling on the number of locked shards, so that we
- # don't hammer the servers too badly.
-
- # FIXME: For now, limit to one shard or set it
- # with the --max-locked-shards. After testing to make sure we
- # can handle multiple shards, we should probably do something like
- # limit this to no more than a quarter of all workers, e.g.:
- # return max(math.ceil(num_workers / 4.0), 1)
- return (self._resize_shards(locked_shards, self._max_locked_shards, 'locked_shard'),
- unlocked_shards)
-
- def _resize_shards(self, old_shards, max_new_shards, shard_name_prefix):
- """Takes a list of shards and redistributes the tests into no more
- than |max_new_shards| new shards."""
-
- # This implementation assumes that each input shard only contains tests from a
- # single directory, and that tests in each shard must remain together; as a
- # result, a given input shard is never split between output shards.
- #
- # Each output shard contains the tests from one or more input shards and
- # hence may contain tests from multiple directories.
-
- def divide_and_round_up(numerator, divisor):
- return int(math.ceil(float(numerator) / divisor))
-
- def extract_and_flatten(shards):
- test_inputs = []
- for shard in shards:
- test_inputs.extend(shard.test_inputs)
- return test_inputs
-
- def split_at(seq, index):
- return (seq[:index], seq[index:])
-
- num_old_per_new = divide_and_round_up(len(old_shards), max_new_shards)
- new_shards = []
- remaining_shards = old_shards
- while remaining_shards:
- some_shards, remaining_shards = split_at(remaining_shards, num_old_per_new)
- new_shards.append(TestShard('%s_%d' % (shard_name_prefix, len(new_shards) + 1), extract_and_flatten(some_shards)))
- return new_shards
</del><ins>+ return shards
</ins></span></pre></div>
<a id="trunkToolsScriptswebkitpylayout_testscontrollerslayout_test_runner_unittestpy"></a>
<div class="modfile"><h4>Modified: trunk/Tools/Scripts/webkitpy/layout_tests/controllers/layout_test_runner_unittest.py (176829 => 176830)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Tools/Scripts/webkitpy/layout_tests/controllers/layout_test_runner_unittest.py 2014-12-05 01:23:51 UTC (rev 176829)
+++ trunk/Tools/Scripts/webkitpy/layout_tests/controllers/layout_test_runner_unittest.py 2014-12-05 01:37:02 UTC (rev 176830)
</span><span class="lines">@@ -51,7 +51,7 @@
</span><span class="cx"> def print_expected(self, run_results, get_tests_with_result_type):
</span><span class="cx"> pass
</span><span class="cx">
</span><del>- def print_workers_and_shards(self, num_workers, num_shards, num_locked_shards):
</del><ins>+ def print_workers_and_shards(self, num_workers, num_shards):
</ins><span class="cx"> pass
</span><span class="cx">
</span><span class="cx"> def print_started_test(self, test_name):
</span><span class="lines">@@ -166,7 +166,7 @@
</span><span class="cx">
</span><span class="cx"> def test_servers_started(self):
</span><span class="cx">
</span><del>- def start_http_server(number_of_servers=None):
</del><ins>+ def start_http_server():
</ins><span class="cx"> self.http_started = True
</span><span class="cx">
</span><span class="cx"> def start_websocket_server():
</span><span class="lines">@@ -189,7 +189,7 @@
</span><span class="cx"> runner = self._runner(port=port)
</span><span class="cx"> runner._needs_http = True
</span><span class="cx"> runner._needs_websockets = False
</span><del>- runner.start_servers_with_lock(number_of_servers=4)
</del><ins>+ runner.start_servers_with_lock()
</ins><span class="cx"> self.assertEqual(self.http_started, True)
</span><span class="cx"> self.assertEqual(self.websocket_started, False)
</span><span class="cx"> runner.stop_servers_with_lock()
</span><span class="lines">@@ -199,7 +199,7 @@
</span><span class="cx"> self.http_started = self.http_stopped = self.websocket_started = self.websocket_stopped = False
</span><span class="cx"> runner._needs_http = True
</span><span class="cx"> runner._needs_websockets = True
</span><del>- runner.start_servers_with_lock(number_of_servers=4)
</del><ins>+ runner.start_servers_with_lock()
</ins><span class="cx"> self.assertEqual(self.http_started, True)
</span><span class="cx"> self.assertEqual(self.websocket_started, True)
</span><span class="cx"> runner.stop_servers_with_lock()
</span><span class="lines">@@ -209,7 +209,7 @@
</span><span class="cx"> self.http_started = self.http_stopped = self.websocket_started = self.websocket_stopped = False
</span><span class="cx"> runner._needs_http = False
</span><span class="cx"> runner._needs_websockets = False
</span><del>- runner.start_servers_with_lock(number_of_servers=4)
</del><ins>+ runner.start_servers_with_lock()
</ins><span class="cx"> self.assertEqual(self.http_started, False)
</span><span class="cx"> self.assertEqual(self.websocket_started, False)
</span><span class="cx"> runner.stop_servers_with_lock()
</span><span class="lines">@@ -234,9 +234,9 @@
</span><span class="cx"> def get_test_input(self, test_file):
</span><span class="cx"> return TestInput(test_file, needs_servers=(test_file.startswith('http')))
</span><span class="cx">
</span><del>- def get_shards(self, num_workers, fully_parallel, test_list=None, max_locked_shards=1):
</del><ins>+ def get_shards(self, num_workers, fully_parallel, test_list=None):
</ins><span class="cx"> port = TestPort(MockSystemHost())
</span><del>- self.sharder = Sharder(port.split_test, max_locked_shards)
</del><ins>+ self.sharder = Sharder(port.split_test)
</ins><span class="cx"> test_list = test_list or self.test_list
</span><span class="cx"> return self.sharder.shard_tests([self.get_test_input(test) for test in test_list], num_workers, fully_parallel)
</span><span class="cx">
</span><span class="lines">@@ -249,80 +249,27 @@
</span><span class="cx"> expected_test_names)
</span><span class="cx">
</span><span class="cx"> def test_shard_by_dir(self):
</span><del>- locked, unlocked = self.get_shards(num_workers=2, fully_parallel=False)
</del><ins>+ result = self.get_shards(num_workers=2, fully_parallel=False)
</ins><span class="cx">
</span><del>- # Note that although there are tests in multiple dirs that need locks,
- # they are crammed into a single shard in order to reduce the # of
- # workers hitting the server at once.
- self.assert_shards(locked,
- [('locked_shard_1',
- ['http/tests/security/view-source-no-refresh.html',
- 'http/tests/websocket/tests/unicode.htm',
- 'http/tests/websocket/tests/websocket-protocol-ignored.html',
- 'http/tests/xmlhttprequest/supported-xml-content-types.html'])])
- self.assert_shards(unlocked,
</del><ins>+ self.assert_shards(result,
</ins><span class="cx"> [('animations', ['animations/keyframes.html']),
</span><span class="cx"> ('dom/html/level2/html', ['dom/html/level2/html/HTMLAnchorElement03.html',
</span><span class="cx"> 'dom/html/level2/html/HTMLAnchorElement06.html']),
</span><span class="cx"> ('fast/css', ['fast/css/display-none-inline-style-change-crash.html']),
</span><ins>+ ('http/tests/security', ['http/tests/security/view-source-no-refresh.html']),
+ ('http/tests/websocket/tests', ['http/tests/websocket/tests/unicode.htm', 'http/tests/websocket/tests/websocket-protocol-ignored.html']),
+ ('http/tests/xmlhttprequest', ['http/tests/xmlhttprequest/supported-xml-content-types.html']),
</ins><span class="cx"> ('ietestcenter/Javascript', ['ietestcenter/Javascript/11.1.5_4-4-c-1.html'])])
</span><span class="cx">
</span><span class="cx"> def test_shard_every_file(self):
</span><del>- locked, unlocked = self.get_shards(num_workers=2, fully_parallel=True)
- self.assert_shards(locked,
</del><ins>+ result = self.get_shards(num_workers=2, fully_parallel=True)
+ self.assert_shards(result,
</ins><span class="cx"> [('.', ['http/tests/websocket/tests/unicode.htm']),
</span><ins>+ ('.', ['animations/keyframes.html']),
</ins><span class="cx"> ('.', ['http/tests/security/view-source-no-refresh.html']),
</span><span class="cx"> ('.', ['http/tests/websocket/tests/websocket-protocol-ignored.html']),
</span><del>- ('.', ['http/tests/xmlhttprequest/supported-xml-content-types.html'])]),
- self.assert_shards(unlocked,
- [('.', ['animations/keyframes.html']),
</del><span class="cx"> ('.', ['fast/css/display-none-inline-style-change-crash.html']),
</span><ins>+ ('.', ['http/tests/xmlhttprequest/supported-xml-content-types.html']),
</ins><span class="cx"> ('.', ['dom/html/level2/html/HTMLAnchorElement03.html']),
</span><span class="cx"> ('.', ['ietestcenter/Javascript/11.1.5_4-4-c-1.html']),
</span><span class="cx"> ('.', ['dom/html/level2/html/HTMLAnchorElement06.html'])])
</span><del>-
- def test_shard_in_two(self):
- locked, unlocked = self.get_shards(num_workers=1, fully_parallel=False)
- self.assert_shards(locked,
- [('locked_tests',
- ['http/tests/websocket/tests/unicode.htm',
- 'http/tests/security/view-source-no-refresh.html',
- 'http/tests/websocket/tests/websocket-protocol-ignored.html',
- 'http/tests/xmlhttprequest/supported-xml-content-types.html'])])
- self.assert_shards(unlocked,
- [('unlocked_tests',
- ['animations/keyframes.html',
- 'fast/css/display-none-inline-style-change-crash.html',
- 'dom/html/level2/html/HTMLAnchorElement03.html',
- 'ietestcenter/Javascript/11.1.5_4-4-c-1.html',
- 'dom/html/level2/html/HTMLAnchorElement06.html'])])
-
- def test_shard_in_two_has_no_locked_shards(self):
- locked, unlocked = self.get_shards(num_workers=1, fully_parallel=False,
- test_list=['animations/keyframe.html'])
- self.assertEqual(len(locked), 0)
- self.assertEqual(len(unlocked), 1)
-
- def test_shard_in_two_has_no_unlocked_shards(self):
- locked, unlocked = self.get_shards(num_workers=1, fully_parallel=False,
- test_list=['http/tests/websocket/tests/unicode.htm'])
- self.assertEqual(len(locked), 1)
- self.assertEqual(len(unlocked), 0)
-
- def test_multiple_locked_shards(self):
- locked, unlocked = self.get_shards(num_workers=4, fully_parallel=False, max_locked_shards=2)
- self.assert_shards(locked,
- [('locked_shard_1',
- ['http/tests/security/view-source-no-refresh.html',
- 'http/tests/websocket/tests/unicode.htm',
- 'http/tests/websocket/tests/websocket-protocol-ignored.html']),
- ('locked_shard_2',
- ['http/tests/xmlhttprequest/supported-xml-content-types.html'])])
-
- locked, unlocked = self.get_shards(num_workers=4, fully_parallel=False)
- self.assert_shards(locked,
- [('locked_shard_1',
- ['http/tests/security/view-source-no-refresh.html',
- 'http/tests/websocket/tests/unicode.htm',
- 'http/tests/websocket/tests/websocket-protocol-ignored.html',
- 'http/tests/xmlhttprequest/supported-xml-content-types.html'])])
</del></span></pre></div>
<a id="trunkToolsScriptswebkitpylayout_testscontrollersmanager_unittestpy"></a>
<div class="modfile"><h4>Modified: trunk/Tools/Scripts/webkitpy/layout_tests/controllers/manager_unittest.py (176829 => 176830)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Tools/Scripts/webkitpy/layout_tests/controllers/manager_unittest.py 2014-12-05 01:23:51 UTC (rev 176829)
+++ trunk/Tools/Scripts/webkitpy/layout_tests/controllers/manager_unittest.py 2014-12-05 01:37:02 UTC (rev 176830)
</span><span class="lines">@@ -46,7 +46,7 @@
</span><span class="cx"> def get_manager():
</span><span class="cx"> port = Mock() # FIXME: Use a tighter mock.
</span><span class="cx"> port.TEST_PATH_SEPARATOR = '/'
</span><del>- manager = Manager(port, options=MockOptions(http=True, max_locked_shards=1), printer=Mock())
</del><ins>+ manager = Manager(port, options=MockOptions(http=True), printer=Mock())
</ins><span class="cx"> return manager
</span><span class="cx">
</span><span class="cx"> manager = get_manager()
</span><span class="lines">@@ -59,7 +59,7 @@
</span><span class="cx"> def get_manager():
</span><span class="cx"> host = MockHost()
</span><span class="cx"> port = host.port_factory.get()
</span><del>- manager = Manager(port, options=MockOptions(test_list=None, http=True, max_locked_shards=1), printer=Mock())
</del><ins>+ manager = Manager(port, options=MockOptions(test_list=None, http=True), printer=Mock())
</ins><span class="cx"> return manager
</span><span class="cx">
</span><span class="cx"> manager = get_manager()
</span><span class="lines">@@ -79,7 +79,7 @@
</span><span class="cx"> def get_manager():
</span><span class="cx"> host = MockHost()
</span><span class="cx"> port = host.port_factory.get('test-mac-leopard')
</span><del>- manager = Manager(port, options=MockOptions(test_list=None, http=True, max_locked_shards=1), printer=Mock())
</del><ins>+ manager = Manager(port, options=MockOptions(test_list=None, http=True), printer=Mock())
</ins><span class="cx"> return manager
</span><span class="cx"> host = MockHost()
</span><span class="cx"> port = host.port_factory.get('test-mac-leopard')
</span></span></pre></div>
<a id="trunkToolsScriptswebkitpylayout_testsrun_webkit_testspy"></a>
<div class="modfile"><h4>Modified: trunk/Tools/Scripts/webkitpy/layout_tests/run_webkit_tests.py (176829 => 176830)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Tools/Scripts/webkitpy/layout_tests/run_webkit_tests.py 2014-12-05 01:23:51 UTC (rev 176829)
+++ trunk/Tools/Scripts/webkitpy/layout_tests/run_webkit_tests.py 2014-12-05 01:37:02 UTC (rev 176830)
</span><span class="lines">@@ -331,9 +331,6 @@
</span><span class="cx"> if not options.child_processes:
</span><span class="cx"> options.child_processes = os.environ.get("WEBKIT_TEST_CHILD_PROCESSES",
</span><span class="cx"> str(port.default_child_processes()))
</span><del>- if not options.max_locked_shards:
- options.max_locked_shards = int(os.environ.get("WEBKIT_TEST_MAX_LOCKED_SHARDS",
- str(port.default_max_locked_shards())))
</del><span class="cx">
</span><span class="cx"> if not options.configuration:
</span><span class="cx"> options.configuration = port.default_configuration()
</span></span></pre></div>
<a id="trunkToolsScriptswebkitpylayout_testsrun_webkit_tests_integrationtestpy"></a>
<div class="modfile"><h4>Modified: trunk/Tools/Scripts/webkitpy/layout_tests/run_webkit_tests_integrationtest.py (176829 => 176830)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Tools/Scripts/webkitpy/layout_tests/run_webkit_tests_integrationtest.py 2014-12-05 01:23:51 UTC (rev 176829)
+++ trunk/Tools/Scripts/webkitpy/layout_tests/run_webkit_tests_integrationtest.py 2014-12-05 01:37:02 UTC (rev 176830)
</span><span class="lines">@@ -224,21 +224,6 @@
</span><span class="cx"> for batch in batch_tests_run:
</span><span class="cx"> self.assertTrue(len(batch) <= 2, '%s had too many tests' % ', '.join(batch))
</span><span class="cx">
</span><del>- def test_max_locked_shards(self):
- # Tests for the default of using one locked shard even in the case of more than one child process.
- if not self.should_test_processes:
- return
- save_env_webkit_test_max_locked_shards = None
- if "WEBKIT_TEST_MAX_LOCKED_SHARDS" in os.environ:
- save_env_webkit_test_max_locked_shards = os.environ["WEBKIT_TEST_MAX_LOCKED_SHARDS"]
- del os.environ["WEBKIT_TEST_MAX_LOCKED_SHARDS"]
- _, regular_output, _ = logging_run(['--debug-rwt-logging', '--child-processes', '2'], shared_port=False)
- try:
- self.assertTrue(any(['1 locked' in line for line in regular_output.buflist]))
- finally:
- if save_env_webkit_test_max_locked_shards:
- os.environ["WEBKIT_TEST_MAX_LOCKED_SHARDS"] = save_env_webkit_test_max_locked_shards
-
</del><span class="cx"> def test_child_processes_2(self):
</span><span class="cx"> if self.should_test_processes:
</span><span class="cx"> _, regular_output, _ = logging_run(
</span></span></pre></div>
<a id="trunkToolsScriptswebkitpylayout_testsserversapache_http_serverpy"></a>
<div class="modfile"><h4>Modified: trunk/Tools/Scripts/webkitpy/layout_tests/servers/apache_http_server.py (176829 => 176830)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Tools/Scripts/webkitpy/layout_tests/servers/apache_http_server.py 2014-12-05 01:23:51 UTC (rev 176829)
+++ trunk/Tools/Scripts/webkitpy/layout_tests/servers/apache_http_server.py 2014-12-05 01:37:02 UTC (rev 176830)
</span><span class="lines">@@ -42,12 +42,12 @@
</span><span class="cx">
</span><span class="cx">
</span><span class="cx"> class LayoutTestApacheHttpd(http_server_base.HttpServerBase):
</span><del>- def __init__(self, port_obj, output_dir, additional_dirs=None, number_of_servers=None):
</del><ins>+ def __init__(self, port_obj, output_dir, additional_dirs=None):
</ins><span class="cx"> """Args:
</span><span class="cx"> port_obj: handle to the platform-specific routines
</span><span class="cx"> output_dir: the absolute path to the layout test result directory
</span><span class="cx"> """
</span><del>- http_server_base.HttpServerBase.__init__(self, port_obj, number_of_servers)
</del><ins>+ http_server_base.HttpServerBase.__init__(self, port_obj)
</ins><span class="cx"> # We use the name "httpd" instead of "apache" to make our paths (e.g. the pid file: /tmp/WebKit/httpd.pid)
</span><span class="cx"> # match old-run-webkit-tests: https://bugs.webkit.org/show_bug.cgi?id=63956
</span><span class="cx"> self._name = 'httpd'
</span><span class="lines">@@ -115,11 +115,6 @@
</span><span class="cx"> '-c', "\'RemoveHandler .cgi .pl\'",
</span><span class="cx"> '-c', "\'</Location>\'"]
</span><span class="cx">
</span><del>- if self._number_of_servers:
- start_cmd += ['-c', "\'StartServers %d\'" % self._number_of_servers,
- '-c', "\'MinSpareServers %d\'" % self._number_of_servers,
- '-c', "\'MaxSpareServers %d\'" % self._number_of_servers]
-
</del><span class="cx"> stop_cmd = [executable,
</span><span class="cx"> '-f', "\"%s\"" % self._get_apache_config_file_path(test_dir, output_dir),
</span><span class="cx"> '-c', "\'PidFile %s'" % self._pid_file,
</span></span></pre></div>
<a id="trunkToolsScriptswebkitpylayout_testsserversapache_http_server_unittestpy"></a>
<div class="modfile"><h4>Modified: trunk/Tools/Scripts/webkitpy/layout_tests/servers/apache_http_server_unittest.py (176829 => 176830)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Tools/Scripts/webkitpy/layout_tests/servers/apache_http_server_unittest.py 2014-12-05 01:23:51 UTC (rev 176829)
+++ trunk/Tools/Scripts/webkitpy/layout_tests/servers/apache_http_server_unittest.py 2014-12-05 01:37:02 UTC (rev 176830)
</span><span class="lines">@@ -53,7 +53,7 @@
</span><span class="cx"> test_port = test.TestPort(host)
</span><span class="cx"> host.filesystem.write_text_file(test_port._path_to_apache_config_file(), '')
</span><span class="cx">
</span><del>- server = LayoutTestApacheHttpd(test_port, "/mock/output_dir", number_of_servers=4)
</del><ins>+ server = LayoutTestApacheHttpd(test_port, "/mock/output_dir")
</ins><span class="cx"> server._check_that_all_ports_are_available = lambda: True
</span><span class="cx"> server._is_server_running_on_all_ports = lambda: True
</span><span class="cx"> server._wait_for_action = fake_pid
</span><span class="lines">@@ -64,7 +64,4 @@
</span><span class="cx"> server.stop()
</span><span class="cx"> finally:
</span><span class="cx"> _, _, logs = oc.restore_output()
</span><del>- self.assertIn("StartServers 4", logs)
- self.assertIn("MinSpareServers 4", logs)
- self.assertIn("MaxSpareServers 4", logs)
</del><span class="cx"> self.assertTrue(host.filesystem.exists("/mock/output_dir/httpd.conf"))
</span></span></pre></div>
<a id="trunkToolsScriptswebkitpylayout_testsservershttp_serverpy"></a>
<div class="modfile"><h4>Modified: trunk/Tools/Scripts/webkitpy/layout_tests/servers/http_server.py (176829 => 176830)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Tools/Scripts/webkitpy/layout_tests/servers/http_server.py 2014-12-05 01:23:51 UTC (rev 176829)
+++ trunk/Tools/Scripts/webkitpy/layout_tests/servers/http_server.py 2014-12-05 01:37:02 UTC (rev 176830)
</span><span class="lines">@@ -42,12 +42,12 @@
</span><span class="cx">
</span><span class="cx"> def __init__(self, port_obj, output_dir, background=False, port=None,
</span><span class="cx"> root=None, run_background=None, additional_dirs=None,
</span><del>- layout_tests_dir=None, number_of_servers=None):
</del><ins>+ layout_tests_dir=None):
</ins><span class="cx"> """Args:
</span><span class="cx"> output_dir: the absolute path to the layout test result directory
</span><span class="cx"> """
</span><span class="cx"> # Webkit tests
</span><del>- http_server_base.HttpServerBase.__init__(self, port_obj, number_of_servers)
</del><ins>+ http_server_base.HttpServerBase.__init__(self, port_obj)
</ins><span class="cx"> self._name = 'lighttpd'
</span><span class="cx"> self._output_dir = output_dir
</span><span class="cx"> self._port = port
</span></span></pre></div>
<a id="trunkToolsScriptswebkitpylayout_testsservershttp_server_basepy"></a>
<div class="modfile"><h4>Modified: trunk/Tools/Scripts/webkitpy/layout_tests/servers/http_server_base.py (176829 => 176830)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Tools/Scripts/webkitpy/layout_tests/servers/http_server_base.py 2014-12-05 01:23:51 UTC (rev 176829)
+++ trunk/Tools/Scripts/webkitpy/layout_tests/servers/http_server_base.py 2014-12-05 01:37:02 UTC (rev 176830)
</span><span class="lines">@@ -46,7 +46,7 @@
</span><span class="cx"> class HttpServerBase(object):
</span><span class="cx"> """A skeleton class for starting and stopping servers used by the layout tests."""
</span><span class="cx">
</span><del>- def __init__(self, port_obj, number_of_servers=None):
</del><ins>+ def __init__(self, port_obj):
</ins><span class="cx"> self._executive = port_obj._executive
</span><span class="cx"> self._filesystem = port_obj._filesystem
</span><span class="cx"> self._name = '<virtual>'
</span><span class="lines">@@ -54,7 +54,6 @@
</span><span class="cx"> self._pid = None
</span><span class="cx"> self._pid_file = None
</span><span class="cx"> self._port_obj = port_obj
</span><del>- self._number_of_servers = number_of_servers
</del><span class="cx">
</span><span class="cx"> # We need a non-checkout-dependent place to put lock files, etc. We
</span><span class="cx"> # don't use the Python default on the Mac because it defaults to a
</span></span></pre></div>
<a id="trunkToolsScriptswebkitpylayout_testsviewsprintingpy"></a>
<div class="modfile"><h4>Modified: trunk/Tools/Scripts/webkitpy/layout_tests/views/printing.py (176829 => 176830)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Tools/Scripts/webkitpy/layout_tests/views/printing.py 2014-12-05 01:23:51 UTC (rev 176829)
+++ trunk/Tools/Scripts/webkitpy/layout_tests/views/printing.py 2014-12-05 01:37:02 UTC (rev 176830)
</span><span class="lines">@@ -110,14 +110,14 @@
</span><span class="cx"> self._print_expected_results_of_type(run_results, test_expectations.FLAKY, "flaky", tests_with_result_type_callback)
</span><span class="cx"> self._print_debug('')
</span><span class="cx">
</span><del>- def print_workers_and_shards(self, num_workers, num_shards, num_locked_shards):
</del><ins>+ def print_workers_and_shards(self, num_workers, num_shards):
</ins><span class="cx"> driver_name = self._port.driver_name()
</span><span class="cx"> if num_workers == 1:
</span><span class="cx"> self._print_default("Running 1 %s." % driver_name)
</span><span class="cx"> self._print_debug("(%s)." % grammar.pluralize(num_shards, "shard"))
</span><span class="cx"> else:
</span><span class="cx"> self._print_default("Running %s in parallel." % (grammar.pluralize(num_workers, driver_name)))
</span><del>- self._print_debug("(%d shards; %d locked)." % (num_shards, num_locked_shards))
</del><ins>+ self._print_debug("(%d shards)." % num_shards)
</ins><span class="cx"> self._print_default('')
</span><span class="cx">
</span><span class="cx"> def _print_expected_results_of_type(self, run_results, result_type, result_type_str, tests_with_result_type_callback):
</span></span></pre></div>
<a id="trunkToolsScriptswebkitpyportbasepy"></a>
<div class="modfile"><h4>Modified: trunk/Tools/Scripts/webkitpy/port/base.py (176829 => 176830)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Tools/Scripts/webkitpy/port/base.py 2014-12-05 01:23:51 UTC (rev 176829)
+++ trunk/Tools/Scripts/webkitpy/port/base.py 2014-12-05 01:37:02 UTC (rev 176830)
</span><span class="lines">@@ -159,10 +159,6 @@
</span><span class="cx"> """Return the number of DumpRenderTree instances to use for this port."""
</span><span class="cx"> return self._executive.cpu_count()
</span><span class="cx">
</span><del>- def default_max_locked_shards(self):
- """Return the number of "locked" shards to run in parallel (like the http tests)."""
- return 1
-
</del><span class="cx"> def worker_startup_delay_secs(self):
</span><span class="cx"> # FIXME: If we start workers up too quickly, DumpRenderTree appears
</span><span class="cx"> # to thrash on something and time out its first few tests. Until
</span><span class="lines">@@ -877,16 +873,16 @@
</span><span class="cx"> storage, it should override this method."""
</span><span class="cx"> pass
</span><span class="cx">
</span><del>- def start_http_server(self, additional_dirs=None, number_of_servers=None):
</del><ins>+ def start_http_server(self, additional_dirs=None):
</ins><span class="cx"> """Start a web server. Raise an error if it can't start or is already running.
</span><span class="cx">
</span><span class="cx"> Ports can stub this out if they don't need a web server to be running."""
</span><span class="cx"> assert not self._http_server, 'Already running an http server.'
</span><span class="cx">
</span><span class="cx"> if self._uses_apache():
</span><del>- server = apache_http_server.LayoutTestApacheHttpd(self, self.results_directory(), additional_dirs=additional_dirs, number_of_servers=number_of_servers)
</del><ins>+ server = apache_http_server.LayoutTestApacheHttpd(self, self.results_directory(), additional_dirs=additional_dirs)
</ins><span class="cx"> else:
</span><del>- server = http_server.Lighttpd(self, self.results_directory(), additional_dirs=additional_dirs, number_of_servers=number_of_servers)
</del><ins>+ server = http_server.Lighttpd(self, self.results_directory(), additional_dirs=additional_dirs)
</ins><span class="cx">
</span><span class="cx"> server.start()
</span><span class="cx"> self._http_server = server
</span></span></pre></div>
<a id="trunkToolsScriptswebkitpyportport_testcasepy"></a>
<div class="modfile"><h4>Modified: trunk/Tools/Scripts/webkitpy/port/port_testcase.py (176829 => 176830)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Tools/Scripts/webkitpy/port/port_testcase.py 2014-12-05 01:23:51 UTC (rev 176829)
+++ trunk/Tools/Scripts/webkitpy/port/port_testcase.py 2014-12-05 01:37:02 UTC (rev 176830)
</span><span class="lines">@@ -91,13 +91,6 @@
</span><span class="cx"> port._config.build_directory = lambda configuration: '/mock-build'
</span><span class="cx"> return port
</span><span class="cx">
</span><del>- def test_default_max_locked_shards(self):
- port = self.make_port()
- port.default_child_processes = lambda: 16
- self.assertEqual(port.default_max_locked_shards(), 1)
- port.default_child_processes = lambda: 2
- self.assertEqual(port.default_max_locked_shards(), 1)
-
</del><span class="cx"> def test_default_timeout_ms(self):
</span><span class="cx"> self.assertEqual(self.make_port(options=MockOptions(configuration='Release')).default_timeout_ms(), 35000)
</span><span class="cx"> self.assertEqual(self.make_port(options=MockOptions(configuration='Debug')).default_timeout_ms(), 35000)
</span></span></pre></div>
<a id="trunkToolsScriptswebkitpyporttestpy"></a>
<div class="modfile"><h4>Modified: trunk/Tools/Scripts/webkitpy/port/test.py (176829 => 176830)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Tools/Scripts/webkitpy/port/test.py 2014-12-05 01:23:51 UTC (rev 176829)
+++ trunk/Tools/Scripts/webkitpy/port/test.py 2014-12-05 01:37:02 UTC (rev 176830)
</span><span class="lines">@@ -463,7 +463,7 @@
</span><span class="cx"> def _driver_class(self):
</span><span class="cx"> return TestDriver
</span><span class="cx">
</span><del>- def start_http_server(self, additional_dirs=None, number_of_servers=None):
</del><ins>+ def start_http_server(self, additional_dirs=None):
</ins><span class="cx"> pass
</span><span class="cx">
</span><span class="cx"> def start_websocket_server(self):
</span></span></pre>
</div>
</div>
</body>
</html>