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

zink: use the dispatch tables 

- removed all usage of GET_PROC_ADDR
- find-and-replaced all instances of `screen->vk_` to `screen->vk.`

Reviewed-By: Mike Blumenkrantz <michael.blumenkrantz@gmail.com>
Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/11036>
This commit is contained in:
Hoe Hao Cheng 2021-05-28 03:45:38 +08:00 committed by Marge Bot
parent 039078fe97
commit 5574868103
11 changed files with 58 additions and 232 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -3331,7 +3331,7 @@ zink_emit_string_marker(struct pipe_context *pctx,
string,
{ 0 }
};
screen->vk_CmdInsertDebugUtilsLabelEXT(batch->state->cmdbuf, &label);
screen->vk.CmdInsertDebugUtilsLabelEXT(batch->state->cmdbuf, &label);
free(temp);
}

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

@ -296,8 +296,8 @@ 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 (screen->vk.GetDescriptorSetLayoutSupport) {
screen->vk.GetDescriptorSetLayoutSupport(screen->dev, &dcslci, &supp);
if (supp.supported == VK_FALSE) {
debug_printf("vkGetDescriptorSetLayoutSupport claims layout is unsupported\n");
return VK_NULL_HANDLE;

10
src/gallium/drivers/zink/zink_descriptors_lazy.c
View File

@ -254,7 +254,7 @@ zink_descriptor_program_init_lazy(struct zink_context *ctx, struct zink_program
template[i].pipelineBindPoint = pg->is_compute ? VK_PIPELINE_BIND_POINT_COMPUTE : VK_PIPELINE_BIND_POINT_GRAPHICS;
template[i].pipelineLayout = pg->layout;
template[i].set = i;
if (screen->vk_CreateDescriptorUpdateTemplate(screen->dev, &template[i], NULL, &pg->dd->templates[i]) != VK_SUCCESS)
if (screen->vk.CreateDescriptorUpdateTemplate(screen->dev, &template[i], NULL, &pg->dd->templates[i]) != VK_SUCCESS)
return false;
}
return true;
@ -267,7 +267,7 @@ zink_descriptor_program_deinit_lazy(struct zink_screen *screen, struct zink_prog
return;
for (unsigned i = 0; i < 1 + !!pg->dd->push_usage; i++) {
if (pg->dd->templates[i])
screen->vk_DestroyDescriptorUpdateTemplate(screen->dev, pg->dd->templates[i], NULL);
screen->vk.DestroyDescriptorUpdateTemplate(screen->dev, pg->dd->templates[i], NULL);
}
ralloc_free(pg->dd);
}
@ -355,7 +355,7 @@ zink_descriptors_update_lazy(struct zink_context *ctx, bool is_compute)
batch_changed |= bs->dd->pg[is_compute] != pg;
assert(pg->dd->layout_key->num_descriptors);
screen->vk_UpdateDescriptorSetWithTemplate(screen->dev, desc_set, pg->dd->templates[0], ctx);
screen->vk.UpdateDescriptorSetWithTemplate(screen->dev, desc_set, pg->dd->templates[0], ctx);
if (pg->dd->layout_key)
vkCmdBindDescriptorSets(batch->state->cmdbuf,
is_compute ? VK_PIPELINE_BIND_POINT_COMPUTE : VK_PIPELINE_BIND_POINT_GRAPHICS,
@ -372,13 +372,13 @@ zink_descriptors_update_lazy(struct zink_context *ctx, bool is_compute)
0, NULL);
}
if (screen->info.have_KHR_push_descriptor)
screen->vk_CmdPushDescriptorSetWithTemplateKHR(batch->state->cmdbuf, pg->dd->templates[1],
screen->vk.CmdPushDescriptorSetWithTemplateKHR(batch->state->cmdbuf, pg->dd->templates[1],
pg->layout, 1, ctx);
else {
struct zink_descriptor_pool *pool = bs->dd->push_pool[is_compute];
VkDescriptorSet desc_set = get_descriptor_set_lazy(ctx, NULL, pool, is_compute);
bs = ctx->batch.state;
screen->vk_UpdateDescriptorSetWithTemplate(screen->dev, desc_set, pg->dd->templates[1], ctx);
screen->vk.UpdateDescriptorSetWithTemplate(screen->dev, desc_set, pg->dd->templates[1], ctx);
vkCmdBindDescriptorSets(batch->state->cmdbuf,
is_compute ? VK_PIPELINE_BIND_POINT_COMPUTE : VK_PIPELINE_BIND_POINT_GRAPHICS,
pg->layout, 1, 1, &desc_set,

10
src/gallium/drivers/zink/zink_device_info.py
View File

@ -341,7 +341,7 @@ zink_get_physical_device_info(struct zink_screen *screen)
}
// get device features
if (screen->vk_GetPhysicalDeviceFeatures2) {
if (screen->vk.GetPhysicalDeviceFeatures2) {
// check for device extension features
info->feats.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2;
@ -366,13 +366,13 @@ zink_get_physical_device_info(struct zink_screen *screen)
%endif
%endfor
screen->vk_GetPhysicalDeviceFeatures2(screen->pdev, &info->feats);
screen->vk.GetPhysicalDeviceFeatures2(screen->pdev, &info->feats);
} else {
vkGetPhysicalDeviceFeatures(screen->pdev, &info->feats.features);
}
// check for device properties
if (screen->vk_GetPhysicalDeviceProperties2) {
if (screen->vk.GetPhysicalDeviceProperties2) {
VkPhysicalDeviceProperties2 props = {};
props.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2;
@ -397,11 +397,11 @@ zink_get_physical_device_info(struct zink_screen *screen)
%endfor
// note: setting up local VkPhysicalDeviceProperties2.
screen->vk_GetPhysicalDeviceProperties2(screen->pdev, &props);
screen->vk.GetPhysicalDeviceProperties2(screen->pdev, &props);
}
// enable the extensions if they match the conditions given by ext.enable_conds
if (screen->vk_GetPhysicalDeviceProperties2) {
if (screen->vk.GetPhysicalDeviceProperties2) {
%for ext in extensions:
<%helpers:guard ext="${ext}">
<%

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

@ -95,7 +95,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,
screen->vk.CmdBindTransformFeedbackBuffersEXT(batch->state->cmdbuf, 0, ctx->num_so_targets,
buffers, buffer_offsets,
buffer_sizes);
ctx->dirty_so_targets = false;
@ -151,7 +151,7 @@ zink_bind_vertex_buffers(struct zink_batch *batch, struct zink_context *ctx)
}
if (screen->info.have_EXT_extended_dynamic_state)
screen->vk_CmdBindVertexBuffers2EXT(batch->state->cmdbuf, 0,
screen->vk.CmdBindVertexBuffers2EXT(batch->state->cmdbuf, 0,
elems->hw_state.num_bindings,
buffers, buffer_offsets, NULL, buffer_strides);
else
@ -559,7 +559,7 @@ zink_draw_vbo(struct pipe_context *pctx,
viewports[i] = viewport;
}
if (screen->info.have_EXT_extended_dynamic_state)
screen->vk_CmdSetViewportWithCountEXT(batch->state->cmdbuf, ctx->vp_state.num_viewports, viewports);
screen->vk.CmdSetViewportWithCountEXT(batch->state->cmdbuf, ctx->vp_state.num_viewports, viewports);
else
vkCmdSetViewport(batch->state->cmdbuf, 0, ctx->vp_state.num_viewports, viewports);
}
@ -581,7 +581,7 @@ zink_draw_vbo(struct pipe_context *pctx,
}
}
if (screen->info.have_EXT_extended_dynamic_state)
screen->vk_CmdSetScissorWithCountEXT(batch->state->cmdbuf, ctx->vp_state.num_viewports, scissors);
screen->vk.CmdSetScissorWithCountEXT(batch->state->cmdbuf, ctx->vp_state.num_viewports, scissors);
else
vkCmdSetScissor(batch->state->cmdbuf, 0, ctx->vp_state.num_viewports, scissors);
}
@ -608,23 +608,23 @@ zink_draw_vbo(struct pipe_context *pctx,
}
if (screen->info.have_EXT_extended_dynamic_state) {
screen->vk_CmdSetDepthBoundsTestEnableEXT(batch->state->cmdbuf, dsa_state->hw_state.depth_bounds_test);
screen->vk.CmdSetDepthBoundsTestEnableEXT(batch->state->cmdbuf, dsa_state->hw_state.depth_bounds_test);
if (dsa_state->hw_state.depth_bounds_test)
vkCmdSetDepthBounds(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);
screen->vk.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);
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);
if (dsa_state->hw_state.stencil_test) {
screen->vk_CmdSetStencilOpEXT(batch->state->cmdbuf, VK_STENCIL_FACE_FRONT_BIT,
screen->vk.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,
screen->vk.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,
@ -641,12 +641,12 @@ zink_draw_vbo(struct pipe_context *pctx,
vkCmdSetStencilCompareMask(batch->state->cmdbuf, VK_STENCIL_FACE_FRONT_AND_BACK, dsa_state->hw_state.stencil_front.compareMask);
}
}
screen->vk_CmdSetFrontFaceEXT(batch->state->cmdbuf, ctx->gfx_pipeline_state.front_face);
screen->vk.CmdSetFrontFaceEXT(batch->state->cmdbuf, ctx->gfx_pipeline_state.front_face);
if (ctx->sample_locations_changed) {
VkSampleLocationsInfoEXT loc;
zink_init_vk_sample_locations(ctx, &loc);
screen->vk_CmdSetSampleLocationsEXT(batch->state->cmdbuf, &loc);
screen->vk.CmdSetSampleLocationsEXT(batch->state->cmdbuf, &loc);
}
ctx->sample_locations_changed = false;
}
@ -688,7 +688,7 @@ zink_draw_vbo(struct pipe_context *pctx,
}
}
}
screen->vk_CmdBeginTransformFeedbackEXT(batch->state->cmdbuf, 0, ctx->num_so_targets, counter_buffers, counter_buffer_offsets);
screen->vk.CmdBeginTransformFeedbackEXT(batch->state->cmdbuf, 0, ctx->num_so_targets, counter_buffers, counter_buffer_offsets);
}
ctx->pipeline_changed[0] = false;
@ -728,7 +728,7 @@ 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,
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);
} else
@ -745,7 +745,7 @@ zink_draw_vbo(struct pipe_context *pctx,
update_drawid(ctx, draw_id);
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,
screen->vk.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) {
@ -757,7 +757,7 @@ 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,
screen->vk.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
@ -779,7 +779,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);
screen->vk.CmdEndTransformFeedbackEXT(batch->state->cmdbuf, 0, ctx->num_so_targets, counter_buffers, counter_buffer_offsets);
}
batch->has_work = true;
/* check memory usage and flush/stall as needed to avoid oom */

1
src/gallium/drivers/zink/zink_extensions.py
View File

@ -151,7 +151,6 @@ class ExtensionRegistryEntry:
# the version in which the extension is promoted to core VK
promoted_in : Version = None
# functions added by the extension are referred to as "commands" in the registry
commands : List[str] = None
device_commands : List[str] = None
pdevice_commands : List[str] = None
instance_commands : List[str] = None

38
src/gallium/drivers/zink/zink_instance.py
View File

@ -95,9 +95,6 @@ struct zink_instance_info {
VkInstance
zink_create_instance(struct zink_instance_info *instance_info);
bool
zink_load_instance_extensions(struct zink_screen *screen);
bool
zink_verify_instance_extensions(struct zink_screen *screen);
@ -220,41 +217,6 @@ zink_create_instance(struct zink_instance_info *instance_info)
return instance;
}
bool
zink_load_instance_extensions(struct zink_screen *screen)
{
if (zink_debug & ZINK_DEBUG_VALIDATION) {
printf("zink: Loader %d.%d.%d \\n", VK_VERSION_MAJOR(screen->instance_info.loader_version), VK_VERSION_MINOR(screen->instance_info.loader_version), VK_VERSION_PATCH(screen->instance_info.loader_version));
}
%for ext in extensions:
%if bool(ext.instance_funcs) and not ext.core_since:
if (screen->instance_info.have_${ext.name_with_vendor()}) {
%for func in ext.instance_funcs:
GET_PROC_ADDR_INSTANCE_LOCAL(screen->instance, ${func}${ext.vendor()});
screen->vk_${func} = vk_${func}${ext.vendor()};
%endfor
}
%elif bool(ext.instance_funcs):
if (screen->instance_info.have_${ext.name_with_vendor()}) {
if (screen->vk_version < ${ext.core_since.version()}) {
%for func in ext.instance_funcs:
GET_PROC_ADDR_INSTANCE_LOCAL(screen->instance, ${func}${ext.vendor()});
screen->vk_${func} = vk_${func}${ext.vendor()};
if (!screen->vk_${func}) return false;
%endfor
} else {
%for func in ext.instance_funcs:
GET_PROC_ADDR_INSTANCE(${func});
%endfor
}
}
%endif
%endfor
return true;
}
bool
zink_verify_instance_extensions(struct zink_screen *screen)
{

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

@ -659,20 +659,20 @@ 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,
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);
q->xfb_running = true;
} else if (q->type == PIPE_QUERY_SO_OVERFLOW_ANY_PREDICATE) {
zink_screen(ctx->base.screen)->vk_CmdBeginQueryIndexedEXT(batch->state->cmdbuf,
zink_screen(ctx->base.screen)->vk.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,
zink_screen(ctx->base.screen)->vk.CmdBeginQueryIndexedEXT(batch->state->cmdbuf,
q->xfb_query_pool[i],
q->curr_query,
flags,
@ -722,15 +722,15 @@ end_query(struct zink_context *ctx, struct zink_batch *batch, struct zink_query
} else 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] :
screen->vk.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);
screen->vk.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);
screen->vk.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))
@ -857,7 +857,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);
screen->vk.CmdBeginConditionalRenderingEXT(batch->state->cmdbuf, &begin_info);
zink_batch_reference_resource_rw(batch, ctx->render_condition.query->predicate, false);
}
@ -867,7 +867,7 @@ 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);
screen->vk.CmdEndConditionalRenderingEXT(batch->state->cmdbuf);
}
static void
@ -1005,7 +1005,7 @@ zink_get_timestamp(struct pipe_context *pctx)
VkCalibratedTimestampInfoEXT cti = {};
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);
screen->vk.GetCalibratedTimestampsEXT(screen->dev, 1, &cti, &timestamp, &deviation);
timestamp_to_nanoseconds(screen, &timestamp);
return timestamp;
}

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

@ -301,7 +301,7 @@ check_ici(struct zink_screen *screen, VkImageCreateInfo *ici)
{
VkImageFormatProperties image_props;
VkResult ret;
if (screen->vk_GetPhysicalDeviceImageFormatProperties2) {
if (screen->vk.GetPhysicalDeviceImageFormatProperties2) {
VkImageFormatProperties2 props2 = {};
props2.sType = VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2;
VkPhysicalDeviceImageFormatInfo2 info = {};
@ -311,7 +311,7 @@ check_ici(struct zink_screen *screen, VkImageCreateInfo *ici)
info.tiling = ici->tiling;
info.usage = ici->usage;
info.flags = ici->flags;
ret = screen->vk_GetPhysicalDeviceImageFormatProperties2(screen->pdev, &info, &props2);
ret = screen->vk.GetPhysicalDeviceImageFormatProperties2(screen->pdev, &info, &props2);
image_props = props2.imageFormatProperties;
} else
ret = vkGetPhysicalDeviceImageFormatProperties(screen->pdev, ici->format, ici->imageType,
@ -691,7 +691,7 @@ zink_resource_get_handle(struct pipe_screen *pscreen,
//TODO: remove for wsi
fd_info.memory = obj->mem;
fd_info.handleType = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT;
VkResult result = (*screen->vk_GetMemoryFdKHR)(screen->dev, &fd_info, &fd);
VkResult result = (*screen->vk.GetMemoryFdKHR)(screen->dev, &fd_info, &fd);
if (result != VK_SUCCESS)
return false;
whandle->handle = fd;

114
src/gallium/drivers/zink/zink_screen.c
View File

@ -962,7 +962,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);
screen->vk.DestroyDebugUtilsMessengerEXT(screen->instance, screen->debugUtilsCallbackHandle, NULL);
}
hash_table_foreach(&screen->surface_cache, entry) {
@ -1225,11 +1225,11 @@ static bool
check_have_device_time(struct zink_screen *screen)
{
uint32_t num_domains = 0;
screen->vk_GetPhysicalDeviceCalibrateableTimeDomainsEXT(screen->pdev, &num_domains, NULL);
screen->vk.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);
screen->vk.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++) {
@ -1242,80 +1242,6 @@ check_have_device_time(struct zink_screen *screen)
return false;
}
static bool
load_device_extensions(struct zink_screen *screen)
{
if (screen->info.have_EXT_transform_feedback) {
GET_PROC_ADDR(CmdBindTransformFeedbackBuffersEXT);
GET_PROC_ADDR(CmdBeginTransformFeedbackEXT);
GET_PROC_ADDR(CmdEndTransformFeedbackEXT);
GET_PROC_ADDR(CmdBeginQueryIndexedEXT);
GET_PROC_ADDR(CmdEndQueryIndexedEXT);
GET_PROC_ADDR(CmdDrawIndirectByteCountEXT);
}
if (screen->info.have_KHR_external_memory_fd)
GET_PROC_ADDR(GetMemoryFdKHR);
if (screen->info.have_EXT_conditional_rendering) {
GET_PROC_ADDR(CmdBeginConditionalRenderingEXT);
GET_PROC_ADDR(CmdEndConditionalRenderingEXT);
}
if (screen->info.have_KHR_draw_indirect_count) {
GET_PROC_ADDR_KHR(CmdDrawIndexedIndirectCount);
GET_PROC_ADDR_KHR(CmdDrawIndirectCount);
}
if (screen->info.have_EXT_calibrated_timestamps) {
GET_PROC_ADDR_INSTANCE(GetPhysicalDeviceCalibrateableTimeDomainsEXT);
GET_PROC_ADDR(GetCalibratedTimestampsEXT);
}
if (screen->info.have_EXT_extended_dynamic_state) {
GET_PROC_ADDR(CmdSetViewportWithCountEXT);
GET_PROC_ADDR(CmdSetScissorWithCountEXT);
GET_PROC_ADDR(CmdSetDepthBoundsTestEnableEXT);
GET_PROC_ADDR(CmdSetDepthCompareOpEXT);
GET_PROC_ADDR(CmdSetDepthTestEnableEXT);
GET_PROC_ADDR(CmdSetDepthWriteEnableEXT);
GET_PROC_ADDR(CmdSetStencilOpEXT);
GET_PROC_ADDR(CmdSetStencilTestEnableEXT);
GET_PROC_ADDR(CmdBindVertexBuffers2EXT);
GET_PROC_ADDR(CmdSetFrontFaceEXT);
}
if (screen->info.have_EXT_image_drm_format_modifier)
GET_PROC_ADDR(GetImageDrmFormatModifierPropertiesEXT);
if (screen->info.have_KHR_timeline_semaphore)
GET_PROC_ADDR_KHR(WaitSemaphores);
if (screen->info.have_KHR_maintenance3)
GET_PROC_ADDR_KHR(GetDescriptorSetLayoutSupport);
if (screen->info.have_KHR_push_descriptor) {
GET_PROC_ADDR(CmdPushDescriptorSetKHR);
GET_PROC_ADDR(CmdPushDescriptorSetWithTemplateKHR);
}
if (screen->info.have_KHR_descriptor_update_template) {
GET_PROC_ADDR_KHR(CreateDescriptorUpdateTemplate);
GET_PROC_ADDR_KHR(DestroyDescriptorUpdateTemplate);
GET_PROC_ADDR_KHR(UpdateDescriptorSetWithTemplate);
}
if (screen->info.have_KHR_swapchain) {
GET_PROC_ADDR(CreateSwapchainKHR);
GET_PROC_ADDR(DestroySwapchainKHR);
}
if (screen->info.have_EXT_sample_locations) {
GET_PROC_ADDR(CmdSetSampleLocationsEXT);
GET_PROC_ADDR_INSTANCE(GetPhysicalDeviceMultisamplePropertiesEXT);
}
return true;
}
static VKAPI_ATTR VkBool32 VKAPI_CALL
zink_debug_util_callback(
VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity,
@ -1342,10 +1268,6 @@ zink_debug_util_callback(
static bool
create_debug(struct zink_screen *screen)
{
GET_PROC_ADDR_INSTANCE(CreateDebugUtilsMessengerEXT);
GET_PROC_ADDR_INSTANCE(DestroyDebugUtilsMessengerEXT);
GET_PROC_ADDR_INSTANCE(CmdInsertDebugUtilsLabelEXT);
VkDebugUtilsMessengerCreateInfoEXT vkDebugUtilsMessengerCreateInfoEXT = {
VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT,
NULL,
@ -1363,7 +1285,7 @@ create_debug(struct zink_screen *screen)
VkDebugUtilsMessengerEXT vkDebugUtilsCallbackEXT = VK_NULL_HANDLE;
screen->vk_CreateDebugUtilsMessengerEXT(
screen->vk.CreateDebugUtilsMessengerEXT(
screen->instance,
&vkDebugUtilsMessengerCreateInfoEXT,
NULL,
@ -1390,25 +1312,25 @@ zink_internal_setup_moltenvk(struct zink_screen *screen)
GET_PROC_ADDR_INSTANCE(UseIOSurfaceMVK);
GET_PROC_ADDR_INSTANCE(GetIOSurfaceMVK);
if (screen->vk_GetVersionStringsMVK) {
if (screen->vk.GetVersionStringsMVK) {
char molten_version[64] = {0};
char vulkan_version[64] = {0};
(*screen->vk_GetVersionStringsMVK)(molten_version, sizeof(molten_version) - 1, vulkan_version, sizeof(vulkan_version) - 1);
(*screen->vk.GetVersionStringsMVK)(molten_version, sizeof(molten_version) - 1, vulkan_version, sizeof(vulkan_version) - 1);
printf("zink: MoltenVK %s Vulkan %s \n", molten_version, vulkan_version);
}
if (screen->vk_GetMoltenVKConfigurationMVK && screen->vk_SetMoltenVKConfigurationMVK) {
if (screen->vk.GetMoltenVKConfigurationMVK && screen->vk.SetMoltenVKConfigurationMVK) {
MVKConfiguration molten_config = {0};
size_t molten_config_size = sizeof(molten_config);
VkResult res = (*screen->vk_GetMoltenVKConfigurationMVK)(screen->instance, &molten_config, &molten_config_size);
VkResult res = (*screen->vk.GetMoltenVKConfigurationMVK)(screen->instance, &molten_config, &molten_config_size);
if (res == VK_SUCCESS || res == VK_INCOMPLETE) {
// Needed to allow MoltenVK to accept VkImageView swizzles.
// Encountered when using VK_FORMAT_R8G8_UNORM
molten_config.fullImageViewSwizzle = VK_TRUE;
(*screen->vk_SetMoltenVKConfigurationMVK)(screen->instance, &molten_config, &molten_config_size);
(*screen->vk.SetMoltenVKConfigurationMVK)(screen->instance, &molten_config, &molten_config_size);
}
}
#endif // MVK_VERSION
@ -1439,10 +1361,10 @@ populate_format_props(struct zink_screen *screen)
VkFormat format = zink_get_format(screen, i);
if (!format)
continue;
if (screen->vk_GetPhysicalDeviceFormatProperties2) {
if (screen->vk.GetPhysicalDeviceFormatProperties2) {
VkFormatProperties2 props = {};
props.sType = VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2;
screen->vk_GetPhysicalDeviceFormatProperties2(screen->pdev, format, &props);
screen->vk.GetPhysicalDeviceFormatProperties2(screen->pdev, format, &props);
screen->format_props[i] = props.formatProperties;
} else
vkGetPhysicalDeviceFormatProperties(screen->pdev, format, &screen->format_props[i]);
@ -1487,7 +1409,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 = screen->vk.WaitSemaphores(screen->dev, &wi, timeout);
success = zink_screen_handle_vkresult(screen, ret);
if (success)
@ -1519,14 +1441,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 && screen->vk.GetPhysicalDeviceMemoryProperties2) {
VkPhysicalDeviceMemoryProperties2 mem = {};
mem.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2;
VkPhysicalDeviceMemoryBudgetPropertiesEXT budget = {};
budget.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT;
mem.pNext = &budget;
screen->vk_GetPhysicalDeviceMemoryProperties2(screen->pdev, &mem);
screen->vk.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) {
@ -1663,9 +1585,6 @@ zink_internal_create_screen(const struct pipe_screen_config *config)
vk_instance_dispatch_table_load(&screen->vk.instance, &vkGetInstanceProcAddr, screen->instance);
vk_physical_device_dispatch_table_load(&screen->vk.physical_device, &vkGetInstanceProcAddr, screen->instance);
if (!zink_load_instance_extensions(screen))
goto fail;
if (!zink_verify_instance_extensions(screen))
goto fail;
@ -1706,9 +1625,6 @@ zink_internal_create_screen(const struct pipe_screen_config *config)
/* this has bad perf on AMD */
screen->info.have_KHR_push_descriptor = false;
if (!load_device_extensions(screen))
goto fail;
vk_device_dispatch_table_load(&screen->vk.device, &vkGetDeviceProcAddr, screen->dev);
if (!zink_verify_device_extensions(screen))
@ -1748,7 +1664,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);
screen->vk.GetPhysicalDeviceMultisamplePropertiesEXT(screen->pdev, 1 << i, &prop);
screen->maxSampleLocationGridSize[i] = prop.maxSampleLocationGridSize;
}
}

51
src/gallium/drivers/zink/zink_screen.h
View File

@ -117,23 +117,6 @@ struct zink_screen {
struct vk_dispatch_table vk;
PFN_vkGetPhysicalDeviceFeatures2 vk_GetPhysicalDeviceFeatures2;
PFN_vkGetPhysicalDeviceProperties2 vk_GetPhysicalDeviceProperties2;
PFN_vkGetPhysicalDeviceFormatProperties2 vk_GetPhysicalDeviceFormatProperties2;
PFN_vkGetPhysicalDeviceImageFormatProperties2 vk_GetPhysicalDeviceImageFormatProperties2;
PFN_vkGetPhysicalDeviceMemoryProperties2 vk_GetPhysicalDeviceMemoryProperties2;
PFN_vkCmdDrawIndirectCount vk_CmdDrawIndirectCount;
PFN_vkCmdDrawIndexedIndirectCount vk_CmdDrawIndexedIndirectCount;
PFN_vkWaitSemaphores vk_WaitSemaphores;
PFN_vkGetDescriptorSetLayoutSupport vk_GetDescriptorSetLayoutSupport;
PFN_vkCmdPushDescriptorSetKHR vk_CmdPushDescriptorSetKHR;
PFN_vkCreateDescriptorUpdateTemplate vk_CreateDescriptorUpdateTemplate;
PFN_vkDestroyDescriptorUpdateTemplate vk_DestroyDescriptorUpdateTemplate;
PFN_vkUpdateDescriptorSetWithTemplate vk_UpdateDescriptorSetWithTemplate;
PFN_vkCmdPushDescriptorSetWithTemplateKHR vk_CmdPushDescriptorSetWithTemplateKHR;
bool (*descriptor_program_init)(struct zink_context *ctx, struct zink_program *pg);
void (*descriptor_program_deinit)(struct zink_screen *screen, struct zink_program *pg);
void (*descriptors_update)(struct zink_context *ctx, bool is_compute);
@ -148,35 +131,6 @@ struct zink_screen {
void (*descriptors_deinit)(struct zink_context *ctx);
bool lazy_descriptors;
PFN_vkGetMemoryFdKHR vk_GetMemoryFdKHR;
PFN_vkCmdBeginConditionalRenderingEXT vk_CmdBeginConditionalRenderingEXT;
PFN_vkCmdEndConditionalRenderingEXT vk_CmdEndConditionalRenderingEXT;
PFN_vkCmdBindTransformFeedbackBuffersEXT vk_CmdBindTransformFeedbackBuffersEXT;
PFN_vkCmdBeginTransformFeedbackEXT vk_CmdBeginTransformFeedbackEXT;
PFN_vkCmdEndTransformFeedbackEXT vk_CmdEndTransformFeedbackEXT;
PFN_vkCmdBeginQueryIndexedEXT vk_CmdBeginQueryIndexedEXT;
PFN_vkCmdEndQueryIndexedEXT vk_CmdEndQueryIndexedEXT;
PFN_vkCmdDrawIndirectByteCountEXT vk_CmdDrawIndirectByteCountEXT;
PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT vk_GetPhysicalDeviceCalibrateableTimeDomainsEXT;
PFN_vkGetCalibratedTimestampsEXT vk_GetCalibratedTimestampsEXT;
PFN_vkCmdSetViewportWithCountEXT vk_CmdSetViewportWithCountEXT;
PFN_vkCmdSetScissorWithCountEXT vk_CmdSetScissorWithCountEXT;
PFN_vkCmdSetDepthBoundsTestEnableEXT vk_CmdSetDepthBoundsTestEnableEXT;
PFN_vkCmdSetDepthCompareOpEXT vk_CmdSetDepthCompareOpEXT;
PFN_vkCmdSetDepthTestEnableEXT vk_CmdSetDepthTestEnableEXT;
PFN_vkCmdSetDepthWriteEnableEXT vk_CmdSetDepthWriteEnableEXT;
PFN_vkCmdSetStencilTestEnableEXT vk_CmdSetStencilTestEnableEXT;
PFN_vkCmdSetStencilOpEXT vk_CmdSetStencilOpEXT;
PFN_vkCmdBindVertexBuffers2EXT vk_CmdBindVertexBuffers2EXT;
PFN_vkCmdSetFrontFaceEXT vk_CmdSetFrontFaceEXT;
PFN_vkCreateDebugUtilsMessengerEXT vk_CreateDebugUtilsMessengerEXT;
PFN_vkDestroyDebugUtilsMessengerEXT vk_DestroyDebugUtilsMessengerEXT;
PFN_vkCmdInsertDebugUtilsLabelEXT vk_CmdInsertDebugUtilsLabelEXT;
#if defined(MVK_VERSION)
PFN_vkGetMoltenVKConfigurationMVK vk_GetMoltenVKConfigurationMVK;
PFN_vkSetMoltenVKConfigurationMVK vk_SetMoltenVKConfigurationMVK;
@ -187,16 +141,11 @@ struct zink_screen {
PFN_vkGetIOSurfaceMVK vk_GetIOSurfaceMVK;
#endif
PFN_vkCreateSwapchainKHR vk_CreateSwapchainKHR;
PFN_vkDestroySwapchainKHR vk_DestroySwapchainKHR;
struct {
bool dual_color_blend_by_location;
bool inline_uniforms;
} driconf;
PFN_vkGetImageDrmFormatModifierPropertiesEXT vk_GetImageDrmFormatModifierPropertiesEXT;
VkFormatProperties format_props[PIPE_FORMAT_COUNT];
struct {
uint32_t image_view;