lvp: Move to the common command pool framework

Reviewed-by: Dave Airlie <airlied@redhat.com>
Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/18324>

diff --git a/src/gallium/frontends/lavapipe/lvp_cmd_buffer.c b/src/gallium/frontends/lavapipe/lvp_cmd_buffer.c
index 7d9f263..3d91357 100644 (file)
--- a/src/gallium/frontends/lavapipe/lvp_cmd_buffer.c
+++ b/src/gallium/frontends/lavapipe/lvp_cmd_buffer.c
@@ -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);
-
-   return VK_SUCCESS;
-}
-
-static VkResult lvp_reset_cmd_buffer(struct lvp_cmd_buffer *cmd_buffer)
-{
-   vk_command_buffer_reset(&cmd_buffer->vk);
+   *cmd_buffer_out = &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);
 
-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]);
+   vk_command_buffer_reset(&cmd_buffer->vk);
 
-      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);
-      }
-   }
+   cmd_buffer->status = LVP_CMD_BUFFER_STATUS_INITIAL;
 }
 
-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)
 {

diff --git a/src/gallium/frontends/lavapipe/lvp_device.c b/src/gallium/frontends/lavapipe/lvp_device.c
index f61763a..9c7cdb0 100644 (file)
--- a/src/gallium/frontends/lavapipe/lvp_device.c
+++ b/src/gallium/frontends/lavapipe/lvp_device.c
@@ -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;

diff --git a/src/gallium/frontends/lavapipe/lvp_private.h b/src/gallium/frontends/lavapipe/lvp_private.h
index b87f6b0..086f351 100644 (file)
--- a/src/gallium/frontends/lavapipe/lvp_private.h
+++ b/src/gallium/frontends/lavapipe/lvp_private.h
@@ -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,