fdo-mirrors/mesa
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/mesa/mesa.git synced 2026-01-04 07:00:11 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions 1

lvp: Move to the common command pool framework

Browse source 
Reviewed-by: Dave Airlie <airlied@redhat.com>
Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/18324>
This commit is contained in:
Jason Ekstrand 2022-08-30 14:46:12 -05:00 • committed by Marge Bot
parent c052c6a333
commit f17f44b91a
3 changed files with 36 additions and 208 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

231
src/gallium/frontends/lavapipe/lvp_cmd_buffer.c
View file

@ -25,143 +25,68 @@
#include "pipe/p_context.h"
#include "vk_util.h"
static VkResult lvp_create_cmd_buffer(
struct lvp_device * device,
struct lvp_cmd_pool * pool,
VkCommandBufferLevel level,
VkCommandBuffer* pCommandBuffer)
#include "vk_common_entrypoints.h"
static void
lvp_cmd_buffer_destroy(struct vk_command_buffer *cmd_buffer)
{
vk_command_buffer_finish(cmd_buffer);
vk_free(&cmd_buffer->pool->alloc, cmd_buffer);
}
static VkResult
lvp_create_cmd_buffer(struct vk_command_pool *pool,
struct vk_command_buffer **cmd_buffer_out)
{
struct lvp_device *device =
container_of(pool->base.device, struct lvp_device, vk);
struct lvp_cmd_buffer *cmd_buffer;
cmd_buffer = vk_alloc(&pool->vk.alloc, sizeof(*cmd_buffer), 8,
cmd_buffer = vk_alloc(&pool->alloc, sizeof(*cmd_buffer), 8,
VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
if (cmd_buffer == NULL)
return vk_error(device, VK_ERROR_OUT_OF_HOST_MEMORY);
VkResult result = vk_command_buffer_init(&pool->vk, &cmd_buffer->vk,
NULL, level);
VkResult result = vk_command_buffer_init(pool, &cmd_buffer->vk,
&lvp_cmd_buffer_ops, 0);
if (result != VK_SUCCESS) {
vk_free(&pool->vk.alloc, cmd_buffer);
vk_free(&pool->alloc, cmd_buffer);
return result;
}
cmd_buffer->device = device;
cmd_buffer->pool = pool;
cmd_buffer->status = LVP_CMD_BUFFER_STATUS_INITIAL;
if (pool) {
list_addtail(&cmd_buffer->pool_link, &pool->cmd_buffers);
} else {
/* Init the pool_link so we can safefly call list_del when we destroy
* the command buffer
*/
list_inithead(&cmd_buffer->pool_link);
}
*pCommandBuffer = lvp_cmd_buffer_to_handle(cmd_buffer);
*cmd_buffer_out = &cmd_buffer->vk;
return VK_SUCCESS;
}
static VkResult lvp_reset_cmd_buffer(struct lvp_cmd_buffer *cmd_buffer)
{
vk_command_buffer_reset(&cmd_buffer->vk);
cmd_buffer->status = LVP_CMD_BUFFER_STATUS_INITIAL;
return VK_SUCCESS;
}
VKAPI_ATTR VkResult VKAPI_CALL lvp_AllocateCommandBuffers(
VkDevice _device,
const VkCommandBufferAllocateInfo* pAllocateInfo,
VkCommandBuffer* pCommandBuffers)
{
LVP_FROM_HANDLE(lvp_device, device, _device);
LVP_FROM_HANDLE(lvp_cmd_pool, pool, pAllocateInfo->commandPool);
VkResult result = VK_SUCCESS;
uint32_t i;
for (i = 0; i < pAllocateInfo->commandBufferCount; i++) {
if (!list_is_empty(&pool->free_cmd_buffers)) {
struct lvp_cmd_buffer *cmd_buffer = list_first_entry(&pool->free_cmd_buffers, struct lvp_cmd_buffer, pool_link);
list_del(&cmd_buffer->pool_link);
list_addtail(&cmd_buffer->pool_link, &pool->cmd_buffers);
result = lvp_reset_cmd_buffer(cmd_buffer);
vk_command_buffer_finish(&cmd_buffer->vk);
VkResult init_result =
vk_command_buffer_init(&pool->vk, &cmd_buffer->vk, NULL,
pAllocateInfo->level);
if (init_result != VK_SUCCESS)
result = init_result;
pCommandBuffers[i] = lvp_cmd_buffer_to_handle(cmd_buffer);
} else {
result = lvp_create_cmd_buffer(device, pool, pAllocateInfo->level,
&pCommandBuffers[i]);
if (result != VK_SUCCESS)
break;
}
}
if (result != VK_SUCCESS) {
lvp_FreeCommandBuffers(_device, pAllocateInfo->commandPool,
i, pCommandBuffers);
memset(pCommandBuffers, 0,
sizeof(*pCommandBuffers) * pAllocateInfo->commandBufferCount);
}
return result;
}
static void
lvp_cmd_buffer_destroy(struct lvp_cmd_buffer *cmd_buffer)
lvp_reset_cmd_buffer(struct vk_command_buffer *vk_cmd_buffer,
UNUSED VkCommandBufferResetFlags flags)
{
vk_command_buffer_finish(&cmd_buffer->vk);
vk_free(&cmd_buffer->pool->vk.alloc, cmd_buffer);
struct lvp_cmd_buffer *cmd_buffer =
container_of(vk_cmd_buffer, struct lvp_cmd_buffer, vk);
vk_command_buffer_reset(&cmd_buffer->vk);
cmd_buffer->status = LVP_CMD_BUFFER_STATUS_INITIAL;
}
VKAPI_ATTR void VKAPI_CALL lvp_FreeCommandBuffers(
VkDevice device,
VkCommandPool commandPool,
uint32_t commandBufferCount,
const VkCommandBuffer* pCommandBuffers)
{
for (uint32_t i = 0; i < commandBufferCount; i++) {
LVP_FROM_HANDLE(lvp_cmd_buffer, cmd_buffer, pCommandBuffers[i]);
if (cmd_buffer) {
if (cmd_buffer->pool) {
list_del(&cmd_buffer->pool_link);
list_addtail(&cmd_buffer->pool_link, &cmd_buffer->pool->free_cmd_buffers);
} else
lvp_cmd_buffer_destroy(cmd_buffer);
}
}
}
VKAPI_ATTR VkResult VKAPI_CALL lvp_ResetCommandBuffer(
VkCommandBuffer commandBuffer,
VkCommandBufferResetFlags flags)
{
LVP_FROM_HANDLE(lvp_cmd_buffer, cmd_buffer, commandBuffer);
return lvp_reset_cmd_buffer(cmd_buffer);
}
const struct vk_command_buffer_ops lvp_cmd_buffer_ops = {
.create = lvp_create_cmd_buffer,
.reset = lvp_reset_cmd_buffer,
.destroy = lvp_cmd_buffer_destroy,
};
VKAPI_ATTR VkResult VKAPI_CALL lvp_BeginCommandBuffer(
VkCommandBuffer commandBuffer,
const VkCommandBufferBeginInfo* pBeginInfo)
{
LVP_FROM_HANDLE(lvp_cmd_buffer, cmd_buffer, commandBuffer);
VkResult result;
if (cmd_buffer->status != LVP_CMD_BUFFER_STATUS_INITIAL) {
result = lvp_reset_cmd_buffer(cmd_buffer);
if (result != VK_SUCCESS)
return result;
}
if (cmd_buffer->status != LVP_CMD_BUFFER_STATUS_INITIAL)
lvp_reset_cmd_buffer(&cmd_buffer->vk, 0);
cmd_buffer->status = LVP_CMD_BUFFER_STATUS_RECORDING;
return VK_SUCCESS;
}
@ -179,94 +104,6 @@ VKAPI_ATTR VkResult VKAPI_CALL lvp_EndCommandBuffer(
return result;
}
VKAPI_ATTR VkResult VKAPI_CALL lvp_CreateCommandPool(
VkDevice _device,
const VkCommandPoolCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkCommandPool* pCmdPool)
{
LVP_FROM_HANDLE(lvp_device, device, _device);
struct lvp_cmd_pool *pool;
pool = vk_alloc2(&device->vk.alloc, pAllocator, sizeof(*pool), 8,
VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
if (pool == NULL)
return vk_error(device, VK_ERROR_OUT_OF_HOST_MEMORY);
VkResult result = vk_command_pool_init(&device->vk, &pool->vk,
pCreateInfo, pAllocator);
if (result != VK_SUCCESS) {
vk_free2(&device->vk.alloc, pAllocator, pool);
return result;
}
list_inithead(&pool->cmd_buffers);
list_inithead(&pool->free_cmd_buffers);
*pCmdPool = lvp_cmd_pool_to_handle(pool);
return VK_SUCCESS;
}
VKAPI_ATTR void VKAPI_CALL lvp_DestroyCommandPool(
VkDevice _device,
VkCommandPool commandPool,
const VkAllocationCallbacks* pAllocator)
{
LVP_FROM_HANDLE(lvp_device, device, _device);
LVP_FROM_HANDLE(lvp_cmd_pool, pool, commandPool);
if (!pool)
return;
list_for_each_entry_safe(struct lvp_cmd_buffer, cmd_buffer,
&pool->cmd_buffers, pool_link) {
lvp_cmd_buffer_destroy(cmd_buffer);
}
list_for_each_entry_safe(struct lvp_cmd_buffer, cmd_buffer,
&pool->free_cmd_buffers, pool_link) {
lvp_cmd_buffer_destroy(cmd_buffer);
}
vk_command_pool_finish(&pool->vk);
vk_free2(&device->vk.alloc, pAllocator, pool);
}
VKAPI_ATTR VkResult VKAPI_CALL lvp_ResetCommandPool(
VkDevice device,
VkCommandPool commandPool,
VkCommandPoolResetFlags flags)
{
LVP_FROM_HANDLE(lvp_cmd_pool, pool, commandPool);
VkResult result;
list_for_each_entry(struct lvp_cmd_buffer, cmd_buffer,
&pool->cmd_buffers, pool_link) {
result = lvp_reset_cmd_buffer(cmd_buffer);
if (result != VK_SUCCESS)
return result;
}
return VK_SUCCESS;
}
VKAPI_ATTR void VKAPI_CALL lvp_TrimCommandPool(
VkDevice device,
VkCommandPool commandPool,
VkCommandPoolTrimFlags flags)
{
LVP_FROM_HANDLE(lvp_cmd_pool, pool, commandPool);
if (!pool)
return;
list_for_each_entry_safe(struct lvp_cmd_buffer, cmd_buffer,
&pool->free_cmd_buffers, pool_link) {
lvp_cmd_buffer_destroy(cmd_buffer);
}
list_inithead(&pool->free_cmd_buffers);
}
static void
lvp_free_CmdPushDescriptorSetWithTemplateKHR(struct vk_cmd_queue *queue, struct vk_cmd_queue_entry *cmd)
{

1
src/gallium/frontends/lavapipe/lvp_device.c
View file

@ -1520,6 +1520,7 @@ VKAPI_ATTR VkResult VKAPI_CALL lvp_CreateDevice(
}
vk_device_enable_threaded_submit(&device->vk);
device->vk.command_buffer_ops = &lvp_cmd_buffer_ops;
device->instance = (struct lvp_instance *)physical_device->vk.instance;
device->physical_device = physical_device;

12
src/gallium/frontends/lavapipe/lvp_private.h
View file

@ -469,13 +469,6 @@ struct lvp_query_pool {
struct pipe_query *queries[0];
};
struct lvp_cmd_pool {
struct vk_command_pool vk;
struct list_head cmd_buffers;
struct list_head free_cmd_buffers;
};
enum lvp_cmd_buffer_status {
LVP_CMD_BUFFER_STATUS_INVALID,
LVP_CMD_BUFFER_STATUS_INITIAL,
@ -490,12 +483,11 @@ struct lvp_cmd_buffer {
struct lvp_device * device;
enum lvp_cmd_buffer_status status;
struct lvp_cmd_pool * pool;
struct list_head pool_link;
uint8_t push_constants[MAX_PUSH_CONSTANTS_SIZE];
};
extern const struct vk_command_buffer_ops lvp_cmd_buffer_ops;
static inline const struct lvp_descriptor_set_layout *
get_set_layout(const struct lvp_pipeline_layout *layout, uint32_t set)
@ -522,8 +514,6 @@ VK_DEFINE_HANDLE_CASTS(lvp_physical_device, vk.base, VkPhysicalDevice,
VK_OBJECT_TYPE_PHYSICAL_DEVICE)
VK_DEFINE_HANDLE_CASTS(lvp_queue, vk.base, VkQueue, VK_OBJECT_TYPE_QUEUE)
VK_DEFINE_NONDISP_HANDLE_CASTS(lvp_cmd_pool, vk.base, VkCommandPool,
VK_OBJECT_TYPE_COMMAND_POOL)
VK_DEFINE_NONDISP_HANDLE_CASTS(lvp_buffer, base, VkBuffer,
VK_OBJECT_TYPE_BUFFER)
VK_DEFINE_NONDISP_HANDLE_CASTS(lvp_buffer_view, base, VkBufferView,