Implement batched query support

PR bevyengine#6161
Issue bevyengine#1990

* Only Dense queries are accelerated currently
* Code refactored to use GATs
* Batch type does not encode alignment as per discussion
* Simplified calling for_each_{mut_}batched (no longer need _ arguments)
* Documentation about SIMD and batching

Author: InBetweenNames

crates/bevy_ecs/Cargo.toml

@@ -30,6 +30,7 @@ serde = { version = "1", features = ["derive"] }
 
 [dev-dependencies]
 rand = "0.8"
+bevy_math = { path = "../bevy_math", version = "0.9.0-dev" }
 
 [[example]]
 name = "events"

crates/bevy_ecs/src/archetype.rs

@@ -23,7 +23,10 @@ use crate::{
     bundle::BundleId,
     component::{ComponentId, StorageType},
     entity::{Entity, EntityLocation},
-    storage::{ImmutableSparseSet, SparseArray, SparseSet, SparseSetIndex, TableId, TableRow},
+    storage::{
+        aligned_vec::SimdAlignedVec, ImmutableSparseSet, SparseArray, SparseSet, SparseSetIndex,
+        TableId, TableRow,
+    },
 };
 use std::{
     collections::HashMap,
@@ -295,7 +298,7 @@ pub struct Archetype {
     id: ArchetypeId,
     table_id: TableId,
     edges: Edges,
-    entities: Vec<ArchetypeEntity>,
+    entities: SimdAlignedVec<ArchetypeEntity>,
     components: ImmutableSparseSet<ComponentId, ArchetypeComponentInfo>,
 }
 
@@ -331,7 +334,7 @@ impl Archetype {
         Self {
             id,
             table_id,
-            entities: Vec::new(),
+            entities: SimdAlignedVec::new(),
             components: components.into_immutable(),
             edges: Default::default(),
         }

crates/bevy_ecs/src/change_detection.rs

@@ -2,10 +2,10 @@
 
 use crate::{
     component::{Tick, TickCells},
-    ptr::PtrMut,
+    ptr::{Batch, PtrMut, UnsafeCellDeref},
     system::Resource,
 };
-use bevy_ptr::UnsafeCellDeref;
+use core::marker::PhantomData;
 use std::ops::{Deref, DerefMut};
 
 /// The (arbitrarily chosen) minimum number of world tick increments between `check_tick` scans.
@@ -283,6 +283,12 @@ impl<'a> Ticks<'a> {
         }
     }
 }
+pub(crate) struct TicksBatch<'a, const N: usize> {
+    pub(crate) added_ticks: &'a mut Batch<Tick, N>,
+    pub(crate) changed_ticks: &'a mut Batch<Tick, N>,
+    pub(crate) last_change_tick: u32,
+    pub(crate) change_tick: u32,
+}
 
 /// Unique mutable borrow of a [`Resource`].
 ///
@@ -407,6 +413,118 @@ change_detection_impl!(Mut<'a, T>, T,);
 impl_methods!(Mut<'a, T>, T,);
 impl_debug!(Mut<'a, T>,);
 
+/// Unique mutable borrow of an entity's component (batched version).
+/// Each batch changes in unison:  a batch has changed if any of its elements have changed.
+pub struct MutBatch<'a, T, const N: usize> {
+    pub(crate) value: &'a mut Batch<T, N>,
+    pub(crate) ticks: TicksBatch<'a, N>,
+    pub(crate) _marker: PhantomData<T>,
+}
+
+impl<'a, T, const N: usize> DetectChanges for MutBatch<'a, T, N> {
+    #[inline]
+    fn is_added(&self) -> bool {
+        self.ticks
+            .added_ticks
+            .iter()
+            .any(|x| x.is_older_than(self.ticks.last_change_tick, self.ticks.change_tick))
+    }
+
+    #[inline]
+    fn is_changed(&self) -> bool {
+        self.ticks
+            .changed_ticks
+            .iter()
+            .any(|x| x.is_older_than(self.ticks.last_change_tick, self.ticks.change_tick))
+    }
+
+    #[inline]
+    fn set_changed(&mut self) {
+        for ticks in self.ticks.changed_ticks.iter_mut() {
+            ticks.set_changed(self.ticks.change_tick);
+        }
+    }
+
+    #[inline]
+    fn last_changed(&self) -> u32 {
+        self.ticks.last_change_tick
+    }
+
+    type Inner = Batch<T, N>;
+
+    fn set_last_changed(&mut self, last_change_tick: u32) {
+        self.ticks.last_change_tick = last_change_tick;
+    }
+
+    fn bypass_change_detection(&mut self) -> &mut Self::Inner {
+        self.value
+    }
+
+    #[inline]
+    fn set_if_neq<Target>(&mut self, value: Target)
+    where
+        Self: Deref<Target = Target> + DerefMut<Target = Target>,
+        Target: PartialEq,
+    {
+        // This dereference is immutable, so does not trigger change detection
+        if *<Self as Deref>::deref(self) != value {
+            // `DerefMut` usage triggers change detection
+            *<Self as DerefMut>::deref_mut(self) = value;
+        }
+    }
+}
+
+impl<'a, T, const N: usize> Deref for MutBatch<'a, T, N> {
+    type Target = Batch<T, N>;
+
+    #[inline]
+    fn deref(&self) -> &Self::Target {
+        self.value
+    }
+}
+
+impl<'a, T, const N: usize> DerefMut for MutBatch<'a, T, N> {
+    #[inline]
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        self.set_changed();
+        self.value
+    }
+}
+
+impl<'a, T, const N: usize> AsRef<Batch<T, N>> for MutBatch<'a, T, N> {
+    #[inline]
+    fn as_ref(&self) -> &Batch<T, N> {
+        self.deref()
+    }
+}
+
+impl<'a, T, const N: usize> AsMut<Batch<T, N>> for MutBatch<'a, T, N> {
+    #[inline]
+    fn as_mut(&mut self) -> &mut Batch<T, N> {
+        self.deref_mut()
+    }
+}
+
+impl<'a, T, const N: usize> MutBatch<'a, T, N> {
+    /// Consume `self` and return a mutable reference to the
+    /// contained value while marking `self` as "changed".
+    #[inline]
+    pub fn into_inner(mut self) -> &'a mut Batch<T, N> {
+        self.set_changed();
+        self.value
+    }
+}
+
+impl<'a, T, const N: usize> std::fmt::Debug for MutBatch<'a, T, N>
+where
+    Batch<T, N>: std::fmt::Debug,
+    T: std::fmt::Debug,
+{
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_tuple(stringify!($name)).field(&self.value).finish()
+    }
+}
+
 /// Unique mutable borrow of resources or an entity's component.
 ///
 /// Similar to [`Mut`], but not generic over the component type, instead