mirrors
/
mesa
mirror of https://gitlab.freedesktop.org/mesa/mesa
1
0
Fork 0
Code Issues 9 Packages Projects Releases Wiki Activity
mesa/src/virtio/vulkan/vn_descriptor_set.c

1087 lines
38 KiB
C
Raw Permalink Blame History

/*
* Copyright 2019 Google LLC
* SPDX-License-Identifier: MIT
*
* based in part on anv and radv which are:
* Copyright © 2015 Intel Corporation
* Copyright © 2016 Red Hat.
* Copyright © 2016 Bas Nieuwenhuizen
*/
#include "vn_descriptor_set.h"
#include "venus-protocol/vn_protocol_driver_descriptor_pool.h"
#include "venus-protocol/vn_protocol_driver_descriptor_set.h"
#include "venus-protocol/vn_protocol_driver_descriptor_set_layout.h"
#include "venus-protocol/vn_protocol_driver_descriptor_update_template.h"
#include "vn_device.h"
#include "vn_pipeline.h"
void
vn_descriptor_set_layout_destroy(struct vn_device *dev,
struct vn_descriptor_set_layout *layout)
{
VkDevice dev_handle = vn_device_to_handle(dev);
VkDescriptorSetLayout layout_handle =
vn_descriptor_set_layout_to_handle(layout);
const VkAllocationCallbacks *alloc = &dev->base.base.alloc;
vn_async_vkDestroyDescriptorSetLayout(dev->primary_ring, dev_handle,
layout_handle, NULL);
vn_object_base_fini(&layout->base);
vk_free(alloc, layout);
}
static void
vn_descriptor_set_destroy(struct vn_device *dev,
struct vn_descriptor_set *set,
const VkAllocationCallbacks *alloc)
{
list_del(&set->head);
vn_descriptor_set_layout_unref(dev, set->layout);
vn_object_base_fini(&set->base);
vk_free(alloc, set);
}
/* Map VkDescriptorType to contiguous enum vn_descriptor_type */
static enum vn_descriptor_type
vn_descriptor_type(VkDescriptorType type)
{
switch (type) {
case VK_DESCRIPTOR_TYPE_SAMPLER:
return VN_DESCRIPTOR_TYPE_SAMPLER;
case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
return VN_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
return VN_DESCRIPTOR_TYPE_SAMPLED_IMAGE;
case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:
return VN_DESCRIPTOR_TYPE_STORAGE_IMAGE;
case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:
return VN_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER;
case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
return VN_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER;
case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
return VN_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
return VN_DESCRIPTOR_TYPE_STORAGE_BUFFER;
case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
return VN_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC;
case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:
return VN_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC;
case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:
return VN_DESCRIPTOR_TYPE_INPUT_ATTACHMENT;
case VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK:
return VN_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK;
case VK_DESCRIPTOR_TYPE_MUTABLE_EXT:
return VN_DESCRIPTOR_TYPE_MUTABLE_EXT;
default:
break;
}
unreachable("bad VkDescriptorType");
}
/* descriptor set layout commands */
void
vn_GetDescriptorSetLayoutSupport(
VkDevice device,
const VkDescriptorSetLayoutCreateInfo *pCreateInfo,
VkDescriptorSetLayoutSupport *pSupport)
{
struct vn_device *dev = vn_device_from_handle(device);
/* TODO per-device cache */
vn_call_vkGetDescriptorSetLayoutSupport(dev->primary_ring, device,
pCreateInfo, pSupport);
}
static void
vn_descriptor_set_layout_init(
struct vn_device *dev,
const VkDescriptorSetLayoutCreateInfo *create_info,
uint32_t last_binding,
struct vn_descriptor_set_layout *layout)
{
VkDevice dev_handle = vn_device_to_handle(dev);
VkDescriptorSetLayout layout_handle =
vn_descriptor_set_layout_to_handle(layout);
const VkDescriptorSetLayoutBindingFlagsCreateInfo *binding_flags =
vk_find_struct_const(create_info->pNext,
DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO);
const VkMutableDescriptorTypeCreateInfoEXT *mutable_descriptor_info =
vk_find_struct_const(create_info->pNext,
MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT);
/* 14.2.1. Descriptor Set Layout
*
* If bindingCount is zero or if this structure is not included in
* the pNext chain, the VkDescriptorBindingFlags for each descriptor
* set layout binding is considered to be zero.
*/
if (binding_flags && !binding_flags->bindingCount)
binding_flags = NULL;
layout->is_push_descriptor =
create_info->flags &
VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR;
layout->refcount = VN_REFCOUNT_INIT(1);
layout->last_binding = last_binding;
for (uint32_t i = 0; i < create_info->bindingCount; i++) {
const VkDescriptorSetLayoutBinding *binding_info =
&create_info->pBindings[i];
const enum vn_descriptor_type type =
vn_descriptor_type(binding_info->descriptorType);
struct vn_descriptor_set_layout_binding *binding =
&layout->bindings[binding_info->binding];
if (binding_info->binding == last_binding) {
/* 14.2.1. Descriptor Set Layout
*
* VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT must only be
* used for the last binding in the descriptor set layout (i.e. the
* binding with the largest value of binding).
*
* 41. Features
*
* descriptorBindingVariableDescriptorCount indicates whether the
* implementation supports descriptor sets with a variable-sized last
* binding. If this feature is not enabled,
* VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT must not be
* used.
*/
layout->has_variable_descriptor_count =
binding_flags &&
(binding_flags->pBindingFlags[i] &
VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT);
}
binding->type = type;
binding->count = binding_info->descriptorCount;
switch (type) {
case VN_DESCRIPTOR_TYPE_SAMPLER:
case VN_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
binding->has_immutable_samplers = binding_info->pImmutableSamplers;
break;
case VN_DESCRIPTOR_TYPE_MUTABLE_EXT:
assert(mutable_descriptor_info->mutableDescriptorTypeListCount &&
mutable_descriptor_info->pMutableDescriptorTypeLists[i]
.descriptorTypeCount);
const VkMutableDescriptorTypeListEXT *list =
&mutable_descriptor_info->pMutableDescriptorTypeLists[i];
for (uint32_t j = 0; j < list->descriptorTypeCount; j++) {
BITSET_SET(binding->mutable_descriptor_types,
vn_descriptor_type(list->pDescriptorTypes[j]));
}
break;
default:
break;
}
}
vn_async_vkCreateDescriptorSetLayout(dev->primary_ring, dev_handle,
create_info, NULL, &layout_handle);
}
VkResult
vn_CreateDescriptorSetLayout(
VkDevice device,
const VkDescriptorSetLayoutCreateInfo *pCreateInfo,
const VkAllocationCallbacks *pAllocator,
VkDescriptorSetLayout *pSetLayout)
{
struct vn_device *dev = vn_device_from_handle(device);
/* ignore pAllocator as the layout is reference-counted */
const VkAllocationCallbacks *alloc = &dev->base.base.alloc;
STACK_ARRAY(VkDescriptorSetLayoutBinding, bindings,
pCreateInfo->bindingCount);
uint32_t last_binding = 0;
VkDescriptorSetLayoutCreateInfo local_create_info;
if (pCreateInfo->bindingCount) {
typed_memcpy(bindings, pCreateInfo->pBindings,
pCreateInfo->bindingCount);
for (uint32_t i = 0; i < pCreateInfo->bindingCount; i++) {
VkDescriptorSetLayoutBinding *binding = &bindings[i];
if (last_binding < binding->binding)
last_binding = binding->binding;
switch (binding->descriptorType) {
case VK_DESCRIPTOR_TYPE_SAMPLER:
case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
break;
default:
binding->pImmutableSamplers = NULL;
break;
}
}
local_create_info = *pCreateInfo;
local_create_info.pBindings = bindings;
pCreateInfo = &local_create_info;
}
const size_t layout_size =
offsetof(struct vn_descriptor_set_layout, bindings[last_binding + 1]);
/* allocated with the device scope */
struct vn_descriptor_set_layout *layout =
vk_zalloc(alloc, layout_size, VN_DEFAULT_ALIGN,
VK_SYSTEM_ALLOCATION_SCOPE_DEVICE);
if (!layout) {
STACK_ARRAY_FINISH(bindings);
return vn_error(dev->instance, VK_ERROR_OUT_OF_HOST_MEMORY);
}
vn_object_base_init(&layout->base, VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT,
&dev->base);
vn_descriptor_set_layout_init(dev, pCreateInfo, last_binding, layout);
STACK_ARRAY_FINISH(bindings);
*pSetLayout = vn_descriptor_set_layout_to_handle(layout);
return VK_SUCCESS;
}
void
vn_DestroyDescriptorSetLayout(VkDevice device,
VkDescriptorSetLayout descriptorSetLayout,
const VkAllocationCallbacks *pAllocator)
{
struct vn_device *dev = vn_device_from_handle(device);
struct vn_descriptor_set_layout *layout =
vn_descriptor_set_layout_from_handle(descriptorSetLayout);
if (!layout)
return;
vn_descriptor_set_layout_unref(dev, layout);
}
/* descriptor pool commands */
VkResult
vn_CreateDescriptorPool(VkDevice device,
const VkDescriptorPoolCreateInfo *pCreateInfo,
const VkAllocationCallbacks *pAllocator,
VkDescriptorPool *pDescriptorPool)
{
VN_TRACE_FUNC();
struct vn_device *dev = vn_device_from_handle(device);
const VkAllocationCallbacks *alloc =
pAllocator ? pAllocator : &dev->base.base.alloc;
const VkDescriptorPoolInlineUniformBlockCreateInfo *iub_info =
vk_find_struct_const(pCreateInfo->pNext,
DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO);
uint32_t mutable_states_count = 0;
for (uint32_t i = 0; i < pCreateInfo->poolSizeCount; i++) {
const VkDescriptorPoolSize *pool_size = &pCreateInfo->pPoolSizes[i];
if (pool_size->type == VK_DESCRIPTOR_TYPE_MUTABLE_EXT)
mutable_states_count++;
}
struct vn_descriptor_pool *pool;
struct vn_descriptor_pool_state_mutable *mutable_states;
VK_MULTIALLOC(ma);
vk_multialloc_add(&ma, &pool, __typeof__(*pool), 1);
vk_multialloc_add(&ma, &mutable_states, __typeof__(*mutable_states),
mutable_states_count);
if (!vk_multialloc_zalloc(&ma, alloc, VK_SYSTEM_ALLOCATION_SCOPE_OBJECT))
return vn_error(dev->instance, VK_ERROR_OUT_OF_HOST_MEMORY);
vn_object_base_init(&pool->base, VK_OBJECT_TYPE_DESCRIPTOR_POOL,
&dev->base);
pool->allocator = *alloc;
pool->mutable_states = mutable_states;
const VkMutableDescriptorTypeCreateInfoEXT *mutable_descriptor_info =
vk_find_struct_const(pCreateInfo->pNext,
MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT);
/* Without VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT, the set
* allocation must not fail due to a fragmented pool per spec. In this
* case, set allocation can be asynchronous with pool resource tracking.
*/
pool->async_set_allocation =
!VN_PERF(NO_ASYNC_SET_ALLOC) &&
!(pCreateInfo->flags &
VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT);
pool->max.set_count = pCreateInfo->maxSets;
if (iub_info)
pool->max.iub_binding_count = iub_info->maxInlineUniformBlockBindings;
uint32_t next_mutable_state = 0;
for (uint32_t i = 0; i < pCreateInfo->poolSizeCount; i++) {
const VkDescriptorPoolSize *pool_size = &pCreateInfo->pPoolSizes[i];
const enum vn_descriptor_type type =
vn_descriptor_type(pool_size->type);
if (type != VN_DESCRIPTOR_TYPE_MUTABLE_EXT) {
pool->max.descriptor_counts[type] += pool_size->descriptorCount;
continue;
}
struct vn_descriptor_pool_state_mutable *mutable_state = NULL;
BITSET_DECLARE(mutable_types, VN_NUM_DESCRIPTOR_TYPES);
if (!mutable_descriptor_info ||
i >= mutable_descriptor_info->mutableDescriptorTypeListCount) {
BITSET_ONES(mutable_types);
} else {
const VkMutableDescriptorTypeListEXT *list =
&mutable_descriptor_info->pMutableDescriptorTypeLists[i];
for (uint32_t j = 0; j < list->descriptorTypeCount; j++) {
BITSET_SET(mutable_types,
vn_descriptor_type(list->pDescriptorTypes[j]));
}
}
for (uint32_t j = 0; j < next_mutable_state; j++) {
if (BITSET_EQUAL(mutable_types, pool->mutable_states[j].types)) {
mutable_state = &pool->mutable_states[j];
break;
}
}
if (!mutable_state) {
/* The application must ensure that partial overlap does not exist in
* pPoolSizes. so this entry must have a disjoint set of types.
*/
mutable_state = &pool->mutable_states[next_mutable_state++];
BITSET_COPY(mutable_state->types, mutable_types);
}
mutable_state->max += pool_size->descriptorCount;
}
pool->mutable_states_count = next_mutable_state;
list_inithead(&pool->descriptor_sets);
VkDescriptorPool pool_handle = vn_descriptor_pool_to_handle(pool);
vn_async_vkCreateDescriptorPool(dev->primary_ring, device, pCreateInfo,
NULL, &pool_handle);
vn_tls_set_async_pipeline_create();
*pDescriptorPool = pool_handle;
return VK_SUCCESS;
}
void
vn_DestroyDescriptorPool(VkDevice device,
VkDescriptorPool descriptorPool,
const VkAllocationCallbacks *pAllocator)
{
VN_TRACE_FUNC();
struct vn_device *dev = vn_device_from_handle(device);
struct vn_descriptor_pool *pool =
vn_descriptor_pool_from_handle(descriptorPool);
const VkAllocationCallbacks *alloc;
if (!pool)
return;
alloc = pAllocator ? pAllocator : &pool->allocator;
vn_async_vkDestroyDescriptorPool(dev->primary_ring, device, descriptorPool,
NULL);
list_for_each_entry_safe(struct vn_descriptor_set, set,
&pool->descriptor_sets, head)
vn_descriptor_set_destroy(dev, set, alloc);
vn_object_base_fini(&pool->base);
vk_free(alloc, pool);
}
static struct vn_descriptor_pool_state_mutable *
vn_get_mutable_state(const struct vn_descriptor_pool *pool,
const struct vn_descriptor_set_layout_binding *binding)
{
for (uint32_t i = 0; i < pool->mutable_states_count; i++) {
struct vn_descriptor_pool_state_mutable *mutable_state =
&pool->mutable_states[i];
BITSET_DECLARE(shared_types, VN_NUM_DESCRIPTOR_TYPES);
BITSET_AND(shared_types, mutable_state->types,
binding->mutable_descriptor_types);
/* The application must ensure that partial overlap does not exist in
* pPoolSizes, so there only exists one matching entry.
*/
if (BITSET_EQUAL(shared_types, binding->mutable_descriptor_types))
return mutable_state;
}
unreachable("bad mutable descriptor binding");
}
static inline void
vn_pool_restore_mutable_states(struct vn_descriptor_pool *pool,
const struct vn_descriptor_set_layout *layout,
uint32_t binding_index,
uint32_t descriptor_count)
{
assert(layout->bindings[binding_index].type ==
VN_DESCRIPTOR_TYPE_MUTABLE_EXT);
assert(descriptor_count);
struct vn_descriptor_pool_state_mutable *mutable_state =
vn_get_mutable_state(pool, &layout->bindings[binding_index]);
assert(mutable_state && mutable_state->used >= descriptor_count);
mutable_state->used -= descriptor_count;
}
static bool
vn_descriptor_pool_alloc_descriptors(
struct vn_descriptor_pool *pool,
const struct vn_descriptor_set_layout *layout,
uint32_t last_binding_descriptor_count)
{
assert(pool->async_set_allocation);
if (pool->used.set_count == pool->max.set_count)
return false;
/* backup current pool state to recovery */
struct vn_descriptor_pool_state recovery = pool->used;
pool->used.set_count++;
uint32_t i = 0;
for (; i <= layout->last_binding; i++) {
const struct vn_descriptor_set_layout_binding *binding =
&layout->bindings[i];
const enum vn_descriptor_type type = binding->type;
const uint32_t count = i == layout->last_binding
? last_binding_descriptor_count
: binding->count;
/* Skip resource accounting for either of below:
* - reserved binding entry that has a valid type with a zero count
* - invalid binding entry from sparse binding indices
*/
if (!count)
continue;
if (type == VN_DESCRIPTOR_TYPE_MUTABLE_EXT) {
/* A mutable descriptor can be allocated if below are satisfied:
* - vn_descriptor_pool_state_mutable::types is a superset
* - vn_descriptor_pool_state_mutable::{max - used} is enough
*/
struct vn_descriptor_pool_state_mutable *mutable_state =
vn_get_mutable_state(pool, binding);
assert(mutable_state);
if (mutable_state->used + count > mutable_state->max)
goto restore;
mutable_state->used += count;
} else {
if (type == VN_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK &&
++pool->used.iub_binding_count > pool->max.iub_binding_count)
goto restore;
pool->used.descriptor_counts[type] += count;
if (pool->used.descriptor_counts[type] >
pool->max.descriptor_counts[type])
goto restore;
}
}
return true;
restore:
/* restore pool state before this allocation */
pool->used = recovery;
for (uint32_t j = 0; j < i; j++) {
/* mutable state at binding i is not changed */
const uint32_t count = layout->bindings[j].count;
if (count && layout->bindings[j].type == VN_DESCRIPTOR_TYPE_MUTABLE_EXT)
vn_pool_restore_mutable_states(pool, layout, j, count);
}
return false;
}
static void
vn_descriptor_pool_free_descriptors(
struct vn_descriptor_pool *pool,
const struct vn_descriptor_set_layout *layout,
uint32_t last_binding_descriptor_count)
{
assert(pool->async_set_allocation);
for (uint32_t i = 0; i <= layout->last_binding; i++) {
const uint32_t count = i == layout->last_binding
? last_binding_descriptor_count
: layout->bindings[i].count;
if (!count)
continue;
const enum vn_descriptor_type type = layout->bindings[i].type;
if (type == VN_DESCRIPTOR_TYPE_MUTABLE_EXT) {
vn_pool_restore_mutable_states(pool, layout, i, count);
} else {
pool->used.descriptor_counts[type] -= count;
if (type == VN_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK)
pool->used.iub_binding_count--;
}
}
pool->used.set_count--;
}
static inline void
vn_descriptor_pool_reset_descriptors(struct vn_descriptor_pool *pool)
{
assert(pool->async_set_allocation);
memset(&pool->used, 0, sizeof(pool->used));
for (uint32_t i = 0; i < pool->mutable_states_count; i++)
pool->mutable_states[i].used = 0;
}
VkResult
vn_ResetDescriptorPool(VkDevice device,
VkDescriptorPool descriptorPool,
VkDescriptorPoolResetFlags flags)
{
VN_TRACE_FUNC();
struct vn_device *dev = vn_device_from_handle(device);
struct vn_descriptor_pool *pool =
vn_descriptor_pool_from_handle(descriptorPool);
const VkAllocationCallbacks *alloc = &pool->allocator;
vn_async_vkResetDescriptorPool(dev->primary_ring, device, descriptorPool,
flags);
list_for_each_entry_safe(struct vn_descriptor_set, set,
&pool->descriptor_sets, head)
vn_descriptor_set_destroy(dev, set, alloc);
if (pool->async_set_allocation)
vn_descriptor_pool_reset_descriptors(pool);
return VK_SUCCESS;
}
/* descriptor set commands */
VkResult
vn_AllocateDescriptorSets(VkDevice device,
const VkDescriptorSetAllocateInfo *pAllocateInfo,
VkDescriptorSet *pDescriptorSets)
{
struct vn_device *dev = vn_device_from_handle(device);
struct vn_descriptor_pool *pool =
vn_descriptor_pool_from_handle(pAllocateInfo->descriptorPool);
const VkAllocationCallbacks *alloc = &pool->allocator;
VkResult result;
/* 14.2.3. Allocation of Descriptor Sets
*
* If descriptorSetCount is zero or this structure is not included in
* the pNext chain, then the variable lengths are considered to be zero.
*/
const VkDescriptorSetVariableDescriptorCountAllocateInfo *variable_info =
vk_find_struct_const(
pAllocateInfo->pNext,
DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO);
if (variable_info && !variable_info->descriptorSetCount)
variable_info = NULL;
uint32_t i = 0;
for (; i < pAllocateInfo->descriptorSetCount; i++) {
struct vn_descriptor_set_layout *layout =
vn_descriptor_set_layout_from_handle(pAllocateInfo->pSetLayouts[i]);
/* 14.2.3. Allocation of Descriptor Sets
*
* If VkDescriptorSetAllocateInfo::pSetLayouts[i] does not include a
* variable count descriptor binding, then pDescriptorCounts[i] is
* ignored.
*/
uint32_t last_binding_descriptor_count = 0;
if (!layout->has_variable_descriptor_count) {
last_binding_descriptor_count =
layout->bindings[layout->last_binding].count;
} else if (variable_info) {
last_binding_descriptor_count = variable_info->pDescriptorCounts[i];
}
if (pool->async_set_allocation &&
!vn_descriptor_pool_alloc_descriptors(
pool, layout, last_binding_descriptor_count)) {
result = VK_ERROR_OUT_OF_POOL_MEMORY;
goto fail;
}
struct vn_descriptor_set *set =
vk_zalloc(alloc, sizeof(*set), VN_DEFAULT_ALIGN,
VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
if (!set) {
if (pool->async_set_allocation) {
vn_descriptor_pool_free_descriptors(
pool, layout, last_binding_descriptor_count);
}
result = VK_ERROR_OUT_OF_HOST_MEMORY;
goto fail;
}
vn_object_base_init(&set->base, VK_OBJECT_TYPE_DESCRIPTOR_SET,
&dev->base);
/* We might reorder vkCmdBindDescriptorSets after
* vkDestroyDescriptorSetLayout due to batching. The spec says
*
* VkDescriptorSetLayout objects may be accessed by commands that
* operate on descriptor sets allocated using that layout, and those
* descriptor sets must not be updated with vkUpdateDescriptorSets
* after the descriptor set layout has been destroyed. Otherwise, a
* VkDescriptorSetLayout object passed as a parameter to create
* another object is not further accessed by that object after the
* duration of the command it is passed into.
*
* It is ambiguous but the reordering is likely invalid. Let's keep the
* layout alive with the set to defer vkDestroyDescriptorSetLayout.
*/
set->layout = vn_descriptor_set_layout_ref(dev, layout);
set->last_binding_descriptor_count = last_binding_descriptor_count;
list_addtail(&set->head, &pool->descriptor_sets);
pDescriptorSets[i] = vn_descriptor_set_to_handle(set);
}
if (pool->async_set_allocation) {
vn_async_vkAllocateDescriptorSets(dev->primary_ring, device,
pAllocateInfo, pDescriptorSets);
} else {
result = vn_call_vkAllocateDescriptorSets(
dev->primary_ring, device, pAllocateInfo, pDescriptorSets);
if (result != VK_SUCCESS)
goto fail;
}
return VK_SUCCESS;
fail:
for (uint32_t j = 0; j < i; j++) {
struct vn_descriptor_set *set =
vn_descriptor_set_from_handle(pDescriptorSets[j]);
if (pool->async_set_allocation) {
vn_descriptor_pool_free_descriptors(
pool, set->layout, set->last_binding_descriptor_count);
}
vn_descriptor_set_destroy(dev, set, alloc);
}
memset(pDescriptorSets, 0,
sizeof(*pDescriptorSets) * pAllocateInfo->descriptorSetCount);
return vn_error(dev->instance, result);
}
VkResult
vn_FreeDescriptorSets(VkDevice device,
VkDescriptorPool descriptorPool,
uint32_t descriptorSetCount,
const VkDescriptorSet *pDescriptorSets)
{
struct vn_device *dev = vn_device_from_handle(device);
struct vn_descriptor_pool *pool =
vn_descriptor_pool_from_handle(descriptorPool);
const VkAllocationCallbacks *alloc = &pool->allocator;
assert(!pool->async_set_allocation);
vn_async_vkFreeDescriptorSets(dev->primary_ring, device, descriptorPool,
descriptorSetCount, pDescriptorSets);
for (uint32_t i = 0; i < descriptorSetCount; i++) {
struct vn_descriptor_set *set =
vn_descriptor_set_from_handle(pDescriptorSets[i]);
if (!set)
continue;
vn_descriptor_set_destroy(dev, set, alloc);
}
return VK_SUCCESS;
}
uint32_t
vn_descriptor_set_count_write_images(uint32_t write_count,
const VkWriteDescriptorSet *writes)
{
uint32_t img_info_count = 0;
for (uint32_t i = 0; i < write_count; i++) {
const VkWriteDescriptorSet *write = &writes[i];
switch (write->descriptorType) {
case VK_DESCRIPTOR_TYPE_SAMPLER:
case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:
case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:
img_info_count += write->descriptorCount;
break;
default:
break;
}
}
return img_info_count;
}
const VkWriteDescriptorSet *
vn_descriptor_set_get_writes(uint32_t write_count,
const VkWriteDescriptorSet *writes,
VkPipelineLayout pipeline_layout_handle,
struct vn_descriptor_set_writes *local)
{
const struct vn_pipeline_layout *pipeline_layout =
vn_pipeline_layout_from_handle(pipeline_layout_handle);
typed_memcpy(local->writes, writes, write_count);
uint32_t img_info_count = 0;
for (uint32_t i = 0; i < write_count; i++) {
const struct vn_descriptor_set_layout *set_layout =
pipeline_layout
? pipeline_layout->push_descriptor_set_layout
: vn_descriptor_set_from_handle(writes[i].dstSet)->layout;
VkWriteDescriptorSet *write = &local->writes[i];
VkDescriptorImageInfo *img_infos = &local->img_infos[img_info_count];
bool ignore_sampler = true;
bool ignore_iview = false;
switch (write->descriptorType) {
case VK_DESCRIPTOR_TYPE_SAMPLER:
ignore_iview = true;
FALLTHROUGH;
case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
ignore_sampler =
set_layout->bindings[write->dstBinding].has_immutable_samplers;
FALLTHROUGH;
case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:
case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:
typed_memcpy(img_infos, write->pImageInfo, write->descriptorCount);
for (uint32_t j = 0; j < write->descriptorCount; j++) {
if (ignore_sampler)
img_infos[j].sampler = VK_NULL_HANDLE;
if (ignore_iview)
img_infos[j].imageView = VK_NULL_HANDLE;
}
write->pImageInfo = img_infos;
write->pBufferInfo = NULL;
write->pTexelBufferView = NULL;
img_info_count += write->descriptorCount;
break;
case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:
case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
write->pImageInfo = NULL;
write->pBufferInfo = NULL;
break;
case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:
write->pImageInfo = NULL;
write->pTexelBufferView = NULL;
break;
case VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK:
case VK_DESCRIPTOR_TYPE_MUTABLE_EXT:
default:
write->pImageInfo = NULL;
write->pBufferInfo = NULL;
write->pTexelBufferView = NULL;
break;
}
}
return local->writes;
}
void
vn_UpdateDescriptorSets(VkDevice device,
uint32_t descriptorWriteCount,
const VkWriteDescriptorSet *pDescriptorWrites,
uint32_t descriptorCopyCount,
const VkCopyDescriptorSet *pDescriptorCopies)
{
struct vn_device *dev = vn_device_from_handle(device);
const uint32_t img_info_count = vn_descriptor_set_count_write_images(
descriptorWriteCount, pDescriptorWrites);
STACK_ARRAY(VkWriteDescriptorSet, writes, descriptorWriteCount);
STACK_ARRAY(VkDescriptorImageInfo, img_infos, img_info_count);
struct vn_descriptor_set_writes local = {
.writes = writes,
.img_infos = img_infos,
};
pDescriptorWrites = vn_descriptor_set_get_writes(
descriptorWriteCount, pDescriptorWrites, VK_NULL_HANDLE, &local);
vn_async_vkUpdateDescriptorSets(dev->primary_ring, device,
descriptorWriteCount, pDescriptorWrites,
descriptorCopyCount, pDescriptorCopies);
STACK_ARRAY_FINISH(writes);
STACK_ARRAY_FINISH(img_infos);
}
/* descriptor update template commands */
static void
vn_descriptor_update_template_init(
struct vn_descriptor_update_template *templ,
const VkDescriptorUpdateTemplateCreateInfo *create_info)
{
templ->entry_count = create_info->descriptorUpdateEntryCount;
for (uint32_t i = 0; i < create_info->descriptorUpdateEntryCount; i++) {
const VkDescriptorUpdateTemplateEntry *entry =
&create_info->pDescriptorUpdateEntries[i];
templ->entries[i] = *entry;
switch (entry->descriptorType) {
case VK_DESCRIPTOR_TYPE_SAMPLER:
case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:
case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:
templ->img_info_count += entry->descriptorCount;
break;
case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:
case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
templ->bview_count += entry->descriptorCount;
break;
case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:
templ->buf_info_count += entry->descriptorCount;
break;
case VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK:
templ->iub_count += 1;
break;
case VK_DESCRIPTOR_TYPE_MUTABLE_EXT:
break;
default:
unreachable("unhandled descriptor type");
break;
}
}
}
VkResult
vn_CreateDescriptorUpdateTemplate(
VkDevice device,
const VkDescriptorUpdateTemplateCreateInfo *pCreateInfo,
const VkAllocationCallbacks *pAllocator,
VkDescriptorUpdateTemplate *pDescriptorUpdateTemplate)
{
VN_TRACE_FUNC();
struct vn_device *dev = vn_device_from_handle(device);
const VkAllocationCallbacks *alloc =
pAllocator ? pAllocator : &dev->base.base.alloc;
const size_t templ_size =
offsetof(struct vn_descriptor_update_template,
entries[pCreateInfo->descriptorUpdateEntryCount]);
struct vn_descriptor_update_template *templ = vk_zalloc(
alloc, templ_size, VN_DEFAULT_ALIGN, VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
if (!templ)
return vn_error(dev->instance, VK_ERROR_OUT_OF_HOST_MEMORY);
vn_object_base_init(&templ->base,
VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE, &dev->base);
if (pCreateInfo->templateType ==
VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR) {
struct vn_pipeline_layout *pipeline_layout =
vn_pipeline_layout_from_handle(pCreateInfo->pipelineLayout);
templ->push.pipeline_bind_point = pCreateInfo->pipelineBindPoint;
templ->push.set_layout = pipeline_layout->push_descriptor_set_layout;
}
vn_descriptor_update_template_init(templ, pCreateInfo);
/* no host object */
*pDescriptorUpdateTemplate =
vn_descriptor_update_template_to_handle(templ);
return VK_SUCCESS;
}
void
vn_DestroyDescriptorUpdateTemplate(
VkDevice device,
VkDescriptorUpdateTemplate descriptorUpdateTemplate,
const VkAllocationCallbacks *pAllocator)
{
VN_TRACE_FUNC();
struct vn_device *dev = vn_device_from_handle(device);
struct vn_descriptor_update_template *templ =
vn_descriptor_update_template_from_handle(descriptorUpdateTemplate);
const VkAllocationCallbacks *alloc =
pAllocator ? pAllocator : &dev->base.base.alloc;
if (!templ)
return;
/* no host object */
vn_object_base_fini(&templ->base);
vk_free(alloc, templ);
}
void
vn_descriptor_set_fill_update_with_template(
struct vn_descriptor_update_template *templ,
VkDescriptorSet set_handle,
const uint8_t *data,
struct vn_descriptor_set_update *update)
{
struct vn_descriptor_set *set = vn_descriptor_set_from_handle(set_handle);
const struct vn_descriptor_set_layout *set_layout =
templ->push.set_layout ? templ->push.set_layout : set->layout;
update->write_count = templ->entry_count;
uint32_t img_info_offset = 0;
uint32_t buf_info_offset = 0;
uint32_t bview_offset = 0;
uint32_t iub_offset = 0;
for (uint32_t i = 0; i < templ->entry_count; i++) {
const VkDescriptorUpdateTemplateEntry *entry = &templ->entries[i];
const uint8_t *ptr = data + entry->offset;
bool ignore_sampler = true;
bool ignore_iview = false;
VkDescriptorImageInfo *img_infos = NULL;
VkDescriptorBufferInfo *buf_infos = NULL;
VkBufferView *bview_handles = NULL;
VkWriteDescriptorSetInlineUniformBlock *iub = NULL;
switch (entry->descriptorType) {
case VK_DESCRIPTOR_TYPE_SAMPLER:
ignore_iview = true;
FALLTHROUGH;
case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
ignore_sampler =
set_layout->bindings[entry->dstBinding].has_immutable_samplers;
FALLTHROUGH;
case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:
case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:
img_infos = &update->img_infos[img_info_offset];
for (uint32_t j = 0; j < entry->descriptorCount; j++) {
const VkDescriptorImageInfo *src = (const void *)ptr;
img_infos[j] = (VkDescriptorImageInfo){
.sampler = ignore_sampler ? VK_NULL_HANDLE : src->sampler,
.imageView = ignore_iview ? VK_NULL_HANDLE : src->imageView,
.imageLayout = src->imageLayout,
};
ptr += entry->stride;
}
img_info_offset += entry->descriptorCount;
break;
case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:
case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
bview_handles = &update->bview_handles[bview_offset];
for (uint32_t j = 0; j < entry->descriptorCount; j++) {
bview_handles[j] = *(const VkBufferView *)ptr;
ptr += entry->stride;
}
bview_offset += entry->descriptorCount;
break;
case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:
buf_infos = &update->buf_infos[buf_info_offset];
for (uint32_t j = 0; j < entry->descriptorCount; j++) {
buf_infos[j] = *(const VkDescriptorBufferInfo *)ptr;
ptr += entry->stride;
}
buf_info_offset += entry->descriptorCount;
break;
case VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK:
iub = &update->iubs[iub_offset];
*iub = (VkWriteDescriptorSetInlineUniformBlock){
.sType =
VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK,
.dataSize = entry->descriptorCount,
.pData = (const void *)ptr,
};
iub_offset++;
break;
case VK_DESCRIPTOR_TYPE_MUTABLE_EXT:
break;
default:
unreachable("unhandled descriptor type");
break;
}
update->writes[i] = (VkWriteDescriptorSet){
.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET,
.pNext = iub,
.dstSet = set_handle,
.dstBinding = entry->dstBinding,
.dstArrayElement = entry->dstArrayElement,
.descriptorCount = entry->descriptorCount,
.descriptorType = entry->descriptorType,
.pImageInfo = img_infos,
.pBufferInfo = buf_infos,
.pTexelBufferView = bview_handles,
};
}
}
void
vn_UpdateDescriptorSetWithTemplate(
VkDevice device,
VkDescriptorSet descriptorSet,
VkDescriptorUpdateTemplate descriptorUpdateTemplate,
const void *pData)
{
struct vn_device *dev = vn_device_from_handle(device);
struct vn_descriptor_update_template *templ =
vn_descriptor_update_template_from_handle(descriptorUpdateTemplate);
STACK_ARRAY(VkWriteDescriptorSet, writes, templ->entry_count);
STACK_ARRAY(VkDescriptorImageInfo, img_infos, templ->img_info_count);
STACK_ARRAY(VkDescriptorBufferInfo, buf_infos, templ->buf_info_count);
STACK_ARRAY(VkBufferView, bview_handles, templ->bview_count);
STACK_ARRAY(VkWriteDescriptorSetInlineUniformBlock, iubs,
templ->iub_count);
struct vn_descriptor_set_update update = {
.writes = writes,
.img_infos = img_infos,
.buf_infos = buf_infos,
.bview_handles = bview_handles,
.iubs = iubs,
};
vn_descriptor_set_fill_update_with_template(templ, descriptorSet, pData,
&update);
vn_async_vkUpdateDescriptorSets(
dev->primary_ring, device, update.write_count, update.writes, 0, NULL);
STACK_ARRAY_FINISH(writes);
STACK_ARRAY_FINISH(img_infos);
STACK_ARRAY_FINISH(buf_infos);
STACK_ARRAY_FINISH(bview_handles);
STACK_ARRAY_FINISH(iubs);
}
Reference in New Issue View Git Blame Copy Permalink