AlexIndustrial/mesa
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

zink: use dispatch table for (almost) all vulkan calls

Browse Source 
try to avoid hitting the loader when possible

Reviewed-by: Dave Airlie <airlied@redhat.com>
Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/12757>
This commit is contained in:
Mike Blumenkrantz
2021-08-18 09:59:18 -04:00
committed by Marge Bot
parent 2777d4f69d
commit ad584ed34e
18 changed files with 263 additions and 262 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/gallium/drivers/zink/zink_batch.c
+23 -21
View File
@@ -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, &region);
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,
src/gallium/drivers/zink/zink_blit.c
+2 -2
View File
@@ -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, &region);
@@ -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, &region,
zink_filter(info->filter));
src/gallium/drivers/zink/zink_bo.c
+5 -5
View File
@@ -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);
}
src/gallium/drivers/zink/zink_clear.c
+4 -4
View File
@@ -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;
src/gallium/drivers/zink/zink_compiler.c
+1 -1
View File
@@ -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:
src/gallium/drivers/zink/zink_context.c
+16 -16
View File
@@ -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, &region);
VKCTX(CmdCopyBuffer)(batch->state->cmdbuf, src->obj->buffer, dst->obj->buffer, 1, &region);
}
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, &region);
VKCTX(CmdCopyBufferToImage)(batch->state->cmdbuf, buf->obj->buffer, img->obj->image, img->layout, 1, &region);
else
vkCmdCopyImageToBuffer(batch->state->cmdbuf, img->obj->image, img->layout, buf->obj->buffer, 1, &region);
VKCTX(CmdCopyImageToBuffer)(batch->state->cmdbuf, img->obj->image, img->layout, buf->obj->buffer, 1, &region);
}
}
@@ -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, &region);
} else if (dst->base.b.target == PIPE_BUFFER &&
src/gallium/drivers/zink/zink_descriptors.c
+14 -14
View File
@@ -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);
src/gallium/drivers/zink/zink_descriptors_lazy.c
+17 -17
View File
@@ -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);
}
src/gallium/drivers/zink/zink_draw.cpp
+64 -65
View File
@@ -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<BATCH_CHANGED>(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<HAS_MULTIDRAW>(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 */
src/gallium/drivers/zink/zink_fence.c
+2 -2
View File
@@ -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) {
src/gallium/drivers/zink/zink_framebuffer.c
+6 -6
View File
@@ -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;
src/gallium/drivers/zink/zink_program.c
+8 -8
View File
@@ -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);
src/gallium/drivers/zink/zink_query.c
+37 -40
View File
@@ -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, &timestamp, &deviation);
VKSCR(GetCalibratedTimestampsEXT)(screen->dev, 1, &cti, &timestamp, &deviation);
timestamp_to_nanoseconds(screen, &timestamp);
return timestamp;
}
src/gallium/drivers/zink/zink_render_pass.c
+4 -4
View File
@@ -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);
}
src/gallium/drivers/zink/zink_resource.c
+28 -28
View File
@@ -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;
src/gallium/drivers/zink/zink_screen.c
+25 -25
View File
@@ -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;
}
}
src/gallium/drivers/zink/zink_screen.h
+3
View File
@@ -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);
src/gallium/drivers/zink/zink_surface.c
+4 -4
View File
@@ -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;