Skip to content

Commit

Permalink
Merge pull request #2 from TheRawMeatball/fix-derive-component-again
Browse files Browse the repository at this point in the history
  • Loading branch information
@Frizi
Frizi authored Sep 24, 2021
2 parents 0cdead1 + 8648736 commit f2f0995
Show file tree
Hide file tree
Showing 54 changed files with 1,922 additions and 493 deletions.
5 changes: 1 addition & 4 deletions .github/workflows/label.yml
View file
Original file line number Diff line number Diff line change
@@ -1,8 +1,6 @@
name: PR-Labeler
on:
on:
pull_request_target:
branches:
- main
types:
- opened

Expand All @@ -15,4 +13,3 @@ jobs:
with:
repo-token: "${{ secrets.GITHUB_TOKEN }}"
configuration-path: .github/label-config.yml
sync-labels: true
1 change: 1 addition & 0 deletions Cargo.toml
View file
Original file line number Diff line number Diff line change
Expand Up @@ -50,6 +50,7 @@ bevy_wgpu = ["bevy_internal/bevy_wgpu"]
bevy_winit = ["bevy_internal/bevy_winit"]

trace_chrome = ["bevy_internal/trace_chrome"]
trace_tracy = ["bevy_internal/trace_tracy"]
trace = ["bevy_internal/trace"]
wgpu_trace = ["bevy_internal/wgpu_trace"]

Expand Down
16 changes: 11 additions & 5 deletions benches/benches/bevy_ecs/commands.rs
View file
Original file line number Diff line number Diff line change
@@ -1,4 +1,5 @@
use bevy::ecs::{
component::Component,
entity::Entity,
system::{Command, CommandQueue, Commands},
world::World,
Expand All @@ -18,8 +19,11 @@ criterion_group!(
);
criterion_main!(benches);

#[derive(Component)]
struct A;
#[derive(Component)]
struct B;
#[derive(Component)]
struct C;

fn empty_commands(criterion: &mut Criterion) {
Expand Down Expand Up @@ -79,10 +83,10 @@ fn spawn_commands(criterion: &mut Criterion) {
group.finish();
}

#[derive(Default)]
#[derive(Default, Component)]
struct Matrix([[f32; 4]; 4]);

#[derive(Default)]
#[derive(Default, Component)]
struct Vec3([f32; 3]);

fn insert_commands(criterion: &mut Criterion) {
Expand All @@ -95,14 +99,16 @@ fn insert_commands(criterion: &mut Criterion) {
let mut world = World::default();
let mut command_queue = CommandQueue::default();
let mut entities = Vec::new();
for i in 0..entity_count {
for _ in 0..entity_count {
entities.push(world.spawn().id());
}

bencher.iter(|| {
let mut commands = Commands::new(&mut command_queue, &world);
for entity in entities.iter() {
commands.entity(*entity).insert_bundle((Matrix::default(), Vec3::default()));
commands
.entity(*entity)
.insert_bundle((Matrix::default(), Vec3::default()));
}
drop(commands);
command_queue.apply(&mut world);
Expand All @@ -112,7 +118,7 @@ fn insert_commands(criterion: &mut Criterion) {
let mut world = World::default();
let mut command_queue = CommandQueue::default();
let mut entities = Vec::new();
for i in 0..entity_count {
for _ in 0..entity_count {
entities.push(world.spawn().id());
}

Expand Down
8 changes: 7 additions & 1 deletion benches/benches/bevy_ecs/stages.rs
View file
Original file line number Diff line number Diff line change
@@ -1,6 +1,7 @@
use bevy::ecs::{
component::Component,
schedule::{Stage, SystemStage},
system::{IntoSystem, Query},
system::Query,
world::World,
};
use criterion::{criterion_group, criterion_main, Criterion};
Expand All @@ -12,10 +13,15 @@ fn run_stage(stage: &mut SystemStage, world: &mut World) {
stage.run(world);
}

#[derive(Component)]
struct A(f32);
#[derive(Component)]
struct B(f32);
#[derive(Component)]
struct C(f32);
#[derive(Component)]
struct D(f32);
#[derive(Component)]
struct E(f32);

const ENTITY_BUNCH: usize = 5000;
Expand Down
183 changes: 104 additions & 79 deletions benches/benches/bevy_ecs/world_get.rs
View file
Original file line number Diff line number Diff line change
@@ -1,8 +1,4 @@
use bevy::ecs::{
component::{ComponentDescriptor, StorageType},
entity::Entity,
world::World,
};
use bevy::ecs::{component::Component, entity::Entity, world::World};
use criterion::{black_box, criterion_group, criterion_main, Criterion};

criterion_group!(
Expand All @@ -15,16 +11,18 @@ criterion_group!(
);
criterion_main!(benches);

struct A(f32);
#[derive(Component, Default)]
#[component(storage = "Table")]
struct Table(f32);
#[derive(Component, Default)]
#[component(storage = "SparseSet")]
struct Sparse(f32);

const RANGE: std::ops::Range<u32> = 5..6;

fn setup(entity_count: u32, storage: StorageType) -> World {
fn setup<T: Component + Default>(entity_count: u32) -> World {
let mut world = World::default();
world
.register_component(ComponentDescriptor::new::<A>(storage))
.unwrap();
world.spawn_batch((0..entity_count).map(|_| (A(0.0),)));
world.spawn_batch((0..entity_count).map(|_| (T::default(),)));
world
}

Expand All @@ -35,7 +33,7 @@ fn world_entity(criterion: &mut Criterion) {

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

bencher.iter(|| {
for i in 0..entity_count {
Expand All @@ -55,21 +53,26 @@ fn world_get(criterion: &mut Criterion) {
group.measurement_time(std::time::Duration::from_secs(4));

for entity_count in RANGE.map(|i| i * 10_000) {
for storage in [StorageType::Table, StorageType::SparseSet] {
group.bench_function(
format!("{}_entities_{:?}", entity_count, storage),
|bencher| {
let world = setup(entity_count, storage);

bencher.iter(|| {
for i in 0..entity_count {
let entity = Entity::new(i);
assert!(world.get::<A>(entity).is_some());
}
});
},
);
}
group.bench_function(format!("{}_entities_table", entity_count), |bencher| {
let world = setup::<Table>(entity_count);

bencher.iter(|| {
for i in 0..entity_count {
let entity = Entity::new(i);
assert!(world.get::<Table>(entity).is_some());
}
});
});
group.bench_function(format!("{}_entities_sparse", entity_count), |bencher| {
let world = setup::<Sparse>(entity_count);

bencher.iter(|| {
for i in 0..entity_count {
let entity = Entity::new(i);
assert!(world.get::<Sparse>(entity).is_some());
}
});
});
}

group.finish();
Expand All @@ -81,22 +84,28 @@ fn world_query_get(criterion: &mut Criterion) {
group.measurement_time(std::time::Duration::from_secs(4));

for entity_count in RANGE.map(|i| i * 10_000) {
for storage in [StorageType::Table, StorageType::SparseSet] {
group.bench_function(
format!("{}_entities_{:?}", entity_count, storage),
|bencher| {
let mut world = setup(entity_count, storage);
let mut query = world.query::<&A>();

bencher.iter(|| {
for i in 0..entity_count {
let entity = Entity::new(i);
assert!(query.get(&world, entity).is_ok());
}
});
},
);
}
group.bench_function(format!("{}_entities_table", entity_count), |bencher| {
let mut world = setup::<Table>(entity_count);
let mut query = world.query::<&Table>();

bencher.iter(|| {
for i in 0..entity_count {
let entity = Entity::new(i);
assert!(query.get(&world, entity).is_ok());
}
});
});
group.bench_function(format!("{}_entities_sparse", entity_count), |bencher| {
let mut world = setup::<Sparse>(entity_count);
let mut query = world.query::<&Sparse>();

bencher.iter(|| {
for i in 0..entity_count {
let entity = Entity::new(i);
assert!(query.get(&world, entity).is_ok());
}
});
});
}

group.finish();
Expand All @@ -108,24 +117,32 @@ fn world_query_iter(criterion: &mut Criterion) {
group.measurement_time(std::time::Duration::from_secs(4));

for entity_count in RANGE.map(|i| i * 10_000) {
for storage in [StorageType::Table, StorageType::SparseSet] {
group.bench_function(
format!("{}_entities_{:?}", entity_count, storage),
|bencher| {
let mut world = setup(entity_count, storage);
let mut query = world.query::<&A>();

bencher.iter(|| {
let mut count = 0;
for comp in query.iter(&world) {
black_box(comp);
count += 1;
}
assert_eq!(black_box(count), entity_count);
});
},
);
}
group.bench_function(format!("{}_entities_table", entity_count), |bencher| {
let mut world = setup::<Table>(entity_count);
let mut query = world.query::<&Table>();

bencher.iter(|| {
let mut count = 0;
for comp in query.iter(&world) {
black_box(comp);
count += 1;
}
assert_eq!(black_box(count), entity_count);
});
});
group.bench_function(format!("{}_entities_sparse", entity_count), |bencher| {
let mut world = setup::<Sparse>(entity_count);
let mut query = world.query::<&Sparse>();

bencher.iter(|| {
let mut count = 0;
for comp in query.iter(&world) {
black_box(comp);
count += 1;
}
assert_eq!(black_box(count), entity_count);
});
});
}

group.finish();
Expand All @@ -137,24 +154,32 @@ fn world_query_for_each(criterion: &mut Criterion) {
group.measurement_time(std::time::Duration::from_secs(4));

for entity_count in RANGE.map(|i| i * 10_000) {
for storage in [StorageType::Table, StorageType::SparseSet] {
group.bench_function(
format!("{}_entities_{:?}", entity_count, storage),
|bencher| {
let mut world = setup(entity_count, storage);
let mut query = world.query::<&A>();

bencher.iter(|| {
let mut count = 0;
query.for_each(&world, |comp| {
black_box(comp);
count += 1;
});
assert_eq!(black_box(count), entity_count);
});
},
);
}
group.bench_function(format!("{}_entities_table", entity_count), |bencher| {
let mut world = setup::<Table>(entity_count);
let mut query = world.query::<&Table>();

bencher.iter(|| {
let mut count = 0;
query.for_each(&world, |comp| {
black_box(comp);
count += 1;
});
assert_eq!(black_box(count), entity_count);
});
});
group.bench_function(format!("{}_entities_sparse", entity_count), |bencher| {
let mut world = setup::<Sparse>(entity_count);
let mut query = world.query::<&Sparse>();

bencher.iter(|| {
let mut count = 0;
query.for_each(&world, |comp| {
black_box(comp);
count += 1;
});
assert_eq!(black_box(count), entity_count);
});
});
}

group.finish();
Expand Down
Loading

0 comments on commit f2f0995

Please sign in to comment.