read_fields()

void MayaFlux::Buffers::VolumeGridBuffer::read_fields	(	const std::vector< std::string > &	names,
		const std::vector< std::pair< void *, size_t > > &	dsts
	)

Read several fields' current values into host memory at once.

One staging buffer and one fence wait for the whole batch, rather than a full round trip per field. Prefer this over repeated read_field when more than one field is wanted from the same cycle, which is the ordinary case for interchange export.

Reads from each field's current read slot, as read_field does. A name that is not declared, or a size that does not match that field, is logged and skipped; the rest of the batch proceeds.

Parameters

names	Field names.
dsts	Destination pointer and byte count per name, parallel to names.

Definition at line 685 of file VolumeGridBuffer.cpp.

{
    if (names.size() != dsts.size()) {
        MF_ERROR(Journal::Component::Buffers, Journal::Context::BufferManagement,
            "VolumeGridBuffer::read_fields: {} names against {} destinations",
            names.size(), dsts.size());
        return;
    }
 
    constexpr size_t k_alignment = 16;
 
    auto& resources = get_buffer_resources();
    std::vector<size_t> indices;
    std::vector<size_t> offsets;
    size_t total = 0;
 
    for (size_t i = 0; i < names.size(); ++i) {
        const auto* field = find_field(names[i], "read_fields");
        if (!field) {
            continue;
        }
 
        const size_t expected = static_cast<size_t>(get_cell_count()) * field->stride_bytes;
        if (dsts[i].second != expected) {
            MF_ERROR(Journal::Component::Buffers, Journal::Context::BufferManagement,
                "VolumeGridBuffer::read_fields: size {} does not match expected {} for '{}'",
                dsts[i].second, expected, names[i]);
            continue;
        }
 
        indices.push_back(i);
        offsets.push_back(total);
        total += (dsts[i].second + k_alignment - 1) & ~(k_alignment - 1);
    }
 
    if (indices.empty()) {
        return;
    }
 
    resolve_transfer(m_pending_transfer);
 
    if (!m_transfer_staging || m_transfer_staging->get_size_bytes() < total) {
        m_transfer_staging = create_staging_buffer(total);
    }
 
    std::vector<TransferHandle> handles;
    handles.reserve(indices.size());
 
    for (size_t k = 0; k < indices.size(); ++k) {
        const auto* field = find_field(names[indices[k]], "read_fields");
        const uint32_t slot = field->read_is_a ? field->slot_a : field->slot_b;
        handles.push_back(download_back_buffer_async(
            resources.back_buffers[slot], dsts[indices[k]].second,
            m_transfer_staging, offsets[k]));
    }
 
    for (size_t k = 0; k < indices.size(); ++k) {
        const auto* field = find_field(names[indices[k]], "read_fields");
        const uint32_t slot = field->read_is_a ? field->slot_a : field->slot_b;
        resolve_back_buffer_read(
            handles[k], resources.back_buffers[slot],
            dsts[indices[k]].first, dsts[indices[k]].second,
            m_transfer_staging, offsets[k]);
    }
}

References MayaFlux::Journal::BufferManagement, MayaFlux::Journal::Buffers, MayaFlux::Buffers::create_staging_buffer(), MayaFlux::Buffers::download_back_buffer_async(), find_field(), MayaFlux::Buffers::VKBuffer::get_buffer_resources(), get_cell_count(), indices, m_pending_transfer, m_transfer_staging, MF_ERROR, MayaFlux::Buffers::resolve_back_buffer_read(), MayaFlux::Buffers::resolve_transfer(), and total.

Here is the call graph for this function: