intel: aubinator_viewer: store urb state during decoding

Signed-off-by: Lionel Landwerlin <[email protected]>
Reviewed-by: Rafael Antognolli <[email protected]>

2 files changed, 153 insertions, 23 deletions

diff --git a/src/intel/tools/aubinator_viewer.h b/src/intel/tools/aubinator_viewer.h
index 2d89d9cf658..4a030efc0d0 100644
--- a/src/intel/tools/aubinator_viewer.h
+++ b/src/intel/tools/aubinator_viewer.h
@@ -33,12 +33,35 @@ struct aub_viewer_decode_cfg {
     show_dwords(true) {}
 };
 
+enum aub_decode_stage {
+   AUB_DECODE_STAGE_VS,
+   AUB_DECODE_STAGE_HS,
+   AUB_DECODE_STAGE_DS,
+   AUB_DECODE_STAGE_GS,
+   AUB_DECODE_STAGE_PS,
+   AUB_DECODE_STAGE_CS,
+   AUB_DECODE_N_STAGE,
+};
+
+struct aub_decode_urb_stage_state {
+   uint32_t start;
+   uint32_t size;
+   uint32_t n_entries;
+
+   uint32_t const_rd_length;
+   uint32_t rd_offset;
+   uint32_t rd_length;
+   uint32_t wr_offset;
+   uint32_t wr_length;
+};
+
 struct aub_viewer_decode_ctx {
    struct gen_batch_decode_bo (*get_bo)(void *user_data, uint64_t address);
    unsigned (*get_state_size)(void *user_data,
                               uint32_t offset_from_dynamic_state_base_addr);
 
    void (*display_shader)(void *user_data, const char *shader_desc, uint64_t address);
+   void (*display_urb)(void *user_data, const struct aub_decode_urb_stage_state *stages);
    void (*edit_address)(void *user_data, uint64_t address, uint32_t length);
 
    void *user_data;
@@ -53,6 +76,9 @@ struct aub_viewer_decode_ctx {
    uint64_t dynamic_base;
    uint64_t instruction_base;
 
+   enum aub_decode_stage stage;
+   uint32_t end_urb_offset;
+   struct aub_decode_urb_stage_state urb_stages[AUB_DECODE_N_STAGE];
 };
 
 void aub_viewer_decode_ctx_init(struct aub_viewer_decode_ctx *ctx,
diff --git a/src/intel/tools/aubinator_viewer_decoder.cpp b/src/intel/tools/aubinator_viewer_decoder.cpp
index a2ea3ba4a64..273bc2da376 100644
--- a/src/intel/tools/aubinator_viewer_decoder.cpp
+++ b/src/intel/tools/aubinator_viewer_decoder.cpp
@@ -695,38 +695,125 @@ decode_load_register_imm(struct aub_viewer_decode_ctx *ctx,
    }
 }
 
+static void
+decode_3dprimitive(struct aub_viewer_decode_ctx *ctx,
+                   struct gen_group *inst,
+                   const uint32_t *p)
+{
+   if (ctx->display_urb) {
+      if (ImGui::Button("Show URB"))
+         ctx->display_urb(ctx->user_data, ctx->urb_stages);
+   }
+}
+
+static void
+handle_urb(struct aub_viewer_decode_ctx *ctx,
+           struct gen_group *inst,
+           const uint32_t *p)
+{
+   struct gen_field_iterator iter;
+   gen_field_iterator_init(&iter, inst, p, 0, false);
+   while (gen_field_iterator_next(&iter)) {
+      if (strstr(iter.name, "URB Starting Address")) {
+         ctx->urb_stages[ctx->stage].start = iter.raw_value * 8192;
+      } else if (strstr(iter.name, "URB Entry Allocation Size")) {
+         ctx->urb_stages[ctx->stage].size = (iter.raw_value + 1) * 64;
+      } else if (strstr(iter.name, "Number of URB Entries")) {
+         ctx->urb_stages[ctx->stage].n_entries = iter.raw_value;
+      }
+   }
+
+   ctx->end_urb_offset = MAX2(ctx->urb_stages[ctx->stage].start +
+                              ctx->urb_stages[ctx->stage].n_entries *
+                              ctx->urb_stages[ctx->stage].size,
+                              ctx->end_urb_offset);
+}
+
+static void
+handle_urb_read(struct aub_viewer_decode_ctx *ctx,
+                struct gen_group *inst,
+                const uint32_t *p)
+{
+   struct gen_field_iterator iter;
+   gen_field_iterator_init(&iter, inst, p, 0, false);
+   while (gen_field_iterator_next(&iter)) {
+      /* Workaround the "Force * URB Entry Read Length" fields */
+      if (iter.end_bit - iter.start_bit < 2)
+         continue;
+
+      if (strstr(iter.name, "URB Entry Read Offset")) {
+         ctx->urb_stages[ctx->stage].rd_offset = iter.raw_value * 32;
+      } else if (strstr(iter.name, "URB Entry Read Length")) {
+         ctx->urb_stages[ctx->stage].rd_length = iter.raw_value * 32;
+      } else if (strstr(iter.name, "URB Entry Output Read Offset")) {
+         ctx->urb_stages[ctx->stage].wr_offset = iter.raw_value * 32;
+      } else if (strstr(iter.name, "URB Entry Output Length")) {
+         ctx->urb_stages[ctx->stage].wr_length = iter.raw_value * 32;
+      }
+   }
+}
+
+static void
+handle_urb_constant(struct aub_viewer_decode_ctx *ctx,
+                    struct gen_group *inst,
+                    const uint32_t *p)
+{
+   struct gen_group *body =
+      gen_spec_find_struct(ctx->spec, "3DSTATE_CONSTANT_BODY");
+
+   struct gen_field_iterator outer;
+   gen_field_iterator_init(&outer, inst, p, 0, false);
+   while (gen_field_iterator_next(&outer)) {
+      if (outer.struct_desc != body)
+         continue;
+
+      struct gen_field_iterator iter;
+      gen_field_iterator_init(&iter, body, &outer.p[outer.start_bit / 32],
+                              0, false);
+
+      ctx->urb_stages[ctx->stage].const_rd_length = 0;
+      while (gen_field_iterator_next(&iter)) {
+         int idx;
+         if (sscanf(iter.name, "Read Length[%d]", &idx) == 1) {
+            ctx->urb_stages[ctx->stage].const_rd_length += iter.raw_value * 32;
+         }
+      }
+   }
+}
+
 struct custom_decoder {
    const char *cmd_name;
    void (*decode)(struct aub_viewer_decode_ctx *ctx,
                   struct gen_group *inst,
                   const uint32_t *p);
+   enum aub_decode_stage stage;
 } display_decoders[] = {
    { "STATE_BASE_ADDRESS", handle_state_base_address },
    { "MEDIA_INTERFACE_DESCRIPTOR_LOAD", handle_media_interface_descriptor_load },
    { "3DSTATE_VERTEX_BUFFERS", handle_3dstate_vertex_buffers },
    { "3DSTATE_INDEX_BUFFER", handle_3dstate_index_buffer },
-   { "3DSTATE_VS", decode_single_ksp },
-   { "3DSTATE_GS", decode_single_ksp },
-   { "3DSTATE_DS", decode_single_ksp },
-   { "3DSTATE_HS", decode_single_ksp },
-   { "3DSTATE_PS", decode_ps_kernels },
-   { "3DSTATE_CONSTANT_VS", decode_3dstate_constant },
-   { "3DSTATE_CONSTANT_GS", decode_3dstate_constant },
-   { "3DSTATE_CONSTANT_PS", decode_3dstate_constant },
-   { "3DSTATE_CONSTANT_HS", decode_3dstate_constant },
-   { "3DSTATE_CONSTANT_DS", decode_3dstate_constant },
-
-   { "3DSTATE_BINDING_TABLE_POINTERS_VS", decode_3dstate_binding_table_pointers },
-   { "3DSTATE_BINDING_TABLE_POINTERS_HS", decode_3dstate_binding_table_pointers },
-   { "3DSTATE_BINDING_TABLE_POINTERS_DS", decode_3dstate_binding_table_pointers },
-   { "3DSTATE_BINDING_TABLE_POINTERS_GS", decode_3dstate_binding_table_pointers },
-   { "3DSTATE_BINDING_TABLE_POINTERS_PS", decode_3dstate_binding_table_pointers },
-
-   { "3DSTATE_SAMPLER_STATE_POINTERS_VS", decode_3dstate_sampler_state_pointers },
-   { "3DSTATE_SAMPLER_STATE_POINTERS_HS", decode_3dstate_sampler_state_pointers },
-   { "3DSTATE_SAMPLER_STATE_POINTERS_DS", decode_3dstate_sampler_state_pointers },
-   { "3DSTATE_SAMPLER_STATE_POINTERS_GS", decode_3dstate_sampler_state_pointers },
-   { "3DSTATE_SAMPLER_STATE_POINTERS_PS", decode_3dstate_sampler_state_pointers },
+   { "3DSTATE_VS", decode_single_ksp, AUB_DECODE_STAGE_VS, },
+   { "3DSTATE_GS", decode_single_ksp, AUB_DECODE_STAGE_GS, },
+   { "3DSTATE_DS", decode_single_ksp, AUB_DECODE_STAGE_DS, },
+   { "3DSTATE_HS", decode_single_ksp, AUB_DECODE_STAGE_HS, },
+   { "3DSTATE_PS", decode_ps_kernels, AUB_DECODE_STAGE_PS, },
+   { "3DSTATE_CONSTANT_VS", decode_3dstate_constant, AUB_DECODE_STAGE_VS, },
+   { "3DSTATE_CONSTANT_GS", decode_3dstate_constant, AUB_DECODE_STAGE_GS, },
+   { "3DSTATE_CONSTANT_DS", decode_3dstate_constant, AUB_DECODE_STAGE_DS, },
+   { "3DSTATE_CONSTANT_HS", decode_3dstate_constant, AUB_DECODE_STAGE_HS, },
+   { "3DSTATE_CONSTANT_PS", decode_3dstate_constant, AUB_DECODE_STAGE_PS, },
+
+   { "3DSTATE_BINDING_TABLE_POINTERS_VS", decode_3dstate_binding_table_pointers, AUB_DECODE_STAGE_VS, },
+   { "3DSTATE_BINDING_TABLE_POINTERS_GS", decode_3dstate_binding_table_pointers, AUB_DECODE_STAGE_GS, },
+   { "3DSTATE_BINDING_TABLE_POINTERS_HS", decode_3dstate_binding_table_pointers, AUB_DECODE_STAGE_HS, },
+   { "3DSTATE_BINDING_TABLE_POINTERS_DS", decode_3dstate_binding_table_pointers, AUB_DECODE_STAGE_DS, },
+   { "3DSTATE_BINDING_TABLE_POINTERS_PS", decode_3dstate_binding_table_pointers, AUB_DECODE_STAGE_PS, },
+
+   { "3DSTATE_SAMPLER_STATE_POINTERS_VS", decode_3dstate_sampler_state_pointers, AUB_DECODE_STAGE_VS, },
+   { "3DSTATE_SAMPLER_STATE_POINTERS_GS", decode_3dstate_sampler_state_pointers, AUB_DECODE_STAGE_GS, },
+   { "3DSTATE_SAMPLER_STATE_POINTERS_DS", decode_3dstate_sampler_state_pointers, AUB_DECODE_STAGE_DS, },
+   { "3DSTATE_SAMPLER_STATE_POINTERS_HS", decode_3dstate_sampler_state_pointers, AUB_DECODE_STAGE_HS, },
+   { "3DSTATE_SAMPLER_STATE_POINTERS_PS", decode_3dstate_sampler_state_pointers, AUB_DECODE_STAGE_PS, },
    { "3DSTATE_SAMPLER_STATE_POINTERS", decode_3dstate_sampler_state_pointers_gen6 },
 
    { "3DSTATE_VIEWPORT_STATE_POINTERS_CC", decode_3dstate_viewport_state_pointers_cc },
@@ -734,11 +821,26 @@ struct custom_decoder {
    { "3DSTATE_BLEND_STATE_POINTERS", decode_3dstate_blend_state_pointers },
    { "3DSTATE_CC_STATE_POINTERS", decode_3dstate_cc_state_pointers },
    { "3DSTATE_SCISSOR_STATE_POINTERS", decode_3dstate_scissor_state_pointers },
-   { "MI_LOAD_REGISTER_IMM", decode_load_register_imm }
+   { "MI_LOAD_REGISTER_IMM", decode_load_register_imm },
+   { "3DPRIMITIVE", decode_3dprimitive },
 };
 
 struct custom_decoder info_decoders[] = {
    { "STATE_BASE_ADDRESS", handle_state_base_address },
+   { "3DSTATE_URB_VS", handle_urb, AUB_DECODE_STAGE_VS, },
+   { "3DSTATE_URB_GS", handle_urb, AUB_DECODE_STAGE_GS, },
+   { "3DSTATE_URB_DS", handle_urb, AUB_DECODE_STAGE_DS, },
+   { "3DSTATE_URB_HS", handle_urb, AUB_DECODE_STAGE_HS, },
+   { "3DSTATE_VS", handle_urb_read, AUB_DECODE_STAGE_VS, },
+   { "3DSTATE_GS", handle_urb_read, AUB_DECODE_STAGE_GS, },
+   { "3DSTATE_DS", handle_urb_read, AUB_DECODE_STAGE_DS, },
+   { "3DSTATE_HS", handle_urb_read, AUB_DECODE_STAGE_HS, },
+   { "3DSTATE_PS", handle_urb_read, AUB_DECODE_STAGE_PS, },
+   { "3DSTATE_CONSTANT_VS", handle_urb_constant, AUB_DECODE_STAGE_VS, },
+   { "3DSTATE_CONSTANT_GS", handle_urb_constant, AUB_DECODE_STAGE_GS, },
+   { "3DSTATE_CONSTANT_DS", handle_urb_constant, AUB_DECODE_STAGE_DS, },
+   { "3DSTATE_CONSTANT_HS", handle_urb_constant, AUB_DECODE_STAGE_HS, },
+   { "3DSTATE_CONSTANT_PS", handle_urb_constant, AUB_DECODE_STAGE_PS, },
 };
 
 static inline uint64_t
@@ -790,6 +892,7 @@ aub_viewer_render_batch(struct aub_viewer_decode_ctx *ctx,
 
       for (unsigned i = 0; i < ARRAY_SIZE(info_decoders); i++) {
          if (strcmp(inst_name, info_decoders[i].cmd_name) == 0) {
+            ctx->stage = info_decoders[i].stage;
             info_decoders[i].decode(ctx, inst, p);
             break;
          }
@@ -804,6 +907,7 @@ aub_viewer_render_batch(struct aub_viewer_decode_ctx *ctx,
 
          for (unsigned i = 0; i < ARRAY_SIZE(display_decoders); i++) {
             if (strcmp(inst_name, display_decoders[i].cmd_name) == 0) {
+               ctx->stage = display_decoders[i].stage;
                display_decoders[i].decode(ctx, inst, p);
                break;
             }