switch (type) {
case VK_DESCRIPTOR_TYPE_SAMPLER:
data = ANV_DESCRIPTOR_SAMPLER_STATE;
+ if (device->has_bindless_samplers)
+ data |= ANV_DESCRIPTOR_SAMPLED_IMAGE;
break;
case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
data = ANV_DESCRIPTOR_SURFACE_STATE |
ANV_DESCRIPTOR_SAMPLER_STATE;
+ if (device->has_bindless_images || device->has_bindless_samplers)
+ data |= ANV_DESCRIPTOR_SAMPLED_IMAGE;
break;
case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:
+ data = ANV_DESCRIPTOR_SURFACE_STATE;
+ if (device->has_bindless_images)
+ data |= ANV_DESCRIPTOR_SAMPLED_IMAGE;
+ break;
+
case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:
data = ANV_DESCRIPTOR_SURFACE_STATE;
break;
data = ANV_DESCRIPTOR_SURFACE_STATE;
if (device->info.gen < 9)
data |= ANV_DESCRIPTOR_IMAGE_PARAM;
+ if (device->has_bindless_images)
+ data |= ANV_DESCRIPTOR_STORAGE_IMAGE;
break;
case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
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;
}
{
unsigned size = 0;
+ if (data & ANV_DESCRIPTOR_SAMPLED_IMAGE)
+ size += sizeof(struct anv_sampled_image_descriptor);
+
+ if (data & ANV_DESCRIPTOR_STORAGE_IMAGE)
+ size += sizeof(struct anv_storage_image_descriptor);
+
if (data & ANV_DESCRIPTOR_IMAGE_PARAM)
size += BRW_IMAGE_PARAM_SIZE * 4;
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)
return layout->array_size;
}
- return anv_descriptor_data_size(layout->data);
+ unsigned size = anv_descriptor_data_size(layout->data);
+
+ /* For multi-planar bindings, we make every descriptor consume the maximum
+ * number of planes so we don't have to bother with walking arrays and
+ * adding things up every time. Fortunately, YCbCr samplers aren't all
+ * that common and likely won't be in the middle of big arrays.
+ */
+ if (layout->max_plane_count > 1)
+ size *= layout->max_plane_count;
+
+ return size;
}
/** Returns the size in bytes of each descriptor of the given type
anv_descriptor_type_size(const struct anv_physical_device *pdevice,
VkDescriptorType type)
{
- assert(type != VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT);
+ assert(type != VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT &&
+ type != VK_DESCRIPTOR_TYPE_SAMPLER &&
+ type != VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE &&
+ type != VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER);
+
return anv_descriptor_data_size(anv_descriptor_data_for_type(pdevice, type));
}
return true;
}
+ if (data & ANV_DESCRIPTOR_SAMPLED_IMAGE) {
+ assert(pdevice->has_bindless_images || pdevice->has_bindless_samplers);
+ return sampler ? pdevice->has_bindless_samplers :
+ pdevice->has_bindless_images;
+ }
+
+ if (data & ANV_DESCRIPTOR_STORAGE_IMAGE) {
+ assert(pdevice->has_bindless_images);
+ return true;
+ }
+
return false;
}
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(
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];
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;
}
}
+ 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;
}
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;
/* Initialize all binding_layout entries to -1 */
memset(&set_layout->binding[b], -1, sizeof(set_layout->binding[b]));
+ set_layout->binding[b].flags = 0;
set_layout->binding[b].data = 0;
set_layout->binding[b].max_plane_count = 0;
set_layout->binding[b].array_size = 0;
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);
}
- for (uint32_t b = 0; b <= max_binding; b++) {
- const VkDescriptorSetLayoutBinding *binding =
- (void *)set_layout->binding[b].immutable_samplers;
-
- if (binding == NULL)
- continue;
+ const VkDescriptorSetLayoutBindingFlagsCreateInfoEXT *binding_flags_info =
+ vk_find_struct_const(pCreateInfo->pNext,
+ DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO_EXT);
- /* 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.
+ for (uint32_t b = 0; b <= max_binding; b++) {
+ /* 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;
#ifndef NDEBUG
set_layout->binding[b].type = binding->descriptorType;
#endif
+
+ 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[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;
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:
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,
sha1_update_descriptor_set_binding_layout(struct mesa_sha1 *ctx,
const struct anv_descriptor_set_binding_layout *layout)
{
+ SHA1_UPDATE_VALUE(ctx, layout->flags);
SHA1_UPDATE_VALUE(ctx, layout->data);
SHA1_UPDATE_VALUE(ctx, layout->max_plane_count);
SHA1_UPDATE_VALUE(ctx, layout->array_size);
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;
dynamic_offset_count += set_layout->binding[b].array_size;
}
}
+ assert(dynamic_offset_count < MAX_DYNAMIC_BUFFERS);
struct mesa_sha1 ctx;
_mesa_sha1_init(&ctx);
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);
}
/*
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)
unsigned desc_data_size = anv_descriptor_data_size(desc_data) *
pCreateInfo->pPoolSizes[i].descriptorCount;
+ /* Combined image sampler descriptors can take up to 3 slots if they
+ * hold a YCbCr image.
+ */
+ if (pCreateInfo->pPoolSizes[i].type ==
+ VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER)
+ desc_data_size *= 3;
+
if (pCreateInfo->pPoolSizes[i].type ==
VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT) {
/* Inline uniform blocks are specified to use the descriptor array
* 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) +
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,
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(
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);
entry->size = set->size;
pool->free_list = (char *) entry - pool->data;
}
-
- list_del(&set->pool_link);
}
struct surface_state_free_list_entry {
/* 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);
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);
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);
* UpdateDescriptorSets if needed. However, if the descriptor
* set has an immutable sampler, UpdateDescriptorSets may never
* touch it, so we need to make sure it's 100% valid now.
+ *
+ * We don't need to actually provide a sampler because the helper
+ * will always write in the immutable sampler regardless of what
+ * is in the sampler parameter.
*/
- desc[i] = (struct anv_descriptor) {
- .type = VK_DESCRIPTOR_TYPE_SAMPLER,
- .sampler = layout->binding[b].immutable_samplers[i],
- };
+ VkDescriptorImageInfo info = { };
+ anv_descriptor_set_write_image_view(device, set, &info,
+ VK_DESCRIPTOR_TYPE_SAMPLER,
+ b, i);
}
}
desc += layout->binding[b].array_size;
anv_descriptor_pool_alloc_state(pool);
}
+ list_addtail(&set->pool_link, &pool->desc_sets);
+
*out_set = set;
return VK_SUCCESS;
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);
}
if (result != VK_SUCCESS)
break;
- list_addtail(&set->pool_link, &pool->desc_sets);
-
pDescriptorSets[i] = anv_descriptor_set_to_handle(set);
}
#undef WRITE_PARAM_FIELD
}
+static uint32_t
+anv_surface_state_to_handle(struct anv_state state)
+{
+ /* Bits 31:12 of the bindless surface offset in the extended message
+ * descriptor is bits 25:6 of the byte-based address.
+ */
+ assert(state.offset >= 0);
+ uint32_t offset = state.offset;
+ assert((offset & 0x3f) == 0 && offset < (1 << 26));
+ return offset << 6;
+}
+
void
anv_descriptor_set_write_image_view(struct anv_device *device,
struct anv_descriptor_set *set,
struct anv_image_view *image_view = NULL;
struct anv_sampler *sampler = NULL;
- assert(type == bind_layout->type);
+ /* We get called with just VK_DESCRIPTOR_TYPE_SAMPLER as part of descriptor
+ * set initialization to set the bindless samplers.
+ */
+ assert(type == bind_layout->type ||
+ type == VK_DESCRIPTOR_TYPE_SAMPLER);
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:
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,
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];
+ memset(desc_data, 0, sizeof(desc_data));
+
+ if (image_view) {
+ for (unsigned p = 0; p < image_view->n_planes; p++) {
+ struct anv_surface_state sstate =
+ (desc->layout == VK_IMAGE_LAYOUT_GENERAL) ?
+ image_view->planes[p].general_sampler_surface_state :
+ image_view->planes[p].optimal_sampler_surface_state;
+ desc_data[p].image = anv_surface_state_to_handle(sstate.state);
+ }
+ }
+
+ if (sampler) {
+ for (unsigned p = 0; p < sampler->n_planes; p++)
+ desc_data[p].sampler = sampler->bindless_state.offset + p * 32;
+ }
+
+ /* We may have max_plane_count < 0 if this isn't a sampled image but it
+ * can be no more than the size of our array of handles.
+ */
+ assert(bind_layout->max_plane_count <= ARRAY_SIZE(desc_data));
+ memcpy(desc_map, desc_data,
+ 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);
+ struct anv_storage_image_descriptor desc_data = {
+ .read_write = anv_surface_state_to_handle(
+ image_view->planes[0].storage_surface_state.state),
+ .write_only = anv_surface_state_to_handle(
+ image_view->planes[0].writeonly_storage_surface_state.state),
+ };
+ memcpy(desc_map, &desc_data, sizeof(desc_data));
+ }
if (bind_layout->data & ANV_DESCRIPTOR_IMAGE_PARAM) {
/* Storage images can only ever have one plane */
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
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),
+ };
+ memcpy(desc_map, &desc_data, sizeof(desc_data));
+ }
+
+ if (bind_layout->data & ANV_DESCRIPTOR_STORAGE_IMAGE) {
+ assert(!(bind_layout->data & ANV_DESCRIPTOR_IMAGE_PARAM));
+ struct anv_storage_image_descriptor desc_data = {
+ .read_write = anv_surface_state_to_handle(
+ buffer_view->storage_surface_state),
+ .write_only = anv_surface_state_to_handle(
+ buffer_view->writeonly_storage_surface_state),
+ };
+ memcpy(desc_map, &desc_data, sizeof(desc_data));
+ }
if (bind_layout->data & ANV_DESCRIPTOR_IMAGE_PARAM) {
anv_descriptor_set_write_image_param(desc_map,
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) {
};
}
- 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));
}
}
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,
&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 +
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));
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)
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(
projects / mesa.git / blobdiff