Add benchmarks for schedule dependency resolution (bevyengine#4961)

# Objective

- Add benchmarks to test the performance of `Schedule`'s system dependency resolution.

## Solution

- Do a series of benchmarks while increasing the number of systems in the schedule to see how the run-time scales.
- Split the benchmarks into a group with no dependencies, and a group with many dependencies.

benches/Cargo.toml

@@ -11,6 +11,7 @@ glam = "0.20"
 rand = "0.8"
 rand_chacha = "0.3"
 criterion = { version = "0.3", features = ["html_reports"] }
+bevy_app = { path = "../crates/bevy_app" }
 bevy_ecs = { path = "../crates/bevy_ecs" }
 bevy_reflect = { path = "../crates/bevy_reflect" }
 bevy_tasks = { path = "../crates/bevy_tasks" }
@@ -46,6 +47,11 @@ name = "world_get"
 path = "benches/bevy_ecs/world_get.rs"
 harness = false
 
+[[bench]]
+name = "schedule"
+path = "benches/bevy_ecs/schedule.rs"
+harness = false
+
 [[bench]]
 name = "reflect_list"
 path = "benches/bevy_reflect/list.rs"

benches/benches/bevy_ecs/schedule.rs

@@ -0,0 +1,69 @@
+use bevy_app::App;
+use bevy_ecs::prelude::*;
+use criterion::{criterion_group, criterion_main, Criterion};
+
+criterion_group!(benches, build_schedule);
+criterion_main!(benches);
+
+fn build_schedule(criterion: &mut Criterion) {
+ // empty system
+ fn empty_system() {}
+
+ // Use multiple different kinds of label to ensure that dynamic dispatch
+ // doesn't somehow get optimized away.
+ #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, SystemLabel)]
+ struct NumLabel(usize);
+ #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, SystemLabel)]
+ struct DummyLabel;
+
+ let mut group = criterion.benchmark_group("build_schedule");
+ group.warm_up_time(std::time::Duration::from_millis(500));
+ group.measurement_time(std::time::Duration::from_secs(15));
+
+ // Method: generate a set of `graph_size` systems which have a One True Ordering.
+ // Add system to the stage with full constraints. Hopefully this should be maximimally
+ // difficult for bevy to figure out.
+ let labels: Vec<_> = (0..1000).map(NumLabel).collect();
+
+ // Benchmark graphs of different sizes.
+ for graph_size in [100, 500, 1000] {
+ // Basic benchmark without constraints.
+ group.bench_function(format!("{graph_size}_schedule_noconstraints"), |bencher| {
+ bencher.iter(|| {
+ let mut app = App::new();
+ for _ in 0..graph_size {
+ app.add_system(empty_system);
+ }
+ app.update();
+ });
+ });
+
+ // Benchmark with constraints.
+ group.bench_function(format!("{graph_size}_schedule"), |bencher| {
+ bencher.iter(|| {
+ let mut app = App::new();
+ app.add_system(empty_system.label(DummyLabel));
+
+ // Build a fully-connected dependency graph describing the One True Ordering.
+ // Not particularly realistic but this can be refined later.
+ for i in 0..graph_size {
+ let mut sys = empty_system.label(labels[i]).before(DummyLabel);
+ for a in 0..i {
+ sys = sys.after(labels[a]);
+ }
+ for b in i + 1..graph_size {
+ sys = sys.before(labels[b]);
+ }
+ app.add_system(sys);
+ }
+ // Run the app for a single frame.
+ // This is necessary since dependency resolution does not occur until the game runs.
+ // FIXME: Running the game clutters up the benchmarks, so ideally we'd be
+ // able to benchmark the dependency resolution directly.
+ app.update();
+ });
+ });
+ }
+
+ group.finish();
+}