Add legion and shipyard packed benchmarks

Author: TomGillen

benches/benchmarks.rs

@@ -27,6 +27,10 @@ fn bench_simple_iter(c: &mut Criterion) {
         let mut bench = legion::simple_iter::Benchmark::new();
         b.iter(move || bench.run());
     });
+    group.bench_function("legion (packed)", |b| {
+        let mut bench = legion_packed::simple_iter::Benchmark::new();
+        b.iter(move || bench.run());
+    });
     group.bench_function("legion_0.2.4", |b| {
         let mut bench = legion_2_4::simple_iter::Benchmark::new();
         b.iter(move || bench.run());
@@ -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("shipyard (packed)", |b| {
+        let mut bench = shipyard_packed::simple_iter::Benchmark::new();
+        b.iter(move || bench.run());
+    });
 }
 
 fn bench_frag_iter_bc(c: &mut Criterion) {
@@ -67,6 +75,10 @@ fn bench_schedule(c: &mut Criterion) {
         let mut bench = legion::schedule::Benchmark::new();
         b.iter(move || bench.run());
     });
+    group.bench_function("legion (packed)", |b| {
+        let mut bench = legion_packed::schedule::Benchmark::new();
+        b.iter(move || bench.run());
+    });
     group.bench_function("legion_0.2.4", |b| {
         let mut bench = legion_2_4::schedule::Benchmark::new();
         b.iter(move || bench.run());
@@ -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("shipyard (packed)", |b| {
+        let mut bench = shipyard_packed::schedule::Benchmark::new();
+        b.iter(move || bench.run());
+    });
 }
 
 fn bench_heavy_compute(c: &mut Criterion) {
@@ -87,6 +103,10 @@ fn bench_heavy_compute(c: &mut Criterion) {
         let mut bench = legion::heavy_compute::Benchmark::new();
         b.iter(move || bench.run());
     });
+    group.bench_function("legion (packed)", |b| {
+        let mut bench = legion_packed::heavy_compute::Benchmark::new();
+        b.iter(move || bench.run());
+    });
     group.bench_function("legion_0.2.4", |b| {
         let mut bench = legion_2_4::heavy_compute::Benchmark::new();
         b.iter(move || bench.run());
@@ -99,6 +119,10 @@ fn bench_heavy_compute(c: &mut Criterion) {
         let mut bench = shipyard::heavy_compute::Benchmark::new();
         b.iter(move || bench.run());
     });
+    group.bench_function("shipyard (packed)", |b| {
+        let mut bench = shipyard_packed::heavy_compute::Benchmark::new();
+        b.iter(move || bench.run());
+    });
 }
 
 fn bench_add_remove(c: &mut Criterion) {

src/legion_packed/heavy_compute.rs

@@ -0,0 +1,48 @@
+use cgmath::*;
+use legion::*;
+use query::Query;
+use storage::PackOptions;
+
+#[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 options = WorldOptions {
+            groups: vec![<(Position, Matrix4<f32>)>::to_group()],
+        };
+
+        let mut world = World::new(options);
+
+        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/legion_packed/mod.rs

@@ -0,0 +1,3 @@
+pub mod heavy_compute;
+pub mod schedule;
+pub mod simple_iter;

src/legion_packed/schedule.rs

@@ -0,0 +1,57 @@
+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 options = WorldOptions {
+            groups: vec![<(A, B)>::to_group(), <(C, D)>::to_group()],
+        };
+
+        let mut world = World::new(options);
+
+        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/legion_packed/simple_iter.rs

@@ -0,0 +1,49 @@
+use cgmath::*;
+use legion::*;
+use query::Query;
+use storage::PackOptions;
+
+#[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(World, Query<(Read<Velocity>, Write<Position>)>);
+
+impl Benchmark {
+    pub fn new() -> Self {
+        let options = WorldOptions {
+            groups: vec![<(Velocity, Position)>::to_group()],
+        };
+
+        let mut world = World::new(options);
+
+        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(),
+        );
+        world.pack(PackOptions::force());
+
+        let query = <(Read<Velocity>, Write<Position>)>::query();
+
+        Self(world, query)
+    }
+
+    pub fn run(&mut self) {
+        self.1.for_each_mut(&mut self.0, |(velocity, position)| {
+            position.0 += velocity.0;
+        });
+    }
+}

src/lib.rs

@@ -3,4 +3,6 @@
 pub mod bevy;
 pub mod legion;
 pub mod legion_2_4;
+pub mod legion_packed;
 pub mod shipyard;
+pub mod shipyard_packed;

src/shipyard_packed/heavy_compute.rs

@@ -0,0 +1,64 @@
+use cgmath::*;
+use rayon::prelude::*;
+use shipyard::*;
+
+#[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);
+
+impl Benchmark {
+    pub fn new() -> Self {
+        let world = World::default();
+
+        world.run(
+            |mut entities: EntitiesViewMut,
+             mut transforms: ViewMut<Matrix4<f32>>,
+             mut positions: ViewMut<Position>,
+             mut rotations: ViewMut<Rotation>,
+             mut velocities: ViewMut<Velocity>| {
+                (&mut positions, &mut transforms).tight_pack();
+
+                for _ in 0..1000 {
+                    entities.add_entity(
+                        (
+                            &mut transforms,
+                            &mut positions,
+                            &mut rotations,
+                            &mut velocities,
+                        ),
+                        (
+                            Matrix4::<f32>::from_angle_x(Rad(1.2)),
+                            Position(Vector3::unit_x()),
+                            Rotation(Vector3::unit_x()),
+                            Velocity(Vector3::unit_x()),
+                        ),
+                    );
+                }
+            },
+        );
+
+        Self(world)
+    }
+
+    pub fn run(&mut self) {
+        self.0.run(
+            |mut positions: ViewMut<Position>, mut transforms: ViewMut<Matrix4<f32>>| {
+                (&mut positions, &mut transforms)
+                    .par_iter()
+                    .for_each(|(pos, mat)| {
+                        for _ in 0..100 {
+                            *mat = mat.invert().unwrap();
+                        }
+                        pos.0 = mat.transform_vector(pos.0);
+                    });
+            },
+        );
+    }
+}

src/shipyard_packed/mod.rs

@@ -0,0 +1,3 @@
+pub mod heavy_compute;
+pub mod schedule;
+pub mod simple_iter;