Method CopyDataFromMemory

layers/gpu_dump/gpu_dump.cpp:33–88

GpuDump::~GpuDump() {}

std::vector<uint8_t> GpuDump::CopyDataFromMemory(VkDeviceAddress memory_addresss, VkDeviceSize copy_size) {
    std::vector<uint8_t> result;
    vvl::span<vvl::Buffer* const> buffer_list = device_state->GetBuffersByAddress(memory_addresss);
    if (buffer_list.empty()) {
        return result;
    }

    auto buffer_state = *buffer_list.begin();
    const vvl::DeviceMemory& memory_state = *buffer_state->MemoryState();

    // Prevent copying OOB of a buffer
    if ((memory_addresss + copy_size) > buffer_state->DeviceAddressRange().end) {
        return result;
    }

    VkDeviceSize offset = memory_addresss - buffer_state->DeviceAddressRange().begin;
    if (memory_state.mappable) {
        uint8_t* data_ptr = static_cast<uint8_t*>(memory_state.p_driver_data);

        if (!memory_state.p_driver_data) {
            // Just use WHOLE_SIZE to avoid issues with partial mappings
            // Example:
            //  The |memory_address| is 0x1001 and |copy_size| is 4, the driver (or at least TestICD) will return back something
            //  aligned to a value like 64, so if the buffer is only 64 bytes, you will now be accessing data over it
            DispatchMapMemory(device, memory_state.VkHandle(), offset, VK_WHOLE_SIZE, 0, (void**)&data_ptr);

            if (memory_state.cache_non_coherent) {
                const VkDeviceSize atom_size = phys_dev_props.limits.nonCoherentAtomSize;
                uint64_t aligned_offset = offset & ~(atom_size - 1);
                if (aligned_offset < offset) {
                    aligned_offset = offset;
                }

                VkMappedMemoryRange memory_range = vku::InitStructHelper();
                memory_range.memory = memory_state.VkHandle();
                memory_range.offset = aligned_offset;
                memory_range.size = VK_WHOLE_SIZE;
                DispatchInvalidateMappedMemoryRanges(device, 1, &memory_range);
            }
        }

        data_ptr += offset;
        result.resize(static_cast<uint32_t>(copy_size));
        memcpy(result.data(), data_ptr, static_cast<uint32_t>(copy_size));

        if (!memory_state.p_driver_data) {
            DispatchUnmapMemory(device, memory_state.VkHandle());
        }
    } else {
        // TODO - Handle non-host visible memory
        // When we add, we need to guard against if trying to read non-aligned data
        //   (which should have a warning already)
    }

    return result;
}

bool GpuDump::ListBuffers(std::ostringstream& ss, VkDeviceAddress address, uint32_t indents, bool new_line_start) {