bevy_ecs changes

Author: maniwani

crates/bevy_ecs/macros/src/component.rs

@@ -39,6 +39,24 @@ pub fn derive_resource(input: TokenStream) -> TokenStream {
     })
 }
 
+pub fn derive_thread_local_resource(input: TokenStream) -> TokenStream {
+    let mut ast = parse_macro_input!(input as DeriveInput);
+    let bevy_ecs_path: Path = crate::bevy_ecs_path();
+
+    ast.generics
+        .make_where_clause()
+        .predicates
+        .push(parse_quote! { Self: 'static });
+
+    let struct_name = &ast.ident;
+    let (impl_generics, type_generics, where_clause) = &ast.generics.split_for_impl();
+
+    TokenStream::from(quote! {
+        impl #impl_generics #bevy_ecs_path::storage::ThreadLocalResource for #struct_name #type_generics #where_clause {
+        }
+    })
+}
+
 pub fn derive_component(input: TokenStream) -> TokenStream {
     let mut ast = parse_macro_input!(input as DeriveInput);
     let bevy_ecs_path: Path = crate::bevy_ecs_path();

crates/bevy_ecs/macros/src/lib.rs

@@ -460,21 +460,31 @@ pub(crate) fn bevy_ecs_path() -> syn::Path {
 }
 
 #[proc_macro_derive(Event)]
+/// Derive macro generating an impl of the trait `Event`.
 pub fn derive_event(input: TokenStream) -> TokenStream {
     component::derive_event(input)
 }
 
 #[proc_macro_derive(Resource)]
+/// Derive macro generating an impl of the trait `Resource`.
 pub fn derive_resource(input: TokenStream) -> TokenStream {
     component::derive_resource(input)
 }
 
+#[proc_macro_derive(ThreadLocalResource)]
+/// Derive macro generating an impl of the trait `ThreadLocalResource`.
+pub fn derive_thread_local_resource(input: TokenStream) -> TokenStream {
+    component::derive_thread_local_resource(input)
+}
+
 #[proc_macro_derive(Component, attributes(component))]
+/// Derive macro generating an impl of the trait `Component`.
 pub fn derive_component(input: TokenStream) -> TokenStream {
     component::derive_component(input)
 }
 
 #[proc_macro_derive(States)]
+/// Derive macro generating an impl of the trait `States`.
 pub fn derive_states(input: TokenStream) -> TokenStream {
     states::derive_states(input)
 }

crates/bevy_ecs/src/change_detection.rs

@@ -579,39 +579,6 @@ impl<'a, T: Resource> From<ResMut<'a, T>> for Mut<'a, T> {
     }
 }
 
-/// Unique borrow of a non-[`Send`] resource.
-///
-/// Only [`Send`] resources may be accessed with the [`ResMut`] [`SystemParam`](crate::system::SystemParam). In case that the
-/// resource does not implement `Send`, this `SystemParam` wrapper can be used. This will instruct
-/// the scheduler to instead run the system on the main thread so that it doesn't send the resource
-/// over to another thread.
-///
-/// # Panics
-///
-/// Panics when used as a `SystemParameter` if the resource does not exist.
-///
-/// Use `Option<NonSendMut<T>>` instead if the resource might not always exist.
-pub struct NonSendMut<'a, T: ?Sized + 'static> {
-    pub(crate) value: &'a mut T,
-    pub(crate) ticks: TicksMut<'a>,
-}
-
-change_detection_impl!(NonSendMut<'a, T>, T,);
-change_detection_mut_impl!(NonSendMut<'a, T>, T,);
-impl_methods!(NonSendMut<'a, T>, T,);
-impl_debug!(NonSendMut<'a, T>,);
-
-impl<'a, T: 'static> From<NonSendMut<'a, T>> for Mut<'a, T> {
-    /// Convert this `NonSendMut` into a `Mut`. This allows keeping the change-detection feature of `Mut`
-    /// while losing the specificity of `NonSendMut`.
-    fn from(other: NonSendMut<'a, T>) -> Mut<'a, T> {
-        Mut {
-            value: other.value,
-            ticks: other.ticks,
-        }
-    }
-}
-
 /// Shared borrow of an entity's component with access to change detection.
 /// Similar to [`Mut`] but is immutable and so doesn't require unique access.
 pub struct Ref<'a, T: ?Sized> {
@@ -910,9 +877,7 @@ mod tests {
 
     use crate::{
         self as bevy_ecs,
-        change_detection::{
-            Mut, NonSendMut, Ref, ResMut, TicksMut, CHECK_TICK_THRESHOLD, MAX_CHANGE_AGE,
-        },
+        change_detection::{Mut, Ref, ResMut, TicksMut, CHECK_TICK_THRESHOLD, MAX_CHANGE_AGE},
         component::{Component, ComponentTicks, Tick},
         system::{IntoSystem, Query, System},
         world::World,
@@ -1056,31 +1021,6 @@ mod tests {
         assert!(val.is_changed());
     }
 
-    #[test]
-    fn mut_from_non_send_mut() {
-        let mut component_ticks = ComponentTicks {
-            added: Tick::new(1),
-            changed: Tick::new(2),
-        };
-        let ticks = TicksMut {
-            added: &mut component_ticks.added,
-            changed: &mut component_ticks.changed,
-            last_run: Tick::new(3),
-            this_run: Tick::new(4),
-        };
-        let mut res = R {};
-        let non_send_mut = NonSendMut {
-            value: &mut res,
-            ticks,
-        };
-
-        let into_mut: Mut<R> = non_send_mut.into();
-        assert_eq!(1, into_mut.ticks.added.get());
-        assert_eq!(2, into_mut.ticks.changed.get());
-        assert_eq!(3, into_mut.ticks.last_run.get());
-        assert_eq!(4, into_mut.ticks.this_run.get());
-    }
-
     #[test]
     fn map_mut() {
         use super::*;

crates/bevy_ecs/src/component.rs

@@ -1,5 +1,6 @@
 //! Types for declaring and storing [`Component`]s.
 
+use crate::storage::ThreadLocalResource;
 use crate::{
     self as bevy_ecs,
     change_detection::MAX_CHANGE_AGE,
@@ -634,11 +635,11 @@ impl Components {
         }
     }
 
-    /// Initializes a [non-send resource](crate::system::NonSend) of type `T` with this instance.
+    /// Initializes a [`ThreadLocalResource`] of type `T` with this instance.
     /// If a resource of this type has already been initialized, this will return
     /// the ID of the pre-existing resource.
     #[inline]
-    pub fn init_non_send<T: Any>(&mut self) -> ComponentId {
+    pub fn init_non_send<T: ThreadLocalResource>(&mut self) -> ComponentId {
         // SAFETY: The [`ComponentDescriptor`] matches the [`TypeId`]
         unsafe {
             self.get_or_insert_resource_with(TypeId::of::<T>(), || {
@@ -759,6 +760,7 @@ impl<'a> TickCells<'a> {
     /// # Safety
     /// All cells contained within must uphold the safety invariants of [`UnsafeCellDeref::read`].
     #[inline]
+    #[allow(dead_code)]
     pub(crate) unsafe fn read(&self) -> ComponentTicks {
         ComponentTicks {
             added: self.added.read(),

crates/bevy_ecs/src/lib.rs

@@ -48,9 +48,10 @@ pub mod prelude {
             IntoSystemConfigs, IntoSystemSet, IntoSystemSetConfigs, NextState, OnEnter, OnExit,
             OnTransition, Schedule, Schedules, State, States, SystemSet,
         },
+        storage::{ThreadLocal, ThreadLocalResource, ThreadLocals},
         system::{
-            Commands, Deferred, In, IntoSystem, Local, NonSend, NonSendMut, ParallelCommands,
-            ParamSet, Query, ReadOnlySystem, Res, ResMut, Resource, System, SystemParamFunction,
+            Commands, Deferred, In, IntoSystem, Local, ParallelCommands, ParamSet, Query,
+            ReadOnlySystem, Res, ResMut, Resource, System, SystemParamFunction,
         },
         world::{EntityMut, EntityRef, EntityWorldMut, FromWorld, World},
     };
@@ -77,7 +78,6 @@ mod tests {
     use bevy_tasks::{ComputeTaskPool, TaskPool};
     use std::{
         any::TypeId,
-        marker::PhantomData,
         sync::{
             atomic::{AtomicUsize, Ordering},
             Arc, Mutex,
@@ -91,9 +91,6 @@ mod tests {
     #[derive(Component, Debug, PartialEq, Eq, Clone, Copy)]
     struct C;
 
-    #[derive(Default)]
-    struct NonSendA(usize, PhantomData<*mut ()>);
-
     #[derive(Component, Clone, Debug)]
     struct DropCk(Arc<AtomicUsize>);
     impl DropCk {
@@ -1269,36 +1266,6 @@ mod tests {
         );
     }
 
-    #[test]
-    fn non_send_resource() {
-        let mut world = World::default();
-        world.insert_non_send_resource(123i32);
-        world.insert_non_send_resource(456i64);
-        assert_eq!(*world.non_send_resource::<i32>(), 123);
-        assert_eq!(*world.non_send_resource_mut::<i64>(), 456);
-    }
-
-    #[test]
-    fn non_send_resource_points_to_distinct_data() {
-        let mut world = World::default();
-        world.insert_resource(A(123));
-        world.insert_non_send_resource(A(456));
-        assert_eq!(*world.resource::<A>(), A(123));
-        assert_eq!(*world.non_send_resource::<A>(), A(456));
-    }
-
-    #[test]
-    #[should_panic]
-    fn non_send_resource_panic() {
-        let mut world = World::default();
-        world.insert_non_send_resource(0i32);
-        std::thread::spawn(move || {
-            let _ = world.non_send_resource_mut::<i32>();
-        })
-        .join()
-        .unwrap();
-    }
-
     #[test]
     fn exact_size_query() {
         let mut world = World::default();
@@ -1416,32 +1383,6 @@ mod tests {
         assert_eq!(world.resource::<A>().0, 1);
     }
 
-    #[test]
-    #[should_panic(
-        expected = "Attempted to access or drop non-send resource bevy_ecs::tests::NonSendA from thread"
-    )]
-    fn non_send_resource_drop_from_different_thread() {
-        let mut world = World::default();
-        world.insert_non_send_resource(NonSendA::default());
-
-        let thread = std::thread::spawn(move || {
-            // Dropping the non-send resource on a different thread
-            // Should result in a panic
-            drop(world);
-        });
-
-        if let Err(err) = thread.join() {
-            std::panic::resume_unwind(err);
-        }
-    }
-
-    #[test]
-    fn non_send_resource_drop_from_same_thread() {
-        let mut world = World::default();
-        world.insert_non_send_resource(NonSendA::default());
-        drop(world);
-    }
-
     #[test]
     fn insert_overwrite_drop() {
         let (dropck1, dropped1) = DropCk::new_pair();

crates/bevy_ecs/src/schedule/config.rs

@@ -6,17 +6,11 @@ use crate::{
         graph_utils::{Ambiguity, Dependency, DependencyKind, GraphInfo},
         set::{BoxedSystemSet, IntoSystemSet, SystemSet},
     },
-    system::{BoxedSystem, IntoSystem, System},
+    system::{BoxedSystem, IntoSystem},
 };
 
 fn new_condition<M>(condition: impl Condition<M>) -> BoxedCondition {
     let condition_system = IntoSystem::into_system(condition);
-    assert!(
-        condition_system.is_send(),
-        "Condition `{}` accesses `NonSend` resources. This is not currently supported.",
-        condition_system.name()
-    );
-
     Box::new(condition_system)
 }
 

crates/bevy_ecs/src/schedule/executor/multi_threaded.rs

@@ -1,5 +1,6 @@
 use std::{
     any::Any,
+    panic::AssertUnwindSafe,
     sync::{Arc, Mutex},
 };
 
@@ -8,7 +9,6 @@ use bevy_utils::default;
 use bevy_utils::syncunsafecell::SyncUnsafeCell;
 #[cfg(feature = "trace")]
 use bevy_utils::tracing::{info_span, Instrument, Span};
-use std::panic::AssertUnwindSafe;
 
 use async_channel::{Receiver, Sender};
 use fixedbitset::FixedBitSet;
@@ -58,8 +58,6 @@ struct SystemTaskMetadata {
     archetype_component_access: Access<ArchetypeComponentId>,
     /// Indices of the systems that directly depend on the system.
     dependents: Vec<usize>,
-    /// Is `true` if the system does not access `!Send` data.
-    is_send: bool,
     /// Is `true` if the system is exclusive.
     is_exclusive: bool,
     /// Cached tracing span for system task
@@ -83,8 +81,6 @@ pub struct MultiThreadedExecutor {
     system_task_metadata: Vec<SystemTaskMetadata>,
     /// Union of the accesses of all currently running systems.
     active_access: Access<ArchetypeComponentId>,
-    /// Returns `true` if a system with non-`Send` access is running.
-    local_thread_running: bool,
     /// Returns `true` if an exclusive system is running.
     exclusive_running: bool,
     /// The number of systems expected to run.
@@ -154,7 +150,6 @@ impl SystemExecutor for MultiThreadedExecutor {
             self.system_task_metadata.push(SystemTaskMetadata {
                 archetype_component_access: default(),
                 dependents: schedule.system_dependents[index].clone(),
-                is_send: schedule.systems[index].is_send(),
                 is_exclusive: schedule.systems[index].is_exclusive(),
                 #[cfg(feature = "trace")]
                 system_task_span: info_span!(
@@ -278,7 +273,6 @@ impl MultiThreadedExecutor {
             num_completed_systems: 0,
             num_dependencies_remaining: Vec::new(),
             active_access: default(),
-            local_thread_running: false,
             exclusive_running: false,
             evaluated_sets: FixedBitSet::new(),
             ready_systems: FixedBitSet::new(),
@@ -378,10 +372,6 @@ impl MultiThreadedExecutor {
             return false;
         }
 
-        if !system_meta.is_send && self.local_thread_running {
-            return false;
-        }
-
         // TODO: an earlier out if world's archetypes did not change
         for set_idx in conditions.sets_with_conditions_of_systems[system_index]
             .difference(&self.evaluated_sets)
@@ -532,12 +522,7 @@ impl MultiThreadedExecutor {
         self.active_access
             .extend(&system_meta.archetype_component_access);
 
-        if system_meta.is_send {
-            scope.spawn(task);
-        } else {
-            self.local_thread_running = true;
-            scope.spawn_on_external(task);
-        }
+        scope.spawn(task);
     }
 
     /// # Safety
@@ -580,7 +565,7 @@ impl MultiThreadedExecutor {
                     .system_task_span
                     .clone(),
             );
-            scope.spawn_on_scope(task);
+            scope.spawn(task);
         } else {
             let task = async move {
                 let res = std::panic::catch_unwind(AssertUnwindSafe(|| {
@@ -610,11 +595,10 @@ impl MultiThreadedExecutor {
                     .system_task_span
                     .clone(),
             );
-            scope.spawn_on_scope(task);
+            scope.spawn(task);
         }
 
         self.exclusive_running = true;
-        self.local_thread_running = true;
     }
 
     fn finish_system_and_handle_dependents(&mut self, result: SystemResult) {
@@ -627,10 +611,6 @@ impl MultiThreadedExecutor {
             self.exclusive_running = false;
         }
 
-        if !self.system_task_metadata[system_index].is_send {
-            self.local_thread_running = false;
-        }
-
         debug_assert!(self.num_running_systems >= 1);
         self.num_running_systems -= 1;
         self.num_completed_systems += 1;