/* * Copyright © 2016 Red Hat. * Copyright © 2016 Bas Nieuwenhuizen * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice (including the next * paragraph) shall be included in all copies or substantial portions of the * Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER * DEALINGS IN THE SOFTWARE. */ #include "tu_private.h" #include #include #include #include #include #include "util/mesa-sha1.h" #include "vk_util.h" static int binding_compare(const void *av, const void *bv) { const VkDescriptorSetLayoutBinding *a = (const VkDescriptorSetLayoutBinding *) av; const VkDescriptorSetLayoutBinding *b = (const VkDescriptorSetLayoutBinding *) bv; return (a->binding < b->binding) ? -1 : (a->binding > b->binding) ? 1 : 0; } static VkDescriptorSetLayoutBinding * create_sorted_bindings(const VkDescriptorSetLayoutBinding *bindings, unsigned count) { VkDescriptorSetLayoutBinding *sorted_bindings = malloc(count * sizeof(VkDescriptorSetLayoutBinding)); if (!sorted_bindings) return NULL; memcpy(sorted_bindings, bindings, count * sizeof(VkDescriptorSetLayoutBinding)); qsort(sorted_bindings, count, sizeof(VkDescriptorSetLayoutBinding), binding_compare); return sorted_bindings; } VkResult tu_CreateDescriptorSetLayout( VkDevice _device, const VkDescriptorSetLayoutCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDescriptorSetLayout *pSetLayout) { TU_FROM_HANDLE(tu_device, device, _device); struct tu_descriptor_set_layout *set_layout; assert(pCreateInfo->sType == VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO); const VkDescriptorSetLayoutBindingFlagsCreateInfoEXT *variable_flags = vk_find_struct_const( pCreateInfo->pNext, DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO_EXT); uint32_t max_binding = 0; uint32_t immutable_sampler_count = 0; for (uint32_t j = 0; j < pCreateInfo->bindingCount; j++) { max_binding = MAX2(max_binding, pCreateInfo->pBindings[j].binding); if (pCreateInfo->pBindings[j].pImmutableSamplers) immutable_sampler_count += pCreateInfo->pBindings[j].descriptorCount; } uint32_t samplers_offset = sizeof(struct tu_descriptor_set_layout) + (max_binding + 1) * sizeof(set_layout->binding[0]); size_t size = samplers_offset + immutable_sampler_count * 4 * sizeof(uint32_t); set_layout = vk_alloc2(&device->alloc, pAllocator, size, 8, VK_SYSTEM_ALLOCATION_SCOPE_OBJECT); if (!set_layout) return vk_error(device->instance, VK_ERROR_OUT_OF_HOST_MEMORY); set_layout->flags = pCreateInfo->flags; /* We just allocate all the samplers at the end of the struct */ uint32_t *samplers = (uint32_t *) &set_layout->binding[max_binding + 1]; (void) samplers; /* TODO: Use me */ VkDescriptorSetLayoutBinding *bindings = create_sorted_bindings( pCreateInfo->pBindings, pCreateInfo->bindingCount); if (!bindings) { vk_free2(&device->alloc, pAllocator, set_layout); return vk_error(device->instance, VK_ERROR_OUT_OF_HOST_MEMORY); } set_layout->binding_count = max_binding + 1; set_layout->shader_stages = 0; set_layout->dynamic_shader_stages = 0; set_layout->has_immutable_samplers = false; set_layout->size = 0; memset(set_layout->binding, 0, size - sizeof(struct tu_descriptor_set_layout)); uint32_t buffer_count = 0; uint32_t dynamic_offset_count = 0; for (uint32_t j = 0; j < pCreateInfo->bindingCount; j++) { const VkDescriptorSetLayoutBinding *binding = bindings + j; uint32_t b = binding->binding; uint32_t alignment; unsigned binding_buffer_count = 0; switch (binding->descriptorType) { case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC: case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC: assert(!(pCreateInfo->flags & VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR)); set_layout->binding[b].dynamic_offset_count = 1; set_layout->dynamic_shader_stages |= binding->stageFlags; set_layout->binding[b].size = 0; binding_buffer_count = 1; alignment = 1; break; case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER: case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER: case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER: case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER: set_layout->binding[b].size = 16; binding_buffer_count = 1; alignment = 16; break; case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE: case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE: case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT: /* main descriptor + fmask descriptor */ set_layout->binding[b].size = 64; binding_buffer_count = 1; alignment = 32; break; case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER: /* main descriptor + fmask descriptor + sampler */ set_layout->binding[b].size = 96; binding_buffer_count = 1; alignment = 32; break; case VK_DESCRIPTOR_TYPE_SAMPLER: set_layout->binding[b].size = 16; alignment = 16; break; default: unreachable("unknown descriptor type\n"); break; } set_layout->size = align(set_layout->size, alignment); set_layout->binding[b].type = binding->descriptorType; set_layout->binding[b].array_size = binding->descriptorCount; set_layout->binding[b].offset = set_layout->size; set_layout->binding[b].buffer_offset = buffer_count; set_layout->binding[b].dynamic_offset_offset = dynamic_offset_count; if (variable_flags && binding->binding < variable_flags->bindingCount && (variable_flags->pBindingFlags[binding->binding] & VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT_EXT)) { assert(!binding->pImmutableSamplers); /* Terribly ill defined how many samplers are valid */ assert(binding->binding == max_binding); set_layout->has_variable_descriptors = true; } if (binding->pImmutableSamplers) { set_layout->binding[b].immutable_samplers_offset = samplers_offset; set_layout->has_immutable_samplers = true; } set_layout->size += binding->descriptorCount * set_layout->binding[b].size; buffer_count += binding->descriptorCount * binding_buffer_count; dynamic_offset_count += binding->descriptorCount * set_layout->binding[b].dynamic_offset_count; set_layout->shader_stages |= binding->stageFlags; } free(bindings); set_layout->buffer_count = buffer_count; set_layout->dynamic_offset_count = dynamic_offset_count; *pSetLayout = tu_descriptor_set_layout_to_handle(set_layout); return VK_SUCCESS; } void tu_DestroyDescriptorSetLayout(VkDevice _device, VkDescriptorSetLayout _set_layout, const VkAllocationCallbacks *pAllocator) { TU_FROM_HANDLE(tu_device, device, _device); TU_FROM_HANDLE(tu_descriptor_set_layout, set_layout, _set_layout); if (!set_layout) return; vk_free2(&device->alloc, pAllocator, set_layout); } void tu_GetDescriptorSetLayoutSupport( VkDevice device, const VkDescriptorSetLayoutCreateInfo *pCreateInfo, VkDescriptorSetLayoutSupport *pSupport) { VkDescriptorSetLayoutBinding *bindings = create_sorted_bindings( pCreateInfo->pBindings, pCreateInfo->bindingCount); if (!bindings) { pSupport->supported = false; return; } const VkDescriptorSetLayoutBindingFlagsCreateInfoEXT *variable_flags = vk_find_struct_const( pCreateInfo->pNext, DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO_EXT); VkDescriptorSetVariableDescriptorCountLayoutSupportEXT *variable_count = vk_find_struct( (void *) pCreateInfo->pNext, DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT_EXT); if (variable_count) { variable_count->maxVariableDescriptorCount = 0; } bool supported = true; uint64_t size = 0; for (uint32_t i = 0; i < pCreateInfo->bindingCount; i++) { const VkDescriptorSetLayoutBinding *binding = bindings + i; uint64_t descriptor_size = 0; uint64_t descriptor_alignment = 1; switch (binding->descriptorType) { case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC: case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC: break; case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER: case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER: case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER: case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER: descriptor_size = 16; descriptor_alignment = 16; break; case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE: case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE: case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT: descriptor_size = 64; descriptor_alignment = 32; break; case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER: descriptor_size = 96; descriptor_alignment = 32; break; case VK_DESCRIPTOR_TYPE_SAMPLER: descriptor_size = 16; descriptor_alignment = 16; break; default: unreachable("unknown descriptor type\n"); break; } if (size && !align_u64(size, descriptor_alignment)) { supported = false; } size = align_u64(size, descriptor_alignment); uint64_t max_count = UINT64_MAX; if (descriptor_size) max_count = (UINT64_MAX - size) / descriptor_size; if (max_count < binding->descriptorCount) { supported = false; } if (variable_flags && binding->binding < variable_flags->bindingCount && variable_count && (variable_flags->pBindingFlags[binding->binding] & VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT_EXT)) { variable_count->maxVariableDescriptorCount = MIN2(UINT32_MAX, max_count); } size += binding->descriptorCount * descriptor_size; } free(bindings); pSupport->supported = supported; } /* * Pipeline layouts. These have nothing to do with the pipeline. They are * just multiple descriptor set layouts pasted together. */ VkResult tu_CreatePipelineLayout(VkDevice _device, const VkPipelineLayoutCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkPipelineLayout *pPipelineLayout) { TU_FROM_HANDLE(tu_device, device, _device); struct tu_pipeline_layout *layout; struct mesa_sha1 ctx; assert(pCreateInfo->sType == VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO); layout = vk_alloc2(&device->alloc, pAllocator, sizeof(*layout), 8, VK_SYSTEM_ALLOCATION_SCOPE_OBJECT); if (layout == NULL) return vk_error(device->instance, VK_ERROR_OUT_OF_HOST_MEMORY); layout->num_sets = pCreateInfo->setLayoutCount; unsigned dynamic_offset_count = 0; _mesa_sha1_init(&ctx); for (uint32_t set = 0; set < pCreateInfo->setLayoutCount; set++) { TU_FROM_HANDLE(tu_descriptor_set_layout, set_layout, pCreateInfo->pSetLayouts[set]); layout->set[set].layout = set_layout; layout->set[set].dynamic_offset_start = dynamic_offset_count; for (uint32_t b = 0; b < set_layout->binding_count; b++) { dynamic_offset_count += set_layout->binding[b].array_size * set_layout->binding[b].dynamic_offset_count; if (set_layout->binding[b].immutable_samplers_offset) _mesa_sha1_update( &ctx, tu_immutable_samplers(set_layout, set_layout->binding + b), set_layout->binding[b].array_size * 4 * sizeof(uint32_t)); } _mesa_sha1_update( &ctx, set_layout->binding, sizeof(set_layout->binding[0]) * set_layout->binding_count); } layout->dynamic_offset_count = dynamic_offset_count; layout->push_constant_size = 0; for (unsigned i = 0; i < pCreateInfo->pushConstantRangeCount; ++i) { const VkPushConstantRange *range = pCreateInfo->pPushConstantRanges + i; layout->push_constant_size = MAX2(layout->push_constant_size, range->offset + range->size); } layout->push_constant_size = align(layout->push_constant_size, 16); _mesa_sha1_update(&ctx, &layout->push_constant_size, sizeof(layout->push_constant_size)); _mesa_sha1_final(&ctx, layout->sha1); *pPipelineLayout = tu_pipeline_layout_to_handle(layout); return VK_SUCCESS; } void tu_DestroyPipelineLayout(VkDevice _device, VkPipelineLayout _pipelineLayout, const VkAllocationCallbacks *pAllocator) { TU_FROM_HANDLE(tu_device, device, _device); TU_FROM_HANDLE(tu_pipeline_layout, pipeline_layout, _pipelineLayout); if (!pipeline_layout) return; vk_free2(&device->alloc, pAllocator, pipeline_layout); } #define EMPTY 1 VkResult tu_CreateDescriptorPool(VkDevice _device, const VkDescriptorPoolCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDescriptorPool *pDescriptorPool) { TU_FROM_HANDLE(tu_device, device, _device); tu_use_args(device); tu_stub(); return VK_SUCCESS; } void tu_DestroyDescriptorPool(VkDevice _device, VkDescriptorPool _pool, const VkAllocationCallbacks *pAllocator) { } VkResult tu_ResetDescriptorPool(VkDevice _device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags) { TU_FROM_HANDLE(tu_device, device, _device); TU_FROM_HANDLE(tu_descriptor_pool, pool, descriptorPool); tu_use_args(device, pool); tu_stub(); return VK_SUCCESS; } VkResult tu_AllocateDescriptorSets(VkDevice _device, const VkDescriptorSetAllocateInfo *pAllocateInfo, VkDescriptorSet *pDescriptorSets) { TU_FROM_HANDLE(tu_device, device, _device); TU_FROM_HANDLE(tu_descriptor_pool, pool, pAllocateInfo->descriptorPool); tu_use_args(device, pool); tu_stub(); return VK_SUCCESS; } VkResult tu_FreeDescriptorSets(VkDevice _device, VkDescriptorPool descriptorPool, uint32_t count, const VkDescriptorSet *pDescriptorSets) { TU_FROM_HANDLE(tu_device, device, _device); TU_FROM_HANDLE(tu_descriptor_pool, pool, descriptorPool); tu_use_args(device, pool); tu_stub(); return VK_SUCCESS; } void tu_update_descriptor_sets(struct tu_device *device, struct tu_cmd_buffer *cmd_buffer, VkDescriptorSet dstSetOverride, uint32_t descriptorWriteCount, const VkWriteDescriptorSet *pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet *pDescriptorCopies) { } void tu_UpdateDescriptorSets(VkDevice _device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet *pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet *pDescriptorCopies) { TU_FROM_HANDLE(tu_device, device, _device); tu_update_descriptor_sets(device, NULL, VK_NULL_HANDLE, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies); } VkResult tu_CreateDescriptorUpdateTemplate( VkDevice _device, const VkDescriptorUpdateTemplateCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDescriptorUpdateTemplate *pDescriptorUpdateTemplate) { TU_FROM_HANDLE(tu_device, device, _device); TU_FROM_HANDLE(tu_descriptor_set_layout, set_layout, pCreateInfo->descriptorSetLayout); const uint32_t entry_count = pCreateInfo->descriptorUpdateEntryCount; const size_t size = sizeof(struct tu_descriptor_update_template) + sizeof(struct tu_descriptor_update_template_entry) * entry_count; struct tu_descriptor_update_template *templ; templ = vk_alloc2(&device->alloc, pAllocator, size, 8, VK_SYSTEM_ALLOCATION_SCOPE_OBJECT); if (!templ) return vk_error(device->instance, VK_ERROR_OUT_OF_HOST_MEMORY); *pDescriptorUpdateTemplate = tu_descriptor_update_template_to_handle(templ); tu_use_args(set_layout); tu_stub(); return VK_SUCCESS; } void tu_DestroyDescriptorUpdateTemplate( VkDevice _device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks *pAllocator) { TU_FROM_HANDLE(tu_device, device, _device); TU_FROM_HANDLE(tu_descriptor_update_template, templ, descriptorUpdateTemplate); if (!templ) return; vk_free2(&device->alloc, pAllocator, templ); } void tu_update_descriptor_set_with_template( struct tu_device *device, struct tu_cmd_buffer *cmd_buffer, struct tu_descriptor_set *set, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void *pData) { TU_FROM_HANDLE(tu_descriptor_update_template, templ, descriptorUpdateTemplate); tu_use_args(templ); } void tu_UpdateDescriptorSetWithTemplate( VkDevice _device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void *pData) { TU_FROM_HANDLE(tu_device, device, _device); TU_FROM_HANDLE(tu_descriptor_set, set, descriptorSet); tu_update_descriptor_set_with_template(device, NULL, set, descriptorUpdateTemplate, pData); } VkResult tu_CreateSamplerYcbcrConversion( VkDevice device, const VkSamplerYcbcrConversionCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSamplerYcbcrConversion *pYcbcrConversion) { *pYcbcrConversion = VK_NULL_HANDLE; return VK_SUCCESS; } void tu_DestroySamplerYcbcrConversion(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks *pAllocator) { /* Do nothing. */ }