tools/trace: Tool to dump gallium state at any draw call.

Based from the code from the good old python state tracker.

Extremely handy to diagnose regressions in state trackers.
Reviewed-by: Brian Paul <[email protected]>

1 files changed, 633 insertions, 0 deletions

diff --git a/src/gallium/tools/trace/dump_state.py b/src/gallium/tools/trace/dump_state.py
new file mode 100755
index 00000000000..cad23bd1517
--- /dev/null
+++ b/src/gallium/tools/trace/dump_state.py
@@ -0,0 +1,633 @@
+#!/usr/bin/env python
+##########################################################################
+# 
+# Copyright 2008-2013, VMware, Inc.
+# All Rights Reserved.
+# 
+# Permission is hereby granted, free of charge, to any person obtaining a
+# copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sub license, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+# 
+# The above copyright notice and this permission notice (including the
+# next paragraph) shall be included in all copies or substantial portions
+# of the Software.
+# 
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+# OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
+# IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
+# ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+# TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+# SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+# 
+##########################################################################
+
+
+import sys
+import struct
+import json
+import binascii
+import re
+
+import model
+import parse as parser
+
+
+try:
+    from struct import unpack_from
+except ImportError:
+    def unpack_from(fmt, buf, offset=0):
+        size = struct.calcsize(fmt)
+        return struct.unpack(fmt, buf[offset:offset + size])
+
+#
+# Some constants
+#
+PIPE_BUFFER = 0
+
+
+def serialize(obj):
+    '''JSON serializer function for non-standard Python objects.'''
+
+    # Don't dump full blobs, but merely a description of their size and
+    # CRC32 hash.
+    if isinstance(obj, bytearray):
+        crc32 = binascii.crc32(obj)
+        if crc32 < 0:
+            crc32 += 0x100000000
+        return 'blob(size=%u,crc32=0x%08x)' % (len(obj), crc32)
+
+    # If the object has a __json__ method, use it.
+    try:
+        method = obj.__json__
+    except AttributeError:
+        raise TypeError(obj)
+    else:
+        return method()
+
+
+class Struct:
+    """C-like struct.
+    
+    Python doesn't have C structs, but do its dynamic nature, any object is
+    pretty close.
+    """
+
+    def __json__(self):
+        '''Convert the structure to a standard Python dict, so it can be
+        serialized.'''
+
+        obj = {}
+        for name, value in self.__dict__.items():
+            if not name.startswith('_'):
+                obj[name] = value
+        return obj
+
+
+class Translator(model.Visitor):
+    """Translate model arguments into regular Python objects"""
+
+    def __init__(self, interpreter):
+        self.interpreter = interpreter
+        self.result = None
+
+    def visit(self, node):
+        self.result = None
+        node.visit(self)
+        return self.result
+        
+    def visit_literal(self, node):
+        self.result = node.value
+    
+    def visit_blob(self, node):
+        self.result = node
+    
+    def visit_named_constant(self, node):
+        self.result = node.name
+    
+    def visit_array(self, node):
+        array = []
+        for element in node.elements:
+            array.append(self.visit(element))
+        self.result = array
+    
+    def visit_struct(self, node):
+        struct = Struct()
+        for member_name, member_node in node.members:
+            member_value = self.visit(member_node)
+            setattr(struct, member_name, member_value)
+        self.result = struct
+    
+    def visit_pointer(self, node):
+        self.result = self.interpreter.lookup_object(node.address)
+
+
+class Dispatcher:
+    '''Base class for classes whose methods can dispatch Gallium calls.'''
+    
+    def __init__(self, interpreter):
+        self.interpreter = interpreter
+        
+
+class Global(Dispatcher):
+    '''Global name space.
+
+    For calls that are not associated with objects, i.e, functions and not
+    methods.
+    '''
+
+    def pipe_screen_create(self):
+        return Screen(self.interpreter)
+    
+    def pipe_context_create(self, screen):
+        return screen.context_create()
+
+    
+class Transfer:
+    '''pipe_transfer'''
+
+    def __init__(self, resource, usage, subresource, box):
+        self.resource = resource
+        self.usage = usage
+        self.subresource = subresource
+        self.box = box
+
+
+class Screen(Dispatcher):
+    '''pipe_screen'''
+    
+    def __init__(self, interpreter):
+        Dispatcher.__init__(self, interpreter)
+
+    def destroy(self):
+        pass
+
+    def context_create(self):
+        return Context(self.interpreter)
+    
+    def is_format_supported(self, format, target, sample_count, bind, geom_flags):
+        pass
+    
+    def resource_create(self, templat):
+        resource = templat
+        # Normalize state to avoid spurious differences
+        if resource.nr_samples == 0:
+            resource.nr_samples = 1
+        if resource.target == PIPE_BUFFER:
+            # We will keep track of buffer contents
+            resource.data = bytearray(resource.width)
+        return resource
+
+    def resource_destroy(self, resource):
+        self.interpreter.unregister_object(resource)
+
+    def fence_finish(self, fence, flags):
+        pass
+    
+    def fence_signalled(self, fence):
+        pass
+    
+    def fence_reference(self, dst, src):
+        pass
+    
+    def flush_frontbuffer(self, resource):
+        pass
+
+
+class Context(Dispatcher):
+    '''pipe_context'''
+
+    # Internal methods variable should be prefixed with '_'
+    
+    def __init__(self, interpreter):
+        Dispatcher.__init__(self, interpreter)
+
+        # Setup initial state
+        self._state = Struct()
+        self._state.scissors = []
+        self._state.viewports = []
+        self._state.vertex_buffers = []
+
+        self._draw_no = 0
+
+    def destroy(self):
+        pass
+    
+    def create_blend_state(self, state):
+        # Normalize state to avoid spurious differences
+        if not state.logicop_enable:
+            del state.logicop_func
+        if not state.rt[0].blend_enable:
+            del state.rt[0].rgb_src_factor
+            del state.rt[0].rgb_dst_factor
+            del state.rt[0].rgb_func
+            del state.rt[0].alpha_src_factor
+            del state.rt[0].alpha_dst_factor
+            del state.rt[0].alpha_func
+        return state
+
+    def bind_blend_state(self, state):
+        # Normalize state
+        self._state.blend = state
+
+    def delete_blend_state(self, state):
+        pass
+    
+    def create_sampler_state(self, state):
+        return state
+
+    def delete_sampler_state(self, state):
+        pass
+
+    def bind_vertex_sampler_states(self, num_states, states):
+        self._state.vertex_sampler = states
+        
+    def bind_geometry_sampler_states(self, num_states, states):
+        self._state.geometry_sampler = states
+        
+    def bind_fragment_sampler_states(self, num_states, states):
+        self._state.fragment_sampler = states
+        
+    def create_rasterizer_state(self, state):
+        return state
+
+    def bind_rasterizer_state(self, state):
+        self._state.rasterizer = state
+        
+    def delete_rasterizer_state(self, state):
+        pass
+    
+    def create_depth_stencil_alpha_state(self, state):
+        # Normalize state to avoid spurious differences
+        if not state.alpha.enabled:
+            del state.alpha.func
+            del state.alpha.ref_value
+        return state
+
+    def bind_depth_stencil_alpha_state(self, state):
+        self._state.depth_stencil_alpha = state
+            
+    def delete_depth_stencil_alpha_state(self, state):
+        pass
+
+    _tokenLabelRE = re.compile('^\s*\d+: ', re.MULTILINE)
+
+    def _create_shader_state(self, state):
+        # Strip the labels from the tokens
+        state.tokens = self._tokenLabelRE.sub('', state.tokens)
+        return state
+
+    create_vs_state = _create_shader_state
+    create_gs_state = _create_shader_state
+    create_fs_state = _create_shader_state
+    
+    def bind_vs_state(self, state):
+        self._state.vs = state
+
+    def bind_gs_state(self, state):
+        self._state.gs = state
+        
+    def bind_fs_state(self, state):
+        self._state.fs = state
+        
+    def _delete_shader_state(self, state):
+        return state
+
+    delete_vs_state = _delete_shader_state
+    delete_gs_state = _delete_shader_state
+    delete_fs_state = _delete_shader_state
+
+    def set_blend_color(self, state):
+        self._state.blend_color = state
+
+    def set_stencil_ref(self, state):
+        self._state.stencil_ref = state
+
+    def set_clip_state(self, state):
+        self._state.clip = state
+
+    def _dump_constant_buffer(self, buffer):
+        if not self.interpreter.verbosity(2):
+            return
+
+        data = self.real.buffer_read(buffer)
+        format = '4f'
+        index = 0
+        for offset in range(0, len(data), struct.calcsize(format)):
+            x, y, z, w = unpack_from(format, data, offset)
+            sys.stdout.write('\tCONST[%2u] = {%10.4f, %10.4f, %10.4f, %10.4f}\n' % (index, x, y, z, w))
+            index += 1
+        sys.stdout.flush()
+
+    def set_constant_buffer(self, shader, index, constant_buffer):
+        # TODO
+        pass
+
+    def set_framebuffer_state(self, state):
+        self._state.fb = state
+
+    def set_polygon_stipple(self, state):
+        self._state.polygon_stipple = state
+
+    def _update(self, array, start_slot, num_slots, states):
+        if not isinstance(states, list):
+            # XXX: trace is not serializing multiple scissors/viewports properly yet
+            num_slots = 1
+            states = [states]
+        while len(array) < start_slot + num_slots:
+            array.append(None)
+        for i in range(num_slots):
+            array[start_slot + i] = states[i]
+
+    def set_scissor_states(self, start_slot, num_scissors, states):
+        self._update(self._state.scissors, start_slot, num_scissors, states)
+
+    def set_viewport_states(self, start_slot, num_viewports, states):
+        self._update(self._state.viewports, start_slot, num_viewports, states)
+
+    def create_sampler_view(self, resource, templ):
+        templ.resource = resource
+        return templ
+
+    def sampler_view_destroy(self, view):
+        pass
+
+    def set_fragment_sampler_views(self, num, views):
+        self._state.fragment_sampler_views = views
+
+    def set_geometry_sampler_views(self, num, views):
+        self._state.geometry_sampler_views = views
+
+    def set_vertex_sampler_views(self, num, views):
+        self._state.vertex_sampler_views = views
+
+    def set_vertex_buffers(self, start_slot, num_buffers, buffers):
+        self._update(self._state.vertex_buffers, start_slot, num_buffers, buffers)
+            
+    def create_vertex_elements_state(self, num_elements, elements):
+        return elements[0:num_elements]
+
+    def bind_vertex_elements_state(self, state):
+        self._state.vertex_elements = state
+
+    def delete_vertex_elements_state(self, state):
+        pass
+
+    def set_index_buffer(self, ib):
+        self._state.index_buffer = ib
+
+    # Don't dump more than this number of indices/vertices
+    MAX_ELEMENTS = 16
+
+    def _merge_indices(self, info):
+        '''Merge the vertices into our state.'''
+
+        index_size = self._state.index_buffer.index_size
+        
+        format = {
+            1: 'B',
+            2: 'H',
+            4: 'I',
+        }[index_size]
+
+        assert struct.calcsize(format) == index_size
+
+        data = self._state.index_buffer.buffer.data
+        max_index, min_index = 0, 0xffffffff
+
+        count = min(info.count, self.MAX_ELEMENTS)
+        indices = []
+        for i in xrange(info.start, info.start + count):
+            offset = self._state.index_buffer.offset + i*index_size
+            index, = unpack_from(format, data, offset)
+            indices.append(index)
+            min_index = min(min_index, index)
+            max_index = max(max_index, index)
+
+        self._state.indices = indices
+
+        return min_index + info.index_bias, max_index + info.index_bias
+
+    def _merge_vertices(self, start, count):
+        '''Merge the vertices into our state.'''
+
+        count = min(count, self.MAX_ELEMENTS)
+        vertices = []
+        for index in xrange(start, start + count):
+            if index >= start + 16:
+                sys.stdout.write('\t...\n')
+                break
+            vertex = []
+            for velem in self._state.vertex_elements:
+                vbuf = self._state.vertex_buffers[velem.vertex_buffer_index]
+                if vbuf.buffer is None:
+                    continue
+
+                data = vbuf.buffer.data
+
+                offset = vbuf.buffer_offset + velem.src_offset + vbuf.stride*index
+                format = {
+                    'PIPE_FORMAT_R32_UINT': 'I',
+                    'PIPE_FORMAT_R32_FLOAT': 'f',
+                    'PIPE_FORMAT_R32G32_FLOAT': '2f',
+                    'PIPE_FORMAT_R32G32B32_FLOAT': '3f',
+                    'PIPE_FORMAT_R32G32B32A32_FLOAT': '4f',
+                    'PIPE_FORMAT_A8R8G8B8_UNORM': '4B',
+                    'PIPE_FORMAT_R8G8B8A8_UNORM': '4B',
+                    'PIPE_FORMAT_B8G8R8A8_UNORM': '4B',
+                    'PIPE_FORMAT_R16G16B16_SNORM': '3h',
+                }[velem.src_format]
+
+                data = vbuf.buffer.data
+                attribute = unpack_from(format, data, offset)
+                vertex.append(attribute)
+
+            vertices.append(vertex)
+
+        self._state.vertices = vertices
+
+    def draw_vbo(self, info):
+        self._draw_no += 1
+
+        if self.interpreter.call_no < self.interpreter.options.call and \
+            self._draw_no < self.interpreter.options.draw:
+                return
+
+        # Merge the all draw state
+
+        self._state.draw = info
+
+        if info.indexed:
+            min_index, max_index = self._merge_indices(info)
+        else:
+            min_index = info.start
+            max_index = info.start + count - 1
+        self._merge_vertices(min_index, max_index - min_index + 1)
+
+        self._dump_state()
+
+    def _dump_state(self):
+        '''Dump our state to JSON and terminate.'''
+
+        json.dump(
+            obj = self._state,
+            fp = sys.stdout,
+            default = serialize,
+            sort_keys = True,
+            indent = 4,
+            separators = (',', ': ')
+        )
+
+        sys.exit(0)
+
+    def resource_copy_region(self, dst, dst_level, dstx, dsty, dstz, src, src_level, src_box):
+        if dst.target == PIPE_BUFFER or src.target == PIPE_BUFFER:
+            # TODO
+            assert 0
+        pass
+
+    def is_resource_referenced(self, texture, face, level):
+        pass
+    
+    def get_transfer(self, texture, sr, usage, box):
+        if texture is None:
+            return None
+        transfer = Transfer(texture, sr, usage, box)
+        return transfer
+    
+    def tex_transfer_destroy(self, transfer):
+        self.interpreter.unregister_object(transfer)
+
+    def transfer_inline_write(self, resource, level, usage, box, stride, layer_stride, data):
+        if resource.target == PIPE_BUFFER:
+            data = data.getValue()
+            assert len(data) == box.width
+            assert box.x + box.width <= len(resource.data)
+            resource.data[box.x : box.x + box.width] = data
+
+    def flush(self, flags):
+        pass
+
+    def clear(self, buffers, color, depth, stencil):
+        pass
+        
+    def clear_render_target(self, dst, rgba, dstx, dsty, width, height):
+        pass
+
+    def clear_depth_stencil(self, dst, clear_flags, depth, stencil, dstx, dsty, width, height):
+        pass
+
+    def create_surface(self, resource, surf_tmpl):
+        surf_tmpl.resource = resource
+        return surf_tmpl
+
+    def surface_destroy(self, surface):
+        self.interpreter.unregister_object(surface)
+
+    def create_query(self, query_type):
+        return query_type
+    
+    def destroy_query(self, query):
+        pass
+
+
+class Interpreter(parser.TraceDumper):
+    '''Specialization of a trace parser that interprets the calls as it goes
+    along.'''
+    
+    ignoredCalls = set((
+            ('pipe_screen', 'is_format_supported'),
+            ('pipe_screen', 'get_name'),
+            ('pipe_screen', 'get_vendor'),
+            ('pipe_screen', 'get_param'),
+            ('pipe_screen', 'get_paramf'),
+            ('pipe_screen', 'get_shader_param'),
+            ('pipe_context', 'clear_render_target'), # XXX workaround trace bugs
+    ))
+
+    def __init__(self, stream, options):
+        parser.TraceDumper.__init__(self, stream, sys.stderr)
+        self.options = options
+        self.objects = {}
+        self.result = None
+        self.globl = Global(self)
+        self.call_no = None
+
+    def register_object(self, address, object):
+        self.objects[address] = object
+        
+    def unregister_object(self, object):
+        # TODO
+        pass
+
+    def lookup_object(self, address):
+        return self.objects[address]
+    
+    def interpret(self, trace):
+        for call in trace.calls:
+            self.interpret_call(call)
+
+    def handle_call(self, call):
+        if (call.klass, call.method) in self.ignoredCalls:
+            return
+
+        self.call_no = call.no
+
+        if self.verbosity(1):
+            # Write the call to stderr (as stdout would corrupt the JSON output)
+            sys.stderr.flush()
+            sys.stdout.flush()
+            parser.TraceDumper.handle_call(self, call)
+            sys.stderr.flush()
+            sys.stdout.flush()
+        
+        args = [(str(name), self.interpret_arg(arg)) for name, arg in call.args] 
+        
+        if call.klass:
+            name, obj = args[0]
+            args = args[1:]
+        else:
+            obj = self.globl
+            
+        method = getattr(obj, call.method)
+        ret = method(**dict(args))
+        
+        # Keep track of created pointer objects.
+        if call.ret and isinstance(call.ret, model.Pointer):
+            if ret is None:
+                sys.stderr.write('warning: NULL returned\n')
+            self.register_object(call.ret.address, ret)
+
+        self.call_no = None
+
+    def interpret_arg(self, node):
+        translator = Translator(self)
+        return translator.visit(node)
+
+    def verbosity(self, level):
+        return self.options.verbosity >= level
+    
+
+class Main(parser.Main):
+
+    def get_optparser(self):
+        '''Custom options.'''
+
+        optparser = parser.Main.get_optparser(self)
+        optparser.add_option("-q", "--quiet", action="store_const", const=0, dest="verbosity", help="no messages")
+        optparser.add_option("-v", "--verbose", action="count", dest="verbosity", default=0, help="increase verbosity level")
+        optparser.add_option("-c", "--call", action="store", type="int", dest="call", default=0xffffffff, help="dump on this call")
+        optparser.add_option("-d", "--draw", action="store", type="int", dest="draw", default=0xffffffff, help="dump on this draw")
+        return optparser
+
+    def process_arg(self, stream, options):
+        parser = Interpreter(stream, options)
+        parser.parse()
+
+
+if __name__ == '__main__':
+    Main().main()