Stitch mode for insert_barriers

Author: kvark

src/command/compute.rs

@@ -1,6 +1,6 @@
 use crate::command::bind::{Binder};
 use crate::hub::HUB;
-use crate::track::TrackerSet;
+use crate::track::{Stitch, TrackerSet};
 use crate::{
     Stored, CommandBuffer,
     BindGroupId, CommandBufferId, ComputePassId, ComputePipelineId,
@@ -71,6 +71,7 @@ pub extern "C" fn wgpu_compute_pass_set_bind_group(
         &mut pass.raw,
         &mut pass.trackers,
         &bind_group.used,
+        Stitch::Last,
         &*HUB.buffers.read(),
         &*HUB.textures.read(),
     );

src/command/mod.rs

@@ -16,7 +16,7 @@ use crate::device::{
 use crate::hub::{HUB, Storage};
 use crate::resource::TexturePlacement;
 use crate::swap_chain::{SwapChainLink, SwapImageEpoch};
-use crate::track::{DummyUsage, TrackerSet};
+use crate::track::{DummyUsage, Stitch, TrackerSet};
 use crate::conv;
 use crate::{
     BufferHandle, TextureHandle,
@@ -94,11 +94,12 @@ impl CommandBufferHandle {
         raw: &mut <Backend as hal::Backend>::CommandBuffer,
         base: &mut TrackerSet,
         head: &TrackerSet,
+        stitch: Stitch,
         buffer_guard: &Storage<BufferHandle>,
         texture_guard: &Storage<TextureHandle>,
     ) {
         let buffer_barriers = base.buffers
-            .consume_by_replace(&head.buffers)
+            .consume_by_replace(&head.buffers, stitch)
             .map(|(id, transit)| {
                 let b = &buffer_guard[id];
                 trace!("transit buffer {:?} {:?}", id, transit);
@@ -110,7 +111,7 @@ impl CommandBufferHandle {
                 }
             });
         let texture_barriers = base.textures
-            .consume_by_replace(&head.textures)
+            .consume_by_replace(&head.textures, stitch)
             .map(|(id, transit)| {
                 let t = &texture_guard[id];
                 trace!("transit texture {:?} {:?}", id, transit);

src/command/render.rs

@@ -1,7 +1,7 @@
 use crate::command::bind::Binder;
 use crate::hub::HUB;
 use crate::resource::BufferUsageFlags;
-use crate::track::TrackerSet;
+use crate::track::{Stitch, TrackerSet};
 use crate::{
     CommandBuffer, Stored,
     BindGroupId, BufferId, CommandBufferId, RenderPassId, RenderPipelineId,
@@ -46,6 +46,7 @@ pub extern "C" fn wgpu_render_pass_end_pass(pass_id: RenderPassId) -> CommandBuf
                 last,
                 &mut cmb.trackers,
                 &pass.trackers,
+                Stitch::Last,
                 &*HUB.buffers.read(),
                 &*HUB.textures.read(),
             );

src/device.rs

@@ -1,6 +1,6 @@
 use crate::{binding_model, command, conv, pipeline, resource, swap_chain};
 use crate::hub::HUB;
-use crate::track::{DummyUsage, TrackerSet, TrackPermit};
+use crate::track::{DummyUsage, Stitch, TrackerSet, TrackPermit};
 use crate::{
     LifeGuard, RefCount, Stored, SubmissionIndex,
     BufferMapAsyncStatus, BufferMapOperation,
@@ -1076,6 +1076,7 @@ pub extern "C" fn wgpu_queue_submit(
                 &mut transit,
                 &mut *trackers,
                 &comb.trackers,
+                Stitch::Init,
                 &*buffer_guard,
                 &*texture_guard,
             );

src/track.rs

@@ -98,6 +98,16 @@ pub type BufferTracker = Tracker<BufferId, BufferUsageFlags>;
 pub type TextureTracker = Tracker<TextureId, TextureUsageFlags>;
 pub type TextureViewTracker = Tracker<TextureViewId, DummyUsage>;
 
+//TODO: make this a generic parameter.
+/// Mode of stitching to states together.
+#[derive(Clone, Copy, Debug)]
+pub enum Stitch {
+    /// Stitch to the init state of the other resource.
+    Init,
+    /// Stitch to the last sttate of the other resource.
+    Last,
+}
+
 pub struct TrackerSet {
     pub buffers: BufferTracker,
     pub textures: TextureTracker,
@@ -209,7 +219,11 @@ impl<I: NewId, U: Copy + GenericUsage + BitOr<Output = U> + PartialEq> Tracker<I
 
     /// Consume another tacker, adding it's transitions to `self`.
     /// Transitions the current usage to the new one.
-    pub fn consume_by_replace<'a>(&'a mut self, other: &'a Self) -> impl 'a + Iterator<Item = (I, Range<U>)> {
+    pub fn consume_by_replace<'a>(
+        &'a mut self,
+        other: &'a Self,
+        stitch: Stitch,
+    ) -> impl 'a + Iterator<Item = (I, Range<U>)> {
         other.map.iter().flat_map(move |(&index, new)| {
             match self.map.entry(index) {
                 Entry::Vacant(e) => {
@@ -222,7 +236,11 @@ impl<I: NewId, U: Copy + GenericUsage + BitOr<Output = U> + PartialEq> Tracker<I
                     if old == new.init {
                         None
                     } else {
-                        Some((I::new(index, new.epoch), old .. new.last))
+                        let state = match stitch {
+                            Stitch::Init => new.init,
+                            Stitch::Last => new.last,
+                        };
+                        Some((I::new(index, new.epoch), old .. state))
                     }
                 }
             }