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 static void
 324 radv_write_begin_general_api_marker(struct radv_cmd_buffer *cmd_buffer,
 325                                     enum rgp_sqtt_marker_general_api_type api_type)
 326 {
 327         struct rgp_sqtt_marker_general_api marker = {};
 328         struct radeon_cmdbuf *cs = cmd_buffer->cs;
 329
 330         marker.identifier = RGP_SQTT_MARKER_IDENTIFIER_GENERAL_API;
 331         marker.api_type = api_type;
 332
 333         radv_emit_thread_trace_userdata(cs, &marker, sizeof(marker) / 4);
 334 }
 335
 336 static void
 337 radv_write_end_general_api_marker(struct radv_cmd_buffer *cmd_buffer,
 338                                   enum rgp_sqtt_marker_general_api_type api_type)
 339 {
 340         struct rgp_sqtt_marker_general_api marker = {};
 341         struct radeon_cmdbuf *cs = cmd_buffer->cs;
 342
 343         marker.identifier = RGP_SQTT_MARKER_IDENTIFIER_GENERAL_API;
 344         marker.api_type = api_type;
 345         marker.is_end = 1;
 346
 347         radv_emit_thread_trace_userdata(cs, &marker, sizeof(marker) / 4);
 348 }
 349
 350 static void
 351 radv_write_event_marker(struct radv_cmd_buffer *cmd_buffer,
 352                         enum rgp_sqtt_marker_event_type api_type,
 353                         uint32_t vertex_offset_user_data,
 354                         uint32_t instance_offset_user_data,
 355                         uint32_t draw_index_user_data)
 356 {
 357         struct rgp_sqtt_marker_event marker = {};
 358         struct radeon_cmdbuf *cs = cmd_buffer->cs;
 359
 360         marker.identifier = RGP_SQTT_MARKER_IDENTIFIER_EVENT;
 361         marker.api_type = api_type;
 362         marker.cmd_id = cmd_buffer->state.num_events++;
 363         marker.cb_id = 0;
 364
 365         if (vertex_offset_user_data == UINT_MAX ||
 366             instance_offset_user_data == UINT_MAX) {
 367                 vertex_offset_user_data = 0;
 368                 instance_offset_user_data = 0;
 369         }
 370
 371         if (draw_index_user_data == UINT_MAX)
 372                 draw_index_user_data = vertex_offset_user_data;
 373
 374         marker.vertex_offset_reg_idx = vertex_offset_user_data;
 375         marker.instance_offset_reg_idx = instance_offset_user_data;
 376         marker.draw_index_reg_idx = draw_index_user_data;
 377
 378         radv_emit_thread_trace_userdata(cs, &marker, sizeof(marker) / 4);
 379 }
 380
 381 static void
 382 radv_write_event_with_dims_marker(struct radv_cmd_buffer *cmd_buffer,
 383                                   enum rgp_sqtt_marker_event_type api_type,
 384                                   uint32_t x, uint32_t y, uint32_t z)
 385 {
 386         struct rgp_sqtt_marker_event_with_dims marker = {};
 387         struct radeon_cmdbuf *cs = cmd_buffer->cs;
 388
 389         marker.event.identifier = RGP_SQTT_MARKER_IDENTIFIER_EVENT;
 390         marker.event.api_type = api_type;
 391         marker.event.cmd_id = cmd_buffer->state.num_events++;
 392         marker.event.cb_id = 0;
 393         marker.event.has_thread_dims = 1;
 394
 395         marker.thread_x = x;
 396         marker.thread_y = y;
 397         marker.thread_z = z;
 398
 399         radv_emit_thread_trace_userdata(cs, &marker, sizeof(marker) / 4);
 400 }
 401
 402 void
 403 radv_describe_begin_cmd_buffer(struct radv_cmd_buffer *cmd_buffer)
 404 {
 405         uint64_t device_id = (uint64_t)cmd_buffer->device;
 406         struct rgp_sqtt_marker_cb_start marker = {};
 407         struct radeon_cmdbuf *cs = cmd_buffer->cs;
 408
 409         if (likely(!cmd_buffer->device->thread_trace_bo))
 410                 return;
 411
 412         marker.identifier = RGP_SQTT_MARKER_IDENTIFIER_CB_START;
 413         marker.cb_id = 0;
 414         marker.device_id_low = device_id;
 415         marker.device_id_high = device_id >> 32;
 416         marker.queue = cmd_buffer->queue_family_index;
 417         marker.queue_flags = VK_QUEUE_COMPUTE_BIT |
 418                              VK_QUEUE_TRANSFER_BIT |
 419                              VK_QUEUE_SPARSE_BINDING_BIT;
 420
 421         if (cmd_buffer->queue_family_index == RADV_QUEUE_GENERAL)
 422                 marker.queue_flags |= VK_QUEUE_GRAPHICS_BIT;
 423
 424         radv_emit_thread_trace_userdata(cs, &marker, sizeof(marker) / 4);
 425 }
 426
 427 void
 428 radv_describe_end_cmd_buffer(struct radv_cmd_buffer *cmd_buffer)
 429 {
 430         uint64_t device_id = (uint64_t)cmd_buffer->device;
 431         struct rgp_sqtt_marker_cb_end marker = {};
 432         struct radeon_cmdbuf *cs = cmd_buffer->cs;
 433
 434         if (likely(!cmd_buffer->device->thread_trace_bo))
 435                 return;
 436
 437         marker.identifier = RGP_SQTT_MARKER_IDENTIFIER_CB_END;
 438         marker.cb_id = 0;
 439         marker.device_id_low = device_id;
 440         marker.device_id_high = device_id >> 32;
 441
 442         radv_emit_thread_trace_userdata(cs, &marker, sizeof(marker) / 4);
 443 }
 444
 445 void
 446 radv_describe_draw(struct radv_cmd_buffer *cmd_buffer)
 447 {
 448         if (likely(!cmd_buffer->device->thread_trace_bo))
 449                 return;
 450
 451         radv_write_event_marker(cmd_buffer, cmd_buffer->state.current_event_type,
 452                                 UINT_MAX, UINT_MAX, UINT_MAX);
 453 }
 454
 455 void
 456 radv_describe_dispatch(struct radv_cmd_buffer *cmd_buffer, int x, int y, int z)
 457 {
 458         if (likely(!cmd_buffer->device->thread_trace_bo))
 459                 return;
 460
 461         radv_write_event_with_dims_marker(cmd_buffer,
 462                                           cmd_buffer->state.current_event_type,
 463                                           x, y, z);
 464 }
 465
 466 void
 467 radv_describe_begin_render_pass_clear(struct radv_cmd_buffer *cmd_buffer,
 468                                       VkImageAspectFlagBits aspects)
 469 {
 470         cmd_buffer->state.current_event_type = (aspects & VK_IMAGE_ASPECT_COLOR_BIT) ?
 471                 EventRenderPassColorClear : EventRenderPassDepthStencilClear;
 472 }
 473
 474 void
 475 radv_describe_end_render_pass_clear(struct radv_cmd_buffer *cmd_buffer)
 476 {
 477         cmd_buffer->state.current_event_type = EventInternalUnknown;
 478 }
 479
 480 void
 481 radv_describe_barrier_start(struct radv_cmd_buffer *cmd_buffer,
 482                            enum rgp_barrier_reason reason)
 483 {
 484         struct rgp_sqtt_marker_barrier_start marker = {};
 485         struct radeon_cmdbuf *cs = cmd_buffer->cs;
 486
 487         if (likely(!cmd_buffer->device->thread_trace_bo))
 488                 return;
 489
 490         marker.identifier = RGP_SQTT_MARKER_IDENTIFIER_BARRIER_START;
 491         marker.cb_id = 0;
 492         marker.dword02 = reason;
 493
 494         radv_emit_thread_trace_userdata(cs, &marker, sizeof(marker) / 4);
 495 }
 496
 497 void
 498 radv_describe_barrier_end(struct radv_cmd_buffer *cmd_buffer)
 499 {
 500         struct rgp_sqtt_marker_barrier_end marker = {};
 501         struct radeon_cmdbuf *cs = cmd_buffer->cs;
 502
 503         if (likely(!cmd_buffer->device->thread_trace_bo))
 504                 return;
 505
 506         marker.identifier = RGP_SQTT_MARKER_IDENTIFIER_BARRIER_END;
 507         marker.cb_id = 0;
 508
 509         /* TODO: fill pipeline stalls, cache flushes, etc */
 510
 511         radv_emit_thread_trace_userdata(cs, &marker, sizeof(marker) / 4);
 512 }
 513
 514 #define EVENT_MARKER(cmd_name, args...) \
 515         RADV_FROM_HANDLE(radv_cmd_buffer, cmd_buffer, commandBuffer); \
 516         radv_write_begin_general_api_marker(cmd_buffer, ApiCmd##cmd_name); \
 517         cmd_buffer->state.current_event_type = EventCmd##cmd_name; \
 518         radv_Cmd##cmd_name(args); \
 519         cmd_buffer->state.current_event_type = EventInternalUnknown; \
 520         radv_write_end_general_api_marker(cmd_buffer, ApiCmd##cmd_name);
 521
 522 void sqtt_CmdDraw(
 523         VkCommandBuffer                             commandBuffer,
 524         uint32_t                                    vertexCount,
 525         uint32_t                                    instanceCount,
 526         uint32_t                                    firstVertex,
 527         uint32_t                                    firstInstance)
 528 {
 529         EVENT_MARKER(Draw, commandBuffer, vertexCount, instanceCount,
 530                      firstVertex, firstInstance);
 531 }
 532
 533 void sqtt_CmdDrawIndexed(
 534         VkCommandBuffer                             commandBuffer,
 535         uint32_t                                    indexCount,
 536         uint32_t                                    instanceCount,
 537         uint32_t                                    firstIndex,
 538         int32_t                                     vertexOffset,
 539         uint32_t                                    firstInstance)
 540 {
 541         EVENT_MARKER(DrawIndexed, commandBuffer, indexCount, instanceCount,
 542                      firstIndex, vertexOffset, firstInstance);
 543 }
 544
 545 void sqtt_CmdDrawIndirect(
 546         VkCommandBuffer                             commandBuffer,
 547         VkBuffer                                    buffer,
 548         VkDeviceSize                                offset,
 549         uint32_t                                    drawCount,
 550         uint32_t                                    stride)
 551 {
 552         EVENT_MARKER(DrawIndirect, commandBuffer, buffer, offset, drawCount,
 553                      stride);
 554 }
 555
 556 void sqtt_CmdDrawIndexedIndirect(
 557         VkCommandBuffer                             commandBuffer,
 558         VkBuffer                                    buffer,
 559         VkDeviceSize                                offset,
 560         uint32_t                                    drawCount,
 561         uint32_t                                    stride)
 562 {
 563         EVENT_MARKER(DrawIndexedIndirect, commandBuffer, buffer, offset,
 564                      drawCount, stride);
 565 }
 566
 567 void sqtt_CmdDrawIndirectCount(
 568         VkCommandBuffer                             commandBuffer,
 569         VkBuffer                                    buffer,
 570         VkDeviceSize                                offset,
 571         VkBuffer                                    countBuffer,
 572         VkDeviceSize                                countBufferOffset,
 573         uint32_t                                    maxDrawCount,
 574         uint32_t                                    stride)
 575 {
 576         EVENT_MARKER(DrawIndirectCount,commandBuffer, buffer, offset,
 577                      countBuffer, countBufferOffset, maxDrawCount, stride);
 578 }
 579
 580 void sqtt_CmdDrawIndexedIndirectCount(
 581         VkCommandBuffer                             commandBuffer,
 582         VkBuffer                                    buffer,
 583         VkDeviceSize                                offset,
 584         VkBuffer                                    countBuffer,
 585         VkDeviceSize                                countBufferOffset,
 586         uint32_t                                    maxDrawCount,
 587         uint32_t                                    stride)
 588 {
 589         EVENT_MARKER(DrawIndexedIndirectCount, commandBuffer, buffer, offset,
 590                      countBuffer, countBufferOffset, maxDrawCount, stride);
 591 }
 592
 593 void sqtt_CmdDispatch(
 594         VkCommandBuffer                             commandBuffer,
 595         uint32_t                                    x,
 596         uint32_t                                    y,
 597         uint32_t                                    z)
 598 {
 599         EVENT_MARKER(Dispatch, commandBuffer, x, y, z);
 600 }
 601
 602 void sqtt_CmdDispatchIndirect(
 603         VkCommandBuffer                             commandBuffer,
 604         VkBuffer                                    buffer,
 605         VkDeviceSize                                offset)
 606 {
 607         EVENT_MARKER(DispatchIndirect, commandBuffer, buffer, offset);
 608 }
 609
 610 void sqtt_CmdCopyBuffer(
 611         VkCommandBuffer                             commandBuffer,
 612         VkBuffer                                    srcBuffer,
 613         VkBuffer                                    destBuffer,
 614         uint32_t                                    regionCount,
 615         const VkBufferCopy*                         pRegions)
 616 {
 617         EVENT_MARKER(CopyBuffer, commandBuffer, srcBuffer, destBuffer,
 618                      regionCount, pRegions);
 619 }
 620
 621 void sqtt_CmdFillBuffer(
 622         VkCommandBuffer                             commandBuffer,
 623         VkBuffer                                    dstBuffer,
 624         VkDeviceSize                                dstOffset,
 625         VkDeviceSize                                fillSize,
 626         uint32_t                                    data)
 627 {
 628         EVENT_MARKER(FillBuffer, commandBuffer, dstBuffer, dstOffset, fillSize,
 629                      data);
 630 }
 631
 632 void sqtt_CmdUpdateBuffer(
 633         VkCommandBuffer                             commandBuffer,
 634         VkBuffer                                    dstBuffer,
 635         VkDeviceSize                                dstOffset,
 636         VkDeviceSize                                dataSize,
 637         const void*                                 pData)
 638 {
 639         EVENT_MARKER(UpdateBuffer, commandBuffer, dstBuffer, dstOffset,
 640                      dataSize, pData);
 641 }
 642
 643 void sqtt_CmdCopyImage(
 644         VkCommandBuffer                             commandBuffer,
 645         VkImage                                     srcImage,
 646         VkImageLayout                               srcImageLayout,
 647         VkImage                                     destImage,
 648         VkImageLayout                               destImageLayout,
 649         uint32_t                                    regionCount,
 650         const VkImageCopy*                          pRegions)
 651 {
 652         EVENT_MARKER(CopyImage, commandBuffer, srcImage, srcImageLayout,
 653                      destImage, destImageLayout, regionCount, pRegions);
 654 }
 655
 656 void sqtt_CmdCopyBufferToImage(
 657         VkCommandBuffer                             commandBuffer,
 658         VkBuffer                                    srcBuffer,
 659         VkImage                                     destImage,
 660         VkImageLayout                               destImageLayout,
 661         uint32_t                                    regionCount,
 662         const VkBufferImageCopy*                    pRegions)
 663 {
 664         EVENT_MARKER(CopyBufferToImage, commandBuffer, srcBuffer, destImage,
 665                      destImageLayout, regionCount, pRegions);
 666 }
 667
 668 void sqtt_CmdCopyImageToBuffer(
 669         VkCommandBuffer                             commandBuffer,
 670         VkImage                                     srcImage,
 671         VkImageLayout                               srcImageLayout,
 672         VkBuffer                                    destBuffer,
 673         uint32_t                                    regionCount,
 674         const VkBufferImageCopy*                    pRegions)
 675 {
 676         EVENT_MARKER(CopyImageToBuffer, commandBuffer, srcImage, srcImageLayout,
 677                      destBuffer, regionCount, pRegions);
 678 }
 679
 680 void sqtt_CmdBlitImage(
 681         VkCommandBuffer                             commandBuffer,
 682         VkImage                                     srcImage,
 683         VkImageLayout                               srcImageLayout,
 684         VkImage                                     destImage,
 685         VkImageLayout                               destImageLayout,
 686         uint32_t                                    regionCount,
 687         const VkImageBlit*                          pRegions,
 688         VkFilter                                    filter)
 689 {
 690         EVENT_MARKER(BlitImage, commandBuffer, srcImage, srcImageLayout,
 691                      destImage, destImageLayout, regionCount, pRegions, filter);
 692 }
 693
 694 void sqtt_CmdClearColorImage(
 695         VkCommandBuffer                             commandBuffer,
 696         VkImage                                     image_h,
 697         VkImageLayout                               imageLayout,
 698         const VkClearColorValue*                    pColor,
 699         uint32_t                                    rangeCount,
 700         const VkImageSubresourceRange*              pRanges)
 701 {
 702         EVENT_MARKER(ClearColorImage, commandBuffer, image_h, imageLayout,
 703                      pColor, rangeCount, pRanges);
 704 }
 705
 706 void sqtt_CmdClearDepthStencilImage(
 707         VkCommandBuffer                             commandBuffer,
 708         VkImage                                     image_h,
 709         VkImageLayout                               imageLayout,
 710         const VkClearDepthStencilValue*             pDepthStencil,
 711         uint32_t                                    rangeCount,
 712         const VkImageSubresourceRange*              pRanges)
 713 {
 714         EVENT_MARKER(ClearDepthStencilImage, commandBuffer, image_h,
 715                      imageLayout, pDepthStencil, rangeCount, pRanges);
 716 }
 717
 718 void sqtt_CmdClearAttachments(
 719         VkCommandBuffer                             commandBuffer,
 720         uint32_t                                    attachmentCount,
 721         const VkClearAttachment*                    pAttachments,
 722         uint32_t                                    rectCount,
 723         const VkClearRect*                          pRects)
 724 {
 725         EVENT_MARKER(ClearAttachments, commandBuffer, attachmentCount,
 726                      pAttachments, rectCount, pRects);
 727 }
 728
 729 void sqtt_CmdResolveImage(
 730         VkCommandBuffer                             commandBuffer,
 731         VkImage                                     src_image_h,
 732         VkImageLayout                               src_image_layout,
 733         VkImage                                     dest_image_h,
 734         VkImageLayout                               dest_image_layout,
 735         uint32_t                                    region_count,
 736         const VkImageResolve*                       regions)
 737 {
 738         EVENT_MARKER(ResolveImage, commandBuffer, src_image_h, src_image_layout,
 739                      dest_image_h, dest_image_layout, region_count, regions);
 740 }
 741
 742 void sqtt_CmdWaitEvents(VkCommandBuffer commandBuffer,
 743                         uint32_t eventCount,
 744                         const VkEvent* pEvents,
 745                         VkPipelineStageFlags srcStageMask,
 746                         VkPipelineStageFlags dstStageMask,
 747                         uint32_t memoryBarrierCount,
 748                         const VkMemoryBarrier* pMemoryBarriers,
 749                         uint32_t bufferMemoryBarrierCount,
 750                         const VkBufferMemoryBarrier* pBufferMemoryBarriers,
 751                         uint32_t imageMemoryBarrierCount,
 752                         const VkImageMemoryBarrier* pImageMemoryBarriers)
 753 {
 754         EVENT_MARKER(WaitEvents, commandBuffer, eventCount, pEvents,
 755                      srcStageMask, dstStageMask, memoryBarrierCount,
 756                      pMemoryBarriers, bufferMemoryBarrierCount,
 757                      pBufferMemoryBarriers, imageMemoryBarrierCount,
 758                      pImageMemoryBarriers);
 759 }
 760
 761 void sqtt_CmdPipelineBarrier(
 762         VkCommandBuffer                             commandBuffer,
 763         VkPipelineStageFlags                        srcStageMask,
 764         VkPipelineStageFlags                        destStageMask,
 765         VkBool32                                    byRegion,
 766         uint32_t                                    memoryBarrierCount,
 767         const VkMemoryBarrier*                      pMemoryBarriers,
 768         uint32_t                                    bufferMemoryBarrierCount,
 769         const VkBufferMemoryBarrier*                pBufferMemoryBarriers,
 770         uint32_t                                    imageMemoryBarrierCount,
 771         const VkImageMemoryBarrier*                 pImageMemoryBarriers)
 772 {
 773         EVENT_MARKER(PipelineBarrier, commandBuffer, srcStageMask,
 774                      destStageMask, byRegion, memoryBarrierCount,
 775                      pMemoryBarriers, bufferMemoryBarrierCount,
 776                      pBufferMemoryBarriers, imageMemoryBarrierCount,
 777                      pImageMemoryBarriers);
 778 }
 779
 780 void sqtt_CmdResetQueryPool(
 781         VkCommandBuffer                             commandBuffer,
 782         VkQueryPool                                 queryPool,
 783         uint32_t                                    firstQuery,
 784         uint32_t                                    queryCount)
 785 {
 786         EVENT_MARKER(ResetQueryPool, commandBuffer, queryPool, firstQuery,
 787                      queryCount);
 788 }
 789
 790 void sqtt_CmdCopyQueryPoolResults(
 791         VkCommandBuffer                             commandBuffer,
 792         VkQueryPool                                 queryPool,
 793         uint32_t                                    firstQuery,
 794         uint32_t                                    queryCount,
 795         VkBuffer                                    dstBuffer,
 796         VkDeviceSize                                dstOffset,
 797         VkDeviceSize                                stride,
 798         VkQueryResultFlags                          flags)
 799 {
 800         EVENT_MARKER(CopyQueryPoolResults, commandBuffer, queryPool, firstQuery,
 801                                      queryCount, dstBuffer, dstOffset, stride,
 802                                      flags);
 803 }
 804
 805 #undef EVENT_MARKER
 806 #define API_MARKER(cmd_name, args...) \
 807         RADV_FROM_HANDLE(radv_cmd_buffer, cmd_buffer, commandBuffer); \
 808         radv_write_begin_general_api_marker(cmd_buffer, ApiCmd##cmd_name); \
 809         radv_Cmd##cmd_name(args); \
 810         radv_write_end_general_api_marker(cmd_buffer, ApiCmd##cmd_name);
 811
 812 void sqtt_CmdBindPipeline(
 813         VkCommandBuffer                             commandBuffer,
 814         VkPipelineBindPoint                         pipelineBindPoint,
 815         VkPipeline                                  pipeline)
 816 {
 817         API_MARKER(BindPipeline, commandBuffer, pipelineBindPoint, pipeline);
 818 }
 819
 820 void sqtt_CmdBindDescriptorSets(
 821         VkCommandBuffer                             commandBuffer,
 822         VkPipelineBindPoint                         pipelineBindPoint,
 823         VkPipelineLayout                            layout,
 824         uint32_t                                    firstSet,
 825         uint32_t                                    descriptorSetCount,
 826         const VkDescriptorSet*                      pDescriptorSets,
 827         uint32_t                                    dynamicOffsetCount,
 828         const uint32_t*                             pDynamicOffsets)
 829 {
 830         API_MARKER(BindDescriptorSets, commandBuffer, pipelineBindPoint,
 831                    layout, firstSet, descriptorSetCount,
 832                    pDescriptorSets, dynamicOffsetCount, pDynamicOffsets);
 833 }
 834
 835 void sqtt_CmdBindIndexBuffer(
 836         VkCommandBuffer                             commandBuffer,
 837         VkBuffer                                    buffer,
 838         VkDeviceSize                                offset,
 839         VkIndexType                                 indexType)
 840 {
 841         API_MARKER(BindIndexBuffer, commandBuffer, buffer, offset, indexType);
 842 }
 843
 844 void sqtt_CmdBindVertexBuffers(
 845         VkCommandBuffer                             commandBuffer,
 846         uint32_t                                    firstBinding,
 847         uint32_t                                    bindingCount,
 848         const VkBuffer*                             pBuffers,
 849         const VkDeviceSize*                         pOffsets)
 850 {
 851         API_MARKER(BindVertexBuffers, commandBuffer, firstBinding, bindingCount,
 852                    pBuffers, pOffsets);
 853 }
 854
 855 void sqtt_CmdBeginQuery(
 856         VkCommandBuffer                             commandBuffer,
 857         VkQueryPool                                 queryPool,
 858         uint32_t                                    query,
 859         VkQueryControlFlags                         flags)
 860 {
 861         API_MARKER(BeginQuery, commandBuffer, queryPool, query, flags);
 862 }
 863
 864 void sqtt_CmdEndQuery(
 865         VkCommandBuffer                             commandBuffer,
 866         VkQueryPool                                 queryPool,
 867         uint32_t                                    query)
 868 {
 869         API_MARKER(EndQuery, commandBuffer, queryPool, query);
 870 }
 871
 872 void sqtt_CmdWriteTimestamp(
 873         VkCommandBuffer                             commandBuffer,
 874         VkPipelineStageFlagBits                     pipelineStage,
 875         VkQueryPool                                 queryPool,
 876         uint32_t                                    flags)
 877 {
 878         API_MARKER(WriteTimestamp, commandBuffer, pipelineStage, queryPool, flags);
 879 }
 880
 881 void sqtt_CmdPushConstants(
 882         VkCommandBuffer                             commandBuffer,
 883         VkPipelineLayout                            layout,
 884         VkShaderStageFlags                          stageFlags,
 885         uint32_t                                    offset,
 886         uint32_t                                    size,
 887         const void*                                 pValues)
 888 {
 889         API_MARKER(PushConstants, commandBuffer, layout, stageFlags, offset,
 890                    size, pValues);
 891 }
 892
 893 void sqtt_CmdBeginRenderPass(
 894         VkCommandBuffer                             commandBuffer,
 895         const VkRenderPassBeginInfo*                pRenderPassBegin,
 896         VkSubpassContents                           contents)
 897 {
 898         API_MARKER(BeginRenderPass, commandBuffer, pRenderPassBegin, contents);
 899 }
 900
 901 void sqtt_CmdNextSubpass(
 902         VkCommandBuffer                             commandBuffer,
 903         VkSubpassContents                           contents)
 904 {
 905         API_MARKER(NextSubpass, commandBuffer, contents);
 906 }
 907
 908 void sqtt_CmdEndRenderPass(
 909         VkCommandBuffer                             commandBuffer)
 910 {
 911         API_MARKER(EndRenderPass, commandBuffer);
 912 }
 913
 914 void sqtt_CmdExecuteCommands(
 915         VkCommandBuffer                             commandBuffer,
 916         uint32_t                                    commandBufferCount,
 917         const VkCommandBuffer*                      pCmdBuffers)
 918 {
 919         API_MARKER(ExecuteCommands, commandBuffer, commandBufferCount,
 920                    pCmdBuffers);
 921 }
 922
 923 void sqtt_CmdSetViewport(
 924         VkCommandBuffer                             commandBuffer,
 925         uint32_t                                    firstViewport,
 926         uint32_t                                    viewportCount,
 927         const VkViewport*                           pViewports)
 928 {
 929         API_MARKER(SetViewport, commandBuffer, firstViewport, viewportCount,
 930                    pViewports);
 931 }
 932
 933 void sqtt_CmdSetScissor(
 934         VkCommandBuffer                             commandBuffer,
 935         uint32_t                                    firstScissor,
 936         uint32_t                                    scissorCount,
 937         const VkRect2D*                             pScissors)
 938 {
 939         API_MARKER(SetScissor, commandBuffer, firstScissor, scissorCount,
 940                    pScissors);
 941 }
 942
 943 void sqtt_CmdSetLineWidth(
 944         VkCommandBuffer                             commandBuffer,
 945         float                                       lineWidth)
 946 {
 947         API_MARKER(SetLineWidth, commandBuffer, lineWidth);
 948 }
 949
 950 void sqtt_CmdSetDepthBias(
 951         VkCommandBuffer                             commandBuffer,
 952         float                                       depthBiasConstantFactor,
 953         float                                       depthBiasClamp,
 954         float                                       depthBiasSlopeFactor)
 955 {
 956         API_MARKER(SetDepthBias, commandBuffer, depthBiasConstantFactor,
 957                    depthBiasClamp, depthBiasSlopeFactor);
 958 }
 959
 960 void sqtt_CmdSetBlendConstants(
 961         VkCommandBuffer                             commandBuffer,
 962         const float                                 blendConstants[4])
 963 {
 964         API_MARKER(SetBlendConstants, commandBuffer, blendConstants);
 965 }
 966
 967 void sqtt_CmdSetDepthBounds(
 968         VkCommandBuffer                             commandBuffer,
 969         float                                       minDepthBounds,
 970         float                                       maxDepthBounds)
 971 {
 972         API_MARKER(SetDepthBounds, commandBuffer, minDepthBounds,
 973                    maxDepthBounds);
 974 }
 975
 976 void sqtt_CmdSetStencilCompareMask(
 977         VkCommandBuffer                             commandBuffer,
 978         VkStencilFaceFlags                          faceMask,
 979         uint32_t                                    compareMask)
 980 {
 981         API_MARKER(SetStencilCompareMask, commandBuffer, faceMask, compareMask);
 982 }
 983
 984 void sqtt_CmdSetStencilWriteMask(
 985         VkCommandBuffer                             commandBuffer,
 986         VkStencilFaceFlags                          faceMask,
 987         uint32_t                                    writeMask)
 988 {
 989         API_MARKER(SetStencilWriteMask, commandBuffer, faceMask, writeMask);
 990 }
 991
 992 void sqtt_CmdSetStencilReference(
 993         VkCommandBuffer                             commandBuffer,
 994         VkStencilFaceFlags                          faceMask,
 995         uint32_t                                    reference)
 996 {
 997         API_MARKER(SetStencilReference, commandBuffer, faceMask, reference);
 998 }
 999
1000 #undef API_MARKER