Merge pull request #8 from leudz/master

shipyard speed-ups

Author: leudz

src/shipyard/add_remove.rs

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

src/shipyard/frag_iter.rs

@@ -34,9 +34,9 @@ impl Benchmark {
 
     pub fn run(&mut self) {
         self.0.run(|mut data: ViewMut<Data>| {
-            for data in (&mut data).iter() {
+            (&mut data).iter().for_each(|data| {
                 data.0 *= 2.0;
-            }
+            })
         });
     }
 }

src/shipyard/schedule.rs

@@ -7,21 +7,21 @@ struct D(f32);
 struct E(f32);
 
 fn ab(mut a: ViewMut<A>, mut b: ViewMut<B>) {
-    for (a, b) in (&mut a, &mut b).iter() {
+    (&mut a, &mut b).iter().for_each(|(a, b)| {
         std::mem::swap(&mut a.0, &mut b.0);
-    }
+    })
 }
 
 fn cd(mut c: ViewMut<C>, mut d: ViewMut<D>) {
-    for (c, d) in (&mut c, &mut d).iter() {
+    (&mut c, &mut d).iter().for_each(|(c, d)| {
         std::mem::swap(&mut c.0, &mut d.0);
-    }
+    })
 }
 
 fn ce(mut c: ViewMut<C>, mut e: ViewMut<E>) {
-    for (c, e) in (&mut c, &mut e).iter() {
+    (&mut c, &mut e).iter().for_each(|(c, e)| {
         std::mem::swap(&mut c.0, &mut e.0);
-    }
+    })
 }
 
 pub struct Benchmark(World);

src/shipyard/simple_iter.rs

@@ -50,9 +50,11 @@ impl Benchmark {
     pub fn run(&mut self) {
         self.0.run(
             |velocities: View<Velocity>, mut positions: ViewMut<Position>| {
-                for (velocity, position) in (&velocities, &mut positions).iter() {
-                    position.0 += velocity.0;
-                }
+                (&velocities, &mut positions)
+                    .iter()
+                    .for_each(|(velocity, position)| {
+                        position.0 += velocity.0;
+                    })
             },
         );
     }

src/shipyard_packed/schedule.rs

@@ -7,21 +7,21 @@ struct D(f32);
 struct E(f32);
 
 fn ab(mut a: ViewMut<A>, mut b: ViewMut<B>) {
-    for (a, b) in (&mut a, &mut b).iter() {
+    (&mut a, &mut b).iter().for_each(|(a, b)| {
         std::mem::swap(&mut a.0, &mut b.0);
-    }
+    })
 }
 
 fn cd(mut c: ViewMut<C>, mut d: ViewMut<D>) {
-    for (c, d) in (&mut c, &mut d).iter() {
+    (&mut c, &mut d).iter().for_each(|(c, d)| {
         std::mem::swap(&mut c.0, &mut d.0);
-    }
+    })
 }
 
 fn ce(mut c: ViewMut<C>, mut e: ViewMut<E>) {
-    for (c, e) in (&mut c, &mut e).iter() {
+    (&mut c, &mut e).iter().for_each(|(c, e)| {
         std::mem::swap(&mut c.0, &mut e.0);
-    }
+    })
 }
 
 pub struct Benchmark(World);
@@ -31,12 +31,15 @@ impl Benchmark {
         let world = World::default();
 
         world.run(
-            |mut a: ViewMut<A>, mut b: ViewMut<B>, mut c: ViewMut<C>, mut d: ViewMut<D>| {
+            |mut a: ViewMut<A>,
+             mut b: ViewMut<B>,
+             mut c: ViewMut<C>,
+             mut d: ViewMut<D>,
+             mut e: ViewMut<E>| {
                 (&mut a, &mut b).tight_pack();
                 (&mut c, &mut d).tight_pack();
 
-                // following pack is mutually exclusive with (c, d)
-                //(&mut c, &mut e).tight_pack();
+                (&mut e, &mut c).loose_pack();
             },
         );
 

src/shipyard_packed/simple_iter.rs

@@ -52,9 +52,11 @@ impl Benchmark {
     pub fn run(&mut self) {
         self.0.run(
             |velocities: View<Velocity>, mut positions: ViewMut<Position>| {
-                for (velocity, position) in (&velocities, &mut positions).iter() {
-                    position.0 += velocity.0;
-                }
+                (&velocities, &mut positions)
+                    .iter()
+                    .for_each(|(velocity, position)| {
+                        position.0 += velocity.0;
+                    })
             },
         );
     }