Skip to content

Commit

Permalink
One thread results
Browse files Browse the repository at this point in the history
  • Loading branch information
adria0 committed Jun 20, 2024
1 parent 814a3d4 commit b2f305d
Show file tree
Hide file tree
Showing 7 changed files with 305 additions and 310 deletions.
18 changes: 7 additions & 11 deletions halo2_proofs/tests/compress_selectors.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -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};

Check failure on line 7 in halo2_proofs/tests/compress_selectors.rs

View workflow job for this annotation

GitHub Actions / Test on ubuntu-latest with basic features 

unresolved import `halo2_debug::test_result`
use halo2_frontend::circuit::compile_circuit;
use halo2_frontend::plonk::Error;
use halo2_proofs::circuit::{Cell, Layouter, SimpleFloorPlanner, Value};
Expand Down Expand Up @@ -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(())
Expand Down
256 changes: 130 additions & 126 deletions halo2_proofs/tests/frontend_backend_split.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -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",
);
}
Loading

0 comments on commit b2f305d

Please sign in to comment.