prepare_gpu_inputs()

void MayaFlux::Yantra::GpuDispatchCore::prepare_gpu_inputs ( const std::vector< std::vector< double > > &  channels, const DataStructureInfo &  structure_info  )

protectedvirtual

Marshal channel data into GPU input buffers.

Handles FLOAT32, UINT32, INT32, PASSTHROUGH, IMAGE_STORAGE, and IMAGE_SAMPLED binding kinds. Called after flatten_channels_to_staging.

Definition at line 109 of file GpuDispatchCore.cpp.

{
    const auto& key = dispatch_key();
 
    flatten_channels_to_staging(channels, structure_info);
    const size_t float_byte_size = m_staging_floats.size() * sizeof(float);
 
    const size_t fallback_bytes = float_byte_size > 0
        ? float_byte_size
        : Kakshya::ContainerDataStructure::get_total_elements(structure_info.dimensions) * sizeof(float);
 
    for (auto b : m_bindings) {
        const size_t idx = b.binding;
 
        if (idx < m_binding_data.size() && !m_binding_data[idx].empty()) {
            m_resources.ensure_buffer(key, idx, m_binding_data[idx].size());
            m_resources.upload_raw(key, idx, m_binding_data[idx].data(), m_binding_data[idx].size());
            continue;
        }
 
        if (b.direction == GpuBufferBinding::Direction::OUTPUT) {
            const auto et = b.element_type;
            if (et == GpuBufferBinding::ElementType::IMAGE_STORAGE
                || et == GpuBufferBinding::ElementType::IMAGE_SAMPLED) {
            } else {
                const size_t sz = (idx < m_output_size_overrides.size() && m_output_size_overrides[idx] > 0)
                    ? m_output_size_overrides[idx]
                    : fallback_bytes;
                m_resources.ensure_buffer(key, idx, sz);
                if (idx < m_output_size_overrides.size() && m_output_size_overrides[idx] > 0) {
                    std::vector<uint8_t> zeros(sz, 0);
                    m_resources.upload_raw(key, idx, zeros.data(), sz);
                }
                continue;
            }
        }
 
        switch (b.element_type) {
        case GpuBufferBinding::ElementType::PASSTHROUGH:
            if (idx < m_passthrough_bytes.size() && !m_passthrough_bytes[idx].empty()) {
                m_resources.ensure_buffer(key, idx, m_passthrough_bytes[idx].size());
                m_resources.upload_raw(key, idx, m_passthrough_bytes[idx].data(),
                    m_passthrough_bytes[idx].size());
            }
            break;
 
        case GpuBufferBinding::ElementType::IMAGE_STORAGE: {
            if (idx >= m_image_bindings.size() || !m_image_bindings[idx].image)
                continue;
            auto& img = m_image_bindings[idx].image;
            if (img->get_current_layout() != vk::ImageLayout::eGeneral) {
                m_resources.transition_image(img, img->get_current_layout(),
                    vk::ImageLayout::eGeneral);
            }
            m_resources.bind_image_storage(key, idx, img, b);
        } break;
 
        case GpuBufferBinding::ElementType::IMAGE_SAMPLED: {
            if (idx >= m_image_bindings.size() || !m_image_bindings[idx].image)
                continue;
            auto& img = m_image_bindings[idx].image;
            auto sampler = m_image_bindings[idx].sampler;
            if (img->get_current_layout() != vk::ImageLayout::eShaderReadOnlyOptimal) {
                m_resources.transition_image(img, img->get_current_layout(),
                    vk::ImageLayout::eShaderReadOnlyOptimal);
            }
            m_resources.bind_image_sampled(key, idx, img, sampler, b);
        } break;
 
        case GpuBufferBinding::ElementType::UINT32:
        case GpuBufferBinding::ElementType::INT32:
            if (!channels.empty()) {
                const size_t raw_bytes = channels[0].size()
                    * (b.element_type == GpuBufferBinding::ElementType::UINT32
                            ? sizeof(uint32_t)
                            : sizeof(int32_t));
                m_resources.ensure_buffer(key, idx, raw_bytes);
                m_resources.upload_raw(key, idx,
                    reinterpret_cast<const uint8_t*>(channels[0].data()),
                    raw_bytes);
            }
            break;
 
        case GpuBufferBinding::ElementType::FLOAT32:
        default:
            if (!m_native_staging_bytes.empty()) {
                m_resources.ensure_buffer(key, idx, m_native_staging_bytes.size());
                m_resources.upload_raw(key, idx, m_native_staging_bytes.data(), m_native_staging_bytes.size());
            } else {
                m_resources.ensure_buffer(key, idx, float_byte_size);
                m_resources.upload(key, idx, m_staging_floats.data(), float_byte_size);
            }
            break;
        }
    }
}

References b, MayaFlux::Yantra::GpuResourceManager::bind_image_sampled(), MayaFlux::Yantra::GpuResourceManager::bind_image_storage(), MayaFlux::Yantra::DataStructureInfo::dimensions, dispatch_key(), MayaFlux::Yantra::GpuResourceManager::ensure_buffer(), flatten_channels_to_staging(), MayaFlux::Portal::Graphics::GpuBufferBinding::FLOAT32, MayaFlux::Kakshya::ContainerDataStructure::get_total_elements(), MayaFlux::Portal::Graphics::GpuBufferBinding::IMAGE_SAMPLED, MayaFlux::Portal::Graphics::GpuBufferBinding::IMAGE_STORAGE, MayaFlux::Portal::Graphics::GpuBufferBinding::INT32, m_binding_data, m_bindings, m_image_bindings, m_native_staging_bytes, m_output_size_overrides, m_passthrough_bytes, m_resources, m_staging_floats, MayaFlux::Portal::Graphics::GpuBufferBinding::OUTPUT, MayaFlux::Portal::Graphics::GpuBufferBinding::PASSTHROUGH, MayaFlux::Yantra::GpuResourceManager::transition_image(), MayaFlux::Portal::Graphics::GpuBufferBinding::UINT32, MayaFlux::Yantra::GpuResourceManager::upload(), and MayaFlux::Yantra::GpuResourceManager::upload_raw().

Referenced by dispatch_core(), dispatch_core_async(), dispatch_core_chained(), dispatch_core_chained_indirect(), and dispatch_core_dependency().

Here is the call graph for this function:

Here is the caller graph for this function: