vulkano-rs/Lobby

I have a simulation where the state is double-buffered, so one timestep I read from buf_0 and write to buf_1 and the following step I do the reverse. I've implemented this by having two descriptor sets but I get an access error:

thread 'main' panicked at 'called `Result::unwrap()` on an `Err` value: AccessError { error: AlreadyInUse, command_name: "vkCmdDispatch", command_param: "Buffer bound to set 0 descriptor 1", command_offset: 2 }', src/main.rs:112:10

No amount of inserting semaphores/cleanup_finished calls seems to help. Does anyone know how I should go about this? Minimal example below.

fn main() {
    // No instance extensions or device extensions/features
    let (_instance, device, queue) = init();

    mod cs {
        vulkano_shaders::shader! {
            ty: "compute",
        src: "
#version 450
layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in;

layout(set = 0, binding = 0) readonly  buffer Old { uint data[]; } old;
layout(set = 0, binding = 1) writeonly buffer New { uint data[]; } new;

void main() {
    new.data[gl_GlobalInvocationID.x] = old.data[gl_GlobalInvocationID.x];
}"
        }
    }

    let len: u32 = 10;

    let make_buf = || {
        DeviceLocalBuffer::<[u32]>::array(
            device.clone(),
            len as DeviceSize,
            BufferUsage {
                storage_buffer: true,
                ..BufferUsage::none()
            },
            Some(queue.family()),
        )
        .unwrap()
    };

    let (buf_0, buf_1) = (make_buf(), make_buf());

    let pipeline = Arc::new(
        ComputePipeline::new(
            device.clone(),
            &cs::Shader::load(device.clone()).unwrap().main_entry_point(),
            &(),
            None,
            |_| {},
        )
        .unwrap(),
    );

    let layout = pipeline.layout().descriptor_set_layouts().get(0).unwrap();
    let set_read_0_write_1 = {
        let mut builder = PersistentDescriptorSet::start(layout.clone());
        builder.add_buffer(buf_0.clone()).unwrap();
        builder.add_buffer(buf_1.clone()).unwrap();
        Arc::new(builder.build().unwrap())
    };
    let set_read_1_write_0 = {
        let mut builder = PersistentDescriptorSet::start(layout.clone());
        builder.add_buffer(buf_1).unwrap();
        builder.add_buffer(buf_0).unwrap();
        Arc::new(builder.build().unwrap())
    };

    let make_command_buffer = |set| {
        let mut builder = AutoCommandBufferBuilder::primary(
            device.clone(),
            queue.family(),
            CommandBufferUsage::OneTimeSubmit,
        )
        .unwrap();

        builder
            .bind_pipeline_compute(pipeline.clone())
            .bind_descriptor_sets(
                PipelineBindPoint::Compute,
                pipeline.layout().clone(),
                0,
                set,
            )
            .dispatch([len, 1, 1])
            .unwrap();

        builder.build().unwrap()
    };

    let command_buffer_read_0_write_1 = make_command_buffer(set_read_0_write_1);
    let command_buffer_read_1_write_0 = make_command_buffer(set_read_1_write_0);

    sync::now(device.clone())
        .then_execute(queue.clone(), command_buffer_read_0_write_1)
        .unwrap()
        .then_execute(queue.clone(), command_buffer_read_1_write_0)
        .unwrap()
        .then_signal_fence_and_flush()
        .unwrap()
        .wait(None)
        .unwrap();
}