Android perf tests: use a proper timer.

build/android/pylib/perf/test_runner.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.
 
 """Runs perf tests.
 
 Our buildbot infrastructure requires each slave to run steps serially.
 This is sub-optimal for android, where these steps can run independently on
 multiple connected devices.
 
@@ skipping 28 matching lines @@
 Note that script_to_execute necessarily have to take at least the following
 option:
   --device: the serial number to be passed to all adb commands.
 """
 
 import datetime
 import logging
 import os
 import pickle
 import sys
+import threading
 import time
 
 from pylib import constants
 from pylib import forwarder
 from pylib import pexpect
 from pylib.base import base_test_result
 from pylib.base import base_test_runner
 
 
 def PrintTestOutput(test_name):
@@ skipping 22 matching lines @@
 
 
 class _HeartBeatLogger(object):
   # How often to print the heartbeat on flush().
   _PRINT_INTERVAL = 600
 
   def __init__(self):
     """A file-like class for keeping the buildbot alive."""
     self._len = 0
     self._tick = time.time()
+    self._stopped = threading.Event()
+    self._timer = threading.Thread(target=self._runner)
+    self._timer.start()
+
+  def _runner(self):
+    while not self._stopped.is_set():
+      self.flush()
+      self._stopped.wait(_HeartBeatLogger._PRINT_INTERVAL)
 
   def write(self, data):
     self._len += len(data)
 
   def flush(self):
     now = time.time()
     if now - self._tick >= _HeartBeatLogger._PRINT_INTERVAL:
       self._tick = now
       print '--single-step output length %d' % self._len
 
+  def stop(self):
+    self._stopped.set()
+
 
 class TestRunner(base_test_runner.BaseTestRunner):
   def __init__(self, test_options, device, tests, flaky_tests):
     """A TestRunner instance runs a perf test on a single device.
 
     Args:
       test_options: A PerfOptions object.
       device: Device to run the tests.
       tests: a dict mapping test_name to command.
       flaky_tests: a list of flaky test_name.
@@ skipping 55 matching lines @@
       # Just print a heart-beat so that the outer buildbot scripts won't timeout
       # without response.
       logfile = _HeartBeatLogger()
     cwd = os.path.abspath(constants.DIR_SOURCE_ROOT)
     if full_cmd.startswith('src/'):
       cwd = os.path.abspath(os.path.join(constants.DIR_SOURCE_ROOT, os.pardir))
     output, exit_code = pexpect.run(
         full_cmd, cwd=cwd,
         withexitstatus=True, logfile=logfile, timeout=timeout,
         env=os.environ)
+    if self._options.single_step:
+      # Stop the logger.
+      logfile.stop()
     end_time = datetime.datetime.now()
     if exit_code is None:
       exit_code = -1
     logging.info('%s : exit_code=%d in %d secs at %s',
                  test_name, exit_code, (end_time - start_time).seconds,
                  self.device)
     result_type = base_test_result.ResultType.FAIL
     if exit_code == 0:
       result_type = base_test_result.ResultType.PASS
     actual_exit_code = exit_code
@@ skipping 27 matching lines @@
     Returns:
       A tuple of (TestRunResults, retry).
     """
     output, result_type = self._LaunchPerfTest(test_name)
     results = base_test_result.TestRunResults()
     results.AddResult(base_test_result.BaseTestResult(test_name, result_type))
     retry = None
     if not results.DidRunPass():
       retry = test_name
     return results, retry