Asynchronous simulation output

Cargo.toml

@@ -24,6 +24,7 @@ description = "A modern hardware description language"
 [workspace.dependencies]
 anyhow = "1.0"
 clap = {version = "4.5.4", features = ["derive"]}
+futures = "0.3.30"
 log = "0.4.20"
 mdbook = "0.4.37"
 miette = {version = "5.10", features = ["fancy"]}
@@ -35,6 +36,7 @@ serde_json = "1.0"
 strnum_bitwidth = "0.1.2"
 tempfile = "3.10"
 thiserror = "1.0"
+tokio = {version = "1.37.0", features = ["full"]}
 toml = "0.7.8"
 url = {version = "2.5", features = ["serde"]}
 

crates/languageserver/Cargo.toml

@@ -17,12 +17,12 @@ exclude = ["build.rs"]
 #crossbeam-channel = "0.5.6"
 async-channel = "2.2"
 dashmap = "5.5.3"
-futures = "0.3.30"
+futures = {workspace = true}
 glob = "0.3.1"
 ropey = "1.6.1"
 miette = {workspace = true}
 serde_json = {workspace = true}
-tokio = {version = "1.37.0", features = ["full"]}
+tokio = {workspace = true}
 tower-lsp = "0.20.0"
 veryl-analyzer = {version = "0.9.0", path = "../analyzer"}
 veryl-formatter = {version = "0.9.0", path = "../formatter"}

crates/veryl/Cargo.toml

@@ -23,9 +23,11 @@ pre-release-replacements = [
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
+anstyle = "1.0"
 clap = {workspace = true}
 console = "0.15.8"
 fern = "0.6.2"
+futures = {workspace = true}
 handlebars = "5.1"
 log = {workspace = true}
 once_cell = {workspace = true}
@@ -38,6 +40,8 @@ serde_json = {workspace = true}
 similar = {version = "2.5.0", features = ["text", "inline"]}
 tempfile = {workspace = true}
 thiserror = {workspace = true}
+tokio = {workspace = true}
+tokio-util = "0.7.10"
 veryl-analyzer = {version = "0.9.0", path = "../analyzer"}
 veryl-emitter = {version = "0.9.0", path = "../emitter"}
 veryl-formatter = {version = "0.9.0", path = "../formatter"}

crates/veryl/src/cmd_test.rs

@@ -1,6 +1,7 @@
 use crate::cmd_build::CmdBuild;
-use crate::runner::{Runner, Vcs, Verilator, Vivado};
+use crate::runner::{Vcs, Verilator, Vivado};
 use crate::{OptBuild, OptTest};
+use log::{error, info};
 use miette::Result;
 use veryl_analyzer::attribute::Attribute;
 use veryl_analyzer::attribute_table;
@@ -40,16 +41,27 @@ impl CmdTest {
  };
 
  let mut runner = match sim_type {
- SimType::Verilator => Box::new(Verilator) as Box<dyn Runner>,
- SimType::Vcs => Box::new(Vcs) as Box<dyn Runner>,
- SimType::Vivado => Box::new(Vivado) as Box<dyn Runner>,
+ SimType::Verilator => Verilator::new().runner(),
+ SimType::Vcs => Vcs::new().runner(),
+ SimType::Vivado => Vivado::new().runner(),
  };
 
- let mut ret = true;
+ let mut success = 0;
+ let mut failure = 0;
  for test in &tests {
- ret &= runner.run(metadata, *test)?;
+ if runner.run(metadata, *test)? {
+ success += 1;
+ } else {
+ failure += 1;
+ }
  }
 
- Ok(ret)
+ if failure == 0 {
+ info!("Completed tests : {} passed, {} failed", success, failure);
+ Ok(true)
+ } else {
+ error!("Completed tests : {} passed, {} failed", success, failure);
+ Ok(false)
+ }
  }
 }

crates/veryl/src/runner.rs

@@ -1,7 +1,7 @@
+use anstyle::{AnsiColor, Style};
 use log::{debug, log_enabled, Level};
 use miette::Result;
-use regex::Regex;
-use std::process::Output;
+use once_cell::sync::Lazy;
 use veryl_metadata::Metadata;
 use veryl_parser::resource_table::StrId;
 
@@ -12,88 +12,50 @@ pub use vcs::*;
 pub use verilator::*;
 pub use vivado::*;
 
-#[derive(Default)]
-pub struct LogRegex {
- warning: Option<&'static Regex>,
- error: Option<&'static Regex>,
- fatal: Option<&'static Regex>,
-}
-
 pub trait Runner {
  fn run(&mut self, metadata: &Metadata, test: StrId) -> Result<bool>;
 
  fn name(&self) -> &'static str;
 
- fn regex_compile(&self) -> LogRegex {
- LogRegex::default()
- }
-
- fn regex_elaborate(&self) -> LogRegex {
- LogRegex::default()
- }
+ fn failure(&mut self);
 
- fn regex_simulate(&self) -> LogRegex {
- LogRegex::default()
+ fn debug(&self, line: &str) {
+ if log_enabled!(Level::Debug) {
+ debug!("{} : {}", self.name(), line);
+ }
  }
 
- fn parse_compile(&self, output: Output) -> bool {
- self.parse(output, self.regex_compile())
+ fn info(&self, line: &str) {
+ static STYLE: Lazy<Style> =
+ Lazy::new(|| Style::new().fg_color(Some(AnsiColor::Green.into())));
+ if !log_enabled!(Level::Debug) {
+ println!("{}{}{}", STYLE.render(), line, STYLE.render_reset());
+ }
  }
 
- fn parse_elaborate(&self, output: Output) -> bool {
- self.parse(output, self.regex_elaborate())
+ fn warning(&mut self, line: &str) {
+ static STYLE: Lazy<Style> =
+ Lazy::new(|| Style::new().fg_color(Some(AnsiColor::Yellow.into())));
+ if !log_enabled!(Level::Debug) {
+ println!("{}{}{}", STYLE.render(), line, STYLE.render_reset());
+ }
  }
 
- fn parse_simulate(&self, output: Output) -> bool {
- self.parse(output, self.regex_simulate())
+ fn error(&mut self, line: &str) {
+ static STYLE: Lazy<Style> =
+ Lazy::new(|| Style::new().fg_color(Some(AnsiColor::Red.into())));
+ if !log_enabled!(Level::Debug) {
+ println!("{}{}{}", STYLE.render(), line, STYLE.render_reset());
+ }
+ self.failure();
  }
 
- fn parse(&self, output: Output, regex: LogRegex) -> bool {
- let stdout = String::from_utf8_lossy(output.stdout.as_slice());
- let stderr = String::from_utf8_lossy(output.stderr.as_slice());
- let text = format!("{}{}", stdout, stderr);
-
- let mut warnings = if let Some(x) = regex.warning {
- x.find_iter(&text)
- .map(|x| (x.start(), x.as_str().to_string()))
- .collect()
- } else {
- vec![]
- };
-
- let mut errors = if let Some(x) = regex.error {
- x.find_iter(&text)
- .map(|x| (x.start(), x.as_str().to_string()))
- .collect()
- } else {
- vec![]
- };
-
- let mut fatals = if let Some(x) = regex.fatal {
- x.find_iter(&text)
- .map(|x| (x.start(), x.as_str().to_string()))
- .collect()
- } else {
- vec![]
- };
-
- let success = errors.is_empty() && fatals.is_empty();
-
- if log_enabled!(Level::Debug) {
- for line in text.lines() {
- debug!("{} : {}", self.name(), line);
- }
- } else {
- let mut all = Vec::new();
- all.append(&mut warnings);
- all.append(&mut errors);
- all.append(&mut fatals);
- all.sort_by(|x, y| x.0.cmp(&y.0));
- for (_, log) in &all {
- println!("{}", log);
- }
+ fn fatal(&mut self, line: &str) {
+ static STYLE: Lazy<Style> =
+ Lazy::new(|| Style::new().fg_color(Some(AnsiColor::Red.into())).bold());
+ if !log_enabled!(Level::Debug) {
+ println!("{}{}{}", STYLE.render(), line, STYLE.render_reset());
  }
-
- success
+ self.failure();
  }
 }