dispatch_core_dependency()

void MayaFlux::Yantra::GpuDispatchCore::dispatch_core_dependency ( const std::vector< DependencyStage > &  stages )

protected

Multi-pipeline dependency dispatch.

For each stage, in order: applies its shader config (swap_shader equivalent), invokes stage_fn to perform whatever staging that stage needs, ensures its GpuResourceManager unit exists, binds its descriptors, invokes hazard_fn to resolve hazard resources now that this stage's data exists, then accumulates a Portal::Graphics::ComputeStage. After every stage is prepared, records and submits the full sequence in one command buffer via GpuResourceManager::dispatch_sequence.

Restores the context's original shader config, bindings, and staged data after the sequence runs, so a subsequent unrelated dispatch_core call on this context is unaffected.

Parameters

stages

Ordered list of stage descriptions.

Definition at line 358 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;
 
    std::vector<std::string> keys;
    std::vector<std::array<uint32_t, 3>> groups_per_key;
    std::vector<std::vector<uint8_t>> pc_per_key;
    std::vector<std::vector<Portal::Graphics::HazardResource>> hazards_per_key;
 
    keys.reserve(stages.size());
    groups_per_key.reserve(stages.size());
    pc_per_key.reserve(stages.size());
    hazards_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> {});
    }
 
    m_resources.dispatch_sequence(keys, groups_per_key, pc_per_key, hazards_per_key);
 
    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;
}

References bind_all_descriptors(), MayaFlux::Journal::BufferProcessing, calculate_dispatch_size(), declare_buffer_bindings(), dispatch_key(), MayaFlux::Yantra::GpuResourceManager::dispatch_sequence(), ensure_gpu_ready(), largest_binding_data_element_count(), m_binding_data, m_bindings, m_gpu_config, m_image_bindings, m_passthrough_bytes, m_push_constants, m_resources, prepare_gpu_inputs(), update_dispatch_key_cache(), and MayaFlux::Journal::Yantra.

Referenced by MayaFlux::Yantra::GpuExecutionContext< InputType, OutputType >::execute().

Here is the call graph for this function:

Here is the caller graph for this function: