initial specs benchmarking

Author: dekuraan

Cargo.toml

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

benches/benchmarks.rs

@@ -19,6 +19,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) {
@@ -39,6 +43,10 @@ fn bench_simple_iter(c: &mut Criterion) {
         let mut bench = shipyard::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) {
@@ -59,6 +67,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) {
@@ -79,6 +91,10 @@ fn bench_schedule(c: &mut Criterion) {
         let mut bench = shipyard::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) {
@@ -99,6 +115,10 @@ fn bench_heavy_compute(c: &mut Criterion) {
         let mut bench = shipyard::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) {
@@ -115,6 +135,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/specs/add_remove.rs

@@ -1,31 +1,29 @@
 use specs::prelude::*;
-
+use specs_derive::*;
+#[derive(Component)]
+#[storage(VecStorage)]
 struct A(f32);
-impl Component for A {
-    type Storage = VecStorage<Self>;
-}
+#[derive(Component)]
+#[storage(VecStorage)]
 struct B(f32);
-impl Component for B {
-    type Storage = VecStorage<Self>;
-}
 
 pub struct Benchmark(World, Vec<Entity>);
 
 impl Benchmark {
     pub fn new() -> Self {
-        let mut world = World::default();
+        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();
-        world.register::<B>();
         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));
+            b_storage.insert(*entity, B(0.0)).unwrap();
         }
 
         for entity in &self.1 {

src/specs/frag_iter.rs

@@ -1,30 +1,29 @@
 use specs::prelude::*;
+use specs_derive::*;
 
 macro_rules! create_entities {
     ($world:ident; $( $variants:ident ),*) => {
         $(
+            #[derive(Component)]
+            #[storage(VecStorage)]
             struct $variants(f32);
-            impl Component for $variants {
-                type Storage = DenseVecStorage<Self>;
-            }
+            $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);
-impl Component for Data {
-    type Storage = VecStorage<Self>;
-}
 
 struct FragIterSystem;
 
 impl<'a> System<'a> for FragIterSystem {
     type SystemData = WriteStorage<'a, Data>;
 
     fn run(&mut self, mut data_storage: Self::SystemData) {
-        for mut data in (&mut data_storage).join() {
+        for data in (&mut data_storage).join() {
             data.0 *= 2.0;
         }
     }
@@ -33,8 +32,8 @@ pub struct Benchmark(World, FragIterSystem);
 
 impl Benchmark {
     pub fn new() -> Self {
-        let mut world = World::default();
-
+        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)

src/specs/heavy_compute.rs

@@ -1,42 +1,60 @@
 use cgmath::*;
 use specs::prelude::*;
-
-#[derive(Copy, Clone)]
+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)]
+#[derive(Copy, Clone, Component)]
+#[storage(VecStorage)]
 struct Rotation(Vector3<f32>);
 
-#[derive(Copy, Clone)]
+#[derive(Copy, Clone, Component)]
+#[storage(VecStorage)]
 struct Velocity(Vector3<f32>);
 
-pub struct Benchmark(World, Query<(Write<Position>, Write<Matrix4<f32>>)>);
+struct HeavyComputeSystem;
 
-impl Benchmark {
-    pub fn new() -> Self {
-        let mut world = World::default();
+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);
+        }
+    }
+}
 
-        world.extend((0..1000).map(|_| {
-            (
-                Matrix4::<f32>::from_angle_x(Rad(1.2)),
-                Position(Vector3::unit_x()),
-                Rotation(Vector3::unit_x()),
-                Velocity(Vector3::unit_x()),
-            )
-        }));
-        world.pack(PackOptions::force());
+pub struct Benchmark(World, HeavyComputeSystem);
 
-        let query = <(Write<Position>, Write<Matrix4<f32>>)>::query();
+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, query)
+        Self(world, HeavyComputeSystem)
     }
 
     pub fn run(&mut self) {
-        self.1.par_for_each_mut(&mut self.0, |(pos, mat)| {
-            for _ in 0..100 {
-                *mat = mat.invert().unwrap();
-            }
-            pos.0 = mat.transform_vector(pos.0);
-        });
+        self.1.run_now(&self.0);
     }
 }

src/specs/mod.rs

@@ -2,7 +2,5 @@ pub mod add_remove;
 pub mod frag_iter;
 pub mod heavy_compute;
 pub mod schedule;
-pub mod serialize_binary;
-pub mod serialize_text;
 pub mod simple_insert;
 pub mod simple_iter;

src/specs/schedule.rs

@@ -1,53 +1,109 @@
-use legion::*;
-use storage::PackOptions;
-
+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);
 
-#[system(for_each)]
-fn ab(a: &mut A, b: &mut B) {
-    std::mem::swap(&mut a.0, &mut b.0);
-}
+struct ABSystem;
 
-#[system(for_each)]
-fn cd(c: &mut C, d: &mut D) {
-    std::mem::swap(&mut c.0, &mut d.0);
-}
+impl<'a> System<'a> for ABSystem {
+    type SystemData = (WriteStorage<'a, A>, WriteStorage<'a, B>);
 
-#[system(for_each)]
-fn ce(c: &mut C, e: &mut E) {
-    std::mem::swap(&mut c.0, &mut e.0);
+    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);
+        }
+    }
 }
 
-pub struct Benchmark(World, Resources, Schedule);
+struct CDSystem;
 
-impl Benchmark {
-    pub fn new() -> Self {
-        let mut world = World::default();
+impl<'a> System<'a> for CDSystem {
+    type SystemData = (WriteStorage<'a, C>, WriteStorage<'a, D>);
 
-        world.extend((0..10000).map(|_| (A(0.0), B(0.0))));
+    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;
 
-        world.extend((0..10000).map(|_| (A(0.0), B(0.0), C(0.0))));
+impl<'a> System<'a> for CESystem {
+    type SystemData = (WriteStorage<'a, C>, WriteStorage<'a, E>);
 
-        world.extend((0..10000).map(|_| (A(0.0), B(0.0), C(0.0), D(0.0))));
+    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);
+        }
+    }
+}
 
-        world.extend((0..10000).map(|_| (A(0.0), B(0.0), C(0.0), E(0.0))));
+pub struct Benchmark<'a>(World, Dispatcher<'a, 'a>);
 
-        world.pack(PackOptions::force());
+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 schedule = Schedule::builder()
-            .add_system(ab_system())
-            .add_system(cd_system())
-            .add_system(ce_system())
+        let dispatcher = DispatcherBuilder::new()
+            .with(ABSystem, "ab", &[])
+            .with(CDSystem, "cd", &[])
+            .with(CESystem, "ce", &[])
             .build();
 
-        Self(world, Resources::default(), schedule)
+        Self(world, dispatcher)
     }
 
     pub fn run(&mut self) {
-        self.2.execute(&mut self.0, &mut self.1);
+        self.1.dispatch_par(&self.0)
     }
 }