initial work on adding specs

Author: dekuraan

Cargo.toml

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

src/lib.rs

@@ -4,3 +4,4 @@ pub mod bevy;
 pub mod legion;
 pub mod legion_2_4;
 pub mod shipyard;
+pub mod specs;

src/specs/add_remove.rs

@@ -0,0 +1,35 @@
+use specs::prelude::*;
+
+struct A(f32);
+impl Component for A {
+    type Storage = VecStorage<Self>;
+}
+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();
+        world.register::<A>();
+        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));
+        }
+
+        for entity in &self.1 {
+            b_storage.remove(*entity);
+        }
+    }
+}

src/specs/frag_iter.rs

@@ -0,0 +1,46 @@
+use specs::prelude::*;
+
+macro_rules! create_entities {
+    ($world:ident; $( $variants:ident ),*) => {
+        $(
+            struct $variants(f32);
+            impl Component for $variants {
+                type Storage = DenseVecStorage<Self>;
+            }
+            (0..20)
+            .for_each(|_| {$world.create_entity().with($variants(0.0)).with(Data(1.0)).build();});
+        )*
+    };
+}
+
+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() {
+            data.0 *= 2.0;
+        }
+    }
+}
+pub struct Benchmark(World, FragIterSystem);
+
+impl Benchmark {
+    pub fn new() -> Self {
+        let mut world = World::default();
+
+        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,42 @@
+use cgmath::*;
+use specs::prelude::*;
+
+#[derive(Copy, Clone)]
+struct Position(Vector3<f32>);
+
+#[derive(Copy, Clone)]
+struct Rotation(Vector3<f32>);
+
+#[derive(Copy, Clone)]
+struct Velocity(Vector3<f32>);
+
+pub struct Benchmark(World, Query<(Write<Position>, Write<Matrix4<f32>>)>);
+
+impl Benchmark {
+    pub fn new() -> Self {
+        let mut world = World::default();
+
+        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());
+
+        let query = <(Write<Position>, Write<Matrix4<f32>>)>::query();
+
+        Self(world, query)
+    }
+
+    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);
+        });
+    }
+}

src/specs/mod.rs

@@ -0,0 +1,8 @@
+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

@@ -0,0 +1,53 @@
+use legion::*;
+use storage::PackOptions;
+
+struct A(f32);
+struct B(f32);
+struct C(f32);
+struct D(f32);
+struct E(f32);
+
+#[system(for_each)]
+fn ab(a: &mut A, b: &mut B) {
+    std::mem::swap(&mut a.0, &mut b.0);
+}
+
+#[system(for_each)]
+fn cd(c: &mut C, d: &mut D) {
+    std::mem::swap(&mut c.0, &mut d.0);
+}
+
+#[system(for_each)]
+fn ce(c: &mut C, e: &mut E) {
+    std::mem::swap(&mut c.0, &mut e.0);
+}
+
+pub struct Benchmark(World, Resources, Schedule);
+
+impl Benchmark {
+    pub fn new() -> Self {
+        let mut world = World::default();
+
+        world.extend((0..10000).map(|_| (A(0.0), B(0.0))));
+
+        world.extend((0..10000).map(|_| (A(0.0), B(0.0), C(0.0))));
+
+        world.extend((0..10000).map(|_| (A(0.0), B(0.0), C(0.0), D(0.0))));
+
+        world.extend((0..10000).map(|_| (A(0.0), B(0.0), C(0.0), E(0.0))));
+
+        world.pack(PackOptions::force());
+
+        let schedule = Schedule::builder()
+            .add_system(ab_system())
+            .add_system(cd_system())
+            .add_system(ce_system())
+            .build();
+
+        Self(world, Resources::default(), schedule)
+    }
+
+    pub fn run(&mut self) {
+        self.2.execute(&mut self.0, &mut self.1);
+    }
+}

src/specs/serialize_binary.rs

@@ -0,0 +1,72 @@
+use legion::*;
+use serde::{de::DeserializeSeed, Deserialize, Serialize};
+
+#[derive(Default, Copy, Clone, Serialize, Deserialize)]
+struct Transform([f32; 16]);
+
+#[derive(Default, Copy, Clone, Serialize, Deserialize)]
+struct Position {
+    x: f32,
+    y: f32,
+    z: f32,
+}
+
+#[derive(Default, Copy, Clone, Serialize, Deserialize)]
+struct Rotation {
+    x: f32,
+    y: f32,
+    z: f32,
+}
+
+#[derive(Default, Copy, Clone, Serialize, Deserialize)]
+struct Velocity {
+    x: f32,
+    y: f32,
+    z: f32,
+}
+
+pub struct Benchmark(World, Registry<u8>);
+
+impl Benchmark {
+    pub fn new() -> Self {
+        let mut world = World::default();
+
+        world.extend(
+            (
+                vec![Transform::default(); 1000],
+                vec![Position::default(); 1000],
+                vec![Rotation::default(); 1000],
+                vec![Velocity::default(); 1000],
+            )
+                .into_soa(),
+        );
+
+        let mut registry = Registry::default();
+        registry.register::<Transform>(0);
+        registry.register::<Position>(1);
+        registry.register::<Rotation>(2);
+        registry.register::<Velocity>(3);
+
+        Self(world, registry)
+    }
+
+    pub fn run(&mut self) {
+        let Self(world, registry) = self;
+        let serializable = &world.as_serializable(any(), &*registry);
+
+        let encoded = bincode::serialize(serializable).unwrap();
+
+        use bincode::config::Options;
+        let mut deserializer = bincode::de::Deserializer::from_slice(
+            &encoded[..],
+            bincode::config::DefaultOptions::new()
+                .with_fixint_encoding()
+                .allow_trailing_bytes(),
+        );
+
+        registry
+            .as_deserialize()
+            .deserialize(&mut deserializer)
+            .unwrap();
+    }
+}

src/specs/serialize_text.rs

@@ -0,0 +1,65 @@
+use legion::*;
+use serde::{de::DeserializeSeed, Deserialize, Serialize};
+
+#[derive(Default, Copy, Clone, Serialize, Deserialize)]
+struct Transform([f32; 16]);
+
+#[derive(Default, Copy, Clone, Serialize, Deserialize)]
+struct Position {
+    x: f32,
+    y: f32,
+    z: f32,
+}
+
+#[derive(Default, Copy, Clone, Serialize, Deserialize)]
+struct Rotation {
+    x: f32,
+    y: f32,
+    z: f32,
+}
+
+#[derive(Default, Copy, Clone, Serialize, Deserialize)]
+struct Velocity {
+    x: f32,
+    y: f32,
+    z: f32,
+}
+
+pub struct Benchmark(World, Registry<u8>);
+
+impl Benchmark {
+    pub fn new() -> Self {
+        let mut world = World::default();
+
+        world.extend(
+            (
+                vec![Transform::default(); 1000],
+                vec![Position::default(); 1000],
+                vec![Rotation::default(); 1000],
+                vec![Velocity::default(); 1000],
+            )
+                .into_soa(),
+        );
+
+        let mut registry = Registry::default();
+        registry.register::<Transform>(0);
+        registry.register::<Position>(1);
+        registry.register::<Rotation>(2);
+        registry.register::<Velocity>(3);
+
+        Self(world, registry)
+    }
+
+    pub fn run(&mut self) {
+        let Self(world, registry) = self;
+        let serializable = &world.as_serializable(any(), &*registry);
+
+        let serialized = ron::ser::to_string(serializable).unwrap();
+
+        let mut deserializer = ron::de::Deserializer::from_str(&serialized).unwrap();
+        registry
+            .as_deserialize()
+            .deserialize(&mut deserializer)
+            .unwrap();
+    }
+}

src/specs/simple_insert.rs

@@ -0,0 +1,36 @@
+use cgmath::*;
+use legion::*;
+
+#[derive(Copy, Clone)]
+struct Transform(Matrix4<f32>);
+
+#[derive(Copy, Clone)]
+struct Position(Vector3<f32>);
+
+#[derive(Copy, Clone)]
+struct Rotation(Vector3<f32>);
+
+#[derive(Copy, Clone)]
+struct Velocity(Vector3<f32>);
+
+pub struct Benchmark;
+
+impl Benchmark {
+    pub fn new() -> Self {
+        Self
+    }
+
+    pub fn run(&mut self) {
+        let mut world = World::default();
+
+        world.extend(
+            (
+                vec![Transform(Matrix4::from_scale(1.0)); 10000],
+                vec![Position(Vector3::unit_x()); 10000],
+                vec![Rotation(Vector3::unit_x()); 10000],
+                vec![Velocity(Vector3::unit_x()); 10000],
+            )
+                .into_soa(),
+        );
+    }
+}