src/amd/vulkan/layers/radv_sqtt_layer.c

   1 /*
   2  * Copyright © 2020 Valve Corporation
   3  *
   4  * Permission is hereby granted, free of charge, to any person obtaining a
   5  * copy of this software and associated documentation files (the "Software"),
   6  * to deal in the Software without restriction, including without limitation
   7  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   8  * and/or sell copies of the Software, and to permit persons to whom the
   9  * Software is furnished to do so, subject to the following conditions:
  10  *
  11  * The above copyright notice and this permission notice (including the next
  12  * paragraph) shall be included in all copies or substantial portions of the
  13  * Software.
  14  *
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  18  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  19  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  20  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
  21  * IN THE SOFTWARE.
  22  */
  23
  24 #include "radv_private.h"
  25
  26 /**
  27  * Identifiers for RGP SQ thread-tracing markers (Table 1)
  28  */
  29 enum rgp_sqtt_marker_identifier {
  30         RGP_SQTT_MARKER_IDENTIFIER_EVENT                = 0x0,
  31         RGP_SQTT_MARKER_IDENTIFIER_CB_START             = 0x1,
  32         RGP_SQTT_MARKER_IDENTIFIER_CB_END               = 0x2,
  33         RGP_SQTT_MARKER_IDENTIFIER_BARRIER_START        = 0x3,
  34         RGP_SQTT_MARKER_IDENTIFIER_BARRIER_END          = 0x4,
  35         RGP_SQTT_MARKER_IDENTIFIER_USER_EVENT           = 0x5,
  36         RGP_SQTT_MARKER_IDENTIFIER_GENERAL_API          = 0x6,
  37         RGP_SQTT_MARKER_IDENTIFIER_SYNC                 = 0x7,
  38         RGP_SQTT_MARKER_IDENTIFIER_PRESENT              = 0x8,
  39         RGP_SQTT_MARKER_IDENTIFIER_LAYOUT_TRANSITION    = 0x9,
  40         RGP_SQTT_MARKER_IDENTIFIER_RENDER_PASS          = 0xA,
  41         RGP_SQTT_MARKER_IDENTIFIER_RESERVED2            = 0xB,
  42         RGP_SQTT_MARKER_IDENTIFIER_BIND_PIPELINE        = 0xC,
  43         RGP_SQTT_MARKER_IDENTIFIER_RESERVED4            = 0xD,
  44         RGP_SQTT_MARKER_IDENTIFIER_RESERVED5            = 0xE,
  45         RGP_SQTT_MARKER_IDENTIFIER_RESERVED6            = 0xF
  46 };
  47
  48 /**
  49  * RGP SQ thread-tracing marker for the start of a command buffer. (Table 2)
  50  */
  51 struct rgp_sqtt_marker_cb_start {
  52         union {
  53                 struct {
  54                         uint32_t identifier : 4;
  55                         uint32_t ext_dwords : 3;
  56                         uint32_t cb_id : 20;
  57                         uint32_t queue : 5;
  58                 };
  59                 uint32_t dword01;
  60         };
  61         union {
  62                 uint32_t device_id_low;
  63                 uint32_t dword02;
  64         };
  65         union {
  66                 uint32_t device_id_high;
  67                 uint32_t dword03;
  68         };
  69         union {
  70                 uint32_t queue_flags;
  71                 uint32_t dword04;
  72         };
  73 };
  74
  75 static_assert(sizeof(struct rgp_sqtt_marker_cb_start) == 16,
  76               "rgp_sqtt_marker_cb_start doesn't match RGP spec");
  77
  78 /**
  79  *
  80  * RGP SQ thread-tracing marker for the end of a command buffer. (Table 3)
  81  */
  82 struct rgp_sqtt_marker_cb_end {
  83         union {
  84                 struct {
  85                         uint32_t identifier : 4;
  86                         uint32_t ext_dwords : 3;
  87                         uint32_t cb_id : 20;
  88                         uint32_t reserved : 5;
  89                 };
  90                 uint32_t dword01;
  91         };
  92         union {
  93                 uint32_t device_id_low;
  94                 uint32_t dword02;
  95         };
  96         union {
  97                 uint32_t device_id_high;
  98                 uint32_t dword03;
  99         };
 100 };
 101
 102 static_assert(sizeof(struct rgp_sqtt_marker_cb_end) == 12,
 103               "rgp_sqtt_marker_cb_end doesn't match RGP spec");
 104
 105 /**
 106  * API types used in RGP SQ thread-tracing markers for the "General API"
 107  * packet.
 108  */
 109 enum rgp_sqtt_marker_general_api_type {
 110         ApiCmdBindPipeline                     = 0,
 111         ApiCmdBindDescriptorSets               = 1,
 112         ApiCmdBindIndexBuffer                  = 2,
 113         ApiCmdBindVertexBuffers                = 3,
 114         ApiCmdDraw                             = 4,
 115         ApiCmdDrawIndexed                      = 5,
 116         ApiCmdDrawIndirect                     = 6,
 117         ApiCmdDrawIndexedIndirect              = 7,
 118         ApiCmdDrawIndirectCountAMD             = 8,
 119         ApiCmdDrawIndexedIndirectCountAMD      = 9,
 120         ApiCmdDispatch                         = 10,
 121         ApiCmdDispatchIndirect                 = 11,
 122         ApiCmdCopyBuffer                       = 12,
 123         ApiCmdCopyImage                        = 13,
 124         ApiCmdBlitImage                        = 14,
 125         ApiCmdCopyBufferToImage                = 15,
 126         ApiCmdCopyImageToBuffer                = 16,
 127         ApiCmdUpdateBuffer                     = 17,
 128         ApiCmdFillBuffer                       = 18,
 129         ApiCmdClearColorImage                  = 19,
 130         ApiCmdClearDepthStencilImage           = 20,
 131         ApiCmdClearAttachments                 = 21,
 132         ApiCmdResolveImage                     = 22,
 133         ApiCmdWaitEvents                       = 23,
 134         ApiCmdPipelineBarrier                  = 24,
 135         ApiCmdBeginQuery                       = 25,
 136         ApiCmdEndQuery                         = 26,
 137         ApiCmdResetQueryPool                   = 27,
 138         ApiCmdWriteTimestamp                   = 28,
 139         ApiCmdCopyQueryPoolResults             = 29,
 140         ApiCmdPushConstants                    = 30,
 141         ApiCmdBeginRenderPass                  = 31,
 142         ApiCmdNextSubpass                      = 32,
 143         ApiCmdEndRenderPass                    = 33,
 144         ApiCmdExecuteCommands                  = 34,
 145         ApiCmdSetViewport                      = 35,
 146         ApiCmdSetScissor                       = 36,
 147         ApiCmdSetLineWidth                     = 37,
 148         ApiCmdSetDepthBias                     = 38,
 149         ApiCmdSetBlendConstants                = 39,
 150         ApiCmdSetDepthBounds                   = 40,
 151         ApiCmdSetStencilCompareMask            = 41,
 152         ApiCmdSetStencilWriteMask              = 42,
 153         ApiCmdSetStencilReference              = 43,
 154         ApiCmdDrawIndirectCount                = 44,
 155         ApiCmdDrawIndexedIndirectCount         = 45,
 156         ApiInvalid                             = 0xffffffff
 157 };
 158
 159 /**
 160  * RGP SQ thread-tracing marker for a "General API" instrumentation packet.
 161  */
 162 struct rgp_sqtt_marker_general_api {
 163         union {
 164                 struct {
 165                         uint32_t identifier : 4;
 166                         uint32_t ext_dwords : 3;
 167                         uint32_t api_type : 20;
 168                         uint32_t is_end : 1;
 169                         uint32_t reserved : 4;
 170                 };
 171                 uint32_t dword01;
 172         };
 173 };
 174
 175 static_assert(sizeof(struct rgp_sqtt_marker_general_api) == 4,
 176               "rgp_sqtt_marker_general_api doesn't match RGP spec");
 177
 178 /**
 179  * API types used in RGP SQ thread-tracing markers (Table 16).
 180  */
 181 enum rgp_sqtt_marker_event_type {
 182         EventCmdDraw                             = 0,
 183         EventCmdDrawIndexed                      = 1,
 184         EventCmdDrawIndirect                     = 2,
 185         EventCmdDrawIndexedIndirect              = 3,
 186         EventCmdDrawIndirectCountAMD             = 4,
 187         EventCmdDrawIndexedIndirectCountAMD      = 5,
 188         EventCmdDispatch                         = 6,
 189         EventCmdDispatchIndirect                 = 7,
 190         EventCmdCopyBuffer                       = 8,
 191         EventCmdCopyImage                        = 9,
 192         EventCmdBlitImage                        = 10,
 193         EventCmdCopyBufferToImage                = 11,
 194         EventCmdCopyImageToBuffer                = 12,
 195         EventCmdUpdateBuffer                     = 13,
 196         EventCmdFillBuffer                       = 14,
 197         EventCmdClearColorImage                  = 15,
 198         EventCmdClearDepthStencilImage           = 16,
 199         EventCmdClearAttachments                 = 17,
 200         EventCmdResolveImage                     = 18,
 201         EventCmdWaitEvents                       = 19,
 202         EventCmdPipelineBarrier                  = 20,
 203         EventCmdResetQueryPool                   = 21,
 204         EventCmdCopyQueryPoolResults             = 22,
 205         EventRenderPassColorClear                = 23,
 206         EventRenderPassDepthStencilClear         = 24,
 207         EventRenderPassResolve                   = 25,
 208         EventInternalUnknown                     = 26,
 209         EventCmdDrawIndirectCount                = 27,
 210         EventCmdDrawIndexedIndirectCount         = 28,
 211         EventInvalid                             = 0xffffffff
 212 };
 213
 214 /**
 215  * "Event (Per-draw/dispatch)" RGP SQ thread-tracing marker. (Table 4)
 216  */
 217 struct rgp_sqtt_marker_event {
 218         union {
 219                 struct {
 220                         uint32_t identifier : 4;
 221                         uint32_t ext_dwords : 3;
 222                         uint32_t api_type : 24;
 223                         uint32_t has_thread_dims : 1;
 224                 };
 225                 uint32_t dword01;
 226         };
 227         union {
 228                 struct {
 229                         uint32_t cb_id : 20;
 230                         uint32_t vertex_offset_reg_idx : 4;
 231                         uint32_t instance_offset_reg_idx : 4;
 232                         uint32_t draw_index_reg_idx : 4;
 233                 };
 234                 uint32_t dword02;
 235         };
 236         union {
 237                 uint32_t cmd_id;
 238                 uint32_t dword03;
 239         };
 240 };
 241
 242 static_assert(sizeof(struct rgp_sqtt_marker_event) == 12,
 243               "rgp_sqtt_marker_event doesn't match RGP spec");
 244
 245 /**
 246  * Per-dispatch specific marker where workgroup dims are included.
 247  */
 248 struct rgp_sqtt_marker_event_with_dims {
 249         struct rgp_sqtt_marker_event event;
 250         uint32_t thread_x;
 251         uint32_t thread_y;
 252         uint32_t thread_z;
 253 };
 254
 255 static_assert(sizeof(struct rgp_sqtt_marker_event_with_dims) == 24,
 256               "rgp_sqtt_marker_event_with_dims doesn't match RGP spec");
 257
 258 /**
 259  * "Barrier Start" RGP SQTT instrumentation marker (Table 5)
 260  */
 261 struct rgp_sqtt_marker_barrier_start {
 262         union {
 263                 struct {
 264                         uint32_t identifier : 4;
 265                         uint32_t ext_dwords : 3;
 266                         uint32_t cb_id : 20;
 267                         uint32_t reserved : 5;
 268                 };
 269                 uint32_t dword01;
 270         };
 271         union {
 272                 struct {
 273                         uint32_t driver_reason : 31;
 274                         uint32_t internal : 1;
 275                 };
 276                 uint32_t dword02;
 277         };
 278 };
 279
 280 static_assert(sizeof(struct rgp_sqtt_marker_barrier_start) == 8,
 281               "rgp_sqtt_marker_barrier_start doesn't match RGP spec");
 282
 283 /**
 284  * "Barrier End" RGP SQTT instrumentation marker (Table 6)
 285  */
 286 struct rgp_sqtt_marker_barrier_end {
 287         union {
 288                 struct {
 289                         uint32_t identifier : 4;
 290                         uint32_t ext_dwords : 3;
 291                         uint32_t cb_id : 20;
 292                         uint32_t wait_on_eop_ts : 1;
 293                         uint32_t vs_partial_flush : 1;
 294                         uint32_t ps_partial_flush : 1;
 295                         uint32_t cs_partial_flush : 1;
 296                         uint32_t pfp_sync_me : 1;
 297                 };
 298                 uint32_t dword01;
 299         };
 300         union {
 301                 struct {
 302                         uint32_t sync_cp_dma : 1;
 303                         uint32_t inval_ccp : 1;
 304                         uint32_t inval_sqI : 1;
 305                         uint32_t inval_sqK : 1;
 306                         uint32_t flush_tcc : 1;
 307                         uint32_t inval_tcc : 1;
 308                         uint32_t flush_cb : 1;
 309                         uint32_t inval_cb : 1;
 310                         uint32_t flush_db : 1;
 311                         uint32_t inval_db : 1;
 312                         uint32_t num_layout_transitions : 16;
 313                         uint32_t inval_gl1 : 1;
 314                         uint32_t reserved : 5;
 315                 };
 316                 uint32_t dword02;
 317         };
 318 };
 319
 320 static_assert(sizeof(struct rgp_sqtt_marker_barrier_end) == 8,
 321               "rgp_sqtt_marker_barrier_end doesn't match RGP spec");
 322
 323 /**
 324  * "Layout Transition" RGP SQTT instrumentation marker (Table 7)
 325  */
 326 struct rgp_sqtt_marker_layout_transition {
 327         union {
 328                 struct {
 329                         uint32_t identifier : 4;
 330                         uint32_t ext_dwords : 3;
 331                         uint32_t depth_stencil_expand : 1;
 332                         uint32_t htile_hiz_range_expand : 1;
 333                         uint32_t depth_stencil_resummarize : 1;
 334                         uint32_t dcc_decompress : 1;
 335                         uint32_t fmask_decompress : 1;
 336                         uint32_t fast_clear_eliminate : 1;
 337                         uint32_t fmask_color_expand : 1;
 338                         uint32_t init_mask_ram : 1;
 339                         uint32_t reserved1 : 17;
 340                 };
 341                 uint32_t dword01;
 342         };
 343         union {
 344                 struct {
 345                         uint32_t reserved2 : 32;
 346                 };
 347                 uint32_t dword02;
 348         };
 349 };
 350
 351 static_assert(sizeof(struct rgp_sqtt_marker_layout_transition) == 8,
 352               "rgp_sqtt_marker_layout_transition doesn't match RGP spec");
 353
 354 static void
 355 radv_write_begin_general_api_marker(struct radv_cmd_buffer *cmd_buffer,
 356                                     enum rgp_sqtt_marker_general_api_type api_type)
 357 {
 358         struct rgp_sqtt_marker_general_api marker = {};
 359         struct radeon_cmdbuf *cs = cmd_buffer->cs;
 360
 361         marker.identifier = RGP_SQTT_MARKER_IDENTIFIER_GENERAL_API;
 362         marker.api_type = api_type;
 363
 364         radv_emit_thread_trace_userdata(cs, &marker, sizeof(marker) / 4);
 365 }
 366
 367 static void
 368 radv_write_end_general_api_marker(struct radv_cmd_buffer *cmd_buffer,
 369                                   enum rgp_sqtt_marker_general_api_type api_type)
 370 {
 371         struct rgp_sqtt_marker_general_api marker = {};
 372         struct radeon_cmdbuf *cs = cmd_buffer->cs;
 373
 374         marker.identifier = RGP_SQTT_MARKER_IDENTIFIER_GENERAL_API;
 375         marker.api_type = api_type;
 376         marker.is_end = 1;
 377
 378         radv_emit_thread_trace_userdata(cs, &marker, sizeof(marker) / 4);
 379 }
 380
 381 static void
 382 radv_write_event_marker(struct radv_cmd_buffer *cmd_buffer,
 383                         enum rgp_sqtt_marker_event_type api_type,
 384                         uint32_t vertex_offset_user_data,
 385                         uint32_t instance_offset_user_data,
 386                         uint32_t draw_index_user_data)
 387 {
 388         struct rgp_sqtt_marker_event marker = {};
 389         struct radeon_cmdbuf *cs = cmd_buffer->cs;
 390
 391         marker.identifier = RGP_SQTT_MARKER_IDENTIFIER_EVENT;
 392         marker.api_type = api_type;
 393         marker.cmd_id = cmd_buffer->state.num_events++;
 394         marker.cb_id = 0;
 395
 396         if (vertex_offset_user_data == UINT_MAX ||
 397             instance_offset_user_data == UINT_MAX) {
 398                 vertex_offset_user_data = 0;
 399                 instance_offset_user_data = 0;
 400         }
 401
 402         if (draw_index_user_data == UINT_MAX)
 403                 draw_index_user_data = vertex_offset_user_data;
 404
 405         marker.vertex_offset_reg_idx = vertex_offset_user_data;
 406         marker.instance_offset_reg_idx = instance_offset_user_data;
 407         marker.draw_index_reg_idx = draw_index_user_data;
 408
 409         radv_emit_thread_trace_userdata(cs, &marker, sizeof(marker) / 4);
 410 }
 411
 412 static void
 413 radv_write_event_with_dims_marker(struct radv_cmd_buffer *cmd_buffer,
 414                                   enum rgp_sqtt_marker_event_type api_type,
 415                                   uint32_t x, uint32_t y, uint32_t z)
 416 {
 417         struct rgp_sqtt_marker_event_with_dims marker = {};
 418         struct radeon_cmdbuf *cs = cmd_buffer->cs;
 419
 420         marker.event.identifier = RGP_SQTT_MARKER_IDENTIFIER_EVENT;
 421         marker.event.api_type = api_type;
 422         marker.event.cmd_id = cmd_buffer->state.num_events++;
 423         marker.event.cb_id = 0;
 424         marker.event.has_thread_dims = 1;
 425
 426         marker.thread_x = x;
 427         marker.thread_y = y;
 428         marker.thread_z = z;
 429
 430         radv_emit_thread_trace_userdata(cs, &marker, sizeof(marker) / 4);
 431 }
 432
 433 void
 434 radv_describe_begin_cmd_buffer(struct radv_cmd_buffer *cmd_buffer)
 435 {
 436         uint64_t device_id = (uintptr_t)cmd_buffer->device;
 437         struct rgp_sqtt_marker_cb_start marker = {};
 438         struct radeon_cmdbuf *cs = cmd_buffer->cs;
 439
 440         if (likely(!cmd_buffer->device->thread_trace_bo))
 441                 return;
 442
 443         marker.identifier = RGP_SQTT_MARKER_IDENTIFIER_CB_START;
 444         marker.cb_id = 0;
 445         marker.device_id_low = device_id;
 446         marker.device_id_high = device_id >> 32;
 447         marker.queue = cmd_buffer->queue_family_index;
 448         marker.queue_flags = VK_QUEUE_COMPUTE_BIT |
 449                              VK_QUEUE_TRANSFER_BIT |
 450                              VK_QUEUE_SPARSE_BINDING_BIT;
 451
 452         if (cmd_buffer->queue_family_index == RADV_QUEUE_GENERAL)
 453                 marker.queue_flags |= VK_QUEUE_GRAPHICS_BIT;
 454
 455         radv_emit_thread_trace_userdata(cs, &marker, sizeof(marker) / 4);
 456 }
 457
 458 void
 459 radv_describe_end_cmd_buffer(struct radv_cmd_buffer *cmd_buffer)
 460 {
 461         uint64_t device_id = (uintptr_t)cmd_buffer->device;
 462         struct rgp_sqtt_marker_cb_end marker = {};
 463         struct radeon_cmdbuf *cs = cmd_buffer->cs;
 464
 465         if (likely(!cmd_buffer->device->thread_trace_bo))
 466                 return;
 467
 468         marker.identifier = RGP_SQTT_MARKER_IDENTIFIER_CB_END;
 469         marker.cb_id = 0;
 470         marker.device_id_low = device_id;
 471         marker.device_id_high = device_id >> 32;
 472
 473         radv_emit_thread_trace_userdata(cs, &marker, sizeof(marker) / 4);
 474 }
 475
 476 void
 477 radv_describe_draw(struct radv_cmd_buffer *cmd_buffer)
 478 {
 479         if (likely(!cmd_buffer->device->thread_trace_bo))
 480                 return;
 481
 482         radv_write_event_marker(cmd_buffer, cmd_buffer->state.current_event_type,
 483                                 UINT_MAX, UINT_MAX, UINT_MAX);
 484 }
 485
 486 void
 487 radv_describe_dispatch(struct radv_cmd_buffer *cmd_buffer, int x, int y, int z)
 488 {
 489         if (likely(!cmd_buffer->device->thread_trace_bo))
 490                 return;
 491
 492         radv_write_event_with_dims_marker(cmd_buffer,
 493                                           cmd_buffer->state.current_event_type,
 494                                           x, y, z);
 495 }
 496
 497 void
 498 radv_describe_begin_render_pass_clear(struct radv_cmd_buffer *cmd_buffer,
 499                                       VkImageAspectFlagBits aspects)
 500 {
 501         cmd_buffer->state.current_event_type = (aspects & VK_IMAGE_ASPECT_COLOR_BIT) ?
 502                 EventRenderPassColorClear : EventRenderPassDepthStencilClear;
 503 }
 504
 505 void
 506 radv_describe_end_render_pass_clear(struct radv_cmd_buffer *cmd_buffer)
 507 {
 508         cmd_buffer->state.current_event_type = EventInternalUnknown;
 509 }
 510
 511 void
 512 radv_describe_barrier_start(struct radv_cmd_buffer *cmd_buffer,
 513                            enum rgp_barrier_reason reason)
 514 {
 515         struct rgp_sqtt_marker_barrier_start marker = {};
 516         struct radeon_cmdbuf *cs = cmd_buffer->cs;
 517
 518         if (likely(!cmd_buffer->device->thread_trace_bo))
 519                 return;
 520
 521         marker.identifier = RGP_SQTT_MARKER_IDENTIFIER_BARRIER_START;
 522         marker.cb_id = 0;
 523         marker.dword02 = reason;
 524
 525         radv_emit_thread_trace_userdata(cs, &marker, sizeof(marker) / 4);
 526 }
 527
 528 void
 529 radv_describe_barrier_end(struct radv_cmd_buffer *cmd_buffer)
 530 {
 531         struct rgp_sqtt_marker_barrier_end marker = {};
 532         struct radeon_cmdbuf *cs = cmd_buffer->cs;
 533
 534         if (likely(!cmd_buffer->device->thread_trace_bo))
 535                 return;
 536
 537         marker.identifier = RGP_SQTT_MARKER_IDENTIFIER_BARRIER_END;
 538         marker.cb_id = 0;
 539
 540         marker.num_layout_transitions = cmd_buffer->state.num_layout_transitions;
 541
 542         /* TODO: fill pipeline stalls, cache flushes, etc */
 543
 544         radv_emit_thread_trace_userdata(cs, &marker, sizeof(marker) / 4);
 545
 546         cmd_buffer->state.num_layout_transitions = 0;
 547 }
 548
 549 void
 550 radv_describe_layout_transition(struct radv_cmd_buffer *cmd_buffer,
 551                                 const struct radv_barrier_data *barrier)
 552 {
 553         struct rgp_sqtt_marker_layout_transition marker = {};
 554         struct radeon_cmdbuf *cs = cmd_buffer->cs;
 555
 556         if (likely(!cmd_buffer->device->thread_trace_bo))
 557                 return;
 558
 559         marker.identifier = RGP_SQTT_MARKER_IDENTIFIER_LAYOUT_TRANSITION;
 560         marker.depth_stencil_expand = barrier->layout_transitions.depth_stencil_expand;
 561         marker.htile_hiz_range_expand = barrier->layout_transitions.htile_hiz_range_expand;
 562         marker.depth_stencil_resummarize = barrier->layout_transitions.depth_stencil_resummarize;
 563         marker.dcc_decompress = barrier->layout_transitions.dcc_decompress;
 564         marker.fmask_decompress = barrier->layout_transitions.fmask_decompress;
 565         marker.fast_clear_eliminate = barrier->layout_transitions.fast_clear_eliminate;
 566         marker.fmask_color_expand = barrier->layout_transitions.fmask_color_expand;
 567         marker.init_mask_ram = barrier->layout_transitions.init_mask_ram;
 568
 569         radv_emit_thread_trace_userdata(cs, &marker, sizeof(marker) / 4);
 570
 571         cmd_buffer->state.num_layout_transitions++;
 572 }
 573
 574 /* TODO: Improve the way to trigger capture (overlay, etc). */
 575 static void
 576 radv_handle_thread_trace(VkQueue _queue)
 577 {
 578         RADV_FROM_HANDLE(radv_queue, queue, _queue);
 579         static bool thread_trace_enabled = false;
 580         static uint64_t num_frames = 0;
 581
 582         if (thread_trace_enabled) {
 583                 struct radv_thread_trace thread_trace = {};
 584
 585                 radv_end_thread_trace(queue);
 586                 thread_trace_enabled = false;
 587
 588                 /* TODO: Do something better than this whole sync. */
 589                 radv_QueueWaitIdle(_queue);
 590
 591                 if (radv_get_thread_trace(queue, &thread_trace))
 592                         radv_dump_thread_trace(queue->device, &thread_trace);
 593         } else {
 594                 bool frame_trigger = num_frames == queue->device->thread_trace_start_frame;
 595                 bool file_trigger = false;
 596                 if (queue->device->thread_trace_trigger_file &&
 597                     access(queue->device->thread_trace_trigger_file, W_OK) == 0) {
 598                         if (unlink(queue->device->thread_trace_trigger_file) == 0) {
 599                                 file_trigger = true;
 600                         } else {
 601                                 /* Do not enable tracing if we cannot remove the file,
 602                                  * because by then we'll trace every frame ... */
 603                                 fprintf(stderr, "RADV: could not remove thread trace trigger file, ignoring\n");
 604                         }
 605                 }
 606
 607                 if (frame_trigger || file_trigger) {
 608                         radv_begin_thread_trace(queue);
 609                         assert(!thread_trace_enabled);
 610                         thread_trace_enabled = true;
 611                 }
 612         }
 613         num_frames++;
 614 }
 615
 616 VkResult sqtt_QueuePresentKHR(
 617         VkQueue                                  _queue,
 618         const VkPresentInfoKHR*                  pPresentInfo)
 619 {
 620         VkResult result;
 621
 622         result = radv_QueuePresentKHR(_queue, pPresentInfo);
 623         if (result != VK_SUCCESS)
 624                 return result;
 625
 626         radv_handle_thread_trace(_queue);
 627
 628         return VK_SUCCESS;
 629 }
 630
 631 #define EVENT_MARKER(cmd_name, args...) \
 632         RADV_FROM_HANDLE(radv_cmd_buffer, cmd_buffer, commandBuffer); \
 633         radv_write_begin_general_api_marker(cmd_buffer, ApiCmd##cmd_name); \
 634         cmd_buffer->state.current_event_type = EventCmd##cmd_name; \
 635         radv_Cmd##cmd_name(args); \
 636         cmd_buffer->state.current_event_type = EventInternalUnknown; \
 637         radv_write_end_general_api_marker(cmd_buffer, ApiCmd##cmd_name);
 638
 639 void sqtt_CmdDraw(
 640         VkCommandBuffer                             commandBuffer,
 641         uint32_t                                    vertexCount,
 642         uint32_t                                    instanceCount,
 643         uint32_t                                    firstVertex,
 644         uint32_t                                    firstInstance)
 645 {
 646         EVENT_MARKER(Draw, commandBuffer, vertexCount, instanceCount,
 647                      firstVertex, firstInstance);
 648 }
 649
 650 void sqtt_CmdDrawIndexed(
 651         VkCommandBuffer                             commandBuffer,
 652         uint32_t                                    indexCount,
 653         uint32_t                                    instanceCount,
 654         uint32_t                                    firstIndex,
 655         int32_t                                     vertexOffset,
 656         uint32_t                                    firstInstance)
 657 {
 658         EVENT_MARKER(DrawIndexed, commandBuffer, indexCount, instanceCount,
 659                      firstIndex, vertexOffset, firstInstance);
 660 }
 661
 662 void sqtt_CmdDrawIndirect(
 663         VkCommandBuffer                             commandBuffer,
 664         VkBuffer                                    buffer,
 665         VkDeviceSize                                offset,
 666         uint32_t                                    drawCount,
 667         uint32_t                                    stride)
 668 {
 669         EVENT_MARKER(DrawIndirect, commandBuffer, buffer, offset, drawCount,
 670                      stride);
 671 }
 672
 673 void sqtt_CmdDrawIndexedIndirect(
 674         VkCommandBuffer                             commandBuffer,
 675         VkBuffer                                    buffer,
 676         VkDeviceSize                                offset,
 677         uint32_t                                    drawCount,
 678         uint32_t                                    stride)
 679 {
 680         EVENT_MARKER(DrawIndexedIndirect, commandBuffer, buffer, offset,
 681                      drawCount, stride);
 682 }
 683
 684 void sqtt_CmdDrawIndirectCount(
 685         VkCommandBuffer                             commandBuffer,
 686         VkBuffer                                    buffer,
 687         VkDeviceSize                                offset,
 688         VkBuffer                                    countBuffer,
 689         VkDeviceSize                                countBufferOffset,
 690         uint32_t                                    maxDrawCount,
 691         uint32_t                                    stride)
 692 {
 693         EVENT_MARKER(DrawIndirectCount,commandBuffer, buffer, offset,
 694                      countBuffer, countBufferOffset, maxDrawCount, stride);
 695 }
 696
 697 void sqtt_CmdDrawIndexedIndirectCount(
 698         VkCommandBuffer                             commandBuffer,
 699         VkBuffer                                    buffer,
 700         VkDeviceSize                                offset,
 701         VkBuffer                                    countBuffer,
 702         VkDeviceSize                                countBufferOffset,
 703         uint32_t                                    maxDrawCount,
 704         uint32_t                                    stride)
 705 {
 706         EVENT_MARKER(DrawIndexedIndirectCount, commandBuffer, buffer, offset,
 707                      countBuffer, countBufferOffset, maxDrawCount, stride);
 708 }
 709
 710 void sqtt_CmdDispatch(
 711         VkCommandBuffer                             commandBuffer,
 712         uint32_t                                    x,
 713         uint32_t                                    y,
 714         uint32_t                                    z)
 715 {
 716         EVENT_MARKER(Dispatch, commandBuffer, x, y, z);
 717 }
 718
 719 void sqtt_CmdDispatchIndirect(
 720         VkCommandBuffer                             commandBuffer,
 721         VkBuffer                                    buffer,
 722         VkDeviceSize                                offset)
 723 {
 724         EVENT_MARKER(DispatchIndirect, commandBuffer, buffer, offset);
 725 }
 726
 727 void sqtt_CmdCopyBuffer(
 728         VkCommandBuffer                             commandBuffer,
 729         VkBuffer                                    srcBuffer,
 730         VkBuffer                                    destBuffer,
 731         uint32_t                                    regionCount,
 732         const VkBufferCopy*                         pRegions)
 733 {
 734         EVENT_MARKER(CopyBuffer, commandBuffer, srcBuffer, destBuffer,
 735                      regionCount, pRegions);
 736 }
 737
 738 void sqtt_CmdFillBuffer(
 739         VkCommandBuffer                             commandBuffer,
 740         VkBuffer                                    dstBuffer,
 741         VkDeviceSize                                dstOffset,
 742         VkDeviceSize                                fillSize,
 743         uint32_t                                    data)
 744 {
 745         EVENT_MARKER(FillBuffer, commandBuffer, dstBuffer, dstOffset, fillSize,
 746                      data);
 747 }
 748
 749 void sqtt_CmdUpdateBuffer(
 750         VkCommandBuffer                             commandBuffer,
 751         VkBuffer                                    dstBuffer,
 752         VkDeviceSize                                dstOffset,
 753         VkDeviceSize                                dataSize,
 754         const void*                                 pData)
 755 {
 756         EVENT_MARKER(UpdateBuffer, commandBuffer, dstBuffer, dstOffset,
 757                      dataSize, pData);
 758 }
 759
 760 void sqtt_CmdCopyImage(
 761         VkCommandBuffer                             commandBuffer,
 762         VkImage                                     srcImage,
 763         VkImageLayout                               srcImageLayout,
 764         VkImage                                     destImage,
 765         VkImageLayout                               destImageLayout,
 766         uint32_t                                    regionCount,
 767         const VkImageCopy*                          pRegions)
 768 {
 769         EVENT_MARKER(CopyImage, commandBuffer, srcImage, srcImageLayout,
 770                      destImage, destImageLayout, regionCount, pRegions);
 771 }
 772
 773 void sqtt_CmdCopyBufferToImage(
 774         VkCommandBuffer                             commandBuffer,
 775         VkBuffer                                    srcBuffer,
 776         VkImage                                     destImage,
 777         VkImageLayout                               destImageLayout,
 778         uint32_t                                    regionCount,
 779         const VkBufferImageCopy*                    pRegions)
 780 {
 781         EVENT_MARKER(CopyBufferToImage, commandBuffer, srcBuffer, destImage,
 782                      destImageLayout, regionCount, pRegions);
 783 }
 784
 785 void sqtt_CmdCopyImageToBuffer(
 786         VkCommandBuffer                             commandBuffer,
 787         VkImage                                     srcImage,
 788         VkImageLayout                               srcImageLayout,
 789         VkBuffer                                    destBuffer,
 790         uint32_t                                    regionCount,
 791         const VkBufferImageCopy*                    pRegions)
 792 {
 793         EVENT_MARKER(CopyImageToBuffer, commandBuffer, srcImage, srcImageLayout,
 794                      destBuffer, regionCount, pRegions);
 795 }
 796
 797 void sqtt_CmdBlitImage(
 798         VkCommandBuffer                             commandBuffer,
 799         VkImage                                     srcImage,
 800         VkImageLayout                               srcImageLayout,
 801         VkImage                                     destImage,
 802         VkImageLayout                               destImageLayout,
 803         uint32_t                                    regionCount,
 804         const VkImageBlit*                          pRegions,
 805         VkFilter                                    filter)
 806 {
 807         EVENT_MARKER(BlitImage, commandBuffer, srcImage, srcImageLayout,
 808                      destImage, destImageLayout, regionCount, pRegions, filter);
 809 }
 810
 811 void sqtt_CmdClearColorImage(
 812         VkCommandBuffer                             commandBuffer,
 813         VkImage                                     image_h,
 814         VkImageLayout                               imageLayout,
 815         const VkClearColorValue*                    pColor,
 816         uint32_t                                    rangeCount,
 817         const VkImageSubresourceRange*              pRanges)
 818 {
 819         EVENT_MARKER(ClearColorImage, commandBuffer, image_h, imageLayout,
 820                      pColor, rangeCount, pRanges);
 821 }
 822
 823 void sqtt_CmdClearDepthStencilImage(
 824         VkCommandBuffer                             commandBuffer,
 825         VkImage                                     image_h,
 826         VkImageLayout                               imageLayout,
 827         const VkClearDepthStencilValue*             pDepthStencil,
 828         uint32_t                                    rangeCount,
 829         const VkImageSubresourceRange*              pRanges)
 830 {
 831         EVENT_MARKER(ClearDepthStencilImage, commandBuffer, image_h,
 832                      imageLayout, pDepthStencil, rangeCount, pRanges);
 833 }
 834
 835 void sqtt_CmdClearAttachments(
 836         VkCommandBuffer                             commandBuffer,
 837         uint32_t                                    attachmentCount,
 838         const VkClearAttachment*                    pAttachments,
 839         uint32_t                                    rectCount,
 840         const VkClearRect*                          pRects)
 841 {
 842         EVENT_MARKER(ClearAttachments, commandBuffer, attachmentCount,
 843                      pAttachments, rectCount, pRects);
 844 }
 845
 846 void sqtt_CmdResolveImage(
 847         VkCommandBuffer                             commandBuffer,
 848         VkImage                                     src_image_h,
 849         VkImageLayout                               src_image_layout,
 850         VkImage                                     dest_image_h,
 851         VkImageLayout                               dest_image_layout,
 852         uint32_t                                    region_count,
 853         const VkImageResolve*                       regions)
 854 {
 855         EVENT_MARKER(ResolveImage, commandBuffer, src_image_h, src_image_layout,
 856                      dest_image_h, dest_image_layout, region_count, regions);
 857 }
 858
 859 void sqtt_CmdWaitEvents(VkCommandBuffer commandBuffer,
 860                         uint32_t eventCount,
 861                         const VkEvent* pEvents,
 862                         VkPipelineStageFlags srcStageMask,
 863                         VkPipelineStageFlags dstStageMask,
 864                         uint32_t memoryBarrierCount,
 865                         const VkMemoryBarrier* pMemoryBarriers,
 866                         uint32_t bufferMemoryBarrierCount,
 867                         const VkBufferMemoryBarrier* pBufferMemoryBarriers,
 868                         uint32_t imageMemoryBarrierCount,
 869                         const VkImageMemoryBarrier* pImageMemoryBarriers)
 870 {
 871         EVENT_MARKER(WaitEvents, commandBuffer, eventCount, pEvents,
 872                      srcStageMask, dstStageMask, memoryBarrierCount,
 873                      pMemoryBarriers, bufferMemoryBarrierCount,
 874                      pBufferMemoryBarriers, imageMemoryBarrierCount,
 875                      pImageMemoryBarriers);
 876 }
 877
 878 void sqtt_CmdPipelineBarrier(
 879         VkCommandBuffer                             commandBuffer,
 880         VkPipelineStageFlags                        srcStageMask,
 881         VkPipelineStageFlags                        destStageMask,
 882         VkBool32                                    byRegion,
 883         uint32_t                                    memoryBarrierCount,
 884         const VkMemoryBarrier*                      pMemoryBarriers,
 885         uint32_t                                    bufferMemoryBarrierCount,
 886         const VkBufferMemoryBarrier*                pBufferMemoryBarriers,
 887         uint32_t                                    imageMemoryBarrierCount,
 888         const VkImageMemoryBarrier*                 pImageMemoryBarriers)
 889 {
 890         EVENT_MARKER(PipelineBarrier, commandBuffer, srcStageMask,
 891                      destStageMask, byRegion, memoryBarrierCount,
 892                      pMemoryBarriers, bufferMemoryBarrierCount,
 893                      pBufferMemoryBarriers, imageMemoryBarrierCount,
 894                      pImageMemoryBarriers);
 895 }
 896
 897 void sqtt_CmdResetQueryPool(
 898         VkCommandBuffer                             commandBuffer,
 899         VkQueryPool                                 queryPool,
 900         uint32_t                                    firstQuery,
 901         uint32_t                                    queryCount)
 902 {
 903         EVENT_MARKER(ResetQueryPool, commandBuffer, queryPool, firstQuery,
 904                      queryCount);
 905 }
 906
 907 void sqtt_CmdCopyQueryPoolResults(
 908         VkCommandBuffer                             commandBuffer,
 909         VkQueryPool                                 queryPool,
 910         uint32_t                                    firstQuery,
 911         uint32_t                                    queryCount,
 912         VkBuffer                                    dstBuffer,
 913         VkDeviceSize                                dstOffset,
 914         VkDeviceSize                                stride,
 915         VkQueryResultFlags                          flags)
 916 {
 917         EVENT_MARKER(CopyQueryPoolResults, commandBuffer, queryPool, firstQuery,
 918                                      queryCount, dstBuffer, dstOffset, stride,
 919                                      flags);
 920 }
 921
 922 #undef EVENT_MARKER
 923 #define API_MARKER(cmd_name, args...) \
 924         RADV_FROM_HANDLE(radv_cmd_buffer, cmd_buffer, commandBuffer); \
 925         radv_write_begin_general_api_marker(cmd_buffer, ApiCmd##cmd_name); \
 926         radv_Cmd##cmd_name(args); \
 927         radv_write_end_general_api_marker(cmd_buffer, ApiCmd##cmd_name);
 928
 929 void sqtt_CmdBindPipeline(
 930         VkCommandBuffer                             commandBuffer,
 931         VkPipelineBindPoint                         pipelineBindPoint,
 932         VkPipeline                                  pipeline)
 933 {
 934         API_MARKER(BindPipeline, commandBuffer, pipelineBindPoint, pipeline);
 935 }
 936
 937 void sqtt_CmdBindDescriptorSets(
 938         VkCommandBuffer                             commandBuffer,
 939         VkPipelineBindPoint                         pipelineBindPoint,
 940         VkPipelineLayout                            layout,
 941         uint32_t                                    firstSet,
 942         uint32_t                                    descriptorSetCount,
 943         const VkDescriptorSet*                      pDescriptorSets,
 944         uint32_t                                    dynamicOffsetCount,
 945         const uint32_t*                             pDynamicOffsets)
 946 {
 947         API_MARKER(BindDescriptorSets, commandBuffer, pipelineBindPoint,
 948                    layout, firstSet, descriptorSetCount,
 949                    pDescriptorSets, dynamicOffsetCount, pDynamicOffsets);
 950 }
 951
 952 void sqtt_CmdBindIndexBuffer(
 953         VkCommandBuffer                             commandBuffer,
 954         VkBuffer                                    buffer,
 955         VkDeviceSize                                offset,
 956         VkIndexType                                 indexType)
 957 {
 958         API_MARKER(BindIndexBuffer, commandBuffer, buffer, offset, indexType);
 959 }
 960
 961 void sqtt_CmdBindVertexBuffers(
 962         VkCommandBuffer                             commandBuffer,
 963         uint32_t                                    firstBinding,
 964         uint32_t                                    bindingCount,
 965         const VkBuffer*                             pBuffers,
 966         const VkDeviceSize*                         pOffsets)
 967 {
 968         API_MARKER(BindVertexBuffers, commandBuffer, firstBinding, bindingCount,
 969                    pBuffers, pOffsets);
 970 }
 971
 972 void sqtt_CmdBeginQuery(
 973         VkCommandBuffer                             commandBuffer,
 974         VkQueryPool                                 queryPool,
 975         uint32_t                                    query,
 976         VkQueryControlFlags                         flags)
 977 {
 978         API_MARKER(BeginQuery, commandBuffer, queryPool, query, flags);
 979 }
 980
 981 void sqtt_CmdEndQuery(
 982         VkCommandBuffer                             commandBuffer,
 983         VkQueryPool                                 queryPool,
 984         uint32_t                                    query)
 985 {
 986         API_MARKER(EndQuery, commandBuffer, queryPool, query);
 987 }
 988
 989 void sqtt_CmdWriteTimestamp(
 990         VkCommandBuffer                             commandBuffer,
 991         VkPipelineStageFlagBits                     pipelineStage,
 992         VkQueryPool                                 queryPool,
 993         uint32_t                                    flags)
 994 {
 995         API_MARKER(WriteTimestamp, commandBuffer, pipelineStage, queryPool, flags);
 996 }
 997
 998 void sqtt_CmdPushConstants(
 999         VkCommandBuffer                             commandBuffer,
1000         VkPipelineLayout                            layout,
1001         VkShaderStageFlags                          stageFlags,
1002         uint32_t                                    offset,
1003         uint32_t                                    size,
1004         const void*                                 pValues)
1005 {
1006         API_MARKER(PushConstants, commandBuffer, layout, stageFlags, offset,
1007                    size, pValues);
1008 }
1009
1010 void sqtt_CmdBeginRenderPass(
1011         VkCommandBuffer                             commandBuffer,
1012         const VkRenderPassBeginInfo*                pRenderPassBegin,
1013         VkSubpassContents                           contents)
1014 {
1015         API_MARKER(BeginRenderPass, commandBuffer, pRenderPassBegin, contents);
1016 }
1017
1018 void sqtt_CmdNextSubpass(
1019         VkCommandBuffer                             commandBuffer,
1020         VkSubpassContents                           contents)
1021 {
1022         API_MARKER(NextSubpass, commandBuffer, contents);
1023 }
1024
1025 void sqtt_CmdEndRenderPass(
1026         VkCommandBuffer                             commandBuffer)
1027 {
1028         API_MARKER(EndRenderPass, commandBuffer);
1029 }
1030
1031 void sqtt_CmdExecuteCommands(
1032         VkCommandBuffer                             commandBuffer,
1033         uint32_t                                    commandBufferCount,
1034         const VkCommandBuffer*                      pCmdBuffers)
1035 {
1036         API_MARKER(ExecuteCommands, commandBuffer, commandBufferCount,
1037                    pCmdBuffers);
1038 }
1039
1040 void sqtt_CmdSetViewport(
1041         VkCommandBuffer                             commandBuffer,
1042         uint32_t                                    firstViewport,
1043         uint32_t                                    viewportCount,
1044         const VkViewport*                           pViewports)
1045 {
1046         API_MARKER(SetViewport, commandBuffer, firstViewport, viewportCount,
1047                    pViewports);
1048 }
1049
1050 void sqtt_CmdSetScissor(
1051         VkCommandBuffer                             commandBuffer,
1052         uint32_t                                    firstScissor,
1053         uint32_t                                    scissorCount,
1054         const VkRect2D*                             pScissors)
1055 {
1056         API_MARKER(SetScissor, commandBuffer, firstScissor, scissorCount,
1057                    pScissors);
1058 }
1059
1060 void sqtt_CmdSetLineWidth(
1061         VkCommandBuffer                             commandBuffer,
1062         float                                       lineWidth)
1063 {
1064         API_MARKER(SetLineWidth, commandBuffer, lineWidth);
1065 }
1066
1067 void sqtt_CmdSetDepthBias(
1068         VkCommandBuffer                             commandBuffer,
1069         float                                       depthBiasConstantFactor,
1070         float                                       depthBiasClamp,
1071         float                                       depthBiasSlopeFactor)
1072 {
1073         API_MARKER(SetDepthBias, commandBuffer, depthBiasConstantFactor,
1074                    depthBiasClamp, depthBiasSlopeFactor);
1075 }
1076
1077 void sqtt_CmdSetBlendConstants(
1078         VkCommandBuffer                             commandBuffer,
1079         const float                                 blendConstants[4])
1080 {
1081         API_MARKER(SetBlendConstants, commandBuffer, blendConstants);
1082 }
1083
1084 void sqtt_CmdSetDepthBounds(
1085         VkCommandBuffer                             commandBuffer,
1086         float                                       minDepthBounds,
1087         float                                       maxDepthBounds)
1088 {
1089         API_MARKER(SetDepthBounds, commandBuffer, minDepthBounds,
1090                    maxDepthBounds);
1091 }
1092
1093 void sqtt_CmdSetStencilCompareMask(
1094         VkCommandBuffer                             commandBuffer,
1095         VkStencilFaceFlags                          faceMask,
1096         uint32_t                                    compareMask)
1097 {
1098         API_MARKER(SetStencilCompareMask, commandBuffer, faceMask, compareMask);
1099 }
1100
1101 void sqtt_CmdSetStencilWriteMask(
1102         VkCommandBuffer                             commandBuffer,
1103         VkStencilFaceFlags                          faceMask,
1104         uint32_t                                    writeMask)
1105 {
1106         API_MARKER(SetStencilWriteMask, commandBuffer, faceMask, writeMask);
1107 }
1108
1109 void sqtt_CmdSetStencilReference(
1110         VkCommandBuffer                             commandBuffer,
1111         VkStencilFaceFlags                          faceMask,
1112         uint32_t                                    reference)
1113 {
1114         API_MARKER(SetStencilReference, commandBuffer, faceMask, reference);
1115 }
1116
1117 #undef API_MARKER