Remove dashing from gpu veto

tools/test_gpuveto.py

 #!/usr/bin/env python
 
 # Copyright 2014 Google Inc.
 #
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 """Script to test out suitableForGpuRasterization (via gpuveto)"""
 
 import argparse
@@ skipping 39 matching lines @@
     output, _ = proc.communicate()
     errcode = proc.returncode
     return (errcode, output)
 
 
 class GpuVeto(object):
 
     def __init__(self):
         self.bench_pictures = find_run_binary.find_path_to_program(
             'bench_pictures')
+        sys.stdout.write('Running: %s\n' % (self.bench_pictures))
         self.gpuveto = find_run_binary.find_path_to_program('gpuveto')
         assert os.path.isfile(self.bench_pictures)
         assert os.path.isfile(self.gpuveto)
+        self.indeterminate = 0
         self.truePositives = 0
         self.falsePositives = 0
         self.trueNegatives = 0
         self.falseNegatives = 0
 
-    def process_skps(self, dir_or_file):
+    def process_skps(self, dir_or_file, timer):
+        if ('c' == timer):
+            timer_str = 'CPU'

[bsalomon, 2014/06/18 13:26:25]

This is going away, Joe is going to remove the CPU timer because it is more
expensive than wall and less accurate.

+        elif ('w' == timer):
+            timer_str = 'Wall'
+        else:
+            sys.stderr.write('Invalid timer parameter. Must be either \'c\' or \'w\'\n')
+            return
+        sys.stdout.write('Using Timer: %s\n' % (timer_str))
+
         for skp in enumerate(dir_or_file):
-            self.process_skp(skp[1])
+            self.process_skp(skp[1], timer)
 
-        sys.stdout.write('TP %d FP %d TN %d FN %d\n' % (self.truePositives,
-                                            self.falsePositives,
-                                            self.trueNegatives,
-                                            self.falseNegatives))
+        sys.stdout.write('TP %d FP %d TN %d FN %d IND %d\n' % (self.truePositives,
+                                                               self.falsePositives,
+                                                               self.trueNegatives,
+                                                               self.falseNegatives,
+                                                               self.indeterminate))
 
 
-    def process_skp(self, skp_file):
+    def process_skp(self, skp_file, timer):
         assert os.path.isfile(skp_file)
+        #print skp_file
 
         # run gpuveto on the skp
         args = [self.gpuveto, '-r', skp_file]
         returncode, output = execute_program(args)
         if (returncode != 0):
             return
 
         if ('unsuitable' in output):
             suitable = False
         else:
             assert 'suitable' in output
             suitable = True
 
         # run raster config
         args = [self.bench_pictures, '-r', skp_file, 
                                      '--repeat', '20', 
+                                     '--timers', timer, 
                                      '--config', '8888']
         returncode, output = execute_program(args)
         if (returncode != 0):
             return
 
-        matches = re.findall('[\d.]+', output)
-        if len(matches) != 4:
+        matches = re.findall('[\d]+\.[\d]+', output)
+        if len(matches) != 1:
             return
 
-        rasterTime = float(matches[3])
+        rasterTime = float(matches[0])
 
         # run gpu config
         args2 = [self.bench_pictures, '-r', skp_file, 
                                       '--repeat', '20', 
+                                      '--timers', timer, 
                                       '--config', 'gpu']
         returncode, output = execute_program(args2)
         if (returncode != 0):
             return
 
-        matches = re.findall('[\d.]+', output)
-        if len(matches) != 4:
+        matches = re.findall('[\d]+\.[\d]+', output)
+        if len(matches) != 1:
             return
 
-        gpuTime = float(matches[3])
+        gpuTime = float(matches[0])
 
-        sys.stdout.write('%s: gpuveto: %d raster %.2f gpu: %.2f\n' % (
-            skp_file, suitable, rasterTime, gpuTime))
+        # happens if page is too big it will not render
+        if 0 == gpuTime:
+            return
 
-        if suitable:
+        tolerance = 0.05
+        tol_range = tolerance * gpuTime
+
+
+        if rasterTime > gpuTime - tol_range and rasterTime < gpuTime + tol_range:
+            result = "NONE"
+            self.indeterminate += 1
+        elif suitable:
             if gpuTime < rasterTime:
                 self.truePositives += 1
+                result = "TP"
             else:
                 self.falsePositives += 1
+                result = "FP"
         else:
             if gpuTime < rasterTime:
                 self.falseNegatives += 1
+                result = "FN"
             else:
                 self.trueNegatives += 1
+                result = "TN"
+        
 
+        sys.stdout.write('%s: gpuveto: %d raster %.2f gpu: %.2f  Result: %s\n' % (
+            skp_file, suitable, rasterTime, gpuTime, result))
 
 def main(main_argv):
     parser = argparse.ArgumentParser()
     parser.add_argument('--skp_path',
                         help='Path to the SKP(s). Can either be a directory ' \
                         'containing SKPs or a single SKP.',
                         required=True)
+    parser.add_argument('--timer',
+                        help='Timer to use in bench pictures. Can either be \'c\' ' \
+                        'for cpu timer or \'w\' for wall time. Default = c',
+                        required=False, default='c')
 
     args = parser.parse_args()
-    GpuVeto().process_skps(list_files(args.skp_path))
+    GpuVeto().process_skps(list_files(args.skp_path), args.timer)
 
 if __name__ == '__main__':
     sys.exit(main(sys.argv[1]))