Merge branch 'master' of https://github.com/TomGillen/ecs_bench_suite

Author: TomGillen

Cargo.toml

@@ -18,6 +18,8 @@ legion_2_4 = { package = "legion", version = "0.2.4" }
 bevy_ecs = "0.1"
 hecs = "0.2"
 shipyard = "0.4"
+specs = {version = "0.16.1", features = ["serde"] }
+specs-derive = "0.4.1"
 
 [dev-dependencies]
 criterion = "0.3"

benches/benchmarks.rs

@@ -23,6 +23,10 @@ fn bench_simple_insert(c: &mut Criterion) {
         let mut bench = shipyard::simple_insert::Benchmark::new();
         b.iter(move || bench.run());
     });
+    group.bench_function("specs", |b| {
+        let mut bench = specs::simple_insert::Benchmark::new();
+        b.iter(move || bench.run());
+    });
 }
 
 fn bench_simple_iter(c: &mut Criterion) {
@@ -55,6 +59,10 @@ fn bench_simple_iter(c: &mut Criterion) {
         let mut bench = shipyard_packed::simple_iter::Benchmark::new();
         b.iter(move || bench.run());
     });
+    group.bench_function("specs", |b| {
+        let mut bench = specs::simple_iter::Benchmark::new();
+        b.iter(move || bench.run());
+    });
 }
 
 fn bench_frag_iter_bc(c: &mut Criterion) {
@@ -79,6 +87,10 @@ fn bench_frag_iter_bc(c: &mut Criterion) {
         let mut bench = shipyard::frag_iter::Benchmark::new();
         b.iter(move || bench.run());
     });
+    group.bench_function("specs", |b| {
+        let mut bench = specs::frag_iter::Benchmark::new();
+        b.iter(move || bench.run());
+    });
 }
 
 fn bench_schedule(c: &mut Criterion) {
@@ -107,6 +119,10 @@ fn bench_schedule(c: &mut Criterion) {
         let mut bench = shipyard_packed::schedule::Benchmark::new();
         b.iter(move || bench.run());
     });
+    group.bench_function("specs", |b| {
+        let mut bench = specs::schedule::Benchmark::new();
+        b.iter(move || bench.run());
+    });
 }
 
 fn bench_heavy_compute(c: &mut Criterion) {
@@ -139,6 +155,10 @@ fn bench_heavy_compute(c: &mut Criterion) {
         let mut bench = shipyard_packed::heavy_compute::Benchmark::new();
         b.iter(move || bench.run());
     });
+    group.bench_function("specs", |b| {
+        let mut bench = specs::heavy_compute::Benchmark::new();
+        b.iter(move || bench.run());
+    });
 }
 
 fn bench_add_remove(c: &mut Criterion) {
@@ -159,6 +179,10 @@ fn bench_add_remove(c: &mut Criterion) {
         let mut bench = shipyard::add_remove::Benchmark::new();
         b.iter(move || bench.run());
     });
+    group.bench_function("specs", |b| {
+        let mut bench = specs::add_remove::Benchmark::new();
+        b.iter(move || bench.run());
+    });
 
     // todo Bevy appears to crash in this benchmark
     // group.bench_function("bevy", |b| {

src/lib.rs

@@ -7,3 +7,4 @@ pub mod legion_2_4;
 pub mod legion_packed;
 pub mod shipyard;
 pub mod shipyard_packed;
+pub mod specs;

src/specs/add_remove.rs

@@ -0,0 +1,33 @@
+use specs::prelude::*;
+use specs_derive::*;
+#[derive(Component)]
+#[storage(VecStorage)]
+struct A(f32);
+#[derive(Component)]
+#[storage(VecStorage)]
+struct B(f32);
+
+pub struct Benchmark(World, Vec<Entity>);
+
+impl Benchmark {
+    pub fn new() -> Self {
+        let mut world = World::new();
+        world.register::<A>();
+        world.register::<B>();
+        let entities = (0..10000)
+            .map(|_| world.create_entity().with(A(0.0)).build())
+            .collect();
+        Self(world, entities)
+    }
+
+    pub fn run(&mut self) {
+        let mut b_storage = self.0.write_storage::<B>();
+        for entity in &self.1 {
+            b_storage.insert(*entity, B(0.0)).unwrap();
+        }
+
+        for entity in &self.1 {
+            b_storage.remove(*entity);
+        }
+    }
+}

src/specs/frag_iter.rs

@@ -0,0 +1,45 @@
+use specs::prelude::*;
+use specs_derive::*;
+
+macro_rules! create_entities {
+    ($world:ident; $( $variants:ident ),*) => {
+        $(
+            #[derive(Component)]
+            #[storage(VecStorage)]
+            struct $variants(f32);
+            $world.register::<$variants>();
+            (0..20)
+            .for_each(|_| {$world.create_entity().with($variants(0.0)).with(Data(1.0)).build();});
+        )*
+    };
+}
+#[derive(Component)]
+#[storage(VecStorage)]
+struct Data(f32);
+
+struct FragIterSystem;
+
+impl<'a> System<'a> for FragIterSystem {
+    type SystemData = WriteStorage<'a, Data>;
+
+    fn run(&mut self, mut data_storage: Self::SystemData) {
+        for data in (&mut data_storage).join() {
+            data.0 *= 2.0;
+        }
+    }
+}
+pub struct Benchmark(World, FragIterSystem);
+
+impl Benchmark {
+    pub fn new() -> Self {
+        let mut world = World::new();
+        world.register::<Data>();
+        create_entities!(world; A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z);
+
+        Self(world, FragIterSystem)
+    }
+
+    pub fn run(&mut self) {
+        self.1.run_now(&self.0)
+    }
+}

src/specs/heavy_compute.rs

@@ -0,0 +1,60 @@
+use cgmath::*;
+use specs::prelude::*;
+use specs_derive::*;
+#[derive(Copy, Clone, Component)]
+#[storage(VecStorage)]
+struct Transform(Matrix4<f32>);
+#[derive(Copy, Clone, Component)]
+#[storage(VecStorage)]
+struct Position(Vector3<f32>);
+
+#[derive(Copy, Clone, Component)]
+#[storage(VecStorage)]
+struct Rotation(Vector3<f32>);
+
+#[derive(Copy, Clone, Component)]
+#[storage(VecStorage)]
+struct Velocity(Vector3<f32>);
+
+struct HeavyComputeSystem;
+
+impl<'a> System<'a> for HeavyComputeSystem {
+    type SystemData = (WriteStorage<'a, Position>, WriteStorage<'a, Transform>);
+
+    fn run(&mut self, (mut pos_store, mut mat_store): Self::SystemData) {
+        use cgmath::Transform;
+        for (pos, mat) in (&mut pos_store, &mut mat_store).join() {
+            for _ in 0..100 {
+                mat.0 = mat.0.invert().unwrap();
+            }
+            pos.0 = mat.0.transform_vector(pos.0);
+        }
+    }
+}
+
+pub struct Benchmark(World, HeavyComputeSystem);
+
+impl Benchmark {
+    pub fn new() -> Self {
+        let mut world = World::new();
+        world.register::<Transform>();
+        world.register::<Position>();
+        world.register::<Rotation>();
+        world.register::<Velocity>();
+        (0..1000).for_each(|_| {
+            world
+                .create_entity()
+                .with(Transform(Matrix4::<f32>::from_angle_x(Rad(1.2))))
+                .with(Position(Vector3::unit_x()))
+                .with(Rotation(Vector3::unit_x()))
+                .with(Velocity(Vector3::unit_x()))
+                .build();
+        });
+
+        Self(world, HeavyComputeSystem)
+    }
+
+    pub fn run(&mut self) {
+        self.1.run_now(&self.0);
+    }
+}

src/specs/mod.rs

@@ -0,0 +1,6 @@
+pub mod add_remove;
+pub mod frag_iter;
+pub mod heavy_compute;
+pub mod schedule;
+pub mod simple_insert;
+pub mod simple_iter;

src/specs/schedule.rs

@@ -0,0 +1,109 @@
+use specs::prelude::*;
+use specs_derive::*;
+#[derive(Component)]
+#[storage(VecStorage)]
+struct A(f32);
+#[derive(Component)]
+#[storage(VecStorage)]
+struct B(f32);
+#[derive(Component)]
+#[storage(VecStorage)]
+struct C(f32);
+#[derive(Component)]
+#[storage(VecStorage)]
+struct D(f32);
+#[derive(Component)]
+#[storage(VecStorage)]
+struct E(f32);
+
+struct ABSystem;
+
+impl<'a> System<'a> for ABSystem {
+    type SystemData = (WriteStorage<'a, A>, WriteStorage<'a, B>);
+
+    fn run(&mut self, (mut a_store, mut b_store): Self::SystemData) {
+        for (a, b) in (&mut a_store, &mut b_store).join() {
+            std::mem::swap(&mut a.0, &mut b.0);
+        }
+    }
+}
+
+struct CDSystem;
+
+impl<'a> System<'a> for CDSystem {
+    type SystemData = (WriteStorage<'a, C>, WriteStorage<'a, D>);
+
+    fn run(&mut self, (mut c_store, mut d_store): Self::SystemData) {
+        for (c, d) in (&mut c_store, &mut d_store).join() {
+            std::mem::swap(&mut c.0, &mut d.0);
+        }
+    }
+}
+struct CESystem;
+
+impl<'a> System<'a> for CESystem {
+    type SystemData = (WriteStorage<'a, C>, WriteStorage<'a, E>);
+
+    fn run(&mut self, (mut c_store, mut e_store): Self::SystemData) {
+        for (c, e) in (&mut c_store, &mut e_store).join() {
+            std::mem::swap(&mut c.0, &mut e.0);
+        }
+    }
+}
+
+pub struct Benchmark<'a>(World, Dispatcher<'a, 'a>);
+
+impl Benchmark<'_> {
+    pub fn new() -> Self {
+        let mut world = World::new();
+        world.register::<A>();
+        world.register::<B>();
+        world.register::<C>();
+        world.register::<D>();
+        world.register::<E>();
+        (0..10000).for_each(|_| {
+            world.create_entity().with(A(0.0)).build();
+        });
+        (0..10000).for_each(|_| {
+            world.create_entity().with(A(0.0)).with(B(0.0)).build();
+        });
+        (0..10000).for_each(|_| {
+            world
+                .create_entity()
+                .with(A(0.0))
+                .with(B(0.0))
+                .with(C(0.0))
+                .build();
+        });
+        (0..10000).for_each(|_| {
+            world
+                .create_entity()
+                .with(A(0.0))
+                .with(B(0.0))
+                .with(C(0.0))
+                .with(D(0.0))
+                .build();
+        });
+        (0..10000).for_each(|_| {
+            world
+                .create_entity()
+                .with(A(0.0))
+                .with(B(0.0))
+                .with(C(0.0))
+                .with(E(0.0))
+                .build();
+        });
+
+        let dispatcher = DispatcherBuilder::new()
+            .with(ABSystem, "ab", &[])
+            .with(CDSystem, "cd", &[])
+            .with(CESystem, "ce", &[])
+            .build();
+
+        Self(world, dispatcher)
+    }
+
+    pub fn run(&mut self) {
+        self.1.dispatch_par(&self.0)
+    }
+}

src/specs/simple_insert.rs

@@ -0,0 +1,43 @@
+use cgmath::*;
+use specs::prelude::*;
+use specs_derive::*;
+
+#[derive(Copy, Clone, Component)]
+#[storage(VecStorage)]
+struct Transform(Matrix4<f32>);
+#[derive(Copy, Clone, Component)]
+#[storage(VecStorage)]
+struct Position(Vector3<f32>);
+
+#[derive(Copy, Clone, Component)]
+#[storage(VecStorage)]
+struct Rotation(Vector3<f32>);
+
+#[derive(Copy, Clone, Component)]
+#[storage(VecStorage)]
+struct Velocity(Vector3<f32>);
+
+pub struct Benchmark;
+
+impl Benchmark {
+    pub fn new() -> Self {
+        Self
+    }
+
+    pub fn run(&mut self) {
+        let mut world = World::new();
+        world.register::<Transform>();
+        world.register::<Position>();
+        world.register::<Rotation>();
+        world.register::<Velocity>();
+        (0..10000).for_each(|_| {
+            world
+                .create_entity()
+                .with(Transform(Matrix4::<f32>::from_scale(1.0)))
+                .with(Position(Vector3::unit_x()))
+                .with(Rotation(Vector3::unit_x()))
+                .with(Velocity(Vector3::unit_x()))
+                .build();
+        });
+    }
+}