/* * 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 { BITSET_ZERO(mutable_types); 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); }