download_back_buffer_async()

MAYAFLUX_API TransferHandle MayaFlux::Buffers::download_back_buffer_async	(	const VKBufferResources::GenerationSlot &	slot,
		size_t	size,
		std::shared_ptr< VKBuffer > &	staging,
		size_t	staging_offset = 0
	)

Record a slot-to-staging copy without waiting for completion.

Parameters

slot	Source slot, typically from VKBuffer::get_back_buffer().
size	Byte count to copy.
staging	Staging buffer, already large enough for staging_offset + size. Not grown here: reallocating mid-batch would orphan copies already recorded against the old allocation. Size it with create_staging_buffer before the batch.
staging_offset	Byte offset within staging the copy lands at, so several reads share one staging buffer and their transfers overlap instead of serialising one round trip each.

Returns

Handle to pass to resolve_back_buffer_read, or null for host-visible slots where no transfer was recorded.

Mirrors upload_back_buffer_async with the direction reversed, and with one asymmetry: an upload's memcpy precedes the fence, a download's follows it, so the host copy lives in resolve_back_buffer_read rather than here. download_back_buffer is the two called back to back.

Note the naming clash with download_from_gpu_async, which is a different family: that one operates on a whole VKBuffer, waits internally, and means only that it avoids queue.waitIdle.

Definition at line 298 of file StagingUtils.cpp.

{
    if (size == 0 || slot.mapped_ptr)
        return {};
 
    auto buffer_service = Registry::BackendRegistry::instance()
                              .get_service<Registry::Service::BufferService>();
 
    if (!buffer_service
        || !buffer_service->execute_fenced
        || !buffer_service->wait_fenced
        || !buffer_service->release_fenced
        || !buffer_service->invalidate_range) {
        error<std::runtime_error>(
            Journal::Component::Buffers,
            Journal::Context::BufferProcessing,
            std::source_location::current(),
            "download_back_buffer_async: BufferService unavailable");
    }
 
    if (!staging || staging->get_size_bytes() < staging_offset + size)
        staging = create_staging_buffer(staging_offset + size);
 
    return buffer_service->copy_buffer_fenced(
        static_cast<void*>(slot.buffer),
        static_cast<void*>(staging->get_buffer()),
        size, 0, staging_offset);
}

References MayaFlux::Buffers::VKBufferResources::GenerationSlot::buffer, MayaFlux::Journal::BufferProcessing, MayaFlux::Journal::Buffers, create_staging_buffer(), MayaFlux::Registry::BackendRegistry::get_service(), MayaFlux::Registry::BackendRegistry::instance(), MayaFlux::Buffers::VKBufferResources::GenerationSlot::mapped_ptr, and size.

Referenced by download_back_buffer(), MayaFlux::Buffers::VolumeGridBuffer::read_fields(), and MayaFlux::Buffers::DataReadProcessor::submit_read().

Here is the call graph for this function:

Here is the caller graph for this function: