X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2Fintel%2Fvulkan%2Fanv_descriptor_set.c;h=cb6fa40b36894c5a328ef0c51f31cd455dae4047;hb=4d44848c470c9d214c03906d8decd8056829c4ce;hp=c8747caa060c0dca99fc48838591ba86fb31dd4e;hpb=d6c9bd6e01b4d593f362a3b5518a71acf2e83ca1;p=mesa.git diff --git a/src/intel/vulkan/anv_descriptor_set.c b/src/intel/vulkan/anv_descriptor_set.c index c8747caa060..cb6fa40b368 100644 --- a/src/intel/vulkan/anv_descriptor_set.c +++ b/src/intel/vulkan/anv_descriptor_set.c @@ -103,6 +103,16 @@ anv_descriptor_data_for_type(const struct anv_physical_device *device, type == VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC)) data |= ANV_DESCRIPTOR_ADDRESS_RANGE; + /* On Ivy Bridge and Bay Trail, we need swizzles textures in the shader + * Do not handle VK_DESCRIPTOR_TYPE_STORAGE_IMAGE and + * VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT because they already must + * have identity swizzle. + */ + if (device->info.gen == 7 && !device->info.is_haswell && + (type == VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE || + type == VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER)) + data |= ANV_DESCRIPTOR_TEXTURE_SWIZZLE; + return data; } @@ -123,9 +133,22 @@ anv_descriptor_data_size(enum anv_descriptor_data data) if (data & ANV_DESCRIPTOR_ADDRESS_RANGE) size += sizeof(struct anv_address_range_descriptor); + if (data & ANV_DESCRIPTOR_TEXTURE_SWIZZLE) + size += sizeof(struct anv_texture_swizzle_descriptor); + return size; } +static bool +anv_needs_descriptor_buffer(VkDescriptorType desc_type, + enum anv_descriptor_data desc_data) +{ + if (desc_type == VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT || + anv_descriptor_data_size(desc_data) > 0) + return true; + return false; +} + /** Returns the size in bytes of each descriptor with the given layout */ unsigned anv_descriptor_size(const struct anv_descriptor_set_binding_layout *layout) @@ -208,7 +231,12 @@ anv_descriptor_requires_bindless(const struct anv_physical_device *pdevice, if (pdevice->always_use_bindless) return anv_descriptor_supports_bindless(pdevice, binding, sampler); - return false; + static const VkDescriptorBindingFlagBitsEXT flags_requiring_bindless = + VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT_EXT | + VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT_EXT | + VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT_EXT; + + return (binding->flags & flags_requiring_bindless) != 0; } void anv_GetDescriptorSetLayoutSupport( @@ -217,10 +245,10 @@ void anv_GetDescriptorSetLayoutSupport( VkDescriptorSetLayoutSupport* pSupport) { ANV_FROM_HANDLE(anv_device, device, _device); - const struct anv_physical_device *pdevice = - &device->instance->physicalDevice; + const struct anv_physical_device *pdevice = device->physical; uint32_t surface_count[MESA_SHADER_STAGES] = { 0, }; + bool needs_descriptor_buffer = false; for (uint32_t b = 0; b < pCreateInfo->bindingCount; b++) { const VkDescriptorSetLayoutBinding *binding = &pCreateInfo->pBindings[b]; @@ -228,11 +256,18 @@ void anv_GetDescriptorSetLayoutSupport( enum anv_descriptor_data desc_data = anv_descriptor_data_for_type(pdevice, binding->descriptorType); + if (anv_needs_descriptor_buffer(binding->descriptorType, desc_data)) + needs_descriptor_buffer = true; + switch (binding->descriptorType) { case VK_DESCRIPTOR_TYPE_SAMPLER: /* There is no real limit on samplers */ break; + case VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT: + /* Inline uniforms don't use a binding */ + break; + case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER: if (anv_descriptor_data_supports_bindless(pdevice, desc_data, false)) break; @@ -260,12 +295,17 @@ void anv_GetDescriptorSetLayoutSupport( } } + for (unsigned s = 0; s < MESA_SHADER_STAGES; s++) { + if (needs_descriptor_buffer) + surface_count[s] += 1; + } + bool supported = true; for (unsigned s = 0; s < MESA_SHADER_STAGES; s++) { /* Our maximum binding table size is 240 and we need to reserve 8 for * render targets. */ - if (surface_count[s] >= MAX_BINDING_TABLE_SIZE - MAX_RTS) + if (surface_count[s] > MAX_BINDING_TABLE_SIZE - MAX_RTS) supported = false; } @@ -318,11 +358,13 @@ VkResult anv_CreateDescriptorSetLayout( anv_multialloc_add(&ma, &bindings, max_binding + 1); anv_multialloc_add(&ma, &samplers, immutable_sampler_count); - if (!anv_multialloc_alloc(&ma, &device->alloc, + if (!anv_multialloc_alloc(&ma, &device->vk.alloc, VK_SYSTEM_ALLOCATION_SCOPE_DEVICE)) return vk_error(VK_ERROR_OUT_OF_HOST_MEMORY); memset(set_layout, 0, sizeof(*set_layout)); + vk_object_base_init(&device->vk, &set_layout->base, + VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT); set_layout->ref_cnt = 1; set_layout->binding_count = max_binding + 1; @@ -347,32 +389,31 @@ VkResult anv_CreateDescriptorSetLayout( for (uint32_t j = 0; j < pCreateInfo->bindingCount; j++) { const VkDescriptorSetLayoutBinding *binding = &pCreateInfo->pBindings[j]; uint32_t b = binding->binding; - /* We temporarily store the pointer to the binding in the + /* We temporarily store pCreateInfo->pBindings[] index (plus one) in the * immutable_samplers pointer. This provides us with a quick-and-dirty * way to sort the bindings by binding number. */ - set_layout->binding[b].immutable_samplers = (void *)binding; + set_layout->binding[b].immutable_samplers = (void *)(uintptr_t)(j + 1); } const VkDescriptorSetLayoutBindingFlagsCreateInfoEXT *binding_flags_info = vk_find_struct_const(pCreateInfo->pNext, DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO_EXT); - if (binding_flags_info) - assert(binding_flags_info->bindingCount == pCreateInfo->bindingCount); for (uint32_t b = 0; b <= max_binding; b++) { - const VkDescriptorSetLayoutBinding *binding = - (void *)set_layout->binding[b].immutable_samplers; - - if (binding == NULL) - continue; - - /* We temporarily stashed the pointer to the binding in the - * immutable_samplers pointer. Now that we've pulled it back out - * again, we reset immutable_samplers to NULL. + /* We stashed the pCreateInfo->pBindings[] index (plus one) in the + * immutable_samplers pointer. Check for NULL (empty binding) and then + * reset it and compute the index. */ + if (set_layout->binding[b].immutable_samplers == NULL) + continue; + const uint32_t info_idx = + (uintptr_t)(void *)set_layout->binding[b].immutable_samplers - 1; set_layout->binding[b].immutable_samplers = NULL; + const VkDescriptorSetLayoutBinding *binding = + &pCreateInfo->pBindings[info_idx]; + if (binding->descriptorCount == 0) continue; @@ -380,15 +421,14 @@ VkResult anv_CreateDescriptorSetLayout( set_layout->binding[b].type = binding->descriptorType; #endif - if (binding_flags_info) { - uint32_t binding_strct_idx = binding - pCreateInfo->pBindings; - assert(binding_strct_idx < binding_flags_info->bindingCount); + if (binding_flags_info && binding_flags_info->bindingCount > 0) { + assert(binding_flags_info->bindingCount == pCreateInfo->bindingCount); set_layout->binding[b].flags = - binding_flags_info->pBindingFlags[binding_strct_idx]; + binding_flags_info->pBindingFlags[info_idx]; } set_layout->binding[b].data = - anv_descriptor_data_for_type(&device->instance->physicalDevice, + anv_descriptor_data_for_type(device->physical, binding->descriptorType); set_layout->binding[b].array_size = binding->descriptorCount; set_layout->binding[b].descriptor_index = set_layout->size; @@ -430,7 +470,15 @@ VkResult anv_CreateDescriptorSetLayout( case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC: case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC: set_layout->binding[b].dynamic_offset_index = dynamic_offset_count; + anv_foreach_stage(s, binding->stageFlags) { + STATIC_ASSERT(MAX_DYNAMIC_BUFFERS <= + sizeof(set_layout->stage_dynamic_offsets[s]) * 8); + set_layout->stage_dynamic_offsets[s] |= + BITFIELD_RANGE(set_layout->binding[b].dynamic_offset_index, + binding->descriptorCount); + } dynamic_offset_count += binding->descriptorCount; + assert(dynamic_offset_count < MAX_DYNAMIC_BUFFERS); break; default: @@ -463,6 +511,15 @@ VkResult anv_CreateDescriptorSetLayout( return VK_SUCCESS; } +void +anv_descriptor_set_layout_destroy(struct anv_device *device, + struct anv_descriptor_set_layout *layout) +{ + assert(layout->ref_cnt == 0); + vk_object_base_finish(&layout->base); + vk_free(&device->vk.alloc, layout); +} + void anv_DestroyDescriptorSetLayout( VkDevice _device, VkDescriptorSetLayout _set_layout, @@ -541,11 +598,13 @@ VkResult anv_CreatePipelineLayout( assert(pCreateInfo->sType == VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO); - layout = vk_alloc2(&device->alloc, pAllocator, sizeof(*layout), 8, + layout = vk_alloc2(&device->vk.alloc, pAllocator, sizeof(*layout), 8, VK_SYSTEM_ALLOCATION_SCOPE_OBJECT); if (layout == NULL) return vk_error(VK_ERROR_OUT_OF_HOST_MEMORY); + vk_object_base_init(&device->vk, &layout->base, + VK_OBJECT_TYPE_PIPELINE_LAYOUT); layout->num_sets = pCreateInfo->setLayoutCount; unsigned dynamic_offset_count = 0; @@ -564,6 +623,7 @@ VkResult anv_CreatePipelineLayout( dynamic_offset_count += set_layout->binding[b].array_size; } } + assert(dynamic_offset_count < MAX_DYNAMIC_BUFFERS); struct mesa_sha1 ctx; _mesa_sha1_init(&ctx); @@ -594,7 +654,8 @@ void anv_DestroyPipelineLayout( for (uint32_t i = 0; i < pipeline_layout->num_sets; i++) anv_descriptor_set_layout_unref(device, pipeline_layout->set[i].layout); - vk_free2(&device->alloc, pAllocator, pipeline_layout); + vk_object_base_finish(&pipeline_layout->base); + vk_free2(&device->vk.alloc, pAllocator, pipeline_layout); } /* @@ -635,7 +696,7 @@ VkResult anv_CreateDescriptorPool( uint32_t descriptor_bo_size = 0; for (uint32_t i = 0; i < pCreateInfo->poolSizeCount; i++) { enum anv_descriptor_data desc_data = - anv_descriptor_data_for_type(&device->instance->physicalDevice, + anv_descriptor_data_for_type(device->physical, pCreateInfo->pPoolSizes[i].type); if (desc_data & ANV_DESCRIPTOR_BUFFER_VIEW) @@ -673,10 +734,10 @@ VkResult anv_CreateDescriptorPool( * of them to 32B. */ descriptor_bo_size += 32 * pCreateInfo->maxSets; - descriptor_bo_size = ALIGN(descriptor_bo_size, 4096); /* We align inline uniform blocks to 32B */ if (inline_info) descriptor_bo_size += 32 * inline_info->maxInlineUniformBlockBindings; + descriptor_bo_size = ALIGN(descriptor_bo_size, 4096); const size_t pool_size = pCreateInfo->maxSets * sizeof(struct anv_descriptor_set) + @@ -684,40 +745,32 @@ VkResult anv_CreateDescriptorPool( buffer_view_count * sizeof(struct anv_buffer_view); const size_t total_size = sizeof(*pool) + pool_size; - pool = vk_alloc2(&device->alloc, pAllocator, total_size, 8, + pool = vk_alloc2(&device->vk.alloc, pAllocator, total_size, 8, VK_SYSTEM_ALLOCATION_SCOPE_OBJECT); if (!pool) return vk_error(VK_ERROR_OUT_OF_HOST_MEMORY); + vk_object_base_init(&device->vk, &pool->base, + VK_OBJECT_TYPE_DESCRIPTOR_POOL); pool->size = pool_size; pool->next = 0; pool->free_list = EMPTY; if (descriptor_bo_size > 0) { - VkResult result = anv_bo_init_new(&pool->bo, device, descriptor_bo_size); + VkResult result = anv_device_alloc_bo(device, + descriptor_bo_size, + ANV_BO_ALLOC_MAPPED | + ANV_BO_ALLOC_SNOOPED, + 0 /* explicit_address */, + &pool->bo); if (result != VK_SUCCESS) { - vk_free2(&device->alloc, pAllocator, pool); + vk_free2(&device->vk.alloc, pAllocator, pool); return result; } - anv_gem_set_caching(device, pool->bo.gem_handle, I915_CACHING_CACHED); - - pool->bo.map = anv_gem_mmap(device, pool->bo.gem_handle, 0, - descriptor_bo_size, 0); - if (pool->bo.map == NULL) { - anv_gem_close(device, pool->bo.gem_handle); - vk_free2(&device->alloc, pAllocator, pool); - return vk_error(VK_ERROR_OUT_OF_HOST_MEMORY); - } - - if (device->instance->physicalDevice.use_softpin) { - pool->bo.flags |= EXEC_OBJECT_PINNED; - anv_vma_alloc(device, &pool->bo); - } - util_vma_heap_init(&pool->bo_heap, POOL_HEAP_OFFSET, descriptor_bo_size); } else { - pool->bo.size = 0; + pool->bo = NULL; } anv_state_stream_init(&pool->surface_state_stream, @@ -742,21 +795,17 @@ void anv_DestroyDescriptorPool( if (!pool) return; - if (pool->bo.size) { - anv_gem_munmap(pool->bo.map, pool->bo.size); - anv_vma_free(device, &pool->bo); - anv_gem_close(device, pool->bo.gem_handle); - } - anv_state_stream_finish(&pool->surface_state_stream); - list_for_each_entry_safe(struct anv_descriptor_set, set, &pool->desc_sets, pool_link) { - anv_descriptor_set_destroy(device, pool, set); + anv_descriptor_set_layout_unref(device, set->layout); } - util_vma_heap_finish(&pool->bo_heap); + if (pool->bo) + anv_device_release_bo(device, pool->bo); + anv_state_stream_finish(&pool->surface_state_stream); - vk_free2(&device->alloc, pAllocator, pool); + vk_object_base_finish(&pool->base); + vk_free2(&device->vk.alloc, pAllocator, pool); } VkResult anv_ResetDescriptorPool( @@ -769,15 +818,16 @@ VkResult anv_ResetDescriptorPool( list_for_each_entry_safe(struct anv_descriptor_set, set, &pool->desc_sets, pool_link) { - anv_descriptor_set_destroy(device, pool, set); + anv_descriptor_set_layout_unref(device, set->layout); } + list_inithead(&pool->desc_sets); pool->next = 0; pool->free_list = EMPTY; - if (pool->bo.size) { + if (pool->bo) { util_vma_heap_finish(&pool->bo_heap); - util_vma_heap_init(&pool->bo_heap, POOL_HEAP_OFFSET, pool->bo.size); + util_vma_heap_init(&pool->bo_heap, POOL_HEAP_OFFSET, pool->bo->size); } anv_state_stream_finish(&pool->surface_state_stream); @@ -837,8 +887,6 @@ anv_descriptor_pool_free_set(struct anv_descriptor_pool *pool, entry->size = set->size; pool->free_list = (char *) entry - pool->data; } - - list_del(&set->pool_link); } struct surface_state_free_list_entry { @@ -899,9 +947,9 @@ anv_descriptor_set_create(struct anv_device *device, /* Align the size to 32 so that alignment gaps don't cause extra holes * in the heap which can lead to bad performance. */ + uint32_t set_buffer_size = ALIGN(layout->descriptor_buffer_size, 32); uint64_t pool_vma_offset = - util_vma_heap_alloc(&pool->bo_heap, - ALIGN(layout->descriptor_buffer_size, 32), 32); + util_vma_heap_alloc(&pool->bo_heap, set_buffer_size, 32); if (pool_vma_offset == 0) { anv_descriptor_pool_free_set(pool, set); return vk_error(VK_ERROR_FRAGMENTED_POOL); @@ -909,14 +957,14 @@ anv_descriptor_set_create(struct anv_device *device, assert(pool_vma_offset >= POOL_HEAP_OFFSET && pool_vma_offset - POOL_HEAP_OFFSET <= INT32_MAX); set->desc_mem.offset = pool_vma_offset - POOL_HEAP_OFFSET; - set->desc_mem.alloc_size = layout->descriptor_buffer_size; - set->desc_mem.map = pool->bo.map + set->desc_mem.offset; + set->desc_mem.alloc_size = set_buffer_size; + set->desc_mem.map = pool->bo->map + set->desc_mem.offset; set->desc_surface_state = anv_descriptor_pool_alloc_state(pool); anv_fill_buffer_surface_state(device, set->desc_surface_state, ISL_FORMAT_R32G32B32A32_FLOAT, (struct anv_address) { - .bo = &pool->bo, + .bo = pool->bo, .offset = set->desc_mem.offset, }, layout->descriptor_buffer_size, 1); @@ -925,6 +973,8 @@ anv_descriptor_set_create(struct anv_device *device, set->desc_surface_state = ANV_STATE_NULL; } + vk_object_base_init(&device->vk, &set->base, + VK_OBJECT_TYPE_DESCRIPTOR_SET); set->pool = pool; set->layout = layout; anv_descriptor_set_layout_ref(layout); @@ -953,7 +1003,7 @@ anv_descriptor_set_create(struct anv_device *device, * will always write in the immutable sampler regardless of what * is in the sampler parameter. */ - struct VkDescriptorImageInfo info = { }; + VkDescriptorImageInfo info = { }; anv_descriptor_set_write_image_view(device, set, &info, VK_DESCRIPTOR_TYPE_SAMPLER, b, i); @@ -968,6 +1018,8 @@ anv_descriptor_set_create(struct anv_device *device, anv_descriptor_pool_alloc_state(pool); } + list_addtail(&set->pool_link, &pool->desc_sets); + *out_set = set; return VK_SUCCESS; @@ -990,6 +1042,9 @@ anv_descriptor_set_destroy(struct anv_device *device, for (uint32_t b = 0; b < set->buffer_view_count; b++) anv_descriptor_pool_free_state(pool, set->buffer_views[b].surface_state); + list_del(&set->pool_link); + + vk_object_base_finish(&set->base); anv_descriptor_pool_free_set(pool, set); } @@ -1013,8 +1068,6 @@ VkResult anv_AllocateDescriptorSets( if (result != VK_SUCCESS) break; - list_addtail(&set->pool_link, &pool->desc_sets); - pDescriptorSets[i] = anv_descriptor_set_to_handle(set); } @@ -1099,12 +1152,16 @@ anv_descriptor_set_write_image_view(struct anv_device *device, switch (type) { case VK_DESCRIPTOR_TYPE_SAMPLER: - sampler = anv_sampler_from_handle(info->sampler); + sampler = bind_layout->immutable_samplers ? + bind_layout->immutable_samplers[element] : + anv_sampler_from_handle(info->sampler); break; case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER: image_view = anv_image_view_from_handle(info->imageView); - sampler = anv_sampler_from_handle(info->sampler); + sampler = bind_layout->immutable_samplers ? + bind_layout->immutable_samplers[element] : + anv_sampler_from_handle(info->sampler); break; case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE: @@ -1117,13 +1174,6 @@ anv_descriptor_set_write_image_view(struct anv_device *device, unreachable("invalid descriptor type"); } - /* If this descriptor has an immutable sampler, we don't want to stomp on - * it. - */ - sampler = bind_layout->immutable_samplers ? - bind_layout->immutable_samplers[element] : - sampler; - *desc = (struct anv_descriptor) { .type = type, .layout = info->imageLayout, @@ -1133,6 +1183,7 @@ anv_descriptor_set_write_image_view(struct anv_device *device, void *desc_map = set->desc_mem.map + bind_layout->descriptor_offset + element * anv_descriptor_size(bind_layout); + memset(desc_map, 0, anv_descriptor_size(bind_layout)); if (bind_layout->data & ANV_DESCRIPTOR_SAMPLED_IMAGE) { struct anv_sampled_image_descriptor desc_data[3]; @@ -1161,6 +1212,9 @@ anv_descriptor_set_write_image_view(struct anv_device *device, MAX2(1, bind_layout->max_plane_count) * sizeof(desc_data[0])); } + if (image_view == NULL) + return; + if (bind_layout->data & ANV_DESCRIPTOR_STORAGE_IMAGE) { assert(!(bind_layout->data & ANV_DESCRIPTOR_IMAGE_PARAM)); assert(image_view->n_planes == 1); @@ -1181,6 +1235,26 @@ anv_descriptor_set_write_image_view(struct anv_device *device, anv_descriptor_set_write_image_param(desc_map, image_param); } + + if (bind_layout->data & ANV_DESCRIPTOR_TEXTURE_SWIZZLE) { + assert(!(bind_layout->data & ANV_DESCRIPTOR_SAMPLED_IMAGE)); + assert(image_view); + struct anv_texture_swizzle_descriptor desc_data[3]; + memset(desc_data, 0, sizeof(desc_data)); + + for (unsigned p = 0; p < image_view->n_planes; p++) { + desc_data[p] = (struct anv_texture_swizzle_descriptor) { + .swizzle = { + (uint8_t)image_view->planes[p].isl.swizzle.r, + (uint8_t)image_view->planes[p].isl.swizzle.g, + (uint8_t)image_view->planes[p].isl.swizzle.b, + (uint8_t)image_view->planes[p].isl.swizzle.a, + }, + }; + } + memcpy(desc_map, desc_data, + MAX2(1, bind_layout->max_plane_count) * sizeof(desc_data[0])); + } } void @@ -1198,14 +1272,20 @@ anv_descriptor_set_write_buffer_view(struct anv_device *device, assert(type == bind_layout->type); + void *desc_map = set->desc_mem.map + bind_layout->descriptor_offset + + element * anv_descriptor_size(bind_layout); + + if (buffer_view == NULL) { + *desc = (struct anv_descriptor) { .type = type, }; + memset(desc_map, 0, anv_descriptor_size(bind_layout)); + return; + } + *desc = (struct anv_descriptor) { .type = type, .buffer_view = buffer_view, }; - void *desc_map = set->desc_mem.map + bind_layout->descriptor_offset + - element * anv_descriptor_size(bind_layout); - if (bind_layout->data & ANV_DESCRIPTOR_SAMPLED_IMAGE) { struct anv_sampled_image_descriptor desc_data = { .image = anv_surface_state_to_handle(buffer_view->surface_state), @@ -1248,9 +1328,25 @@ anv_descriptor_set_write_buffer(struct anv_device *device, assert(type == bind_layout->type); + void *desc_map = set->desc_mem.map + bind_layout->descriptor_offset + + element * anv_descriptor_size(bind_layout); + + if (buffer == NULL) { + *desc = (struct anv_descriptor) { .type = type, }; + memset(desc_map, 0, anv_descriptor_size(bind_layout)); + return; + } + struct anv_address bind_addr = anv_address_add(buffer->address, offset); uint64_t bind_range = anv_buffer_get_range(buffer, offset, range); + /* We report a bounds checking alignment of 32B for the sake of block + * messages which read an entire register worth at a time. + */ + if (type == VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER || + type == VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC) + bind_range = align_u64(bind_range, ANV_UBO_ALIGNMENT); + if (type == VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC || type == VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC) { *desc = (struct anv_descriptor) { @@ -1284,15 +1380,12 @@ anv_descriptor_set_write_buffer(struct anv_device *device, }; } - void *desc_map = set->desc_mem.map + bind_layout->descriptor_offset + - element * anv_descriptor_size(bind_layout); - if (bind_layout->data & ANV_DESCRIPTOR_ADDRESS_RANGE) { - struct anv_address_range_descriptor desc = { + struct anv_address_range_descriptor desc_data = { .address = anv_address_physical(bind_addr), .range = bind_range, }; - memcpy(desc_map, &desc, sizeof(desc)); + memcpy(desc_map, &desc_data, sizeof(desc_data)); } } @@ -1361,9 +1454,7 @@ void anv_UpdateDescriptorSets( case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC: case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC: for (uint32_t j = 0; j < write->descriptorCount; j++) { - assert(write->pBufferInfo[j].buffer); ANV_FROM_HANDLE(anv_buffer, buffer, write->pBufferInfo[j].buffer); - assert(buffer); anv_descriptor_set_write_buffer(device, set, NULL, @@ -1411,9 +1502,6 @@ void anv_UpdateDescriptorSets( &dst->descriptors[dst_layout->descriptor_index]; dst_desc += copy->dstArrayElement; - for (uint32_t j = 0; j < copy->descriptorCount; j++) - dst_desc[j] = src_desc[j]; - if (src_layout->data & ANV_DESCRIPTOR_INLINE_UNIFORM) { assert(src_layout->data == ANV_DESCRIPTOR_INLINE_UNIFORM); memcpy(dst->desc_mem.map + dst_layout->descriptor_offset + @@ -1422,6 +1510,9 @@ void anv_UpdateDescriptorSets( copy->srcArrayElement, copy->descriptorCount); } else { + for (uint32_t j = 0; j < copy->descriptorCount; j++) + dst_desc[j] = src_desc[j]; + unsigned desc_size = anv_descriptor_size(src_layout); if (desc_size > 0) { assert(desc_size == anv_descriptor_size(dst_layout)); @@ -1525,11 +1616,13 @@ VkResult anv_CreateDescriptorUpdateTemplate( size_t size = sizeof(*template) + pCreateInfo->descriptorUpdateEntryCount * sizeof(template->entries[0]); - template = vk_alloc2(&device->alloc, pAllocator, size, 8, + template = vk_alloc2(&device->vk.alloc, pAllocator, size, 8, VK_SYSTEM_ALLOCATION_SCOPE_OBJECT); if (template == NULL) return vk_error(VK_ERROR_OUT_OF_HOST_MEMORY); + vk_object_base_init(&device->vk, &template->base, + VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE); template->bind_point = pCreateInfo->pipelineBindPoint; if (pCreateInfo->templateType == VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET) @@ -1565,7 +1658,8 @@ void anv_DestroyDescriptorUpdateTemplate( ANV_FROM_HANDLE(anv_descriptor_update_template, template, descriptorUpdateTemplate); - vk_free2(&device->alloc, pAllocator, template); + vk_object_base_finish(&template->base); + vk_free2(&device->vk.alloc, pAllocator, template); } void anv_UpdateDescriptorSetWithTemplate(