git.cworth.org Git - apitrace/blob - scripts/retracediff.py

   1 #!/usr/bin/env python
   2 ##########################################################################
   3 #
   4 # Copyright 2011 Jose Fonseca
   5 # All Rights Reserved.
   6 #
   7 # Permission is hereby granted, free of charge, to any person obtaining a copy
   8 # of this software and associated documentation files (the 'Software'), to deal
   9 # in the Software without restriction, including without limitation the rights
  10 # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  11 # copies of the Software, and to permit persons to whom the Software is
  12 # furnished to do so, subject to the following conditions:
  13 #
  14 # The above copyright notice and this permission notice shall be included in
  15 # all copies or substantial portions of the Software.
  16 #
  17 # THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  18 # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  19 # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  20 # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  21 # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  22 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  23 # THE SOFTWARE.
  24 #
  25 ##########################################################################/
  26
  27 '''Run two retrace instances in parallel, comparing generated snapshots.
  28 '''
  29
  30
  31 import optparse
  32 import os.path
  33 import subprocess
  34 import platform
  35 import sys
  36
  37 from PIL import Image
  38
  39 from snapdiff import Comparer
  40 from highlight import AutoHighlighter
  41 import jsondiff
  42
  43
  44 # Null file, to use when we're not interested in subprocesses output
  45 if platform.system() == 'Windows':
  46     NULL = open('NUL:', 'wb')
  47 else:
  48     NULL = open('/dev/null', 'wb')
  49
  50
  51 class RetraceRun:
  52
  53     def __init__(self, process):
  54         self.process = process
  55
  56     def nextSnapshot(self):
  57         image, comment = read_pnm(self.process.stdout)
  58         if image is None:
  59             return None, None
  60
  61         callNo = int(comment.strip())
  62
  63         return image, callNo
  64
  65     def terminate(self):
  66         try:
  67             self.process.terminate()
  68         except OSError:
  69             # Avoid http://bugs.python.org/issue14252
  70             pass
  71
  72
  73 class Retracer:
  74
  75     def __init__(self, retraceExe, args, env=None):
  76         self.retraceExe = retraceExe
  77         self.args = args
  78         self.env = env
  79
  80     def _retrace(self, args, stdout=subprocess.PIPE):
  81         cmd = [
  82             self.retraceExe,
  83         ] + args + self.args
  84         if self.env:
  85             for name, value in self.env.iteritems():
  86                 sys.stderr.write('%s=%s ' % (name, value))
  87         sys.stderr.write(' '.join(cmd) + '\n')
  88         try:
  89             return subprocess.Popen(cmd, env=self.env, stdout=stdout, stderr=NULL)
  90         except OSError, ex:
  91             sys.stderr.write('error: failed to execute %s: %s\n' % (cmd[0], ex.strerror))
  92             sys.exit(1)
  93
  94     def retrace(self, args):
  95         p = self._retrace([])
  96         p.wait()
  97         return p.returncode
  98
  99     def snapshot(self, call_nos):
 100         process = self._retrace([
 101             '-s', '-',
 102             '-S', call_nos,
 103         ])
 104         return RetraceRun(process)
 105
 106     def dump_state(self, call_no):
 107         '''Get the state dump at the specified call no.'''
 108
 109         p = self._retrace([
 110             '-D', str(call_no),
 111         ])
 112         state = jsondiff.load(p.stdout)
 113         p.wait()
 114         return state.get('parameters', {})
 115
 116     def diff_state(self, ref_call_no, src_call_no, stream):
 117         '''Compare the state between two calls.'''
 118
 119         ref_state = self.dump_state(ref_call_no)
 120         src_state = self.dump_state(src_call_no)
 121
 122         stream.flush()
 123         differ = jsondiff.Differ(stream)
 124         differ.visit(ref_state, src_state)
 125         stream.write('\n')
 126
 127
 128 def read_pnm(stream):
 129     '''Read a PNM from the stream, and return the image object, and the comment.'''
 130
 131     magic = stream.readline()
 132     if not magic:
 133         return None, None
 134     magic = magic.rstrip()
 135     if magic == 'P5':
 136         channels = 1
 137         bytesPerChannel = 1
 138         mode = 'L'
 139     elif magic == 'P6':
 140         channels = 3
 141         bytesPerChannel = 1
 142         mode = 'RGB'
 143     elif magic == 'Pf':
 144         channels = 1
 145         bytesPerChannel = 4
 146         mode = 'R'
 147     elif magic == 'PF':
 148         channels = 3
 149         bytesPerChannel = 4
 150         mode = 'RGB'
 151     else:
 152         raise Exception('Unsupported magic `%s`' % magic)
 153     comment = ''
 154     line = stream.readline()
 155     while line.startswith('#'):
 156         comment += line[1:]
 157         line = stream.readline()
 158     width, height = map(int, line.strip().split())
 159     maximum = int(stream.readline().strip())
 160     if bytesPerChannel == 1:
 161         assert maximum == 255
 162     else:
 163         assert maximum == 1
 164     data = stream.read(height * width * channels * bytesPerChannel)
 165     if bytesPerChannel == 4:
 166         # Image magic only supports single channel floating point images, so
 167         # represent the image as numpy arrays
 168
 169         import numpy
 170         pixels = numpy.fromstring(data, dtype=numpy.float32)
 171         pixels.resize((height, width, channels))
 172         return pixels, comment
 173
 174     image = Image.frombuffer(mode, (width, height), data, 'raw', mode, 0, 1)
 175     return image, comment
 176
 177
 178 def parse_env(optparser, entries):
 179     '''Translate a list of NAME=VALUE entries into an environment dictionary.'''
 180
 181     if not entries:
 182         return None
 183
 184     env = os.environ.copy()
 185     for entry in entries:
 186         try:
 187             name, var = entry.split('=', 1)
 188         except Exception:
 189             optparser.error('invalid environment entry %r' % entry)
 190         env[name] = var
 191     return env
 192
 193
 194 def main():
 195     '''Main program.
 196     '''
 197
 198     global options
 199
 200     # Parse command line options
 201     optparser = optparse.OptionParser(
 202         usage='\n\t%prog [options] -- [glretrace options] <trace>',
 203         version='%%prog')
 204     optparser.add_option(
 205         '-r', '--retrace', metavar='PROGRAM',
 206         type='string', dest='retrace', default='glretrace',
 207         help='retrace command [default: %default]')
 208     optparser.add_option(
 209         '--ref-driver', metavar='DRIVER',
 210         type='string', dest='ref_driver', default=None,
 211         help='force reference driver')
 212     optparser.add_option(
 213         '--src-driver', metavar='DRIVER',
 214         type='string', dest='src_driver', default=None,
 215         help='force source driver')
 216     optparser.add_option(
 217         '--ref-arg', metavar='OPTION',
 218         type='string', action='append', dest='ref_args', default=[],
 219         help='pass argument to reference retrace')
 220     optparser.add_option(
 221         '--src-arg', metavar='OPTION',
 222         type='string', action='append', dest='src_args', default=[],
 223         help='pass argument to source retrace')
 224     optparser.add_option(
 225         '--ref-env', metavar='NAME=VALUE',
 226         type='string', action='append', dest='ref_env', default=[],
 227         help='add variable to reference environment')
 228     optparser.add_option(
 229         '--src-env', metavar='NAME=VALUE',
 230         type='string', action='append', dest='src_env', default=[],
 231         help='add variable to source environment')
 232     optparser.add_option(
 233         '--diff-prefix', metavar='PATH',
 234         type='string', dest='diff_prefix', default='.',
 235         help='prefix for the difference images')
 236     optparser.add_option(
 237         '-t', '--threshold', metavar='BITS',
 238         type="float", dest="threshold", default=12.0,
 239         help="threshold precision  [default: %default]")
 240     optparser.add_option(
 241         '-S', '--snapshot-frequency', metavar='CALLSET',
 242         type="string", dest="snapshot_frequency", default='draw',
 243         help="calls to compare [default: %default]")
 244     optparser.add_option(
 245         '--diff-state',
 246         action='store_true', dest='diff_state', default=False,
 247         help='diff state between failing calls')
 248     optparser.add_option(
 249         '-o', '--output', metavar='FILE',
 250         type="string", dest="output",
 251         help="output file [default: stdout]")
 252
 253     (options, args) = optparser.parse_args(sys.argv[1:])
 254     ref_env = parse_env(optparser, options.ref_env)
 255     src_env = parse_env(optparser, options.src_env)
 256     if not args:
 257         optparser.error("incorrect number of arguments")
 258
 259     if options.ref_driver:
 260         options.ref_args.insert(0, '--driver=' + options.ref_driver)
 261     if options.src_driver:
 262         options.src_args.insert(0, '--driver=' + options.src_driver)
 263
 264     refRetracer = Retracer(options.retrace, options.ref_args + args, ref_env)
 265     srcRetracer = Retracer(options.retrace, options.src_args + args, src_env)
 266
 267     if options.output:
 268         output = open(options.output, 'wt')
 269     else:
 270         output = sys.stdout
 271
 272     highligher = AutoHighlighter(output)
 273
 274     highligher.write('call\tprecision\n')
 275
 276     last_bad = -1
 277     last_good = 0
 278     refRun = refRetracer.snapshot(options.snapshot_frequency)
 279     try:
 280         srcRun = srcRetracer.snapshot(options.snapshot_frequency)
 281         try:
 282             while True:
 283                 # Get the reference image
 284                 refImage, refCallNo = refRun.nextSnapshot()
 285                 if refImage is None:
 286                     break
 287
 288                 # Get the source image
 289                 srcImage, srcCallNo = srcRun.nextSnapshot()
 290                 if srcImage is None:
 291                     break
 292
 293                 assert refCallNo == srcCallNo
 294                 callNo = refCallNo
 295
 296                 # Compare the two images
 297                 if isinstance(refImage, Image.Image) and isinstance(srcImage, Image.Image):
 298                     # Using PIL
 299                     numpyImages = False
 300                     comparer = Comparer(refImage, srcImage)
 301                     precision = comparer.precision()
 302                 else:
 303                     # Using numpy (for floating point images)
 304                     # TODO: drop PIL when numpy path becomes general enough
 305                     import numpy
 306                     assert not isinstance(refImage, Image.Image)
 307                     assert not isinstance(srcImage, Image.Image)
 308                     numpyImages = True
 309                     assert refImage.shape == srcImage.shape
 310                     diffImage = numpy.square(srcImage - refImage)
 311                     match = numpy.all(diffImage == 0)
 312                     if match:
 313                         precision = 24
 314                     else:
 315                         precision = 0
 316
 317                 mismatch = precision < options.threshold
 318
 319                 if mismatch:
 320                     highligher.color(highligher.red)
 321                     highligher.bold()
 322                 highligher.write('%u\t%f\n' % (callNo, precision))
 323                 if mismatch:
 324                     highligher.normal()
 325
 326                 if mismatch:
 327                     if options.diff_prefix and not numpyImages:
 328                         prefix = os.path.join(options.diff_prefix, '%010u' % callNo)
 329                         prefix_dir = os.path.dirname(prefix)
 330                         if not os.path.isdir(prefix_dir):
 331                             os.makedirs(prefix_dir)
 332                         refImage.save(prefix + '.ref.png')
 333                         srcImage.save(prefix + '.src.png')
 334                         comparer.write_diff(prefix + '.diff.png')
 335                     if last_bad < last_good and options.diff_state:
 336                         srcRetracer.diff_state(last_good, callNo, output)
 337                     last_bad = callNo
 338                 else:
 339                     last_good = callNo
 340
 341                 highligher.flush()
 342         finally:
 343             srcRun.terminate()
 344     finally:
 345         refRun.terminate()
 346
 347
 348 if __name__ == '__main__':
 349     main()