OpenHarmony/third_party_mesa3d
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

anv: Use vk_object_alloc/free

Browse Source 
Reviewed-by: Lionel Landwerlin <lionel.g.landwerlin@intel.com>
Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/10123>
This commit is contained in:
Jason Ekstrand
2021-04-08 16:12:27 -05:00
committed by Marge Bot
parent 22478bb0e4
commit c43109c07b
10 changed files with 70 additions and 137 deletions
Download Patch File Download Diff File Expand all files Collapse all files

19
src/intel/vulkan/anv_cmd_buffer.c
View File

@@ -253,14 +253,11 @@ static VkResult anv_create_cmd_buffer(
struct anv_cmd_buffer *cmd_buffer; struct anv_cmd_buffer *cmd_buffer;
VkResult result; VkResult result;
cmd_buffer = vk_alloc(&pool->alloc, sizeof(*cmd_buffer), 8, cmd_buffer = vk_object_alloc(&device->vk, &pool->alloc, sizeof(*cmd_buffer),
VK_SYSTEM_ALLOCATION_SCOPE_OBJECT); VK_OBJECT_TYPE_COMMAND_BUFFER);
if (cmd_buffer == NULL) if (cmd_buffer == NULL)
return vk_error(VK_ERROR_OUT_OF_HOST_MEMORY); return vk_error(VK_ERROR_OUT_OF_HOST_MEMORY);
vk_object_base_init(&device->vk, &cmd_buffer->base,
VK_OBJECT_TYPE_COMMAND_BUFFER);
cmd_buffer->batch.status = VK_SUCCESS; cmd_buffer->batch.status = VK_SUCCESS;
cmd_buffer->device = device; cmd_buffer->device = device;
@@ -341,8 +338,7 @@ anv_cmd_buffer_destroy(struct anv_cmd_buffer *cmd_buffer)
vk_free(&cmd_buffer->pool->alloc, cmd_buffer->self_mod_locations); vk_free(&cmd_buffer->pool->alloc, cmd_buffer->self_mod_locations);
vk_object_base_finish(&cmd_buffer->base); vk_object_free(&cmd_buffer->device->vk, &cmd_buffer->pool->alloc, cmd_buffer);
vk_free(&cmd_buffer->pool->alloc, cmd_buffer);
} }
void anv_FreeCommandBuffers( void anv_FreeCommandBuffers(
@@ -1137,13 +1133,11 @@ VkResult anv_CreateCommandPool(
ANV_FROM_HANDLE(anv_device, device, _device); ANV_FROM_HANDLE(anv_device, device, _device);
struct anv_cmd_pool *pool; struct anv_cmd_pool *pool;
pool = vk_alloc2(&device->vk.alloc, pAllocator, sizeof(*pool), 8, pool = vk_object_alloc(&device->vk, pAllocator, sizeof(*pool),
VK_SYSTEM_ALLOCATION_SCOPE_OBJECT); VK_OBJECT_TYPE_COMMAND_POOL);
if (pool == NULL) if (pool == NULL)
return vk_error(VK_ERROR_OUT_OF_HOST_MEMORY); return vk_error(VK_ERROR_OUT_OF_HOST_MEMORY);
vk_object_base_init(&device->vk, &pool->base, VK_OBJECT_TYPE_COMMAND_POOL);
if (pAllocator) if (pAllocator)
pool->alloc = *pAllocator; pool->alloc = *pAllocator;
else else
@@ -1174,8 +1168,7 @@ void anv_DestroyCommandPool(
anv_cmd_buffer_destroy(cmd_buffer); anv_cmd_buffer_destroy(cmd_buffer);
} }
vk_object_base_finish(&pool->base); vk_object_free(&device->vk, pAllocator, pool);
vk_free2(&device->vk.alloc, pAllocator, pool);
} }
VkResult anv_ResetCommandPool( VkResult anv_ResetCommandPool(

40
src/intel/vulkan/anv_descriptor_set.c
View File

@@ -385,13 +385,10 @@ VkResult anv_CreateDescriptorSetLayout(
VK_MULTIALLOC_DECL(&ma, struct anv_sampler *, samplers, VK_MULTIALLOC_DECL(&ma, struct anv_sampler *, samplers,
immutable_sampler_count); immutable_sampler_count);
if (!vk_multialloc_alloc(&ma, &device->vk.alloc, if (!vk_object_multizalloc(&device->vk, &ma, NULL,
VK_SYSTEM_ALLOCATION_SCOPE_DEVICE)) VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT))
return vk_error(VK_ERROR_OUT_OF_HOST_MEMORY); return vk_error(VK_ERROR_OUT_OF_HOST_MEMORY);
memset(set_layout, 0, sizeof(*set_layout));
vk_object_base_init(&device->vk, &set_layout->base,
VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT);
set_layout->ref_cnt = 1; set_layout->ref_cnt = 1;
set_layout->binding_count = num_bindings; set_layout->binding_count = num_bindings;
@@ -553,8 +550,7 @@ anv_descriptor_set_layout_destroy(struct anv_device *device,
struct anv_descriptor_set_layout *layout) struct anv_descriptor_set_layout *layout)
{ {
assert(layout->ref_cnt == 0); assert(layout->ref_cnt == 0);
vk_object_base_finish(&layout->base); vk_object_free(&device->vk, NULL, layout);
vk_free(&device->vk.alloc, layout);
} }
static const struct anv_descriptor_set_binding_layout * static const struct anv_descriptor_set_binding_layout *
@@ -711,13 +707,11 @@ VkResult anv_CreatePipelineLayout(
assert(pCreateInfo->sType == VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO); assert(pCreateInfo->sType == VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO);
layout = vk_alloc2(&device->vk.alloc, pAllocator, sizeof(*layout), 8, layout = vk_object_alloc(&device->vk, pAllocator, sizeof(*layout),
VK_SYSTEM_ALLOCATION_SCOPE_OBJECT); VK_OBJECT_TYPE_PIPELINE_LAYOUT);
if (layout == NULL) if (layout == NULL)
return vk_error(VK_ERROR_OUT_OF_HOST_MEMORY); return vk_error(VK_ERROR_OUT_OF_HOST_MEMORY);
vk_object_base_init(&device->vk, &layout->base,
VK_OBJECT_TYPE_PIPELINE_LAYOUT);
layout->num_sets = pCreateInfo->setLayoutCount; layout->num_sets = pCreateInfo->setLayoutCount;
unsigned dynamic_offset_count = 0; unsigned dynamic_offset_count = 0;
@@ -767,8 +761,7 @@ void anv_DestroyPipelineLayout(
for (uint32_t i = 0; i < pipeline_layout->num_sets; i++) for (uint32_t i = 0; i < pipeline_layout->num_sets; i++)
anv_descriptor_set_layout_unref(device, pipeline_layout->set[i].layout); anv_descriptor_set_layout_unref(device, pipeline_layout->set[i].layout);
vk_object_base_finish(&pipeline_layout->base); vk_object_free(&device->vk, pAllocator, pipeline_layout);
vk_free2(&device->vk.alloc, pAllocator, pipeline_layout);
} }
/* /*
@@ -860,13 +853,11 @@ VkResult anv_CreateDescriptorPool(
buffer_view_count * sizeof(struct anv_buffer_view); buffer_view_count * sizeof(struct anv_buffer_view);
const size_t total_size = sizeof(*pool) + pool_size; const size_t total_size = sizeof(*pool) + pool_size;
pool = vk_alloc2(&device->vk.alloc, pAllocator, total_size, 8, pool = vk_object_alloc(&device->vk, pAllocator, total_size,
VK_SYSTEM_ALLOCATION_SCOPE_OBJECT); VK_OBJECT_TYPE_DESCRIPTOR_POOL);
if (!pool) if (!pool)
return vk_error(VK_ERROR_OUT_OF_HOST_MEMORY); return vk_error(VK_ERROR_OUT_OF_HOST_MEMORY);
vk_object_base_init(&device->vk, &pool->base,
VK_OBJECT_TYPE_DESCRIPTOR_POOL);
pool->size = pool_size; pool->size = pool_size;
pool->next = 0; pool->next = 0;
pool->free_list = EMPTY; pool->free_list = EMPTY;
@@ -880,8 +871,7 @@ VkResult anv_CreateDescriptorPool(
0 /* explicit_address */, 0 /* explicit_address */,
&pool->bo); &pool->bo);
if (result != VK_SUCCESS) { if (result != VK_SUCCESS) {
vk_object_base_finish(&pool->base); vk_object_free(&device->vk, pAllocator, pool);
vk_free2(&device->vk.alloc, pAllocator, pool);
return result; return result;
} }
@@ -923,8 +913,7 @@ void anv_DestroyDescriptorPool(
} }
anv_state_stream_finish(&pool->surface_state_stream); anv_state_stream_finish(&pool->surface_state_stream);
vk_object_base_finish(&pool->base); vk_object_free(&device->vk, pAllocator, pool);
vk_free2(&device->vk.alloc, pAllocator, pool);
} }
VkResult anv_ResetDescriptorPool( VkResult anv_ResetDescriptorPool(
@@ -1768,13 +1757,11 @@ VkResult anv_CreateDescriptorUpdateTemplate(
size_t size = sizeof(*template) + size_t size = sizeof(*template) +
pCreateInfo->descriptorUpdateEntryCount * sizeof(template->entries[0]); pCreateInfo->descriptorUpdateEntryCount * sizeof(template->entries[0]);
template = vk_alloc2(&device->vk.alloc, pAllocator, size, 8, template = vk_object_alloc(&device->vk, pAllocator, size,
VK_SYSTEM_ALLOCATION_SCOPE_OBJECT); VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE);
if (template == NULL) if (template == NULL)
return vk_error(VK_ERROR_OUT_OF_HOST_MEMORY); return vk_error(VK_ERROR_OUT_OF_HOST_MEMORY);
vk_object_base_init(&device->vk, &template->base,
VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE);
template->bind_point = pCreateInfo->pipelineBindPoint; template->bind_point = pCreateInfo->pipelineBindPoint;
if (pCreateInfo->templateType == VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET) if (pCreateInfo->templateType == VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET)
@@ -1813,8 +1800,7 @@ void anv_DestroyDescriptorUpdateTemplate(
if (!template) if (!template)
return; return;
vk_object_base_finish(&template->base); vk_object_free(&device->vk, pAllocator, template);
vk_free2(&device->vk.alloc, pAllocator, template);
} }
void anv_UpdateDescriptorSetWithTemplate( void anv_UpdateDescriptorSetWithTemplate(

41
src/intel/vulkan/anv_device.c
View File

@@ -3702,13 +3702,11 @@ VkResult anv_AllocateMemory(
if (mem_heap_used + aligned_alloc_size > mem_heap->size) if (mem_heap_used + aligned_alloc_size > mem_heap->size)
return vk_error(VK_ERROR_OUT_OF_DEVICE_MEMORY); return vk_error(VK_ERROR_OUT_OF_DEVICE_MEMORY);
mem = vk_alloc2(&device->vk.alloc, pAllocator, sizeof(*mem), 8, mem = vk_object_alloc(&device->vk, pAllocator, sizeof(*mem),
VK_SYSTEM_ALLOCATION_SCOPE_OBJECT); VK_OBJECT_TYPE_DEVICE_MEMORY);
if (mem == NULL) if (mem == NULL)
return vk_error(VK_ERROR_OUT_OF_HOST_MEMORY); return vk_error(VK_ERROR_OUT_OF_HOST_MEMORY);
assert(pAllocateInfo->memoryTypeIndex < pdevice->memory.type_count);
vk_object_base_init(&device->vk, &mem->base, VK_OBJECT_TYPE_DEVICE_MEMORY);
mem->type = mem_type; mem->type = mem_type;
mem->map = NULL; mem->map = NULL;
mem->map_size = 0; mem->map_size = 0;
@@ -3935,8 +3933,7 @@ VkResult anv_AllocateMemory(
return VK_SUCCESS; return VK_SUCCESS;
fail: fail:
vk_object_base_finish(&mem->base); vk_object_free(&device->vk, pAllocator, mem);
vk_free2(&device->vk.alloc, pAllocator, mem);
return result; return result;
} }
@@ -4036,8 +4033,7 @@ void anv_FreeMemory(
AHardwareBuffer_release(mem->ahw); AHardwareBuffer_release(mem->ahw);
#endif #endif
vk_object_base_finish(&mem->base); vk_object_free(&device->vk, pAllocator, mem);
vk_free2(&device->vk.alloc, pAllocator, mem);
} }
VkResult anv_MapMemory( VkResult anv_MapMemory(
@@ -4295,12 +4291,11 @@ VkResult anv_CreateEvent(
assert(pCreateInfo->sType == VK_STRUCTURE_TYPE_EVENT_CREATE_INFO); assert(pCreateInfo->sType == VK_STRUCTURE_TYPE_EVENT_CREATE_INFO);
event = vk_alloc2(&device->vk.alloc, pAllocator, sizeof(*event), 8, event = vk_object_alloc(&device->vk, pAllocator, sizeof(*event),
VK_SYSTEM_ALLOCATION_SCOPE_OBJECT); VK_OBJECT_TYPE_EVENT);
if (event == NULL) if (event == NULL)
return vk_error(VK_ERROR_OUT_OF_HOST_MEMORY); return vk_error(VK_ERROR_OUT_OF_HOST_MEMORY);
vk_object_base_init(&device->vk, &event->base, VK_OBJECT_TYPE_EVENT);
event->state = anv_state_pool_alloc(&device->dynamic_state_pool, event->state = anv_state_pool_alloc(&device->dynamic_state_pool,
sizeof(uint64_t), 8); sizeof(uint64_t), 8);
*(uint64_t *)event->state.map = VK_EVENT_RESET; *(uint64_t *)event->state.map = VK_EVENT_RESET;
@@ -4323,8 +4318,7 @@ void anv_DestroyEvent(
anv_state_pool_free(&device->dynamic_state_pool, event->state); anv_state_pool_free(&device->dynamic_state_pool, event->state);
vk_object_base_finish(&event->base); vk_object_free(&device->vk, pAllocator, event);
vk_free2(&device->vk.alloc, pAllocator, event);
} }
VkResult anv_GetEventStatus( VkResult anv_GetEventStatus(
@@ -4383,12 +4377,11 @@ VkResult anv_CreateBuffer(
assert(pCreateInfo->sType == VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO); assert(pCreateInfo->sType == VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO);
buffer = vk_alloc2(&device->vk.alloc, pAllocator, sizeof(*buffer), 8, buffer = vk_object_alloc(&device->vk, pAllocator, sizeof(*buffer),
VK_SYSTEM_ALLOCATION_SCOPE_OBJECT); VK_OBJECT_TYPE_BUFFER);
if (buffer == NULL) if (buffer == NULL)
return vk_error(VK_ERROR_OUT_OF_HOST_MEMORY); return vk_error(VK_ERROR_OUT_OF_HOST_MEMORY);
vk_object_base_init(&device->vk, &buffer->base, VK_OBJECT_TYPE_BUFFER);
buffer->create_flags = pCreateInfo->flags; buffer->create_flags = pCreateInfo->flags;
buffer->size = pCreateInfo->size; buffer->size = pCreateInfo->size;
buffer->usage = pCreateInfo->usage; buffer->usage = pCreateInfo->usage;
@@ -4410,8 +4403,7 @@ void anv_DestroyBuffer(
if (!buffer) if (!buffer)
return; return;
vk_object_base_finish(&buffer->base); vk_object_free(&device->vk, pAllocator, buffer);
vk_free2(&device->vk.alloc, pAllocator, buffer);
} }
VkDeviceAddress anv_GetBufferDeviceAddress( VkDeviceAddress anv_GetBufferDeviceAddress(
@@ -4483,8 +4475,7 @@ void anv_DestroySampler(
sampler->custom_border_color); sampler->custom_border_color);
} }
vk_object_base_finish(&sampler->base); vk_object_free(&device->vk, pAllocator, sampler);
vk_free2(&device->vk.alloc, pAllocator, sampler);
} }
VkResult anv_CreateFramebuffer( VkResult anv_CreateFramebuffer(
@@ -4508,14 +4499,11 @@ VkResult anv_CreateFramebuffer(
if (!(pCreateInfo->flags & VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT_KHR)) if (!(pCreateInfo->flags & VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT_KHR))
size += sizeof(struct anv_image_view *) * pCreateInfo->attachmentCount; size += sizeof(struct anv_image_view *) * pCreateInfo->attachmentCount;
framebuffer = vk_alloc2(&device->vk.alloc, pAllocator, size, 8, framebuffer = vk_object_alloc(&device->vk, pAllocator, size,
VK_SYSTEM_ALLOCATION_SCOPE_OBJECT); VK_OBJECT_TYPE_FRAMEBUFFER);
if (framebuffer == NULL) if (framebuffer == NULL)
return vk_error(VK_ERROR_OUT_OF_HOST_MEMORY); return vk_error(VK_ERROR_OUT_OF_HOST_MEMORY);
vk_object_base_init(&device->vk, &framebuffer->base,
VK_OBJECT_TYPE_FRAMEBUFFER);
framebuffer->width = pCreateInfo->width; framebuffer->width = pCreateInfo->width;
framebuffer->height = pCreateInfo->height; framebuffer->height = pCreateInfo->height;
framebuffer->layers = pCreateInfo->layers; framebuffer->layers = pCreateInfo->layers;
@@ -4544,8 +4532,7 @@ void anv_DestroyFramebuffer(
if (!fb) if (!fb)
return; return;
vk_object_base_finish(&fb->base); vk_object_free(&device->vk, pAllocator, fb);
vk_free2(&device->vk.alloc, pAllocator, fb);
} }
static const VkTimeDomainEXT anv_time_domains[] = { static const VkTimeDomainEXT anv_time_domains[] = {

11
src/intel/vulkan/anv_formats.c
View File

@@ -1564,15 +1564,11 @@ VkResult anv_CreateSamplerYcbcrConversion(
assert(pCreateInfo->sType == VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO); assert(pCreateInfo->sType == VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO);
conversion = vk_alloc2(&device->vk.alloc, pAllocator, sizeof(*conversion), 8, conversion = vk_object_zalloc(&device->vk, pAllocator, sizeof(*conversion),
VK_SYSTEM_ALLOCATION_SCOPE_OBJECT); VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION);
if (!conversion) if (!conversion)
return vk_error(VK_ERROR_OUT_OF_HOST_MEMORY); return vk_error(VK_ERROR_OUT_OF_HOST_MEMORY);
memset(conversion, 0, sizeof(*conversion));
vk_object_base_init(&device->vk, &conversion->base,
VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION);
conversion->format = anv_get_format(pCreateInfo->format); conversion->format = anv_get_format(pCreateInfo->format);
conversion->ycbcr_model = pCreateInfo->ycbcrModel; conversion->ycbcr_model = pCreateInfo->ycbcrModel;
conversion->ycbcr_range = pCreateInfo->ycbcrRange; conversion->ycbcr_range = pCreateInfo->ycbcrRange;
@@ -1622,6 +1618,5 @@ void anv_DestroySamplerYcbcrConversion(
if (!conversion) if (!conversion)
return; return;
vk_object_base_finish(&conversion->base); vk_object_free(&device->vk, pAllocator, conversion);
vk_free2(&device->vk.alloc, pAllocator, conversion);
} }

28
src/intel/vulkan/anv_image.c
View File

@@ -1278,12 +1278,11 @@ anv_image_create(VkDevice _device,
anv_assert(pCreateInfo->extent.height > 0); anv_assert(pCreateInfo->extent.height > 0);
anv_assert(pCreateInfo->extent.depth > 0); anv_assert(pCreateInfo->extent.depth > 0);
image = vk_zalloc2(&device->vk.alloc, alloc, sizeof(*image), 8, image = vk_object_zalloc(&device->vk, alloc, sizeof(*image),
VK_SYSTEM_ALLOCATION_SCOPE_OBJECT); VK_OBJECT_TYPE_IMAGE);
if (!image) if (!image)
return vk_error(VK_ERROR_OUT_OF_HOST_MEMORY); return vk_error(VK_ERROR_OUT_OF_HOST_MEMORY);
vk_object_base_init(&device->vk, &image->base, VK_OBJECT_TYPE_IMAGE);
image->type = pCreateInfo->imageType; image->type = pCreateInfo->imageType;
image->extent = anv_sanitize_image_extent(pCreateInfo->imageType, image->extent = anv_sanitize_image_extent(pCreateInfo->imageType,
pCreateInfo->extent); pCreateInfo->extent);
@@ -1373,8 +1372,7 @@ anv_image_create(VkDevice _device,
return VK_SUCCESS; return VK_SUCCESS;
fail: fail:
vk_object_base_finish(&image->base); vk_object_free(&device->vk, alloc, image);
vk_free2(&device->vk.alloc, alloc, image);
return r; return r;
} }
@@ -1517,8 +1515,7 @@ anv_DestroyImage(VkDevice _device, VkImage _image,
if (private_bo) if (private_bo)
anv_device_release_bo(device, private_bo); anv_device_release_bo(device, private_bo);
vk_object_base_finish(&image->base); vk_object_free(&device->vk, pAllocator, image);
vk_free2(&device->vk.alloc, pAllocator, image);
} }
/* We are binding AHardwareBuffer. Get a description, resolve the /* We are binding AHardwareBuffer. Get a description, resolve the
@@ -2678,13 +2675,11 @@ anv_CreateImageView(VkDevice _device,
ANV_FROM_HANDLE(anv_image, image, pCreateInfo->image); ANV_FROM_HANDLE(anv_image, image, pCreateInfo->image);
struct anv_image_view *iview; struct anv_image_view *iview;
iview = vk_zalloc2(&device->vk.alloc, pAllocator, sizeof(*iview), 8, iview = vk_object_zalloc(&device->vk, pAllocator, sizeof(*iview),
VK_SYSTEM_ALLOCATION_SCOPE_OBJECT); VK_OBJECT_TYPE_IMAGE_VIEW);
if (iview == NULL) if (iview == NULL)
return vk_error(VK_ERROR_OUT_OF_HOST_MEMORY); return vk_error(VK_ERROR_OUT_OF_HOST_MEMORY);
vk_object_base_init(&device->vk, &iview->base, VK_OBJECT_TYPE_IMAGE_VIEW);
const VkImageSubresourceRange *range = &pCreateInfo->subresourceRange; const VkImageSubresourceRange *range = &pCreateInfo->subresourceRange;
assert(range->layerCount > 0); assert(range->layerCount > 0);
@@ -2938,8 +2933,7 @@ anv_DestroyImageView(VkDevice _device, VkImageView _iview,
} }
} }
vk_object_base_finish(&iview->base); vk_object_free(&device->vk, pAllocator, iview);
vk_free2(&device->vk.alloc, pAllocator, iview);
} }
@@ -2953,14 +2947,13 @@ anv_CreateBufferView(VkDevice _device,
ANV_FROM_HANDLE(anv_buffer, buffer, pCreateInfo->buffer); ANV_FROM_HANDLE(anv_buffer, buffer, pCreateInfo->buffer);
struct anv_buffer_view *view; struct anv_buffer_view *view;
view = vk_alloc2(&device->vk.alloc, pAllocator, sizeof(*view), 8, view = vk_object_alloc(&device->vk, pAllocator, sizeof(*view),
VK_SYSTEM_ALLOCATION_SCOPE_OBJECT); VK_OBJECT_TYPE_BUFFER_VIEW);
if (!view) if (!view)
return vk_error(VK_ERROR_OUT_OF_HOST_MEMORY); return vk_error(VK_ERROR_OUT_OF_HOST_MEMORY);
/* TODO: Handle the format swizzle? */ /* TODO: Handle the format swizzle? */
vk_object_base_init(&device->vk, &view->base, VK_OBJECT_TYPE_BUFFER_VIEW);
view->format = anv_get_isl_format(&device->info, pCreateInfo->format, view->format = anv_get_isl_format(&device->info, pCreateInfo->format,
VK_IMAGE_ASPECT_COLOR_BIT, VK_IMAGE_ASPECT_COLOR_BIT,
VK_IMAGE_TILING_LINEAR); VK_IMAGE_TILING_LINEAR);
@@ -3038,6 +3031,5 @@ anv_DestroyBufferView(VkDevice _device, VkBufferView bufferView,
anv_state_pool_free(&device->surface_state_pool, anv_state_pool_free(&device->surface_state_pool,
view->writeonly_storage_surface_state); view->writeonly_storage_surface_state);
vk_object_base_finish(&view->base); vk_object_free(&device->vk, pAllocator, view);
vk_free2(&device->vk.alloc, pAllocator, view);
} }

9
src/intel/vulkan/anv_pass.c
View File

@@ -328,15 +328,13 @@ VkResult anv_CreateRenderPass2(
VK_MULTIALLOC_DECL(&ma, struct anv_subpass_attachment, subpass_attachments, VK_MULTIALLOC_DECL(&ma, struct anv_subpass_attachment, subpass_attachments,
subpass_attachment_count); subpass_attachment_count);
if (!vk_multialloc_alloc2(&ma, &device->vk.alloc, pAllocator, if (!vk_object_multizalloc(&device->vk, &ma, pAllocator,
VK_SYSTEM_ALLOCATION_SCOPE_OBJECT)) VK_OBJECT_TYPE_RENDER_PASS))
return vk_error(VK_ERROR_OUT_OF_HOST_MEMORY); return vk_error(VK_ERROR_OUT_OF_HOST_MEMORY);
/* Clear the subpasses along with the parent pass. This required because /* Clear the subpasses along with the parent pass. This required because
* each array member of anv_subpass must be a valid pointer if not NULL. * each array member of anv_subpass must be a valid pointer if not NULL.
*/ */
memset(pass, 0, ma.size);
vk_object_base_init(&device->vk, &pass->base, VK_OBJECT_TYPE_RENDER_PASS);
pass->attachment_count = pCreateInfo->attachmentCount; pass->attachment_count = pCreateInfo->attachmentCount;
pass->subpass_count = pCreateInfo->subpassCount; pass->subpass_count = pCreateInfo->subpassCount;
pass->attachments = attachments; pass->attachments = attachments;
@@ -468,8 +466,7 @@ void anv_DestroyRenderPass(
if (!pass) if (!pass)
return; return;
vk_object_base_finish(&pass->base); vk_object_free(&device->vk, pAllocator, pass);
vk_free2(&device->vk.alloc, pAllocator, pass);
} }
void anv_GetRenderAreaGranularity( void anv_GetRenderAreaGranularity(

15
src/intel/vulkan/anv_perf.c
View File

@@ -218,8 +218,8 @@ VkResult anv_AcquirePerformanceConfigurationINTEL(
ANV_FROM_HANDLE(anv_device, device, _device); ANV_FROM_HANDLE(anv_device, device, _device);
struct anv_performance_configuration_intel *config; struct anv_performance_configuration_intel *config;
config = vk_alloc(&device->vk.alloc, sizeof(*config), 8, config = vk_object_alloc(&device->vk, NULL, sizeof(*config),
VK_SYSTEM_ALLOCATION_SCOPE_DEVICE); VK_OBJECT_TYPE_PERFORMANCE_CONFIGURATION_INTEL);
if (!config) if (!config)
return vk_error(VK_ERROR_OUT_OF_HOST_MEMORY); return vk_error(VK_ERROR_OUT_OF_HOST_MEMORY);
@@ -228,7 +228,7 @@ VkResult anv_AcquirePerformanceConfigurationINTEL(
gen_perf_load_configuration(device->physical->perf, device->fd, gen_perf_load_configuration(device->physical->perf, device->fd,
GEN_PERF_QUERY_GUID_MDAPI); GEN_PERF_QUERY_GUID_MDAPI);
if (!config->register_config) { if (!config->register_config) {
vk_free(&device->vk.alloc, config); vk_object_free(&device->vk, NULL, config);
return VK_INCOMPLETE; return VK_INCOMPLETE;
} }
@@ -237,16 +237,13 @@ VkResult anv_AcquirePerformanceConfigurationINTEL(
config->register_config, NULL /* guid */); config->register_config, NULL /* guid */);
if (ret < 0) { if (ret < 0) {
ralloc_free(config->register_config); ralloc_free(config->register_config);
vk_free(&device->vk.alloc, config); vk_object_free(&device->vk, NULL, config);
return VK_INCOMPLETE; return VK_INCOMPLETE;
} }
config->config_id = ret; config->config_id = ret;
} }
vk_object_base_init(&device->vk, &config->base,
VK_OBJECT_TYPE_PERFORMANCE_CONFIGURATION_INTEL);
*pConfiguration = anv_performance_configuration_intel_to_handle(config); *pConfiguration = anv_performance_configuration_intel_to_handle(config);
return VK_SUCCESS; return VK_SUCCESS;
@@ -263,8 +260,8 @@ VkResult anv_ReleasePerformanceConfigurationINTEL(
intel_ioctl(device->fd, DRM_IOCTL_I915_PERF_REMOVE_CONFIG, &config->config_id); intel_ioctl(device->fd, DRM_IOCTL_I915_PERF_REMOVE_CONFIG, &config->config_id);
ralloc_free(config->register_config); ralloc_free(config->register_config);
vk_object_base_finish(&config->base);
vk_free(&device->vk.alloc, config); vk_object_free(&device->vk, NULL, config);
return VK_SUCCESS; return VK_SUCCESS;
} }

30
src/intel/vulkan/anv_queue.c
View File

@@ -1465,13 +1465,11 @@ VkResult anv_CreateFence(
assert(pCreateInfo->sType == VK_STRUCTURE_TYPE_FENCE_CREATE_INFO); assert(pCreateInfo->sType == VK_STRUCTURE_TYPE_FENCE_CREATE_INFO);
fence = vk_zalloc2(&device->vk.alloc, pAllocator, sizeof(*fence), 8, fence = vk_object_zalloc(&device->vk, pAllocator, sizeof(*fence),
VK_SYSTEM_ALLOCATION_SCOPE_OBJECT); VK_OBJECT_TYPE_FENCE);
if (fence == NULL) if (fence == NULL)
return vk_error(VK_ERROR_OUT_OF_HOST_MEMORY); return vk_error(VK_ERROR_OUT_OF_HOST_MEMORY);
vk_object_base_init(&device->vk, &fence->base, VK_OBJECT_TYPE_FENCE);
if (device->physical->has_syncobj_wait) { if (device->physical->has_syncobj_wait) {
fence->permanent.type = ANV_FENCE_TYPE_SYNCOBJ; fence->permanent.type = ANV_FENCE_TYPE_SYNCOBJ;
@@ -1558,8 +1556,7 @@ void anv_DestroyFence(
anv_fence_impl_cleanup(device, &fence->temporary); anv_fence_impl_cleanup(device, &fence->temporary);
anv_fence_impl_cleanup(device, &fence->permanent); anv_fence_impl_cleanup(device, &fence->permanent);
vk_object_base_finish(&fence->base); vk_object_free(&device->vk, pAllocator, fence);
vk_free2(&device->vk.alloc, pAllocator, fence);
} }
VkResult anv_ResetFences( VkResult anv_ResetFences(
@@ -2228,13 +2225,11 @@ VkResult anv_CreateSemaphore(
uint64_t timeline_value = 0; uint64_t timeline_value = 0;
VkSemaphoreTypeKHR sem_type = get_semaphore_type(pCreateInfo->pNext, &timeline_value); VkSemaphoreTypeKHR sem_type = get_semaphore_type(pCreateInfo->pNext, &timeline_value);
semaphore = vk_alloc(&device->vk.alloc, sizeof(*semaphore), 8, semaphore = vk_object_alloc(&device->vk, NULL, sizeof(*semaphore),
VK_SYSTEM_ALLOCATION_SCOPE_DEVICE); VK_OBJECT_TYPE_SEMAPHORE);
if (semaphore == NULL) if (semaphore == NULL)
return vk_error(VK_ERROR_OUT_OF_HOST_MEMORY); return vk_error(VK_ERROR_OUT_OF_HOST_MEMORY);
vk_object_base_init(&device->vk, &semaphore->base, VK_OBJECT_TYPE_SEMAPHORE);
p_atomic_set(&semaphore->refcount, 1); p_atomic_set(&semaphore->refcount, 1);
const VkExportSemaphoreCreateInfo *export = const VkExportSemaphoreCreateInfo *export =
@@ -2249,8 +2244,7 @@ VkResult anv_CreateSemaphore(
else else
result = timeline_semaphore_create(device, &semaphore->permanent, timeline_value); result = timeline_semaphore_create(device, &semaphore->permanent, timeline_value);
if (result != VK_SUCCESS) { if (result != VK_SUCCESS) {
vk_object_base_finish(&semaphore->base); vk_object_free(&device->vk, pAllocator, semaphore);
vk_free2(&device->vk.alloc, pAllocator, semaphore);
return result; return result;
} }
} else if (handleTypes & VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT) { } else if (handleTypes & VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT) {
@@ -2260,8 +2254,7 @@ VkResult anv_CreateSemaphore(
else else
result = timeline_semaphore_create(device, &semaphore->permanent, timeline_value); result = timeline_semaphore_create(device, &semaphore->permanent, timeline_value);
if (result != VK_SUCCESS) { if (result != VK_SUCCESS) {
vk_object_base_finish(&semaphore->base); vk_object_free(&device->vk, pAllocator, semaphore);
vk_free2(&device->vk.alloc, pAllocator, semaphore);
return result; return result;
} }
} else if (handleTypes & VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT) { } else if (handleTypes & VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT) {
@@ -2271,8 +2264,7 @@ VkResult anv_CreateSemaphore(
semaphore->permanent.type = ANV_SEMAPHORE_TYPE_DRM_SYNCOBJ; semaphore->permanent.type = ANV_SEMAPHORE_TYPE_DRM_SYNCOBJ;
semaphore->permanent.syncobj = anv_gem_syncobj_create(device, 0); semaphore->permanent.syncobj = anv_gem_syncobj_create(device, 0);
if (!semaphore->permanent.syncobj) { if (!semaphore->permanent.syncobj) {
vk_object_base_finish(&semaphore->base); vk_object_free(&device->vk, pAllocator, semaphore);
vk_free2(&device->vk.alloc, pAllocator, semaphore);
return vk_error(VK_ERROR_OUT_OF_HOST_MEMORY); return vk_error(VK_ERROR_OUT_OF_HOST_MEMORY);
} }
} else { } else {
@@ -2281,8 +2273,7 @@ VkResult anv_CreateSemaphore(
} }
} else { } else {
assert(!"Unknown handle type"); assert(!"Unknown handle type");
vk_object_base_finish(&semaphore->base); vk_object_free(&device->vk, pAllocator, semaphore);
vk_free2(&device->vk.alloc, pAllocator, semaphore);
return vk_error(VK_ERROR_INVALID_EXTERNAL_HANDLE); return vk_error(VK_ERROR_INVALID_EXTERNAL_HANDLE);
} }
@@ -2356,8 +2347,7 @@ anv_semaphore_unref(struct anv_device *device, struct anv_semaphore *semaphore)
anv_semaphore_impl_cleanup(device, &semaphore->temporary); anv_semaphore_impl_cleanup(device, &semaphore->temporary);
anv_semaphore_impl_cleanup(device, &semaphore->permanent); anv_semaphore_impl_cleanup(device, &semaphore->permanent);
vk_object_base_finish(&semaphore->base); vk_object_free(&device->vk, NULL, semaphore);
vk_free(&device->vk.alloc, semaphore);
} }
void anv_DestroySemaphore( void anv_DestroySemaphore(

9
src/intel/vulkan/genX_query.c
View File

@@ -161,12 +161,10 @@ VkResult genX(CreateQueryPool)(
assert(!"Invalid query type"); assert(!"Invalid query type");
} }
if (!vk_multialloc_alloc2(&ma, &device->vk.alloc, if (!vk_object_multialloc(&device->vk, &ma, pAllocator,
pAllocator, VK_OBJECT_TYPE_QUERY_POOL))
VK_SYSTEM_ALLOCATION_SCOPE_OBJECT))
return vk_error(VK_ERROR_OUT_OF_HOST_MEMORY); return vk_error(VK_ERROR_OUT_OF_HOST_MEMORY);
vk_object_base_init(&device->vk, &pool->base, VK_OBJECT_TYPE_QUERY_POOL);
pool->type = pCreateInfo->queryType; pool->type = pCreateInfo->queryType;
pool->pipeline_statistics = pipeline_statistics; pool->pipeline_statistics = pipeline_statistics;
pool->stride = uint64s_per_slot * sizeof(uint64_t); pool->stride = uint64s_per_slot * sizeof(uint64_t);
@@ -255,8 +253,7 @@ void genX(DestroyQueryPool)(
return; return;
anv_device_release_bo(device, pool->bo); anv_device_release_bo(device, pool->bo);
vk_object_base_finish(&pool->base); vk_object_free(&device->vk, pAllocator, pool);
vk_free2(&device->vk.alloc, pAllocator, pool);
} }
#if GFX_VER >= 8 #if GFX_VER >= 8

5
src/intel/vulkan/genX_state.c
View File

@@ -649,12 +649,11 @@ VkResult genX(CreateSampler)(
assert(pCreateInfo->sType == VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO); assert(pCreateInfo->sType == VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO);
sampler = vk_zalloc2(&device->vk.alloc, pAllocator, sizeof(*sampler), 8, sampler = vk_object_zalloc(&device->vk, pAllocator, sizeof(*sampler),
VK_SYSTEM_ALLOCATION_SCOPE_OBJECT); VK_OBJECT_TYPE_SAMPLER);
if (!sampler) if (!sampler)
return vk_error(VK_ERROR_OUT_OF_HOST_MEMORY); return vk_error(VK_ERROR_OUT_OF_HOST_MEMORY);
vk_object_base_init(&device->vk, &sampler->base, VK_OBJECT_TYPE_SAMPLER);
sampler->n_planes = 1; sampler->n_planes = 1;
uint32_t border_color_stride = GFX_VERx10 == 75 ? 512 : 64; uint32_t border_color_stride = GFX_VERx10 == 75 ? 512 : 64;