Add reflect path parsing benchmark (#9364)

# Objective

We want to measure performance on path reflection parsing.

## Solution

Benchmark path-based reflection:
- Add a benchmark for `ParsedPath::parse`

It's fairly noisy, this is why I added the 3% threshold.

Ideally we would fix the noisiness though. Supposedly I'm seeding the
RNG correctly, so there shouldn't be much observable variance. Maybe
someone can help spot the issue.

benches/Cargo.toml

@@ -47,6 +47,11 @@ name = "reflect_struct"
 path = "benches/bevy_reflect/struct.rs"
 harness = false
 
+[[bench]]
+name = "parse_reflect_path"
+path = "benches/bevy_reflect/path.rs"
+harness = false
+
 [[bench]]
 name = "iter"
 path = "benches/bevy_tasks/iter.rs"

benches/benches/bevy_reflect/path.rs

@@ -0,0 +1,94 @@
+use std::{fmt::Write, str, time::Duration};
+
+use bevy_reflect::ParsedPath;
+use criterion::{
+ black_box, criterion_group, criterion_main, BatchSize, BenchmarkId, Criterion, Throughput,
+};
+use rand::{distributions::Uniform, Rng, SeedableRng};
+use rand_chacha::ChaCha8Rng;
+
+criterion_group!(benches, parse_reflect_path);
+criterion_main!(benches);
+
+const WARM_UP_TIME: Duration = Duration::from_millis(500);
+const MEASUREMENT_TIME: Duration = Duration::from_secs(2);
+const SAMPLE_SIZE: usize = 500;
+const NOISE_THRESHOLD: f64 = 0.03;
+const SIZES: [usize; 6] = [100, 3160, 1000, 3_162, 10_000, 24_000];
+
+fn deterministic_rand() -> ChaCha8Rng {
+ ChaCha8Rng::seed_from_u64(42)
+}
+fn random_ident(rng: &mut ChaCha8Rng, f: &mut dyn Write) {
+ let between = Uniform::try_from(b'a'..=b'z').unwrap();
+ let ident_size = rng.gen_range(1..128);
+ let ident: Vec<u8> = rng.sample_iter(between).take(ident_size).collect();
+ let ident = str::from_utf8(&ident).unwrap();
+ let _ = write!(f, "{ident}");
+}
+
+fn random_index(rng: &mut ChaCha8Rng, f: &mut dyn Write) {
+ let index = rng.gen_range(1..128);
+ let _ = write!(f, "{index}");
+}
+
+fn write_random_access(rng: &mut ChaCha8Rng, f: &mut dyn Write) {
+ match rng.gen_range(0..4) {
+ 0 => {
+ // Access::Field
+ f.write_char('.').unwrap();
+ random_ident(rng, f);
+ }
+ 1 => {
+ // Access::FieldIndex
+ f.write_char('#').unwrap();
+ random_index(rng, f);
+ }
+ 2 => {
+ // Access::Index
+ f.write_char('[').unwrap();
+ random_index(rng, f);
+ f.write_char(']').unwrap();
+ }
+ 3 => {
+ // Access::TupleIndex
+ f.write_char('.').unwrap();
+ random_index(rng, f);
+ }
+ _ => unreachable!(),
+ }
+}
+
+fn mk_paths(size: usize) -> impl FnMut() -> String {
+ let mut rng = deterministic_rand();
+ move || {
+ let mut ret = String::new();
+ (0..size).for_each(|_| write_random_access(&mut rng, &mut ret));
+ ret
+ }
+}
+
+fn parse_reflect_path(criterion: &mut Criterion) {
+ let mut group = criterion.benchmark_group("parse_reflect_path");
+ group.warm_up_time(WARM_UP_TIME);
+ group.measurement_time(MEASUREMENT_TIME);
+ group.sample_size(SAMPLE_SIZE);
+ group.noise_threshold(NOISE_THRESHOLD);
+ let group = &mut group;
+
+ for size in SIZES {
+ group.throughput(Throughput::Elements(size as u64));
+ group.bench_with_input(
+ BenchmarkId::new("parse_reflect_path", size),
+ &size,
+ |bencher, &size| {
+ let mut mk_paths = mk_paths(size);
+ bencher.iter_batched(
+ || mk_paths(),
+ |path| assert!(ParsedPath::parse(black_box(&path)).is_ok()),
+ BatchSize::SmallInput,
+ );
+ },
+ );
+ }
+}