Bump shipyard to 0.5

Author: Oliver Becker

Cargo.toml

@@ -9,14 +9,14 @@ edition = "2018"
 [dependencies]
 bevy_ecs = "0.3"
 bincode = "1.3"
-cgmath = { version = "0.17", feature = ["serde"] }
+cgmath = { version = "0.17", features = ["serde"] }
 hecs = { version = "0.5", features = ["column-serialize", "row-serialize"] }
 legion = "0.3"
 planck_ecs = { version = "1.1.0", features = ["parallel"] }
 rayon = "1.3"
 ron = "0.6"
 serde = { version = "1.0", features = ["derive"] }
-shipyard = "0.4"
+shipyard = "0.5.0"
 specs = {version = "0.16.1", features = ["serde"] }
 specs-derive = "0.4.1"
 

benches/benchmarks.rs

@@ -55,10 +55,6 @@ 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());
-    });
     group.bench_function("specs", |b| {
         let mut bench = specs::simple_iter::Benchmark::new();
         b.iter(move || bench.run());
@@ -115,10 +111,6 @@ 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());
-    });
     group.bench_function("specs", |b| {
         let mut bench = specs::schedule::Benchmark::new();
         b.iter(move || bench.run());
@@ -147,10 +139,6 @@ 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());
-    });
     group.bench_function("specs", |b| {
         let mut bench = specs::heavy_compute::Benchmark::new();
         b.iter(move || bench.run());

src/lib.rs

@@ -6,5 +6,4 @@ pub mod legion;
 pub mod legion_packed;
 pub mod planck_ecs;
 pub mod shipyard;
-pub mod shipyard_packed;
 pub mod specs;

src/shipyard/add_remove.rs

@@ -16,22 +16,22 @@ impl Benchmark {
                 entity_ids.push(entity);
             }
             entity_ids
-        });
+        }).unwrap();
 
         Self(world, entities)
     }
 
     pub fn run(&mut self) {
         self.0.run(|entities: EntitiesViewMut, mut b: ViewMut<B>| {
             for entity in &self.1 {
-                entities.add_component(&mut b, B(0.0), *entity);
+                entities.add_component(*entity, &mut b, B(0.0));
             }
-        });
+        }).unwrap();
 
         self.0.run(|mut b: ViewMut<B>| {
             for entity in &self.1 {
                 b.remove(*entity);
             }
-        });
+        }).unwrap();
     }
 }

src/shipyard/frag_iter.rs

@@ -14,7 +14,7 @@ macro_rules! create_entities {
                         ($variants(0.0), Data(1.0)),
                     );
                 }
-            });
+            }).unwrap();
         )*
     };
 }
@@ -34,9 +34,9 @@ impl Benchmark {
 
     pub fn run(&mut self) {
         self.0.run(|mut data: ViewMut<Data>| {
-            (&mut data).iter().for_each(|data| {
+            (&mut data).iter().for_each(|mut data| {
                 data.0 *= 2.0;
             })
-        });
+        }).unwrap();
     }
 }

src/shipyard/heavy_compute.rs

@@ -40,7 +40,7 @@ impl Benchmark {
                     );
                 }
             },
-        );
+        ).unwrap();
 
         Self(world)
     }
@@ -50,13 +50,13 @@ impl Benchmark {
             |mut positions: ViewMut<Position>, mut transforms: ViewMut<Matrix4<f32>>| {
                 (&mut positions, &mut transforms)
                     .par_iter()
-                    .for_each(|(pos, mat)| {
+                    .for_each(|(mut pos, mut mat)| {
                         for _ in 0..100 {
                             *mat = mat.invert().unwrap();
                         }
                         pos.0 = mat.transform_vector(pos.0);
                     });
             },
-        );
+        ).unwrap();
     }
 }

src/shipyard/schedule.rs

@@ -7,19 +7,19 @@ struct D(f32);
 struct E(f32);
 
 fn ab(mut a: ViewMut<A>, mut b: ViewMut<B>) {
-    (&mut a, &mut b).iter().for_each(|(a, b)| {
+    (&mut a, &mut b).iter().for_each(|(mut a, mut b)| {
         std::mem::swap(&mut a.0, &mut b.0);
     })
 }
 
 fn cd(mut c: ViewMut<C>, mut d: ViewMut<D>) {
-    (&mut c, &mut d).iter().for_each(|(c, d)| {
+    (&mut c, &mut d).iter().for_each(|(mut c, mut d)| {
         std::mem::swap(&mut c.0, &mut d.0);
     })
 }
 
 fn ce(mut c: ViewMut<C>, mut e: ViewMut<E>) {
-    (&mut c, &mut e).iter().for_each(|(c, e)| {
+    (&mut c, &mut e).iter().for_each(|(mut c, mut e)| {
         std::mem::swap(&mut c.0, &mut e.0);
     })
 }
@@ -36,7 +36,7 @@ impl Benchmark {
                     entities.add_entity((&mut a, &mut b), (A(0.0), B(0.0)));
                 }
             },
-        );
+        ).unwrap();
 
         world.run(
             |mut entities: EntitiesViewMut,
@@ -47,7 +47,7 @@ impl Benchmark {
                     entities.add_entity((&mut a, &mut b, &mut c), (A(0.0), B(0.0), C(0.0)));
                 }
             },
-        );
+        ).unwrap();
 
         world.run(
             |mut entities: EntitiesViewMut,
@@ -62,7 +62,7 @@ impl Benchmark {
                     );
                 }
             },
-        );
+        ).unwrap();
 
         world.run(
             |mut entities: EntitiesViewMut,
@@ -77,19 +77,19 @@ impl Benchmark {
                     );
                 }
             },
-        );
+        ).unwrap();
 
-        world
-            .add_workload("run")
-            .with_system(system!(ab))
-            .with_system(system!(cd))
-            .with_system(system!(ce))
-            .build();
+        Workload::builder("run")
+            .with_system(&ab)
+            .with_system(&cd)
+            .with_system(&ce)
+            .add_to_world(&world)
+            .unwrap();
 
         Self(world)
     }
 
     pub fn run(&mut self) {
-        self.0.run_workload("run");
+        self.0.run_workload("run").unwrap();
     }
 }

src/shipyard/simple_insert.rs

@@ -46,6 +46,6 @@ impl Benchmark {
                     );
                 }
             },
-        );
+        ).unwrap();
     }
 }

src/shipyard/simple_iter.rs

@@ -42,7 +42,7 @@ impl Benchmark {
                     );
                 }
             },
-        );
+        ).unwrap();
 
         Self(world)
     }
@@ -52,10 +52,10 @@ impl Benchmark {
             |velocities: View<Velocity>, mut positions: ViewMut<Position>| {
                 (&velocities, &mut positions)
                     .iter()
-                    .for_each(|(velocity, position)| {
+                    .for_each(|(velocity, mut position)| {
                         position.0 += velocity.0;
                     })
             },
-        );
+        ).unwrap();
     }
 }