fdo-mirrors/mesa
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/mesa/mesa.git synced 2026-05-29 18:28:14 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions 2

dzn: Remove device pointers from descriptor heaps

Browse source 
A future change is going to add descriptor heaps *to* the dzn_device,
and having 3x ID3D12Device pointers in a single object just seems
wrong. All of the callers already had a device, so just pass it
along where needed.

Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/21913>
This commit is contained in:
Jesse Natalie 2023-02-28 13:54:18 -08:00 • committed by Marge Bot
parent 79ef6e4e8f
commit 599abf5b1a
4 changed files with 110 additions and 87 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

8
src/microsoft/vulkan/dzn_cmd_buffer.c
View file

@ -2664,7 +2664,7 @@ dzn_cmd_buffer_blit_prepare_src_view(struct dzn_cmd_buffer *cmdbuf,
struct dzn_image_view iview;
dzn_image_view_init(device, &iview, &iview_info);
dzn_descriptor_heap_write_image_view_desc(heap, heap_slot, false, false, &iview);
dzn_descriptor_heap_write_image_view_desc(device, heap, heap_slot, false, false, &iview);
dzn_image_view_finish(&iview);
D3D12_GPU_DESCRIPTOR_HANDLE handle =
@ -3083,7 +3083,7 @@ dzn_cmd_buffer_update_heaps(struct dzn_cmd_buffer *cmdbuf, uint32_t bindpoint)
uint32_t set_desc_count = pipeline->sets[s].range_desc_count[type];
if (set_desc_count) {
mtx_lock(&set->pool->defragment_lock);
dzn_descriptor_heap_copy(dst_heap, dst_heap_offset + set_heap_offset,
dzn_descriptor_heap_copy(device, dst_heap, dst_heap_offset + set_heap_offset,
&set->pool->heaps[type], set->heap_offsets[type],
set_desc_count);
mtx_unlock(&set->pool->defragment_lock);
@ -3097,13 +3097,13 @@ dzn_cmd_buffer_update_heaps(struct dzn_cmd_buffer *cmdbuf, uint32_t bindpoint)
struct dzn_buffer_desc bdesc = set->dynamic_buffers[o];
bdesc.offset += desc_state->sets[s].dynamic_offsets[o];
dzn_descriptor_heap_write_buffer_desc(dst_heap,
dzn_descriptor_heap_write_buffer_desc(device, dst_heap,
dst_heap_offset + set_heap_offset + desc_heap_offset,
false, &bdesc);
if (pipeline->sets[s].dynamic_buffer_heap_offsets[o].uav != ~0) {
desc_heap_offset = pipeline->sets[s].dynamic_buffer_heap_offsets[o].uav;
dzn_descriptor_heap_write_buffer_desc(dst_heap,
dzn_descriptor_heap_write_buffer_desc(device, dst_heap,
dst_heap_offset + set_heap_offset + desc_heap_offset,
true, &bdesc);
}

164
src/microsoft/vulkan/dzn_descriptor_set.c
View file

@ -823,12 +823,6 @@ dzn_descriptor_heap_finish(struct dzn_descriptor_heap *heap)
{
if (heap->heap)
ID3D12DescriptorHeap_Release(heap->heap);
if (heap->dev)
ID3D12Device_Release(heap->dev);
if (heap->dev11)
ID3D12Device11_Release(heap->dev11);
}
static VkResult
@ -838,20 +832,10 @@ dzn_descriptor_heap_init(struct dzn_descriptor_heap *heap,
uint32_t desc_count,
bool shader_visible)
{
struct dzn_physical_device *pdev =
container_of(device->vk.physical, struct dzn_physical_device, vk);
heap->desc_count = desc_count;
heap->type = type;
heap->dev = device->dev;
heap->desc_sz = ID3D12Device1_GetDescriptorHandleIncrementSize(device->dev, type);
if (pdev->options14.AdvancedTextureOpsSupported &&
FAILED(IUnknown_QueryInterface(heap->dev, &IID_ID3D12Device11, (void **)&heap->dev11)))
return vk_error(device,
shader_visible ?
VK_ERROR_OUT_OF_DEVICE_MEMORY : VK_ERROR_OUT_OF_HOST_MEMORY);
D3D12_DESCRIPTOR_HEAP_DESC desc = {
.Type = type,
.NumDescriptors = desc_count,
@ -875,8 +859,6 @@ dzn_descriptor_heap_init(struct dzn_descriptor_heap *heap,
heap->gpu_base = gpu_handle.ptr;
}
ID3D12Device1_AddRef(heap->dev);
return VK_SUCCESS;
}
@ -897,20 +879,23 @@ dzn_descriptor_heap_get_gpu_handle(const struct dzn_descriptor_heap *heap, uint3
}
static void
dzn_descriptor_heap_write_sampler_desc(struct dzn_descriptor_heap *heap,
dzn_descriptor_heap_write_sampler_desc(struct dzn_device *device,
struct dzn_descriptor_heap *heap,
uint32_t desc_offset,
const struct dzn_sampler *sampler)
{
if (heap->dev11)
ID3D12Device11_CreateSampler2(heap->dev11, &sampler->desc,
struct dzn_physical_device *pdev = container_of(device->vk.physical, struct dzn_physical_device, vk);
if (device->dev11 && pdev->options14.AdvancedTextureOpsSupported)
ID3D12Device11_CreateSampler2(device->dev11, &sampler->desc,
dzn_descriptor_heap_get_cpu_handle(heap, desc_offset));
else
ID3D12Device1_CreateSampler(heap->dev, (D3D12_SAMPLER_DESC *)&sampler->desc,
ID3D12Device1_CreateSampler(device->dev, (D3D12_SAMPLER_DESC *)&sampler->desc,
dzn_descriptor_heap_get_cpu_handle(heap, desc_offset));
}
void
dzn_descriptor_heap_write_image_view_desc(struct dzn_descriptor_heap *heap,
dzn_descriptor_heap_write_image_view_desc(struct dzn_device *device,
struct dzn_descriptor_heap *heap,
uint32_t desc_offset,
bool writeable, bool cube_as_2darray,
const struct dzn_image_view *iview)
@ -920,7 +905,7 @@ dzn_descriptor_heap_write_image_view_desc(struct dzn_descriptor_heap *heap,
struct dzn_image *image = container_of(iview->vk.image, struct dzn_image, vk);
if (writeable) {
ID3D12Device1_CreateUnorderedAccessView(heap->dev, image->res, NULL, &iview->uav_desc, view_handle);
ID3D12Device1_CreateUnorderedAccessView(device->dev, image->res, NULL, &iview->uav_desc, view_handle);
} else if (cube_as_2darray &&
(iview->srv_desc.ViewDimension == D3D12_SRV_DIMENSION_TEXTURECUBEARRAY ||
iview->srv_desc.ViewDimension == D3D12_SRV_DIMENSION_TEXTURECUBE)) {
@ -946,14 +931,15 @@ dzn_descriptor_heap_write_image_view_desc(struct dzn_descriptor_heap *heap,
srv_desc.Texture2DArray.ArraySize = 6;
}
ID3D12Device1_CreateShaderResourceView(heap->dev, image->res, &srv_desc, view_handle);
ID3D12Device1_CreateShaderResourceView(device->dev, image->res, &srv_desc, view_handle);
} else {
ID3D12Device1_CreateShaderResourceView(heap->dev, image->res, &iview->srv_desc, view_handle);
ID3D12Device1_CreateShaderResourceView(device->dev, image->res, &iview->srv_desc, view_handle);
}
}
static void
dzn_descriptor_heap_write_buffer_view_desc(struct dzn_descriptor_heap *heap,
dzn_descriptor_heap_write_buffer_view_desc(struct dzn_device *device,
struct dzn_descriptor_heap *heap,
uint32_t desc_offset,
bool writeable,
const struct dzn_buffer_view *bview)
@ -962,13 +948,14 @@ dzn_descriptor_heap_write_buffer_view_desc(struct dzn_descriptor_heap *heap,
dzn_descriptor_heap_get_cpu_handle(heap, desc_offset);
if (writeable)
ID3D12Device1_CreateUnorderedAccessView(heap->dev, bview->buffer->res, NULL, &bview->uav_desc, view_handle);
ID3D12Device1_CreateUnorderedAccessView(device->dev, bview->buffer->res, NULL, &bview->uav_desc, view_handle);
else
ID3D12Device1_CreateShaderResourceView(heap->dev, bview->buffer->res, &bview->srv_desc, view_handle);
ID3D12Device1_CreateShaderResourceView(device->dev, bview->buffer->res, &bview->srv_desc, view_handle);
}
void
dzn_descriptor_heap_write_buffer_desc(struct dzn_descriptor_heap *heap,
dzn_descriptor_heap_write_buffer_desc(struct dzn_device *device,
struct dzn_descriptor_heap *heap,
uint32_t desc_offset,
bool writeable,
const struct dzn_buffer_desc *info)
@ -988,7 +975,7 @@ dzn_descriptor_heap_write_buffer_desc(struct dzn_descriptor_heap *heap,
.BufferLocation = info->buffer->gpuva + info->offset,
.SizeInBytes = ALIGN_POT(size, 256),
};
ID3D12Device1_CreateConstantBufferView(heap->dev, &cbv_desc, view_handle);
ID3D12Device1_CreateConstantBufferView(device->dev, &cbv_desc, view_handle);
} else if (writeable) {
D3D12_UNORDERED_ACCESS_VIEW_DESC uav_desc = {
.Format = DXGI_FORMAT_R32_TYPELESS,
@ -999,7 +986,7 @@ dzn_descriptor_heap_write_buffer_desc(struct dzn_descriptor_heap *heap,
.Flags = D3D12_BUFFER_UAV_FLAG_RAW,
},
};
ID3D12Device1_CreateUnorderedAccessView(heap->dev, info->buffer->res, NULL, &uav_desc, view_handle);
ID3D12Device1_CreateUnorderedAccessView(device->dev, info->buffer->res, NULL, &uav_desc, view_handle);
} else {
D3D12_SHADER_RESOURCE_VIEW_DESC srv_desc = {
.Format = DXGI_FORMAT_R32_TYPELESS,
@ -1011,12 +998,13 @@ dzn_descriptor_heap_write_buffer_desc(struct dzn_descriptor_heap *heap,
.Flags = D3D12_BUFFER_SRV_FLAG_RAW,
},
};
ID3D12Device1_CreateShaderResourceView(heap->dev, info->buffer->res, &srv_desc, view_handle);
ID3D12Device1_CreateShaderResourceView(device->dev, info->buffer->res, &srv_desc, view_handle);
}
}
void
dzn_descriptor_heap_copy(struct dzn_descriptor_heap *dst_heap,
dzn_descriptor_heap_copy(struct dzn_device *device,
struct dzn_descriptor_heap *dst_heap,
uint32_t dst_offset,
const struct dzn_descriptor_heap *src_heap,
uint32_t src_offset,
@ -1027,7 +1015,7 @@ dzn_descriptor_heap_copy(struct dzn_descriptor_heap *dst_heap,
D3D12_CPU_DESCRIPTOR_HANDLE src_handle =
dzn_descriptor_heap_get_cpu_handle(src_heap, src_offset);
ID3D12Device1_CopyDescriptorsSimple(dst_heap->dev, desc_count,
ID3D12Device1_CopyDescriptorsSimple(device->dev, desc_count,
dst_handle,
src_handle,
dst_heap->type);
@ -1129,7 +1117,8 @@ dzn_descriptor_set_ptr_get_heap_offset(const struct dzn_descriptor_set_layout *l
}
static void
dzn_descriptor_set_write_sampler_desc(struct dzn_descriptor_set *set,
dzn_descriptor_set_write_sampler_desc(struct dzn_device *device,
struct dzn_descriptor_set *set,
uint32_t heap_offset,
const struct dzn_sampler *sampler)
{
@ -1139,14 +1128,16 @@ dzn_descriptor_set_write_sampler_desc(struct dzn_descriptor_set *set,
D3D12_DESCRIPTOR_HEAP_TYPE type = D3D12_DESCRIPTOR_HEAP_TYPE_SAMPLER;
mtx_lock(&set->pool->defragment_lock);
dzn_descriptor_heap_write_sampler_desc(&set->pool->heaps[type],
dzn_descriptor_heap_write_sampler_desc(device,
&set->pool->heaps[type],
set->heap_offsets[type] + heap_offset,
sampler);
mtx_unlock(&set->pool->defragment_lock);
}
static void
dzn_descriptor_set_ptr_write_sampler_desc(struct dzn_descriptor_set *set,
dzn_descriptor_set_ptr_write_sampler_desc(struct dzn_device *device,
struct dzn_descriptor_set *set,
const struct dzn_descriptor_set_ptr *ptr,
const struct dzn_sampler *sampler)
{
@ -1154,7 +1145,7 @@ dzn_descriptor_set_ptr_write_sampler_desc(struct dzn_descriptor_set *set,
uint32_t heap_offset =
dzn_descriptor_set_ptr_get_heap_offset(set->layout, type, ptr, false);
dzn_descriptor_set_write_sampler_desc(set, heap_offset, sampler);
dzn_descriptor_set_write_sampler_desc(device, set, heap_offset, sampler);
}
static uint32_t
@ -1206,7 +1197,8 @@ dzn_descriptor_set_ptr_get_vk_type(const struct dzn_descriptor_set_layout *layou
}
static void
dzn_descriptor_set_write_image_view_desc(struct dzn_descriptor_set *set,
dzn_descriptor_set_write_image_view_desc(struct dzn_device *device,
struct dzn_descriptor_set *set,
uint32_t heap_offset,
uint32_t alt_heap_offset,
bool cube_as_2darray,
@ -1218,13 +1210,15 @@ dzn_descriptor_set_write_image_view_desc(struct dzn_descriptor_set *set,
return;
mtx_lock(&set->pool->defragment_lock);
dzn_descriptor_heap_write_image_view_desc(&set->pool->heaps[type],
dzn_descriptor_heap_write_image_view_desc(device,
&set->pool->heaps[type],
set->heap_offsets[type] + heap_offset,
false, cube_as_2darray,
iview);
if (alt_heap_offset != ~0) {
dzn_descriptor_heap_write_image_view_desc(&set->pool->heaps[type],
dzn_descriptor_heap_write_image_view_desc(device,
&set->pool->heaps[type],
set->heap_offsets[type] + alt_heap_offset,
true, cube_as_2darray,
iview);
@ -1233,7 +1227,8 @@ dzn_descriptor_set_write_image_view_desc(struct dzn_descriptor_set *set,
}
static void
dzn_descriptor_set_ptr_write_image_view_desc(struct dzn_descriptor_set *set,
dzn_descriptor_set_ptr_write_image_view_desc(struct dzn_device *device,
struct dzn_descriptor_set *set,
const struct dzn_descriptor_set_ptr *ptr,
bool cube_as_2darray,
const struct dzn_image_view *iview)
@ -1244,12 +1239,13 @@ dzn_descriptor_set_ptr_write_image_view_desc(struct dzn_descriptor_set *set,
uint32_t alt_heap_offset =
dzn_descriptor_set_ptr_get_heap_offset(set->layout, type, ptr, true);
dzn_descriptor_set_write_image_view_desc(set, heap_offset, alt_heap_offset,
dzn_descriptor_set_write_image_view_desc(device, set, heap_offset, alt_heap_offset,
cube_as_2darray, iview);
}
static void
dzn_descriptor_set_write_buffer_view_desc(struct dzn_descriptor_set *set,
dzn_descriptor_set_write_buffer_view_desc(struct dzn_device *device,
struct dzn_descriptor_set *set,
uint32_t heap_offset,
uint32_t alt_heap_offset,
const struct dzn_buffer_view *bview)
@ -1260,13 +1256,15 @@ dzn_descriptor_set_write_buffer_view_desc(struct dzn_descriptor_set *set,
D3D12_DESCRIPTOR_HEAP_TYPE type = D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV;
mtx_lock(&set->pool->defragment_lock);
dzn_descriptor_heap_write_buffer_view_desc(&set->pool->heaps[type],
dzn_descriptor_heap_write_buffer_view_desc(device,
&set->pool->heaps[type],
set->heap_offsets[type] +
heap_offset,
false, bview);
if (alt_heap_offset != ~0) {
dzn_descriptor_heap_write_buffer_view_desc(&set->pool->heaps[type],
dzn_descriptor_heap_write_buffer_view_desc(device,
&set->pool->heaps[type],
set->heap_offsets[type] +
alt_heap_offset,
true, bview);
@ -1275,7 +1273,8 @@ dzn_descriptor_set_write_buffer_view_desc(struct dzn_descriptor_set *set,
}
static void
dzn_descriptor_set_ptr_write_buffer_view_desc(struct dzn_descriptor_set *set,
dzn_descriptor_set_ptr_write_buffer_view_desc(struct dzn_device *device,
struct dzn_descriptor_set *set,
const struct dzn_descriptor_set_ptr *ptr,
const struct dzn_buffer_view *bview)
{
@ -1285,11 +1284,12 @@ dzn_descriptor_set_ptr_write_buffer_view_desc(struct dzn_descriptor_set *set,
uint32_t alt_heap_offset =
dzn_descriptor_set_ptr_get_heap_offset(set->layout, type, ptr, true);
dzn_descriptor_set_write_buffer_view_desc(set, heap_offset, alt_heap_offset, bview);
dzn_descriptor_set_write_buffer_view_desc(device, set, heap_offset, alt_heap_offset, bview);
}
static void
dzn_descriptor_set_write_buffer_desc(struct dzn_descriptor_set *set,
dzn_descriptor_set_write_buffer_desc(struct dzn_device *device,
struct dzn_descriptor_set *set,
uint32_t heap_offset,
uint32_t alt_heap_offset,
const struct dzn_buffer_desc *bdesc)
@ -1299,12 +1299,12 @@ dzn_descriptor_set_write_buffer_desc(struct dzn_descriptor_set *set,
return;
mtx_lock(&set->pool->defragment_lock);
dzn_descriptor_heap_write_buffer_desc(&set->pool->heaps[type],
dzn_descriptor_heap_write_buffer_desc(device, &set->pool->heaps[type],
set->heap_offsets[type] + heap_offset,
false, bdesc);
if (alt_heap_offset != ~0) {
dzn_descriptor_heap_write_buffer_desc(&set->pool->heaps[type],
dzn_descriptor_heap_write_buffer_desc(device, &set->pool->heaps[type],
set->heap_offsets[type] +
alt_heap_offset,
true, bdesc);
@ -1313,7 +1313,8 @@ dzn_descriptor_set_write_buffer_desc(struct dzn_descriptor_set *set,
}
static void
dzn_descriptor_set_ptr_write_buffer_desc(struct dzn_descriptor_set *set,
dzn_descriptor_set_ptr_write_buffer_desc(struct dzn_device *device,
struct dzn_descriptor_set *set,
const struct dzn_descriptor_set_ptr *ptr,
const struct dzn_buffer_desc *bdesc)
{
@ -1323,7 +1324,7 @@ dzn_descriptor_set_ptr_write_buffer_desc(struct dzn_descriptor_set *set,
uint32_t alt_heap_offset =
dzn_descriptor_set_ptr_get_heap_offset(set->layout, type, ptr, true);
dzn_descriptor_set_write_buffer_desc(set, heap_offset, alt_heap_offset, bdesc);
dzn_descriptor_set_write_buffer_desc(device, set, heap_offset, alt_heap_offset, bdesc);
}
static void
@ -1360,7 +1361,7 @@ dzn_descriptor_set_init(struct dzn_descriptor_set *set,
for (dzn_descriptor_set_ptr_init(set->layout, &ptr, b, 0);
dzn_descriptor_set_ptr_is_valid(&ptr);
dzn_descriptor_set_ptr_move(set->layout, &ptr, 1)) {
dzn_descriptor_set_ptr_write_sampler_desc(set, &ptr, *sampler);
dzn_descriptor_set_ptr_write_sampler_desc(device, set, &ptr, *sampler);
sampler++;
}
}
@ -1463,10 +1464,10 @@ dzn_descriptor_pool_create(struct dzn_device *device,
}
static VkResult
dzn_descriptor_pool_defragment_heap(struct dzn_descriptor_pool *pool,
dzn_descriptor_pool_defragment_heap(struct dzn_device *device,
struct dzn_descriptor_pool *pool,
D3D12_DESCRIPTOR_HEAP_TYPE type)
{
struct dzn_device *device = container_of(pool->base.device, struct dzn_device, vk);
struct dzn_descriptor_heap new_heap;
VkResult result =
@ -1482,7 +1483,8 @@ dzn_descriptor_pool_defragment_heap(struct dzn_descriptor_pool *pool,
if (!pool->sets[s].layout)
continue;
dzn_descriptor_heap_copy(&new_heap, heap_offset,
dzn_descriptor_heap_copy(device,
&new_heap, heap_offset,
&pool->heaps[type],
pool->sets[s].heap_offsets[type],
pool->sets[s].heap_sizes[type]);
@ -1660,7 +1662,7 @@ dzn_AllocateDescriptorSets(VkDevice dev,
}
if (pool->free_offset[type] + layout->range_desc_count[type] > pool->desc_count[type]) {
result = dzn_descriptor_pool_defragment_heap(pool, type);
result = dzn_descriptor_pool_defragment_heap(device, pool, type);
if (result != VK_SUCCESS) {
dzn_FreeDescriptorSets(dev, pAllocateInfo->descriptorPool, i, pDescriptorSets);
return vk_error(device, VK_ERROR_FRAGMENTED_POOL);
@ -1724,7 +1726,8 @@ dzn_FreeDescriptorSets(VkDevice dev,
}
static void
dzn_descriptor_set_write(const VkWriteDescriptorSet *pDescriptorWrite)
dzn_descriptor_set_write(struct dzn_device *device,
const VkWriteDescriptorSet *pDescriptorWrite)
{
VK_FROM_HANDLE(dzn_descriptor_set, set, pDescriptorWrite->dstSet);
@ -1748,7 +1751,7 @@ dzn_descriptor_set_write(const VkWriteDescriptorSet *pDescriptorWrite)
VK_FROM_HANDLE(dzn_sampler, sampler, pImageInfo->sampler);
if (sampler)
dzn_descriptor_set_ptr_write_sampler_desc(set, &ptr, sampler);
dzn_descriptor_set_ptr_write_sampler_desc(device, set, &ptr, sampler);
d++;
}
@ -1762,10 +1765,10 @@ dzn_descriptor_set_write(const VkWriteDescriptorSet *pDescriptorWrite)
VK_FROM_HANDLE(dzn_image_view, iview, pImageInfo->imageView);
if (sampler)
dzn_descriptor_set_ptr_write_sampler_desc(set, &ptr, sampler);
dzn_descriptor_set_ptr_write_sampler_desc(device, set, &ptr, sampler);
if (iview)
dzn_descriptor_set_ptr_write_image_view_desc(set, &ptr, cube_as_2darray, iview);
dzn_descriptor_set_ptr_write_image_view_desc(device, set, &ptr, cube_as_2darray, iview);
d++;
}
@ -1781,7 +1784,7 @@ dzn_descriptor_set_write(const VkWriteDescriptorSet *pDescriptorWrite)
VK_FROM_HANDLE(dzn_image_view, iview, pImageInfo->imageView);
if (iview)
dzn_descriptor_set_ptr_write_image_view_desc(set, &ptr, cube_as_2darray, iview);
dzn_descriptor_set_ptr_write_image_view_desc(device, set, &ptr, cube_as_2darray, iview);
d++;
}
@ -1799,7 +1802,7 @@ dzn_descriptor_set_write(const VkWriteDescriptorSet *pDescriptorWrite)
};
if (desc.buffer)
dzn_descriptor_set_ptr_write_buffer_desc(set, &ptr, &desc);
dzn_descriptor_set_ptr_write_buffer_desc(device, set, &ptr, &desc);
d++;
}
@ -1832,7 +1835,7 @@ dzn_descriptor_set_write(const VkWriteDescriptorSet *pDescriptorWrite)
VK_FROM_HANDLE(dzn_buffer_view, bview, pDescriptorWrite->pTexelBufferView[d]);
if (bview)
dzn_descriptor_set_ptr_write_buffer_view_desc(set, &ptr, bview);
dzn_descriptor_set_ptr_write_buffer_view_desc(device, set, &ptr, bview);
d++;
}
@ -1847,7 +1850,8 @@ dzn_descriptor_set_write(const VkWriteDescriptorSet *pDescriptorWrite)
}
static void
dzn_descriptor_set_copy(const VkCopyDescriptorSet *pDescriptorCopy)
dzn_descriptor_set_copy(struct dzn_device *device,
const VkCopyDescriptorSet *pDescriptorCopy)
{
VK_FROM_HANDLE(dzn_descriptor_set, src_set, pDescriptorCopy->srcSet);
VK_FROM_HANDLE(dzn_descriptor_set, dst_set, pDescriptorCopy->dstSet);
@ -1899,7 +1903,8 @@ dzn_descriptor_set_copy(const VkCopyDescriptorSet *pDescriptorCopy)
mtx_lock(&src_set->pool->defragment_lock);
mtx_lock(&dst_set->pool->defragment_lock);
dzn_descriptor_heap_copy(&dst_set->pool->heaps[type],
dzn_descriptor_heap_copy(device,
&dst_set->pool->heaps[type],
dst_set->heap_offsets[type] + dst_heap_offset,
&src_set->pool->heaps[type],
src_set->heap_offsets[type] + src_heap_offset,
@ -1912,7 +1917,8 @@ dzn_descriptor_set_copy(const VkCopyDescriptorSet *pDescriptorCopy)
dzn_descriptor_set_ptr_get_heap_offset(dst_set->layout, type, &dst_ptr, true);
assert(src_heap_offset != ~0);
assert(dst_heap_offset != ~0);
dzn_descriptor_heap_copy(&dst_set->pool->heaps[type],
dzn_descriptor_heap_copy(device,
&dst_set->pool->heaps[type],
dst_set->heap_offsets[type] + dst_heap_offset,
&src_set->pool->heaps[type],
src_set->heap_offsets[type] + src_heap_offset,
@ -1938,11 +1944,12 @@ dzn_UpdateDescriptorSets(VkDevice _device,
uint32_t descriptorCopyCount,
const VkCopyDescriptorSet *pDescriptorCopies)
{
VK_FROM_HANDLE(dzn_device, device, _device);
for (unsigned i = 0; i < descriptorWriteCount; i++)
dzn_descriptor_set_write(&pDescriptorWrites[i]);
dzn_descriptor_set_write(device, &pDescriptorWrites[i]);
for (unsigned i = 0; i < descriptorCopyCount; i++)
dzn_descriptor_set_copy(&pDescriptorCopies[i]);
dzn_descriptor_set_copy(device, &pDescriptorCopies[i]);
}
static void
@ -2092,11 +2099,12 @@ dzn_descriptor_update_template_get_desc_data(const struct dzn_descriptor_update_
}
VKAPI_ATTR void VKAPI_CALL
dzn_UpdateDescriptorSetWithTemplate(VkDevice device,
dzn_UpdateDescriptorSetWithTemplate(VkDevice _device,
VkDescriptorSet descriptorSet,
VkDescriptorUpdateTemplate descriptorUpdateTemplate,
const void *pData)
{
VK_FROM_HANDLE(dzn_device, device, _device);
VK_FROM_HANDLE(dzn_descriptor_set, set, descriptorSet);
VK_FROM_HANDLE(dzn_descriptor_update_template, templ, descriptorUpdateTemplate);
@ -2113,7 +2121,7 @@ dzn_UpdateDescriptorSetWithTemplate(VkDevice device,
VK_FROM_HANDLE(dzn_sampler, sampler, info->sampler);
if (sampler)
dzn_descriptor_set_write_sampler_desc(set, entry->heap_offsets.sampler + d, sampler);
dzn_descriptor_set_write_sampler_desc(device, set, entry->heap_offsets.sampler + d, sampler);
}
break;
@ -2125,10 +2133,10 @@ dzn_UpdateDescriptorSetWithTemplate(VkDevice device,
VK_FROM_HANDLE(dzn_image_view, iview, info->imageView);
if (sampler)
dzn_descriptor_set_write_sampler_desc(set, entry->heap_offsets.sampler + d, sampler);
dzn_descriptor_set_write_sampler_desc(device, set, entry->heap_offsets.sampler + d, sampler);
if (iview)
dzn_descriptor_set_write_image_view_desc(set, entry->heap_offsets.cbv_srv_uav + d, ~0, cube_as_2darray, iview);
dzn_descriptor_set_write_image_view_desc(device, set, entry->heap_offsets.cbv_srv_uav + d, ~0, cube_as_2darray, iview);
}
break;
@ -2145,7 +2153,7 @@ dzn_UpdateDescriptorSetWithTemplate(VkDevice device,
VK_FROM_HANDLE(dzn_image_view, iview, info->imageView);
if (iview)
dzn_descriptor_set_write_image_view_desc(set, srv_heap_offset, uav_heap_offset, cube_as_2darray, iview);
dzn_descriptor_set_write_image_view_desc(device, set, srv_heap_offset, uav_heap_offset, cube_as_2darray, iview);
}
break;
case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
@ -2165,7 +2173,7 @@ dzn_UpdateDescriptorSetWithTemplate(VkDevice device,
};
if (desc.buffer)
dzn_descriptor_set_write_buffer_desc(set, cbv_srv_heap_offset, uav_heap_offset, &desc);
dzn_descriptor_set_write_buffer_desc(device, set, cbv_srv_heap_offset, uav_heap_offset, &desc);
}
break;
@ -2199,7 +2207,7 @@ dzn_UpdateDescriptorSetWithTemplate(VkDevice device,
entry->heap_offsets.extra_uav + d : ~0;
if (bview)
dzn_descriptor_set_write_buffer_view_desc(set, srv_heap_offset, uav_heap_offset, bview);
dzn_descriptor_set_write_buffer_view_desc(device, set, srv_heap_offset, uav_heap_offset, bview);
}
break;

12
src/microsoft/vulkan/dzn_device.c
View file

@ -159,6 +159,9 @@ dzn_physical_device_destroy(struct vk_physical_device *physical)
if (pdev->dev10)
ID3D12Device1_Release(pdev->dev10);
if (pdev->dev11)
ID3D12Device1_Release(pdev->dev11);
if (pdev->adapter)
IUnknown_Release(pdev->adapter);
@ -633,6 +636,8 @@ dzn_physical_device_get_d3d12_dev(struct dzn_physical_device *pdev)
if (FAILED(ID3D12Device1_QueryInterface(pdev->dev, &IID_ID3D12Device10, (void **)&pdev->dev10)))
pdev->dev10 = NULL;
if (FAILED(ID3D12Device1_QueryInterface(pdev->dev, &IID_ID3D12Device11, (void **)&pdev->dev11)))
pdev->dev11 = NULL;
dzn_physical_device_cache_caps(pdev);
dzn_physical_device_init_memory(pdev);
dzn_physical_device_init_uuids(pdev);
@ -2172,6 +2177,9 @@ dzn_device_destroy(struct dzn_device *device, const VkAllocationCallbacks *pAllo
if (device->dev10)
ID3D12Device1_Release(device->dev10);
if (device->dev11)
ID3D12Device1_Release(device->dev11);
vk_device_finish(&device->vk);
vk_free2(&instance->vk.alloc, pAllocator, device);
}
@ -2267,6 +2275,10 @@ dzn_device_create(struct dzn_physical_device *pdev,
device->dev10 = pdev->dev10;
ID3D12Device1_AddRef(device->dev10);
}
if (pdev->dev11) {
device->dev11 = pdev->dev11;
ID3D12Device1_AddRef(device->dev11);
}
ID3D12InfoQueue *info_queue;
if (SUCCEEDED(ID3D12Device1_QueryInterface(device->dev,

13
src/microsoft/vulkan/dzn_private.h
View file

@ -201,6 +201,7 @@ struct dzn_physical_device {
mtx_t dev_lock;
ID3D12Device4 *dev;
ID3D12Device10 *dev10;
ID3D12Device11 *dev11;
D3D_FEATURE_LEVEL feature_level;
D3D_SHADER_MODEL shader_model;
D3D_ROOT_SIGNATURE_VERSION root_sig_version;
@ -262,6 +263,7 @@ struct dzn_device {
ID3D12Device4 *dev;
ID3D12Device10 *dev10;
ID3D12Device11 *dev11;
ID3D12DeviceConfiguration *dev_config;
struct dzn_meta_indirect_draw indirect_draws[DZN_NUM_INDIRECT_DRAW_TYPES];
@ -379,8 +381,6 @@ struct dzn_buffer_desc {
#define MAX_DESCS_PER_CBV_SRV_UAV_HEAP 1000000u
struct dzn_descriptor_heap {
ID3D12Device4 *dev;
ID3D12Device11 *dev11;
ID3D12DescriptorHeap *heap;
D3D12_DESCRIPTOR_HEAP_TYPE type;
SIZE_T cpu_base;
@ -396,20 +396,23 @@ D3D12_GPU_DESCRIPTOR_HANDLE
dzn_descriptor_heap_get_gpu_handle(const struct dzn_descriptor_heap *heap, uint32_t slot);
void
dzn_descriptor_heap_write_image_view_desc(struct dzn_descriptor_heap *heap,
dzn_descriptor_heap_write_image_view_desc(struct dzn_device *device,
struct dzn_descriptor_heap *heap,
uint32_t heap_offset,
bool writeable,
bool cube_as_2darray,
const struct dzn_image_view *iview);
void
dzn_descriptor_heap_write_buffer_desc(struct dzn_descriptor_heap *heap,
dzn_descriptor_heap_write_buffer_desc(struct dzn_device *device,
struct dzn_descriptor_heap *heap,
uint32_t heap_offset,
bool writeable,
const struct dzn_buffer_desc *bdesc);
void
dzn_descriptor_heap_copy(struct dzn_descriptor_heap *dst_heap, uint32_t dst_heap_offset,
dzn_descriptor_heap_copy(struct dzn_device *device,
struct dzn_descriptor_heap *dst_heap, uint32_t dst_heap_offset,
const struct dzn_descriptor_heap *src_heap, uint32_t src_heap_offset,
uint32_t desc_count);