OpenHarmony/third_party_mesa3d
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

anv: add support for direct descriptor in allocation/writes

Browse Source 
Signed-off-by: Lionel Landwerlin <lionel.g.landwerlin@intel.com>
Reviewed-by: Kenneth Graunke <kenneth@whitecape.org>
Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/21645>
This commit is contained in:
Lionel Landwerlin
2023-02-23 21:37:59 +02:00
committed by Marge Bot
parent 64f20cec28
commit 688968e888
3 changed files with 313 additions and 79 deletions
Download Patch File Download Diff File Expand all files Collapse all files

360
src/intel/vulkan/anv_descriptor_set.c
View File

@@ -36,50 +36,72 @@
* Descriptor set layouts.
*/
static unsigned
anv_descriptor_data_alignment(enum anv_descriptor_data data)
{
unsigned alignment = 1;
if (data & (ANV_DESCRIPTOR_INDIRECT_SAMPLED_IMAGE |
ANV_DESCRIPTOR_INDIRECT_STORAGE_IMAGE |
ANV_DESCRIPTOR_INDIRECT_ADDRESS_RANGE))
alignment = MAX2(alignment, 8);
if (data & (ANV_DESCRIPTOR_SURFACE |
ANV_DESCRIPTOR_SURFACE_SAMPLER))
alignment = MAX2(alignment, ANV_SURFACE_STATE_SIZE);
if (data & ANV_DESCRIPTOR_SAMPLER)
alignment = MAX2(alignment, ANV_SAMPLER_STATE_SIZE);
if (data & ANV_DESCRIPTOR_INLINE_UNIFORM)
alignment = MAX2(alignment, ANV_UBO_ALIGNMENT);
return alignment;
}
static enum anv_descriptor_data
anv_descriptor_data_for_type(const struct anv_physical_device *device,
VkDescriptorType type)
anv_indirect_descriptor_data_for_type(VkDescriptorType type)
{
enum anv_descriptor_data data = 0;
switch (type) {
case VK_DESCRIPTOR_TYPE_SAMPLER:
data = ANV_DESCRIPTOR_SAMPLER_STATE |
ANV_DESCRIPTOR_SAMPLED_IMAGE;
data = ANV_DESCRIPTOR_BTI_SAMPLER_STATE |
ANV_DESCRIPTOR_INDIRECT_SAMPLED_IMAGE;
break;
case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
data = ANV_DESCRIPTOR_SURFACE_STATE |
ANV_DESCRIPTOR_SAMPLER_STATE |
ANV_DESCRIPTOR_SAMPLED_IMAGE;
data = ANV_DESCRIPTOR_BTI_SURFACE_STATE |
ANV_DESCRIPTOR_BTI_SAMPLER_STATE |
ANV_DESCRIPTOR_INDIRECT_SAMPLED_IMAGE;
break;
case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:
data = ANV_DESCRIPTOR_SURFACE_STATE |
ANV_DESCRIPTOR_SAMPLED_IMAGE;
data = ANV_DESCRIPTOR_BTI_SURFACE_STATE |
ANV_DESCRIPTOR_INDIRECT_SAMPLED_IMAGE;
break;
case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:
data = ANV_DESCRIPTOR_SURFACE_STATE |
ANV_DESCRIPTOR_SAMPLED_IMAGE;
data = ANV_DESCRIPTOR_BTI_SURFACE_STATE |
ANV_DESCRIPTOR_INDIRECT_SAMPLED_IMAGE;
break;
case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:
case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
data = ANV_DESCRIPTOR_SURFACE_STATE |
ANV_DESCRIPTOR_STORAGE_IMAGE;
data = ANV_DESCRIPTOR_BTI_SURFACE_STATE |
ANV_DESCRIPTOR_INDIRECT_STORAGE_IMAGE;
break;
case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
data = ANV_DESCRIPTOR_SURFACE_STATE |
data = ANV_DESCRIPTOR_BTI_SURFACE_STATE |
ANV_DESCRIPTOR_BUFFER_VIEW;
break;
case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:
data = ANV_DESCRIPTOR_SURFACE_STATE;
data = ANV_DESCRIPTOR_BTI_SURFACE_STATE;
break;
case VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK:
@@ -87,7 +109,7 @@ anv_descriptor_data_for_type(const struct anv_physical_device *device,
break;
case VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR:
data = ANV_DESCRIPTOR_ADDRESS_RANGE;
data = ANV_DESCRIPTOR_INDIRECT_ADDRESS_RANGE;
break;
default:
@@ -101,11 +123,78 @@ anv_descriptor_data_for_type(const struct anv_physical_device *device,
type == VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC ||
type == VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER ||
type == VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC)
data |= ANV_DESCRIPTOR_ADDRESS_RANGE;
data |= ANV_DESCRIPTOR_INDIRECT_ADDRESS_RANGE;
return data;
}
static enum anv_descriptor_data
anv_direct_descriptor_data_for_type(VkDescriptorType type)
{
enum anv_descriptor_data data = 0;
switch (type) {
case VK_DESCRIPTOR_TYPE_SAMPLER:
data = ANV_DESCRIPTOR_BTI_SAMPLER_STATE |
ANV_DESCRIPTOR_SAMPLER;
break;
case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
data = ANV_DESCRIPTOR_BTI_SURFACE_STATE |
ANV_DESCRIPTOR_BTI_SAMPLER_STATE |
ANV_DESCRIPTOR_SURFACE_SAMPLER;
break;
case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:
case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:
data = ANV_DESCRIPTOR_BTI_SURFACE_STATE |
ANV_DESCRIPTOR_SURFACE;
break;
case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:
data = ANV_DESCRIPTOR_BTI_SURFACE_STATE |
ANV_DESCRIPTOR_SURFACE;
break;
case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
data = ANV_DESCRIPTOR_BTI_SURFACE_STATE |
ANV_DESCRIPTOR_SURFACE;
break;
case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:
data = ANV_DESCRIPTOR_BTI_SURFACE_STATE |
ANV_DESCRIPTOR_SURFACE;
break;
case VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK:
data = ANV_DESCRIPTOR_INLINE_UNIFORM;
break;
case VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR:
data = ANV_DESCRIPTOR_INDIRECT_ADDRESS_RANGE;
break;
default:
unreachable("Unsupported descriptor type");
}
return data;
}
static enum anv_descriptor_data
anv_descriptor_data_for_type(const struct anv_physical_device *device,
VkDescriptorType type)
{
if (device->indirect_descriptors)
return anv_indirect_descriptor_data_for_type(type);
else
return anv_direct_descriptor_data_for_type(type);
}
static enum anv_descriptor_data
anv_descriptor_data_for_mutable_type(const struct anv_physical_device *device,
const VkMutableDescriptorTypeCreateInfoEXT *mutable_info,
@@ -144,15 +233,26 @@ anv_descriptor_data_size(enum anv_descriptor_data data)
{
unsigned size = 0;
if (data & ANV_DESCRIPTOR_SAMPLED_IMAGE)
if (data & ANV_DESCRIPTOR_INDIRECT_SAMPLED_IMAGE)
size += sizeof(struct anv_sampled_image_descriptor);
if (data & ANV_DESCRIPTOR_STORAGE_IMAGE)
if (data & ANV_DESCRIPTOR_INDIRECT_STORAGE_IMAGE)
size += sizeof(struct anv_storage_image_descriptor);
if (data & ANV_DESCRIPTOR_ADDRESS_RANGE)
if (data & ANV_DESCRIPTOR_INDIRECT_ADDRESS_RANGE)
size += sizeof(struct anv_address_range_descriptor);
if (data & ANV_DESCRIPTOR_SURFACE)
size += ANV_SURFACE_STATE_SIZE;
if (data & ANV_DESCRIPTOR_SAMPLER)
size += ANV_SAMPLER_STATE_SIZE;
if (data & ANV_DESCRIPTOR_SURFACE_SAMPLER) {
size += ALIGN(ANV_SURFACE_STATE_SIZE + ANV_SAMPLER_STATE_SIZE,
ANV_SURFACE_STATE_SIZE);
}
return size;
}
@@ -232,9 +332,14 @@ anv_descriptor_data_supports_bindless(const struct anv_physical_device *pdevice,
enum anv_descriptor_data data,
bool sampler)
{
return data & (ANV_DESCRIPTOR_ADDRESS_RANGE |
ANV_DESCRIPTOR_SAMPLED_IMAGE |
ANV_DESCRIPTOR_STORAGE_IMAGE);
if (pdevice->indirect_descriptors) {
return data & (ANV_DESCRIPTOR_INDIRECT_ADDRESS_RANGE |
ANV_DESCRIPTOR_INDIRECT_SAMPLED_IMAGE |
ANV_DESCRIPTOR_INDIRECT_STORAGE_IMAGE);
}
/* Directly descriptor support bindless for everything */
return true;
}
bool
@@ -557,13 +662,11 @@ VkResult anv_CreateDescriptorSetLayout(
anv_descriptor_size_for_mutable_type(device->physical, mutable_info, b) :
anv_descriptor_size(&set_layout->binding[b]);
if (binding->descriptorType ==
VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK) {
/* Inline uniform blocks are specified to use the descriptor array
* size as the size in bytes of the block.
*/
descriptor_buffer_size = align(descriptor_buffer_size,
ANV_UBO_ALIGNMENT);
descriptor_buffer_size =
align(descriptor_buffer_size,
anv_descriptor_data_alignment(set_layout->binding[b].data));
if (binding->descriptorType == VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK) {
set_layout->binding[b].descriptor_offset = descriptor_buffer_size;
descriptor_buffer_size += binding->descriptorCount;
} else {
@@ -1017,8 +1120,11 @@ VkResult anv_CreateDescriptorPool(
}
} else {
VkResult result = anv_device_alloc_bo(device,
"indirect descriptors",
device->physical->indirect_descriptors ?
"indirect descriptors" :
"direct descriptors",
descriptor_bo_size,
ANV_BO_ALLOC_CAPTURE |
ANV_BO_ALLOC_MAPPED |
ANV_BO_ALLOC_SNOOPED |
ANV_BO_ALLOC_DESCRIPTOR_POOL,
@@ -1450,6 +1556,26 @@ anv_surface_state_to_handle(struct anv_physical_device *device,
}
}
static const void *
anv_image_view_surface_data_for_plane_layout(struct anv_image_view *image_view,
VkDescriptorType desc_type,
unsigned plane,
VkImageLayout layout)
{
if (desc_type == VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER ||
desc_type == VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE ||
desc_type == VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT) {
return layout == VK_IMAGE_LAYOUT_GENERAL ?
&image_view->planes[plane].general_sampler.state_data :
&image_view->planes[plane].optimal_sampler.state_data;
}
if (desc_type == VK_DESCRIPTOR_TYPE_STORAGE_IMAGE)
return &image_view->planes[plane].storage.state_data;
unreachable("Invalid descriptor type");
}
void
anv_descriptor_set_write_image_view(struct anv_device *device,
struct anv_descriptor_set *set,
@@ -1505,18 +1631,13 @@ anv_descriptor_set_write_image_view(struct anv_device *device,
void *desc_map = set->desc_mem.map + bind_layout->descriptor_offset +
element * bind_layout->descriptor_stride;
memset(desc_map, 0, bind_layout->descriptor_stride);
if (image_view == NULL && sampler == NULL)
return;
enum anv_descriptor_data data =
bind_layout->type == VK_DESCRIPTOR_TYPE_MUTABLE_EXT ?
anv_descriptor_data_for_type(device->physical, type) :
bind_layout->data;
if (data & ANV_DESCRIPTOR_SAMPLED_IMAGE) {
if (data & ANV_DESCRIPTOR_INDIRECT_SAMPLED_IMAGE) {
struct anv_sampled_image_descriptor desc_data[3];
memset(desc_data, 0, sizeof(desc_data));
@@ -1544,18 +1665,87 @@ 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 (data & ANV_DESCRIPTOR_STORAGE_IMAGE) {
assert(image_view->n_planes == 1);
struct anv_storage_image_descriptor desc_data = {
.vanilla = anv_surface_state_to_handle(
device->physical,
image_view->planes[0].storage.state),
};
memcpy(desc_map, &desc_data, sizeof(desc_data));
if (data & ANV_DESCRIPTOR_INDIRECT_STORAGE_IMAGE) {
if (image_view) {
assert(image_view->n_planes == 1);
struct anv_storage_image_descriptor desc_data = {
.vanilla = anv_surface_state_to_handle(
device->physical,
image_view->planes[0].storage.state),
};
memcpy(desc_map, &desc_data, sizeof(desc_data));
} else {
memset(desc_map, 0, bind_layout->descriptor_stride);
}
}
if (data & ANV_DESCRIPTOR_SAMPLER) {
if (sampler) {
for (unsigned p = 0; p < sampler->n_planes; p++) {
memcpy(desc_map + p * ANV_SAMPLER_STATE_SIZE,
sampler->state[p], ANV_SAMPLER_STATE_SIZE);
}
} else {
memset(desc_map, 0, bind_layout->descriptor_stride);
}
}
if (data & ANV_DESCRIPTOR_SURFACE) {
unsigned max_plane_count = image_view ? image_view->n_planes : 1;
for (unsigned p = 0; p < max_plane_count; p++) {
void *plane_map = desc_map + p * ANV_SURFACE_STATE_SIZE;
if (image_view) {
memcpy(plane_map,
anv_image_view_surface_data_for_plane_layout(image_view, type,
p, desc->layout),
ANV_SURFACE_STATE_SIZE);
} else {
memcpy(plane_map, device->null_surface_state.map, ANV_SURFACE_STATE_SIZE);
}
}
}
if (data & ANV_DESCRIPTOR_SURFACE_SAMPLER) {
unsigned max_plane_count =
MAX2(image_view ? image_view->n_planes : 1,
sampler ? sampler->n_planes : 1);
for (unsigned p = 0; p < max_plane_count; p++) {
void *plane_map = desc_map + p * 2 * ANV_SURFACE_STATE_SIZE;
if (image_view) {
memcpy(plane_map,
anv_image_view_surface_data_for_plane_layout(image_view, type,
p, desc->layout),
ANV_SURFACE_STATE_SIZE);
} else {
memcpy(plane_map, device->null_surface_state.map, ANV_SURFACE_STATE_SIZE);
}
if (sampler) {
memcpy(plane_map + ANV_SURFACE_STATE_SIZE,
sampler->state[p], ANV_SAMPLER_STATE_SIZE);
} else {
memset(plane_map + ANV_SURFACE_STATE_SIZE, 0,
ANV_SAMPLER_STATE_SIZE);
}
}
}
}
static const void *
anv_buffer_view_surface_data(struct anv_buffer_view *buffer_view,
VkDescriptorType desc_type)
{
if (desc_type == VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER)
return &buffer_view->general.state_data;
if (desc_type == VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER)
return &buffer_view->storage.state_data;
unreachable("Invalid descriptor type");
}
void
@@ -1592,7 +1782,7 @@ anv_descriptor_set_write_buffer_view(struct anv_device *device,
return;
}
if (data & ANV_DESCRIPTOR_SAMPLED_IMAGE) {
if (data & ANV_DESCRIPTOR_INDIRECT_SAMPLED_IMAGE) {
struct anv_sampled_image_descriptor desc_data = {
.image = anv_surface_state_to_handle(
device->physical, buffer_view->general.state),
@@ -1600,13 +1790,23 @@ anv_descriptor_set_write_buffer_view(struct anv_device *device,
memcpy(desc_map, &desc_data, sizeof(desc_data));
}
if (data & ANV_DESCRIPTOR_STORAGE_IMAGE) {
if (data & ANV_DESCRIPTOR_INDIRECT_STORAGE_IMAGE) {
struct anv_storage_image_descriptor desc_data = {
.vanilla = anv_surface_state_to_handle(
device->physical, buffer_view->storage.state),
};
memcpy(desc_map, &desc_data, sizeof(desc_data));
}
if (data & ANV_DESCRIPTOR_SURFACE) {
if (buffer_view != NULL) {
memcpy(desc_map,
anv_buffer_view_surface_data(buffer_view, type),
ANV_SURFACE_STATE_SIZE);
} else {
memcpy(desc_map, device->null_surface_state.map, ANV_SURFACE_STATE_SIZE);
}
}
}
void
@@ -1658,20 +1858,24 @@ anv_descriptor_set_write_buffer(struct anv_device *device,
.buffer = buffer,
};
enum anv_descriptor_data data =
bind_layout->type == VK_DESCRIPTOR_TYPE_MUTABLE_EXT ?
anv_descriptor_data_for_type(device->physical, type) :
bind_layout->data;
void *desc_map = set->desc_mem.map + bind_layout->descriptor_offset +
element * bind_layout->descriptor_stride;
if (buffer == NULL) {
memset(desc_map, 0, bind_layout->descriptor_stride);
if (data & ANV_DESCRIPTOR_SURFACE)
memcpy(desc_map, device->null_surface_state.map, ANV_SURFACE_STATE_SIZE);
else
memset(desc_map, 0, bind_layout->descriptor_stride);
return;
}
struct anv_address bind_addr = anv_address_add(buffer->address, offset);
uint64_t bind_range = vk_buffer_range(&buffer->vk, offset, range);
enum anv_descriptor_data data =
bind_layout->type == VK_DESCRIPTOR_TYPE_MUTABLE_EXT ?
anv_descriptor_data_for_type(device->physical, type) :
bind_layout->data;
/* We report a bounds checking alignment of 32B for the sake of block
* messages which read an entire register worth at a time.
@@ -1680,7 +1884,7 @@ anv_descriptor_set_write_buffer(struct anv_device *device,
type == VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC)
bind_range = align64(bind_range, ANV_UBO_ALIGNMENT);
if (data & ANV_DESCRIPTOR_ADDRESS_RANGE) {
if (data & ANV_DESCRIPTOR_INDIRECT_ADDRESS_RANGE) {
struct anv_address_range_descriptor desc_data = {
.address = anv_address_physical(bind_addr),
.range = bind_range,
@@ -1688,23 +1892,43 @@ anv_descriptor_set_write_buffer(struct anv_device *device,
memcpy(desc_map, &desc_data, sizeof(desc_data));
}
if (data & ANV_DESCRIPTOR_SURFACE) {
isl_surf_usage_flags_t usage =
desc->type == VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER ?
ISL_SURF_USAGE_CONSTANT_BUFFER_BIT :
ISL_SURF_USAGE_STORAGE_BIT;
enum isl_format format =
anv_isl_format_for_descriptor_type(device, desc->type);
isl_buffer_fill_state(&device->isl_dev, desc_map,
.address = anv_address_physical(bind_addr),
.mocs = isl_mocs(&device->isl_dev, usage,
bind_addr.bo && bind_addr.bo->is_external),
.size_B = desc->range,
.format = format,
.swizzle = ISL_SWIZZLE_IDENTITY,
.stride_B = 1);
}
if (type == VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC ||
type == VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC)
return;
assert(data & ANV_DESCRIPTOR_BUFFER_VIEW);
struct anv_buffer_view *bview =
&set->buffer_views[bind_layout->buffer_view_index + element];
if (data & ANV_DESCRIPTOR_BUFFER_VIEW) {
struct anv_buffer_view *bview =
&set->buffer_views[bind_layout->buffer_view_index + element];
desc->set_buffer_view = bview;
desc->set_buffer_view = bview;
bview->range = bind_range;
bview->address = bind_addr;
bview->range = bind_range;
bview->address = bind_addr;
if (set->is_push)
set->generate_surface_states |= BITFIELD_BIT(descriptor_index);
else
anv_descriptor_write_surface_state(device, desc, bview->general.state);
if (set->is_push)
set->generate_surface_states |= BITFIELD_BIT(descriptor_index);
else
anv_descriptor_write_surface_state(device, desc, bview->general.state);
}
}
void
@@ -1737,7 +1961,7 @@ anv_descriptor_set_write_acceleration_structure(struct anv_device *device,
struct anv_descriptor *desc =
&set->descriptors[bind_layout->descriptor_index + element];
assert(bind_layout->data & ANV_DESCRIPTOR_ADDRESS_RANGE);
assert(bind_layout->data & ANV_DESCRIPTOR_INDIRECT_ADDRESS_RANGE);
*desc = (struct anv_descriptor) {
.type = VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR,
.accel_struct = accel,
@@ -1881,6 +2105,8 @@ void anv_UpdateDescriptorSets(
* - anv_sampled_image_descriptor
* - anv_storage_image_descriptor
* - anv_address_range_descriptor
* - RENDER_SURFACE_STATE
* - SAMPLER_STATE
*/
memcpy(dst->desc_mem.map +
dst_layout->descriptor_offset +

4
src/intel/vulkan/anv_nir_apply_pipeline_layout.c
View File

@@ -1419,7 +1419,7 @@ anv_nir_apply_pipeline_layout(nir_shader *shader,
if (binding->dynamic_offset_index >= 0)
state.has_dynamic_buffers = true;
if (binding->data & ANV_DESCRIPTOR_SURFACE_STATE) {
if (binding->data & ANV_DESCRIPTOR_BTI_SURFACE_STATE) {
if (map->surface_count + array_size > MAX_BINDING_TABLE_SIZE ||
anv_descriptor_requires_bindless(pdevice, binding, false) ||
brw_shader_stage_requires_bindless_resources(shader->info.stage)) {
@@ -1460,7 +1460,7 @@ anv_nir_apply_pipeline_layout(nir_shader *shader,
assert(map->surface_count <= MAX_BINDING_TABLE_SIZE);
}
if (binding->data & ANV_DESCRIPTOR_SAMPLER_STATE) {
if (binding->data & ANV_DESCRIPTOR_BTI_SAMPLER_STATE) {
if (map->sampler_count + array_size > MAX_SAMPLER_TABLE_SIZE ||
anv_descriptor_requires_bindless(pdevice, binding, true) ||
brw_shader_stage_requires_bindless_resources(shader->info.stage)) {

28
src/intel/vulkan/anv_private.h
View File

@@ -218,6 +218,7 @@ struct intel_perf_query_result;
* and we can't put anything else there we use 64b.
*/
#define ANV_SURFACE_STATE_SIZE (64)
#define ANV_SAMPLER_STATE_SIZE (32)
/* For gfx12 we set the streamout buffers using 4 separate commands
* (3DSTATE_SO_BUFFER_INDEX_*) instead of 3DSTATE_SO_BUFFER. However the layout
@@ -1653,19 +1654,25 @@ struct anv_address_range_descriptor {
enum anv_descriptor_data {
/** The descriptor contains a BTI reference to a surface state */
ANV_DESCRIPTOR_SURFACE_STATE = (1 << 0),
ANV_DESCRIPTOR_BTI_SURFACE_STATE = BITFIELD_BIT(0),
/** The descriptor contains a BTI reference to a sampler state */
ANV_DESCRIPTOR_SAMPLER_STATE = (1 << 1),
ANV_DESCRIPTOR_BTI_SAMPLER_STATE = BITFIELD_BIT(1),
/** The descriptor contains an actual buffer view */
ANV_DESCRIPTOR_BUFFER_VIEW = (1 << 2),
ANV_DESCRIPTOR_BUFFER_VIEW = BITFIELD_BIT(2),
/** The descriptor contains inline uniform data */
ANV_DESCRIPTOR_INLINE_UNIFORM = (1 << 3),
ANV_DESCRIPTOR_INLINE_UNIFORM = BITFIELD_BIT(3),
/** anv_address_range_descriptor with a buffer address and range */
ANV_DESCRIPTOR_ADDRESS_RANGE = (1 << 4),
/** Bindless surface handle */
ANV_DESCRIPTOR_SAMPLED_IMAGE = (1 << 5),
/** Storage image handles */
ANV_DESCRIPTOR_STORAGE_IMAGE = (1 << 6),
ANV_DESCRIPTOR_INDIRECT_ADDRESS_RANGE = BITFIELD_BIT(4),
/** Bindless surface handle (through anv_sampled_image_descriptor) */
ANV_DESCRIPTOR_INDIRECT_SAMPLED_IMAGE = BITFIELD_BIT(5),
/** Storage image handles (through anv_storage_image_descriptor) */
ANV_DESCRIPTOR_INDIRECT_STORAGE_IMAGE = BITFIELD_BIT(6),
/** The descriptor contains a single RENDER_SURFACE_STATE */
ANV_DESCRIPTOR_SURFACE = BITFIELD_BIT(7),
/** The descriptor contains a SAMPLER_STATE */
ANV_DESCRIPTOR_SAMPLER = BITFIELD_BIT(8),
/** A tuple of RENDER_SURFACE_STATE & SAMPLER_STATE */
ANV_DESCRIPTOR_SURFACE_SAMPLER = BITFIELD_BIT(9),
};
struct anv_descriptor_set_binding_layout {
@@ -1700,7 +1707,8 @@ struct anv_descriptor_set_binding_layout {
/* Offset into the descriptor buffer where this descriptor lives */
uint32_t descriptor_offset;
/* Pre computed stride */
/* Pre computed stride (with multiplane descriptor, the descriptor includes
* all the planes) */
unsigned descriptor_stride;
/* Immutable samplers (or NULL if no immutable samplers) */