git.cworth.org Git - apitrace-tests/blob - driver.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 '''Main test driver.'''
  28
  29
  30 import optparse
  31 import os.path
  32 import platform
  33 import re
  34 import shutil
  35 import subprocess
  36 import sys
  37 import time
  38 import json
  39 import base64
  40
  41 from PIL import Image
  42
  43 try:
  44     from cStringIO import StringIO
  45 except ImportError:
  46     from StringIO import StringIO
  47
  48
  49 def _exit(status, code, reason=None):
  50     if reason is None:
  51         reason = ''
  52     else:
  53         reason = ' (%s)' % reason
  54     sys.stdout.write('%s%s\n' % (status, reason))
  55     sys.exit(code)
  56
  57 def fail(reason=None):
  58     _exit('FAIL', 1, reason)
  59
  60 def skip(reason=None):
  61     _exit('SKIP', 0, reason)
  62
  63 def pass_(reason=None):
  64     _exit('PASS', 0, reason)
  65
  66
  67 def popen(command, *args, **kwargs):
  68     if kwargs.get('cwd', None) is not None:
  69         sys.stdout.write('cd %s && ' % kwargs['cwd'])
  70
  71     try:
  72         env = kwargs.pop('env')
  73     except KeyError:
  74         env = None
  75     else:
  76         names = env.keys()
  77         names.sort()
  78         for name in names:
  79             value = env[name]
  80             if value != os.environ.get(name, None):
  81                 sys.stdout.write('%s=%s ' % (name, value))
  82             env[name] = str(value)
  83
  84     sys.stdout.write(' '.join(command) + '\n')
  85     sys.stdout.flush()
  86
  87     return subprocess.Popen(command, *args, env=env, **kwargs)
  88
  89
  90 def _get_build_path(path):
  91     if options.build is not None:
  92         path = os.path.abspath(os.path.join(options.build, path))
  93     if not os.path.exists(path):
  94         sys.stderr.write('error: %s does not exist\n' % path)
  95         sys.exit(1)
  96     return path
  97
  98 def _get_build_program(program):
  99     if platform.system() == 'Windows':
 100         program += '.exe'
 101     return _get_build_path(program)
 102
 103 def _get_source_path(path):
 104     cache = _get_build_path('CMakeCache.txt')
 105     for line in open(cache, 'rt'):
 106         if line.startswith('CMAKE_HOME_DIRECTORY:INTERNAL='):
 107             _, source_root = line.strip().split('=', 1)
 108             return os.path.join(source_root, path)
 109     return None
 110
 111
 112 class TraceChecker:
 113
 114     def __init__(self, srcStream, refFileName, verbose=False):
 115         self.srcStream = srcStream
 116         self.refFileName = refFileName
 117         if refFileName:
 118             self.refStream = open(refFileName, 'rt')
 119         else:
 120             self.refStream = None
 121         self.verbose = verbose
 122         self.doubleBuffer = False
 123         self.callNo = 0
 124         self.refLine = ''
 125         self.images = []
 126         self.states = []
 127
 128     call_re = re.compile(r'^([0-9]+) (\w+)\(')
 129
 130     def check(self):
 131
 132         swapbuffers = 0
 133         flushes = 0
 134
 135         srcLines = []
 136         self.consumeRefLine()
 137         for line in self.srcStream:
 138             line = line.rstrip()
 139             if self.verbose:
 140                 sys.stdout.write(line + '\n')
 141             mo = self.call_re.match(line)
 142             if mo:
 143                 self.callNo = int(mo.group(1))
 144                 function_name = mo.group(2)
 145                 if function_name.find('SwapBuffers') != -1 or \
 146                    line.find('kCGLPFADoubleBuffer') != -1:
 147                     swapbuffers += 1
 148                 if function_name in ('glFlush', 'glFinish'):
 149                     flushes += 1
 150                 srcLine = line[mo.start(2):]
 151             else:
 152                 srcLine = line
 153             if self.refLine:
 154                 if srcLine == self.refLine:
 155                     self.consumeRefLine()
 156                     srcLines = []
 157                 else:
 158                     srcLines.append(srcLine)
 159
 160         if self.refLine:
 161             if srcLines:
 162                 fail('missing call `%s` (found `%s`)' % (self.refLine, srcLines[0]))
 163             else:
 164                 fail('missing call %s' % self.refLine)
 165
 166         if swapbuffers:
 167             self.doubleBuffer = True
 168         else:
 169             self.doubleBuffer = False
 170
 171     def consumeRefLine(self):
 172         if not self.refStream:
 173             self.refLine = ''
 174             return
 175
 176         while True:
 177             line = self.refStream.readline()
 178             if not line:
 179                 break
 180             line = line.rstrip()
 181             if line.startswith('#'):
 182                 self.handlePragma(line)
 183             else:
 184                 break
 185         self.refLine = line
 186
 187     def handlePragma(self, line):
 188         pragma, rest = line.split(None, 1)
 189         if pragma == '#image':
 190             imageFileName = self.getAbsPath(rest)
 191             self.images.append((self.callNo, imageFileName))
 192         elif pragma == '#state':
 193             stateFileName = self.getAbsPath(rest)
 194             self.states.append((self.callNo, stateFileName))
 195         else:
 196             assert False
 197
 198     def getAbsPath(self, path):
 199         '''Get the absolute from a path relative to the reference filename'''
 200         return os.path.abspath(os.path.join(os.path.dirname(self.refFileName), path))
 201
 202
 203
 204 class TestCase:
 205
 206     cmd = None
 207     cwd = None
 208
 209     api = 'gl'
 210     max_frames = None
 211     trace_file = None
 212
 213     ref_dump = None
 214
 215     doubleBuffer = True
 216
 217     verbose = False
 218
 219     def __init__(self):
 220         self.stateCache = {}
 221
 222     def runApp(self):
 223         '''Run the application standalone, skipping this test if it fails by
 224         some reason.'''
 225
 226         if not self.cmd:
 227             return
 228
 229         p = popen(self.cmd, cwd=self.cwd)
 230         p.wait()
 231         if p.returncode:
 232             skip('application returned code %i' % p.returncode)
 233
 234     api_map = {
 235         'gl': 'gl',
 236         'egl_gl': 'egl',
 237         'egl_gles1': 'egl',
 238         'egl_gles2': 'egl',
 239     }
 240
 241     def traceApp(self):
 242         if not self.cmd:
 243             return
 244
 245         if self.trace_file is None:
 246             name, ext = os.path.splitext(os.path.basename(self.cmd[0]))
 247             self.trace_file = os.path.abspath(os.path.join(self.results, name + '.trace'))
 248         if os.path.exists(self.trace_file):
 249             os.remove(self.trace_file)
 250         else:
 251             trace_dir = os.path.dirname(self.trace_file)
 252             if not os.path.exists(trace_dir):
 253                 os.makedirs(trace_dir)
 254
 255         cmd = self.cmd
 256         env = os.environ.copy()
 257
 258         system = platform.system()
 259         local_wrapper = None
 260         if system == 'Windows':
 261             wrapper = _get_build_path('wrappers/opengl32.dll')
 262             local_wrapper = os.path.join(os.path.dirname(self.cmd[0]), os.path.basename(wrapper))
 263             shutil.copy(wrapper, local_wrapper)
 264             env['TRACE_FILE'] = str(self.trace_file)
 265         else:
 266             apitrace = _get_build_program('apitrace')
 267             cmd = [
 268                 apitrace, 'trace',
 269                 '--api', self.api_map[self.api],
 270                 '--output', self.trace_file,
 271                 '--'
 272             ] + cmd
 273         if self.max_frames is not None:
 274             env['TRACE_FRAMES'] = str(self.max_frames)
 275
 276         try:
 277             p = popen(cmd, env=env, cwd=self.cwd)
 278             p.wait()
 279         finally:
 280             if local_wrapper is not None:
 281                 os.remove(local_wrapper)
 282
 283         if not os.path.exists(self.trace_file):
 284             fail('no trace file generated\n')
 285
 286     def checkTrace(self):
 287         cmd = [_get_build_program('apitrace'), 'dump', '--color=never', self.trace_file]
 288         p = popen(cmd, stdout=subprocess.PIPE)
 289
 290         checker = TraceChecker(p.stdout, self.ref_dump, self.verbose)
 291         checker.check()
 292         p.wait()
 293         if p.returncode != 0:
 294             fail('`apitrace dump` returned code %i' % p.returncode)
 295
 296         self.doubleBuffer = checker.doubleBuffer
 297
 298         for callNo, refImageFileName in checker.images:
 299             self.checkImage(callNo, refImageFileName)
 300         for callNo, refStateFileName in checker.states:
 301             self.checkState(callNo, refStateFileName)
 302
 303     def checkImage(self, callNo, refImageFileName):
 304         srcImage = self.getImage(callNo)
 305         refImage = Image.open(refImageFileName)
 306
 307         from snapdiff import Comparer
 308         comparer = Comparer(refImage, srcImage)
 309         match = comparer.ae()
 310         if not match:
 311             prefix = '%s.%u' % (self.getNamePrefix(), callNo)
 312             srcImageFileName = prefix + '.src.png'
 313             srcImage.save(srcImageFileName)
 314             diffImageFileName = prefix + '.diff.png'
 315             comparer.write_diff(diffImageFileName)
 316             fail('snapshot from call %u does not match %s' % (callNo, refImageFileName))
 317
 318     def checkState(self, callNo, refStateFileName):
 319         srcState = self.getState(callNo)
 320         refState = self.getRefState(refStateFileName)
 321
 322         from jsondiff import Comparer, Differ
 323         comparer = Comparer(ignore_added = True)
 324         match = comparer.visit(refState, srcState)
 325         if not match:
 326             prefix = '%s.%u' % (self.getNamePrefix(), callNo)
 327             srcStateFileName = prefix + '.src.json'
 328             diffStateFileName = prefix + '.diff.json'
 329             self.saveState(srcState, srcStateFileName)
 330             #diffStateFile = open(diffStateFileName, 'wt')
 331             diffStateFile = sys.stdout
 332             differ = Differ(diffStateFile, ignore_added = True)
 333             differ.visit(refState, srcState)
 334             fail('state from call %u does not match %s' % (callNo, refStateFileName))
 335
 336     # Allo non-standard JS comments in JSON
 337     json_comment_re = re.compile(r'//.*$', re.MULTILINE)
 338
 339     def getRefState(self, refStateFileName):
 340         data = open(refStateFileName, 'rt').read()
 341         data = self.json_comment_re.sub('', data)
 342         state = json.loads(data, strict=False)
 343         self.adjustRefState(state)
 344         return state
 345
 346     def getNamePrefix(self):
 347         name = os.path.basename(self.ref_dump)
 348         try:
 349             index = name.index('.')
 350         except ValueError:
 351             pass
 352         else:
 353             name = name[:index]
 354         return name
 355
 356     def saveState(self, state, filename):
 357         s = json.dumps(state, sort_keys=True, indent=2)
 358         open(filename, 'wt').write(s)
 359
 360     def retrace(self):
 361         p = self._retrace()
 362         p.wait()
 363         if p.returncode != 0:
 364             fail('retrace failed with code %i' % (p.returncode))
 365
 366     def getImage(self, callNo):
 367         state = self.getState(callNo)
 368         if self.doubleBuffer:
 369             attachments = ['GL_BACK', 'GL_BACK_LEFT', 'GL_BACK_RIGHT', 'GL_COLOR_ATTACHMENT0']
 370         else:
 371             attachments = ['GL_FRONT', 'GL_FRONT_LEFT', 'GL_FRONT_RIGHT', 'GL_COLOR_ATTACHMENT0']
 372         imageObj = self.getFramebufferAttachment(state, attachments)
 373         data = imageObj['__data__']
 374         stream = StringIO(base64.b64decode(data))
 375         im = Image.open(stream)
 376         im.save('test.png')
 377         return im
 378
 379     def getFramebufferAttachment(self, state, attachments):
 380         framebufferObj = state['framebuffer']
 381         for attachment in attachments:
 382             try:
 383                 attachmentObj = framebufferObj[attachment]
 384             except KeyError:
 385                 pass
 386             else:
 387                 return attachmentObj
 388         raise Exception("no attachment found")
 389
 390     def getState(self, callNo):
 391         try:
 392             state = self.stateCache[callNo]
 393         except KeyError:
 394             pass
 395         else:
 396             return state
 397
 398         p = self._retrace(['-D', str(callNo)])
 399         state = json.load(p.stdout, strict=False)
 400         p.wait()
 401         if p.returncode != 0:
 402             fail('retrace returned code %i' % (p.returncode))
 403
 404         self.adjustSrcState(state)
 405
 406         self.stateCache[callNo] = state
 407
 408         return state
 409
 410     def adjustSrcState(self, state):
 411         # Do some adjustments on the obtained state to eliminate failures from
 412         # bugs/issues outside of apitrace
 413
 414         try:
 415             parameters = state['parameters']
 416         except KeyError:
 417             return
 418
 419         # On NVIDIA drivers glGetIntegerv(GL_INDEX_WRITEMASK) returns -1
 420         self.replaceState(parameters, 'GL_INDEX_WRITEMASK', 255, -1)
 421
 422         # On Gallium
 423         if 'Gallium' in parameters['GL_RENDERER'].split():
 424             # Gallium drivers have wrong defaults for draw/read buffer state
 425             self.replaceState(parameters, 'GL_DRAW_BUFFER', 'GL_BACK_LEFT', 'GL_BACK')
 426             self.replaceState(parameters, 'GL_DRAW_BUFFER0', 'GL_BACK_LEFT', 'GL_BACK')
 427             self.replaceState(parameters, 'GL_READ_BUFFER', 'GL_BACK_LEFT', 'GL_BACK')
 428             self.replaceState(parameters, 'GL_DRAW_BUFFER', 'GL_FRONT_LEFT', 'GL_FRONT')
 429             self.replaceState(parameters, 'GL_DRAW_BUFFER0', 'GL_FRONT_LEFT', 'GL_FRONT')
 430             self.replaceState(parameters, 'GL_READ_BUFFER', 'GL_FRONT_LEFT', 'GL_FRONT')
 431
 432     def adjustRefState(self, state):
 433         # Do some adjustments on reference state to eliminate failures from
 434         # bugs/issues outside of apitrace
 435
 436         try:
 437             parameters = state['parameters']
 438         except KeyError:
 439             return
 440
 441         if platform.system() == 'Darwin' or True:
 442             # Mac OS X drivers fail on GL_COLOR_SUM
 443             # XXX: investigate this
 444             self.removeState(parameters, 'GL_COLOR_SUM')
 445
 446     def replaceState(self, obj, key, srcValue, dstValue):
 447         try:
 448             value = obj[key]
 449         except KeyError:
 450             pass
 451         else:
 452             if value == srcValue:
 453                 obj[key] = dstValue
 454
 455     def removeState(self, obj, key):
 456         try:
 457             del obj[key]
 458         except KeyError:
 459             pass
 460
 461     def _retrace(self, args = None, stdout=subprocess.PIPE):
 462         retrace = self.api_map[self.api] + 'retrace'
 463         cmd = [_get_build_program(retrace)]
 464         if self.doubleBuffer:
 465             cmd += ['-db']
 466         else:
 467             cmd += ['-sb']
 468         if args:
 469             cmd += args
 470         cmd += [self.trace_file]
 471         return popen(cmd, stdout=stdout)
 472
 473     def run(self):
 474         self.runApp()
 475         self.traceApp()
 476         self.checkTrace()
 477         self.retrace()
 478
 479         pass_()
 480
 481
 482 def main():
 483     global options
 484
 485     # Parse command line options
 486     optparser = optparse.OptionParser(
 487         usage='\n\t%prog [options] -- [TRACE|PROGRAM] ...',
 488         version='%%prog')
 489     optparser.add_option(
 490         '-v', '--verbose',
 491         action="store_true",
 492         dest="verbose", default=False,
 493         help="verbose output")
 494     optparser.add_option(
 495         '-a', '--api', metavar='API',
 496         type='string', dest='api', default='gl',
 497         help='api to trace')
 498     optparser.add_option(
 499         '-B', '--build', metavar='PATH',
 500         type='string', dest='build', default='..',
 501         help='path to apitrace build')
 502     optparser.add_option(
 503         '-C', '--directory', metavar='PATH',
 504         type='string', dest='cwd', default=None,
 505         help='change to directory')
 506     optparser.add_option(
 507         '-R', '--results', metavar='PATH',
 508         type='string', dest='results', default='.',
 509         help='results directory [default=%default]')
 510     optparser.add_option(
 511         '--ref-dump', metavar='PATH',
 512         type='string', dest='ref_dump', default=None,
 513         help='reference dump')
 514
 515     (options, args) = optparser.parse_args(sys.argv[1:])
 516     if not args:
 517         optparser.error('an argument must be specified')
 518
 519     if not os.path.exists(options.results):
 520         os.makedirs(options.results)
 521
 522     sys.path.insert(0, _get_source_path('scripts'))
 523
 524     test = TestCase()
 525     test.verbose = options.verbose
 526
 527     if args[0].endswith('.trace'):
 528         test.trace_file = args[0]
 529     else:
 530         test.cmd = args
 531     test.cwd = options.cwd
 532     test.api = options.api
 533     test.ref_dump = options.ref_dump
 534     test.results = options.results
 535
 536     test.run()
 537
 538
 539 if __name__ == '__main__':
 540     main()