以下代码向您展示了我如何将顶点缓冲区数据从暂存缓冲区传输到本地内存缓冲区:

bool Vulkan::UpdateVertexBuffer(std::vector<VERTEX>& data, VULKAN_BUFFER& vertex_buffer)
{
    std::memcpy(this->staging_buffer.pointer, &data[0], vertex_buffer.size);

    size_t flush_size = static_cast<size_t>(vertex_buffer.size);
    unsigned int multiple = static_cast<unsigned int>(flush_size / this->physical_device.properties.limits.nonCoherentAtomSize);
    flush_size = this->physical_device.properties.limits.nonCoherentAtomSize * ((uint64_t)multiple + 1);

    VkMappedMemoryRange flush_range = {};
    flush_range.sType = VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE;
    flush_range.pNext = nullptr;
    flush_range.memory = this->staging_buffer.memory;
    flush_range.offset = 0;
    flush_range.size = flush_size;
    vkFlushMappedMemoryRanges(this->device, 1, &flush_range);

    VkResult result = vkWaitForFences(this->device, 1, &this->transfer.fence, VK_FALSE, 1000000000);
    if(result != VK_SUCCESS) {
        #if defined(_DEBUG)
        std::cout << "UpdateVertexBuffer => vkWaitForFences : Timeout" << std::endl;
        #endif
        return false;
    }
    vkResetFences(this->device, 1, &this->transfer.fence);

    VkCommandBufferBeginInfo command_buffer_begin_info = {};
    command_buffer_begin_info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
    command_buffer_begin_info.pNext = nullptr; 
    command_buffer_begin_info.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT;
    command_buffer_begin_info.pInheritanceInfo = nullptr;

    vkBeginCommandBuffer(this->transfer.command_buffer, &command_buffer_begin_info);

    VkBufferCopy buffer_copy_info = {};
    buffer_copy_info.srcOffset = 0;
    buffer_copy_info.dstOffset = 0;
    buffer_copy_info.size = vertex_buffer.size;

    vkCmdCopyBuffer(this->transfer.command_buffer, this->staging_buffer.handle, vertex_buffer.handle, 1, &buffer_copy_info);

    VkBufferMemoryBarrier buffer_memory_barrier = {};
    buffer_memory_barrier.sType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER;
    buffer_memory_barrier.pNext = nullptr;
    buffer_memory_barrier.srcAccessMask = VK_ACCESS_MEMORY_WRITE_BIT;
    buffer_memory_barrier.dstAccessMask = VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT;
    buffer_memory_barrier.srcQueueFamilyIndex = this->queue_stack[this->transfer_stack_index].index;
    buffer_memory_barrier.dstQueueFamilyIndex = this->queue_stack[this->graphics_stack_index].index;
    buffer_memory_barrier.buffer = vertex_buffer.handle;
    buffer_memory_barrier.offset = 0;
    buffer_memory_barrier.size = VK_WHOLE_SIZE;

    vkCmdPipelineBarrier(this->transfer.command_buffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_VERTEX_INPUT_BIT, 0, 0, nullptr, 1, &buffer_memory_barrier, 0, nullptr);

    vkEndCommandBuffer(this->transfer.command_buffer);

    VkSubmitInfo submit_info = {};
    submit_info.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
    submit_info.pNext = nullptr;
    submit_info.waitSemaphoreCount = 0;
    submit_info.pWaitSemaphores = nullptr;
    submit_info.pWaitDstStageMask = nullptr;
    submit_info.commandBufferCount = 1;
    submit_info.pCommandBuffers = &this->transfer.command_buffer;
    submit_info.signalSemaphoreCount = 0;
    submit_info.pSignalSemaphores = nullptr;

    VkResult result = vkQueueSubmit(this->queue_stack[this->transfer_stack_index].handle, 1, &submit_info, this->transfer.fence);
    if(result != VK_SUCCESS) {
        #if defined(_DEBUG)
        std::cout << "UpdateVertexBuffer => vkQueueSubmit : Failed" << std::endl;
        #endif
        return false;
    }

    #if defined(_DEBUG)
    std::cout << "UpdateVertexBuffer : Success" << std::endl;
    #endif
    return true;
}

它在没有任何验证层警告的情况下完美运行。但是当我两次调用 i 时，两个缓冲区都包含来自第二次调用的相同数据。例如:

UpdateVertexBuffer(cube_data, cube_buffer);
UpdateVertexBuffer(prism_data, prism_buffer);

这将导致在 cube_buffer 和 prism_buffer 中都有一个棱镜。要解决此问题，我只需在两次调用之间等待几毫秒即可:

UpdateVertexBuffer(cube_data, cube_buffer);
std::this_thread::sleep_for(std::chrono::milliseconds(100));
UpdateVertexBuffer(prism_data, prism_buffer);

或者更好的是，我可以通过调用来替换围栏 vkQueueWaitIdle(this->queue_stack[this->transfer_stack_index].handle);

在我看来，这将导致性能损失，并且栅栏应该是等待传输操作正确完成的最佳方式，那么为什么当我使用栅栏时我的第一个缓冲区被第二个填充。有没有一种方法可以在不使用 vkQueueWaitIdle 的情况下正确执行此操作。

感谢您的帮助。

最佳答案

您已经将数据写入暂存缓冲区，之后您等待上一次上传的围栏。那太晚了；栅栏是为了防止您将数据写入正在读取的内存。

但实际上，您的问题是您的设计有误。您的设计使得顺序更新都使用相同的内存。他们不应该。相反，顺序更新应该使用同一内存的不同区域，以便它们不能重叠。这样，您就可以执行传输，而不必在栅栏上等待(或者至少，不必等到下一帧)。

基本上，您应该像对待环形缓冲区一样对待暂存缓冲区。每个想要执行一些分段传输工作的操作都应该从分段环形缓冲区“分配”X 字节的内存。暂存缓冲区系统按顺序分配内存，如果空间不足则回绕。但它也记得它同步的最后一个内存区域在哪里。如果您尝试暂存太多工作，则必须进行同步。

此外，映射内存背后的目的之一是您可以直接写入该内存，而不是写入其他 CPU 内存并将其复制进去。因此，与其传入 VULKAN_BUFFER (不管那是什么)，生成该数据的进程应该已经获取了一个指向事件暂存缓冲区区域的指针并将其数据写入该区域。

哦，还有一件事:永远，永远 创建命令缓冲区并立即提交。只是不要这样做。 vkQueueSubmit 可以使用多个命令缓冲区和多个批处理 命令缓冲区是有原因的。对于任何一个队列，您不应该每帧提交超过一次(或可能两次)。

关于c++ - 是否可以在不调用 vkQueueWaitIdle 的情况下等待暂存缓冲区的传输完成，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/56668424/