Implement batched query support

* Only Dense queries are accelerated currently
* Certain features are awaiting on GATs/generic const expressions

Author: InBetweenNames

crates/bevy_ecs/Cargo.toml

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

crates/bevy_ecs/src/archetype.rs

@@ -5,7 +5,10 @@ use crate::{
     bundle::BundleId,
     component::{ComponentId, StorageType},
     entity::{Entity, EntityLocation},
-    storage::{Column, SparseArray, SparseSet, SparseSetIndex, TableId},
+    ptr::ThinSimdAlignedSlicePtr,
+    storage::{
+        aligned_vec::SimdAlignedVec, Column, SparseArray, SparseSet, SparseSetIndex, TableId,
+    },
 };
 use std::{
     collections::HashMap,
@@ -120,7 +123,7 @@ impl Edges {
 
 struct TableInfo {
     id: TableId,
-    entity_rows: Vec<usize>,
+    entity_rows: SimdAlignedVec<usize>,
 }
 
 pub(crate) struct ArchetypeSwapRemoveResult {
@@ -135,7 +138,7 @@ pub(crate) struct ArchetypeComponentInfo {
 
 pub struct Archetype {
     id: ArchetypeId,
-    entities: Vec<Entity>,
+    entities: SimdAlignedVec<Entity>,
     edges: Edges,
     table_info: TableInfo,
     table_components: Box<[ComponentId]>,
@@ -214,6 +217,18 @@ impl Archetype {
         &self.table_info.entity_rows
     }
 
+    //These 'aligned' functions are necessary for batching but aren't meant for general consumption.
+    //However, we can't convert from an arbitrary slice into a ThinSimdAlignedSlicePtr.
+    #[inline]
+    pub(crate) fn entities_aligned(&self) -> ThinSimdAlignedSlicePtr<Entity> {
+        self.entities.get_slice()
+    }
+
+    #[inline]
+    pub(crate) fn entity_table_rows_aligned(&self) -> ThinSimdAlignedSlicePtr<usize> {
+        self.table_info.entity_rows.get_slice()
+    }
+
     #[inline]
     pub fn table_components(&self) -> &[ComponentId] {
         &self.table_components

crates/bevy_ecs/src/change_detection.rs

@@ -1,6 +1,9 @@
 //! Types that detect when their internal data mutate.
 
+use crate::ptr::batch::{AlignedBatchGat, AlignedBatchT, AlignedBatchTrait};
+
 use crate::{component::ComponentTicks, ptr::PtrMut, system::Resource};
+use std::marker::PhantomData;
 #[cfg(feature = "bevy_reflect")]
 use std::ops::{Deref, DerefMut};
 
@@ -198,6 +201,15 @@ pub(crate) struct Ticks<'a> {
     pub(crate) change_tick: u32,
 }
 
+pub(crate) struct TicksBatch<'a, const N: usize, const ALIGN: usize>
+where
+    ComponentTicks: AlignedBatchGat<N, ALIGN>,
+{
+    pub(crate) component_ticks: &'a mut AlignedBatchT<ComponentTicks, N, ALIGN>,
+    pub(crate) last_change_tick: u32,
+    pub(crate) change_tick: u32,
+}
+
 /// Unique mutable borrow of a [`Resource`].
 ///
 /// See the [`Resource`] documentation for usage.
@@ -271,6 +283,143 @@ change_detection_impl!(Mut<'a, T>, T,);
 impl_into_inner!(Mut<'a, T>, T,);
 impl_debug!(Mut<'a, T>,);
 
+/// Unique mutable borrow of an entity's component (batched version)
+/// a batch changes in unison.  A batch has changed if any of its elements have changed.
+pub struct MutBatch<'a, T: ?Sized, const N: usize, const ALIGN: usize>
+where
+    ComponentTicks: AlignedBatchGat<N, ALIGN>,
+    T: AlignedBatchGat<N, ALIGN>,
+{
+    pub(crate) value: &'a mut AlignedBatchT<T, N, ALIGN>,
+    pub(crate) ticks: TicksBatch<'a, N, ALIGN>,
+    pub(crate) _marker: PhantomData<T>,
+}
+
+impl<'a, T: ?Sized, const N: usize, const ALIGN: usize> DetectChanges for MutBatch<'a, T, N, ALIGN>
+where
+    ComponentTicks: AlignedBatchGat<N, ALIGN>,
+    T: AlignedBatchGat<N, ALIGN>,
+{
+    #[inline]
+    fn is_added(&self) -> bool {
+        self.ticks
+            .component_ticks
+            .as_array()
+            .iter()
+            .any(|x| x.is_added(self.ticks.last_change_tick, self.ticks.change_tick))
+    }
+
+    #[inline]
+    fn is_changed(&self) -> bool {
+        self.ticks
+            .component_ticks
+            .as_array()
+            .iter()
+            .any(|x| x.is_changed(self.ticks.last_change_tick, self.ticks.change_tick))
+    }
+
+    #[inline]
+    fn set_changed(&mut self) {
+        for ticks in self.ticks.component_ticks.as_array_mut().iter_mut() {
+            ticks.set_changed(self.ticks.change_tick);
+        }
+    }
+
+    #[inline]
+    fn last_changed(&self) -> u32 {
+        self.ticks.last_change_tick
+    }
+
+    type Inner = AlignedBatchT<T, N, ALIGN>;
+
+    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
+    }
+}
+
+impl<'a, T, const N: usize, const ALIGN: usize> Deref for MutBatch<'a, T, N, ALIGN>
+where
+    ComponentTicks: AlignedBatchGat<N, ALIGN>,
+    T: AlignedBatchGat<N, ALIGN>,
+{
+    type Target = AlignedBatchT<T, N, ALIGN>;
+
+    #[inline]
+    fn deref(&self) -> &Self::Target {
+        self.value
+    }
+}
+
+impl<'a, T, const N: usize, const ALIGN: usize> DerefMut for MutBatch<'a, T, N, ALIGN>
+where
+    ComponentTicks: AlignedBatchGat<N, ALIGN>,
+    T: AlignedBatchGat<N, ALIGN>,
+{
+    #[inline]
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        self.set_changed();
+        self.value
+    }
+}
+
+impl<'a, T, const N: usize, const ALIGN: usize> AsRef<AlignedBatchT<T, N, ALIGN>>
+    for MutBatch<'a, T, N, ALIGN>
+where
+    ComponentTicks: AlignedBatchGat<N, ALIGN>,
+    T: AlignedBatchGat<N, ALIGN>,
+{
+    #[inline]
+    fn as_ref(&self) -> &AlignedBatchT<T, N, ALIGN> {
+        self.deref()
+    }
+}
+
+impl<'a, T, const N: usize, const ALIGN: usize> AsMut<AlignedBatchT<T, N, ALIGN>>
+    for MutBatch<'a, T, N, ALIGN>
+where
+    ComponentTicks: AlignedBatchGat<N, ALIGN>,
+    T: AlignedBatchGat<N, ALIGN>,
+{
+    #[inline]
+    fn as_mut(&mut self) -> &mut AlignedBatchT<T, N, ALIGN> {
+        self.deref_mut()
+    }
+}
+
+//change_detection_impl!(MutBatch<'a, T>, T,);
+//impl_into_inner!(MutBatch<'a, T>, T,);
+//impl_debug!(MutBatch<'a, T>,);
+
+impl<'a, T, const N: usize, const ALIGN: usize> MutBatch<'a, T, N, ALIGN>
+where
+    ComponentTicks: AlignedBatchGat<N, ALIGN>,
+    T: AlignedBatchGat<N, ALIGN>,
+{
+    /// 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 AlignedBatchT<T, N, ALIGN> {
+        self.set_changed();
+        self.value
+    }
+}
+
+impl<'a, T, const N: usize, const ALIGN: usize> std::fmt::Debug for MutBatch<'a, T, N, ALIGN>
+where
+    ComponentTicks: AlignedBatchGat<N, ALIGN>,
+    T: AlignedBatchGat<N, ALIGN>,
+    AlignedBatchT<T, N, ALIGN>: 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