From 8f3bd8ed95de3d1eacd4b569149ab0395d45e5e0 Mon Sep 17 00:00:00 2001 From: eigmax Date: Mon, 20 Nov 2023 00:28:43 +0800 Subject: [PATCH 1/5] chore: fix bootstrap --- src/cpu/bootstrap_kernel.rs | 6 +++--- src/cpu/cpu_stark.rs | 38 ++++++++++++++++++++++++++++++++++++- src/cross_table_lookup.rs | 4 ---- src/witness/transition.rs | 6 +++++- 4 files changed, 45 insertions(+), 9 deletions(-) diff --git a/src/cpu/bootstrap_kernel.rs b/src/cpu/bootstrap_kernel.rs index 71450c13..8cf7f6d8 100644 --- a/src/cpu/bootstrap_kernel.rs +++ b/src/cpu/bootstrap_kernel.rs @@ -20,7 +20,7 @@ pub(crate) fn generate_bootstrap_kernel(state: &mut GenerationState // Iterate through chunks of the code, such that we can write one chunk to memory per row. for chunk in &KERNEL.program.image.iter().chunks(NUM_GP_CHANNELS) { let mut cpu_row = CpuColumnsView::default(); - println!("trace: {:?}", state.traces.clock()); + log::debug!("trace: {:?}", state.traces.clock()); cpu_row.clock = F::from_canonical_usize(state.traces.clock()); cpu_row.is_bootstrap_kernel = F::ONE; @@ -28,7 +28,7 @@ pub(crate) fn generate_bootstrap_kernel(state: &mut GenerationState for (channel, (addr, val)) in chunk.enumerate() { // FIXMEBoth instruction and memory data are located in // code section for MIPS - println!("addr: {}", *addr); + log::debug!("addr: {}", *addr); let address = MemoryAddress::new(0, Segment::Code, *addr as usize); let write = mem_write_gp_log_and_fill(channel, address, state, &mut cpu_row, (*val).to_be()); @@ -91,7 +91,7 @@ pub(crate) fn eval_bootstrap_kernel_packed> yield_constr.constraint(filter * (channel.addr_segment - code_segment)); /* FIXME let delta_virt = channel.addr_virtual + P::from(F::from_canonical_u32(32)) - next_values.mem_channels[i].addr_virtual; - println!("virt {:?} {:?} {:?} {:?} {}", channel.addr_virtual, delta_virt, local_values.clock, NUM_GP_CHANNELS, i); + log::debug!("virt {:?} {:?} {:?} {:?} {}", channel.addr_virtual, delta_virt, local_values.clock, NUM_GP_CHANNELS, i); yield_constr.constraint_transition(filter * delta_virt); */ } diff --git a/src/cpu/cpu_stark.rs b/src/cpu/cpu_stark.rs index 6e7eadfd..8489896c 100644 --- a/src/cpu/cpu_stark.rs +++ b/src/cpu/cpu_stark.rs @@ -253,10 +253,19 @@ impl, const D: usize> Stark for CpuStark Result<()> { @@ -284,4 +293,31 @@ mod tests { }; test_stark_circuit_constraints::(stark) } + + #[test] + fn test_stark_check_memio() { + env_logger::try_init().unwrap_or_default(); + const D: usize = 2; + type C = PoseidonGoldilocksConfig; + type F = >::F; + type S = CpuStark; + + let stark = S { + f: Default::default(), + }; + + let inputs = GenerationInputs {}; + let mut state = GenerationState::::new(inputs.clone(), &KERNEL.code, 4).unwrap(); + generate_bootstrap_kernel::(&mut state); + + let vals: Vec<[F; NUM_CPU_COLUMNS]> = state + .traces + .cpu + .into_iter() + .map(|x| x.into()) + .collect::>(); + for i in 0..(vals.len() - 1) { + test_stark_check_constraints::(stark, &vals[i], &vals[i + 1]); + } + } } diff --git a/src/cross_table_lookup.rs b/src/cross_table_lookup.rs index d8d2498e..b093b0d8 100644 --- a/src/cross_table_lookup.rs +++ b/src/cross_table_lookup.rs @@ -277,10 +277,6 @@ impl CrossTableLookup { looking_tables: Vec>, looked_table: TableWithColumns, ) -> Self { - looking_tables - .iter() - .for_each(|e| println!("looking: {}, columns: {:?}", e.columns.len(), e)); - println!("looked:{} {:?}", looked_table.columns.len(), looked_table); assert!(looking_tables .iter() .all(|twc| twc.columns.len() == looked_table.columns.len())); diff --git a/src/witness/transition.rs b/src/witness/transition.rs index dba74823..83a9c2ae 100644 --- a/src/witness/transition.rs +++ b/src/witness/transition.rs @@ -44,7 +44,11 @@ fn decode(registers: RegistersState, insn: u32) -> Result Date: Mon, 20 Nov 2023 08:17:15 +0800 Subject: [PATCH 2/5] chore: fix memio --- src/cpu/cpu_stark.rs | 16 +++++++--------- src/stark_testing.rs | 42 ++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 49 insertions(+), 9 deletions(-) diff --git a/src/cpu/cpu_stark.rs b/src/cpu/cpu_stark.rs index 8489896c..5de5b29a 100644 --- a/src/cpu/cpu_stark.rs +++ b/src/cpu/cpu_stark.rs @@ -191,22 +191,20 @@ impl, const D: usize> Stark for CpuStark = next_values.borrow(); - bootstrap_kernel::eval_bootstrap_kernel_packed(local_values, next_values, yield_constr); /* + bootstrap_kernel::eval_bootstrap_kernel_packed(local_values, next_values, yield_constr); contextops::eval_packed(local_values, next_values, yield_constr); control_flow::eval_packed_generic(local_values, next_values, yield_constr); */ decode::eval_packed_generic(local_values, yield_constr); jumps::eval_packed(local_values, next_values, yield_constr); membus::eval_packed(local_values, yield_constr); - //memio::eval_packed(local_values, next_values, yield_constr); + memio::eval_packed(local_values, next_values, yield_constr); pc::eval_packed(local_values, next_values, yield_constr); - /* shift::eval_packed(local_values, yield_constr); syscall::eval_packed(local_values, yield_constr); mov::eval_packed(local_values, yield_constr); count::eval_packed(local_values, yield_constr); - */ } fn eval_ext_circuit( @@ -222,27 +220,25 @@ impl, const D: usize> Stark for CpuStark> = next_values.borrow(); + /* bootstrap_kernel::eval_bootstrap_kernel_ext_circuit( builder, local_values, next_values, yield_constr, ); - /* contextops::eval_ext_circuit(builder, local_values, next_values, yield_constr); control_flow::eval_ext_circuit(builder, local_values, next_values, yield_constr); */ decode::eval_ext_circuit(builder, local_values, yield_constr); jumps::eval_ext_circuit(builder, local_values, next_values, yield_constr); membus::eval_ext_circuit(builder, local_values, yield_constr); - //memio::eval_ext_circuit(builder, local_values, next_values, yield_constr); + memio::eval_ext_circuit(builder, local_values, next_values, yield_constr); pc::eval_ext_circuit(builder, local_values, next_values, yield_constr); - /* shift::eval_ext_circuit(builder, local_values, yield_constr); syscall::eval_ext_circuit(builder, local_values, yield_constr); mov::eval_ext_circuit(builder, local_values, yield_constr); count::eval_ext_circuit(builder, local_values, yield_constr); - */ } fn constraint_degree(&self) -> usize { @@ -265,6 +261,7 @@ mod tests { use crate::generation::GenerationInputs; use crate::stark_testing::{ test_stark_check_constraints, test_stark_circuit_constraints, test_stark_low_degree, + test_stark_cpu_check_constraints, }; #[test] @@ -317,7 +314,8 @@ mod tests { .map(|x| x.into()) .collect::>(); for i in 0..(vals.len() - 1) { - test_stark_check_constraints::(stark, &vals[i], &vals[i + 1]); + println!("vals: {:?}", vals[i]); + test_stark_cpu_check_constraints::(stark, &vals[i], &vals[i + 1]); } } } diff --git a/src/stark_testing.rs b/src/stark_testing.rs index 57f27428..9e47c57b 100644 --- a/src/stark_testing.rs +++ b/src/stark_testing.rs @@ -193,3 +193,45 @@ pub fn test_stark_check_constraints< assert_eq!(acc, F::Extension::ZERO); } } + +pub fn test_stark_cpu_check_constraints< + F: RichField + Extendable, + C: GenericConfig, + S: Stark, + const D: usize, +>( + stark: S, + lv: &[C::F], + nv: &[C::F], +) { + // Compute native constraint evaluation on random values. + let vars = S::EvaluationFrame::from_values( + &lv.iter() + .copied() + .map(F::Extension::from_basefield) + .collect::>()[..], + &nv.iter() + .copied() + .map(F::Extension::from_basefield) + .collect::>()[..], + ); + + let alphas = F::rand_vec(1); + let z_last = F::Extension::rand(); + let lagrange_first = F::Extension::rand(); + let lagrange_last = F::Extension::rand(); + let mut consumer = ConstraintConsumer::::new( + alphas + .iter() + .copied() + .map(F::Extension::from_basefield) + .collect(), + z_last, + lagrange_first, + lagrange_last, + ); + stark.eval_packed_generic(&vars, &mut consumer); + for &acc in &consumer.constraint_accs { + assert_eq!(acc, F::Extension::ZERO); + } +} From 1a534f63fe8e0748af19cc311a6a3a363b08edf1 Mon Sep 17 00:00:00 2001 From: eigmax Date: Mon, 20 Nov 2023 18:11:10 +0800 Subject: [PATCH 3/5] fix: logic --- src/cpu/bootstrap_kernel.rs | 2 -- src/cpu/cpu_stark.rs | 10 +++++----- src/stark_testing.rs | 2 +- 3 files changed, 6 insertions(+), 8 deletions(-) diff --git a/src/cpu/bootstrap_kernel.rs b/src/cpu/bootstrap_kernel.rs index 8cf7f6d8..463f2974 100644 --- a/src/cpu/bootstrap_kernel.rs +++ b/src/cpu/bootstrap_kernel.rs @@ -20,7 +20,6 @@ pub(crate) fn generate_bootstrap_kernel(state: &mut GenerationState // Iterate through chunks of the code, such that we can write one chunk to memory per row. for chunk in &KERNEL.program.image.iter().chunks(NUM_GP_CHANNELS) { let mut cpu_row = CpuColumnsView::default(); - log::debug!("trace: {:?}", state.traces.clock()); cpu_row.clock = F::from_canonical_usize(state.traces.clock()); cpu_row.is_bootstrap_kernel = F::ONE; @@ -28,7 +27,6 @@ pub(crate) fn generate_bootstrap_kernel(state: &mut GenerationState for (channel, (addr, val)) in chunk.enumerate() { // FIXMEBoth instruction and memory data are located in // code section for MIPS - log::debug!("addr: {}", *addr); let address = MemoryAddress::new(0, Segment::Code, *addr as usize); let write = mem_write_gp_log_and_fill(channel, address, state, &mut cpu_row, (*val).to_be()); diff --git a/src/cpu/cpu_stark.rs b/src/cpu/cpu_stark.rs index 5de5b29a..b2a7f8eb 100644 --- a/src/cpu/cpu_stark.rs +++ b/src/cpu/cpu_stark.rs @@ -191,8 +191,8 @@ impl, const D: usize> Stark for CpuStark = next_values.borrow(); - /* bootstrap_kernel::eval_bootstrap_kernel_packed(local_values, next_values, yield_constr); + /* contextops::eval_packed(local_values, next_values, yield_constr); control_flow::eval_packed_generic(local_values, next_values, yield_constr); */ @@ -220,13 +220,13 @@ impl, const D: usize> Stark for CpuStark> = next_values.borrow(); - /* bootstrap_kernel::eval_bootstrap_kernel_ext_circuit( builder, local_values, next_values, yield_constr, ); + /* contextops::eval_ext_circuit(builder, local_values, next_values, yield_constr); control_flow::eval_ext_circuit(builder, local_values, next_values, yield_constr); */ @@ -256,7 +256,6 @@ mod tests { use crate::cpu::columns::{COL_MAP, NUM_CPU_COLUMNS}; use crate::cpu::cpu_stark::CpuStark; use crate::cpu::kernel::KERNEL; - use crate::generation::generate_traces; use crate::generation::state::GenerationState; use crate::generation::GenerationInputs; use crate::stark_testing::{ @@ -304,7 +303,7 @@ mod tests { }; let inputs = GenerationInputs {}; - let mut state = GenerationState::::new(inputs.clone(), &KERNEL.code, 4).unwrap(); + let mut state = GenerationState::::new(inputs.clone(), &KERNEL.code, 40000000).unwrap(); generate_bootstrap_kernel::(&mut state); let vals: Vec<[F; NUM_CPU_COLUMNS]> = state @@ -313,8 +312,9 @@ mod tests { .into_iter() .map(|x| x.into()) .collect::>(); + for i in 0..(vals.len() - 1) { - println!("vals: {:?}", vals[i]); + println!("val: {:?}", vals[i]); test_stark_cpu_check_constraints::(stark, &vals[i], &vals[i + 1]); } } diff --git a/src/stark_testing.rs b/src/stark_testing.rs index 9e47c57b..d02b89ea 100644 --- a/src/stark_testing.rs +++ b/src/stark_testing.rs @@ -219,7 +219,7 @@ pub fn test_stark_cpu_check_constraints< let alphas = F::rand_vec(1); let z_last = F::Extension::rand(); let lagrange_first = F::Extension::rand(); - let lagrange_last = F::Extension::rand(); + let lagrange_last = F::Extension::ZERO; let mut consumer = ConstraintConsumer::::new( alphas .iter() From 99f959a6296ac1dc26852054a14b475822cf7a25 Mon Sep 17 00:00:00 2001 From: eigmax Date: Mon, 20 Nov 2023 23:59:38 +0800 Subject: [PATCH 4/5] chore: add sample --- src/arithmetic/mod.rs | 2 +- src/cpu/cpu_stark.rs | 9 ++++++--- src/generation/mod.rs | 2 +- src/generation/state.rs | 1 + src/logic.rs | 2 +- src/witness/traces.rs | 2 +- 6 files changed, 11 insertions(+), 7 deletions(-) diff --git a/src/arithmetic/mod.rs b/src/arithmetic/mod.rs index 8bc01334..06f60df2 100644 --- a/src/arithmetic/mod.rs +++ b/src/arithmetic/mod.rs @@ -152,7 +152,7 @@ impl BinaryOperator { } /// An enum representing arithmetic operations that can be either binary. -#[derive(Debug)] +#[derive(Debug, Clone)] pub(crate) enum Operation { BinaryOperation { operator: BinaryOperator, diff --git a/src/cpu/cpu_stark.rs b/src/cpu/cpu_stark.rs index b2a7f8eb..881aef45 100644 --- a/src/cpu/cpu_stark.rs +++ b/src/cpu/cpu_stark.rs @@ -256,11 +256,12 @@ mod tests { use crate::cpu::columns::{COL_MAP, NUM_CPU_COLUMNS}; use crate::cpu::cpu_stark::CpuStark; use crate::cpu::kernel::KERNEL; + use crate::generation::simulate_cpu; use crate::generation::state::GenerationState; use crate::generation::GenerationInputs; use crate::stark_testing::{ - test_stark_check_constraints, test_stark_circuit_constraints, test_stark_low_degree, - test_stark_cpu_check_constraints, + test_stark_check_constraints, test_stark_circuit_constraints, + test_stark_cpu_check_constraints, test_stark_low_degree, }; #[test] @@ -305,8 +306,10 @@ mod tests { let inputs = GenerationInputs {}; let mut state = GenerationState::::new(inputs.clone(), &KERNEL.code, 40000000).unwrap(); generate_bootstrap_kernel::(&mut state); + simulate_cpu::(&mut state).unwrap(); let vals: Vec<[F; NUM_CPU_COLUMNS]> = state + .clone() .traces .cpu .into_iter() @@ -314,7 +317,7 @@ mod tests { .collect::>(); for i in 0..(vals.len() - 1) { - println!("val: {:?}", vals[i]); + println!("vals: {:?}, cpu column: {:?}", vals[i], state.traces.cpu[i]); test_stark_cpu_check_constraints::(stark, &vals[i], &vals[i + 1]); } } diff --git a/src/generation/mod.rs b/src/generation/mod.rs index be0c08e5..9a881865 100644 --- a/src/generation/mod.rs +++ b/src/generation/mod.rs @@ -71,7 +71,7 @@ pub fn generate_traces, const D: usize>( } /// Perform MIPS instruction and transit state -fn simulate_cpu, const D: usize>( +pub(crate) fn simulate_cpu, const D: usize>( state: &mut GenerationState, ) -> anyhow::Result<()> { let mut step = 0; diff --git a/src/generation/state.rs b/src/generation/state.rs index d8cfbd63..b93404b0 100644 --- a/src/generation/state.rs +++ b/src/generation/state.rs @@ -15,6 +15,7 @@ pub(crate) struct GenerationStateCheckpoint { pub(crate) traces: TraceCheckpoint, } +#[derive(Clone)] pub(crate) struct GenerationState { pub(crate) inputs: GenerationInputs, pub(crate) registers: RegistersState, diff --git a/src/logic.rs b/src/logic.rs index bc52d643..865a77f0 100644 --- a/src/logic.rs +++ b/src/logic.rs @@ -113,7 +113,7 @@ impl Op { } } -#[derive(Debug)] +#[derive(Debug, Clone)] pub(crate) struct Operation { operator: Op, input0: u32, diff --git a/src/witness/traces.rs b/src/witness/traces.rs index 8d979fbb..4cb6fbb8 100644 --- a/src/witness/traces.rs +++ b/src/witness/traces.rs @@ -29,7 +29,7 @@ pub struct TraceCheckpoint { pub(self) memory_len: usize, } -#[derive(Debug)] +#[derive(Debug, Clone)] pub(crate) struct Traces { pub(crate) arithmetic_ops: Vec, // pub(crate) byte_packing_ops: Vec, From 9105ec73b7b3cfd41e4e8056f16e37a2f6745662 Mon Sep 17 00:00:00 2001 From: eigmax Date: Tue, 21 Nov 2023 00:04:46 +0800 Subject: [PATCH 5/5] chore: add sample --- src/cpu/cpu_stark.rs | 4 ++-- src/stark_testing.rs | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/src/cpu/cpu_stark.rs b/src/cpu/cpu_stark.rs index 881aef45..10990fb5 100644 --- a/src/cpu/cpu_stark.rs +++ b/src/cpu/cpu_stark.rs @@ -191,8 +191,8 @@ impl, const D: usize> Stark for CpuStark = next_values.borrow(); - bootstrap_kernel::eval_bootstrap_kernel_packed(local_values, next_values, yield_constr); /* + bootstrap_kernel::eval_bootstrap_kernel_packed(local_values, next_values, yield_constr); contextops::eval_packed(local_values, next_values, yield_constr); control_flow::eval_packed_generic(local_values, next_values, yield_constr); */ @@ -220,13 +220,13 @@ impl, const D: usize> Stark for CpuStark> = next_values.borrow(); + /* bootstrap_kernel::eval_bootstrap_kernel_ext_circuit( builder, local_values, next_values, yield_constr, ); - /* contextops::eval_ext_circuit(builder, local_values, next_values, yield_constr); control_flow::eval_ext_circuit(builder, local_values, next_values, yield_constr); */ diff --git a/src/stark_testing.rs b/src/stark_testing.rs index d02b89ea..9e47c57b 100644 --- a/src/stark_testing.rs +++ b/src/stark_testing.rs @@ -219,7 +219,7 @@ pub fn test_stark_cpu_check_constraints< let alphas = F::rand_vec(1); let z_last = F::Extension::rand(); let lagrange_first = F::Extension::rand(); - let lagrange_last = F::Extension::ZERO; + let lagrange_last = F::Extension::rand(); let mut consumer = ConstraintConsumer::::new( alphas .iter()