skpbench: filter out junk spewed by Pixel C driver

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 111 matching lines @@
 
   @classmethod
   def run_warmup(cls, warmup_time):
     if not warmup_time:
       return
     print('running %i second warmup...' % warmup_time, file=sys.stderr)
     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')
+    output = subprocess.check_output(commandline, stderr=subprocess.STDOUT)
+
     # validate the warmup run output.
-    for line in output.split('\n'):
+    for line in output.decode('utf-8').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
@@ skipping 16 matching lines @@
     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])
     dump_commandline_if_verbose(commandline)
-    self._proc = subprocess.Popen(commandline, stdout=subprocess.PIPE)
+    self._proc = subprocess.Popen(commandline, stdout=subprocess.PIPE,
+                                  stderr=subprocess.STDOUT)
     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()
           self._process_result(result)
-        else:
+        elif hardware.filter_line(message.value):
           print(message.value, file=sys.stderr)
-        sys.stdout.flush()
         continue
       if message.message == Message.POLL_HARDWARE:
         hardware.sanity_check()
         self._schedule_hardware_poll()
         continue
       if message.message == Message.EXIT:
         self._monitor.join()
         self._proc.wait()
         if self._proc.returncode != 0:
           raise Exception("skpbench exited with nonzero exit code %i" %
                           self._proc.returncode)
         self._proc = None
         break
 
   def _schedule_hardware_poll(self):
     if self._hw_poll_timer:
       self._hw_poll_timer.cancel()
     self._hw_poll_timer = \
       Timer(1, lambda: self._queue.put(Message(Message.POLL_HARDWARE)))
     self._hw_poll_timer.start()
 
   def _process_result(self, result):
     if not self.best_result or result.stddev <= self.best_result.stddev:
       self.best_result = result
     elif FLAGS.verbosity >= 2:
       print("reusing previous result for %s/%s with lower stddev "
             "(%s%% instead of %s%%)." %
             (result.config, result.bench, self.best_result.stddev,
              result.stddev), file=sys.stderr)
+      sys.stdout.flush()
     if self.max_stddev and self.best_result.stddev > self.max_stddev:
       raise StddevException()
 
   def terminate(self):
     if self._proc:
       self._proc.terminate()
       self._monitor.join()
       self._proc.wait()
       self._proc = None
 
@@ skipping 64 matching lines @@
   else:
     hardware = Hardware()
 
   with hardware:
     SKPBench.run_warmup(hardware.warmup_time)
     run_benchmarks(configs, skps, hardware)
 
 
 if __name__ == '__main__':
   main()