Speedup net_unittests on Android by 30%.

build/android/pylib/chrome_test_server_spawner.py

 # Copyright 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.
 
 """A "Test Server Spawner" that handles killing/stopping per-test test servers.
 
 It's used to accept requests from the device to spawn and kill instances of the
 chrome test server on the host.
 """
 
@@ skipping 27 matching lines @@
     'ftp': '-f',
     'sync': '',  # Sync uses its own script, and doesn't take a server type arg.
     'tcpecho': '--tcp-echo',
     'udpecho': '--udp-echo',
 }
 
 
 # The timeout (in seconds) of starting up the Python test server.
 TEST_SERVER_STARTUP_TIMEOUT = 10
 
+INITIAL_SLEEP_TIMEOUT_SEC = 0.025
 
 def _CheckPortStatus(port, expected_status):
   """Returns True if port has expected_status.
 
   Args:
     port: the port number.
     expected_status: boolean of expected status.
 
   Returns:
     Returns True if the status is expected. Otherwise returns False.
   """
-  for timeout in range(1, 5):
+  sleep_time_sec = INITIAL_SLEEP_TIMEOUT_SEC
+  for attempt in range(1, 5):
     if ports.IsHostPortUsed(port) == expected_status:
       return True
-    time.sleep(timeout)
+    time.sleep(sleep_time_sec)
+    sleep_time_sec *= 2
   return False
 
 
 def _GetServerTypeCommandLine(server_type):
   """Returns the command-line by the given server type.
 
   Args:
     server_type: the server type to be used (e.g. 'http').
 
   Returns:
@@ skipping 151 matching lines @@
         self.is_ready = _CheckPortStatus(self.host_port, True)
     if self.is_ready:
       self._test_server_forwarder = Forwarder(self.adb, self.build_type)
       self._test_server_forwarder.Run(
           [(0, self.host_port)], self.tool, '127.0.0.1')
       # Check whether the forwarder is ready on the device.
       self.is_ready = False
       device_port = self._test_server_forwarder.DevicePortForHostPort(
           self.host_port)
       if device_port:
-        for timeout in range(1, 5):
+        sleep_time_sec = INITIAL_SLEEP_TIMEOUT_SEC
+        for attempt in range(1, 5):
           if ports.IsDevicePortUsed(self.adb, device_port, 'LISTEN'):
             self.is_ready = True
             self.forwarder_device_port = device_port
             break
-          time.sleep(timeout)
+          time.sleep(sleep_time_sec)
+          sleep_time_sec *= 2

[bulach, 2013/05/07 15:09:28]

perhaps move this out into a "_CheckDevicePortStatus()", similarly to
_CheckPortStatus() above?
so this would then become:

if device_port and _CheckDevicePortStatus(adb, device_port):
  self.is_ready = True
  self.forwarder_device_port = device_port


also, not sure how prevalent this functionality is, but maybe move to ports
itself?

[Philippe, 2013/05/07 15:47:41]

Good idea. I would not encourage people to use this pattern so if you agree we
can keep this here.

     # Wake up the request handler thread.
     self.ready_event.set()
     # Keep thread running until Stop() gets called.
+    sleep_time_sec = INITIAL_SLEEP_TIMEOUT_SEC
     while not self.stop_flag:
-      time.sleep(1)
+      time.sleep(sleep_time_sec)
+      sleep_time_sec *= 2

[bulach, 2013/05/07 15:09:28]

should we limit this somehow up to say, 1 or two secs? since this is just on the
host side, if Stop() is called at X+1, this would take another whole X to
actually stop...

[Philippe, 2013/05/07 15:47:41]

Yeah good point.

     if self.process.poll() is None:
       self.process.kill()
     if self._test_server_forwarder:
       self._test_server_forwarder.Close()
     self.process = None
     self.is_ready = False
     if self.pipe_out:
       os.close(self.pipe_in)
       os.close(self.pipe_out)
       self.pipe_in = None
@@ skipping 139 matching lines @@
 
   def _Listen(self):
     logging.info('Starting test server spawner')
     self.server.serve_forever()
 
   def Start(self):
     """Starts the test server spawner."""
     listener_thread = threading.Thread(target=self._Listen)
     listener_thread.setDaemon(True)
     listener_thread.start()
-    time.sleep(1)
 
   def Stop(self):
     """Stops the test server spawner.
 
     Also cleans the server state.
     """
     self.CleanupState()
     self.server.shutdown()
 
   def CleanupState(self):
     """Cleans up the spawning server state.
 
     This should be called if the test server spawner is reused,
     to avoid sharing the test server instance.
     """
     if self.server.test_server_instance:
       self.server.test_server_instance.Stop()
       self.server.test_server_instance = None