zink: rework memory_barrier hook

this is a bit more sensible all around without being too much hammer
and not enough nail

Acked-by: Dave Airlie <airlied@redhat.com>
Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/9886>

1 files changed, 62 insertions, 106 deletions

diff --git a/src/gallium/drivers/zink/zink_context.c b/src/gallium/drivers/zink/zink_context.c
index 94c8a5101dd..9307d35aebe 100644
--- a/src/gallium/drivers/zink/zink_context.c
+++ b/src/gallium/drivers/zink/zink_context.c
@@ -2003,14 +2003,21 @@ zink_texture_barrier(struct pipe_context *pctx, unsigned flags)
       );
 }
 
+static inline void
+mem_barrier(struct zink_batch *batch, VkPipelineStageFlags stage, VkAccessFlags src, VkAccessFlags dst)
+{
+   VkMemoryBarrier mb;
+   mb.sType = VK_STRUCTURE_TYPE_MEMORY_BARRIER;
+   mb.pNext = NULL;
+   mb.srcAccessMask = src;
+   mb.dstAccessMask = dst;
+   vkCmdPipelineBarrier(batch->state->cmdbuf, stage, stage, 0, 1, &mb, 0, NULL, 0, NULL);
+}
+
 static void
 zink_memory_barrier(struct pipe_context *pctx, unsigned flags)
 {
    struct zink_context *ctx = zink_context(pctx);
-   VkAccessFlags sflags = 0;
-   VkAccessFlags dflags = 0;
-   VkPipelineStageFlags src = 0;
-   VkPipelineStageFlags dst = 0;
 
    VkPipelineStageFlags all_flags = VK_PIPELINE_STAGE_VERTEX_SHADER_BIT |
                                     VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT |
@@ -2019,111 +2026,60 @@ zink_memory_barrier(struct pipe_context *pctx, unsigned flags)
                                     VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT |
                                     VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT;
 
-   if (flags == PIPE_BARRIER_ALL) {
-      sflags = dflags = VK_ACCESS_MEMORY_READ_BIT | VK_ACCESS_MEMORY_WRITE_BIT;
-      src = dst = VK_PIPELINE_STAGE_ALL_COMMANDS_BIT;
-   } else {
-      while (flags) {
-         unsigned flag = u_bit_scan(&flags);
-         
-         switch (1 << flag) {
-         case PIPE_BARRIER_MAPPED_BUFFER:
-            sflags |= VK_ACCESS_SHADER_WRITE_BIT;
-            dflags |= VK_ACCESS_TRANSFER_READ_BIT;
-            break;
-         case PIPE_BARRIER_SHADER_BUFFER:
-            sflags |= VK_ACCESS_SHADER_WRITE_BIT;
-            dflags |= VK_ACCESS_SHADER_READ_BIT;
-            src |= all_flags;
-            dst |= all_flags;
-            break;
-         case PIPE_BARRIER_QUERY_BUFFER:
-            sflags |= VK_ACCESS_SHADER_WRITE_BIT | VK_ACCESS_TRANSFER_WRITE_BIT;
-            dflags |= VK_ACCESS_TRANSFER_WRITE_BIT | VK_ACCESS_SHADER_WRITE_BIT |
-                      VK_ACCESS_TRANSFER_READ_BIT | VK_ACCESS_SHADER_READ_BIT;
-            break;
-         case PIPE_BARRIER_VERTEX_BUFFER:
-            sflags |= VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT;
-            dflags |= VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT;
-            src |= VK_PIPELINE_STAGE_VERTEX_INPUT_BIT;
-            dst |= VK_PIPELINE_STAGE_VERTEX_INPUT_BIT;
-            break;
-         case PIPE_BARRIER_INDEX_BUFFER:
-            sflags |= VK_ACCESS_INDEX_READ_BIT;
-            dflags |= VK_ACCESS_INDEX_READ_BIT;
-            src |= VK_PIPELINE_STAGE_VERTEX_INPUT_BIT;
-            dst |= VK_PIPELINE_STAGE_VERTEX_INPUT_BIT;
-            break;
-         case PIPE_BARRIER_CONSTANT_BUFFER:
-            sflags |= VK_ACCESS_UNIFORM_READ_BIT;
-            dflags |= VK_ACCESS_UNIFORM_READ_BIT;
-            src |= all_flags;
-            dst |= all_flags;
-            break;
-         case PIPE_BARRIER_INDIRECT_BUFFER:
-            sflags |= VK_ACCESS_INDIRECT_COMMAND_READ_BIT;
-            dflags |= VK_ACCESS_INDIRECT_COMMAND_READ_BIT;
-            src |= VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT;
-            dst |= VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT;
-            break;
-         case PIPE_BARRIER_TEXTURE:
-            sflags |= VK_ACCESS_TRANSFER_WRITE_BIT | VK_ACCESS_SHADER_WRITE_BIT;
-            dflags |= VK_ACCESS_TRANSFER_READ_BIT | VK_ACCESS_SHADER_READ_BIT;
-            src |= all_flags;
-            dst |= all_flags;
-            break;
-         case PIPE_BARRIER_IMAGE:
-            sflags |= VK_ACCESS_TRANSFER_WRITE_BIT | VK_ACCESS_SHADER_WRITE_BIT;
-            dflags |= VK_ACCESS_TRANSFER_READ_BIT | VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_UNIFORM_READ_BIT;
-            src |= all_flags;
-            dst |= all_flags;
-            break;
-         case PIPE_BARRIER_FRAMEBUFFER:
-            sflags |= VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT |
-                      VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT;
-            dflags |= VK_ACCESS_INPUT_ATTACHMENT_READ_BIT |
-                      VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT;
-            src |= VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT;
-            dst |= VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
-            break;
-         case PIPE_BARRIER_STREAMOUT_BUFFER:
-            sflags |= VK_ACCESS_TRANSFORM_FEEDBACK_WRITE_BIT_EXT;
-            dflags |= VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT;
-            src |= VK_PIPELINE_STAGE_TRANSFORM_FEEDBACK_BIT_EXT;
-            dst |= VK_PIPELINE_STAGE_VERTEX_INPUT_BIT;
-            break;
-         case PIPE_BARRIER_GLOBAL_BUFFER:
-            debug_printf("zink: unhandled barrier flag %u\n", flag);
-            break;
-         case PIPE_BARRIER_UPDATE_BUFFER:
-            sflags |= VK_ACCESS_TRANSFER_WRITE_BIT;
-            dflags |= VK_ACCESS_TRANSFER_READ_BIT;
-            src |= VK_PIPELINE_STAGE_TRANSFER_BIT;
-            dst |= VK_PIPELINE_STAGE_TRANSFER_BIT;
-            break;
-         case PIPE_BARRIER_UPDATE_TEXTURE:
-            sflags |= VK_ACCESS_TRANSFER_WRITE_BIT;
-            dflags |= VK_ACCESS_TRANSFER_READ_BIT;
-            src |= VK_PIPELINE_STAGE_TRANSFER_BIT;
-            dst |= VK_PIPELINE_STAGE_TRANSFER_BIT;
-            break;
-         }
-      }
-   }
-   VkMemoryBarrier b = {};
-   b.sType = VK_STRUCTURE_TYPE_MEMORY_BARRIER;
-   /* TODO: these are all probably wrong */
-   b.srcAccessMask = sflags;
-   b.dstAccessMask = dflags;
+   if (!(flags & ~PIPE_BARRIER_UPDATE))
+      return;
 
    struct zink_batch *batch = &ctx->batch;
-   if (batch->has_work) {
-      zink_end_render_pass(ctx, batch);
+   zink_end_render_pass(ctx, batch);
 
-      /* this should be the only call needed */
-      vkCmdPipelineBarrier(batch->state->cmdbuf, src, dst, 0, 0, &b, 0, NULL, 0, NULL);
-      flush_batch(ctx);
-   }
+   if (flags & PIPE_BARRIER_MAPPED_BUFFER) {
+      /* TODO: this should flush all persistent buffers in use as I think */
+   }
+
+   if (flags & (PIPE_BARRIER_SHADER_BUFFER | PIPE_BARRIER_TEXTURE |
+                PIPE_BARRIER_IMAGE | PIPE_BARRIER_GLOBAL_BUFFER))
+      mem_barrier(batch, all_flags, VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_SHADER_WRITE_BIT,
+                                    VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_SHADER_WRITE_BIT);
+
+   if (flags & (PIPE_BARRIER_QUERY_BUFFER | PIPE_BARRIER_IMAGE))
+      mem_barrier(batch, VK_PIPELINE_STAGE_TRANSFER_BIT,
+                  VK_ACCESS_TRANSFER_READ_BIT | VK_ACCESS_TRANSFER_WRITE_BIT,
+                  VK_ACCESS_TRANSFER_READ_BIT | VK_ACCESS_TRANSFER_WRITE_BIT);
+
+   if (flags & PIPE_BARRIER_VERTEX_BUFFER)
+      mem_barrier(batch, VK_PIPELINE_STAGE_VERTEX_INPUT_BIT,
+                  VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT,
+                  VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT);
+
+   if (flags & PIPE_BARRIER_INDEX_BUFFER)
+      mem_barrier(batch, VK_PIPELINE_STAGE_VERTEX_INPUT_BIT,
+                  VK_ACCESS_INDEX_READ_BIT,
+                  VK_ACCESS_INDEX_READ_BIT);
+
+   if (flags & (PIPE_BARRIER_CONSTANT_BUFFER | PIPE_BARRIER_IMAGE))
+      mem_barrier(batch, all_flags,
+                  VK_ACCESS_UNIFORM_READ_BIT,
+                  VK_ACCESS_UNIFORM_READ_BIT);
+
+   if (flags & PIPE_BARRIER_INDIRECT_BUFFER)
+      mem_barrier(batch, VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT,
+                  VK_ACCESS_INDIRECT_COMMAND_READ_BIT,
+                  VK_ACCESS_INDIRECT_COMMAND_READ_BIT);
+
+   if (flags & PIPE_BARRIER_FRAMEBUFFER) {
+      mem_barrier(batch, VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
+                  VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
+                  VK_ACCESS_COLOR_ATTACHMENT_READ_BIT);
+      mem_barrier(batch, VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT,
+                  VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT,
+                  VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT);
+   }
+   if (flags & PIPE_BARRIER_STREAMOUT_BUFFER)
+      mem_barrier(batch, VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT |
+                  VK_PIPELINE_STAGE_TRANSFORM_FEEDBACK_BIT_EXT,
+                  VK_ACCESS_TRANSFORM_FEEDBACK_WRITE_BIT_EXT |
+                  VK_ACCESS_TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_EXT,
+                  VK_ACCESS_TRANSFORM_FEEDBACK_COUNTER_READ_BIT_EXT);
 }
 
 static void