Vulkan Compute Shader同步问题：CPU等待计算完成及错误排查

云原生阿岚

2026-6-21

问题描述

我在应用里用Compute Shader快速处理数据，每个模型实例调度一次Compute Shader（比如30个实例就调度30次）：

for(int i = 0; i < engineModLoader.instanceNumber; i++)
{   
    engineRenderer.DispatchCompute(phoenixMesh.totalMeshlets.size(), selectedMeshlet, 
    engineModLoader.instancesData[i].instancePos);
}

我需要用Compute Shader的结果填充实例绘制用的全局索引缓冲区，所以所有调度的Compute Shader必须在调用DrawFrame()（渲染实例）前执行完毕。请问怎么在CPU上等待Compute Shader执行结束？

我尝试了下面的同步实现，但得到错误数据：

void Renderer::DispatchCompute(int numberOfElements, std::vector<Phoenix::DataToCompute>& selectedMeshlet, 
    const glm::vec3& instancePos)
    {
        VkSubmitInfo computeSubmitInfo{};
        computeSubmitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
        vkWaitForFences(engineDevice.logicalDevice, 1, &computeInFlightFences[currentComputeFrame], VK_TRUE, UINT64_MAX);

        engineTransform.ubo.instancePos = instancePos;
        UpdateUniformBuffer(currentComputeFrame);  
        vkResetFences(engineDevice.logicalDevice, 1, &computeInFlightFences[currentComputeFrame]);
        vkResetCommandBuffer(computeCommandBuffers[currentComputeFrame], 0);
        RecordComputeBuffer(numberOfElements, computeCommandBuffers[currentComputeFrame]);

        computeSubmitInfo.commandBufferCount = 1;
        computeSubmitInfo.pCommandBuffers = &computeCommandBuffers[currentComputeFrame];
        computeSubmitInfo.signalSemaphoreCount = 1;
        computeSubmitInfo.pSignalSemaphores = &computeSemaphores[currentComputeFrame];

        if (vkQueueSubmit(engineDevice.computeQueue, 1, &computeSubmitInfo, computeInFlightFences[currentComputeFrame]) != VK_SUCCESS) 
        {
            throw std::runtime_error("failed to submit compute command buffer!");
        }

        VkDeviceSize bufferSize = sizeof(Phoenix::DataToCompute) * numberOfElements;

        VkBuffer stagingBuffer;
        VkDeviceMemory stagingBufferMemory;
        
        CreateBuffer(bufferSize, VK_BUFFER_USAGE_TRANSFER_DST_BIT,
        VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
        stagingBuffer, stagingBufferMemory);
        CopyBuffer(SSBOBuffers[currentComputeFrame], stagingBuffer, bufferSize, 
        &computeSemaphores[currentComputeFrame]);


        void* bufferData = nullptr;
        vkMapMemory(engineDevice.logicalDevice, stagingBufferMemory, 0, bufferSize, 0, &bufferData);
        memcpy(selectedMeshlet.data(), bufferData, bufferSize);
        vkUnmapMemory(engineDevice.logicalDevice, stagingBufferMemory); 
        
        currentComputeFrame = (currentComputeFrame + 1) % MAX_FRAMES_IN_FLIGHT;

        vkDestroyBuffer(engineDevice.logicalDevice, stagingBuffer, nullptr);
        vkFreeMemory(engineDevice.logicalDevice, stagingBufferMemory, nullptr);
        
    }
    void Renderer::RecordComputeBuffer(int numberOfElements, VkCommandBuffer commandBuffer)
    {
        VkCommandBufferBeginInfo beginInfo{};
        beginInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;

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

        VkDeviceSize ssboSize = sizeof(Phoenix::DataToCompute) * numberOfElements;

        vkCmdBindPipeline(commandBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, enginePipeline.computePipeline);
        vkCmdBindDescriptorSets(commandBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, enginePipeline.computePipelineLayout, 0, 1, 
        &descriptorSets[currentComputeFrame], 0, 0);

        vkCmdDispatch(commandBuffer, numberOfElements / 32, 1, 1);

        if (vkEndCommandBuffer(commandBuffer) != VK_SUCCESS) 
        {
            throw std::runtime_error("failed to record command buffer!");
        }
    }

请问我哪里错了？

错误分析与解决方案

核心错误点

未等待Compute执行完成就读取数据：提交Compute命令后直接执行Copy和内存读取操作，此时GPU可能还没完成Compute Shader的计算，拿到的是旧数据或未初始化数据。
Fence未起到同步作用：提交命令时关联了Fence，但没有等待Fence触发就继续后续流程，完全没利用Fence做CPU-GPU同步。
Semaphore逻辑缺失：CopyBuffer传入了Semaphore，但未确保Copy操作等待Compute Shader执行完成，同步链条断裂。
帧索引循环冲突：每次调用DispatchCompute都会切换currentComputeFrame，如果实例数量大于MAX_FRAMES_IN_FLIGHT，会覆盖未完成的命令缓冲区或Fence，导致数据混乱。

修复步骤

1. 强制CPU等待Compute执行完成

在提交Compute命令后，添加Fence等待逻辑，确保GPU完成计算后再处理结果：

// 提交Compute命令后
if (vkQueueSubmit(engineDevice.computeQueue, 1, &computeSubmitInfo, computeInFlightFences[currentComputeFrame]) != VK_SUCCESS) 
{
    throw std::runtime_error("failed to submit compute command buffer!");
}

// 等待Compute Shader执行完毕
vkWaitForFences(engineDevice.logicalDevice, 1, &computeInFlightFences[currentComputeFrame], VK_TRUE, UINT64_MAX);
vkResetFences(engineDevice.logicalDevice, 1, &computeInFlightFences[currentComputeFrame]); // 重置Fence供下次使用

2. 完善Copy操作的同步逻辑

如果CopyBuffer是异步提交到队列的，需要在Copy的提交信息中添加对Compute Semaphore的等待。更简单的方式是将Copy命令合并到Compute的命令缓冲区中，并添加内存屏障确保Compute写入完成后再执行Copy：

// 在RecordComputeBuffer的vkCmdDispatch之后添加内存屏障
VkMemoryBarrier barrier{};
barrier.sType = VK_STRUCTURE_TYPE_MEMORY_BARRIER;
barrier.srcAccessMask = VK_ACCESS_SHADER_WRITE_BIT; // Compute Shader的写入权限
barrier.dstAccessMask = VK_ACCESS_TRANSFER_READ_BIT; // Copy操作的读取权限

vkCmdPipelineBarrier(commandBuffer,
    VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT,
    VK_PIPELINE_STAGE_TRANSFER_BIT,
    0,
    1, &barrier,
    0, nullptr,
    0, nullptr);

// 直接在当前命令缓冲区添加Copy命令
vkCmdCopyBuffer(commandBuffer, SSBOBuffers[currentComputeFrame], stagingBuffer, 1, &copyRegion);

3. 重构循环调用的帧索引管理

如果实例数量大于MAX_FRAMES_IN_FLIGHT，不要每次调用都切换帧索引，改为批量提交所有Compute任务后统一等待：

// 批量录制所有Compute命令
std::vector<VkCommandBuffer> computeCmds;
for(int i = 0; i < engineModLoader.instanceNumber; i++)
{
    VkCommandBuffer cmd = AllocateTempCommandBuffer();
    // 录制对应实例的Compute命令
    RecordComputeBuffer(phoenixMesh.totalMeshlets.size(), cmd, engineModLoader.instancesData[i].instancePos);
    computeCmds.push_back(cmd);
}

// 批量提交到Compute队列
VkSubmitInfo submitInfo{};
submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
submitInfo.commandBufferCount = computeCmds.size();
submitInfo.pCommandBuffers = computeCmds.data();

VkFence fence;
VkFenceCreateInfo fenceInfo{};
fenceInfo.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO;
fenceInfo.flags = VK_FENCE_CREATE_SIGNALED_BIT;
vkCreateFence(engineDevice.logicalDevice, &fenceInfo, nullptr, &fence);
vkResetFences(engineDevice.logicalDevice, 1, &fence);

if (vkQueueSubmit(engineDevice.computeQueue, 1, &submitInfo, fence) != VK_SUCCESS)
{
    throw std::runtime_error("failed to submit batch compute commands!");
}

// 等待所有Compute任务完成
vkWaitForFences(engineDevice.logicalDevice, 1, &fence, VK_TRUE, UINT64_MAX);

// 清理临时资源
for(auto cmd : computeCmds)
{
    FreeTempCommandBuffer(cmd);
}
vkDestroyFence(engineDevice.logicalDevice, fence, nullptr);

额外优化建议

避免为每个实例单独调度Compute Shader，尽量合并成一次Dispatch，通过实例ID区分不同实例的处理，减少队列提交开销。
优先使用GPU内部同步（Semaphore）代替CPU等待（Fence），减少CPU-GPU阻塞，提升整体性能。如果必须等待CPU，仅在必要时机执行。

内容的提问来源于stack exchange，提问作者Giuseppe