Vulkan 教程第五部分：多线程渲染

徒慕风流

于 2024-07-13 11:29:25 发布

阅读量1k

点赞数 9

分类专栏： Vulkan 教程文章标签： c++ 开发语言图形渲染

本文链接：https://blog.csdn.net/qq_54098120/article/details/140397117

版权

Vulkan 教程专栏收录该内容

7 篇文章

订阅专栏

多线程渲染可以显著提高渲染性能，特别是在现代多核CPU上。Vulkan的设计使其天然适合多线程渲染。在本节中，我们将详细探讨如何在Vulkan中实现多线程渲染，包括创建命令池和命令缓冲、多线程记录命令缓冲、以及提交命令缓冲。

1. 多线程命令缓冲记录

在Vulkan中，我们可以在多个线程中并行记录命令缓冲，然后将它们提交到图形队列。这种方法可以充分利用多核CPU的性能，提高渲染效率。

创建命令池和命令缓冲

每个线程需要自己的命令池和命令缓冲，以便独立记录命令。

std::vector<VkCommandPool> commandPools;
std::vector<std::vector<VkCommandBuffer>> commandBuffers;

void createCommandPoolsAndBuffers(size_t threadCount) {
    commandPools.resize(threadCount);
    commandBuffers.resize(threadCount);

    for (size_t i = 0; i < threadCount; i++) {
        VkCommandPoolCreateInfo poolInfo{};
        poolInfo.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO;
        poolInfo.queueFamilyIndex = graphicsQueueFamilyIndex;
        poolInfo.flags = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT;

        if (vkCreateCommandPool(device, &poolInfo, nullptr, &commandPools[i]) != VK_SUCCESS) {
            throw std::runtime_error("failed to create command pool!");
        }

        commandBuffers[i].resize(swapChainFramebuffers.size());

        VkCommandBufferAllocateInfo allocInfo{};
        allocInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
        allocInfo.commandPool = commandPools[i];
        allocInfo.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
        allocInfo.commandBufferCount = (uint32_t)commandBuffers[i].size();

        if (vkAllocateCommandBuffers(device, &allocInfo, commandBuffers[i].data()) != VK_SUCCESS) {
            throw std::runtime_error("failed to allocate command buffers!");
        }
    }
}

在上述代码中，我们为每个线程创建一个命令池，并从中分配命令缓冲。每个命令池和命令缓冲是线程独有的，确保了命令记录的并行性和独立性。

多线程记录命令缓冲

使用标准库中的线程和互斥锁来实现多线程命令缓冲记录。

void recordCommandBuffers(size_t threadIndex, size_t imageIndex) {
    VkCommandBufferBeginInfo beginInfo{};
    beginInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;

    if (vkBeginCommandBuffer(commandBuffers[threadIndex][imageIndex], &beginInfo) != VK_SUCCESS) {
        throw std::runtime_error("failed to begin recording command buffer!");
    }

    VkRenderPassBeginInfo renderPassInfo{};
    renderPassInfo.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO;
    renderPassInfo.renderPass = renderPass;
    renderPassInfo.framebuffer = swapChainFramebuffers[imageIndex];
    renderPassInfo.renderArea.offset = {0, 0};
    renderPassInfo.renderArea.extent = swapChainExtent;

    VkClearValue clearColor = {0.0f, 0.0f, 0.0f, 1.0f};
    renderPassInfo.clearValueCount = 1;
    renderPassInfo.pClearValues = &clearColor;

    vkCmdBeginRenderPass(commandBuffers[threadIndex][imageIndex], &renderPassInfo, VK_SUBPASS_CONTENTS_INLINE);
    vkCmdBindPipeline(commandBuffers[threadIndex][imageIndex], VK_PIPELINE_BIND_POINT_GRAPHICS, graphicsPipeline);

    VkBuffer vertexBuffers[] = {vertexBuffer};
    VkDeviceSize offsets[] = {0};
    vkCmdBindVertexBuffers(commandBuffers[threadIndex][imageIndex], 0, 1, vertexBuffers, offsets);

    vkCmdBindIndexBuffer(commandBuffers[threadIndex][imageIndex], indexBuffer, 0, VK_INDEX_TYPE_UINT16);

    vkCmdBindDescriptorSets(commandBuffers[threadIndex][imageIndex], VK_PIPELINE_BIND_POINT_GRAPHICS, pipelineLayout, 0, 1, &descriptorSet, 0, nullptr);

    vkCmdDrawIndexed(commandBuffers[threadIndex][imageIndex], static_cast<uint32_t>(indices.size()), 1, 0, 0, 0);

    vkCmdEndRenderPass(commandBuffers[threadIndex][imageIndex]);

    if (vkEndCommandBuffer(commandBuffers[threadIndex][imageIndex]) != VK_SUCCESS) {
        throw std::runtime_error("failed to record command buffer!");
    }
}

void recordCommandBuffersInParallel() {
    std::vector<std::thread> threads;

    for (size_t i = 0; i < commandBuffers.size(); i++) {
        threads.push_back(std::thread([this, i]() {
            for (size_t j = 0; j < swapChainFramebuffers.size(); j++) {
                recordCommandBuffers(i, j);
            }
        }));
    }

    for (auto& thread : threads) {
        thread.join();
    }
}

在上述代码中，recordCommandBuffers函数负责记录单个命令缓冲，而recordCommandBuffersInParallel函数则使用多个线程并行记录所有命令缓冲。每个线程会分别处理不同的命令池和命令缓冲，确保命令记录过程的并行执行。

2. 提交命令缓冲

在提交命令缓冲时，需要确保所有线程都已经完成命令缓冲的记录。

void drawFrame() {
    vkWaitForFences(device, 1, &inFlightFence, VK_TRUE, UINT64_MAX);
    vkResetFences(device, 1, &inFlightFence);

    uint32_t imageIndex;
    vkAcquireNextImageKHR(device, swapChain, UINT64_MAX, imageAvailableSemaphore, VK_NULL_HANDLE, &imageIndex);

    recordCommandBuffersInParallel();

    VkSubmitInfo submitInfo{};
    submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;

    VkSemaphore waitSemaphores[] = {imageAvailableSemaphore};
    VkPipelineStageFlags waitStages[] = {VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT};
    submitInfo.waitSemaphoreCount = 1;
    submitInfo.pWaitSemaphores = waitSemaphores;
    submitInfo.pWaitDstStageMask = waitStages;

    std::vector<VkCommandBuffer> buffersToSubmit;
    for (const auto& bufferSet : commandBuffers) {
        buffersToSubmit.push_back(bufferSet[imageIndex]);
    }

    submitInfo.commandBufferCount = static_cast<uint32_t>(buffersToSubmit.size());
    submitInfo.pCommandBuffers = buffersToSubmit.data();

    VkSemaphore signalSemaphores[] = {renderFinishedSemaphore};
    submitInfo.signalSemaphoreCount = 1;
    submitInfo.pSignalSemaphores = signalSemaphores;

    if (vkQueueSubmit(graphicsQueue, 1, &submitInfo, inFlightFence) != VK_SUCCESS) {
        throw std::runtime_error("failed to submit draw command buffer!");
    }

    VkPresentInfoKHR presentInfo{};
    presentInfo.sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR;
    presentInfo.waitSemaphoreCount = 1;
    presentInfo.pWaitSemaphores = signalSemaphores;
    presentInfo.swapchainCount = 1;
    presentInfo.pSwapchains = &swapChain;
    presentInfo.pImageIndices = &imageIndex;

    if (vkQueuePresentKHR(presentQueue, &presentInfo) != VK_SUCCESS) {
        throw std::runtime_error("failed to present swap chain image!");
    }
}

在上述代码中，我们首先等待上一帧的渲染完成，然后重置相关的同步对象。接着，我们获取交换链中的下一张图像，并并行记录命令缓冲。所有命令缓冲记录完成后，我们将它们提交到图形队列并呈现图像。