feat: add P2E bank DiffTest

Cargo.toml

@@ -6,6 +6,7 @@ members = [
   "src/nodes/lib/rushB",
   "src/nodes/lib/fd-redirect",
   "src/nodes/lib/rtl-trace",
+  "src/nodes/lib/syscall",
   "src/nodes/lib/uart",
   "src/nodes/verilator",
   "src/nodes/p2e",

src/main.rs

@@ -68,6 +68,8 @@ pub enum BuildTarget {
         rtl_dir: PathBuf,
         #[arg(long, value_name = "DIR")]
         out_dir: PathBuf,
+        #[arg(long, help = "Build a P2E+BEMU Bank DiffTest executable")]
+        diff: bool,
     },
 }
 
@@ -137,6 +139,16 @@ pub enum RunTarget {
         wave: bool,
         #[arg(long, help = "Start waveform dump from this cycle")]
         wave_start: Option<u64>,
+        #[arg(
+            long,
+            requires = "golden_elf",
+            help = "Run P2E FPGA with a BEMU Bank DiffTest golden model"
+        )]
+        diff: bool,
+        #[arg(long, value_name = "ELF")]
+        golden_elf: Option<PathBuf>,
+        #[arg(long, help = "Initialize the BEMU golden model with proxy kernel mode")]
+        golden_pk: bool,
         #[arg(long, help = "Enable RTL instruction trace")]
         itrace: bool,
         #[arg(long, help = "Enable RTL memory trace")]
@@ -162,3 +174,72 @@ fn main() {
         std::process::exit(1);
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn p2e_args() -> Vec<&'static str> {
+        vec![
+            "bebop",
+            "run",
+            "p2e",
+            "--image",
+            "image.hex",
+            "--bitstream",
+            "bitstream.bit",
+            "--log-dir",
+            "log",
+        ]
+    }
+
+    #[test]
+    fn parses_p2e_diff_options() {
+        let mut args = p2e_args();
+        args.extend(["--diff", "--golden-elf", "golden.elf", "--golden-pk"]);
+        let cli = Cli::try_parse_from(args).unwrap();
+        let Commands::Run(RunCommand {
+            target:
+                RunTarget::P2e {
+                    diff,
+                    golden_elf,
+                    golden_pk,
+                    ..
+                },
+        }) = cli.command
+        else {
+            panic!("expected P2E run command");
+        };
+        assert!(diff);
+        assert_eq!(golden_elf, Some(PathBuf::from("golden.elf")));
+        assert!(golden_pk);
+    }
+
+    #[test]
+    fn p2e_diff_requires_golden_elf() {
+        let mut args = p2e_args();
+        args.push("--diff");
+        let error = Cli::try_parse_from(args).unwrap_err().to_string();
+        assert!(error.contains("--golden-elf <ELF>"));
+    }
+
+    #[test]
+    fn parses_p2e_without_diff() {
+        let cli = Cli::try_parse_from(p2e_args()).unwrap();
+        let Commands::Run(RunCommand {
+            target:
+                RunTarget::P2e {
+                    diff,
+                    golden_elf,
+                    golden_pk,
+                    ..
+                },
+        }) = cli.command
+        else {
+            panic!("expected P2E run command");
+        };
+        assert!(!diff);
+        assert_eq!(golden_elf, None);
+        assert!(!golden_pk);
+    }
+}

src/nodes/bemu/chip/build.rs

@@ -8,6 +8,7 @@ use std::path::PathBuf;
 fn main() {
     let manifest_dir = PathBuf::from(env::var("CARGO_MANIFEST_DIR").expect("CARGO_MANIFEST_DIR"));
     let out_dir = PathBuf::from(env::var("OUT_DIR").expect("OUT_DIR"));
+    let p2e_abi = env::var_os("BEBOP_BEMU_P2E_ABI").is_some();
     let dispatch = manifest_dir.join("dispatch.rs");
     let pb = manifest_dir
         .parent()
@@ -30,11 +31,48 @@ fn main() {
     println!("cargo:rerun-if-changed={}", pb.display());
     println!("cargo:rerun-if-changed={}", proto.display());
 
+    if p2e_abi {
+        let cc = env::var("BEBOP_BEMU_CC").expect("BEBOP_BEMU_CC");
+        env::set_var("CC", &cc);
+        env::set_var("CXX", env::var("BEBOP_BEMU_CXX").expect("BEBOP_BEMU_CXX"));
+        env::set_var("DTC", env::var("BEBOP_BEMU_DTC").expect("BEBOP_BEMU_DTC"));
+        env::set_var(
+            "PATH",
+            format!(
+                "{}:/usr/bin:/bin",
+                PathBuf::from(cc).parent().expect("BEBOP_BEMU_CC parent").display()
+            ),
+        );
+        env::set_var(
+            "LD_LIBRARY_PATH",
+            env::var("BEBOP_BEMU_COMPILER_LIBRARY_PATH").expect("BEBOP_BEMU_COMPILER_LIBRARY_PATH"),
+        );
+        for name in [
+            "NIX_CFLAGS_COMPILE",
+            "NIX_CFLAGS_COMPILE_FOR_TARGET",
+            "NIX_LDFLAGS",
+            "NIX_LDFLAGS_FOR_TARGET",
+            "CPATH",
+            "LIBRARY_PATH",
+            "C_INCLUDE_PATH",
+            "CPLUS_INCLUDE_PATH",
+            "CFLAGS",
+            "CXXFLAGS",
+            "LDFLAGS",
+        ] {
+            env::remove_var(name);
+        }
+    }
+
     let engine = manifest_dir.join("../../../../../../bebop/src/nodes/bemu");
     let native_dir = build_support::spike::native_dir(&engine);
     let spike_dir = native_dir.join("spike");
-    let spike_install_dir = out_dir.join("spike_install");
-    let spike_build_dir = out_dir.join("spike_build");
+    let spike_install_dir = out_dir.join(if p2e_abi { "spike_install_p2e" } else { "spike_install" });
+    let spike_build_dir = out_dir.join(if p2e_abi { "spike_build_p2e" } else { "spike_build" });
     build_support::spike::build_and_link(&native_dir, &spike_dir, &spike_build_dir, &spike_install_dir);
+    println!(
+        "cargo:rustc-env=BEBOP_BEMU_SPIKE_LIB_DIR={}",
+        spike_install_dir.join("lib").display()
+    );
     build_support::rerun::emit_engine(&engine, &native_dir);
 }

src/nodes/bemu/native/ffi.rs

@@ -41,7 +41,7 @@ pub struct SharedMemory {
 }
 
 struct SharedBankState {
-    storage: Vec<Vec<u8>>,
+    storage: Vec<inst::instruction::PrivateBank>,
     cfgs: Vec<BankConfig>,
     map: BankMap,
     virtual_bank_count: usize,
@@ -61,7 +61,9 @@ impl SharedMemory {
         Arc::new(Self {
             data: std::cell::UnsafeCell::new(vec![0; size]),
             banks: std::cell::UnsafeCell::new(SharedBankState {
-                storage: vec![vec![0; shared_bank_size]; shared_physical_bank_count],
+                storage: (0..shared_physical_bank_count)
+                    .map(|_| inst::instruction::PrivateBank::new(shared_bank_size))
+                    .collect(),
                 cfgs: vec![BankConfig::default(); core_count * virtual_bank_count],
                 map: BankMap::new(shared_physical_bank_count),
                 virtual_bank_count,
@@ -176,7 +178,7 @@ impl std::ops::DerefMut for GuestMemory {
 
 struct EmuState {
     memory: GuestMemory,
-    banks: Vec<Vec<u8>>,
+    banks: Vec<inst::instruction::PrivateBank>,
     bank_cfgs: Vec<BankConfig>,
     bank_map: BankMap,
     shared_memory: Option<Arc<SharedMemory>>,
@@ -211,7 +213,9 @@ impl EmuState {
             memory: shared_memory
                 .clone()
                 .map_or_else(|| GuestMemory::Owned(vec![0; MEM_SIZE]), GuestMemory::Shared),
-            banks: vec![vec![0; bank_size()]; bank_num()],
+            banks: (0..bank_num())
+                .map(|_| inst::instruction::PrivateBank::new(bank_size()))
+                .collect(),
             bank_cfgs: vec![BankConfig::default(); virtual_bank_num()],
             bank_map: BankMap::new(bank_num()),
             shared_memory,
@@ -233,7 +237,7 @@ impl EmuState {
 
     fn reset_accel(&mut self) {
         for b in &mut self.banks {
-            b.fill(0);
+            b.reset();
         }
         self.bank_cfgs.fill(BankConfig::default());
         self.bank_map = BankMap::new(bank_num());
@@ -253,7 +257,9 @@ impl EmuState {
     fn new_host() -> Self {
         Self {
             memory: GuestMemory::Owned(Vec::new()),
-            banks: vec![vec![0; bank_size()]; bank_num()],
+            banks: (0..bank_num())
+                .map(|_| inst::instruction::PrivateBank::new(bank_size()))
+                .collect(),
             bank_cfgs: vec![BankConfig::default(); virtual_bank_num()],
             bank_map: BankMap::new(bank_num()),
             shared_memory: None,
@@ -987,7 +993,7 @@ pub extern "C" fn buckyball_exec(state: *mut c_void, funct7: u8, xs1: u64, xs2:
                             vbank_id,
                             group_id,
                             physical_bank_id,
-                            bank_hash(&banks[physical_bank_id]),
+                            bank_hash(&banks[physical_bank_id].canonical_bytes()),
                         )
                     } else {
                         let shared = shared_memory
@@ -1295,6 +1301,10 @@ struct HartInit {
 }
 
 fn load_elf_memory(state: &mut EmuState, elf_path: &str) -> Result<LoadInfo, String> {
+    state.syscall.working_dir = Path::new(elf_path)
+        .parent()
+        .expect("BEMU ELF must have a parent directory")
+        .to_path_buf();
     let load = load_elf(elf_path, &mut state.memory, DRAM_BASE)?;
     let entry = load.entry;
     let mem_end = DRAM_BASE + state.memory.len() as u64;
@@ -1322,7 +1332,9 @@ fn load_elf_memory(state: &mut EmuState, elf_path: &str) -> Result<LoadInfo, Str
 
 fn hart_init(ctx: *mut c_void, state: &mut EmuState, load: LoadInfo, mem_mb: usize, pk: bool) -> Result<(), String> {
     let mem_end = DRAM_BASE + state.memory.len() as u64;
+    let working_dir = state.syscall.working_dir.clone();
     state.syscall = SyscallState::new();
+    state.syscall.working_dir = working_dir;
     state.pk_vm = None;
     set_guest_mappings(&[]);