I'd only half ported private memory support, finish the job.
Cc: "20.3" <mesa-stable@lists.freedesktop.org>
Reviewed-by: Adam Jackson <ajax@redhat.com>
Reviewed-by: Roland Scheidegger <sroland@vmware.com>
Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/7705>
LVP_FROM_HANDLE(lvp_device, device, _device);
struct lvp_cmd_pool *pool;
- pool = vk_alloc2(&device->alloc, pAllocator, sizeof(*pool), 8,
+ pool = vk_alloc2(&device->vk.alloc, pAllocator, sizeof(*pool), 8,
VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
if (pool == NULL)
return vk_error(device->instance, VK_ERROR_OUT_OF_HOST_MEMORY);
if (pAllocator)
pool->alloc = *pAllocator;
else
- pool->alloc = device->alloc;
+ pool->alloc = device->vk.alloc;
list_inithead(&pool->cmd_buffers);
list_inithead(&pool->free_cmd_buffers);
}
vk_object_base_finish(&pool->base);
- vk_free2(&device->alloc, pAllocator, pool);
+ vk_free2(&device->vk.alloc, pAllocator, pool);
}
VkResult lvp_ResetCommandPool(
(max_binding + 1) * sizeof(set_layout->binding[0]) +
immutable_sampler_count * sizeof(struct lvp_sampler *);
- 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);
if (!_set_layout)
return;
vk_object_base_finish(&set_layout->base);
- vk_free2(&device->alloc, pAllocator, set_layout);
+ vk_free2(&device->vk.alloc, pAllocator, set_layout);
}
VkResult lvp_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);
if (!_pipelineLayout)
return;
vk_object_base_finish(&pipeline_layout->base);
- vk_free2(&device->alloc, pAllocator, pipeline_layout);
+ vk_free2(&device->vk.alloc, pAllocator, pipeline_layout);
}
VkResult
struct lvp_descriptor_set *set;
size_t size = sizeof(*set) + layout->size * sizeof(set->descriptors[0]);
- set = vk_alloc(&device->alloc /* XXX: Use the pool */, size, 8,
+ set = vk_alloc(&device->vk.alloc /* XXX: Use the pool */, size, 8,
VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
if (!set)
return vk_error(device->instance, VK_ERROR_OUT_OF_HOST_MEMORY);
struct lvp_descriptor_set *set)
{
vk_object_base_finish(&set->base);
- vk_free(&device->alloc, set);
+ vk_free(&device->vk.alloc, set);
}
VkResult lvp_AllocateDescriptorSets(
LVP_FROM_HANDLE(lvp_device, device, _device);
struct lvp_descriptor_pool *pool;
size_t size = sizeof(struct lvp_descriptor_pool);
- pool = vk_zalloc2(&device->alloc, pAllocator, size, 8,
+ pool = vk_zalloc2(&device->vk.alloc, pAllocator, size, 8,
VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
if (!pool)
return vk_error(device->instance, VK_ERROR_OUT_OF_HOST_MEMORY);
struct lvp_descriptor_set *set, *tmp;
LIST_FOR_EACH_ENTRY_SAFE(set, tmp, &pool->sets, link) {
list_del(&set->link);
- vk_free(&device->alloc, set);
+ vk_free(&device->vk.alloc, set);
}
}
lvp_reset_descriptor_pool(device, pool);
vk_object_base_finish(&pool->base);
- vk_free2(&device->alloc, pAllocator, pool);
+ vk_free2(&device->vk.alloc, pAllocator, pool);
}
VkResult lvp_ResetDescriptorPool(
features->storageInputOutput16 = false;
break;
}
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES_EXT: {
+ VkPhysicalDevicePrivateDataFeaturesEXT *features =
+ (VkPhysicalDevicePrivateDataFeaturesEXT *)ext;
+ features->privateData = true;
+ break;
+ }
default:
break;
}
if (!device)
return vk_error(physical_device->instance, VK_ERROR_OUT_OF_HOST_MEMORY);
+ vk_device_init(&device->vk, pCreateInfo,
+ &physical_device->instance->alloc, pAllocator);
+
device->instance = physical_device->instance;
device->physical_device = physical_device;
- if (pAllocator)
- device->alloc = *pAllocator;
- else
- device->alloc = physical_device->instance->alloc;
-
for (uint32_t i = 0; i < pCreateInfo->enabledExtensionCount; i++) {
const char *ext_name = pCreateInfo->ppEnabledExtensionNames[i];
int index = lvp_get_device_extension_index(ext_name);
if (index < 0 || !physical_device->supported_extensions.extensions[index]) {
- vk_free(&device->alloc, device);
+ vk_free(&device->vk.alloc, device);
return vk_error(physical_device->instance, VK_ERROR_EXTENSION_NOT_PRESENT);
}
LVP_FROM_HANDLE(lvp_device, device, _device);
lvp_queue_finish(&device->queue);
- vk_free(&device->alloc, device);
+ vk_free(&device->vk.alloc, device);
}
VkResult lvp_EnumerateInstanceExtensionProperties(
return VK_SUCCESS;
}
- mem = vk_alloc2(&device->alloc, pAllocator, sizeof(*mem), 8,
+ mem = vk_alloc2(&device->vk.alloc, pAllocator, sizeof(*mem), 8,
VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
if (mem == NULL)
return vk_error(device->instance, VK_ERROR_OUT_OF_HOST_MEMORY);
VK_OBJECT_TYPE_DEVICE_MEMORY);
mem->pmem = device->pscreen->allocate_memory(device->pscreen, pAllocateInfo->allocationSize);
if (!mem->pmem) {
- vk_free2(&device->alloc, pAllocator, mem);
+ vk_free2(&device->vk.alloc, pAllocator, mem);
return vk_error(device->instance, VK_ERROR_OUT_OF_HOST_MEMORY);
}
device->pscreen->free_memory(device->pscreen, mem->pmem);
vk_object_base_finish(&mem->base);
- vk_free2(&device->alloc, pAllocator, mem);
+ vk_free2(&device->vk.alloc, pAllocator, mem);
}
LVP_FROM_HANDLE(lvp_device, device, _device);
struct lvp_fence *fence;
- fence = vk_alloc2(&device->alloc, pAllocator, sizeof(*fence), 8,
+ fence = vk_alloc2(&device->vk.alloc, pAllocator, sizeof(*fence), 8,
VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
if (fence == NULL)
return vk_error(device->instance, VK_ERROR_OUT_OF_HOST_MEMORY);
device->pscreen->fence_reference(device->pscreen, &fence->handle, NULL);
vk_object_base_finish(&fence->base);
- vk_free2(&device->alloc, pAllocator, fence);
+ vk_free2(&device->vk.alloc, pAllocator, fence);
}
VkResult lvp_ResetFences(
size_t size = sizeof(*framebuffer) +
sizeof(struct lvp_image_view *) * pCreateInfo->attachmentCount;
- framebuffer = vk_alloc2(&device->alloc, pAllocator, size, 8,
+ framebuffer = vk_alloc2(&device->vk.alloc, pAllocator, size, 8,
VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
if (framebuffer == NULL)
return vk_error(device->instance, VK_ERROR_OUT_OF_HOST_MEMORY);
if (!fb)
return;
vk_object_base_finish(&fb->base);
- vk_free2(&device->alloc, pAllocator, fb);
+ vk_free2(&device->vk.alloc, pAllocator, fb);
}
VkResult lvp_WaitForFences(
{
LVP_FROM_HANDLE(lvp_device, device, _device);
- struct lvp_semaphore *sema = vk_alloc2(&device->alloc, pAllocator,
+ struct lvp_semaphore *sema = vk_alloc2(&device->vk.alloc, pAllocator,
sizeof(*sema), 8,
VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
if (!_semaphore)
return;
vk_object_base_finish(&semaphore->base);
- vk_free2(&device->alloc, pAllocator, semaphore);
+ vk_free2(&device->vk.alloc, pAllocator, semaphore);
}
VkResult lvp_CreateEvent(
VkEvent* pEvent)
{
LVP_FROM_HANDLE(lvp_device, device, _device);
- struct lvp_event *event = vk_alloc2(&device->alloc, pAllocator,
+ struct lvp_event *event = vk_alloc2(&device->vk.alloc, pAllocator,
sizeof(*event), 8,
VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
return;
vk_object_base_finish(&event->base);
- vk_free2(&device->alloc, pAllocator, event);
+ vk_free2(&device->vk.alloc, pAllocator, event);
}
VkResult lvp_GetEventStatus(
assert(pCreateInfo->sType == VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO);
- sampler = vk_alloc2(&device->alloc, pAllocator, sizeof(*sampler), 8,
+ sampler = vk_alloc2(&device->vk.alloc, pAllocator, sizeof(*sampler), 8,
VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
if (!sampler)
return vk_error(device->instance, VK_ERROR_OUT_OF_HOST_MEMORY);
if (!_sampler)
return;
vk_object_base_finish(&sampler->base);
- vk_free2(&device->alloc, pAllocator, sampler);
+ vk_free2(&device->vk.alloc, pAllocator, sampler);
}
VkResult lvp_CreatePrivateDataSlotEXT(
assert(pCreateInfo->sType == VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO);
- image = vk_zalloc2(&device->alloc, alloc, sizeof(*image), 8,
+ image = vk_zalloc2(&device->vk.alloc, alloc, sizeof(*image), 8,
VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
if (image == NULL)
return vk_error(device->instance, VK_ERROR_OUT_OF_HOST_MEMORY);
return;
pipe_resource_reference(&image->bo, NULL);
vk_object_base_finish(&image->base);
- vk_free2(&device->alloc, pAllocator, image);
+ vk_free2(&device->vk.alloc, pAllocator, image);
}
VkResult
LVP_FROM_HANDLE(lvp_image, image, pCreateInfo->image);
struct lvp_image_view *view;
- view = vk_alloc2(&device->alloc, pAllocator, sizeof(*view), 8,
+ view = vk_alloc2(&device->vk.alloc, pAllocator, sizeof(*view), 8,
VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
if (view == NULL)
return vk_error(device->instance, VK_ERROR_OUT_OF_HOST_MEMORY);
pipe_surface_reference(&iview->surface, NULL);
vk_object_base_finish(&iview->base);
- vk_free2(&device->alloc, pAllocator, iview);
+ vk_free2(&device->vk.alloc, pAllocator, iview);
}
void lvp_GetImageSubresourceLayout(
if (pCreateInfo->size > UINT32_MAX)
return VK_ERROR_OUT_OF_DEVICE_MEMORY;
- buffer = vk_alloc2(&device->alloc, pAllocator, sizeof(*buffer), 8,
+ buffer = vk_alloc2(&device->vk.alloc, pAllocator, sizeof(*buffer), 8,
VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
if (buffer == NULL)
return vk_error(device->instance, VK_ERROR_OUT_OF_HOST_MEMORY);
&template,
&buffer->total_size);
if (!buffer->bo) {
- vk_free2(&device->alloc, pAllocator, buffer);
+ vk_free2(&device->vk.alloc, pAllocator, buffer);
return vk_error(device->instance, VK_ERROR_OUT_OF_DEVICE_MEMORY);
}
}
pipe_resource_reference(&buffer->bo, NULL);
vk_object_base_finish(&buffer->base);
- vk_free2(&device->alloc, pAllocator, buffer);
+ vk_free2(&device->vk.alloc, pAllocator, buffer);
}
VkResult
LVP_FROM_HANDLE(lvp_device, device, _device);
LVP_FROM_HANDLE(lvp_buffer, buffer, pCreateInfo->buffer);
struct lvp_buffer_view *view;
- view = vk_alloc2(&device->alloc, pAllocator, sizeof(*view), 8,
+ view = vk_alloc2(&device->vk.alloc, pAllocator, sizeof(*view), 8,
VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
if (!view)
return vk_error(device->instance, VK_ERROR_OUT_OF_HOST_MEMORY);
if (!bufferView)
return;
vk_object_base_finish(&view->base);
- vk_free2(&device->alloc, pAllocator, view);
+ vk_free2(&device->vk.alloc, pAllocator, view);
}
attachments_offset = size;
size += pCreateInfo->attachmentCount * sizeof(pass->attachments[0]);
- pass = vk_alloc2(&device->alloc, pAllocator, size, 8,
+ pass = vk_alloc2(&device->vk.alloc, pAllocator, size, 8,
VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
if (pass == NULL)
return vk_error(device->instance, VK_ERROR_OUT_OF_HOST_MEMORY);
if (subpass_attachment_count) {
pass->subpass_attachments =
- vk_alloc2(&device->alloc, pAllocator,
+ vk_alloc2(&device->vk.alloc, pAllocator,
subpass_attachment_count * sizeof(struct lvp_subpass_attachment), 8,
VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
if (pass->subpass_attachments == NULL) {
- vk_free2(&device->alloc, pAllocator, pass);
+ vk_free2(&device->vk.alloc, pAllocator, pass);
return vk_error(device->instance, VK_ERROR_OUT_OF_HOST_MEMORY);
}
} else
if (!_pass)
return;
vk_object_base_finish(&pass->base);
- vk_free2(&device->alloc, pAllocator, pass->subpass_attachments);
- vk_free2(&device->alloc, pAllocator, pass);
+ vk_free2(&device->vk.alloc, pAllocator, pass->subpass_attachments);
+ vk_free2(&device->vk.alloc, pAllocator, pass);
}
void lvp_GetRenderAreaGranularity(
assert(pCreateInfo->sType == VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO);
assert(pCreateInfo->flags == 0);
- module = vk_alloc2(&device->alloc, pAllocator,
+ module = vk_alloc2(&device->vk.alloc, pAllocator,
sizeof(*module) + pCreateInfo->codeSize, 8,
VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
if (module == NULL)
if (!_module)
return;
vk_object_base_finish(&module->base);
- vk_free2(&device->alloc, pAllocator, module);
+ vk_free2(&device->vk.alloc, pAllocator, module);
}
void lvp_DestroyPipeline(
if (pipeline->compute_create_info.stage.pSpecializationInfo)
free((void *)pipeline->compute_create_info.stage.pSpecializationInfo);
vk_object_base_finish(&pipeline->base);
- vk_free2(&device->alloc, pAllocator, pipeline);
+ vk_free2(&device->vk.alloc, pAllocator, pipeline);
}
static VkResult
const VkAllocationCallbacks *alloc)
{
if (alloc == NULL)
- alloc = &device->alloc;
+ alloc = &device->vk.alloc;
pipeline->device = device;
pipeline->layout = lvp_pipeline_layout_from_handle(pCreateInfo->layout);
pipeline->force_min_sample = false;
assert(pCreateInfo->sType == VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO);
- pipeline = vk_zalloc2(&device->alloc, pAllocator, sizeof(*pipeline), 8,
+ pipeline = vk_zalloc2(&device->vk.alloc, pAllocator, sizeof(*pipeline), 8,
VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
if (pipeline == NULL)
return vk_error(device->instance, VK_ERROR_OUT_OF_HOST_MEMORY);
result = lvp_graphics_pipeline_init(pipeline, device, cache, pCreateInfo,
pAllocator);
if (result != VK_SUCCESS) {
- vk_free2(&device->alloc, pAllocator, pipeline);
+ vk_free2(&device->vk.alloc, pAllocator, pipeline);
return result;
}
LVP_FROM_HANDLE(lvp_shader_module, module,
pCreateInfo->stage.module);
if (alloc == NULL)
- alloc = &device->alloc;
+ alloc = &device->vk.alloc;
pipeline->device = device;
pipeline->layout = lvp_pipeline_layout_from_handle(pCreateInfo->layout);
pipeline->force_min_sample = false;
assert(pCreateInfo->sType == VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO);
- pipeline = vk_zalloc2(&device->alloc, pAllocator, sizeof(*pipeline), 8,
+ pipeline = vk_zalloc2(&device->vk.alloc, pAllocator, sizeof(*pipeline), 8,
VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
if (pipeline == NULL)
return vk_error(device->instance, VK_ERROR_OUT_OF_HOST_MEMORY);
result = lvp_compute_pipeline_init(pipeline, device, cache, pCreateInfo,
pAllocator);
if (result != VK_SUCCESS) {
- vk_free2(&device->alloc, pAllocator, pipeline);
+ vk_free2(&device->vk.alloc, pAllocator, pipeline);
return result;
}
assert(pCreateInfo->sType == VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO);
assert(pCreateInfo->flags == 0);
- cache = vk_alloc2(&device->alloc, pAllocator,
+ cache = vk_alloc2(&device->vk.alloc, pAllocator,
sizeof(*cache), 8,
VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
if (cache == NULL)
if (pAllocator)
cache->alloc = *pAllocator;
else
- cache->alloc = device->alloc;
+ cache->alloc = device->vk.alloc;
cache->device = device;
*pPipelineCache = lvp_pipeline_cache_to_handle(cache);
return;
// lvp_pipeline_cache_finish(cache);
vk_object_base_finish(&cache->base);
- vk_free2(&device->alloc, pAllocator, cache);
+ vk_free2(&device->vk.alloc, pAllocator, cache);
}
VkResult lvp_GetPipelineCacheData(
struct lvp_device {
struct vk_device vk;
- VkAllocationCallbacks alloc;
-
struct lvp_queue queue;
struct lvp_instance * instance;
struct lvp_physical_device *physical_device;
struct lvp_query_pool *pool;
uint32_t pool_size = sizeof(*pool) + pCreateInfo->queryCount * sizeof(struct pipe_query *);
- pool = vk_zalloc2(&device->alloc, pAllocator,
+ pool = vk_zalloc2(&device->vk.alloc, pAllocator,
pool_size, 8,
VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
if (!pool)
if (pool->queries[i])
device->queue.ctx->destroy_query(device->queue.ctx, pool->queries[i]);
vk_object_base_finish(&pool->base);
- vk_free2(&device->alloc, pAllocator, pool);
+ vk_free2(&device->vk.alloc, pAllocator, pool);
}
VkResult lvp_GetQueryPoolResults(
if (pAllocator)
alloc = pAllocator;
else
- alloc = &device->alloc;
+ alloc = &device->vk.alloc;
return wsi_common_create_swapchain(&device->physical_device->wsi_device,
lvp_device_to_handle(device),
if (pAllocator)
alloc = pAllocator;
else
- alloc = &device->alloc;
+ alloc = &device->vk.alloc;
wsi_common_destroy_swapchain(_device, swapchain, alloc);
}