queue.c

#include <kiba/gpu/vulkan/queue.h>
 
#include <kiba/gpu/vulkan/allocator.h>
#include <kiba/gpu/vulkan/util.h>
 
b8 vk_queue_create(VkDevice logical_device, struct vk_queue *queue) {
    if (!queue->available)
        return true;
    vkGetDeviceQueue(logical_device, queue->index, 0, &queue->queue);
    VkSemaphoreCreateInfo sp_create_info = {
        .sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO,
    };
    VK_CALL_B8(vkCreateSemaphore(logical_device, &sp_create_info, &vk_alloc.vulkan_callbacks, &queue->sp_relays[0]));
    VK_CALL_B8(vkCreateSemaphore(logical_device, &sp_create_info, &vk_alloc.vulkan_callbacks, &queue->sp_relays[1]));
    queue->sp_index = -1;
    // TODO check if flags are ok here
    VkCommandPoolCreateInfo pool_create_info = {
        .sType            = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,
        .queueFamilyIndex = queue->index,
        .flags            = VK_COMMAND_POOL_CREATE_TRANSIENT_BIT | VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT,
    };
    VK_CALL_B8(
        vkCreateCommandPool(logical_device, &pool_create_info, &vk_alloc.vulkan_callbacks, &queue->command_pool));
    queue->encoders = array_create(struct gpu_backend_command_encoder, 5, &vk_alloc.kiba_alloc);
    return queue->encoders != KB_NULL;
}
 
void vk_queue_destroy(VkDevice logical_device, struct vk_queue *queue) {
    if (queue->available) {
        array_for_each(struct gpu_backend_command_encoder, encoder, queue->encoders) {
            vkWaitForFences(logical_device, 1, &encoder->exec_done, VK_TRUE, UINT64_MAX);
            vkDestroyFence(logical_device, encoder->exec_done, &vk_alloc.vulkan_callbacks);
            vkFreeCommandBuffers(logical_device, queue->command_pool, 1, &encoder->buffer);
        }
        vkDestroyCommandPool(logical_device, queue->command_pool, &vk_alloc.vulkan_callbacks);
        vkDestroySemaphore(logical_device, queue->sp_relays[0], &vk_alloc.vulkan_callbacks);
        vkDestroySemaphore(logical_device, queue->sp_relays[1], &vk_alloc.vulkan_callbacks);
    }
}
 
b8 vk_queue_get_command_encoder(struct gpu_backend_device *device, struct gpu_backend_command_encoder *encoder) {
    // TODO don't restrict this to graphics queue, maybe via parameter
    const usize cache_size = array_size(device->graphics_queue.encoders);
    for (usize i = 0; i < cache_size; ++i) {
        const struct gpu_backend_command_encoder candidate = device->graphics_queue.encoders[i];
        if (vkGetFenceStatus(device->logical, candidate.exec_done) == VK_SUCCESS) {
            vkResetFences(device->logical, 1, &candidate.exec_done);
            *encoder = candidate;
            array_remove(&device->graphics_queue.encoders, i, KB_NULL);
            return true;
        }
    }
 
    VkCommandBufferAllocateInfo cb_allocate_info = {
        .sType              = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,
        .commandPool        = device->graphics_queue.command_pool,
        .level              = VK_COMMAND_BUFFER_LEVEL_PRIMARY,
        .commandBufferCount = 1,
    };
    VK_CALL_B8(vkAllocateCommandBuffers(device->logical, &cb_allocate_info, &encoder->buffer));
    VkFenceCreateInfo fence_info = {
        .sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO,
    };
    VK_CALL_B8(vkCreateFence(device->logical, &fence_info, &vk_alloc.vulkan_callbacks, &encoder->exec_done));
    return true;
}
 
void vk_queue_return_command_encoder(struct gpu_backend_device *device, struct gpu_backend_command_encoder encoder) {
    // FIXME this is a workaround for lifetime issues
    // the validation layers will complain if resources bound to this buffer are destroyed
    // the buffer should be done because the last present call waits for all previous buffer
    // submissions but oh well
    // it appears i have to rethink how to manage the lifetime of the command buffer and by extension
    // its associated objects
    vkWaitForFences(device->logical, 1, &encoder.exec_done, VK_TRUE, UINT64_MAX);
    if (!array_push_checked(&device->graphics_queue.encoders, &encoder)) {
        // TODO should probably destroy the buffer instead
        KB_WARN("could not return command buffer to queue");
    }
}
 
b8 vk_queue_submit_encoder(struct gpu_backend_command_encoder *encoder, struct gpu_backend_device *device) {
    VkPipelineStageFlags *wait_stages      = KB_NULL;
    VkPipelineStageFlags  sp_wait_stages[] = {VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT};
    VkSemaphore           sp_wait[]        = {VK_NULL_HANDLE};
    u32                   sp_wait_count    = 0;
    i32                   old_index        = device->graphics_queue.sp_index;
    i32                   new_index        = 0;
    if (old_index >= 0) {
        sp_wait[sp_wait_count++] = device->graphics_queue.sp_relays[old_index];
        wait_stages              = sp_wait_stages;
        new_index                = (old_index + 1) % 2;
    }
    VkSemaphore sp_signal[]         = {device->graphics_queue.sp_relays[new_index]};
    device->graphics_queue.sp_index = new_index;
 
    VkSubmitInfo submit_info = {
        .sType                = VK_STRUCTURE_TYPE_SUBMIT_INFO,
        .waitSemaphoreCount   = sp_wait_count,
        .pWaitSemaphores      = sp_wait,
        .pWaitDstStageMask    = wait_stages,
        .commandBufferCount   = 1,
        .pCommandBuffers      = &encoder->buffer,
        .signalSemaphoreCount = 1,
        .pSignalSemaphores    = sp_signal,
    };
    KB_DEBUG("submitting");
    VK_CALL_B8(vkQueueSubmit(device->graphics_queue.queue, 1, &submit_info, encoder->exec_done));
    return true;
}
 
VkResult vk_queue_present_surface(struct gpu_backend_surface *surface, struct gpu_backend_device *device) {
    VkSemaphore sp_wait[]           = {VK_NULL_HANDLE};
    u32         sp_wait_count       = 0;
    i32         old_index           = device->graphics_queue.sp_index;
    device->graphics_queue.sp_index = -1;
    if (old_index >= 0) {
        sp_wait[sp_wait_count++] = device->graphics_queue.sp_relays[old_index];
    }
    VkPresentInfoKHR present_info = {
        .sType              = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR,
        .waitSemaphoreCount = sp_wait_count,
        .pWaitSemaphores    = sp_wait,
        .swapchainCount     = 1,
        .pSwapchains        = &surface->swap_chain,
        .pImageIndices      = &surface->presentation_image_index,
        .pResults           = NULL,
    };
    KB_DEBUG("presenting");
    return vkQueuePresentKHR(device->present_queue.queue, &present_info);
}