benches/benchmark.rs

@@ -1,35 +1,23 @@
-use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion, Throughput};
+use criterion::{BenchmarkId, measurement::Measurement};
+use criterion::{criterion_group, criterion_main, Criterion, Throughput, BenchmarkGroup};
 use gntag::agent::{Agent, SimpleAgent};
 use gntag::world::ActualWorld;
 
-fn get_world(width: isize, spacing: usize, validate: bool) -> ActualWorld {
-  let mut agents = vec![];
-  for x in (0..width).step_by(spacing) {
-    for y in (0..width).step_by(spacing) {
-      agents.push(((x, y).into(), Box::new(SimpleAgent) as Box<dyn Agent>));
-    }
-  }
-  ActualWorld::new((width, width).into(), agents, validate)
-}
-
-fn world(c: &mut Criterion) {
-  let mut group = c.benchmark_group("world");
+fn world<M: Measurement>(mut group: BenchmarkGroup<M>, validate: bool) {
   let width: isize = 1000;
-  for spacing in (50..=100).step_by(25) {
+  for spacing in (50..100).step_by(10) {
     group.throughput(Throughput::Elements((width / spacing).pow(2) as u64));
     group.bench_with_input(
-      BenchmarkId::new("validating", spacing),
+      BenchmarkId::from_parameter(spacing),
       &spacing,
       |b, &spacing| {
-        let mut world = get_world(width, spacing as usize, true);
-        b.iter(|| world.do_step());
-      },
-    );
-    group.bench_with_input(
-      BenchmarkId::new("non-validating", spacing),
-      &spacing,
-      |b, &spacing| {
-        let mut world = get_world(width, spacing as usize, false);
+        let mut agents: Vec<(_, Box<dyn Agent>)> = vec![];
+        for x in (0..width).step_by(spacing as usize) {
+          for y in (0..width).step_by(spacing as usize) {
+            agents.push(((x, y).into(), Box::new(SimpleAgent)));
+          }
+        }
+        let mut world = ActualWorld::new((width, width).into(), agents, validate);
         b.iter(|| world.do_step());
       },
     );
@@ -37,7 +25,17 @@ fn world(c: &mut Criterion) {
   group.finish();
 }
 
-criterion_group!(benches, world);
+fn world_validating(c: &mut Criterion) {
+  let group = c.benchmark_group("world_validating");
+  world(group, true)
+}
+
+fn world_nonvalidating(c: &mut Criterion) {
+  let group = c.benchmark_group("world_nonvalidating");
+  world(group, false)
+}
+
+criterion_group!(benches, world_validating, world_nonvalidating);
 criterion_main!(benches);
 
 // 5000/1000 ->     9,993

src/agent.rs

@@ -1,6 +1,5 @@
 pub type Distance = isize;
 
-#[derive(Clone)]
 pub struct Position {
   pub x: Distance,
   pub y: Distance,
@@ -26,12 +25,12 @@ impl From<(Distance, Distance)> for Direction {
 
 pub type AgentId = usize;
 
-pub struct WorldView<'o> {
+pub struct WorldView {
   pub self_id: AgentId,
   pub tagged: AgentId,
   pub tagged_by: Option<AgentId>,
   pub bounds_distance: (Distance, Distance, Distance, Distance),
-  pub other_agents: &'o mut dyn Iterator<Item = (Direction, AgentId)>,
+  pub other_agents: Vec<(Direction, AgentId)>,
 }
 
 #[derive(Debug)]

src/world.rs

@@ -58,7 +58,7 @@ impl ActualWorld {
             tagged_by: self.state.tagged_by,
             tagged: self.state.tagged,
             bounds_distance: (pos.y, self.size.x - pos.x, self.size.y - pos.y, pos.x),
-            other_agents: &mut self
+            other_agents: self
               .state
               .agent_positions
               .iter()
@@ -71,7 +71,8 @@ impl ActualWorld {
                   },
                   *id,
                 )
-              }),
+              })
+              .collect(),
           }),
         )
       })
@@ -86,7 +87,6 @@ impl ActualWorld {
         self.check_move(id, &mv);
       }
       let mut new_pos = None;
-      let pos = self.state.agent_positions.get(&id).unwrap();
       match mv {
         Move::Noop => {}
         Move::TryTag(other_id) => {
@@ -94,12 +94,14 @@ impl ActualWorld {
           new_state.tagged_by = Some(id);
         }
         Move::TryMove(dir) => {
+          let pos = self.state.agent_positions.get(&id).unwrap();
           new_pos = Some((pos.x + dir.x, pos.y + dir.y).into());
         }
       }
-      new_state
-        .agent_positions
-        .insert(id, new_pos.unwrap_or_else(|| pos.clone()));
+      new_state.agent_positions.insert(
+        id,
+        new_pos.unwrap_or_else(|| self.state.agent_positions.remove(&id).unwrap()),
+      );
     }
     self.state = new_state;
   }