OpenHarmony/third_party_mesa3d
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

zink: use screen interfaces for pipeline barriers

Browse Source 
Reviewed-by: Dave Airlie <airlied@redhat.com>
Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/18628>
This commit is contained in:
Mike Blumenkrantz
2022-08-30 11:24:25 -04:00
committed by Marge Bot
parent 8c4aaa154a
commit 73797c2f46
6 changed files with 33 additions and 33 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
src/gallium/drivers/zink/zink_clear.c
View File

@@ -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;

36
src/gallium/drivers/zink/zink_context.c
View File

@@ -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++) {

14
src/gallium/drivers/zink/zink_draw.cpp
View File

@@ -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;

2
src/gallium/drivers/zink/zink_kopper.c
View File

@@ -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;

4
src/gallium/drivers/zink/zink_query.c
View File

@@ -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;

8
src/gallium/drivers/zink/zink_resource.c
View File

@@ -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);