Add hecs benchmarks

Author: TomGillen

benches/benchmarks.rs

@@ -15,6 +15,10 @@ fn bench_simple_insert(c: &mut Criterion) {
         let mut bench = bevy::simple_insert::Benchmark::new();
         b.iter(move || bench.run());
     });
+    group.bench_function("hecs", |b| {
+        let mut bench = hecs::simple_insert::Benchmark::new();
+        b.iter(move || bench.run());
+    });
     group.bench_function("shipyard", |b| {
         let mut bench = shipyard::simple_insert::Benchmark::new();
         b.iter(move || bench.run());
@@ -39,6 +43,10 @@ fn bench_simple_iter(c: &mut Criterion) {
         let mut bench = bevy::simple_iter::Benchmark::new();
         b.iter(move || bench.run());
     });
+    group.bench_function("hecs", |b| {
+        let mut bench = hecs::simple_iter::Benchmark::new();
+        b.iter(move || bench.run());
+    });
     group.bench_function("shipyard", |b| {
         let mut bench = shipyard::simple_iter::Benchmark::new();
         b.iter(move || bench.run());
@@ -63,6 +71,10 @@ fn bench_frag_iter_bc(c: &mut Criterion) {
         let mut bench = bevy::frag_iter::Benchmark::new();
         b.iter(move || bench.run());
     });
+    group.bench_function("hecs", |b| {
+        let mut bench = hecs::frag_iter::Benchmark::new();
+        b.iter(move || bench.run());
+    });
     group.bench_function("shipyard", |b| {
         let mut bench = shipyard::frag_iter::Benchmark::new();
         b.iter(move || bench.run());
@@ -115,6 +127,10 @@ fn bench_heavy_compute(c: &mut Criterion) {
         let mut bench = bevy::heavy_compute::Benchmark::new();
         b.iter(move || bench.run());
     });
+    group.bench_function("hecs", |b| {
+        let mut bench = hecs::heavy_compute::Benchmark::new();
+        b.iter(move || bench.run());
+    });
     group.bench_function("shipyard", |b| {
         let mut bench = shipyard::heavy_compute::Benchmark::new();
         b.iter(move || bench.run());
@@ -135,6 +151,10 @@ fn bench_add_remove(c: &mut Criterion) {
         let mut bench = legion_2_4::add_remove::Benchmark::new();
         b.iter(move || bench.run());
     });
+    group.bench_function("hecs", |b| {
+        let mut bench = hecs::add_remove::Benchmark::new();
+        b.iter(move || bench.run());
+    });
     group.bench_function("shipyard", |b| {
         let mut bench = shipyard::add_remove::Benchmark::new();
         b.iter(move || bench.run());

src/hecs/add_remove.rs

@@ -0,0 +1,28 @@
+use hecs::*;
+
+struct A(f32);
+struct B(f32);
+
+pub struct Benchmark(World, Vec<Entity>);
+
+impl Benchmark {
+    pub fn new() -> Self {
+        let mut world = World::default();
+
+        let entities = world
+            .spawn_batch((0..10000).map(|_| (A(0.0),)))
+            .collect::<Vec<_>>();
+
+        Self(world, entities)
+    }
+
+    pub fn run(&mut self) {
+        for entity in &self.1 {
+            self.0.insert_one(*entity, B(0.0)).unwrap();
+        }
+
+        for entity in &self.1 {
+            self.0.remove_one::<B>(*entity).unwrap();
+        }
+    }
+}

src/hecs/frag_iter.rs

@@ -0,0 +1,30 @@
+use hecs::*;
+
+macro_rules! create_entities {
+    ($world:ident; $( $variants:ident ),*) => {
+        $(
+            struct $variants(f32);
+            $world.spawn_batch((0..20).map(|_| ($variants(0.0), Data(1.0))));
+        )*
+    };
+}
+
+struct Data(f32);
+
+pub struct Benchmark(World);
+
+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)
+    }
+
+    pub fn run(&mut self) {
+        for (_, mut data) in self.0.query::<&mut Data>().iter() {
+            data.0 *= 2.0;
+        }
+    }
+}

src/hecs/heavy_compute.rs

@@ -0,0 +1,40 @@
+use cgmath::*;
+use hecs::*;
+
+#[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 mut world = World::default();
+
+        world.spawn_batch((0..1000).map(|_| {
+            (
+                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) {
+        for (_, (mut pos, mat)) in self.0.query::<(&mut Position, &mut Matrix4<f32>)>().iter() {
+            for _ in 0..100 {
+                *mat = mat.invert().unwrap();
+            }
+
+            pos.0 = mat.transform_vector(pos.0);
+        }
+    }
+}

src/hecs/mod.rs

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

src/hecs/simple_insert.rs

@@ -0,0 +1,34 @@
+use cgmath::*;
+use hecs::*;
+
+#[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::new();
+        world.spawn_batch((0..10_000).map(|_| {
+            (
+                Transform(Matrix4::from_scale(1.0)),
+                Position(Vector3::unit_x()),
+                Rotation(Vector3::unit_x()),
+                Velocity(Vector3::unit_x()),
+            )
+        }));
+    }
+}

src/hecs/simple_iter.rs

@@ -0,0 +1,38 @@
+use cgmath::*;
+use hecs::*;
+
+#[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);
+
+impl Benchmark {
+    pub fn new() -> Self {
+        let mut world = World::new();
+        world.spawn_batch((0..10_000).map(|_| {
+            (
+                Transform(Matrix4::from_scale(1.0)),
+                Position(Vector3::unit_x()),
+                Rotation(Vector3::unit_x()),
+                Velocity(Vector3::unit_x()),
+            )
+        }));
+
+        Self(world)
+    }
+
+    pub fn run(&mut self) {
+        for (_, (velocity, position)) in self.0.query::<(&Velocity, &mut Position)>().iter() {
+            position.0 += velocity.0;
+        }
+    }
+}

src/lib.rs

@@ -1,6 +1,7 @@
 #![allow(clippy::new_without_default)]
 
 pub mod bevy;
+pub mod hecs;
 pub mod legion;
 pub mod legion_2_4;
 pub mod legion_packed;