Merge pull request #3034 from ljedrz/perf/faster_db_deser

[Perf] More unchecked deserialization from the DB

Author: kaimast

algorithms/src/polycommit/sonic_pc/data_structures.rs

@@ -686,6 +686,11 @@ impl<E: PairingEngine> FromBytes for BatchLCProof<E> {
         CanonicalDeserialize::deserialize_compressed(&mut reader)
             .map_err(|err| into_io_error(anyhow::Error::from(err).context("could not deserialize struct")))
     }
+
+    fn read_le_unchecked<R: Read>(mut reader: R) -> io::Result<Self> {
+        CanonicalDeserialize::deserialize_compressed_unchecked(&mut reader)
+            .map_err(|err| into_io_error(anyhow::Error::from(err).context("could not deserialize struct")))
+    }
 }
 
 impl<E: PairingEngine> ToBytes for BatchLCProof<E> {

algorithms/src/snark/varuna/data_structures/certificate.rs

@@ -44,4 +44,9 @@ impl<E: PairingEngine> FromBytes for Certificate<E> {
         Self::deserialize_compressed(&mut r)
             .map_err(|err| into_io_error(anyhow::Error::from(err).context("Failed to deserialize certificate")))
     }
+
+    fn read_le_unchecked<R: Read>(mut r: R) -> io::Result<Self> {
+        Self::deserialize_compressed_unchecked(&mut r)
+            .map_err(|err| into_io_error(anyhow::Error::from(err).context("Failed to deserialize certificate")))
+    }
 }

algorithms/src/snark/varuna/data_structures/circuit_verifying_key.rs

@@ -43,6 +43,11 @@ impl<E: PairingEngine> FromBytes for CircuitVerifyingKey<E> {
         Self::deserialize_compressed(r)
             .map_err(|err| into_io_error(anyhow::Error::from(err).context("could not deserialize CircuitVerifyingKey")))
     }
+
+    fn read_le_unchecked<R: Read>(r: R) -> io::Result<Self> {
+        Self::deserialize_compressed_unchecked(r)
+            .map_err(|err| into_io_error(anyhow::Error::from(err).context("could not deserialize CircuitVerifyingKey")))
+    }
 }
 
 impl<E: PairingEngine> ToBytes for CircuitVerifyingKey<E> {

algorithms/src/snark/varuna/data_structures/proof.rs

@@ -379,6 +379,11 @@ impl<E: PairingEngine> FromBytes for Proof<E> {
         Self::deserialize_compressed(&mut r)
             .map_err(|err| into_io_error(anyhow::Error::from(err).context("could not deserialize Proof")))
     }
+
+    fn read_le_unchecked<R: Read>(mut r: R) -> io::Result<Self> {
+        Self::deserialize_compressed_unchecked(&mut r)
+            .map_err(|err| into_io_error(anyhow::Error::from(err).context("could not deserialize Proof")))
+    }
 }
 
 /// Computes the size in bytes of a Varuna proof as produced by

ledger/authority/src/lib.rs

@@ -34,7 +34,7 @@ use console::{
         Error,
         Formatter,
         FromBytes,
-        FromBytesDeserializer,
+        FromBytesUncheckedDeserializer,
         FromStr,
         IoResult,
         Read,

ledger/authority/src/serialize.rs

@@ -59,7 +59,7 @@ impl<'de, N: Network> Deserialize<'de> for Authority<N> {
                     _ => Err(de::Error::custom(error("Invalid authority type"))),
                 }
             }
-            false => FromBytesDeserializer::<Self>::deserialize_with_size_encoding(deserializer, "authority"),
+            false => FromBytesUncheckedDeserializer::<Self>::deserialize_with_size_encoding(deserializer, "authority"),
         }
     }
 }

synthesizer/snark/src/certificate/bytes.rs

@@ -29,6 +29,19 @@ impl<N: Network> FromBytes for Certificate<N> {
         // Return the certificate.
         Ok(Self { certificate })
     }
+
+    fn read_le_unchecked<R: Read>(mut reader: R) -> IoResult<Self> {
+        // Read the version.
+        let version = u8::read_le(&mut reader)?;
+        // Ensure the version is valid.
+        if version != 1 {
+            return Err(error("Invalid certificate version"));
+        }
+        // Read the certificate.
+        let certificate = FromBytes::read_le_unchecked(&mut reader)?;
+        // Return the certificate.
+        Ok(Self { certificate })
+    }
 }
 
 impl<N: Network> ToBytes for Certificate<N> {

synthesizer/snark/src/certificate/serialize.rs

@@ -30,7 +30,9 @@ impl<'de, N: Network> Deserialize<'de> for Certificate<N> {
     fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
         match deserializer.is_human_readable() {
             true => FromStr::from_str(&String::deserialize(deserializer)?).map_err(de::Error::custom),
-            false => FromBytesDeserializer::<Self>::deserialize_with_size_encoding(deserializer, "certificate"),
+            false => {
+                FromBytesUncheckedDeserializer::<Self>::deserialize_with_size_encoding(deserializer, "certificate")
+            }
         }
     }
 }

synthesizer/snark/src/proof/bytes.rs

@@ -29,6 +29,19 @@ impl<N: Network> FromBytes for Proof<N> {
         // Return the proof.
         Ok(Self { proof })
     }
+
+    fn read_le_unchecked<R: Read>(mut reader: R) -> IoResult<Self> {
+        // Read the version.
+        let version = u8::read_le(&mut reader)?;
+        // Ensure the version is valid.
+        if version != 1 {
+            return Err(error("Invalid proof version"));
+        }
+        // Read the proof.
+        let proof = FromBytes::read_le_unchecked(&mut reader)?;
+        // Return the proof.
+        Ok(Self { proof })
+    }
 }
 
 impl<N: Network> ToBytes for Proof<N> {

synthesizer/snark/src/proof/serialize.rs

@@ -30,7 +30,7 @@ impl<'de, N: Network> Deserialize<'de> for Proof<N> {
     fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
         match deserializer.is_human_readable() {
             true => FromStr::from_str(&String::deserialize(deserializer)?).map_err(de::Error::custom),
-            false => FromBytesDeserializer::<Self>::deserialize_with_size_encoding(deserializer, "proof"),
+            false => FromBytesUncheckedDeserializer::<Self>::deserialize_with_size_encoding(deserializer, "proof"),
         }
     }
 }