skpbench: add warmup run

tools/skpbench/skpbench.py

 #!/usr/bin/env python
 
 # Copyright 2016 Google Inc.
 #
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 from __future__ import print_function
 from _adb import Adb
 from _benchresult import BenchResult
@@ skipping 49 matching lines @@
     nargs='+',
     help=".skp files or directories to expand for .skp files")
 
 FLAGS = __argparse.parse_args()
 if FLAGS.adb:
   import _adb_path as _path
   _path.init(FLAGS.device_serial)
 else:
   import _os_path as _path
 
+def dump_commandline_if_verbose(commandline):
+  if FLAGS.verbosity >= 4:
+    quoted = ['\'%s\'' % re.sub(r'([\\\'])', r'\\\1', x) for x in commandline]
+    print(' '.join(quoted), file=sys.stderr)
+
 
 class StddevException(Exception):
   pass
 
 class Message:
   READLINE = 0,
   POLL_HARDWARE = 1,
   EXIT = 2
   def __init__(self, message, value=None):
     self.message = message
@@ skipping 24 matching lines @@
   if FLAGS.path:
     ARGV[0] = _path.join(FLAGS.path, ARGV[0])
   if FLAGS.adb:
     if FLAGS.device_serial is None:
       ARGV = ['adb', 'shell'] + ARGV
     else:
       ARGV = ['adb', '-s', FLAGS.device_serial, 'shell'] + ARGV
 
   @classmethod
   def print_header(cls):
-    subprocess.call(cls.ARGV + ['--duration', '0'])
+    commandline = cls.ARGV + ['--duration', '0']
+    dump_commandline_if_verbose(commandline)
+    subprocess.call(commandline)
+
+  @classmethod
+  def run_warmup(cls, warmup_time):
+    if not warmup_time:
+      return
+    print('running %i second warmup...' % warmup_time)
+    commandline = cls.ARGV + ['--duration', str(warmup_time * 1000),
+                              '--config', 'gpu',
+                              '--skp', 'warmup']
+    dump_commandline_if_verbose(commandline)
+    output = subprocess.check_output(commandline).decode('utf-8')
+    # validate the warmup run output.
+    for line in output.split('\n'):
+      match = BenchResult.match(line.rstrip())
+      if match and match.bench == 'warmup':
+        return
+    raise Exception('Invalid warmup output:\n%s' % output)
 
   def __init__(self, skp, config, max_stddev, best_result=None):
     self.skp = skp
     self.config = config
     self.max_stddev = max_stddev
     self.best_result = best_result
     self._queue = Queue()
     self._proc = None
     self._monitor = None
     self._hw_poll_timer = None
@@ skipping 11 matching lines @@
     hardware.sanity_check()
     self._schedule_hardware_poll()
 
     commandline = self.ARGV + ['--config', self.config,
                                '--skp', self.skp,
                                '--suppressHeader', 'true']
     if FLAGS.write_path:
       pngfile = _path.join(FLAGS.write_path, self.config,
                            _path.basename(self.skp) + '.png')
       commandline.extend(['--png', pngfile])
-    if (FLAGS.verbosity >= 4):
-      quoted = ['\'%s\'' % re.sub(r'([\\\'])', r'\\\1', x) for x in commandline]
-      print(' '.join(quoted), file=sys.stderr)
+    dump_commandline_if_verbose(commandline)
     self._proc = subprocess.Popen(commandline, stdout=subprocess.PIPE)
     self._monitor = SubprocessMonitor(self._queue, self._proc)
     self._monitor.start()
 
     while True:
       message = self._queue.get()
       if message.message == Message.READLINE:
         result = BenchResult.match(message.value)
         if result:
           hardware.sanity_check()
@@ skipping 67 matching lines @@
                  skpbench.best_result.stddev, skpbench.max_stddev,
                  retry_max_stddev),
                 file=sys.stderr)
         benches.append((skpbench.skp, skpbench.config, retry_max_stddev,
                         skpbench.best_result))
 
       except HardwareException as exception:
         if FLAGS.verbosity >= 5:
           hardware.print_debug_diagnostics()
         skpbench.terminate()
-        naptime = max(hardware.kick_in_time, exception.sleeptime)
         if FLAGS.verbosity >= 1:
           print("%s; taking a %i second nap..." %
-                (exception.message, naptime), file=sys.stderr)
+                (exception.message, exception.sleeptime), file=sys.stderr)
         benches.appendleft(benchargs) # retry the same bench next time.
-        hardware.sleep(naptime - hardware.kick_in_time)
-        time.sleep(hardware.kick_in_time)
+        hardware.sleep(exception.sleeptime)
+        SKPBench.run_warmup(hardware.warmup_time)
 
 
 def main():
   # Delimiter is ',' or ' ', skip if nested inside parens (e.g. gpu(a=b,c=d)).
   DELIMITER = r'[, ](?!(?:[^(]*\([^)]*\))*[^()]*\))'
   configs = re.split(DELIMITER, FLAGS.config)
   skps = _path.find_skps(FLAGS.skps)
 
   if FLAGS.adb:
     adb = Adb(FLAGS.device_serial)
     model = adb.get_device_model()
     if model == 'Pixel C':
       from _hardware_pixel_c import HardwarePixelC
       hardware = HardwarePixelC(adb)
     else:
       from _hardware_android import HardwareAndroid
       print("WARNING: %s: don't know how to monitor this hardware; results "
             "may be unreliable." % model, file=sys.stderr)
       hardware = HardwareAndroid(adb)
   else:
     hardware = Hardware()
 
   with hardware:
-    if hardware.kick_in_time:
-      print("sleeping %i seconds to allow hardware settings to kick in..." %
-            hardware.kick_in_time, file=sys.stderr)
-      time.sleep(hardware.kick_in_time)
+    SKPBench.run_warmup(hardware.warmup_time)
     run_benchmarks(configs, skps, hardware)
 
 
 if __name__ == '__main__':
   main()