Optimize memory size of SparseArray and integer-based ECS IDs

crates/bevy_ecs/src/archetype.rs

@@ -28,6 +28,7 @@ use crate::{
 use std::{
     collections::HashMap,
     hash::Hash,
+    num::{NonZeroU32, NonZeroUsize},
     ops::{Index, IndexMut},
 };
 
@@ -71,24 +72,42 @@ impl ArchetypeRow {
 #[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
 // SAFETY: Must be repr(transparent) due to the safety requirements on EntityLocation
 #[repr(transparent)]
-pub struct ArchetypeId(u32);
+pub struct ArchetypeId(NonZeroU32);
 
 impl ArchetypeId {
     /// The ID for the [`Archetype`] without any components.
-    pub const EMPTY: ArchetypeId = ArchetypeId(0);
-    /// # Safety:
+    pub const EMPTY: ArchetypeId = {
+        // SAFETY: 1 is guaranteed to not equal 0
+        unsafe { Self::new_unchecked(1) }
+    };
+
+    /// Creates a new [`ArchetypeId`].
     ///
-    /// This must always have an all-1s bit pattern to ensure soundness in fast entity id space allocation.
-    pub const INVALID: ArchetypeId = ArchetypeId(u32::MAX);
+    /// # Panics
+    /// This will panic if `index` is not in the range `[0, u32::MAX]` or greater.
+    pub(crate) const fn new(index: usize) -> Self {
+        assert!(
+            index > 0 && index <= u32::MAX as usize,
+            "ArchetypeID cannot be u32::MAX or greater"
+        );
+        // SAFETY: The above assertion will fail if the value is not valid.
+        unsafe { Self::new_unchecked(index) }
+    }
 
+    /// Creates a new [`ArchetypeId`] without checking for validity of the
+    /// provided index.
+    ///
+    /// # Safety
+    /// This is only safe if `index` is in the range of `[0, u32::MAX]`.
     #[inline]
-    pub(crate) const fn new(index: usize) -> Self {
-        ArchetypeId(index as u32)
+    pub(crate) const unsafe fn new_unchecked(index: usize) -> Self {
+        Self(NonZeroU32::new_unchecked(index as u32))
     }
 
+    /// Gets the corresponding index for the ID.
     #[inline]
-    pub(crate) fn index(self) -> usize {
-        self.0 as usize
+    pub(crate) const fn index(self) -> usize {
+        self.0.get() as usize
     }
 }
 
@@ -530,7 +549,7 @@ pub struct ArchetypeGeneration(usize);
 impl ArchetypeGeneration {
     #[inline]
     pub(crate) const fn initial() -> Self {
-        ArchetypeGeneration(0)
+        ArchetypeGeneration(1)
     }
 
     #[inline]
@@ -572,23 +591,45 @@ struct ArchetypeIdentity {
 /// [`Resource`]: crate::system::Resource
 /// [many-to-many relationship]: https://en.wikipedia.org/wiki/Many-to-many_(data_model)
 #[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
-pub struct ArchetypeComponentId(usize);
+pub struct ArchetypeComponentId(NonZeroUsize);
 
 impl ArchetypeComponentId {
+    /// Creates a new [`ArchetypeComponentId`] from an index.
     #[inline]
     pub(crate) const fn new(index: usize) -> Self {
-        Self(index)
+        assert!(index != 0);
+        // SAFETY: The value is guarenteed not to be 0 by the above check.
+        Self(unsafe { NonZeroUsize::new_unchecked(index) })
     }
 }
 
 impl SparseSetIndex for ArchetypeComponentId {
+    type Repr = NonZeroUsize;
+    const MAX_SIZE: usize = NonZeroUsize::MAX_SIZE;
+
     #[inline]
     fn sparse_set_index(&self) -> usize {
-        self.0
+        self.0.get()
     }
 
+    #[inline]
     fn get_sparse_set_index(value: usize) -> Self {
-        Self(value)
+        Self::new(value)
+    }
+
+    #[inline]
+    unsafe fn repr_from_index(index: usize) -> Self::Repr {
+        debug_assert!(index < Self::MAX_SIZE);
+        // SAFETY: Caller guarentees that `index` does not exceed `u32::MAX - 1`.
+        // This addition cannot overflow under these guarentees.
+        //
+        // Created index cannot be zero as it's being incremented by one.
+        unsafe { NonZeroUsize::new_unchecked(index + 1) }
+    }
+
+    #[inline]
+    fn repr_to_index(repr: &Self::Repr) -> usize {
+        repr.get() as usize - 1
     }
 }
 
@@ -607,9 +648,16 @@ pub struct Archetypes {
 impl Archetypes {
     pub(crate) fn new() -> Self {
         let mut archetypes = Archetypes {
-            archetypes: Vec::new(),
+            // Dummy value to fill the zero-index slot.
+            archetypes: vec![Archetype {
+                id: ArchetypeId::new(1),
+                table_id: TableId::empty(),
+                edges: Default::default(),
+                entities: Vec::new(),
+                components: SparseSet::new().into_immutable(),
+            }],
             archetype_ids: Default::default(),
-            archetype_component_count: 0,
+            archetype_component_count: 1,
         };
         archetypes.get_id_or_insert(TableId::empty(), Vec::new(), Vec::new());
         archetypes
@@ -700,11 +748,12 @@ impl Archetypes {
                 let table_start = *archetype_component_count;
                 *archetype_component_count += table_components.len();
                 let table_archetype_components =
-                    (table_start..*archetype_component_count).map(ArchetypeComponentId);
+                    (table_start..*archetype_component_count).map(ArchetypeComponentId::new);
                 let sparse_start = *archetype_component_count;
                 *archetype_component_count += sparse_set_components.len();
                 let sparse_set_archetype_components =
-                    (sparse_start..*archetype_component_count).map(ArchetypeComponentId);
+                    (sparse_start..*archetype_component_count).map(ArchetypeComponentId::new);
+
                 archetypes.push(Archetype::new(
                     id,
                     table_id,

crates/bevy_ecs/src/bundle.rs

@@ -241,20 +241,43 @@ all_tuples!(tuple_impl, 0, 15, B);
 pub struct BundleId(usize);
 
 impl BundleId {
+    /// Creates a new [`BundleId`] from an index.
+    ///
+    /// # Panic
+    /// This function will panic if `value` is greater than or equal to [`u32::MAX`].
+    #[inline]
+    pub(crate) const fn new(value: usize) -> Self {
+        Self(value)
+    }
+
     #[inline]
-    pub fn index(self) -> usize {
+    pub(crate) fn index(self) -> usize {
         self.0
     }
 }
 
 impl SparseSetIndex for BundleId {
+    type Repr = usize;
+    const MAX_SIZE: usize = (u32::MAX - 1) as usize;
+
     #[inline]
     fn sparse_set_index(&self) -> usize {
         self.index()
     }
 
+    #[inline]
     fn get_sparse_set_index(value: usize) -> Self {
-        Self(value)
+        Self::new(value)
+    }
+
+    #[inline]
+    unsafe fn repr_from_index(index: usize) -> Self::Repr {
+        index
+    }
+
+    #[inline]
+    fn repr_to_index(repr: &Self::Repr) -> usize {
+        *repr
     }
 }
 
@@ -680,7 +703,6 @@ impl<'a, 'b> BundleSpawner<'a, 'b> {
     }
 }
 
-#[derive(Default)]
 pub struct Bundles {
     bundle_infos: Vec<BundleInfo>,
     bundle_ids: HashMap<TypeId, BundleId>,
@@ -714,7 +736,20 @@ impl Bundles {
             id
         });
         // SAFETY: index either exists, or was initialized
-        unsafe { self.bundle_infos.get_unchecked(id.0) }
+        unsafe { self.bundle_infos.get_unchecked(id.index()) }
+    }
+}
+
+impl Default for Bundles {
+    fn default() -> Self {
+        Bundles {
+            // Dummy value to fill the zero-index slot.
+            bundle_infos: vec![BundleInfo {
+                id: BundleId::new(1),
+                component_ids: Vec::new(),
+            }],
+            bundle_ids: Default::default(),
+        }
     }
 }