Apply exponential resize strategy to reserve

Dramatically improves performance of iterated spawn_batch.

src/archetype.rs

@@ -222,7 +222,7 @@ impl Archetype {
     /// Every type must be written immediately after this call
     pub(crate) unsafe fn allocate(&mut self, id: u32) -> u32 {
         if self.len as usize == self.entities.len() {
-            self.grow(self.len.max(64));
+            self.grow(64);
         }
 
         self.entities[self.len as usize] = id;
@@ -237,15 +237,23 @@ impl Archetype {
 
     pub(crate) fn reserve(&mut self, additional: u32) {
         if additional > (self.capacity() - self.len()) {
-            self.grow(additional - (self.capacity() - self.len()));
+            let increment = additional - (self.capacity() - self.len());
+            self.grow(increment.max(64));
         }
     }
 
     pub(crate) fn capacity(&self) -> u32 {
         self.entities.len() as u32
     }
 
-    fn grow(&mut self, increment: u32) {
+    /// Increase capacity by at least `min_increment`
+    fn grow(&mut self, min_increment: u32) {
+        // Double capacity or increase it by `min_increment`, whichever is larger.
+        self.grow_exact(self.capacity().max(min_increment))
+    }
+
+    /// Increase capacity by exactly `increment`
+    fn grow_exact(&mut self, increment: u32) {
         unsafe {
             let old_count = self.len as usize;
             let new_cap = self.entities.len() + increment as usize;

src/batch.rs

@@ -33,6 +33,7 @@ impl ColumnBatchType {
         arch.reserve(size);
         ColumnBatchBuilder {
             fill,
+            target_fill: size,
             archetype: Some(arch),
         }
     }
@@ -42,6 +43,7 @@ impl ColumnBatchType {
 pub struct ColumnBatchBuilder {
     /// Number of components written so far for each component type
     fill: TypeIdMap<u32>,
+    target_fill: u32,
     pub(crate) archetype: Option<Archetype>,
 }
 
@@ -62,7 +64,7 @@ impl ColumnBatchBuilder {
         Some(BatchWriter {
             fill: self.fill.entry(TypeId::of::<T>()).or_insert(0),
             storage: unsafe {
-                slice::from_raw_parts_mut(base.as_ptr().cast(), archetype.capacity() as usize)
+                slice::from_raw_parts_mut(base.as_ptr().cast(), self.target_fill as usize)
                     .iter_mut()
             },
         })
@@ -74,12 +76,12 @@ impl ColumnBatchBuilder {
         if archetype
             .types()
             .iter()
-            .any(|ty| self.fill.get(&ty.id()).copied().unwrap_or(0) != archetype.capacity())
+            .any(|ty| self.fill.get(&ty.id()).copied().unwrap_or(0) != self.target_fill)
         {
             return Err(BatchIncomplete { _opaque: () });
         }
         unsafe {
-            archetype.set_len(archetype.capacity());
+            archetype.set_len(self.target_fill);
         }
         Ok(ColumnBatch(archetype))
     }

src/world.rs

@@ -293,7 +293,7 @@ impl World {
         Ok(())
     }
 
-    /// Ensure `additional` entities with exact components `T` can be spawned without reallocating
+    /// Ensure at least `additional` entities with exact components `T` can be spawned without reallocating
     pub fn reserve<T: Bundle + 'static>(&mut self, additional: u32) {
         self.reserve_inner::<T>(additional);
     }