Zisk New Arch

Cargo.toml

@@ -1,18 +1,18 @@
 [workspace]
 members = [
-    "cli",
+    "cli", "common",
     "core",
-    "emulator",
+    "emulator", "executor",
     "pil",
     "riscv",
     "rom-merkle",
     "state-machines/arith",
     "state-machines/binary",
     "state-machines/common",
-    "state-machines/freq-ops",
     "state-machines/main",
     "state-machines/mem",
     "state-machines/rom",
+    "state-machines/std",
     "witness-computation",
     "ziskos/entrypoint",
 ]
@@ -26,19 +26,17 @@ opt-level = 3
 opt-level = 3
 
 [workspace.dependencies]
-proofman-common = { git = "https://github.com/0xPolygonHermez/pil2-proofman.git", rev = "0.0.10" }
-proofman-macros = { git = "https://github.com/0xPolygonHermez/pil2-proofman.git", rev = "0.0.10" }
-proofman-util = { git = "https://github.com/0xPolygonHermez/pil2-proofman.git", rev = "0.0.10" }
-proofman = { git = "https://github.com/0xPolygonHermez/pil2-proofman.git", rev = "0.0.10" }
-pil-std-lib = { git = "https://github.com/0xPolygonHermez/pil2-proofman.git", rev = "0.0.10" }
-stark = { git = "https://github.com/0xPolygonHermez/pil2-proofman.git", rev = "0.0.10" }
+proofman-common = { git = "https://github.com/0xPolygonHermez/pil2-proofman.git", branch = "feature/minor_clean" }
+proofman-macros = { git = "https://github.com/0xPolygonHermez/pil2-proofman.git", branch = "feature/minor_clean" }
+proofman-util = { git = "https://github.com/0xPolygonHermez/pil2-proofman.git", branch = "feature/minor_clean" }
+pil-std-lib = { git = "https://github.com/0xPolygonHermez/pil2-proofman.git", branch = "feature/minor_clean" }
+witness = { git = "https://github.com/0xPolygonHermez/pil2-proofman.git", branch = "feature/minor_clean" }
 # Local development
 # proofman-common = { path = "../pil2-proofman/common" }
 # proofman-macros = { path = "../pil2-proofman/macros" }
 # proofman-util = { path = "../pil2-proofman/util" }
-# proofman = { path = "../pil2-proofman/proofman" }
 # pil-std-lib = { path = "../pil2-proofman/pil2-components/lib/std/rs" }
-# stark = { path = "../pil2-proofman/provers/stark" }
+# witness = { path = "../pil2-proofman/witness" }
 
 p3-field = { git = "https://github.com/Plonky3/Plonky3.git", rev = "c3d754ef77b9fce585b46b972af751fe6e7a9803" }
 log = "0.4"

book/getting_started/quickstart_dev.md

@@ -127,7 +127,7 @@ Run this whenever the `.pilout` file changes:
 ### Generate Setup Data
 Run this whenever the `.pilout` file changes:
 
-```bash
+```bash[]
 node --max-old-space-size=65536 ../pil2-proofman-js/src/main_setup.js -a pil/zisk.pilout -b build -t ../pil2-proofman/pil2-stark/build/bctree
 ```
 

common/Cargo.toml

@@ -0,0 +1,7 @@
+[package]
+name = "zisk-common"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+zisk-core = { path = "../core" }

common/src/inst_observer.rs

@@ -0,0 +1,5 @@
+use zisk_core::{InstContext, ZiskInst};
+
+pub trait InstObserver {
+    fn on_instruction(&mut self, inst: &ZiskInst, inst_ctx: &InstContext) -> bool;
+}

common/src/lib.rs

@@ -0,0 +1,3 @@
+mod inst_observer;
+
+pub use inst_observer::*;

core/src/inst_context.rs

@@ -34,6 +34,7 @@ pub struct InstContext {
 
     /// End flag, set to true only by the last instruction to execute
     pub end: bool,
+    pub regs: [u64; 32],
 }
 
 /// RisK instruction context implementation
@@ -50,6 +51,7 @@ impl InstContext {
             pc: ROM_ENTRY,
             step: 0,
             end: false,
+            regs: [0; 32],
         }
     }
 

core/src/mem.rs

@@ -79,6 +79,8 @@
 //! * The third RW memory region going from `AVAILABLE_MEM_ADDR` onwards can be used during the
 //!   program execution a general purpose memory.
 
+use crate::{REG_FIRST, REG_LAST};
+
 /// Fist input data memory address
 pub const INPUT_ADDR: u64 = 0x90000000;
 /// Maximum size of the input data
@@ -203,7 +205,9 @@ impl Mem {
     /// address and width
     #[inline(always)]
     pub fn read(&self, addr: u64, width: u64) -> u64 {
-        // First try to read from the write section
+        debug_assert!(!Mem::address_is_register(addr));
+
+        // First try to read in the write section
         if (addr >= self.write_section.start) && (addr <= (self.write_section.end - width)) {
             // Calculate the read position
             let read_position: usize = (addr - self.write_section.start) as usize;
@@ -265,6 +269,8 @@ impl Mem {
     /// Write a u64 value to the memory write section, based on the provided address and width
     #[inline(always)]
     pub fn write(&mut self, addr: u64, val: u64, width: u64) {
+        debug_assert!(!Mem::address_is_register(addr));
+
         // Call write_silent to perform the real work
         self.write_silent(addr, val, width);
 
@@ -277,6 +283,8 @@ impl Mem {
     /// Write a u64 value to the memory write section, based on the provided address and width
     #[inline(always)]
     pub fn write_silent(&mut self, addr: u64, val: u64, width: u64) {
+        debug_assert!(!Mem::address_is_register(addr));
+
         //println!("Mem::write() addr={:x}={} width={} value={:x}={}", addr, addr, width, val,
         // val);
 
@@ -306,4 +314,15 @@ impl Mem {
             _ => panic!("Mem::write_silent() invalid width={}", width),
         }
     }
+
+    #[inline(always)]
+    pub fn address_is_register(address: u64) -> bool {
+        ((address & 0x7) == 0) && (REG_FIRST..=REG_LAST).contains(&address)
+    }
+
+    #[inline(always)]
+    pub fn address_to_register_index(address: u64) -> usize {
+        debug_assert!(Mem::address_is_register(address));
+        ((address - REG_FIRST) >> 3) as usize
+    }
 }

core/src/zisk_inst.rs

@@ -61,7 +61,7 @@ pub const STORE_IND: u64 = 2;
 /// Internal operations are proven as part of the main state machine itself, given their
 /// simplicity. External operations (rest of types) are proven in their corresponding secondary
 /// state machine.
-#[derive(Clone, Copy, Debug, PartialEq, PartialOrd)]
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd)]
 #[repr(u32)]
 pub enum ZiskOperationType {
     None,
@@ -73,11 +73,9 @@ pub enum ZiskOperationType {
     PubOut,
 }
 
-/// Defines the length of the enumerated ZiskOperationType, required to build some structures to
-/// store data splitted by operation type.
-pub const ZISK_OPERATION_TYPE_VARIANTS: usize = 7;
+pub const ZISK_OP_TYPE_COUNT: usize = 7;
 
-/// Zisk instruction structure.   
+/// ZisK instruction definition
 ///
 /// ZisK instructions are defined as a binary operation with 2 results: op(a, b) -> (c, flag)
 /// a, b and c are u64 registers; flag is a boolean.  
@@ -157,7 +155,7 @@ impl ZiskInst {
     pub fn to_text(&self) -> String {
         let mut s = String::new();
         if self.paddr != 0 {
-            s += &(" paddr=".to_string() + &self.paddr.to_string());
+            s += &format!(" paddr=0x{:x}", self.paddr);
         }
         if self.store_ra {
             s += &(" store_ra=".to_string() + &self.store_ra.to_string());
@@ -169,7 +167,7 @@ impl ZiskInst {
             s += &format!(" store={}={}", self.store, store_to_str(self.store));
         }
         if self.store_offset != 0 {
-            s += &(" store_offset=".to_string() + &self.store_offset.to_string());
+            s += &format!(" store_offset=0x{:x}", self.store_offset);
         }
         if self.set_pc {
             s += &(" set_pc=".to_string() + &self.set_pc.to_string());
@@ -192,19 +190,19 @@ impl ZiskInst {
             s += &format!(" a_src={}={}", self.a_src, source_to_str(self.a_src));
         }
         if self.a_use_sp_imm1 != 0 {
-            s += &(" a_use_sp_imm1=".to_string() + &self.a_use_sp_imm1.to_string());
+            s += &format!(" a_use_sp_imm1=0x{:x}", self.a_use_sp_imm1);
         }
         if self.a_offset_imm0 != 0 {
-            s += &(" a_offset_imm0=".to_string() + &self.a_offset_imm0.to_string());
+            s += &format!(" a_offset_imm0=0x{:x}", self.a_offset_imm0);
         }
         if self.b_src != 0 {
             s += &format!(" b_src={}={}", self.b_src, source_to_str(self.b_src));
         }
         if self.b_use_sp_imm1 != 0 {
-            s += &(" b_use_sp_imm1=".to_string() + &self.b_use_sp_imm1.to_string());
+            s += &format!(" b_use_sp_imm1=0x{:x}", self.b_use_sp_imm1);
         }
         if self.b_offset_imm0 != 0 {
-            s += &(" b_offset_imm0=".to_string() + &self.b_offset_imm0.to_string());
+            s += &format!(" b_offset_imm0=0x{:x}", self.b_offset_imm0);
         }
         if self.jmp_offset1 != 0 {
             s += &(" jmp_offset1=".to_string() + &self.jmp_offset1.to_string());

core/src/zisk_required_operation.rs

@@ -1,7 +1,5 @@
 //! Data required to prove the different Zisk operations
 
-use std::collections::HashMap;
-
 /// Required data to make an operation.  
 ///
 /// Stores the minimum information to reproduce an operation execution:
@@ -27,23 +25,3 @@ pub struct ZiskRequiredMemory {
     pub width: u64,
     pub value: u64,
 }
-
-/// Data required to get some operations proven by the secondary state machine
-#[derive(Clone, Default)]
-pub struct ZiskRequired {
-    pub arith: Vec<ZiskRequiredOperation>,
-    pub binary: Vec<ZiskRequiredOperation>,
-    pub binary_extension: Vec<ZiskRequiredOperation>,
-    pub memory: Vec<ZiskRequiredMemory>,
-}
-
-/// Histogram of the program counter values used during the program execution.  
-///
-/// Each pc value has a u64 counter, associated to it via a hash map.  
-/// The counter is increased every time the corresponding instruction is executed.
-#[derive(Clone, Default)]
-pub struct ZiskPcHistogram {
-    pub map: HashMap<u64, u64>,
-    pub end_pc: u64,
-    pub steps: u64,
-}

emulator/Cargo.toml

@@ -15,11 +15,12 @@ path = "src/bin/ziskemu.rs"
 zisk-core = { path = "../core" }
 riscv = { path="../riscv" }
 zisk-pil = { path="../pil" }
+zisk-common = { path="../common" }
 rayon = { workspace = true }
 
 p3-field = { workspace=true }
 clap = { version = "4.5.9", features = ["derive", "env"] }
-sysinfo = "0.31.2"
+sysinfo = "0.33"
 
 [build-dependencies]
 vergen = { version = "8", default-features = false, features = [