radv: use the base object struct types

[mesa.git] / src / amd / vulkan / radv_descriptor_set.c

diff --git a/src/amd/vulkan/radv_descriptor_set.c b/src/amd/vulkan/radv_descriptor_set.c
index dff774ace69c4a16f1d902457e30d7ec23e2fb68..8d1343d2d8bb6ec81638d0913f312d451cb9186a 100644 (file)
--- a/src/amd/vulkan/radv_descriptor_set.c
+++ b/src/amd/vulkan/radv_descriptor_set.c
@@ -109,11 +109,14 @@ VkResult radv_CreateDescriptorSetLayout(
                size += ycbcr_sampler_count * sizeof(struct radv_sampler_ycbcr_conversion) + (max_binding + 1) * sizeof(uint32_t);
        }
 
-       set_layout = vk_zalloc2(&device->alloc, pAllocator, size, 8,
+       set_layout = vk_zalloc2(&device->vk.alloc, pAllocator, size, 8,
                                VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
        if (!set_layout)
                return vk_error(device->instance, VK_ERROR_OUT_OF_HOST_MEMORY);
 
+       vk_object_base_init(&device->vk, &set_layout->base,
+                           VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT);
+
        set_layout->flags = pCreateInfo->flags;
        set_layout->layout_size = size;
 
@@ -132,7 +135,8 @@ VkResult radv_CreateDescriptorSetLayout(
        VkDescriptorSetLayoutBinding *bindings = create_sorted_bindings(pCreateInfo->pBindings,
                                                                        pCreateInfo->bindingCount);
        if (!bindings) {
-               vk_free2(&device->alloc, pAllocator, set_layout);
+               vk_object_base_finish(&set_layout->base);
+               vk_free2(&device->vk.alloc, pAllocator, set_layout);
                return vk_error(device->instance, VK_ERROR_OUT_OF_HOST_MEMORY);
        }
 
@@ -295,7 +299,8 @@ void radv_DestroyDescriptorSetLayout(
        if (!set_layout)
                return;
 
-       vk_free2(&device->alloc, pAllocator, set_layout);
+       vk_object_base_finish(&set_layout->base);
+       vk_free2(&device->vk.alloc, pAllocator, set_layout);
 }
 
 void radv_GetDescriptorSetLayoutSupport(VkDevice device,
@@ -408,11 +413,14 @@ VkResult radv_CreatePipelineLayout(
 
        assert(pCreateInfo->sType == VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO);
 
-       layout = vk_alloc2(&device->alloc, pAllocator, sizeof(*layout), 8,
+       layout = vk_alloc2(&device->vk.alloc, pAllocator, sizeof(*layout), 8,
                             VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
        if (layout == NULL)
                return vk_error(device->instance, VK_ERROR_OUT_OF_HOST_MEMORY);
 
+       vk_object_base_init(&device->vk, &layout->base,
+                           VK_OBJECT_TYPE_PIPELINE_LAYOUT);
+
        layout->num_sets = pCreateInfo->setLayoutCount;
 
        unsigned dynamic_offset_count = 0;
@@ -462,7 +470,9 @@ void radv_DestroyPipelineLayout(
 
        if (!pipeline_layout)
                return;
-       vk_free2(&device->alloc, pAllocator, pipeline_layout);
+
+       vk_object_base_finish(&pipeline_layout->base);
+       vk_free2(&device->vk.alloc, pAllocator, pipeline_layout);
 }
 
 #define EMPTY 1
@@ -496,7 +506,7 @@ radv_descriptor_set_create(struct radv_device *device,
                set = (struct radv_descriptor_set*)pool->host_memory_ptr;
                pool->host_memory_ptr += mem_size;
        } else {
-               set = vk_alloc2(&device->alloc, NULL, mem_size, 8,
+               set = vk_alloc2(&device->vk.alloc, NULL, mem_size, 8,
                                VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
 
                if (!set)
@@ -505,6 +515,9 @@ radv_descriptor_set_create(struct radv_device *device,
 
        memset(set, 0, mem_size);
 
+       vk_object_base_init(&device->vk, &set->base,
+                           VK_OBJECT_TYPE_DESCRIPTOR_SET);
+
        if (layout->dynamic_offset_count) {
                set->dynamic_descriptors = (struct radv_descriptor_range*)((uint8_t*)set + range_offset);
        }
@@ -526,7 +539,7 @@ radv_descriptor_set_create(struct radv_device *device,
                set->size = layout_size;
 
                if (!pool->host_memory_base && pool->entry_count == pool->max_entry_count) {
-                       vk_free2(&device->alloc, NULL, set);
+                       vk_free2(&device->vk.alloc, NULL, set);
                        return vk_error(device->instance, VK_ERROR_OUT_OF_POOL_MEMORY);
                }
 
@@ -555,7 +568,7 @@ radv_descriptor_set_create(struct radv_device *device,
                        }
 
                        if (pool->size - offset < layout_size) {
-                               vk_free2(&device->alloc, NULL, set);
+                               vk_free2(&device->vk.alloc, NULL, set);
                                return vk_error(device->instance, VK_ERROR_OUT_OF_POOL_MEMORY);
                        }
                        set->bo = pool->bo;
@@ -612,7 +625,8 @@ radv_descriptor_set_destroy(struct radv_device *device,
                        }
                }
        }
-       vk_free2(&device->alloc, NULL, set);
+       vk_object_base_finish(&set->base);
+       vk_free2(&device->vk.alloc, NULL, set);
 }
 
 VkResult radv_CreateDescriptorPool(
@@ -684,13 +698,16 @@ VkResult radv_CreateDescriptorPool(
                size += sizeof(struct radv_descriptor_pool_entry) * pCreateInfo->maxSets;
        }
 
-       pool = vk_alloc2(&device->alloc, pAllocator, size, 8,
+       pool = vk_alloc2(&device->vk.alloc, pAllocator, size, 8,
                         VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
        if (!pool)
                return vk_error(device->instance, VK_ERROR_OUT_OF_HOST_MEMORY);
 
        memset(pool, 0, sizeof(*pool));
 
+       vk_object_base_init(&device->vk, &pool->base,
+                           VK_OBJECT_TYPE_DESCRIPTOR_POOL);
+
        if (!(pCreateInfo->flags & VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT)) {
                pool->host_memory_base = (uint8_t*)pool + sizeof(struct radv_descriptor_pool);
                pool->host_memory_ptr = pool->host_memory_base;
@@ -732,7 +749,9 @@ void radv_DestroyDescriptorPool(
 
        if (pool->bo)
                device->ws->buffer_destroy(pool->bo);
-       vk_free2(&device->alloc, pAllocator, pool);
+
+       vk_object_base_finish(&pool->base);
+       vk_free2(&device->vk.alloc, pAllocator, pool);
 }
 
 VkResult radv_ResetDescriptorPool(
@@ -830,6 +849,11 @@ static void write_texel_buffer_descriptor(struct radv_device *device,
 {
        RADV_FROM_HANDLE(radv_buffer_view, buffer_view, _buffer_view);
 
+       if (!buffer_view) {
+               memset(dst, 0, 4 * 4);
+               return;
+       }
+
        memcpy(dst, buffer_view->state, 4 * 4);
 
        if (cmd_buffer)
@@ -845,6 +869,12 @@ static void write_buffer_descriptor(struct radv_device *device,
                                     const VkDescriptorBufferInfo *buffer_info)
 {
        RADV_FROM_HANDLE(radv_buffer, buffer, buffer_info->buffer);
+
+       if (!buffer) {
+               memset(dst, 0, 4 * 4);
+               return;
+       }
+
        uint64_t va = radv_buffer_get_va(buffer->bo);
        uint32_t range = buffer_info->range;
 
@@ -898,8 +928,14 @@ static void write_dynamic_buffer_descriptor(struct radv_device *device,
                                             const VkDescriptorBufferInfo *buffer_info)
 {
        RADV_FROM_HANDLE(radv_buffer, buffer, buffer_info->buffer);
-       uint64_t va = radv_buffer_get_va(buffer->bo);
-       unsigned size = buffer_info->range;
+       uint64_t va;
+       unsigned size;
+
+       if (!buffer)
+               return;
+
+       va = radv_buffer_get_va(buffer->bo);
+       size = buffer_info->range;
 
        if (buffer_info->range == VK_WHOLE_SIZE)
                size = buffer->size - buffer_info->offset;
@@ -928,6 +964,11 @@ write_image_descriptor(struct radv_device *device,
        RADV_FROM_HANDLE(radv_image_view, iview, image_info->imageView);
        union radv_descriptor *descriptor;
 
+       if (!iview) {
+               memset(dst, 0, size);
+               return;
+       }
+
        if (descriptor_type == VK_DESCRIPTOR_TYPE_STORAGE_IMAGE) {
                descriptor = &iview->storage_descriptor;
        } else {
@@ -1157,10 +1198,13 @@ VkResult radv_CreateDescriptorUpdateTemplate(VkDevice _device,
        struct radv_descriptor_update_template *templ;
        uint32_t i;
 
-       templ = vk_alloc2(&device->alloc, pAllocator, size, 8, VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
+       templ = vk_alloc2(&device->vk.alloc, pAllocator, size, 8, VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
        if (!templ)
                return vk_error(device->instance, VK_ERROR_OUT_OF_HOST_MEMORY);
 
+       vk_object_base_init(&device->vk, &templ->base,
+                           VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE);
+
        templ->entry_count = entry_count;
 
        if (pCreateInfo->templateType == VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR) {
@@ -1244,7 +1288,8 @@ void radv_DestroyDescriptorUpdateTemplate(VkDevice _device,
        if (!templ)
                return;
 
-       vk_free2(&device->alloc, pAllocator, templ);
+       vk_object_base_finish(&templ->base);
+       vk_free2(&device->vk.alloc, pAllocator, templ);
 }
 
 void radv_update_descriptor_set_with_template(struct radv_device *device,
@@ -1340,12 +1385,15 @@ VkResult radv_CreateSamplerYcbcrConversion(VkDevice _device,
        RADV_FROM_HANDLE(radv_device, device, _device);
        struct radv_sampler_ycbcr_conversion *conversion = NULL;
 
-       conversion = vk_zalloc2(&device->alloc, pAllocator, sizeof(*conversion), 8,
+       conversion = vk_zalloc2(&device->vk.alloc, pAllocator, sizeof(*conversion), 8,
                                VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
 
        if (conversion == NULL)
                return vk_error(device->instance, VK_ERROR_OUT_OF_HOST_MEMORY);
 
+       vk_object_base_init(&device->vk, &conversion->base,
+                           VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION);
+
        conversion->format = pCreateInfo->format;
        conversion->ycbcr_model = pCreateInfo->ycbcrModel;
        conversion->ycbcr_range = pCreateInfo->ycbcrRange;
@@ -1366,6 +1414,9 @@ void radv_DestroySamplerYcbcrConversion(VkDevice _device,
        RADV_FROM_HANDLE(radv_device, device, _device);
        RADV_FROM_HANDLE(radv_sampler_ycbcr_conversion, ycbcr_conversion, ycbcrConversion);
 
-       if (ycbcr_conversion)
-               vk_free2(&device->alloc, pAllocator, ycbcr_conversion);
+       if (!ycbcr_conversion)
+               return;
+
+       vk_object_base_finish(&ycbcr_conversion->base);
+       vk_free2(&device->vk.alloc, pAllocator, ycbcr_conversion);
 }