Contiguous access

benches/benches/bevy_ecs/iteration/iter_simple_contiguous.rs

@@ -0,0 +1,47 @@
+use bevy_ecs::prelude::*;
+use glam::*;
+
+#[derive(Component, Copy, Clone)]
+struct Transform(Mat4);
+
+#[derive(Component, Copy, Clone)]
+struct Position(Vec3);
+
+#[derive(Component, Copy, Clone)]
+struct Rotation(Vec3);
+
+#[derive(Component, Copy, Clone)]
+struct Velocity(Vec3);
+
+pub struct Benchmark<'w>(World, QueryState<(&'w Velocity, &'w mut Position)>);
+
+impl<'w> Benchmark<'w> {
+    pub fn new() -> Self {
+        let mut world = World::new();
+
+        world.spawn_batch(core::iter::repeat_n(
+            (
+                Transform(Mat4::from_scale(Vec3::ONE)),
+                Position(Vec3::X),
+                Rotation(Vec3::X),
+                Velocity(Vec3::X),
+            ),
+            10_000,
+        ));
+
+        let query = world.query::<(&Velocity, &mut Position)>();
+        Self(world, query)
+    }
+
+    #[inline(never)]
+    pub fn run(&mut self) {
+        let mut iter = self.1.iter_mut(&mut self.0);
+        for (velocity, (position, mut ticks)) in iter.as_contiguous_iter().unwrap() {
+            for (v, p) in velocity.iter().zip(position.iter_mut()) {
+                p.0 += v.0;
+            }
+            // to match the iter_simple benchmark
+            ticks.mark_all_as_updated();
+        }
+    }
+}

benches/benches/bevy_ecs/iteration/iter_simple_contiguous_avx2.rs

@@ -0,0 +1,63 @@
+use bevy_ecs::prelude::*;
+use glam::*;
+
+#[derive(Component, Copy, Clone)]
+struct Transform(Mat4);
+
+#[derive(Component, Copy, Clone)]
+struct Position(Vec3);
+
+#[derive(Component, Copy, Clone)]
+struct Rotation(Vec3);
+
+#[derive(Component, Copy, Clone)]
+struct Velocity(Vec3);
+
+pub struct Benchmark<'w>(World, QueryState<(&'w Velocity, &'w mut Position)>);
+
+impl<'w> Benchmark<'w> {
+    pub fn supported() -> bool {
+        is_x86_feature_detected!("avx2")
+    }
+
+    pub fn new() -> Option<Self> {
+        if !Self::supported() {
+            return None;
+        }
+
+        let mut world = World::new();
+
+        world.spawn_batch(core::iter::repeat_n(
+            (
+                Transform(Mat4::from_scale(Vec3::ONE)),
+                Position(Vec3::X),
+                Rotation(Vec3::X),
+                Velocity(Vec3::X),
+            ),
+            10_000,
+        ));
+
+        let query = world.query::<(&Velocity, &mut Position)>();
+        Some(Self(world, query))
+    }
+
+    #[inline(never)]
+    pub fn run(&mut self) {
+        #[target_feature(enable = "avx2")]
+        fn exec(position: &mut [Position], velocity: &[Velocity]) {
+            for i in 0..position.len() {
+                position[i].0 += velocity[i].0;
+            }
+        }
+
+        let mut iter = self.1.iter_mut(&mut self.0);
+        for (velocity, (position, mut ticks)) in iter.as_contiguous_iter().unwrap() {
+            // SAFETY: checked in new
+            unsafe {
+                exec(position, velocity);
+            }
+            // to match the iter_simple benchmark
+            ticks.mark_all_as_updated();
+        }
+    }
+}

benches/benches/bevy_ecs/iteration/iter_simple_no_detection.rs

@@ -0,0 +1,42 @@
+use bevy_ecs::prelude::*;
+use glam::*;
+
+#[derive(Component, Copy, Clone)]
+struct Transform(Mat4);
+
+#[derive(Component, Copy, Clone)]
+struct Position(Vec3);
+
+#[derive(Component, Copy, Clone)]
+struct Rotation(Vec3);
+
+#[derive(Component, Copy, Clone)]
+struct Velocity(Vec3);
+
+pub struct Benchmark<'w>(World, QueryState<(&'w Velocity, &'w mut Position)>);
+
+impl<'w> Benchmark<'w> {
+    pub fn new() -> Self {
+        let mut world = World::new();
+
+        world.spawn_batch(core::iter::repeat_n(
+            (
+                Transform(Mat4::from_scale(Vec3::ONE)),
+                Position(Vec3::X),
+                Rotation(Vec3::X),
+                Velocity(Vec3::X),
+            ),
+            10_000,
+        ));
+
+        let query = world.query::<(&Velocity, &mut Position)>();
+        Self(world, query)
+    }
+
+    #[inline(never)]
+    pub fn run(&mut self) {
+        for (velocity, mut position) in self.1.iter_mut(&mut self.0) {
+            position.bypass_change_detection().0 += velocity.0;
+        }
+    }
+}

benches/benches/bevy_ecs/iteration/iter_simple_no_detection_contiguous.rs

@@ -0,0 +1,45 @@
+use bevy_ecs::prelude::*;
+use glam::*;
+
+#[derive(Component, Copy, Clone)]
+struct Transform(Mat4);
+
+#[derive(Component, Copy, Clone)]
+struct Position(Vec3);
+
+#[derive(Component, Copy, Clone)]
+struct Rotation(Vec3);
+
+#[derive(Component, Copy, Clone)]
+struct Velocity(Vec3);
+
+pub struct Benchmark<'w>(World, QueryState<(&'w Velocity, &'w mut Position)>);
+
+impl<'w> Benchmark<'w> {
+    pub fn new() -> Self {
+        let mut world = World::new();
+
+        world.spawn_batch(core::iter::repeat_n(
+            (
+                Transform(Mat4::from_scale(Vec3::ONE)),
+                Position(Vec3::X),
+                Rotation(Vec3::X),
+                Velocity(Vec3::X),
+            ),
+            10_000,
+        ));
+
+        let query = world.query::<(&Velocity, &mut Position)>();
+        Self(world, query)
+    }
+
+    #[inline(never)]
+    pub fn run(&mut self) {
+        let mut iter = self.1.iter_mut(&mut self.0);
+        for (velocity, (position, _ticks)) in iter.as_contiguous_iter().unwrap() {
+            for (v, p) in velocity.iter().zip(position.iter_mut()) {
+                p.0 += v.0;
+            }
+        }
+    }
+}

benches/benches/bevy_ecs/iteration/mod.rs

@@ -8,11 +8,16 @@ mod iter_frag_sparse;
 mod iter_frag_wide;
 mod iter_frag_wide_sparse;
 mod iter_simple;
+mod iter_simple_contiguous;
+#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
+mod iter_simple_contiguous_avx2;
 mod iter_simple_foreach;
 mod iter_simple_foreach_hybrid;
 mod iter_simple_foreach_sparse_set;
 mod iter_simple_foreach_wide;
 mod iter_simple_foreach_wide_sparse_set;
+mod iter_simple_no_detection;
+mod iter_simple_no_detection_contiguous;
 mod iter_simple_sparse_set;
 mod iter_simple_system;
 mod iter_simple_wide;
@@ -40,6 +45,27 @@ fn iter_simple(c: &mut Criterion) {
         let mut bench = iter_simple::Benchmark::new();
         b.iter(move || bench.run());
     });
+    group.bench_function("base_contiguous", |b| {
+        let mut bench = iter_simple_contiguous::Benchmark::new();
+        b.iter(move || bench.run());
+    });
+    #[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
+    {
+        if iter_simple_contiguous_avx2::Benchmark::supported() {
+            group.bench_function("base_contiguous_avx2", |b| {
+                let mut bench = iter_simple_contiguous_avx2::Benchmark::new().unwrap();
+                b.iter(move || bench.run());
+            });
+        }
+    }
+    group.bench_function("base_no_detection", |b| {
+        let mut bench = iter_simple_no_detection::Benchmark::new();
+        b.iter(move || bench.run());
+    });
+    group.bench_function("base_no_detection_contiguous", |b| {
+        let mut bench = iter_simple_no_detection_contiguous::Benchmark::new();
+        b.iter(move || bench.run());
+    });
     group.bench_function("wide", |b| {
         let mut bench = iter_simple_wide::Benchmark::new();
         b.iter(move || bench.run());

crates/bevy_ecs/src/change_detection/params.rs

@@ -3,8 +3,9 @@ use crate::{
     ptr::PtrMut,
     resource::Resource,
 };
-use bevy_ptr::{Ptr, UnsafeCellDeref};
+use bevy_ptr::{Ptr, ThinSlicePtr, UnsafeCellDeref};
 use core::{
+    cell::UnsafeCell,
     ops::{Deref, DerefMut},
     panic::Location,
 };
@@ -463,6 +464,82 @@ impl<'w, T: ?Sized> Mut<'w, T> {
     }
 }
 
+/// Used by [`Mut`] for [`crate::query::ContiguousQueryData`] to allow marking component's changes
+pub struct ContiguousComponentTicks<'w, const MUTABLE: bool> {
+    added: ThinSlicePtr<'w, UnsafeCell<Tick>>,
+    changed: ThinSlicePtr<'w, UnsafeCell<Tick>>,
+    changed_by: MaybeLocation<ThinSlicePtr<'w, UnsafeCell<&'static Location<'static>>>>,
+    count: usize,
+    last_run: Tick,
+    this_run: Tick,
+}
+
+impl<'w> ContiguousComponentTicks<'w, true> {
+    /// Returns mutable changed ticks slice
+    pub fn get_changed_ticks_mut(&mut self) -> &mut [Tick] {
+        // SAFETY: `changed` slice is `self.count` long, aliasing rules are uphold by `new`.
+        unsafe { self.changed.as_mut_slice(self.count) }
+    }
+
+    /// Marks all components as updated
+    pub fn mark_all_as_updated(&mut self) {
+        let this_run = self.this_run;
+
+        for i in 0..self.count {
+            // SAFETY: `changed_by` slice is `self.count` long, aliasing rules are uphold by `new`
+            self.changed_by
+                .map(|v| unsafe { v.get_unchecked(i).deref_mut() })
+                .assign(MaybeLocation::caller());
+        }
+
+        for t in self.get_changed_ticks_mut() {
+            *t = this_run;
+        }
+    }
+}
+
+impl<'w, const MUTABLE: bool> ContiguousComponentTicks<'w, MUTABLE> {
+    pub(crate) unsafe fn new(
+        added: ThinSlicePtr<'w, UnsafeCell<Tick>>,
+        changed: ThinSlicePtr<'w, UnsafeCell<Tick>>,
+        changed_by: MaybeLocation<ThinSlicePtr<'w, UnsafeCell<&'static Location<'static>>>>,
+        count: usize,
+        last_run: Tick,
+        this_run: Tick,
+    ) -> Self {
+        Self {
+            added,
+            changed,
+            count,
+            changed_by,
+            last_run,
+            this_run,
+        }
+    }
+
+    /// Returns immutable changed ticks slice
+    pub fn get_changed_ticks(&self) -> &[Tick] {
+        // SAFETY: `self.changed` is `self.count` long
+        unsafe { self.changed.cast::<Tick>().as_slice(self.count) }
+    }
+
+    /// Returns immutable added ticks slice
+    pub fn get_added_ticks(&self) -> &[Tick] {
+        // SAFETY: `self.added` is `self.count` long
+        unsafe { self.added.cast::<Tick>().as_slice(self.count) }
+    }
+
+    /// Returns the last tick system ran
+    pub fn last_run(&self) -> Tick {
+        self.last_run
+    }
+
+    /// Returns the current tick
+    pub fn this_run(&self) -> Tick {
+        self.this_run
+    }
+}
+
 impl<'w, T: ?Sized> From<Mut<'w, T>> for Ref<'w, T> {
     fn from(mut_ref: Mut<'w, T>) -> Self {
         Self {