feat: update serialization example to compare bincode

axiom-crypto · Jul 27, 2023 · 2fac78b · 2fac78b
1 parent 7d7527d
commit 2fac78b
Show file tree

Hide file tree

Showing 2 changed files with 84 additions and 51 deletions.
diff --git a/halo2_proofs/Cargo.toml b/halo2_proofs/Cargo.toml
@@ -62,6 +62,7 @@ rustc-hash = "1.1.0"
 sha3 = "0.9.1"
 ark-std = { version = "0.3.0", features = ["print-trace"], optional = true }
 serde = { version = "1.0", default-features = false, features = ["derive"] }
+bincode = "1.3.3"
 
 # Developer tooling dependencies
 plotters = { version = "0.3.0", optional = true }

diff --git a/halo2_proofs/examples/serialization.rs b/halo2_proofs/examples/serialization.rs
@@ -1,5 +1,5 @@
 use std::{
-    fs::File,
+    fs::{self, File},
     io::{BufReader, BufWriter, Write},
 };
 
@@ -126,59 +126,91 @@ impl Circuit<Fr> for StandardPlonk {
     }
 }
 
-fn main() {
-    let k = 4;
+fn main() -> std::io::Result<()> {
+    let k = 22;
     let circuit = StandardPlonk(Fr::random(OsRng));
     let params = ParamsKZG::<Bn256>::setup(k, OsRng);
     let vk = keygen_vk(&params, &circuit).expect("vk should not fail");
     let pk = keygen_pk(&params, vk, &circuit).expect("pk should not fail");
 
-    let f = File::create("serialization-test.pk").unwrap();
-    let mut writer = BufWriter::new(f);
-    pk.write(&mut writer, SerdeFormat::RawBytes).unwrap();
-    writer.flush().unwrap();
-
-    let f = File::open("serialization-test.pk").unwrap();
-    let mut reader = BufReader::new(f);
-    let pk = ProvingKey::<G1Affine>::read::<_, StandardPlonk>(&mut reader, SerdeFormat::RawBytes)
-        .unwrap();
-
-    std::fs::remove_file("serialization-test.pk").unwrap();
-
-    let instances: &[&[Fr]] = &[&[circuit.0]];
-    let mut transcript = Blake2bWrite::<_, _, Challenge255<_>>::init(vec![]);
-    create_proof::<
-        KZGCommitmentScheme<Bn256>,
-        ProverGWC<'_, Bn256>,
-        Challenge255<G1Affine>,
-        _,
-        Blake2bWrite<Vec<u8>, G1Affine, Challenge255<_>>,
-        _,
-    >(
-        &params,
-        &pk,
-        &[circuit],
-        &[instances],
-        OsRng,
-        &mut transcript,
-    )
-    .expect("prover should not fail");
-    let proof = transcript.finalize();
-
-    let strategy = SingleStrategy::new(&params);
-    let mut transcript = Blake2bRead::<_, _, Challenge255<_>>::init(&proof[..]);
-    assert!(verify_proof::<
-        KZGCommitmentScheme<Bn256>,
-        VerifierGWC<'_, Bn256>,
-        Challenge255<G1Affine>,
-        Blake2bRead<&[u8], G1Affine, Challenge255<G1Affine>>,
-        SingleStrategy<'_, Bn256>,
-    >(
-        &params,
-        pk.get_vk(),
-        strategy,
-        &[instances],
-        &mut transcript
-    )
-    .is_ok());
+    for buf_size in [1024, 1024 * 1024, 1024 * 1024 * 1024] {
+        println!("buf_size: {buf_size}");
+        // Using halo2_proofs serde implementation
+        let f = File::create("serialization-test.pk")?;
+        let mut writer = BufWriter::with_capacity(buf_size, f);
+        let start = std::time::Instant::now();
+        pk.write(&mut writer, SerdeFormat::RawBytes)?;
+        writer.flush().unwrap();
+        println!("SerdeFormat::RawBytes pk write time: {:?}", start.elapsed());
+
+        let f = File::open("serialization-test.pk")?;
+        let mut reader = BufReader::with_capacity(buf_size, f);
+        let start = std::time::Instant::now();
+        let pk =
+            ProvingKey::<G1Affine>::read::<_, StandardPlonk>(&mut reader, SerdeFormat::RawBytes)
+                .unwrap();
+        println!("SerdeFormat::RawBytes pk read time: {:?}", start.elapsed());
+
+        let metadata = fs::metadata("serialization-test.pk")?;
+        let file_size = metadata.len();
+        println!("The size of the file is {} bytes", file_size);
+        std::fs::remove_file("serialization-test.pk")?;
+
+        // Using bincode
+        let f = File::create("serialization-test.pk")?;
+        let mut writer = BufWriter::with_capacity(buf_size, f);
+        let start = std::time::Instant::now();
+        bincode::serialize_into(&mut writer, &pk).unwrap();
+        writer.flush().unwrap();
+        println!("bincode pk write time: {:?}", start.elapsed());
+
+        let f = File::open("serialization-test.pk").unwrap();
+        let mut reader = BufReader::with_capacity(buf_size, f);
+        let start = std::time::Instant::now();
+        let pk: ProvingKey<G1Affine> = bincode::deserialize_from(&mut reader).unwrap();
+        println!("bincode pk read time: {:?}", start.elapsed());
+
+        let metadata = fs::metadata("serialization-test.pk")?;
+        let file_size = metadata.len();
+        println!("The size of the file is {} bytes", file_size);
+        std::fs::remove_file("serialization-test.pk").unwrap();
+
+        let instances: &[&[Fr]] = &[&[circuit.clone().0]];
+        let mut transcript = Blake2bWrite::<_, _, Challenge255<_>>::init(vec![]);
+        create_proof::<
+            KZGCommitmentScheme<Bn256>,
+            ProverGWC<'_, Bn256>,
+            Challenge255<G1Affine>,
+            _,
+            Blake2bWrite<Vec<u8>, G1Affine, Challenge255<_>>,
+            _,
+        >(
+            &params,
+            &pk,
+            &[circuit.clone()],
+            &[instances],
+            OsRng,
+            &mut transcript,
+        )
+        .expect("prover should not fail");
+        let proof = transcript.finalize();
+
+        let strategy = SingleStrategy::new(&params);
+        let mut transcript = Blake2bRead::<_, _, Challenge255<_>>::init(&proof[..]);
+        assert!(verify_proof::<
+            KZGCommitmentScheme<Bn256>,
+            VerifierGWC<'_, Bn256>,
+            Challenge255<G1Affine>,
+            Blake2bRead<&[u8], G1Affine, Challenge255<G1Affine>>,
+            SingleStrategy<'_, Bn256>,
+        >(
+            &params,
+            pk.get_vk(),
+            strategy,
+            &[instances],
+            &mut transcript
+        )
+        .is_ok());
+    }
+    Ok(())
 }