diff --git a/starky/src/interpreter.rs b/starky/src/interpreter.rs index 71838043..45b2b9c3 100644 --- a/starky/src/interpreter.rs +++ b/starky/src/interpreter.rs @@ -407,7 +407,7 @@ fn get_ref( next: usize, modulas: usize, ) -> Expr { - log::trace!("get_ref: r {:?} dom {} ", r, dom); + //log::trace!("get_ref: r {:?} dom {} ", r, dom); match r.type_.as_str() { "tmp" => Expr::new( Ops::Refer, diff --git a/starky/src/polsarray.rs b/starky/src/polsarray.rs index 9d6ec302..9f69b90c 100644 --- a/starky/src/polsarray.rs +++ b/starky/src/polsarray.rs @@ -281,14 +281,6 @@ impl PolsArray { chunk[j] = F::from(self.array[j][i]); } }); - /* - let mut buff = vec![]; - for i in 0..self.n { - for j in 0..self.nPols { - buff.push(F::from(self.array[j][i])); - } - } - */ buff } } diff --git a/starky/src/prove.rs b/starky/src/prove.rs index f9efbb1e..eebbfc1a 100644 --- a/starky/src/prove.rs +++ b/starky/src/prove.rs @@ -37,7 +37,11 @@ pub fn stark_prove( const_pol.load(const_pol_file)?; let mut cm_pol = PolsArray::new(&pil, PolKind::Commit); - cm_pol.load(cm_pol_file)?; + + match std::env::var("LOAD_FROM_CPP") { + Ok(_) => cm_pol.load_from_cpp(cm_pol_file)?, + _ => cm_pol.load(cm_pol_file)?, + }; let stark_struct = load_json::(stark_struct)?; match stark_struct.verificationHashType.as_str() { diff --git a/starky/src/stark_gen.rs b/starky/src/stark_gen.rs index 202543fb..b7294c58 100644 --- a/starky/src/stark_gen.rs +++ b/starky/src/stark_gen.rs @@ -210,34 +210,24 @@ impl<'a, M: MerkleTree> StarkProof { let mut n_cm = starkinfo.n_cm1; - log::info!("write cm buf"); + log::trace!("Alloc context memory"); ctx.cm1_n = cm_pols.write_buff(); drop(cm_pols); - log::info!("cm2_n"); ctx.cm2_n = vec![M::ExtendField::ZERO; (starkinfo.map_sectionsN.cm2_n) * ctx.N]; ctx.cm3_n = vec![M::ExtendField::ZERO; (starkinfo.map_sectionsN.cm3_n) * ctx.N]; - log::info!("cm3_n"); ctx.tmpexp_n = vec![M::ExtendField::ZERO; (starkinfo.map_sectionsN.tmpexp_n) * ctx.N]; - log::info!("cm1_2ns"); ctx.cm1_2ns = vec![M::ExtendField::ZERO; starkinfo.map_sectionsN.cm1_n * ctx.Next]; - log::info!("cm2_2ns"); ctx.cm2_2ns = vec![M::ExtendField::ZERO; starkinfo.map_sectionsN.cm2_n * ctx.Next]; - log::info!("cm3_2ns"); ctx.cm3_2ns = vec![M::ExtendField::ZERO; starkinfo.map_sectionsN.cm3_n * ctx.Next]; - log::info!("cm4_2ns"); ctx.cm4_2ns = vec![M::ExtendField::ZERO; starkinfo.map_sectionsN.cm4_n * ctx.Next]; ctx.const_2ns = vec![M::ExtendField::ZERO; const_tree.element_size()]; - log::info!("q_2ns"); ctx.q_2ns = vec![M::ExtendField::ZERO; starkinfo.q_dim * ctx.Next]; - log::info!("f_2ns"); ctx.f_2ns = vec![M::ExtendField::ZERO; 3 * ctx.Next]; - log::info!("x_n"); ctx.x_n = vec![M::ExtendField::ZERO; ctx.N]; - log::info!("alloc memory done"); let xx = M::ExtendField::ONE; // Using the precomputing value @@ -257,7 +247,7 @@ impl<'a, M: MerkleTree> StarkProof { ctx.Zi = build_Zh_Inv::(ctx.nbits, extend_bits, 0); - log::info!("write pols buf"); + log::trace!("Convert const pols to array"); ctx.const_n = const_pols.write_buff(); const_tree.to_extend(&mut ctx.const_2ns); drop(const_pols); @@ -290,7 +280,7 @@ impl<'a, M: MerkleTree> StarkProof { //Do pre-allocation let mut result = vec![M::ExtendField::ZERO; (1 << stark_struct.nBitsExt) * 8]; - log::info!("Merkelizing 1...."); + log::trace!("Merkelizing 1...."); let tree1 = extend_and_merkelize::(&mut ctx, starkinfo, "cm1_n", &mut result)?; tree1.to_extend(&mut ctx.cm1_2ns); @@ -319,7 +309,7 @@ impl<'a, M: MerkleTree> StarkProof { n_cm += 1; } - log::info!("Merkelizing 2...."); + log::trace!("Merkelizing 2...."); let tree2 = extend_and_merkelize::(&mut ctx, starkinfo, "cm2_n", &mut result)?; tree2.to_extend(&mut ctx.cm2_2ns); transcript.put(&[tree2.root().as_elements().to_vec()])?; @@ -365,7 +355,7 @@ impl<'a, M: MerkleTree> StarkProof { calculate_exps_parallel(&mut ctx, starkinfo, &program.step3, "n", "step3"); - log::info!("Merkelizing 3...."); + log::trace!("Merkelizing 3...."); let tree3 = extend_and_merkelize::(&mut ctx, starkinfo, "cm3_n", &mut result)?; tree3.to_extend(&mut ctx.cm3_2ns); @@ -408,7 +398,7 @@ impl<'a, M: MerkleTree> StarkProof { &mut ctx.cm4_2ns, ); - log::info!("Merkelizing 4...."); + log::trace!("Merkelizing 4...."); let tree4 = merkelize::(&mut ctx, starkinfo, "cm4_2ns").unwrap(); log::trace!( "tree4 root: {}", @@ -460,7 +450,6 @@ impl<'a, M: MerkleTree> StarkProof { } }; let l = if ev.prime { &LpEv } else { &LEv }; - log::trace!("calculate acc: N={}", N); let acc = (0..N) .into_par_iter() .map(|k| { @@ -584,7 +573,7 @@ impl<'a, M: MerkleTree> StarkProof { ) -> T { ctx.tmp = vec![T::ZERO; seg.tmp_used]; let t = compile_code(ctx, starkinfo, &seg.first, "n", true); - log::trace!("calculate_exp_at_point compile_code ctx.first:\n{}", t); + //log::trace!("calculate_exp_at_point compile_code ctx.first:\n{}", t); // just let public codegen run multiple times //log::trace!("{} = {} @ {}", res, ctx.cm1_n[1 + 2 * idx], idx); @@ -792,18 +781,18 @@ pub fn calculate_exps( starkinfo: &StarkInfo, seg: &Segment, dom: &str, - step: &str, + //step: &str, N: usize, ) { ctx.tmp = vec![F::ZERO; seg.tmp_used]; let c_first = compile_code(ctx, starkinfo, &seg.first, dom, false); + /* log::trace!( "calculate_exps compile_code {} ctx.first:\n{}", step, c_first ); - /* let mut N = if dom == "n" { ctx.N } else { ctx.Next }; let _c_i = compile_code(ctx, starkinfo, &seg.i, dom, false); let _c_last = compile_code(ctx, starkinfo, &seg.last, dom, false); @@ -1090,7 +1079,7 @@ pub fn calculate_exps_parallel( *tmp = vec![F::ZERO; so.width * (cur_n + next)]; } } - calculate_exps(tmp_ctx, starkinfo, seg, dom, step, cur_n); + calculate_exps(tmp_ctx, starkinfo, seg, dom, cur_n); }); // write back the output @@ -1271,23 +1260,14 @@ pub mod tests { #[test] fn test_stark_plookup_gl() { - env_logger::try_init().unwrap_or_default(); - let mut pil = - load_json::("../../zkevm-prover/config/pil/zkevm/main.pil.json").unwrap(); + let mut pil = load_json::("data/plookup.pil.json.gl").unwrap(); let mut const_pol = PolsArray::new(&pil, PolKind::Constant); - const_pol - .load("../../zkevm-proverjs/build/proof/zkevm.const") - .unwrap(); + const_pol.load("data/plookup.const.gl").unwrap(); let mut cm_pol = PolsArray::new(&pil, PolKind::Commit); - cm_pol - .load("../../zkevm-proverjs/build/proof/zkevm.commit") - .unwrap(); - let stark_struct = - load_json::("../../zkevm-proverjs/testvectors/zkevm.starkstruct.json") - .unwrap(); + cm_pol.load("data/plookup.cm.gl").unwrap(); + let stark_struct = load_json::("data/starkStruct.json.gl").unwrap(); let mut setup = StarkSetup::::new(&const_pol, &mut pil, &stark_struct, None).unwrap(); - log::info!("stark_gen gen"); let starkproof = StarkProof::::stark_gen::( cm_pol, const_pol, diff --git a/starky/src/stark_setup.rs b/starky/src/stark_setup.rs index 306334ea..62844817 100644 --- a/starky/src/stark_setup.rs +++ b/starky/src/stark_setup.rs @@ -37,14 +37,12 @@ impl StarkSetup { let mut p: Vec> = vec![Vec::new(); const_pol.nPols]; for i in 0..const_pol.nPols { p[i] = vec![FGL::ZERO; const_pol.n]; - /* - for j in 0..const_pol.n { - p[i].push(const_pol.array[i][j]) - } - */ - p[i].par_iter_mut().enumerate().for_each(|(j, out)| { *out = const_pol.array[i][j]; }); + p[i].par_iter_mut().enumerate().for_each(|(j, out)| { + *out = const_pol.array[i][j]; + }); } + log::trace!("Write const pol buff and interpolate"); let const_buff = const_pol.write_buff(); //extend and merkelize let mut const_pols_array_e = vec![M::ExtendField::ZERO; (1 << nBitsExt) * pil.nConstants]; @@ -66,6 +64,7 @@ impl StarkSetup { }); let mut const_tree = M::new(); + log::trace!("Merkelize const tree"); const_tree.merkelize( const_pols_array_e_be, const_pol.nPols, diff --git a/starky/src/starkinfo_Z.rs b/starky/src/starkinfo_Z.rs index 2ef4c8b7..d28f01c4 100644 --- a/starky/src/starkinfo_Z.rs +++ b/starky/src/starkinfo_Z.rs @@ -159,7 +159,6 @@ impl StarkInfo { pil.nQ += 1; num_exp.keep = Some(true); pu_ctx.num_id = pil.expressions.len(); - log::trace!("num_exp: {} {}", i, num_exp); pil.expressions.push(num_exp); // G(\beta, \gamma) @@ -178,7 +177,6 @@ impl StarkInfo { pil.nQ += 1; pu_ctx.den_id = pil.expressions.len(); den_exp.keep = Some(true); - log::trace!("den_exp: {} {}", i, den_exp); pil.expressions.push(den_exp); let num = E::exp(pu_ctx.num_id, None); diff --git a/starky/src/starkinfo_map.rs b/starky/src/starkinfo_map.rs index c601f727..bb16106f 100644 --- a/starky/src/starkinfo_map.rs +++ b/starky/src/starkinfo_map.rs @@ -268,22 +268,15 @@ impl StarkInfo { f_2ns: Next, }; - log::trace!("fix_prover_code for public"); for i in 0..program.publics_code.len() { self.fix_prover_code(&mut program.publics_code[i], "n", pil, &mut tmpexps); } - log::trace!("fix_prover_code for step2prev"); self.fix_prover_code(&mut program.step2prev, "n", pil, &mut tmpexps); - log::trace!("fix_prover_code for step3prev"); self.fix_prover_code(&mut program.step3prev, "n", pil, &mut tmpexps); - log::trace!("fix_prover_code for step3"); self.fix_prover_code(&mut program.step3, "n", pil, &mut tmpexps); - log::trace!("fix_prover_code for step42"); self.fix_prover_code(&mut program.step42ns, "2ns", pil, &mut tmpexps); - log::trace!("fix_prover_code for step52"); self.fix_prover_code(&mut program.step52ns, "2ns", pil, &mut tmpexps); - log::trace!("fix_prover_code for verfier_query_code"); self.fix_prover_code(&mut program.verifier_query_code, "2ns", pil, &mut tmpexps); let fix_ref = |r: &mut Node, ctx: &mut ContextF, _pil: &mut PIL| { @@ -326,7 +319,6 @@ impl StarkInfo { } } - log::trace!("set code dim"); self.set_code_dimensions(&mut program.step2prev, 1); self.set_code_dimensions(&mut program.step3prev, 1); self.set_code_dimensions(&mut program.step3, 1); @@ -335,7 +327,6 @@ impl StarkInfo { self.set_code_dimensions(&mut program.verifier_code, 3); self.set_code_dimensions(&mut program.verifier_query_code, 1); - log::trace!("map done"); Ok(()) }