projects / mesa.git / blob
? search:


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