prepare_dependency()

GpuDispatchCore::DependencyPlan MayaFlux::Yantra::GpuDispatchCore::prepare_dependency ( const std::vector< DependencyStage > &  stages )

private

Definition at line 375 of file GpuDispatchCore.cpp.

{
    const GpuComputeConfig original_config = m_gpu_config;
    const auto original_bindings = m_bindings;
    const auto original_image_bindings = m_image_bindings;
    const auto original_binding_data = m_binding_data;
    const auto original_passthrough_bytes = m_passthrough_bytes;
    const auto original_push_constants = m_push_constants;
 
    DependencyPlan plan;
    auto& keys = plan.keys;
    auto& groups_per_key = plan.groups;
    auto& pc_per_key = plan.push_constants;
    auto& hazards_per_key = plan.hazards;
    auto& indirect_per_key = plan.indirect;
 
    keys.reserve(stages.size());
    groups_per_key.reserve(stages.size());
    pc_per_key.reserve(stages.size());
    hazards_per_key.reserve(stages.size());
    indirect_per_key.reserve(stages.size());
 
    for (const auto& stage : stages) {
        m_gpu_config = stage.config;
        update_dispatch_key_cache();
        m_bindings = declare_buffer_bindings();
        m_image_bindings.clear();
        m_binding_data.clear();
        m_passthrough_bytes.clear();
        m_push_constants.clear();
 
        stage.stage_fn(*this);
 
        if (!ensure_gpu_ready()) {
            error<std::runtime_error>(Journal::Component::Yantra,
                Journal::Context::BufferProcessing,
                std::source_location::current(),
                "GpuDispatchCore: dispatch_core_dependency failed to initialise key '{}'",
                stage.config.shader_path);
        }
 
        prepare_gpu_inputs({}, {});
 
        bind_all_descriptors();
 
        keys.push_back(dispatch_key());
        groups_per_key.push_back(stage.explicit_groups ? *stage.explicit_groups : calculate_dispatch_size(largest_binding_data_element_count(), {}));
        pc_per_key.push_back(m_push_constants);
        hazards_per_key.push_back(stage.hazard_fn ? stage.hazard_fn(*this) : std::vector<Portal::Graphics::HazardResource> {});
 
        Portal::Graphics::IndirectDispatch indirect;
        if (stage.indirect_groups) {
            indirect.buffer = m_resources.shared_buffer_handle(stage.indirect_groups->set, stage.indirect_groups->binding).buffer;
            indirect.offset = stage.indirect_groups->offset_bytes;
        }
        indirect_per_key.push_back(indirect);
    }
 
    m_gpu_config = original_config;
    update_dispatch_key_cache();
    m_bindings = original_bindings;
    m_image_bindings = original_image_bindings;
    m_binding_data = original_binding_data;
    m_passthrough_bytes = original_passthrough_bytes;
    m_push_constants = original_push_constants;
 
    return plan;
}

References bind_all_descriptors(), MayaFlux::Portal::Graphics::IndirectDispatch::buffer, MayaFlux::Portal::Graphics::GpuBufferHandle::buffer, MayaFlux::Journal::BufferProcessing, calculate_dispatch_size(), declare_buffer_bindings(), dispatch_key(), ensure_gpu_ready(), MayaFlux::Yantra::GpuDispatchCore::DependencyPlan::groups, MayaFlux::Yantra::GpuDispatchCore::DependencyPlan::hazards, MayaFlux::Yantra::GpuDispatchCore::DependencyPlan::indirect, MayaFlux::Yantra::GpuDispatchCore::DependencyPlan::keys, largest_binding_data_element_count(), m_binding_data, m_bindings, m_gpu_config, m_image_bindings, m_passthrough_bytes, m_push_constants, m_resources, MayaFlux::Portal::Graphics::IndirectDispatch::offset, prepare_gpu_inputs(), MayaFlux::Yantra::GpuDispatchCore::DependencyPlan::push_constants, MayaFlux::Yantra::GpuResourceManager::shared_buffer_handle(), update_dispatch_key_cache(), and MayaFlux::Journal::Yantra.

Referenced by dispatch_core_dependency(), and dispatch_core_dependency_async().

Here is the call graph for this function:

Here is the caller graph for this function: