From ad584ed34e45e410c28756fed5cadbbf11633749 Mon Sep 17 00:00:00 2001 From: Mike Blumenkrantz Date: Wed, 18 Aug 2021 09:59:18 -0400 Subject: [PATCH] zink: use dispatch table for (almost) all vulkan calls try to avoid hitting the loader when possible Reviewed-by: Dave Airlie Part-of: --- src/gallium/drivers/zink/zink_batch.c | 44 +++--- src/gallium/drivers/zink/zink_blit.c | 4 +- src/gallium/drivers/zink/zink_bo.c | 10 +- src/gallium/drivers/zink/zink_clear.c | 8 +- src/gallium/drivers/zink/zink_compiler.c | 2 +- src/gallium/drivers/zink/zink_context.c | 32 ++--- src/gallium/drivers/zink/zink_descriptors.c | 28 ++-- .../drivers/zink/zink_descriptors_lazy.c | 34 ++--- src/gallium/drivers/zink/zink_draw.cpp | 129 +++++++++--------- src/gallium/drivers/zink/zink_fence.c | 4 +- src/gallium/drivers/zink/zink_framebuffer.c | 12 +- src/gallium/drivers/zink/zink_program.c | 16 +-- src/gallium/drivers/zink/zink_query.c | 77 +++++------ src/gallium/drivers/zink/zink_render_pass.c | 8 +- src/gallium/drivers/zink/zink_resource.c | 56 ++++---- src/gallium/drivers/zink/zink_screen.c | 50 +++---- src/gallium/drivers/zink/zink_screen.h | 3 + src/gallium/drivers/zink/zink_surface.c | 8 +- 18 files changed, 263 insertions(+), 262 deletions(-) diff --git a/src/gallium/drivers/zink/zink_batch.c b/src/gallium/drivers/zink/zink_batch.c index 4762f707032..8e772d8701f 100644 --- a/src/gallium/drivers/zink/zink_batch.c +++ b/src/gallium/drivers/zink/zink_batch.c @@ -30,7 +30,7 @@ zink_reset_batch_state(struct zink_context *ctx, struct zink_batch_state *bs) { struct zink_screen *screen = zink_screen(ctx->base.screen); - if (vkResetCommandPool(screen->dev, bs->cmdpool, 0) != VK_SUCCESS) + if (VKSCR(ResetCommandPool)(screen->dev, bs->cmdpool, 0) != VK_SUCCESS) debug_printf("vkResetCommandPool failed\n"); /* unref all used resources */ @@ -61,7 +61,7 @@ zink_reset_batch_state(struct zink_context *ctx, struct zink_batch_state *bs) } util_dynarray_clear(&bs->dead_framebuffers); util_dynarray_foreach(&bs->zombie_samplers, VkSampler, samp) { - vkDestroySampler(screen->dev, *samp, NULL); + VKSCR(DestroySampler)(screen->dev, *samp, NULL); } util_dynarray_clear(&bs->zombie_samplers); util_dynarray_clear(&bs->persistent_resources); @@ -130,14 +130,14 @@ zink_batch_state_destroy(struct zink_screen *screen, struct zink_batch_state *bs mtx_destroy(&bs->usage.mtx); if (bs->fence.fence) - vkDestroyFence(screen->dev, bs->fence.fence, NULL); + VKSCR(DestroyFence)(screen->dev, bs->fence.fence, NULL); if (bs->cmdbuf) - vkFreeCommandBuffers(screen->dev, bs->cmdpool, 1, &bs->cmdbuf); + VKSCR(FreeCommandBuffers)(screen->dev, bs->cmdpool, 1, &bs->cmdbuf); if (bs->barrier_cmdbuf) - vkFreeCommandBuffers(screen->dev, bs->cmdpool, 1, &bs->barrier_cmdbuf); + VKSCR(FreeCommandBuffers)(screen->dev, bs->cmdpool, 1, &bs->barrier_cmdbuf); if (bs->cmdpool) - vkDestroyCommandPool(screen->dev, bs->cmdpool, NULL); + VKSCR(DestroyCommandPool)(screen->dev, bs->cmdpool, NULL); util_dynarray_fini(&bs->zombie_samplers); util_dynarray_fini(&bs->dead_framebuffers); @@ -159,7 +159,7 @@ create_batch_state(struct zink_context *ctx) cpci.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO; cpci.queueFamilyIndex = screen->gfx_queue; cpci.flags = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT; - if (vkCreateCommandPool(screen->dev, &cpci, NULL, &bs->cmdpool) != VK_SUCCESS) + if (VKSCR(CreateCommandPool)(screen->dev, &cpci, NULL, &bs->cmdpool) != VK_SUCCESS) goto fail; VkCommandBufferAllocateInfo cbai = {0}; @@ -168,10 +168,10 @@ create_batch_state(struct zink_context *ctx) cbai.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY; cbai.commandBufferCount = 1; - if (vkAllocateCommandBuffers(screen->dev, &cbai, &bs->cmdbuf) != VK_SUCCESS) + if (VKSCR(AllocateCommandBuffers)(screen->dev, &cbai, &bs->cmdbuf) != VK_SUCCESS) goto fail; - if (vkAllocateCommandBuffers(screen->dev, &cbai, &bs->barrier_cmdbuf) != VK_SUCCESS) + if (VKSCR(AllocateCommandBuffers)(screen->dev, &cbai, &bs->barrier_cmdbuf) != VK_SUCCESS) goto fail; #define SET_CREATE_OR_FAIL(ptr) \ @@ -199,7 +199,7 @@ create_batch_state(struct zink_context *ctx) VkFenceCreateInfo fci = {0}; fci.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO; - if (vkCreateFence(screen->dev, &fci, NULL, &bs->fence.fence) != VK_SUCCESS) + if (VKSCR(CreateFence)(screen->dev, &fci, NULL, &bs->fence.fence) != VK_SUCCESS) goto fail; util_queue_fence_init(&bs->flush_completed); @@ -285,9 +285,9 @@ zink_start_batch(struct zink_context *ctx, struct zink_batch *batch) VkCommandBufferBeginInfo cbbi = {0}; cbbi.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO; cbbi.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT; - if (vkBeginCommandBuffer(batch->state->cmdbuf, &cbbi) != VK_SUCCESS) + if (VKCTX(BeginCommandBuffer)(batch->state->cmdbuf, &cbbi) != VK_SUCCESS) debug_printf("vkBeginCommandBuffer failed\n"); - if (vkBeginCommandBuffer(batch->state->barrier_cmdbuf, &cbbi) != VK_SUCCESS) + if (VKCTX(BeginCommandBuffer)(batch->state->barrier_cmdbuf, &cbbi) != VK_SUCCESS) debug_printf("vkBeginCommandBuffer failed\n"); batch->state->fence.batch_id = ctx->curr_batch; @@ -296,6 +296,7 @@ zink_start_batch(struct zink_context *ctx, struct zink_batch *batch) struct zink_batch_state *last_state = zink_batch_state(ctx->last_fence); batch->last_batch_usage = &last_state->usage; } + if (!ctx->queries_disabled) zink_resume_queries(ctx, batch); } @@ -328,7 +329,7 @@ submit_queue(void *data, void *gdata, int thread_index) bs->usage.unflushed = false; simple_mtx_unlock(&ctx->batch_mtx); - vkResetFences(screen->dev, 1, &bs->fence.fence); + VKSCR(ResetFences)(screen->dev, 1, &bs->fence.fence); uint64_t batch_id = bs->fence.batch_id; si.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO; @@ -365,12 +366,12 @@ submit_queue(void *data, void *gdata, int thread_index) si.pNext = &mem_signal; } - if (vkEndCommandBuffer(bs->cmdbuf) != VK_SUCCESS) { + if (VKSCR(EndCommandBuffer)(bs->cmdbuf) != VK_SUCCESS) { debug_printf("vkEndCommandBuffer failed\n"); bs->is_device_lost = true; goto end; } - if (vkEndCommandBuffer(bs->barrier_cmdbuf) != VK_SUCCESS) { + if (VKSCR(EndCommandBuffer)(bs->barrier_cmdbuf) != VK_SUCCESS) { debug_printf("vkEndCommandBuffer failed\n"); bs->is_device_lost = true; goto end; @@ -379,10 +380,10 @@ submit_queue(void *data, void *gdata, int thread_index) while (util_dynarray_contains(&bs->persistent_resources, struct zink_resource_object*)) { struct zink_resource_object *obj = util_dynarray_pop(&bs->persistent_resources, struct zink_resource_object*); VkMappedMemoryRange range = zink_resource_init_mem_range(screen, obj, 0, obj->size); - vkFlushMappedMemoryRanges(screen->dev, 1, &range); + VKSCR(FlushMappedMemoryRanges)(screen->dev, 1, &range); } - if (vkQueueSubmit(bs->queue, 1, &si, bs->fence.fence) != VK_SUCCESS) { + if (VKSCR(QueueSubmit)(bs->queue, 1, &si, bs->fence.fence) != VK_SUCCESS) { debug_printf("ZINK: vkQueueSubmit() failed\n"); bs->is_device_lost = true; } @@ -400,6 +401,7 @@ copy_scanout(struct zink_batch_state *bs, struct zink_resource *res) { if (!bs->scanout_flush) return; + struct zink_context *ctx = bs->ctx; VkImageCopy region = {0}; struct pipe_box box = {0, 0, 0, @@ -472,7 +474,7 @@ copy_scanout(struct zink_batch_state *bs, struct zink_resource *res) VkImageMemoryBarrier imb1; zink_resource_image_barrier_init(&imb1, res, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, VK_ACCESS_TRANSFER_READ_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT); - vkCmdPipelineBarrier( + VKCTX(CmdPipelineBarrier)( bs->cmdbuf, res->access_stage ? res->access_stage : VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, @@ -499,7 +501,7 @@ copy_scanout(struct zink_batch_state *bs, struct zink_resource *res) res->scanout_obj->image, isr }; - vkCmdPipelineBarrier( + VKCTX(CmdPipelineBarrier)( bs->cmdbuf, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, @@ -509,14 +511,14 @@ copy_scanout(struct zink_batch_state *bs, struct zink_resource *res) 1, &imb ); - vkCmdCopyImage(bs->cmdbuf, res->obj->image, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, + VKCTX(CmdCopyImage)(bs->cmdbuf, res->obj->image, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, res->scanout_obj->image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, ®ion); imb.srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT; imb.dstAccessMask = 0; imb.oldLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL; imb.newLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR; - vkCmdPipelineBarrier( + VKCTX(CmdPipelineBarrier)( bs->cmdbuf, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, diff --git a/src/gallium/drivers/zink/zink_blit.c b/src/gallium/drivers/zink/zink_blit.c index 3e216a118b3..dad367c87d8 100644 --- a/src/gallium/drivers/zink/zink_blit.c +++ b/src/gallium/drivers/zink/zink_blit.c @@ -96,7 +96,7 @@ blit_resolve(struct zink_context *ctx, const struct pipe_blit_info *info) region.extent.width = info->dst.box.width; region.extent.height = info->dst.box.height; region.extent.depth = info->dst.box.depth; - vkCmdResolveImage(batch->state->cmdbuf, src->obj->image, src->layout, + VKCTX(CmdResolveImage)(batch->state->cmdbuf, src->obj->image, src->layout, dst->obj->image, dst->layout, 1, ®ion); @@ -235,7 +235,7 @@ blit_native(struct zink_context *ctx, const struct pipe_blit_info *info) } assert(region.dstOffsets[0].z != region.dstOffsets[1].z); - vkCmdBlitImage(batch->state->cmdbuf, src->obj->image, src->layout, + VKCTX(CmdBlitImage)(batch->state->cmdbuf, src->obj->image, src->layout, dst->obj->image, dst->layout, 1, ®ion, zink_filter(info->filter)); diff --git a/src/gallium/drivers/zink/zink_bo.c b/src/gallium/drivers/zink/zink_bo.c index 29c1bd0b729..e673efefb3e 100644 --- a/src/gallium/drivers/zink/zink_bo.c +++ b/src/gallium/drivers/zink/zink_bo.c @@ -130,7 +130,7 @@ bo_destroy(struct zink_screen *screen, struct pb_buffer *pbuf) zink_bo_unmap(screen, bo); } - vkFreeMemory(screen->dev, bo->mem, NULL); + VKSCR(FreeMemory)(screen->dev, bo->mem, NULL); simple_mtx_destroy(&bo->lock); FREE(bo); @@ -265,7 +265,7 @@ bo_create_internal(struct zink_screen *screen, alignment = MAX2(alignment, screen->info.props.limits.minMemoryMapAlignment); mai.allocationSize = align(mai.allocationSize, screen->info.props.limits.minMemoryMapAlignment); } - VkResult ret = vkAllocateMemory(screen->dev, &mai, NULL, &bo->mem); + VkResult ret = VKSCR(AllocateMemory)(screen->dev, &mai, NULL, &bo->mem); if (!zink_screen_handle_vkresult(screen, ret)) goto fail; @@ -642,7 +642,7 @@ zink_bo_map(struct zink_screen *screen, struct zink_bo *bo) * be atomic thanks to the lock. */ cpu = real->u.real.cpu_ptr; if (!cpu) { - VkResult result = vkMapMemory(screen->dev, real->mem, 0, real->base.size, 0, &cpu); + VkResult result = VKSCR(MapMemory)(screen->dev, real->mem, 0, real->base.size, 0, &cpu); if (result != VK_SUCCESS) { simple_mtx_unlock(&real->lock); return NULL; @@ -665,7 +665,7 @@ zink_bo_unmap(struct zink_screen *screen, struct zink_bo *bo) if (p_atomic_dec_zero(&real->u.real.map_count)) { p_atomic_set(&real->u.real.cpu_ptr, NULL); - vkUnmapMemory(screen->dev, real->mem); + VKSCR(UnmapMemory)(screen->dev, real->mem); } } @@ -681,7 +681,7 @@ resource_commit(struct zink_screen *screen, VkBindSparseInfo *sparse) { VkQueue queue = screen->threaded ? screen->thread_queue : screen->queue; - VkResult ret = vkQueueBindSparse(queue, 1, sparse, VK_NULL_HANDLE); + VkResult ret = VKSCR(QueueBindSparse)(queue, 1, sparse, VK_NULL_HANDLE); return zink_screen_handle_vkresult(screen, ret); } diff --git a/src/gallium/drivers/zink/zink_clear.c b/src/gallium/drivers/zink/zink_clear.c index 09be568af58..eb8927db4ac 100644 --- a/src/gallium/drivers/zink/zink_clear.c +++ b/src/gallium/drivers/zink/zink_clear.c @@ -117,7 +117,7 @@ clear_in_rp(struct pipe_context *pctx, cr.baseArrayLayer = 0; cr.layerCount = util_framebuffer_get_num_layers(fb); struct zink_batch *batch = zink_batch_rp(ctx); - vkCmdClearAttachments(batch->state->cmdbuf, num_attachments, attachments, 1, &cr); + VKCTX(CmdClearAttachments)(batch->state->cmdbuf, num_attachments, attachments, 1, &cr); } static void @@ -141,7 +141,7 @@ clear_color_no_rp(struct zink_context *ctx, struct zink_resource *res, const uni zink_resource_image_needs_barrier(res, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 0, 0)) zink_resource_image_barrier(ctx, NULL, res, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 0, 0); zink_batch_reference_resource_rw(batch, res, true); - vkCmdClearColorImage(batch->state->cmdbuf, res->obj->image, res->layout, &color, 1, &range); + VKCTX(CmdClearColorImage)(batch->state->cmdbuf, res->obj->image, res->layout, &color, 1, &range); } static void @@ -161,7 +161,7 @@ clear_zs_no_rp(struct zink_context *ctx, struct zink_resource *res, VkImageAspec zink_resource_image_needs_barrier(res, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 0, 0)) zink_resource_image_barrier(ctx, NULL, res, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 0, 0); zink_batch_reference_resource_rw(batch, res, true); - vkCmdClearDepthStencilImage(batch->state->cmdbuf, res->obj->image, res->layout, &zs_value, 1, &range); + VKCTX(CmdClearDepthStencilImage)(batch->state->cmdbuf, res->obj->image, res->layout, &zs_value, 1, &range); } @@ -451,7 +451,7 @@ zink_clear_buffer(struct pipe_context *pctx, struct zink_batch *batch = 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); - vkCmdFillBuffer(batch->state->cmdbuf, res->obj->buffer, offset, size, *(uint32_t*)clear_value); + VKCTX(CmdFillBuffer)(batch->state->cmdbuf, res->obj->buffer, offset, size, *(uint32_t*)clear_value); return; } struct pipe_transfer *xfer; diff --git a/src/gallium/drivers/zink/zink_compiler.c b/src/gallium/drivers/zink/zink_compiler.c index 71d2b342577..3b02d29d8c2 100644 --- a/src/gallium/drivers/zink/zink_compiler.c +++ b/src/gallium/drivers/zink/zink_compiler.c @@ -803,7 +803,7 @@ zink_shader_compile(struct zink_screen *screen, struct zink_shader *zs, nir_shad smci.codeSize = spirv->num_words * sizeof(uint32_t); smci.pCode = spirv->words; - if (vkCreateShaderModule(screen->dev, &smci, NULL, &mod) != VK_SUCCESS) + if (VKSCR(CreateShaderModule)(screen->dev, &smci, NULL, &mod) != VK_SUCCESS) mod = VK_NULL_HANDLE; done: diff --git a/src/gallium/drivers/zink/zink_context.c b/src/gallium/drivers/zink/zink_context.c index de319393ba5..a69220d30fd 100644 --- a/src/gallium/drivers/zink/zink_context.c +++ b/src/gallium/drivers/zink/zink_context.c @@ -83,7 +83,7 @@ zink_context_destroy(struct pipe_context *pctx) struct zink_context *ctx = zink_context(pctx); struct zink_screen *screen = zink_screen(pctx->screen); - if (screen->queue && !screen->device_lost && vkQueueWaitIdle(screen->queue) != VK_SUCCESS) + if (screen->queue && !screen->device_lost && VKSCR(QueueWaitIdle)(screen->queue) != VK_SUCCESS) debug_printf("vkQueueWaitIdle failed\n"); util_blitter_destroy(ctx->blitter); @@ -361,7 +361,7 @@ zink_create_sampler_state(struct pipe_context *pctx, if (!sampler) return NULL; - if (vkCreateSampler(screen->dev, &sci, NULL, &sampler->sampler) != VK_SUCCESS) { + if (VKSCR(CreateSampler)(screen->dev, &sci, NULL, &sampler->sampler) != VK_SUCCESS) { FREE(sampler); return NULL; } @@ -628,11 +628,11 @@ get_buffer_view(struct zink_context *ctx, struct zink_resource *res, enum pipe_f p_atomic_inc(&buffer_view->reference.count); } else { VkBufferView view; - if (vkCreateBufferView(screen->dev, &bvci, NULL, &view) != VK_SUCCESS) + if (VKSCR(CreateBufferView)(screen->dev, &bvci, NULL, &view) != VK_SUCCESS) goto out; buffer_view = CALLOC_STRUCT(zink_buffer_view); if (!buffer_view) { - vkDestroyBufferView(screen->dev, view, NULL); + VKSCR(DestroyBufferView)(screen->dev, view, NULL); goto out; } pipe_reference_init(&buffer_view->reference, 1); @@ -751,7 +751,7 @@ zink_destroy_buffer_view(struct zink_screen *screen, struct zink_buffer_view *bu assert(he); _mesa_hash_table_remove(&screen->bufferview_cache, he); simple_mtx_unlock(&screen->bufferview_mtx); - vkDestroyBufferView(screen->dev, buffer_view->buffer_view, NULL); + VKSCR(DestroyBufferView)(screen->dev, buffer_view->buffer_view, NULL); zink_descriptor_set_refs_clear(&buffer_view->desc_set_refs, buffer_view); FREE(buffer_view); } @@ -1766,7 +1766,7 @@ begin_render_pass(struct zink_context *ctx) if (zink_screen(ctx->base.screen)->info.have_KHR_imageless_framebuffer) rpbi.pNext = &infos; - vkCmdBeginRenderPass(batch->state->cmdbuf, &rpbi, VK_SUBPASS_CONTENTS_INLINE); + VKCTX(CmdBeginRenderPass)(batch->state->cmdbuf, &rpbi, VK_SUBPASS_CONTENTS_INLINE); batch->in_rp = true; ctx->new_swapchain = false; return clear_buffers; @@ -1817,7 +1817,7 @@ zink_end_render_pass(struct zink_context *ctx, struct zink_batch *batch) if (batch->in_rp) { if (ctx->render_condition.query) zink_stop_conditional_render(ctx); - vkCmdEndRenderPass(batch->state->cmdbuf); + VKCTX(CmdEndRenderPass)(batch->state->cmdbuf); } batch->in_rp = false; } @@ -2381,7 +2381,7 @@ zink_resource_image_barrier(struct zink_context *ctx, struct zink_batch *batch, if (res->obj->needs_zs_evaluate) imb.pNext = &res->obj->zs_evaluate; res->obj->needs_zs_evaluate = false; - vkCmdPipelineBarrier( + VKCTX(CmdPipelineBarrier)( cmdbuf, res->access_stage ? res->access_stage : VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, pipeline, @@ -2478,7 +2478,7 @@ zink_resource_buffer_barrier(struct zink_context *ctx, struct zink_batch *batch, bmb.dstAccessMask = flags; VkCommandBuffer cmdbuf = get_cmdbuf(ctx, res); /* only barrier if we're changing layout or doing something besides read -> read */ - vkCmdPipelineBarrier( + VKCTX(CmdPipelineBarrier)( cmdbuf, res->access_stage ? res->access_stage : pipeline_access_stage(res->access), pipeline, @@ -2729,7 +2729,7 @@ zink_texture_barrier(struct pipe_context *pctx, unsigned flags) dmb.pNext = NULL; dmb.srcAccessMask = VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT; dmb.dstAccessMask = VK_ACCESS_SHADER_READ_BIT; - vkCmdPipelineBarrier( + VKCTX(CmdPipelineBarrier)( ctx->batch.state->cmdbuf, VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT | VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, @@ -2747,7 +2747,7 @@ zink_texture_barrier(struct pipe_context *pctx, unsigned flags) bmb.dstAccessMask |= VK_ACCESS_SHADER_READ_BIT; } if (bmb.srcAccessMask) - vkCmdPipelineBarrier( + VKCTX(CmdPipelineBarrier)( ctx->batch.state->cmdbuf, VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, @@ -2768,7 +2768,7 @@ mem_barrier(struct zink_context *ctx, VkPipelineStageFlags src_stage, VkPipeline mb.srcAccessMask = src; mb.dstAccessMask = dst; zink_end_render_pass(ctx, batch); - vkCmdPipelineBarrier(batch->state->cmdbuf, src_stage, dst_stage, 0, 1, &mb, 0, NULL, 0, NULL); + VKCTX(CmdPipelineBarrier)(batch->state->cmdbuf, src_stage, dst_stage, 0, 1, &mb, 0, NULL, 0, NULL); } void @@ -2864,7 +2864,7 @@ zink_copy_buffer(struct zink_context *ctx, struct zink_batch *batch, struct zink util_range_add(&dst->base.b, &dst->valid_buffer_range, dst_offset, dst_offset + size); zink_resource_buffer_barrier(ctx, batch, src, VK_ACCESS_TRANSFER_READ_BIT, 0); zink_resource_buffer_barrier(ctx, batch, dst, VK_ACCESS_TRANSFER_WRITE_BIT, 0); - vkCmdCopyBuffer(batch->state->cmdbuf, src->obj->buffer, dst->obj->buffer, 1, ®ion); + VKCTX(CmdCopyBuffer)(batch->state->cmdbuf, src->obj->buffer, dst->obj->buffer, 1, ®ion); } void @@ -2955,9 +2955,9 @@ zink_copy_image_buffer(struct zink_context *ctx, struct zink_batch *batch, struc * - vkCmdCopyBufferToImage spec */ if (buf2img) - vkCmdCopyBufferToImage(batch->state->cmdbuf, buf->obj->buffer, img->obj->image, img->layout, 1, ®ion); + VKCTX(CmdCopyBufferToImage)(batch->state->cmdbuf, buf->obj->buffer, img->obj->image, img->layout, 1, ®ion); else - vkCmdCopyImageToBuffer(batch->state->cmdbuf, img->obj->image, img->layout, buf->obj->buffer, 1, ®ion); + VKCTX(CmdCopyImageToBuffer)(batch->state->cmdbuf, img->obj->image, img->layout, buf->obj->buffer, 1, ®ion); } } @@ -3054,7 +3054,7 @@ zink_resource_copy_region(struct pipe_context *pctx, zink_batch_reference_resource_rw(batch, dst, true); zink_resource_setup_transfer_layouts(ctx, src, dst); - vkCmdCopyImage(batch->state->cmdbuf, src->obj->image, src->layout, + VKCTX(CmdCopyImage)(batch->state->cmdbuf, src->obj->image, src->layout, dst->obj->image, dst->layout, 1, ®ion); } else if (dst->base.b.target == PIPE_BUFFER && diff --git a/src/gallium/drivers/zink/zink_descriptors.c b/src/gallium/drivers/zink/zink_descriptors.c index 1fa1535d995..bd9e59054ba 100644 --- a/src/gallium/drivers/zink/zink_descriptors.c +++ b/src/gallium/drivers/zink/zink_descriptors.c @@ -264,7 +264,7 @@ descriptor_pool_free(struct zink_screen *screen, struct zink_descriptor_pool *po if (!pool) return; if (pool->descpool) - vkDestroyDescriptorPool(screen->dev, pool->descpool, NULL); + VKSCR(DestroyDescriptorPool)(screen->dev, pool->descpool, NULL); simple_mtx_lock(&pool->mtx); #ifndef NDEBUG @@ -322,7 +322,7 @@ descriptor_pool_create(struct zink_screen *screen, enum zink_descriptor_type typ dpci.poolSizeCount = num_type_sizes; dpci.flags = 0; dpci.maxSets = ZINK_DEFAULT_MAX_DESCS; - if (vkCreateDescriptorPool(screen->dev, &dpci, 0, &pool->descpool) != VK_SUCCESS) { + if (VKSCR(CreateDescriptorPool)(screen->dev, &dpci, 0, &pool->descpool) != VK_SUCCESS) { debug_printf("vkCreateDescriptorPool failed\n"); goto fail; } @@ -359,14 +359,14 @@ descriptor_layout_create(struct zink_screen *screen, enum zink_descriptor_type t supp.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT; supp.pNext = NULL; supp.supported = VK_FALSE; - if (screen->vk.GetDescriptorSetLayoutSupport) { - screen->vk.GetDescriptorSetLayoutSupport(screen->dev, &dcslci, &supp); + if (VKSCR(GetDescriptorSetLayoutSupport)) { + VKSCR(GetDescriptorSetLayoutSupport)(screen->dev, &dcslci, &supp); if (supp.supported == VK_FALSE) { debug_printf("vkGetDescriptorSetLayoutSupport claims layout is unsupported\n"); return VK_NULL_HANDLE; } } - if (vkCreateDescriptorSetLayout(screen->dev, &dcslci, 0, &dsl) != VK_SUCCESS) + if (VKSCR(CreateDescriptorSetLayout)(screen->dev, &dcslci, 0, &dsl) != VK_SUCCESS) debug_printf("vkCreateDescriptorSetLayout failed\n"); return dsl; } @@ -407,7 +407,7 @@ create_layout(struct zink_context *ctx, enum zink_descriptor_type type, k->bindings = ralloc_size(k, bindings_size); if (!k->bindings) { ralloc_free(k); - vkDestroyDescriptorSetLayout(screen->dev, dsl, NULL); + VKSCR(DestroyDescriptorSetLayout)(screen->dev, dsl, NULL); return VK_NULL_HANDLE; } memcpy(k->bindings, bindings, bindings_size); @@ -527,7 +527,7 @@ zink_descriptor_util_init_null_set(struct zink_context *ctx, VkDescriptorSet des zink_resource(ctx->dummy_vertex_buffer)->obj->buffer; push_info.offset = 0; push_info.range = VK_WHOLE_SIZE; - vkUpdateDescriptorSets(screen->dev, 1, &push_wd, 0, NULL); + VKSCR(UpdateDescriptorSets)(screen->dev, 1, &push_wd, 0, NULL); } VkImageLayout @@ -611,7 +611,7 @@ zink_descriptor_util_alloc_sets(struct zink_screen *screen, VkDescriptorSetLayou layouts[i] = dsl; dsai.pSetLayouts = layouts; - if (vkAllocateDescriptorSets(screen->dev, &dsai, sets) != VK_SUCCESS) { + if (VKSCR(AllocateDescriptorSets)(screen->dev, &dsai, sets) != VK_SUCCESS) { debug_printf("ZINK: %" PRIu64 " failed to allocate descriptor set :/\n", (uint64_t)dsl); return false; } @@ -1266,7 +1266,7 @@ update_push_ubo_descriptors(struct zink_context *ctx, struct zink_descriptor_set } if (!cache_hit) - vkUpdateDescriptorSets(screen->dev, num_stages + !!fbfetch, wds, 0, NULL); + VKSCR(UpdateDescriptorSets)(screen->dev, num_stages + !!fbfetch, wds, 0, NULL); return num_stages; } @@ -1380,7 +1380,7 @@ update_descriptors_internal(struct zink_context *ctx, struct zink_descriptor_set } } if (num_wds) - vkUpdateDescriptorSets(screen->dev, num_wds, wds, 0, NULL); + VKSCR(UpdateDescriptorSets)(screen->dev, num_wds, wds, 0, NULL); } } @@ -1434,7 +1434,7 @@ zink_descriptors_update(struct zink_context *ctx, bool is_compute) update_descriptors_internal(ctx, zds, pg, cache_hit); - vkCmdBindDescriptorSets(batch->state->cmdbuf, is_compute ? VK_PIPELINE_BIND_POINT_COMPUTE : VK_PIPELINE_BIND_POINT_GRAPHICS, + VKCTX(CmdBindDescriptorSets)(batch->state->cmdbuf, is_compute ? VK_PIPELINE_BIND_POINT_COMPUTE : VK_PIPELINE_BIND_POINT_GRAPHICS, pg->layout, 0, pg->num_dsl, sets, dynamic_offset_idx, dynamic_offsets); ctx->dd->pg[is_compute] = pg; @@ -1720,9 +1720,9 @@ zink_descriptor_layouts_deinit(struct zink_context *ctx) for (unsigned i = 0; i < ZINK_DESCRIPTOR_TYPES; i++) { hash_table_foreach(&ctx->desc_set_layouts[i], he) { struct zink_descriptor_layout *layout = he->data; - vkDestroyDescriptorSetLayout(screen->dev, layout->layout, NULL); + VKSCR(DestroyDescriptorSetLayout)(screen->dev, layout->layout, NULL); if (layout->desc_template) - screen->vk.DestroyDescriptorUpdateTemplate(screen->dev, layout->desc_template, NULL); + VKSCR(DestroyDescriptorUpdateTemplate)(screen->dev, layout->desc_template, NULL); ralloc_free(layout); _mesa_hash_table_remove(&ctx->desc_set_layouts[i], he); } @@ -1737,7 +1737,7 @@ zink_descriptor_util_init_fbfetch(struct zink_context *ctx) return; struct zink_screen *screen = zink_screen(ctx->base.screen); - vkDestroyDescriptorSetLayout(screen->dev, ctx->dd->push_dsl[0]->layout, NULL); + VKSCR(DestroyDescriptorSetLayout)(screen->dev, ctx->dd->push_dsl[0]->layout, NULL); ralloc_free(ctx->dd->push_dsl[0]); ralloc_free(ctx->dd->push_layout_keys[0]); ctx->dd->push_dsl[0] = create_gfx_layout(ctx, &ctx->dd->push_layout_keys[0], true); diff --git a/src/gallium/drivers/zink/zink_descriptors_lazy.c b/src/gallium/drivers/zink/zink_descriptors_lazy.c index d722c8a2e06..e3af4ec7ce0 100644 --- a/src/gallium/drivers/zink/zink_descriptors_lazy.c +++ b/src/gallium/drivers/zink/zink_descriptors_lazy.c @@ -274,7 +274,7 @@ zink_descriptor_program_init_lazy(struct zink_context *ctx, struct zink_program template[i].pipelineLayout = pg->layout; template[i].set = i; VkDescriptorUpdateTemplateKHR t; - if (screen->vk.CreateDescriptorUpdateTemplate(screen->dev, &template[i], NULL, &t) != VK_SUCCESS) + if (VKSCR(CreateDescriptorUpdateTemplate)(screen->dev, &template[i], NULL, &t) != VK_SUCCESS) return false; if (is_push) pg->dd->push_template = t; @@ -292,7 +292,7 @@ zink_descriptor_program_deinit_lazy(struct zink_screen *screen, struct zink_prog pg->dd->layout_key[i]->use_count--; } if (pg->dd && pg->dd->push_template) - screen->vk.DestroyDescriptorUpdateTemplate(screen->dev, pg->dd->push_template, NULL); + VKSCR(DestroyDescriptorUpdateTemplate)(screen->dev, pg->dd->push_template, NULL); ralloc_free(pg->dd); } @@ -306,7 +306,7 @@ create_pool(struct zink_screen *screen, unsigned num_type_sizes, VkDescriptorPoo dpci.poolSizeCount = num_type_sizes; dpci.flags = flags; dpci.maxSets = MAX_LAZY_DESCRIPTORS; - if (vkCreateDescriptorPool(screen->dev, &dpci, 0, &pool) != VK_SUCCESS) { + if (VKSCR(CreateDescriptorPool)(screen->dev, &dpci, 0, &pool) != VK_SUCCESS) { debug_printf("vkCreateDescriptorPool failed\n"); return VK_NULL_HANDLE; } @@ -440,7 +440,7 @@ void zink_descriptor_set_update_lazy(struct zink_context *ctx, struct zink_program *pg, enum zink_descriptor_type type, VkDescriptorSet set) { struct zink_screen *screen = zink_screen(ctx->base.screen); - screen->vk.UpdateDescriptorSetWithTemplate(screen->dev, set, pg->dd->layouts[type + 1]->desc_template, ctx); + VKCTX(UpdateDescriptorSetWithTemplate)(screen->dev, set, pg->dd->layouts[type + 1]->desc_template, ctx); } void @@ -491,9 +491,9 @@ zink_descriptors_update_lazy(struct zink_context *ctx, bool is_compute) if (pg->dd->binding_usage && changed_sets) { u_foreach_bit(type, changed_sets) { if (pg->dd->layout_key[type]) - screen->vk.UpdateDescriptorSetWithTemplate(screen->dev, desc_sets[type + 1], pg->dd->layouts[type + 1]->desc_template, ctx); + VKSCR(UpdateDescriptorSetWithTemplate)(screen->dev, desc_sets[type + 1], pg->dd->layouts[type + 1]->desc_template, ctx); assert(type + 1 < pg->num_dsl); - vkCmdBindDescriptorSets(bs->cmdbuf, + VKSCR(CmdBindDescriptorSets)(bs->cmdbuf, is_compute ? VK_PIPELINE_BIND_POINT_COMPUTE : VK_PIPELINE_BIND_POINT_GRAPHICS, /* set index incremented by 1 to account for push set */ pg->layout, type + 1, 1, &desc_sets[type + 1], @@ -504,19 +504,19 @@ zink_descriptors_update_lazy(struct zink_context *ctx, bool is_compute) if (pg->dd->push_usage && dd_lazy(ctx)->push_state_changed[is_compute]) { if (screen->info.have_KHR_push_descriptor) - screen->vk.CmdPushDescriptorSetWithTemplateKHR(batch->state->cmdbuf, pg->dd->push_template, + VKSCR(CmdPushDescriptorSetWithTemplateKHR)(batch->state->cmdbuf, pg->dd->push_template, pg->layout, 0, ctx); else { assert(desc_sets[0]); - screen->vk.UpdateDescriptorSetWithTemplate(screen->dev, desc_sets[0], pg->dd->push_template, ctx); - vkCmdBindDescriptorSets(batch->state->cmdbuf, + VKSCR(UpdateDescriptorSetWithTemplate)(screen->dev, desc_sets[0], pg->dd->push_template, ctx); + VKSCR(CmdBindDescriptorSets)(batch->state->cmdbuf, is_compute ? VK_PIPELINE_BIND_POINT_COMPUTE : VK_PIPELINE_BIND_POINT_GRAPHICS, pg->layout, 0, 1, &desc_sets[0], 0, NULL); } dd_lazy(ctx)->push_state_changed[is_compute] = false; } else if (dd_lazy(ctx)->push_state_changed[is_compute]) { - vkCmdBindDescriptorSets(bs->cmdbuf, + VKSCR(CmdBindDescriptorSets)(bs->cmdbuf, is_compute ? VK_PIPELINE_BIND_POINT_COMPUTE : VK_PIPELINE_BIND_POINT_GRAPHICS, pg->layout, 0, 1, &ctx->dd->dummy_set, 0, NULL); @@ -546,13 +546,13 @@ zink_batch_descriptor_deinit_lazy(struct zink_screen *screen, struct zink_batch_ for (unsigned i = 0; i < ZINK_DESCRIPTOR_TYPES; i++) { hash_table_foreach(&bdd->pools[i], entry) { struct zink_descriptor_pool *pool = (void*)entry->data; - vkDestroyDescriptorPool(screen->dev, pool->pool, NULL); + VKSCR(DestroyDescriptorPool)(screen->dev, pool->pool, NULL); } } if (bdd->push_pool[0]) - vkDestroyDescriptorPool(screen->dev, bdd->push_pool[0]->pool, NULL); + VKSCR(DestroyDescriptorPool)(screen->dev, bdd->push_pool[0]->pool, NULL); if (bdd->push_pool[1]) - vkDestroyDescriptorPool(screen->dev, bdd->push_pool[1]->pool, NULL); + VKSCR(DestroyDescriptorPool)(screen->dev, bdd->push_pool[1]->pool, NULL); } ralloc_free(bs->dd); } @@ -560,7 +560,7 @@ zink_batch_descriptor_deinit_lazy(struct zink_screen *screen, struct zink_batch_ static void pool_destroy(struct zink_screen *screen, struct zink_descriptor_pool *pool) { - vkDestroyDescriptorPool(screen->dev, pool->pool, NULL); + VKSCR(DestroyDescriptorPool)(screen->dev, pool->pool, NULL); ralloc_free(pool); } @@ -670,11 +670,11 @@ zink_descriptors_deinit_lazy(struct zink_context *ctx) if (ctx->dd) { struct zink_screen *screen = zink_screen(ctx->base.screen); if (ctx->dd->dummy_pool) - vkDestroyDescriptorPool(screen->dev, ctx->dd->dummy_pool, NULL); + VKSCR(DestroyDescriptorPool)(screen->dev, ctx->dd->dummy_pool, NULL); if (ctx->dd->push_dsl[0]) - vkDestroyDescriptorSetLayout(screen->dev, ctx->dd->push_dsl[0]->layout, NULL); + VKSCR(DestroyDescriptorSetLayout)(screen->dev, ctx->dd->push_dsl[0]->layout, NULL); if (ctx->dd->push_dsl[1]) - vkDestroyDescriptorSetLayout(screen->dev, ctx->dd->push_dsl[1]->layout, NULL); + VKSCR(DestroyDescriptorSetLayout)(screen->dev, ctx->dd->push_dsl[1]->layout, NULL); } ralloc_free(ctx->dd); } diff --git a/src/gallium/drivers/zink/zink_draw.cpp b/src/gallium/drivers/zink/zink_draw.cpp index 7554f3cabc2..8cc26b54dee 100644 --- a/src/gallium/drivers/zink/zink_draw.cpp +++ b/src/gallium/drivers/zink/zink_draw.cpp @@ -65,7 +65,6 @@ static void zink_emit_stream_output_targets(struct pipe_context *pctx) { struct zink_context *ctx = zink_context(pctx); - struct zink_screen *screen = zink_screen(pctx->screen); struct zink_batch *batch = &ctx->batch; VkBuffer buffers[PIPE_MAX_SO_OUTPUTS] = {0}; VkDeviceSize buffer_offsets[PIPE_MAX_SO_OUTPUTS] = {0}; @@ -95,7 +94,7 @@ zink_emit_stream_output_targets(struct pipe_context *pctx) t->base.buffer_offset + t->base.buffer_size); } - screen->vk.CmdBindTransformFeedbackBuffersEXT(batch->state->cmdbuf, 0, ctx->num_so_targets, + VKCTX(CmdBindTransformFeedbackBuffersEXT)(batch->state->cmdbuf, 0, ctx->num_so_targets, buffers, buffer_offsets, buffer_sizes); ctx->dirty_so_targets = false; @@ -157,16 +156,16 @@ zink_bind_vertex_buffers(struct zink_batch *batch, struct zink_context *ctx) } if (HAS_DYNAMIC_STATE && !HAS_VERTEX_INPUT) - screen->vk.CmdBindVertexBuffers2EXT(batch->state->cmdbuf, 0, + VKCTX(CmdBindVertexBuffers2EXT)(batch->state->cmdbuf, 0, elems->hw_state.num_bindings, buffers, buffer_offsets, NULL, buffer_strides); else - vkCmdBindVertexBuffers(batch->state->cmdbuf, 0, + VKSCR(CmdBindVertexBuffers)(batch->state->cmdbuf, 0, elems->hw_state.num_bindings, buffers, buffer_offsets); if (HAS_VERTEX_INPUT) - screen->vk.CmdSetVertexInputEXT(batch->state->cmdbuf, + VKCTX(CmdSetVertexInputEXT)(batch->state->cmdbuf, elems->hw_state.num_bindings, elems->hw_state.dynbindings, elems->hw_state.num_attribs, elems->hw_state.dynattribs); @@ -237,7 +236,7 @@ line_width_needed(enum pipe_prim_type reduced_prim, ALWAYS_INLINE static void update_drawid(struct zink_context *ctx, unsigned draw_id) { - vkCmdPushConstants(ctx->batch.state->cmdbuf, ctx->curr_program->base.layout, VK_SHADER_STAGE_VERTEX_BIT, + VKCTX(CmdPushConstants)(ctx->batch.state->cmdbuf, ctx->curr_program->base.layout, VK_SHADER_STAGE_VERTEX_BIT, offsetof(struct zink_gfx_push_constant, draw_id), sizeof(unsigned), &draw_id); } @@ -254,7 +253,7 @@ draw_indexed_need_index_buffer_unref(struct zink_context *ctx, if (dinfo->increment_draw_id && needs_drawid) { for (unsigned i = 0; i < num_draws; i++) { update_drawid(ctx, draw_id); - vkCmdDrawIndexed(cmdbuf, + VKCTX(CmdDrawIndexed)(cmdbuf, draws[i].count, dinfo->instance_count, 0, draws[i].index_bias, dinfo->start_instance); draw_id++; @@ -263,7 +262,7 @@ draw_indexed_need_index_buffer_unref(struct zink_context *ctx, if (needs_drawid) update_drawid(ctx, draw_id); for (unsigned i = 0; i < num_draws; i++) - vkCmdDrawIndexed(cmdbuf, + VKCTX(CmdDrawIndexed)(cmdbuf, draws[i].count, dinfo->instance_count, 0, draws[i].index_bias, dinfo->start_instance); @@ -283,7 +282,7 @@ draw_indexed(struct zink_context *ctx, if (dinfo->increment_draw_id && needs_drawid) { for (unsigned i = 0; i < num_draws; i++) { update_drawid(ctx, draw_id); - vkCmdDrawIndexed(cmdbuf, + VKCTX(CmdDrawIndexed)(cmdbuf, draws[i].count, dinfo->instance_count, draws[i].start, draws[i].index_bias, dinfo->start_instance); draw_id++; @@ -292,13 +291,13 @@ draw_indexed(struct zink_context *ctx, if (needs_drawid) update_drawid(ctx, draw_id); if (HAS_MULTIDRAW) { - zink_screen(ctx->base.screen)->vk.CmdDrawMultiIndexedEXT(cmdbuf, num_draws, (const VkMultiDrawIndexedInfoEXT*)draws, - dinfo->instance_count, - dinfo->start_instance, sizeof(struct pipe_draw_start_count_bias), - dinfo->index_bias_varies ? NULL : &draws[0].index_bias); + VKCTX(CmdDrawMultiIndexedEXT)(cmdbuf, num_draws, (const VkMultiDrawIndexedInfoEXT*)draws, + dinfo->instance_count, + dinfo->start_instance, sizeof(struct pipe_draw_start_count_bias), + dinfo->index_bias_varies ? NULL : &draws[0].index_bias); } else { for (unsigned i = 0; i < num_draws; i++) - vkCmdDrawIndexed(cmdbuf, + VKCTX(CmdDrawIndexed)(cmdbuf, draws[i].count, dinfo->instance_count, draws[i].start, draws[i].index_bias, dinfo->start_instance); } @@ -318,19 +317,19 @@ draw(struct zink_context *ctx, if (dinfo->increment_draw_id && needs_drawid) { for (unsigned i = 0; i < num_draws; i++) { update_drawid(ctx, draw_id); - vkCmdDraw(cmdbuf, draws[i].count, dinfo->instance_count, draws[i].start, dinfo->start_instance); + VKCTX(CmdDraw)(cmdbuf, draws[i].count, dinfo->instance_count, draws[i].start, dinfo->start_instance); draw_id++; } } else { if (needs_drawid) update_drawid(ctx, draw_id); if (HAS_MULTIDRAW) - zink_screen(ctx->base.screen)->vk.CmdDrawMultiEXT(cmdbuf, num_draws, (const VkMultiDrawInfoEXT*)draws, - dinfo->instance_count, dinfo->start_instance, - sizeof(struct pipe_draw_start_count_bias)); + VKCTX(CmdDrawMultiEXT)(cmdbuf, num_draws, (const VkMultiDrawInfoEXT*)draws, + dinfo->instance_count, dinfo->start_instance, + sizeof(struct pipe_draw_start_count_bias)); else { for (unsigned i = 0; i < num_draws; i++) - vkCmdDraw(cmdbuf, draws[i].count, dinfo->instance_count, draws[i].start, dinfo->start_instance); + VKCTX(CmdDraw)(cmdbuf, draws[i].count, dinfo->instance_count, draws[i].start, dinfo->start_instance); } } @@ -404,7 +403,7 @@ update_gfx_pipeline(struct zink_context *ctx, struct zink_batch_state *bs, enum VkPipeline pipeline = zink_get_gfx_pipeline(ctx, ctx->curr_program, &ctx->gfx_pipeline_state, mode); bool pipeline_changed = prev_pipeline != pipeline; if (BATCH_CHANGED || pipeline_changed) - vkCmdBindPipeline(bs->cmdbuf, VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline); + VKCTX(CmdBindPipeline)(bs->cmdbuf, VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline); return pipeline_changed; } @@ -496,7 +495,7 @@ zink_draw_vbo(struct pipe_context *pctx, VK_INDEX_TYPE_UINT32, }; struct zink_resource *res = zink_resource(index_buffer); - vkCmdBindIndexBuffer(batch->state->cmdbuf, res->obj->buffer, index_offset, index_type[index_size >> 1]); + VKCTX(CmdBindIndexBuffer)(batch->state->cmdbuf, res->obj->buffer, index_offset, index_type[index_size >> 1]); } bool have_streamout = !!ctx->num_so_targets; @@ -536,9 +535,9 @@ zink_draw_vbo(struct pipe_context *pctx, viewports[i] = viewport; } if (HAS_DYNAMIC_STATE) - screen->vk.CmdSetViewportWithCountEXT(batch->state->cmdbuf, ctx->vp_state.num_viewports, viewports); + VKCTX(CmdSetViewportWithCountEXT)(batch->state->cmdbuf, ctx->vp_state.num_viewports, viewports); else - vkCmdSetViewport(batch->state->cmdbuf, 0, ctx->vp_state.num_viewports, viewports); + VKCTX(CmdSetViewport)(batch->state->cmdbuf, 0, ctx->vp_state.num_viewports, viewports); } if (BATCH_CHANGED || ctx->scissor_changed || ctx->vp_state_changed || (!HAS_DYNAMIC_STATE && pipeline_changed)) { VkRect2D scissors[PIPE_MAX_VIEWPORTS]; @@ -558,39 +557,39 @@ zink_draw_vbo(struct pipe_context *pctx, } } if (HAS_DYNAMIC_STATE) - screen->vk.CmdSetScissorWithCountEXT(batch->state->cmdbuf, ctx->vp_state.num_viewports, scissors); + VKCTX(CmdSetScissorWithCountEXT)(batch->state->cmdbuf, ctx->vp_state.num_viewports, scissors); else - vkCmdSetScissor(batch->state->cmdbuf, 0, ctx->vp_state.num_viewports, scissors); + VKCTX(CmdSetScissor)(batch->state->cmdbuf, 0, ctx->vp_state.num_viewports, scissors); } ctx->vp_state_changed = false; ctx->scissor_changed = false; if (BATCH_CHANGED || ctx->stencil_ref_changed) { - vkCmdSetStencilReference(batch->state->cmdbuf, VK_STENCIL_FACE_FRONT_BIT, + VKCTX(CmdSetStencilReference)(batch->state->cmdbuf, VK_STENCIL_FACE_FRONT_BIT, ctx->stencil_ref.ref_value[0]); - vkCmdSetStencilReference(batch->state->cmdbuf, VK_STENCIL_FACE_BACK_BIT, + VKCTX(CmdSetStencilReference)(batch->state->cmdbuf, VK_STENCIL_FACE_BACK_BIT, ctx->stencil_ref.ref_value[1]); ctx->stencil_ref_changed = false; } if (HAS_DYNAMIC_STATE && (BATCH_CHANGED || ctx->dsa_state_changed)) { - screen->vk.CmdSetDepthBoundsTestEnableEXT(batch->state->cmdbuf, dsa_state->hw_state.depth_bounds_test); + VKCTX(CmdSetDepthBoundsTestEnableEXT)(batch->state->cmdbuf, dsa_state->hw_state.depth_bounds_test); if (dsa_state->hw_state.depth_bounds_test) - vkCmdSetDepthBounds(batch->state->cmdbuf, + VKCTX(CmdSetDepthBounds)(batch->state->cmdbuf, dsa_state->hw_state.min_depth_bounds, dsa_state->hw_state.max_depth_bounds); - screen->vk.CmdSetDepthTestEnableEXT(batch->state->cmdbuf, dsa_state->hw_state.depth_test); + VKCTX(CmdSetDepthTestEnableEXT)(batch->state->cmdbuf, dsa_state->hw_state.depth_test); if (dsa_state->hw_state.depth_test) - screen->vk.CmdSetDepthCompareOpEXT(batch->state->cmdbuf, dsa_state->hw_state.depth_compare_op); - screen->vk.CmdSetDepthWriteEnableEXT(batch->state->cmdbuf, dsa_state->hw_state.depth_write); - screen->vk.CmdSetStencilTestEnableEXT(batch->state->cmdbuf, dsa_state->hw_state.stencil_test); + VKCTX(CmdSetDepthCompareOpEXT)(batch->state->cmdbuf, dsa_state->hw_state.depth_compare_op); + VKCTX(CmdSetDepthWriteEnableEXT)(batch->state->cmdbuf, dsa_state->hw_state.depth_write); + VKCTX(CmdSetStencilTestEnableEXT)(batch->state->cmdbuf, dsa_state->hw_state.stencil_test); if (dsa_state->hw_state.stencil_test) { - screen->vk.CmdSetStencilOpEXT(batch->state->cmdbuf, VK_STENCIL_FACE_FRONT_BIT, + VKCTX(CmdSetStencilOpEXT)(batch->state->cmdbuf, VK_STENCIL_FACE_FRONT_BIT, dsa_state->hw_state.stencil_front.failOp, dsa_state->hw_state.stencil_front.passOp, dsa_state->hw_state.stencil_front.depthFailOp, dsa_state->hw_state.stencil_front.compareOp); - screen->vk.CmdSetStencilOpEXT(batch->state->cmdbuf, VK_STENCIL_FACE_BACK_BIT, + VKCTX(CmdSetStencilOpEXT)(batch->state->cmdbuf, VK_STENCIL_FACE_BACK_BIT, dsa_state->hw_state.stencil_back.failOp, dsa_state->hw_state.stencil_back.passOp, dsa_state->hw_state.stencil_back.depthFailOp, @@ -598,13 +597,13 @@ zink_draw_vbo(struct pipe_context *pctx, } if (dsa_state->base.stencil[0].enabled) { if (dsa_state->base.stencil[1].enabled) { - vkCmdSetStencilWriteMask(batch->state->cmdbuf, VK_STENCIL_FACE_FRONT_BIT, dsa_state->hw_state.stencil_front.writeMask); - vkCmdSetStencilWriteMask(batch->state->cmdbuf, VK_STENCIL_FACE_BACK_BIT, dsa_state->hw_state.stencil_back.writeMask); - vkCmdSetStencilCompareMask(batch->state->cmdbuf, VK_STENCIL_FACE_FRONT_BIT, dsa_state->hw_state.stencil_front.compareMask); - vkCmdSetStencilCompareMask(batch->state->cmdbuf, VK_STENCIL_FACE_BACK_BIT, dsa_state->hw_state.stencil_back.compareMask); + VKCTX(CmdSetStencilWriteMask)(batch->state->cmdbuf, VK_STENCIL_FACE_FRONT_BIT, dsa_state->hw_state.stencil_front.writeMask); + VKCTX(CmdSetStencilWriteMask)(batch->state->cmdbuf, VK_STENCIL_FACE_BACK_BIT, dsa_state->hw_state.stencil_back.writeMask); + VKCTX(CmdSetStencilCompareMask)(batch->state->cmdbuf, VK_STENCIL_FACE_FRONT_BIT, dsa_state->hw_state.stencil_front.compareMask); + VKCTX(CmdSetStencilCompareMask)(batch->state->cmdbuf, VK_STENCIL_FACE_BACK_BIT, dsa_state->hw_state.stencil_back.compareMask); } else { - vkCmdSetStencilWriteMask(batch->state->cmdbuf, VK_STENCIL_FACE_FRONT_AND_BACK, dsa_state->hw_state.stencil_front.writeMask); - vkCmdSetStencilCompareMask(batch->state->cmdbuf, VK_STENCIL_FACE_FRONT_AND_BACK, dsa_state->hw_state.stencil_front.compareMask); + VKCTX(CmdSetStencilWriteMask)(batch->state->cmdbuf, VK_STENCIL_FACE_FRONT_AND_BACK, dsa_state->hw_state.stencil_front.writeMask); + VKCTX(CmdSetStencilCompareMask)(batch->state->cmdbuf, VK_STENCIL_FACE_FRONT_AND_BACK, dsa_state->hw_state.stencil_front.compareMask); } } } @@ -612,10 +611,10 @@ zink_draw_vbo(struct pipe_context *pctx, bool rast_state_changed = ctx->rast_state_changed; if (HAS_DYNAMIC_STATE && (BATCH_CHANGED || rast_state_changed)) - screen->vk.CmdSetFrontFaceEXT(batch->state->cmdbuf, ctx->gfx_pipeline_state.dyn_state1.front_face); + VKCTX(CmdSetFrontFaceEXT)(batch->state->cmdbuf, ctx->gfx_pipeline_state.dyn_state1.front_face); if ((BATCH_CHANGED || rast_state_changed) && screen->info.have_EXT_line_rasterization && rast_state->base.line_stipple_enable) - screen->vk.CmdSetLineStippleEXT(batch->state->cmdbuf, rast_state->base.line_stipple_factor, rast_state->base.line_stipple_pattern); + VKCTX(CmdSetLineStippleEXT)(batch->state->cmdbuf, rast_state->base.line_stipple_factor, rast_state->base.line_stipple_pattern); if (BATCH_CHANGED || ctx->rast_state_changed || mode_changed) { enum pipe_prim_type reduced_prim = u_reduced_prim(mode); @@ -640,14 +639,14 @@ zink_draw_vbo(struct pipe_context *pctx, if (line_width_needed(reduced_prim, rast_state->hw_state.polygon_mode)) { if (screen->info.feats.features.wideLines || rast_state->line_width == 1.0f) - vkCmdSetLineWidth(batch->state->cmdbuf, rast_state->line_width); + VKCTX(CmdSetLineWidth)(batch->state->cmdbuf, rast_state->line_width); else debug_printf("BUG: wide lines not supported, needs fallback!"); } if (depth_bias) - vkCmdSetDepthBias(batch->state->cmdbuf, rast_state->offset_units, rast_state->offset_clamp, rast_state->offset_scale); + VKCTX(CmdSetDepthBias)(batch->state->cmdbuf, rast_state->offset_units, rast_state->offset_clamp, rast_state->offset_scale); else - vkCmdSetDepthBias(batch->state->cmdbuf, 0.0f, 0.0f, 0.0f); + VKCTX(CmdSetDepthBias)(batch->state->cmdbuf, 0.0f, 0.0f, 0.0f); } ctx->rast_state_changed = false; @@ -655,14 +654,14 @@ zink_draw_vbo(struct pipe_context *pctx, if (ctx->sample_locations_changed) { VkSampleLocationsInfoEXT loc; zink_init_vk_sample_locations(ctx, &loc); - screen->vk.CmdSetSampleLocationsEXT(batch->state->cmdbuf, &loc); + VKCTX(CmdSetSampleLocationsEXT)(batch->state->cmdbuf, &loc); } ctx->sample_locations_changed = false; } if ((BATCH_CHANGED || ctx->blend_state_changed) && ctx->gfx_pipeline_state.blend_state->need_blend_constants) { - vkCmdSetBlendConstants(batch->state->cmdbuf, ctx->blend_constants); + VKCTX(CmdSetBlendConstants)(batch->state->cmdbuf, ctx->blend_constants); } ctx->blend_state_changed = false; @@ -685,7 +684,7 @@ zink_draw_vbo(struct pipe_context *pctx, } } } - screen->vk.CmdBeginTransformFeedbackEXT(batch->state->cmdbuf, 0, ctx->num_so_targets, counter_buffers, counter_buffer_offsets); + VKCTX(CmdBeginTransformFeedbackEXT)(batch->state->cmdbuf, 0, ctx->num_so_targets, counter_buffers, counter_buffer_offsets); } if (BATCH_CHANGED) { @@ -696,11 +695,11 @@ zink_draw_vbo(struct pipe_context *pctx, if (HAS_DYNAMIC_STATE) { update_gfx_pipeline(ctx, batch->state, mode); if (BATCH_CHANGED || mode_changed) - screen->vk.CmdSetPrimitiveTopologyEXT(batch->state->cmdbuf, zink_primitive_topology(mode)); + VKCTX(CmdSetPrimitiveTopologyEXT)(batch->state->cmdbuf, zink_primitive_topology(mode)); } if (HAS_DYNAMIC_STATE2 && (BATCH_CHANGED || ctx->primitive_restart != dinfo->primitive_restart)) { - screen->vk.CmdSetPrimitiveRestartEnableEXT(batch->state->cmdbuf, dinfo->primitive_restart); + VKCTX(CmdSetPrimitiveRestartEnableEXT)(batch->state->cmdbuf, dinfo->primitive_restart); ctx->primitive_restart = dinfo->primitive_restart; } @@ -709,12 +708,12 @@ zink_draw_vbo(struct pipe_context *pctx, if (reads_basevertex) { unsigned draw_mode_is_indexed = index_size > 0; - vkCmdPushConstants(batch->state->cmdbuf, ctx->curr_program->base.layout, VK_SHADER_STAGE_VERTEX_BIT, + VKCTX(CmdPushConstants)(batch->state->cmdbuf, ctx->curr_program->base.layout, VK_SHADER_STAGE_VERTEX_BIT, offsetof(struct zink_gfx_push_constant, draw_mode_is_indexed), sizeof(unsigned), &draw_mode_is_indexed); } if (ctx->curr_program->shaders[PIPE_SHADER_TESS_CTRL] && ctx->curr_program->shaders[PIPE_SHADER_TESS_CTRL]->is_generated) - vkCmdPushConstants(batch->state->cmdbuf, ctx->curr_program->base.layout, VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT, + VKCTX(CmdPushConstants)(batch->state->cmdbuf, ctx->curr_program->base.layout, VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT, offsetof(struct zink_gfx_push_constant, default_inner_level), sizeof(float) * 6, &ctx->tess_levels[0]); @@ -730,11 +729,11 @@ zink_draw_vbo(struct pipe_context *pctx, if (dindirect->indirect_draw_count) { struct zink_resource *indirect_draw_count = zink_resource(dindirect->indirect_draw_count); zink_batch_reference_resource_rw(batch, indirect_draw_count, false); - screen->vk.CmdDrawIndexedIndirectCount(batch->state->cmdbuf, indirect->obj->buffer, dindirect->offset, - indirect_draw_count->obj->buffer, dindirect->indirect_draw_count_offset, - dindirect->draw_count, dindirect->stride); + VKCTX(CmdDrawIndexedIndirectCount)(batch->state->cmdbuf, indirect->obj->buffer, dindirect->offset, + indirect_draw_count->obj->buffer, dindirect->indirect_draw_count_offset, + dindirect->draw_count, dindirect->stride); } else - vkCmdDrawIndexedIndirect(batch->state->cmdbuf, indirect->obj->buffer, dindirect->offset, dindirect->draw_count, dindirect->stride); + VKCTX(CmdDrawIndexedIndirect)(batch->state->cmdbuf, indirect->obj->buffer, dindirect->offset, dindirect->draw_count, dindirect->stride); } else { if (need_index_buffer_unref) draw_indexed_need_index_buffer_unref(ctx, dinfo, draws, num_draws, drawid_offset, needs_drawid); @@ -747,7 +746,7 @@ zink_draw_vbo(struct pipe_context *pctx, update_drawid(ctx, drawid_offset); zink_batch_reference_resource_rw(batch, zink_resource(so_target->base.buffer), false); zink_batch_reference_resource_rw(batch, zink_resource(so_target->counter_buffer), true); - screen->vk.CmdDrawIndirectByteCountEXT(batch->state->cmdbuf, dinfo->instance_count, dinfo->start_instance, + VKCTX(CmdDrawIndirectByteCountEXT)(batch->state->cmdbuf, dinfo->instance_count, dinfo->start_instance, zink_resource(so_target->counter_buffer)->obj->buffer, so_target->counter_buffer_offset, 0, MIN2(so_target->stride, screen->info.tf_props.maxTransformFeedbackBufferDataStride)); } else if (dindirect && dindirect->buffer) { @@ -759,11 +758,11 @@ zink_draw_vbo(struct pipe_context *pctx, if (dindirect->indirect_draw_count) { struct zink_resource *indirect_draw_count = zink_resource(dindirect->indirect_draw_count); zink_batch_reference_resource_rw(batch, indirect_draw_count, false); - screen->vk.CmdDrawIndirectCount(batch->state->cmdbuf, indirect->obj->buffer, dindirect->offset, + VKCTX(CmdDrawIndirectCount)(batch->state->cmdbuf, indirect->obj->buffer, dindirect->offset, indirect_draw_count->obj->buffer, dindirect->indirect_draw_count_offset, dindirect->draw_count, dindirect->stride); } else - vkCmdDrawIndirect(batch->state->cmdbuf, indirect->obj->buffer, dindirect->offset, dindirect->draw_count, dindirect->stride); + VKCTX(CmdDrawIndirect)(batch->state->cmdbuf, indirect->obj->buffer, dindirect->offset, dindirect->draw_count, dindirect->stride); } else { draw(ctx, dinfo, draws, num_draws, drawid_offset, needs_drawid); } @@ -778,7 +777,7 @@ zink_draw_vbo(struct pipe_context *pctx, t->counter_buffer_valid = true; } } - screen->vk.CmdEndTransformFeedbackEXT(batch->state->cmdbuf, 0, ctx->num_so_targets, counter_buffers, counter_buffer_offsets); + VKCTX(CmdEndTransformFeedbackEXT)(batch->state->cmdbuf, 0, ctx->num_so_targets, counter_buffers, counter_buffer_offsets); } batch->has_work = true; batch->last_was_compute = false; @@ -813,24 +812,24 @@ zink_launch_grid(struct pipe_context *pctx, const struct pipe_grid_info *info) } if (prev_pipeline != pipeline || BATCH_CHANGED) - vkCmdBindPipeline(batch->state->cmdbuf, VK_PIPELINE_BIND_POINT_COMPUTE, pipeline); + VKCTX(CmdBindPipeline)(batch->state->cmdbuf, VK_PIPELINE_BIND_POINT_COMPUTE, pipeline); if (BATCH_CHANGED) { ctx->pipeline_changed[1] = false; zink_select_launch_grid(ctx); } if (BITSET_TEST(ctx->compute_stage->nir->info.system_values_read, SYSTEM_VALUE_WORK_DIM)) - vkCmdPushConstants(batch->state->cmdbuf, ctx->curr_compute->base.layout, VK_SHADER_STAGE_COMPUTE_BIT, + VKCTX(CmdPushConstants)(batch->state->cmdbuf, ctx->curr_compute->base.layout, VK_SHADER_STAGE_COMPUTE_BIT, offsetof(struct zink_cs_push_constant, work_dim), sizeof(uint32_t), &info->work_dim); batch->work_count++; zink_batch_no_rp(ctx); if (info->indirect) { - vkCmdDispatchIndirect(batch->state->cmdbuf, zink_resource(info->indirect)->obj->buffer, info->indirect_offset); + VKCTX(CmdDispatchIndirect)(batch->state->cmdbuf, zink_resource(info->indirect)->obj->buffer, info->indirect_offset); zink_batch_reference_resource_rw(batch, zink_resource(info->indirect), false); } else - vkCmdDispatch(batch->state->cmdbuf, info->grid[0], info->grid[1], info->grid[2]); + VKCTX(CmdDispatch)(batch->state->cmdbuf, info->grid[0], info->grid[1], info->grid[2]); batch->has_work = true; batch->last_was_compute = true; /* flush if there's >100k computes */ diff --git a/src/gallium/drivers/zink/zink_fence.c b/src/gallium/drivers/zink/zink_fence.c index b6f95462974..b2118618bc0 100644 --- a/src/gallium/drivers/zink/zink_fence.c +++ b/src/gallium/drivers/zink/zink_fence.c @@ -131,9 +131,9 @@ zink_vkfence_wait(struct zink_screen *screen, struct zink_fence *fence, uint64_t VkResult ret; if (timeout_ns) - ret = vkWaitForFences(screen->dev, 1, &fence->fence, VK_TRUE, timeout_ns); + ret = VKSCR(WaitForFences)(screen->dev, 1, &fence->fence, VK_TRUE, timeout_ns); else - ret = vkGetFenceStatus(screen->dev, fence->fence); + ret = VKSCR(GetFenceStatus)(screen->dev, fence->fence); success = zink_screen_handle_vkresult(screen, ret); if (success) { diff --git a/src/gallium/drivers/zink/zink_framebuffer.c b/src/gallium/drivers/zink/zink_framebuffer.c index 6147581383e..87b0077fc6b 100644 --- a/src/gallium/drivers/zink/zink_framebuffer.c +++ b/src/gallium/drivers/zink/zink_framebuffer.c @@ -38,10 +38,10 @@ zink_destroy_framebuffer(struct zink_screen *screen, { hash_table_foreach(&fb->objects, he) { #if defined(_WIN64) || defined(__x86_64__) - vkDestroyFramebuffer(screen->dev, he->data, NULL); + VKSCR(DestroyFramebuffer)(screen->dev, he->data, NULL); #else VkFramebuffer *ptr = he->data; - vkDestroyFramebuffer(screen->dev, *ptr, NULL); + VKSCR(DestroyFramebuffer)(screen->dev, *ptr, NULL); #endif } @@ -86,14 +86,14 @@ zink_init_framebuffer_imageless(struct zink_screen *screen, struct zink_framebuf attachments.pAttachmentImageInfos = fb->infos; fci.pNext = &attachments; - if (vkCreateFramebuffer(screen->dev, &fci, NULL, &ret) != VK_SUCCESS) + if (VKSCR(CreateFramebuffer)(screen->dev, &fci, NULL, &ret) != VK_SUCCESS) return; #if defined(_WIN64) || defined(__x86_64__) _mesa_hash_table_insert_pre_hashed(&fb->objects, hash, rp, ret); #else VkFramebuffer *ptr = ralloc(fb, VkFramebuffer); if (!ptr) { - vkDestroyFramebuffer(screen->dev, ret, NULL); + VKSCR(DestroyFramebuffer)(screen->dev, ret, NULL); return; } *ptr = ret; @@ -203,14 +203,14 @@ zink_init_framebuffer(struct zink_screen *screen, struct zink_framebuffer *fb, s fci.height = fb->state.height; fci.layers = fb->state.layers + 1; - if (vkCreateFramebuffer(screen->dev, &fci, NULL, &ret) != VK_SUCCESS) + if (VKSCR(CreateFramebuffer)(screen->dev, &fci, NULL, &ret) != VK_SUCCESS) return; #if defined(_WIN64) || defined(__x86_64__) _mesa_hash_table_insert_pre_hashed(&fb->objects, hash, rp, ret); #else VkFramebuffer *ptr = ralloc(fb, VkFramebuffer); if (!ptr) { - vkDestroyFramebuffer(screen->dev, ret, NULL); + VKSCR(DestroyFramebuffer)(screen->dev, ret, NULL); return; } *ptr = ret; diff --git a/src/gallium/drivers/zink/zink_program.c b/src/gallium/drivers/zink/zink_program.c index 253180f96f6..d0121762071 100644 --- a/src/gallium/drivers/zink/zink_program.c +++ b/src/gallium/drivers/zink/zink_program.c @@ -260,7 +260,7 @@ get_shader_module_for_stage(struct zink_context *ctx, struct zink_shader *zs, st static void zink_destroy_shader_module(struct zink_screen *screen, struct zink_shader_module *zm) { - vkDestroyShaderModule(screen->dev, zm->shader, NULL); + VKSCR(DestroyShaderModule)(screen->dev, zm->shader, NULL); free(zm); } @@ -388,7 +388,7 @@ zink_pipeline_layout_create(struct zink_screen *screen, struct zink_program *pg) plci.pPushConstantRanges = &pcr[0]; VkPipelineLayout layout; - if (vkCreatePipelineLayout(screen->dev, &plci, NULL, &layout) != VK_SUCCESS) { + if (VKSCR(CreatePipelineLayout)(screen->dev, &plci, NULL, &layout) != VK_SUCCESS) { debug_printf("vkCreatePipelineLayout failed!\n"); return VK_NULL_HANDLE; } @@ -677,7 +677,7 @@ zink_destroy_gfx_program(struct zink_screen *screen, struct zink_gfx_program *prog) { if (prog->base.layout) - vkDestroyPipelineLayout(screen->dev, prog->base.layout, NULL); + VKSCR(DestroyPipelineLayout)(screen->dev, prog->base.layout, NULL); for (int i = 0; i < ZINK_SHADER_COUNT; ++i) { if (prog->shaders[i]) { @@ -704,12 +704,12 @@ zink_destroy_gfx_program(struct zink_screen *screen, hash_table_foreach(&prog->pipelines[i], entry) { struct gfx_pipeline_cache_entry *pc_entry = entry->data; - vkDestroyPipeline(screen->dev, pc_entry->pipeline, NULL); + VKSCR(DestroyPipeline)(screen->dev, pc_entry->pipeline, NULL); free(pc_entry); } } if (prog->base.pipeline_cache) - vkDestroyPipelineCache(screen->dev, prog->base.pipeline_cache, NULL); + VKSCR(DestroyPipelineCache)(screen->dev, prog->base.pipeline_cache, NULL); screen->descriptor_program_deinit(screen, &prog->base); ralloc_free(prog); @@ -720,7 +720,7 @@ zink_destroy_compute_program(struct zink_screen *screen, struct zink_compute_program *comp) { if (comp->base.layout) - vkDestroyPipelineLayout(screen->dev, comp->base.layout, NULL); + VKSCR(DestroyPipelineLayout)(screen->dev, comp->base.layout, NULL); if (comp->shader) _mesa_set_remove_key(comp->shader->programs, comp); @@ -728,13 +728,13 @@ zink_destroy_compute_program(struct zink_screen *screen, hash_table_foreach(comp->pipelines, entry) { struct compute_pipeline_cache_entry *pc_entry = entry->data; - vkDestroyPipeline(screen->dev, pc_entry->pipeline, NULL); + VKSCR(DestroyPipeline)(screen->dev, pc_entry->pipeline, NULL); free(pc_entry); } _mesa_hash_table_destroy(comp->pipelines, NULL); destroy_shader_cache(screen, &comp->base.shader_cache[0]); if (comp->base.pipeline_cache) - vkDestroyPipelineCache(screen->dev, comp->base.pipeline_cache, NULL); + VKSCR(DestroyPipelineCache)(screen->dev, comp->base.pipeline_cache, NULL); screen->descriptor_program_deinit(screen, &comp->base); ralloc_free(comp); diff --git a/src/gallium/drivers/zink/zink_query.c b/src/gallium/drivers/zink/zink_query.c index 779d226c5f7..581425482fb 100644 --- a/src/gallium/drivers/zink/zink_query.c +++ b/src/gallium/drivers/zink/zink_query.c @@ -249,7 +249,7 @@ destroy_query(struct zink_screen *screen, struct zink_query *query) { assert(zink_screen_usage_check_completion(screen, query->batch_id)); if (query->query_pool) - vkDestroyQueryPool(screen->dev, query->query_pool, NULL); + VKSCR(DestroyQueryPool)(screen->dev, query->query_pool, NULL); struct zink_query_buffer *qbo, *next; LIST_FOR_EACH_ENTRY_SAFE(qbo, next, &query->buffers, list) { pipe_resource_reference(&qbo->buffer, NULL); @@ -259,7 +259,7 @@ destroy_query(struct zink_screen *screen, struct zink_query *query) } for (unsigned i = 0; i < ARRAY_SIZE(query->xfb_query_pool); i++) { if (query->xfb_query_pool[i]) - vkDestroyQueryPool(screen->dev, query->xfb_query_pool[i], NULL); + VKSCR(DestroyQueryPool)(screen->dev, query->xfb_query_pool[i], NULL); } pipe_resource_reference((struct pipe_resource**)&query->predicate, NULL); FREE(query); @@ -305,7 +305,7 @@ zink_create_query(struct pipe_context *pctx, else if (query_type == PIPE_QUERY_PIPELINE_STATISTICS_SINGLE) pool_create.pipelineStatistics = pipeline_statistic_convert(index); - VkResult status = vkCreateQueryPool(screen->dev, &pool_create, NULL, &query->query_pool); + VkResult status = VKSCR(CreateQueryPool)(screen->dev, &pool_create, NULL, &query->query_pool); if (status != VK_SUCCESS) goto fail; if (query_type == PIPE_QUERY_PRIMITIVES_GENERATED) { @@ -314,13 +314,13 @@ zink_create_query(struct pipe_context *pctx, pool_create.queryType = VK_QUERY_TYPE_TRANSFORM_FEEDBACK_STREAM_EXT; pool_create.queryCount = NUM_QUERIES; - status = vkCreateQueryPool(screen->dev, &pool_create, NULL, &query->xfb_query_pool[0]); + status = VKSCR(CreateQueryPool)(screen->dev, &pool_create, NULL, &query->xfb_query_pool[0]); if (status != VK_SUCCESS) goto fail; } else if (query_type == PIPE_QUERY_SO_OVERFLOW_ANY_PREDICATE) { /* need to monitor all xfb streams */ for (unsigned i = 0; i < ARRAY_SIZE(query->xfb_query_pool); i++) { - status = vkCreateQueryPool(screen->dev, &pool_create, NULL, &query->xfb_query_pool[i]); + status = VKSCR(CreateQueryPool)(screen->dev, &pool_create, NULL, &query->xfb_query_pool[i]); if (status != VK_SUCCESS) goto fail; } @@ -562,7 +562,7 @@ copy_pool_results_to_buffer(struct zink_context *ctx, struct zink_query *query, zink_resource_buffer_barrier(ctx, batch, 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); - vkCmdCopyQueryPoolResults(batch->state->cmdbuf, pool, query_id, num_results, res->obj->buffer, + VKCTX(CmdCopyQueryPoolResults)(batch->state->cmdbuf, pool, query_id, num_results, res->obj->buffer, offset, 0, flags); } @@ -585,12 +585,12 @@ reset_pool(struct zink_context *ctx, struct zink_batch *batch, struct zink_query if (q->needs_update) update_qbo(ctx, q); - vkCmdResetQueryPool(batch->state->cmdbuf, q->query_pool, 0, NUM_QUERIES); + VKCTX(CmdResetQueryPool)(batch->state->cmdbuf, q->query_pool, 0, NUM_QUERIES); if (q->type == PIPE_QUERY_PRIMITIVES_GENERATED) - vkCmdResetQueryPool(batch->state->cmdbuf, q->xfb_query_pool[0], 0, NUM_QUERIES); + VKCTX(CmdResetQueryPool)(batch->state->cmdbuf, q->xfb_query_pool[0], 0, NUM_QUERIES); else if (q->type == PIPE_QUERY_SO_OVERFLOW_ANY_PREDICATE) { for (unsigned i = 0; i < ARRAY_SIZE(q->xfb_query_pool); i++) - vkCmdResetQueryPool(batch->state->cmdbuf, q->xfb_query_pool[i], 0, NUM_QUERIES); + VKCTX(CmdResetQueryPool)(batch->state->cmdbuf, q->xfb_query_pool[i], 0, NUM_QUERIES); } memset(q->have_gs, 0, sizeof(q->have_gs)); memset(q->have_xfb, 0, sizeof(q->have_xfb)); @@ -665,7 +665,7 @@ begin_query(struct zink_context *ctx, struct zink_batch *batch, struct zink_quer q->active = true; batch->has_work = true; if (q->type == PIPE_QUERY_TIME_ELAPSED) { - vkCmdWriteTimestamp(batch->state->cmdbuf, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, q->query_pool, q->curr_query); + VKCTX(CmdWriteTimestamp)(batch->state->cmdbuf, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, q->query_pool, q->curr_query); q->curr_query++; update_qbo(ctx, q); zink_batch_usage_set(&q->batch_id, batch->state); @@ -679,28 +679,28 @@ begin_query(struct zink_context *ctx, struct zink_batch *batch, struct zink_quer if (q->type == PIPE_QUERY_PRIMITIVES_EMITTED || q->type == PIPE_QUERY_PRIMITIVES_GENERATED || q->type == PIPE_QUERY_SO_OVERFLOW_PREDICATE) { - zink_screen(ctx->base.screen)->vk.CmdBeginQueryIndexedEXT(batch->state->cmdbuf, - q->xfb_query_pool[0] ? q->xfb_query_pool[0] : q->query_pool, - q->curr_query, - flags, - q->index); + VKCTX(CmdBeginQueryIndexedEXT)(batch->state->cmdbuf, + q->xfb_query_pool[0] ? q->xfb_query_pool[0] : q->query_pool, + q->curr_query, + flags, + q->index); q->xfb_running = true; } else if (q->type == PIPE_QUERY_SO_OVERFLOW_ANY_PREDICATE) { - zink_screen(ctx->base.screen)->vk.CmdBeginQueryIndexedEXT(batch->state->cmdbuf, - q->query_pool, - q->curr_query, - flags, - 0); + VKCTX(CmdBeginQueryIndexedEXT)(batch->state->cmdbuf, + q->query_pool, + q->curr_query, + flags, + 0); for (unsigned i = 0; i < ARRAY_SIZE(q->xfb_query_pool); i++) - zink_screen(ctx->base.screen)->vk.CmdBeginQueryIndexedEXT(batch->state->cmdbuf, - q->xfb_query_pool[i], - q->curr_query, - flags, - i + 1); + VKCTX(CmdBeginQueryIndexedEXT)(batch->state->cmdbuf, + q->xfb_query_pool[i], + q->curr_query, + flags, + i + 1); q->xfb_running = true; } if (q->vkqtype != VK_QUERY_TYPE_TRANSFORM_FEEDBACK_STREAM_EXT) - vkCmdBeginQuery(batch->state->cmdbuf, q->query_pool, q->curr_query, flags); + VKCTX(CmdBeginQuery)(batch->state->cmdbuf, q->query_pool, q->curr_query, flags); if (needs_stats_list(q)) list_addtail(&q->stats_list, &ctx->primitives_generated_queries); zink_batch_usage_set(&q->batch_id, batch->state); @@ -742,7 +742,6 @@ update_query_id(struct zink_context *ctx, struct zink_query *q) static void end_query(struct zink_context *ctx, struct zink_batch *batch, struct zink_query *q) { - struct zink_screen *screen = zink_screen(ctx->base.screen); ASSERTED struct zink_query_buffer *qbo = q->curr_qbo; assert(qbo); assert(!is_time_query(q)); @@ -750,19 +749,19 @@ end_query(struct zink_context *ctx, struct zink_batch *batch, struct zink_query if (q->type == PIPE_QUERY_PRIMITIVES_EMITTED || q->type == PIPE_QUERY_PRIMITIVES_GENERATED || q->type == PIPE_QUERY_SO_OVERFLOW_PREDICATE) { - screen->vk.CmdEndQueryIndexedEXT(batch->state->cmdbuf, q->xfb_query_pool[0] ? q->xfb_query_pool[0] : - q->query_pool, - q->curr_query, q->index); + VKCTX(CmdEndQueryIndexedEXT)(batch->state->cmdbuf, + q->xfb_query_pool[0] ? q->xfb_query_pool[0] : q->query_pool, + q->curr_query, q->index); } else if (q->type == PIPE_QUERY_SO_OVERFLOW_ANY_PREDICATE) { - screen->vk.CmdEndQueryIndexedEXT(batch->state->cmdbuf, q->query_pool, q->curr_query, 0); + VKCTX(CmdEndQueryIndexedEXT)(batch->state->cmdbuf, q->query_pool, q->curr_query, 0); for (unsigned i = 0; i < ARRAY_SIZE(q->xfb_query_pool); i++) { - screen->vk.CmdEndQueryIndexedEXT(batch->state->cmdbuf, q->xfb_query_pool[i], q->curr_query, i + 1); + VKCTX(CmdEndQueryIndexedEXT)(batch->state->cmdbuf, q->xfb_query_pool[i], q->curr_query, i + 1); } } if (q->vkqtype != VK_QUERY_TYPE_TRANSFORM_FEEDBACK_STREAM_EXT && !is_time_query(q)) - vkCmdEndQuery(batch->state->cmdbuf, q->query_pool, q->curr_query); + VKCTX(CmdEndQuery)(batch->state->cmdbuf, q->query_pool, q->curr_query); if (needs_stats_list(q)) list_delinit(&q->stats_list); @@ -791,7 +790,7 @@ zink_end_query(struct pipe_context *pctx, if (is_time_query(query)) { if (query->needs_reset) reset_pool(ctx, batch, query); - vkCmdWriteTimestamp(batch->state->cmdbuf, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, + VKCTX(CmdWriteTimestamp)(batch->state->cmdbuf, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, query->query_pool, query->curr_query); zink_batch_usage_set(&query->batch_id, batch->state); _mesa_set_add(batch->state->active_queries, query); @@ -894,7 +893,6 @@ void zink_start_conditional_render(struct zink_context *ctx) { struct zink_batch *batch = &ctx->batch; - struct zink_screen *screen = zink_screen(ctx->base.screen); VkConditionalRenderingFlagsEXT begin_flags = 0; if (ctx->render_condition.inverted) begin_flags = VK_CONDITIONAL_RENDERING_INVERTED_BIT_EXT; @@ -902,7 +900,7 @@ zink_start_conditional_render(struct zink_context *ctx) begin_info.sType = VK_STRUCTURE_TYPE_CONDITIONAL_RENDERING_BEGIN_INFO_EXT; begin_info.buffer = ctx->render_condition.query->predicate->obj->buffer; begin_info.flags = begin_flags; - screen->vk.CmdBeginConditionalRenderingEXT(batch->state->cmdbuf, &begin_info); + VKCTX(CmdBeginConditionalRenderingEXT)(batch->state->cmdbuf, &begin_info); zink_batch_reference_resource_rw(batch, ctx->render_condition.query->predicate, false); } @@ -910,9 +908,8 @@ void zink_stop_conditional_render(struct zink_context *ctx) { struct zink_batch *batch = &ctx->batch; - struct zink_screen *screen = zink_screen(ctx->base.screen); zink_clear_apply_conditionals(ctx); - screen->vk.CmdEndConditionalRenderingEXT(batch->state->cmdbuf); + VKCTX(CmdEndConditionalRenderingEXT)(batch->state->cmdbuf); } static void @@ -1001,7 +998,7 @@ zink_get_query_result_resource(struct pipe_context *pctx, VkQueryResultFlags flag = is_time_query(query) ? 0 : VK_QUERY_RESULT_PARTIAL_BIT; if (zink_batch_usage_check_completion(ctx, query->batch_id)) { uint64_t u64[2] = {0}; - if (vkGetQueryPoolResults(screen->dev, query->query_pool, query_id, 1, 2 * result_size, u64, + if (VKCTX(GetQueryPoolResults)(screen->dev, query->query_pool, query_id, 1, 2 * result_size, u64, 0, size_flags | VK_QUERY_RESULT_WITH_AVAILABILITY_BIT | flag) == VK_SUCCESS) { pipe_buffer_write(pctx, pres, offset, result_size, (unsigned char*)u64 + result_size); return; @@ -1049,7 +1046,7 @@ zink_get_timestamp(struct pipe_context *pctx) VkCalibratedTimestampInfoEXT cti = {0}; cti.sType = VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_EXT; cti.timeDomain = VK_TIME_DOMAIN_DEVICE_EXT; - screen->vk.GetCalibratedTimestampsEXT(screen->dev, 1, &cti, ×tamp, &deviation); + VKSCR(GetCalibratedTimestampsEXT)(screen->dev, 1, &cti, ×tamp, &deviation); timestamp_to_nanoseconds(screen, ×tamp); return timestamp; } diff --git a/src/gallium/drivers/zink/zink_render_pass.c b/src/gallium/drivers/zink/zink_render_pass.c index a2508141fa4..132dcd0d278 100644 --- a/src/gallium/drivers/zink/zink_render_pass.c +++ b/src/gallium/drivers/zink/zink_render_pass.c @@ -29,7 +29,7 @@ #include "util/u_string.h" static VkRenderPass -create_render_pass(VkDevice dev, struct zink_render_pass_state *state, struct zink_render_pass_pipeline_state *pstate) +create_render_pass(struct zink_screen *screen, struct zink_render_pass_state *state, struct zink_render_pass_pipeline_state *pstate) { VkAttachmentReference color_refs[PIPE_MAX_COLOR_BUFS], zs_ref; @@ -118,7 +118,7 @@ create_render_pass(VkDevice dev, struct zink_render_pass_state *state, struct zi rpci.pDependencies = deps; VkRenderPass render_pass; - if (vkCreateRenderPass(dev, &rpci, NULL, &render_pass) != VK_SUCCESS) { + if (VKSCR(CreateRenderPass)(screen->dev, &rpci, NULL, &render_pass) != VK_SUCCESS) { debug_printf("vkCreateRenderPass failed\n"); return VK_NULL_HANDLE; } @@ -135,7 +135,7 @@ zink_create_render_pass(struct zink_screen *screen, if (!rp) goto fail; - rp->render_pass = create_render_pass(screen->dev, state, pstate); + rp->render_pass = create_render_pass(screen, state, pstate); if (!rp->render_pass) goto fail; memcpy(&rp->state, state, sizeof(struct zink_render_pass_state)); @@ -151,7 +151,7 @@ void zink_destroy_render_pass(struct zink_screen *screen, struct zink_render_pass *rp) { - vkDestroyRenderPass(screen->dev, rp->render_pass, NULL); + VKSCR(DestroyRenderPass)(screen->dev, rp->render_pass, NULL); FREE(rp); } diff --git a/src/gallium/drivers/zink/zink_resource.c b/src/gallium/drivers/zink/zink_resource.c index bb242993c04..e5b178ce756 100644 --- a/src/gallium/drivers/zink/zink_resource.c +++ b/src/gallium/drivers/zink/zink_resource.c @@ -73,10 +73,10 @@ zink_destroy_resource_object(struct zink_screen *screen, struct zink_resource_ob { if (obj->is_buffer) { util_dynarray_foreach(&obj->tmp, VkBuffer, buffer) - vkDestroyBuffer(screen->dev, *buffer, NULL); - vkDestroyBuffer(screen->dev, obj->buffer, NULL); + VKSCR(DestroyBuffer)(screen->dev, *buffer, NULL); + VKSCR(DestroyBuffer)(screen->dev, obj->buffer, NULL); } else { - vkDestroyImage(screen->dev, obj->image, NULL); + VKSCR(DestroyImage)(screen->dev, obj->image, NULL); } util_dynarray_fini(&obj->tmp); @@ -156,8 +156,8 @@ check_ici(struct zink_screen *screen, VkImageCreateInfo *ici, uint64_t modifier) VkImageFormatProperties image_props; VkResult ret; assert(modifier == DRM_FORMAT_MOD_INVALID || - (screen->vk.GetPhysicalDeviceImageFormatProperties2 && screen->info.have_EXT_image_drm_format_modifier)); - if (screen->vk.GetPhysicalDeviceImageFormatProperties2) { + (VKSCR(GetPhysicalDeviceImageFormatProperties2) && screen->info.have_EXT_image_drm_format_modifier)); + if (VKSCR(GetPhysicalDeviceImageFormatProperties2)) { VkImageFormatProperties2 props2; props2.sType = VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2; props2.pNext = NULL; @@ -180,10 +180,10 @@ check_ici(struct zink_screen *screen, VkImageCreateInfo *ici, uint64_t modifier) } else info.pNext = NULL; - ret = screen->vk.GetPhysicalDeviceImageFormatProperties2(screen->pdev, &info, &props2); + ret = VKSCR(GetPhysicalDeviceImageFormatProperties2)(screen->pdev, &info, &props2); image_props = props2.imageFormatProperties; } else - ret = vkGetPhysicalDeviceImageFormatProperties(screen->pdev, ici->format, ici->imageType, + ret = VKSCR(GetPhysicalDeviceImageFormatProperties)(screen->pdev, ici->format, ici->imageType, ici->tiling, ici->usage, ici->flags, &image_props); return ret == VK_SUCCESS; } @@ -435,12 +435,12 @@ resource_object_create(struct zink_screen *screen, const struct pipe_resource *t if (templ->target == PIPE_BUFFER) { VkBufferCreateInfo bci = create_bci(screen, templ, templ->bind); - if (vkCreateBuffer(screen->dev, &bci, NULL, &obj->buffer) != VK_SUCCESS) { + if (VKSCR(CreateBuffer)(screen->dev, &bci, NULL, &obj->buffer) != VK_SUCCESS) { debug_printf("vkCreateBuffer failed\n"); goto fail1; } - vkGetBufferMemoryRequirements(screen->dev, obj->buffer, &reqs); + VKSCR(GetBufferMemoryRequirements)(screen->dev, obj->buffer, &reqs); if (templ->usage == PIPE_USAGE_STAGING) flags = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_CACHED_BIT; else if (templ->usage == PIPE_USAGE_STREAM) @@ -527,13 +527,13 @@ resource_object_create(struct zink_screen *screen, const struct pipe_resource *t ici.pNext = &image_wsi_info; } - VkResult result = vkCreateImage(screen->dev, &ici, NULL, &obj->image); + VkResult result = VKSCR(CreateImage)(screen->dev, &ici, NULL, &obj->image); if (result != VK_SUCCESS) { debug_printf("vkCreateImage failed\n"); goto fail1; } - if (screen->vk.GetImageMemoryRequirements2) { + if (VKSCR(GetImageMemoryRequirements2)) { VkMemoryRequirements2 req2; req2.sType = VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2; VkImageMemoryRequirementsInfo2 info2; @@ -544,11 +544,11 @@ resource_object_create(struct zink_screen *screen, const struct pipe_resource *t ded.sType = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS; ded.pNext = NULL; req2.pNext = &ded; - screen->vk.GetImageMemoryRequirements2(screen->dev, &info2, &req2); + VKSCR(GetImageMemoryRequirements2)(screen->dev, &info2, &req2); memcpy(&reqs, &req2.memoryRequirements, sizeof(VkMemoryRequirements)); need_dedicated = ded.prefersDedicatedAllocation || ded.requiresDedicatedAllocation; } else { - vkGetImageMemoryRequirements(screen->dev, obj->image, &reqs); + VKSCR(GetImageMemoryRequirements)(screen->dev, obj->image, &reqs); } if (templ->usage == PIPE_USAGE_STAGING && ici.tiling == VK_IMAGE_TILING_LINEAR) flags = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT; @@ -657,10 +657,10 @@ resource_object_create(struct zink_screen *screen, const struct pipe_resource *t if (templ->target == PIPE_BUFFER) { if (!(templ->flags & PIPE_RESOURCE_FLAG_SPARSE)) - if (vkBindBufferMemory(screen->dev, obj->buffer, zink_bo_get_mem(obj->bo), obj->offset) != VK_SUCCESS) + if (VKSCR(BindBufferMemory)(screen->dev, obj->buffer, zink_bo_get_mem(obj->bo), obj->offset) != VK_SUCCESS) goto fail3; } else { - if (vkBindImageMemory(screen->dev, obj->image, zink_bo_get_mem(obj->bo), obj->offset) != VK_SUCCESS) + if (VKSCR(BindImageMemory)(screen->dev, obj->image, zink_bo_get_mem(obj->bo), obj->offset) != VK_SUCCESS) goto fail3; } return obj; @@ -670,9 +670,9 @@ fail3: fail2: if (templ->target == PIPE_BUFFER) - vkDestroyBuffer(screen->dev, obj->buffer, NULL); + VKSCR(DestroyBuffer)(screen->dev, obj->buffer, NULL); else - vkDestroyImage(screen->dev, obj->image, NULL); + VKSCR(DestroyImage)(screen->dev, obj->image, NULL); fail1: FREE(obj); return NULL; @@ -801,7 +801,7 @@ zink_resource_get_param(struct pipe_screen *pscreen, struct pipe_context *pctx, sub_res.aspectMask = aspect; - vkGetImageSubresourceLayout(screen->dev, obj->image, &sub_res, &sub_res_layout); + VKSCR(GetImageSubresourceLayout)(screen->dev, obj->image, &sub_res, &sub_res_layout); *value = sub_res_layout.rowPitch; break; @@ -814,7 +814,7 @@ zink_resource_get_param(struct pipe_screen *pscreen, struct pipe_context *pctx, layer }; VkSubresourceLayout srl; - vkGetImageSubresourceLayout(screen->dev, obj->image, &isr, &srl); + VKSCR(GetImageSubresourceLayout)(screen->dev, obj->image, &isr, &srl); *value = srl.offset; break; } @@ -828,7 +828,7 @@ zink_resource_get_param(struct pipe_screen *pscreen, struct pipe_context *pctx, VkImageDrmFormatModifierPropertiesEXT prop; prop.sType = VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT; prop.pNext = NULL; - if (screen->vk.GetImageDrmFormatModifierPropertiesEXT(screen->dev, obj->image, &prop) == VK_SUCCESS) + if (VKSCR(GetImageDrmFormatModifierPropertiesEXT)(screen->dev, obj->image, &prop) == VK_SUCCESS) *value = prop.drmFormatModifier; break; } @@ -840,7 +840,7 @@ zink_resource_get_param(struct pipe_screen *pscreen, struct pipe_context *pctx, layer }; VkSubresourceLayout srl; - vkGetImageSubresourceLayout(screen->dev, obj->image, &isr, &srl); + VKSCR(GetImageSubresourceLayout)(screen->dev, obj->image, &isr, &srl); if (res->base.b.target == PIPE_TEXTURE_3D) *value = srl.depthPitch; else @@ -889,7 +889,7 @@ zink_resource_get_handle(struct pipe_screen *pscreen, //TODO: remove for wsi fd_info.memory = zink_bo_get_mem(obj->bo); fd_info.handleType = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT; - VkResult result = (*screen->vk.GetMemoryFdKHR)(screen->dev, &fd_info, &fd); + VkResult result = VKSCR(GetMemoryFdKHR)(screen->dev, &fd_info, &fd); if (result != VK_SUCCESS) return false; whandle->handle = fd; @@ -1235,7 +1235,7 @@ zink_buffer_map(struct pipe_context *pctx, VkDeviceSize size = box->width; VkDeviceSize offset = res->obj->offset + trans->offset; VkMappedMemoryRange range = zink_resource_init_mem_range(screen, res->obj, offset, size); - if (vkInvalidateMappedMemoryRanges(screen->dev, 1, &range) != VK_SUCCESS) { + if (VKSCR(InvalidateMappedMemoryRanges)(screen->dev, 1, &range) != VK_SUCCESS) { zink_bo_unmap(screen, res->obj->bo); goto fail; } @@ -1334,7 +1334,7 @@ zink_image_map(struct pipe_context *pctx, 0 }; VkSubresourceLayout srl; - vkGetImageSubresourceLayout(screen->dev, res->obj->image, &isr, &srl); + VKSCR(GetImageSubresourceLayout)(screen->dev, res->obj->image, &isr, &srl); trans->base.b.stride = srl.rowPitch; if (res->base.b.target == PIPE_TEXTURE_3D) trans->base.b.layer_stride = srl.depthPitch; @@ -1350,7 +1350,7 @@ zink_image_map(struct pipe_context *pctx, if (!res->obj->coherent) { VkDeviceSize size = (VkDeviceSize)box->width * box->height * desc->block.bits / 8; VkMappedMemoryRange range = zink_resource_init_mem_range(screen, res->obj, res->obj->offset + offset, size); - vkFlushMappedMemoryRanges(screen->dev, 1, &range); + VKSCR(FlushMappedMemoryRanges)(screen->dev, 1, &range); } ptr = ((uint8_t *)ptr) + offset; } @@ -1397,7 +1397,7 @@ zink_transfer_flush_region(struct pipe_context *pctx, } if (!m->obj->coherent) { VkMappedMemoryRange range = zink_resource_init_mem_range(screen, m->obj, m->obj->offset, m->obj->size); - vkFlushMappedMemoryRanges(screen->dev, 1, &range); + VKSCR(FlushMappedMemoryRanges)(screen->dev, 1, &range); } if (trans->staging_res) { struct zink_resource *staging_res = zink_resource(trans->staging_res); @@ -1509,9 +1509,9 @@ zink_resource_tmp_buffer(struct zink_screen *screen, struct zink_resource *res, bci.size = size; VkBuffer buffer; - if (vkCreateBuffer(screen->dev, &bci, NULL, &buffer) != VK_SUCCESS) + if (VKSCR(CreateBuffer)(screen->dev, &bci, NULL, &buffer) != VK_SUCCESS) return VK_NULL_HANDLE; - vkBindBufferMemory(screen->dev, buffer, zink_bo_get_mem(res->obj->bo), res->obj->offset + offset); + VKSCR(BindBufferMemory)(screen->dev, buffer, zink_bo_get_mem(res->obj->bo), res->obj->offset + offset); if (offset_out) *offset_out = offset_add - offset; return buffer; diff --git a/src/gallium/drivers/zink/zink_screen.c b/src/gallium/drivers/zink/zink_screen.c index 32ec458d771..8b810ac6d6a 100644 --- a/src/gallium/drivers/zink/zink_screen.c +++ b/src/gallium/drivers/zink/zink_screen.c @@ -165,14 +165,14 @@ cache_put_job(void *data, void *gdata, int thread_index) struct zink_program *pg = data; struct zink_screen *screen = gdata; size_t size = 0; - if (vkGetPipelineCacheData(screen->dev, pg->pipeline_cache, &size, NULL) != VK_SUCCESS) + if (VKSCR(GetPipelineCacheData)(screen->dev, pg->pipeline_cache, &size, NULL) != VK_SUCCESS) return; if (pg->pipeline_cache_size == size) return; void *pipeline_data = malloc(size); if (!pipeline_data) return; - if (vkGetPipelineCacheData(screen->dev, pg->pipeline_cache, &size, pipeline_data) == VK_SUCCESS) { + if (VKSCR(GetPipelineCacheData)(screen->dev, pg->pipeline_cache, &size, pipeline_data) == VK_SUCCESS) { pg->pipeline_cache_size = size; cache_key key; @@ -208,7 +208,7 @@ cache_get_job(void *data, void *gdata, int thread_index) disk_cache_compute_key(screen->disk_cache, pg->sha1, sizeof(pg->sha1), key); pcci.pInitialData = disk_cache_get(screen->disk_cache, key, &pg->pipeline_cache_size); pcci.initialDataSize = pg->pipeline_cache_size; - vkCreatePipelineCache(screen->dev, &pcci, NULL, &pg->pipeline_cache); + VKSCR(CreatePipelineCache)(screen->dev, &pcci, NULL, &pg->pipeline_cache); free((void*)pcci.pInitialData); } @@ -1056,7 +1056,7 @@ zink_destroy_screen(struct pipe_screen *pscreen) struct zink_screen *screen = zink_screen(pscreen); if (VK_NULL_HANDLE != screen->debugUtilsCallbackHandle) { - screen->vk.DestroyDebugUtilsMessengerEXT(screen->instance, screen->debugUtilsCallbackHandle, NULL); + VKSCR(DestroyDebugUtilsMessengerEXT)(screen->instance, screen->debugUtilsCallbackHandle, NULL); } hash_table_foreach(&screen->surface_cache, entry) { @@ -1096,14 +1096,14 @@ zink_destroy_screen(struct pipe_screen *pscreen) util_live_shader_cache_deinit(&screen->shaders); if (screen->sem) - vkDestroySemaphore(screen->dev, screen->sem, NULL); + VKSCR(DestroySemaphore)(screen->dev, screen->sem, NULL); if (screen->prev_sem) - vkDestroySemaphore(screen->dev, screen->prev_sem, NULL); + VKSCR(DestroySemaphore)(screen->dev, screen->prev_sem, NULL); if (screen->threaded) util_queue_destroy(&screen->flush_queue); - vkDestroyDevice(screen->dev, NULL); + VKSCR(DestroyDevice)(screen->dev, NULL); vkDestroyInstance(screen->instance, NULL); util_idalloc_mt_fini(&screen->buffer_ids); @@ -1231,7 +1231,7 @@ bool zink_is_depth_format_supported(struct zink_screen *screen, VkFormat format) { VkFormatProperties props; - vkGetPhysicalDeviceFormatProperties(screen->pdev, format, &props); + VKSCR(GetPhysicalDeviceFormatProperties)(screen->pdev, format, &props); return (props.linearTilingFeatures | props.optimalTilingFeatures) & VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT; } @@ -1330,11 +1330,11 @@ static bool check_have_device_time(struct zink_screen *screen) { uint32_t num_domains = 0; - screen->vk.GetPhysicalDeviceCalibrateableTimeDomainsEXT(screen->pdev, &num_domains, NULL); + VKSCR(GetPhysicalDeviceCalibrateableTimeDomainsEXT)(screen->pdev, &num_domains, NULL); assert(num_domains > 0); VkTimeDomainEXT *domains = malloc(sizeof(VkTimeDomainEXT) * num_domains); - screen->vk.GetPhysicalDeviceCalibrateableTimeDomainsEXT(screen->pdev, &num_domains, domains); + VKSCR(GetPhysicalDeviceCalibrateableTimeDomainsEXT)(screen->pdev, &num_domains, domains); /* VK_TIME_DOMAIN_DEVICE_EXT is used for the ctx->get_timestamp hook and is the only one we really need */ for (unsigned i = 0; i < num_domains; i++) { @@ -1390,7 +1390,7 @@ create_debug(struct zink_screen *screen) VkDebugUtilsMessengerEXT vkDebugUtilsCallbackEXT = VK_NULL_HANDLE; - screen->vk.CreateDebugUtilsMessengerEXT( + VKSCR(CreateDebugUtilsMessengerEXT)( screen->instance, &vkDebugUtilsMessengerCreateInfoEXT, NULL, @@ -1462,7 +1462,7 @@ populate_format_props(struct zink_screen *screen) VkFormat format = zink_get_format(screen, i); if (!format) continue; - if (screen->vk.GetPhysicalDeviceFormatProperties2) { + if (VKSCR(GetPhysicalDeviceFormatProperties2)) { VkFormatProperties2 props = {0}; props.sType = VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2; @@ -1475,7 +1475,7 @@ populate_format_props(struct zink_screen *screen) mod_props.pDrmFormatModifierProperties = mods; props.pNext = &mod_props; } - screen->vk.GetPhysicalDeviceFormatProperties2(screen->pdev, format, &props); + VKSCR(GetPhysicalDeviceFormatProperties2)(screen->pdev, format, &props); screen->format_props[i] = props.formatProperties; if (screen->info.have_EXT_image_drm_format_modifier && mod_props.drmFormatModifierCount) { screen->modifier_props[i].drmFormatModifierCount = mod_props.drmFormatModifierCount; @@ -1486,7 +1486,7 @@ populate_format_props(struct zink_screen *screen) } } } else - vkGetPhysicalDeviceFormatProperties(screen->pdev, format, &screen->format_props[i]); + VKSCR(GetPhysicalDeviceFormatProperties)(screen->pdev, format, &screen->format_props[i]); } } @@ -1501,12 +1501,12 @@ zink_screen_init_semaphore(struct zink_screen *screen) tci.sType = VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO; tci.semaphoreType = VK_SEMAPHORE_TYPE_TIMELINE; - if (vkCreateSemaphore(screen->dev, &sci, NULL, &sem) == VK_SUCCESS) { + if (VKSCR(CreateSemaphore)(screen->dev, &sci, NULL, &sem) == VK_SUCCESS) { /* semaphore signal values can never decrease, * so we need a new semaphore anytime we overflow */ if (screen->prev_sem) - vkDestroySemaphore(screen->dev, screen->prev_sem, NULL); + VKSCR(DestroySemaphore)(screen->dev, screen->prev_sem, NULL); screen->prev_sem = screen->sem; screen->sem = sem; return true; @@ -1532,7 +1532,7 @@ zink_screen_timeline_wait(struct zink_screen *screen, uint32_t batch_id, uint64_ bool success = false; if (screen->device_lost) return true; - VkResult ret = screen->vk.WaitSemaphores(screen->dev, &wi, timeout); + VkResult ret = VKSCR(WaitSemaphores)(screen->dev, &wi, timeout); success = zink_screen_handle_vkresult(screen, ret); if (success) @@ -1552,7 +1552,7 @@ noop_submit(void *data, void *gdata, int thread_index) struct noop_submit_info *n = data; VkSubmitInfo si = {0}; si.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO; - if (vkQueueSubmit(n->screen->threaded ? n->screen->thread_queue : n->screen->queue, + if (n->VKSCR(QueueSubmit)(n->screen->threaded ? n->screen->thread_queue : n->screen->queue, 1, &si, n->fence) != VK_SUCCESS) { debug_printf("ZINK: vkQueueSubmit() failed\n"); n->screen->device_lost = true; @@ -1583,7 +1583,7 @@ zink_screen_batch_id_wait(struct zink_screen *screen, uint32_t batch_id, uint64_ util_queue_fence_init(&fence); fci.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO; - if (vkCreateFence(screen->dev, &fci, NULL, &n.fence) != VK_SUCCESS) + if (VKSCR(CreateFence)(screen->dev, &fci, NULL, &n.fence) != VK_SUCCESS) return false; n.screen = screen; @@ -1600,10 +1600,10 @@ zink_screen_batch_id_wait(struct zink_screen *screen, uint32_t batch_id, uint64_ } if (remaining) - ret = vkWaitForFences(screen->dev, 1, &n.fence, VK_TRUE, remaining); + ret = VKSCR(WaitForFences)(screen->dev, 1, &n.fence, VK_TRUE, remaining); else - ret = vkGetFenceStatus(screen->dev, n.fence); - vkDestroyFence(screen->dev, n.fence, NULL); + ret = VKSCR(GetFenceStatus)(screen->dev, n.fence); + VKSCR(DestroyFence)(screen->dev, n.fence, NULL); bool success = zink_screen_handle_vkresult(screen, ret); if (success) @@ -1635,14 +1635,14 @@ zink_query_memory_info(struct pipe_screen *pscreen, struct pipe_memory_info *inf { struct zink_screen *screen = zink_screen(pscreen); memset(info, 0, sizeof(struct pipe_memory_info)); - if (screen->info.have_EXT_memory_budget && screen->vk.GetPhysicalDeviceMemoryProperties2) { + if (screen->info.have_EXT_memory_budget && VKSCR(GetPhysicalDeviceMemoryProperties2)) { VkPhysicalDeviceMemoryProperties2 mem = {0}; mem.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2; VkPhysicalDeviceMemoryBudgetPropertiesEXT budget = {0}; budget.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT; mem.pNext = &budget; - screen->vk.GetPhysicalDeviceMemoryProperties2(screen->pdev, &mem); + VKSCR(GetPhysicalDeviceMemoryProperties2)(screen->pdev, &mem); for (unsigned i = 0; i < mem.memoryProperties.memoryHeapCount; i++) { if (mem.memoryProperties.memoryHeaps[i].flags & VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT) { @@ -1865,7 +1865,7 @@ zink_internal_create_screen(const struct pipe_screen_config *config) prop.pNext = NULL; for (unsigned i = 0; i < ARRAY_SIZE(screen->maxSampleLocationGridSize); i++) { if (screen->info.sample_locations_props.sampleLocationSampleCounts & (1 << i)) { - screen->vk.GetPhysicalDeviceMultisamplePropertiesEXT(screen->pdev, 1 << i, &prop); + VKSCR(GetPhysicalDeviceMultisamplePropertiesEXT)(screen->pdev, 1 << i, &prop); screen->maxSampleLocationGridSize[i] = prop.maxSampleLocationGridSize; } } diff --git a/src/gallium/drivers/zink/zink_screen.h b/src/gallium/drivers/zink/zink_screen.h index dff16008f70..f2514ad0b46 100644 --- a/src/gallium/drivers/zink/zink_screen.h +++ b/src/gallium/drivers/zink/zink_screen.h @@ -241,6 +241,9 @@ struct mem_cache_entry { void *map; }; +#define VKCTX(fn) zink_screen(ctx->base.screen)->vk.fn +#define VKSCR(fn) screen->vk.fn + VkFormat zink_get_format(struct zink_screen *screen, enum pipe_format format); diff --git a/src/gallium/drivers/zink/zink_surface.c b/src/gallium/drivers/zink/zink_surface.c index 233ec4c20ea..305a280fd75 100644 --- a/src/gallium/drivers/zink/zink_surface.c +++ b/src/gallium/drivers/zink/zink_surface.c @@ -137,7 +137,7 @@ create_surface(struct pipe_context *pctx, surface->info.format = ivci->format; surface->info_hash = _mesa_hash_data(&surface->info, sizeof(surface->info)); - if (vkCreateImageView(screen->dev, ivci, NULL, + if (VKSCR(CreateImageView)(screen->dev, ivci, NULL, &surface->image_view) != VK_SUCCESS) { FREE(surface); return NULL; @@ -243,8 +243,8 @@ zink_destroy_surface(struct zink_screen *screen, struct pipe_surface *psurface) util_dynarray_fini(&surface->framebuffer_refs); pipe_resource_reference(&psurface->texture, NULL); if (surface->simage_view) - vkDestroyImageView(screen->dev, surface->simage_view, NULL); - vkDestroyImageView(screen->dev, surface->image_view, NULL); + VKSCR(DestroyImageView)(screen->dev, surface->simage_view, NULL); + VKSCR(DestroyImageView)(screen->dev, surface->image_view, NULL); FREE(surface); } @@ -284,7 +284,7 @@ zink_rebind_surface(struct zink_context *ctx, struct pipe_surface **psurface) assert(entry); _mesa_hash_table_remove(&screen->surface_cache, entry); VkImageView image_view; - if (vkCreateImageView(screen->dev, &ivci, NULL, &image_view) != VK_SUCCESS) { + if (VKSCR(CreateImageView)(screen->dev, &ivci, NULL, &image_view) != VK_SUCCESS) { debug_printf("zink: failed to create new imageview"); simple_mtx_unlock(&screen->surface_mtx); return false;