From 73797c2f4651fe2c125e13e631fd081c66d3e85c Mon Sep 17 00:00:00 2001 From: Mike Blumenkrantz Date: Tue, 30 Aug 2022 11:24:25 -0400 Subject: [PATCH] zink: use screen interfaces for pipeline barriers Reviewed-by: Dave Airlie Part-of: --- src/gallium/drivers/zink/zink_clear.c | 2 +- src/gallium/drivers/zink/zink_context.c | 36 ++++++++++++------------ src/gallium/drivers/zink/zink_draw.cpp | 14 ++++----- src/gallium/drivers/zink/zink_kopper.c | 2 +- src/gallium/drivers/zink/zink_query.c | 4 +-- src/gallium/drivers/zink/zink_resource.c | 8 +++--- 6 files changed, 33 insertions(+), 33 deletions(-) diff --git a/src/gallium/drivers/zink/zink_clear.c b/src/gallium/drivers/zink/zink_clear.c index 01813a7081f..9a0630b01e8 100644 --- a/src/gallium/drivers/zink/zink_clear.c +++ b/src/gallium/drivers/zink/zink_clear.c @@ -545,7 +545,7 @@ zink_clear_buffer(struct pipe_context *pctx, zink_batch_no_rp(ctx); zink_batch_reference_resource_rw(batch, res, true); util_range_add(&res->base.b, &res->valid_buffer_range, offset, offset + size); - zink_resource_buffer_barrier(ctx, res, VK_ACCESS_TRANSFER_WRITE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT); + zink_screen(ctx->base.screen)->buffer_barrier(ctx, res, VK_ACCESS_TRANSFER_WRITE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT); res->obj->unordered_read = res->obj->unordered_write = false; VKCTX(CmdFillBuffer)(batch->state->cmdbuf, res->obj->buffer, offset, size, *(uint32_t*)clear_value); return; diff --git a/src/gallium/drivers/zink/zink_context.c b/src/gallium/drivers/zink/zink_context.c index 5751e8204ed..ff51c749afb 100644 --- a/src/gallium/drivers/zink/zink_context.c +++ b/src/gallium/drivers/zink/zink_context.c @@ -1183,7 +1183,7 @@ zink_set_vertex_buffers(struct pipe_context *pctx, ctx_vb->buffer_offset = vb->buffer_offset; zink_batch_resource_usage_set(&ctx->batch, res, false, true); /* always barrier before possible rebind */ - zink_resource_buffer_barrier(ctx, res, VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT, + zink_screen(ctx->base.screen)->buffer_barrier(ctx, res, VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT, VK_PIPELINE_STAGE_VERTEX_INPUT_BIT); res->obj->unordered_read = false; } else { @@ -1335,7 +1335,7 @@ zink_set_constant_buffer(struct pipe_context *pctx, update_res_bind_count(ctx, new_res, shader == MESA_SHADER_COMPUTE, false); } zink_batch_resource_usage_set(&ctx->batch, new_res, false, true); - zink_resource_buffer_barrier(ctx, new_res, VK_ACCESS_UNIFORM_READ_BIT, + zink_screen(ctx->base.screen)->buffer_barrier(ctx, new_res, VK_ACCESS_UNIFORM_READ_BIT, new_res->gfx_barrier); new_res->obj->unordered_read = false; } @@ -1453,7 +1453,7 @@ zink_set_shader_buffers(struct pipe_context *pctx, ssbo->buffer_size = MIN2(buffers[i].buffer_size, new_res->base.b.width0 - ssbo->buffer_offset); util_range_add(&new_res->base.b, &new_res->valid_buffer_range, ssbo->buffer_offset, ssbo->buffer_offset + ssbo->buffer_size); - zink_resource_buffer_barrier(ctx, new_res, access, + zink_screen(ctx->base.screen)->buffer_barrier(ctx, new_res, access, new_res->gfx_barrier); update = true; max_slot = MAX2(max_slot, start_slot + i); @@ -1674,7 +1674,7 @@ zink_set_shader_images(struct pipe_context *pctx, } image_view->buffer_view = bv; zink_batch_usage_set(&image_view->buffer_view->batch_uses, ctx->batch.state); - zink_resource_buffer_barrier(ctx, res, access, + zink_screen(ctx->base.screen)->buffer_barrier(ctx, res, access, res->gfx_barrier); zink_batch_resource_usage_set(&ctx->batch, res, zink_resource_access_is_write(access), true); @@ -1795,7 +1795,7 @@ zink_set_sampler_views(struct pipe_context *pctx, update = true; } zink_batch_usage_set(&b->buffer_view->batch_uses, ctx->batch.state); - zink_resource_buffer_barrier(ctx, res, VK_ACCESS_SHADER_READ_BIT, + zink_screen(ctx->base.screen)->buffer_barrier(ctx, res, VK_ACCESS_SHADER_READ_BIT, res->gfx_barrier); if (!a || a->buffer_view->buffer_view != b->buffer_view->buffer_view) update = true; @@ -1976,7 +1976,7 @@ zink_make_texture_handle_resident(struct pipe_context *pctx, uint64_t handle, bo rebind_bindless_bufferview(ctx, res, ds); VkBufferView *bv = &ctx->di.bindless[0].buffer_infos[handle]; *bv = ds->bufferview->buffer_view; - zink_resource_buffer_barrier(ctx, res, VK_ACCESS_SHADER_READ_BIT, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT | VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT); + zink_screen(ctx->base.screen)->buffer_barrier(ctx, res, VK_ACCESS_SHADER_READ_BIT, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT | VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT); zink_batch_resource_usage_set(&ctx->batch, res, false, true); } else { VkDescriptorImageInfo *ii = &ctx->di.bindless[0].img_infos[handle]; @@ -2097,7 +2097,7 @@ zink_make_image_handle_resident(struct pipe_context *pctx, uint64_t handle, unsi rebind_bindless_bufferview(ctx, res, ds); VkBufferView *bv = &ctx->di.bindless[1].buffer_infos[handle]; *bv = ds->bufferview->buffer_view; - zink_resource_buffer_barrier(ctx, res, access, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT | VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT); + zink_screen(ctx->base.screen)->buffer_barrier(ctx, res, access, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT | VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT); zink_batch_resource_usage_set(&ctx->batch, res, zink_resource_access_is_write(access), true); } else { VkDescriptorImageInfo *ii = &ctx->di.bindless[1].img_infos[handle]; @@ -2500,7 +2500,7 @@ zink_prep_fb_attachment(struct zink_context *ctx, struct zink_surface *surf, uns zink_init_zs_attachment(ctx, &rt); layout = zink_render_pass_attachment_get_barrier_info(&rt, i < ctx->fb_state.nr_cbufs, &pipeline, &access); } - zink_resource_image_barrier(ctx, res, layout, access, pipeline); + zink_screen(ctx->base.screen)->image_barrier(ctx, res, layout, access, pipeline); res->obj->unordered_read = res->obj->unordered_write = false; if (i == ctx->fb_state.nr_cbufs && res->sampler_bind_count[0]) update_res_sampler_layouts(ctx, res); @@ -2892,7 +2892,7 @@ zink_set_framebuffer_state(struct pipe_context *pctx, if (changed && unlikely(res->obj->needs_zs_evaluate)) /* have to flush zs eval while the sample location data still exists, * so just throw some random barrier */ - zink_resource_image_barrier(ctx, res, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, + zink_screen(ctx->base.screen)->image_barrier(ctx, res, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, VK_ACCESS_SHADER_READ_BIT, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT); } /* renderpass changes if the number or types of attachments change */ @@ -3558,7 +3558,7 @@ zink_flush(struct pipe_context *pctx, if (ctx->needs_present && (flags & PIPE_FLUSH_END_OF_FRAME)) { if (ctx->needs_present->obj->image) - zink_resource_image_barrier(ctx, ctx->needs_present, VK_IMAGE_LAYOUT_PRESENT_SRC_KHR, 0, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT); + zink_screen(ctx->base.screen)->image_barrier(ctx, ctx->needs_present, VK_IMAGE_LAYOUT_PRESENT_SRC_KHR, 0, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT); ctx->needs_present = NULL; } @@ -3833,7 +3833,7 @@ zink_flush_resource(struct pipe_context *pctx, struct zink_resource *res = zink_resource(pres); if (res->obj->dt) { if (zink_kopper_acquired(res->obj->dt, res->obj->dt_idx)) { - zink_resource_image_barrier(ctx, res, VK_IMAGE_LAYOUT_PRESENT_SRC_KHR, 0, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT); + zink_screen(ctx->base.screen)->image_barrier(ctx, res, VK_IMAGE_LAYOUT_PRESENT_SRC_KHR, 0, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT); zink_batch_reference_resource_rw(&ctx->batch, res, true); } else { ctx->needs_present = res; @@ -4158,8 +4158,8 @@ zink_copy_buffer(struct zink_context *ctx, struct zink_resource *dst, struct zin struct zink_batch *batch = &ctx->batch; util_range_add(&dst->base.b, &dst->valid_buffer_range, dst_offset, dst_offset + size); - zink_resource_buffer_barrier(ctx, src, VK_ACCESS_TRANSFER_READ_BIT, 0); - zink_resource_buffer_barrier(ctx, dst, VK_ACCESS_TRANSFER_WRITE_BIT, 0); + zink_screen(ctx->base.screen)->buffer_barrier(ctx, src, VK_ACCESS_TRANSFER_READ_BIT, 0); + zink_screen(ctx->base.screen)->buffer_barrier(ctx, dst, VK_ACCESS_TRANSFER_WRITE_BIT, 0); VkCommandBuffer cmdbuf = zink_get_cmdbuf(ctx, src, dst); zink_batch_reference_resource_rw(batch, src, false); zink_batch_reference_resource_rw(batch, dst, true); @@ -4183,13 +4183,13 @@ zink_copy_image_buffer(struct zink_context *ctx, struct zink_resource *dst, stru if (!zink_kopper_acquire(ctx, img, UINT64_MAX)) return; } - zink_resource_image_barrier(ctx, img, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 0, 0); - zink_resource_buffer_barrier(ctx, buf, VK_ACCESS_TRANSFER_READ_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT); + zink_screen(ctx->base.screen)->image_barrier(ctx, img, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 0, 0); + zink_screen(ctx->base.screen)->buffer_barrier(ctx, buf, VK_ACCESS_TRANSFER_READ_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT); } else { if (zink_is_swapchain(img)) needs_present_readback = zink_kopper_acquire_readback(ctx, img); - zink_resource_image_barrier(ctx, img, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, 0, 0); - zink_resource_buffer_barrier(ctx, buf, VK_ACCESS_TRANSFER_WRITE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT); + zink_screen(ctx->base.screen)->image_barrier(ctx, img, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, 0, 0); + zink_screen(ctx->base.screen)->buffer_barrier(ctx, buf, VK_ACCESS_TRANSFER_WRITE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT); util_range_add(&dst->base.b, &dst->valid_buffer_range, dstx, dstx + src_box->width); } @@ -4457,7 +4457,7 @@ zink_rebind_all_buffers(struct zink_context *ctx) ctx->vertex_buffers_dirty = ctx->gfx_pipeline_state.vertex_buffers_enabled_mask > 0; ctx->dirty_so_targets = ctx->num_so_targets > 0; if (ctx->num_so_targets) - zink_resource_buffer_barrier(ctx, zink_resource(ctx->dummy_xfb_buffer), + zink_screen(ctx->base.screen)->buffer_barrier(ctx, zink_resource(ctx->dummy_xfb_buffer), VK_ACCESS_TRANSFORM_FEEDBACK_WRITE_BIT_EXT, VK_PIPELINE_STAGE_TRANSFORM_FEEDBACK_BIT_EXT); for (unsigned shader = MESA_SHADER_VERTEX; shader < MESA_SHADER_STAGES; shader++) { for (unsigned slot = 0; slot < ctx->di.num_ubos[shader]; slot++) { diff --git a/src/gallium/drivers/zink/zink_draw.cpp b/src/gallium/drivers/zink/zink_draw.cpp index bfef9025f9d..108da55c161 100644 --- a/src/gallium/drivers/zink/zink_draw.cpp +++ b/src/gallium/drivers/zink/zink_draw.cpp @@ -41,7 +41,7 @@ zink_emit_xfb_counter_barrier(struct zink_context *ctx) access |= VK_ACCESS_TRANSFORM_FEEDBACK_COUNTER_READ_BIT_EXT; stage |= VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT; } - zink_resource_buffer_barrier(ctx, res, access, stage); + zink_screen(ctx->base.screen)->buffer_barrier(ctx, res, access, stage); res->obj->unordered_read = false; } } @@ -87,7 +87,7 @@ ALWAYS_INLINE static void check_buffer_barrier(struct zink_context *ctx, struct pipe_resource *pres, VkAccessFlags flags, VkPipelineStageFlags pipeline) { struct zink_resource *res = zink_resource(pres); - zink_resource_buffer_barrier(ctx, res, flags, pipeline); + zink_screen(ctx->base.screen)->buffer_barrier(ctx, res, flags, pipeline); res->obj->unordered_read = false; } @@ -291,11 +291,11 @@ update_barriers(struct zink_context *ctx, bool is_compute, if (res->bind_count[is_compute]) { VkPipelineStageFlagBits pipeline = is_compute ? VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT : res->gfx_barrier; if (res->base.b.target == PIPE_BUFFER) - zink_resource_buffer_barrier(ctx, res, res->barrier_access[is_compute], pipeline); + zink_screen(ctx->base.screen)->buffer_barrier(ctx, res, res->barrier_access[is_compute], pipeline); else { VkImageLayout layout = zink_descriptor_util_image_layout_eval(ctx, res, is_compute); if (layout != res->layout) - zink_resource_image_barrier(ctx, res, layout, res->barrier_access[is_compute], pipeline); + zink_screen(ctx->base.screen)->image_barrier(ctx, res, layout, res->barrier_access[is_compute], pipeline); } if (zink_resource_access_is_write(res->barrier_access[is_compute])) res->obj->unordered_read = res->obj->unordered_write = false; @@ -408,7 +408,7 @@ zink_draw(struct pipe_context *pctx, struct zink_so_target *t = (struct zink_so_target *)ctx->so_targets[i]; if (t) { struct zink_resource *res = zink_resource(t->base.buffer); - zink_resource_buffer_barrier(ctx, res, + zink_screen(ctx->base.screen)->buffer_barrier(ctx, res, VK_ACCESS_TRANSFORM_FEEDBACK_WRITE_BIT_EXT, VK_PIPELINE_STAGE_TRANSFORM_FEEDBACK_BIT_EXT); res->obj->unordered_read = res->obj->unordered_write = false; } @@ -425,7 +425,7 @@ zink_draw(struct pipe_context *pctx, */ if (so_target && so_target->counter_buffer_valid) { struct zink_resource *res = zink_resource(so_target->counter_buffer); - zink_resource_buffer_barrier(ctx, res, + zink_screen(ctx->base.screen)->buffer_barrier(ctx, res, VK_ACCESS_TRANSFORM_FEEDBACK_COUNTER_READ_BIT_EXT, VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT); res->obj->unordered_read = false; @@ -830,7 +830,7 @@ zink_draw_vertex_state(struct pipe_context *pctx, dinfo.index.resource = vstate->input.indexbuf; struct zink_context *ctx = zink_context(pctx); struct zink_resource *res = zink_resource(vstate->input.vbuffer.buffer.resource); - zink_resource_buffer_barrier(ctx, res, VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT, + zink_screen(ctx->base.screen)->buffer_barrier(ctx, res, VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT, VK_PIPELINE_STAGE_VERTEX_INPUT_BIT); res->obj->unordered_read = false; struct zink_vertex_elements_hw_state *hw_state = ctx->gfx_pipeline_state.element_state; diff --git a/src/gallium/drivers/zink/zink_kopper.c b/src/gallium/drivers/zink/zink_kopper.c index bc00d5b0828..cc826166cab 100644 --- a/src/gallium/drivers/zink/zink_kopper.c +++ b/src/gallium/drivers/zink/zink_kopper.c @@ -810,7 +810,7 @@ zink_kopper_present_readback(struct zink_context *ctx, struct zink_resource *res if (res->obj->last_dt_idx == UINT32_MAX) return true; if (res->layout != VK_IMAGE_LAYOUT_PRESENT_SRC_KHR) { - zink_resource_image_barrier(ctx, res, VK_IMAGE_LAYOUT_PRESENT_SRC_KHR, 0, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT); + zink_screen(ctx->base.screen)->image_barrier(ctx, res, VK_IMAGE_LAYOUT_PRESENT_SRC_KHR, 0, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT); ctx->base.flush(&ctx->base, NULL, 0); } si.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO; diff --git a/src/gallium/drivers/zink/zink_query.c b/src/gallium/drivers/zink/zink_query.c index 1a0c494e8a4..7fc23bd4fc6 100644 --- a/src/gallium/drivers/zink/zink_query.c +++ b/src/gallium/drivers/zink/zink_query.c @@ -726,7 +726,7 @@ copy_pool_results_to_buffer(struct zink_context *ctx, struct zink_query *query, zink_batch_no_rp(ctx); /* if it's a single query that doesn't need special handling, we can copy it and be done */ zink_batch_reference_resource_rw(batch, res, true); - zink_resource_buffer_barrier(ctx, res, VK_ACCESS_TRANSFER_WRITE_BIT, 0); + zink_screen(ctx->base.screen)->buffer_barrier(ctx, res, VK_ACCESS_TRANSFER_WRITE_BIT, 0); util_range_add(&res->base.b, &res->valid_buffer_range, offset, offset + result_size); assert(query_id < NUM_QUERIES); res->obj->unordered_read = res->obj->unordered_write = false; @@ -1224,7 +1224,7 @@ zink_render_condition(struct pipe_context *pctx, /* these need special handling */ force_cpu_read(ctx, pquery, PIPE_QUERY_TYPE_U32, &res->base.b, 0); } - zink_resource_buffer_barrier(ctx, res, VK_ACCESS_CONDITIONAL_RENDERING_READ_BIT_EXT, VK_PIPELINE_STAGE_CONDITIONAL_RENDERING_BIT_EXT); + zink_screen(ctx->base.screen)->buffer_barrier(ctx, res, VK_ACCESS_CONDITIONAL_RENDERING_READ_BIT_EXT, VK_PIPELINE_STAGE_CONDITIONAL_RENDERING_BIT_EXT); query->predicate_dirty = false; } ctx->render_condition.inverted = condition; diff --git a/src/gallium/drivers/zink/zink_resource.c b/src/gallium/drivers/zink/zink_resource.c index 69aa9d6d897..bf9a8813e5f 100644 --- a/src/gallium/drivers/zink/zink_resource.c +++ b/src/gallium/drivers/zink/zink_resource.c @@ -1247,7 +1247,7 @@ add_resource_bind(struct zink_context *ctx, struct zink_resource *res, unsigned { struct zink_screen *screen = zink_screen(ctx->base.screen); assert((res->base.b.bind & bind) == 0); - zink_resource_image_barrier(ctx, res, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, 0, 0); + zink_screen(ctx->base.screen)->image_barrier(ctx, res, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, 0, 0); res->base.b.bind |= bind; struct zink_resource_object *old_obj = res->obj; if (bind & ZINK_BIND_DMABUF && !res->modifiers_count && screen->info.have_EXT_image_drm_format_modifier) { @@ -2217,17 +2217,17 @@ zink_resource_setup_transfer_layouts(struct zink_context *ctx, struct zink_resou * VK_IMAGE_LAYOUT_GENERAL. And since this isn't a present-related * operation, VK_IMAGE_LAYOUT_GENERAL seems most appropriate. */ - zink_resource_image_barrier(ctx, src, + zink_screen(ctx->base.screen)->image_barrier(ctx, src, VK_IMAGE_LAYOUT_GENERAL, VK_ACCESS_TRANSFER_READ_BIT | VK_ACCESS_TRANSFER_WRITE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT); } else { - zink_resource_image_barrier(ctx, src, + zink_screen(ctx->base.screen)->image_barrier(ctx, src, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, VK_ACCESS_TRANSFER_READ_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT); - zink_resource_image_barrier(ctx, dst, + zink_screen(ctx->base.screen)->image_barrier(ctx, dst, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, VK_ACCESS_TRANSFER_WRITE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT);