projects / mesa.git / blob
? search:


af8fa40a0a966117dc493e811aaef5d757182ca0
[mesa.git] / src / intel / vulkan / anv_descriptor_set.c
1 /*
2 * Copyright © 2015 Intel Corporation
3 *
4 * Permission is hereby granted, free of charge, to any person obtaining a
5 * copy of this software and associated documentation files (the "Software"),
6 * to deal in the Software without restriction, including without limitation
7 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
8 * and/or sell copies of the Software, and to permit persons to whom the
9 * Software is furnished to do so, subject to the following conditions:
10 *
11 * The above copyright notice and this permission notice (including the next
12 * paragraph) shall be included in all copies or substantial portions of the
13 * Software.
14 *
15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
18 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
20 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
21 * IN THE SOFTWARE.
22 */
23
24 #include <assert.h>
25 #include <stdbool.h>
26 #include <string.h>
27 #include <unistd.h>
28 #include <fcntl.h>
29
30 #include "util/mesa-sha1.h"
31 #include "vk_util.h"
32
33 #include "anv_private.h"
34
35 /*
36 * Descriptor set layouts.
37 */
38
39 static enum anv_descriptor_data
40 anv_descriptor_data_for_type(const struct anv_physical_device *device,
41 VkDescriptorType type)
42 {
43 enum anv_descriptor_data data = 0;
44
45 switch (type) {
46 case VK_DESCRIPTOR_TYPE_SAMPLER:
47 data = ANV_DESCRIPTOR_SAMPLER_STATE;
48 if (device->has_bindless_samplers)
49 data |= ANV_DESCRIPTOR_SAMPLED_IMAGE;
50 break;
51
52 case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
53 data = ANV_DESCRIPTOR_SURFACE_STATE |
54 ANV_DESCRIPTOR_SAMPLER_STATE;
55 if (device->has_bindless_images || device->has_bindless_samplers)
56 data |= ANV_DESCRIPTOR_SAMPLED_IMAGE;
57 break;
58
59 case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
60 case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:
61 data = ANV_DESCRIPTOR_SURFACE_STATE;
62 if (device->has_bindless_images)
63 data |= ANV_DESCRIPTOR_SAMPLED_IMAGE;
64 break;
65
66 case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:
67 data = ANV_DESCRIPTOR_SURFACE_STATE;
68 break;
69
70 case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:
71 case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
72 data = ANV_DESCRIPTOR_SURFACE_STATE;
73 if (device->info.gen < 9)
74 data |= ANV_DESCRIPTOR_IMAGE_PARAM;
75 if (device->has_bindless_images)
76 data |= ANV_DESCRIPTOR_STORAGE_IMAGE;
77 break;
78
79 case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
80 case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
81 data = ANV_DESCRIPTOR_SURFACE_STATE |
82 ANV_DESCRIPTOR_BUFFER_VIEW;
83 break;
84
85 case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
86 case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:
87 data = ANV_DESCRIPTOR_SURFACE_STATE;
88 break;
89
90 case VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT:
91 data = ANV_DESCRIPTOR_INLINE_UNIFORM;
92 break;
93
94 default:
95 unreachable("Unsupported descriptor type");
96 }
97
98 /* On gen8 and above when we have softpin enabled, we also need to push
99 * SSBO address ranges so that we can use A64 messages in the shader.
100 */
101 if (device->has_a64_buffer_access &&
102 (type == VK_DESCRIPTOR_TYPE_STORAGE_BUFFER ||
103 type == VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC))
104 data |= ANV_DESCRIPTOR_ADDRESS_RANGE;
105
106 /* On Ivy Bridge and Bay Trail, we need swizzles textures in the shader
107 * Do not handle VK_DESCRIPTOR_TYPE_STORAGE_IMAGE and
108 * VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT because they already must
109 * have identity swizzle.
110 */
111 if (device->info.gen == 7 && !device->info.is_haswell &&
112 (type == VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE ||
113 type == VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER))
114 data |= ANV_DESCRIPTOR_TEXTURE_SWIZZLE;
115
116 return data;
117 }
118
119 static unsigned
120 anv_descriptor_data_size(enum anv_descriptor_data data)
121 {
122 unsigned size = 0;
123
124 if (data & ANV_DESCRIPTOR_SAMPLED_IMAGE)
125 size += sizeof(struct anv_sampled_image_descriptor);
126
127 if (data & ANV_DESCRIPTOR_STORAGE_IMAGE)
128 size += sizeof(struct anv_storage_image_descriptor);
129
130 if (data & ANV_DESCRIPTOR_IMAGE_PARAM)
131 size += BRW_IMAGE_PARAM_SIZE * 4;
132
133 if (data & ANV_DESCRIPTOR_ADDRESS_RANGE)
134 size += sizeof(struct anv_address_range_descriptor);
135
136 if (data & ANV_DESCRIPTOR_TEXTURE_SWIZZLE)
137 size += sizeof(struct anv_texture_swizzle_descriptor);
138
139 return size;
140 }
141
142 static bool
143 anv_needs_descriptor_buffer(VkDescriptorType desc_type,
144 enum anv_descriptor_data desc_data)
145 {
146 if (desc_type == VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT ||
147 anv_descriptor_data_size(desc_data) > 0)
148 return true;
149 return false;
150 }
151
152 /** Returns the size in bytes of each descriptor with the given layout */
153 unsigned
154 anv_descriptor_size(const struct anv_descriptor_set_binding_layout *layout)
155 {
156 if (layout->data & ANV_DESCRIPTOR_INLINE_UNIFORM) {
157 assert(layout->data == ANV_DESCRIPTOR_INLINE_UNIFORM);
158 return layout->array_size;
159 }
160
161 unsigned size = anv_descriptor_data_size(layout->data);
162
163 /* For multi-planar bindings, we make every descriptor consume the maximum
164 * number of planes so we don't have to bother with walking arrays and
165 * adding things up every time. Fortunately, YCbCr samplers aren't all
166 * that common and likely won't be in the middle of big arrays.
167 */
168 if (layout->max_plane_count > 1)
169 size *= layout->max_plane_count;
170
171 return size;
172 }
173
174 /** Returns the size in bytes of each descriptor of the given type
175 *
176 * This version of the function does not have access to the entire layout so
177 * it may only work on certain descriptor types where the descriptor size is
178 * entirely determined by the descriptor type. Whenever possible, code should
179 * use anv_descriptor_size() instead.
180 */
181 unsigned
182 anv_descriptor_type_size(const struct anv_physical_device *pdevice,
183 VkDescriptorType type)
184 {
185 assert(type != VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT &&
186 type != VK_DESCRIPTOR_TYPE_SAMPLER &&
187 type != VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE &&
188 type != VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER);
189
190 return anv_descriptor_data_size(anv_descriptor_data_for_type(pdevice, type));
191 }
192
193 static bool
194 anv_descriptor_data_supports_bindless(const struct anv_physical_device *pdevice,
195 enum anv_descriptor_data data,
196 bool sampler)
197 {
198 if (data & ANV_DESCRIPTOR_ADDRESS_RANGE) {
199 assert(pdevice->has_a64_buffer_access);
200 return true;
201 }
202
203 if (data & ANV_DESCRIPTOR_SAMPLED_IMAGE) {
204 assert(pdevice->has_bindless_images || pdevice->has_bindless_samplers);
205 return sampler ? pdevice->has_bindless_samplers :
206 pdevice->has_bindless_images;
207 }
208
209 if (data & ANV_DESCRIPTOR_STORAGE_IMAGE) {
210 assert(pdevice->has_bindless_images);
211 return true;
212 }
213
214 return false;
215 }
216
217 bool
218 anv_descriptor_supports_bindless(const struct anv_physical_device *pdevice,
219 const struct anv_descriptor_set_binding_layout *binding,
220 bool sampler)
221 {
222 return anv_descriptor_data_supports_bindless(pdevice, binding->data,
223 sampler);
224 }
225
226 bool
227 anv_descriptor_requires_bindless(const struct anv_physical_device *pdevice,
228 const struct anv_descriptor_set_binding_layout *binding,
229 bool sampler)
230 {
231 if (pdevice->always_use_bindless)
232 return anv_descriptor_supports_bindless(pdevice, binding, sampler);
233
234 static const VkDescriptorBindingFlagBitsEXT flags_requiring_bindless =
235 VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT_EXT |
236 VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT_EXT |
237 VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT_EXT;
238
239 return (binding->flags & flags_requiring_bindless) != 0;
240 }
241
242 void anv_GetDescriptorSetLayoutSupport(
243 VkDevice _device,
244 const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
245 VkDescriptorSetLayoutSupport* pSupport)
246 {
247 ANV_FROM_HANDLE(anv_device, device, _device);
248 const struct anv_physical_device *pdevice =
249 &device->instance->physicalDevice;
250
251 uint32_t surface_count[MESA_SHADER_STAGES] = { 0, };
252 bool needs_descriptor_buffer = false;
253
254 for (uint32_t b = 0; b < pCreateInfo->bindingCount; b++) {
255 const VkDescriptorSetLayoutBinding *binding = &pCreateInfo->pBindings[b];
256
257 enum anv_descriptor_data desc_data =
258 anv_descriptor_data_for_type(pdevice, binding->descriptorType);
259
260 if (anv_needs_descriptor_buffer(binding->descriptorType, desc_data))
261 needs_descriptor_buffer = true;
262
263 switch (binding->descriptorType) {
264 case VK_DESCRIPTOR_TYPE_SAMPLER:
265 /* There is no real limit on samplers */
266 break;
267
268 case VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT:
269 /* Inline uniforms don't use a binding */
270 break;
271
272 case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
273 if (anv_descriptor_data_supports_bindless(pdevice, desc_data, false))
274 break;
275
276 if (binding->pImmutableSamplers) {
277 for (uint32_t i = 0; i < binding->descriptorCount; i++) {
278 ANV_FROM_HANDLE(anv_sampler, sampler,
279 binding->pImmutableSamplers[i]);
280 anv_foreach_stage(s, binding->stageFlags)
281 surface_count[s] += sampler->n_planes;
282 }
283 } else {
284 anv_foreach_stage(s, binding->stageFlags)
285 surface_count[s] += binding->descriptorCount;
286 }
287 break;
288
289 default:
290 if (anv_descriptor_data_supports_bindless(pdevice, desc_data, false))
291 break;
292
293 anv_foreach_stage(s, binding->stageFlags)
294 surface_count[s] += binding->descriptorCount;
295 break;
296 }
297 }
298
299 for (unsigned s = 0; s < MESA_SHADER_STAGES; s++) {
300 if (needs_descriptor_buffer)
301 surface_count[s] += 1;
302 }
303
304 bool supported = true;
305 for (unsigned s = 0; s < MESA_SHADER_STAGES; s++) {
306 /* Our maximum binding table size is 240 and we need to reserve 8 for
307 * render targets.
308 */
309 if (surface_count[s] > MAX_BINDING_TABLE_SIZE - MAX_RTS)
310 supported = false;
311 }
312
313 pSupport->supported = supported;
314 }
315
316 VkResult anv_CreateDescriptorSetLayout(
317 VkDevice _device,
318 const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
319 const VkAllocationCallbacks* pAllocator,
320 VkDescriptorSetLayout* pSetLayout)
321 {
322 ANV_FROM_HANDLE(anv_device, device, _device);
323
324 assert(pCreateInfo->sType == VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO);
325
326 uint32_t max_binding = 0;
327 uint32_t immutable_sampler_count = 0;
328 for (uint32_t j = 0; j < pCreateInfo->bindingCount; j++) {
329 max_binding = MAX2(max_binding, pCreateInfo->pBindings[j].binding);
330
331 /* From the Vulkan 1.1.97 spec for VkDescriptorSetLayoutBinding:
332 *
333 * "If descriptorType specifies a VK_DESCRIPTOR_TYPE_SAMPLER or
334 * VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER type descriptor, then
335 * pImmutableSamplers can be used to initialize a set of immutable
336 * samplers. [...] If descriptorType is not one of these descriptor
337 * types, then pImmutableSamplers is ignored.
338 *
339 * We need to be careful here and only parse pImmutableSamplers if we
340 * have one of the right descriptor types.
341 */
342 VkDescriptorType desc_type = pCreateInfo->pBindings[j].descriptorType;
343 if ((desc_type == VK_DESCRIPTOR_TYPE_SAMPLER ||
344 desc_type == VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER) &&
345 pCreateInfo->pBindings[j].pImmutableSamplers)
346 immutable_sampler_count += pCreateInfo->pBindings[j].descriptorCount;
347 }
348
349 struct anv_descriptor_set_layout *set_layout;
350 struct anv_descriptor_set_binding_layout *bindings;
351 struct anv_sampler **samplers;
352
353 /* We need to allocate decriptor set layouts off the device allocator
354 * with DEVICE scope because they are reference counted and may not be
355 * destroyed when vkDestroyDescriptorSetLayout is called.
356 */
357 ANV_MULTIALLOC(ma);
358 anv_multialloc_add(&ma, &set_layout, 1);
359 anv_multialloc_add(&ma, &bindings, max_binding + 1);
360 anv_multialloc_add(&ma, &samplers, immutable_sampler_count);
361
362 if (!anv_multialloc_alloc(&ma, &device->alloc,
363 VK_SYSTEM_ALLOCATION_SCOPE_DEVICE))
364 return vk_error(VK_ERROR_OUT_OF_HOST_MEMORY);
365
366 memset(set_layout, 0, sizeof(*set_layout));
367 set_layout->ref_cnt = 1;
368 set_layout->binding_count = max_binding + 1;
369
370 for (uint32_t b = 0; b <= max_binding; b++) {
371 /* Initialize all binding_layout entries to -1 */
372 memset(&set_layout->binding[b], -1, sizeof(set_layout->binding[b]));
373
374 set_layout->binding[b].flags = 0;
375 set_layout->binding[b].data = 0;
376 set_layout->binding[b].max_plane_count = 0;
377 set_layout->binding[b].array_size = 0;
378 set_layout->binding[b].immutable_samplers = NULL;
379 }
380
381 /* Initialize all samplers to 0 */
382 memset(samplers, 0, immutable_sampler_count * sizeof(*samplers));
383
384 uint32_t buffer_view_count = 0;
385 uint32_t dynamic_offset_count = 0;
386 uint32_t descriptor_buffer_size = 0;
387
388 for (uint32_t j = 0; j < pCreateInfo->bindingCount; j++) {
389 const VkDescriptorSetLayoutBinding *binding = &pCreateInfo->pBindings[j];
390 uint32_t b = binding->binding;
391 /* We temporarily store pCreateInfo->pBindings[] index (plus one) in the
392 * immutable_samplers pointer. This provides us with a quick-and-dirty
393 * way to sort the bindings by binding number.
394 */
395 set_layout->binding[b].immutable_samplers = (void *)(uintptr_t)(j + 1);
396 }
397
398 const VkDescriptorSetLayoutBindingFlagsCreateInfoEXT *binding_flags_info =
399 vk_find_struct_const(pCreateInfo->pNext,
400 DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO_EXT);
401
402 for (uint32_t b = 0; b <= max_binding; b++) {
403 /* We stashed the pCreateInfo->pBindings[] index (plus one) in the
404 * immutable_samplers pointer. Check for NULL (empty binding) and then
405 * reset it and compute the index.
406 */
407 if (set_layout->binding[b].immutable_samplers == NULL)
408 continue;
409 const uint32_t info_idx =
410 (uintptr_t)(void *)set_layout->binding[b].immutable_samplers - 1;
411 set_layout->binding[b].immutable_samplers = NULL;
412
413 const VkDescriptorSetLayoutBinding *binding =
414 &pCreateInfo->pBindings[info_idx];
415
416 if (binding->descriptorCount == 0)
417 continue;
418
419 #ifndef NDEBUG
420 set_layout->binding[b].type = binding->descriptorType;
421 #endif
422
423 if (binding_flags_info && binding_flags_info->bindingCount > 0) {
424 assert(binding_flags_info->bindingCount == pCreateInfo->bindingCount);
425 set_layout->binding[b].flags =
426 binding_flags_info->pBindingFlags[info_idx];
427 }
428
429 set_layout->binding[b].data =
430 anv_descriptor_data_for_type(&device->instance->physicalDevice,
431 binding->descriptorType);
432 set_layout->binding[b].array_size = binding->descriptorCount;
433 set_layout->binding[b].descriptor_index = set_layout->size;
434 set_layout->size += binding->descriptorCount;
435
436 if (set_layout->binding[b].data & ANV_DESCRIPTOR_BUFFER_VIEW) {
437 set_layout->binding[b].buffer_view_index = buffer_view_count;
438 buffer_view_count += binding->descriptorCount;
439 }
440
441 switch (binding->descriptorType) {
442 case VK_DESCRIPTOR_TYPE_SAMPLER:
443 case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
444 set_layout->binding[b].max_plane_count = 1;
445 if (binding->pImmutableSamplers) {
446 set_layout->binding[b].immutable_samplers = samplers;
447 samplers += binding->descriptorCount;
448
449 for (uint32_t i = 0; i < binding->descriptorCount; i++) {
450 ANV_FROM_HANDLE(anv_sampler, sampler,
451 binding->pImmutableSamplers[i]);
452
453 set_layout->binding[b].immutable_samplers[i] = sampler;
454 if (set_layout->binding[b].max_plane_count < sampler->n_planes)
455 set_layout->binding[b].max_plane_count = sampler->n_planes;
456 }
457 }
458 break;
459
460 case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
461 set_layout->binding[b].max_plane_count = 1;
462 break;
463
464 default:
465 break;
466 }
467
468 switch (binding->descriptorType) {
469 case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
470 case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:
471 set_layout->binding[b].dynamic_offset_index = dynamic_offset_count;
472 anv_foreach_stage(s, binding->stageFlags) {
473 STATIC_ASSERT(MAX_DYNAMIC_BUFFERS <=
474 sizeof(set_layout->stage_dynamic_offsets[s]) * 8);
475 set_layout->stage_dynamic_offsets[s] |=
476 BITFIELD_RANGE(set_layout->binding[b].dynamic_offset_index,
477 binding->descriptorCount);
478 }
479 dynamic_offset_count += binding->descriptorCount;
480 assert(dynamic_offset_count < MAX_DYNAMIC_BUFFERS);
481 break;
482
483 default:
484 break;
485 }
486
487 if (binding->descriptorType ==
488 VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT) {
489 /* Inline uniform blocks are specified to use the descriptor array
490 * size as the size in bytes of the block.
491 */
492 descriptor_buffer_size = align_u32(descriptor_buffer_size, 32);
493 set_layout->binding[b].descriptor_offset = descriptor_buffer_size;
494 descriptor_buffer_size += binding->descriptorCount;
495 } else {
496 set_layout->binding[b].descriptor_offset = descriptor_buffer_size;
497 descriptor_buffer_size += anv_descriptor_size(&set_layout->binding[b]) *
498 binding->descriptorCount;
499 }
500
501 set_layout->shader_stages |= binding->stageFlags;
502 }
503
504 set_layout->buffer_view_count = buffer_view_count;
505 set_layout->dynamic_offset_count = dynamic_offset_count;
506 set_layout->descriptor_buffer_size = descriptor_buffer_size;
507
508 *pSetLayout = anv_descriptor_set_layout_to_handle(set_layout);
509
510 return VK_SUCCESS;
511 }
512
513 void anv_DestroyDescriptorSetLayout(
514 VkDevice _device,
515 VkDescriptorSetLayout _set_layout,
516 const VkAllocationCallbacks* pAllocator)
517 {
518 ANV_FROM_HANDLE(anv_device, device, _device);
519 ANV_FROM_HANDLE(anv_descriptor_set_layout, set_layout, _set_layout);
520
521 if (!set_layout)
522 return;
523
524 anv_descriptor_set_layout_unref(device, set_layout);
525 }
526
527 #define SHA1_UPDATE_VALUE(ctx, x) _mesa_sha1_update(ctx, &(x), sizeof(x));
528
529 static void
530 sha1_update_immutable_sampler(struct mesa_sha1 *ctx,
531 const struct anv_sampler *sampler)
532 {
533 if (!sampler->conversion)
534 return;
535
536 /* The only thing that affects the shader is ycbcr conversion */
537 _mesa_sha1_update(ctx, sampler->conversion,
538 sizeof(*sampler->conversion));
539 }
540
541 static void
542 sha1_update_descriptor_set_binding_layout(struct mesa_sha1 *ctx,
543 const struct anv_descriptor_set_binding_layout *layout)
544 {
545 SHA1_UPDATE_VALUE(ctx, layout->flags);
546 SHA1_UPDATE_VALUE(ctx, layout->data);
547 SHA1_UPDATE_VALUE(ctx, layout->max_plane_count);
548 SHA1_UPDATE_VALUE(ctx, layout->array_size);
549 SHA1_UPDATE_VALUE(ctx, layout->descriptor_index);
550 SHA1_UPDATE_VALUE(ctx, layout->dynamic_offset_index);
551 SHA1_UPDATE_VALUE(ctx, layout->buffer_view_index);
552 SHA1_UPDATE_VALUE(ctx, layout->descriptor_offset);
553
554 if (layout->immutable_samplers) {
555 for (uint16_t i = 0; i < layout->array_size; i++)
556 sha1_update_immutable_sampler(ctx, layout->immutable_samplers[i]);
557 }
558 }
559
560 static void
561 sha1_update_descriptor_set_layout(struct mesa_sha1 *ctx,
562 const struct anv_descriptor_set_layout *layout)
563 {
564 SHA1_UPDATE_VALUE(ctx, layout->binding_count);
565 SHA1_UPDATE_VALUE(ctx, layout->size);
566 SHA1_UPDATE_VALUE(ctx, layout->shader_stages);
567 SHA1_UPDATE_VALUE(ctx, layout->buffer_view_count);
568 SHA1_UPDATE_VALUE(ctx, layout->dynamic_offset_count);
569 SHA1_UPDATE_VALUE(ctx, layout->descriptor_buffer_size);
570
571 for (uint16_t i = 0; i < layout->binding_count; i++)
572 sha1_update_descriptor_set_binding_layout(ctx, &layout->binding[i]);
573 }
574
575 /*
576 * Pipeline layouts. These have nothing to do with the pipeline. They are
577 * just multiple descriptor set layouts pasted together
578 */
579
580 VkResult anv_CreatePipelineLayout(
581 VkDevice _device,
582 const VkPipelineLayoutCreateInfo* pCreateInfo,
583 const VkAllocationCallbacks* pAllocator,
584 VkPipelineLayout* pPipelineLayout)
585 {
586 ANV_FROM_HANDLE(anv_device, device, _device);
587 struct anv_pipeline_layout *layout;
588
589 assert(pCreateInfo->sType == VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO);
590
591 layout = vk_alloc2(&device->alloc, pAllocator, sizeof(*layout), 8,
592 VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
593 if (layout == NULL)
594 return vk_error(VK_ERROR_OUT_OF_HOST_MEMORY);
595
596 layout->num_sets = pCreateInfo->setLayoutCount;
597
598 unsigned dynamic_offset_count = 0;
599
600 for (uint32_t set = 0; set < pCreateInfo->setLayoutCount; set++) {
601 ANV_FROM_HANDLE(anv_descriptor_set_layout, set_layout,
602 pCreateInfo->pSetLayouts[set]);
603 layout->set[set].layout = set_layout;
604 anv_descriptor_set_layout_ref(set_layout);
605
606 layout->set[set].dynamic_offset_start = dynamic_offset_count;
607 for (uint32_t b = 0; b < set_layout->binding_count; b++) {
608 if (set_layout->binding[b].dynamic_offset_index < 0)
609 continue;
610
611 dynamic_offset_count += set_layout->binding[b].array_size;
612 }
613 }
614 assert(dynamic_offset_count < MAX_DYNAMIC_BUFFERS);
615
616 struct mesa_sha1 ctx;
617 _mesa_sha1_init(&ctx);
618 for (unsigned s = 0; s < layout->num_sets; s++) {
619 sha1_update_descriptor_set_layout(&ctx, layout->set[s].layout);
620 _mesa_sha1_update(&ctx, &layout->set[s].dynamic_offset_start,
621 sizeof(layout->set[s].dynamic_offset_start));
622 }
623 _mesa_sha1_update(&ctx, &layout->num_sets, sizeof(layout->num_sets));
624 _mesa_sha1_final(&ctx, layout->sha1);
625
626 *pPipelineLayout = anv_pipeline_layout_to_handle(layout);
627
628 return VK_SUCCESS;
629 }
630
631 void anv_DestroyPipelineLayout(
632 VkDevice _device,
633 VkPipelineLayout _pipelineLayout,
634 const VkAllocationCallbacks* pAllocator)
635 {
636 ANV_FROM_HANDLE(anv_device, device, _device);
637 ANV_FROM_HANDLE(anv_pipeline_layout, pipeline_layout, _pipelineLayout);
638
639 if (!pipeline_layout)
640 return;
641
642 for (uint32_t i = 0; i < pipeline_layout->num_sets; i++)
643 anv_descriptor_set_layout_unref(device, pipeline_layout->set[i].layout);
644
645 vk_free2(&device->alloc, pAllocator, pipeline_layout);
646 }
647
648 /*
649 * Descriptor pools.
650 *
651 * These are implemented using a big pool of memory and a free-list for the
652 * host memory allocations and a state_stream and a free list for the buffer
653 * view surface state. The spec allows us to fail to allocate due to
654 * fragmentation in all cases but two: 1) after pool reset, allocating up
655 * until the pool size with no freeing must succeed and 2) allocating and
656 * freeing only descriptor sets with the same layout. Case 1) is easy enogh,
657 * and the free lists lets us recycle blocks for case 2).
658 */
659
660 /* The vma heap reserves 0 to mean NULL; we have to offset by some ammount to
661 * ensure we can allocate the entire BO without hitting zero. The actual
662 * amount doesn't matter.
663 */
664 #define POOL_HEAP_OFFSET 64
665
666 #define EMPTY 1
667
668 VkResult anv_CreateDescriptorPool(
669 VkDevice _device,
670 const VkDescriptorPoolCreateInfo* pCreateInfo,
671 const VkAllocationCallbacks* pAllocator,
672 VkDescriptorPool* pDescriptorPool)
673 {
674 ANV_FROM_HANDLE(anv_device, device, _device);
675 struct anv_descriptor_pool *pool;
676
677 const VkDescriptorPoolInlineUniformBlockCreateInfoEXT *inline_info =
678 vk_find_struct_const(pCreateInfo->pNext,
679 DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO_EXT);
680
681 uint32_t descriptor_count = 0;
682 uint32_t buffer_view_count = 0;
683 uint32_t descriptor_bo_size = 0;
684 for (uint32_t i = 0; i < pCreateInfo->poolSizeCount; i++) {
685 enum anv_descriptor_data desc_data =
686 anv_descriptor_data_for_type(&device->instance->physicalDevice,
687 pCreateInfo->pPoolSizes[i].type);
688
689 if (desc_data & ANV_DESCRIPTOR_BUFFER_VIEW)
690 buffer_view_count += pCreateInfo->pPoolSizes[i].descriptorCount;
691
692 unsigned desc_data_size = anv_descriptor_data_size(desc_data) *
693 pCreateInfo->pPoolSizes[i].descriptorCount;
694
695 /* Combined image sampler descriptors can take up to 3 slots if they
696 * hold a YCbCr image.
697 */
698 if (pCreateInfo->pPoolSizes[i].type ==
699 VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER)
700 desc_data_size *= 3;
701
702 if (pCreateInfo->pPoolSizes[i].type ==
703 VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT) {
704 /* Inline uniform blocks are specified to use the descriptor array
705 * size as the size in bytes of the block.
706 */
707 assert(inline_info);
708 desc_data_size += pCreateInfo->pPoolSizes[i].descriptorCount;
709 }
710
711 descriptor_bo_size += desc_data_size;
712
713 descriptor_count += pCreateInfo->pPoolSizes[i].descriptorCount;
714 }
715 /* We have to align descriptor buffer allocations to 32B so that we can
716 * push descriptor buffers. This means that each descriptor buffer
717 * allocated may burn up to 32B of extra space to get the right alignment.
718 * (Technically, it's at most 28B because we're always going to start at
719 * least 4B aligned but we're being conservative here.) Allocate enough
720 * extra space that we can chop it into maxSets pieces and align each one
721 * of them to 32B.
722 */
723 descriptor_bo_size += 32 * pCreateInfo->maxSets;
724 /* We align inline uniform blocks to 32B */
725 if (inline_info)
726 descriptor_bo_size += 32 * inline_info->maxInlineUniformBlockBindings;
727 descriptor_bo_size = ALIGN(descriptor_bo_size, 4096);
728
729 const size_t pool_size =
730 pCreateInfo->maxSets * sizeof(struct anv_descriptor_set) +
731 descriptor_count * sizeof(struct anv_descriptor) +
732 buffer_view_count * sizeof(struct anv_buffer_view);
733 const size_t total_size = sizeof(*pool) + pool_size;
734
735 pool = vk_alloc2(&device->alloc, pAllocator, total_size, 8,
736 VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
737 if (!pool)
738 return vk_error(VK_ERROR_OUT_OF_HOST_MEMORY);
739
740 pool->size = pool_size;
741 pool->next = 0;
742 pool->free_list = EMPTY;
743
744 if (descriptor_bo_size > 0) {
745 VkResult result = anv_device_alloc_bo(device,
746 descriptor_bo_size,
747 ANV_BO_ALLOC_MAPPED |
748 ANV_BO_ALLOC_SNOOPED,
749 &pool->bo);
750 if (result != VK_SUCCESS) {
751 vk_free2(&device->alloc, pAllocator, pool);
752 return result;
753 }
754
755 util_vma_heap_init(&pool->bo_heap, POOL_HEAP_OFFSET, descriptor_bo_size);
756 } else {
757 pool->bo = NULL;
758 }
759
760 anv_state_stream_init(&pool->surface_state_stream,
761 &device->surface_state_pool, 4096);
762 pool->surface_state_free_list = NULL;
763
764 list_inithead(&pool->desc_sets);
765
766 *pDescriptorPool = anv_descriptor_pool_to_handle(pool);
767
768 return VK_SUCCESS;
769 }
770
771 void anv_DestroyDescriptorPool(
772 VkDevice _device,
773 VkDescriptorPool _pool,
774 const VkAllocationCallbacks* pAllocator)
775 {
776 ANV_FROM_HANDLE(anv_device, device, _device);
777 ANV_FROM_HANDLE(anv_descriptor_pool, pool, _pool);
778
779 if (!pool)
780 return;
781
782 list_for_each_entry_safe(struct anv_descriptor_set, set,
783 &pool->desc_sets, pool_link) {
784 anv_descriptor_set_layout_unref(device, set->layout);
785 }
786
787 if (pool->bo)
788 anv_device_release_bo(device, pool->bo);
789 anv_state_stream_finish(&pool->surface_state_stream);
790
791 vk_free2(&device->alloc, pAllocator, pool);
792 }
793
794 VkResult anv_ResetDescriptorPool(
795 VkDevice _device,
796 VkDescriptorPool descriptorPool,
797 VkDescriptorPoolResetFlags flags)
798 {
799 ANV_FROM_HANDLE(anv_device, device, _device);
800 ANV_FROM_HANDLE(anv_descriptor_pool, pool, descriptorPool);
801
802 list_for_each_entry_safe(struct anv_descriptor_set, set,
803 &pool->desc_sets, pool_link) {
804 anv_descriptor_set_layout_unref(device, set->layout);
805 }
806 list_inithead(&pool->desc_sets);
807
808 pool->next = 0;
809 pool->free_list = EMPTY;
810
811 if (pool->bo) {
812 util_vma_heap_finish(&pool->bo_heap);
813 util_vma_heap_init(&pool->bo_heap, POOL_HEAP_OFFSET, pool->bo->size);
814 }
815
816 anv_state_stream_finish(&pool->surface_state_stream);
817 anv_state_stream_init(&pool->surface_state_stream,
818 &device->surface_state_pool, 4096);
819 pool->surface_state_free_list = NULL;
820
821 return VK_SUCCESS;
822 }
823
824 struct pool_free_list_entry {
825 uint32_t next;
826 uint32_t size;
827 };
828
829 static VkResult
830 anv_descriptor_pool_alloc_set(struct anv_descriptor_pool *pool,
831 uint32_t size,
832 struct anv_descriptor_set **set)
833 {
834 if (size <= pool->size - pool->next) {
835 *set = (struct anv_descriptor_set *) (pool->data + pool->next);
836 pool->next += size;
837 return VK_SUCCESS;
838 } else {
839 struct pool_free_list_entry *entry;
840 uint32_t *link = &pool->free_list;
841 for (uint32_t f = pool->free_list; f != EMPTY; f = entry->next) {
842 entry = (struct pool_free_list_entry *) (pool->data + f);
843 if (size <= entry->size) {
844 *link = entry->next;
845 *set = (struct anv_descriptor_set *) entry;
846 return VK_SUCCESS;
847 }
848 link = &entry->next;
849 }
850
851 if (pool->free_list != EMPTY) {
852 return vk_error(VK_ERROR_FRAGMENTED_POOL);
853 } else {
854 return vk_error(VK_ERROR_OUT_OF_POOL_MEMORY);
855 }
856 }
857 }
858
859 static void
860 anv_descriptor_pool_free_set(struct anv_descriptor_pool *pool,
861 struct anv_descriptor_set *set)
862 {
863 /* Put the descriptor set allocation back on the free list. */
864 const uint32_t index = (char *) set - pool->data;
865 if (index + set->size == pool->next) {
866 pool->next = index;
867 } else {
868 struct pool_free_list_entry *entry = (struct pool_free_list_entry *) set;
869 entry->next = pool->free_list;
870 entry->size = set->size;
871 pool->free_list = (char *) entry - pool->data;
872 }
873 }
874
875 struct surface_state_free_list_entry {
876 void *next;
877 struct anv_state state;
878 };
879
880 static struct anv_state
881 anv_descriptor_pool_alloc_state(struct anv_descriptor_pool *pool)
882 {
883 struct surface_state_free_list_entry *entry =
884 pool->surface_state_free_list;
885
886 if (entry) {
887 struct anv_state state = entry->state;
888 pool->surface_state_free_list = entry->next;
889 assert(state.alloc_size == 64);
890 return state;
891 } else {
892 return anv_state_stream_alloc(&pool->surface_state_stream, 64, 64);
893 }
894 }
895
896 static void
897 anv_descriptor_pool_free_state(struct anv_descriptor_pool *pool,
898 struct anv_state state)
899 {
900 /* Put the buffer view surface state back on the free list. */
901 struct surface_state_free_list_entry *entry = state.map;
902 entry->next = pool->surface_state_free_list;
903 entry->state = state;
904 pool->surface_state_free_list = entry;
905 }
906
907 size_t
908 anv_descriptor_set_layout_size(const struct anv_descriptor_set_layout *layout)
909 {
910 return
911 sizeof(struct anv_descriptor_set) +
912 layout->size * sizeof(struct anv_descriptor) +
913 layout->buffer_view_count * sizeof(struct anv_buffer_view);
914 }
915
916 VkResult
917 anv_descriptor_set_create(struct anv_device *device,
918 struct anv_descriptor_pool *pool,
919 struct anv_descriptor_set_layout *layout,
920 struct anv_descriptor_set **out_set)
921 {
922 struct anv_descriptor_set *set;
923 const size_t size = anv_descriptor_set_layout_size(layout);
924
925 VkResult result = anv_descriptor_pool_alloc_set(pool, size, &set);
926 if (result != VK_SUCCESS)
927 return result;
928
929 if (layout->descriptor_buffer_size) {
930 /* Align the size to 32 so that alignment gaps don't cause extra holes
931 * in the heap which can lead to bad performance.
932 */
933 uint32_t set_buffer_size = ALIGN(layout->descriptor_buffer_size, 32);
934 uint64_t pool_vma_offset =
935 util_vma_heap_alloc(&pool->bo_heap, set_buffer_size, 32);
936 if (pool_vma_offset == 0) {
937 anv_descriptor_pool_free_set(pool, set);
938 return vk_error(VK_ERROR_FRAGMENTED_POOL);
939 }
940 assert(pool_vma_offset >= POOL_HEAP_OFFSET &&
941 pool_vma_offset - POOL_HEAP_OFFSET <= INT32_MAX);
942 set->desc_mem.offset = pool_vma_offset - POOL_HEAP_OFFSET;
943 set->desc_mem.alloc_size = set_buffer_size;
944 set->desc_mem.map = pool->bo->map + set->desc_mem.offset;
945
946 set->desc_surface_state = anv_descriptor_pool_alloc_state(pool);
947 anv_fill_buffer_surface_state(device, set->desc_surface_state,
948 ISL_FORMAT_R32G32B32A32_FLOAT,
949 (struct anv_address) {
950 .bo = pool->bo,
951 .offset = set->desc_mem.offset,
952 },
953 layout->descriptor_buffer_size, 1);
954 } else {
955 set->desc_mem = ANV_STATE_NULL;
956 set->desc_surface_state = ANV_STATE_NULL;
957 }
958
959 set->pool = pool;
960 set->layout = layout;
961 anv_descriptor_set_layout_ref(layout);
962
963 set->size = size;
964 set->buffer_views =
965 (struct anv_buffer_view *) &set->descriptors[layout->size];
966 set->buffer_view_count = layout->buffer_view_count;
967
968 /* By defining the descriptors to be zero now, we can later verify that
969 * a descriptor has not been populated with user data.
970 */
971 memset(set->descriptors, 0, sizeof(struct anv_descriptor) * layout->size);
972
973 /* Go through and fill out immutable samplers if we have any */
974 struct anv_descriptor *desc = set->descriptors;
975 for (uint32_t b = 0; b < layout->binding_count; b++) {
976 if (layout->binding[b].immutable_samplers) {
977 for (uint32_t i = 0; i < layout->binding[b].array_size; i++) {
978 /* The type will get changed to COMBINED_IMAGE_SAMPLER in
979 * UpdateDescriptorSets if needed. However, if the descriptor
980 * set has an immutable sampler, UpdateDescriptorSets may never
981 * touch it, so we need to make sure it's 100% valid now.
982 *
983 * We don't need to actually provide a sampler because the helper
984 * will always write in the immutable sampler regardless of what
985 * is in the sampler parameter.
986 */
987 struct VkDescriptorImageInfo info = { };
988 anv_descriptor_set_write_image_view(device, set, &info,
989 VK_DESCRIPTOR_TYPE_SAMPLER,
990 b, i);
991 }
992 }
993 desc += layout->binding[b].array_size;
994 }
995
996 /* Allocate surface state for the buffer views. */
997 for (uint32_t b = 0; b < layout->buffer_view_count; b++) {
998 set->buffer_views[b].surface_state =
999 anv_descriptor_pool_alloc_state(pool);
1000 }
1001
1002 list_addtail(&set->pool_link, &pool->desc_sets);
1003
1004 *out_set = set;
1005
1006 return VK_SUCCESS;
1007 }
1008
1009 void
1010 anv_descriptor_set_destroy(struct anv_device *device,
1011 struct anv_descriptor_pool *pool,
1012 struct anv_descriptor_set *set)
1013 {
1014 anv_descriptor_set_layout_unref(device, set->layout);
1015
1016 if (set->desc_mem.alloc_size) {
1017 util_vma_heap_free(&pool->bo_heap,
1018 (uint64_t)set->desc_mem.offset + POOL_HEAP_OFFSET,
1019 set->desc_mem.alloc_size);
1020 anv_descriptor_pool_free_state(pool, set->desc_surface_state);
1021 }
1022
1023 for (uint32_t b = 0; b < set->buffer_view_count; b++)
1024 anv_descriptor_pool_free_state(pool, set->buffer_views[b].surface_state);
1025
1026 list_del(&set->pool_link);
1027
1028 anv_descriptor_pool_free_set(pool, set);
1029 }
1030
1031 VkResult anv_AllocateDescriptorSets(
1032 VkDevice _device,
1033 const VkDescriptorSetAllocateInfo* pAllocateInfo,
1034 VkDescriptorSet* pDescriptorSets)
1035 {
1036 ANV_FROM_HANDLE(anv_device, device, _device);
1037 ANV_FROM_HANDLE(anv_descriptor_pool, pool, pAllocateInfo->descriptorPool);
1038
1039 VkResult result = VK_SUCCESS;
1040 struct anv_descriptor_set *set;
1041 uint32_t i;
1042
1043 for (i = 0; i < pAllocateInfo->descriptorSetCount; i++) {
1044 ANV_FROM_HANDLE(anv_descriptor_set_layout, layout,
1045 pAllocateInfo->pSetLayouts[i]);
1046
1047 result = anv_descriptor_set_create(device, pool, layout, &set);
1048 if (result != VK_SUCCESS)
1049 break;
1050
1051 pDescriptorSets[i] = anv_descriptor_set_to_handle(set);
1052 }
1053
1054 if (result != VK_SUCCESS)
1055 anv_FreeDescriptorSets(_device, pAllocateInfo->descriptorPool,
1056 i, pDescriptorSets);
1057
1058 return result;
1059 }
1060
1061 VkResult anv_FreeDescriptorSets(
1062 VkDevice _device,
1063 VkDescriptorPool descriptorPool,
1064 uint32_t count,
1065 const VkDescriptorSet* pDescriptorSets)
1066 {
1067 ANV_FROM_HANDLE(anv_device, device, _device);
1068 ANV_FROM_HANDLE(anv_descriptor_pool, pool, descriptorPool);
1069
1070 for (uint32_t i = 0; i < count; i++) {
1071 ANV_FROM_HANDLE(anv_descriptor_set, set, pDescriptorSets[i]);
1072
1073 if (!set)
1074 continue;
1075
1076 anv_descriptor_set_destroy(device, pool, set);
1077 }
1078
1079 return VK_SUCCESS;
1080 }
1081
1082 static void
1083 anv_descriptor_set_write_image_param(uint32_t *param_desc_map,
1084 const struct brw_image_param *param)
1085 {
1086 #define WRITE_PARAM_FIELD(field, FIELD) \
1087 for (unsigned i = 0; i < ARRAY_SIZE(param->field); i++) \
1088 param_desc_map[BRW_IMAGE_PARAM_##FIELD##_OFFSET + i] = param->field[i]
1089
1090 WRITE_PARAM_FIELD(offset, OFFSET);
1091 WRITE_PARAM_FIELD(size, SIZE);
1092 WRITE_PARAM_FIELD(stride, STRIDE);
1093 WRITE_PARAM_FIELD(tiling, TILING);
1094 WRITE_PARAM_FIELD(swizzling, SWIZZLING);
1095 WRITE_PARAM_FIELD(size, SIZE);
1096
1097 #undef WRITE_PARAM_FIELD
1098 }
1099
1100 static uint32_t
1101 anv_surface_state_to_handle(struct anv_state state)
1102 {
1103 /* Bits 31:12 of the bindless surface offset in the extended message
1104 * descriptor is bits 25:6 of the byte-based address.
1105 */
1106 assert(state.offset >= 0);
1107 uint32_t offset = state.offset;
1108 assert((offset & 0x3f) == 0 && offset < (1 << 26));
1109 return offset << 6;
1110 }
1111
1112 void
1113 anv_descriptor_set_write_image_view(struct anv_device *device,
1114 struct anv_descriptor_set *set,
1115 const VkDescriptorImageInfo * const info,
1116 VkDescriptorType type,
1117 uint32_t binding,
1118 uint32_t element)
1119 {
1120 const struct anv_descriptor_set_binding_layout *bind_layout =
1121 &set->layout->binding[binding];
1122 struct anv_descriptor *desc =
1123 &set->descriptors[bind_layout->descriptor_index + element];
1124 struct anv_image_view *image_view = NULL;
1125 struct anv_sampler *sampler = NULL;
1126
1127 /* We get called with just VK_DESCRIPTOR_TYPE_SAMPLER as part of descriptor
1128 * set initialization to set the bindless samplers.
1129 */
1130 assert(type == bind_layout->type ||
1131 type == VK_DESCRIPTOR_TYPE_SAMPLER);
1132
1133 switch (type) {
1134 case VK_DESCRIPTOR_TYPE_SAMPLER:
1135 sampler = anv_sampler_from_handle(info->sampler);
1136 break;
1137
1138 case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
1139 image_view = anv_image_view_from_handle(info->imageView);
1140 sampler = anv_sampler_from_handle(info->sampler);
1141 break;
1142
1143 case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
1144 case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:
1145 case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:
1146 image_view = anv_image_view_from_handle(info->imageView);
1147 break;
1148
1149 default:
1150 unreachable("invalid descriptor type");
1151 }
1152
1153 /* If this descriptor has an immutable sampler, we don't want to stomp on
1154 * it.
1155 */
1156 sampler = bind_layout->immutable_samplers ?
1157 bind_layout->immutable_samplers[element] :
1158 sampler;
1159
1160 *desc = (struct anv_descriptor) {
1161 .type = type,
1162 .layout = info->imageLayout,
1163 .image_view = image_view,
1164 .sampler = sampler,
1165 };
1166
1167 void *desc_map = set->desc_mem.map + bind_layout->descriptor_offset +
1168 element * anv_descriptor_size(bind_layout);
1169
1170 if (bind_layout->data & ANV_DESCRIPTOR_SAMPLED_IMAGE) {
1171 struct anv_sampled_image_descriptor desc_data[3];
1172 memset(desc_data, 0, sizeof(desc_data));
1173
1174 if (image_view) {
1175 for (unsigned p = 0; p < image_view->n_planes; p++) {
1176 struct anv_surface_state sstate =
1177 (desc->layout == VK_IMAGE_LAYOUT_GENERAL) ?
1178 image_view->planes[p].general_sampler_surface_state :
1179 image_view->planes[p].optimal_sampler_surface_state;
1180 desc_data[p].image = anv_surface_state_to_handle(sstate.state);
1181 }
1182 }
1183
1184 if (sampler) {
1185 for (unsigned p = 0; p < sampler->n_planes; p++)
1186 desc_data[p].sampler = sampler->bindless_state.offset + p * 32;
1187 }
1188
1189 /* We may have max_plane_count < 0 if this isn't a sampled image but it
1190 * can be no more than the size of our array of handles.
1191 */
1192 assert(bind_layout->max_plane_count <= ARRAY_SIZE(desc_data));
1193 memcpy(desc_map, desc_data,
1194 MAX2(1, bind_layout->max_plane_count) * sizeof(desc_data[0]));
1195 }
1196
1197 if (bind_layout->data & ANV_DESCRIPTOR_STORAGE_IMAGE) {
1198 assert(!(bind_layout->data & ANV_DESCRIPTOR_IMAGE_PARAM));
1199 assert(image_view->n_planes == 1);
1200 struct anv_storage_image_descriptor desc_data = {
1201 .read_write = anv_surface_state_to_handle(
1202 image_view->planes[0].storage_surface_state.state),
1203 .write_only = anv_surface_state_to_handle(
1204 image_view->planes[0].writeonly_storage_surface_state.state),
1205 };
1206 memcpy(desc_map, &desc_data, sizeof(desc_data));
1207 }
1208
1209 if (bind_layout->data & ANV_DESCRIPTOR_IMAGE_PARAM) {
1210 /* Storage images can only ever have one plane */
1211 assert(image_view->n_planes == 1);
1212 const struct brw_image_param *image_param =
1213 &image_view->planes[0].storage_image_param;
1214
1215 anv_descriptor_set_write_image_param(desc_map, image_param);
1216 }
1217
1218 if (image_view && (bind_layout->data & ANV_DESCRIPTOR_TEXTURE_SWIZZLE)) {
1219 assert(!(bind_layout->data & ANV_DESCRIPTOR_SAMPLED_IMAGE));
1220 assert(image_view);
1221 struct anv_texture_swizzle_descriptor desc_data[3];
1222 memset(desc_data, 0, sizeof(desc_data));
1223
1224 for (unsigned p = 0; p < image_view->n_planes; p++) {
1225 desc_data[p] = (struct anv_texture_swizzle_descriptor) {
1226 .swizzle = {
1227 (uint8_t)image_view->planes[p].isl.swizzle.r,
1228 (uint8_t)image_view->planes[p].isl.swizzle.g,
1229 (uint8_t)image_view->planes[p].isl.swizzle.b,
1230 (uint8_t)image_view->planes[p].isl.swizzle.a,
1231 },
1232 };
1233 }
1234 memcpy(desc_map, desc_data,
1235 MAX2(1, bind_layout->max_plane_count) * sizeof(desc_data[0]));
1236 }
1237 }
1238
1239 void
1240 anv_descriptor_set_write_buffer_view(struct anv_device *device,
1241 struct anv_descriptor_set *set,
1242 VkDescriptorType type,
1243 struct anv_buffer_view *buffer_view,
1244 uint32_t binding,
1245 uint32_t element)
1246 {
1247 const struct anv_descriptor_set_binding_layout *bind_layout =
1248 &set->layout->binding[binding];
1249 struct anv_descriptor *desc =
1250 &set->descriptors[bind_layout->descriptor_index + element];
1251
1252 assert(type == bind_layout->type);
1253
1254 *desc = (struct anv_descriptor) {
1255 .type = type,
1256 .buffer_view = buffer_view,
1257 };
1258
1259 void *desc_map = set->desc_mem.map + bind_layout->descriptor_offset +
1260 element * anv_descriptor_size(bind_layout);
1261
1262 if (bind_layout->data & ANV_DESCRIPTOR_SAMPLED_IMAGE) {
1263 struct anv_sampled_image_descriptor desc_data = {
1264 .image = anv_surface_state_to_handle(buffer_view->surface_state),
1265 };
1266 memcpy(desc_map, &desc_data, sizeof(desc_data));
1267 }
1268
1269 if (bind_layout->data & ANV_DESCRIPTOR_STORAGE_IMAGE) {
1270 assert(!(bind_layout->data & ANV_DESCRIPTOR_IMAGE_PARAM));
1271 struct anv_storage_image_descriptor desc_data = {
1272 .read_write = anv_surface_state_to_handle(
1273 buffer_view->storage_surface_state),
1274 .write_only = anv_surface_state_to_handle(
1275 buffer_view->writeonly_storage_surface_state),
1276 };
1277 memcpy(desc_map, &desc_data, sizeof(desc_data));
1278 }
1279
1280 if (bind_layout->data & ANV_DESCRIPTOR_IMAGE_PARAM) {
1281 anv_descriptor_set_write_image_param(desc_map,
1282 &buffer_view->storage_image_param);
1283 }
1284 }
1285
1286 void
1287 anv_descriptor_set_write_buffer(struct anv_device *device,
1288 struct anv_descriptor_set *set,
1289 struct anv_state_stream *alloc_stream,
1290 VkDescriptorType type,
1291 struct anv_buffer *buffer,
1292 uint32_t binding,
1293 uint32_t element,
1294 VkDeviceSize offset,
1295 VkDeviceSize range)
1296 {
1297 const struct anv_descriptor_set_binding_layout *bind_layout =
1298 &set->layout->binding[binding];
1299 struct anv_descriptor *desc =
1300 &set->descriptors[bind_layout->descriptor_index + element];
1301
1302 assert(type == bind_layout->type);
1303
1304 struct anv_address bind_addr = anv_address_add(buffer->address, offset);
1305 uint64_t bind_range = anv_buffer_get_range(buffer, offset, range);
1306
1307 if (type == VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC ||
1308 type == VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC) {
1309 *desc = (struct anv_descriptor) {
1310 .type = type,
1311 .buffer = buffer,
1312 .offset = offset,
1313 .range = range,
1314 };
1315 } else {
1316 assert(bind_layout->data & ANV_DESCRIPTOR_BUFFER_VIEW);
1317 struct anv_buffer_view *bview =
1318 &set->buffer_views[bind_layout->buffer_view_index + element];
1319
1320 bview->format = anv_isl_format_for_descriptor_type(type);
1321 bview->range = bind_range;
1322 bview->address = bind_addr;
1323
1324 /* If we're writing descriptors through a push command, we need to
1325 * allocate the surface state from the command buffer. Otherwise it will
1326 * be allocated by the descriptor pool when calling
1327 * vkAllocateDescriptorSets. */
1328 if (alloc_stream)
1329 bview->surface_state = anv_state_stream_alloc(alloc_stream, 64, 64);
1330
1331 anv_fill_buffer_surface_state(device, bview->surface_state,
1332 bview->format, bind_addr, bind_range, 1);
1333
1334 *desc = (struct anv_descriptor) {
1335 .type = type,
1336 .buffer_view = bview,
1337 };
1338 }
1339
1340 void *desc_map = set->desc_mem.map + bind_layout->descriptor_offset +
1341 element * anv_descriptor_size(bind_layout);
1342
1343 if (bind_layout->data & ANV_DESCRIPTOR_ADDRESS_RANGE) {
1344 struct anv_address_range_descriptor desc = {
1345 .address = anv_address_physical(bind_addr),
1346 .range = bind_range,
1347 };
1348 memcpy(desc_map, &desc, sizeof(desc));
1349 }
1350 }
1351
1352 void
1353 anv_descriptor_set_write_inline_uniform_data(struct anv_device *device,
1354 struct anv_descriptor_set *set,
1355 uint32_t binding,
1356 const void *data,
1357 size_t offset,
1358 size_t size)
1359 {
1360 const struct anv_descriptor_set_binding_layout *bind_layout =
1361 &set->layout->binding[binding];
1362
1363 assert(bind_layout->data & ANV_DESCRIPTOR_INLINE_UNIFORM);
1364
1365 void *desc_map = set->desc_mem.map + bind_layout->descriptor_offset;
1366
1367 memcpy(desc_map + offset, data, size);
1368 }
1369
1370 void anv_UpdateDescriptorSets(
1371 VkDevice _device,
1372 uint32_t descriptorWriteCount,
1373 const VkWriteDescriptorSet* pDescriptorWrites,
1374 uint32_t descriptorCopyCount,
1375 const VkCopyDescriptorSet* pDescriptorCopies)
1376 {
1377 ANV_FROM_HANDLE(anv_device, device, _device);
1378
1379 for (uint32_t i = 0; i < descriptorWriteCount; i++) {
1380 const VkWriteDescriptorSet *write = &pDescriptorWrites[i];
1381 ANV_FROM_HANDLE(anv_descriptor_set, set, write->dstSet);
1382
1383 switch (write->descriptorType) {
1384 case VK_DESCRIPTOR_TYPE_SAMPLER:
1385 case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
1386 case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
1387 case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:
1388 case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:
1389 for (uint32_t j = 0; j < write->descriptorCount; j++) {
1390 anv_descriptor_set_write_image_view(device, set,
1391 write->pImageInfo + j,
1392 write->descriptorType,
1393 write->dstBinding,
1394 write->dstArrayElement + j);
1395 }
1396 break;
1397
1398 case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:
1399 case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
1400 for (uint32_t j = 0; j < write->descriptorCount; j++) {
1401 ANV_FROM_HANDLE(anv_buffer_view, bview,
1402 write->pTexelBufferView[j]);
1403
1404 anv_descriptor_set_write_buffer_view(device, set,
1405 write->descriptorType,
1406 bview,
1407 write->dstBinding,
1408 write->dstArrayElement + j);
1409 }
1410 break;
1411
1412 case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
1413 case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
1414 case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
1415 case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:
1416 for (uint32_t j = 0; j < write->descriptorCount; j++) {
1417 assert(write->pBufferInfo[j].buffer);
1418 ANV_FROM_HANDLE(anv_buffer, buffer, write->pBufferInfo[j].buffer);
1419 assert(buffer);
1420
1421 anv_descriptor_set_write_buffer(device, set,
1422 NULL,
1423 write->descriptorType,
1424 buffer,
1425 write->dstBinding,
1426 write->dstArrayElement + j,
1427 write->pBufferInfo[j].offset,
1428 write->pBufferInfo[j].range);
1429 }
1430 break;
1431
1432 case VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT: {
1433 const VkWriteDescriptorSetInlineUniformBlockEXT *inline_write =
1434 vk_find_struct_const(write->pNext,
1435 WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK_EXT);
1436 assert(inline_write->dataSize == write->descriptorCount);
1437 anv_descriptor_set_write_inline_uniform_data(device, set,
1438 write->dstBinding,
1439 inline_write->pData,
1440 write->dstArrayElement,
1441 inline_write->dataSize);
1442 break;
1443 }
1444
1445 default:
1446 break;
1447 }
1448 }
1449
1450 for (uint32_t i = 0; i < descriptorCopyCount; i++) {
1451 const VkCopyDescriptorSet *copy = &pDescriptorCopies[i];
1452 ANV_FROM_HANDLE(anv_descriptor_set, src, copy->srcSet);
1453 ANV_FROM_HANDLE(anv_descriptor_set, dst, copy->dstSet);
1454
1455 const struct anv_descriptor_set_binding_layout *src_layout =
1456 &src->layout->binding[copy->srcBinding];
1457 struct anv_descriptor *src_desc =
1458 &src->descriptors[src_layout->descriptor_index];
1459 src_desc += copy->srcArrayElement;
1460
1461 const struct anv_descriptor_set_binding_layout *dst_layout =
1462 &dst->layout->binding[copy->dstBinding];
1463 struct anv_descriptor *dst_desc =
1464 &dst->descriptors[dst_layout->descriptor_index];
1465 dst_desc += copy->dstArrayElement;
1466
1467 if (src_layout->data & ANV_DESCRIPTOR_INLINE_UNIFORM) {
1468 assert(src_layout->data == ANV_DESCRIPTOR_INLINE_UNIFORM);
1469 memcpy(dst->desc_mem.map + dst_layout->descriptor_offset +
1470 copy->dstArrayElement,
1471 src->desc_mem.map + src_layout->descriptor_offset +
1472 copy->srcArrayElement,
1473 copy->descriptorCount);
1474 } else {
1475 for (uint32_t j = 0; j < copy->descriptorCount; j++)
1476 dst_desc[j] = src_desc[j];
1477
1478 unsigned desc_size = anv_descriptor_size(src_layout);
1479 if (desc_size > 0) {
1480 assert(desc_size == anv_descriptor_size(dst_layout));
1481 memcpy(dst->desc_mem.map + dst_layout->descriptor_offset +
1482 copy->dstArrayElement * desc_size,
1483 src->desc_mem.map + src_layout->descriptor_offset +
1484 copy->srcArrayElement * desc_size,
1485 copy->descriptorCount * desc_size);
1486 }
1487 }
1488 }
1489 }
1490
1491 /*
1492 * Descriptor update templates.
1493 */
1494
1495 void
1496 anv_descriptor_set_write_template(struct anv_device *device,
1497 struct anv_descriptor_set *set,
1498 struct anv_state_stream *alloc_stream,
1499 const struct anv_descriptor_update_template *template,
1500 const void *data)
1501 {
1502 for (uint32_t i = 0; i < template->entry_count; i++) {
1503 const struct anv_descriptor_template_entry *entry =
1504 &template->entries[i];
1505
1506 switch (entry->type) {
1507 case VK_DESCRIPTOR_TYPE_SAMPLER:
1508 case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
1509 case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
1510 case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:
1511 case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:
1512 for (uint32_t j = 0; j < entry->array_count; j++) {
1513 const VkDescriptorImageInfo *info =
1514 data + entry->offset + j * entry->stride;
1515 anv_descriptor_set_write_image_view(device, set,
1516 info, entry->type,
1517 entry->binding,
1518 entry->array_element + j);
1519 }
1520 break;
1521
1522 case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:
1523 case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
1524 for (uint32_t j = 0; j < entry->array_count; j++) {
1525 const VkBufferView *_bview =
1526 data + entry->offset + j * entry->stride;
1527 ANV_FROM_HANDLE(anv_buffer_view, bview, *_bview);
1528
1529 anv_descriptor_set_write_buffer_view(device, set,
1530 entry->type,
1531 bview,
1532 entry->binding,
1533 entry->array_element + j);
1534 }
1535 break;
1536
1537 case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
1538 case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
1539 case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
1540 case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:
1541 for (uint32_t j = 0; j < entry->array_count; j++) {
1542 const VkDescriptorBufferInfo *info =
1543 data + entry->offset + j * entry->stride;
1544 ANV_FROM_HANDLE(anv_buffer, buffer, info->buffer);
1545
1546 anv_descriptor_set_write_buffer(device, set,
1547 alloc_stream,
1548 entry->type,
1549 buffer,
1550 entry->binding,
1551 entry->array_element + j,
1552 info->offset, info->range);
1553 }
1554 break;
1555
1556 case VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT:
1557 anv_descriptor_set_write_inline_uniform_data(device, set,
1558 entry->binding,
1559 data + entry->offset,
1560 entry->array_element,
1561 entry->array_count);
1562 break;
1563
1564 default:
1565 break;
1566 }
1567 }
1568 }
1569
1570 VkResult anv_CreateDescriptorUpdateTemplate(
1571 VkDevice _device,
1572 const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo,
1573 const VkAllocationCallbacks* pAllocator,
1574 VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate)
1575 {
1576 ANV_FROM_HANDLE(anv_device, device, _device);
1577 struct anv_descriptor_update_template *template;
1578
1579 size_t size = sizeof(*template) +
1580 pCreateInfo->descriptorUpdateEntryCount * sizeof(template->entries[0]);
1581 template = vk_alloc2(&device->alloc, pAllocator, size, 8,
1582 VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
1583 if (template == NULL)
1584 return vk_error(VK_ERROR_OUT_OF_HOST_MEMORY);
1585
1586 template->bind_point = pCreateInfo->pipelineBindPoint;
1587
1588 if (pCreateInfo->templateType == VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET)
1589 template->set = pCreateInfo->set;
1590
1591 template->entry_count = pCreateInfo->descriptorUpdateEntryCount;
1592 for (uint32_t i = 0; i < template->entry_count; i++) {
1593 const VkDescriptorUpdateTemplateEntry *pEntry =
1594 &pCreateInfo->pDescriptorUpdateEntries[i];
1595
1596 template->entries[i] = (struct anv_descriptor_template_entry) {
1597 .type = pEntry->descriptorType,
1598 .binding = pEntry->dstBinding,
1599 .array_element = pEntry->dstArrayElement,
1600 .array_count = pEntry->descriptorCount,
1601 .offset = pEntry->offset,
1602 .stride = pEntry->stride,
1603 };
1604 }
1605
1606 *pDescriptorUpdateTemplate =
1607 anv_descriptor_update_template_to_handle(template);
1608
1609 return VK_SUCCESS;
1610 }
1611
1612 void anv_DestroyDescriptorUpdateTemplate(
1613 VkDevice _device,
1614 VkDescriptorUpdateTemplate descriptorUpdateTemplate,
1615 const VkAllocationCallbacks* pAllocator)
1616 {
1617 ANV_FROM_HANDLE(anv_device, device, _device);
1618 ANV_FROM_HANDLE(anv_descriptor_update_template, template,
1619 descriptorUpdateTemplate);
1620
1621 vk_free2(&device->alloc, pAllocator, template);
1622 }
1623
1624 void anv_UpdateDescriptorSetWithTemplate(
1625 VkDevice _device,
1626 VkDescriptorSet descriptorSet,
1627 VkDescriptorUpdateTemplate descriptorUpdateTemplate,
1628 const void* pData)
1629 {
1630 ANV_FROM_HANDLE(anv_device, device, _device);
1631 ANV_FROM_HANDLE(anv_descriptor_set, set, descriptorSet);
1632 ANV_FROM_HANDLE(anv_descriptor_update_template, template,
1633 descriptorUpdateTemplate);
1634
1635 anv_descriptor_set_write_template(device, set, NULL, template, pData);
1636 }