[difftest] refactor difftest error output

Signed-off-by: Avimitin <[email protected]>

Author: Avimitin

sail-impl/boat/Cargo.lock

@@ -14,3 +14,4 @@ tracing-subscriber = { version = "0.3.19", features = ["env-filter", "json"] }
 clap = { version = "4.5.37", features = ["derive"] }
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
+anyhow = "1"

sail-impl/boat/Cargo.toml

@@ -5,10 +5,12 @@ version.workspace = true
 
 [dependencies]
 clap = { workspace = true }
+thiserror = { workspace = true }
 tracing-subscriber = { workspace = true }
 tracing = { workspace = true }
 serde = { workspace = true }
 serde_json = { workspace = true }
+anyhow = { workspace = true }
 glob = "0.3.2"
 # Rust standard process library have unexpected behavior of finding exeuctable in PATH.
 which = "7.0.3"

sail-impl/boat/difftest/Cargo.toml

@@ -1,12 +1,14 @@
+use anyhow::Context;
 use serde::Deserialize;
+use std::fmt::Display;
 
 pub type BoatLog = Vec<BoatEvent>;
 
 pub fn run_process(
     args: &[String],
     elf_path: impl AsRef<std::ffi::OsStr>,
-) -> Result<BoatLog, String> {
-    let boat_exec = which::which("boat").unwrap_or_else(|err| panic!("boat exec not found: {err}"));
+) -> anyhow::Result<BoatLog> {
+    let boat_exec = which::which("boat").with_context(|| "boat exec not found")?;
 
     const EVENT_PATH: &str = "./boat_trace_event.jsonl";
     let result = std::process::Command::new(&boat_exec)
@@ -17,17 +19,17 @@ pub fn run_process(
         .arg(EVENT_PATH)
         .args(args)
         .output()
-        .unwrap_or_else(|err| panic!("fail exeuting boat: {err}"));
+        .with_context(|| "fail exeuting boat")?;
 
     if !result.status.success() {
-        return Err(format!(
-            "fail to execute '{boat_exec:?}' with args {args:?} for elf {}",
+        anyhow::bail!(
+            "fail to execute boat with args {args:?} for elf {}",
             elf_path.as_ref().to_str().unwrap()
-        ));
+        );
     }
 
     let trace_event =
-        std::fs::read(EVENT_PATH).unwrap_or_else(|err| panic!("fail reading {EVENT_PATH}: {err}"));
+        std::fs::read(EVENT_PATH).with_context(|| format!("fail reading {EVENT_PATH}"))?;
 
     let boat_log = get_boat_events(&trace_event);
 
@@ -52,6 +54,7 @@ pub struct BoatLogLine {
     pub fields: BoatEvent,
 }
 
+#[allow(dead_code)]
 #[derive(Debug, Deserialize)]
 #[serde(tag = "event_type")]
 pub enum BoatEvent {
@@ -74,6 +77,23 @@ pub enum BoatEvent {
     ResetVector { new_addr: u64 },
 }
 
+impl Display for BoatEvent {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::ArchState {
+                action,
+                pc,
+                reg_idx,
+                data,
+            } => indoc::writedoc!(
+                f,
+                "PC={pc:#018x} {action} to register [x{reg_idx}] with [{data:#018x}]"
+            ),
+            _ => write!(f, "{self:#?}"),
+        }
+    }
+}
+
 impl BoatEvent {
     pub fn get_reset_vector(&self) -> Option<u64> {
         match self {

sail-impl/boat/difftest/src/boat.rs

@@ -1,7 +1,12 @@
+use anyhow::Context;
 use boat::{BoatEvent, BoatLog};
+use clap::Parser;
 use serde::Deserialize;
 use serde::Deserializer;
 use spike::SpikeLog;
+use tracing::{error, info};
+use tracing_subscriber;
+
 mod boat;
 mod spike;
 
@@ -37,25 +42,48 @@ struct CaseConfig {
     end_pattern: EndPattern,
 }
 
-fn main() {
-    let cfg_raw = std::fs::read("./sail_difftest_config.json")
-        .unwrap_or_else(|err| panic!("fail to read sail difftest config: {err}"));
-    let cfg: CaseConfig = serde_json::from_slice(&cfg_raw)
-        .unwrap_or_else(|err| panic!("fail to parse config: {err}"));
+#[derive(clap::Parser, Debug)]
+#[command(version, about, long_about = None)]
+struct DiffTestArgs {
+    #[arg(short = 'c', long, default_value_t = String::from("./sail_difftest_config.json"))]
+    config_path: String,
+}
+
+fn main() -> anyhow::Result<()> {
+    let args = DiffTestArgs::parse();
+
+    tracing_subscriber::fmt()
+        .pretty()
+        .with_file(false)
+        .with_line_number(false)
+        .without_time()
+        .init();
+
+    let cfg_raw =
+        std::fs::read(args.config_path).with_context(|| "fail to read sail difftest config")?;
+    let cfg: CaseConfig =
+        serde_json::from_slice(&cfg_raw).with_context(|| "fail to parse sail difftest config")?;
+
     let all_elf_files = glob::glob(&cfg.elf_path_glob)
-        .unwrap_or_else(|err| panic!("invalid path glob {}: {}", cfg.elf_path_glob, err));
-    all_elf_files.for_each(|path| {
-        let path = path.unwrap_or_else(|err| panic!("glob leads to unreadable path: {err}"));
-        println!("Running elf {path:?}");
-        let spike_log = spike::run_process(&cfg.spike_args, &path).unwrap();
-        let boat_log = boat::run_process(&cfg.boat_args, &path).unwrap();
+        .with_context(|| format!("invalid path glob {}", cfg.elf_path_glob))?;
+
+    for path in all_elf_files {
+        let path = path.with_context(|| "internal error: glob leads to unreadable path")?;
+
+        info!("running difftest for {path:?}");
+
+        let spike_log = spike::run_process(&cfg.spike_args, &path)?;
+        let boat_log = boat::run_process(&cfg.boat_args, &path)?;
         let diff_result = diff(&spike_log, &boat_log, &cfg.end_pattern);
+
         if !diff_result.is_same {
-            panic!("\n{}\n", diff_result.context);
+            error!("\n{}", diff_result.context);
         } else {
-            println!("difftest pass")
+            info!("difftest pass")
         }
-    });
+    }
+
+    Ok(())
 }
 
 struct DiffMeta {
@@ -170,13 +198,18 @@ fn diff(spike_log: &SpikeLog, boat_log: &BoatLog, end_pattern: &EndPattern) -> D
 
         if match_event.is_none() {
             return DiffMeta::failed(indoc::formatdoc! {"
-                At PC={pc:#018x} boat write {data:#018x} to register x{reg_idx}, but this action was not found at spike side.
+                At PC={pc:#018x} boat write {data:#018x} to register x{reg_idx},
+                but this action was not found at spike side.
+
+                ------------
+                |Event Dump|
+                ------------
 
-                Displaying Spike event dump:
-                {spike_event:#?}
+                We get boat:
+                {search_result}
 
-                Displaying Boat event dump:
-                {search_result:#?}
+                But have spike:
+                {spike_event}
             "});
         }
     }

sail-impl/boat/difftest/src/main.rs

@@ -1,29 +1,31 @@
 use std::fmt::Display;
 use std::ops::{Deref, DerefMut};
 
+use anyhow::Context;
+
 pub fn run_process(
     args: &[String],
     elf_path: impl AsRef<std::ffi::OsStr>,
-) -> Result<SpikeLog, String> {
-    let spike_exec =
-        which::which("spike").unwrap_or_else(|err| panic!("spike exec not found: {err}"));
+) -> anyhow::Result<SpikeLog> {
+    let spike_exec = which::which("spike").with_context(|| "spike exec not found")?;
 
     let result = std::process::Command::new(&spike_exec)
         .args(args)
         .arg(&elf_path)
         .output()
-        .unwrap_or_else(|err| panic!("fail exeuting spike: {err}"));
+        .with_context(|| "fail exeuting spike")?;
 
     if !result.status.success() {
         println!("{}", String::from_utf8_lossy(&result.stderr));
-        return Err(format!(
-            "fail to execute '{spike_exec:?}' with args {} for elf {}",
+        anyhow::bail!(
+            "fail to execute spike with args {} for elf {}",
             args.join(" "),
             elf_path.as_ref().to_str().unwrap()
-        ));
+        );
     }
 
-    std::fs::write("./spike_commit.log", &result.stderr).unwrap();
+    std::fs::write("./spike_commit.log", &result.stderr)
+        .with_context(|| "fail storing spike commit log")?;
     let stdout = String::from_utf8_lossy(&result.stderr);
     let spike_log_ast = parse_spike_log(stdout);
 
@@ -70,6 +72,8 @@ impl SpikeLog {
         self.0.is_empty()
     }
 
+    // TODO: future usage
+    #[allow(dead_code)]
     pub fn has_register_commits(&self) -> Vec<&SpikeLogSyntax> {
         self.0
             .iter()
@@ -364,6 +368,7 @@ impl SpikeLogSyntax {
                         // behavior to spike, so trim memory here
                         ParseCursor::RegParseBegin if elem != "mem" && !elem.starts_with("0x") => {
                             const VALID: [char; 4] = ['x', 'f', 'v', 'c'];
+                            // TODO: handle CSR
                             if VALID.contains(&elem.chars().next().unwrap()) {
                                 ctx.cursor = ParseCursor::RegParseName(elem);
                             } else {