One thread results

privacy-scaling-explorations · Jun 20, 2024 · d4cf60b · d4cf60b
1 parent 814a3d4
commit d4cf60b
Show file tree

Hide file tree

Showing 9 changed files with 330 additions and 311 deletions.
diff --git a/halo2_debug/Cargo.toml b/halo2_debug/Cargo.toml
@@ -28,4 +28,8 @@ halo2_middleware = { path = "../halo2_middleware" }
 tiny-keccak = { version = "2.0.2", features=["keccak"] }
 hex = "0.4.3"
 rand_core = "0.6.4"
-rand_chacha = "0.3"
+rand_chacha = "0.3"
+rayon = "1.8"
+
+[features]
+vector-tests = []
diff --git a/halo2_debug/src/lib.rs b/halo2_debug/src/lib.rs
@@ -14,4 +14,24 @@ pub fn keccak_hex<D: AsRef<[u8]>>(data: D) -> String {
     hasher.finalize(&mut hash);
     hex::encode(hash)
 }
+
+/// Executes a test and checks the result against the expected value
+pub fn test_result<F: FnOnce() -> Vec<u8> + Send>(test: F, _expected: &str) -> Vec<u8> {
+    #[cfg(feature = "vector-tests")]
+    let result = rayon::ThreadPoolBuilder::new()
+        .num_threads(1)
+        .build()
+        .unwrap()
+        .install(|| {
+            let result = test();
+            assert_eq!(_expected, keccak_hex(result.clone()),);
+            result
+        });
+
+    #[cfg(not(feature = "vector-tests"))]
+    let result = test();
+
+    result
+}
+
 pub mod display;
diff --git a/halo2_proofs/tests/compress_selectors.rs b/halo2_proofs/tests/compress_selectors.rs
@@ -4,7 +4,7 @@ use std::marker::PhantomData;
 
 use ff::PrimeField;
 use halo2_debug::display::expr_disp_names;
-use halo2_debug::test_rng;
+use halo2_debug::{test_result, test_rng};
 use halo2_frontend::circuit::compile_circuit;
 use halo2_frontend::plonk::Error;
 use halo2_proofs::circuit::{Cell, Layouter, SimpleFloorPlanner, Value};
@@ -486,19 +486,15 @@ fn test_compress_gates() {
 #[test]
 fn test_success() -> Result<(), halo2_proofs::plonk::Error> {
     // vk & pk keygen both WITH compress
-    let _proof = test_mycircuit(true, true)?;
-    #[cfg(all(feature = "vector-tests", not(coverage)))]
-    assert_eq!(
-        "54567f2f61aca2232780ff6becb4e3d755b10deefea3a421af2b0448336e0bfb",
-        halo2_debug::keccak_hex(_proof),
+    test_result(
+        || test_mycircuit(true, true).expect("should pass"),
+        "8326140d1873a91630d439a8812d1f104667144e03e0cd5c59eb358ae5d1a4eb",
     );
 
     // vk & pk keygen both WITHOUT compress
-    let _proof = test_mycircuit(false, false)?;
-    #[cfg(all(feature = "vector-tests", not(coverage)))]
-    assert_eq!(
-        "74695fecf57b69fd698c55290beb34e21c631df58cb31947e3ecf0b961e56631",
-        halo2_debug::keccak_hex(_proof),
+    test_result(
+        || test_mycircuit(false, false).expect("should pass"),
+        "73dd4c3c9c51d55dc8cf68ca2b5d8acdb40ed44bc8a88d718325bc0023688f64",
     );
 
     Ok(())

diff --git a/halo2_proofs/tests/frontend_backend_split.rs b/halo2_proofs/tests/frontend_backend_split.rs
@@ -485,136 +485,140 @@ const WIDTH_FACTOR: usize = 1;
 
 #[test]
 fn test_mycircuit_full_legacy() {
-    use halo2_proofs::plonk::{
-        create_proof, keygen_pk as keygen_pk_legacy, keygen_vk as keygen_vk_legacy,
-    };
-
-    let k = K;
-    let circuit: MyCircuit<Fr, WIDTH_FACTOR> = MyCircuit::new(k, 42);
-
-    // Setup
-    let mut rng = test_rng();
-    let params = ParamsKZG::<Bn256>::setup(k, &mut rng);
-    let start = Instant::now();
-    let vk = keygen_vk_legacy(&params, &circuit).expect("keygen_vk should not fail");
-    let pk = keygen_pk_legacy(&params, vk.clone(), &circuit).expect("keygen_pk should not fail");
-    println!("Keygen: {:?}", start.elapsed());
-
-    // Proving
-    let instances = vec![circuit.instances()];
-
-    let start = Instant::now();
-    let mut transcript = Blake2bWrite::<_, G1Affine, Challenge255<_>>::init(vec![]);
-    create_proof::<KZGCommitmentScheme<Bn256>, ProverSHPLONK<'_, Bn256>, _, _, _, _>(
-        &params,
-        &pk,
-        &[circuit],
-        instances.as_slice(),
-        &mut rng,
-        &mut transcript,
-    )
-    .expect("proof generation should not fail");
-    let proof = transcript.finalize();
-    println!("Prove: {:?}", start.elapsed());
-
-    // Verify
-    let start = Instant::now();
-    let mut verifier_transcript =
-        Blake2bRead::<_, G1Affine, Challenge255<_>>::init(proof.as_slice());
-    let verifier_params = params.verifier_params();
-    let strategy = SingleStrategy::new(&verifier_params);
-
-    verify_proof::<KZGCommitmentScheme<Bn256>, VerifierSHPLONK<Bn256>, _, _, _>(
-        &verifier_params,
-        &vk,
-        strategy,
-        instances.as_slice(),
-        &mut verifier_transcript,
-    )
-    .expect("verify succeeds");
-    println!("Verify: {:?}", start.elapsed());
-
-    #[cfg(all(feature = "vector-tests", not(coverage)))]
-    assert_eq!(
-        "625d492217ab78c9a55eb6f9154bd57a63ca7a37f6e3f64cce670b6d1fc8271d",
-        halo2_debug::keccak_hex(proof),
+    halo2_debug::test_result(
+        || {
+            use halo2_proofs::plonk::{
+                create_proof, keygen_pk as keygen_pk_legacy, keygen_vk as keygen_vk_legacy,
+            };
+
+            let k = K;
+            let circuit: MyCircuit<Fr, WIDTH_FACTOR> = MyCircuit::new(k, 42);
+
+            // Setup
+            let mut rng = test_rng();
+            let params = ParamsKZG::<Bn256>::setup(k, &mut rng);
+            let start = Instant::now();
+            let vk = keygen_vk_legacy(&params, &circuit).expect("keygen_vk should not fail");
+            let pk =
+                keygen_pk_legacy(&params, vk.clone(), &circuit).expect("keygen_pk should not fail");
+            println!("Keygen: {:?}", start.elapsed());
+
+            // Proving
+            let instances = vec![circuit.instances()];
+
+            let start = Instant::now();
+            let mut transcript = Blake2bWrite::<_, G1Affine, Challenge255<_>>::init(vec![]);
+            create_proof::<KZGCommitmentScheme<Bn256>, ProverSHPLONK<'_, Bn256>, _, _, _, _>(
+                &params,
+                &pk,
+                &[circuit],
+                instances.as_slice(),
+                &mut rng,
+                &mut transcript,
+            )
+            .expect("proof generation should not fail");
+            let proof = transcript.finalize();
+            println!("Prove: {:?}", start.elapsed());
+
+            // Verify
+            let start = Instant::now();
+            let mut verifier_transcript =
+                Blake2bRead::<_, G1Affine, Challenge255<_>>::init(proof.as_slice());
+            let verifier_params = params.verifier_params();
+            let strategy = SingleStrategy::new(&verifier_params);
+
+            verify_proof::<KZGCommitmentScheme<Bn256>, VerifierSHPLONK<Bn256>, _, _, _>(
+                &verifier_params,
+                &vk,
+                strategy,
+                instances.as_slice(),
+                &mut verifier_transcript,
+            )
+            .expect("verify succeeds");
+            println!("Verify: {:?}", start.elapsed());
+
+            proof
+        },
+        "427e55eafeaafd9f4dfc7ec6f782ec7464251c749bb08e23efb663790c0419ed",
     );
 }
 
 #[test]
 fn test_mycircuit_full_split() {
-    use halo2_middleware::zal::impls::{H2cEngine, PlonkEngineConfig};
-
-    let engine = PlonkEngineConfig::new()
-        .set_curve::<G1Affine>()
-        .set_msm(H2cEngine::new())
-        .build();
-    let k = K;
-    let circuit: MyCircuit<Fr, WIDTH_FACTOR> = MyCircuit::new(k, 42);
-    let (compiled_circuit, config, cs) = compile_circuit(k, &circuit, true).unwrap();
-
-    // Setup
-    let mut rng = test_rng();
-    let params = ParamsKZG::<Bn256>::setup(k, &mut rng);
-    let start = Instant::now();
-    let vk = keygen_vk(&params, &compiled_circuit).expect("keygen_vk should not fail");
-    let pk = keygen_pk(&params, vk.clone(), &compiled_circuit).expect("keygen_pk should not fail");
-    println!("Keygen: {:?}", start.elapsed());
-    drop(compiled_circuit);
-
-    let instances = circuit.instances();
-    // Proving
-    println!("Proving...");
-    let start = Instant::now();
-    let mut witness_calc = WitnessCalculator::new(k, &circuit, &config, &cs, &instances);
-    let mut transcript = Blake2bWrite::<_, G1Affine, Challenge255<_>>::init(vec![]);
-    let mut prover = ProverSingle::<
-        KZGCommitmentScheme<Bn256>,
-        ProverSHPLONK<'_, Bn256>,
-        _,
-        _,
-        _,
-        _,
-    >::new_with_engine(
-        engine,
-        &params,
-        &pk,
-instances.clone(),
-        &mut rng,
-        &mut transcript,
-    )
-    .unwrap();
-    let mut challenges = HashMap::new();
-    for phase in 0..cs.phases().count() {
-        println!("phase {phase}");
-        let witness = witness_calc.calc(phase as u8, &challenges).unwrap();
-        challenges = prover.commit_phase(phase as u8, witness).unwrap();
-    }
-    prover.create_proof().unwrap();
-    let proof = transcript.finalize();
-    println!("Prove: {:?}", start.elapsed());
-
-    // Verify
-    let start = Instant::now();
-    println!("Verifying...");
-    let mut verifier_transcript =
-        Blake2bRead::<_, G1Affine, Challenge255<_>>::init(proof.as_slice());
-    let verifier_params = params.verifier_params();
-    let strategy = SingleStrategy::new(&verifier_params);
-
-    verify_proof_single::<KZGCommitmentScheme<Bn256>, VerifierSHPLONK<Bn256>, _, _, _>(
-        &verifier_params,
-        &vk,
-        strategy,
-        instances,
-        &mut verifier_transcript,
-    )
-    .expect("verify succeeds");
-    println!("Verify: {:?}", start.elapsed());
-
-    #[cfg(all(feature = "vector-tests", not(coverage)))]
-    assert_eq!(
-        "625d492217ab78c9a55eb6f9154bd57a63ca7a37f6e3f64cce670b6d1fc8271d",
-        halo2_debug::keccak_hex(proof),
+    halo2_debug::test_result(
+        || {
+            use halo2_middleware::zal::impls::{H2cEngine, PlonkEngineConfig};
+
+            let engine = PlonkEngineConfig::new()
+                .set_curve::<G1Affine>()
+                .set_msm(H2cEngine::new())
+                .build();
+            let k = K;
+            let circuit: MyCircuit<Fr, WIDTH_FACTOR> = MyCircuit::new(k, 42);
+            let (compiled_circuit, config, cs) = compile_circuit(k, &circuit, true).unwrap();
+
+            // Setup
+            let mut rng = test_rng();
+            let params = ParamsKZG::<Bn256>::setup(k, &mut rng);
+            let start = Instant::now();
+            let vk = keygen_vk(&params, &compiled_circuit).expect("keygen_vk should not fail");
+            let pk = keygen_pk(&params, vk.clone(), &compiled_circuit)
+                .expect("keygen_pk should not fail");
+            println!("Keygen: {:?}", start.elapsed());
+            drop(compiled_circuit);
+
+            let instances = circuit.instances();
+            // Proving
+            println!("Proving...");
+            let start = Instant::now();
+            let mut witness_calc = WitnessCalculator::new(k, &circuit, &config, &cs, &instances);
+            let mut transcript = Blake2bWrite::<_, G1Affine, Challenge255<_>>::init(vec![]);
+            let mut prover = ProverSingle::<
+                KZGCommitmentScheme<Bn256>,
+                ProverSHPLONK<'_, Bn256>,
+                _,
+                _,
+                _,
+                _,
+            >::new_with_engine(
+                engine,
+                &params,
+                &pk,
+                instances.clone(),
+                &mut rng,
+                &mut transcript,
+            )
+            .unwrap();
+            let mut challenges = HashMap::new();
+            for phase in 0..cs.phases().count() {
+                println!("phase {phase}");
+                let witness = witness_calc.calc(phase as u8, &challenges).unwrap();
+                challenges = prover.commit_phase(phase as u8, witness).unwrap();
+            }
+            prover.create_proof().unwrap();
+            let proof = transcript.finalize();
+            println!("Prove: {:?}", start.elapsed());
+
+            // Verify
+            let start = Instant::now();
+            println!("Verifying...");
+            let mut verifier_transcript =
+                Blake2bRead::<_, G1Affine, Challenge255<_>>::init(proof.as_slice());
+            let verifier_params = params.verifier_params();
+            let strategy = SingleStrategy::new(&verifier_params);
+
+            verify_proof_single::<KZGCommitmentScheme<Bn256>, VerifierSHPLONK<Bn256>, _, _, _>(
+                &verifier_params,
+                &vk,
+                strategy,
+                instances,
+                &mut verifier_transcript,
+            )
+            .expect("verify succeeds");
+            println!("Verify: {:?}", start.elapsed());
+
+            proof
+        },
+        "427e55eafeaafd9f4dfc7ec6f782ec7464251c749bb08e23efb663790c0419ed",
     );
 }