record_sequence()

void MayaFlux::Portal::Graphics::ComputePress::record_sequence	(	CommandBufferID	cmd_id,
		const std::vector< ComputeStage > &	stages
	)

Record multiple pipeline dispatches into one already-open command buffer, inserting a barrier between each consecutive stage for that stage's hazard_bindings.

Vulkan permits binding different pipelines sequentially within a single command buffer recording — this is not a render-pass-style batching mechanism, only direct multi-pipeline recording plus the hazard barriers each transition needs. Does not submit; caller owns the command buffer's lifetime via ShaderFoundry (begin_commands / submit_and_wait or submit_async), the same as any other recorded sequence of commands.

Image bindings receive an eGeneral -> eGeneral shader write/read hazard barrier via ShaderFoundry::image_barrier. Non-image bindings receive a buffer_barrier with the same access/stage masks. Both use compute-to-compute pipeline stages throughout, since this method is for chaining compute stages only.

Parameters

cmd_id	Command buffer to record into. Must already be active (begun via ShaderFoundry::begin_commands).
stages	Ordered list of pipeline dispatches to record.

Definition at line 395 of file ComputePress.cpp.

{
    auto& foundry = *m_shader_foundry;
 
    for (size_t i = 0; i < stages.size(); ++i) {
        const auto& stage = stages[i];
 
        bind_all(
            cmd_id,
            stage.pipeline_id,
            stage.descriptor_set_ids,
            stage.push_constant_data.empty() ? nullptr : stage.push_constant_data.data(),
            stage.push_constant_data.size());
 
        dispatch(cmd_id, stage.groups[0], stage.groups[1], stage.groups[2]);
 
        for (const auto& hazard : stage.hazard_resources) {
            if (hazard.binding.direction != GpuBufferBinding::Direction::INPUT_OUTPUT)
                continue;
 
            const bool is_image = hazard.binding.element_type == GpuBufferBinding::ElementType::IMAGE_STORAGE
                || hazard.binding.element_type == GpuBufferBinding::ElementType::IMAGE_SAMPLED;
 
            if (is_image) {
                foundry.image_barrier(
                    cmd_id,
                    hazard.image,
                    vk::ImageLayout::eGeneral,
                    vk::ImageLayout::eGeneral,
                    vk::AccessFlagBits::eShaderWrite | vk::AccessFlagBits::eShaderRead,
                    vk::AccessFlagBits::eShaderWrite | vk::AccessFlagBits::eShaderRead,
                    vk::PipelineStageFlagBits::eComputeShader,
                    vk::PipelineStageFlagBits::eComputeShader);
            } else {
                foundry.buffer_barrier(
                    cmd_id,
                    hazard.buffer,
                    vk::AccessFlagBits::eShaderWrite | vk::AccessFlagBits::eShaderRead,
                    vk::AccessFlagBits::eShaderWrite | vk::AccessFlagBits::eShaderRead,
                    vk::PipelineStageFlagBits::eComputeShader,
                    vk::PipelineStageFlagBits::eComputeShader);
            }
        }
 
        MF_DEBUG(Journal::Component::Portal, Journal::Context::GPUCompute,
            "record_sequence: stage {} of {} recorded ({} hazard barriers)",
            i + 1, stages.size(), stage.hazard_resources.size());
    }
}

References bind_all(), dispatch(), MayaFlux::Journal::GPUCompute, MayaFlux::Portal::Graphics::GpuBufferBinding::IMAGE_SAMPLED, MayaFlux::Portal::Graphics::GpuBufferBinding::IMAGE_STORAGE, MayaFlux::Portal::Graphics::GpuBufferBinding::INPUT_OUTPUT, MayaFlux::is_image(), m_shader_foundry, MF_DEBUG, and MayaFlux::Journal::Portal.

Here is the call graph for this function: