projects / mesa.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
radv: Remove binding buffer count.
[mesa.git] / src / amd / vulkan / radv_descriptor_set.c
1 /*
2 * Copyright © 2016 Red Hat.
3 * Copyright © 2016 Bas Nieuwenhuizen
4 *
5 * Permission is hereby granted, free of charge, to any person obtaining a
6 * copy of this software and associated documentation files (the "Software"),
7 * to deal in the Software without restriction, including without limitation
8 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
9 * and/or sell copies of the Software, and to permit persons to whom the
10 * Software is furnished to do so, subject to the following conditions:
11 *
12 * The above copyright notice and this permission notice (including the next
13 * paragraph) shall be included in all copies or substantial portions of the
14 * Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
21 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
22 * IN THE SOFTWARE.
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 "radv_private.h"
32 #include "sid.h"
33
34 VkResult radv_CreateDescriptorSetLayout(
35 VkDevice _device,
36 const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
37 const VkAllocationCallbacks* pAllocator,
38 VkDescriptorSetLayout* pSetLayout)
39 {
40 RADV_FROM_HANDLE(radv_device, device, _device);
41 struct radv_descriptor_set_layout *set_layout;
42
43 assert(pCreateInfo->sType == VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO);
44
45 uint32_t max_binding = 0;
46 uint32_t immutable_sampler_count = 0;
47 for (uint32_t j = 0; j < pCreateInfo->bindingCount; j++) {
48 max_binding = MAX2(max_binding, pCreateInfo->pBindings[j].binding);
49 if (pCreateInfo->pBindings[j].pImmutableSamplers)
50 immutable_sampler_count += pCreateInfo->pBindings[j].descriptorCount;
51 }
52
53 uint32_t samplers_offset = sizeof(struct radv_descriptor_set_layout) +
54 (max_binding + 1) * sizeof(set_layout->binding[0]);
55 size_t size = samplers_offset + immutable_sampler_count * 4 * sizeof(uint32_t);
56
57 set_layout = vk_alloc2(&device->alloc, pAllocator, size, 8,
58 VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
59 if (!set_layout)
60 return vk_error(VK_ERROR_OUT_OF_HOST_MEMORY);
61
62 set_layout->flags = pCreateInfo->flags;
63
64 /* We just allocate all the samplers at the end of the struct */
65 uint32_t *samplers = (uint32_t*)&set_layout->binding[max_binding + 1];
66
67 set_layout->binding_count = max_binding + 1;
68 set_layout->shader_stages = 0;
69 set_layout->size = 0;
70
71 memset(set_layout->binding, 0, size - sizeof(struct radv_descriptor_set_layout));
72
73 uint32_t buffer_count = 0;
74 uint32_t dynamic_offset_count = 0;
75
76 for (uint32_t j = 0; j < pCreateInfo->bindingCount; j++) {
77 const VkDescriptorSetLayoutBinding *binding = &pCreateInfo->pBindings[j];
78 uint32_t b = binding->binding;
79 uint32_t alignment;
80 unsigned binding_buffer_count = 0;
81
82 switch (binding->descriptorType) {
83 case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
84 case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:
85 assert(!(pCreateInfo->flags & VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR));
86 set_layout->binding[b].dynamic_offset_count = 1;
87 set_layout->dynamic_shader_stages |= binding->stageFlags;
88 set_layout->binding[b].size = 0;
89 binding_buffer_count = 1;
90 alignment = 1;
91 break;
92 case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
93 case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
94 case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:
95 case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
96 set_layout->binding[b].size = 16;
97 binding_buffer_count = 1;
98 alignment = 16;
99 break;
100 case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:
101 case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
102 case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:
103 /* main descriptor + fmask descriptor */
104 set_layout->binding[b].size = 64;
105 binding_buffer_count = 1;
106 alignment = 32;
107 break;
108 case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
109 /* main descriptor + fmask descriptor + sampler */
110 set_layout->binding[b].size = 96;
111 binding_buffer_count = 1;
112 alignment = 32;
113 break;
114 case VK_DESCRIPTOR_TYPE_SAMPLER:
115 set_layout->binding[b].size = 16;
116 alignment = 16;
117 break;
118 default:
119 unreachable("unknown descriptor type\n");
120 break;
121 }
122
123 set_layout->size = align(set_layout->size, alignment);
124 assert(binding->descriptorCount > 0);
125 set_layout->binding[b].type = binding->descriptorType;
126 set_layout->binding[b].array_size = binding->descriptorCount;
127 set_layout->binding[b].offset = set_layout->size;
128 set_layout->binding[b].buffer_offset = buffer_count;
129 set_layout->binding[b].dynamic_offset_offset = dynamic_offset_count;
130
131 if (binding->pImmutableSamplers) {
132 set_layout->binding[b].immutable_samplers_offset = samplers_offset;
133 set_layout->binding[b].immutable_samplers_equal = true;
134
135
136 for (uint32_t i = 0; i < binding->descriptorCount; i++)
137 memcpy(samplers + 4 * i, &radv_sampler_from_handle(binding->pImmutableSamplers[i])->state, 16);
138 for (uint32_t i = 1; i < binding->descriptorCount; i++)
139 if (memcmp(samplers + 4 * i, samplers, 16) != 0)
140 set_layout->binding[b].immutable_samplers_equal = false;
141
142 /* Don't reserve space for the samplers if they're not accessed. */
143 if (set_layout->binding[b].immutable_samplers_equal) {
144 if (binding->descriptorType == VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER)
145 set_layout->binding[b].size -= 32;
146 else if (binding->descriptorType == VK_DESCRIPTOR_TYPE_SAMPLER)
147 set_layout->binding[b].size -= 16;
148 }
149 samplers += 4 * binding->descriptorCount;
150 samplers_offset += 4 * sizeof(uint32_t) * binding->descriptorCount;
151 }
152
153 set_layout->size += binding->descriptorCount * set_layout->binding[b].size;
154 buffer_count += binding->descriptorCount * binding_buffer_count;
155 dynamic_offset_count += binding->descriptorCount *
156 set_layout->binding[b].dynamic_offset_count;
157 set_layout->shader_stages |= binding->stageFlags;
158 }
159
160 set_layout->buffer_count = buffer_count;
161 set_layout->dynamic_offset_count = dynamic_offset_count;
162
163 *pSetLayout = radv_descriptor_set_layout_to_handle(set_layout);
164
165 return VK_SUCCESS;
166 }
167
168 void radv_DestroyDescriptorSetLayout(
169 VkDevice _device,
170 VkDescriptorSetLayout _set_layout,
171 const VkAllocationCallbacks* pAllocator)
172 {
173 RADV_FROM_HANDLE(radv_device, device, _device);
174 RADV_FROM_HANDLE(radv_descriptor_set_layout, set_layout, _set_layout);
175
176 if (!set_layout)
177 return;
178
179 vk_free2(&device->alloc, pAllocator, set_layout);
180 }
181
182 /*
183 * Pipeline layouts. These have nothing to do with the pipeline. They are
184 * just muttiple descriptor set layouts pasted together
185 */
186
187 VkResult radv_CreatePipelineLayout(
188 VkDevice _device,
189 const VkPipelineLayoutCreateInfo* pCreateInfo,
190 const VkAllocationCallbacks* pAllocator,
191 VkPipelineLayout* pPipelineLayout)
192 {
193 RADV_FROM_HANDLE(radv_device, device, _device);
194 struct radv_pipeline_layout *layout;
195 struct mesa_sha1 ctx;
196
197 assert(pCreateInfo->sType == VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO);
198
199 layout = vk_alloc2(&device->alloc, pAllocator, sizeof(*layout), 8,
200 VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
201 if (layout == NULL)
202 return vk_error(VK_ERROR_OUT_OF_HOST_MEMORY);
203
204 layout->num_sets = pCreateInfo->setLayoutCount;
205
206 unsigned dynamic_offset_count = 0;
207
208
209 _mesa_sha1_init(&ctx);
210 for (uint32_t set = 0; set < pCreateInfo->setLayoutCount; set++) {
211 RADV_FROM_HANDLE(radv_descriptor_set_layout, set_layout,
212 pCreateInfo->pSetLayouts[set]);
213 layout->set[set].layout = set_layout;
214
215 layout->set[set].dynamic_offset_start = dynamic_offset_count;
216 for (uint32_t b = 0; b < set_layout->binding_count; b++) {
217 dynamic_offset_count += set_layout->binding[b].array_size * set_layout->binding[b].dynamic_offset_count;
218 if (set_layout->binding[b].immutable_samplers_offset)
219 _mesa_sha1_update(&ctx, radv_immutable_samplers(set_layout, set_layout->binding + b),
220 set_layout->binding[b].array_size * 4 * sizeof(uint32_t));
221 }
222 _mesa_sha1_update(&ctx, set_layout->binding,
223 sizeof(set_layout->binding[0]) * set_layout->binding_count);
224 }
225
226 layout->dynamic_offset_count = dynamic_offset_count;
227 layout->push_constant_size = 0;
228 for (unsigned i = 0; i < pCreateInfo->pushConstantRangeCount; ++i) {
229 const VkPushConstantRange *range = pCreateInfo->pPushConstantRanges + i;
230 layout->push_constant_size = MAX2(layout->push_constant_size,
231 range->offset + range->size);
232 }
233
234 layout->push_constant_size = align(layout->push_constant_size, 16);
235 _mesa_sha1_update(&ctx, &layout->push_constant_size,
236 sizeof(layout->push_constant_size));
237 _mesa_sha1_final(&ctx, layout->sha1);
238 *pPipelineLayout = radv_pipeline_layout_to_handle(layout);
239
240 return VK_SUCCESS;
241 }
242
243 void radv_DestroyPipelineLayout(
244 VkDevice _device,
245 VkPipelineLayout _pipelineLayout,
246 const VkAllocationCallbacks* pAllocator)
247 {
248 RADV_FROM_HANDLE(radv_device, device, _device);
249 RADV_FROM_HANDLE(radv_pipeline_layout, pipeline_layout, _pipelineLayout);
250
251 if (!pipeline_layout)
252 return;
253 vk_free2(&device->alloc, pAllocator, pipeline_layout);
254 }
255
256 #define EMPTY 1
257
258 static VkResult
259 radv_descriptor_set_create(struct radv_device *device,
260 struct radv_descriptor_pool *pool,
261 const struct radv_descriptor_set_layout *layout,
262 struct radv_descriptor_set **out_set)
263 {
264 struct radv_descriptor_set *set;
265 unsigned range_offset = sizeof(struct radv_descriptor_set) +
266 sizeof(struct radeon_winsys_bo *) * layout->buffer_count;
267 unsigned mem_size = range_offset +
268 sizeof(struct radv_descriptor_range) * layout->dynamic_offset_count;
269
270 if (pool->host_memory_base) {
271 if (pool->host_memory_end - pool->host_memory_ptr < mem_size)
272 return vk_error(VK_ERROR_OUT_OF_POOL_MEMORY_KHR);
273
274 set = (struct radv_descriptor_set*)pool->host_memory_ptr;
275 pool->host_memory_ptr += mem_size;
276 } else {
277 set = vk_alloc2(&device->alloc, NULL, mem_size, 8,
278 VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
279
280 if (!set)
281 return vk_error(VK_ERROR_OUT_OF_HOST_MEMORY);
282 }
283
284 memset(set, 0, mem_size);
285
286 if (layout->dynamic_offset_count) {
287 set->dynamic_descriptors = (struct radv_descriptor_range*)((uint8_t*)set + range_offset);
288 }
289
290 set->layout = layout;
291 if (layout->size) {
292 uint32_t layout_size = align_u32(layout->size, 32);
293 set->size = layout->size;
294
295 /* try to allocate linearly first, so that we don't spend
296 * time looking for gaps if the app only allocates &
297 * resets via the pool. */
298 if (pool->current_offset + layout_size <= pool->size) {
299 set->bo = pool->bo;
300 set->mapped_ptr = (uint32_t*)(pool->mapped_ptr + pool->current_offset);
301 set->va = device->ws->buffer_get_va(set->bo) + pool->current_offset;
302 pool->current_offset += layout_size;
303 list_addtail(&set->vram_list, &pool->vram_list);
304 } else if (!pool->host_memory_base) {
305 uint64_t offset = 0;
306 struct list_head *prev = &pool->vram_list;
307 struct radv_descriptor_set *cur;
308
309 assert(!pool->host_memory_base);
310 LIST_FOR_EACH_ENTRY(cur, &pool->vram_list, vram_list) {
311 uint64_t start = (uint8_t*)cur->mapped_ptr - pool->mapped_ptr;
312 if (start - offset >= layout_size)
313 break;
314
315 offset = start + cur->size;
316 prev = &cur->vram_list;
317 }
318
319 if (pool->size - offset < layout_size) {
320 vk_free2(&device->alloc, NULL, set->dynamic_descriptors);
321 vk_free2(&device->alloc, NULL, set);
322 return vk_error(VK_ERROR_OUT_OF_POOL_MEMORY_KHR);
323 }
324 set->bo = pool->bo;
325 set->mapped_ptr = (uint32_t*)(pool->mapped_ptr + offset);
326 set->va = device->ws->buffer_get_va(set->bo) + offset;
327 list_add(&set->vram_list, prev);
328 } else
329 return vk_error(VK_ERROR_OUT_OF_POOL_MEMORY_KHR);
330 }
331
332 for (unsigned i = 0; i < layout->binding_count; ++i) {
333 if (!layout->binding[i].immutable_samplers_offset ||
334 layout->binding[i].immutable_samplers_equal)
335 continue;
336
337 unsigned offset = layout->binding[i].offset / 4;
338 if (layout->binding[i].type == VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER)
339 offset += 16;
340
341 const uint32_t *samplers = (const uint32_t*)((const char*)layout + layout->binding[i].immutable_samplers_offset);
342 for (unsigned j = 0; j < layout->binding[i].array_size; ++j) {
343 memcpy(set->mapped_ptr + offset, samplers + 4 * j, 16);
344 offset += layout->binding[i].size / 4;
345 }
346
347 }
348 *out_set = set;
349 return VK_SUCCESS;
350 }
351
352 static void
353 radv_descriptor_set_destroy(struct radv_device *device,
354 struct radv_descriptor_pool *pool,
355 struct radv_descriptor_set *set,
356 bool free_bo)
357 {
358 assert(!pool->host_memory_base);
359
360 if (free_bo && set->size)
361 list_del(&set->vram_list);
362 vk_free2(&device->alloc, NULL, set);
363 }
364
365 VkResult radv_CreateDescriptorPool(
366 VkDevice _device,
367 const VkDescriptorPoolCreateInfo* pCreateInfo,
368 const VkAllocationCallbacks* pAllocator,
369 VkDescriptorPool* pDescriptorPool)
370 {
371 RADV_FROM_HANDLE(radv_device, device, _device);
372 struct radv_descriptor_pool *pool;
373 int size = sizeof(struct radv_descriptor_pool);
374 uint64_t bo_size = 0, bo_count = 0, range_count = 0;
375
376
377 for (unsigned i = 0; i < pCreateInfo->poolSizeCount; ++i) {
378 if (pCreateInfo->pPoolSizes[i].type != VK_DESCRIPTOR_TYPE_SAMPLER)
379 bo_count += pCreateInfo->pPoolSizes[i].descriptorCount;
380
381 switch(pCreateInfo->pPoolSizes[i].type) {
382 case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
383 case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:
384 range_count += pCreateInfo->pPoolSizes[i].descriptorCount;
385 break;
386 case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
387 case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
388 case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:
389 case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
390 case VK_DESCRIPTOR_TYPE_SAMPLER:
391 /* 32 as we may need to align for images */
392 bo_size += 32 * pCreateInfo->pPoolSizes[i].descriptorCount;
393 break;
394 case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
395 case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:
396 case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:
397 bo_size += 64 * pCreateInfo->pPoolSizes[i].descriptorCount;
398 break;
399 case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
400 bo_size += 96 * pCreateInfo->pPoolSizes[i].descriptorCount;
401 break;
402 default:
403 unreachable("unknown descriptor type\n");
404 break;
405 }
406 }
407
408 if (!(pCreateInfo->flags & VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT)) {
409 uint64_t host_size = pCreateInfo->maxSets * sizeof(struct radv_descriptor_set);
410 host_size += sizeof(struct radeon_winsys_bo*) * bo_count;
411 host_size += sizeof(struct radv_descriptor_range) * range_count;
412 size += host_size;
413 }
414
415 pool = vk_alloc2(&device->alloc, pAllocator, size, 8,
416 VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
417 if (!pool)
418 return vk_error(VK_ERROR_OUT_OF_HOST_MEMORY);
419
420 memset(pool, 0, sizeof(*pool));
421
422 if (!(pCreateInfo->flags & VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT)) {
423 pool->host_memory_base = (uint8_t*)pool + sizeof(struct radv_descriptor_pool);
424 pool->host_memory_ptr = pool->host_memory_base;
425 pool->host_memory_end = (uint8_t*)pool + size;
426 }
427
428 if (bo_size) {
429 pool->bo = device->ws->buffer_create(device->ws, bo_size,
430 32, RADEON_DOMAIN_VRAM, 0);
431 pool->mapped_ptr = (uint8_t*)device->ws->buffer_map(pool->bo);
432 }
433 pool->size = bo_size;
434
435 list_inithead(&pool->vram_list);
436 *pDescriptorPool = radv_descriptor_pool_to_handle(pool);
437 return VK_SUCCESS;
438 }
439
440 void radv_DestroyDescriptorPool(
441 VkDevice _device,
442 VkDescriptorPool _pool,
443 const VkAllocationCallbacks* pAllocator)
444 {
445 RADV_FROM_HANDLE(radv_device, device, _device);
446 RADV_FROM_HANDLE(radv_descriptor_pool, pool, _pool);
447
448 if (!pool)
449 return;
450
451 if (!pool->host_memory_base) {
452 list_for_each_entry_safe(struct radv_descriptor_set, set,
453 &pool->vram_list, vram_list) {
454 radv_descriptor_set_destroy(device, pool, set, false);
455 }
456 }
457
458 if (pool->bo)
459 device->ws->buffer_destroy(pool->bo);
460 vk_free2(&device->alloc, pAllocator, pool);
461 }
462
463 VkResult radv_ResetDescriptorPool(
464 VkDevice _device,
465 VkDescriptorPool descriptorPool,
466 VkDescriptorPoolResetFlags flags)
467 {
468 RADV_FROM_HANDLE(radv_device, device, _device);
469 RADV_FROM_HANDLE(radv_descriptor_pool, pool, descriptorPool);
470
471 if (!pool->host_memory_base) {
472 list_for_each_entry_safe(struct radv_descriptor_set, set,
473 &pool->vram_list, vram_list) {
474 radv_descriptor_set_destroy(device, pool, set, false);
475 }
476 }
477
478 list_inithead(&pool->vram_list);
479
480 pool->current_offset = 0;
481 pool->host_memory_ptr = pool->host_memory_base;
482
483 return VK_SUCCESS;
484 }
485
486 VkResult radv_AllocateDescriptorSets(
487 VkDevice _device,
488 const VkDescriptorSetAllocateInfo* pAllocateInfo,
489 VkDescriptorSet* pDescriptorSets)
490 {
491 RADV_FROM_HANDLE(radv_device, device, _device);
492 RADV_FROM_HANDLE(radv_descriptor_pool, pool, pAllocateInfo->descriptorPool);
493
494 VkResult result = VK_SUCCESS;
495 uint32_t i;
496 struct radv_descriptor_set *set;
497
498 /* allocate a set of buffers for each shader to contain descriptors */
499 for (i = 0; i < pAllocateInfo->descriptorSetCount; i++) {
500 RADV_FROM_HANDLE(radv_descriptor_set_layout, layout,
501 pAllocateInfo->pSetLayouts[i]);
502
503 assert(!(layout->flags & VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR));
504
505 result = radv_descriptor_set_create(device, pool, layout, &set);
506 if (result != VK_SUCCESS)
507 break;
508
509 pDescriptorSets[i] = radv_descriptor_set_to_handle(set);
510 }
511
512 if (result != VK_SUCCESS)
513 radv_FreeDescriptorSets(_device, pAllocateInfo->descriptorPool,
514 i, pDescriptorSets);
515 return result;
516 }
517
518 VkResult radv_FreeDescriptorSets(
519 VkDevice _device,
520 VkDescriptorPool descriptorPool,
521 uint32_t count,
522 const VkDescriptorSet* pDescriptorSets)
523 {
524 RADV_FROM_HANDLE(radv_device, device, _device);
525 RADV_FROM_HANDLE(radv_descriptor_pool, pool, descriptorPool);
526
527 for (uint32_t i = 0; i < count; i++) {
528 RADV_FROM_HANDLE(radv_descriptor_set, set, pDescriptorSets[i]);
529
530 if (set)
531 radv_descriptor_set_destroy(device, pool, set, true);
532 }
533 return VK_SUCCESS;
534 }
535
536 static void write_texel_buffer_descriptor(struct radv_device *device,
537 struct radv_cmd_buffer *cmd_buffer,
538 unsigned *dst,
539 struct radeon_winsys_bo **buffer_list,
540 const VkBufferView _buffer_view)
541 {
542 RADV_FROM_HANDLE(radv_buffer_view, buffer_view, _buffer_view);
543
544 memcpy(dst, buffer_view->state, 4 * 4);
545
546 if (cmd_buffer)
547 device->ws->cs_add_buffer(cmd_buffer->cs, buffer_view->bo, 7);
548 else
549 *buffer_list = buffer_view->bo;
550 }
551
552 static void write_buffer_descriptor(struct radv_device *device,
553 struct radv_cmd_buffer *cmd_buffer,
554 unsigned *dst,
555 struct radeon_winsys_bo **buffer_list,
556 const VkDescriptorBufferInfo *buffer_info)
557 {
558 RADV_FROM_HANDLE(radv_buffer, buffer, buffer_info->buffer);
559 uint64_t va = device->ws->buffer_get_va(buffer->bo);
560 uint32_t range = buffer_info->range;
561
562 if (buffer_info->range == VK_WHOLE_SIZE)
563 range = buffer->size - buffer_info->offset;
564
565 va += buffer_info->offset + buffer->offset;
566 dst[0] = va;
567 dst[1] = S_008F04_BASE_ADDRESS_HI(va >> 32);
568 dst[2] = range;
569 dst[3] = S_008F0C_DST_SEL_X(V_008F0C_SQ_SEL_X) |
570 S_008F0C_DST_SEL_Y(V_008F0C_SQ_SEL_Y) |
571 S_008F0C_DST_SEL_Z(V_008F0C_SQ_SEL_Z) |
572 S_008F0C_DST_SEL_W(V_008F0C_SQ_SEL_W) |
573 S_008F0C_NUM_FORMAT(V_008F0C_BUF_NUM_FORMAT_FLOAT) |
574 S_008F0C_DATA_FORMAT(V_008F0C_BUF_DATA_FORMAT_32);
575
576 if (cmd_buffer)
577 device->ws->cs_add_buffer(cmd_buffer->cs, buffer->bo, 7);
578 else
579 *buffer_list = buffer->bo;
580 }
581
582 static void write_dynamic_buffer_descriptor(struct radv_device *device,
583 struct radv_descriptor_range *range,
584 struct radeon_winsys_bo **buffer_list,
585 const VkDescriptorBufferInfo *buffer_info)
586 {
587 RADV_FROM_HANDLE(radv_buffer, buffer, buffer_info->buffer);
588 uint64_t va = device->ws->buffer_get_va(buffer->bo);
589 unsigned size = buffer_info->range;
590
591 if (buffer_info->range == VK_WHOLE_SIZE)
592 size = buffer->size - buffer_info->offset;
593
594 va += buffer_info->offset + buffer->offset;
595 range->va = va;
596 range->size = size;
597
598 *buffer_list = buffer->bo;
599 }
600
601 static void
602 write_image_descriptor(struct radv_device *device,
603 struct radv_cmd_buffer *cmd_buffer,
604 unsigned *dst,
605 struct radeon_winsys_bo **buffer_list,
606 const VkDescriptorImageInfo *image_info)
607 {
608 RADV_FROM_HANDLE(radv_image_view, iview, image_info->imageView);
609 memcpy(dst, iview->descriptor, 8 * 4);
610 memcpy(dst + 8, iview->fmask_descriptor, 8 * 4);
611
612 if (cmd_buffer)
613 device->ws->cs_add_buffer(cmd_buffer->cs, iview->bo, 7);
614 else
615 *buffer_list = iview->bo;
616 }
617
618 static void
619 write_combined_image_sampler_descriptor(struct radv_device *device,
620 struct radv_cmd_buffer *cmd_buffer,
621 unsigned *dst,
622 struct radeon_winsys_bo **buffer_list,
623 const VkDescriptorImageInfo *image_info,
624 bool has_sampler)
625 {
626 RADV_FROM_HANDLE(radv_sampler, sampler, image_info->sampler);
627
628 write_image_descriptor(device, cmd_buffer, dst, buffer_list, image_info);
629 /* copy over sampler state */
630 if (has_sampler)
631 memcpy(dst + 16, sampler->state, 16);
632 }
633
634 static void
635 write_sampler_descriptor(struct radv_device *device,
636 unsigned *dst,
637 const VkDescriptorImageInfo *image_info)
638 {
639 RADV_FROM_HANDLE(radv_sampler, sampler, image_info->sampler);
640
641 memcpy(dst, sampler->state, 16);
642 }
643
644 void radv_update_descriptor_sets(
645 struct radv_device* device,
646 struct radv_cmd_buffer* cmd_buffer,
647 VkDescriptorSet dstSetOverride,
648 uint32_t descriptorWriteCount,
649 const VkWriteDescriptorSet* pDescriptorWrites,
650 uint32_t descriptorCopyCount,
651 const VkCopyDescriptorSet* pDescriptorCopies)
652 {
653 uint32_t i, j;
654 for (i = 0; i < descriptorWriteCount; i++) {
655 const VkWriteDescriptorSet *writeset = &pDescriptorWrites[i];
656 RADV_FROM_HANDLE(radv_descriptor_set, set,
657 dstSetOverride ? dstSetOverride : writeset->dstSet);
658 const struct radv_descriptor_set_binding_layout *binding_layout =
659 set->layout->binding + writeset->dstBinding;
660 uint32_t *ptr = set->mapped_ptr;
661 struct radeon_winsys_bo **buffer_list = set->descriptors;
662 /* Immutable samplers are not copied into push descriptors when they are
663 * allocated, so if we are writing push descriptors we have to copy the
664 * immutable samplers into them now.
665 */
666 const bool copy_immutable_samplers = cmd_buffer &&
667 binding_layout->immutable_samplers_offset && !binding_layout->immutable_samplers_equal;
668 const uint32_t *samplers = radv_immutable_samplers(set->layout, binding_layout);
669
670 ptr += binding_layout->offset / 4;
671 ptr += binding_layout->size * writeset->dstArrayElement / 4;
672 buffer_list += binding_layout->buffer_offset;
673 buffer_list += writeset->dstArrayElement;
674 for (j = 0; j < writeset->descriptorCount; ++j) {
675 switch(writeset->descriptorType) {
676 case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
677 case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC: {
678 unsigned idx = writeset->dstArrayElement + j;
679 idx += binding_layout->dynamic_offset_offset;
680 assert(!(set->layout->flags & VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR));
681 write_dynamic_buffer_descriptor(device, set->dynamic_descriptors + idx,
682 buffer_list, writeset->pBufferInfo + j);
683 break;
684 }
685 case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
686 case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
687 write_buffer_descriptor(device, cmd_buffer, ptr, buffer_list,
688 writeset->pBufferInfo + j);
689 break;
690 case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:
691 case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
692 write_texel_buffer_descriptor(device, cmd_buffer, ptr, buffer_list,
693 writeset->pTexelBufferView[j]);
694 break;
695 case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
696 case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:
697 case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:
698 write_image_descriptor(device, cmd_buffer, ptr, buffer_list,
699 writeset->pImageInfo + j);
700 break;
701 case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
702 write_combined_image_sampler_descriptor(device, cmd_buffer, ptr, buffer_list,
703 writeset->pImageInfo + j,
704 !binding_layout->immutable_samplers_offset);
705 if (copy_immutable_samplers) {
706 const unsigned idx = writeset->dstArrayElement + j;
707 memcpy(ptr + 16, samplers + 4 * idx, 16);
708 }
709 break;
710 case VK_DESCRIPTOR_TYPE_SAMPLER:
711 if (!binding_layout->immutable_samplers_offset) {
712 write_sampler_descriptor(device, ptr,
713 writeset->pImageInfo + j);
714 } else if (copy_immutable_samplers) {
715 unsigned idx = writeset->dstArrayElement + j;
716 memcpy(ptr, samplers + 4 * idx, 16);
717 }
718 break;
719 default:
720 unreachable("unimplemented descriptor type");
721 break;
722 }
723 ptr += binding_layout->size / 4;
724 ++buffer_list;
725 }
726
727 }
728 if (descriptorCopyCount)
729 radv_finishme("copy descriptors");
730 }
731
732 void radv_UpdateDescriptorSets(
733 VkDevice _device,
734 uint32_t descriptorWriteCount,
735 const VkWriteDescriptorSet* pDescriptorWrites,
736 uint32_t descriptorCopyCount,
737 const VkCopyDescriptorSet* pDescriptorCopies)
738 {
739 RADV_FROM_HANDLE(radv_device, device, _device);
740
741 radv_update_descriptor_sets(device, NULL, VK_NULL_HANDLE, descriptorWriteCount, pDescriptorWrites,
742 descriptorCopyCount, pDescriptorCopies);
743 }
744
745 VkResult radv_CreateDescriptorUpdateTemplateKHR(VkDevice _device,
746 const VkDescriptorUpdateTemplateCreateInfoKHR *pCreateInfo,
747 const VkAllocationCallbacks *pAllocator,
748 VkDescriptorUpdateTemplateKHR *pDescriptorUpdateTemplate)
749 {
750 RADV_FROM_HANDLE(radv_device, device, _device);
751 RADV_FROM_HANDLE(radv_descriptor_set_layout, set_layout, pCreateInfo->descriptorSetLayout);
752 const uint32_t entry_count = pCreateInfo->descriptorUpdateEntryCount;
753 const size_t size = sizeof(struct radv_descriptor_update_template) +
754 sizeof(struct radv_descriptor_update_template_entry) * entry_count;
755 struct radv_descriptor_update_template *templ;
756 uint32_t i;
757
758 templ = vk_alloc2(&device->alloc, pAllocator, size, 8, VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
759 if (!templ)
760 return vk_error(VK_ERROR_OUT_OF_HOST_MEMORY);
761
762 templ->entry_count = entry_count;
763
764 for (i = 0; i < entry_count; i++) {
765 const VkDescriptorUpdateTemplateEntryKHR *entry = &pCreateInfo->pDescriptorUpdateEntries[i];
766 const struct radv_descriptor_set_binding_layout *binding_layout =
767 set_layout->binding + entry->dstBinding;
768 const uint32_t buffer_offset = binding_layout->buffer_offset + entry->dstArrayElement;
769 const uint32_t *immutable_samplers = NULL;
770 uint32_t dst_offset;
771 uint32_t dst_stride;
772
773 /* dst_offset is an offset into dynamic_descriptors when the descriptor
774 is dynamic, and an offset into mapped_ptr otherwise */
775 switch (entry->descriptorType) {
776 case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
777 case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:
778 assert(pCreateInfo->templateType == VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET_KHR);
779 dst_offset = binding_layout->dynamic_offset_offset + entry->dstArrayElement;
780 dst_stride = 0; /* Not used */
781 break;
782 default:
783 switch (entry->descriptorType) {
784 case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
785 case VK_DESCRIPTOR_TYPE_SAMPLER:
786 /* Immutable samplers are copied into push descriptors when they are pushed */
787 if (pCreateInfo->templateType == VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR &&
788 binding_layout->immutable_samplers_offset && !binding_layout->immutable_samplers_equal) {
789 immutable_samplers = radv_immutable_samplers(set_layout, binding_layout) + entry->dstArrayElement * 4;
790 }
791 break;
792 default:
793 break;
794 }
795 dst_offset = binding_layout->offset / 4 + binding_layout->size * entry->dstArrayElement / 4;
796 dst_stride = binding_layout->size / 4;
797 break;
798 }
799
800 templ->entry[i] = (struct radv_descriptor_update_template_entry) {
801 .descriptor_type = entry->descriptorType,
802 .descriptor_count = entry->descriptorCount,
803 .src_offset = entry->offset,
804 .src_stride = entry->stride,
805 .dst_offset = dst_offset,
806 .dst_stride = dst_stride,
807 .buffer_offset = buffer_offset,
808 .has_sampler = !binding_layout->immutable_samplers_offset,
809 .immutable_samplers = immutable_samplers
810 };
811 }
812
813 *pDescriptorUpdateTemplate = radv_descriptor_update_template_to_handle(templ);
814 return VK_SUCCESS;
815 }
816
817 void radv_DestroyDescriptorUpdateTemplateKHR(VkDevice _device,
818 VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate,
819 const VkAllocationCallbacks *pAllocator)
820 {
821 RADV_FROM_HANDLE(radv_device, device, _device);
822 RADV_FROM_HANDLE(radv_descriptor_update_template, templ, descriptorUpdateTemplate);
823
824 if (!templ)
825 return;
826
827 vk_free2(&device->alloc, pAllocator, templ);
828 }
829
830 void radv_update_descriptor_set_with_template(struct radv_device *device,
831 struct radv_cmd_buffer *cmd_buffer,
832 struct radv_descriptor_set *set,
833 VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate,
834 const void *pData)
835 {
836 RADV_FROM_HANDLE(radv_descriptor_update_template, templ, descriptorUpdateTemplate);
837 uint32_t i;
838
839 for (i = 0; i < templ->entry_count; ++i) {
840 struct radeon_winsys_bo **buffer_list = set->descriptors + templ->entry[i].buffer_offset;
841 uint32_t *pDst = set->mapped_ptr + templ->entry[i].dst_offset;
842 const uint8_t *pSrc = ((const uint8_t *) pData) + templ->entry[i].src_offset;
843 uint32_t j;
844
845 for (j = 0; j < templ->entry[i].descriptor_count; ++j) {
846 switch (templ->entry[i].descriptor_type) {
847 case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
848 case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC: {
849 const unsigned idx = templ->entry[i].dst_offset + j;
850 assert(!(set->layout->flags & VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR));
851 write_dynamic_buffer_descriptor(device, set->dynamic_descriptors + idx,
852 buffer_list, (struct VkDescriptorBufferInfo *) pSrc);
853 break;
854 }
855 case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
856 case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
857 write_buffer_descriptor(device, cmd_buffer, pDst, buffer_list,
858 (struct VkDescriptorBufferInfo *) pSrc);
859 break;
860 case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:
861 case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
862 write_texel_buffer_descriptor(device, cmd_buffer, pDst, buffer_list,
863 *(VkBufferView *) pSrc);
864 break;
865 case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
866 case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:
867 case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:
868 write_image_descriptor(device, cmd_buffer, pDst, buffer_list,
869 (struct VkDescriptorImageInfo *) pSrc);
870 break;
871 case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
872 write_combined_image_sampler_descriptor(device, cmd_buffer, pDst, buffer_list,
873 (struct VkDescriptorImageInfo *) pSrc,
874 templ->entry[i].has_sampler);
875 if (templ->entry[i].immutable_samplers)
876 memcpy(pDst + 16, templ->entry[i].immutable_samplers + 4 * j, 16);
877 break;
878 case VK_DESCRIPTOR_TYPE_SAMPLER:
879 if (templ->entry[i].has_sampler)
880 write_sampler_descriptor(device, pDst,
881 (struct VkDescriptorImageInfo *) pSrc);
882 else if (templ->entry[i].immutable_samplers)
883 memcpy(pDst, templ->entry[i].immutable_samplers + 4 * j, 16);
884 break;
885 default:
886 unreachable("unimplemented descriptor type");
887 break;
888 }
889 pSrc += templ->entry[i].src_stride;
890 pDst += templ->entry[i].dst_stride;
891 ++buffer_list;
892 }
893 }
894 }
895
896 void radv_UpdateDescriptorSetWithTemplateKHR(VkDevice _device,
897 VkDescriptorSet descriptorSet,
898 VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate,
899 const void *pData)
900 {
901 RADV_FROM_HANDLE(radv_device, device, _device);
902 RADV_FROM_HANDLE(radv_descriptor_set, set, descriptorSet);
903
904 radv_update_descriptor_set_with_template(device, NULL, set, descriptorUpdateTemplate, pData);
905 }