From 306c0a5c58a0fabd266a233b0bb8faf292b11252 Mon Sep 17 00:00:00 2001 From: Trashtalk Date: Mon, 14 Sep 2026 01:02:20 +0200 Subject: [PATCH 1/6] simplify dependency --- .../schedule/auto_insert_apply_deferred.rs | 6 +- crates/bevy_ecs/src/schedule/config.rs | 67 ++++++----- crates/bevy_ecs/src/schedule/graph/mod.rs | 26 ++-- crates/bevy_ecs/src/schedule/pass.rs | 33 +----- crates/bevy_ecs/src/schedule/schedule.rs | 111 ++++++++++++------ 5 files changed, 135 insertions(+), 108 deletions(-) diff --git a/crates/bevy_ecs/src/schedule/auto_insert_apply_deferred.rs b/crates/bevy_ecs/src/schedule/auto_insert_apply_deferred.rs index 0c45f81c27bea..6d2662ba40d04 100644 --- a/crates/bevy_ecs/src/schedule/auto_insert_apply_deferred.rs +++ b/crates/bevy_ecs/src/schedule/auto_insert_apply_deferred.rs @@ -61,10 +61,8 @@ impl AutoInsertApplyDeferredPass { } impl ScheduleBuildPass for AutoInsertApplyDeferredPass { - type EdgeOptions = IgnoreDeferred; - - fn add_dependency(&mut self, from: NodeId, to: NodeId, options: Option<&Self::EdgeOptions>) { - if options.is_some() { + fn add_dependency(&mut self, from: NodeId, to: NodeId, _: bool, ignore_deferred: bool) { + if ignore_deferred { self.no_sync_edges.insert((from, to)); } } diff --git a/crates/bevy_ecs/src/schedule/config.rs b/crates/bevy_ecs/src/schedule/config.rs index d153bbb11afb6..52953cf5ea089 100644 --- a/crates/bevy_ecs/src/schedule/config.rs +++ b/crates/bevy_ecs/src/schedule/config.rs @@ -3,11 +3,10 @@ use variadics_please::all_tuples; use crate::{ schedule::{ - auto_insert_apply_deferred::IgnoreDeferred, condition::{BoxedCondition, SystemCondition}, graph::{Ambiguity, Dependency, DependencyKind, GraphInfo}, set::{InternedSystemSet, IntoSystemSet, SystemSet}, - Chain, Weak, + Chain, }, system::{BoxedSystem, IntoSystem, ScheduleSystem, System}, }; @@ -129,10 +128,12 @@ impl> ScheduleConfig fn before_inner(&mut self, set: InternedSystemSet) { match self { Self::ScheduleConfig(config) => { - config - .metadata - .dependencies - .push(Dependency::new(DependencyKind::Before, set)); + config.metadata.dependencies.push(Dependency::new( + DependencyKind::Before, + set, + false, + false, + )); } Self::Configs { configs, .. } => { for config in configs { @@ -145,10 +146,12 @@ impl> ScheduleConfig fn after_inner(&mut self, set: InternedSystemSet) { match self { Self::ScheduleConfig(config) => { - config - .metadata - .dependencies - .push(Dependency::new(DependencyKind::After, set)); + config.metadata.dependencies.push(Dependency::new( + DependencyKind::After, + set, + false, + false, + )); } Self::Configs { configs, .. } => { for config in configs { @@ -161,10 +164,12 @@ impl> ScheduleConfig fn before_weak_inner(&mut self, set: InternedSystemSet) { match self { Self::ScheduleConfig(config) => { - config - .metadata - .dependencies - .push(Dependency::new(DependencyKind::Before, set).add_config(Weak)); + config.metadata.dependencies.push(Dependency::new( + DependencyKind::Before, + set, + true, + false, + )); } Self::Configs { configs, .. } => { for config in configs { @@ -177,10 +182,12 @@ impl> ScheduleConfig fn after_weak_inner(&mut self, set: InternedSystemSet) { match self { Self::ScheduleConfig(config) => { - config - .metadata - .dependencies - .push(Dependency::new(DependencyKind::After, set).add_config(Weak)); + config.metadata.dependencies.push(Dependency::new( + DependencyKind::After, + set, + true, + false, + )); } Self::Configs { configs, .. } => { for config in configs { @@ -193,10 +200,12 @@ impl> ScheduleConfig fn before_ignore_deferred_inner(&mut self, set: InternedSystemSet) { match self { Self::ScheduleConfig(config) => { - config - .metadata - .dependencies - .push(Dependency::new(DependencyKind::Before, set).add_config(IgnoreDeferred)); + config.metadata.dependencies.push(Dependency::new( + DependencyKind::Before, + set, + false, + true, + )); } Self::Configs { configs, .. } => { for config in configs { @@ -209,10 +218,12 @@ impl> ScheduleConfig fn after_ignore_deferred_inner(&mut self, set: InternedSystemSet) { match self { Self::ScheduleConfig(config) => { - config - .metadata - .dependencies - .push(Dependency::new(DependencyKind::After, set).add_config(IgnoreDeferred)); + config.metadata.dependencies.push(Dependency::new( + DependencyKind::After, + set, + false, + true, + )); } Self::Configs { configs, .. } => { for config in configs { @@ -293,7 +304,7 @@ impl> ScheduleConfig match &mut self { Self::ScheduleConfig(_) => { /* no op */ } Self::Configs { metadata, .. } => { - metadata.set_chained_with_config(IgnoreDeferred); + metadata.set_chained_ignore_deferred(); } } self @@ -303,7 +314,7 @@ impl> ScheduleConfig match &mut self { Self::ScheduleConfig(_) => { /* no op */ } Self::Configs { metadata, .. } => { - metadata.set_chained_with_config(Weak); + metadata.set_chained_weak(); } } self diff --git a/crates/bevy_ecs/src/schedule/graph/mod.rs b/crates/bevy_ecs/src/schedule/graph/mod.rs index 911ab6626ef66..5523fb602e8e0 100644 --- a/crates/bevy_ecs/src/schedule/graph/mod.rs +++ b/crates/bevy_ecs/src/schedule/graph/mod.rs @@ -1,10 +1,5 @@ -use alloc::{boxed::Box, vec::Vec}; -use core::{ - any::{Any, TypeId}, - fmt::Debug, -}; - -use bevy_utils::TypeIdHashMap; +use alloc::vec::Vec; +use core::fmt::Debug; use crate::schedule::InternedSystemSet; @@ -28,21 +23,24 @@ pub(crate) enum DependencyKind { pub(crate) struct Dependency { pub(crate) kind: DependencyKind, pub(crate) set: InternedSystemSet, - pub(crate) options: TypeIdHashMap>, + pub(crate) is_weak: bool, + pub(crate) ignore_deferred: bool, } impl Dependency { - pub fn new(kind: DependencyKind, set: InternedSystemSet) -> Self { + pub fn new( + kind: DependencyKind, + set: InternedSystemSet, + is_weak: bool, + ignore_deferred: bool, + ) -> Self { Self { kind, set, - options: Default::default(), + is_weak, + ignore_deferred, } } - pub fn add_config(mut self, option: T) -> Self { - self.options.insert(TypeId::of::(), Box::new(option)); - self - } } /// Configures ambiguity detection for a single system. diff --git a/crates/bevy_ecs/src/schedule/pass.rs b/crates/bevy_ecs/src/schedule/pass.rs index 7f4bd402b62ef..f13289e22240e 100644 --- a/crates/bevy_ecs/src/schedule/pass.rs +++ b/crates/bevy_ecs/src/schedule/pass.rs @@ -1,12 +1,7 @@ -use alloc::{boxed::Box, vec::Vec}; -use core::{ - any::{Any, TypeId}, - fmt::Debug, - ops::Deref, -}; +use alloc::vec::Vec; +use core::{fmt::Debug, ops::Deref}; use bevy_platform::{collections::HashSet, hash::FixedHasher}; -use bevy_utils::TypeIdHashMap; use indexmap::IndexSet; use super::{DiGraph, NodeId, ScheduleBuildError, ScheduleGraph}; @@ -20,11 +15,8 @@ use crate::{ /// A pass for modular modification of the dependency graph. pub trait ScheduleBuildPass: Send + Sync + Debug + 'static { - /// Custom options for dependencies between sets or systems. - type EdgeOptions: 'static; - /// Called when a dependency between sets or systems was explicitly added to the graph. - fn add_dependency(&mut self, from: NodeId, to: NodeId, options: Option<&Self::EdgeOptions>); + fn add_dependency(&mut self, from: NodeId, to: NodeId, is_weak: bool, is_deferred: bool); /// Called while flattening the dependency graph. For each `set`, this method is called /// with the `systems` associated with the set as well as an immutable reference to the current graph. @@ -127,12 +119,7 @@ pub(super) trait ScheduleBuildPassObj: Send + Sync + Debug { dependency_flattening: &DiGraph, dependencies_to_add: &mut Vec<(NodeId, NodeId)>, ); - fn add_dependency( - &mut self, - from: NodeId, - to: NodeId, - all_options: &TypeIdHashMap>, - ); + fn add_dependency(&mut self, from: NodeId, to: NodeId, is_weak: bool, ignore_deferred: bool); } impl ScheduleBuildPassObj for T { @@ -154,15 +141,7 @@ impl ScheduleBuildPassObj for T { let iter = self.collapse_set(set, systems, dependency_flattening); dependencies_to_add.extend(iter); } - fn add_dependency( - &mut self, - from: NodeId, - to: NodeId, - all_options: &TypeIdHashMap>, - ) { - let option = all_options - .get(&TypeId::of::()) - .and_then(|x| x.downcast_ref::()); - self.add_dependency(from, to, option); + fn add_dependency(&mut self, from: NodeId, to: NodeId, is_weak: bool, ignore_deferred: bool) { + self.add_dependency(from, to, is_weak, ignore_deferred); } } diff --git a/crates/bevy_ecs/src/schedule/schedule.rs b/crates/bevy_ecs/src/schedule/schedule.rs index 52195a876cf82..36be77126b97c 100644 --- a/crates/bevy_ecs/src/schedule/schedule.rs +++ b/crates/bevy_ecs/src/schedule/schedule.rs @@ -15,9 +15,9 @@ use bevy_platform::{ collections::{HashMap, HashSet}, hash::FixedHasher, }; -use bevy_utils::{default, TypeIdHashMap}; +use bevy_utils::default; use core::{ - any::{Any, TypeId}, + any::TypeId, fmt::{Debug, Write}, }; use fixedbitset::FixedBitSet; @@ -282,12 +282,6 @@ impl Schedules { } } -/// Marker stored in a [`Chain`]'s options by -/// [`chain_weak`](crate::schedule::IntoScheduleConfigs::chain_weak) to tag its edges as weak, -/// meaning the ordering is only kept between systems that actually conflict (access the same data in a way that is incompatible with the borrow checker). See `chain_weak` -/// for the semantics. -pub(crate) struct Weak; - /// Chain systems into dependencies #[derive(Default)] pub enum Chain { @@ -296,22 +290,48 @@ pub enum Chain { Unchained, /// Systems are chained. `before -> after` ordering constraints /// will be added between the successive elements. - Chained(TypeIdHashMap>), + Chained { + /// Specifies if the links between the chained links are weak + is_weak: bool, + /// Whether or not to insert sync points between systems in this chain + ignore_deferred: bool, + }, } impl Chain { /// Specify that the systems must be chained. pub fn set_chained(&mut self) { if matches!(self, Chain::Unchained) { - *self = Self::Chained(Default::default()); + *self = Self::Chained { + is_weak: false, + ignore_deferred: false, + }; }; } - /// Specify that the systems must be chained, and add the specified configuration for - /// all dependencies created between these systems. - pub fn set_chained_with_config(&mut self, config: T) { + + /// Specify that the systems must be chained, and the links are weak + pub fn set_chained_weak(&mut self) { self.set_chained(); - if let Chain::Chained(config_map) = self { - config_map.insert(TypeId::of::(), Box::new(config)); + if let Chain::Chained { + is_weak, + ignore_deferred: _, + } = self + { + *is_weak = true; + } else { + unreachable!() + }; + } + + /// Specify that the systems must be chained, and the links ignore deferred operations + pub fn set_chained_ignore_deferred(&mut self) { + self.set_chained(); + if let Chain::Chained { + is_weak: _, + ignore_deferred, + } = self + { + *ignore_deferred = true; } else { unreachable!() }; @@ -893,16 +913,24 @@ impl ScheduleGraph { } => { self.apply_collective_conditions(&mut configs, collective_conditions); - let is_chained = matches!(metadata, Chain::Chained(_)); - let is_weak = matches!( - &metadata, - Chain::Chained(options) if options.contains_key(&TypeId::of::()) - ); + let mut is_chained = false; + let mut weak_link = false; + + match metadata { + Chain::Chained { + is_weak, + ignore_deferred: _, + } => { + weak_link = is_weak; + is_chained = true; + } + _ => {} + } // Densely chained if // * a non-weak chain whose configs are all densely chained, or // * a single densely chained config - let mut densely_chained = (is_chained && !is_weak) || configs.len() == 1; + let mut densely_chained = (is_chained && !weak_link) || configs.len() == 1; let mut configs = configs.into_iter(); let mut nodes = Vec::new(); @@ -919,7 +947,11 @@ impl ScheduleGraph { let current_result = self.process_configs(current, collect_nodes || is_chained); densely_chained &= current_result.densely_chained; - if let Chain::Chained(chain_options) = &metadata { + if let Chain::Chained { + is_weak, + ignore_deferred, + } = &metadata + { // if the current result is densely chained, we only need to chain the first node let current_nodes = if current_result.densely_chained { ¤t_result.nodes[..1] @@ -939,7 +971,7 @@ impl ScheduleGraph { for current_node in current_nodes { self.dependency.add_edge(*previous_node, *current_node); - if is_weak { + if weak_link { self.weak_node_edges.insert((*previous_node, *current_node)); } else { self.strict_node_edges @@ -950,7 +982,8 @@ impl ScheduleGraph { pass.add_dependency( *previous_node, *current_node, - chain_options, + *is_weak, + *ignore_deferred, ); } } @@ -1166,25 +1199,33 @@ impl ScheduleGraph { self.dependency.add_node(NodeId::Set(key)); } - for (kind, key, options) in - dependencies - .into_iter() - .map(|Dependency { kind, set, options }| { - (kind, self.system_sets.get_key_or_insert(set), options) - }) - { + for (kind, key, is_weak, ignore_deferred) in dependencies.into_iter().map( + |Dependency { + kind, + set, + is_weak, + ignore_deferred, + }| { + ( + kind, + self.system_sets.get_key_or_insert(set), + is_weak, + ignore_deferred, + ) + }, + ) { let (lhs, rhs) = match kind { DependencyKind::Before => (id, NodeId::Set(key)), DependencyKind::After => (NodeId::Set(key), id), }; self.dependency.add_edge(lhs, rhs); - if options.contains_key(&TypeId::of::()) { + if is_weak { self.weak_node_edges.insert((lhs, rhs)); } else { self.strict_node_edges.insert((lhs, rhs)); } for pass in self.passes.values_mut() { - pass.add_dependency(lhs, rhs, &options); + pass.add_dependency(lhs, rhs, is_weak, ignore_deferred); } // ensure set also appears in hierarchy graph @@ -2938,12 +2979,12 @@ mod tests { struct Pass; impl ScheduleBuildPass for Pass { - type EdgeOptions = (); fn add_dependency( &mut self, _from: crate::schedule::NodeId, _to: crate::schedule::NodeId, - _options: Option<&Self::EdgeOptions>, + _is_weak: bool, + _ignore_deferred: bool, ) { } fn build( From 3c97e6e821f22eb3eaaf56f7dd4577dcf6b0fba2 Mon Sep 17 00:00:00 2001 From: Trashtalk Date: Mon, 14 Sep 2026 02:09:51 +0200 Subject: [PATCH 2/6] clippy --- crates/bevy_ecs/src/schedule/schedule.rs | 16 +++++++--------- 1 file changed, 7 insertions(+), 9 deletions(-) diff --git a/crates/bevy_ecs/src/schedule/schedule.rs b/crates/bevy_ecs/src/schedule/schedule.rs index 36be77126b97c..73c33698e5c66 100644 --- a/crates/bevy_ecs/src/schedule/schedule.rs +++ b/crates/bevy_ecs/src/schedule/schedule.rs @@ -916,15 +916,13 @@ impl ScheduleGraph { let mut is_chained = false; let mut weak_link = false; - match metadata { - Chain::Chained { - is_weak, - ignore_deferred: _, - } => { - weak_link = is_weak; - is_chained = true; - } - _ => {} + if let Chain::Chained { + is_weak, + ignore_deferred: _, + } = metadata + { + weak_link = is_weak; + is_chained = true; } // Densely chained if From 6e8ca2178c52c53b048767efe877f712934bf7ac Mon Sep 17 00:00:00 2001 From: Trashtalk Date: Mon, 14 Sep 2026 02:30:21 +0200 Subject: [PATCH 3/6] cleanup --- crates/bevy_ecs/src/schedule/config.rs | 60 +++++++++-------------- crates/bevy_ecs/src/schedule/graph/mod.rs | 25 +++++++--- 2 files changed, 41 insertions(+), 44 deletions(-) diff --git a/crates/bevy_ecs/src/schedule/config.rs b/crates/bevy_ecs/src/schedule/config.rs index 52953cf5ea089..2562b2c4e0c55 100644 --- a/crates/bevy_ecs/src/schedule/config.rs +++ b/crates/bevy_ecs/src/schedule/config.rs @@ -128,12 +128,10 @@ impl> ScheduleConfig fn before_inner(&mut self, set: InternedSystemSet) { match self { Self::ScheduleConfig(config) => { - config.metadata.dependencies.push(Dependency::new( - DependencyKind::Before, - set, - false, - false, - )); + config + .metadata + .dependencies + .push(Dependency::new(DependencyKind::Before, set)); } Self::Configs { configs, .. } => { for config in configs { @@ -146,12 +144,10 @@ impl> ScheduleConfig fn after_inner(&mut self, set: InternedSystemSet) { match self { Self::ScheduleConfig(config) => { - config.metadata.dependencies.push(Dependency::new( - DependencyKind::After, - set, - false, - false, - )); + config + .metadata + .dependencies + .push(Dependency::new(DependencyKind::After, set)); } Self::Configs { configs, .. } => { for config in configs { @@ -164,12 +160,10 @@ impl> ScheduleConfig fn before_weak_inner(&mut self, set: InternedSystemSet) { match self { Self::ScheduleConfig(config) => { - config.metadata.dependencies.push(Dependency::new( - DependencyKind::Before, - set, - true, - false, - )); + config + .metadata + .dependencies + .push(Dependency::new(DependencyKind::Before, set).set_weak()); } Self::Configs { configs, .. } => { for config in configs { @@ -182,12 +176,10 @@ impl> ScheduleConfig fn after_weak_inner(&mut self, set: InternedSystemSet) { match self { Self::ScheduleConfig(config) => { - config.metadata.dependencies.push(Dependency::new( - DependencyKind::After, - set, - true, - false, - )); + config + .metadata + .dependencies + .push(Dependency::new(DependencyKind::After, set).set_weak()); } Self::Configs { configs, .. } => { for config in configs { @@ -200,12 +192,10 @@ impl> ScheduleConfig fn before_ignore_deferred_inner(&mut self, set: InternedSystemSet) { match self { Self::ScheduleConfig(config) => { - config.metadata.dependencies.push(Dependency::new( - DependencyKind::Before, - set, - false, - true, - )); + config + .metadata + .dependencies + .push(Dependency::new(DependencyKind::Before, set).ignore_deferred()); } Self::Configs { configs, .. } => { for config in configs { @@ -218,12 +208,10 @@ impl> ScheduleConfig fn after_ignore_deferred_inner(&mut self, set: InternedSystemSet) { match self { Self::ScheduleConfig(config) => { - config.metadata.dependencies.push(Dependency::new( - DependencyKind::After, - set, - false, - true, - )); + config + .metadata + .dependencies + .push(Dependency::new(DependencyKind::After, set).ignore_deferred()); } Self::Configs { configs, .. } => { for config in configs { diff --git a/crates/bevy_ecs/src/schedule/graph/mod.rs b/crates/bevy_ecs/src/schedule/graph/mod.rs index 5523fb602e8e0..be6771d7b7341 100644 --- a/crates/bevy_ecs/src/schedule/graph/mod.rs +++ b/crates/bevy_ecs/src/schedule/graph/mod.rs @@ -28,19 +28,28 @@ pub(crate) struct Dependency { } impl Dependency { - pub fn new( - kind: DependencyKind, - set: InternedSystemSet, - is_weak: bool, - ignore_deferred: bool, - ) -> Self { + pub fn new(kind: DependencyKind, set: InternedSystemSet) -> Self { Self { kind, set, - is_weak, - ignore_deferred, + is_weak: false, + ignore_deferred: false, } } + + // Marks de dependency as weak. + // A weak dependency allows systems to run in parallel if they do not conflict. + pub fn set_weak(mut self) -> Self { + self.is_weak = true; + self + } + + // Marks the dependency to ignore deferred commands between systems. + // This ensures that there will not be a sync point between systems, where commands get flushed. + pub fn ignore_deferred(mut self) -> Self { + self.ignore_deferred = true; + self + } } /// Configures ambiguity detection for a single system. From cab635bdfce01d494946d39f3e28f7723952bff2 Mon Sep 17 00:00:00 2001 From: Trashtalk Date: Mon, 14 Sep 2026 02:41:33 +0200 Subject: [PATCH 4/6] mistake in comments --- crates/bevy_ecs/src/schedule/schedule.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/crates/bevy_ecs/src/schedule/schedule.rs b/crates/bevy_ecs/src/schedule/schedule.rs index 73c33698e5c66..74ceb32755439 100644 --- a/crates/bevy_ecs/src/schedule/schedule.rs +++ b/crates/bevy_ecs/src/schedule/schedule.rs @@ -291,7 +291,7 @@ pub enum Chain { /// Systems are chained. `before -> after` ordering constraints /// will be added between the successive elements. Chained { - /// Specifies if the links between the chained links are weak + /// Specifies if the links between the chained systems are weak is_weak: bool, /// Whether or not to insert sync points between systems in this chain ignore_deferred: bool, From 869007cfd173e2d54d287ca550c6c5fedd94e744 Mon Sep 17 00:00:00 2001 From: Trashtalk217 Date: Mon, 14 Sep 2026 02:51:29 +0200 Subject: [PATCH 5/6] Apply batched suggestions from code review Co-authored-by: Christian Hughes <9044780+ItsDoot@users.noreply.github.com> --- crates/bevy_ecs/src/schedule/graph/mod.rs | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-) diff --git a/crates/bevy_ecs/src/schedule/graph/mod.rs b/crates/bevy_ecs/src/schedule/graph/mod.rs index be6771d7b7341..015d299362ded 100644 --- a/crates/bevy_ecs/src/schedule/graph/mod.rs +++ b/crates/bevy_ecs/src/schedule/graph/mod.rs @@ -37,15 +37,17 @@ impl Dependency { } } - // Marks de dependency as weak. - // A weak dependency allows systems to run in parallel if they do not conflict. + /// Marks the dependency as weak. + /// A weak dependency allows systems to run in parallel if they do not conflict. pub fn set_weak(mut self) -> Self { self.is_weak = true; self } - // Marks the dependency to ignore deferred commands between systems. - // This ensures that there will not be a sync point between systems, where commands get flushed. + /// Marks the dependency to ignore deferred commands between systems. + /// This tells the [`AutoInsertApplyDeferredPass`] to ignore this dependency when considering sync points. + /// + /// [`AutoInsertApplyDeferredPass`]: crate::schedule::AutoInsertApplyDeferredPass pub fn ignore_deferred(mut self) -> Self { self.ignore_deferred = true; self From 2bdcccb1a9ad10f59baad93d0519f7af2592e9cd Mon Sep 17 00:00:00 2001 From: Alice Cecile Date: Tue, 15 Sep 2026 13:31:27 -0700 Subject: [PATCH 6/6] Fix CI by repairing broken doc link (no longer exported) --- crates/bevy_ecs/src/schedule/graph/mod.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/crates/bevy_ecs/src/schedule/graph/mod.rs b/crates/bevy_ecs/src/schedule/graph/mod.rs index 015d299362ded..ea11d3e8bf66c 100644 --- a/crates/bevy_ecs/src/schedule/graph/mod.rs +++ b/crates/bevy_ecs/src/schedule/graph/mod.rs @@ -47,7 +47,7 @@ impl Dependency { /// Marks the dependency to ignore deferred commands between systems. /// This tells the [`AutoInsertApplyDeferredPass`] to ignore this dependency when considering sync points. /// - /// [`AutoInsertApplyDeferredPass`]: crate::schedule::AutoInsertApplyDeferredPass + /// [`AutoInsertApplyDeferredPass`]: crate::schedule::passes::AutoInsertApplyDeferredPass pub fn ignore_deferred(mut self) -> Self { self.ignore_deferred = true; self