Cosmic Refactor

difftest/Cargo.toml

@@ -4,9 +4,9 @@ members = [
     "test_common",
     "spike_rs",
     "offline",
-    "online_dpi",
-    "online_drive",
-    "online_vcs",
+    "dpi_t1",
+    "dpi_t1rocket",
+    "dpi_common",
 ]
 exclude = [
     "spike_interfaces"

difftest/dpi_common/Cargo.toml

@@ -0,0 +1,14 @@
+[package]
+name = "dpi_common"
+edition = "2021"
+version.workspace = true
+
+[dependencies]
+svdpi = { workspace = true }
+tracing = { workspace = true }
+tracing-subscriber = { workspace = true }
+
+[features]
+vcs = ["svdpi/vpi"]
+verilator = ["svdpi/sv2023"]
+trace = []

difftest/dpi_common/src/dpi_target.rs

@@ -0,0 +1,42 @@
+use std::sync::Mutex;
+
+pub struct DpiTarget<T> {
+  target: Mutex<Option<T>>,
+}
+
+impl<T> DpiTarget<T> {
+  pub const fn new() -> Self {
+    Self { target: Mutex::new(None) }
+  }
+
+  #[track_caller]
+  pub fn init(&self, init_fn: impl FnOnce() -> T) {
+    let mut target = self.target.lock().unwrap();
+    if target.is_some() {
+      panic!("DpiTarget is already initialized");
+    }
+    *target = Some(init_fn());
+  }
+
+  #[track_caller]
+  pub fn with<R>(&self, f: impl FnOnce(&mut T) -> R) -> R {
+    let mut target = self.target.lock().unwrap();
+    let target = target.as_mut().expect("DpiTarget is not initialized");
+    f(target)
+  }
+
+  #[track_caller]
+  pub fn with_optional<R>(&self, f: impl FnOnce(Option<&mut T>) -> R) -> R {
+    let mut target = self.target.lock().unwrap();
+    f(target.as_mut())
+  }
+
+  #[track_caller]
+  pub fn dispose(&self) {
+    let mut target = self.target.lock().unwrap();
+    if target.is_none() {
+      panic!("DpiTarget is not initialized");
+    }
+    *target = None;
+  }
+}

difftest/dpi_common/src/dump.rs

@@ -0,0 +1,130 @@
+use svdpi::SvScope;
+use tracing::error;
+
+use crate::plusarg::PlusArgMatcher;
+
+pub struct DumpEndError;
+
+#[cfg(feature = "trace")]
+pub type DumpControl = RealDumpControl;
+#[cfg(not(feature = "trace"))]
+pub type DumpControl = EmptyDumpControl;
+
+#[cfg(feature = "trace")]
+mod dpi_export {
+  use std::ffi::c_char;
+  extern "C" {
+    /// `export "DPI-C" function dump_wave(input string file)`
+    pub fn dump_wave(path: *const c_char);
+  }
+}
+
+#[cfg(feature = "trace")]
+fn dump_wave(scope: svdpi::SvScope, path: &str) {
+  use std::ffi::CString;
+  let path_cstring = CString::new(path).unwrap();
+
+  svdpi::set_scope(scope);
+  unsafe {
+    dpi_export::dump_wave(path_cstring.as_ptr());
+  }
+}
+
+#[cfg(feature = "trace")]
+pub struct RealDumpControl {
+  svscope: svdpi::SvScope,
+  wave_path: String,
+  dump_start: u64,
+  dump_end: u64,
+
+  started: bool,
+}
+
+#[cfg(feature = "trace")]
+impl RealDumpControl {
+  fn new(svscope: SvScope, wave_path: &str, dump_range: &str) -> Self {
+    let (dump_start, dump_end) = parse_range(dump_range);
+    Self {
+      svscope,
+      wave_path: wave_path.to_owned(),
+      dump_start,
+      dump_end,
+
+      started: false,
+    }
+  }
+
+  pub fn from_plusargs(svscope: SvScope, marcher: &PlusArgMatcher) -> Self {
+    let wave_path = marcher.match_("t1_wave_path");
+    let dump_range = marcher.try_match("t1_dump_range").unwrap_or("");
+    Self::new(svscope, wave_path, dump_range)
+  }
+
+  pub fn start(&mut self) {
+    if !self.started {
+      dump_wave(self.svscope, &self.wave_path);
+      self.started = true;
+    }
+  }
+
+  pub fn trigger_watchdog(&mut self, tick: u64) -> Result<(), DumpEndError> {
+    if self.dump_end != 0 && tick > self.dump_end {
+      return Err(DumpEndError);
+    }
+
+    if tick >= self.dump_start {
+      self.start();
+    }
+
+    Ok(())
+  }
+}
+
+pub struct EmptyDumpControl {}
+impl EmptyDumpControl {
+  pub fn from_plusargs(svscope: SvScope, marcher: &PlusArgMatcher) -> Self {
+    // do nothing
+    let _ = svscope;
+    let _ = marcher;
+    Self {}
+  }
+  pub fn start(&mut self) {
+    // do nothing
+  }
+  pub fn trigger_watchdog(&mut self, tick: u64) -> Result<(), DumpEndError> {
+    // do nothing
+    let _ = tick;
+    Ok(())
+  }
+}
+
+fn parse_range(input: &str) -> (u64, u64) {
+  if input.is_empty() {
+    return (0, 0);
+  }
+
+  let parts: Vec<&str> = input.split(",").collect();
+
+  if parts.len() != 1 && parts.len() != 2 {
+    error!("invalid dump wave range: `{input}` was given");
+    return (0, 0);
+  }
+
+  const INVALID_NUMBER: &'static str = "invalid number";
+
+  if parts.len() == 1 {
+    return (parts[0].parse().expect(INVALID_NUMBER), 0);
+  }
+
+  if parts[0].is_empty() {
+    return (0, parts[1].parse().expect(INVALID_NUMBER));
+  }
+
+  let start = parts[0].parse().expect(INVALID_NUMBER);
+  let end = parts[1].parse().expect(INVALID_NUMBER);
+  if start > end {
+    panic!("dump start is larger than end: `{input}`");
+  }
+
+  (start, end)
+}

difftest/dpi_common/src/lib.rs

@@ -0,0 +1,19 @@
+pub mod dpi_target;
+pub mod dump;
+pub mod plusarg;
+
+pub use dpi_target::DpiTarget;
+
+use tracing_subscriber::{EnvFilter, FmtSubscriber};
+
+pub fn setup_logger() {
+  let global_logger = FmtSubscriber::builder()
+    .with_env_filter(EnvFilter::from_default_env()) // default level: error
+    .without_time()
+    .with_target(false)
+    .with_ansi(true)
+    .compact()
+    .finish();
+  tracing::subscriber::set_global_default(global_logger)
+    .expect("internal error: fail to setup log subscriber");
+}

difftest/dpi_common/src/plusarg.rs

@@ -0,0 +1,29 @@
+pub struct PlusArgMatcher {
+  plusargs: Vec<String>,
+}
+
+impl PlusArgMatcher {
+  pub fn from_args() -> Self {
+    let plusargs = std::env::args().filter(|arg| arg.starts_with('+')).collect();
+
+    Self { plusargs }
+  }
+
+  pub fn try_match(&self, arg_name: &str) -> Option<&str> {
+    let prefix = &format!("+{arg_name}=");
+
+    for plusarg in &self.plusargs {
+      if plusarg.starts_with(prefix) {
+        return Some(&plusarg[prefix.len()..]);
+      }
+    }
+    None
+  }
+
+  pub fn match_(&self, arg_name: &str) -> &str {
+    self.try_match(arg_name).unwrap_or_else(|| {
+      tracing::error!("required plusarg '+{arg_name}=' not found");
+      panic!("failed to march '+{arg_name}='");
+    })
+  }
+}

difftest/online_dpi/Cargo.toml → difftest/dpi_t1/Cargo.toml

@@ -1,17 +1,18 @@
 [package]
-name = "online_dpi"
+name = "dpi_t1"
 edition = "2021"
 version.workspace = true
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
+[lib]
+crate-type = ["staticlib"]
+
 [dependencies]
-common = { path = "../test_common" }
+dpi_common = { path = "../dpi_common" }
 spike_rs = { path = "../spike_rs" }
-clap = { workspace = true }
 tracing = { workspace = true }
 svdpi = { workspace = true }
 hex = "0.4.3"
 
 [features]
-trace = []