How would you create compute shader tasks that are not dispatched from render_graph::Node? Is this a good idea?

[l-monninger]

Summary

I've been struggling to set up a GPU compute task pipeline which I would prefer to manage outside of the render graph. Namely, I'm running to:

1. ComputePipeline status is forever Queued.
2. It's not clear to me from the examples if you have to use a pattern like add_compute_render_graph_node, or if this was merely used for this particular example.

Ideally, this would allow for a high-level request-response, form to the pipeline runs.

Note

I've taken a look at the GOL and GPU Readback examples. Both seem to be a bit more tightly coupled with the render graph than I was initially hoping.

My failed approach

Roughly what I wanted to do is be able to call a dispatch method on a pipeline imperatively like the below, handling when to dispatch and when to read read back myself and mostly outside of then Bevy scheduler.

pub fn dispatch(
		device: &RenderDevice,
		pipelines: &MarchingCubesPipelines,
		layout: &BindGroupLayout,
		block_sums: &Buffer,
		block_prefix: &Buffer,
		encoder: &mut CommandEncoder,
	) {
		let bind =
			create_bind_group(device, "mc_prefix_block_bind", layout, &[block_sums, block_prefix]);

		let mut pass = encoder.begin_compute_pass(&ComputePassDescriptor::default());
		pass.set_pipeline(&pipelines.prefix_block);
		pass.set_bind_group(0, &bind, &[]);
		pass.dispatch_workgroups(1, 1, 1);
	}

To do this, I wrote systems to queue the pipelines and then to fill a resource MarchingCubesPipelines with the needed ComputePipelines when they are ready.

// Queue RenderApp systems for GPU pipeline initialization
app.sub_app_mut(bevy::render::RenderApp).add_systems(
	bevy::render::Render,
	pipeline::proc::render_setup::queue_marching_cubes_pipelines
		.in_set(bevy::render::RenderSystems::Prepare),
);

// Check for available pipelines
app.sub_app_mut(bevy::render::RenderApp).add_systems(
	bevy::render::Render,
	pipeline::proc::render_setup::init_marching_cubes_pipelines
		.in_set(bevy::render::RenderSystems::Prepare),
);

At the type-level, this checks out. But, I've tried several variations of the setup scheduling and my pipelines are always Queued.

What I may do next

Even though it would be nice to really understand what is keeping the pipelines Queued and try to work towards my initial goal. I'm about to go for a pattern wherein I try to copy the example pattern with render_graph::Node and enqueue requests to the pipeline on the world object.

I think I'm going to have do something like this wherein I despawn the resource constituting a request on the GPU readback, thus completing the request for the task:

commands
        .spawn(Readback::buffer(buffer.clone()))
        .observe(|event: On<ReadbackComplete>| {
            // This matches the type which was used to create the `ShaderStorageBuffer` above,
            // and is a convenient way to interpret the data.
            let data: Vec<u32> = event.to_shader_type();
            info!("Buffer {:?}", data);
            // despawn resource constituting "request" for GPU pipeline run or something similar
        });

To me it seems like this would be overkill for a lot of compute tasks that don't need to be synchronized in some way with the frame rendering. But, perhaps, GPU exclusivity is bearing here.

Questions

1. Why would the ComputePipelines be whenever I try to access them?
2. Is dispatching and reading back without inserting a render_graph::Node fundamentally unsafe?