Skip to content

Adjust benches to be more robust #20207

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
merged 2 commits into from
Jul 20, 2025
Merged

Adjust benches to be more robust #20207

Changes from all commits
Commits
Show all changes
2 commits
Select commit Hold shift + click to select a range
c98b90c
make benches more sane
Trashtalk217 Jul 19, 2025
a37b1ea
cargo clippy
Trashtalk217 Jul 19, 2025
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
92 changes: 38 additions & 54 deletions benches/benches/bevy_ecs/world/world_get.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -1,10 +1,9 @@
use core::hint::black_box;
use nonmax::NonMaxU32;

use bevy_ecs::{
bundle::{Bundle, NoBundleEffect},
component::Component,
entity::{Entity, EntityRow},
entity::Entity,
system::{Query, SystemState},
world::World,
};
Expand All @@ -31,16 +30,22 @@ fn deterministic_rand() -> ChaCha8Rng {
ChaCha8Rng::seed_from_u64(42)
}

fn setup<T: Component + Default>(entity_count: u32) -> World {
fn setup<T: Component + Default>(entity_count: u32) -> (World, Vec<Entity>) {
let mut world = World::default();
world.spawn_batch((0..entity_count).map(|_| T::default()));
black_box(world)
let entities: Vec<Entity> = world
.spawn_batch((0..entity_count).map(|_| T::default()))
.collect();
black_box((world, entities))
}

fn setup_wide<T: Bundle<Effect: NoBundleEffect> + Default>(entity_count: u32) -> World {
fn setup_wide<T: Bundle<Effect: NoBundleEffect> + Default>(
entity_count: u32,
) -> (World, Vec<Entity>) {
let mut world = World::default();
world.spawn_batch((0..entity_count).map(|_| T::default()));
black_box(world)
let entities: Vec<Entity> = world
.spawn_batch((0..entity_count).map(|_| T::default()))
.collect();
black_box((world, entities))
}

pub fn world_entity(criterion: &mut Criterion) {
Expand All @@ -50,14 +55,11 @@ pub fn world_entity(criterion: &mut Criterion) {

for entity_count in RANGE.map(|i| i * 10_000) {
group.bench_function(format!("{entity_count}_entities"), |bencher| {
let world = setup::<Table>(entity_count);
let (world, entities) = setup::<Table>(entity_count);

bencher.iter(|| {
for i in 0..entity_count {
let entity =
// SAFETY: Range is exclusive.
Entity::from_raw(EntityRow::new(unsafe { NonMaxU32::new_unchecked(i) }));
black_box(world.entity(entity));
for entity in &entities {
black_box(world.entity(*entity));
}
});
});
Expand All @@ -73,26 +75,20 @@ pub fn world_get(criterion: &mut Criterion) {

for entity_count in RANGE.map(|i| i * 10_000) {
group.bench_function(format!("{entity_count}_entities_table"), |bencher| {
let world = setup::<Table>(entity_count);
let (world, entities) = setup::<Table>(entity_count);

bencher.iter(|| {
for i in 0..entity_count {
let entity =
// SAFETY: Range is exclusive.
Entity::from_raw(EntityRow::new(unsafe { NonMaxU32::new_unchecked(i) }));
assert!(world.get::<Table>(entity).is_some());
for entity in &entities {
assert!(world.get::<Table>(*entity).is_some());
}
});
});
group.bench_function(format!("{entity_count}_entities_sparse"), |bencher| {
let world = setup::<Sparse>(entity_count);
let (world, entities) = setup::<Sparse>(entity_count);

bencher.iter(|| {
for i in 0..entity_count {
let entity =
// SAFETY: Range is exclusive.
Entity::from_raw(EntityRow::new(unsafe { NonMaxU32::new_unchecked(i) }));
assert!(world.get::<Sparse>(entity).is_some());
for entity in &entities {
assert!(world.get::<Sparse>(*entity).is_some());
}
});
});
Expand All @@ -108,20 +104,17 @@ pub fn world_query_get(criterion: &mut Criterion) {

for entity_count in RANGE.map(|i| i * 10_000) {
group.bench_function(format!("{entity_count}_entities_table"), |bencher| {
let mut world = setup::<Table>(entity_count);
let (mut world, entities) = setup::<Table>(entity_count);
let mut query = world.query::<&Table>();

bencher.iter(|| {
for i in 0..entity_count {
let entity =
// SAFETY: Range is exclusive.
Entity::from_raw(EntityRow::new(unsafe { NonMaxU32::new_unchecked(i) }));
assert!(query.get(&world, entity).is_ok());
for entity in &entities {
assert!(query.get(&world, *entity).is_ok());
}
});
});
group.bench_function(format!("{entity_count}_entities_table_wide"), |bencher| {
let mut world = setup_wide::<(
let (mut world, entities) = setup_wide::<(
WideTable<0>,
WideTable<1>,
WideTable<2>,
Expand All @@ -139,29 +132,23 @@ pub fn world_query_get(criterion: &mut Criterion) {
)>();

bencher.iter(|| {
for i in 0..entity_count {
let entity =
// SAFETY: Range is exclusive.
Entity::from_raw(EntityRow::new(unsafe { NonMaxU32::new_unchecked(i) }));
assert!(query.get(&world, entity).is_ok());
for entity in &entities {
assert!(query.get(&world, *entity).is_ok());
}
});
});
group.bench_function(format!("{entity_count}_entities_sparse"), |bencher| {
let mut world = setup::<Sparse>(entity_count);
let (mut world, entities) = setup::<Sparse>(entity_count);
let mut query = world.query::<&Sparse>();

bencher.iter(|| {
for i in 0..entity_count {
let entity =
// SAFETY: Range is exclusive.
Entity::from_raw(EntityRow::new(unsafe { NonMaxU32::new_unchecked(i) }));
assert!(query.get(&world, entity).is_ok());
for entity in &entities {
assert!(query.get(&world, *entity).is_ok());
}
});
});
group.bench_function(format!("{entity_count}_entities_sparse_wide"), |bencher| {
let mut world = setup_wide::<(
let (mut world, entities) = setup_wide::<(
WideSparse<0>,
WideSparse<1>,
WideSparse<2>,
Expand All @@ -179,11 +166,8 @@ pub fn world_query_get(criterion: &mut Criterion) {
)>();

bencher.iter(|| {
for i in 0..entity_count {
// SAFETY: Range is exclusive.
let entity =
Entity::from_raw(EntityRow::new(unsafe { NonMaxU32::new_unchecked(i) }));
assert!(query.get(&world, entity).is_ok());
for entity in &entities {
assert!(query.get(&world, *entity).is_ok());
}
});
});
Expand All @@ -199,7 +183,7 @@ pub fn world_query_iter(criterion: &mut Criterion) {

for entity_count in RANGE.map(|i| i * 10_000) {
group.bench_function(format!("{entity_count}_entities_table"), |bencher| {
let mut world = setup::<Table>(entity_count);
let (mut world, _) = setup::<Table>(entity_count);
let mut query = world.query::<&Table>();

bencher.iter(|| {
Expand All @@ -213,7 +197,7 @@ pub fn world_query_iter(criterion: &mut Criterion) {
});
});
group.bench_function(format!("{entity_count}_entities_sparse"), |bencher| {
let mut world = setup::<Sparse>(entity_count);
let (mut world, _) = setup::<Sparse>(entity_count);
let mut query = world.query::<&Sparse>();

bencher.iter(|| {
Expand All @@ -238,7 +222,7 @@ pub fn world_query_for_each(criterion: &mut Criterion) {

for entity_count in RANGE.map(|i| i * 10_000) {
group.bench_function(format!("{entity_count}_entities_table"), |bencher| {
let mut world = setup::<Table>(entity_count);
let (mut world, _) = setup::<Table>(entity_count);
let mut query = world.query::<&Table>();

bencher.iter(|| {
Expand All @@ -252,7 +236,7 @@ pub fn world_query_for_each(criterion: &mut Criterion) {
});
});
group.bench_function(format!("{entity_count}_entities_sparse"), |bencher| {
let mut world = setup::<Sparse>(entity_count);
let (mut world, _) = setup::<Sparse>(entity_count);
let mut query = world.query::<&Sparse>();

bencher.iter(|| {
Expand Down
Loading