C++ Vulkan:缓冲区复制期间设备丢失

我在提交缓冲区复制命令时遇到了很大的困难，这对我来说毫无意义。当我尝试从暂存缓冲区复制到设备本地缓冲区时，验证层出现“设备丢失”错误。真正让人困惑的是，它只在我以特定方式调用copy函数时才会发生

代码如下：

Buffer.cpp

#include "Buffer.h"

namespace vkr
{
    Buffer::Buffer() : buffer(VK_NULL_HANDLE), size(0) {}

    Buffer::Buffer(
        const VmaAllocator & _allocator,
        const vk::DeviceSize bufferSize,
        const vk::BufferUsageFlags usage,
        const VmaMemoryUsage memoryUsageFlags
    ) :
        size(bufferSize)
    {
        vk::BufferCreateInfo bufferInfo = {};
        bufferInfo.size = size;
        bufferInfo.usage = usage;
        bufferInfo.sharingMode = vk::SharingMode::eExclusive;

        VmaAllocationCreateInfo allocInfo = {};
        allocInfo.usage = memoryUsageFlags;

        auto vanillaBufferInfo = (VkBufferCreateInfo)bufferInfo;

        vmaCreateBuffer(_allocator, &vanillaBufferInfo, &allocInfo, &buffer, &allocation, nullptr);
    }

    Buffer::Buffer(Buffer && otherBuffer)
    {
        buffer = otherBuffer.buffer;
        allocation = otherBuffer.allocation;
        size = otherBuffer.size;

        otherBuffer.buffer = VK_NULL_HANDLE;
        otherBuffer.allocation = VmaAllocation();
        otherBuffer.size = 0;
    }

    Buffer & Buffer::operator=(Buffer && otherBuffer)
    {
        if (this != &otherBuffer) {
            buffer = otherBuffer.buffer;
            allocation = otherBuffer.allocation;
            size = otherBuffer.size;

            otherBuffer.buffer = VK_NULL_HANDLE;
            otherBuffer.allocation = VmaAllocation();
            otherBuffer.size = 0;
        }
        return *this;
    }

    Buffer::operator vk::Buffer() const
    {
        return vk::Buffer(buffer);
    }

    Buffer::operator VkBuffer() const
    {
        return buffer;
    }

    void Buffer::copyInto(const VmaAllocator & _allocator, const void* dataSrc)
    {
        void* mappedData;
        vmaMapMemory(_allocator, allocation, &mappedData);
        memcpy(mappedData, dataSrc, (size_t)size);
        vmaUnmapMemory(_allocator, allocation);
    }

    void Buffer::copyInto(const VmaAllocator & _allocator, const void* dataSrc, const size_t newSize)
    {
        void* mappedData;

        vmaMapMemory(_allocator, allocation, &mappedData);
        memcpy(mappedData, dataSrc, newSize);
        vmaUnmapMemory(_allocator, allocation);
    }

    void Buffer::destroy(const VmaAllocator & _allocator)
    {
        vmaDestroyBuffer(_allocator, buffer, allocation);
    }
}

分段缓冲区：

#include "StagedBufferFactory.h"


namespace vkr
{
    namespace StagedBufferFactory
    {
        vkr::Buffer create(
            vk::Device & device,
            vk::CommandPool & commandPool,
            vk::Queue & graphicsQueue,
            const vk::BufferUsageFlags usageFlags,
            const vk::DeviceSize size,
            const void * dataSrc,
            const VmaAllocator & _allocator
        )
        {
            // Staging buffer that we load the data onto that's visible to our CPU
            vk::BufferUsageFlags stagingUsageFlags = vk::BufferUsageFlagBits::eTransferSrc;
            vkr::Buffer stagingBuffer{ _allocator, size, stagingUsageFlags, VMA_MEMORY_USAGE_CPU_ONLY };
            stagingBuffer.copyInto(_allocator, &dataSrc, (size_t)size);

            // This is our buffer located on our GPU, inaccessible to our CPU
            vk::BufferUsageFlags gpuBufferUsageFlags = vk::BufferUsageFlagBits::eTransferDst | usageFlags;
            vkr::Buffer gpuBuffer{ _allocator, size, gpuBufferUsageFlags, VMA_MEMORY_USAGE_GPU_ONLY };

            copyBuffer(device, commandPool, graphicsQueue, stagingBuffer, gpuBuffer);

            stagingBuffer.destroy(_allocator);

            return gpuBuffer;
        }

        void copyBuffer(
            vk::Device & device,
            vk::CommandPool & commandPool,
            vk::Queue & graphicsQueue,
            vkr::Buffer & stagingBuffer,
            vkr::Buffer & gpuBuffer
        )
        {
            vk::CommandBufferAllocateInfo allocInfo = {};
            allocInfo.level = vk::CommandBufferLevel::ePrimary;
            allocInfo.commandPool = commandPool;
            allocInfo.commandBufferCount = 1;

            vk::CommandBuffer commandBuffer;
            device.allocateCommandBuffers(&allocInfo, &commandBuffer);

            vk::CommandBufferBeginInfo beginInfo = {};
            beginInfo.flags = vk::CommandBufferUsageFlagBits::eOneTimeSubmit;

            commandBuffer.begin(&beginInfo);

            vk::BufferCopy copyRegion = {};
            copyRegion.srcOffset = 0;
            copyRegion.dstOffset = 0;
            copyRegion.size = stagingBuffer.size;
            commandBuffer.copyBuffer(stagingBuffer.buffer, gpuBuffer.buffer, 1, &copyRegion);

            commandBuffer.end();

            vk::SubmitInfo submitInfo = {};
            submitInfo.commandBufferCount = 1;
            submitInfo.pCommandBuffers = &commandBuffer;

            // Create fence to ensure that the command buffer has finished executing
            vk::FenceCreateInfo fenceInfo{};
            vk::Fence fence = device.createFence(fenceInfo);

            // Submit to the queue
            graphicsQueue.submit(1, &submitInfo, fence);
            graphicsQueue.waitIdle();
            //device.waitForFences({ fence }, true, 100000000000);
            device.destroyFence(fence);

            device.free(commandPool, 1, &commandBuffer);
        }
    }
}

缓冲区创建：

void HelloTriangleApplication::createIndexBuffer()
{
    vk::DeviceSize bufferSize = sizeof(indices[0]) * indices.size();

    //// Staging buffer that we load the data onto that's visible to our CPU
    vk::BufferUsageFlags stagingUsageFlags = vk::BufferUsageFlagBits::eTransferSrc;
    vkr::Buffer stagingBuffer{ vulkanAllocator, bufferSize, stagingUsageFlags, VMA_MEMORY_USAGE_CPU_ONLY };

    stagingBuffer.copyInto(vulkanAllocator, indices.data());

    //// This is our buffer located on our GPU, inaccessible to our CPU
    vk::BufferUsageFlags indexUsageFlags = vk::BufferUsageFlagBits::eTransferDst | vk::BufferUsageFlagBits::eIndexBuffer;
    indexBuffer = vkr::Buffer{ vulkanAllocator, bufferSize, indexUsageFlags, VMA_MEMORY_USAGE_GPU_ONLY };

    vkr::StagedBufferFactory::copyBuffer(device, commandPool, graphicsQueue, stagingBuffer, indexBuffer);

    stagingBuffer.destroy(vulkanAllocator);
}

所以这段代码没有问题。。。但是，如果我尝试使用我的

vkr:：StagedBuffer:：create

函数（据我所知，该函数调用的正是这段代码），程序就无法运行。我得到一个黑屏（而不是彩虹色的矩形），偶尔验证层会告诉我“设备丢失”

---

我正在发疯，我绝对不明白为什么会出现这种情况。

正如弗兰克指出的，这都是由于我上面发布的

vkr:：StagedBufferFactory:：create

代码中的语法错误造成的。我无意中使用了传入的

dataSrc

指针的指针，导致我试图用垃圾填充VkBuffer。

&dataSrc

是本地堆栈变量的地址，您可能是指

dataSrc

，因此您的索引缓冲区充满垃圾，这可能是问题的原因，也可能不是问题的原因。这肯定会导致黑屏，但我不太确定验证错误。在处理越界索引时，这可能是驱动程序中的一个错误？哦，天哪，这几乎肯定是问题所在。我今晚会试试看，确认一下。谢谢你的帮助！不幸的是，这样的问题很常见，也很难发现。如果存在与您描述的问题类似的问题，在大多数情况下，这是代码中的错误-未初始化变量，传递指向临时变量的指针等。如果此问题得到解决，请将此标记为正确答案，以便将其从未回答问题列表中删除。解决此类错误的一个好机制是避免将

void*

作为函数参数，而是使用模板允许您传入类型化数据引用，而不是指针。这也会导致呼叫端的代码更干净。谢谢你的建议，杰里科，我会调查的！

void HelloTriangleApplication::createIndexBuffer()
{
    vk::DeviceSize bufferSize = sizeof(indices[0]) * indices.size();

    indexBuffer = vkr::StagedBufferFactory::create(device, commandPool, graphicsQueue, vk::BufferUsageFlagBits::eIndexBuffer, bufferSize, indices.data(), vulkanAllocator);
}