Optimise Entity with repr align & manual PartialOrd/Ord

crates/bevy_ecs/src/entity/mod.rs

@@ -115,18 +115,55 @@ type IdCursor = isize;
 /// [`EntityCommands`]: crate::system::EntityCommands
 /// [`Query::get`]: crate::system::Query::get
 /// [`World`]: crate::world::World
-#[derive(Clone, Copy, Eq, Ord, PartialOrd)]
+#[derive(Clone, Copy, Eq)]
+// Alignment repr necessary to allow LLVM to better output
+// optimised codegen for `to_bits`, `PartialEq` and `Ord`.
+// See <https://github.com/rust-lang/rust/issues/106107>
+#[repr(align(8))]
 pub struct Entity {
-    generation: u32,
+    // The field order below is necessary for rust to
+    // optimise better how it handles `Entity`
     index: u32,
+    generation: u32,
 }
 
 // By not short-circuiting in comparisons, we get better codegen.
 // See <https://github.com/rust-lang/rust/issues/117800>
 impl PartialEq for Entity {
     #[inline]
     fn eq(&self, other: &Entity) -> bool {
-        (self.generation == other.generation) & (self.index == other.index)
+        // By using `to_bits`, the codegen can be optimised out even
+        // further potentially. Relies on the correct alignment/order of
+        // `Entity`.
+        self.to_bits() == other.to_bits()
+    }
+}
+
+// The macro codegen output is not optimal and can't be optimised as well
+// by the compiler. This impl resolves that like with `PartialEq`, but by
+// instead relying on the better alignment of `Entity`, and then by
+// comparing against the bit representation directly instead of relying on
+// the normal field order.
+impl PartialOrd for Entity {
+    #[inline]
+    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
+        // Make use of our `Ord` impl to ensure optimal codegen output
+        Some(self.cmp(other))
+    }
+}
+
+// The macro codegen output is not optimal and can't be optimised as well
+// by the compiler. This impl resolves that like with `PartialEq`, but by
+// instead relying on the better alignment of `Entity`, and then by
+// comparing against the bit representation directly instead of relying on
+// the normal field order.
+impl Ord for Entity {
+    #[inline]
+    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
+        // This will result in better codegen for ordering comparisons, plus
+        // avoids pitfalls with regards to macro codegen relying on property
+        // position when we want to compare against the bit representation.
+        self.to_bits().cmp(&other.to_bits())
     }
 }
 
@@ -145,6 +182,7 @@ pub(crate) enum AllocAtWithoutReplacement {
 
 impl Entity {
     #[cfg(test)]
+    #[inline]
     pub(crate) const fn new(index: u32, generation: u32) -> Entity {
         Entity { index, generation }
     }
@@ -197,6 +235,7 @@ impl Entity {
     /// In general, one should not try to synchronize the ECS by attempting to ensure that
     /// `Entity` lines up between instances, but instead insert a secondary identifier as
     /// a component.
+    #[inline]
     pub const fn from_raw(index: u32) -> Entity {
         Entity {
             index,
@@ -210,13 +249,15 @@ impl Entity {
     /// for serialization between runs.
     ///
     /// No particular structure is guaranteed for the returned bits.
+    #[inline]
     pub const fn to_bits(self) -> u64 {
         (self.generation as u64) << 32 | self.index as u64
     }
 
     /// Reconstruct an `Entity` previously destructured with [`Entity::to_bits`].
     ///
     /// Only useful when applied to results from `to_bits` in the same instance of an application.
+    #[inline]
     pub const fn from_bits(bits: u64) -> Self {
         Self {
             generation: (bits >> 32) as u32,