trace: Bring state dump up to speed.

Reviewed-by: Brian Paul <brianp@vmware.com>
Reviewed-by: Roland Scheidegger <sroland@vmware.com>
Reviewed-By: Mike Blumenkrantz <michael.blumenkrantz@gmail.com>
Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/17107>

src/gallium/tools/trace/dump_state.py

@@ -1,7 +1,7 @@
 #!/usr/bin/env python3
 ##########################################################################
 #
-# Copyright 2008-2013, VMware, Inc.
+# Copyright 2008-2021, VMware, Inc.
 # All Rights Reserved.
 #
 # Permission is hereby granted, free of charge, to any person obtaining a
@@ -50,12 +50,7 @@ except ImportError:
 #
 # Some constants
 #
-PIPE_BUFFER = 0
+PIPE_BUFFER = 'PIPE_BUFFER'
-PIPE_SHADER_VERTEX   = 0
-PIPE_SHADER_FRAGMENT = 1
-PIPE_SHADER_GEOMETRY = 2
-PIPE_SHADER_COMPUTE  = 3
-PIPE_SHADER_TYPES    = 4
 
 
 def serialize(obj):
@@ -190,9 +185,6 @@ class Screen(Dispatcher):
     def context_create(self, priv=None, flags=0):
         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
@@ -205,6 +197,23 @@ class Screen(Dispatcher):
             del resource.format
         return resource
 
+    resource_create_unbacked = resource_create
+
+    def allocate_memory(screen, size):
+        pass
+
+    def free_memory(screen, pmem):
+        pass
+
+    def map_memory(screen, pmem):
+        pass
+
+    def unmap_memory(screen, pmem):
+        pass
+
+    def resource_bind_backing(screen, resource, pmem, offset):
+        pass
+
     def resource_destroy(self, resource):
         self.interpreter.unregister_object(resource)
 
@@ -236,22 +245,33 @@ class Context(Dispatcher):
         self._state.vertex_buffers = []
         self._state.vertex_elements = []
         self._state.vs = Struct()
+        self._state.tcs = Struct()
+        self._state.tes = Struct()
         self._state.gs = Struct()
         self._state.fs = Struct()
         self._state.vs.shader = None
+        self._state.tcs.shader = None
+        self._state.tes.shader = None
         self._state.gs.shader = None
         self._state.fs.shader = None
         self._state.vs.sampler = []
+        self._state.tcs.sampler = []
+        self._state.tes.sampler = []
         self._state.gs.sampler = []
         self._state.fs.sampler = []
         self._state.vs.sampler_views = []
+        self._state.tcs.sampler_views = []
+        self._state.tes.sampler_views = []
         self._state.gs.sampler_views = []
         self._state.fs.sampler_views = []
         self._state.vs.constant_buffer = []
+        self._state.tcs.constant_buffer = []
+        self._state.tes.constant_buffer = []
         self._state.gs.constant_buffer = []
         self._state.fs.constant_buffer = []
         self._state.render_condition_condition = 0
         self._state.render_condition_mode = 0
+        self._state.sample_mask = 0xffffffff
 
         self._draw_no = 0
 
@@ -312,9 +332,9 @@ class Context(Dispatcher):
 
     def create_depth_stencil_alpha_state(self, state):
         # Normalize state to avoid spurious differences
-        if not state.alpha.enabled:
+        if not state.alpha_enabled:
-            del state.alpha.func
+            del state.alpha_func
-            del state.alpha.ref_value
+            del state.alpha_ref_value
         for i in range(2):
             if not state.stencil[i].enabled:
                 del state.stencil[i].func
@@ -335,22 +355,35 @@ class Context(Dispatcher):
         return state
 
     create_vs_state = _create_shader_state
+    create_tcs_state = _create_shader_state
+    create_tes_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.shader = state
 
+    def bind_tcs_state(self, state):
+        self._state.tcs.shader = state
+
+    def bind_tes_state(self, state):
+        self._state.tes.shader = state
+
     def bind_gs_state(self, state):
         self._state.gs.shader = state
 
     def bind_fs_state(self, state):
         self._state.fs.shader = state
 
+    def bind_tcz_state(self, state):
+        self._state.tcs.shader = state
+
     def _delete_shader_state(self, state):
         return state
 
     delete_vs_state = _delete_shader_state
+    delete_tcs_state = _delete_shader_state
+    delete_tes_state = _delete_shader_state
     delete_gs_state = _delete_shader_state
     delete_fs_state = _delete_shader_state
 
@@ -377,15 +410,19 @@ class Context(Dispatcher):
         sys.stdout.flush()
 
     def _get_stage_state(self, shader):
-        if shader == PIPE_SHADER_VERTEX:
+        if shader == 'PIPE_SHADER_VERTEX':
             return self._state.vs
-        if shader == PIPE_SHADER_GEOMETRY:
+        if shader == 'PIPE_SHADER_TESS_CTRL':
+            return self._state.tcs
+        if shader == 'PIPE_SHADER_TESS_EVAL':
+            return self._state.tes
+        if shader == 'PIPE_SHADER_GEOMETRY':
             return self._state.gs
-        if shader == PIPE_SHADER_FRAGMENT:
+        if shader == 'PIPE_SHADER_FRAGMENT':
             return self._state.fs
         assert False
 
-    def set_constant_buffer(self, shader, index, constant_buffer):
+    def set_constant_buffer(self, shader, index, take_ownership, constant_buffer):
         self._update(self._get_stage_state(shader).constant_buffer, index, 1, [constant_buffer])
 
     def set_framebuffer_state(self, state):
@@ -417,7 +454,7 @@ class Context(Dispatcher):
     def sampler_view_destroy(self, view):
         pass
 
-    def set_sampler_views(self, shader, start, num, views):
+    def set_sampler_views(self, shader, start, num, unbind_num_trailing_slots, take_ownership, views):
         # FIXME: Handle non-zero start
         assert start == 0
         self._get_stage_state(shader).sampler_views = views
@@ -434,7 +471,7 @@ class Context(Dispatcher):
         # XXX: deprecated
         self._state.vs.sampler_views = views
 
-    def set_vertex_buffers(self, start_slot, num_buffers, buffers):
+    def set_vertex_buffers(self, start_slot, num_buffers, unbind_num_trailing_slots, take_ownership, buffers):
         self._update(self._state.vertex_buffers, start_slot, num_buffers, buffers)
 
     def create_vertex_elements_state(self, num_elements, elements):
@@ -449,6 +486,9 @@ class Context(Dispatcher):
     def set_index_buffer(self, ib):
         self._state.index_buffer = ib
 
+    def set_patch_vertices(self, patch_vertices):
+        pass
+
     # Don't dump more than this number of indices/vertices
     MAX_ELEMENTS = 16
 
@@ -543,7 +583,13 @@ class Context(Dispatcher):
         self._state.so_targets = tgs
         self._state.offsets = offsets
 
-    def draw_vbo(self, info):
+    def set_sample_mask(self, sample_mask):
+        self._state.sample_mask = sample_mask
+
+    def set_min_samples(self, min_samples):
+        pass
+
+    def draw_vbo(self, info, drawid_offset, indirect, draws, num_draws):
         self._draw_no += 1
 
         if self.interpreter.call_no < self.interpreter.options.call and \
@@ -557,8 +603,8 @@ class Context(Dispatcher):
         if info.index_size != 0:
             min_index, max_index = self._merge_indices(info)
         else:
-            min_index = info.start
+            min_index = draws[0].start
-            max_index = info.start + info.count - 1
+            max_index = draws[0].start + draws[0].count - 1
         self._merge_vertices(min_index, max_index - min_index + 1)
 
         self._dump_state()
@@ -566,33 +612,32 @@ class Context(Dispatcher):
     _dclRE = re.compile('^DCL\s+(IN|OUT|SAMP|SVIEW)\[([0-9]+)\].*$', re.MULTILINE)
 
     def _normalize_stage_state(self, stage):
-
-        registers = {}
-
         if stage.shader is not None and stage.shader.tokens is not None:
+            registers = {}
+
             for mo in self._dclRE.finditer(stage.shader.tokens):
                 file_ = mo.group(1)
                 index = mo.group(2)
                 register = registers.setdefault(file_, set())
                 register.add(int(index))
 
-        if 'SAMP' in registers and 'SVIEW' not in registers:
+            if 'SAMP' in registers and 'SVIEW' not in registers:
-            registers['SVIEW'] = registers['SAMP']
+                registers['SVIEW'] = registers['SAMP']
 
-        mapping = [
+            mapping = [
-            #("CONST", "constant_buffer"),
+                #("CONST", "constant_buffer"),
-            ("SAMP", "sampler"),
+                ("SAMP", "sampler"),
-            ("SVIEW", "sampler_views"),
+                ("SVIEW", "sampler_views"),
-        ]
+            ]
 
-        for fileName, attrName in mapping:
+            for fileName, attrName in mapping:
-            register = registers.setdefault(fileName, set())
+                register = registers.setdefault(fileName, set())
-            attr = getattr(stage, attrName)
+                attr = getattr(stage, attrName)
-            for index in range(len(attr)):
+                for index in range(len(attr)):
-                if index not in register:
+                    if index not in register:
-                    attr[index] = None
+                        attr[index] = None
-            while attr and attr[-1] is None:
+                while attr and attr[-1] is None:
-                attr.pop()
+                    attr.pop()
 
     def _dump_state(self):
         '''Dump our state to JSON and terminate.'''
@@ -600,6 +645,8 @@ class Context(Dispatcher):
         state = copy.deepcopy(self._state)
 
         self._normalize_stage_state(state.vs)
+        self._normalize_stage_state(state.tcs)
+        self._normalize_stage_state(state.tes)
         self._normalize_stage_state(state.gs)
         self._normalize_stage_state(state.fs)
 
@@ -673,10 +720,13 @@ class Context(Dispatcher):
     def clear(self, buffers, color, depth, stencil, scissor_state=None):
         pass
 
-    def clear_render_target(self, dst, rgba, dstx, dsty, width, height):
+    def clear_render_target(self, dst, rgba, dstx, dsty, width, height, render_condition_enabled):
         pass
 
-    def clear_depth_stencil(self, dst, clear_flags, depth, stencil, dstx, dsty, width, height):
+    def clear_depth_stencil(self, dst, clear_flags, depth, stencil, dstx, dsty, width, height, render_condition_enabled):
+        pass
+
+    def clear_texture(self, res, level, box, **color):
         pass
 
     def create_surface(self, resource, surf_tmpl):
@@ -715,12 +765,19 @@ class Interpreter(parser.SimpleTraceDumper):
             ('pipe_screen', 'is_format_supported'),
             ('pipe_screen', 'get_name'),
             ('pipe_screen', 'get_vendor'),
+            ('pipe_screen', 'get_device_uuid'),
+            ('pipe_screen', 'get_driver_uuid'),
+            ('pipe_screen', 'get_compiler_options'),
             ('pipe_screen', 'get_param'),
             ('pipe_screen', 'get_paramf'),
             ('pipe_screen', 'get_shader_param'),
+            ('pipe_screen', 'get_compute_param'),
             ('pipe_screen', 'get_disk_shader_cache'),
             ('pipe_context', 'clear_render_target'), # XXX workaround trace bugs
             ('pipe_context', 'flush_resource'),
+            ('pipe_context', 'buffer_map'),
+            ('pipe_context', 'texture_map'),
+            ('pipe_context', 'transfer_unmap'),
     ))
 
     def __init__(self, stream, options, formatter):