dispatch_batched()

void MayaFlux::Yantra::GpuResourceManager::dispatch_batched	(	const std::string &	key,
		const std::array< uint32_t, 3 > &	groups,
		const std::vector< GpuBufferBinding > &	bindings,
		size_t	push_constant_size,
		const ExecutionContext &	ctx
	)

Definition at line 636 of file GpuResourceManager.cpp.

{
    const auto& params = safe_variant_get_or_throw<ChainedParams>(ctx.parameters,
        "GpuResourceManager: dispatch_batched requires ChainedParams");
 
    auto& unit = unit_for(key);
    auto& foundry = Portal::Graphics::get_shader_foundry();
    auto& compute_press = Portal::Graphics::get_compute_press();
 
    const uint32_t workgroups_per_pass = groups[0] * groups[1] * groups[2];
 
    const uint32_t default_passes = std::max(1U, 65536U / std::max(1U, workgroups_per_pass));
 
    const uint32_t effective_passes_per_batch = params.passes_per_batch.value_or(default_passes);
    for (uint32_t base = 0; base < params.pass_count; base += effective_passes_per_batch) {
        const uint32_t batch_end = std::min(base + effective_passes_per_batch, params.pass_count);
        auto cmd_id = foundry.begin_commands(
            Portal::Graphics::ShaderFoundry::CommandBufferType::COMPUTE);
 
        for (uint32_t pass = base; pass < batch_end; ++pass) {
            std::vector<uint8_t> pc_data(push_constant_size);
            params.pc_updater(pass, pc_data.data());
            compute_press.bind_all(
                cmd_id, unit.pipeline_id, unit.descriptor_set_ids,
                pc_data.data(), push_constant_size);
            compute_press.dispatch(cmd_id, groups[0], groups[1], groups[2]);
 
            for (const auto& b : bindings) {
                if (b.direction != GpuBufferBinding::Direction::INPUT_OUTPUT)
                    continue;
 
                const bool is_image = b.element_type == GpuBufferBinding::ElementType::IMAGE_STORAGE
                    || b.element_type == GpuBufferBinding::ElementType::IMAGE_SAMPLED;
                const bool is_shared = m_shared->slots.contains({ b.set, static_cast<size_t>(b.binding) });
 
                if (is_image) {
                    if (static_cast<size_t>(b.binding) < unit.image_slots.size() && unit.image_slots[b.binding]) {
                        foundry.image_barrier(
                            cmd_id,
                            unit.image_slots[b.binding]->get_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 if (!is_shared && static_cast<size_t>(b.binding) < unit.impl->buffers.size()
                    && unit.impl->buffers[b.binding].buffer) {
                    foundry.buffer_barrier(
                        cmd_id,
                        unit.impl->buffers[b.binding].buffer,
                        vk::AccessFlagBits::eShaderWrite | vk::AccessFlagBits::eShaderRead,
                        vk::AccessFlagBits::eShaderWrite | vk::AccessFlagBits::eShaderRead,
                        vk::PipelineStageFlagBits::eComputeShader,
                        vk::PipelineStageFlagBits::eComputeShader);
                }
            }
        }
 
        for (const auto& b : bindings) {
            if (b.direction == GpuBufferBinding::Direction::OUTPUT
                || b.direction == GpuBufferBinding::Direction::INPUT_OUTPUT) {
                const bool is_image = b.element_type == GpuBufferBinding::ElementType::IMAGE_STORAGE
                    || b.element_type == GpuBufferBinding::ElementType::IMAGE_SAMPLED;
                const bool is_shared = m_shared->slots.contains({ b.set, static_cast<size_t>(b.binding) });
                if (!is_image && !is_shared && static_cast<size_t>(b.binding) < unit.impl->buffers.size()
                    && unit.impl->buffers[b.binding].buffer) {
                    foundry.buffer_barrier(
                        cmd_id,
                        unit.impl->buffers[b.binding].buffer,
                        vk::AccessFlagBits::eShaderWrite,
                        vk::AccessFlagBits::eHostRead,
                        vk::PipelineStageFlagBits::eComputeShader,
                        vk::PipelineStageFlagBits::eHost);
                }
            }
        }
 
        foundry.submit_and_wait(cmd_id);
    }
}

References b, MayaFlux::Portal::Graphics::ShaderFoundry::COMPUTE, 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::GpuBufferBinding::INPUT_OUTPUT, MayaFlux::is_image(), m_shared, MayaFlux::Portal::Graphics::GpuBufferBinding::OUTPUT, MayaFlux::Yantra::ExecutionContext::parameters, and unit_for().

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

Here is the call graph for this function:

Here is the caller graph for this function: