Validate param benchmarks

benches/benches/bevy_ecs/benches.rs

@@ -5,6 +5,7 @@ mod events;
 mod fragmentation;
 mod iteration;
 mod observers;
+mod param;
 mod scheduling;
 mod world;
 
@@ -16,4 +17,5 @@ criterion_main!(
     observers::observer_benches,
     scheduling::scheduling_benches,
     world::world_benches,
+    param::param_benches,
 );

benches/benches/bevy_ecs/param/combinator_system.rs

@@ -0,0 +1,31 @@
+use bevy_ecs::prelude::*;
+use criterion::Criterion;
+
+pub fn combinator_system(criterion: &mut Criterion) {
+    let mut world = World::new();
+    let mut group = criterion.benchmark_group("param/combinator_system");
+
+    group.warm_up_time(core::time::Duration::from_millis(500));
+    group.measurement_time(core::time::Duration::from_secs(3));
+
+    let mut schedule = Schedule::default();
+    schedule.add_systems(
+        (|| {})
+            .pipe(|| {})
+            .pipe(|| {})
+            .pipe(|| {})
+            .pipe(|| {})
+            .pipe(|| {})
+            .pipe(|| {})
+            .pipe(|| {}),
+    );
+    // run once to initialize systems
+    schedule.run(&mut world);
+    group.bench_function("8_piped_systems", |bencher| {
+        bencher.iter(|| {
+            schedule.run(&mut world);
+        });
+    });
+
+    group.finish();
+}

benches/benches/bevy_ecs/param/dyn_param.rs

@@ -0,0 +1,49 @@
+use bevy_ecs::{
+    prelude::*,
+    system::{DynParamBuilder, DynSystemParam, ParamBuilder},
+};
+use criterion::Criterion;
+
+pub fn dyn_param(criterion: &mut Criterion) {
+    let mut world = World::new();
+    let mut group = criterion.benchmark_group("param/combinator_system");
+
+    group.warm_up_time(core::time::Duration::from_millis(500));
+    group.measurement_time(core::time::Duration::from_secs(3));
+
+    #[derive(Resource)]
+    struct R;
+
+    let mut schedule = Schedule::default();
+    let system = (
+        DynParamBuilder::new::<Res<R>>(ParamBuilder),
+        DynParamBuilder::new::<Res<R>>(ParamBuilder),
+        DynParamBuilder::new::<Res<R>>(ParamBuilder),
+        DynParamBuilder::new::<Res<R>>(ParamBuilder),
+        DynParamBuilder::new::<Res<R>>(ParamBuilder),
+        DynParamBuilder::new::<Res<R>>(ParamBuilder),
+        DynParamBuilder::new::<Res<R>>(ParamBuilder),
+        DynParamBuilder::new::<Res<R>>(ParamBuilder),
+    )
+        .build_state(&mut world)
+        .build_system(
+            |_: DynSystemParam,
+             _: DynSystemParam,
+             _: DynSystemParam,
+             _: DynSystemParam,
+             _: DynSystemParam,
+             _: DynSystemParam,
+             _: DynSystemParam,
+             _: DynSystemParam| {},
+        );
+    schedule.add_systems(system);
+    // run once to initialize systems
+    schedule.run(&mut world);
+    group.bench_function("8_dyn_params_system", |bencher| {
+        bencher.iter(|| {
+            schedule.run(&mut world);
+        });
+    });
+
+    group.finish();
+}

benches/benches/bevy_ecs/param/mod.rs

@@ -0,0 +1,11 @@
+use criterion::criterion_group;
+
+mod combinator_system;
+mod dyn_param;
+mod param_set;
+
+use combinator_system::*;
+use dyn_param::*;
+use param_set::*;
+
+criterion_group!(param_benches, combinator_system, dyn_param, param_set);

benches/benches/bevy_ecs/param/param_set.rs

@@ -0,0 +1,36 @@
+use bevy_ecs::prelude::*;
+use criterion::Criterion;
+
+pub fn param_set(criterion: &mut Criterion) {
+    let mut world = World::new();
+    let mut group = criterion.benchmark_group("param/combinator_system");
+
+    group.warm_up_time(core::time::Duration::from_millis(500));
+    group.measurement_time(core::time::Duration::from_secs(3));
+
+    #[derive(Resource)]
+    struct R;
+
+    let mut schedule = Schedule::default();
+    schedule.add_systems(
+        |_: ParamSet<(
+            ResMut<R>,
+            ResMut<R>,
+            ResMut<R>,
+            ResMut<R>,
+            ResMut<R>,
+            ResMut<R>,
+            ResMut<R>,
+            ResMut<R>,
+        )>| {},
+    );
+    // run once to initialize systems
+    schedule.run(&mut world);
+    group.bench_function("8_variant_param_set_system", |bencher| {
+        bencher.iter(|| {
+            schedule.run(&mut world);
+        });
+    });
+
+    group.finish();
+}

benches/benches/bevy_ecs/world/commands.rs

@@ -1,6 +1,5 @@
 use bevy_ecs::{
     component::Component,
-    entity::Entity,
     system::Commands,
     world::{Command, CommandQueue, World},
 };