Refactor insert_barriers

wgpu-native/src/command/compute.rs

@@ -67,11 +67,10 @@ pub extern "C" fn wgpu_compute_pass_set_bind_group(
     //Note: currently, WebGPU compute passes have synchronization defined
     // at a dispatch granularity, so we insert the necessary barriers here.
 
-    //TODO: have `TrackerSet::consume()` ?
     CommandBuffer::insert_barriers(
         &mut pass.raw,
-        pass.trackers.buffers.consume_by_replace(&bind_group.used.buffers),
-        pass.trackers.textures.consume_by_replace(&bind_group.used.textures),
+        &mut pass.trackers,
+        &bind_group.used,
         &*HUB.buffers.read(),
         &*HUB.textures.read(),
     );

wgpu-native/src/command/mod.rs

@@ -20,9 +20,9 @@ use crate::track::TrackerSet;
 use crate::conv;
 use crate::{
     BufferHandle, TextureHandle,
-    BufferId, CommandBufferId, CommandEncoderId, DeviceId,
-    TextureId, TextureViewId,
-    BufferUsageFlags, TextureUsageFlags, Color,
+    CommandBufferId, CommandEncoderId, DeviceId,
+    TextureViewId,
+    TextureUsageFlags, Color,
     LifeGuard, Stored,
     CommandBufferHandle,
 };
@@ -35,7 +35,6 @@ use hal::{Device as _Device};
 use log::trace;
 
 use std::collections::hash_map::Entry;
-use std::ops::Range;
 use std::{iter, slice};
 use std::thread::ThreadId;
 
@@ -91,39 +90,40 @@ pub struct CommandBuffer<B: hal::Backend> {
 }
 
 impl CommandBufferHandle {
-    pub(crate) fn insert_barriers<I, J>(
+    pub(crate) fn insert_barriers(
         raw: &mut <Backend as hal::Backend>::CommandBuffer,
-        buffer_iter: I,
-        texture_iter: J,
+        base: &mut TrackerSet,
+        head: &TrackerSet,
         buffer_guard: &Storage<BufferHandle>,
         texture_guard: &Storage<TextureHandle>,
-    ) where
-        I: Iterator<Item = (BufferId, Range<BufferUsageFlags>)>,
-        J: Iterator<Item = (TextureId, Range<TextureUsageFlags>)>,
-    {
-
-        let buffer_barriers = buffer_iter.map(|(id, transit)| {
-            let b = &buffer_guard[id];
-            trace!("transit {:?} {:?}", id, transit);
-            hal::memory::Barrier::Buffer {
-                states: conv::map_buffer_state(transit.start) .. conv::map_buffer_state(transit.end),
-                target: &b.raw,
-                range: None .. None,
-                families: None,
-            }
-        });
-        let texture_barriers = texture_iter.map(|(id, transit)| {
-            let t = &texture_guard[id];
-            trace!("transit {:?} {:?}", id, transit);
-            let aspects = t.full_range.aspects;
-            hal::memory::Barrier::Image {
-                states: conv::map_texture_state(transit.start, aspects)
-                    ..conv::map_texture_state(transit.end, aspects),
-                target: &t.raw,
-                range: t.full_range.clone(), //TODO?
-                families: None,
-            }
-        });
+    ) {
+        let buffer_barriers = base.buffers
+            .consume_by_replace(&head.buffers)
+            .map(|(id, transit)| {
+                let b = &buffer_guard[id];
+                trace!("transit buffer {:?} {:?}", id, transit);
+                hal::memory::Barrier::Buffer {
+                    states: conv::map_buffer_state(transit.start) .. conv::map_buffer_state(transit.end),
+                    target: &b.raw,
+                    range: None .. None,
+                    families: None,
+                }
+            });
+        let texture_barriers = base.textures
+            .consume_by_replace(&head.textures)
+            .map(|(id, transit)| {
+                let t = &texture_guard[id];
+                trace!("transit texture {:?} {:?}", id, transit);
+                let aspects = t.full_range.aspects;
+                hal::memory::Barrier::Image {
+                    states: conv::map_texture_state(transit.start, aspects)
+                        ..conv::map_texture_state(transit.end, aspects),
+                    target: &t.raw,
+                    range: t.full_range.clone(), //TODO?
+                    families: None,
+                }
+            });
+        base.views.consume(&head.views);
 
         let stages = all_buffer_stages() | all_image_stages();
         unsafe {

wgpu-native/src/command/render.rs

@@ -44,23 +44,17 @@ pub extern "C" fn wgpu_render_pass_end_pass(pass_id: RenderPassId) -> CommandBuf
         Some(ref mut last) => {
             CommandBuffer::insert_barriers(
                 last,
-                cmb.trackers.buffers.consume_by_replace(&pass.trackers.buffers),
-                cmb.trackers.textures.consume_by_replace(&pass.trackers.textures),
+                &mut cmb.trackers,
+                &pass.trackers,
                 &*HUB.buffers.read(),
                 &*HUB.textures.read(),
             );
             unsafe { last.finish() };
         }
         None => {
-            cmb.trackers.buffers
-                .consume_by_extend(&pass.trackers.buffers)
-                .unwrap();
-            cmb.trackers.textures
-                .consume_by_extend(&pass.trackers.textures)
-                .unwrap();
+            cmb.trackers.consume_by_extend(&pass.trackers);
         }
     }
-    cmb.trackers.views.consume(&pass.trackers.views);
 
     cmb.raw.push(pass.raw);
     pass.cmb_id.value

wgpu-native/src/device.rs

@@ -12,7 +12,7 @@ use crate::{
 #[cfg(feature = "local")]
 use crate::{
     BindGroupLayoutId, PipelineLayoutId, SamplerId, SwapChainId,
-    ShaderModuleId, CommandEncoderId, RenderPipelineId, ComputePipelineId, 
+    ShaderModuleId, CommandEncoderId, RenderPipelineId, ComputePipelineId,
 };
 
 use arrayvec::ArrayVec;
@@ -1072,16 +1072,13 @@ pub extern "C" fn wgpu_queue_submit(
                     hal::command::CommandBufferInheritanceInfo::default(),
                 );
             }
-            //TODO: fix the consume
-            let TrackerSet { ref mut buffers, ref mut textures, ref mut views } = *trackers;
             command::CommandBuffer::insert_barriers(
                 &mut transit,
-                buffers.consume_by_replace(&comb.trackers.buffers),
-                textures.consume_by_replace(&comb.trackers.textures),
+                &mut *trackers,
+                &comb.trackers,
                 &*buffer_guard,
                 &*texture_guard,
             );
-            views.consume(&comb.trackers.views);
             unsafe {
                 transit.finish();
             }
@@ -1751,4 +1748,4 @@ pub extern "C" fn wgpu_buffer_unmap(
     }
 
     unsafe { device.raw.unmap_memory(&buffer.memory) };
-}
+}

wgpu-native/src/track.rs

@@ -103,6 +103,16 @@ impl TrackerSet {
             views: TextureViewTracker::new(),
         }
     }
+
+    pub fn consume_by_extend(&mut self, other: &Self) {
+        self.buffers
+            .consume_by_extend(&other.buffers)
+            .unwrap();
+        self.textures
+            .consume_by_extend(&other.textures)
+            .unwrap();
+        self.views.consume(&other.views);
+    }
 }
 
 impl<I: NewId> DummyTracker<I> {