perf: added an optimized impl of PartialEq to Mv (#1400)

Another small improvement I noticed while comparing perf to `dav1d`.

This improves the performance of `add_temporal_candidate` by ~20% (on
M3), so it now matches the one from `dav1d` (to less than 0.1% diff), as
measured when decoding Chimera-AV1-8bit-1920x1080-6736kbps.ivf.

The overall improvement is about 0.5%.

Edit: also for `RefMvs{Mv,Ref}Pair`, which seems to have a smaller
effect.

Author: kkysen

src/levels.rs

@@ -354,7 +354,7 @@ pub enum InterIntraType {
 /// which includes `&self` methods, including autogenerated ones like [`PartialEq::eq`].
 ///
 /// [`refmvs_block`]: crate::src::refmvs::refmvs_block
-#[derive(Clone, Copy, PartialEq, Eq, Default, FromZeroes, FromBytes, AsBytes)]
+#[derive(Clone, Copy, Eq, Default, FromZeroes, FromBytes, AsBytes)]
 #[repr(C)]
 pub struct Mv {
     pub y: i16,
@@ -390,6 +390,17 @@ impl Neg for Mv {
     }
 }
 
+impl PartialEq for Mv {
+    #[inline(always)]
+    fn eq(&self, other: &Self) -> bool {
+        // `#[derive(PartialEq)]` compares per-field with `&&`,
+        // which isn't optimized well and isn't coalesced into wider loads.
+        // Comparing all of the bytes at once optimizes better with wider loads.
+        // See <https://github.com/rust-lang/rust/issues/140167>.
+        self.as_bytes() == other.as_bytes()
+    }
+}
+
 #[derive(Debug, Clone, Copy, PartialEq, Eq, FromRepr, Default)]
 pub enum MotionMode {
     #[default]

src/refmvs.rs

@@ -28,6 +28,7 @@ use std::mem;
 use std::mem::MaybeUninit;
 use std::ptr;
 use std::slice;
+use zerocopy::AsBytes;
 use zerocopy::FromZeroes;
 
 #[derive(Clone, Copy, Default, PartialEq, Eq)]
@@ -38,7 +39,7 @@ pub struct RefMvsTemporalBlock {
 }
 const _: () = assert!(mem::size_of::<RefMvsTemporalBlock>() == 5);
 
-#[derive(Clone, Copy, PartialEq, Eq, FromZeroes)]
+#[derive(Clone, Copy, Eq, FromZeroes, AsBytes)]
 // In C, this is packed and is 2 bytes.
 // In Rust, being packed and aligned is tricky
 #[repr(C, align(2))]
@@ -47,19 +48,42 @@ pub struct RefMvsRefPair {
 }
 const _: () = assert!(mem::size_of::<RefMvsRefPair>() == 2);
 
+impl PartialEq for RefMvsRefPair {
+    #[inline(always)]
+    fn eq(&self, other: &Self) -> bool {
+        // `#[derive(PartialEq)]` compares per-field with `&&`,
+        // which isn't optimized well and isn't coalesced into wider loads.
+        // Comparing all of the bytes at once optimizes better with wider loads.
+        // See <https://github.com/rust-lang/rust/issues/140167>.
+        self.as_bytes() == other.as_bytes()
+    }
+}
+
 impl From<[i8; 2]> for RefMvsRefPair {
     fn from(from: [i8; 2]) -> Self {
         RefMvsRefPair { r#ref: from }
     }
 }
 
-#[derive(Clone, Copy, Default, PartialEq, Eq, FromZeroes)]
+#[derive(Clone, Copy, Default, Eq, FromZeroes, AsBytes)]
 #[repr(C)]
+#[repr(align(4))] // Is a `union` with a `uint64_t` in C, so `align(8)`, but `align(8)` doesn't allow `align(4)` for `RefMvsBlock`.
 pub struct RefMvsMvPair {
     pub mv: [Mv; 2],
 }
 const _: () = assert!(mem::size_of::<RefMvsMvPair>() == 8);
 
+impl PartialEq for RefMvsMvPair {
+    #[inline(always)]
+    fn eq(&self, other: &Self) -> bool {
+        // `#[derive(PartialEq)]` compares per-field with `&&`,
+        // which isn't optimized well and isn't coalesced into wider loads.
+        // Comparing all of the bytes at once optimizes better with wider loads.
+        // See <https://github.com/rust-lang/rust/issues/140167>.
+        self.as_bytes() == other.as_bytes()
+    }
+}
+
 #[derive(Clone, Copy, FromZeroes)]
 // In C, this is packed and is 12 bytes.
 // In Rust, being packed and aligned is tricky