Skip to content

Commit

Permalink
chore: recover UT
Browse files Browse the repository at this point in the history
  • Loading branch information
@eigmax
eigmax committed Dec 27, 2023
1 parent 32e14f8 commit f6fac86
Show file tree
Hide file tree
Showing 7 changed files with 25 additions and 61 deletions.
2 changes: 1 addition & 1 deletion starky/src/interpreter.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -407,7 +407,7 @@ fn get_ref<F: FieldExtension>(
next: usize,
modulas: usize,
) -> Expr<F> {
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,
Expand Down
8 changes: 0 additions & 8 deletions starky/src/polsarray.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -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
}
}
Expand Down
6 changes: 5 additions & 1 deletion starky/src/prove.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -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::<StarkStruct>(stark_struct)?;
match stark_struct.verificationHashType.as_str() {
Expand Down
48 changes: 14 additions & 34 deletions starky/src/stark_gen.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -210,34 +210,24 @@ impl<'a, M: MerkleTree> StarkProof<M> {

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
Expand All @@ -257,7 +247,7 @@ impl<'a, M: MerkleTree> StarkProof<M> {

ctx.Zi = build_Zh_Inv::<M::ExtendField>(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);
Expand Down Expand Up @@ -290,7 +280,7 @@ impl<'a, M: MerkleTree> StarkProof<M> {

//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::<M>(&mut ctx, starkinfo, "cm1_n", &mut result)?;
tree1.to_extend(&mut ctx.cm1_2ns);

Expand Down Expand Up @@ -319,7 +309,7 @@ impl<'a, M: MerkleTree> StarkProof<M> {
n_cm += 1;
}

log::info!("Merkelizing 2....");
log::trace!("Merkelizing 2....");
let tree2 = extend_and_merkelize::<M>(&mut ctx, starkinfo, "cm2_n", &mut result)?;
tree2.to_extend(&mut ctx.cm2_2ns);
transcript.put(&[tree2.root().as_elements().to_vec()])?;
Expand Down Expand Up @@ -365,7 +355,7 @@ impl<'a, M: MerkleTree> StarkProof<M> {

calculate_exps_parallel(&mut ctx, starkinfo, &program.step3, "n", "step3");

log::info!("Merkelizing 3....");
log::trace!("Merkelizing 3....");

let tree3 = extend_and_merkelize::<M>(&mut ctx, starkinfo, "cm3_n", &mut result)?;
tree3.to_extend(&mut ctx.cm3_2ns);
Expand Down Expand Up @@ -408,7 +398,7 @@ impl<'a, M: MerkleTree> StarkProof<M> {
&mut ctx.cm4_2ns,
);

log::info!("Merkelizing 4....");
log::trace!("Merkelizing 4....");
let tree4 = merkelize::<M>(&mut ctx, starkinfo, "cm4_2ns").unwrap();
log::trace!(
"tree4 root: {}",
Expand Down Expand Up @@ -460,7 +450,6 @@ impl<'a, M: MerkleTree> StarkProof<M> {
}
};
let l = if ev.prime { &LpEv } else { &LEv };
log::trace!("calculate acc: N={}", N);
let acc = (0..N)
.into_par_iter()
.map(|k| {
Expand Down Expand Up @@ -584,7 +573,7 @@ impl<'a, M: MerkleTree> StarkProof<M> {
) -> 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);
Expand Down Expand Up @@ -792,18 +781,18 @@ pub fn calculate_exps<F: FieldExtension>(
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);
Expand Down Expand Up @@ -1090,7 +1079,7 @@ pub fn calculate_exps_parallel<F: FieldExtension>(
*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
Expand Down Expand Up @@ -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::<PIL>("../../zkevm-prover/config/pil/zkevm/main.pil.json").unwrap();
let mut pil = load_json::<PIL>("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::<StarkStruct>("../../zkevm-proverjs/testvectors/zkevm.starkstruct.json")
.unwrap();
cm_pol.load("data/plookup.cm.gl").unwrap();
let stark_struct = load_json::<StarkStruct>("data/starkStruct.json.gl").unwrap();
let mut setup =
StarkSetup::<MerkleTreeGL>::new(&const_pol, &mut pil, &stark_struct, None).unwrap();
log::info!("stark_gen gen");
let starkproof = StarkProof::<MerkleTreeGL>::stark_gen::<TranscriptGL>(
cm_pol,
const_pol,
Expand Down
11 changes: 5 additions & 6 deletions starky/src/stark_setup.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -37,14 +37,12 @@ impl<M: MerkleTree> StarkSetup<M> {
let mut p: Vec<Vec<FGL>> = 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];
Expand All @@ -66,6 +64,7 @@ impl<M: MerkleTree> StarkSetup<M> {
});

let mut const_tree = M::new();
log::trace!("Merkelize const tree");
const_tree.merkelize(
const_pols_array_e_be,
const_pol.nPols,
Expand Down
2 changes: 0 additions & 2 deletions starky/src/starkinfo_Z.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -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)
Expand All @@ -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);
Expand Down
9 changes: 0 additions & 9 deletions starky/src/starkinfo_map.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -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| {
Expand Down Expand Up @@ -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);
Expand All @@ -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(())
}

Expand Down

0 comments on commit f6fac86

Please sign in to comment.