cleanup

Author: hero78119

ceno_cli/src/commands/common_args/ceno.rs

@@ -13,6 +13,7 @@ use ceno_zkvm::{
 use clap::Args;
 use ff_ext::{BabyBearExt4, ExtensionField, GoldilocksExt2};
 
+use ceno_emul::shards::Shards;
 use mpcs::{
     Basefold, BasefoldRSParams, PolynomialCommitmentScheme, SecurityLevel, Whir, WhirDefaultSpec,
 };
@@ -78,6 +79,14 @@ pub struct CenoOptions {
     #[arg(long)]
     pub out_vk: Option<PathBuf>,
 
+    /// shard id
+    #[arg(long, default_value = "0")]
+    shard_id: u32,
+
+    /// number of total shards.
+    #[arg(long, default_value = "1")]
+    max_num_shards: u32,
+
     /// Profiling granularity.
     /// Setting any value restricts logs to profiling information
     #[arg(long)]
@@ -337,6 +346,7 @@ fn run_elf_inner<
         std::fs::read(elf_path).context(format!("failed to read {}", elf_path.display()))?;
     let program = Program::load_elf(&elf_bytes, u32::MAX).context("failed to load elf")?;
     print_cargo_message("Loaded", format_args!("{}", elf_path.display()));
+    let shards = Shards::new(options.shard_id as usize, options.max_num_shards as usize);
 
     let public_io = options
         .read_public_io()
@@ -385,6 +395,7 @@ fn run_elf_inner<
         create_prover(backend.clone()),
         program,
         platform,
+        shards,
         &hints,
         &public_io,
         options.max_steps,

ceno_emul/src/tracer.rs

@@ -25,7 +25,7 @@ use crate::{
 /// - Any pair of `rs1 / rs2 / rd` **may be the same**. Then, one op will point to the other op in the same instruction but a different subcycle. The circuits may follow the operations **without special handling** of repeated registers.
 #[derive(Clone, Debug, Default, PartialEq, Eq)]
 pub struct StepRecord {
-    pub cycle: Cycle,
+    cycle: Cycle,
     pc: Change<ByteAddr>,
     pub insn: Instruction,
 

ceno_zkvm/src/e2e.rs

@@ -142,7 +142,7 @@ impl<'a> Default for ShardContext<'a> {
                     .map(|_| BTreeMap::new())
                     .collect::<Vec<_>>(),
             ),
-            cur_shard_cycle_range: 0..usize::MAX,
+            cur_shard_cycle_range: Tracer::SUBCYCLES_PER_INSN as usize..usize::MAX,
         }
     }
 }
@@ -161,12 +161,15 @@ impl<'a> ShardContext<'a> {
             "implement mechanism to skip current shard proof"
         );
 
+        let subcycle_per_insn = Tracer::SUBCYCLES_PER_INSN as usize;
         let max_threads = max_usable_threads();
         // let max_record_per_thread = max_insts.div_ceil(max_threads as u64);
         let expected_inst_per_shard = executed_instructions.div_ceil(max_num_shards) as usize;
-        let max_cycle = (executed_instructions + 1) * 4; // cycle start from 4
-        let cur_shard_cycle_range = (shard_id * expected_inst_per_shard * 4 + 4)
-            ..((shard_id + 1) * expected_inst_per_shard * 4 + 4).min(max_cycle);
+        let max_cycle = (executed_instructions + 1) * subcycle_per_insn; // cycle start from subcycle_per_insn
+        let cur_shard_cycle_range = (shard_id * expected_inst_per_shard * subcycle_per_insn
+            + subcycle_per_insn)
+            ..((shard_id + 1) * expected_inst_per_shard * subcycle_per_insn + subcycle_per_insn)
+                .min(max_cycle);
 
         ShardContext {
             shard_id,
@@ -248,15 +251,15 @@ impl<'a> ShardContext<'a> {
     #[inline(always)]
     pub fn aligned_prev_ts(&self, prev_cycle: Cycle) -> Cycle {
         let mut ts = prev_cycle.saturating_sub(self.cur_shard_cycle_range.start as Cycle);
-        if ts < 4 {
+        if ts < Tracer::SUBCYCLES_PER_INSN {
             ts = 0
         }
         ts
     }
 
     pub fn current_shard_offset_cycle(&self) -> Cycle {
-        // `-4` as cycle of each local shard start from 4
-        (self.cur_shard_cycle_range.start as Cycle) - 4
+        // cycle of each local shard start from Tracer::SUBCYCLES_PER_INSN
+        (self.cur_shard_cycle_range.start as Cycle) - Tracer::SUBCYCLES_PER_INSN
     }
 
     #[inline(always)]
@@ -383,8 +386,6 @@ pub fn emulate_program<'a>(
         vm.get_pc().into(),
         end_cycle,
         shards.shard_id as u32,
-        !shards.is_first_shard(), // first shard disable global read
-        !shards.is_last_shard(),  // last shard disable global write
         io_init.iter().map(|rec| rec.value).collect_vec(),
     );
 

ceno_zkvm/src/scheme.rs

@@ -73,8 +73,6 @@ pub struct PublicValues {
     end_pc: u32,
     end_cycle: u64,
     shard_id: u32,
-    mem_bus_with_read: bool,
-    mem_bus_with_write: bool,
     public_io: Vec<u32>,
 }
 
@@ -86,8 +84,6 @@ impl PublicValues {
         end_pc: u32,
         end_cycle: u64,
         shard_id: u32,
-        mem_bus_with_read: bool,
-        mem_bus_with_write: bool,
         public_io: Vec<u32>,
     ) -> Self {
         Self {
@@ -97,8 +93,6 @@ impl PublicValues {
             end_pc,
             end_cycle,
             shard_id,
-            mem_bus_with_read,
-            mem_bus_with_write,
             public_io,
         }
     }
@@ -113,8 +107,6 @@ impl PublicValues {
             vec![E::BaseField::from_canonical_u32(self.end_pc)],
             vec![E::BaseField::from_canonical_u64(self.end_cycle)],
             vec![E::BaseField::from_canonical_u32(self.shard_id)],
-            vec![E::BaseField::from_bool(self.mem_bus_with_read)],
-            vec![E::BaseField::from_bool(self.mem_bus_with_write)],
         ]
         .into_iter()
         .chain(

ceno_zkvm/src/scheme/tests.rs

@@ -370,7 +370,7 @@ fn test_single_add_instance_e2e() {
         .assign_table_circuit::<ProgramTableCircuit<E>>(&zkvm_cs, &prog_config, &program)
         .unwrap();
 
-    let pi = PublicValues::new(0, 0, 0, 0, 0, vec![0]);
+    let pi = PublicValues::new(0, 0, 0, 0, 0, 0, vec![0]);
     let transcript = BasicTranscript::new(b"riscv");
     let zkvm_proof = prover
         .create_proof(zkvm_witness, pi, transcript)