Avoid temporary Vec<u8> allocation during deserialization

Instead of reusing `Vec::<u8>::deserialize` to defer the
deserialization, implement a Visitor that can construct `$typ` directly
from the deserialization byte stream. This eliminates a temporary
allocation where the input byte stream is first copied into a `Vec<u8>`
and later copied to the stack to construct `$typ` via `transmute!`.

This saves a few microseconds (up to 1ms on specific hardware) when
deserializing microVM snapshots.

Signed-off-by: Patrick Roy <roypat@amazon.co.uk>

Author: roypat

coverage_config_x86_64.json

@@ -1,5 +1,5 @@
 {
-  "coverage_score": 80.77,
+  "coverage_score": 78.57,
   "exclude_path": ".*bindings\\.rs",
   "crate_features": "fam-wrappers,serde"
 }

src/serialize.rs

@@ -27,13 +27,24 @@ macro_rules! serde_impls {
                 where
                     D: Deserializer<'de>
                 {
-                    let bytes = Vec::<u8>::deserialize(deserializer)?;
+                    struct BytesVisitor;
 
-                    let mut backing = [0u8; std::mem::size_of::<$typ>()];
+                    impl<'a> serde::de::Visitor<'a> for BytesVisitor {
+                        type Value = [u8; std::mem::size_of::<$typ>()];
 
-                    let limit = bytes.len().min(backing.len());
+                        fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
+                            formatter.write_str("a byte array")
+                        }
 
-                    backing[..limit].copy_from_slice(&bytes[..limit]);
+                        fn visit_bytes<E>(self, bytes: &[u8]) -> Result<Self::Value, E> {
+                            let mut backing = [0u8; std::mem::size_of::<$typ>()];
+                            let limit = bytes.len().min(backing.len());
+                            backing[..limit].copy_from_slice(&bytes[..limit]);
+                            Ok(backing)
+                        }
+                    }
+
+                    let backing = deserializer.deserialize_bytes(BytesVisitor)?;
 
                     Ok(transmute!(backing))
                 }