Merge branch 'main' into refactor_hierarchy_commands

Author: JaySpruce

benches/benches/bevy_ecs/change_detection.rs

@@ -1,11 +1,13 @@
+use core::hint::black_box;
+
 use bevy_ecs::{
     component::{Component, Mutable},
     entity::Entity,
     prelude::{Added, Changed, EntityWorldMut, QueryState},
     query::QueryFilter,
     world::World,
 };
-use criterion::{black_box, criterion_group, Criterion};
+use criterion::{criterion_group, Criterion};
 use rand::{prelude::SliceRandom, SeedableRng};
 use rand_chacha::ChaCha8Rng;
 

benches/benches/bevy_ecs/empty_archetypes.rs

@@ -1,5 +1,7 @@
+use core::hint::black_box;
+
 use bevy_ecs::{component::Component, prelude::*, schedule::ExecutorKind, world::World};
-use criterion::{black_box, criterion_group, BenchmarkId, Criterion};
+use criterion::{criterion_group, BenchmarkId, Criterion};
 
 criterion_group!(benches, empty_archetypes);
 

benches/benches/bevy_ecs/entity_cloning.rs

@@ -1,10 +1,12 @@
+use core::hint::black_box;
+
 use bevy_ecs::bundle::Bundle;
 use bevy_ecs::reflect::AppTypeRegistry;
 use bevy_ecs::{component::Component, reflect::ReflectComponent, world::World};
 use bevy_hierarchy::{BuildChildren, CloneEntityHierarchyExt};
 use bevy_math::Mat4;
 use bevy_reflect::{GetTypeRegistration, Reflect};
-use criterion::{black_box, criterion_group, criterion_main, Bencher, Criterion};
+use criterion::{criterion_group, criterion_main, Bencher, Criterion};
 
 criterion_group!(benches, reflect_benches, clone_benches);
 criterion_main!(benches);

benches/benches/bevy_ecs/observers/propagation.rs

@@ -1,9 +1,11 @@
+use core::hint::black_box;
+
 use bevy_ecs::{
     component::Component, entity::Entity, event::Event, observer::Trigger, world::World,
 };
 use bevy_hierarchy::{BuildChildren, Parent};
 
-use criterion::{black_box, Criterion};
+use criterion::Criterion;
 use rand::SeedableRng;
 use rand::{seq::IteratorRandom, Rng};
 use rand_chacha::ChaCha8Rng;

benches/benches/bevy_ecs/observers/simple.rs

@@ -1,6 +1,8 @@
+use core::hint::black_box;
+
 use bevy_ecs::{entity::Entity, event::Event, observer::Trigger, world::World};
 
-use criterion::{black_box, Criterion};
+use criterion::Criterion;
 use rand::{prelude::SliceRandom, SeedableRng};
 use rand_chacha::ChaCha8Rng;
 fn deterministic_rand() -> ChaCha8Rng {

benches/benches/bevy_ecs/world/commands.rs

@@ -1,9 +1,11 @@
+use core::hint::black_box;
+
 use bevy_ecs::{
     component::Component,
     system::Commands,
     world::{Command, CommandQueue, World},
 };
-use criterion::{black_box, Criterion};
+use criterion::Criterion;
 
 #[derive(Component)]
 struct A;

benches/benches/bevy_ecs/world/world_get.rs

@@ -1,11 +1,13 @@
+use core::hint::black_box;
+
 use bevy_ecs::{
     bundle::Bundle,
     component::Component,
     entity::Entity,
     system::{Query, SystemState},
     world::World,
 };
-use criterion::{black_box, Criterion};
+use criterion::Criterion;
 use rand::{prelude::SliceRandom, SeedableRng};
 use rand_chacha::ChaCha8Rng;
 

benches/benches/bevy_math/bezier.rs

@@ -1,94 +1,99 @@
-use criterion::{black_box, criterion_group, Criterion};
+use benches::bench;
+use bevy_math::{prelude::*, VectorSpace};
+use core::hint::black_box;
+use criterion::{
+    criterion_group, measurement::Measurement, BatchSize, BenchmarkGroup, BenchmarkId, Criterion,
+};
 
-use bevy_math::prelude::*;
+criterion_group!(benches, segment_ease, curve_position, curve_iter_positions);
 
-fn easing(c: &mut Criterion) {
-    let cubic_bezier = CubicSegment::new_bezier(vec2(0.25, 0.1), vec2(0.25, 1.0));
-    c.bench_function("easing_1000", |b| {
-        b.iter(|| {
-            (0..1000).map(|i| i as f32 / 1000.0).for_each(|t| {
-                black_box(cubic_bezier.ease(black_box(t)));
-            });
-        });
+fn segment_ease(c: &mut Criterion) {
+    let segment = black_box(CubicSegment::new_bezier(vec2(0.25, 0.1), vec2(0.25, 1.0)));
+
+    c.bench_function(bench!("segment_ease"), |b| {
+        let mut t = 0;
+
+        b.iter_batched(
+            || {
+                // Increment `t` by 1, but use modulo to constrain it to `0..=1000`.
+                t = (t + 1) % 1001;
+
+                // Return time as a decimal between 0 and 1, inclusive.
+                t as f32 / 1000.0
+            },
+            |t| segment.ease(t),
+            BatchSize::SmallInput,
+        );
     });
 }
 
-fn cubic_2d(c: &mut Criterion) {
-    let bezier = CubicBezier::new([[
+fn curve_position(c: &mut Criterion) {
+    /// A helper function that benchmarks calling [`CubicCurve::position()`] over a generic [`VectorSpace`].
+    fn bench_curve<M: Measurement, P: VectorSpace>(
+        group: &mut BenchmarkGroup<M>,
+        name: &str,
+        curve: CubicCurve<P>,
+    ) {
+        group.bench_with_input(BenchmarkId::from_parameter(name), &curve, |b, curve| {
+            b.iter(|| curve.position(black_box(0.5)));
+        });
+    }
+
+    let mut group = c.benchmark_group(bench!("curve_position"));
+
+    let bezier_2 = CubicBezier::new([[
         vec2(0.0, 0.0),
         vec2(0.0, 1.0),
         vec2(1.0, 0.0),
         vec2(1.0, 1.0),
     ]])
     .to_curve()
-    .expect("Unable to build a curve from this data");
-    c.bench_function("cubic_position_Vec2", |b| {
-        b.iter(|| black_box(bezier.position(black_box(0.5))));
-    });
-}
+    .unwrap();
 
-fn cubic(c: &mut Criterion) {
-    let bezier = CubicBezier::new([[
-        vec3a(0.0, 0.0, 0.0),
-        vec3a(0.0, 1.0, 0.0),
-        vec3a(1.0, 0.0, 0.0),
-        vec3a(1.0, 1.0, 1.0),
-    ]])
-    .to_curve()
-    .expect("Unable to build a curve from this data");
-    c.bench_function("cubic_position_Vec3A", |b| {
-        b.iter(|| black_box(bezier.position(black_box(0.5))));
-    });
-}
+    bench_curve(&mut group, "vec2", bezier_2);
 
-fn cubic_vec3(c: &mut Criterion) {
-    let bezier = CubicBezier::new([[
+    let bezier_3 = CubicBezier::new([[
         vec3(0.0, 0.0, 0.0),
         vec3(0.0, 1.0, 0.0),
         vec3(1.0, 0.0, 0.0),
         vec3(1.0, 1.0, 1.0),
     ]])
     .to_curve()
-    .expect("Unable to build a curve from this data");
-    c.bench_function("cubic_position_Vec3", |b| {
-        b.iter(|| black_box(bezier.position(black_box(0.5))));
-    });
-}
+    .unwrap();
 
-fn build_pos_cubic(c: &mut Criterion) {
-    let bezier = CubicBezier::new([[
+    bench_curve(&mut group, "vec3", bezier_3);
+
+    let bezier_3a = CubicBezier::new([[
         vec3a(0.0, 0.0, 0.0),
         vec3a(0.0, 1.0, 0.0),
         vec3a(1.0, 0.0, 0.0),
         vec3a(1.0, 1.0, 1.0),
     ]])
     .to_curve()
-    .expect("Unable to build a curve from this data");
-    c.bench_function("build_pos_cubic_100_points", |b| {
-        b.iter(|| black_box(bezier.iter_positions(black_box(100)).collect::<Vec<_>>()));
-    });
+    .unwrap();
+
+    bench_curve(&mut group, "vec3a", bezier_3a);
+
+    group.finish();
 }
 
-fn build_accel_cubic(c: &mut Criterion) {
+fn curve_iter_positions(c: &mut Criterion) {
     let bezier = CubicBezier::new([[
         vec3a(0.0, 0.0, 0.0),
         vec3a(0.0, 1.0, 0.0),
         vec3a(1.0, 0.0, 0.0),
         vec3a(1.0, 1.0, 1.0),
     ]])
     .to_curve()
-    .expect("Unable to build a curve from this data");
-    c.bench_function("build_accel_cubic_100_points", |b| {
-        b.iter(|| black_box(bezier.iter_positions(black_box(100)).collect::<Vec<_>>()));
+    .unwrap();
+
+    c.bench_function(bench!("curve_iter_positions"), |b| {
+        b.iter(|| {
+            for x in bezier.iter_positions(black_box(100)) {
+                // Discard `x`, since we just care about `iter_positions()` being consumed, but make
+                // the compiler believe `x` is being used so it doesn't eliminate the iterator.
+                black_box(x);
+            }
+        });
     });
 }
-
-criterion_group!(
-    benches,
-    easing,
-    cubic_2d,
-    cubic_vec3,
-    cubic,
-    build_pos_cubic,
-    build_accel_cubic,
-);

benches/benches/bevy_picking/ray_mesh_intersection.rs

@@ -1,6 +1,8 @@
+use core::hint::black_box;
+
 use bevy_math::{Dir3, Mat4, Ray3d, Vec3};
 use bevy_picking::mesh_picking::ray_cast;
-use criterion::{black_box, criterion_group, Criterion};
+use criterion::{criterion_group, Criterion};
 
 fn ptoxznorm(p: u32, size: u32) -> (f32, f32) {
     let ij = (p / (size), p % (size));

benches/benches/bevy_reflect/list.rs

@@ -1,10 +1,10 @@
-use core::{iter, time::Duration};
+use core::{hint::black_box, iter, time::Duration};
 
 use benches::bench;
 use bevy_reflect::{DynamicList, List};
 use criterion::{
-    black_box, criterion_group, measurement::Measurement, AxisScale, BatchSize, BenchmarkGroup,
-    BenchmarkId, Criterion, PlotConfiguration, Throughput,
+    criterion_group, measurement::Measurement, AxisScale, BatchSize, BenchmarkGroup, BenchmarkId,
+    Criterion, PlotConfiguration, Throughput,
 };
 
 criterion_group!(