What is the correct way to write unified memory code?

[GardenerAether]

I've been using WGPU for my engine and I largely enjoy the API, and the idiomatic integration with Rust makes it especially pleasant. Despite the recent-ish switch to the CurrentSurfaceTexture model - which admittedly took me a few hours to debug before realizing that suboptimal frames needed to be handled separately to ensure the frame was actually dropped - I have found it very intuitive. However, proper optimization for unified memory architectures is not obvious to me.

I have an M2 Pro as my main chip (running Asahi linux) and I'm interested in what the correct way to utilize the unified memory architecture is. My game engine based on voxels and so I have a function to rebuild the draw data (indirect buffer and storage buffer to position chunks) whenever needed (though admittedly this function is currently called rather pervasively).

fn rebuild_draw_data(&mut self) {
    self.draw_count = 0;
    let mut ssbo = Vec::new();
    let mut params = Vec::new();

    for (&(x, y, z, dir), &(size, offset)) in self.mesh_sizes.iter() {
        ssbo.push([(x << 5) as f32, (y << 5) as f32, (z << 5) as f32, dir as usize as f32]);
        params.push(wgpu::util::DrawIndirectArgs {vertex_count: 4, instance_count: size, first_vertex: 0, first_instance: offset});

        self.draw_count += 1;
    }

    self.queue.write_buffer(&self.face_ssbo, 0, bytemuck::cast_slice(&ssbo));
    self.queue.write_buffer(&self.draw_params, 0, bytemuck::cast_slice(&params));
}

You can see that this function simply allocates two vectors which data is written into before that data is copied to their respective buffers. My understanding is that write_buffer clones the data provided by the slice to a temporary staging buffer, which itself then gets cloned to be sent off to the gpu, and this all requires a separate Vec allocation.

My question is, being on a unified memory architecture, how would I write to these buffers directly? I have tried using map_async with get_mapped_range_mut, however this resulted in a extremely noticeable stuttering, and the move requirements leave me unsure of how I could possibly write each element in without making a separate allocation.

[kpreid]

I have tried using map_async with get_mapped_range_mut, however this resulted in a extremely noticeable stuttering,

This should not have significant performance effects unless you are blocking on the mapping completing. If that's what you're doing, you need to avoid it — usually by using multiple buffers ("triple buffering" — one for the GPU, one for the CPU, and one potentially in transit).

the move requirements leave me unsure of how I could possibly write each element in without making a separate allocation.

You mean the requirements of WriteOnly? If you use into_chunks() followed by .into_iter(), you get an iterator with which you can write elements one at a time.