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 101 of file GpuDispatchCore.cpp.

{
    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 (size_t i = 0; i < m_bindings.size(); ++i) {
        const auto& b = m_bindings[i];
 
        if (i < m_binding_data.size() && !m_binding_data[i].empty()) {
            m_resources.ensure_buffer(i, m_binding_data[i].size());
            m_resources.upload_raw(i, m_binding_data[i].data(), m_binding_data[i].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 = (i < m_output_size_overrides.size() && m_output_size_overrides[i] > 0)
                    ? m_output_size_overrides[i]
                    : fallback_bytes;
                m_resources.ensure_buffer(i, sz);
                if (i < m_output_size_overrides.size() && m_output_size_overrides[i] > 0) {
                    std::vector<uint8_t> zeros(sz, 0);
                    m_resources.upload_raw(i, zeros.data(), sz);
                }
                continue;
            }
        }
 
        switch (b.element_type) {
        case GpuBufferBinding::ElementType::PASSTHROUGH:
            if (i < m_passthrough_bytes.size() && !m_passthrough_bytes[i].empty()) {
                m_resources.ensure_buffer(i, m_passthrough_bytes[i].size());
                m_resources.upload_raw(i, m_passthrough_bytes[i].data(),
                    m_passthrough_bytes[i].size());
            }
            break;
 
        case GpuBufferBinding::ElementType::IMAGE_STORAGE: {
            if (i >= m_image_bindings.size() || !m_image_bindings[i].image)
                continue;
            auto& img = m_image_bindings[i].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(i, img, b);
        } break;
 
        case GpuBufferBinding::ElementType::IMAGE_SAMPLED: {
            if (i >= m_image_bindings.size() || !m_image_bindings[i].image)
                continue;
            auto& img = m_image_bindings[i].image;
            auto sampler = m_image_bindings[i].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(i, 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(i, raw_bytes);
                m_resources.upload_raw(i,
                    reinterpret_cast<const uint8_t*>(channels[0].data()),
                    raw_bytes);
            }
            break;
 
        case GpuBufferBinding::ElementType::FLOAT32:
        default:
            m_resources.ensure_buffer(i, float_byte_size);
            m_resources.upload(i, 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, MayaFlux::Yantra::GpuResourceManager::ensure_buffer(), flatten_channels_to_staging(), MayaFlux::Yantra::GpuBufferBinding::FLOAT32, MayaFlux::Kakshya::ContainerDataStructure::get_total_elements(), MayaFlux::Yantra::GpuBufferBinding::IMAGE_SAMPLED, MayaFlux::Yantra::GpuBufferBinding::IMAGE_STORAGE, MayaFlux::Yantra::GpuBufferBinding::INT32, m_binding_data, m_bindings, m_image_bindings, m_output_size_overrides, m_passthrough_bytes, m_resources, m_staging_floats, MayaFlux::Yantra::GpuBufferBinding::OUTPUT, MayaFlux::Yantra::GpuBufferBinding::PASSTHROUGH, size, MayaFlux::Yantra::GpuResourceManager::transition_image(), MayaFlux::Yantra::GpuBufferBinding::UINT32, MayaFlux::Yantra::GpuResourceManager::upload(), and MayaFlux::Yantra::GpuResourceManager::upload_raw().

Referenced by dispatch_core(), and dispatch_core_chained().

Here is the call graph for this function:

Here is the caller graph for this function: