initialise()

bool MayaFlux::Yantra::GpuResourceManager::initialise	(	const std::string &	key,
		const GpuComputeConfig &	config,
		const std::vector< GpuBufferBinding > &	bindings
	)

Create (or confirm existing) pipeline for the given key.

Create-if-absent: if a unit already exists and is ready for this key, returns true immediately without recreating anything. Call release(key) first to force recreation with a different config.

Definition at line 202 of file GpuResourceManager.cpp.

{
    if (const auto* existing = find_unit(key); existing && existing->ready)
        return true;
 
    auto& foundry = Portal::Graphics::get_shader_foundry();
    auto& compute_press = Portal::Graphics::get_compute_press();
 
    auto unit = std::make_unique<PipelineUnit>();
 
    if (config.shader_id != Portal::Graphics::INVALID_SHADER) {
        unit->shader_id = config.shader_id;
    } else {
        unit->shader_id = foundry.load_shader(config.shader_path);
    }
 
    if (unit->shader_id == Portal::Graphics::INVALID_SHADER) {
        MF_ERROR(Journal::Component::Yantra, Journal::Context::BufferProcessing,
            "GpuResourceManager: failed to load shader '{}' for key '{}'",
            config.shader_path.empty() ? "<generated>" : config.shader_path, key);
        return false;
    }
 
    std::map<uint32_t, std::vector<Portal::Graphics::DescriptorBindingInfo>> by_set;
    for (const auto& b : bindings) {
        const auto et = b.element_type;
        const bool is_image = et == GpuBufferBinding::ElementType::IMAGE_STORAGE
            || et == GpuBufferBinding::ElementType::IMAGE_SAMPLED;
        if (is_image) {
            by_set[b.set].push_back({
                .set = b.set,
                .binding = b.binding,
                .type = element_type_to_vk(et),
            });
        }
    }
 
    for (const auto& b : bindings) {
        const auto et = b.element_type;
        const bool is_image = et == GpuBufferBinding::ElementType::IMAGE_STORAGE
            || et == GpuBufferBinding::ElementType::IMAGE_SAMPLED;
        if (!is_image) {
            by_set[b.set].push_back({
                .set = b.set,
                .binding = b.binding,
                .type = vk::DescriptorType::eStorageBuffer,
            });
        }
    }
 
    std::vector<std::vector<Portal::Graphics::DescriptorBindingInfo>> descriptor_sets;
    descriptor_sets.reserve(by_set.size());
    for (auto& [set_idx, set_bindings] : by_set)
        descriptor_sets.push_back(std::move(set_bindings));
 
    unit->pipeline_id = compute_press.create_pipeline(
        unit->shader_id, descriptor_sets, config.push_constant_size);
 
    if (unit->pipeline_id == Portal::Graphics::INVALID_COMPUTE_PIPELINE) {
        MF_ERROR(Journal::Component::Yantra, Journal::Context::BufferProcessing,
            "GpuResourceManager: failed to create pipeline for key '{}'", key);
        foundry.destroy_shader(unit->shader_id);
        return false;
    }
 
    unit->descriptor_set_ids = compute_press.allocate_pipeline_descriptors(unit->pipeline_id);
    if (unit->descriptor_set_ids.empty()) {
        MF_ERROR(Journal::Component::Yantra, Journal::Context::BufferProcessing,
            "GpuResourceManager: failed to allocate descriptor sets for key '{}'", key);
        compute_press.destroy_pipeline(unit->pipeline_id);
        foundry.destroy_shader(unit->shader_id);
        return false;
    }
 
    unit->impl = std::make_unique<GpuResourceManagerImpl>();
    size_t max_binding = 0;
    for (const auto& b : bindings)
        max_binding = std::max(max_binding, static_cast<size_t>(b.binding));
    const size_t capacity = bindings.empty() ? 0 : max_binding + 1;
    unit->impl->buffers.resize(capacity);
    unit->buffer_slots.resize(capacity);
    unit->image_slots.resize(capacity);
    unit->ready = true;
 
    m_units[key] = std::move(unit);
    return true;
}

References b, MayaFlux::Journal::BufferProcessing, find_unit(), MayaFlux::Portal::Graphics::get_compute_press(), MayaFlux::Portal::Graphics::get_shader_foundry(), MayaFlux::Portal::Graphics::GpuBufferBinding::IMAGE_SAMPLED, MayaFlux::Portal::Graphics::GpuBufferBinding::IMAGE_STORAGE, MayaFlux::Portal::Graphics::INVALID_COMPUTE_PIPELINE, MayaFlux::Portal::Graphics::INVALID_SHADER, MayaFlux::is_image(), m_units, MF_ERROR, MayaFlux::Portal::Graphics::GpuComputeConfig::push_constant_size, MayaFlux::Portal::Graphics::GpuComputeConfig::shader_id, MayaFlux::Portal::Graphics::GpuComputeConfig::shader_path, and MayaFlux::Journal::Yantra.

Referenced by MayaFlux::Yantra::GpuDispatchCore::ensure_gpu_ready().

Here is the call graph for this function:

Here is the caller graph for this function: